6.57 Другие встроенные функции, предоставляемые GCC

GCC предоставляет большое количество встроенных функций помимо упомянутых выше. Некоторые из них предназначены для внутреннего использования при обработке исключений или списков аргументов переменной длины и не документированы здесь, поскольку они могут время от времени изменяться; мы не рекомендуем использовать эти функции в общем случае.

Остальные функции предоставляются для целей оптимизации.

GCC включает встроенные версии многих функций стандартной библиотеки C. Версии, префикс которых __builtin_, всегда интерпретируются так же, как функция из библиотеки C, даже если вы укажете опцию -fno-builtin. (см. Опции диалекта C) Многие из этих функций оптимизируются только в определенных случаях; если они не оптимизируются в конкретном случае, вызывается функция из библиотеки.

Вне строгого режима ISO C (-ansi, -std=c90, -std=c99 или -std=c11), функции _exit, alloca, bcmp, bzero, dcgettext, dgettext, dremf, dreml, drem, exp10f, exp10l, exp10, ffsll, ffsl, ffs, fprintf_unlocked, fputs_unlocked, gammaf, gammal, gamma, gammaf_r, gammal_r, gamma_r, gettext, index, isascii, j0f, j0l, j0, j1f, j1l, j1, jnf, jnl, jn, lgammaf_r, lgammal_r, lgamma_r, mempcpy, pow10f, pow10l, pow10, printf_unlocked, rindex, scalbf, scalbl, scalb, signbit, signbitf, signbitl, signbitd32, signbitd64, signbitd128, significandf, significandl, significand, sincosf, sincosl, sincos, stpcpy, stpncpy, strcasecmp, strdup, strfmon, strncasecmp, strndup, toascii, y0f, y0l, y0, y1f, y1l, y1, ynf, ynl и yn могут обрабатываться как встроенные функции. Все эти функции имеют соответствующие версии с префиксом __builtin_, которые могут быть использованы даже в строгом режиме C90.

Функции ISO C99 _Exit, acoshf, acoshl, acosh, asinhf, asinhl, asinh, atanhf, atanhl, atanh, cabsf, cabsl, cabs, cacosf, cacoshf, cacoshl, cacosh, cacosl, cacos, cargf, cargl, carg, casinf, casinhf, casinhl, casinh, casinl, casin, catanf, catanhf, catanhl, catanh, catanl, catan, cbrtf, cbrtl, cbrt, ccosf, ccoshf, ccoshl, ccosh, ccosl, ccos, cexpf, cexpl, cexp, cimagf, cimagl, cimag, clogf, clogl, clog, conjf, conjl, conj, copysignf, copysignl, copysign, cpowf, cpowl, cpow, cprojf, cprojl, cproj, crealf, creall, creal, csinf, csinhf, csinhl, csinh, csinl, csin, csqrtf, csqrtl, csqrt, ctanf, ctanhf, ctanhl, ctanh, ctanl, ctan, erfcf, erfcl, erfc, erff, erfl, erf, exp2f, exp2l, exp2, expm1f, expm1l, expm1, fdimf, fdiml, fdim, fmaf, fmal, fmaxf, fmaxl, fmax, fma, fminf, fminl, fmin, hypotf, hypotl, hypot, ilogbf, ilogbl, ilogb, imaxabs, isblank, iswblank, lgammaf, lgammal, lgamma, llabs, llrintf, llrintl, llrint, llroundf, llroundl, llround, log1pf, log1pl, log1p, log2f, log2l, log2, logbf, logbl, logb, lrintf, lrintl, lrint, lroundf, lroundl, lround, nearbyintf, nearbyintl, nearbyint, nextafterf, nextafterl, nextafter, nexttowardf, nexttowardl, nexttoward, remainderf, remainderl, remainder, remquof, remquol, remquo, rintf, rintl, rint, roundf, roundl, round, scalblnf, scalblnl, scalbln, scalbnf, scalbnl, scalbn, snprintf, tgammaf, tgammal, tgamma, truncf, truncl, trunc, vfscanf, vscanf, vsnprintf и vsscanf обрабатываются как встроенные функции, кроме строгого режима ISO C90 (-ansi или -std=c90).

