PSRAW, PSRAD, PSRAQ

右侧数据包算术

stableVMJITAOTinstruction

编码

操作码	指令	Op/En	64 位	兼容/传统	说明
`NP 0F E1 /r1`	`PSRAW mm, mm/m64`	A	有效	有效	以毫米为单位的字以毫米/m64右移,同时以符号位移.
`66 0F E1 /r`	`PSRAW xmm1, xmm2/m128`	A	有效	有效	右移 xmm1 中的单词由 xmm2/m128 移动,同时以符号位移.
`NP 0F 71 /4 ib1`	`PSRAW mm, imm8`	B	有效	有效	Imm8 右移以毫米表示的单词,同时以符号位移
`66 0F 71 /4 ib`	`PSRAW xmm1, imm8`	B	有效	有效	右移 xmm1 中的单词, 由 imm8 移动, 同时以符号位移
`NP 0F E2 /r1`	`PSRAD mm, mm/m64`	A	有效	有效	以毫米为单位的双字右移 mm/m64,同时以符号位移。
`66 0F E2 /r`	`PSRAD xmm1, xmm2/m128`	A	有效	有效	在xmm1右侧以xmm2 /m128移动双字,同时以符号位移.
`NP 0F 72 /4 ib1`	`PSRAD mm, imm8`	B	有效	有效	以毫米为单位的双字右转 imm8,同时以符号位移.
`66 0F 72 /4 ib`	`PSRAD xmm1, imm8`	B	有效	有效	在xmm1右侧以imm8移动双字,同时以符号位移.
`VEX.128.66.0F.WIG E1 /r`	`VPSRAW xmm1, xmm2, xmm3/m128`	C	有效	有效	按 xmm3/m128 指定的数量右移 xmm2 中的单词,同时以符号位移.
`VEX.128.66.0F.WIG 71 /4 ib`	`VPSRAW xmm1, xmm2, imm8`	D	有效	有效	右移 xmm2 中的单词由 imm8 移动,同时以符号位移.
`VEX.128.66.0F.WIG E2 /r`	`VPSRAD xmm1, xmm2, xmm3/m128`	C	有效	有效	按 xmm3/m128 指定的数量在 xmm2 右侧移动双字,同时以符号位移.
`VEX.128.66.0F.WIG 72 /4 ib`	`VPSRAD xmm1, xmm2, imm8`	D	有效	有效	在xmm2右侧以imm8移动双字,同时以符号位移.
`VEX.256.66.0F.WIG E1 /r`	`VPSRAW ymm1, ymm2, xmm3/m128`	C	有效	有效	按 xmm3/m128 指定的数量右移 ymm2 中的单词,同时以符号位移.
`VEX.256.66.0F.WIG 71 /4 ib`	`VPSRAW ymm1, ymm2, imm8`	D	有效	有效	右移 ymm2 中的单词由 imm8 移动,同时以符号位移.
`VEX.256.66.0F.WIG E2 /r`	`VPSRAD ymm1, ymm2, xmm3/m128`	C	有效	有效	按 xmm3/m128 指定的数量在 ymm2 右侧移动双字,同时以符号位移.
`VEX.256.66.0F.WIG 72 /4 ib`	`VPSRAD ymm1, ymm2, imm8`	D	有效	有效	在ymm2右侧以imm8移动双字,同时以符号位移.
`EVEX.128.66.0F.WIG E1 /r`	`VPSRAW xmm1 {k1}{z}, xmm2, xmm3/m128`	G	有效	有效	在使用 AVX10.1 写掩码 k1 的符号位移时,用 AVX512BW 右侧的 xmm2 或 xmm3/m128 的数值移动单词。
`EVEX.256.66.0F.WIG E1 /r`	`VPSRAW ymm1 {k1}{z}, ymm2, xmm3/m128`	G	有效	有效	在使用 AVX10.1 写掩码 k1 的符号位移时,用 AVX512BW 右侧的 ymm2 或 xmm3/m128 的数值移动单词。
`EVEX.512.66.0F.WIG E1 /r`	`VPSRAW zmm1 {k1}{z}, zmm2, xmm3/m128 Opcode/ Instruction`	G	有效	有效	移动单词在zmm2按指定数量或AVX10.1输入xmm3/m128在符号位中移动时使用写掩码 k1。 Op/64/32 位点CPUID特性描述模式支持旗帜
`EVEX.128.66.0F.WIG 71 /4 ib`	`VPSRAW xmm1 {k1}{z}, xmm2/m128 imm8`	E	有效	有效	在 xmm2/m128 中以 imm8 右移字,而 AVX512BW)OR AVX10.12 使用写掩码 k1 的符号位移字.
`EVEX.256.66.0F.WIG 71 /4 ib`	`VPSRAW ymm1 {k1}{z}, ymm2/m256 imm8`	E	有效	有效	在 ymm2/m256 中以 imm8 右移字,在 AVX512BW 中,使用写掩码 k1. AVX10.1 在符号位中移动字.
`EVEX.512.66.0F.WIG 71 /4 ib`	`VPSRAW zmm1 {k1}{z}, zmm2/m512 imm8`	E	有效	有效	右移 zmm2/m512 中的单词为 imm8 ,而 OR AVX10.1 则使用写掩码 k1 的符号位移.
`EVEX.128.66.0F.W0 E2 /r`	`VPSRAD xmm1 {k1}{z}, xmm2, xmm3/m128`	G	有效	有效	以量 AVX512F 右移 xmm2 中的双词 OR 以 xmm3/m128 指定,同时使用 writemask k1 以符号 AVX10.1 位移.
`EVEX.256.66.0F.W0 E2 /r`	`VPSRAD ymm1 {k1}{z}, ymm2, xmm3/m128`	G	有效	有效	以量 AVX512F 右移 ymm2 中的双词 OR 以 xmm3/m128 指定,同时使用 writemask k1 以符号 AVX10.1 位移.
`EVEX.512.66.0F.W0 E2 /r`	`VPSRAD zmm1 {k1}{z}, zmm2, xmm3/m128`	G	有效	有效	在使用写掩码 k1 的符号位移时,用 xmm3/m128 指定的量将 zmm2 右侧的双字移走 OR AVX10.1 。
`EVEX.128.66.0F.W0 72 /4 ib`	`VPSRAD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8`	F	有效	有效	以 xmm2/m128/m32bcst AVX512F)右移双字,由 imm8 右移,同时使用 AVX10.1 写掩码 k1 的符号位移.
`EVEX.256.66.0F.W0 72 /4 ib`	`VPSRAD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8`	F	有效	有效	以 ymm2/m256/m32bcst AVX512F)右移双字,由 imm8 右移,同时使用 AVX10.1 写掩码 k1 的符号位移.
`EVEX.512.66.0F.W0 72 /4 ib`	`VPSRAD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8`	F	有效	有效	以 zmm2/m512/m32bcst OR AVX10.1右移双字,以 imm8 移动,同时使用 writemask k1 的符号位移.
`EVEX.128.66.0F.W1 E2 /r`	`VPSRAQ xmm1 {k1}{z}, xmm2, xmm3/m128`	G	有效	有效	右移 xmm2 中的四字,用量 AVX512F) OR 在 xmm3/m128 中指定,同时使用 writemask k1 以符号 AVX10.1 位移.
`EVEX.256.66.0F.W1 E2 /r`	`VPSRAQ ymm1 {k1}{z}, ymm2, xmm3/m128`	G	有效	有效	右移 ymm2 中的四字,用量 AVX512F) OR 在 xmm3/m128 中指定,同时使用 writemask k1 以符号 AVX10.1 位移.
`EVEX.512.66.0F.W1 E2 /r`	`VPSRAQ zmm1 {k1}{z}, zmm2, xmm3/m128`	G	有效	有效	在使用写掩码 k1 的符号位移时,用 xmm3/m128 指定的量将 zmm2 中的四字移到 OR AVX10.1 中.
`EVEX.128.66.0F.W1 72 /4 ib`	`VPSRAQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8`	F	有效	有效	以 xmm2/m128/m64bcst 右侧的 AVX512F 或 imm8 移动四字,同时使用 AVX10.1 写掩码 k1 的符号位移.
`EVEX.256.66.0F.W1 72 /4 ib`	`VPSRAQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8`	F	有效	有效	以 ymm2/m256/m64bcst 右侧的 AVX512F 或 imm8 移动四字,同时使用 AVX10.1 写掩码 k1 的符号位移.
`EVEX.512.66.0F.W1 72 /4 ib`	`VPSRAQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8`	F	有效	有效	Zmm2/m512/m64bcst右侧 OR AVX10.1 以 imm8 移动四字,同时使用写掩码 k1 以符号位移.

