Vesta
中文
源代码

PSLLW, PSLLD, PSLLQ

左侧数据包逻辑

stableVMJITAOTinstruction

编码

操作码指令Op/En64 位兼容/传统说明
NP 0F F1 /r1PSLLW mm, mm/m64A有效有效以mm左mm/m64为单位移动单词,而以0s为单位移动.
66 0F F1 /rPSLLW xmm1, xmm2/m128A有效有效以 xmm1 移动 xmm2/m128 留下的单词,同时以 0s 移动.
NP 0F 71 /6 ibPSLLW mm1, imm8B有效有效Imm8在0s中移动时左移以毫米表示的单词.
66 0F 71 /6 ibPSLLW xmm1, imm8B有效有效以 xmm1 移动 imm8 留下的单词,同时以 0s 移动.
NP 0F F2 /r1PSLLD mm, mm/m64A有效有效以毫米/m64左移双字,以0s为单位。
66 0F F2 /rPSLLD xmm1, xmm2/m128A有效有效以 xmm1 键左移双字,在 0s 键上移时为 xmm2/m128 键.
NP 0F 72 /6 ib1PSLLD mm, imm8B有效有效Imm8左移双字为毫米,0s则移动.
66 0F 72 /6 ibPSLLD xmm1, imm8B有效有效以 xmm1 键左移双字,在 0s 键上移时为 imm8 键.
NP 0F F3 /r1PSLLQ mm, mm/m64A有效有效以毫米/m64左移四字,以0s为单位。
66 0F F3 /rPSLLQ xmm1, xmm2/m128A有效有效Xmm1中的四字在0s中移动时由xmm2/m128留下.
NP 0F 73 /6 ib1PSLLQ mm, imm8B有效有效Imm8在0s中移动时左移四字,以毫米表示。
66 0F 73 /6 ibPSLLQ xmm1, imm8B有效有效Xmm1中的四字在0s中移动时由imm8留下.
VEX.128.66.0F.WIG F1 /rVPSLLW xmm1, xmm2, xmm3/m128C有效有效按 xmm3/m128 指定的量将 xmm2 中的单词移到 0s 中。
VEX.128.66.0F.WIG 71 /6 ibVPSLLW xmm1, xmm2, imm8D有效有效以 xmm2 移动 imm8 留下的单词,同时以 0s 移动.
VEX.128.66.0F.WIG F2 /rVPSLLD xmm1, xmm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量在 xmm2 中左移双字,同时以 0s 移动 。
VEX.128.66.0F.WIG 72 /6 ibVPSLLD xmm1, xmm2, imm8D有效有效以 xmm2 键左移双字,在 0s 键上移时为 imm8 键.
VEX.128.66.0F.WIG F3 /rVPSLLQ xmm1, xmm2, xmm3/m128C有效有效按 xmm3/m128 指定的数值在 0s 中左移 xmm2 中的四字。
VEX.128.66.0F.WIG 73 /6 ibVPSLLQ xmm1, xmm2, imm8D有效有效Xmm2中的四字在0s中移动时由imm8留下.
VEX.256.66.0F.WIG F1 /rVPSLLW ymm1, ymm2, xmm3/m128C有效有效按 xmm3/m128 指定的量将 ymm2 中的单词移到 0s 中。
VEX.256.66.0F.WIG 71 /6 ibVPSLLW ymm1, ymm2, imm8 Opcode/ InstructionD有效有效Ymm2中的字词在零s中移动时由imm8留下. Op/64/32 bit CPUID 特性描述模式支持旗帜
VEX.256.66.0F.WIG F2 /rVPSLLD ymm1, ymm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量在 ymm2 中左移双字,同时以 0s 移动 。
VEX.256.66.0F.WIG 72 /6 ibVPSLLD ymm1, ymm2, imm8D有效有效以 ymm2 键左移双字,在 0s 键上移时为 imm8 键.
VEX.256.66.0F.WIG F3 /rVPSLLQ ymm1, ymm2, xmm3/m128C有效有效按 xmm3/m128 指定的数值在 0s 中左移 ymm2 中的四字。
VEX.256.66.0F.WIG 73 /6 ibVPSLLQ ymm1, ymm2, imm8D有效有效Ymm2中的四字在0s中移动时由imm8留下.
EVEX.128.66.0F.WIG F1 /rVPSLLW xmm1 {k1}{z}, xmm2, xmm3/m128G有效有效使用 AVX10.1 写掩码 k1 以 AVX512BW 指定的数量左移 xmm2 中的单词 OR xmm3/m128 ,同时在 0s 中移动.
EVEX.256.66.0F.WIG F1 /rVPSLLW ymm1 {k1}{z}, ymm2, xmm3/m128G有效有效使用 AVX10.1 写掩码 k1 以 AVX512BW 指定的数量左移 ymm2 中的单词 OR xmm3/m128 ,同时在 0s 中移动.
EVEX.512.66.0F.WIG F1 /rVPSLLW zmm1 {k1}{z}, zmm2, xmm3/m128G有效有效在使用 写掩码 k1 时,在 OR AVX10.1 xmm3/m128 中按照指定的数量左移 zmm2 中的单词。
EVEX.128.66.0F.WIG 71 /6 ibVPSLLW xmm1 {k1}{z}, xmm2/m128 imm8E有效有效使用 写掩码 k1. AVX10.1 以 imm8 左移 xmm2/m128 中的单词 , AVX512BW ) 或 零s 中移.
EVEX.256.66.0F.WIG 71 /6 ibVPSLLW ymm1 {k1}{z}, ymm2/m256 imm8E有效有效使用 写掩码 k1. AVX10.1 以 imm8 左移 ymm2/m256 中的单词 , AVX512BW ) 或 零s 中移.
EVEX.512.66.0F.WIG 71 /6 ibVPSLLW zmm1 {k1}{z}, zmm2/m512 imm8E有效有效在 imm8 时左移 zmm2/m512 中的单词,OR AVX10.1 使用 写掩码 k1 在 0 中移位.
EVEX.128.66.0F.W0 F2 /rVPSLLD xmm1 {k1}{z}, xmm2, xmm3/m128G有效有效在 xmm2 中以 量 AVX512F 左移双字 OR 指定在 xmm3/m128 中,同时在 writemask k1 下以 0s AVX10.1 移动双字.
EVEX.256.66.0F.W0 F2 /rVPSLLD ymm1 {k1}{z}, ymm2, xmm3/m128G有效有效在 ymm2 中以 量 AVX512F 左移双字 OR 指定在 xmm3/m128 中,同时在 writemask k1 下以 0s AVX10.1 移动双字.
EVEX.512.66.0F.W0 F2 /rVPSLLD zmm1 {k1}{z}, zmm2, xmm3/m128G有效有效移动双字zmm2按数额分列AVX10.1指定于xmm3/m128在 0s 下移动时写掩码 k1.
EVEX.128.66.0F.W0 72 /6 ibVPSLLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8F有效有效以 xmm2/m128/m32bcst 形式移动双词 OR 由 AVX512F 转换为 imm8 ,同时使用 writemask k1. AVX10.1 转换为 0s
EVEX.256.66.0F.W0 72 /6 ibVPSLLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8F有效有效以 ymm2/m256/m32bcst 形式移动双词 OR 由 AVX512F 转换为 imm8 ,同时使用 writemask k1. AVX10.1 转换为 0s
EVEX.512.66.0F.W0 72 /6 ibVPSLLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8F有效有效Zmm2/m512/m32bcst中的移位双字在0s使用写掩码 k1时由imm8离开OR AVX10.1.
EVEX.128.66.0F.W1 F3 /rVPSLLQ xmm1 {k1}{z}, xmm2, xmm3/m128 Opcode/ InstructionG有效有效以 xmm2 形式左移四字 以量 AVX512F 形式左移 OR 以 xmm3/m128 形式指定,同时使用 writemask k1 以 0s AVX10.1 形式移动。 Op/64/32 b it CPUID Featu 重新描述 En 模式支持旗帜
EVEX.256.66.0F.W1 F3 /rVPSLLQ ymm1 {k1}{z}, ymm2, xmm3/m128G有效有效Ymm2中的 ND Shift 四字以数量 AVX512F) OR 以 xmm3/m128 指定,同时使用 writemask k1 以 0s AVX10.1 转换.
EVEX.512.66.0F.W1 F3 /rVPSLLQ zmm1 {k1}{z}, zmm2, xmm3/m128G有效有效以 zmm2 键左移四字,以数量 OR AVX10.1 键在 xmm3/m128 键上指定,同时使用 writemask k1 键在 0s 键上移动.
EVEX.128.66.0F.W1 73 /6 ibVPSLLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8F有效有效Xmm2/m128/m64bcst中的 ND Shift 四个字左转 AVX512F) OR 由 imm8 在 0s 中移动时使用 writemask k1. AVX10.1
EVEX.256.66.0F.W1 73 /6 ibVPSLLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8F有效有效Ymm2/m256/m64bcst中的 ND Shift 四个字左转 AVX512F) OR 由 imm8 在 0s 中移动时使用 writemask k1. AVX10.1
EVEX.512.66.0F.W1 73 /6 ibVPSLLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8F有效有效Zmm2/m512/m64bcst中的四字移左 OR AVX10.1 由 imm8 转换为 0s 使用 写掩码 k1.