Также есть встроенные версии функций ISO C99 acosf, acosl, asinf, asinl, atan2f, atan2l, atanf, atanl, ceilf, ceill, cosf, coshf, coshl, cosl, expf, expl, fabsf, fabsl, floorf, floorl, fmodf, fmodl, frexpf, frexpl, ldexpf, ldexpl, log10f, log10l, logf, logl, modfl, modf, powf, powl, sinf, sinhf, sinhl, sinl, sqrtf, sqrtl, tanf, tanhf, tanhl и tanl, которые распознаются в любом режиме, так как ISO C90 оставляет эти имена для целей, которым ISO C99 их использует. Все эти функции имеют соответствующие версии с префиксом __builtin_.

Функции ISO C94 iswalnum, iswalpha, iswcntrl, iswdigit, iswgraph, iswlower, iswprint, iswpunct, iswspace, iswupper, iswxdigit, towlower и towupper обрабатываются как встроенные функции, кроме строгого режима ISO C90 (-ansi или -std=c90).

Функции ISO C90 abort, abs, acos, asin, atan2, atan, calloc, ceil, cosh, cos, exit, exp, fabs, floor, fmod, fprintf, fputs, frexp, fscanf, isalnum, isalpha, iscntrl, isdigit, isgraph, islower, isprint, ispunct, isspace, isupper, isxdigit, tolower, toupper, labs, ldexp, log10, log, malloc, memchr, memcmp, memcpy, memset, modf, pow, printf, putchar, puts, scanf, sinh, sin, snprintf, sprintf, sqrt, sscanf, strcat, strchr, strcmp, strcpy, strcspn, strlen, strncat, strncmp, strncpy, strpbrk, strrchr, strspn, strstr, tanh, tan, vfprintf, vprintf и vsprintf все распознаются как встроенные функции, если не указано -fno-builtin (или -fno-builtin-function для отдельной функции). Все эти функции имеют соответствующие версии с префиксом __builtin_.

GCC предоставляет встроенные версии макросов сравнения чисел с плавающей точкой ISO C99, которые избегают повышения исключений для неупорядоченных операндов. Они имеют те же имена, что и стандартные макросы (isgreater, isgreaterequal, isless, islessequal, islessgreater, и isunordered) , с префиксом __builtin_. Мы намерены предоставить реализатору библиотеки возможность просто заменить каждый стандартный макрос на его встроенный аналог. Аналогичным образом, GCC предоставляет fpclassify, isfinite, isinf_sign и isnormal встроенные функции, используемые с префиксом __builtin_. Встроенные функции isinf и isnan появляются как с префиксом __builtin_, так и без него.

Встроенная функция: int __builtin_types_compatible_p (type1, type2)

Вы можете использовать встроенную функцию __builtin_types_compatible_p для определения, являются ли два типа одинаковыми.

Эта встроенная функция возвращает 1, если неквалифицированные версии типов type1 и type2 (которые являются типами, а не выражениями) совместимы, и 0 в противном случае. Результат этой встроенной функции может быть использован в целочисленных константных выражениях.

Эта встроенная функция игнорирует квалификаторы верхнего уровня (например, const, volatile). Например, int эквивалентно const int.

Тип int[] и int[5] совместимы. С другой стороны, int и char * не совместимы, даже если размер их типов на конкретной архитектуре одинаков. Также учитывается количество указателей при определении сходства. Следовательно, short * не похож на short **. Кроме того, два типа, которые являются псевдонимами (typedef), считаются совместимыми, если их основополагающие типы совместимы.

Тип enum не считается совместимым с другим типом enum, даже если оба совместимы с одним целым типом; это то, что определяет стандарт C. Например, enum {foo, bar} не похож на enum {hot, dog}.

Обычно вы используете эту функцию в коде, выполнение которого зависит от типов аргументов. Например:

