Поддерживаемые MCST builtin'ы
=============================

.. contents:: Содержание

.. Для автонумерации нужно использовать директиву
   .. sectnum::
   но она работает дебильно, т.к. автонумерует в том числе и заголовок документа

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

В данном документе описываются только собственные builtin'ы.
Те builtin'ы, которые позаимствованы у gcc, описаны в статье :doc:`builtin_gnu`

Машинно-независимые 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-кодом