操作数编码

每个模式对应上表 Op/En 列的一个取值，说明各操作数按书写顺序分别编码在指令的哪个字段，以及指令对它是读、是写还是两者兼有。

A

  1. modrm.reg lectura y escrituraModRM 字节的 reg 字段（第 5-3 位）
  2. modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

B

  1. modrm.rm lectura y escrituraModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移
  2. imm8指令后的立即数字节

C

  1. modrm.reg escrituraModRM 字节的 reg 字段（第 5-3 位）
  2. vex.vvvv lecturaVEX 前缀的 vvvv 字段（按位取反）
  3. modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

D

  1. vex.vvvv escrituraVEX 前缀的 vvvv 字段（按位取反）
  2. modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移
  3. imm8指令后的立即数字节

E

  1. evex.vvvv escrituraEVEX 前缀的 vvvv 字段（按位取反）
  2. modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移
  3. imm8指令后的立即数字节

Tupla: Full Mem

F

  1. evex.vvvv escrituraEVEX 前缀的 vvvv 字段（按位取反）
  2. modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移
  3. imm8指令后的立即数字节

Tupla: Full

G

  1. modrm.reg escrituraModRM 字节的 reg 字段（第 5-3 位）
  2. evex.vvvv lecturaEVEX 前缀的 vvvv 字段（按位取反）
  3. modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

