# Поддерживаемые MCST builtin’ы

Содержание

- Поддерживаемые MCST builtin’ы

  - Общая информация

  - Машинно-независимые builtin’ы

  - E2K-зависимые builtin’ы

    - Обращения в память с MAS’ом

    - Вычисление типа процессора в runtime

    - Builtin’ы для работы с конкретными машинными операциями

      - Система команд v1 и выше

      - Система команд v2 и выше

      - Система команд v3 и выше

      - Система команд v4 и выше

      - Система команд v5 и выше

      - Система команд v6 и выше

    - Builtin’ы для работы в защищённом режиме

  - E90-зависимые builtin’ы

    - Обращения в память с ASI-кодом

## Общая информация

В данном документе описываются только собственные builtin’ы. Те builtin’ы, которые позаимствованы у gcc, описаны в статье Поддерживаемые GNU builtin’ы

## Машинно-независимые builtin’ы

`void` __builtin_read_barrier `(void)`

> Барьер для операций чтения из памяти. Через данную точку кода компилятор НЕ будет переставлять операции чтения из памяти

`void` __builtin_write_barrier `(void)`

> Барьер для операций записи в память. Через данную точку кода компилятор НЕ будет переставлять операции записи в память

`void` __builtin_mem_barrier `(void)`

> Барьер для операций чтения из памяти и и записи в память. Является комбинацией `__builtin_read_barrier` и `__builtin_write_barrier`

`void` __builtin_barrier `(void)`

> Барьер для всех операций. Через данную точку кода компилятор НЕ будет переставлять никакие операции

## E2K-зависимые builtin’ы

### Обращения в память с MAS’ом

Данные builtin’ы предназначены для построения операций load/store с использованием MAS (Memory Access Specifier). Во всех builtin’ах данной группы параметр `addr` обозначает целевой адрес, параметр `val` обозначает записываемое значение (для store’ов), параметр `mas` обозначает значение MAS, параметр `channel` обозначает номер канала (номер ALU-устройства), параметр `mask` означает маску записываемого значения (для pstore’ов).

В качестве параметра `mas` можно подать значение `__LCC_MAS_NO` для обозначения отсутствия MAS’а. К параметру `mas` через логическое “или” можно добавить следующие значения:

> - `__LCC_MAS_SPEC` для обозначения спекулятивности операции

> - `__LCC_MAS_VOLATILE` для обозначения обращения в память со смыслом, аналогичным `volatile` в языках C/C++

> - `__LCC_MAS_CLEARTAG` для обозначения обращения в память с чисткой тэгов у прочитанного значения (для load’ов)

В качестве параметра `channel` можно подать значение `__LCC_CHAN_ANY` для обозначения любого допустимого канала

Тип `v2di` обозначает `long long __attribute__((vector_size(16)))`

`uint8` __builtin_loadmas_8u `(const void *addr, int mas, int channel)`
`uint16` __builtin_loadmas_16u `(const void *addr, int mas, int channel)`
`uint32` __builtin_loadmas_32u `(const void *addr, int mas, int channel)`
`uint64` __builtin_loadmas_64u `(const void *addr, int mas, int channel)`

> Построение операций ldgd*/ld*/ldap* с mas’ом

`v2di` __builtin_loadmas_128v `(const void *addr, int mas, int channel)`

> Построение операций ldgdqp/ldqp/ldapqp с mas’ом. Доступен только для режима `-march=elbrus-v5` и выше

`void` __builtin_storemas_8u `(uint8 val, void *addr, int mas, int channel)`
`void` __builtin_storemas_16u `(uint16 val, void *addr, int mas, int channel)`
`void` __builtin_storemas_32u `(uint32 val, void *addr, int mas, int channel)`
`void` __builtin_storemas_64u `(uint64 val, void *addr, int mas, int channel)`

> Построение операций stgd*/st*/stap* с mas’ом

`void` __builtin_storemas_128v `(v2di val, void *addr, int mas, int channel)`

> Построение операций stgdqp/stqp/stapqp с mas’ом. Доступен только для режима `-march=elbrus-v5` и выше

`void` __builtin_pstoremas_128v `(v2di val, void *addr, unsigned int mask, int mas, int channel)`

> Построение операций stgdmqp/stmqp/stapmqp с mas’ом. Доступен только для режима `-march=elbrus-v5` и выше

### Вычисление типа процессора в runtime

`void` __builtin_cpu_init `(void)`