#define foo(x)                                                  \
  ({                                                           \
    typeof (x) tmp = (x);                                       \
    if (__builtin_types_compatible_p (typeof (x), long double)) \
      tmp = foo_long_double (tmp);                              \
    else if (__builtin_types_compatible_p (typeof (x), double)) \
      tmp = foo_double (tmp);                                   \
    else if (__builtin_types_compatible_p (typeof (x), float))  \
      tmp = foo_float (tmp);                                    \
    else                                                        \
      abort ();                                                 \
    tmp;                                                        \
  })

Примечание: Этот конструкт доступен только для языка C.

Встроенная функция: type __builtin_call_with_static_chain (call_exp, pointer_exp)

Выражение call_exp должно быть вызовом функции, а выражение pointer_exp должно быть указателем. pointer_exp передается в вызов функции в месте статической цепочки целевого объекта. Результатом встроенной функции является результат вызова функции.

Примечание: Эта встроенная функция доступна только для языка C. Эта функция может быть использована для вызова замыканий Go из C.

Встроенная функция: type __builtin_choose_expr (const_exp, exp1, exp2)

Вы можете использовать встроенную функцию __builtin_choose_expr для оценки кода в зависимости от значения константного выражения. Эта встроенная функция возвращает exp1, если const_exp, которое является целочисленным константным выражением, отлично от нуля. В противном случае она возвращает exp2.

Эта встроенная функция аналогична оператору ‘? :’ в языке C, за исключением того, что тип возвращаемого выражения не изменяется правилами повышения приоритета. Кроме того, встроенная функция не вычисляет выражение, которое не выбрано. Например, если const_exp принимает значение «истина», то exp2 не вычисляется, даже если оно имеет побочные эффекты.

Эта встроенная функция может возвращать lvalue, если выбранный аргумент является lvalue.

Если возвращается exp1, тип возврата совпадает с типом exp1. Аналогично, если возвращается exp2, тип возврата совпадает с типом exp2.

Пример:

#define foo(x)                                                    \
  __builtin_choose_expr (                                         \
    __builtin_types_compatible_p (typeof (x), double),            \
    foo_double (x),                                               \
    __builtin_choose_expr (                                       \
      __builtin_types_compatible_p (typeof (x), float),           \
      foo_float (x),                                              \
      /* The void expression results in a compile-time error  \
         when assigning the result to something.  */          \
      (void)0))

Примечание: Этот конструкт доступен только для языка C. Кроме того, неиспользуемое выражение (exp1 или exp2 в зависимости от значения const_exp) все еще может генерировать синтаксические ошибки. Это может измениться в будущих версиях.

Встроенная функция: type __builtin_complex (real, imag)

Встроенная функция __builtin_complex предоставляется для использования при реализации макросов ISO C11 CMPLXF, CMPLX и CMPLXL. real и imag должны иметь одинаковый тип, вещественный двоичный тип с плавающей точкой, а результат имеет соответствующий комплексный тип с вещественной и мнимой частями real и imag. В отличие от ‘real + I * imag’, это работает даже при наличии бесконечностей, NaN и отрицательных нулей.

Встроенная функция: int __builtin_constant_p (exp)

Вы можете использовать встроенную функцию __builtin_constant_p для определения, является ли значение известной константой на этапе компиляции, и, следовательно, GCC может выполнить константное сворачивание выражений, включающих это значение. Аргументом функции является значение для проверки. Функция возвращает целое число 1, если аргумент известен как константа на этапе компиляции, и 0, если он не известен как константа на этапе компиляции. Возврат 0 не означает, что значение не является константой, а лишь то, что GCC не может доказать, что это константа с заданным значением опции -O.

Обычно вы используете эту функцию встраиваемом приложении, где память является важным ресурсом. Если у вас есть какое-то сложное вычисление, вы можете захотеть, чтобы оно сворачивалось, если оно включает константы, но вам нужно вызвать функцию, если это не так. Например:

