Vesta
中文
源代码

PSRLW, PSRLD, PSRLQ

右移包装数据逻辑

stableVMJITAOTinstruction

编码

操作码指令Op/En64 位兼容/传统说明
NP 0F D1 /r1PSRLW mm, mm/m64A有效有效以毫米/ m64 指定数量,在0s 中以毫米右移字。
66 0F D1 /rPSRLW xmm1, xmm2/m128A有效有效按 xmm2/m128 指定的数量将 xmm1 右侧的单词移到 0s 中。
NP 0F 71 /2 ib1PSRLW mm, imm8B有效有效右移以毫米表示的单词, 由 imm8 在 0s 中移动 。
66 0F 71 /2 ibPSRLW xmm1, imm8B有效有效右移 xmm1 中的单词由 imm8 在 0s 中移动 。
NP 0F D2 /r1PSRLD mm, mm/m64A有效有效以毫米/ m64 指定数量,在0s 中以毫米右移双字。
66 0F D2 /rPSRLD xmm1, xmm2/m128A有效有效按 xmm2 / m128 中指定的数量,将 xmm1 右侧的双字移到 0s 中.
NP 0F 72 /2 ib1PSRLD mm, imm8B有效有效以毫米为单位的双字右移由 imm8 进行,以 0s 为单位。
66 0F 72 /2 ibPSRLD xmm1, imm8B有效有效右移 xmm1 中的双字,以 imm8 为单位,同时在 0s 中移动.
NP 0F D3 /r1PSRLQ mm, mm/m64A有效有效以 mm/m64 表示的量向右移动毫米, 以 0s 表示。
66 0F D3 /rPSRLQ xmm1, xmm2/m128A有效有效按 xmm2/m128 指定的数量将 xmm1 右侧的四字移到 0s 中。
NP 0F 73 /2 ib1PSRLQ mm, imm8B有效有效右移mm 由 imm8 在 0s 中移动时 。
66 0F 73 /2 ibPSRLQ xmm1, imm8B有效有效右移 xmm1 中的四字,以 imm8 为单位,同时在 0s 中移动.
VEX.128.66.0F.WIG D1 /rVPSRLW xmm1, xmm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量将 xmm2 右侧的单词移到 0s 中。
VEX.128.66.0F.WIG 71 /2 ibVPSRLW xmm1, xmm2, imm8D有效有效右移 xmm2 中的单词由 imm8 在 0s 中移动 。
VEX.128.66.0F.WIG D2 /rVPSRLD xmm1, xmm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量将 xmm2 右侧的双字移到 0s 中。
VEX.128.66.0F.WIG 72 /2 ibVPSRLD xmm1, xmm2, imm8D有效有效右移 xmm2 中的双字,以 imm8 为单位,同时在 0s 中移动.
VEX.128.66.0F.WIG D3 /rVPSRLQ xmm1, xmm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量将 xmm2 右侧的四字移到 0s 中。
VEX.128.66.0F.WIG 73 /2 ibVPSRLQ xmm1, xmm2, imm8D有效有效右移 xmm2 中的四字,以 imm8 为单位,同时在 0s 中移动.
VEX.256.66.0F.WIG D1 /rVPSRLW ymm1, ymm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量将 ymm2 右侧的单词移到 0s 中。
VEX.256.66.0F.WIG 71 /2 ibVPSRLW ymm1, ymm2, imm8 Opcode/ InstructionD有效有效右移 ymm2 中的单词, 由 imm8 转换为 0s 。 Op/ 64/ 32 bit CPUID 特性描述为模式支持旗
VEX.256.66.0F.WIG D2 /rVPSRLD ymm1, ymm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量将 ymm2 右侧的双字移到 0s 中。
VEX.256.66.0F.WIG 72 /2 ibVPSRLD ymm1, ymm2, imm8D有效有效右移 ymm2 中的双字,以 imm8 为单位,同时在 0s 中移动.
VEX.256.66.0F.WIG D3 /rVPSRLQ ymm1, ymm2, xmm3/m128C有效有效按 xmm3/m128 指定的数量将 ymm2 右侧的四字移到 0s 中。
VEX.256.66.0F.WIG 73 /2 ibVPSRLQ ymm1, ymm2, imm8D有效有效右移 ymm2 中的四字,以 imm8 为单位,同时在 0s 中移动.
EVEX.128.66.0F.WIG D1 /rVPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128G有效有效Xmm2右侧的字按照指定的数量移动 AVX512BW) OR AVX10.1 在xmm3/m128中移动,同时使用写掩码 k1在0s中移动.
EVEX.256.66.0F.WIG D1 /rVPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128G有效有效Ymm2右侧的字按照指定的数量移动 AVX512BW) OR AVX10.1 在xmm3/m128中移动,同时使用写掩码 k1在0s中移动.
EVEX.512.66.0F.WIG D1 /rVPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128G有效有效移动单词在zmm2按指定数量分列的权利AVX10.1输入xmm3/m128使用 0s 移动时写掩码 k1.
EVEX.128.66.0F.WIG 71 /2 ibVPSRLW xmm1 {k1}{z}, xmm2/m128, imm8E有效有效右移 xmm2/m128 中的单词由 imm8 AVX512BW) OR AVX10.1 在 0s 中使用 写掩码 k1 进行移动.
EVEX.256.66.0F.WIG 71 /2 ibVPSRLW ymm1 {k1}{z}, ymm2/m256, imm8E有效有效右移 ymm2/m256 中的单词由 imm8 AVX512BW) OR AVX10.1 在 0s 中使用 写掩码 k1 进行移动.
EVEX.512.66.0F.WIG 71 /2 ibVPSRLW zmm1 {k1}{z}, zmm2/m512, imm8E有效有效右移 zmm2/m512 中的单词由 imm8 AVX10.1 转换为 0s 使用 写掩码 k1.
EVEX.128.66.0F.W0 D2 /rVPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128G有效有效在使用 写掩码 k1 的 0s 中移动 xmm2 右侧的双字,以 量 AVX512F 表示) OR AVX10.1 指定 xmm3/m128 的双字.
EVEX.256.66.0F.W0 D2 /rVPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128G有效有效在使用 写掩码 k1 的 0s 中移动 ymm2 右侧的双字,以 量 AVX512F 表示) OR AVX10.1 指定 xmm3/m128 的双字.
EVEX.512.66.0F.W0 D2 /rVPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128G有效有效在使用 写掩码 k1 时,用 xmm3/m128 指定的量将 zmm2 右侧的双字移位 OR AVX10.1 。
EVEX.128.66.0F.W0 72 /2 ibVPSRLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8F有效有效以 xmm2/m128/m32bcst AVX512F)右移双字,以 imm8为单位,同时使用 AVX10.1 写掩码 k1在 0s 中移位.
EVEX.256.66.0F.W0 72 /2 ibVPSRLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8F有效有效以 ymm2/m256/m32bcst AVX512F)右移双字,以 imm8为单位,同时使用 AVX10.1 写掩码 k1在 0s 中移位.
EVEX.512.66.0F.W0 72 /2 ibVPSRLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8F有效有效以 zmm2/m512/m32bcst OR AVX10.1右移双字,以 imm8为单位,同时使用 写掩码 k1 进行0s 的移动.
EVEX.128.66.0F.W1 D3 /rVPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 Opcode/ InstructionG有效有效使用 writemask k1 移动 xmm2 右侧的四字,用量为 AVX512F ) OR AVX10.1 指定 xmm3/m128 ,同时在 0s 中使用 writemask k1 移动. Op/64/32 bit CPUID 特性描述 模式支持旗
EVEX.256.66.0F.W1 D3 /rVPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128G有效有效在使用 写掩码 k1 的 0s 中移动 ymm2 右侧的四字,以 量 AVX512F 表示) OR AVX10.1 指定 xmm3/m128 的四字.
EVEX.512.66.0F.W1 D3 /rVPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128G有效有效在使用 writemask k1 时,用 xmm3/m128 指定的量向 zmm2 右移四字 OR AVX10.1 。
EVEX.128.66.0F.W1 73 /2 ibVPSRLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8F有效有效以 xmm2/m128/m64bcst AVX512F)右移四字,以 imm8为单位,同时使用 AVX10.1 写掩码 k1在0s 中移动.
EVEX.256.66.0F.W1 73 /2 ibVPSRLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8F有效有效以 ymm2/m256/m64bcst AVX512F)右移四字,以 imm8为单位,同时使用 AVX10.1 写掩码 k1在0s 中移动.
EVEX.512.66.0F.W1 73 /2 ibVPSRLQ 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-19给出了一个在64位的操作数中移动单词的例子.