> Инициализация для работы `__builtin_cpu_is`, `__builtin_cpu_name` и `__builtin_cpu_arch`. Если указанные builtin’ы`используются в приложениях пользовательского уровня в кодах, которые работают после начала функции `main`, то вручную вызывать `__builtin_cpu_init` нет необходимости (хотя от лишнего вызова ничего плохого не случится), т.к. инициализация выполняется на уровне инициализации языковых конструкторов. Для приложений системного уровня, которые линкуются нестандартным образом, требуется вручную вызвать `__builtin_cpu_init` до первого вызова указанных builtin’ов

`int` __builtin_cpu_is `(const char *arg)`

> Проверяет в run-time, удовлетворяет ли процессор, на котором исполняется программа, условию `arg`, которое должно быть строковым литералом и может принимать следующие значения:

> `"elbrus-v1"` - любой процессор с системой команд v1
> `"elbrus-v2"` - любой процессор с системой команд v2
> `"elbrus-v3"` - любой процессор с системой команд v3
> `"elbrus-v4"` - любой процессор с системой команд v4
> `"elbrus-v5"` - любой процессор с системой команд v5
> `"elbrus-v6"` - любой процессор с системой команд v6
> `"elbrus"` - процессор модели “elbrus” (система команд v1)
> `"elbrus-2c+"` - процессор модели “elbrus-2c+” (система команд v2)
> `"elbrus-4c"` - процессор модели “elbrus-4c” (система команд v3)
> `"elbrus-8c"` - процессор модели “elbrus-8c” (система команд v4)
> `"elbrus-1c+"` - процессор модели “elbrus-1c+” (система команд v4)
> `"elbrus-8c2"` - процессор модели “elbrus-8c2” (система команд v5)
> `"elbrus-12c"` - процессор модели “elbrus-12c” (система команд v6)
> `"elbrus-16c"` - процессор модели “elbrus-16c” (система команд v6)
> `"elbrus-2c3"` - процессор модели “elbrus-2c3” (система команд v6)

> См. так же описание `__builtin_cpu_init`

`const char*` __builtin_cpu_name `(void)`

> Получить в run-time название модели процессора в виде строки

> См. так же описание `__builtin_cpu_init`

`const char*` __builtin_cpu_arch `(void)`

> Получить в run-time название архитектуры процессора в виде строки

> См. так же описание `__builtin_cpu_init`

### Builtin’ы для работы с конкретными машинными операциями

Каждый builtin описывает одну машинную операцию. Имя builtin’а соответствует имени операции по системе команд. Например, действие `__builtin_e2k_paddb` соответствует тому, как работает машинная операция `paddb` (описание см. в системе команд)

Тип `v2di` означает `long long __attribute__((vector_size(16)))` - такой же тип, как и в `__builtin_loadmas_128v`, `__builtin_storemas_128v`, `__builtin_pstoremas_128v`

#### Система команд v1 и выше

Сложение и вычитание по модулю
`uint64` __builtin_e2k_paddb `(uint64 src1, uint64 src2)`

> Сложение 8-ми байт (8S/8U)

`uint64` __builtin_e2k_paddh `(uint64 src1, uint64 src2)`

> Сложение 4-х short’ов (16S/16U)

`uint64` __builtin_e2k_paddw `(uint64 src1, uint64 src2)`

> Сложение 2-х int’ов (32S/32U)

`uint64` __builtin_e2k_paddd `(uint64 src1, uint64 src2)`

> Сложение 1-го long’а (64S/64U)

`uint64` __builtin_e2k_psubb `(uint64 src1, uint64 src2)`

> Вычитание 8-ми байт (8S/8U)

`uint64` __builtin_e2k_psubh `(uint64 src1, uint64 src2)`

> Вычитание 4-х short’ов (16S/16U)

`uint64` __builtin_e2k_psubw `(uint64 src1, uint64 src2)`

> Вычитание 2-х int’ов (32S/32U)

`uint64` __builtin_e2k_psubd `(uint64 src1, uint64 src2)`

> Вычитание 1-го long’а (64S/64U)

Сложение и вычитание c насыщением
`uint64` __builtin_e2k_paddsb `(uint64 src1, uint64 src2)`

> Сложение 8-ми знаковых байт (8S)

`uint64` __builtin_e2k_paddsh `(uint64 src1, uint64 src2)`

> Cложение 4-х знаковых short’ов (16S)

`uint64` __builtin_e2k_paddusb `(uint64 src1, uint64 src2)`

> Cложение 8-ми беззнаковых байт (8U)

`uint64` __builtin_e2k_paddush `(uint64 src1, uint64 src2)`

> Cложение 4-х беззнаковых short’ов (16U)

`uint64` __builtin_e2k_psubsb `(uint64 src1, uint64 src2)`

> Вычитание 8-ми знаковых байт (8S)

`uint64` __builtin_e2k_psubsh `(uint64 src1, uint64 src2)`

> Вычитание 4-х знаковых short’ов (16S)

`uint64` __builtin_e2k_psubusb `(uint64 src1, uint64 src2)`

> Вычитание 8-ми беззнаковых байт (8U)

`uint64` __builtin_e2k_psubush `(uint64 src1, uint64 src2)`

> Вычитание 4-х беззнаковых short’ов (16U)

Среднее арифметическое
`uint64` __builtin_e2k_pavgusb `(uint64 src1, uint64 src2)`

> Среднее 8-ми беззнаковых байт (8U)

`uint64` __builtin_e2k_pavgush `(uint64 src1, uint64 src2)`

> Среднее 4-х беззнаковых short’ов (16U)

Максимум и минимум
`uint64` __builtin_e2k_pmaxub `(uint64 src1, uint64 src2)`

> Максимум 8-ми беззнаковых байт (8U)

`uint64` __builtin_e2k_pmaxsh `(uint64 src1, uint64 src2)`

> Максимум 4-х знаковых short’ов (16S)

`uint64` __builtin_e2k_pminub `(uint64 src1, uint64 src2)`

> Минимум 8-ми беззнаковых байт (8U)

`uint64` __builtin_e2k_pminsh `(uint64 src1, uint64 src2)`

> Минимум 4-х знаковых short’ов (16S)

Умножение short’ов
`uint64` __builtin_e2k_pmulhuh `(uint64 src1, uint64 src2)`

> Умножение 4-х беззнаковых short’ов (16U) и выдача старших 16 разрядов произведений

`uint64` __builtin_e2k_pmulhh `(uint64 src1, uint64 src2)`

> Умножение 4-х знаковых short’ов (16S) и выдача старших 16 разрядов произведений

`uint64` __builtin_e2k_pmullh `(uint64 src1, uint64 src2)`

> Умножение 4-х short’ов (16S/16U) и выдача младших 16 разрядов произведений

Умножение int’ов
`uint64` __builtin_e2k_umulx `(uint64 src1, uint64 src2)`

> Умножение беззнаковых int’ов (32U) и получение 64-х разрядного произведения

`uint64` __builtin_e2k_smulx `(uint64 src1, uint64 src2)`

> Умножение знаковых int’ов (32S) и получение 64-х разрядного произведения

Умножение short’ов с горизонтальным сложением
`uint64` __builtin_e2k_pmaddh `(uint64 src1, uint64 src2)`

> Умножение 4-х знаковых short’ов (16S) и попарное сложение смежных int’овых произведений

Cложение абсолютных разностей беззнаковых байт
`uint64` __builtin_e2k_psadbw `(uint64 src1, uint64 src2)`

> Сложение абсолютных разностей 8-ми беззнаковых байт (8U)

Cравнение
`uint64` __builtin_e2k_pcmpeqb `(uint64 src1, uint64 src2)`

> Сравнение на “равно” 8-ми байт (8S/8U)

`uint64` __builtin_e2k_pcmpeqh `(uint64 src1, uint64 src2)`

> Сравнение на “равно” 4-х short’ов (16S/16U)

`uint64` __builtin_e2k_pcmpeqw `(uint64 src1, uint64 src2)`

> Сравнение на “равно” 2-х int’ов (32S/32U)

`uint64` __builtin_e2k_pcmpgtb `(uint64 src1, uint64 src2)`

> Сравнение на “больше” 8-ми знаковых байт (8S)

`uint64` __builtin_e2k_pcmpgth `(uint64 src1, uint64 src2)`

> Сравнение на “больше” 4-х знаковых short’ов (16S)

`uint64` __builtin_e2k_pcmpgtw `(uint64 src1, uint64 src2)`

> Сравнение на “больше” 2-х знаковых int’ов (32S)

Логические операции
`uint64` __builtin_e2k_pandd `(uint64 src1, uint64 src2)`

> Поразрядное логическое AND 64-х разрядов (64S/64U)

`uint64` __builtin_e2k_pandnd `(uint64 src1, uint64 src2)`

> Поразрядное логическое AND 64-х разрядов c инверсией второго операнда (64S/64U)

`uint64` __builtin_e2k_pord `(uint64 src1, uint64 src2)`

> Поразрядное логическое OR 64-х разрядов (64S/64U)

`uint64` __builtin_e2k_pxord `(uint64 src1, uint64 src2)`

> Поразрядное логическое XOR 64-х разрядов (64S/64U)

Формирование маски
`uint64` __builtin_e2k_pmovmskb `(uint64 src1, uint64 src2)`

> Формирование 16-разрядной маски из знаков каждого байта (8S)

`uint64` __builtin_e2k_pmovmskps `(uint64 src1, uint64 src2)`

> Формирование 4-разрядной маски из знаков каждого int’а (32S)

`uint64` __builtin_e2k_pmovmskpd `(uint64 src1, uint64 src2)`

> Формирование 2-разрядной маски из знаков каждого long’а (64S)

Битовый сдвиг
`uint64` __builtin_e2k_psllh `(uint64 src1, uint64 src2)`

> Сдвиг влево 4-х short’ов (16S/16U)

`uint64` __builtin_e2k_psllw `(uint64 src1, uint64 src2)`

> Сдвиг влево 2-х int’ов (32S/32U)

`uint64` __builtin_e2k_pslld `(uint64 src1, uint64 src2)`

> Сдвиг влево long’а (64S/64U)

`uint64` __builtin_e2k_psrlh `(uint64 src1, uint64 src2)`

> Логический сдвиг вправо 4-х беззнаковых short’ов (16U)

`uint64` __builtin_e2k_psrlw `(uint64 src1, uint64 src2)`

> Логический сдвиг вправо 2-х беззнаковых int’ов (32U)

`uint64` __builtin_e2k_psrld `(uint64 src1, uint64 src2)`

> Логический сдвиг вправо беззнакового long’а (64U)

`uint64` __builtin_e2k_psrah `(uint64 src1, uint64 src2)`

> Арифметический сдвиг вправо 4-х знаковых short’ов (16S)

`uint64` __builtin_e2k_psraw `(uint64 src1, uint64 src2)`

> Арифметический сдвиг вправо 2-х знаковых int’ов (32S)

Байтовый сдвиг
`uint64` __builtin_e2k_psllqh `(uint64 src1, uint64 src2, uint64 src3)`

> Сдвиг влево 16-ти байт (сцепленные первые 2 операнда) на число байт, равное константе в 3-м операнде, и выдача старших 8 байт

`uint64` __builtin_e2k_psllql `(uint64 src1, uint64 src2, uint64 src3)`

> Сдвиг влево 16-ти байт (сцепленные первые 2 операнда) на число байт, равное константе в 3-м операнде, и выдача младших 8 байт

`uint64` __builtin_e2k_psrlqh `(uint64 src1, uint64 src2, uint64 src3)`

> Логический сдвиг вправо 16-ти байт (сцепленные первые 2 операнда) на число байт, равное константе в 3-м операнде, и выдача старших 8 байт

`uint64` __builtin_e2k_psrlql `(uint64 src1, uint64 src2, uint64 src3)`

> Логический сдвиг вправо 16-ти байт (сцепленные первые 2 операнда) на число байт, равное константе в 3-м операнде, и выдача младших 8 байт

Вставка / выделение short’а
`uint64 (или uint32)` __builtin_e2k_pextrh `(uint64 src1, uint64 src2, uint32 src3)`

> Выделение беззнакового short’а из 8-ми short’ов (сцепленные первые 2 операнда) с номером, задаваемым константой в 3-м операнде (ноль соответствует младшему short’у)

`uint64` __builtin_e2k_pinsh `(uint64 src1, uint64 src2, uint64 src3)`

> Вcтавка short’а из младшей части операнда 2 в операнд 1 на место с номером, задаваемым константой в 3-м операнде (ноль соответствует младшему short’у)

Перестановка
`uint64` __builtin_e2k_pshufw `(uint64 src1, uint64 src2, uint64 src3)`

> Выделение из 4-х входных int’ов двух, положение которых определяется 4-мя младшими разрядами константы 3-го операнда

`uint64` __builtin_e2k_pshufh `(uint64 src1, uint64 src2)`

> Перестановка 4-х short’ов в соответствии с порядком, определенным в 8-ми младших разрядах константы 2-го операнда

Упаковка
`uint64` __builtin_e2k_packsshb `(uint64 src1, uint64 src2)`

> Упаковка 8-ми знаковых short’ов (16S) в знаковые байты (8S) с насыщением

`uint64` __builtin_e2k_packushb `(uint64 src1, uint64 src2)`

> Упаковка 8-ми знаковых short’ов (16S) в беззнаковые байты (8U) с насыщением

`uint64` __builtin_e2k_packsswh `(uint64 src1, uint64 src2)`

> Упаковка 4-х знаковых int’ов (32S) в знаковые short’ы (16S) с насыщением

Распаковка
`uint64` __builtin_e2k_punpckhbh `(uint64 src1, uint64 src2)`

> Чередование 4-х старших байт (8U) операнда 1 и 4-х старших байт (8U) операнда 2

`uint64` __builtin_e2k_punpcklbh `(uint64 src1, uint64 src2)`

> Чередование 4-х младших байт (8U) операнда 1 и 4-х младших байт (8U) операнда 2

`uint64` __builtin_e2k_punpckhhw `(uint64 src1, uint64 src2)`

> Чередование 2-х старших short’ов (16U) операнда 1 и 2-х старших short’ов (16U) операнда 2

`uint64` __builtin_e2k_punpcklhw `(uint64 src1, uint64 src2)`

> Чередование 2-х младших short’ов (16U) операнда 1 и 2-х младших short’ов (16U) операнда 2

`uint64` __builtin_e2k_punpckhwd `(uint64 src1, uint64 src2)`

> Чередование старшего int’а (32U) операнда 1 и старшего int’а (32U) операнда 2

`uint64` __builtin_e2k_punpcklwd `(uint64 src1, uint64 src2)`

> Чередование младшего int’а (32U) операнда 1 и младшего int’а (32U) операнда 2

Упакованные операции над числами c плавающей точкой одинарного формата
`uint64` __builtin_e2k_pfadds `(uint64 src1, uint64 src2)`

> Сложение 2-х float’ов (32F)

`uint64` __builtin_e2k_pfsubs `(uint64 src1, uint64 src2)`

> Вычитание 2-х float’ов (32F)

`uint64` __builtin_e2k_pfmaxs `(uint64 src1, uint64 src2)`

> Максимум 2-х float’ов (32F)

`uint64` __builtin_e2k_pfmins `(uint64 src1, uint64 src2)`

> Минимум 2-х float’ов (32F)

`uint64` __builtin_e2k_pfmuls `(uint64 src1, uint64 src2)`

> Умножение 2-х float’ов (32F)

`uint64` __builtin_e2k_pfstois `(uint64 src)`

> Преобразование 2-х float’ов (32F) в 2 int’а (32S) в текущем режиме округления

`uint64` __builtin_e2k_pfstoistr `(uint64 src)`

> Преобразование 2-х float’ов (32F) в 2 int’а (32S) c обрубанием

`uint64` __builtin_e2k_pistofs `(uint64 src)`

> Преобразование 2-х int’ов (32S) в 2 float’а (32F) в текущем режиме округления

`uint64` __builtin_e2k_pfcmpeqs `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmplts `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “меньше” с формированием битовой маски

`uint64` __builtin_e2k_pfcmples `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “меньше или равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpuods `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “неупорядочено” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpneqs `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “не равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpnlts `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “не меньше” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpnles `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “не меньше или равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpods `(uint64 src1, uint64 src2)`