Tupla: Mem128

实测开销

正在从 arch-data 加载实测数据...

说明

将 目标操作数(第一个操作数)中单个数据元素中的位数(字,双字,或四字)按计数 操作数(第二个操作数)中指定的位数向左移动. 随着数据元素中的位位左移,空的低序位位被清除(设置为0). 如果计数操作数指定的值大于15(对于单词),31(对于双词),或63(对于四词),则目标操作数被设定为所有0s. 图4-17给出了一个在64位的操作数中移动单词的例子.

                   Pre-Shift   X3                           X2             X1    X0

DEST

左移,零扩展

       Post-Shift              X3 << COUNT              X2 << COUNT   X1 << COUNT X0 << COUNT

DEST

图4-17. PSLLW, PSLLD, 和 PSLLQ 指令操作 使用 64 位 操作数

(V)PSLLW 指令将 目标操作数 中每个单词向左移动,以 计数 操作数 中指定的位数; (V)PSLLD 指令将 目标操作数 中每个双词的位移; (V)PSLLQ 指令将 目标操作数 中四词(或四词)的位移.

在64位模式中,没有用VEX/EVEX编码,使用REX前缀形式为REX.R允许此指令访问额外的注册(XMM8-XMM15).

遗产 SSE 指令 64 位 操作数 : 目标操作数是一个MMX技术登记册;计数的操作数可以是MMX技术登记册,也可以是64位的内存位置技术登记册.

128位遗产 SSE 版本 : 目的地和第一个源操作数是XMM登记册. 相应的YMM目的地注册保持不变的位数(MAXVL-1:128). 计数的操作数可以是XMM寄存器,也可以是128位的内存位置,也可以是8位的即时寄存器. 如果计数操作数是一个内存地址,则128位被加载,但上64位被忽略.

VEX.128 编码版本 : 目的地和第一个源操作数是XMM登记册. 目的地YMM的位数(MAXVL-1:128)登记被清零. 计数的操作数可以是XMM寄存器,也可以是128位的内存位置,也可以是8位的即时寄存器. 如果计数操作数是一个内存地址,则128位被加载,但上64位被忽略.

