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

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

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

За исключением встроенных функций, имеющих библиотечные аналоги, такие как стандартные функции библиотеки C, обсуждаемые ниже, или функций, расширяющихся до вызовов библиотеки, встроенные функции 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, roundeven, roundevenf, roundevenl, scalbf, scalbl, scalb, signbit, signbitf, signbitl, signbitd32, signbitd64, signbitd128, significandf, significandl, significand, sincosf, sincosl, sincos, stpcpy, stpncpy, strcasecmp, strdup, strfmon, strncasecmp, strndup, strnlen, 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 обрабатываются как встроенные функции, за исключением строгого режима 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, modff, powf, powl, sinf, sinhf, sinhl, sinl, sqrtf, sqrtl, tanf, tanhf, tanhl и tanl, которые распознаются в любом режиме, так как ISO C90 оставляет эти имена для целей, которым их использует ISO C99. Все эти функции имеют соответствующие версии с префиксом __builtin_.

Также существуют встроенные функции __builtin_fabsfn, __builtin_fabsfnx, __builtin_copysignfn и __builtin_copysignfnx, соответствующие функциям TS 18661-3 fabsfn, fabsfnx, copysignfn и copysignfnx, для поддерживаемых типов _Floatn и _Floatnx.

Также существуют функции расширения GNU clog10, clog10f и clog10l, имена которых зарезервированы 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, free, 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, realloc, 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, iseqsig, isfinite, isinf_sign, isnormal и signbit, используемые с префиксом __builtin_. Встроенные функции isinf и isnan представлены как с, так и без префикса __builtin_. С опцией -ffinite-math-only встроенные функции isinf и isnan всегда возвращают 0.

GCC предоставляет встроенные версии функций ISO C99 для обработки округления и исключений чисел с плавающей точкой fegetround, feclearexcept и feraiseexcept. Они могут быть недоступны для всех целей, и из-за необходимости тесного взаимодействия с внутренними значениями libc, они могут быть недоступны для всех целевых библиотек libc, но в любом случае они будут плавно переключаться на вызовы libc.

Встроенная функция: void * __builtin_alloca (size_t size)

Функция __builtin_alloca должна вызываться в области блока. Функция выделяет на стеке вызывающей функции объект размером size байт. Объект выравнивается на границе выравнивания стека по умолчанию для целевой системы, определяемой макросом __BIGGEST_ALIGNMENT__. Функция __builtin_alloca возвращает указатель на первый байт выделенного объекта. Жизненный цикл выделенного объекта заканчивается непосредственно перед тем, как вызывающая функция вернется своему вызывающему. Это так даже когда __builtin_alloca вызывается внутри вложенного блока.

Например, следующая функция выделяет на стеке восемь объектов по n байт каждый, сохраняя указатель на каждый из них в последовательных элементах массива a. Затем она передает массив функции g, которая может безопасно использовать хранилище, на которое указывает каждый из элементов массива.

void f (unsigned n)
{
  void *a [8];
  for (int i = 0; i != 8; ++i)
    a [i] = __builtin_alloca (n);

  g (a, n);   // safe
}

Поскольку функция __builtin_alloca не проверяет свой аргумент, вызывающая функция отвечает за обеспечение того, чтобы аргумент не привел к превышению размера стека. Функция __builtin_alloca предоставляется для возможности выделения на стеке массивов байтов с верхним пределом, который может быть вычислен во время выполнения. Поскольку переменные массивы длины C99 предлагают аналогичную функциональность через портативный, более удобный и безопасный интерфейс, они рекомендуются вместо них в программах C99 и C++, где GCC предоставляет их как расширение. См. Переменные массивы длины для получения подробностей.

Встроенная функция: void * __builtin_alloca_with_align (size_t size, size_t alignment)

Функция __builtin_alloca_with_align должна вызываться в области блока. Функция выделяет на стеке вызывающей функции объект размером size байт. Выделенный объект выравнивается на границу, указанную аргументом alignment, единица которого задана в битах (а не байтах). Аргумент size должен быть положительным и не превышать предел размера стека. Аргумент alignment должен быть константным целочисленным выражением, равным степени двойки, большему или равному CHAR_BIT и меньшему некоторому неопределенному максимуму. Вызовы с другими значениями отклоняются с сообщением об ошибке, указывающим допустимые границы. Функция возвращает указатель на первый байт выделенного объекта. Жизненный цикл выделенного объекта заканчивается в конце блока, в котором была вызвана функция. Выделенная память освобождается не позднее, чем непосредственно перед возвратом вызывающей функции своему вызывающему, но может быть освобождена в конце блока, в котором была вызвана функция.