操作数编码

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

A

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

B

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

C

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

D

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

E

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

Tupla: Full Mem

F

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

Tupla: Full

G

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

Tupla: Mem128

实测开销

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

说明

将目标操作数(第一个操作数)中单个数据元素中的位数(字,双字或四字)按计数操作数(第二个操作数)中指定的位数向右移动. 随着数据元素中的位移右转,空高序位被数据元素的符号位的初始值填充. 如果计数操作数指定的值大于15(对于单词),31(对于双词),或63(对于四字),则每个目的地数据元素都填充元素的符号位的初始值. (图4-18给出了一个在64位的操作数中移动单词的例子.

                   Pre-Shift    X3                     X2             X1  X0

DEST

右移带有符号扩展

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

DEST

图4-18. PSRAW 和 PSRAD 指令操作使用 64 位操作数

注意只检查128位计数操作数的前64位来计算计数. 如果第二源操作数是一个内存地址,则128位被加载.

(V)PSRAW 指令将目标操作数中每个单词按计数操作数中指定的位数向右移动,(V)PSRAD 指令将目标操作数中每个双词的位移.

在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-73/4,EVEX.128.66.0F 71-73q/4),VEX.vvvv/EVEX.vvvv编码目的地登记册.

行动

PSRAW (With 64-bit Operand)
    IF (COUNT > 15)
          THEN COUNT := 16;
    FI;
    DEST[15:0] := SignExtend(DEST[15:0] >> COUNT);
    (* Repeat shift operation for 2nd and 3rd words *)
    DEST[63:48] := SignExtend(DEST[63:48] >> COUNT);