VEX.256 编码版本 : 目标操作数是一个YMM登记册. 源操作数是一个YMM的寄存器或内存位置. 操作数的计数可以来自XMM的寄存器,也可以来自内存位置或8位即时. 对应的ZMM注册被清零的位数(MAXVL-1:256).

EVEX 编码版本 : 目标操作数是一个按照写掩码更新的ZMM登记册. 计数操作数要么是一个8位即时(即时计数版本),要么是一个XMM寄存器或内存位置(可变计数版本)的8位值. 对于即时计数版本,源操作数(第二个操作数)可以是ZMM寄存器,512位内存位置或512位向量从32/64位内存位置广播. 对于可变计数版本,第一源操作数(第二个操作数)是一个ZMM的寄存器,第二源操作数(第三个操作数,8位变量计数)可以是XMM寄存器或内存位置.

说明: 在VEX/EVEX编码的有即时计数的班次版本中,vvv的VEX/EVEX编码了目的地登记册,VEX.B/EVEX.B+ModRM.r/m编码了源登记册.

说明: 对于有即时计数的班次(VEX.128.66.0F 71-73qz 6,或EVEX.128.66.0F 71-73qz 6),VEX.vvvv/EVEX.vvvv编码目的地登记册.

行动

PSLLW (With 64-bit Operand)
    IF (COUNT > 15)
    THEN
          DEST[64:0] := 0000000000000000H;
    ELSE
         DEST[15:0] := ZeroExtend(DEST[15:0] << COUNT);
          (* Repeat shift operation for 2nd and 3rd words *)
         DEST[63:48] := ZeroExtend(DEST[63:48] << COUNT);
    FI;

PSLLD (with 64-bit operand)
    IF (COUNT > 31)
    THEN
          DEST[64:0] := 0000000000000000H;
    ELSE
         DEST[31:0] := ZeroExtend(DEST[31:0] << COUNT);
         DEST[63:32] := ZeroExtend(DEST[63:32] << COUNT);
    FI;

PSLLQ (With 64-bit Operand)
    IF (COUNT > 63)
    THEN
          DEST[64:0] := 0000000000000000H;
    ELSE


         DEST := ZeroExtend(DEST << COUNT);
    FI;

LOGICAL_LEFT_SHIFT_WORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 15)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
ELSE

    DEST[15:0] := ZeroExtend(SRC[15:0] << COUNT);
    (* Repeat shift operation for 2nd through 7th words *)
    DEST[127:112] := ZeroExtend(SRC[127:112] << COUNT);
FI;

LOGICAL_LEFT_SHIFT_DWORDS1(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[31:0] := 0
ELSE

    DEST[31:0] := ZeroExtend(SRC[31:0] << COUNT);
FI;

LOGICAL_LEFT_SHIFT_DWORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
ELSE

    DEST[31:0] := ZeroExtend(SRC[31:0] << COUNT);
    (* Repeat shift operation for 2nd through 3rd words *)
    DEST[127:96] := ZeroExtend(SRC[127:96] << COUNT);
FI;

LOGICAL_LEFT_SHIFT_QWORDS1(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN

    DEST[63:0] := 0
ELSE

    DEST[63:0] := ZeroExtend(SRC[63:0] << COUNT);
FI;

LOGICAL_LEFT_SHIFT_QWORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
ELSE

    DEST[63:0] := ZeroExtend(SRC[63:0] << COUNT);
    DEST[127:64] := ZeroExtend(SRC[127:64] << COUNT);
FI;
LOGICAL_LEFT_SHIFT_WORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];


IF (COUNT > 15)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
    DEST[255:128] := 00000000000000000000000000000000H
ELSE
    DEST[15:0] := ZeroExtend(SRC[15:0] << COUNT);
    (* Repeat shift operation for 2nd through 15th words *)
    DEST[255:240] := ZeroExtend(SRC[255:240] << COUNT);
FI;

LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
    DEST[255:128] := 00000000000000000000000000000000H
ELSE
    DEST[31:0] := ZeroExtend(SRC[31:0] << COUNT);
    (* Repeat shift operation for 2nd through 7th words *)
    DEST[255:224] := ZeroExtend(SRC[255:224] << COUNT);
FI;

LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
    DEST[255:128] := 00000000000000000000000000000000H
ELSE
    DEST[63:0] := ZeroExtend(SRC[63:0] << COUNT);
    DEST[127:64] := ZeroExtend(SRC[127:64] << COUNT)
    DEST[191:128] := ZeroExtend(SRC[191:128] << COUNT);
    DEST[255:192] := ZeroExtend(SRC[255:192] << COUNT);
FI;

VPSLLW (EVEX Versions, xmm/m128)
(KL, VL) = (8, 128), (16, 256), (32, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_LEFT_SHIFT_WORDS_128b(SRC1[127:0], SRC2)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1[255:0], SRC2)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1[255:0], SRC2)
    TMP_DEST[511:256] := LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1[511:256], SRC2)