Например, в следующей функции вызов g небезопасен, потому что когда overalign не равно нулю, пространство, выделенное __builtin_alloca_with_align, может быть освобождено в конце оператора if, в котором оно было вызвано.

void f (unsigned n, bool overalign)
{
  void *p;
  if (overalign)
    p = __builtin_alloca_with_align (n, 64 /* bits */);
  else
    p = __builtin_alloc (n);

  g (p, n);   // unsafe
}

Поскольку функция __builtin_alloca_with_align не проверяет свой аргумент size, вызывающая функция отвечает за обеспечение того, чтобы аргумент не привел к превышению размера стека. Функция __builtin_alloca_with_align предоставляется для возможности выделения на стеке массивов байтов с произвольным выравниванием, верхняя граница которых может быть вычислена во время выполнения. Поскольку переменные массивы длины C99 предлагают ту же функциональность через портативный, более удобный и безопасный интерфейс, они рекомендуются вместо них в программах C99 и C++, где GCC предоставляет их как расширение. См. Переменные массивы длины для получения подробностей.

Встроенная функция: void * __builtin_alloca_with_align_and_max (size_t size, size_t alignment, size_t max_size): Аналогично __builtin_alloca_with_align, но принимает дополнительный аргумент, определяющий верхнюю границу для size в том случае, если его значение не может быть вычислено во время компиляции, для использования с -fstack-usage, -Wstack-usage и -Walloca-larger-than. max_size должен быть константным целочисленным выражением, оно не влияет на генерацию кода и не предпринимаются попытки проверить его совместимость с size.

END_OF_DOCUMENT_MARKER

Встроенная функция: bool __builtin_has_attribute (type-or-expression, attribute)

Функция __builtin_has_attribute возвращает целочисленное константное выражение, равное true, если символ или тип, на который ссылается аргумент type-or-expression, объявлен с атрибутом, указанным во втором аргументе. Для аргумента type-or-expression, не ссылающегося на символ, поскольку атрибуты не применяются к выражениям, встроенная функция рассматривает тип аргумента. Ни один из аргументов не вычисляется. Аргумент type-or-expression подчиняется тем же ограничениям, что и аргумент функции typeof (см. Ссылка на тип с typeof). Аргумент attribute — это имя атрибута, за которым необязательно следует список аргументов, разделенных запятыми, заключенных в скобки. Признаются оба варианта имен атрибутов — с двойными ведущими и завершающими подчёркиваниями и без них. Подробнее см. Синтаксис атрибутов. Если для атрибута, ожидающего один или несколько аргументов, не указаны аргументы, функция возвращает true, если type-or-expression объявлен с этим атрибутом независимо от значений аргументов атрибута. Указанные для атрибута аргументы, ожидающие некоторые, проверяются и сопоставляются с указанным количеством. Функция возвращает true, если все предоставленные аргументы совпадают. Например, первый вызов функции ниже возвращает true, потому что x объявлен с атрибутом aligned, но второй вызов возвращает false, потому что x объявлен с aligned (8), а не с aligned (4).

__attribute__ ((aligned (8))) int x;
_Static_assert (__builtin_has_attribute (x, aligned), "aligned");
_Static_assert (!__builtin_has_attribute (x, aligned (4)), "aligned (4)");

Из-за ограничения функция __builtin_has_attribute возвращает false для атрибута mode, даже если тип или переменная, на которую ссылается аргумент type-or-expression, были объявлены с ним. Функция также не поддерживается с метками и в C с перечислениями.

Обратите внимание, что в отличие от препроцессорного оператора __has_attribute, подходящего для использования в директивах препроцессинга #if, __builtin_has_attribute — это встроенная функция, которая не распознается в таких контекстах.

Встроенная функция: type __builtin_speculation_safe_value (type val, type failval)