#define Scale_Value(X)      \
  (__builtin_constant_p (X) \
  ? ((X) * SCALE + OFFSET) : Scale (X))

Вы можете использовать эту встроенную функцию как в макросе, так и во встроенной функции. Однако, если вы используете ее во встроенной функции и передаете аргумент функции как аргумент встроенной функции, GCC никогда не возвращает 1, когда вы вызываете встроенную функцию со строковой константой или составной литеральной (см. Составные литералы), и не возвращает 1, когда вы передаете числовое значение константы во встроенную функцию, если вы не укажете опцию -O.

Вы также можете использовать __builtin_constant_p в инициализаторах статических данных. Например, вы можете написать

static const int table[] = {
   __builtin_constant_p (EXPRESSION) ? (EXPRESSION) : -1,
   /* … */
};

Это допустимый инициализатор даже если EXPRESSION не является константным выражением, включая случай, когда __builtin_constant_p возвращает 1, потому что EXPRESSION может быть свернуто в константу, но EXPRESSION содержит операнды, которые в противном случае не разрешены в статическом инициализаторе (например, 0 && foo ()). GCC должен быть более консервативным при оценке встроенной функции в этом случае, потому что у него нет возможности выполнить оптимизацию.

Встроенная функция: long __builtin_expect (long exp, long c)

Вы можете использовать __builtin_expect для предоставления компилятору информации о предсказании ветвления. В общем случае вы должны отдавать предпочтение фактической обратной связи профиля для этого (-fprofile-arcs), так как программисты известны своей плохой способностью предсказывать, как на самом деле будет работать их программа. Однако существуют приложения, в которых эти данные трудно собрать.

Значение возврата — значение exp, которое должно быть целочисленным выражением. Семантика встроенной функции заключается в том, что ожидается, что exp == c. Например:

if (__builtin_expect (x, 0))
  foo ();

указывает, что мы не ожидаем вызова foo, так как ожидаем, что x будет равно нулю. Поскольку вы ограничены целочисленными выражениями для exp, вы должны использовать конструкции, такие как

if (__builtin_expect (ptr != NULL, 1))
  foo (*ptr);

при проверке указателей или значений с плавающей точкой.

Встроенная функция: void __builtin_trap (void)

Эта функция приводит к аномальному завершению программы. GCC реализует эту функцию, используя механизм, зависящий от целевой системы (например, намеренно выполняет незаконную инструкцию) или вызывая abort. Используемый механизм может меняться от релиза к релизу, поэтому вы не должны полагаться на какую-либо конкретную реализацию.

Встроенная функция: void __builtin_unreachable (void)

Если поток управления достигает точки __builtin_unreachable, поведение программы не определено. Это полезно в ситуациях, когда компилятор не может вывести недостижимость кода.

Один из таких случаев — сразу после оператора asm, который либо никогда не завершается, либо передает управление в другое место и никогда не возвращается. В этом примере без __builtin_unreachable, GCC выдает предупреждение о том, что управление достигает конца функции, не имеющей тип возвращаемого значения void. Он также генерирует код для возврата после asm.

int f (int c, int v)
{
  if (c)
    {
      return v;
    }
  else
    {
      asm("jmp error_handler");
      __builtin_unreachable ();
    }
}

Поскольку оператор asm безусловно передает управление из функции, управление никогда не достигает конца тела функции. __builtin_unreachable фактически недостижима и сообщает об этом компилятору.

Еще одно применение __builtin_unreachable — после вызова функции, которая никогда не возвращается, но не объявлена __attribute__((noreturn)), как в этом примере:

void function_that_never_returns (void);

int g (int c)
{
  if (c)
    {
      return 1;
    }
  else
    {
      function_that_never_returns ();
      __builtin_unreachable ();
    }
}

Встроенная функция: void *__builtin_assume_aligned (const void *exp, size_t align, ...)

