Следующее: Встроенные функции, специфичные для конкретных целевых машин, Предыдущее: Встроенные функции проверки размера объектов, Наверх: Расширения для языков семейства C [Содержание][Индекс]

6.59 Другие встроенные функции, предоставляемые 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, vsscanf, 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, __builtin_, __builtin_fabsfn, __builtin_fabsfnx, __builtin_copysignfn, __builtin_copysignfnx, fabsfn, fabsfnx, copysignfn, copysignfnx, _Floatn, _Floatnx.

END_OF_DOCUMENT_MARKER

Также имеются функции расширения 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, isfinite, isinf_sign, isnormal и signbit встроенные функции, используемые с префиксом __builtin_. Встроенные функции isinf и isnan появляются как с, так и без префикса __builtin_.

Встроенная функция: 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, объявлен с атрибутом attribute, указанным во втором аргументе. Для аргумента 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 **. Кроме того, два типа, которые являются псевдонимами, считаются совместимыми, если их базовые типы совместимы.

Тип 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) рассматриваются как _Complex double в этих целях (или _Complex _Float64 если все типы возвращаемых значений функций являются одинаковым типом _Floatn или _Floatnx). Если типы возвращаемых значений функций различаются или все являются одинаковым целочисленным типом, вызывается функция, для которой t равно u, и это ошибка, если такой функции нет. Если типы возвращаемых значений функций являются одинаковым типом с плавающей точкой, тип-обобщающий макрос считается одним из тех, что из TS 18661, который округляет результат до более узкого типа; если существует функция, для которой t равно u, она вызывается, а в противном случае вызывается первая функция, если таковая имеется, для которой t имеет, по крайней мере, диапазон и точность u, и это ошибка, если такой функции нет.

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

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

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

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

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

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

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

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

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

Эта встроенная функция позволяет переинтерпретировать биты аргумента 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 — за call функцией, которая никогда не возвращается, но не объявлена __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__ и возвращает константный адрес, указывающий на имя функции, из которой была вызвана встроенная функция, или пустую строку, если вызов не происходит в области видимости функции. При использовании в качестве аргумента по умолчанию для функции 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 — это константа времени компиляции, равная нулю или единице; единица означает, что предварительная выборка готовится к записи в адрес памяти, а ноль (значение по умолчанию) означает, что предварительная выборка готовится к чтению. Значение locality должно быть целочисленной константой времени компиляции от нуля до трех. Значение ноль означает, что данные не имеют временной локализации, поэтому их не нужно оставлять в кэше после доступа. Значение три означает, что данные имеют высокую степень временной локализации и должны быть оставлены во всех возможных уровнях кэша. Значения один и два означают соответственно низкую или среднюю степень временной локализации. Значение по умолчанию — три.

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 не выдает предупреждение.

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

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

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

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

Далее: Встроенные функции, специфичные для конкретных целевых машин, Предыдущее: Встроенные функции проверки размера объектов, Наверх: Расширения языка семейства C [Оглавление][Указатель]

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