Эта встроенная функция может использоваться для снижения риска небезопасного спекулятивного выполнения. type может быть любым целочисленным типом или любым указателем.

Если процессор не выполняет код спекулятивно, то возвращается val.
Если процессор выполняет код спекулятивно, то либо:
- Функция может приостановить выполнение, пока не будет известно, что код больше не выполняется спекулятивно (в этом случае можно вернуть val, как и выше); или
- Функция может использовать зависящее от целевой платформы состояние отслеживания спекуляций, чтобы вернуть failval, когда известно, что спекулятивное выполнение неправильно предсказало операцию условного перехода.

Второй аргумент failval является необязательным и по умолчанию равен нулю, если опущен.

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

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

int array[500];
int f (unsigned untrusted_index)
{
  if (untrusted_index < 500)
    return array[untrusted_index];
  return 0;
}

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

int array[500];
int f (unsigned untrusted_index)
{
  if (untrusted_index < 500)
    return array[__builtin_speculation_safe_value (untrusted_index)];
  return 0;
}

Встроенная функция либо приостановит выполнение, пока условный переход не будет полностью разрешен, либо может разрешить спекулятивное выполнение продолжить, но использовать 0 вместо untrusted_value, если это превышает предел.

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

int array[500];
int f (unsigned untrusted_index)
{
  if (untrusted_index < 500)
    return *__builtin_speculation_safe_value (&array[untrusted_index], NULL);
  return 0;
}

что приведет к использованию указателя NULL в случае небезопасности.

Встроенная функция: 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 оценивается как true, 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_tgmath (functions, arguments)

Встроенная функция __builtin_tgmath, доступная только для C и Objective-C, вызывает функцию, определяемую согласно правилам <tgmath.h> макросов. Она предназначена для использования в реализациях данного заголовочного файла, чтобы расширения макросов из этого заголовочного файла расширяли каждый из своих аргументов только один раз, чтобы избежать проблем, когда вызовы таких макросов вложены внутри аргументов других вызовов таких макросов; кроме того, это приводит к лучшей диагностике для некорректных вызовов <tgmath.h> макросов, чем реализации, использующие другие функции языка GNU C. Например, pow тип-обобщающий макрос может быть определён как:

#define pow(a, b) __builtin_tgmath (powf, pow, powl, \
                                    cpowf, cpow, cpowl, a, b)

Аргументами __builtin_tgmath являются по меньшей мере два указателя на функции, за которыми следуют аргументы тип-обобщающего макроса (которые будут переданы в качестве аргументов выбранной функции). Все указатели на функции должны быть указателями на типизированные функции, ни одна из которых не может иметь переменное число аргументов, и все они должны иметь одинаковое количество параметров; количество параметров первой функции определяет, сколько аргументов __builtin_tgmath интерпретируются как указатели на функции, а сколько как аргументы вызываемой функции.

Типы указанных функций должны быть все разные, но взаимосвязаны так же, как набор функций, между которыми может выбирать макрос в <tgmath.h>. Это означает, что функции параметризованы типом с плавающей точкой t, различным для каждой такой функции. Типы возвращаемых значений функций могут быть одинаковыми, или они могут быть типом t для каждой функции, или они могут быть вещественным типом, соответствующим t для каждой функции (если некоторые из типов t являются комплексными). Аналогично, для каждой позиции параметра тип параметра в этой позиции может всегда быть одним и тем же типом, или может быть типом t для каждой функции (этот случай должен применяться по крайней мере для одной позиции параметра), или может быть вещественным типом, соответствующим t для каждой функции.

Используются стандартные правила для <tgmath.h> макросов, чтобы найти общий тип u из типов аргументов для параметров, типы которых различаются между функциями; комплексные целочисленные типы (расширение GNU) обрабатываются как комплексный тип, соответствующий вещественному типу с плавающей точкой, который был бы выбран для соответствующего вещественного целочисленного типа. Если типы возвращаемых значений функций изменяются или все являются одинаковым целочисленным типом, вызывается функция, для которой t есть u, и это ошибка, если такой функции нет. Если типы возвращаемых значений функций являются одним и тем же типом с плавающей точкой, предполагается, что тип-обобщающий макрос — это один из тех из TS 18661, который округляет результат до более узкого типа; если есть функция, для которой t есть u, она вызывается, а в противном случае вызывается первая функция, если таковая имеется, для которой t имеет по крайней мере тот же диапазон и точность, что и u, и это ошибка, если такой функции нет.

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

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

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