PSRAD (with 64-bit operand)
    IF (COUNT > 31)
          THEN COUNT := 32;
    FI;
    DEST[31:0] := SignExtend(DEST[31:0] >> COUNT);
    DEST[63:32] := SignExtend(DEST[63:32] >> COUNT);

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

    DEST[31:0] := SignBit
ELSE

    DEST[31:0] := SignExtend(SRC[31:0] >> COUNT);
FI;

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

    DEST[63:0] := SignBit
ELSE

    DEST[63:0] := SignExtend(SRC[63:0] >> COUNT);
FI;

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

    THEN COUNT := 16;
FI;
DEST[15:0] := SignExtend(SRC[15:0] >> COUNT);

    (* Repeat shift operation for 2nd through 15th words *)
DEST[255:240] := SignExtend(SRC[255:240] >> COUNT);


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

    THEN COUNT := 32;
FI;
DEST[31:0] := SignExtend(SRC[31:0] >> COUNT);

    (* Repeat shift operation for 2nd through 7th words *)
DEST[255:224] := SignExtend(SRC[255:224] >> COUNT);

ARITHMETIC_RIGHT_SHIFT_QWORDS(SRC, COUNT_SRC, VL) ; VL: 128b, 256b or 512b
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)

    THEN COUNT := 64;
FI;
DEST[63:0] := SignExtend(SRC[63:0] >> COUNT);

    (* Repeat shift operation for 2nd through 7th words *)
DEST[VL-1:VL-64] := SignExtend(SRC[VL-1:VL-64] >> COUNT);

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

    THEN COUNT := 16;
FI;
DEST[15:0] := SignExtend(SRC[15:0] >> COUNT);

    (* Repeat shift operation for 2nd through 7th words *)
DEST[127:112] := SignExtend(SRC[127:112] >> COUNT);

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

    THEN COUNT := 32;
FI;
DEST[31:0] := SignExtend(SRC[31:0] >> COUNT);

    (* Repeat shift operation for 2nd through 3rd words *)
DEST[127:96] := SignExtend(SRC[127:96] >> COUNT);

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

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

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

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

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

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

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

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