注意只检查128位计数操作数的低64位计算数.

Pre-Shift X3 X2 X1 X0 DEST

右移为零扩展

后闪存X3>> COUNT X2 >> COUNT X1 >> COUNT X0 >> COUNT DEST

图4-19. PSRLW, PSRLD, 和 PSRLQ 指令操作 使用 64 位 操作数

(V)PSRLW 指令将 目标操作数 中每个单词按计数 操作数 中指定的位数向右移动; (V)PSRLD 指令将 目标操作数 中每个双词的位移; PSRLQ 指令将 目标操作数 中的四词(或四词)移位.

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

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

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

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

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 2,或EVEX.128.66.0F 71-73qz /2),VEX.vvvv/EVEX.vvvv编码目的地注册.

行动

PSRLW (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;


PSRLD (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;

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

LOGICAL_RIGHT_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_RIGHT_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_RIGHT_SHIFT_WORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 15)
THEN

    DEST[255:0] := 0
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_RIGHT_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_RIGHT_SHIFT_DWORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[255:0] := 0
ELSE

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

LOGICAL_RIGHT_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_RIGHT_SHIFT_QWORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN
    DEST[255:0] := 0
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;

LOGICAL_RIGHT_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;

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

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

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

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], SRC2)


    TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[511:256], SRC2)
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

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

    TMP_DEST[127:0] := LOGICAL_RIGHT_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_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], imm8)
    TMP_DEST[511:256] := LOGICAL_RIGHT_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

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

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


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

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

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

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

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

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

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

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC1[255:0], SRC2)
    TMP_DEST[511:256] := LOGICAL_RIGHT_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