#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 должен быть более консервативным при вычислении встроенной функции в этом случае, потому что у него нет возможности выполнить оптимизацию.

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

Функция __builtin_is_constant_evaluated доступна только в C++. Встроенная функция предназначена для использования реализациями std::is_constant_evaluated функции C++. Программы должны использовать последнюю функцию, а не вызывать непосредственно встроенную.

Основное применение встроенной функции заключается в определении того, вызывается ли constexpr функция в constexpr контексте. Вызов функции оценивается как явная константная выражение со значением true тогда и только тогда, когда он встречается в вычислении выражения или преобразования, которое явно является константным, как определено в стандарте C++. К контекстам явной константной оценки относятся константные выражения, условия constexpr if инструкций, выражения ограничений и инициализаторы переменных, используемых в константных выражениях. Для получения более подробной информации см. последнюю редакцию стандарта C++.

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

Встроенная функция __builtin_clear_padding очищает биты заполнения внутри представления объекта, на который указывает ptr, который должен быть указателем. Представление значения объекта не изменяется. Тип объекта предполагается как тип, на который указывает указатель. Внутри объединения очищаются только биты, которые являются битами заполнения для всех членов объединения.

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

Для C++, тип аргумента ptr должен быть указателем на тип, который тривиально копируется, за исключением случаев, когда аргументом является адрес переменной или параметра, так как в противном случае неизвестно, не является ли тип просто базовым классом, чьи биты заполнения используются повторно или располагаются по-разному в производном классе.

Встроенная функция: type __builtin_bit_cast (type, arg)

Функция __builtin_bit_cast доступна только в C++. Встроенная функция предназначена для использования в реализациях std::bit_cast шаблонной функции C++. Программы должны использовать последнюю функцию, а не вызывать встроенную функцию напрямую.

Эта встроенная функция позволяет переинтерпретировать биты аргумента arg так, как если бы он имел тип type. type и тип аргумента arg должны быть тривиально копируемыми типами с одинаковым размером. При явной константной оценке выполняется дополнительная диагностика, необходимая для std::bit_cast, и возвращается константное выражение, если arg — константное выражение. Для получения более подробной информации см. последнюю редакцию стандарта C++.

Встроенная функция: 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);

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

Для целей оптимизации прогнозирования ветвлений вероятность того, что __builtin_expect выражение равно true, регулируется параметром builtin-expect-probability GCC, который по умолчанию равен 90%.

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

Встроенная функция: long __builtin_expect_with_probability

(long exp, long c, double probability)

Эта функция имеет те же семантику, что и __builtin_expect, но вызывающая сторона предоставляет ожидаемую вероятность того, что exp == c. Последний аргумент, probability, — это значение с плавающей запятой в диапазоне от 0,0 до 1,0 включительно. Аргумент probability должен быть константным выражением с плавающей запятой.

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

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

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

Один из таких случаев — сразу после оператора asm, который либо никогда не завершается, либо перенаправляет управление в другое место и никогда не возвращается. В этом примере, без __builtin_unreachable, GCC выдает предупреждение о том, что управление достигает конца функции, не возвращающей значение. Он также генерирует код для возврата после 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 ();
    }
}

Встроенная функция: type __builtin_assoc_barrier (type expr)

Эта встроенная функция препятствует повторной ассоциации выражения с плавающей запятой expr с выражениями, использующими возвращаемое значение встроенной функции. Само выражение expr может быть переупорядочено, и все выражение expr может быть переупорядочено с операндами после барьера. Барьер актуален только при -fassociative-math, так как в противном случае арифметика с плавающей запятой не рассматривается как ассоциативная.

float x0 = a + b - b;
float x1 = __builtin_assoc_barrier(a + b) - b;

означает, что с -fassociative-math, x0 может быть оптимизировано до x0 = a, но x1 не может.