Эта функция возвращает свой первый аргумент и позволяет компилятору предположить, что возвращаемый указатель выровнен как минимум на align байт. У этой встроенной функции может быть два или три аргумента. Если она имеет три аргумента, третий аргумент должен иметь целочисленный тип, а если он отличен от нуля, означает смещение при неправильном выравнивании. Например:

void *x = __builtin_assume_aligned (arg, 16);

означает, что компилятор может предположить, что x, установленное в arg, выровнено как минимум на 16 байт, в то время как:

void *x = __builtin_assume_aligned (arg, 32, 8);

означает, что компилятор может предположить для x, установленного в arg, что (char *) x - 8 выровнено как минимум на 32 байта.

Встроенная функция: int __builtin_LINE ()

Эта функция эквивалентна препроцессорному макросу __LINE__ и возвращает номер строки вызова встроенной функции. В C++ по умолчанию для аргумента функции F она получает номер строки вызова F.

Встроенная функция: const char * __builtin_FUNCTION ()

Эта функция эквивалентна препроцессорному макросу __FUNCTION__ и возвращает имя функции, в которой находится вызов встроенной функции.

Встроенная функция: const char * __builtin_FILE ()

Эта функция эквивалентна препроцессорному макросу __FILE__ и возвращает имя файла, в котором находится вызов встроенной функции. В C++ по умолчанию для аргумента функции F она получает имя файла вызова F.

Встроенная функция: void __builtin___clear_cache (char *begin, char *end)

Эта функция используется для сброса кэш-памяти инструкций процессора для области памяти между begin (включительно) и end (исключительно). Некоторые целевые платформы требуют сброса кэша инструкций после изменения памяти, содержащей код, для получения детерминированного поведения.

Если целевая платформа не требует сброса кэша инструкций, __builtin___clear_cache не оказывает никакого эффекта. В противном случае либо генерируются инструкции для сброса кэша инструкций, либо вызывается функция __clear_cache из библиотеки libgcc.

Встроенная функция: void __builtin_prefetch (const void *addr, ...)

Эта функция используется для минимизации задержки промахов кэша, перемещая данные в кэш перед доступом к ним. Вы можете вставлять вызовы __builtin_prefetch в код, для которого известны адреса данных в памяти, которые, вероятно, будут обработаны в ближайшем будущем. Если целевая платформа их поддерживает, генерируются инструкции предварительной выборки данных. Если предварительная выборка выполняется достаточно рано перед доступом, данные будут находиться в кэше к моменту обращения к ним.

Значение addr — это адрес памяти, которую нужно предварительно выбрать. Существуют два необязательных аргумента, rw и locality. Значение rw — это константа времени компиляции 1 или 0; 1 означает, что предварительная выборка подготавливается к записи в адрес памяти, а 0, по умолчанию, — к чтению. Значение locality должно быть целочисленной константой времени компиляции от нуля до трех. Значение 0 означает, что данные не имеют временной локализации, поэтому их не нужно оставлять в кэше после доступа. Значение 3 означает, что данные имеют высокую временную локализацию и должны оставаться во всех уровнях кэша, насколько это возможно. Значения 1 и 2 соответственно означают низкую или среднюю степень временной локализации. По умолчанию используется 3.

for (i = 0; i < n; i++)
  {
    a[i] = a[i] + b[i];
    __builtin_prefetch (&a[i+j], 1, 1);
    __builtin_prefetch (&b[i+j], 0, 1);
    /* … */
  }

Предварительная выборка данных не генерирует ошибки, если addr недействителен, но само выражение адреса должно быть действительным. Например, предварительная выборка p->next не вызывает ошибку, если p->next не является действительным адресом, но вычисление вызывает ошибку, если p не является действительным адресом.

Если целевая платформа не поддерживает предварительную выборку данных, выражение адреса вычисляется, если оно включает побочные эффекты, но другой код не генерируется, и GCC не выводит предупреждение.

Встроенная функция: double __builtin_huge_val (void)

Возвращает положительную бесконечность, если это поддерживается форматом с плавающей точкой, иначе DBL_MAX. Эта функция подходит для реализации макроса ISO C HUGE_VAL.

