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

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

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

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

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