PMOVSX

用符号扩展包装移动

stableVMJITAOTinstruction

编码

操作码	指令	Op/En	64 位	兼容/传统	说明
`66 0f 38 20 /r`	`PMOVSXBW xmm1, xmm2/m64`	A	有效	有效	在低 8 字节中签名 8 块8 位整数xmm2/m64到8个装入的16位整数xmm1.
`66 0f 38 21 /r`	`PMOVSXBD xmm1, xmm2/m32`	A	有效	有效	在 4 字节的低位数中签名 4 个装填的 8 位整数xmm2/m32到4个装入的32位整数xmm1.
`66 0f 38 22 /r`	`PMOVSXBQ xmm1, xmm2/m16`	A	有效	有效	在xmm2/m16的低2字节中,签名将2个已包装的8位整数扩展为2个已包装的64位整数. xmm1.
`66 0f 38 23/r`	`PMOVSXWD xmm1, xmm2/m64`	A	有效	有效	在低 8 字节中签名 4 个装填的 16 位整数xmm2/m64到4个装入的32位整数xmm1.
`66 0f 38 24 /r`	`PMOVSXWQ xmm1, xmm2/m32`	A	有效	有效	在xmm2/m32的低4字节中,签名将2个装箱的16位整数扩展为2个装箱的64位整数. xmm1.
`66 0f 38 25 /r`	`PMOVSXDQ xmm1, xmm2/m64`	A	有效	有效	在xmm2/m64的低8字节中,签名将2个已包装的32位整数扩展为2个已包装的64位整数. xmm1.
`VEX.128.66.0F38.WIG 20 /r`	`VPMOVSXBW xmm1, xmm2/m64`	A	有效	有效	在低 8 字节中签名 8 块8 位整数xmm2/m64到8个装入的16位整数xmm1.
`VEX.128.66.0F38.WIG 21 /r`	`VPMOVSXBD xmm1, xmm2/m32`	A	有效	有效	在 4 字节的低位数中签名 4 个装填的 8 位整数xmm2/m32到4个装入的32位整数xmm1.
`VEX.128.66.0F38.WIG 22 /r`	`VPMOVSXBQ xmm1, xmm2/m16`	A	有效	有效	在xmm2/m16的低2字节中,签名将2个已包装的8位整数扩展为2个已包装的64位整数. xmm1.
`VEX.128.66.0F38.WIG 23 /r`	`VPMOVSXWD xmm1, xmm2/m64`	A	有效	有效	在低 8 字节中签名 4 个装填的 16 位整数xmm2/m64到4个装入的32位整数xmm1.
`VEX.128.66.0F38.WIG 24 /r`	`VPMOVSXWQ xmm1, xmm2/m32`	A	有效	有效	在xmm2/m32的低4字节中,签名将2个装箱的16位整数扩展为2个装箱的64位整数. xmm1.
`VEX.128.66.0F38.WIG 25 /r`	`VPMOVSXDQ xmm1, xmm2/m64`	A	有效	有效	在xmm2/m64的低8字节中,签名将2个已包装的32位整数扩展为2个已包装的64位整数. xmm1.
`VEX.256.66.0F38.WIG 20 /r`	`VPMOVSXBW ymm1, xmm2/m128`	A	有效	有效	签名将xmm2/m128的16个已包装的8位整数扩展至ymm1的16个已包装的16位整数.
`VEX.256.66.0F38.WIG 21 /r`	`VPMOVSXBD ymm1, xmm2/m64`	A	有效	有效	在低 8 字节中签名 8 块8 位整数xmm2/m64到8个装入的32位整数ymm1.
`VEX.256.66.0F38.WIG 22 /r`	`VPMOVSXBQ ymm1, xmm2/m32`	A	有效	有效	在xmm2/m32的低4字节中,签名将4个已包装的8位整数扩展至4个已包装的64位整数. ymm1.
`VEX.256.66.0F38.WIG 23 /r`	`VPMOVSXWD ymm1, xmm2/m128`	A	有效	有效	在 16 字节的低位数中, 签名扩展 8 块 16 位整数xmm2/m128到8个装入的32位整数ymm1.
`VEX.256.66.0F38.WIG 24 /r`	`VPMOVSXWQ ymm1, xmm2/m64`	A	有效	有效	在低 8 字节中签名 4 个装填的 16 位整数xmm2/m64至 4 个装填的64位整数ymm1.
`VEX.256.66.0F38.WIG 25 /r`	`VPMOVSXDQ ymm1, xmm2/m128 Opcode/ Instruction`	A	有效	有效	签名将 xmm2/m128 的 16 字节中的 4 个装入的 32 位整数扩展为 ymm1 中的 4 个装入的 64 位整数。 Op / 64/ 32 位 CPUID 特性描述模式支持旗
`EVEX.128.66.0F38.WIG 20 /r`	`VPMOVSXBW xmm1 {k1}{z}, xmm2/m64`	B	有效	有效	签名将 xmm2/m64 的 8 个装填的 8 位整数扩展为 AVX512BW 或 8 个装填的 16 位整数。 zmm1 。 AVX10.1
`EVEX.256.66.0F38.WIG 20 /r`	`VPMOVSXBW ymm1 {k1}{z}, xmm2/m128`	B	有效	有效	签名将 xmm2/m128 AVX512BW 的 16 个已包装的 8 位整数扩展为 ymm1 的 16 个已包装的 16 位整数. AVX10.1
`EVEX.512.66.0F38.WIG 20 /r`	`VPMOVSXBW zmm1 {k1}{z}, ymm2/m256`	B	有效	有效	符号将ymm2/m256 OR AVX10.1中的32个已包装的8位整数扩展为zmm1中的32个已包装的16位整数.
`EVEX.128.66.0F38.WIG 21 /r`	`VPMOVSXBD xmm1 {k1}{z}, xmm2/m32`	C	有效	有效	在低4字节AVX512F)或xmm2/m32中,签名将4个装箱的8位整数扩展为4个装箱的32位整数,在xmm1,AVX10.1中必须写出k1.
`EVEX.256.66.0F38.WIG 21 /r`	`VPMOVSXBD ymm1 {k1}{z}, xmm2/m64`	C	有效	有效	在低8字节AVX512F)或xmm2/m64中,签名将8个装箱的8位整数扩展为8个装箱的32位整数,在ymm1,AVX10.1中必须写出k1.
`EVEX.512.66.0F38.WIG 21 /r`	`VPMOVSXBD zmm1 {k1}{z}, xmm2/m128`	C	有效	有效	在xmm2/m128的低16OR AVX10.1字节中,签名将16个已包装的8位整数扩展至zmm1的16个已包装的32位整数,以写作k1.
`EVEX.128.66.0F38.WIG 22 /r`	`VPMOVSXBQ xmm1 {k1}{z}, xmm2/m16`	D	有效	有效	在低2字节AVX512F)或xmm2/m16的符号中,将2个装箱的8位整数扩展为2个装箱的64位整数,在xmm1,AVX10.1的符号中,必须写出k1.
`EVEX.256.66.0F38.WIG 22 /r`	`VPMOVSXBQ ymm1 {k1}{z}, xmm2/m32`	D	有效	有效	在低4字节AVX512F)或xmm2/m32中,签名将4个装箱的8位整数扩展为4个装箱的64位整数,在ymm1,AVX10.1中以写入mask k1为对象.
`EVEX.512.66.0F38.WIG 22 /r`	`VPMOVSXBQ zmm1 {k1}{z}, xmm2/m64`	D	有效	有效	在xmm2/m64的低8字节或AVX10.1中,签名将8个已包装的8位整数扩展为8个已包装的64位整数,在zmm1中,必须写作k1.
`EVEX.128.66.0F38.WIG 23 /r`	`VPMOVSXWD xmm1 {k1}{z}, xmm2/m64`	B	有效	有效	标志在低位8 AVX512F)或字节ymm2/mem中将4个已包装的16位整数延伸至AVX10.1 xmm1中4个已包装的32位整数,受写掩码 k1的限制.
`EVEX.256.66.0F38.WIG 23 /r`	`VPMOVSXWD ymm1 {k1}{z}, xmm2/m128`	B	有效	有效	在低位的16 AVX512F)或ymm2/m128的字节中,签名将8个装入的16位整数扩展为8个装入的32位整数,在AVX10.1ymm1中以写入的k1为对象.
`EVEX.512.66.0F38.WIG 23 /r`	`VPMOVSXWD zmm1 {k1}{z}, ymm2/m256`	B	有效	有效	在ymm2/m256的低32 OR AVX10.1字节中,签名将16个已包装的16位整数延伸至zmm1的16个已包装的32位整数,以写掩码 k1为限.
`EVEX.128.66.0F38.WIG 24 /r`	`VPMOVSXWQ xmm1 {k1}{z}, xmm2/m32`	C	有效	有效	在低4AVX512F)或xmm2/m32的字节中,签名将2个装入的16位整数扩展为2个装入的64位整数,在AVX10.1xmm1中,以写作mask k1为对象.
`EVEX.256.66.0F38.WIG 24 /r`	`VPMOVSXWQ ymm1 {k1}{z}, xmm2/m64`	C	有效	有效	标志在低8 AVX512F)或xmm2/m64的字节中将4个已装入的16位整数扩展为4个已装入的64位整数,在AVX10.1ymm1中以写入mask k1为对象.
`EVEX.512.66.0F38.WIG 24 /r`	`VPMOVSXWQ zmm1 {k1}{z}, xmm2/m128`	C	有效	有效	在xmm2/m128的低16OR AVX10.1字节中,签名将8个装入的16位整数扩展至zmm1的8个装入的64位整数,以写作k1.
`EVEX.128.66.0F38.W0 25 /r`	`VPMOVSXDQ xmm1 {k1}{z}, xmm2/m64 Opcode/ Instruction`	B	有效	有效	在低 8 中签名扩展 2 块32 位整数AVX512F或字节xmm2/m64至 2 个装填的64位整数AVX10.1 zmm1使用写掩码 k1。 Op 64/32 位点CPUIDFeatur e 描述模式支持旗帜
`EVEX.256.66.0F38.W0 25 /r`	`VPMOVSXDQ ymm1 {k1}{z}, xmm2/m128`	B	有效	有效	D 符号扩展 4 个装填的 32 位整数AVX512F或字节xmm2/m128至 4 个装填的64位整数AVX10.1 zmm1使用写掩码 k1.
`EVEX.512.66.0F38.W0 25 /r`	`VPMOVSXDQ zmm1 {k1}{z}, ymm2/m256`	B	有效	有效	在低32 OR 中签名扩展 8 块32 位整数AVX10.1字节数ymm2/m256到8个装填的64位整数zmm1使用写掩码 k1.