> Сравнение 2-х float’ов (32F) на “упорядочено” с формированием битовой маски

Операции преобразования из формата чисел с плавающей точкой в целые
`uint64` __builtin_e2k_fdtoid `(uint64 src)`

> Преобразование double’а (64F) в long (64S) в текущем режиме округления

`uint32` __builtin_e2k_fstois `(uint32 src)`

> Преобразование float’а (32F) в int (32S) в текущем режиме округления

`uint32` __builtin_e2k_fdtois `(uint64 src)`

> Преобразование double’а (64F) в int (32S) в текущем режиме округления

Операции над числами c плавающей точкой одинарного формата
`uint32` __builtin_e2k_fcmpodsf `(uint32 src1, uint32 src2)`

> “Упорядоченное” сравнение float’ов (32F) с результатом в виде флагов

`uint32` __builtin_e2k_fcmpudsf `(uint32 src1, uint32 src2)`

> “Неупорядоченное” сравнение float’ов (32F) с результатом в виде флагов

Операции над числами c плавающей точкой двойного формата
`uint64` __builtin_e2k_pfmaxd `(uint64 src1, uint64 src2)`

> Максимум double’ов (64F)

`uint64` __builtin_e2k_pfmind `(uint64 src1, uint64 src2)`

> Минимум double’ов (64F)

`uint64` __builtin_e2k_idtofd `(uint64 src)`

> Преобразование long’a (64S) в double (64F) в текущем режиме округления

`uint64` __builtin_e2k_pfcmpeqd `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpltd `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “меньше” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpled `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “меньше или равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpuodd `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “неупорядочено” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpneqd `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “не равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpnltd `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “не меньше” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpnled `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “не меньше или равно” с формированием битовой маски

`uint64` __builtin_e2k_pfcmpodd `(uint64 src1, uint64 src2)`

> Сравнение double’ов (64F) на “упорядочено” с формированием битовой маски

`uint32` __builtin_e2k_fcmpoddf `(uint64 src1, uint64 src2)`

> “Упорядоченное” сравнение double’ов (64F) с результатом в виде флагов

`uint32` __builtin_e2k_fcmpuddf `(uint64 src1, uint64 src2)`

> “Неупорядоченное” сравнение double’ов (64F) с результатом в виде флагов

Циклический битовый сдвиг
`uint32` __builtin_e2k_scls `(uint32 src1, uint32 src2)`

> Циклический сдвиг влево int’а (32S/32U)

`uint64` __builtin_e2k_scld `(uint64 src1, uint64 src2)`

> Циклический сдвиг влево long’а (64S/64U)

`uint32` __builtin_e2k_scrs `(uint32 src1, uint32 src2)`

> Циклический сдвиг вправо int’а (32S/32U)

`uint64` __builtin_e2k_scrd `(uint64 src1, uint64 src2)`

> Циклический сдвиг вправо long’а (64S/64U)

Сложение/вычитание с результатом в виде intel’овских флагов
`uint32` __builtin_e2k_adds_fw `(uint32 src1, uint32 src2)`

> Сложение int’ов (32S/32U)

`uint32` __builtin_e2k_subs_fw `(uint32 src1, uint32 src2)`

> Вычитание int’ов (32S/32U)

Вставление поля
`uint32` __builtin_e2k_insfs `(uint32 src1, uint32 src2, uint32 src3)`

> Вставление поля в int (32S/32U)

`uint64` __builtin_e2k_insfd `(uint64 src1, uint64 src2, uint64 src3)`

> Вставление поля в long (64S/64U)

Выделение поля
`uint32` __builtin_e2k_getfs `(uint32 src1, uint32 src2)`

> Выделение поля из int’а (32S/32U)

`uint64` __builtin_e2k_getfd `(uint64 src1, uint64 src2)`

> Выделение поля из long’а (64S/64U)

Вставить поле внешнего тэга
Данные builtin’ы реализованы в виде inline-функций или макросов и требуют подключения `#include <e2kintrin.h>` или использования опции ``-include e2kintrin.h``**
`uint64` __builtin_e2k_puttagd `(uint64 src1, uint64 src2)`

> Вставление тэга в long (64S/64U)

> Осторожно: если компилятор вставит дополнительную безусловную пересылку аргумента этой операции, то на ней может произойти падение еще до выполнения операции

Операции чтения/записи
Данные builtin’ы реализованы в виде inline-функций или макросов и требуют подключения `#include <e2kintrin.h>` или использования опции ``-include e2kintrin.h``**
`uint32` __builtin_e2k_ld_32u_be `(const void *pval)`

> Чтение int’а (32S/32U) в big endian режиме (с разворотом байт)

`uint32` __builtin_e2k_ld_32u_t1 `(const void *pval)`

> Чтение int’а (32S/32U) без заведения в L1 кэше

`uint32` __builtin_e2k_ld_32u_t2 `(const void *pval)`

> Чтение int’а (32S/32U) без заведения в L1 и L2 кэше

`uint32` __builtin_e2k_ld_32u_nta `(const void *pval)`

> Чтение int’а (32S/32U) без заведения во всех кэшах

`uint64` __builtin_e2k_ld_64s_be `(const void *pval)`

> Чтение long’а (64S/64U) в big endian режиме (с разворотом байт)

`uint64` __builtin_e2k_ld_64s_t1 `(const void *pval)`

> Чтение long’а (64S/64U) без заведения в L1 кэше

`uint64` __builtin_e2k_ld_64s_t2 `(const void *pval)`

> Чтение long’а (64S/64U) без заведения в L1 и L2 кэше

`uint64` __builtin_e2k_ld_64s_nta `(const void *pval)`

> Чтение long’а (64S/64U) без заведения во всех кэшах

`uint64` __builtin_e2k_ld_64s_sm `(const void *pval, long ind)`

> Чтение long’а (64S/64U) в спекулятивном режиме

`uint64` __builtin_e2k_ld_64s_cleartag `(const void *pval, long ind)`

> Чтение long’а (64S/64U) в спекулятивном режиме c обнулением тега

`void` __builtin_e2k_st_32u_be `(uint32 val, void *pval)`

> Запись int’а (32S/32U) в big endian режиме (с разворотом байт)

`void` __builtin_e2k_st_32u_nt `(uint32 val, void *pval)`

> Запись int’а (32S/32U) мимо кэшей, напрямую в память (non temporal)

`void` __builtin_e2k_st_64s_be `(uint64 val, void *pval)`

> Запись long’а (64S/64U) в big endian режиме (с разворотом байт)

`void` __builtin_e2k_st_64s_nt `(uint64 val, void *pval)`

> Запись long’а (64S/64U) мимо кэшей, напрямую в память (non temporal)

`void` __builtin_e2k_clflush `(void *p)`

> Очистка строки кэша и удаление ее из всех кэшей

`uint64` __builtin_e2k_prefetch `(void *p, __e2k_hint i)`

> Подкачка строки в кэш соответствующего уровня

#### Система команд v2 и выше