FI;

FOR j := 0 TO KL-1                                 ; merging-masking
    i := j * 16
    IF k1[j] OR *no writemask*
          THEN DEST[i+15:i] := TMP_DEST[i+15:i]
          ELSE
                IF *merging-masking*


                 THEN *DEST[i+15:i] remains unchanged*

                 ELSE *zeroing-masking*            ; zeroing-masking

                    DEST[i+15:i] = 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPSLLW (EVEX Versions, imm8)
(KL, VL) = (8, 128), (16, 256), (32, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_LEFT_SHIFT_WORDS_128b(SRC1[127:0], imm8)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], imm8)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1[255:0], imm8)
    TMP_DEST[511:256] := LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1[511:256], imm8)
FI;

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN DEST[i+15:i] := TMP_DEST[i+15:i]

     ELSE

             IF *merging-masking*                  ; merging-masking

                 THEN *DEST[i+15:i] remains unchanged*

                 ELSE *zeroing-masking*            ; zeroing-masking

                    DEST[i+15:i] = 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPSLLW (ymm, ymm, xmm/m128) - VEX.256 Encoding
DEST[255:0] := LOGICAL_LEFT_SHIFT_WORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0;

VPSLLW (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_LEFT_SHIFT_WORD_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;

VPSLLW (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_LEFT_SHIFT_WORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSLLW (xmm, imm8) - VEX.128 Encoding
DEST[127:0] := LOGICAL_LEFT_SHIFT_WORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSLLW (xmm, xmm, xmm/m128)
DEST[127:0] := LOGICAL_LEFT_SHIFT_WORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)


PSLLW (xmm, imm8)
DEST[127:0] := LOGICAL_LEFT_SHIFT_WORDS(DEST, imm8)
DEST[MAXVL-1:128] (Unmodified)

VPSLLD (EVEX versions, imm8)

(KL, VL) = (4, 128), (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask* THEN

             IF (EVEX.b = 1) AND (SRC1 *is memory*)

                  THEN DEST[i+31:i] := LOGICAL_LEFT_SHIFT_DWORDS1(SRC1[31:0], imm8)

                  ELSE DEST[i+31:i] := LOGICAL_LEFT_SHIFT_DWORDS1(SRC1[i+31:i], imm8)

             FI;

     ELSE

             IF *merging-masking*                  ; merging-masking

                  THEN *DEST[i+31:i] remains unchanged*

                  ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+31:i] := 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPSLLD (EVEX Versions, xmm/m128)
(KL, VL) = (4, 128), (8, 256), (16, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_LEFT_SHIFT_DWORDS_128b(SRC1[127:0], SRC2)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1[255:0], SRC2)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1[255:0], SRC2)
    TMP_DEST[511:256] := LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1[511:256], SRC2)
FI;

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := TMP_DEST[i+31:i]

     ELSE

             IF *merging-masking*                  ; merging-masking

                  THEN *DEST[i+31:i] remains unchanged*

                  ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+31:i] := 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPSLLD (ymm, ymm, xmm/m128) - VEX.256 Encoding
DEST[255:0] := LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0;