操作数编码

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

A

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

B

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

Tupla: Half Mem

C

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

Tupla: Quarter Mem

D

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

Tupla: Eighth Mem

实测开销

未实测：不在 64 位处理器上运行。

说明

遗留和VEX编码版本: 被包装的字节,单词,或dword整数在源操作符(第二个操作符)的低字节中的符号扩展为单词,dword,或四字整数,并存储在被包装的签名字节中,即目的地操作符.

128位遗产 SSE 版本 : 对应目的地的比特(MAXVL-1:128)注册保持不变.

VEX.128和EVEX.128编码版本: 对应目的地的比特(MAXVL-1:128)注册被清零.

VEX.256和EVEX.256编码版本: 对应目的地的比特(MAXVL-1:256)注册被清零.

EVEX 编码版本 : 包装的字节,词或词的整数,从源操作(第二个操作)的低字节开始,符号扩展为词,词或四字整数,并存储在写屏下的目的地操作. 目的地注册为XMM,YMM或ZMM注册.

说明: VEX.vvvv和EVEX.vvvv是保留的,必须是1111b,否则指令会#UD.

行动

Packed_Sign_Extend_BYTE_to_WORD(DEST, SRC)
DEST[15:0] := SignExtend(SRC[7:0]);
DEST[31:16] := SignExtend(SRC[15:8]);
DEST[47:32] := SignExtend(SRC[23:16]);
DEST[63:48] := SignExtend(SRC[31:24]);
DEST[79:64] := SignExtend(SRC[39:32]);
DEST[95:80] := SignExtend(SRC[47:40]);
DEST[111:96] := SignExtend(SRC[55:48]);
DEST[127:112] := SignExtend(SRC[63:56]);