Перестановка разрядов в обратном порядке
`uint32` __builtin_e2k_bitrevs `(uint32 src)`

> Перестановка разрядов в обратном порядке в int’е (32S/32U)

`uint64` __builtin_e2k_bitrevd `(uint64 src)`

> Перестановка разрядов в обратном порядке в long’е (64S/64U)

Подсчет количества лидирующих нулей
`uint32` __builtin_e2k_lzcnts `(uint32 src)`

> Подсчет количества лидирующих нулей в int’е (32S/32U)

`uint64` __builtin_e2k_lzcntd `(uint64 src)`

> Подсчет количества лидирующих нулей в long’е (64S/64U)

Подсчет количества единиц
`uint32` __builtin_e2k_popcnts `(uint32 src)`

> Подсчет количества единиц в int’е (32S/32U)

`uint64` __builtin_e2k_popcntd `(uint64 src)`

> Подсчет количества единиц в long’е (64S/64U)

Умножение байт на short’ы
`uint64` __builtin_e2k_pmulubhh `(uint64 src1, uint64 src2)`

> Умножение 4-х беззнаковых байт (8U) на 4-ре знаковых short’а (16S) со сдвигом результата вправо на 8 и округлением к ближайшему

Перестановка байт
`uint64` __builtin_e2k_pshufb `(uint64 src1, uint64 src2, uint64 src3)`

> Выделение из 16-ти входных байт восьми, положение которых определяется значениями в соответствующих байтах 3-го операнда. Либо заполнение предопределенными константами. Для v4 и выше - дополнительно работает инверсия, реверсивная перестановка бит или заполнение знаком

Выбор байт
`uint64` __builtin_e2k_pmerge `(uint64 src1, uint64 src2, uint64 src3)`

> Выбор 8-ми байт либо из операнда 1, либо из операнда 2 в зависимости от значения масок, содержащихся в операнде 3

Операции над числами c плавающей точкой двойного формата
`uint64` __builtin_e2k_fdtoidtr `(uint64 src)`

> Преобразование double’а (64F) в long (64S) с обрубанием

#### Система команд v3 и выше

Горизонтальное сложение и вычитание по модулю
Аргументы выкладываются в обратном порядке перед операцией : src2, src1
`uint64` __builtin_e2k_phaddh `(uint64 src1, uint64 src2)`

> Четыре горизонтальных сложения соседних short’ов (16S/16U)

`uint64` __builtin_e2k_phaddw `(uint64 src1, uint64 src2)`

> Два горизонтальных сложения соседних int’ов (32S/32U)

`uint64` __builtin_e2k_phsubh `(uint64 src1, uint64 src2)`

> Четыре горизонтальных вычитания соседних short’ов (16S/16U)

`uint64` __builtin_e2k_phsubw `(uint64 src1, uint64 src2)`

> Два горизонтальных вычитания соседних int’ов (32S/32U)

Горизонтальное сложение и вычитание c насыщением
`uint64` __builtin_e2k_phaddsh `(uint64 src1, uint64 src2)`

> Четыре горизонтальных сложения соседних знаковых short’ов (16S)

`uint64` __builtin_e2k_phsubsh `(uint64 src1, uint64 src2)`

> Четыре горизонтальных вычитания соседних знаковых short’ов (16S)

Максимум и минимум
`uint64` __builtin_e2k_pmaxsb `(uint64 src1, uint64 src2)`

> Максимум 8-ми знаковых байт (8S)

`uint64` __builtin_e2k_pmaxuh `(uint64 src1, uint64 src2)`

> Максимум 4-х беззнаковых short’ов (16U)

`uint64` __builtin_e2k_pmaxuw `(uint64 src1, uint64 src2)`

> Максимум 2-х беззнаковых int’ов (32U)

`uint64` __builtin_e2k_pmaxsw `(uint64 src1, uint64 src2)`

> Максимум 2-х знаковых int’ов (32S)

`uint64` __builtin_e2k_pminsb `(uint64 src1, uint64 src2)`

> Минимум 8-ми знаковых байт (8S)

`uint64` __builtin_e2k_pminuh `(uint64 src1, uint64 src2)`

> Минимум 4-х беззнаковых short’ов (16U)

`uint64` __builtin_e2k_pminuw `(uint64 src1, uint64 src2)`

> Минимум 2-х беззнаковых int’ов (32U)

`uint64` __builtin_e2k_pminsw `(uint64 src1, uint64 src2)`

> Минимум 2-х знаковых int’ов (32S)

Минимум и его позиция
`uint64` __builtin_e2k_phminposuh `(uint64 src1, uint64 src2)`

> Поиск минимального из 8-ми беззнаковых short’ов (16U) и его позиции

Умножение байт с горизонтальным сложением
`uint64` __builtin_e2k_pmaddubsh `(uint64 src1, uint64 src2)`

> Умножение 8-ми знаковых байт (8S) на 8 беззнаковых байт (8U) и попарное сложение смежных short’овых произведений с сатурацией

Умножение short’ов с масштабированием
`uint64` __builtin_e2k_pmulhrsh `(uint64 src1, uint64 src2)`

> Умножение 4-х знаковых short’ов (16S) c масштабированием (>> 15) и округлением

Умножение long’ов
`uint64` __builtin_e2k_umulhd `(uint64 src1, uint64 src2)`

> Умножение беззнаковых long’ов (64S) и выдача старших 64 разрядов произведения

`uint64` __builtin_e2k_smulhd `(uint64 src1, uint64 src2)`

> Умножение знаковых long’ов (64S) и выдача старших 64 разрядов произведения

Сложение/вычитание с результатом в виде intel’овских флагов
`uint32` __builtin_e2k_addd_fd `(uint64 src1, uint64 src2)`

> Сложение long’ов (64S/64U)

`uint32` __builtin_e2k_subd_fd `(uint64 src1, uint64 src2)`

> Вычитание long’ов (64S/64U)

Множественное сложение абсолютных разностей беззнаковых байт
`uint64` __builtin_e2k_mpsadbh `(uint64 src1, uint64 src2)`

> Четыре cложения абсолютных разностей 4-х беззнаковых байт (8U) со сдвигом операндов первого аргумента и 4-х беззнаковых байт (8U) второго аргумента с формированием 4-х беззнаковых short’ов (16U)

Cравнение long’ов
`uint64` __builtin_e2k_pcmpeqd `(uint64 src1, uint64 src2)`

> Сравнение на “равно” long’ов (64S/64U)

`uint64` __builtin_e2k_pcmpgtd `(uint64 src1, uint64 src2)`

> Сравнение на “больше” знаковых long’ов (64S)

Упаковка int’ов
`uint64` __builtin_e2k_packuswh `(uint64 src1, uint64 src2)`

> Упаковка 4-х знаковых int’ов (32S) в беззнаковые short’ы (16U) с насыщением

Изменение знака
`uint64` __builtin_e2k_psignb `(uint64 src1, uint64 src2)`

> Умножение 8-ми знаковых байт (8S) на знаки 8-ми байт (8S) второго аргумента

`uint64` __builtin_e2k_psignh `(uint64 src1, uint64 src2)`

> Умножение 4-х знаковых short’ов (16S) на знаки 4-х short’ов (16S) второго аргумента

`uint64` __builtin_e2k_psignw `(uint64 src1, uint64 src2)`

> Умножение 2-х знаковых int’ов (32S) на знаки 2-х int’ов (32S) второго аргумента

Упакованные операции над числами c плавающей точкой одинарного формата
`uint64` __builtin_e2k_pfhadds `(uint64 src1, uint64 src2)`

> Два горизонтальных сложения соседних float’ов (32F)

`uint64` __builtin_e2k_pfhsubs `(uint64 src1, uint64 src2)`

> Два горизонтальных вычитания соседних float’ов (32F)

`uint64` __builtin_e2k_pfaddsubs `(uint64 src1, uint64 src2)`

> Сложение старших и вычитание младших 2-х float’ов (32F)

Операции преобразования c плавающей точкой
`uint32` __builtin_e2k_fstoifs `(uint32 src1, uint32 src2)`

> Выделение целой части значения float’а (32F) в заданном режиме округления

`uint64` __builtin_e2k_pfstoifs `(uint64 src1, uint64 src2)`

> Выделение целой части значений 2-х float’ов (32F) в заданном режиме округления

`uint64` __builtin_e2k_fdtoifd `(uint64 src1, uint64 src2)`

> Выделение целой части значения double’а (64F) в заданном режиме округления

#### Система команд v4 и выше

Умножение вещественного числа на целую степень двойки
`uint32` __builtin_e2k_fscales `(uint32 src1, uint32 src2)`

> Умножение float’а (32F) на целую степень двойки

`uint64` __builtin_e2k_fscaled `(uint64 src1, uint32 src2)`

> Умножение double’а (64F) на целую степень двойки

`long double` __builtin_e2k_fxscalesx `(long double src1, uint32 src2)`

> Умножение long double’а (80F) на целую степень двойки

#### Система команд v5 и выше

Сложение и вычитание по модулю
`v2di` __builtin_e2k_qpaddb `(v2di src1, v2di src2)`

> Сложение 16-ти байт (8S/8U)

`v2di` __builtin_e2k_qpaddh `(v2di src1, v2di src2)`

> Сложение 8-ми short’ов (16S/16U)

