6.59.21 Встроенные функции PowerPC

Следующие встроенные функции всегда доступны и могут использоваться для проверки типа целевой платформы PowerPC:

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

Эта функция является nop на платформе PowerPC и включена только для сохранения совместимости API с встроенными функциями x86.

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

Эта функция возвращает значение 1 если процессор во время выполнения имеет тип cpuname, и возвращает 0 в противном случае

Функция __builtin_cpu_is требует GLIBC 2.23 или новее, которые экспортируют биты аппаратных возможностей. GCC определяет макрос __BUILTIN_CPU_SUPPORTS__ если функция __builtin_cpu_supports полностью поддерживается.

Если GCC был сконфигурирован для использования GLIBC до версии 2.23, встроенная функция __builtin_cpu_is всегда возвращает 0, и компилятор выдает предупреждение.

Могут быть обнаружены следующие имена процессоров:

‘power9’

Процессор IBM POWER9.

‘power8’

Процессор IBM POWER8.

‘power7’

Процессор IBM POWER7.

‘power6x’

Процессор IBM POWER6 (режим RAW).

‘power6’

Процессор IBM POWER6 (архитектурный режим).

‘power5+’

Процессор IBM POWER5+.

‘power5’

Процессор IBM POWER5.

‘ppc970’

Процессор IBM 970 (например, Apple G5).

‘power4’

Процессор IBM POWER4.

‘ppca2’

Встроенный 64-битный процессор IBM A2.

‘ppc476’

Встроенный 32-битный процессор IBM PowerPC 476FP.

‘ppc464’

Встроенный 32-битный процессор IBM PowerPC 464.

‘ppc440’

Встроенный 32-битный процессор PowerPC 440.

‘ppc405’

Встроенный 32-битный процессор PowerPC 405.

‘ppc-cell-be’

Процессор архитектуры IBM PowerPC Cell Broadband Engine.

Вот пример:

#ifdef __BUILTIN_CPU_SUPPORTS__
  if (__builtin_cpu_is ("power8"))
    {
       do_power8 (); // POWER8 specific implementation.
    }
  else
#endif
    {
       do_generic (); // Generic implementation.
    }

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

Эта функция возвращает значение 1 если процессор во время выполнения поддерживает аппаратную возможность feature, и возвращает 0 в противном случае.

Функция __builtin_cpu_supports требует GLIBC 2.23 или новее, которые экспортируют биты аппаратных возможностей. GCC определяет макрос __BUILTIN_CPU_SUPPORTS__ если функция __builtin_cpu_supports полностью поддерживается.

Если GCC был сконфигурирован для использования GLIBC до версии 2.23, встроенная функция __builtin_cpu_suports всегда возвращает 0, и компилятор выдает предупреждение.

Могут быть обнаружены следующие возможности:

‘4xxmac’

Процессор 4xx имеет множитель-сумматор.

‘altivec’

Процессор имеет SIMD/векторный блок.

‘arch_2_05’

Процессор поддерживает ISA 2.05 (например, POWER6).

‘arch_2_06’

Процессор поддерживает ISA 2.06 (например, POWER7).

‘arch_2_07’

Процессор поддерживает ISA 2.07 (например, POWER8).

‘arch_3_00’

Процессор поддерживает ISA 3.0 (например, POWER9).

‘archpmu’

Процессор поддерживает набор совместимых событий мониторинга производительности.

‘booke’

Процессор поддерживает встроенную категорию ISA.

‘cellbe’

Процессор имеет CELL broadband engine.

‘dfp’

Процессор имеет блок десятичной плавающей точки.

‘dscr’

Процессор поддерживает регистр управления потоком данных.

‘ebb’

Процессор поддерживает ветвления с основой событий.

‘efpdouble’

Процессор имеет блок плавающей точки двойной точности SPE.

‘efpsingle’

Процессор имеет блок плавающей точки одинарной точности SPE.

‘fpu’

Процессор имеет блок плавающей точки.

‘htm’

Процессор имеет аппаратные инструкции памяти транзакций.

‘htm-nosc’

Ядро прерывает аппаратные транзакции при выполнении системного вызова.

‘ic_snoop’

