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

Предыдущие версии GCC не принимали эту встроенную функцию в инициализаторах данных. Самая ранняя версия, где это полностью безопасно, — 3.0.1.

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

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

Возвращает количество единичных битов в x.

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

Возвращает чётность x, т. е. количество единичных битов в 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-битные.