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

Также есть функции расширений 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_. Мы намерены предоставить разработчикам библиотек возможность просто заменить каждый стандартный макрос его встроенным аналогом. Также, 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 предоставляет их в качестве расширения. Подробности см. в разделе Массивы переменной длины.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void function_that_never_returns (void);

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

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

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

void *x = __builtin_assume_aligned (arg, 16);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает единицу плюс индекс младшего значащего бита 1 в x, или, если 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-битный размер.

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