Процессор поддерживает возможности прослушивания кэша инструкций.

‘ieee128’

Процессор поддерживает инструкции двоичной плавающей точки IEEE 128-битной.

‘isel’

Процессор поддерживает инструкцию целочисленного выбора.

‘mmu’

Процессор имеет блок управления памятью.

‘notb’

Процессор не имеет тайм-базы (например, 601 и 403gx).

‘pa6t’

Процессор поддерживает ISA ядра PA Semi 6T.

‘power4’

Процессор поддерживает ISA 2.00 (например, POWER4).

‘power5’

Процессор поддерживает ISA 2.02 (например, POWER5).

‘power5+’

Процессор поддерживает ISA 2.03 (например, POWER5+).

‘power6x’

Процессор поддерживает расширенные инструкции ISA 2.05 (например, POWER6) mffgpr и mftgpr.

‘ppc32’

Процессор поддерживает выполнение в 32-битном режиме.

‘ppc601’

Процессор поддерживает старую архитектуру POWER (например, 601).

‘ppc64’

Процессор поддерживает выполнение в 64-битном режиме.

‘ppcle’

Процессор поддерживает режим little-endian с использованием перемещения адресов.

‘smt’

Процессор поддерживает одновременную многопоточность.

‘spe’

Процессор имеет блок расширения обработки сигналов.

‘tar’

Процессор поддерживает регистр целевого адреса.

‘true_le’

Процессор поддерживает режим true little-endian.

‘ucache’

Процессор имеет объединенный кэш I/D.

‘vcrypto’

Процессор поддерживает векторные инструкции криптографии.

‘vsx’

Процессор поддерживает расширение вектор-скаляр.

Вот пример:

#ifdef __BUILTIN_CPU_SUPPORTS__
  if (__builtin_cpu_supports ("fpu"))
    {
       asm("fadd %0,%1,%2" : "=d"(dst) : "d"(src1), "d"(src2));
    }
  else
#endif
    {
       dst = __fadd (src1, src2); // Software FP addition function.
    }

Эти встроенные функции доступны для семейства процессоров PowerPC:

float __builtin_recipdivf (float, float);
float __builtin_rsqrtf (float);
double __builtin_recipdiv (double, double);
double __builtin_rsqrt (double);
uint64_t __builtin_ppc_get_timebase ();
unsigned long __builtin_ppc_mftb ();
double __builtin_unpack_longdouble (long double, int);
long double __builtin_pack_longdouble (double, double);
__ibm128 __builtin_unpack_ibm128 (__ibm128, int);
__ibm128 __builtin_pack_ibm128 (double, double);

Функции vec_rsqrt, __builtin_rsqrt, и __builtin_rsqrtf генерируют несколько инструкций для реализации функции обратного квадратного корня, используя инструкции оценки обратного квадратного корня.

Функции __builtin_recipdiv, и __builtin_recipdivf генерируют несколько инструкций для реализации деления, используя инструкции оценки обратного значения.

Функции __builtin_ppc_get_timebase и __builtin_ppc_mftb генерируют инструкции для чтения регистра Time Base. Функция __builtin_ppc_get_timebase может генерировать несколько инструкций и всегда возвращает 64 бита регистра Time Base. Функция __builtin_ppc_mftb всегда генерирует одну инструкцию и возвращает значение регистра Time Base как unsigned long, отбрасывая старший разряд в 32-битных средах.

Функция __builtin_unpack_longdouble принимает аргумент long double и константу времени компиляции 0 или 1. Если константа равна 0, возвращается первая double в long double, в противном случае возвращается вторая double. Функция __builtin_unpack_longdouble доступна только если long double использует расширенное представление двойной точности IBM.

Функция __builtin_pack_longdouble принимает два аргумента double и возвращает значение long double, которое объединяет два аргумента. Функция __builtin_pack_longdouble доступна только если long double использует расширенное представление двойной точности IBM.

Функция __builtin_unpack_ibm128 принимает аргумент __ibm128 и константу времени компиляции 0 или 1. Если константа равна 0, возвращается первая double в __ibm128, в противном случае возвращается вторая double.