`v2di` __builtin_e2k_qpaddw `(v2di src1, v2di src2)`

> Сложение 4-х int’ов (32S/32U)

`v2di` __builtin_e2k_qpaddd `(v2di src1, v2di src2)`

> Сложение 2-х long’ов (64S/64U)

`v2di` __builtin_e2k_qpsubb `(v2di src1, v2di src2)`

> Вычитание 16-ти байт (8S/8U)

`v2di` __builtin_e2k_qpsubh `(v2di src1, v2di src2)`

> Вычитание 8-ми short’ов (16S/16U)

`v2di` __builtin_e2k_qpsubw `(v2di src1, v2di src2)`

> Вычитание 4-х int’ов (32S/32U)

`v2di` __builtin_e2k_qpsubd `(v2di src1, v2di src2)`

> Вычитание 2-х long’ов (64S/64U)

Горизонтальное сложение и вычитание по модулю
`v2di` __builtin_e2k_qphaddh `(v2di src1, v2di src2)`

> Восемь горизонтальных сложений соседних short’ов (16S/16U)

`v2di` __builtin_e2k_qphaddw `(v2di src1, v2di src2)`

> Четыре горизонтальных сложения соседних int’ов (32S/32U)

`v2di` __builtin_e2k_qphsubh `(v2di src1, v2di src2)`

> Восемь горизонтальных вычитаний соседних short’ов (16S/16U)

`v2di` __builtin_e2k_qphsubw `(v2di src1, v2di src2)`

> Четыре горизонтальных вычитания соседних int’ов (32S/32U)

Сложение и вычитание c насыщением
`v2di` __builtin_e2k_qpaddsb `(v2di src1, v2di src2)`

> Сложение 16-ти знаковых байт (8S)

`v2di` __builtin_e2k_qpaddsh `(v2di src1, v2di src2)`

> Сложение 8-ми знаковых short’ов (16S)

`v2di` __builtin_e2k_qpaddusb `(v2di src1, v2di src2)`

> Сложение 16-ти беззнаковых байт (8U)

`v2di` __builtin_e2k_qpaddush `(v2di src1, v2di src2)`

> Сложение 8-ми беззнаковых short’ов (16U)

`v2di` __builtin_e2k_qpsubsb `(v2di src1, v2di src2)`

> Вычитание 16-ти знаковых байт (8S)

`v2di` __builtin_e2k_qpsubsh `(v2di src1, v2di src2)`

> Вычитание 8-ми знаковых short’ов (16S)

`v2di` __builtin_e2k_qpsubusb `(v2di src1, v2di src2)`

> Вычитание 16-ти беззнаковых байт (8U)

`v2di` __builtin_e2k_qpsubush `(v2di src1, v2di src2)`

> Вычитание 8-ми беззнаковых short’ов (16U)

Горизонтальное сложение и вычитание c насыщением
`v2di` __builtin_e2k_qphaddsh `(v2di src1, v2di src2)`

> Восемь горизонтальных сложений соседних знаковых short’ов (16S)

`v2di` __builtin_e2k_qphsubsh `(v2di src1, v2di src2)`

> Восемь горизонтальных вычитаний соседних знаковых short’ов (16S)

Максимум и минимум
`v2di` __builtin_e2k_qpmaxub `(v2di src1, v2di src2)`

> Максимум 16-ти беззнаковых байт (8U)

`v2di` __builtin_e2k_qpmaxsb `(v2di src1, v2di src2)`

> Максимум 16-ти знаковых байт (8S)

`v2di` __builtin_e2k_qpmaxuh `(v2di src1, v2di src2)`

> Максимум 8-ми беззнаковых short’ов (16U)

`v2di` __builtin_e2k_qpmaxsh `(v2di src1, v2di src2)`

> Максимум 8-ми знаковых short’ов (16S)

`v2di` __builtin_e2k_qpmaxuw `(v2di src1, v2di src2)`

> Максимум 4-х беззнаковых int’ов (32U)

`v2di` __builtin_e2k_qpmaxsw `(v2di src1, v2di src2)`

> Максимум 4-х знаковых int’ов (32S)

`v2di` __builtin_e2k_qpminub `(v2di src1, v2di src2)`

> Минимум 16-ти беззнаковых байт (8U)

`v2di` __builtin_e2k_qpminsb `(v2di src1, v2di src2)`

> Минимум 16-ти знаковых байт (8S)

`v2di` __builtin_e2k_qpminuh `(v2di src1, v2di src2)`

> Минимум 8-ми беззнаковых short’ов (16U)

`v2di` __builtin_e2k_qpminsh `(v2di src1, v2di src2)`

> Минимум 8-ми знаковых short’ов (16S)

`v2di` __builtin_e2k_qpminuw `(v2di src1, v2di src2)`

> Минимум 4-х беззнаковых int’ов (32U)

`v2di` __builtin_e2k_qpminsw `(v2di src1, v2di src2)`

> Минимум 4-х знаковых int’ов (32S)

Минимум и его позиция
`uint64` __builtin_e2k_qphminposuh `(v2di src1, v2di src2)`

> Поиск минимального из 16-ти беззнаковых short’ов (16U) и его позиции

Умножение short’ов
`v2di` __builtin_e2k_qpmulhuh `(v2di src1, v2di src2)`

> Умножение 8-ми беззнаковых short’ов (16U) и выдача старших 16 разрядов произведений

`v2di` __builtin_e2k_qpmulhh `(v2di src1, v2di src2)`

> Умножение 8-ми знаковых short’ов (16S) и выдача старших 16 разрядов произведений

`v2di` __builtin_e2k_qpmullh `(v2di src1, v2di src2)`

> Умножение 8-ми short’ов (16S/16U) и выдача младших 16 разрядов произведений

Умножение int’ов
`uint64` __builtin_e2k_pmullw `(uint64 src1, uint64 src2)`

> Умножение 2-х int’ов (32S/32U) и выдача младших 32 разрядов произведений

`v2di` __builtin_e2k_qpmullw `(v2di src1, v2di src2)`

> Умножение 4-х int’ов (32S/32U) и выдача младших 32 разрядов произведений

Умножение байт на short’ы
`v2di` __builtin_e2k_qpmulubhh `(uint64 src1, v2di src2)`

> Умножение 8-ми беззнаковых байт (8U) на 8-мь знаковых short’ов (16S) со сдвигом результата вправо на 8 и округлением к ближайшему

Умножение short’ов с масштабированием
`v2di` __builtin_e2k_qpmulhrsh `(v2di src1, v2di src2)`

> Умножение 8-ми знаковых short’ов (16S) c масштабированием (>> 15) и округлением

Умножение short’ов с горизонтальным сложением
`v2di` __builtin_e2k_qpmaddh `(v2di src1, v2di src2)`

> Умножение 8-ми знаковых short’ов (16S) и попарное сложение смежных int’овых произведений

Умножение байт с горизонтальным сложением
`v2di` __builtin_e2k_qpmaddubsh `(v2di src1, v2di src2)`

> Умножение 16-ти знаковых байт (8S) на 16 беззнаковых байт (8U) и попарное сложение смежных short’овых произведений с сатурацией

Изменение знака
`v2di` __builtin_e2k_qpsignb `(v2di src1, v2di src2)`

> Умножение 16-ти знаковых байт (8S) на знаки 16-ти байт (8S) второго аргумента

`v2di` __builtin_e2k_qpsignh `(v2di src1, v2di src2)`

> Умножение 8-ми знаковых short’ов (16S) на знаки 8-ми short’ов (16S) второго аргумента

`v2di` __builtin_e2k_qpsignw `(v2di src1, v2di src2)`

> Умножение 4-х знаковых int’ов (32S) на знаки 4-х int’ов (32S) второго аргумента

Cложение абсолютных разностей беззнаковых байт
`v2di` __builtin_e2k_qpsadbw `(v2di src1, v2di src2)`

> Сложение абсолютных разностей 16-ти беззнаковых байт (8U)

Множественное сложение абсолютных разностей беззнаковых байт
`v2di` __builtin_e2k_qpmpsadbh `(v2di src1, uint32 src2)`

> Две операции mpsadbh над младшей и старшей половинами операнда 1 и общим операндом 2

Среднее арифметическое
`v2di` __builtin_e2k_qpavgusb `(v2di src1, v2di src2)`

> Среднее 16-ти беззнаковых байт (8U)

`v2di` __builtin_e2k_qpavgush `(v2di src1, v2di src2)`

> Среднее 8-ми беззнаковых short’ов (16U)

Cравнение
`v2di` __builtin_e2k_qpcmpeqb `(v2di src1, v2di src2)`

> Сравнение на “равно” 16-ти байт (8S/8U)

`v2di` __builtin_e2k_qpcmpeqh `(v2di src1, v2di src2)`

> Сравнение на “равно” 8-ми short’ов (16S/16U)

`v2di` __builtin_e2k_qpcmpeqw `(v2di src1, v2di src2)`

> Сравнение на “равно” 4-х int’ов (32S/32U)

`v2di` __builtin_e2k_qpcmpeqd `(v2di src1, v2di src2)`

> Сравнение на “равно” 2-х long’ов (64S/64U)

`v2di` __builtin_e2k_qpcmpgtb `(v2di src1, v2di src2)`