VPSRAW (ymm, ymm, xmm/m128) - VEX
DEST[255:0] := ARITHMETIC_RIGHT_SHIFT_WORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0

VPSRAW (ymm, imm8) - VEX
DEST[255:0] := ARITHMETIC_RIGHT_SHIFT_WORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0

VPSRAW (xmm, xmm, xmm/m128) - VEX
DEST[127:0] := ARITHMETIC_RIGHT_SHIFT_WORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSRAW (xmm, imm8) - VEX
DEST[127:0] := ARITHMETIC_RIGHT_SHIFT_WORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSRAW (xmm, xmm, xmm/m128)


DEST[127:0] := ARITHMETIC_RIGHT_SHIFT_WORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)

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

VPSRAD (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] := ARITHMETIC_RIGHT_SHIFT_DWORDS1(SRC1[31:0], imm8)

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

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

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

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

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

VPSRAD (ymm, ymm, xmm/m128) - VEX


DEST[255:0] := ARITHMETIC_RIGHT_SHIFT_DWORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0

VPSRAD (ymm, imm8) - VEX
DEST[255:0] := ARITHMETIC_RIGHT_SHIFT_DWORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0

VPSRAD (xmm, xmm, xmm/m128) - VEX
DEST[127:0] := ARITHMETIC_RIGHT_SHIFT_DWORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSRAD (xmm, imm8) - VEX
DEST[127:0] := ARITHMETIC_RIGHT_SHIFT_DWORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

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

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

VPSRAQ (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] := ARITHMETIC_RIGHT_SHIFT_QWORDS1(SRC1[63:0], imm8)

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

VPSRAQ (EVEX Versions, xmm/m128)
(KL, VL) = (2, 128), (4, 256), (8, 512)
TMP_DEST[VL-1:0] := ARITHMETIC_RIGHT_SHIFT_QWORDS(SRC1[VL-1:0], SRC2, VL)

FOR j := 0 TO 7

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

Intel C/C++ 内在编译器

