6.58 Другие встроенные функции, предоставляемые 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, scalbf, scalbl, scalb, signbit, signbitf, signbitl, signbitd32, signbitd64, signbitd128, significandf, significandl, significand, sincosf, sincosl, sincos, stpcpy, stpncpy, strcasecmp, strdup, strfmon, strncasecmp, strndup, toascii, y0f, y0l, y0, y1f, y1l, y1, ynf, ynl и yn могут обрабатываться как встроенные функции. Все эти функции имеют соответствующие версии с префиксом __builtin_, которые могут использоваться даже в строгом режиме C90.

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

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

Также есть встроенные функции __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, frexp, fscanf, isalnum, isalpha, iscntrl, isdigit, isgraph, islower, isprint, ispunct, isspace, isupper, isxdigit, tolower, toupper, labs, ldexp, log10, log, malloc, memchr, memcmp, memcpy, memset, modf, pow, printf, putchar, puts, scanf, sinh, sin, snprintf, sprintf, sqrt, sscanf, strcat, strchr, strcmp, strcpy, strcspn, strlen, strncat, strncmp, strncpy, strpbrk, strrchr, strspn, strstr, tanh, tan, vfprintf, vprintf и vsprintf — все являются встроенными функциями, если не указано -fno-builtin (или -fno-builtin-function для конкретной функции). Все эти функции имеют соответствующие версии с префиксом __builtin_.

GCC предоставляет встроенные версии макросов сравнения с плавающей запятой ISO C99, которые избегают повышения исключений для неупорядоченных операндов. У них такие же имена, как у стандартных макросов (isgreater, isgreaterequal, isless, islessequal, islessgreater, и isunordered) с префиксом __builtin_. Мы намерены, чтобы реализатор библиотеки смог просто #define каждый стандартный макрос своему встроенному эквиваленту. Аналогично, 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 предоставляет их как расширение. Подробности см. в Variable Length.

Встроенная функция: 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 предоставляет их как расширение. Подробности см. в Variable Length.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

Встроенная функция: тип __builtin_tgmath (функции, аргументы)

Встроенная функция __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, и это ошибка, если такой функции нет.

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

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

Вы можете использовать встроенную функцию __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,
   /* … */
};

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

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

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

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

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

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

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

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

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

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

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

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 (char *begin, char *end)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Встроенная функция: int __builtin_clrsb (int x): Возвращает количество старших избыточных знаковых битов в x, то есть количество битов, следующих за старшим битом и идентичных ему. Нет особых случаев для 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-битные.

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

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

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