Packed_Sign_Extend_BYTE_to_DWORD(DEST, SRC)
DEST[31:0] := SignExtend(SRC[7:0]);
DEST[63:32] := SignExtend(SRC[15:8]);
DEST[95:64] := SignExtend(SRC[23:16]);
DEST[127:96] := SignExtend(SRC[31:24]);

Packed_Sign_Extend_BYTE_to_QWORD(DEST, SRC)
DEST[63:0] := SignExtend(SRC[7:0]);
DEST[127:64] := SignExtend(SRC[15:8]);

Packed_Sign_Extend_WORD_to_DWORD(DEST, SRC)
DEST[31:0] := SignExtend(SRC[15:0]);
DEST[63:32] := SignExtend(SRC[31:16]);
DEST[95:64] := SignExtend(SRC[47:32]);
DEST[127:96] := SignExtend(SRC[63:48]);

Packed_Sign_Extend_WORD_to_QWORD(DEST, SRC)
DEST[63:0] := SignExtend(SRC[15:0]);
DEST[127:64] := SignExtend(SRC[31:16]);

Packed_Sign_Extend_DWORD_to_QWORD(DEST, SRC)
DEST[63:0] := SignExtend(SRC[31:0]);
DEST[127:64] := SignExtend(SRC[63:32]);