VPSRAD __m512i _mm512_srai_epi32(__m512i a, unsigned int imm);
VPSRAD __m512i _mm512_mask_srai_epi32(__m512i s, __mmask16 k, __m512i a, unsigned int imm);
VPSRAD __m512i _mm512_maskz_srai_epi32( __mmask16 k, __m512i a, unsigned int imm);
VPSRAD __m256i _mm256_mask_srai_epi32(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSRAD __m256i _mm256_maskz_srai_epi32( __mmask8 k, __m256i a, unsigned int imm);
VPSRAD __m128i _mm_mask_srai_epi32(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRAD __m128i _mm_maskz_srai_epi32( __mmask8 k, __m128i a, unsigned int imm);
VPSRAD __m512i _mm512_sra_epi32(__m512i a, __m128i cnt);
VPSRAD __m512i _mm512_mask_sra_epi32(__m512i s, __mmask16 k, __m512i a, __m128i cnt);
VPSRAD __m512i _mm512_maskz_sra_epi32( __mmask16 k, __m512i a, __m128i cnt);
VPSRAD __m256i _mm256_mask_sra_epi32(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRAD __m256i _mm256_maskz_sra_epi32( __mmask8 k, __m256i a, __m128i cnt);
VPSRAD __m128i _mm_mask_sra_epi32(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRAD __m128i _mm_maskz_sra_epi32( __mmask8 k, __m128i a, __m128i cnt);
VPSRAQ __m512i _mm512_srai_epi64(__m512i a, unsigned int imm);
VPSRAQ __m512i _mm512_mask_srai_epi64(__m512i s, __mmask8 k, __m512i a, unsigned int imm) VPSRAQ __m512i _mm512_maskz_srai_epi64( __mmask8 k, __m512i a, unsigned int imm) VPSRAQ __m256i _mm256_mask_srai_epi64(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSRAQ __m256i _mm256_maskz_srai_epi64( __mmask8 k, __m256i a, unsigned int imm);
VPSRAQ __m128i _mm_mask_srai_epi64(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRAQ __m128i _mm_maskz_srai_epi64( __mmask8 k, __m128i a, unsigned int imm);
VPSRAQ __m512i _mm512_sra_epi64(__m512i a, __m128i cnt);
VPSRAQ __m512i _mm512_mask_sra_epi64(__m512i s, __mmask8 k, __m512i a, __m128i cnt) VPSRAQ __m512i _mm512_maskz_sra_epi64( __mmask8 k, __m512i a, __m128i cnt) VPSRAQ __m256i _mm256_mask_sra_epi64(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRAQ __m256i _mm256_maskz_sra_epi64( __mmask8 k, __m256i a, __m128i cnt);
VPSRAQ __m128i _mm_mask_sra_epi64(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRAQ __m128i _mm_maskz_sra_epi64( __mmask8 k, __m128i a, __m128i cnt);
VPSRAW __m512i _mm512_srai_epi16(__m512i a, unsigned int imm);
VPSRAW __m512i _mm512_mask_srai_epi16(__m512i s, __mmask32 k, __m512i a, unsigned int imm);
VPSRAW __m512i _mm512_maskz_srai_epi16( __mmask32 k, __m512i a, unsigned int imm);
VPSRAW __m256i _mm256_mask_srai_epi16(__m256i s, __mmask16 k, __m256i a, unsigned int imm);
VPSRAW __m256i _mm256_maskz_srai_epi16( __mmask16 k, __m256i a, unsigned int imm);
VPSRAW __m128i _mm_mask_srai_epi16(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRAW __m128i _mm_maskz_srai_epi16( __mmask8 k, __m128i a, unsigned int imm);
VPSRAW __m512i _mm512_sra_epi16(__m512i a, __m128i cnt);
VPSRAW __m512i _mm512_mask_sra_epi16(__m512i s, __mmask16 k, __m512i a, __m128i cnt);
VPSRAW __m512i _mm512_maskz_sra_epi16( __mmask16 k, __m512i a, __m128i cnt);
VPSRAW __m256i _mm256_mask_sra_epi16(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRAW __m256i _mm256_maskz_sra_epi16( __mmask8 k, __m256i a, __m128i cnt);
VPSRAW __m128i _mm_mask_sra_epi16(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRAW __m128i _mm_maskz_sra_epi16( __mmask8 k, __m128i a, __m128i cnt);
PSRAW __m64 _mm_srai_pi16 (__m64 m, int count) PSRAW __m64 _mm_sra_pi16 (__m64 m, __m64 count) (V)PSRAW __m128i _mm_srai_epi16(__m128i m, int count) (V)PSRAW __m128i _mm_sra_epi16(__m128i m, __m128i count) VPSRAW __m256i _mm256_srai_epi16 (__m256i m, int count) VPSRAW __m256i _mm256_sra_epi16 (__m256i m, __m128i count) PSRAD __m64 _mm_srai_pi32 (__m64 m, int count) PSRAD __m64 _mm_sra_pi32 (__m64 m, __m64 count) (V)PSRAD __m128i _mm_srai_epi32 (__m128i m, int count) (V)PSRAD __m128i _mm_sra_epi32 (__m128i m, __m128i count) VPSRAD __m256i _mm256_srai_epi32 (__m256i m, int count) VPSRAD __m256i _mm256_sra_epi32 (__m256i m, __m128i count);

受影响的旗帜

None.

数字例外

None.

其他例外

VEX 编码指令 :

语法与RM/RVM 操作数编码(操作数编码表中的A/C),参见表2-21"第4类例外条件".

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

EVEX-encoded VPSRAW(E in the 操作数编码表),参见表2-52中的例外类型 E4NF.nb,"Type"

E4NF 类例外条件".

EVEX - 编码为VPSRAD/Q:

语法上与Mem128的tuple类型(操作数编码表中的G),参见表2-52中的例外类型E4NF.nb,"Type E4NF类例外条件".

语法与全Tuple类型(操作数编码表中的F),参见表2-51,"Type E4类例外条件".

PSRAW, PSRAD, PSRAQ

编码

操作数编码

A

B

C

D

E

F

G

实测开销

说明#

行动#

Intel C/C++ 内在编译器#

受影响的旗帜#

数字例外#

其他例外#

来源

说明

行动

Intel C/C++ 内在编译器

受影响的旗帜

数字例外

其他例外