Функция __builtin_pack_ibm128 принимает два аргумента double и возвращает значение __ibm128, которое объединяет два аргумента.

Дополнительные встроенные функции доступны для 64-битного семейства процессоров PowerPC для эффективного использования 128-битных значений плавающей точки (__float128).

Предыдущие версии GCC поддерживали некоторые встроенные функции ‘q’ для плавающей точки IEEE 128-бит. Сейчас эти функции отображаются на эквивалентные встроенные функции ‘f128’.

__builtin_fabsq is mapped into __builtin_fabsf128
__builtin_copysignq is mapped into __builtin_copysignf128
__builtin_infq is mapped into __builtin_inff128
__builtin_huge_valq is mapped into __builtin_huge_valf128
__builtin_nanq is mapped into __builtin_nanf128
__builtin_nansq is mapped into __builtin_nansf128

Следующие встроенные функции доступны на 64-битных системах Linux, которые используют набор инструкций ISA 3.0.

__float128 __builtin_sqrtf128 (__float128)

Выполнение операции извлечения квадратного корня для 128-битной плавающей точки IEEE.

__float128 __builtin_fmaf128 (__float128, __float128, __float128)

Выполнение операции умножения и сложения для 128-битной плавающей точки IEEE.

__float128 __builtin_addf128_round_to_odd (__float128, __float128)

Выполнение сложения для 128-битной плавающей точки IEEE с округлением до нечётного.

__float128 __builtin_subf128_round_to_odd (__float128, __float128)

Выполнение вычитания для 128-битной плавающей точки IEEE с округлением до нечётного.

__float128 __builtin_mulf128_round_to_odd (__float128, __float128)

Выполнение умножения для 128-битной плавающей точки IEEE с округлением до нечётного.

__float128 __builtin_divf128_round_to_odd (__float128, __float128)

Выполнение деления для 128-битной плавающей точки IEEE с округлением до нечётного.

__float128 __builtin_sqrtf128_round_to_odd (__float128)

Выполнение операции извлечения квадратного корня для 128-битной плавающей точки IEEE с округлением до нечётного.

__float128 __builtin_fmaf128 (__float128, __float128, __float128)

Выполнение операции умножения и сложения для 128-битной плавающей точки IEEE с округлением до нечётного.

double __builtin_truncf128_round_to_odd (__float128)

Преобразование значения 128-битной плавающей точки IEEE в double с округлением до нечётного.

Следующие встроенные функции доступны для семейства процессоров PowerPC, начиная с ISA 2.05 или новее (-mcpu=power6 или -mcmpb):

unsigned long long __builtin_cmpb (unsigned long long int, unsigned long long int);
unsigned int __builtin_cmpb (unsigned int, unsigned int);

Функция __builtin_cmpb выполняет побайтовое сравнение содержимого своих двух аргументов, возвращая результат побайтового сравнения в качестве возвращаемого значения. Для каждого побайтового сравнения соответствующий байт возвращаемого значения содержит 0xff, если входные байты равны, и 0, если входные байты не равны. Если любой из аргументов этой встроенной функции шире 32 бит, вызов функции расширяется в форму, ожидающую unsigned long long int аргументы, которая доступна только на 64-битных целевых платформах.

Следующие встроенные функции доступны для процессоров семейства PowerPC, начиная с ISA 2.06 или более поздней версии (-mcpu=power7 или -mpopcntd):

long __builtin_bpermd (long, long);
int __builtin_divwe (int, int);
unsigned int __builtin_divweu (unsigned int, unsigned int);
long __builtin_divde (long, long);
unsigned long __builtin_divdeu (unsigned long, unsigned long);
unsigned int cdtbcd (unsigned int);
unsigned int cbcdtd (unsigned int);
unsigned int addg6s (unsigned int, unsigned int);
void __builtin_rs6000_speculation_barrier (void);

Функции __builtin_divde и __builtin_divdeu требуют 64-битной среды, поддерживающей ISA 2.06 или более позднюю версию.

Следующие встроенные функции доступны для процессоров семейства PowerPC, начиная с ISA 3.0 или более поздней версии (-mcpu=power9):

long long __builtin_darn (void);
long long __builtin_darn_raw (void);
int __builtin_darn_32 (void);