VPMOVSXBW (EVEX Encoded Versions)

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

Packed_Sign_Extend_BYTE_to_WORD(TMP_DEST[127:0], SRC[63:0])

IF VL >= 256

     Packed_Sign_Extend_BYTE_to_WORD(TMP_DEST[255:128], SRC[127:64])

FI;

IF VL >= 512

     Packed_Sign_Extend_BYTE_to_WORD(TMP_DEST[383:256], SRC[191:128])

     Packed_Sign_Extend_BYTE_to_WORD(TMP_DEST[511:384], SRC[255:192])

FI;

FOR j := 0 TO KL-1

     i := j * 16

     IF k1[j] OR *no writemask*

          THEN DEST[i+15:i] := TEMP_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


VPMOVSXBD (EVEX Encoded Versions)

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

Packed_Sign_Extend_BYTE_to_DWORD(TMP_DEST[127:0], SRC[31:0])

IF VL >= 256

     Packed_Sign_Extend_BYTE_to_DWORD(TMP_DEST[255:128], SRC[63:32])

FI;

IF VL >= 512

     Packed_Sign_Extend_BYTE_to_DWORD(TMP_DEST[383:256], SRC[95:64])

     Packed_Sign_Extend_BYTE_to_DWORD(TMP_DEST[511:384], SRC[127:96])

FI;

FOR j := 0 TO KL-1

     i := j * 32

     IF k1[j] OR *no writemask*

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

VPMOVSXBQ (EVEX Encoded Versions)

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

Packed_Sign_Extend_BYTE_to_QWORD(TMP_DEST[127:0], SRC[15:0])

IF VL >= 256

     Packed_Sign_Extend_BYTE_to_QWORD(TMP_DEST[255:128], SRC[31:16])

FI;

IF VL >= 512

     Packed_Sign_Extend_BYTE_to_QWORD(TMP_DEST[383:256], SRC[47:32])

     Packed_Sign_Extend_BYTE_to_QWORD(TMP_DEST[511:384], SRC[63:48])

FI;

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

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