VPSRLD (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_RIGHT_SHIFT_DWORDS1(SRC1[31:0], imm8)

                  ELSE DEST[i+31:i] := LOGICAL_RIGHT_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

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

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

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

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

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

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

VPSRLQ (EVEX Versions, xmm/m128)

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

TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)

TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[511:256], SRC2)

IF VL = 128

     TMP_DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS_128b(SRC1[127:0], SRC2)

FI;

IF VL = 256

     TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)

FI;

IF VL = 512

     TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)

     TMP_DEST[511:256] := LOGICAL_RIGHT_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

VPSRLQ (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_RIGHT_SHIFT_QWORDS1(SRC1[63:0], imm8)

                  ELSE DEST[i+63:i] := LOGICAL_RIGHT_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

DEST[MAXVL-1:VL] := 0

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

VPSRLQ (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;
VPSRLQ (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

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

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

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

Intel C/C++ 内在编译器

VPSRLD __m512i _mm512_srli_epi32(__m512i a, unsigned int imm);
VPSRLD __m512i _mm512_mask_srli_epi32(__m512i s, __mmask16 k, __m512i a, unsigned int imm);
VPSRLD __m512i _mm512_maskz_srli_epi32( __mmask16 k, __m512i a, unsigned int imm);
VPSRLD __m256i _mm256_mask_srli_epi32(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSRLD __m256i _mm256_maskz_srli_epi32( __mmask8 k, __m256i a, unsigned int imm);
VPSRLD __m128i _mm_mask_srli_epi32(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRLD __m128i _mm_maskz_srli_epi32( __mmask8 k, __m128i a, unsigned int imm);
VPSRLD __m512i _mm512_srl_epi32(__m512i a, __m128i cnt);
VPSRLD __m512i _mm512_mask_srl_epi32(__m512i s, __mmask16 k, __m512i a, __m128i cnt);
VPSRLD __m512i _mm512_maskz_srl_epi32( __mmask16 k, __m512i a, __m128i cnt);
VPSRLD __m256i _mm256_mask_srl_epi32(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRLD __m256i _mm256_maskz_srl_epi32( __mmask8 k, __m256i a, __m128i cnt);
VPSRLD __m128i _mm_mask_srl_epi32(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRLD __m128i _mm_maskz_srl_epi32( __mmask8 k, __m128i a, __m128i cnt);
VPSRLQ __m512i _mm512_srli_epi64(__m512i a, unsigned int imm);
VPSRLQ __m512i _mm512_mask_srli_epi64(__m512i s, __mmask8 k, __m512i a, unsigned int imm);
VPSRLQ __m512i _mm512_mask_srli_epi64( __mmask8 k, __m512i a, unsigned int imm);
VPSRLQ __m256i _mm256_mask_srli_epi64(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSRLQ __m256i _mm256_maskz_srli_epi64( __mmask8 k, __m256i a, unsigned int imm);
VPSRLQ __m128i _mm_mask_srli_epi64(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRLQ __m128i _mm_maskz_srli_epi64( __mmask8 k, __m128i a, unsigned int imm);
VPSRLQ __m512i _mm512_srl_epi64(__m512i a, __m128i cnt);
VPSRLQ __m512i _mm512_mask_srl_epi64(__m512i s, __mmask8 k, __m512i a, __m128i cnt);
VPSRLQ __m512i _mm512_mask_srl_epi64( __mmask8 k, __m512i a, __m128i cnt);
VPSRLQ __m256i _mm256_mask_srl_epi64(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRLQ __m256i _mm256_maskz_srl_epi64( __mmask8 k, __m256i a, __m128i cnt);
VPSRLQ __m128i _mm_mask_srl_epi64(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRLQ __m128i _mm_maskz_srl_epi64( __mmask8 k, __m128i a, __m128i cnt);
VPSRLW __m512i _mm512_srli_epi16(__m512i a, unsigned int imm);
VPSRLW __m512i _mm512_mask_srli_epi16(__m512i s, __mmask32 k, __m512i a, unsigned int imm);
VPSRLW __m512i _mm512_maskz_srli_epi16( __mmask32 k, __m512i a, unsigned int imm);
VPSRLW __m256i _mm256_mask_srli_epi16(__m256i s, __mmask16 k, __m256i a, unsigned int imm);
VPSRLW __m256i _mm256_maskz_srli_epi16( __mmask16 k, __m256i a, unsigned int imm);
VPSRLW __m128i _mm_mask_srli_epi16(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRLW __m128i _mm_maskz_srli_epi16( __mmask8 k, __m128i a, unsigned int imm);
VPSRLW __m512i _mm512_srl_epi16(__m512i a, __m128i cnt);
VPSRLW __m512i _mm512_mask_srl_epi16(__m512i s, __mmask32 k, __m512i a, __m128i cnt);
VPSRLW __m512i _mm512_maskz_srl_epi16( __mmask32 k, __m512i a, __m128i cnt);
VPSRLW __m256i _mm256_mask_srl_epi16(__m256i s, __mmask16 k, __m256i a, __m128i cnt);
VPSRLW __m256i _mm256_maskz_srl_epi16( __mmask8 k, __mmask16 a, __m128i cnt);
VPSRLW __m128i _mm_mask_srl_epi16(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRLW __m128i _mm_maskz_srl_epi16( __mmask8 k, __m128i a, __m128i cnt);
PSRLW __m64 _mm_srli_pi16(__m64 m, int count) PSRLW __m64 _mm_srl_pi16 (__m64 m, __m64 count) (V)PSRLW __m128i _mm_srli_epi16 (__m128i m, int count) (V)PSRLW __m128i _mm_srl_epi16 (__m128i m, __m128i count) VPSRLW __m256i _mm256_srli_epi16 (__m256i m, int count) VPSRLW __m256i _mm256_srl_epi16 (__m256i m, __m128i count) PSRLD __m64 _mm_srli_pi32 (__m64 m, int count) PSRLD __m64 _mm_srl_pi32 (__m64 m, __m64 count) (V)PSRLD __m128i _mm_srli_epi32 (__m128i m, int count) (V)PSRLD __m128i _mm_srl_epi32 (__m128i m, __m128i count) VPSRLD __m256i _mm256_srli_epi32 (__m256i m, int count) VPSRLD __m256i _mm256_srl_epi32 (__m256i m, __m128i count) PSRLQ __m64 _mm_srli_si64 (__m64 m, int count) PSRLQ __m64 _mm_srl_si64 (__m64 m, __m64 count) (V)PSRLQ __m128i _mm_srli_epi64 (__m128i m, int count) (V)PSRLQ __m128i _mm_srl_epi64 (__m128i m, __m128i count) VPSRLQ __m256i _mm256_srli_epi64 (__m256i m, int count) VPSRLQ __m256i _mm256_srl_epi64 (__m256i m, __m128i count);

受影响的旗帜

None.

数字例外

None.

其他例外

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

E4NF 类例外条件".

来源