unsigned int scalar_extract_exp (double source);
unsigned long long int scalar_extract_exp (__ieee128 source);

unsigned long long int scalar_extract_sig (double source);
unsigned __int128 scalar_extract_sig (__ieee128 source);

double
scalar_insert_exp (unsigned long long int significand, unsigned long long int exponent);
double
scalar_insert_exp (double significand, unsigned long long int exponent);

ieee_128
scalar_insert_exp (unsigned __int128 significand, unsigned long long int exponent);
ieee_128
scalar_insert_exp (ieee_128 significand, unsigned long long int exponent);

int scalar_cmp_exp_gt (double arg1, double arg2);
int scalar_cmp_exp_lt (double arg1, double arg2);
int scalar_cmp_exp_eq (double arg1, double arg2);
int scalar_cmp_exp_unordered (double arg1, double arg2);

bool scalar_test_data_class (float source, const int condition);
bool scalar_test_data_class (double source, const int condition);
bool scalar_test_data_class (__ieee128 source, const int condition);

bool scalar_test_neg (float source);
bool scalar_test_neg (double source);
bool scalar_test_neg (__ieee128 source);

vector _uint128_t vec_msum (vector unsigned long long,
                           vector unsigned long long,
                           vector _uint128_t);
vector _int128_t vec_msum (vector signed long long,
                          vector signed long long,
                          vector _int128_t);

int __builtin_byte_in_set (unsigned char u, unsigned long long set);
int __builtin_byte_in_range (unsigned char u, unsigned int range);
int __builtin_byte_in_either_range (unsigned char u, unsigned int ranges);