> Сравнение на “больше” 16-ти знаковых байт (8S)

`v2di` __builtin_e2k_qpcmpgth `(v2di src1, v2di src2)`

> Сравнение на “больше” 8-ми знаковых short’ов (16S)

`v2di` __builtin_e2k_qpcmpgtw `(v2di src1, v2di src2)`

> Сравнение на “больше” 4-х знаковых int’ов (32S)

`v2di` __builtin_e2k_qpcmpgtd `(v2di src1, v2di src2)`

> Сравнение на “больше” 2-х знаковых long’ов (64S)

Перестановка байт
`v2di` __builtin_e2k_qpshufb `(v2di src1, v2di src2, v2di src3)`

> Выделение из 32-х входных байт 16-ти, положение которых определяется значениями в соответствующих байтах 3-го операнда. Выделение байт возможно только локально внутри старшей и младшей половин аргументов и результата. Далее возможно заполнение предопределенными константами, инверсия, реверсивная перестановка бит или заполнение знаком. Поле [3:0] определяет номер байта, а поле [7:4] - тип операции над выбранным байтом

`v2di` __builtin_e2k_qppermb `(v2di src1, v2di src2, v2di src3)`

> Выделение из 32-х входных байт произвольных 16-ти, положение которых определяется значениями в соответствующих байтах 3-го операнда и выполнение над ними логических операций в зависимости от значений управляющих байт в src3. Поле [4:0] определяет номер байта, а поле [7:5] - тип операции над выбранным байтом

Выбор байт
`v2di` __builtin_e2k_qpmerge `(v2di src1, v2di src2, v2di src3)`

> Выбор 16-ти байт либо из операнда 1, либо из операнда 2 в зависимости от значения масок, содержащихся в операнде 3

Упаковка long’ов
`v2di` __builtin_e2k_qppackdl `(uint64 src1, uint64 src2)`

> Упаковка 2-х long’ов (64S/64U) в квадро-регистр

Перестановки
`v2di` __builtin_e2k_qpswitchd `(v2di src)`

> Меняет местами двойные слова (64S)

`v2di` __builtin_e2k_qpswitchw `(v2di src)`

> Меняет местами значения внутри 2-х пар int’ов (32S)

Формирование маски
`uint32` __builtin_e2k_qpsgn2mskb `(v2di src)`

> Формирование маски из знака байтов

Модификация разрядов знака
`v2di` __builtin_e2k_qpmsk2sgnb `(v2di src1, uint32 src2)`

> Модификация разрядов знака упакованных байтов (8S) значениями битов 16-разрядной инверсной маски

Логические операции
`v2di` __builtin_e2k_qpand `(v2di src1, v2di src2)`

> Поразрядное логическое AND 128-и разрядов (128U)

`v2di` __builtin_e2k_qpandn `(v2di src1, v2di src2)`

> Поразрядное логическое AND 128-и разрядов c инверсией второго операнда (128U)

`v2di` __builtin_e2k_qpor `(v2di src1, v2di src2)`

> Поразрядное логическое OR 128-и разрядов (128U)

`v2di` __builtin_e2k_qpxor `(v2di src1, v2di src2)`

> Поразрядное логическое XOR 128-и разрядов (128U)

Произвольные логическая операции
`uint64` __builtin_e2k_plog `(uint32 n, uint64 src1, uint64 src2, uint64 src3)`

> Произвольная поразрядная логическая операция над 64 разрядами (64S/64U)

`v2di` __builtin_e2k_qplog `(uint32 n, v2di src1, v2di src2, v2di src3)`

> Произвольная поразрядная логическая операция над 128 разрядами (128U)

Битовый сдвиг
`v2di` __builtin_e2k_qpsllh `(v2di src1, uint64 src2)`

> Сдвиг влево 8-ми short’ов (16S/16U)

`v2di` __builtin_e2k_qpsllw `(v2di src1, uint64 src2)`

> Сдвиг влево 4-х int’ов (32S/32U)

`v2di` __builtin_e2k_qpslld `(v2di src1, uint64 src2)`

> Сдвиг влево 2-х long’ов (64S/64U)

`v2di` __builtin_e2k_qpsrlh `(v2di src1, uint64 src2)`

> Логический сдвиг вправо 8-ми беззнаковых short’ов (16U)

`v2di` __builtin_e2k_qpsrlw `(v2di src1, uint64 src2)`

> Логический сдвиг вправо 4-х беззнаковых int’ов (32U)

`v2di` __builtin_e2k_qpsrld `(v2di src1, uint64 src2)`

> Логический сдвиг вправо 2-х беззнаковых long’ов (64U)

`v2di` __builtin_e2k_qpsrah `(v2di src1, uint64 src2)`

> Арифметический сдвиг вправо 8-ми знаковых short’ов (16S)

`v2di` __builtin_e2k_qpsraw `(v2di src1, uint64 src2)`

> Арифметический сдвиг вправо 4-х знаковых int’ов (32S)

`v2di` __builtin_e2k_qpsrad `(v2di src1, uint64 src2)`

> Арифметический сдвиг вправо 2-х знаковых long’ов (64S)

Циклический битовый сдвиг вправо
`uint64` __builtin_e2k_psrcw `(uint64 src1, uint64 src2)`

> Циклический сдвиг вправо 2-х int’ов (32S/32U)

`uint64` __builtin_e2k_psrcd `(uint64 src1, uint64 src2)`

> Циклический сдвиг вправо long’а (64S/64U)

`v2di` __builtin_e2k_qpsrcw `(v2di src1, uint64 src2)`

> Циклический сдвиг вправо 4-х int’ов (32S/32U)

`v2di` __builtin_e2k_qpsrcd `(v2di src1, uint64 src2)`

> Циклический сдвиг вправо 2-х long’ов (64S/64U)

Упаковка
`v2di` __builtin_e2k_qpacksshb `(v2di src1, uint64 src2)`

> Упаковка 16-ти знаковых short’ов (16S) в знаковые байты (8S) с насыщением

`v2di` __builtin_e2k_qpackushb `(v2di src1, uint64 src2)`

> Упаковка 16-ти знаковых short’ов (16S) в беззнаковые байты (8U) с насыщением

`v2di` __builtin_e2k_qpacksswh `(v2di src1, uint64 src2)`

> Упаковка 8-ми знаковых int’ов (32S) в знаковые short’ы (16S) с насыщением

`v2di` __builtin_e2k_qpackuswh `(v2di src1, uint64 src2)`

> Упаковка 8-ми знаковых int’ов (32S) в беззнаковые short’ы (16U) с насыщением

Распаковка
Данные builtin’ы реализованы в виде inline-функций или макросов и требуют подключения `#include <e2kintrin.h>` или использования опции ``-include e2kintrin.h`
`v2di` __builtin_e2k_qpunpckhbh `(v2di src1, v2di src2)`

> Чередование 8-ми старших байт (8U) операнда 1 и 8-ми старших байт (8U) операнда 2

`v2di` __builtin_e2k_qpunpcklbh `(v2di src1, v2di src2)`

> Чередование 8-ми младших байт (8U) операнда 1 и 8-ми младших байт (8U) операнда 2

`v2di` __builtin_e2k_qpunpckhhw `(v2di src1, v2di src2)`

> Чередование 4-х старших short’ов (16U) операнда 1 и 4-х старших short’ов (16U) операнда 2

`v2di` __builtin_e2k_qpunpcklhw `(v2di src1, v2di src2)`

> Чередование 4-х младших short’ов (16U) операнда 1 и 4-х младших short’ов (16U) операнда 2

`v2di` __builtin_e2k_qpunpckhwd `(v2di src1, v2di src2)`

> Чередование 2-х старших int’ов (32U) операнда 1 и 2-х старших int’ов (32U) операнда 2

`v2di` __builtin_e2k_qpunpcklwd `(v2di src1, v2di src2)`

> Чередование 2-х младших int’ов (32U) операнда 1 и 2-х младших int’ов (32U) операнда 2

`v2di` __builtin_e2k_qpunpckhdq `(v2di src1, v2di src2)`

> Чередование старшего long’а (64U) операнда 1 и старшего long’а (64U) операнда 2

`v2di` __builtin_e2k_qpunpckldq `(v2di src1, v2di src2)`

> Чередование младшего long’а (64U) операнда 1 и младшего long’а (64U) операнда 2

Выделение поля c обнулением младших разрядов
`uint32` __builtin_e2k_getfzs `(uint32 src1, uint32 src2)`

> Выделение поля из int’а (32S/32U) c обнулением младших разрядов

`uint64` __builtin_e2k_getfzd `(uint64 src1, uint64 src2)`

> Выделение поля из long’а (64S/64U) c обнулением младших разрядов

Вставить поле внешнего тэга
Данные builtin’ы реализованы в виде inline-функций или макросов и требуют подключения `#include <e2kintrin.h>` или использования опции ``-include e2kintrin.h`
`v2di` __builtin_e2k_puttagqp `(v2di src1, uint32 src2)`

> Вставление тэга в 128-ми разрядное значение (128U)

> Осторожно: если компилятор вставит дополнительную безусловную пересылку аргумента этой операции, то на ней может произойти падение еще до выполнения операции

Сложение и вычитание c битом переноса (carry)
`uint64` __builtin_e2k_addcd `(uint64 src1, uint64 src2, uint32 src3)`