Встроенная функция: float __builtin_huge_valf (void)

Аналогично __builtin_huge_val, за исключением того, что тип возвращаемого значения — float.

Встроенная функция: long double __builtin_huge_vall (void)

Аналогично __builtin_huge_val, за исключением того, что тип возвращаемого значения — long double.

Встроенная функция: int __builtin_fpclassify (int, int, int, int, int, ...)

Эта встроенная функция реализует функциональность C99 fpclassify. Первые пять аргументов int должны представлять возможные классы FP в библиотеке целевой платформы и используются для значений возврата. Они должны быть константными и должны появляться в таком порядке: FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL и FP_ZERO. Эллипс предназначен для одного значения с плавающей точкой для классификации. GCC обрабатывает последний аргумент как тип-обобщение, что означает, что он не выполняет автоматическое преобразование типа float в double.

Встроенная функция: double __builtin_inf (void)

Аналогично __builtin_huge_val, за исключением того, что генерируется предупреждение, если целевой формат с плавающей точкой не поддерживает бесконечности.

Встроенная функция: _Decimal32 __builtin_infd32 (void)

Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — _Decimal32.

Встроенная функция: _Decimal64 __builtin_infd64 (void)

Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — _Decimal64.

Встроенная функция: _Decimal128 __builtin_infd128 (void)

Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — _Decimal128.

Встроенная функция: float __builtin_inff (void)

Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — float. Эта функция подходит для реализации макроса ISO C99 INFINITY.

Встроенная функция: long double __builtin_infl (void)

Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — long double.

Встроенная функция: int __builtin_isinf_sign (...)

Аналогично isinf, за исключением того, что значение возврата равно -1 для аргумента -Inf и 1 для аргумента +Inf. Обратите внимание, что, хотя список параметров является эллипсом, эта функция принимает ровно один аргумент с плавающей точкой. GCC обрабатывает этот параметр как тип-обобщение, что означает, что он не выполняет автоматическое преобразование типа float в double.

Встроенная функция: double __builtin_nan (const char *str)

Это реализация функции ISO C99 nan.

Так как ISO C99 определяет эту функцию через strtod, которую мы не реализуем, необходимо описать процесс парсинга. Строка разбирается как strtol; то есть, основание распознаётся по префиксам «0» или «0x». Разбираемое число помещается в мантиссу таким образом, что младший бит числа находится в младшем бите мантиссы. Число усекается для соответствия предоставленному полю мантиссы. Мантисса принудительно устанавливается в тихий NaN.

Если этой функции передано строковое литеральное выражение, которое полностью потреблялось бы strtol, это выражение вычисляется достаточно рано, чтобы считаться константой времени компиляции.

Встроенная функция: _Decimal32 __builtin_nand32 (const char *str)

Аналогично __builtin_nan, за исключением того, что тип возвращаемого значения — _Decimal32.

Встроенная функция: _Decimal64 __builtin_nand64 (const char *str)

Аналогично __builtin_nan, за исключением того, что тип возвращаемого значения — _Decimal64.

Встроенная функция: _Decimal128 __builtin_nand128 (const char *str)

Аналогично __builtin_nan, за исключением того, что тип возвращаемого значения — _Decimal128.

Встроенная функция: float __builtin_nanf (const char *str)

Аналогично __builtin_nan, за исключением того, что тип возвращаемого значения — float.

Встроенная функция: long double __builtin_nanl (const char *str)

Аналогично __builtin_nan, за исключением того, что тип возвращаемого значения — long double.

Встроенная функция: double __builtin_nans (const char *str)

Аналогично __builtin_nan, за исключением того, что мантисса принудительно устанавливается в сигнализирующий NaN. Функция nans предложена в WG14 N965.

Встроенная функция: float __builtin_nansf (const char *str)

Аналогично __builtin_nans, за исключением того, что тип возвращаемого значения — float.

Встроенная функция: long double __builtin_nansl (const char *str)

Аналогично __builtin_nans, за исключением того, что тип возвращаемого значения — long double.