Встроенная функция: 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__ и возвращает константный адрес, указывающий на имя функции, из которой был вызван встроенный элемент, или пустую строку, если вызов не происходит из области функции. При использовании в качестве аргумента по умолчанию C++ для функции F она возвращает имя вызывающей стороны F или пустую строку, если вызов не происходил из области функции.

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

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

Например, в следующем примере каждый вызов функции foo выведет строку, подобную "file.c:123: foo: message", с именем файла и номером строки вызова printf, именем функции foo, за которым следует слово message.

const char*
function (const char *func = __builtin_FUNCTION ())
{
  return func;
}

void foo (void)
{
  printf ("%s:%i: %s: message\n", file (), line (), function ());
}

Встроенная функция: void __builtin___clear_cache (void *begin, void *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. Значение 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 не выдает предупреждение.

Встроенная функция: size_t __builtin_object_size (const void * ptr, int type): Возвращает оценочный размер объекта, на который указывает ptr. Подробное описание функции см. в разделе Проверка размера объекта.

Встроенная функция: size_t __builtin_dynamic_object_size (const void * ptr, int type): Аналогично __builtin_object_size, за исключением того, что возвращаемое значение необязательно должно быть константой. Подробное описание функции см. в разделе Проверка размера объекта.

END_OF_DOCUMENT_MARKER

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

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

Функция __builtin_classify_type возвращает целое число, представляющее категорию типа аргумента arg, например, void type, integer type, enumeral type, boolean type, pointer type, reference type, offset type, real type, complex type, function type, method type, record type, union type, array type, string type, bit-precise integer type, vector type и т.д. Когда аргументом является выражение, по причинам обратной совместимости аргумент преобразуется так же, как аргументы, передаваемые в ... в функции varargs, поэтому некоторые классы никогда не возвращаются в определённых языках. В качестве альтернативы, аргументом встроенной функции может быть имя типа, например, спецификатор typeof.

int a[2];
__builtin_classify_type (a) == __builtin_classify_type (int[5]);
__builtin_classify_type (a) == __builtin_classify_type (void*);
__builtin_classify_type (typeof (a)) == __builtin_classify_type (int[5]);

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

Встроенная функция: 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.

Встроенная функция: _Floatn __builtin_huge_valfn (void): Аналогично __builtin_huge_val, за исключением того, что тип возвращаемого значения — _Floatn.

Встроенная функция: _Floatnx __builtin_huge_valfnx (void): Аналогично __builtin_huge_val, за исключением того, что тип возвращаемого значения — _Floatnx.

Встроенная функция: int __builtin_fpclassify (int, int, int, int, int, ...): Эта встроенная функция реализует функциональность fpclassify из C99. Первые пять целочисленных аргументов должны представлять понимание целевой библиотекой возможных классов 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.

Встроенная функция: _Floatn __builtin_inffn (void): Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — _Floatn.

Встроенная функция: _Floatn __builtin_inffnx (void): Аналогично __builtin_inf, за исключением того, что тип возвращаемого значения — _Floatnx.

Встроенная функция: 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.

Встроенная функция: _Floatn __builtin_nanfn (const char *str): Аналогично __builtin_nan, за исключением того, что возвращаемый тип — _Floatn.

Встроенная функция: _Floatnx __builtin_nanfnx (const char *str): Аналогично __builtin_nan, за исключением того, что возвращаемый тип — _Floatnx.

Встроенная функция: double __builtin_nans (const char *str): Аналогично __builtin_nan, за исключением того, что мантисса принудительно устанавливается как сигнализирующее NaN. Функция nans предложена в WG14 N965.

Встроенная функция: _Decimal32 __builtin_nansd32 (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — _Decimal32.

Встроенная функция: _Decimal64 __builtin_nansd64 (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — _Decimal64.

Встроенная функция: _Decimal128 __builtin_nansd128 (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — _Decimal128.

Встроенная функция: float __builtin_nansf (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — float.

Встроенная функция: long double __builtin_nansl (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — long double.

Встроенная функция: _Floatn __builtin_nansfn (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — _Floatn.

Встроенная функция: _Floatnx __builtin_nansfnx (const char *str): Аналогично __builtin_nans, за исключением того, что возвращаемый тип — _Floatnx.

Встроенная функция: int __builtin_issignaling (...): Возвращает ненулевое значение, если аргумент является сигнализирующим NaN, и нуль в противном случае. Обратите внимание, что хотя список параметров является многоточием, эта функция принимает только один аргумент с плавающей точкой. GCC рассматривает этот параметр как имеющий общий тип, что означает, что он не выполняет стандартное повышение типа от float до double. Эта встроенная функция может работать даже без опции -fsignaling-nans, отличной от значения по умолчанию, хотя, если сигнализирующее NaN вычисляется, сохраняется или передается как аргумент какой-либо функции, отличной от этой встроенной, в текущем трансляционном блоке, безопаснее использовать -fsignaling-nans. С опцией -ffinite-math-only эта встроенная функция всегда будет возвращать 0.

Встроенная функция: int __builtin_ffs (int x): Возвращает единицу плюс индекс наименьшего значащего 1-бита x, или, если x равно нулю, возвращает ноль.

Встроенная функция: int __builtin_clz (unsigned int x): Возвращает количество ведущих 0-битов в x, начиная с наиболее значимого бита. Если x равно 0, результат не определен.

Встроенная функция: int __builtin_ctz (unsigned int x): Возвращает количество завершающих 0-битов в x, начиная с наименее значащего бита. Если x равно 0, результат не определен.

Встроенная функция: int __builtin_clrsb (int x): Возвращает количество ведущих избыточных битов знака в x, т.е. количество битов после наиболее значимого бита, которые идентичны ему. Нет специальных случаев для 0 или других значений.

Встроенная функция: 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.

Встроенная функция: int __builtin_ffsg (...): Аналогично __builtin_ffs, за исключением того, что аргумент является универсальным знаковым целым числом (стандартным, расширенным или битово-точным). К аргументу не применяются повышения типа целочисленных аргументов.

Встроенная функция: int __builtin_clzg (...): Аналогично __builtin_clz, за исключением того, что аргумент является универсальным беззнаковым целым числом (стандартным, расширенным или битово-точным), и существует необязательный второй аргумент типа int. К первому аргументу не применяются повышения типа целочисленных аргументов. Если указаны два аргумента, и первый аргумент равен 0, результатом является второй аргумент. Если указан только один аргумент, и он равен 0, результат не определен.

Встроенная функция: int __builtin_ctzg (...): Аналогично __builtin_ctz, за исключением того, что аргумент является универсальным беззнаковым целым числом (стандартным, расширенным или битово-точным), и существует необязательный второй аргумент типа int. К первому аргументу не применяются повышения типа целочисленных аргументов. Если указаны два аргумента, и первый аргумент равен 0, результатом является второй аргумент. Если указан только один аргумент, и он равен 0, результат не определен.

Встроенная функция: int __builtin_clrsbg (...): Аналогично __builtin_clrsb, за исключением того, что аргумент является универсальным знаковым целым числом (стандартным, расширенным или битово-точным). К аргументу не применяются повышения типа целочисленных аргументов.

Встроенная функция: int __builtin_popcountg (...): Аналогично __builtin_popcount, за исключением того, что аргумент является универсальным беззнаковым целым числом (стандартным, расширенным или битово-точным). К аргументу не применяются повышения типа целочисленных аргументов.

Встроенная функция: int __builtin_parityg (...): Аналогично __builtin_parity, за исключением того, что аргумент является универсальным беззнаковым целым числом (стандартным, расширенным или битово-точным). К аргументу не применяются повышения типа целочисленных аргументов.

Встроенная функция: type __builtin_stdc_bit_ceil (type arg): Функция __builtin_stdc_bit_ceil доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна arg <= 1 ? (type) 1 : (type) 2 << (prec - 1 - __builtin_clzg ((type) (arg - 1))), где prec — это разрядность type, за исключением того, что побочные эффекты в arg вычисляются только один раз.

Встроенная функция: type __builtin_stdc_bit_floor (type arg): Функция __builtin_stdc_bit_floor доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна arg == 0 ? (type) 0 : (type) 1 << (prec - 1 - __builtin_clzg (arg)), где prec — это разрядность type, за исключением того, что побочные эффекты в arg вычисляются только один раз.

Встроенная функция: unsigned int __builtin_stdc_bit_width (type arg): Функция __builtin_stdc_bit_width доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (unsigned int) (prec - __builtin_clzg (arg, prec)), где prec — это разрядность type.

Встроенная функция: unsigned int __builtin_stdc_count_ones (type arg): Функция __builtin_stdc_count_ones доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (unsigned int) __builtin_popcountg (arg)

Встроенная функция: unsigned int __builtin_stdc_count_zeros (type arg): Функция __builtin_stdc_count_zeros доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (unsigned int) __builtin_popcountg ((type) ~arg)

Встроенная функция: unsigned int __builtin_stdc_first_leading_one (type arg): Функция __builtin_stdc_first_leading_one доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна __builtin_clzg (arg, -1) + 1U

Встроенная функция: unsigned int __builtin_stdc_first_leading_zero (type arg): Функция __builtin_stdc_first_leading_zero доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна __builtin_clzg ((type) ~arg, -1) + 1U

Встроенная функция: unsigned int __builtin_stdc_first_trailing_one (type arg): Функция __builtin_stdc_first_trailing_one доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна __builtin_ctzg (arg, -1) + 1U

Встроенная функция: unsigned int __builtin_stdc_first_trailing_zero (type arg): Функция __builtin_stdc_first_trailing_zero доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна __builtin_ctzg ((type) ~arg, -1) + 1U

Встроенная функция: unsigned int __builtin_stdc_has_single_bit (type arg): Функция __builtin_stdc_has_single_bit доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (_Bool) (__builtin_popcountg (arg) == 1)

Встроенная функция: unsigned int __builtin_stdc_leading_ones (type arg): Функция __builtin_stdc_leading_ones доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (unsigned int) __builtin_clzg ((type) ~arg, prec)

Встроенная функция: unsigned int __builtin_stdc_leading_zeros (type arg): Функция __builtin_stdc_leading_zeros доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (unsigned int) __builtin_clzg (arg, prec)

Встроенная функция: unsigned int __builtin_stdc_trailing_ones (type arg): Функция __builtin_stdc_trailing_ones доступна только в C. Она является универсальной по типу, аргументом может быть любое беззнаковое целое число (стандартное, расширенное или битово-точное). К аргументу не применяются повышения типа целочисленных аргументов. Она эквивалентна (unsigned int) __builtin_ctzg ((type) ~arg, prec)

Встроенная функция: unsigned int __builtin_stdc_trailing_zeros (type arg): Функция __builtin_stdc_trailing_zeros доступна только в C. Она является типобезопасной, аргумент может быть любым беззнаковым целым числом (стандартным, расширенным или битовым). Аргументу не выполняются продвижения целочисленных аргументов. Она эквивалентна (unsigned int) __builtin_ctzg (arg, prec)

Встроенная функция: double __builtin_powi (double, int)
Встроенная функция: float __builtin_powif (float, int)
Встроенная функция: long double __builtin_powil (long double, int): Возвращает первый аргумент, возведённый в степень второго. В отличие от функции pow, не гарантируется точность и округление.

Встроенная функция: 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 бита.

Встроенная функция: uint128_t __builtin_bswap128 (uint128_t x): Аналогично __builtin_bswap64, за исключением того, что аргумент и возвращаемое значение имеют 128 бит. Поддерживается только на целевых платформах, где поддерживаются 128-битные типы.

Встроенная функция: Pmode __builtin_extend_pointer (void * x): На целевых платформах, где размер видимого пользователю указателя меньше размера фактического аппаратного адреса, эта функция возвращает расширенный указатель пользователя. К таким платформам относятся ILP32 режим на x86_64 или Aarch64. Эта функция в основном полезна при написании кода встроенного ассемблера.

Встроенная функция: int __builtin_goacc_parlevel_id (int x): Возвращает идентификатор группы, работника или вектора openacc в зависимости от того, является ли x равным 0, 1 или 2.

Встроенная функция: int __builtin_goacc_parlevel_size (int x): Возвращает размер группы, работника или вектора openacc в зависимости от того, является ли x равным 0, 1 или 2.

© Free Software Foundation
Licensed under the GNU Free Documentation License, Version 1.3.
https://gcc.gnu.org/onlinedocs/gcc-14.2.0/gcc/Other-Builtins.html