VPSLLD (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_LEFT_SHIFT_DWORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;

VPSLLD (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_LEFT_SHIFT_DWORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSLLD (xmm, imm8) - VEX.128 Encoding
DEST[127:0] := LOGICAL_LEFT_SHIFT_DWORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSLLD (xmm, xmm, xmm/m128)
DEST[127:0] := LOGICAL_LEFT_SHIFT_DWORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)

PSLLD (xmm, imm8)
DEST[127:0] := LOGICAL_LEFT_SHIFT_DWORDS(DEST, imm8)
DEST[MAXVL-1:128] (Unmodified)

VPSLLQ (EVEX Versions, imm8)

(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask* THEN

             IF (EVEX.b = 1) AND (SRC1 *is memory*)

                  THEN DEST[i+63:i] := LOGICAL_LEFT_SHIFT_QWORDS1(SRC1[63:0], imm8)

                  ELSE DEST[i+63:i] := LOGICAL_LEFT_SHIFT_QWORDS1(SRC1[i+63:i], imm8)

             FI;

     ELSE

             IF *merging-masking*                  ; merging-masking

                  THEN *DEST[i+63:i] remains unchanged*

                  ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+63:i] := 0

             FI

FI;

ENDFOR

VPSLLQ (EVEX Versions, xmm/m128)
(KL, VL) = (2, 128), (4, 256), (8, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_LEFT_SHIFT_QWORDS_128b(SRC1[127:0], SRC2)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)
    TMP_DEST[511:256] := LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1[511:256], SRC2)
FI;

FOR j := 0 TO KL-1
    i := j * 64


IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := TMP_DEST[i+63:i]

     ELSE

        IF *merging-masking*                       ; merging-masking

            THEN *DEST[i+63:i] remains unchanged*

            ELSE *zeroing-masking*                 ; zeroing-masking

            DEST[i+63:i] := 0

        FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPSLLQ (ymm, ymm, xmm/m128) - VEX.256 Encoding
DEST[255:0] := LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0;