> Сложение long’ов (64S/64U) и бита переноса c выработкой числового результата

`uint64` __builtin_e2k_subcd `(uint64 src1, uint64 src2, uint32 src3)`

> Вычитание long’ов (64S/64U) и бита переноса c выработкой числового результата

`uint64` __builtin_e2k_addcd_c `(uint64 src1, uint64 src2, uint32 src3)`

> Сложение long’ов (64S/64U) и бита переноса c выработкой нового переноса

`uint64` __builtin_e2k_subcd_c `(uint64 src1, uint64 src2, uint32 src3)`

> Вычитание long’ов (64S/64U) и бита переноса c выработкой нового переноса

Упакованные операции над числами c плавающей точкой одинарного формата
`v2di` __builtin_e2k_qpfadds `(v2di src1, v2di src2)`

> Сложение 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfhadds `(v2di src1, v2di src2)`

> Горизонтальное сложение 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfsubs `(v2di src1, v2di src2)`

> Вычитание 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfhsubs `(v2di src1, v2di src2)`

> Горизонтальное вычитание 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfaddsubs `(v2di src1, v2di src2)`

> Сложение нечетных и вычитание четных 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfmaxs `(v2di src1, v2di src2)`

> Максимум 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfmins `(v2di src1, v2di src2)`

> Минимум 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfmuls `(v2di src1, v2di src2)`

> Умножение 4-х float’ов (32F)

`v2di` __builtin_e2k_qpfcmpeqs `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmplts `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “меньше” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmples `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “меньше или равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpuods `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “не упорядочено” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpneqs `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “не равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpnlts `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “не меньше” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpnles `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “не меньше или равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpods `(v2di src1, v2di src2)`

> Сравнение 4-х float’ов (32F) на “упорядочено” с формированием битовой маски

`v2di` __builtin_e2k_qpfstois `(v2di src)`

> Преобразование 4-х float’ов (32F) в 4 int’а (32S) в текущем режиме округления

`v2di` __builtin_e2k_qpfstoistr `(v2di src)`

> Преобразование 4-х float’ов (32F) в 4 int’а (32S) c обрубанием

`v2di` __builtin_e2k_qpistofs `(v2di src)`

> Преобразование 4-х int’ов (32S) в 4 float’а (32F) в текущем режиме округления

`v2di` __builtin_e2k_qpidtofs `(v2di src)`

> Преобразование 2-х long’ов (64S) в 2 float’а (32F)

`v2di` __builtin_e2k_qpfstoifs `(uint64 src1, v2di src2)`

> Выделение целой части значений 4-х float’ов (32F) в заданном режиме округления

`v2di` __builtin_e2k_qpfstofd `(v2di src)`

> Преобразование 2-х float’ов (32F) в 2 double’а (64F)

`v2di` __builtin_e2k_qpfstoid `(v2di src)`

> Преобразование 2-х float’ов (32F) в 2 long’а (64S) в текущем режиме округления

`v2di` __builtin_e2k_qpfstoidtr `(v2di src)`

> Преобразование 2-х float’ов (32F) в 2 long’а (64S) c обрубанием

Упакованные операции над числами c плавающей точкой двойного формата
`v2di` __builtin_e2k_qpfaddd `(v2di src1, v2di src2)`

> Сложение 2-х double’ов (64F)

`v2di` __builtin_e2k_qpfsubd `(v2di src1, v2di src2)`

> Вычитание 2-х double’ов (64F)

`v2di` __builtin_e2k_qpfaddsubd `(v2di src1, v2di src2)`

> Сложение старших и вычитание младших 2-х double’ов (64F)

`v2di` __builtin_e2k_qpfmaxd `(v2di src1, v2di src2)`

> Максимум 2-х double’ов (64F)

`v2di` __builtin_e2k_qpfmind `(v2di src1, v2di src2)`

> Минимум 2-х double’ов (64F)

`v2di` __builtin_e2k_qpfmuld `(v2di src1, v2di src2)`

> Умножение 2-х double’ов (64F)

`v2di` __builtin_e2k_qpfcmpeqd `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpltd `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “меньше” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpled `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “меньше или равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpuodd `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “не упорядочено” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpneqd `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “не равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpnltd `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “не меньше” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpnled `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “не меньше или равно” с формированием битовой маски

`v2di` __builtin_e2k_qpfcmpodd `(v2di src1, v2di src2)`

> Сравнение 2-х double’ов (64F) на “упорядочено” с формированием битовой маски

`v2di` __builtin_e2k_qpfdtois `(v2di src)`

> Преобразование 2-х double’ов (64F) в 2 long’а (32S) в текущем режиме округления

`v2di` __builtin_e2k_qpfdtoistr `(v2di src)`

> Преобразование 2-х double’ов (64F) в 2 int’а (32S) c обрубанием

`v2di` __builtin_e2k_qpistofd `(v2di src)`

> Преобразование 2-х int’ов (32S) в 2 double’а (64F)

`v2di` __builtin_e2k_qpidtofd `(v2di src)`

> Преобразование 2-х long’ов (64S) в 2 double’а (64F)

`v2di` __builtin_e2k_qpfdtoifd `(uint64 src1, v2di src2)`

> Выделение целой части значений 2-х double’ов (64F) в заданном режиме округления

`v2di` __builtin_e2k_qpfdtofs `(v2di src)`

> Преобразование 2-х double’ов (64F) в 2 float’а (32F)

`v2di` __builtin_e2k_qpfdtoid `(v2di src)`

> Преобразование 2-х double’ов (64F) в 2 long’а (64S) в текущем режиме округления

`v2di` __builtin_e2k_qpfdtoidtr `(v2di src)`

> Преобразование 2-х double’ов (64F) в 2 long’а (64S) c обрубанием

Операции чтения/записи
Данные builtin’ы реализованы в виде inline-функций или макросов и требуют подключения `#include <e2kintrin.h>` или использования опции `-include e2kintrin.h`
`v2di` __builtin_e2k_ld_128_be `(const void *pval)`

> Чтение 16 байт (2*64U) в big endian режиме (с разворотом байт)

`v2di` __builtin_e2k_ld_128_t1 `(const void *pval)`

> Чтение 16 байт (2*64U) без заведения в L1 кэше

`v2di` __builtin_e2k_ld_128_t2 `(const void *pval)`

> Чтение 16 байт (2*64U) без заведения в L1 и L2 кэше

`v2di` __builtin_e2k_ld_128_nta `(const void *pval)`

> Чтение 16 байт (2*64U) без заведения во всех кэшах

`v2di` __builtin_e2k_ld_128_sm `(const v2di *pval, long ind)`

> Чтение 16 байт (2*64U) в спекулятивном режиме

`v2di` __builtin_e2k_ld_128_cleartag `(const v2di *pval, long ind)`

> Чтение 16 байт (2*64U) в спекулятивном режиме c обнулением тега

`void` __builtin_e2k_st_128_be `(v2di val, v2di *pval)`

> Запись 16 байт (2*64U) в big endian режиме (с разворотом байт)

`void` __builtin_e2k_st_128_nt `(v2di val, v2di *pval)`

> Запись 16 байт (2*64U) мимо кэшей, напрямую в память (non temporal)

`void` __builtin_e2k_pst_128 `(v2di val, v2di *pval, uint32 mask)`

> Запись 16 байт (2*64U) по маске

`void` __builtin_e2k_pst_128_sm `(v2di val, v2di *pval, uint32 mask)`

> Запись 16 байт (2*64U) по маске в спекулятивном режиме

`void` __builtin_e2k_pst_128_be `(v2di val, v2di *pval, uint32 mask)`

> Запись 16 байт (2*64U) по маске в big endian режиме (с разворотом байт)

#### Система команд v6 и выше

Умножение вещественных чисел со сложением без промежуточного округления
`uint32` __builtin_e2k_fmas `(uint32, uint32, uint32)`

> Умножение cо сложением float’ов (32F) : src1 * src2 + src3

`uint32` __builtin_e2k_fmss `(uint32, uint32, uint32)`

> Умножение c вычитанием float’ов (32F) : src1 * src2 - src3

`uint32` __builtin_e2k_fnmas `(uint32, uint32, uint32)`

> Обратное умножение cо сложением float’ов (32F) : -(src1 * src2) + src3

`uint32` __builtin_e2k_fnmss `(uint32, uint32, uint32)`

> Обратное умножение c вычитанием float’ов (32F) : -(src1 * src2) - src3

`uint64` __builtin_e2k_fmad `(uint64, uint64, uint64)`

> Умножение cо сложением double’ов (64F) : src1 * src2 + src3

`uint64` __builtin_e2k_fmsd `(uint64, uint64, uint64)`

> Умножение c вычитанием double’ов (64F) : src1 * src2 - src3

`uint64` __builtin_e2k_fnmad `(uint64, uint64, uint64)`

> Обратное умножение cо сложением double’ов (64F) : -(src1 * src2) + src3

`uint64` __builtin_e2k_fnmsd `(uint64, uint64, uint64)`

> Обратное умножение c вычитанием double’ов (64F) : -(src1 * src2) - src3

Упакованное умножение вещественных чисел со сложением без промежуточного округления
`v2di` __builtin_e2k_qpfmas `(v2di, v2di, v2di)`