VPMOVSXWD (EVEX Encoded Versions)

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

Packed_Sign_Extend_WORD_to_DWORD(TMP_DEST[127:0], SRC[63:0])

IF VL >= 256

     Packed_Sign_Extend_WORD_to_DWORD(TMP_DEST[255:128], SRC[127:64])

FI;

IF VL >= 512

     Packed_Sign_Extend_WORD_to_DWORD(TMP_DEST[383:256], SRC[191:128])

     Packed_Sign_Extend_WORD_to_DWORD(TMP_DEST[511:384], SRC[256:192])

FI;

FOR j := 0 TO KL-1

     i := j * 32

     IF k1[j] OR *no writemask*

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

VPMOVSXWQ (EVEX Encoded Versions)

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

Packed_Sign_Extend_WORD_to_QWORD(TMP_DEST[127:0], SRC[31:0])

IF VL >= 256

     Packed_Sign_Extend_WORD_to_QWORD(TMP_DEST[255:128], SRC[63:32])

FI;

IF VL >= 512

     Packed_Sign_Extend_WORD_to_QWORD(TMP_DEST[383:256], SRC[95:64])

     Packed_Sign_Extend_WORD_to_QWORD(TMP_DEST[511:384], SRC[127:96])

FI;

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

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


VPMOVSXDQ (EVEX Encoded Versions)

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

Packed_Sign_Extend_DWORD_to_QWORD(TEMP_DEST[127:0], SRC[63:0])

IF VL >= 256

     Packed_Sign_Extend_DWORD_to_QWORD(TEMP_DEST[255:128], SRC[127:64])

FI;

IF VL >= 512

     Packed_Sign_Extend_DWORD_to_QWORD(TEMP_DEST[383:256], SRC[191:128])

     Packed_Sign_Extend_DWORD_to_QWORD(TEMP_DEST[511:384], SRC[255:192])

FI;

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

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

VPMOVSXBW (VEX.256 Encoded Version)
Packed_Sign_Extend_BYTE_to_WORD(DEST[127:0], SRC[63:0])
Packed_Sign_Extend_BYTE_to_WORD(DEST[255:128], SRC[127:64])
DEST[MAXVL-1:256] := 0

VPMOVSXBD (VEX.256 Encoded Version)
Packed_Sign_Extend_BYTE_to_DWORD(DEST[127:0], SRC[31:0])
Packed_Sign_Extend_BYTE_to_DWORD(DEST[255:128], SRC[63:32])
DEST[MAXVL-1:256] := 0

VPMOVSXBQ (VEX.256 Encoded Version)
Packed_Sign_Extend_BYTE_to_QWORD(DEST[127:0], SRC[15:0])
Packed_Sign_Extend_BYTE_to_QWORD(DEST[255:128], SRC[31:16])
DEST[MAXVL-1:256] := 0

VPMOVSXWD (VEX.256 Encoded Version)
Packed_Sign_Extend_WORD_to_DWORD(DEST[127:0], SRC[63:0])
Packed_Sign_Extend_WORD_to_DWORD(DEST[255:128], SRC[127:64])
DEST[MAXVL-1:256] := 0

VPMOVSXWQ (VEX.256 Encoded Version)
Packed_Sign_Extend_WORD_to_QWORD(DEST[127:0], SRC[31:0])
Packed_Sign_Extend_WORD_to_QWORD(DEST[255:128], SRC[63:32])
DEST[MAXVL-1:256] := 0

VPMOVSXDQ (VEX.256 Encoded Version)
Packed_Sign_Extend_DWORD_to_QWORD(DEST[127:0], SRC[63:0])
Packed_Sign_Extend_DWORD_to_QWORD(DEST[255:128], SRC[127:64])
DEST[MAXVL-1:256] := 0


VPMOVSXBW (VEX.128 Encoded Version)
Packed_Sign_Extend_BYTE_to_WORDDEST[127:0], SRC[127:0]()
DEST[MAXVL-1:128] := 0