VPSLLQ (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_LEFT_SHIFT_QWORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;

VPSLLQ (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_LEFT_SHIFT_QWORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSLLQ (xmm, imm8) - VEX.128 Encoding
DEST[127:0] := LOGICAL_LEFT_SHIFT_QWORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSLLQ (xmm, xmm, xmm/m128)
DEST[127:0] := LOGICAL_LEFT_SHIFT_QWORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)

PSLLQ (xmm, imm8)
DEST[127:0] := LOGICAL_LEFT_SHIFT_QWORDS(DEST, imm8)
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ 内在编译器

VPSLLD __m512i _mm512_slli_epi32(__m512i a, unsigned int imm);
VPSLLD __m512i _mm512_mask_slli_epi32(__m512i s, __mmask16 k, __m512i a, unsigned int imm);
VPSLLD __m512i _mm512_maskz_slli_epi32( __mmask16 k, __m512i a, unsigned int imm);
VPSLLD __m256i _mm256_mask_slli_epi32(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSLLD __m256i _mm256_maskz_slli_epi32( __mmask8 k, __m256i a, unsigned int imm);
VPSLLD __m128i _mm_mask_slli_epi32(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSLLD __m128i _mm_maskz_slli_epi32( __mmask8 k, __m128i a, unsigned int imm);
VPSLLD __m512i _mm512_sll_epi32(__m512i a, __m128i cnt);
VPSLLD __m512i _mm512_mask_sll_epi32(__m512i s, __mmask16 k, __m512i a, __m128i cnt);
VPSLLD __m512i _mm512_maskz_sll_epi32( __mmask16 k, __m512i a, __m128i cnt);
VPSLLD __m256i _mm256_mask_sll_epi32(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSLLD __m256i _mm256_maskz_sll_epi32( __mmask8 k, __m256i a, __m128i cnt);
VPSLLD __m128i _mm_mask_sll_epi32(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSLLD __m128i _mm_maskz_sll_epi32( __mmask8 k, __m128i a, __m128i cnt);
VPSLLQ __m512i _mm512_mask_slli_epi64(__m512i a, unsigned int imm);
VPSLLQ __m512i _mm512_mask_slli_epi64(__m512i s, __mmask8 k, __m512i a, unsigned int imm);
VPSLLQ __m512i _mm512_maskz_slli_epi64( __mmask8 k, __m512i a, unsigned int imm);
VPSLLQ __m256i _mm256_mask_slli_epi64(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSLLQ __m256i _mm256_maskz_slli_epi64( __mmask8 k, __m256i a, unsigned int imm);
VPSLLQ __m128i _mm_mask_slli_epi64(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSLLQ __m128i _mm_maskz_slli_epi64( __mmask8 k, __m128i a, unsigned int imm);
VPSLLQ __m512i _mm512_mask_sll_epi64(__m512i a, __m128i cnt);
VPSLLQ __m512i _mm512_mask_sll_epi64(__m512i s, __mmask8 k, __m512i a, __m128i cnt);
VPSLLQ __m512i _mm512_maskz_sll_epi64( __mmask8 k, __m512i a, __m128i cnt);
VPSLLQ __m256i _mm256_mask_sll_epi64(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSLLQ __m256i _mm256_maskz_sll_epi64( __mmask8 k, __m256i a, __m128i cnt);
VPSLLQ __m128i _mm_mask_sll_epi64(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSLLQ __m128i _mm_maskz_sll_epi64( __mmask8 k, __m128i a, __m128i cnt);
VPSLLW __m512i _mm512_slli_epi16(__m512i a, unsigned int imm);
VPSLLW __m512i _mm512_mask_slli_epi16(__m512i s, __mmask32 k, __m512i a, unsigned int imm);
VPSLLW __m512i _mm512_maskz_slli_epi16( __mmask32 k, __m512i a, unsigned int imm);
VPSLLW __m256i _mm256_mask_slli_epi16(__m256i s, __mmask16 k, __m256i a, unsigned int imm);
VPSLLW __m256i _mm256_maskz_slli_epi16( __mmask16 k, __m256i a, unsigned int imm);
VPSLLW __m128i _mm_mask_slli_epi16(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSLLW __m128i _mm_maskz_slli_epi16( __mmask8 k, __m128i a, unsigned int imm);
VPSLLW __m512i _mm512_sll_epi16(__m512i a, __m128i cnt);
VPSLLW __m512i _mm512_mask_sll_epi16(__m512i s, __mmask32 k, __m512i a, __m128i cnt);
VPSLLW __m512i _mm512_maskz_sll_epi16( __mmask32 k, __m512i a, __m128i cnt);
VPSLLW __m256i _mm256_mask_sll_epi16(__m256i s, __mmask16 k, __m256i a, __m128i cnt);
VPSLLW __m256i _mm256_maskz_sll_epi16( __mmask16 k, __m256i a, __m128i cnt);
VPSLLW __m128i _mm_mask_sll_epi16(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSLLW __m128i _mm_maskz_sll_epi16( __mmask8 k, __m128i a, __m128i cnt);
PSLLW __m64 _mm_slli_pi16 (__m64 m, int count) PSLLW __m64 _mm_sll_pi16(__m64 m, __m64 count) (V)PSLLW __m128i _mm_slli_epi16(__m64 m, int count) (V)PSLLW __m128i _mm_sll_epi16(__m128i m, __m128i count) VPSLLW __m256i _mm256_slli_epi16 (__m256i m, int count) VPSLLW __m256i _mm256_sll_epi16 (__m256i m, __m128i count) PSLLD __m64 _mm_slli_pi32(__m64 m, int count) PSLLD __m64 _mm_sll_pi32(__m64 m, __m64 count) (V)PSLLD __m128i _mm_slli_epi32(__m128i m, int count) (V)PSLLD __m128i _mm_sll_epi32(__m128i m, __m128i count) VPSLLD __m256i _mm256_slli_epi32 (__m256i m, int count) VPSLLD __m256i _mm256_sll_epi32 (__m256i m, __m128i count) PSLLQ __m64 _mm_slli_si64(__m64 m, int count) PSLLQ __m64 _mm_sll_si64(__m64 m, __m64 count) (V)PSLLQ __m128i _mm_slli_epi64(__m128i m, int count) (V)PSLLQ __m128i _mm_sll_epi64(__m128i m, __m128i count) VPSLLQ __m256i _mm256_slli_epi64 (__m256i m, int count) VPSLLQ __m256i _mm256_sll_epi64 (__m256i m, __m128i count);

受影响的旗帜

None.

数字例外

None.

其他例外

--语法与MI/VMI 操作数编码(操作数编码表中的B/D),参见表2-24,"第7类例外条件".

E4NF 类例外条件".

来源