> Умножение 4-х float’ов (32F) cо сложением : src1 * src2 + src3

`v2di` __builtin_e2k_qpfmss `(v2di, v2di, v2di)`

> Умножение 4-х float’ов (32F) c вычитанием : src1 * src2 - src3

`v2di` __builtin_e2k_qpfnmas `(v2di, v2di, v2di)`

> Обратное умножение 4-х float’ов (32F) cо сложением : -(src1 * src2) + src3

`v2di` __builtin_e2k_qpfnmss `(v2di, v2di, v2di)`

> Обратное умножение 4-х float’ов (32F) c вычитанием : -(src1 * src2) - src3

`v2di` __builtin_e2k_qpfmass `(v2di, v2di, v2di)`

> Умножение 4-х float’ов (32F) cо сложением четных элементов : src1 * src2 + src3 и c вычитанием нечетных элементов : src1 * src2 - src3

`v2di` __builtin_e2k_qpfmsas `(v2di, v2di, v2di)`

> Умножение 4-х float’ов (32F) c вычитанием четных элементов : src1 * src2 - src3 и cо сложением нечетных элементов : src1 * src2 + src3

`v2di` __builtin_e2k_qpfmad `(v2di, v2di, v2di)`

> Умножение 2-х double’ов (64F) cо сложением : src1 * src2 + src3

`v2di` __builtin_e2k_qpfmsd `(v2di, v2di, v2di)`

> Умножение 2-х double’ов (64F) c вычитанием : src1 * src2 - src3

`v2di` __builtin_e2k_qpfnmad `(v2di, v2di, v2di)`

> Обратное умножение 2-х double’ов (64F) cо сложением : -(src1 * src2) + src3

`v2di` __builtin_e2k_qpfnmsd `(v2di, v2di, v2di)`

> Обратное умножение 2-х double’ов (64F) c вычитанием : -(src1 * src2) - src3

`v2di` __builtin_e2k_qpfmasd `(v2di, v2di, v2di)`

> Умножение 2-х double’ов (64F) cо сложением четных элементов : src1 * src2 + src3 и c вычитанием нечетных элементов : src1 * src2 - src3

`v2di` __builtin_e2k_qpfmsad `(v2di, v2di, v2di)`

> Умножение 2-х double’ов (64F) c вычитанием четных элементов : src1 * src2 - src3 и cо сложением нечетных элементов : src1 * src2 + src3

Cравнение c выработкой предиката для 64-х бит
`uint32` __builtin_e2k_pcmpeqbop `(uint64, uint64)`

> Сравнение на “равно” 8-ми байт (8S/8U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpeqhop `(uint64, uint64)`

> Сравнение на “равно” 4-х short’ов (16S/16U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpeqwop `(uint64, uint64)`

> Сравнение на “равно” 2-х int’ов (32S/32U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpeqdop `(uint64, uint64)`

> Сравнение на “равно” long’ов (64S/64U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpgtbop `(uint64, uint64)`

> Сравнение на “больше” 8-ми знаковых байт (8S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpgthop `(uint64, uint64)`

> Сравнение на “больше” 4-х знаковых short’ов (16S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpgtwop `(uint64, uint64)`

> Сравнение на “больше” 2-х знаковых int’ов (32S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpgtdop `(uint64, uint64)`

> Сравнение на “больше” знаковых long’ов (64S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_pcmpeqbap `(uint64, uint64)`

> Сравнение на “равно” 8-ми байт (8S/8U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpeqhap `(uint64, uint64)`

> Сравнение на “равно” 4-х short’ов (16S/16U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpeqwap `(uint64, uint64)`

> Сравнение на “равно” 2-х int’ов (32S/32U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpeqdap `(uint64, uint64)`

> Сравнение на “равно” long’ов (64S/64U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpgtbap `(uint64, uint64)`

> Сравнение на “больше” 8-ми знаковых байт (8S) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpgthap `(uint64, uint64)`

> Сравнение на “больше” 4-х знаковых short’ов (16S) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpgtwap `(uint64, uint64)`

> Сравнение на “больше” 2-х знаковых int’ов (32S) c последующим AND результатов сравнений

`uint32` __builtin_e2k_pcmpgtdap `(uint64, uint64)`

> Сравнение на “больше” знаковых long’ов (64S) c последующим AND результатов сравнений

Cравнение c выработкой предиката для 128-и бит
`uint32` __builtin_e2k_qpcmpeqbop `(v2di, v2di)`

> Сравнение на “равно” 16-ти байт (8S/8U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpeqhop `(v2di, v2di)`

> Сравнение на “равно” 8-ми short’ов (16S/16U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpeqwop `(v2di, v2di)`

> Сравнение на “равно” 4-х int’ов (32S/32U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpeqdop `(v2di, v2di)`

> Сравнение на “равно” 2-х long’ов (64S/64U) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpgtbop `(v2di, v2di)`

> Сравнение на “больше” 16-ти знаковых байт (8S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpgthop `(v2di, v2di)`

> Сравнение на “больше” 8-ми знаковых short’ов (16S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpgtwop `(v2di, v2di)`

> Сравнение на “больше” 4-х знаковых int’ов (32S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpgtdop `(v2di, v2di)`

> Сравнение на “больше” 2-х знаковых long’ов (64S) c последующим OR результатов сравнений

`uint32` __builtin_e2k_qpcmpeqbap `(v2di, v2di)`

> Сравнение на “равно” 16-ти байт (8S/8U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpeqhap `(v2di, v2di)`

> Сравнение на “равно” 8-ми short’ов (16S/16U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpeqwap `(v2di, v2di)`

> Сравнение на “равно” 4-х int’ов (32S/32U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpeqdap `(v2di, v2di)`

> Сравнение на “равно” 2-х long’ов (64S/64U) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpgtbap `(v2di, v2di)`

> Сравнение на “больше” 16-ти знаковых байт (8S) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpgthap `(v2di, v2di)`

> Сравнение на “больше” 8-ми знаковых short’ов (16S) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpgtwap `(v2di, v2di)`

> Сравнение на “больше” 4-х знаковых int’ов (32S) c последующим AND результатов сравнений

`uint32` __builtin_e2k_qpcmpgtdap `(v2di, v2di)`

> Сравнение на “больше” 2-х знаковых long’ов (64S) c последующим AND результатов сравнений

Беспереносное умножение целых
`uint64` __builtin_e2k_clmull `(uint64, uint64)`

> Беспереносное умножение беззнаковых long’ов (64U) с выдачей младших 64-х бит результата

`uint64` __builtin_e2k_clmulh `(uint64, uint64)`

> Беспереносное умножение беззнаковых long’ов (64U) с выдачей старших 64-х бит результата

Битовый сдвиг
`v2di` __builtin_e2k_qpsrad `(v2di, uint64)`

> Арифметический сдвиг вправо 2-х знаковых long’ов (64S)

### Builtin’ы для работы в защищённом режиме

Данные builtin’ы поддерживаются только в защищённом режиме

`uint64` __builtin_e2k_get_ap_base `(const void *ap)`

> У дескриптора AP взять поле AP.base

`uint32` __builtin_e2k_get_ap_size `(const void *ap)`

> У дескриптора AP взять поле AP.size

`uint32` __builtin_e2k_get_ap_curptr `(const void *ap)`

> У дескриптора AP взять поле AP.curptr

`void*` __builtin_e2k_create_ap_subarray `(const void *ap, uint32 offset, uint32 size)`

> На базе существующего дескриптора AP построить новый дескриптор, описывающий подмассив размером `size` и начинающийся со смещением `offset` внутри входного дескриптора AP

`uint32` __builtin_e2k_load_gettags `(const void *addr)`
`uint32` __builtin_e2k_load_gettagd `(const void *addr)`

> Из памяти по адресу `addr` прочитать тэг у фрагмента памяти рамзером 4/8 байт. Адрес `addr` должен быть выровнен на 4/8 байт. Если по указанному адресу лежит дескриптор, то при чтении фрагмента тэг потеряется. Это особенность работы аппаратуры - чтобы не было возможности сконструировать дескриптор из отдельных кусков

## E90-зависимые builtin’ы

### Обращения в память с ASI-кодом

Данные builtin’ы предназначены для построения операций load/store с использованием ASI-кода (Address Space Identifier). Во всех builtin’ах данной группы параметр `addr` обозначает целевой адрес, параметр `index` означает смещение к адресу (т.е. реальное обращение в память проходит по адресу `addr + index`), параметр `val` обозначает записываемое значение (для store’ов), параметр `asi` обозначает значение ASI-кода, параметр `mask` означает маску записываемого значения (для pstore’ов)

`uint8` __builtin_loadasi_8u `(const void *addr, long index, int asi)`
`uint16` __builtin_loadasi_16u `(const void *addr, long index, int asi)`
`uint32` __builtin_loadasi_32u `(const void *addr, long index, int asi)`
`float32` __builtin_loadasi_32f `(const void *addr, long index, int asi)`
`float64` __builtin_loadasi_64f `(const void *addr, long index, int asi)`

> Построение операций load с ASI-кодом

`void` __builtin_storeasi_64f `(float64 val, void *addr, long index, int asi)`
`void` __builtin_pstoreasi_64f `(float64 val, void *addr, int mask, int asi)`

> Построение операций store с ASI-кодом