Встроенная функция: int __builtin_ffs (int x)

Возвращает значение, на единицу большее индекса младшего бита 1 в x, или 0, если x равно нулю.

Встроенная функция: int __builtin_clz (unsigned int x)

Возвращает количество старших нулевых битов в x, начиная с самого старшего бита. Если x равно 0, результат не определён.

Встроенная функция: int __builtin_ctz (unsigned int x)

Возвращает количество младших нулевых битов в x, начиная с младшего бита. Если x равно 0, результат не определён.

Встроенная функция: int __builtin_clrsb (int x)

Возвращает количество ведущих избыточных знаковых битов в x, т.е. количество битов после старшего значащего бита, равных ему.

Встроенная функция: int __builtin_popcount (unsigned int x)

Возвращает количество битов 1 в x.

Встроенная функция: int __builtin_parity (unsigned int x)

Возвращает чётность x, т.е. количество битов 1 в x по модулю 2.

Встроенная функция: int __builtin_ffsl (long)

Аналогично __builtin_ffs, за исключением того, что тип аргумента — long.

Встроенная функция: int __builtin_clzl (unsigned long)

Аналогично __builtin_clz, за исключением того, что тип аргумента — unsigned long.

Встроенная функция: int __builtin_ctzl (unsigned long)

Аналогично __builtin_ctz, за исключением того, что тип аргумента — unsigned long.

Встроенная функция: int __builtin_clrsbl (long)

Аналогично __builtin_clrsb, за исключением того, что тип аргумента — long.

Встроенная функция: int __builtin_popcountl (unsigned long)

Аналогично __builtin_popcount, за исключением того, что тип аргумента — unsigned long.

Встроенная функция: int __builtin_parityl (unsigned long)

Аналогична __builtin_parity, за исключением типа аргумента, который является unsigned long.

Встроенная функция: int __builtin_ffsll (long long)

Аналогична __builtin_ffs, за исключением типа аргумента, который является long long.

Встроенная функция: int __builtin_clzll (unsigned long long)

Аналогична __builtin_clz, за исключением типа аргумента, который является unsigned long long.

Встроенная функция: int __builtin_ctzll (unsigned long long)

Аналогична __builtin_ctz, за исключением типа аргумента, который является unsigned long long.

Встроенная функция: int __builtin_clrsbll (long long)

Аналогична __builtin_clrsb, за исключением типа аргумента, который является long long.

Встроенная функция: int __builtin_popcountll (unsigned long long)

Аналогична __builtin_popcount, за исключением типа аргумента, который является unsigned long long.

Встроенная функция: int __builtin_parityll (unsigned long long)

Аналогична __builtin_parity, за исключением типа аргумента, который является unsigned long long.

Встроенная функция: double __builtin_powi (double, int)

Возвращает первый аргумент, возведённый в степень второго. В отличие от функции pow, никакие гарантии относительно точности и округления не предоставляются.

Встроенная функция: float __builtin_powif (float, int)

Аналогична __builtin_powi, за исключением типов аргумента и возвращаемого значения, которые являются float.

Встроенная функция: long double __builtin_powil (long double, int)

Аналогична __builtin_powi, за исключением типов аргумента и возвращаемого значения, которые являются long double.

Встроенная функция: uint16_t __builtin_bswap16 (uint16_t x)

Возвращает x с инвертированным порядком байтов; например, 0xaabb становится 0xbbaa. Байтом здесь всегда является ровно 8 бит.

Встроенная функция: uint32_t __builtin_bswap32 (uint32_t x)

Аналогична __builtin_bswap16, за исключением 32-битных типов аргумента и возвращаемого значения.

Встроенная функция: uint64_t __builtin_bswap64 (uint64_t x)

Аналогична __builtin_bswap32, за исключением 64-битных типов аргумента и возвращаемого значения.

Далее: Встроенные функции целевой системы, Предыдущее: Встроенные функции Cilk Plus, Наверх: Расширения C [Содержание][Индекс]