Руководство по ассемблеру MASM для архитектуры Intel x86-64

Тема в разделе "MASM", создана пользователем Mikl___, 28 окт 2026.

  1. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    FPU, SSE и числа с плавающей точкой

    Сравнение чисел с плавающей точкой в FPU

    FPU предоставляет несколько инструкций для сравнения значений с плавающей точкой. Инструкции fcom, fcomp и fcompp сравнивают два значения на вершине стека и соответствующим образом устанавливают биты состояния.
    • fcom
    • fcomp
    • fcompp
    • fcom st(i)
    • fcomp st(i)
    • fcom mem32
    • fcom mem64
    • fcomp mem32
    • fcomp mem64
    Формы инструкций fcom, fcomp и fcompp без операндов сравнивают ST(0) с ST(1) и соответственно устанавливают флаги FPU. Кроме того, fcomp извлекает ST(0) из стека, а fcompp извлекает из стека ST(0) и ST(1).
    fcom и fcomp в качестве операнда могут принимать регистр ST(i), который сравнивается с ST(0). fcomp также извлекает значение ST(0) из стека после сравнения.
    Инструкции fcom и fcomp могут принимать 32- и 64-битные переменные - числа с плавающей точкой, которые преобразуются в 80-битное значение повышенной точности, а затем сравнивают ST(0) с этим значением и соответствующим образом устанавливают биты состояния. fcomp также извлекает значение ST(0) из стека после сравнения.
    Эти инструкции устанавливают бит состояния C2, если два операнда несопоставимы (например, NaN). Поэтому если при сравнении теоретически может участвовать недопустимое значение с плавающей точкой, то перед проверкой желаемого условия следует проверить флаг четности на наличие ошибки (например, с помощью инструкций setp/setnp или jp/jnp). Эти инструкции устанавливают бит ошибки стека, если на вершине стека регистров нет двух элементов. Они устанавливают бит денормализованного исключения, если один или оба операнда денормализованы. Они устанавливают флаг недопустимой операции, если один или оба операнда являются NaN. Эти инструкции всегда очищают код состояния C1.
    Сразу после сравнения можно проверить биты кода состояния. Однако проблема состоит в том, что FPU не имеет инструкций для прямой проверки кодов состояния. Вместо этого применяется инструкция fstsw для копирования регистра состояния FPU в регистр AX, а затем инструкция sahf копирует регистр AH в биты кода состояния FLAGS: бит C0 компируется во флаг переноса CF, C2 - во флаг четности и C3 - во флаг нуля. Флаг C1 не копируется. Кроме того, sahf не копирует биты состояния FPU во флаг знака SF или флаг переполнения OF. Поэтому для проверки кодов состояния с помощью инструкций x86-64 нельзя использовать инструкции, применяемые для сравнения двух чисел со знаком. Нужно применять только инструкции для беззнакового сравнения (несмотря на то, что числа с плавающей точкой сами по себе имееют знак).
    Пример сравнения:
    Код (ASM):
    1. .data
    2.  st0 real8 2.8
    3.  st1 real8 2.9
    4. .code
    5. main proc
    6.  fld st1
    7.  fld st0
    8.  fcompp  ; сравниваем ST(0) и ST(1)
    9.  fstsw ax  ; данные регистра состояния загружаем в AX
    10.  sahf  ; загружаем данные из AX в регистр FLAGS
    11.  setb al  ; AL = true if st(0) < st(1)
    12.  movzx eax, al ; проверяем значение AL
    13.  ret
    14. main endp
    15. end
    Здесь с помощью инструкции fcompp сравниваются значения регистров ST(0) и ST(1). В ST(0) число 2.8, а в ST(1) - 2.9. После сравнения помещаем регистр состояния FPU в регистр общего назначения AX: fstsw ax
    Далее загружаем флаги состояния, которые теперь в AH, в стандартный регистр состояния FLAGS sahf
    Далее, используя инструкции для беззнакового сравнения можно выполнить те или иные действия. В частности, здесь устанавливаем число 1 в регистр AL, если первое число при сравнении (ST(0)) меньше второго (ST(1)) setb al
    В нашем случае первое число (2.8) меньше второго (2.9), поэтому в AL будет число 1
    Другой пример:
    Код (ASM):
    1. .data
    2.  st0 real8 2.8
    3.  st1 real8 2.1
    4. .code
    5. main proc
    6.  fld st1
    7.  fld st0
    8.  fcompp  ; сравниваем ST(0) и ST(1)
    9.  fstsw ax  ; данные регистра состояния загружаем в AX
    10.  sahf  ; загружаем данные из AX в регистр FLAGS
    11.  jnb set_10  ; если st(0) >= st(1) переход к set_10
    12.  mov eax, 5;
    13.  jmp end_proc
    14. set_10:
    15.  mov eax, 10
    16. end_proc:
    17.  ret
    18. main endp
    19. end
    Здесь с помощью инструкции jnb сравниваем операнды, и если первый операнд (в данном случае ST(0)) больше или равен второму (в данном случае ST(1)), то переходим к метке set_10. Таким образом, в зависимости от сравнения в регистре EAX будет либо число 5, либо число 10.
    Процессор x86-64 также предоставляют дополнительный набор инструкций сравнения с плавающей точкой, которые непосредственно влияют на флаги состояния x86-64 - fcomi и fcomip. Эти инструкции позволяют обойти необходимость использования fstsw и sahf для копирования вручную состояния FPU в регистр FLAGS. С другой стороны, fcomi и fcomip поддерживают только ограниченное число форм операндов: первый операнд - всегда регистр ST(0), который сравнивается регистром из второго операнда:
    fcomi st(0), st(i)
    fcomip st(0), st(i)

    На основе результата сравнения устанавливают соответствующие биты кода состояния FLAGS. Пример применения:
    Код (ASM):
    1. .data
    2.  st0 real8 2.8
    3.  st1 real8 2.9
    4. .code
    5. main proc
    6.  fld st1
    7.  fld st0
    8.  fcomip st(0), st(1)  ; сравниваем ST(0) и ST(1)
    9.  setb al  ; AL = 1 если st(0) < st(1)
    10.  movzx eax, al  ; проверяем значение AL
    11.  ret
    12. main endp
    13. end
    Стоит отметить, что fcomip извлекает верхний элемент (ST(0)) из стека.
    ftst
    Инструкция ftst сравнивает значение на вершине стека с 0:
    Код (ASM):
    1. .data
    2.  st0 real8 0.0
    3. .code
    4. main proc
    5.  fld st0
    6.  ftst
    7.  fstsw ax
    8.  sahf
    9.  sete al  ; AL = 1 если ST(0) = 0.0
    10.  movzx eax, al  ; проверяем значение AL
    11.  ret
    12. main endp
    13. end
     
    Последнее редактирование: 31 окт 2026
  2. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    FPU, SSE и числа с плавающей точкой

    Расширения SSE для чисел с плавающей точкой

    В дополнение к FPU Intel предоставляет еще один механизм для работы с числами с плавающей точкой - расширения SSE или Streaming SIMD Extensions, которые призваны преодолеть недостатки стековой архитектуры FPU. Для вычислений SSE определяет 16 регистров XMM (от XMM0 до XMM15).
    Набор инструкций SSE поддерживает два типа данных с плавающей точкой: 32-битные значения одинарной точности и 64-битные значения двойной точности. 80-битные значения расширенной точности не поддерживаются.
    Регистр управления
    Для управления операциями SSE с плавающей точкой в SSE предназначен 32-битный регистр состояния и управления SSE MXCSR. Первые 16 бит имеют определенное значение:
    • 0 (IE): Флаг исключения недопустимой операции. Устанавливается, если была попытка выполнить недопустимую операцию
    • 1 (DE): Флаг исключения денормализации. Устанавливается, если результат операции - денормализованное значение
    • 2 (ZE): Флаг нулевого исключения. Устанавливается, если была предпринята попытка деления на 0.
    • 3 (OE): Флаг переполнения. Устанавливается, если было переполнение.
    • 4 (UE): Флаг потери значимости (underflow). Устанавливается, если была потеря значимости
    • 5 (PE): Флаг потери точности. Устанавливается, если была потеря точности.
    • 6 (DAZ): Денормализованные значения равны 0. Если установлено, денормализованные значения обрабатываются как 0.
    • 7 (IM): Неверная маска операции. Если установлено, исключения недопустимой операции игнорируются
    • 8 (DM): Денормализованная маска. Если установлено, исключения денормализации игнорируются
    • 9 (ZM): Маска деления на ноль. Если установлено, исключения деления на ноль игнорируются
    • 10 (OM): Маска переполнения. Если установлено, исключения переполнения игнорируются
    • 11 (UM): Маска потери значимости. Если установлено, исключения потери значимости игнорируются
    • 12 (PM): Маска точности. Если установлено, исключения точности игнорируются
    • 13-14: Управление округлением. может принимать ряд значений:
      • 00: округление до ближайшего
      • 01: округление до -бесконечности
      • 10: округление до +бесконечности
      • 11: округление до 0 (усечение)
    • 15 (FTZ): Сброс до нуля. Когда установлено, все условия потери значимости устанавливают регистр в 0
    Остальне биты 16-32 зарезервированы и в настоящее время не имеют значения.
    Доступ к регистру SSE MXCSR осуществляется с помощью следующих двух инструкций:
    • ldmxcsr mem32
    • stmxcsr mem32
    Инструкция ldmxcsr загружает регистр MXCSR из 32-битной переменной. Инструкция stmxcsr сохраняет текущее содержимое регистра MXCSR в 32-битную переменную. Как правило, данный регистр применяется для установки режима округления.
    Помещение данных в регистр
    Для перемещения данных между регистрами XMM и переменными для чисел с плавающей точкой одинарной точности применяется инструкция movss, а для чисел с плавающей точкой двойной точности - инструкция movsd:
    • movss xmmn, mem32
    • movss mem32, xmmn
    • movsd xmmn, mem64
    • movsd mem64, xmmn
    Для максимальной производительности переменные, используемые в инструкции movss, должны располагаться выравнены в памяти по двойному слову (4 бита), а операнды инструкции movsd — по адресу памяти, выровненному по четверному слову.
    В дополнение SSE предоставляет инструкции movd и movq, которые позволяют перемещать данные между регистрами XMM и 32- и 64-битными регистрами общего назначения:
    • movd reg32, xmmn
    • movd xmmn, reg32
    • movq reg64, xmmn
    • movq xmmn, reg64
    Стоит отметить, что эти команды не преобразуют значения с плавающей точкой в целые числа.
    Преобразования SSE
    SSE предоставляет ряд инструкций для преобразования чисел с плавающей точкой в целые числа и обратно:
    • cvtsd2si: преобразует число с плавающей точкой двойной точности в 32- или 64-битное целое число. Использует текущий режим округления в MXCSR. Результат сохраняется в 32- или 64-битном регистре общего назначения.
      cvtsd2si reg32/64, xmmn/mem64
    • cvtsd2ss: преобразует число с плавающей точкой двойной точности (в регистре XMM или переменной) в число с плавающей точкой одинарной точности и оставляет результат в первом операнде - регистре XMM. Использует текущий режим округления в MXCSR.
      cvtsd2ss xmmn, xmmn/mem64
    • cvtsi2sd: преобразует 32- или 64-разрядное целое число в целочисленном регистре или переменной в число с плавающей точкой двойной точности, оставляя результат в регистре XMM.
      cvtsi2sd xmmn, reg32/64/mem32/64
    • cvtsi2ss: преобразует 32- или 64-разрядное целое число в целочисленном регистре или переменной в число с плавающей точкой одинарной точности, оставляя результат в регистре XMM.
      cvtsi2ss xmmn, reg32/64/mem32/64
    • cvtss2sd: преобразует значение с плавающей точкой одинарной точности в регистре XMM или переменной в значение двойной точности, оставляя результат в регистре XMM в первом операнде.
      cvtss2sd xmmn, xmmn/mem32
    • cvtss2si: преобразует значение с плавающей точкой одинарной точности в регистре XMM или переменной в целое число и оставляет результат в 32- или 64-битном регистре общего назначения. Использует текущий режим округления в MXCSR.
      cvtss2si reg32/64, xmmn/mem32
    • cvttsd2si: преобразует значение с плавающей точкой двойной точности в 32- или 64-битное целое число. Преобразование выполняется с использованием усечения (не использует биты управления округлением в MXCSR). Результат сохраняется в 32- или 64-битном регистре общего назначения.
      cvttsd2si reg32/64, xmmn/mem64
    • cvttss2si: преобразует значение с плавающей точкой одинарной точности в 32- или 64-битное целое число. Преобразование выполняется с использованием усечения (не использует биты управления округлением в MXCSR). Результат сохраняется в 32- или 64-битном регистре общего назначения.
      cvttss2si reg32/64, xmmn/mem32
    Пример преобразования:
    Код (ASM):
    1. .data
    2.  double1 real8 3.4
    3. .code
    4. main proc
    5.  movsd xmm0, double1  ; помещаем в xmm0 число double1
    6.  cvtsd2si rax, xmm0  ; из xmm0 преобразуем в целое число и помещаем в rax
    7.  ret
    8. main endp
    9. end
    В данном случае число 3.4, которое хранится в XMM0, преобразуется в целочисленное значение. И мы получим в регистре RAX число 3.
     
    Последнее редактирование: 31 окт 2026
    Marylin нравится это.
  3. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    FPU, SSE и числа с плавающей точкой

    Арифметика чисел с плавающей точкой в SSE

    Для выполнения арифметических действий над числами с плавающей точкой расширения SSE предоставляет ряд инструкций:
    • addss и addsd: сложение
    • subss и subsd: вычитание
    • mulss и mulsd: умножение
    • divss и divsd: деление
    • minss и minsd: вычисляют минимальное значение двух операндов, сохраняя минимальное значение в первом операнде.
    • maxss и maxsd: вычисляют максимальное значение двух операндов, сохраняя минимальное значение в первом операнде.
    • sqrtss и sqrtsd: вычисляют квадратный корень второго операнда и сохраняют результат в первый операнд
    • rcpss и rcpsd: вычисляют обратное значение второго операнда, сохраняя результат в первый операнд
    • rsqrtss и rsqrtsd: вычисляют обратное значение квадратного корня второго операнда, сохраняя результат в первый операнд
    • addss xmmn, xmmn
    • addss xmmn, mem32
    • addsd xmmn, xmmn
    • addsd xmmn, mem64
    • subss xmmn, xmmn
    • subss xmmn, mem32
    • subsd xmmn, xmmn
    • subsd xmmn, mem64
    • mulss xmmn, xmmn
    • mulss xmmn, mem32
    • mulsd xmmn, xmmn
    • mulsd xmmn, mem64
    • divss xmmn, xmmn
    • divss xmmn, mem32
    • divsd xmmn, xmmn
    • divsd xmmn, mem64
    • minss xmmn, xmmn
    • minss xmmn, mem32
    • minsd xmmn, xmmn
    • minsd xmmn, mem64
    • maxss xmmn, xmmn
    • maxss xmmn, mem32
    • maxsd xmmn, xmmn
    • maxsd xmmn, mem64
    • sqrtss xmmn, xmmn
    • sqrtss xmmn, mem32
    • sqrtsd xmmn, xmmn
    • sqrtsd xmmn, mem64
    • rcpss xmmn, xmmn
    • rcpss xmmn, mem32
    • rsqrtss xmmn, xmmn
    • rsqrtss xmmn, mem32
    Первый операнд всегда должен быть регистром XMM. Например, сложим два числа:
    Код (ASM):
    1. .data
    2.  double1 real8 3.4
    3.  double2 real8 6.6
    4. .code
    5. main proc
    6.  movsd xmm0, double1  ; помещаем в xmm0 число double1
    7.  movsd xmm1, double2  ; помещаем в xmm1 число double2
    8.  addsd xmm0, xmm1  ; XMM0 - XMM0 + XMM1
    9.  cvtsd2si rax, xmm0  ; из xmm0 преобразуем в целое число и помещаем в rax
    10.  ret
    11. main endp
    12. end
     
    Последнее редактирование: 31 окт 2026
  4. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    FPU, SSE и числа с плавающей точкой

    Сравнение чисел с плавающей точкой в SSE

    Для сравнения чисел с плавающей точкой расширения SSE предоставляют набор инструкций сравнения для конкретных условий, которые сохраняют значение true (все биты 1) или false (все биты 0) в первом операнде:
    • cmpss xmmn, xmmm/mem32, imm8
    • cmpsd xmmn, xmmm/mem64, imm8
    • cmpeqss xmmn, xmmm/mem32 ; операнды равны
    • cmpltss xmmn, xmmm/mem32 ; первый операнд меньше второго
    • cmpless xmmn, xmmm/mem32 ; первый операнд меньше или равен второму
    • cmpunordss xmmn, xmmm/mem32 ; неупорядоченное сравнение (один из операндов или оба равны NaN)
    • cmpneqss xmmn, xmmm/mem32 ; операнды не равны
    • cmpnltss xmmn, xmmm/mem32 ; первый операнд НЕ меньше второго
    • cmpnless xmmn, xmmm/mem32 ; первый операнд НЕ меньше или равен второму
    • cmpordss xmmn, xmmm/mem32 ; упорядоченное сравнение
    • cmpeqsd xmmn, xmmm/mem64 ; операнды равны
    • cmpltsd xmmn, xmmm/mem64 ; первый операнд меньше второго
    • cmplesd xmmn, xmmm/mem64 ; первый операнд меньше или равен второму
    • cmpunordsd xmmn, xmmm/mem64 ; неупорядоченное сравнение (один из операндов или оба равны NaN)
    • cmpneqsd xmmn, xmmm/mem64 ; операнды не равны
    • cmpnltsd xmmn, xmmm/mem64 ; первый операнд НЕ меньше второго
    • cmpnlesd xmmn, xmmm/mem64 ; первый операнд НЕ меньше или равен второму
    • cmpordsd xmmn, xmmm/mem64 ; упорядоченное сравнение
    Первые две инструкции могут в качестве третьего операнда (imm8) принимать значение от 0 до 7, которое указывает на принцип сравнения:
    • 0: Первый операнд == второй операнд
    • 1: Первый операнд < второй операнд
    • 2: Первый операнд <= второй операнд
    • 3: Неупорядоченное сравнение
    • 4: Первый операнд ≠ второй операнд
    • 5: Первый операнд не меньше второго операнда (>=)
    • 6: Первый операнд не меньше или равен второму операнду (>)
    • 7: Упорядоченное сравнение
    Эти инструкции устанавливают в 0 (неверно, ложь) или 1 (верно, истина) все биты в первом операнде. После сравнения значение из регистра XMM можно поместит в регистр общего назначения и проверить этот регистр на наличие нуля/не нуля. Для этого можно использовать инструкции movq или movd:
    Код (ASM):
    1. .data
    2.  double1 real8 1.2
    3.  double2 real8 1.2
    4. .code
    5. main proc
    6.  movsd xmm0, double1
    7.  movsd xmm1, double2
    8.  cmpeqsd xmm0, xmm1  ; равны ли операнды
    9.  movd eax, xmm0
    10.  ret
    11. main endp
    12. end
    Здесь помещаем в XMM0 и XMM1 два числа real8 и инструкцией cmpeqsd сравниваем их на равенство. Если они равны, то в xmm0 все биты будут равны 1, если нет - то 0. Для проверки значения помещаем его в регистр EAX. Поскольку при равестве все биты будут установлены в 1, то фактически в десятичной системе это будет число -1.
    Получив результат проверки в регистр EAX, мы можем использовать уже стандартные инструкции перехода, чтобы определить условные конструкции:
    Код (ASM):
    1. .data
    2.  double1 real8 1.2
    3.  double2 real8 1.2
    4. .code
    5. main proc
    6.  movsd xmm0, double1
    7.  movsd xmm1, double2
    8.  cmpeqsd xmm0, xmm1  ; равны и=ли операнды
    9.  movd eax, xmm0
    10.  and eax, eax  ; проверяем на равенство
    11.  jnz equal  ; если xmm0 == xmm1
    12.  mov eax, 0
    13.  jmp proc_end
    14. equal:
    15.  mov eax, 1
    16. proc_end:
    17.  ret
    18. main endp
    19. end
    Здесь по сравнению с предыдущим примером добавили проверку на 0 с помощью инструкции and - если результат этой инструкции равен 0, то будет установлен флаг нуля ZF, который мы можем проверить с помощью инструкции jnz - если флаг не установлен (то есть по сути если xmm0 и xmm1 были равны), то далее выполняем переход на метку equal.
     
    Последнее редактирование: 31 окт 2026
  5. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    FPU, SSE и числа с плавающей точкой

    Десятичная арифметика и двоично-десятичный формат BCD

    Хотя процессоры x86-64 используют двоичную систему счисления для собственного внутреннего представления данных, но некоторые алгоритмы могут зависеть от десятичных вычислений для получения правильных результатов. Поэтому, хотя десятичная арифметика, как правило, менее эффективна и менее точна, чем двоичная, потребность в десятичной арифметике сохраняется.
    Для представления десятичных чисел в двоичном формате наиболее распространенным методом является использование представления в двоично-десятичном формате (BCD). При этом используются 4 бита для представления 10 возможных десятичных цифр. Двоичное значение этих 4 бит равно соответствующему десятичному значению в диапазоне от 0 до 9.
    BCDДесятичное
    значение
    BCDДесятичное
    значение
    0000 0000​
    0​
    0001 0110​
    16​
    0000 0001​
    1​
    0001 0111​
    17​
    0000 0010​
    2​
    0001 1000​
    18​
    0000 0011​
    3​
    0001 1001​
    19​
    0000 0100​
    4​
    0010 0000​
    20​
    0000 0101​
    5​
    0010 0001​
    21​
    0000 0110​
    6​
    0010 0010​
    22​
    0000 0111​
    7​
    0010 0011​
    23​
    0000 1000​
    8​
    0010 0100​
    24​
    0000 1001​
    9​
    0010 0101​
    25​
    0001 0000​
    10​
    0010 0110​
    26​
    0001 0001​
    11​
    0010 0111​
    27​
    0001 0010​
    12​
    0010 1000​
    28​
    0001 0011​
    13​
    0010 1001​
    29​
    0001 0100​
    14​
    0011 0000​
    30​
    0001 0101​
    15​
    0011 0001​
    31​
    Хотя с помощью 4 бит можно представить 16 различных значений; формат BCD игнорирует оставшиеся шесть битовых комбинаций. Поскольку для каждой двоично-десятичной цифры требуется 4 бита, мы можем представить двузначное двоично-десятичное число одним байтом. Это означает, что мы можем представить десятичные значения в диапазоне от 0 до 99 с помощью одного байта (в отличие от 0 до 255 с байтом в двоичном формате).
    Например, число 99 в BCD-формате равно 99h. Хотя в конце добавляется символ h, как и в случае с обычными шестнадцатеричными числами. Но в реальности это десятичное число 99.
    Чтобы повысить производительность приложений с десятичной арифметикой, Intel внедрила поддержку десятичной арифметики непосредственно в FPU. FPU поддерживает значения с точностью до 18 знаков после точкой, при этом в вычислениях используются все арифметические возможности FPU (сложение, вычитание и т.д.).
    FPU поддерживает только один тип данных BCD: 10-байтовое 18-разрядное десятичное значение. Первые 9 байтов используются для хранения значения BCD в стандартном упакованном десятичном формате. Первый байт содержит младшие две цифры, а девятый байт содержит старшие две цифры числа. Старший бит десятого байта содержит бит знака, оставшиеся биты в десятом байте игнорируются и никак не используются (поскольку использование этих битов может создать возможные значения BCD, которые FPU не может точно представить в родном формате с плавающей точкой).
    FPU использует нотацию с дополнением до единицы для отрицательных значений BCD. Бит знака содержит 1, если число отрицательное, и содержит 0, если число положительное. Если число равно 0, бит знака может быть либо 0, либо 1, потому что для 0 существует два различных представления.
    В MASM — для определения упакованных переменных BCD применяется тип данных tbyte, значения которого можно инициализировать шестнадцатеричным/BCD-значением.
    FPU предоставляет две инструкции, fbld и fbstp, которые преобразуют упакованные десятичные в двоичные форматы с плавающей точкой при перемещении данных в FPU и обратно. Инструкция fbld загружает 80-битное упакованное значение BCD в вершину стека FPU после преобразования этого значения значение с плавающей точкой. Аналогично, инструкция fbstp извлекает значение с плавающей точкй из вершины стека, преобразует его в упакованное значение BCD и сохраняет значение в переменной. Преобразование между упакованным BCD и форматом с плавающей точкой — недешевая операция, поэтому данные инструкции могут быть довольно медленными.
    Поскольку FPU преобразует упакованные десятичные значения во внутренний формат с плавающей точкой, можно смешивать числа BCD и числа с плавающей точкой и целочисленные (двоичные) значения в одном и том же вычислении:
    Код (ASM):
    1. .data
    2.  value1 tbyte 21h
    3.  value2 real8 2.0
    4.  value3 dword 1
    5. .code
    6. main proc
    7.  
    8.  fbld value1  ; загружаем value1
    9.  fmul value2  ; умножаем на value2
    10.  fiadd value3  ; прибавляем value3
    11.  fbstp value1  ; сохраняем данные обратно в value1
    12.  mov rax, qword ptr value1  ; RAX = 67
    13.  ret
    14. main endp
    15. end
    В данном случае значение tbyte хранится в переменной value1. В программе загружаем это значение в стек FPU, умножаем на value2, прибавляем value3 и полученное значение извлекаем из вершины стека и сохраняем обратно в value1.
    Таким образом, учитывая, что tbyte использует формат BCD, а переменная value1 изначальна равна 21h (то есть десятичное число 21), то после умножения на 2 и прибавления 1 оно будет равно 21 * 2 + 1 = 43
    Для примера в конце программы идет загрузука результата из value1 в регистр RAX с преобразованием до qword. И мы увидим, что в RAX в реальности не 43, а 67. Потому что для RAX это число в двоичном формате, и поэтому интерпертируется как 67.
    Но мы можем использовать преобразования FPU для конвертации значения в вершине стека в нужный формат:
    Код (ASM):
    1. .data
    2.  value1 tbyte 21h
    3.  value2 real8 2.0
    4.  value3 dword 1
    5.  result qword ?
    6. .code
    7. main proc
    8.  
    9.  fbld value1  ; загружаем value1
    10.  fmul value2  ; умножаем на value2
    11.  fiadd value3  ; прибавляем value3
    12.  fistp result  ; извлекаем значение в переменную result
    13.  mov rax, result  ; RAX = 43
    14.  ret
    15. main endp
    16. end
    Здесь значение из вершины стека - результат операции извлекается в переменную result. FPU автоматически преобразует значение в нужный формат. И поэтому в RAX будет число 43, как и ожидалось.
     
    Последнее редактирование: 31 окт 2026
  6. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Расширения SSE и AVX/AVX2

    SIMD (Single-Instruction, Multiple-Data - "Одна инструкция, много данных") представляет специальный набор инструкций, которые предоставляют параллельную обработку данных. То есть некоторые группы данных могут обрабатываться одновременно, благодаря чему увеличивается производительность и ускоряется выполнение программы. В архитектуре x86-64 инструкции SIMD представлены специальными расширениями SSE/AVX, которые имеют три поколения:
    • Архитектура SSE (Streaming SIMD Extensions), которая предоставляет шестнадцать 128-битных регистров XMM (поддерживают как целочисленные типы данных, так и типы с плавающей точкой)
    • Архитектура AVX/AVX2, которая поддерживает шестнадцать 256-битных регистров YMM (также поддерживают как целочисленные типы данных, так и типы с плавающей точкой)
    • Архитектура AVX-512, которая поддерживает до 32-х 512-битных регистров ZMM.
    Архитектуры SSE и AVX поддерживают два основных типа данных: скалярные значения (отдельные числа) и векторы (наборы чисел). Скалярные значения представляют отдельные значения с плавающей точкой одинарной или двойной точности. Векторы содержат несколько значений с плавающей точкой или целых чисел (от 2 до 32 значений, в зависимости от типа данных: byte, word, dword, qword, real4 или real8, а также регистра и размера памяти) .
    Регистры XMM (XMM0-XMM15) могут хранить одно 32-разрядное значение с плавающей точкой (то есть значение типа real4) или четыре значения с плавающей точкой одинарной точности (то есть вектор из 4-х значений). Регистры YMM (YMM0-YMM15) могут хранить 8 чисел с плавающей точкой одинарной точности (32-разрядных):
    [​IMG]
    Регистры XMM могут также хранить одно число с плавающей точкой двойной точности - real8 или вектор из двух значений чисел real8. Регистры YMM могут хранить вектор из четырех чисел с плавающей точкой двойной точности
    [​IMG]
    Аналогичным образом, регистр XMM может хранить вектор с 16 значениями byte (YMM - вектор с 32 байтами), с 8 значениями word (YMM - вектор с 16 word), 4 числами dword ((YMM - вектор с 8 dword)) и 2 числами qword (YMM - 4 qword)
    [​IMG]
    Элементы вектора еще называются дорожками (lane) регистров XMM и YMM. Например, 128-битный регистр XMM может хранить вектор из 16 байтов. Биты с 0 по 7 — это дорожка 0, биты с 8 по 15 — дорожка 1, биты с 16 по 23 — дорожка 2, и так далее. Последние биты со 120 по 127 образуют дорожку 15. 256-битный регистр YMM имеет 32 байтовые дорожки, а 512-битный регистр ZMM имеет 64 байтовые дорожки.
    Аналогично 128-битный регистр XMM имеет восемь дорожек размером для типов word (дорожки с 0 по 7). 256-битный регистр YMM имеет шестнадцать дорожек размером в слово (дорожки с 0 по 15). На процессорах с поддержкой AVX-512 регистр ZMM (размер 512 бит) имеет 32 дорожки для типов word, пронумерованные от 0 до 31. Регистр XMM имеет 4 дорожки размером с dword и real4 (дорожки с 0 по 3). Регистр YMM имеет 8 дорожек для dword и real4 (дорожки с 0 по 7). Регистр ZMM имеет 16 дорожек размера двойного слова или одинарной точности (номера от 0 до 15).
    Для работы с этими расширениями MASM добавляет три типа данных:
    • xmmword: вектор размером 128 байт, который представляет регистр XMM
    • ymmword: вектор размером 256 байт, который представляет регистр YMM
    • zmmword: вектор размером 512 байт, который представляет регистр ZMM
    Проверка доступности расширений для SIMD
    Разные процессоры имеют разную поддержку расширений для SIMD. Более новые версии расширений могут быть доступны для более новых версий процессоров. Расширения SSE 4.2 было анонсировано в 2006, и таким образом, есть очень большая вероятность, что компьютер, на котором будет запускаться программа, поддерживает это расширение (не говоря уже о более ранних версиях SSE). Расширения AVX были предложены в 2008 году, а первый процессор с этими расширениями - Sandy Bridge вышел в 2011 году. Расширения AVX2 вышли в свет с процессором Haswell в 2013 году. Расширения AVX-512, которые добавили поддержку 512-битных регистров, были предложены в 2013 г\оду и были впервые реализованы в процессорах Xeon Phi x200 и Skylake-X в 2015/2016 году.
    Чтобы определить, поддерживает ли тот или иной процессор определенные расширения, мы можем применять инструкцию cpuid. Она принимает один параметр, который передается через регистр EAX. В зависимости от значения, переданного в EAX, эта инструкция возвращает различную информацию о процессоре. Приложение может проверить возвращаемую информацию, чтобы узнать, доступны ли определенные функции процессора.
    Например, чтобы узнать поддержку расширений для SIMD, в EAX передается значение 1. В этом случае результат инструкции помещается в регистр ECX. Определенные биты результат могут указывать на поддержку определенных возможностей:
    БитОписание
    0Доступно SSE3
    1Доступно PCLMULQDQ
    9Доступно SSSE3
    19Доступно SSE4.1
    20Доступно SSE4.2
    28Доступно AVX
    (Advanced Vector Extensions)
    Простейший пример:
    Код (ASM):
    1. .code
    2. main proc
    3.  mov eax, 1
    4.  cpuid
    5.  mov eax, ecx
    6.  ret
    7. main endp
    8. end
    Допустим, на компьютере результатом инструкции CPUID является число -2428017=0FFDAF38Fh=1111.1111.1101.1010.1111.0011.1000.1111 в бинарной форме. Исходя из установленных битов, узнайте, какие именно версии расширений поддерживаются.
    Дополнительную информацию можно получить, установив значения EAX = 7 и ECX = 0. В этом случае информация с битами будет помещаться в регистр EBX
    БитОписание
    3Доступно BMI1 (Bit Manipulation Instruction
    ― набор инструкций для манипуляции с битами)
    5Доступно AVX2
    8Доступно BMI2
    Используя логические операции, мы можем проверить поддержку того или иного расширения на текущей машине:
    Код (ASM):
    1. .data
    2.  SSE42Support = 00180000h  ; проверяем биты 19 и 20
    3.  AVXSupport = 10000000h  ; проверяем бит 28
    4.  AVX2Support = 20h  ; проверяем бит 5
    5. .code
    6. main proc
    7.  ; Определяем, доступны ли расширения AVX и соответственно регистры YMM
    8.  mov eax, 7
    9.  xor ecx, ecx
    10.  cpuid
    11.  and ebx, AVX2Support  ; проверяем на поддержку AVX2 бит 5
    12.  jnz AVX2  ; если AVX доступно, переходим к метке AVX2
    13.  mov eax, 1
    14.  cpuid
    15.  and ecx, AVXSupport  ; проверяем на поддержку AVX бит 28
    16.  jnz AVX  ; если AVX доступно, переходим к метке AVX
    17.  and ecx, SSE42Support  ; проверяем на поддержку SSE42 бит 19 и 20
    18.  jnz SSE42  ; если AVX доступно, переходим к метке SSE42
    19.  mov eax, 0  ; если ни одно из трех расширений не установлено
    20.  jmp exit
    21. AVX2:
    22.  mov rax, 52
    23.  jmp exit
    24. AVX:
    25.  mov rax, 50
    26.  jmp exit
    27. SSE42:
    28.  mov rax, 42
    29.  jmp exit
    30. exit:
    31.  ret
    32. end
    В данном случае применяем к результату инструкции cpuid одну из масок и по результатам сравнения помещаем в регистр RAX то или иное число.
     
    Последнее редактирование: 31 окт 2026
  7. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Копирование данных с помощью инструкций SIMD

    Архитектура x86-64 предоставляет множество инструкций для копирования данных, которые копируют данные между регистрами (SSE/AVX), получают данные из регистров общего назначения или переменных или сохраняют данные обратно в переменные и другие регистры. И здесь мы можем копировать либо единичные значения, либо вектор значений.
    Копирование скалярных значений
    Расширения SSE предоставляют инструкции movd (для копирования данных типа dword) и movq:
    • movd xmm, reg32/mem32
    • movq xmm, reg64/mem64
    Инструкция movd копирует значение из 32-разрядного регистра общего назначения или переменной в младшие 32 бита регистра XMM. А инструкция movq копирует значение из 64-разрядного регистра общего назначения или переменной в младшие 64 бита регистра XMM.
    Также эти инструкции поддерживают обратную операцию - сохранение данных из регистров XMM в 32- или 64-разрядный регистр общего назначения или переменную:
    • movd reg32/mem32, xmm
    • movq reg64/mem64, xmm
    Инструкция movq также позволяет копировать данные из младших 64 бит одного регистра XMM в другой регистр XMM:
    • movq xmm, xmm
    Расширение AVX поддержиет аналогичные инструкции, только их название предваряется символом v:
    • vmovd xmm, reg32/mem32
    • vmovd reg32/mem32, xmm
    • vmovq xmm, reg64/mem64
    • vmovq reg64/mem64, xmm
    Поскольку в этих операциях участвуют 32- и 64-разрядные операнды, то для переменных необязательно выравнивание в памяти по 16/32/64 битам (хотя при наличии подобного выравнивания инструкции могут выполняться быстрее).
    Пример копирования:
    Код (ASM):
    1. .data
    2.  num dword 22
    3. .code
    4. main proc
    5.  mov eax, 7
    6.  ; в XMM
    7.  movq xmm0, rax  ; в XMM0 число 7
    8.  movd xmm1, num  ; в XMM1 число 22
    9.  ; из XMM
    10.  movq rax, xmm1  ; RAX = 22
    11.  movd num, xmm0  ; num = 7
    12.  add eax, num  ; eax = 22 + 7 = 29
    13.  ret
    14. main endp
    15. end
    Копирование векторов чисел
    Копирование выравненных данных
    Отдельно есть инструкции, которые выполняют копирование выровненных данных
    • movaps: копирование числа с плавающей точкой одинарной точности. Допускает переменные типов real4, dword и oword
    • movapd: копирование числа с плавающей точкой одинарной точности. Допускает переменные типов real8, qword и oword
    • movdqa: копирование восьмеричного слова (oword). Допускает только переменные типа oword
    Эти инструкции копируют 16 байтов данных между переменными и регистрами XMM или между двумя регистрами XMM. Расширения AVX представляют аналогичные инструкции с префиксом v, которые копируют 16 или 32 байта между переменными и регистрами XMM или YMM или между двумя регистрами XMM или YMM (при копировании в регистры XMM обнуляются старшие биты соответствующего регистра YMM):
    • vmovaps: копирование числа с плавающей точкой одинарной точности. Допускает переменные типов real4, dword и (при использовании регистров YMM) ymmword ptr
    • vmovapd: копирование числа с плавающей точкой одинарной точности. Допускает переменные типов real8, qword и (при использовании регистров YMM) ymmword ptr
    • vmovdqa: копирование восьмеричного слова (oword). При использовании регистров YMM допускает только переменные типа ymmword ptr
    Инструкции принимают следующие формы:
    • movaps xmm, mem128
    • vmovaps xmm, mem128
    • vmovaps ymm, mem256
    • movaps mem128, xmm
    • vmovaps mem128, xmm
    • vmovaps mem256, ymm
    • movaps xmm, xmm
    • vmovaps xmm, xmm
    • vmovaps ymm, ymm
    • movapd xmm, mem128
    • vmovapd xmm, mem128
    • vmovapd ymm, mem256
    • movapd mem128, xmm
    • vmovapd mem128, xmm
    • vmovapd mem256, ymm
    • movapd xmm, xmm
    • vmovapd xmm, xmm
    • vmovapd ymm, ymm
    • movdqa xmm, mem128
    • vmovdqa xmm, mem128
    • vmovdqa ymm, mem256
    • movdqa mem128, xmm
    • vmovdqa mem128, xmm
    • vmovdqa mem256, ymm
    • movdqa xmm, xmm
    • vmovdqa xmm, xmm
    • vmovdqa ymm, ymm
    При копировании переменные должны быть выровнены по 16-байтовой или 32-байтовой границе (соответственно), иначе процессор сгенерирует ошибку невыровненного доступа.
    Операнд mem128 должен быть выровнен по 16-байтовой границе и в зависимости от инструкции должен представлять:
    • для инструкции (v)movaps - вектор из четырех 32-разрядных чисел
    • для инструкции (v)movapd - вектор из двух 64-разрядных чисел
    • для инструкции (v)movdqa - 16-байтовое значение (16 байтов, 8 word, 4 dword или 2 qword)
    Операнд mem256 должен быть выровнен по 32-байтовой границе и в зависимости от инструкции должен представлять:
    • для инструкции vmovaps - вектор из восьми 32-разрядных чисел
    • для инструкции vmovapd - вектор из четырех 64-разрядных чисел
    • для инструкции vmovdqa - 32-байтовое значение (32 байта, 16 word, 8 dword или 4 qword)
    Подобные инструкции удобно применять для копирования данных из одного вектора в другой:
    Код (ASM):
    1. .data
    2.  qnums qword 121, 122
    3.  qnums_copy qword 2 dup(?)
    4. .code
    5. main proc
    6.  ; в XMM
    7.  movapd xmm0, qnums
    8.  ; из XMM
    9.  movapd qnums_copy, xmm0
    10.  
    11.  mov rax, qnums_copy  ; rax = 121
    12.  ret
    13. main endp
    14. end
    В данном случае определены два вектора, они состоят из 2-х чисел qword.
    С помощью инструкции movapd вектор qnums загружается в регистр XMM0. Затем эти данные выгружаются обратно в переменную qnums_copy.
    Как выше говорилось, для определенных инструкций мы можем передать определенное количество данных определенного типа. Так, в примере выше мы передаем инструкции movapd вектор из 2 чисел qword. Что будет, если мы передадим вектор из большего количества чисел? Например:
    Код (ASM):
    1. .data
    2. qnums qword 121, 122, 123, 124
    3.  ................................
    4. movapd xmm0, qnums
    В этом случае в XMM0 будут загружены только 2 первых числа, что вообщем-то логично, так как 128-разрядный регистр XMM1 вмешает только два 64-разрядных числа.
    Аналогично можно копировать строки:
    Код (ASM):
    1. includelib kernel32.lib  ; подключаем библиотеку kernel32.lib
    2. ; подключаем функции WriteFile и GetStdHandle
    3. extrn WriteFile: PROC
    4. extrn GetStdHandle: PROC
    5. len equ 16
    6. .data
    7.  source byte "Hello METANIT",10
    8.  align 16
    9.  dest byte len dup(?)
    10. .code
    11. main proc
    12.  movdqa xmm0, oword ptr source  ; копируем из source в %ymm0
    13.  movdqa oword ptr dest, xmm0  ; копируем из %ymm0 в dest
    14.  ; вывод строки dest на консоль
    15.  sub  rsp, 40  ; Для параметров функций WriteFile и GetStdHandle резервируем 40 байт плюс 8 байт для выравнивания данных
    16.  mov  rcx, -11  ; Аргумент для GetStdHandle - STD_OUTPUT
    17.  call GetStdHandle ; вызываем функцию GetStdHandle
    18.  mov  rcx, rax  ; Первый параметр WriteFile - в регистр RCX помещаем дескриптор файла - консоли
    19.  lea  rdx, dest  ; Второй параметр WriteFile - загружаем указатель на строку в регистр RDX
    20.  mov  r8d, len  ; Третий параметр WriteFile - длина строки для записи в регистре R8D
    21.  xor  r9, r9  ; Четвертый параметр WriteFile - адрес для получения записанных байтов
    22.  mov  qword ptr [rsp + 32], 0  ; Пятый параметр WriteFile
    23.  call WriteFile ; вызываем функцию WriteFile
    24.  add  rsp, 40
    25.  ret
    26. main endp
    27. end
    В данном случае копируем строку source в регистр xmm0, а затем из регистра xmm0 - в переменную dest. Затем выводим строку на консоль с помощью функции WriteLine.
    Но стоит не забывать главную вещь - эти инструкции требуют выравнивания. Например, в примере выше выравнивание устанавливалось по умолчанию - обе переменных автоматически было выровнены по 16 байтам (как того требуют инструкции movaps и movapd), поскольку перед первой переменной ничего нет, а она сама занимает 4× 32 = 128 байт, то есть размер кратный 16. Соответственно вторая переменная также была выравнена по 16 байтам. Но возьмем другой пример:
    Код (ASM):
    1. .data
    2.  temp1 byte 1
    3.  qnums qword 121, 122
    4.  temp2 byte 31
    5.  qnums_copy qword 2 dup(?)
    6. .code
    7. main proc
    8.  ; в XMM
    9.  movapd xmm0, qnums
    10.  ; из XMM
    11.  movapd qnums_copy, xmm0
    12.  
    13.  mov rax, qnums_copy ; для теста получим в RAX первый элемент вектора qnums_copy
    14.  ret
    15. main endp
    16. end
    Перед вектором qnums идет однобайтная переменная, поэтому он не выровнен по 16 байт, соответственно также не выровнен и вектор qnums_copy. И здесь как раз можно использовать выравнивание:
    Код (ASM):
    1. .data
    2.  temp1 byte 1
    3.  align 16
    4.  qnums qword 121, 122
    5.  temp2 byte 31
    6.  align 16
    7.  qnums_copy qword 2 dup(?)
    Из минусов - программа занимает больше места. Однако если порядок переменных не играет значения, то лучше переупорядочить, чтобы избежать избыточных выравниваний:
    Код (ASM):
    1. .data
    2.  qnums qword 121, 122
    3.  qnums_copy qword 2 dup(?)
    4.  temp1 byte 1
    5.  temp2 byte 31
    Сегменты с выравниванием
    Однако подобное выравнивание имеет недостаток - мы не можем так задать выравнивание по 32 байтам, если нам нужна, например, 256-разрядная переменная, которую надо поместить в один из 256-разрядных регистров YMM, как в следующем случае:
    Код (ASM):
    1. .data
    2.  temps qword 1, 2, 3
    3. align 32  ; Ошибка: 32 - некорректное значение
    4.  nums qword 11, 22, 33, 44
    5.  nums_copy  qword 4 dup(?)
    6. .code
    7. main proc
    8.  vmovapd ymm0, nums
    9.  vmovapd nums_copy, ymm0
    10.  mov rax, nums_copy
    11.  ret
    12. main endp
    13. end
    Здесь мы столкнемся с ошибкой, так как 32 - некорректное значение для установки выравнивания. С аналогичной проблемой мы столкнемся, если захотим выравнить данные по 64 байтам, например, для последущего копирования в 516-разрядный регистр ZMM.
    Чтобы решить проблему, нам надо определить сегмент с установкой выравнивания. Сегмент определяется следующим образом:
    имя_сегмента segment readonly alignment
    инструкции
    имя_сегмента ends

    Сначала идет имя сегмента, после которого указывается оператор segment. После слова segment указывается параметр выравнивания, который может принимать значения: byte (выравнивае по 1 байту), word (по 2 байтам), dword (по 4 байтам), para (выравнивание по параграфу - 16 байтам), page (по странице - 256 байтам), align(n) (выравнивание по n байт). Если сегмент надо сделать доступным только для чтения (например, если его переменные не планируется изменять), то после слова segment указывается слово readonly.
    После выравнивания размещаются инструкции или определения данных. Завершается сегмент также именем сегмента с оператором ends.
    Например, перепишем предыдущтй пример, используя сегменты:
    Код (ASM):
    1. dataSeg segment align(32)
    2.  temps qword 1, 2, 3
    3.  align 32
    4.  nums qword 11, 22, 33, 44
    5.  nums_copy qword 4 dup(?)
    6. dataSeg ends
    7. .code
    8. main proc
    9.  vmovapd ymm0, nums
    10.  vmovapd nums_copy, ymm0
    11.  mov rax, nums_copy
    12.  ret
    13. main endp
    14. end
    Здесь сегмент называется dataSeg. Он вырованен по 32 байтам (align(32)), что гарантирует, что первая переменная будет выровнена по 32 байтам. Кроме того, внутри сегмента мы можем использовать директиву align 32, чтобы также выровнять переменную nums по 32 байтам. Но опять же в данном случае, если порядок данных в сегменте не важен, то мы могли бы перегруппировать данные, чтобы избежать ненужного выравнивания:
    Код (ASM):
    1. dataSeg segment align(32)
    2.  nums dword 12, 22, 33, 44, 55, 66, 77, 88
    3.  nums_copy  dword 8 dup(?)
    4.  temps dword 1, 2, 3, 4
    5. dataSeg ends
    Копирование без выравнивания
    Если нельзя гарантировать, что переменные-операнды выровнены по 16- или 32-байтовой адресной границе, то для копирования данных между регистрами XMM или YMM и памятью можно использовать ряд других инструкций:
    • (v)movups: копирование невыровненных 4-байтных чисел
    • (v)movupd: копирование невыровненных 8-байтных чисел
    • (v)movdqu: копирование невыровненного 16-байтного числа
    Хотя считается, что эти инструкции работают в целом медленнее, чем их аналоги для выровненных данных.
     
    Последнее редактирование: 31 окт 2026
    Marylin нравится это.
  8. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Копирование чисел с плавающей точкой

    Отдельный набор инструкций предназначен специально для копирования чисел с плавающей точкой как одинарной, так и двойной точности.
    (v)movlps и (v)movlpd
    Инструкции (v)movlps и (v)movlpd копирует данные в младшие 64 бита регистра или из 64 младших 64 бит регистра:
    • movlps xmm, mem64
    • movlps mem64, xmm
    • vmovlps xmm, xmm, mem64
    • vmovlps mem64, xmm
    Первая форма инструкции movlps копирует пару значений с плавающей точкой одинарной точности в две первые 32-битные дорожки регистра XMM. Старшие 64 бита при этом остаются без изменений.
    Вторая форма movlps копирует 64 бита первых 2 дорожек регистра XMM в указанную переменную. Функционально это эквивалентно инструкциям movq или movsd (поскольку они копируют 64 бита в память), хотя эта инструкция может быть немного быстрее, если младшие 64 бита регистра XMM на самом деле содержат два числа с плавающей точкой одинарной точности
    Инструкция vmovlps имеет три операнда: целевой регистр XMM, исходный регистр XMM и 64-разрядную переменную. Эта инструкция копирует два значения одинарной точности из переменной в младшие 64 бита целевого регистра XMM и старшие 64 бита исходного регистра (которые также содержат два значения одинарной точности) в старшие 64 бита целевого регистра.
    Как и movsd, инструкция movlpd копирует младшие 64 бита (64-разрядное число с плавающей точкой) из второго операнда в младшие 64 бита операнда назначения. Разница в том, что инструкция movlpd не расширяет значение нулями при перемещении данных из памяти в регистр XMM, тогда как инструкция movsd расширяет значение нулями до старших 64 бит целевого регистра XMM, а также копируют старшие 64 бита регистра XMM в переменную:
    movhps и movhpd
    Инструкции movhps и movhpd копируют 64-битную переменную (либо два числа с плавающей точкой одинарной точности в случае movhps, либо одно число двойной точности в случае movhpd) в старшие 64 бита регистра XMM и обратно - из старших 64 битов XMM в 64-разрядную переменную.
    • movhps xmm, mem64
    • movhps mem64, xmm
    • movhpd xmm, mem64
    • movhpd mem64, xmm
    Эти инструкции не влияют на биты со 128 по 255 регистров YMM.
    С помощью последовательного использования инструкций movlps и movhps можно загрузить четыре 32-разрядных числа с плавающей точкой в регистр XMM, получая значения из двух разных источников (аналогично можно использовать инструкции movlpd и movhpd для загрузки из двух разных источников двух 64-разрядных чисел в один регистр XMM). И наоборот, можно использовать данные инструкции, чтобы разделить векторный результат пополам и сохранить две половины в разных переменных:
    Код (ASM):
    1. .data
    2.  floats real4 1.0, 2.0
    3.  doubles real8 1.0
    4. .code
    5. main proc
    6.  movlps xmm0, qword ptr floats  ; в младших 64 битах XMM0 - вектор floats
    7.  movhpd xmm0, doubles  ; в старших 64 битах XMM0 - вектор doubles
    8.  ret
    9. main endp
    10. end
    vmovhps и vmovhpd
    Отдельно стоит сказать об инструкциях vmovhps и vmovhpd, которые не являются простыми расширениями AVX для выше рассмотренных инструкций movhpsи movhpd
    • vmovhps xmm, xmm, mem64
    • vmovhps mem64, xmm
    • vmovhpd xmm, xmm, mem64
    • vmovhpd mem64, xmm
    При загрузке данных в регистр XMM эти инструкции принимают два операнда, из которых берутся данные. Инструкции загружают все 128 бит (четыре числа с одинарной точностью или два числа с двойной точностью) в регистр назначения XMM. Данные для старших 64 бит регистра поступают из переменной, а для младших 64 бит - из второго операнда-другого регистра XMM. Эти инструкции также расширяют значение нулями до старших 128 бит (перекрывающегося) регистра YMM.
    При сохранении данных в 64-разрядной переменной инструкции vmovhps и vmovhpd ведут себя аналогично инструкциям movhps и movhpd.
    movlhps и vmovlhps
    Инструкция movlhps копирует два 32-битных значения с плавающей точкой из младших 64 бит исходного регистра XMM в старшие 64 бита целевого регистра XMM. Она оставляет младшие 64 бита целевого регистра XMM и старшие 128 бит перекрывающего регистра YMM без изменений.
    • movlhps xmm, xmm
    • vmovlhps xmm, xmm, xmm
    Инструкция vmovlhps принимает три операнда: первый операнд - целевой регистр, а второй и третий операнд - регистры XMM. из которых берутся данные. vmovlhps копирует младшие 64 бита из второго операнда в младшие 64 бита первого операнда и младшие 64 бита из тертьего операнда в старшие 64 бита первого операнда. Инструкция расширяет нулями Старшие 128 бит перекрывающегося регистра YMM.
    Данные инструкции не поддерживают работу с переменными и работают только с 32-разрядными числами с плавающей точкой.
    movhlps и vmovhlps
    Инструкции movhlps копирует два 32-битных числа с плавающей точкой из старших 64 бит исходного операнда в младшие 64 бита целевого регистра, оставляя старшие 64 бита целевого регистра без изменения.
    • movhlps xmmdest, xmmsrc
    Инструкция vmovhlps принимает три операнда:
    • vmovhlps xmmdest, xmmsrc1, xmmsrc2
    Эта инструкция копирует старшие 64 бита второго операнда в старшие 64 бита первого операнда и старшие 64 бита третьего операнда в младшие 64 бита первого операнда. Старшие 128 бит наложенного регистра YMM дополняются нулями.
    Данные инструкции не поддерживают работу с переменными и работают только с 32-разрядными числами с плавающей точкой.
    (v)movshdup и (v)movsldup
    Инструкция movshdup копирует два 32-битных числа с плавающей точкой одинарной точности с нечетным индексом из исходного операнда (переменной или регистра XMM) и дублирует каждое число в целевом регистре XMM. Числа по четным индексам в исходном операнде игнорируются. Инструкция vmovshdup работает аналогично, только также может принимать регистры YMM - в этом случае копируются четыре 32-битных числа с плавающей точкой.
    • movshdup xmmdest, mem128/xmmsrc
    • vmovshdup xmmdest, mem128/xmmsrc
    • vmovshdup ymmdest, mem256/ymmsrc
    [​IMG]
    Инструкция movsldup копирует и дублирует в целевом регистре XMM два 32-битных числа с плавающей точкой, которые располагаются на четных индексах в исходном регистре XMM или переменной. Аналогичным образом инструкция vmovsldup копирует и дублирует четыре 32-разрядных числа, которые располагаются на четных индексах в исходном регистре YMM или переменной.
    • movsldup xmmdest, mem128/xmmsrc
    • vmovsldup xmmdest, mem128/xmmsrc
    • vmovsldup ymmdest, mem256/ymmsrc
    [​IMG]
    (v)movddup
    Инструкция movddup копирует 64-битные числа с плавающей точкой из младших 64 бит регистра XMM или переменной в младшие 64 бит целевого регистра XMM и затем дублирует это значение в старшие 64 бит целевого регистра XMM. Эта инструкция не влияет на старшие 128 бит перекрывающего регистра YMM.
    • movddup xmmdest, mem64/xmmsrc
    • vmovddup xmmdest, mem64/xmmsrc
    • vmovddup ymmdest, mem256/ymmsrc
    128-битная версия инструкции vmovddup работает так же, как инструкция movddup, за исключением того, что она обнуляет старшие биты целевого регистра YMM. 256-битная версия копирует два 64-битных числа с четными индексами (0 и 2) из исходного регистра или переменной на соответствующие индексы в целевом регистре YMM и дублирует эти значения по нечетным индексам в целевом регистре.
    [​IMG]
    (v)lddqu
    Инструкция (v)lddqu позволяет копировать невыравненное 128- и 256-разрядное значение:
    • lddqu xmmdest, mem128
    • vlddqu xmmdest, mem128
    • vlddqu ymmdest, mem256
     
    Последнее редактирование: 31 окт 2026
    Marylin нравится это.
  9. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Переупорядочивание данных

    Ряд инструкций позволяют переупорядочивать данные внутри регистра XMM/YMM.
    (v)pshufb
    Инструкция pshufb позволяет перемешать данные в соответствии с индексами:
    pshufb xmmdest, xmmsrc/mem128
    Первый операнд представляет регистр XMM, байтовые дорожки которого будут переупорядочиваться. Второй операнд (либо регистр XMM, либо 128-битная переменная) представляет собой массив из 16 байтов, которые содержат индексы для перемешивания элементов. Если второй операнд является переменной, он должен быть выровнен по 16-байтовой границе.
    Каждый байт из второго операнда имеет следующую композицию:
    [​IMG]
    Первые 4 бита хранят индекс байта регистра XMM, из которого надо взять данные. 4 бита позволяют закодировать 16 чисел, что достаточно для 16 дорожек. Биты с 4 по 6 игнорируются. Бит 7 управляет перемешиванием: если этот бит содержит 1, то биты индекса дорожки также игнорируются, а в соответствующем байте в регистре XMM сохраняется 0. Если этот бит содержит 0, то инструкция pshufb выполняет операцию перемешивания.
    Инструкция pshufb выполняется для каждой дорожки. Инструкция сначала создает временную копию регистра XMM. Затем для каждого байта индекса (страший бит которых равен 0) инструкция копирует дорожку, указанную в младших 4 битах. Например:
    Код (ASM):
    1. .data
    2.  nums byte 11, 12, 13, 14, 15, 16, 17, 18
    3.  byte  19, 20, 21, 22, 23, 24, 25, 26
    4.  indexes byte 0, 1, 4, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
    5. .code
    6. main proc
    7.  movdqa xmm0, oword ptr nums
    8.  pshufb xmm0, oword ptr indexes
    9.  ret
    10. main endp
    11. end
    Здесь в XMM0 вначале загружается массив из 16 однобайтовых чисел nums. Поскольку инструкция копирования данных movdqa принимает 16-байтное число, то вектор nums приводим к типу oword. С помощью инструкции pshufb перемешиваем данные в XMM0, используя индексы indexes:
    indexes byte 0, 1, 3, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
    Индексация начинаяется с 0, то есть индекс 0 представляет первый элемент в векторе. Например, по индексу 0 в массиве indexes располагается число 0. Это означает, что для этой дорожки данные будут браться из дорожки с индексом 0, то есть по сути из той же самой дорожки. В итоге те данные, которые были в этой дорожке, они и останутся после выполнения инструкции. И так почти для всех дорожек, кроме дорожки с индексом 2. Она хранит число 4. То есть для дорожки с индексом 2 данные будут браться из дорожки с индексом 4.
    [​IMG]
    То есть в итоге в дорожке 2 регистра XMM после выполненния программы будет число 15 (из дорожки 4).
    Чтобы перевернуть данные мы могли бы использовать индексы в обратном порядке:
    Код (ASM):
    1. .data
    2.  nums byte 11, 12, 13, 14, 15, 16, 17, 18
    3.  byte  19, 20, 21, 22, 23, 24, 25, 26
    4.  ; для переворота вектора nums
    5.  reversed byte 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
    6. .code
    7. main proc
    8.  movdqa xmm0, oword ptr nums
    9.  pshufb xmm0, oword ptr reversed
    10.  ret
    11. main endp
    12. end
    Инструкция vpshufb в качестве второго операнда принимает регистр, из которого берутся данные, и использует этот регистр вместо создания копии регистра из первого операнда. Массив индексов передается через третий параметр. Также данная инструкция позволяет указать 256-битные регистры YMM в дополнение к 128-битным регистрам XMM
    vpshufb xmmdest, xmmsrc, xmmindex/mem128
    vpshufb ymmdest, ymmsrc, ymmindex/mem256

    (v)pshufd
    Инструкции pshufd и vpshufd переупорядочивают 32-битные целые числа (dword) в регистрах XMM и YMM аналогично инструкциям (v)pshufb:
    pshufd xmmdest, xmmsrc/mem128, imm8
    vpshufd xmmdest, xmmsrc/mem128, imm8
    vpshufd ymmdest, ymmsrc/mem256, imm8

    Первый операнд представляет целевой регистр, в котором будут храниться перемешанные значения. Второй операнд является источником, из которого инструкция выбирает двойные слова для размещения в целевой регистре (если второй операнд - переменная, то она должна быть выровнена по 16- или 32-байтовой границе). Третий операнд представляет собой 8-разрядное непосредственное значение, которое хранит индексы двойных слов для выбора из второго операнда.
    Третий операнд имеет определенную организацию битов. Определенные биты определяют индекс данных из операнда-источника, которые помещаются в определенную дорожку целевого регистра
    БитыДорожка
    0-10
    2-31
    4-52
    6-73
    Поскольку в данном случае копируются двойные слова (32 бита), то под дорожкой понимаются 32 бита целевого регистра. Так, биты 0-1 определяют двойное слово из операнда-источника, которое помещается в первые 32 бита целевого регистра. Биты 2-3 определяют двойное слово из операнда-источника, которое помещается во вторые 32 бита целевого регистра. Биты 4-5 определяют двойное слово из операнда-источника, которое помещается во третьи 32 бита целевого регистра. Наконец, биты 6 -7 определяют значение, которое помещается во четвертые 32 бита целевого регистра.
    Разница между 128-битными инструкциями pshufd и vpshufd заключается в том, что pshufd оставляет старшие 128 бит регистра YMM без изменений, а vpshufd обнуляет их.
    256-битная версия vpshufd (при использовании регистров YMM в качестве исходного и целевого операндов) также использует 8-битный непосредственный операнд в качестве значения индекса. Каждое 2-битное значение индекса манипулирует двумя значениями dword в регистрах YMM. Биты 0-1 управляют двойными словами 0 и 4, биты 2-3 управляют двойными словами 1 и 5, биты 4-5 управляют двойными словами 2 и 6, а биты 6-7 управляют двойными словами 3 и 7.
    Пример применения:
    Код (ASM):
    1. .data
    2.  nums0 dword 11, 12, 13, 14
    3.  nums1 dword 21, 22, 23, 24
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  pshufd xmm0, nums1, 000001111b
    8.  ret
    9. main endp
    10. end
    Здесь изначально в регистр XMM0 загружается вектор nums0. С помощью инструкции pshufd заменяем некоторые его элементы числами из вектора nums1. Индексы определяются непосредственным операндом 000001111b, который задан в бинарной форме. Где мы видим, что для дорожки с индексом 0 и 1 регистра XMM0 будет браться число dword по индексу 3 из nums1, для дорожки 2 и 3 - число по индексу 0.
    (v)pshuflw и (v)pshufhw
    Инструкции (v)pshuflw и (v)pshufhw обеспечивают перемешивание 16-разрядных чисел в регистре XMM или YMM:
    pshuflw xmmdest, xmmsrc/mem128, imm8
    pshufhw xmmdest, xmmsrc/mem128, imm8
    vpshuflw xmmdest, xmmsrc/mem128, imm8
    vpshufhw xmmdest, xmmsrc/mem128, imm8
    vpshuflw ymmdest, ymmsrc/mem256, imm8
    vpshufhw ymmdest, ymmsrc/mem256, imm8

    128-битные варианты (v)pshuflw копируют старшие 64 бита операнда-источника в те же позиции в целевом регистре. Затем с помощью третьего операнда индекса - imm8 они выбирают 16-битные дорожки от 0 до 3 в младших 64 битах операнде-источнике, значения которых копируются в младшие 16-битные дорожки целевого регистра. Например, если младшие 2 бита операнда imm8 равны 10b, то инструкция pshuflw копирует дорожку 2 из источника в дорожку 0 целевого регистра. При этом pshuflw не изменяет старшие 128 бит перекрывающего регистра YMM, тогда как vpshuflw обнуляет эти биты.
    256-битная инструкция vpshuflw (с целевым регистром YMM) также копирует 16-битное число из дорожки в источнике, на которую указывает индексу в imm8. Но это число копируется одновременно в определенную дорожку в старших 128 битах и в младших 128 битах целевого регистра YMM.
    128-битные варианты (v)pshufhw копируют младшие 64 бита операнда-источника в те же позиции в целевом регистре. Затем с помощью операнда индекса imm8 они выбирают 16-битные дорожки от 4 до 7 в старших 64 битах операнда-источника, значения которых копируются в старшие 16-битные дорожки целевого регистра.
    256-битная инструкция vpshufhw также копирует 16-битное число из дорожки в источнике, на которую указывает индексу в imm8. Но это число копируется одновременно в определенную дорожку в старших 128 битах и в младших 128 битах целевого регистра YMM.
    shufps и shufpd
    Инструкции shufps и shufpd копируют соответственно 32- и 64-разрядные числа с плавающей точкой из операнда-источника и помещают их в указанные позиции в целевом регистре. Третий операнд определяет индексы дорожек операнда-источника, которые копируются в соответствующие дорожки целевого регистра.
    shufps xmmdest, xmmsrc2/mem128, imm8
    shufpd xmmdest, xmmsrc2/mem128, imm8

    Третий операнд (imm8) представляет массив из четырех 2-битных чисел. Его биты 0 и 1 выбирают 32-битное число с плавающей точкой из одной из четырех дорожек первого операнда для сохранения в дорожку 0 целевого регистра, которым также является первый операнд.
    Аналогично биты 2 и 3 выбирают 32-битное число из одной из четырех дорожек первого операнда для сохранения в дорожку 1 первого операнда.
    Биты 4 и 5 выбирают 32-битное число из одной из четырех дорожек второго операнда для сохранения в дорожке 2 первого операнда.
    Биты 6 и 7 выбирают 32-битное число из одной из четырех дорожек второго операнда для сохранения в дорожку 3 первого операнда.
    Рассмотрим небольшой пример:
    Код (ASM):
    1. .data
    2.  nums0 dword 11, 12, 13, 14
    3.  nums1 dword 21, 22, 23, 24
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  shufps xmm0, xmm1, 11100100b
    9.  ret
    10. main endp
    11. end
    В XMM0 и XMM1 загружаются соответственно векторы nums0 и nums1. Инструкция shufps для перемешивания данных применяет индексный операнд 11100100b. Таким образом, сопоставление значений будет выглядеть следующим образом:
    • Биты 00: в XMM0[0-31] копируются данные из XMM0[0-31] (по сути остаются начальные данные)
    • Биты 01: в XMM0[32-63] копируются данные из XMM0[32-63]
    • Биты 10: в XMM0[64-95] копируются данные из XMM1[64-95]
    • Биты 11: в XMM0[96-127] копируются данные из XMM0[96-127]
    Таким образом, в итоге в регистре XMM0 окажется вектор 11, 12, 23, 24
    Инструкция shufpd работает аналогично, только перемешивает 64-битные числа. Соответственно индексы в третьем операнде указывают на индексы 64-битных дорожек. Поскольку в регистре XMM могут храниться только два 64-разрядных значения, для выбора дорожки требуется только один бит - 0 или 1. Поэтому биты со 2 по 7 в операнде imm8 игнорируются. Бит 0 операнда imm8 выбирает одну из двух 64-битных дорожек первого операнда для компирования в дорожку 0 целевого регистра (он же первый операнд). Бит 1 операнда imm8 выбирает одну из двух 64-битных дорожек второго операнда для компирования в дорожку 1 целевого регистра. Например:
    Код (ASM):
    1. .data
    2.  nums0 qword 11, 12
    3.  nums1 qword 21, 22
    4. .code
    5. main proc
    6.  movapd xmm0, nums0
    7.  movapd xmm1, nums1
    8.  shufpd xmm0, xmm1, 01b
    9.  ret
    10. main endp
    11. end
    Здесь после выполнения программы в регистре XMM0 будет храниться вектор 12, 21
    vshufps и vshufpd
    Инструкции vshufps и vshufpd аналогичны инструкциям shufps и shufpd. Они позволяют перемешивать значения в 128-битных регистрах XMM или 256-битных регистрах YMM. Инструкции vshufps и vshufpd имеют четыре операнда:
    vshufps xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    vshufpd xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    vshufps ymmdest, ymmsrc1, ymmsrc2/mem256, imm8
    vshufpd ymmdest, ymmsrc1, ymmsrc2/mem256, imm8

    первый операнд - целевой регистр XMM или YMM, в который копируются данные. Второй и третий операнды - два источника (второй операнд должен быть регистром XMM или YMM, а третий операнд может быть регистром XMM или YMM или 128- или 256-битной переменной). Четверный операнд - индексный операнд imm8.
    128-битные версии инструкций vshufps и vshufpd аналогичны инструкциям shufps и shufpd за тем исключением, что для младших 64 бит целевого регистра данные копируются из второго операнда, а для старших 64 бит - из третьего операнда.
    Для 256-битной инструкции vshufps биты 0-1 и 2-3 операнда imm8 определяют индексы дорожек второго операнда, из которых берутся данные для 32-битных дорожек 0 и 1 целевого регистра XMM. А биты 4-5 и 6-7 операнда imm8 определяют индексы дорожек третьего операнда, из которых берутся данные для дорожек 2 и 3 целевого регистра XMM. Для второй 128-битной половины целевого регистра YMM процесс повторяется.
    [​IMG]
    Для 256-битной инструкции vshufpd бит 0 операнда imm8 определяет индекс дорожки второго операнда, из которой берется значение для 64-битной дорожки 0 целевого регистра XMM. А бит 1 операнда imm8 определяет индекс дорожки третьего операнда, из которой берется значение для 64-битной дорожки 1 целевого регистра XMM.. Для второй 128-битной половины целевого регистра YMM процесс повторяется.
    [​IMG]
     
    Последнее редактирование: 31 окт 2026
  10. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Логические операции SSE/AVX

    Расширения SSE/AVX предоставляют следующие поразрядные логические операции:
    • andpd: логическое умножение dest = dest and source (128-разрядные операнды)
    • vandpd: логическое умножение dest = source1 and source2 (128- или 256-разрядные операнды)
    • andnpd: логическое умножение с отрицанием (NAND) dest = dest and ~source (128-разрядные операнды)
    • vandnpd: логическое умножение с отрицанием (NAND) dest = source1 and ~source2 (128- или 256-разрядные операнды)
    • orpd: логическое сложение dest = dest | source (128-разрядные операнды)
    • vorpd: логическое сложение dest = source1 | source2 (128- или 256-разрядные операнды)
    • xorpd: операция XOR dest = dest ^ source (128-разрядные операнды)
    • vxorpd: операция XOR dest = source1 ^ source2 (128- или 256-разрядные операнды)
    Синтаксис инструкций:
    • andpd xmmdest, xmmsrc/mem128
    • vandpd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vandpd ymmdest, ymmsrc1, ymmsrc2/mem256
    • andnpd xmmdest, xmmsrc/mem128
    • vandnpd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vandnpd ymmdest, ymmsrc1, ymmsrc2/mem256
    • orpd xmmdest, xmmsrc/mem128
    • vorpd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vorpd ymmdest, ymmsrc1, ymmsrc2/mem256
    • xorpd xmmdest, xmmsrc/mem128
    • vxorpd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vxorpd ymmdest, ymmsrc1, ymmsrc2/mem256
    Инструкции SSE (без префикса v) оставляют старшие биты в целевом регистре YMM без изменений. Инструкции AVX (с префиксом v), которые имеют 128-битные операнды, заполняют старшие 128 бит регистра YMM нулями. Если третий операнд является переменной, он должен быть выровнен по соответствующей границе (например, 16 байтов для значений mem128 и 32 байта для значений mem256). Невыполнение этого требования приведет к ошибке выравнивания памяти во время выполнения.
    Пример применения:
    Код (ASM):
    1. .data
    2.  nums0 dword 0, 1, 0, 1
    3.  nums1 dword 0, 1, 1, 0
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  andpd xmm0, xmm1  ; XMM0 = 0, 1, 0, 0
    9.  ret
    10. main endp
    11. end
    Здесь в регистры XMM0 и XMM1 загружаются соответственно векторы nums0 и nums1. Далее к элементам этих векторов применяется логическая операции AND, которая возвращает 1, если только обы разряда двух операндов равны 1. То есть мы получим следующие вычисления:
    0, 1, 0, 1
    *0, 1, 1, 0
    =0, 1, 0, 0
    В итоге в регистре XMM0 будет содержаться вектор 0, 1, 0, 0
     
    Последнее редактирование: 31 окт 2026
  11. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Операции сдвига SSE/AVX

    Расширения SSE/AVX поддерживают инструкции логического и арифметического сдвига:
    • pslldq: сдвигает данные в регистре XMM влево на количество байтов, указанное в операнде imm8. В освободившиеся младшие байты помещаются нули.
      • pslldq xmmdest, imm8
    • vpslldq: берет значение из второго операнда-регистра XMM или YMM, сдвигает это значение влево на количество байт, указанное в третьем операнде. Затем сохраняет результат в регистре из первого операнда.
      • vpslldq xmmdest, xmmsrc, imm8
      • vpslldq ymmdest, ymmsrc, imm8
      128-битный вариант инструкция также заполняет нулями биты со 128 по 255 регистра YMM.
    • psrldq: сдвигает данные в регистре XMM вправо на количество байтов, указанное в операнде imm8. В освободившиеся старшие байты помещаются нули.
      • psrldq xmmdest, imm8
    • vpsrldq: сдвигает вправл значение из второго операнда-регистра XMM или YMM на количество байт, указанное в третьем операнде. Затем сохраняет результат в первом операнде.
      • vpsrldq xmmdest, xmmsrc, imm8
      • vpsrldq ymmdest, ymmsrc, imm8
    Стоит отметить, что эти инструкции сдвигают по байтам (то есть как минимум можно сдвинуть 8 разрядов). Но также есть ряд инструкций, которые сдвигают по отдельным битам причем не весь регистр в целом, а отдельные элементы в векторе в регистре. То есть каждый элемент вектора сдвигается на определенное количество бит. Это инструкции:
    • (v)psllw: сдвигает влево слово (значение word)
    • (v)pslld: сдвигает влево двойное слово (значение dword)
    • (v)psllq: сдвигает влево четверное слово (значение qword)
    • (v)psrlw: сдвигает вправо слово
    • (v)psrld: сдвигает вправо двойное слово
    • (v)psrlq: сдвигает вправо четверное слово
    • (v)psraw: арифметический сдвиг слова вправо
    • (v)psrad: арифметический сдвиг двойного слова вправо
    • (v)psraq: арифметический сдвиг четверного слова вправо
    Синтаксис инструкций на примере (v)psllw (остальные инструкции принимают те же операнды)
    • psllw xmmdest, imm8
    • psllw xmmdest, xmmsrc/mem128
    • vpsllw xmmdest, xmmsrc, imm8
    • vpsllw xmmdest, xmmsrc, mem128
    • vpsllw ymmdest, ymmsrc, imm8
    • vpsllw ymmdest, ymmsrc, xmm/mem128
    В инструкции с двумя операндами первый операнд представляет сдвигаемое значение, а второй операнд указывает количество битов для сдвига. (это либо 8-битная непосредственная константа, либо регистр XMM, либо в 128-битная переменная).
    В инструкции с тремя операндами второй операнд представляет сдвигаемое значение, а третий - количество битов для сдвига. Результат сдвига помещается в первый операнд. Исходный регистр остается неизменным (если, конечно, инструкция не указывает один и тот же регистр для исходного и целевого операндов).
    Пример:
    Код (ASM):
    1. .data
    2.  nums0 dword 1, 2, 4, 8
    3. .code
    4. main proc
    5.  movaps xmm0, nums0
    6.  pslld xmm0, 2  ; сдвигаем влево на 2 бита
    7.  ret
    8. main endp
    9. end
    Здесь сдвигаются влево на 2 разряда числа dword. Фактически каждое число будет умножено на 4. В итоге в XMM0 будет вектор 4, 8, 16, 32
     
    Последнее редактирование: 31 окт 2026
  12. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Сложение с помощью инструкций SSE/AVX

    Для сложения соответствующих элементов векторов применяются следующие инструкции:
    • paddb: сложение байтов в 16 дорожках
    • vpaddb: сложение байтов в 16 дорожках (для 128-битной версии) и в 32 дорожках (для 256-битной версии)
    • paddw: сложение слов (значений word) в 8 дорожках
    • vpaddw: сложение слов в 8 дорожках (для 128-битной версии) и в 16 дорожках (для 256-битной версии)
    • paddd: сложение двойных слов (значений dword) в 4 дорожках
    • vpaddd: сложение двойных слов в 4 дорожках (для 128-битной версии) и в 8 дорожках (для 256-битной версии)
    • paddq: сложение четверных слов (тип qword) в 2 дорожках
    • vpaddq: сложение четверных слов в 2 дорожках (128-битной версии) и в 4 дорожках (для 256-битной версии)
    Синтаксис инструкций:
    • paddb xmmdest, xmmsrc/mem128
    • vpaddb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddb ymmdest, ymmsrc1, ymmsrc2/mem256
    • paddw xmmdest, xmmsrc/mem128
    • vpaddw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddw ymmdest, ymmsrc1, ymmsrc2/mem256
    • paddd xmmdest, xmmsrc/mem128
    • vpaddd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddd ymmdest, ymmsrc1, ymmsrc2/mem256
    • paddq xmmdest, xmmsrc/mem128
    • vpaddq xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddq ymmdest, ymmsrc1, ymmsrc2/mem256
    Инструкции с двумя операндами складывают соответствующие дорожки двух операндов и результат помещают в первый операнд. Инструкции с тремя операндами складывают второй и третий операнды и результат помещают в первый. Пример сложения:
    Код (ASM):
    1. .data
    2.  nums0 dword 1, 2, 4, 8
    3.  nums1 dword 2, 3, 5, 9
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  paddd xmm0, xmm1  ; XMM0 = XMM0 + XMM1
    9.  ret
    10. main endp
    11. end
    В данном случае в регистре XMM0 окажется вектор, элементы которого представляют сумму соответствующих дорожек двух регистров, то есть вектор 3, 5, 9, 17
    Эти инструкции не влияют ни на какие флаги и, таким образом, не указывают, когда во время выполнения этих инструкций происходит переполнение (со знаком или без знака). Если перенос происходит во время добавления, перенос теряется. Это может привести к неправильным результатам при расчетах, например:
    Код (ASM):
    1. .data
    2.  nums0 sword -32768, ..........
    3.  nums1 sword -10, ...........
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  paddw xmm0, xmm1  ; XMM0 = XMM0 + XMM1
    Первый элемент вектора nums0 (-32768) складывается с первым элементом вектора nums1 (-10), результатом будет число 32758. Определенно это не тот результат, который мы бы хотели видеть. Программа сама должна проверять, что складываемые операнды находятся в соответствующем диапазоне. Но дополнительно SSE/AVX предоставляют инструкции, которые используют так называемую "арифметику насыщения" (saturation arithmetic). Арифметика насыщения хорошо работает для обработки мультимедиа - аудио, видео, изображений. Это следующие инструкции:
    • paddsb: сложение байтов со знаком в 16 дорожках
    • vpaddsb: сложение байтов со знаком в 16 дорожках
    • vpaddsb: сложение байтов со знаком в 32 дорожках
    • paddsw: сложение слов со знаком в 8 дорожках
    • vpaddsw: сложение слов со знаком в 8 дорожках
    • vpaddsw: сложение слов со знаком в 16 дорожках
    • paddusb: сложение беззнаковых байтов в 16 дорожках
    • vpaddusb: сложение беззнаковых байтов в 16 дорожках
    • vpaddusb: сложение беззнаковых байтов в 32 дорожках
    • paddusw: сложение беззнаковых слов в 8 дорожках
    • vpaddusw: сложение беззнаковых слов в 8 дорожках
    • vpaddusw: сложение беззнаковых слов в 16 дорожках
    Синтаксис инструкций:
    • paddsb xmmdest, xmmsrc/mem128
    • vpaddsb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddsb ymmdest, ymmsrc1, ymmsrc2/mem256
    • paddsw xmmdest, xmmsrc/mem128
    • vpaddsw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddsw ymmdest, ymmsrc1, ymmsrc2/mem256
    • paddusb xmmdest, xmmsrc/mem128
    • vpaddusb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddusb ymmdest, ymmsrc1, ymmsrc2/mem256
    • paddusw xmmdest, xmmsrc/mem128
    • vpaddusw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpaddusw ymmdest, ymmsrc1, ymmsrc2/mem256
    Для сложения без знака переполнение усекается до максимально возможного значения, которое может выдержать размер инструкции. Например, если сложение двух байтовых значений превышает 0FFh, арифметика насыщения дает 0FFh — максимально возможное 8-битное значение без знака. Аналогично, если при вычитании произойдет потеря значимости (underflow), то результат округляется до 0. Для арифметики насыщения со знаком отсечение происходит при наибольшем положительном и наименьшем отрицательном значениях (например, для чисел размером с 1 байт это 7Fh/+127 для положительных значений и 80h/–128 для отрицательных значений). Пример использования:
    Код (ASM):
    1. .data
    2.  nums0 sword -32768, 2, -4, 8, -16, 32, -64, 128
    3.  nums1 sword -10, -3, 5, -9, 15, -31, 55, -112
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  paddsw xmm0, xmm1  ; XMM0 = XMM0 + XMM1
    9.  ; XMM0 = -32768, -1, 1, -1, -1, 1, -9, 16
    10.  ret
    11. main endp
    12. end
    В данном случае результат сложения первых элементов векторов - -32768 + -10 выходит за минимальные границы диапазона типа sword, но теперь минимальное значение - -32768, что, возможно, в каких ситуациях может быть приемлимым результатом.
    Горизонтальное сложение
    Расширения e SSE/AVX также предоставляют инструкции для так называемого "горизонтального сложения":
    • (v)phaddw: сложение 16-битных чисел
    • (v)phaddd: сложение 32-битных чисел
    • (v)phaddsw: сложение 16-битных чисел с насыщением
    Они имеют аналогичный синтаксис:
    • phaddw xmmdest, xmmsrc/mem128
    • vphaddw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vphaddw ymmdest, ymmsrc1, ymmsrc2/mem256
    • phaddd xmmdest, xmmsrc/mem128
    • vphaddd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vphaddd ymmdest, ymmsrc1, ymmsrc2/mem256
    • phaddsw xmmdest, xmmsrc/mem128
    • vphaddsw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vphaddsw ymmdest, ymmsrc1, ymmsrc2/mem256
    Инструкции горизонтального сложения складывают соседние слова или двойные слова обоих операндов и сохраняют сумму в дорожке регистра из первого операнда. В случае с инструкцией phaddw сложение будет выполняться следующим образом:
    temp[0-15] = xmmdest[0-15] + xmmdest[16-31]
    temp[16-31] = xmmdest[32-47] + xmmdest[48-63]
    temp[32-47] = xmmdest[64-79] + xmmdest[80-95]
    temp[48-63] = xmmdest[96-111] + xmmdest[112-127]
    temp[64-79] = xmmsrc/mem128[0-15] + xmmsrc/mem128[16-31]
    temp[80-95] = xmmsrc/mem128[32-47] + xmmsrc/mem128[48-63]
    temp[96-111] = xmmsrc/mem128[64-79] + xmmsrc/mem128[80-95]
    temp[112-127] = xmmsrc/mem128[96-111] + xmmsrc/mem128[112-127]
    xmmdest = temp
    4 слова из младших 64 битов результата являются суммой соседних слов первого операнда, а 4 слова из старших 64 бит результата - сумма соседних слов из второго операнда. Инструкция phaddw не затрагивает старшие 128 бит перекрывающего регистра YMM.
    Инструкция vphaddw складывает слова из второго и третьего операнда и результат помещает в первый. При этом старшие 128 бит перекрывающего регистра YMM заполняются нулями:
    xmmdest[0-15] = xmmsrc1[0-15] + xmmsrc1[16-31]
    xmmdest[16-31] = xmmsrc1[32-47] + xmmsrc1[48-63]
    xmmdest[32-47] = xmmsrc1[64-79] + xmmsrc1[80-95]
    xmmdest[48-63] = xmmsrc1[96-111] + xmmsrc1[112-127]
    xmmdest[64-79] = xmmsrc2/mem128[0-15] + xmmsrc2/mem128[16-31]
    xmmdest[80-95] = xmmsrc2/mem128[32-47] + xmmsrc2/mem128[48-63]
    xmmdest[96-111] = xmmsrc2/mem128[64-79] + xmmsrc2/mem128[80-95]
    xmmdest[111-127] = xmmsrc2/mem128[96-111] + xmmsrc2/mem128[112-127]
    256-разрядная версия инструкции vphaddw выполняет вычисления следующим образом:
    ymmdest[0-15] = ymmsrc1[16-31] + ymmsrc1[0-15]
    ymmdest[16-31] = ymmsrc1[48-63] + ymmsrc1[32-47]
    ymmdest[32-47] = ymmsrc1[80-95] + ymmsrc1[64-79]
    ymmdest[48-63] = ymmsrc1[112-127] + ymmsrc1[96-111]
    ymmdest[64-79] = ymmsrc2[16-31] + ymmsrc2[0-15]
    ymmdest[80-95] = ymmsrc2[48-63] + ymmsrc2[32-47]
    ymmdest[96-111] = ymmsrc2[80-95] + ymmsrc2[64-79]
    ymmdest[112-127] = ymmsrc2[112-127] + ymmsrc2[96-111]
    ymmdest[128-143] = ymmsrc1[144-159] + ymmsrc1[128-143]
    ymmdest[144-159] = ymmsrc1[176-191] + ymmsrc1[160-175]
    ymmdest[160-175] = ymmsrc1[208-223] + ymmsrc1[192-207]
    ymmdest[176-191] = ymmsrc1[240-255] + ymmsrc1[224-239]
    ymmdest[192-207] = ymmsrc2[144-159] + ymmsrc2[128-143]
    ymmdest[208-223] = ymmsrc2[176-191] + ymmsrc2[160-175]
    ymmdest[224-239] = ymmsrc2[208-223] + ymmsrc2[192-207]
    ymmdest[240-255] = ymmsrc2[240-255] + ymmsrc2[224-239]
    Горизонтальное сложение двойных слов с помощью инструкции phaddd:
    temp[0-31] = xmmdest[0-31] + xmmdest[32-63]
    temp[32-63] = xmmdest[64-95] + xmmdest[96-127]
    temp[64-95] = xmmsrc/mem128[0-31] + xmmsrc/mem128[32-63]
    temp[96-127] = xmmsrc/mem128[64-95] + xmmsrc/mem128[96-127]
    xmmdest = temp
    Сложение с помощью 128-битной инструкции vphaddd
    xmmdest[0-31] = xmmsrc1[0-31] + xmmsrc1[32-63]
    xmmdest[32-63] = xmmsrc1[64-95] + xmmsrc1[96-127]
    xmmdest[64-95] = xmmsrc2/mem128[0-31] + xmmsrc2/mem128[32-63]
    xmmdest[96-127] = xmmsrc2/mem128[64-95] + xmmsrc2/mem128[96-127]
    (ymmdest[128-255] = 0)
    Сложение с помощью 256-битной инструкции vphaddd
    ymmdest[0-31] = ymmsrc1[32-63] + ymmsrc1[0-31]
    ymmdest[32-63] = ymmsrc1[96-127] + ymmsrc1[64-95]
    ymmdest[64-95] = ymmsrc2/mem128[32-63] + ymmsrc2/mem128[0-31]
    ymmdest[96-127] = ymmsrc2/mem128[96-127] + ymmsrc2/mem128[64-95]
    ymmdest[128-159] = ymmsrc1[160-191] + ymmsrc1[128-159]
    ymmdest[160-191] = ymmsrc1[224-255] + ymmsrc1[192-223]
    ymmdest[192-223] = ymmsrc2/mem128[160-191] + ymmsrc2/mem128[128-159]
    ymmdest[224-255] = ymmsrc2/mem128[224-255] + ymmsrc2/mem128[192-223]
    Если при горизонтальном сложеним с помощью инструкций (v)phaddw и (v)phaddd происходит переполнение, то оно просто игнорируется. При горизонтальном сложении с насыщением с помощью phaddsw любое (положительное) переполнение приводит к значению 7FFFh, независимо от фактического результата. Аналогично, любое отрицательное значение потери значимости приводит к значению 8000h.
     
    Последнее редактирование: 31 окт 2026
  13. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Вычитание с помощью инструкций SSE/AVX

    Для вычитания соответствующих элементов векторов применяются следующие инструкции:
    • psubb: вычитание байтов в 16 дорожках
    • vpsubb: вычитание байтов в 16 дорожках (для 128-битной версии) и в 32 дорожках (для 256-битной версии)
    • psubw: вычитание слов (значений word) в 8 дорожках
    • vpsubw: вычитание слов в 8 дорожках (для 128-битной версии) и в 16 дорожках (для 256-битной версии)
    • psubd: вычитание двойных слов (значений dword) в 4 дорожках
    • vpsubd: вычитание двойных слов в 4 дорожках (для 128-битной версии) и в 8 дорожках (для 256-битной версии)
    • psubq: вычитание четверных слов (тип qword) в 2 дорожках
    • vpsubq: вычитание четверных слов в 2 дорожках (128-битной версии) и в 4 дорожках (для 256-битной версии)
    Синтаксис инструкций:
    • psubb xmmdest, xmmsrc/mem128
    • vpsubb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubb ymmdest, ymmsrc1, ymmsrc2/mem256
    • psubw xmmdest, xmmsrc/mem128
    • vpsubw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubw ymmdest, ymmsrc1, ymmsrc2/mem256
    • psubd xmmdest, xmmsrc/mem128
    • vpsubd xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubd ymmdest, ymmsrc1, ymmsrc2/mem256
    • psubq xmmdest, xmmsrc/mem128
    • vpsubq xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubq ymmdest, ymmsrc1, ymmsrc2/mem256
    Инструкции с двумя операндами вычитают из первого операнда соответствующие дорожки второго операнда и результат помещают в первый операнд. Инструкции с тремя операндами вычитают из второго соответствующие дорожки третьего операнда и результат помещают в первый. Пример вычитания:
    Код (ASM):
    1. .data
    2.  nums0 dword 1, 2, 4, 8
    3.  nums1 dword 2, 3, 5, 9
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  psubd xmm0, xmm1  ; XMM0 = XMM0 - XMM1
    9.  ret
    10. main endp
    11. end
    Инструкции вычитания не влияют ни на какие флаги, и любая информация о переносе, заимствовании, переполнении или недостатке будет потеряна. Эти инструкции вычитают второй операнд-источник из первого операнда-источника (который также является операндом-назначением для инструкций только для SSE) и сохраняют результат в операнде-назначении.
    И аналогично сложению расширения SSE/AVX предоставляют инструкции для вычитания с насыщением:
    • psubsb: вычитание байтов со знаком в 16 дорожках
    • vpsubsb: вычитание байтов со знаком в 16 дорожках
    • vpsubsb: вычитание байтов со знаком в 32 дорожках
    • psubsw: вычитание слов со знаком в 8 дорожках
    • vpsubsw: вычитание слов со знаком в 8 дорожках
    • vpsubsw: вычитание слов со знаком в 16 дорожках
    • psubusb: вычитание беззнаковых байтов в 16 дорожках
    • vpsubusb: вычитание беззнаковых байтов в 16 дорожках
    • vpsubusb: вычитание беззнаковых байтов в 32 дорожках
    • psubusw: вычитание беззнаковых слов в 8 дорожках
    • vpsubusw: вычитание беззнаковых слов в 8 дорожках
    • vpsubusw: вычитание беззнаковых слов в 16 дорожках
    Синтаксис инструкций:
    • psubsb xmmdest, xmmsrc/mem128
    • vpsubsb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubsb ymmdest, ymmsrc1, ymmsrc2/mem256
    • psubsw xmmdest, xmmsrc/mem128
    • vpsubsw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubsw ymmdest, ymmsrc1, ymmsrc2/mem256
    • psubusb xmmdest, xmmsrc/mem128
    • vpsubusb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubusb ymmdest, ymmsrc1, ymmsrc2/mem256
    • psubusw xmmdest, xmmsrc/mem128
    • vpsubusw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpsubusw ymmdest, ymmsrc1, ymmsrc2/mem256
    Инструкций для вычитания однобайтовых чисел со знаком насыщают положительное переполнение до 7Fh (+127) и отрицательное переполнение до 80h (-128). Инструкции для вычитания 2-байтных чисел (слов) насыщаются до 7FFFh (+32 767) и до 8000h (-32 768) соответственно. Инструкции насыщения без знака насыщают до 0FFFFh (+65 535) и 0 соответственно.
    Пример использования инструкции вычитания:
    Код (ASM):
    1. .data
    2.  nums0 sword -1, -32768, 5, 10, 20, 40, 80, 160
    3.  nums1 sword -1,  10, 4,  8, 16, 32, 64, 128
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  psubsw xmm0, xmm1  ; XMM0 = XMM0 - XMM1
    9.  ; XMM0 = 0, -32768, 1, 2, 4, 8, 16, 32
    10.  ret
    11. main endp
    12. end
     
    Последнее редактирование: 31 окт 2026
  14. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Умножение с помощью инструкций SSE/AVX


    • pmullw: перемножает слова из 8 дорожек, младшее слово результата помещается в итоговую дорожку
    • vpmullw: перемножает слова из 8 дорожек (128-битная версия) или из 16 дорожек (256-битная версия), младшее слово результата помещается в итоговую дорожку
    • pmulhuw: перемножает беззнаковые слова из 8 дорожек, старшее слово результата помещается в итоговую дорожку
    • vpmulhuw: перемножает слова из 8 дорожек (128-битная версия) или из 16 дорожек (256-битная версия), старшее слово результата помещается в итоговую дорожку
    • pmulhw: перемножает слова со знаком из 8 дорожек, старшее слово результата помещается в итоговую дорожку
    • vpmulhw: перемножает слова из 8 дорожек (128-битная версия) или из 16 дорожек (256-битная версия), старшее слово результата помещается в итоговую дорожку
    • pmulld: перемножает двойные слова (dword) из 4 дорожек, младшее двойное слово результата помещается в итоговую дорожку
      Схематично это выглядит так:
      Temp0[63:0] := SRC1[31:0] * SRC2[31:0]
      Temp1[63:0] := SRC1[63:32] * SRC2[63:32]
      Temp2[63:0] := SRC1[95:64] * SRC2[95:64]
      Temp3[63:0] := SRC1[127:96] * SRC2[127:96]
      DEST[31:0] := Temp0[31:0]
      DEST[63:32] := Temp1[31:0]
      DEST[95:64] := Temp2[31:0]
      DEST[127:96] := Temp3[31:0]
      DEST[MAXVL-1:128] := 0
    • vpmulld: перемножает двойные слова из 4 дорожек (128-битная версия) или из 8 дорожек (256-битная версия), младшее двойное слово результата помещается в итоговую дорожку
      Схематично это выглядит так (для 128-битной версии):
      Temp0[63:0] := SRC1[31:0] * SRC2[31:0]
      Temp1[63:0] := SRC1[63:32] * SRC2[63:32]
      Temp2[63:0] := SRC1[95:64] * SRC2[95:64]
      Temp3[63:0] := SRC1[127:96] * SRC2[127:96]
      DEST[31:0] := Temp0[31:0]
      DEST[63:32] := Temp1[31:0]
      DEST[95:64] := Temp2[31:0]
      DEST[127:96] := Temp3[31:0]
      DEST[MAXVL-1:128] := 0
      Для 256-разрядной версии
      Temp0[63:0] := SRC1[31:0] * SRC2[31:0]
      Temp1[63:0] := SRC1[63:32] * SRC2[63:32]
      Temp2[63:0] := SRC1[95:64] * SRC2[95:64]
      Temp3[63:0] := SRC1[127:96] * SRC2[127:96]
      Temp4[63:0] := SRC1[159:128] * SRC2[159:128]
      Temp5[63:0] := SRC1[191:160] * SRC2[191:160]
      Temp6[63:0] := SRC1[223:192] * SRC2[223:192]
      Temp7[63:0] := SRC1[255:224] * SRC2[255:224]
      DEST[31:0] := Temp0[31:0]
      DEST[63:32] := Temp1[31:0]
      DEST[95:64] := Temp2[31:0]
      DEST[127:96] := Temp3[31:0]
      DEST[159:128] := Temp4[31:0]
      DEST[191:160] := Temp5[31:0]
      DEST[223:192] := Temp6[31:0]
      DEST[255:224] := Temp7[31:0]
      DEST[MAXVL-1:256] := 0
    • vpmullq: перемножает четверные слова из 2 дорожек (128-битная версия) или из 4 дорожек (256-битная версия), младшее четверное слово результата помещается в итоговую дорожку
    Проблема умножения дорожек связана с тем, что при умножении двух n-битных чисел результат надо помещать в дорожку, которая занимает n бит, хотя умножение n × n может дать результат 2×n бит. Таким образом, операция умножения по дорожкам создает проблемы, поскольку теряется переполнение. Подобные инструкции предполагают, что результат может занять 2*n бит, однако в итоговую дорожку регистра помещается только младшие или старшие n бит результата.
    Синтаксис инструкций:
    • pmullw xmmdest, xmmsrc/mem128
    • vpmullw xmmdest, xmmsrc, xmm/mem128
    • vpmullw ymmdest, ymmsrc, ymm/mem256
    • pmulhuw xmmdest, xmmsrc/mem128
    • vpmulhuw xmmdest, xmmsrc, xmm/mem128
    • vpmulhuw ymmdest, ymmsrc, ymm/mem256
    • pmulhw xmmdest, xmmsrc/mem128
    • vpmulhw xmmdest, xmmsrc, xmm/mem128
    • vpmulhw ymmdest, ymmsrc, ymm/mem256
    • pmulld xmmdest, xmmsrc/mem128
    • vpmulld xmmdest, xmmsrc, xmm/mem128
    • vpmulld ymmdest, ymmsrc, ymm/mem256
    • vpmullq xmmdest, xmmsrc, xmm/mem128
    • vpmullq ymmdest, ymmsrc, ymm/mem256
    Ряд инструкций позволяют обойти ограничения на разрядность результата
    • pmuldq: умножает двойные слова (dword) со знаком в 32-битных дорожках 0 и 2 и сохраняет 64-битные результаты в 64-битных дорожках 0 и 1 (они же 32-битные дорожки 0, 1, 2 и 3). Старшие 128 бит перекрывающего регистра YMM остаются без изменений
    • pmuludq: умножает беззнаковые двойные слова в 32-битных дорожках 0 и 2 и сохраняет 64-битные результаты в 64-битных дорожках 0 и 1 (они же 32-битные дорожки 0, 1, 2 и 3). Старшие 128 бит перекрывающего регистра YMM остаются без изменений
    • vpmuldq: 256-битные варианты умножает двойные слова со знаком в 32-битных дорожках 0, 2, 4, 6 и сохраняет 64-битные результаты в 64-битных дорожках 0, 1, 2 и 3 (они же 32-битные дорожки 0, 1, 2, 3 и 4, 5, 6, 7). 128-битная аналогична pmuldq за тем исключением, что старшие 128 бит перекрывающего регистра YMM заполняются нулями
    • vpmuludq: 256-битные варианты умножает беззнаковые двойные слова в 32-битных дорожках 0, 2, 4, 6 и сохраняет 64-битные результаты в 64-битных дорожках 0, 1, 2 и 3 (они же 32-битные дорожки 0, 1, 2, 3 и 4, 5, 6, 7). 128-битная аналогична pmuludq за тем исключением, что старшие 128 бит перекрывающего регистра YMM заполняются нулями
    Синтаксис инструкций:
    • pmuldq xmmdest, xmmsrc/mem128
    • vpmuldq xmmdest, xmmsrc1, xmm/mem128
    • vpmuldq ymmdest, ymmsrc1, ymm/mem256
    • pmuludq xmmdest, xmmsrc/mem128
    • vpmuludq xmmdest, xmmsrc1, xmm/mem128
    • vpmuludq ymmdest, ymmsrc1, ymm/mem256
    И еще пара инструкций - pclmulqdq и vpclmulqdq умножают четверные слова (qword) и сохраняют 128-битныq результат. pclmulqdq оставляет старшие 128 бит перекрывающего регистра YMM без изменений, а vpclmulqdq заполняет их нулями.
    • pclmulqdq xmmdest, xmmsrc/mem128, imm8
    • vpclmulqdq xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    Операнд imm8 указывает, какие четверные слова использовать в качестве исходных операндов. На примере pclmulqdq:
    imm8Результат
    00hXMMdest = xmmdest[0-63] * XMM/mem128[0-63]
    01hXMMdest = xmmdest[64-127] * XMM/mem128[0-63]
    10hXMMdest = xmmdest[0-63] * XMM/mem128[64-127]
    11hXMMdest = xmmdest[64-127] * XMM/mem128[64-127]
    vpclmulqdq работает аналогично, только числа берутся из второго и третьего операнда.
    Пример умножения 128-разрядных чисел:
    Код (ASM):
    1. .data
    2.  nums0 word 1, 2, 3, 4, 5, 6, 7, 8
    3.  nums1 word 2, 3, 4, 5, 6, 7, 8, 9
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  pmullw xmm0, xmm1  ; XMM0 = XMM0 * XMM1
    9.  ; XMM0 = 2, 6, 12, 20, 30, 42, 56, 81
    10.  ret
    11. main endp
    12. end
     
    Последнее редактирование: 31 окт 2026
  15. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Математические инструкции SSE/AVX


    Среднее значение
    Инструкции (v)pavgb и (v)pavgw вычисляют среднее значение двух соответствующих дорожек операндов:
    • pavgb xmmdest, xmmsrc/mem128
    • vpavgb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpavgb ymmdest, ymmsrc1, ymmsrc2/mem256
    • pavgw xmmdest, xmmsrc/mem128
    • vpavgw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpavgw ymmdest, ymmsrc1, ymmsrc2/mem256
    128-битные инструкции pavgb и vpavgb берут два байта из соответствующих 16 дорожек первого и второго операндах и вычисляют среднее этих двух чисел. Среднее значение помещается в первый операнж. 256-битный вариант инструкции vpavgb вычисляет средние значения для 32 дорожек.
    128-битные инструкции pavgw и vpavgw вычисляют 8 средних значений для каждой пары слов из 8 дорожек первого и второго операнда. 256-битный вариант инструкции vpavgw вычисляет средние значения для 16 дорожек.
    Пример применения:
    Код (ASM):
    1. .data
    2.  nums0 word 1, 3, 4, 6, 7, 8, 9, 10
    3.  nums1 word 2, 2, 3, 4, 5, 6, 7, 8
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  pavgw xmm0, xmm1  ; XMM0 = (XMM0 + XMM1) / 2
    9.  ; XMM0 = 2, 3, 4, 5, 6, 7, 8, 9
    10.  ret
    11. main endp
    12. end
    Если результат дробный, то он округляется.
    Максимальное и минимальное значения
    Расширения SSE4.1 добавили восемь инструкций для поиска минимума и максимума из двух соответствующих дорожек:
    • (v)pmaxsb: выбирает максимальное однобайтовое число со знаком из соответствующих дорожек операндов.
    • (v)pmaxsw: выбирает максимальное 16-битное число со знаком из соответствующих дорожек операндов.
    • (v)pmaxsd: выбирает максимальное 32-битное число со знаком (sdword).
    • vpmaxsq: выбирает максимальное 64-битное число со знаком.
    • (v)pmaxub: выбирает максимальное беззнаковое 8-битное число из соответствующих дорожек операндов.
    • (v)pmaxuw: выбирает максимальное беззнаковое 16-битное число.
    • (v)pmaxud: выбирает максимальное беззнаковое 32-битное число.
    • vpmaxuq: выбирает максимальное беззнаковое 64-битное число.
    • (v)pminsb: выбирает минимальное однобайтовое число со знаком из соответствующих дорожек операндов.
    • (v)pminsw: выбирает минимальное 16-битное число со знаком из соответствующих дорожек операндов.
    • (v)pminsd: выбирает минимальное 32-битное число со знаком (sdword).
    • vpminsq: выбирает минимальное 64-битное число со знаком.
    • (v)pminub: выбирает минимальное беззнаковое 8-битное число из соответствующих дорожек операндов.
    • (v)pminuw: выбирает минимальное беззнаковое 16-битное число.
    • (v)pminud: выбирает минимальное беззнаковое 32-битное число.
    • vpminuq: выбирает минимальное беззнаковое 64-битное число.
    Общий синтаксис инструкций на примере pmaxuw и vpmaxuw (остальные инструкции имеют аналогичный синтаксис)
    • pmaxuw xmmdest, xmmsrc/mem128
    • vpmaxuw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpmaxuw ymmdest, ymmsrc1, ymmsrc2/mem256
    Эти инструкции сканируют дорожки пары 128- или 256-битных операндов и копируют максимальное или минимальное значение из этой дорожки в ту же дорожку первого операнда. Пример нахожжения максимальных слов в дорожках:
    Код (ASM):
    1. .data
    2.  nums0 word 1, 2, 4, 8, 16, 32, 64, 128
    3.  nums1 word 1, 3, 5, 7, 11, 13, 17, 19
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  pmaxuw xmm0, xmm1  ; XMM0 = MAX (XMM0, XMM1)
    9.  ; XMM0 = 1, 3, 5, 8, 16, 32, 64, 128
    10.  ret
    11. main endp
    12. end
    Абсолютное значение
    SSE/AVX предоставляют несколько инструкций для вычисления абсолютных значений целых чисел со знаком: (v)pabsb (для байтов), (v)pabsw (для слов) и (v)pabsd (для двойных слов). Их синтаксис:
    • pabsb xmmdest, xmmsrc/mem128
    • vpabsb xmmdest, xmmsrc/mem128
    • vpabsb ymmdest, ymmsrc/mem256
    • pabsw xmmdest, xmmsrc/mem128
    • vpabsw xmmdest, xmmsrc/mem128
    • vpabsw ymmdest, ymmsrc/mem256
    • pabsd xmmdest, xmmsrc/mem128
    • vpabsd xmmdest, xmmsrc/mem128
    • vpabsd ymmdest, ymmsrc/mem256
    Инструкции pabsb, pabsw и pabsd не изменяют старшие 128 битов регистров YMM, а 128-битные версии инструкций vpabsb, vpabsw и vpabsd заполняют нулями старшие 128 битов регистров YMM.
     
    Последнее редактирование: 31 окт 2026
  16. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Сравнение целых чисел в SSE/AVX

    Инструкции (v)pcmpeqb, (v)pcmpeqw, (v)pcmpeqd, (v)pcmpeqq, (v)pcmpgtb, (v)pcmpgtw, (v)pcmpgtd и (v)pcmpgtq сравнивают байты, числа word, dword или qword в соответствующих дорожках операндов. Результат сравнения сохраняется в первом операнде.
    Инструкции pcmpeqX, сравнивают на равенство соответственно два байта, два слова, два двойных и два четверных слова из соответствуюших дорожек.
    • pcmpeqb xmmdest, xmmsrc/mem128 ; сравнивает 16 байтовых дорожек
    • pcmpeqw xmmdest, xmmsrc/mem128 ; сравнивает 8 дорожек с числами word
    • pcmpeqd xmmdest, xmmsrc/mem128 ; сравнивает 4 дорожек с числами dword
    • pcmpeqq xmmdest, xmmsrc/mem128 ; сравнивает 2 дорожек с числами qword
    Инструкции устанавливают значение всех битов 1, если два значения в одной дорожке равны. Если значения не равны, то устанавливается 0 для всех бит. Например:
    Код (ASM):
    1. .data
    2.  nums0 dword 1, 2, 4, 8
    3.  nums1 dword 1, 2, 3, 4
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  pcmpeqd xmm0, xmm1  ; XMM0 = XMM0 == XMM1
    9.  ; XMM0 = -1, -1, 0, 0
    10.  ret
    11. main endp
    12. end
    Здесь сравниваются соответствуюшие элементы векторов из XMM0 и XMM1, которые представляют числа dword. Поскольку первые два элемента обоих векторо равны, а последние два не равны, то в результате получим вектор FFFFFFFFh, FFFFFFFFh, 0, 0
    Инструкции pcmpgtX проверят, больше первый операнд чем второй:
    • pcmpgtb xmmdest, xmmsrc/mem128 ; сравнивает байты в 16 дорожках
    • pcmpgtw xmmdest, xmmsrc/mem128 ; сравнивает числа word в 8 дорожках
    • pcmpgtd xmmdest, xmmsrc/mem128 ; сравнивает числа dword в 4 дорожках
    • pcmpgtq xmmdest, xmmsrc/mem128 ; сравнивает числа qword в 2 дорожках
    Инструкции устанавливают значение всех битов 1, если значение из первого операнда больше значения из второго. Иначе устанавливается 0 для всех бит. Например:
    Код (ASM):
    1. .data
    2.  nums0 dword 0, 2, 4, 5
    3.  nums1 dword 0, 1, 2, 7
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  pcmpgtd xmm0, xmm1  ; XMM0 = XMM0 > XMM1
    9.  ; XMM0 = 0, -1, -1, 0
    10.  ret
    11. main endp
    12. end
    128-варианты инструкций vpcmpeqX и vpcmpgtX работают аналогично SSE-инструкциям, только сравнивают второй и третий операнды и результат помещают в первый операнд.
    • vpcmpeqb xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает байты в 16 дорожках
    • vpcmpeqw xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает числа word в 8 дорожках
    • vpcmpeqd xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает числа dword в 4 дорожках
    • vpcmpeqq xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает числа qword в 2 дорожках
    • vpcmpgtb xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает байты в 16 дорожках
    • vpcmpgtw xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает числа word в 8 дорожках
    • vpcmpgtd xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает числа dword в 4 дорожках
    • vpcmpgtq xmmdest, xmmsrc1, xmmsrc2/mem128 ; сравнивает числа qword в 2 дорожках
    256-разрядные варианты инструкций vpcmpeqX и vpcmpgtX сравнивают в два раза больше дорожек в 256-битных операндах:
    • vpcmpeqb ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает байты в 32 дорожках
    • vpcmpeqw ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает числа word в 16 дорожках
    • vpcmpeqd ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает числа dword в 8 дорожках
    • vpcmpeqq ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает числа qword в 4 дорожках
    • vpcmpgtb ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает байты в 32 дорожках
    • vpcmpgtw ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает числа word в 16 дорожках
    • vpcmpgtd ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает числа dword в 8 дорожках
    • vpcmpgtq ymmdest, ymmsrc1, ymmsrc2/mem256 ; сравнивает числа qword в 4 дорожках
    Сравнение целых чисел со знаком SSE/AVX не влияет на флаги состояния (поскольку они сравнивают несколько значений, и только одно из этих сравнений может быть перемещено во флаги).
    (v)pmovmskb
    Инструкция (v)pmovmskb позволяет проверить результат сравнения. Она извлекает старший бит из всех байтов в регистре XMM или YMM и сохраняет 16 или 32 бита (соответственно) в регистре общего назначения. Эта инструкция устанавливают все старшие биты регистра общего назначения в 0 (помимо тех, которые необходимы для хранения битов маски):
    • pmovmskb reg, xmm
    • vpmovmskb reg, xmm
    • vpmovmskb reg, ymm
    Первым операндом инструкции является 32- или 64-битный регистр общего назначения.
    Инструкция (v)pmovmskb копирует знаковые биты из каждой байтовой дорожки в соответствующую битовую позицию регистра общего назначения. Так, она копирует бит 7 из регистра XMM (бит знака для дорожки 0) в бит 0 регистра назначения; она копирует бит 15 из регистра XMM (бит знака для дорожки 1) в бит 1 регистра назначения, бит 23 из регистра XMM (бит знака для дорожки 2) в бит 2 регистра назначения и так далее.
    128-битные инструкции заполняют только биты с 0 по 15 регистра назначения (обнуляя все остальные биты). 256-битная форма инструкции vpmovmskb заполняет биты с 0 по 31 целевого регистра (при использовании 64-битного регистра все остальные биты обнуляются)
    Можно использовать инструкцию pmovmskb для извлечения одного бита из каждой байтовой дорожки в регистре XMM или YMM после инструкций (v)pcmpeqb или (v)pcmpgtb.
    Код (ASM):
    1. .data
    2.  nums0 byte 0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43
    3.  nums1 byte 0, 0, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 55, 34, 21, 13
    4. .code
    5. main proc
    6.  movdqa xmm0, oword ptr nums0
    7.  movdqa xmm1, oword ptr nums1
    8.  pcmpgtb xmm0, xmm1  ; XMM0 = XMM0 > XMM1
    9.  pmovmskb eax, xmm0
    10.  ret
    11. main endp
    12. end
    После выполнения этой программы бит 0 EAX будет равен 1 или 0, если байт 0 XMM0 был равен или не равен байту 0 XMM1 соответственно. Аналогично, бит 1 EAX будет содержать результат сравнения байта 1 XMM0 с XMM1 и т. д. вплоть до бита 15, который хранит результат сравнивнения байтов из дорожек 15 регистров XMM0 и XMM1.
    Проблема этой инструкции заключается в том, что она работает только для байтов, для число word/dword/qword аналогичных инструкций нет. Однако используя логические операции сдвига и умножения/сложения, мы можем определить необходимую логику.
     
    Последнее редактирование: 31 окт 2026
  17. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Преобразования целых чисел в SSE/AVX

    Расширения набора инструкций SSE и AVX предоставляют различные инструкции для преобразования целочисленных значений из одной формы в другую, например, преобразуют меньшее значение в большее и наоборот.
    Инструкции копирования с расширением нулем:
    • pmovzxbw : расширяет каждый байт из первых 8 байтов второго операнда нулями до числа word
    • pmovzxbd : расширяет каждый байт из первых 4 байтов второго операнда нулями до числа dword
    • pmovzxbq : расширяеткаждый байт из первых 4 байтов второго операнда нулями до числа qword
    • pmovzxwd : расширяет каждое из 4 слов (первые 8 байт второго операнда) нулями до числа dword
    • pmovzxwq : расширяет каждое из 2 слов (первые 4 байт второго операнда) нулями до числа qword
    • pmovzxdq : расширяет каждое из 2 двойных слов (первые 8 байт второго операнда) нулями до числа qword
    Расширяемое значение передается через первый операнд, результат расширения - в первом операнде.
    • pmovzxbw xmmdest, xmmsrc/mem64
    • pmovzxbd xmmdest, xmmsrc/mem32
    • pmovzxbq xmmdest, xmmsrc/mem16
    • pmovzxwd xmmdest, xmmsrc/mem64
    • pmovzxwq xmmdest, xmmsrc/mem32
    • pmovzxdq xmmdest, xmmsrc/mem64
    Инструкции расширений AVX2 удваивают количество дорожек, позволяя использовать регистры YMM. Они берут те же операнды, обрабатывают в два раза больше дорожек.
    • vpmovzxbw : расширяет каждый байт из первых 16 байтов второго операнда нулями до числа word
    • vpmovzxbd : расширяет каждый байт из первых 8 байтов второго операнда нулями до числа dword
    • vpmovzxbq : расширяеткаждый байт из первых 4 байтов второго операнда нулями до числа qword
    • vpmovzxwd : расширяет каждое из 8 слов (первые 8 байт второго операнда) нулями до числа dword
    • vpmovzxwq : расширяет каждое из 4 слов (первые 4 байт второго операнда) нулями до числа qword
    • vpmovzxdq : расширяет каждое из 4 двойных слов (первые 8 байт второго операнда) нулями до числа qword
    Синтаксис инструкций:
    • vpmovzxbw xmmdest, xmmsrc/mem128
    • vpmovzxbd xmmdest, xmmsrc/mem64
    • vpmovzxbq xmmdest, xmmsrc/mem32
    • vpmovzxwd xmmdest, xmmsrc/mem128
    • vpmovzxwq xmmdest, xmmsrc/mem64
    • vpmovzxdq xmmdest, xmmsrc/mem128
    Инструкции для преобразования чисел со знаком
    Расширения SSE/AVX/AVX2 также предоставляют ряд инструкций для преобразования чисел со знаком:
    • pmovsxbw : расширяет каждый байт из первых 8 байтов второго операнда битом знака до числа word
    • pmovsxbd : расширяет каждый байт из первых 4 байтов второго операнда битом знака до числа dword
    • pmovsxbq : расширяеткаждый байт из первых 4 байтов второго операнда битом знака до числа qword
    • pmovsxwd : расширяет каждое из 4 слов (первые 8 байт второго операнда) битом знака до числа dword
    • pmovsxwq : расширяет каждое из 2 слов (первые 4 байт второго операнда) битом знака до числа qword
    • pmovsxdq : расширяет каждое из 2 двойных слов (первые 8 байт второго операнда) битом знака до числа qword
    • vpmovsxbw : расширяет каждый байт из первых 16 байтов второго операнда битом знака до числа word
    • vpmovsxbd : расширяет каждый байт из первых 8 байтов второго операнда битом знака до числа dword
    • vpmovsxbq : расширяеткаждый байт из первых 4 байтов второго операнда битом знака до числа qword
    • vpmovsxwd : расширяет каждое из 8 слов (первые 8 байт второго операнда) битом знака до числа dword
    • vpmovsxwq : расширяет каждое из 4 слов (первые 4 байт второго операнда) битом знака до числа qword
    • vpmovsxdq : расширяет каждое из 4 двойных слов (первые 8 байт второго операнда) битом знака до числа qword
    Синтаксис:
    • pmovsxbw xmmdest, xmmsrc/mem64
    • pmovsxbd xmmdest, xmmsrc/mem32
    • pmovsxbq xmmdest, xmmsrc/mem16
    • pmovsxwd xmmdest, xmmsrc/mem64
    • pmovsxwq xmmdest, xmmsrc/mem32
    • pmovsxdq xmmdest, xmmsrc/mem64
    • vpmovsxbw xmmdest, xmmsrc/mem128
    • vpmovsxbd xmmdest, xmmsrc/mem64
    • vpmovsxbq xmmdest, xmmsrc/mem32
    • vpmovsxwd xmmdest, xmmsrc/mem128
    • vpmovsxwq xmmdest, xmmsrc/mem64
    • vpmovsxdq xmmdest, xmmsrc/mem128
    Преобразование с насыщением
    Также расширения SSE позволяют преобразовывать большие значения в меньшие значения посредством насыщения. Это инструкции:
    • packsswb: преобразует 16 слов (word) со знаком в 16 байтов, применяя насыщение со знаком
    • packuswb: преобразует беззнаковых 16 слов в 16 байтов, применяя беззнаковое насыщение
    • packssdw: преобразует 8 двойных слов (dword) со знаком в 8 слов, применяя насыщение со знаком
    • packusdw: преобразует беззнаковых 8 двойных слов в 8 слов, применяя беззнаковое насыщение
    Синтаксис инструкций:
    • packsswb xmmdest, xmmsrc/mem128
    • packuswb xmmdest, xmmsrc/mem128
    • packssdw xmmdest, xmmsrc/mem128
    • packusdw xmmdest, xmmsrc/mem128
    Операция насыщения проверяет свой операнд, чтобы увидеть, превышает ли значение допустимый диапазон результата (от –128 до +127 для байтов со знаком, от 0 до 255 для байтов без знака, от –32768 до +32767 для слов со знаком и от 0 до 65535 для слов без знака). При насыщении до байта, если исходное значение со знаком меньше –128, насыщение байта устанавливает значение –128. При насыщении до слова, если исходное значение со знаком меньше –32786, насыщение со знаком устанавливает значение
    –32768. Точно так же, если значение байта или слова со знаком превышает 127 или 32767, то насыщение заменяет значение на 127 или 32767 соответственно. Для беззнаковых операций насыщение ограничивает значение до 255 для байтов и 65535 для слов. Значения без знака никогда не бывают меньше 0, поэтому беззнаковое насыщение обрезает значения только до 255 или 65535.
    Расширения AVX/AVX2 также предоставляют инструкция преобразования с насыщением, которые позволяют использовать 256-битные операнды - регистры YMM и переменные.
    • vpacksswb: преобразует 16 слов со знаком в 16 байтов (для 128-битной версии) и 32 слова со знаком в 32 байта (для 256-битной версии), применяя насыщение со знаком
    • vpackuswb: преобразует 16 беззнаковых слов в 16 байтов (для 128-битной версии) и 32 беззнаковых слова в 32 байта (для 256-битной версии), применяя беззнаковое насыщение
    • vpackssdw: преобразует 8 двойных слов со знаком в 8 слов (для 128-битной версии) и 16 двойных слов со знаком в 16 слов (для 256-битной версии), применяя насыщение со знаком
    • vpackusdw: преобразует 8 беззнаковых двойных слов в 8 слов (для 128-битной версии) и 16 беззнаковых двойных слов в 16 слов (для 256-битной версии), применяя беззнаковое насыщение
    Синтаксис инструкций:
    • vpacksswb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpackuswb xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpackssdw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpackusdw xmmdest, xmmsrc1, xmmsrc2/mem128
    • vpacksswb ymmdest, ymmsrc1, ymmsrc2/mem256
    • vpackuswb ymmdest, ymmsrc1, ymmsrc2/mem256
    • vpackssdw ymmdest, ymmsrc1, ymmsrc2/mem256
    • vpackusdw ymmdest, ymmsrc1, ymmsrc2/mem256
     
    Последнее редактирование: 31 окт 2026
  18. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Арифметические операции с плавающей точкой в SSE/AVX


    Расширения SSE/AVX предоставляют инструкции для параллельных операций с плавающей точкой:
    • addps: складывает 4 дорожки операндов с числами с плавающей точкой одинарной точности
    • addpd: складывает 2 дорожки операндов с числами с плавающей точкой двойной точности
    • vaddps: складывает 4 дорожки (128-битная версия) или 8 дорожек (256-битная версия) с числами с плавающей точкой одинарной точности
    • vaddpd: складывает 2 дорожки (128-битная версия) или 4 дорожки (256-битная версия) с числами с плавающей точкой двойной точности
    • subps: вычитает 4 дорожки операндов с числами с плавающей точкой одинарной точности
    • subpd: вычитает 2 дорожки операндов с числами с плавающей точкой двойной точности
    • vsubps: вычитает 4 дорожки (128-битная версия) или 8 дорожек (256-битная версия) с числами с плавающей точкой одинарной точности
    • vsubpd: вычитает 2 дорожки (128-битная версия) или 4 дорожки (256-битная версия) с числами с плавающей точкой двойной точности
    • mulps: перемножает 4 дорожки операндов с числами с плавающей точкой одинарной точности
    • mulpd: перемножает 2 дорожки операндов с числами с плавающей точкой двойной точности
    • vmulps: перемножает 4 дорожки (128-битная версия) или 8 дорожек (256-битная версия) с числами с плавающей точкой одинарной точности
    • vmulpd: перемножает 2 дорожки (128-битная версия) или 4 дорожки (256-битная версия) с числами с плавающей точкой двойной точности
    • divps: делит 4 дорожки операндов с числами с плавающей точкой одинарной точности
    • divpd: делит 2 дорожки операндов с числами с плавающей точкой двойной точности
    • vdivps: делит 4 дорожки (128-битная версия) или 8 дорожек (256-битная версия) с числами с плавающей точкой одинарной точности
    • vdivpd: делит 2 дорожки (128-битная версия) или 4 дорожки (256-битная версия) с числами с плавающей точкой двойной точности
    • maxps: вычисляет максимальное в каждой из 4 пар чисел с плавающей точкой одинарной точности
    • maxpd: вычисляет максимальное в каждой из 2 пар чисел с плавающей точкой двойной точности
    • vmaxps: вычисляет максимальное в каждой из 4 (для 128-битной версии) или 8 (для 256-битной версии) пар чисел с плавающей точкой одинарной точности
    • vmaxpd: вычисляет максимальное в каждой из 2 (для 128-битной версии) или 4 (для 256-битной версии) пар чисел с плавающей точкой двойной точности
    • minps: вычисляет минимальное в каждой из 4 пар чисел с плавающей точкой одинарной точности
    • minpd: вычисляет минимальное в каждой из 2 пар чисел с плавающей точкой двойной точности
    • vminps: вычисляет минимальное в каждой из 4 (для 128-битной версии) или 8 (для 256-битной версии) пар чисел с плавающей точкой одинарной точности
    • vminpd: вычисляет минимальное в каждой из 2 (для 128-битной версии) или 4 (для 256-битной версии) пар чисел с плавающей точкой двойной точности
    • sqrtps: вычисляет квадратный корень для каждого из 4 чисел с плавающей точкой одинарной точности
    • sqrtpd: вычисляет квадратный корень для 2 чисел с плавающей точкой двойной точности
    • vsqrtps: вычисляет квадратный корень для каждого из 4 (для 128-битной версии) или 8 (для 256-битной версии) чисел с плавающей точкой одинарной точности
    • vsqrtpd: вычисляет квадратный корень для каждого из 2 (для 128-битной версии) или 4 (для 256-битной версии) чисел с плавающей точкой двойной точности
    • rsqrtps: вычисляет приблизительно обратный квадратный корень для каждого из 4 чисел с плавающей точкой одинарной точности
    • vrsqrtps: вычисляет приблизительно обратный квадратный корень для каждого из 4 (для 128-битной версии) или 8 (для 256-битной версии) чисел с плавающей точкой одинарной точности
    Общий синтаксис инструкций на примере v(addps):
    • addps xmmdest, xmmsrc/mem128
    • vaddps xmmdest, xmmsrc1, xmmsrc2/mem128
    • vaddps ymmdest, ymmsrc1, ymmsrc2/mem256
    Инструкции вычисления квадратного корня принимают один операнд:
    • sqrtps xmmdest, xmmsrc/mem128
    • vsqrtps xmmdest, xmmsrc/mem128
    • vsqrtps ymmdest, ymmsrc/mem256
     
    Последнее редактирование: 31 окт 2026
  19. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Сравнение чисел с плавающей точкой в SIMD

    Для сравнения чисел с плавающей точкой расширения SSE/AVX предоставляют инструкции (v)cmpps (сравнивает числа одинарной точности) и (v)cmppd (для чисел двойной точности):
    • cmpps xmmdest, xmmsrc/mem128, imm8
    • vcmpps xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    • vcmpps ymmdest, ymmsrc1, ymmsrc2/mem256, imm8
    • cmppd xmmdest, xmmsrc/mem128, imm8
    • vcmppd xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    • vcmppd ymmdest, ymmsrc1, ymmsrc2/mem256, imm8
    Стоит отметить, что сравнения могут быть упорядоченными (ordered) и неупорядоченными (unordered). При неупорядоченном сравнении как минимум один из операндов представляет значение NaN. Упорядоченное сравнение, наоборот, - это такое сравнение, где ни один из операндов не является NaN.
    Кроме того, сравнения могут быть сигнальные (signaling) и тихие (quiet). Сигнальные сравнения генерируют исключение недопустимой арифметической операции (IA), если результатом операцим является NaN. Тихие сравнения не вызывают исключения и отражают только состояние в регистре MXCSR.
    Последний операнд инструкций - imm8 указывает на тип сравнения.
    • 00h: проверяет операнды на равенство, если они равны, устанавливает для всех битов дорожки 1, иначе устанавливает 0, (сравнение упорядоченное, тихое)
    • 01h: если первый операнд меньше второго, устанавливает 1 (сравнение упорядоченное, сигнальное)
    • 02h: если первый операнд меньше или равен второму, устанавливает 1 (сравнение упорядоченное, сигнальное)
    • 03h: устанавливает 1, если сравенение неупорядоченное (сравнение неупорядоченное, тихое)
    • 04h: если операнды не равны, устанавливает 1 (сравнение неупорядоченное, тихое)
    • 05h: если первый операнд НЕ меньше второго, устанавливает 1 (сравнение неупорядоченное, сигнальное)
    • 06h: если первый операнд НЕ меньше и НЕ равен второму, устанавливает 1 (сравнение неупорядоченное, сигнальное)
    • 07h: устанавливает 1, если сравенение упорядоченное (сравнение упорядоченное, тихое)
    • 08h: если операнды равны, устанавливает 1 (сравнение неупорядоченное, тихое)
    • 09h: если первый операнд НЕ больше и НЕ равен второму, устанавливает 1 (сравнение неупорядоченное, сигнальное)
    • 0Ah: если первый операнд НЕ больше второго, устанавливает 1 (сравнение неупорядоченное, сигнальное)
    • 0Bh: возвращает 0, если сравнение упорядоченное (сравнение упорядоченное, тихое)
    • 0Ch: если операнды не равны, устанавливает 1 (сравнение упорядоченное, тихое)
    • 0Dh: если первый операнд больше или равен второму, устанавливает 1 (сравнение упорядоченное, сигнальное)
    • 0Eh: если первый операнд больше второго, устанавливает 1 (сравнение упорядоченное, сигнальное)
    • 0Fh: устанавливает 1, если сравнение неупорядоченное (сравнение неупорядоченное, тихое)
    • 10h: если операнды равны, устанавливает 1 (сравнение упорядоченное, сигнальное)
    • 11h: если первый операнд меньше второго, устанавливает 1 (сравнение упорядоченное, тихое)
    • 12h: если первый операнд меньше или равен второму, устанавливает 1 (сравнение упорядоченное, тихое)
    • 13h: устанавливает 1, если сравнение неупорядоченное (сравнение неупорядоченное, сигнальное)
    • 14h: если операнды не равны, устанавливает 1 (сравнение неупорядоченное, сигнальное)
    • 15h: если первый операнд НЕ меньше второго, устанавливает 1 (сравнение неупорядоченное, тихое)
    • 16h: если первый операнд НЕ меньше и НЕ равен второму, устанавливает 1 (сравнение неупорядоченное, тихое)
    • 17h: устанавливает 1, если сравнение упорядоченное (сравнение упорядоченное, сигнальное)
    • 18h: если операнды равны, устанавливает 1 (сравнение неупорядоченное, сигнальное)
    • 19h: если первый операнд НЕ больше и НЕ равен второму, устанавливает 1 (сравнение неупорядоченное, тихое)
    • 1Ah: если первый операнд НЕ больше второго, устанавливает 1 (сравнение неупорядоченное, тихое)
    • 1Bh: возвращает 0, если сравнение упорядоченное (сравнение упорядоченное, сигнальное)
    • 1Ch: если операнды не равны, устанавливает 1 (сравнение упорядоченное, сигнальное)
    • 1Dh: если первый операнд больше или равен второму, устанавливает 1 (сравнение упорядоченное, тихое)
    • 1Eh: если первый операнд больше второго, устанавливает 1 (сравнение упорядоченное, тихое)
    • 1Fh: устанавливает 1, если сравнение неупорядоченное, (сравнение неупорядоченное, сигнальное)
    Если условие верно, то в соответствующей 32- или 64-битной дорожке XMM0 все биты устанавливаются в 1, если условие не верно, то все биты равны 0.
    Например, сравнивним два вектора чисел real4:
    Код (ASM):
    1. .data
    2.  nums0 real4 0.1, 1.2, 2.1, 3.2
    3.  nums1 real4 0.1, 1.1, 2.1, 3.1
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  cmpps xmm0, xmm1, 0
    9.  ;XMM0 = -1, 0, -1, 0
    10.  ret
    11. main endp
    12. end
    Здесь сравниваем векторы real4 из регистров XMM0 и XMM1. Поскольку инструкции cmpps в качестве третьего операнда передается число 0 (или 00h), то инструкция проверяет числа в сооветствующих дорожках регистров на равенство. То есть единовременно сравниваем 4 числа из XMM0 с 4 числами из XMM1. Результат сравнения помещается в XMM0 и он будет представлять вектор чисел [-1, 0, -1, 0]. То есть первые и третьи 32-битные дорожки регистров равны, а вторые и четвертые дорожки не равны.
    Для ряда случаев есть синонимичные инструкции, которые упрощают понимание кода:
    • cmpeqps x1, x2: синоним для cmpps x1, x2, 0
    • cmpeqpd x1, x2: синоним для cmppd x1, x2, 0
    • cmpltps x1, x2: синоним для cmpps x1, x2, 1
    • cmpltpd x1, x2: синоним для cmppd x1, x2, 1
    • cmpleps x1, x2: синоним для cmpps x1, x2, 2
    • cmplepd x1, x2: синоним для cmppd x1, x2, 2
    • cmpunordps x1, x2: синоним для cmpps x1, x2, 3
    • cmpunordpd x1, x2: синоним для cmppd x1, x2, 3
    • cmpneqps x1, x2: синоним для cmpps x1, x2, 4
    • cmpneqpd x1, x2: синоним для cmppd x1, x2, 4
    • cmpnltps x1, x2: синоним для cmpps x1, x2, 5
    • cmpnltpd x1, x2: синоним для cmppd x1, x2, 5
    • cmpnleps x1, x2: синоним для cmpps x1, x2, 6
    • cmpnlepd x1, x2: синоним для cmppd x1, x2, 6
    • cmpordps x1, x2: синоним для cmpps x1, x2, 7
    • cmpordpd x1, x2: синоним для cmppd x1, x2, 7
    Так, примеры выше мы могли бы переписать так:
    Код (ASM):
    1. .data
    2.  nums0 real4 0.1, 1.2, 2.1, 3.2
    3.  nums1 real4 0.1, 1.1, 2.1, 3.1
    4. .code
    5. main proc
    6.  movaps xmm0, nums0
    7.  movaps xmm1, nums1
    8.  cmpeqps xmm0, xmm1
    9.  ;XMM0 = -1, 0, -1, 0
    10.  ret
    11. main endp
    12. end
    Версии AVX этих инструкций принимают 4 операнда: целевой регистр XMM или YMM для хранения результатов сравнения, два сравниваемых операнда и операнд imm8, который указывает на тип сравнения:
    • vcmpps xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    • vcmpps ymmdest, ymmsrc1, ymmsrc2/mem256, imm8
    • vcmppd xmmdest, xmmsrc1, xmmsrc2/mem128, imm8
    • vcmppd ymmdest, ymmsrc1, ymmsrc2/mem256, imm8
    В зависимости от значения четверного операнда - imm8 для этих инструкций есть синонимичные инструкций:
    imm8Инструкцияimm8Инструкция
    00hvcmpeqps и vcmpeqpd10hvcmpeq_osps и vcmpeq_ospd
    01hvcmpltps и vcmpltpd11hvcmplt_oqps и vcmplt_oqpd
    02hvcmpleps и vcmplepd12hvcmple_oqps и vcmple_oqpd
    03hvcmpunordps и vcmpunordpd13hvcmpunord_sps и vcmpunord_spd
    04hvcmpneqps и vcmpneqpd14hvcmpneq_usps и vcmpneq_uspd
    05hvcmpltps и vcmpltpd15hvcmpnlt_uqps и vcmpnlt_uqpd
    06hvcmpleps и vcmplepd16hvcmpnle_uqps и vcmpnle_uqpd
    07hvcmpordps и vcmpordpd17hvcmpord_sps и vcmpord_spd
    08hvcmpeq_uqps и vcmpeq_uqpd18hvcmpeq_usps и vcmpeq_uspd
    09hvcmpngeps и vcmpngepd19hvcmpnge_uqps и vcmpnge_uqpd
    0Ahvcmpngtps и vcmpngtpd1Ahvcmpngt_uqps и vcmpngt_uqpd
    0Bhvcmpfalseps и vcmpfalsepd1Bhvcmpfalse_osps и vcmpfalse_ospd
    0Chvcmpneq_oqps и vcmpneq_oqpd1Chvcmpneq_osps и vcmpneq_ospd
    0Dhvcmpgeps и vcmpgepd1Dhvcmpge_oqps и vcmpge_oqpd
    0Ehvcmpgtps и vcmpgtpd1Ehvcmpgt_oqps и vcmpgt_oqpd
    0Fhvcmptrueps и vcmptruepd1Fhvcmptrue_usps и vcmptrue_uspd
    Получение результатов сравнения
    Инструкции movmskps и movmskpd извлекают знаковые биты 32- и 64-битных дорожек регистров XMM и YMM соответственно и сохраняют эти биты в младших 4 или 8 битах регистра общего назначения.
    • movmskps reg, xmmsrc
    • movmskpd reg, xmmsrc
    • vmovmskps reg, ymmsrc
    • vmovmskpd reg, ymmsrc
    Первый операнд представляет 32- или 64-битный регистр общего назначения. Второй операнд представляет регистр XMM или YMM с результатами сравнения.
    Инструкция movmskps копирует знаковые биты из четырех дорожек регистра XMM в младшие 4 бита регистра общего назначения
    [​IMG]
    Инструкция movmskpd копирует знаковые биты из четырех дорожек регистра XMM в биты 0 и 1 регистра общего назначения.
    Инструкция vmovmskps копирует знаковые биты из четырех дорожек регистра XMM или из восьми дорожек регистра YMM в малдшие 4 и 8 битов регистра назначения соответственно.
    Инструкция vmovmskpd копирует знаковые биты из четырех дорожек регистра YMM в младшие 4 биты регистра общего назначения.
    Стоит отметить, что хотя эти инструкции ориентированы прежде всего на сравнение чисел с плавающей точкой - real4 и real8, но их также можно использовать для получения результатов сравнения целых чисел (movmskps и vmovmskps) и 64-битных целых чисел (movmskpd и vmovmskpd). Например:
    Код (ASM):
    1. .data
    2.  nums0 qword 23, 55
    3.  nums1 qword 22, 55
    4. .code
    5. main proc
    6.  movapd xmm0, nums0
    7.  movapd xmm1, nums1
    8.  cmpeqpd xmm0, xmm1  ; XMM0 = XMM0 == XMM1  (XMM0 =  -1, 0)
    9.  movmskpd rax, xmm0  ; RAX = 2 (010b - в двоичной системе)
    10.  ret
    11. main endp
    12. end
    В данном случае проверяются на равенство элементы двух векторов четверных слов, и с помощью инструкции movmskpd результаты сравнения помещаются в регистр RAX. Поскольку сравнивают два значения, то в регистре RAX результаты будут помещаться в два первых бита. В итоге в RAX будет число 2 или 10b в бинарной системе. Первый бит равен 0, так как числа первых дорожек векторов не равны. Второй бит равен 1, так как вторые дорожки векторов равны.
    Получив результаты сравнения в регистр общего назначения, очень удобно использовать данный регистр для условной обработки:
    Код (ASM):
    1. .data
    2.  nums0 qword 23, 55
    3.  nums1 qword 22, 55
    4. .code
    5. main proc
    6.  movapd xmm0, nums0
    7.  movapd xmm1, nums1
    8.  cmpeqpd xmm0, xmm1  ; XMM0 = XMM0 == XMM1
    9.  movmskpd rax, xmm0  ; RAX = 2 (010b - в двоичной системе)
    10.  lea rcx, jmpTable  ; загружаем адрес таблицы jmpTable
    11.  jmp qword ptr [rcx][rax*8]  ; в зависимости от результата переходим к определенной метке
    12.  
    13.  jmpTable qword nene  ; обе пары чисел не равны
    14.  qword neeq  ; в первой паре  числа равны, во второй не равны
    15.  qword eqne  ; во второй паре  числа равны, первой не равны
    16.  qword eqeq  ; обе пары чисел равны
    17. nene:
    18.  mov rax, 4
    19.  jmp exit
    20. neeq:
    21.  mov rax, 8
    22.  jmp exit
    23. eqne:
    24.  mov rax, 16
    25.  jmp exit
    26. eqeq:
    27.  mov rax, 32
    28.  jmp exit
    29. exit:
    30.  ret
    31. main endp
    32. end
    Так как инструкция movmskpd копирует 2 бита из XMM0 в RAX, можно использовать RAX в качестве индекса в таблице переходов для выбора одной из четырех разных меток. Код с меткой nene выполняется, если в обоих парах числа не равны. Метка neeq определяет код, если в первой паре числа равны, во второй не равны. Метка eqne определяет код для ситуации, если во второй паре числа равны, а в первой не равны. И метка eqeq определяет код для ситуации, когда оба набора дорожек содержат одинаковые значения.
     
    Последнее редактирование: 31 окт 2026
  20. Mikl___

    Mikl___ Супермодератор Команда форума

    Публикаций:
    14
    Регистрация:
    25 июн 2008
    Сообщения:
    4.406

    SIMD

    Преобразование чисел с плавающей точкой в целые числа и обратно

    Расширения SSE/AVX/AVX2 предоставляют ряд инструкций для преобразования чисел с плавающей точкой в целые числа и наоборот:
    • cvtdq2pd: преобразует два двойных слова со знаком в два числа с плавающей точкой двойной точности
      cvtdq2pd xmmdest, xmmsrc/mem64
    • vcvtdq2pd: преобразует два двойных слова со знаком в два числа с плавающей точкой двойной точности (результат в XMM)
      vcvtdq2pd xmmdest, xmmsrc/mem64
      либо преобразует 4 двойных слова со знаком в 4 числа с плавающей точкой двойной точности (результат в YMM)
      vcvtdq2pd ymmdest, xmmsrc/mem128
    • cvtdq2ps: преобразует 4 двойных слова со знаком в 4 числа с плавающей точкой одинарной точности
      cvtdq2ps xmmdest, xmmsrc/mem128
    • vcvtdq2ps: преобразует 4 двойных слова со знаком в 4 числа с плавающей точкой одинарной точности
      vcvtdq2ps xmmdest, xmmsrc/mem128
      Другая форма инструкции преобразует 8 двойных слова со знаком в 8 чисел с плавающей точкой одинарной точности
      vcvtdq2ps ymmdest, ymmsrc/mem256
    • cvtpd2dq: преобразует два числа с плавающей точкой двойной точности в два двойных слова со знаком
      cvtpd2dq xmmdest, xmmsrc/mem128
    • vcvtpd2dq: преобразует два числа с плавающей точкой двойной точности в два двойных слова со знаком (результат в XMM)
      vcvtpd2dq xmmdest, xmmsrc/mem128
      Другая форма преобразует преобразует 4 числа с плавающей точкой двойной точности в 4 двойных слова со знаком (результат в YMM)
      vcvtpd2dq xmmdest, ymmsrc/mem256
    • cvtpd2ps: преобразует два числа с плавающей точкой двойной точности в два числа с плавающей точкой одинарной точности
      cvtpd2ps xmmdest, xmmsrc/mem128
    • vcvtpd2ps: преобразует два числа с плавающей точкой двойной точности в два числа с плавающей точкой одинарной точности
      vcvtpd2ps xmmdest, xmmsrc/mem128
      Другая форма преобразует преобразует 4 числа с плавающей точкой двойной точности в 4 числа с плавающей точкой одинарной точности
      vcvtpd2ps xmmdest, ymmsrc/mem256
    • cvtps2dq: преобразует 4 числа с плавающей точкой одинарной точности в 4 двойных слова со знаком
      cvtps2dq xmmdest, xmmsrc/mem128
    • vcvtps2dq: преобразует 4 числа с плавающей точкой одинарной точности в 4 двойных слова со знаком
      vcvtps2dq xmmdest, xmmsrc/mem128
      Другая форма преобразует 8 чисел с плавающей точкой одинарной точности в 8 двойных слов со знаком
      vcvtps2dq ymmdest, ymmsrc/mem256
    • cvtps2pd: преобразует два числа с плавающей точкой одинарной точности в два числа с плавающей точкой двойной точности
      cvtps2pd xmmdest, xmmsrc/mem64
    • vcvtps2pd: преобразует два числа с плавающей точкой одинарной точности в два числа с плавающей точкой двойной точности
      vcvtps2pd xmmdest, xmmsrc/mem64
      другая форма преобразует 4 числа с плавающей точкой одинарной точности в 4 числа с плавающей точкой двойной точности
      vcvtps2pd ymmdest, xmmsrc/mem128
    • cvttpd2dq: преобразует два числа с плавающей точкой двойной точности в два двойных слова со знаком
      cvttpd2dq xmmdest, xmmsrc/mem128
    • vcvttpd2dq: преобразует два числа с плавающей точкой двойной точности в два двойных слова со знаком
      vcvttpd2dq xmmdest, xmmsrc/mem128
      другая форма преобразует 4 числа с плавающей точкой двойной точности в 4 двойных слова со знаком
      vcvttpd2dq xmmdest, ymmsrc/mem256
    • cvttps2dq: преобразует 4 числа с плавающей точкой одинарной точности в 4 двойных слова со знаком
      cvttps2dq xmmdest, xmmsrc/mem128
    • vcvttps2dq: преобразует 4 числа с плавающей точкой одинарной точности в 4 двойных слова со знаком
      vcvttps2dq xmmdest, xmmsrc/mem128
      другая форма преобразует 8 чисел с плавающей точкой одинарной точности в 8 двойных слов со знаком
      vcvttps2dq ymmdest, ymmsrc/mem256
     
    Последнее редактирование: 1 ноя 2026