int __builtin_dfp_dtstsfi_lt (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_lt (unsigned int comparison, _Decimal128 value);
int __builtin_dfp_dtstsfi_lt_dd (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_lt_td (unsigned int comparison, _Decimal128 value);

int __builtin_dfp_dtstsfi_gt (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_gt (unsigned int comparison, _Decimal128 value);
int __builtin_dfp_dtstsfi_gt_dd (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_gt_td (unsigned int comparison, _Decimal128 value);

int __builtin_dfp_dtstsfi_eq (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_eq (unsigned int comparison, _Decimal128 value);
int __builtin_dfp_dtstsfi_eq_dd (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_eq_td (unsigned int comparison, _Decimal128 value);

int __builtin_dfp_dtstsfi_ov (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_ov (unsigned int comparison, _Decimal128 value);
int __builtin_dfp_dtstsfi_ov_dd (unsigned int comparison, _Decimal64 value);
int __builtin_dfp_dtstsfi_ov_td (unsigned int comparison, _Decimal128 value);

Функции __builtin_darn и __builtin_darn_raw требуют 64-битной среды, поддерживающей ISA 3.0 или более позднюю версию. Функция __builtin_darn предоставляет 64-битное условное случайное число. Функция __builtin_darn_raw предоставляет 64-битное «сырое» случайное число. Функция __builtin_darn_32 предоставляет 32-битное случайное число.

Функции scalar_extract_exp и scalar_extract_sig требуют 64-битной среды, поддерживающей ISA 3.0 или более позднюю версию. Встроенные функции scalar_extract_exp и scalar_extract_sig возвращают соответственно мантиссу и смещённое значение экспоненты для своих аргументов source. При использовании 64-битного аргумента source, результат, возвращаемый функцией scalar_extract_sig, имеет бит 0x0010000000000000 установленным, если аргумент функции source находится в нормализованной форме. В противном случае этот бит установлен в 0. При использовании 128-битного аргумента source, бит 0x00010000000000000000000000000000 результата обрабатывается аналогично. Обратите внимание, что знак мантиссы не представлен в результате, возвращаемом функцией scalar_extract_sig. Используйте функцию scalar_test_neg для проверки знака своего аргумента double. Функции vec_msum выполняют векторное умножение-суммирование, возвращая результат arg1*arg2+arg3. ISA 3.0 добавляет поддержку vec_msum, возвращающей векторный результат int128.

Функции scalar_insert_exp требуют 64-битной среды, поддерживающей ISA 3.0 или более позднюю версию. При использовании 64-битного первого аргумента, встроенная функция scalar_insert_exp возвращает значение с двойной точностью с плавающей запятой, которое формируется путём сборки значений своих аргументов significand и exponent. Знак результата копируется из старшего бита аргумента significand. Компоненты мантиссы и экспоненты результата составлены из 11 младших битов аргумента exponent и 52 младших битов аргумента significand соответственно.

При использовании 128-битного первого аргумента, встроенная функция scalar_insert_exp возвращает значение с четырёхкратной точностью с плавающей запятой IEEE. Бит знака результата копируется из старшего бита аргумента significand. Компоненты мантиссы и экспоненты результата составлены из 15 младших битов аргумента exponent и 112 младших битов аргумента significand соответственно.

Встроенные функции scalar_cmp_exp_gt, scalar_cmp_exp_lt, scalar_cmp_exp_eq и scalar_cmp_exp_unordered возвращают ненулевое значение, если arg1 больше, меньше, равно или не сравнимо с arg2 соответственно. Аргументы не сравнимы, если один или другой равен NaN (не число).

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

0x40    Test for NaN
0x20    Test for +Infinity
0x10    Test for -Infinity
0x08    Test for +Zero
0x04    Test for -Zero
0x02    Test for +Denormal
0x01    Test for -Denormal

Встроенная функция scalar_test_neg возвращает 1, если её аргумент source содержит отрицательное значение, и 0 в противном случае.

Функция __builtin_byte_in_set требует 64-битной среды, поддерживающей ISA 3.0 или более позднюю версию. Эта функция возвращает ненулевое значение, если и только если её аргумент u точно равен одному из восьми байтов, содержащихся в её 64-битном аргументе set.

Функции __builtin_byte_in_range и __builtin_byte_in_either_range требуют среды, поддерживающей ISA 3.0 или более позднюю версию. Для этих двух функций аргумент range закодирован как 4 байта, организованные как hi_1:lo_1:hi_2:lo_2. Функция __builtin_byte_in_range возвращает ненулевое значение, если и только если её аргумент u находится в диапазоне от lo_2 до hi_2 включительно. Функция __builtin_byte_in_either_range возвращает ненулевое значение, если и только если её аргумент u находится в диапазоне от lo_1 до hi_1 включительно или от lo_2 до hi_2 включительно.

Функция __builtin_dfp_dtstsfi_lt возвращает ненулевое значение, если и только если количество значащих цифр её аргумента value меньше, чем её аргумент comparison. Функции __builtin_dfp_dtstsfi_lt_dd и __builtin_dfp_dtstsfi_lt_td ведут себя аналогично, но требуют, чтобы тип аргумента value был __Decimal64 и __Decimal128 соответственно.

Функция __builtin_dfp_dtstsfi_gt возвращает ненулевое значение, если и только если количество значащих цифр её аргумента value больше, чем её аргумент comparison. Функции __builtin_dfp_dtstsfi_gt_dd и __builtin_dfp_dtstsfi_gt_td ведут себя аналогично, но требуют, чтобы тип аргумента value был __Decimal64 и __Decimal128 соответственно.

Функция __builtin_dfp_dtstsfi_eq возвращает ненулевое значение, если и только если количество значащих цифр её аргумента value равно её аргументу comparison. Функции __builtin_dfp_dtstsfi_eq_dd и __builtin_dfp_dtstsfi_eq_td ведут себя аналогично, но требуют, чтобы тип аргумента value был __Decimal64 и __Decimal128 соответственно.

Функция __builtin_dfp_dtstsfi_ov возвращает ненулевое значение, если и только если её аргумент value имеет неопределённое количество значащих цифр, например, когда value является кодированием NaN. Функции __builtin_dfp_dtstsfi_ov_dd и __builtin_dfp_dtstsfi_ov_td ведут себя аналогично, но требуют, чтобы тип аргумента value был __Decimal64 и __Decimal128 соответственно.

Следующие встроенные функции также доступны для процессоров семейства PowerPC, начиная с ISA 3.0 или более поздней версии (-mcpu=power9). Эти строковые функции описываются отдельно, чтобы сгруппировать описания ближе к прототипам функций:

int vec_all_nez (vector signed char, vector signed char);
int vec_all_nez (vector unsigned char, vector unsigned char);
int vec_all_nez (vector signed short, vector signed short);
int vec_all_nez (vector unsigned short, vector unsigned short);
int vec_all_nez (vector signed int, vector signed int);
int vec_all_nez (vector unsigned int, vector unsigned int);

int vec_any_eqz (vector signed char, vector signed char);
int vec_any_eqz (vector unsigned char, vector unsigned char);
int vec_any_eqz (vector signed short, vector signed short);
int vec_any_eqz (vector unsigned short, vector unsigned short);
int vec_any_eqz (vector signed int, vector signed int);
int vec_any_eqz (vector unsigned int, vector unsigned int);

vector bool char vec_cmpnez (vector signed char arg1, vector signed char arg2);
vector bool char vec_cmpnez (vector unsigned char arg1, vector unsigned char arg2);
vector bool short vec_cmpnez (vector signed short arg1, vector signed short arg2);
vector bool short vec_cmpnez (vector unsigned short arg1, vector unsigned short arg2);
vector bool int vec_cmpnez (vector signed int arg1, vector signed int arg2);
vector bool int vec_cmpnez (vector unsigned int, vector unsigned int);

vector signed char vec_cnttz (vector signed char);
vector unsigned char vec_cnttz (vector unsigned char);
vector signed short vec_cnttz (vector signed short);
vector unsigned short vec_cnttz (vector unsigned short);
vector signed int vec_cnttz (vector signed int);
vector unsigned int vec_cnttz (vector unsigned int);
vector signed long long vec_cnttz (vector signed long long);
vector unsigned long long vec_cnttz (vector unsigned long long);

signed int vec_cntlz_lsbb (vector signed char);
signed int vec_cntlz_lsbb (vector unsigned char);

signed int vec_cnttz_lsbb (vector signed char);
signed int vec_cnttz_lsbb (vector unsigned char);

unsigned int vec_first_match_index (vector signed char, vector signed char);
unsigned int vec_first_match_index (vector unsigned char,
                                    vector unsigned char);
unsigned int vec_first_match_index (vector signed int, vector signed int);
unsigned int vec_first_match_index (vector unsigned int, vector unsigned int);
unsigned int vec_first_match_index (vector signed short, vector signed short);
unsigned int vec_first_match_index (vector unsigned short,
                                    vector unsigned short);
unsigned int vec_first_match_or_eos_index (vector signed char,
                                           vector signed char);
unsigned int vec_first_match_or_eos_index (vector unsigned char,
                                           vector unsigned char);
unsigned int vec_first_match_or_eos_index (vector signed int,
                                           vector signed int);
unsigned int vec_first_match_or_eos_index (vector unsigned int,
                                           vector unsigned int);
unsigned int vec_first_match_or_eos_index (vector signed short,
                                           vector signed short);
unsigned int vec_first_match_or_eos_index (vector unsigned short,
                                           vector unsigned short);
unsigned int vec_first_mismatch_index (vector signed char,
                                       vector signed char);
unsigned int vec_first_mismatch_index (vector unsigned char,
                                       vector unsigned char);
unsigned int vec_first_mismatch_index (vector signed int,
                                       vector signed int);
unsigned int vec_first_mismatch_index (vector unsigned int,
                                       vector unsigned int);
unsigned int vec_first_mismatch_index (vector signed short,
                                       vector signed short);
unsigned int vec_first_mismatch_index (vector unsigned short,
                                       vector unsigned short);
unsigned int vec_first_mismatch_or_eos_index (vector signed char,
                                              vector signed char);
unsigned int vec_first_mismatch_or_eos_index (vector unsigned char,
                                              vector unsigned char);
unsigned int vec_first_mismatch_or_eos_index (vector signed int,
                                              vector signed int);
unsigned int vec_first_mismatch_or_eos_index (vector unsigned int,
                                              vector unsigned int);
unsigned int vec_first_mismatch_or_eos_index (vector signed short,
                                              vector signed short);
unsigned int vec_first_mismatch_or_eos_index (vector unsigned short,
                                              vector unsigned short);

vector unsigned short vec_pack_to_short_fp32 (vector float, vector float);

vector signed char vec_xl_be (signed long long, signed char *);
vector unsigned char vec_xl_be (signed long long, unsigned char *);
vector signed int vec_xl_be (signed long long, signed int *);
vector unsigned int vec_xl_be (signed long long, unsigned int *);
vector signed __int128 vec_xl_be (signed long long, signed __int128 *);
vector unsigned __int128 vec_xl_be (signed long long, unsigned __int128 *);
vector signed long long vec_xl_be (signed long long, signed long long *);
vector unsigned long long vec_xl_be (signed long long, unsigned long long *);
vector signed short vec_xl_be (signed long long, signed short *);
vector unsigned short vec_xl_be (signed long long, unsigned short *);
vector double vec_xl_be (signed long long, double *);
vector float vec_xl_be (signed long long, float *);

vector signed char vec_xl_len (signed char *addr, size_t len);
vector unsigned char vec_xl_len (unsigned char *addr, size_t len);
vector signed int vec_xl_len (signed int *addr, size_t len);
vector unsigned int vec_xl_len (unsigned int *addr, size_t len);
vector signed __int128 vec_xl_len (signed __int128 *addr, size_t len);
vector unsigned __int128 vec_xl_len (unsigned __int128 *addr, size_t len);
vector signed long long vec_xl_len (signed long long *addr, size_t len);
vector unsigned long long vec_xl_len (unsigned long long *addr, size_t len);
vector signed short vec_xl_len (signed short *addr, size_t len);
vector unsigned short vec_xl_len (unsigned short *addr, size_t len);
vector double vec_xl_len (double *addr, size_t len);
vector float vec_xl_len (float *addr, size_t len);

vector unsigned char vec_xl_len_r (unsigned char *addr, size_t len);

void vec_xst_len (vector signed char data, signed char *addr, size_t len);
void vec_xst_len (vector unsigned char data, unsigned char *addr, size_t len);
void vec_xst_len (vector signed int data, signed int *addr, size_t len);
void vec_xst_len (vector unsigned int data, unsigned int *addr, size_t len);
void vec_xst_len (vector unsigned __int128 data, unsigned __int128 *addr, size_t len);
void vec_xst_len (vector signed long long data, signed long long *addr, size_t len);
void vec_xst_len (vector unsigned long long data, unsigned long long *addr, size_t len);
void vec_xst_len (vector signed short data, signed short *addr, size_t len);
void vec_xst_len (vector unsigned short data, unsigned short *addr, size_t len);
void vec_xst_len (vector signed __int128 data, signed __int128 *addr, size_t len);
void vec_xst_len (vector double data, double *addr, size_t len);
void vec_xst_len (vector float data, float *addr, size_t len);

void vec_xst_len_r (vector unsigned char data, unsigned char *addr, size_t len);

signed char vec_xlx (unsigned int index, vector signed char data);
unsigned char vec_xlx (unsigned int index, vector unsigned char data);
signed short vec_xlx (unsigned int index, vector signed short data);
unsigned short vec_xlx (unsigned int index, vector unsigned short data);
signed int vec_xlx (unsigned int index, vector signed int data);
unsigned int vec_xlx (unsigned int index, vector unsigned int data);
float vec_xlx (unsigned int index, vector float data);

signed char vec_xrx (unsigned int index, vector signed char data);
unsigned char vec_xrx (unsigned int index, vector unsigned char data);
signed short vec_xrx (unsigned int index, vector signed short data);
unsigned short vec_xrx (unsigned int index, vector unsigned short data);
signed int vec_xrx (unsigned int index, vector signed int data);
unsigned int vec_xrx (unsigned int index, vector unsigned int data);
float vec_xrx (unsigned int index, vector float data);

Функции vec_all_nez, vec_any_eqz и vec_cmpnez выполняют парные сравнения элементов в тех же позициях в своих двух векторных аргументах. Функция vec_all_nez возвращает ненулевое значение, если и только если все парные сравнения не равны, и ни один элемент ни одного векторного аргумента не содержит ноль. Функция vec_any_eqz возвращает ненулевое значение, если и только если хотя бы одно парное сравнение равно или если хотя бы один элемент любого векторного аргумента содержит ноль. Функция vec_cmpnez возвращает вектор того же типа, что и её два аргумента, в котором каждый элемент состоит из всех единиц, чтобы указать, что соответствующие элементы входных аргументов не равны или что, по крайней мере, один из соответствующих элементов содержит ноль. В противном случае элемент возвращаемого вектора содержит все нули.

Функция vec_cntlz_lsbb возвращает количество последовательных ведущих байтовых элементов (начиная с позиции 0 в предоставленном векторном аргументе), для которых младший бит равен нулю. Функция vec_cnttz_lsbb возвращает количество последовательных хвостовых байтовых элементов (начиная с позиции 15 и считая назад в предоставленном векторном аргументе), для которых младший бит равен нулю.

Функции vec_xl_len и vec_xst_len требуют 64-битной среды, поддерживающей ISA 3.0 или более позднюю версию. Функция vec_xl_len загружает вектор переменной длины из памяти. Функция vec_xst_len сохраняет вектор переменной длины в памяти. В обеих функциях vec_xl_len и vec_xst_len аргумент addr представляет адрес памяти, в который или из которого данные будут переданы, а аргумент len представляет количество байтов, которые будут переданы, как вычисляется выражением C min((len & 0xff), 16). Если значение этого выражения не кратно размеру элемента вектора, поведение этой функции является неопределённым. В случае, если компьютер сконфигурирован для работы в режиме big-endian, передача данных перемещает байты с 0 до (len - 1) соответствующего вектора. В режиме little-endian передача данных перемещает байты с (16 - len) до 15 соответствующего вектора. В случае функции загрузки, любые байты вектора результата, которые не загружены из памяти, устанавливаются в ноль. Значение аргумента addr не должно быть выровнено на кратной величине размера элемента вектора.

Функции vec_xlx и vec_xrx извлекают отдельный элемент, выбранный аргументом index, из вектора, представленного аргументом data. Аргумент index всегда задаёт байтовый смещение, независимо от размера элемента вектора. С vec_xlx, index является смещением первого байта извлекаемого элемента. С vec_xrx, index представляет последний байт извлекаемого элемента, измеряемый с правого конца вектора. Другими словами, последний байт извлекаемого элемента находится в позиции (15 - index). Нет требования, чтобы index было кратно размеру элемента вектора. Однако, если размер элемента вектора, добавленный к index, превышает 15, содержание возвращаемого значения является неопределённым.

Следующие встроенные функции доступны для семейства процессоров PowerPC, когда доступен аппаратный десятичный плавающий тип (-mhard-dfp):

long long __builtin_dxex (_Decimal64);
long long __builtin_dxexq (_Decimal128);
_Decimal64 __builtin_ddedpd (int, _Decimal64);
_Decimal128 __builtin_ddedpdq (int, _Decimal128);
_Decimal64 __builtin_denbcd (int, _Decimal64);
_Decimal128 __builtin_denbcdq (int, _Decimal128);
_Decimal64 __builtin_diex (long long, _Decimal64);
_Decimal128 _builtin_diexq (long long, _Decimal128);
_Decimal64 __builtin_dscli (_Decimal64, int);
_Decimal128 __builtin_dscliq (_Decimal128, int);
_Decimal64 __builtin_dscri (_Decimal64, int);
_Decimal128 __builtin_dscriq (_Decimal128, int);
unsigned long long __builtin_unpack_dec128 (_Decimal128, int);
_Decimal128 __builtin_pack_dec128 (unsigned long long, unsigned long long);

Следующие встроенные функции доступны для семейства процессоров PowerPC, когда доступен набор инструкций Vector Scalar (vsx):

unsigned long long __builtin_unpack_vector_int128 (vector __int128_t, int);
vector __int128_t __builtin_pack_vector_int128 (unsigned long long,
                                                unsigned long long);

Далее: Встроенные функции PowerPC AltiVec/VSX, Предыдущее: Встроенные функции picoChip, Вверх: Встроенные функции целевого процессора [Оглавление][Индекс]