VPMOVSXBD (VEX.128 Encoded Version)
Packed_Sign_Extend_BYTE_to_DWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] := 0

VPMOVSXBQ (VEX.128 Encoded Version)
Packed_Sign_Extend_BYTE_to_QWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] := 0

VPMOVSXWD (VEX.128 Encoded Version)
Packed_Sign_Extend_WORD_to_DWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] := 0

VPMOVSXWQ (VEX.128 Encoded Version)
Packed_Sign_Extend_WORD_to_QWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] := 0

VPMOVSXDQ (VEX.128 Encoded Version)
Packed_Sign_Extend_DWORD_to_QWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] := 0

PMOVSXBW
Packed_Sign_Extend_BYTE_to_WORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

PMOVSXBD
Packed_Sign_Extend_BYTE_to_DWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

PMOVSXBQ
Packed_Sign_Extend_BYTE_to_QWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

PMOVSXWD
Packed_Sign_Extend_WORD_to_DWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

PMOVSXWQ
Packed_Sign_Extend_WORD_to_QWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

PMOVSXDQ
Packed_Sign_Extend_DWORD_to_QWORD(DEST[127:0], SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ 内在编译器

VPMOVSXBW __m512i _mm512_cvtepi8_epi16(__m512i a);
VPMOVSXBW __m512i _mm512_mask_cvtepi8_epi16(__m512i a, __mmask32 k, __m512i b);
VPMOVSXBW __m512i _mm512_maskz_cvtepi8_epi16( __mmask32 k, __m512i b);
VPMOVSXBD __m512i _mm512_cvtepi8_epi32(__m512i a);
VPMOVSXBD __m512i _mm512_mask_cvtepi8_epi32(__m512i a, __mmask16 k, __m512i b);
VPMOVSXBD __m512i _mm512_maskz_cvtepi8_epi32( __mmask16 k, __m512i b);
VPMOVSXBQ __m512i _mm512_cvtepi8_epi64(__m512i a);
VPMOVSXBQ __m512i _mm512_mask_cvtepi8_epi64(__m512i a, __mmask8 k, __m512i b);
VPMOVSXBQ __m512i _mm512_maskz_cvtepi8_epi64( __mmask8 k, __m512i a);
VPMOVSXDQ __m512i _mm512_cvtepi32_epi64(__m512i a);
VPMOVSXDQ __m512i _mm512_mask_cvtepi32_epi64(__m512i a, __mmask8 k, __m512i b);
VPMOVSXDQ __m512i _mm512_maskz_cvtepi32_epi64( __mmask8 k, __m512i a);
VPMOVSXWD __m512i _mm512_cvtepi16_epi32(__m512i a);
VPMOVSXWD __m512i _mm512_mask_cvtepi16_epi32(__m512i a, __mmask16 k, __m512i b);
VPMOVSXWD __m512i _mm512_maskz_cvtepi16_epi32(__mmask16 k, __m512i a);
VPMOVSXWQ __m512i _mm512_cvtepi16_epi64(__m512i a);
VPMOVSXWQ __m512i _mm512_mask_cvtepi16_epi64(__m512i a, __mmask8 k, __m512i b);
VPMOVSXWQ __m512i _mm512_maskz_cvtepi16_epi64( __mmask8 k, __m512i a);
VPMOVSXBW __m256i _mm256_cvtepi8_epi16(__m256i a);
VPMOVSXBW __m256i _mm256_mask_cvtepi8_epi16(__m256i a, __mmask16 k, __m256i b);
VPMOVSXBW __m256i _mm256_maskz_cvtepi8_epi16( __mmask16 k, __m256i b);
VPMOVSXBD __m256i _mm256_cvtepi8_epi32(__m256i a);
VPMOVSXBD __m256i _mm256_mask_cvtepi8_epi32(__m256i a, __mmask8 k, __m256i b);
VPMOVSXBD __m256i _mm256_maskz_cvtepi8_epi32( __mmask8 k, __m256i b);
VPMOVSXBQ __m256i _mm256_cvtepi8_epi64(__m256i a);
VPMOVSXBQ __m256i _mm256_mask_cvtepi8_epi64(__m256i a, __mmask8 k, __m256i b);
VPMOVSXBQ __m256i _mm256_maskz_cvtepi8_epi64( __mmask8 k, __m256i a);
VPMOVSXDQ __m256i _mm256_cvtepi32_epi64(__m256i a);
VPMOVSXDQ __m256i _mm256_mask_cvtepi32_epi64(__m256i a, __mmask8 k, __m256i b);
VPMOVSXDQ __m256i _mm256_maskz_cvtepi32_epi64( __mmask8 k, __m256i a);
VPMOVSXWD __m256i _mm256_cvtepi16_epi32(__m256i a);
VPMOVSXWD __m256i _mm256_mask_cvtepi16_epi32(__m256i a, __mmask16 k, __m256i b);
VPMOVSXWD __m256i _mm256_maskz_cvtepi16_epi32(__mmask16 k, __m256i a);
VPMOVSXWQ __m256i _mm256_cvtepi16_epi64(__m256i a);
VPMOVSXWQ __m256i _mm256_mask_cvtepi16_epi64(__m256i a, __mmask8 k, __m256i b);
VPMOVSXWQ __m256i _mm256_maskz_cvtepi16_epi64( __mmask8 k, __m256i a);
VPMOVSXBW __m128i _mm_mask_cvtepi8_epi16(__m128i a, __mmask8 k, __m128i b);
VPMOVSXBW __m128i _mm_maskz_cvtepi8_epi16( __mmask8 k, __m128i b);
VPMOVSXBD __m128i _mm_mask_cvtepi8_epi32(__m128i a, __mmask8 k, __m128i b);
VPMOVSXBD __m128i _mm_maskz_cvtepi8_epi32( __mmask8 k, __m128i b);
VPMOVSXBQ __m128i _mm_mask_cvtepi8_epi64(__m128i a, __mmask8 k, __m128i b);
VPMOVSXBQ __m128i _mm_maskz_cvtepi8_epi64( __mmask8 k, __m128i a);
VPMOVSXDQ __m128i _mm_mask_cvtepi32_epi64(__m128i a, __mmask8 k, __m128i b);
VPMOVSXDQ __m128i _mm_maskz_cvtepi32_epi64( __mmask8 k, __m128i a);
VPMOVSXWD __m128i _mm_mask_cvtepi16_epi32(__m128i a, __mmask16 k, __m128i b);
VPMOVSXWD __m128i _mm_maskz_cvtepi16_epi32(__mmask16 k, __m128i a);
VPMOVSXWQ __m128i _mm_mask_cvtepi16_epi64(__m128i a, __mmask8 k, __m128i b);
VPMOVSXWQ __m128i _mm_maskz_cvtepi16_epi64( __mmask8 k, __m128i a);
PMOVSXBW __m128i _mm_ cvtepi8_epi16 ( __m128i a);
PMOVSXBD __m128i _mm_ cvtepi8_epi32 ( __m128i a);
PMOVSXBQ __m128i _mm_ cvtepi8_epi64 ( __m128i a);
PMOVSXWD __m128i _mm_ cvtepi16_epi32 ( __m128i a);
PMOVSXWQ __m128i _mm_ cvtepi16_epi64 ( __m128i a);
PMOVSXDQ __m128i _mm_ cvtepi32_epi64 ( __m128i a);

SIMD 浮点例外

None.

其他例外

Non-EVEX-encoded discription,参见表2-22,"第5类例外条件".

EVEX-encoded 指令,参见表2-53,"Type E5类例外条件".

Additionally:

#UD               If VEX.vvvv != 1111B, or EVEX.vvvv != 1111B.

来源

本指令在 Intel 手册中的位置

PMOVSX

编码

操作数编码

A

B

C

D

实测开销

说明#

行动#

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

SIMD 浮点 例外#

其他例外#

来源

说明

行动

Intel C/C++ 内在编译器

SIMD 浮点例外

其他例外