Vesta
中文
源代码

PMOVZX

以零扩展包装移动

stableVMJITAOTinstruction

编码

操作码指令Op/En64 位兼容/传统说明
66 0f 38 30 /rPMOVZXBW xmm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将8个打包的8位整数扩展为8个打包的16位整数. xmm1.
66 0f 38 31 /rPMOVZXBD xmm1, xmm2/m32A有效有效0在xmm2/m32的低4字节中将4个打包的8位整数扩展为4个打包的32位整数. xmm1.
66 0f 38 32 /rPMOVZXBQ xmm1, xmm2/m16A有效有效0在xmm2/m16的低2字节中扩展2个已包装的8位整数到xmm1的2个已包装的64位整数.
66 0f 38 33 /rPMOVZXWD xmm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将4个装箱的16位整数扩展至xmm1的4个装箱的32位整数.
66 0f 38 34 /rPMOVZXWQ xmm1, xmm2/m32A有效有效0延伸2个在xmm2/m32的低4字节中装入的16位整数到xmm1的2个装入的64位整数.
66 0f 38 35 /rPMOVZXDQ xmm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将2个装箱的32位整数扩展为2个装箱的64位整数在xmm1.
VEX.128.66.0F38.WIG 30 /rVPMOVZXBW xmm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将8个打包的8位整数扩展为8个打包的16位整数. xmm1.
VEX.128.66.0F38.WIG 31 /rVPMOVZXBD xmm1, xmm2/m32A有效有效0在xmm2/m32的低4字节中将4个打包的8位整数扩展为4个打包的32位整数. xmm1.
VEX.128.66.0F38.WIG 32 /rVPMOVZXBQ xmm1, xmm2/m16A有效有效0在xmm2/m16的低2字节中扩展2个已包装的8位整数到xmm1的2个已包装的64位整数.
VEX.128.66.0F38.WIG 33 /rVPMOVZXWD xmm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将4个装箱的16位整数扩展至xmm1的4个装箱的32位整数.
VEX.128.66.0F38.WIG 34 /rVPMOVZXWQ xmm1, xmm2/m32A有效有效0延伸2个在xmm2/m32的低4字节中装入的16位整数到xmm1的2个装入的64位整数.
VEX.128.66.0F 38.WIG 35 /rVPMOVZXDQ xmm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将2个装箱的32位整数扩展为2个装箱的64位整数在xmm1.
VEX.256.66.0F38.WIG 30 /rVPMOVZXBW ymm1, xmm2/m128A有效有效0将xmm2/m128的16个装箱的8位整数扩展至ymm1的16个装箱的16位整数.
VEX.256.66.0F38.WIG 31 /rVPMOVZXBD ymm1, xmm2/m64A有效有效0 扩展 8 块8 位整数在低 8 字节xmm2/m64到8个装入的32位整数ymm1.
VEX.256.66.0F38.WIG 32 /rVPMOVZXBQ ymm1, xmm2/m32A有效有效0在xmm2/m32的低4字节中将4个打包的8位整数扩展为4个打包的64位整数. ymm1.
VEX.256.66.0F38.WIG 33 /rVPMOVZXWD ymm1, xmm2/m128 Opcode/ InstructionA有效有效0 将 xmm2/m128 的 8 个装入的 16 位整数扩展为 ymm1 的 8 个装入的 32 位整数 。 Op / 64/32 比特 CPUID 特性描述 模式支持旗
VEX.256.66.0F38.WIG 34 /rVPMOVZXWQ ymm1, xmm2/m64A有效有效0在xmm2/m64的低8字节中将4个装箱的16位整数扩展至ymm1的4个装箱的64位整数.
VEX.256.66.0F38.WIG 35 /rVPMOVZXDQ ymm1, xmm2/m128A有效有效0将xmm2/m128中的4个装箱的32位整数扩展为ymm1中的4个装箱的64位整数.
EVEX.128.66.0F38 30.WIG /rVPMOVZXBW xmm1 {k1}{z}, xmm2/m64B有效有效0在低位8 AVX512BW)或字节的xmm2/m64中将8个包装的8位整数扩展为8个包装的16位整数. AVX10.1 xmm1.
EVEX.256.66.0F38.WIG 30 /rVPMOVZXBW ymm1 {k1}{z}, xmm2/m128B有效有效0 将 AVX512BW 的 16 个已装箱的 8 位整数 OR xmm2/m128 扩展为 ymm1 的 16 个已装箱的 16 位整数 . AVX10.1
EVEX.512.66.0F38.WIG 30 /rVPMOVZXBW zmm1 {k1}{z}, ymm2/m256B有效有效0在OR AVX10.1 ymm2/m256中将32个装箱的8位整数扩展为32个装箱的16位整数在zmm1.
EVEX.128.66.0F38.WIG 31 /rVPMOVZXBD xmm1 {k1}{z}, xmm2/m32C有效有效0在低位4 AVX512F)或字节的xmm2/m32中将4个装箱的8位整数扩展为4个装箱的32位整数. AVX10.1 xmm1受写掩码 k1的约束.
EVEX.256.66.0F38.WIG 31 /rVPMOVZXBD ymm1 {k1}{z}, xmm2/m64C有效有效0在低位8 AVX512F)或xmm2/m64的字节中将8个已包装的8位整数扩展为8个已包装的32位整数,在AVX10.1ymm1中以写入mask k1为对象.
EVEX.512.66.0F38.WIG 31 /rVPMOVZXBD zmm1 {k1}{z}, xmm2/m128C有效有效0在OR AVX10.1 xmm2/m128中将16个装箱的8位整数扩展为16个装箱的32位整数,在zmm1中以写掩码 k1为对象.
EVEX.128.66.0F38.WIG 32 /rVPMOVZXBQ xmm1 {k1}{z}, xmm2/m16D有效有效0 扩展 2 包装 8 位整数 在低 2 AVX512F) 或 xmm2/m16 的字节为 2 包装 64 位整数 在 AVX10.1 xmm1 的下限为 writemask k1.
EVEX.256.66.0F38.WIG 32 /rVPMOVZXBQ ymm1 {k1}{z}, xmm2/m32D有效有效0在低位4 AVX512F)或字节的xmm2/m32中将4个装箱的8位整数扩展为4个装箱的64位整数. AVX10.1 ymm1受写掩码 k1的约束.
EVEX.512.66.0F38.WIG 32 /rVPMOVZXBQ zmm1 {k1}{z}, xmm2/m64D有效有效0在xmm2/m64的低8OR AVX10.1字节中将8个已包装的8位整数延伸至zmm1的8个已包装的64位整数,以写作k1.
EVEX.128.66.0F38.WIG 33 /rVPMOVZXWD xmm1 {k1}{z}, xmm2/m64B有效有效0在低位8 AVX512F)或xmm2/m64的字节中将4个装箱的16位整数扩展为4个装箱的32位整数,在AVX10.1,xmm1中以写入mask k1为对象.
EVEX.256.66.0F38.WIG 33 /rVPMOVZXWD ymm1 {k1}{z}, xmm2/m128B有效有效0在AVX512F中将8个装填的16位整数)OR xmm2/m128在zmm1 AVX10.1中将8个装填的32位整数按照写作程序k1.
EVEX.512.66.0F38.WIG 33 /rVPMOVZXWD zmm1 {k1}{z}, ymm2/m256B有效有效0在OR AVX10.1 ymm2/m256中将16个装箱的16位整数扩展为16个装箱的32位整数,在zmm1中以写掩码 k1为对象.
EVEX.128.66.0F38.WIG 34 /rVPMOVZXWQ xmm1 {k1}{z}, xmm2/m32C有效有效0延伸2个装箱的16位整数在低4AVX512F)或xmm2/m32的字节为2个装箱的64位整数在AVX10.1xmm1中以写mask k1为对象.
EVEX.256.66.0F38.WIG 34 /rVPMOVZXWQ ymm1 {k1}{z}, xmm2/m64 Opcode/ InstructionC有效有效0 扩展 4 包装的 16 位整数在低 8 位AVX512F或字节xmm2/m64至 4 个装填的64位整数AVX10.1 ymm1须遵守写掩码 k1. Op 64/32 bi tCPUIDFeatur e 描述模式支持旗帜
EVEX.512.66.0F38.WIG 34 /rVPMOVZXWQ zmm1 {k1}{z}, xmm2/m128C有效有效0在OR AVX10.1 xmm2/m128中将8个装箱的16位整数扩展为8个装箱的64位整数,在zmm1中以写掩码 k1为对象.
EVEX.128.66.0F38.W0 35 /rVPMOVZXDQ xmm1 {k1}{z}, xmm2/m64B有效有效D 零 扩展 2 组装的 32 位整数AVX512F或字节xmm2/m64至 2 个装填的64位整数AVX10.1 zmm1使用写掩码 k1.
EVEX.256.66.0F38.W0 35 /rVPMOVZXDQ ymm1 {k1}{z}, xmm2/m128B有效有效D 0 扩展 4 个装填的 32 位整数AVX512F(或)xmm2/m128至 4 个装填的64位整数zmm1 AVX10.1使用写掩码 k1.
EVEX.512.66.0F38.W0 35 /rVPMOVZXDQ zmm1 {k1}{z}, ymm2/m256B有效有效0 扩展 8 块32 位整数AVX10.1 ymm2/m256到8个装填的64位整数zmm1使用写掩码 k1.

操作数编码

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

A

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

B

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

Tupla: Half Mem

C

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

Tupla: Quarter Mem

D

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

Tupla: Eighth Mem

实测开销

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

说明

VEX和EVEX编码版本: 从源操作数(第二个操作数)的低位字节开始的包装字节,单词,或单词整数为零扩展为单词,单词,或四词整数,并存储在已签名的目标操作数的包式字节中.

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

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

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

EVEX 编码版本 : 从源操作数(第二个操作数)的低字节开始的包装dword整数为零扩展为四字整数,并在写掩码下存储到目标操作数. 目的地登记册是XMM,YMM或ZMM Register.

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

行动

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

Packed_Zero_Extend_BYTE_to_DWORD(DEST, SRC)
DEST[31:0] := ZeroExtend(SRC[7:0]);
DEST[63:32] := ZeroExtend(SRC[15:8]);


DEST[95:64] := ZeroExtend(SRC[23:16]);
DEST[127:96] := ZeroExtend(SRC[31:24]);

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

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

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

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

VPMOVZXBW (EVEX Encoded Versions)

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

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

IF VL >= 256

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

FI;

IF VL >= 512

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

     Packed_Zero_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


VPMOVZXBD (EVEX Encoded Versions)

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

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

IF VL >= 256

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

FI;

IF VL >= 512

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

     Packed_Zero_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

VPMOVZXBQ (EVEX Encoded Versions)

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

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

IF VL >= 256

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

FI;

IF VL >= 512

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

     Packed_Zero_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


VPMOVZXWD (EVEX Encoded Versions)

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

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

IF VL >= 256

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

FI;

IF VL >= 512

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

     Packed_Zero_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

VPMOVZXWQ (EVEX Encoded Versions)

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

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

IF VL >= 256

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

FI;

IF VL >= 512

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

     Packed_Zero_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


VPMOVZXDQ (EVEX Encoded Versions)

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

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

IF VL >= 256

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

FI;

IF VL >= 512

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

     Packed_Zero_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

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

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

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

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

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

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


VPMOVZXBW (VEX.128 Encoded Version)
Packed_Zero_Extend_BYTE_to_WORD()
DEST[MAXVL-1:128] := 0

VPMOVZXBD (VEX.128 Encoded Version)
Packed_Zero_Extend_BYTE_to_DWORD()
DEST[MAXVL-1:128] := 0

VPMOVZXBQ (VEX.128 Encoded Version)
Packed_Zero_Extend_BYTE_to_QWORD()
DEST[MAXVL-1:128] := 0

VPMOVZXWD (VEX.128 Encoded Version)
Packed_Zero_Extend_WORD_to_DWORD()
DEST[MAXVL-1:128] := 0

VPMOVZXWQ (VEX.128 Encoded Version)
Packed_Zero_Extend_WORD_to_QWORD()
DEST[MAXVL-1:128] := 0

VPMOVZXDQ (VEX.128 Encoded Version)
Packed_Zero_Extend_DWORD_to_QWORD()
DEST[MAXVL-1:128] := 0

PMOVZXBW
Packed_Zero_Extend_BYTE_to_WORD()
DEST[MAXVL-1:128] (Unmodified)

PMOVZXBD
Packed_Zero_Extend_BYTE_to_DWORD()
DEST[MAXVL-1:128] (Unmodified)

PMOVZXBQ
Packed_Zero_Extend_BYTE_to_QWORD()
DEST[MAXVL-1:128] (Unmodified)

PMOVZXWD
Packed_Zero_Extend_WORD_to_DWORD()
DEST[MAXVL-1:128] (Unmodified)

PMOVZXWQ
Packed_Zero_Extend_WORD_to_QWORD()
DEST[MAXVL-1:128] (Unmodified)

PMOVZXDQ
Packed_Zero_Extend_DWORD_to_QWORD()
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ 内在编译器

VPMOVZXBW __m512i _mm512_cvtepu8_epi16(__m256i a);
VPMOVZXBW __m512i _mm512_mask_cvtepu8_epi16(__m512i a, __mmask32 k, __m256i b);
VPMOVZXBW __m512i _mm512_maskz_cvtepu8_epi16( __mmask32 k, __m256i b);
VPMOVZXBD __m512i _mm512_cvtepu8_epi32(__m128i a);
VPMOVZXBD __m512i _mm512_mask_cvtepu8_epi32(__m512i a, __mmask16 k, __m128i b);
VPMOVZXBD __m512i _mm512_maskz_cvtepu8_epi32( __mmask16 k, __m128i b);
VPMOVZXBQ __m512i _mm512_cvtepu8_epi64(__m128i a);
VPMOVZXBQ __m512i _mm512_mask_cvtepu8_epi64(__m512i a, __mmask8 k, __m128i b);
VPMOVZXBQ __m512i _mm512_maskz_cvtepu8_epi64( __mmask8 k, __m128i a);
VPMOVZXDQ __m512i _mm512_cvtepu32_epi64(__m256i a);
VPMOVZXDQ __m512i _mm512_mask_cvtepu32_epi64(__m512i a, __mmask8 k, __m256i b);
VPMOVZXDQ __m512i _mm512_maskz_cvtepu32_epi64( __mmask8 k, __m256i a);
VPMOVZXWD __m512i _mm512_cvtepu16_epi32(__m128i a);
VPMOVZXWD __m512i _mm512_mask_cvtepu16_epi32(__m512i a, __mmask16 k, __m128i b);
VPMOVZXWD __m512i _mm512_maskz_cvtepu16_epi32(__mmask16 k, __m128i a);
VPMOVZXWQ __m512i _mm512_cvtepu16_epi64(__m256i a);
VPMOVZXWQ __m512i _mm512_mask_cvtepu16_epi64(__m512i a, __mmask8 k, __m256i b);
VPMOVZXWQ __m512i _mm512_maskz_cvtepu16_epi64( __mmask8 k, __m256i a);
VPMOVZXBW __m256i _mm256_cvtepu8_epi16(__m256i a);
VPMOVZXBW __m256i _mm256_mask_cvtepu8_epi16(__m256i a, __mmask16 k, __m128i b);
VPMOVZXBW __m256i _mm256_maskz_cvtepu8_epi16( __mmask16 k, __m128i b);
VPMOVZXBD __m256i _mm256_cvtepu8_epi32(__m128i a);
VPMOVZXBD __m256i _mm256_mask_cvtepu8_epi32(__m256i a, __mmask8 k, __m128i b);
VPMOVZXBD __m256i _mm256_maskz_cvtepu8_epi32( __mmask8 k, __m128i b);
VPMOVZXBQ __m256i _mm256_cvtepu8_epi64(__m128i a);
VPMOVZXBQ __m256i _mm256_mask_cvtepu8_epi64(__m256i a, __mmask8 k, __m128i b);
VPMOVZXBQ __m256i _mm256_maskz_cvtepu8_epi64( __mmask8 k, __m128i a);
VPMOVZXDQ __m256i _mm256_cvtepu32_epi64(__m128i a);
VPMOVZXDQ __m256i _mm256_mask_cvtepu32_epi64(__m256i a, __mmask8 k, __m128i b);
VPMOVZXDQ __m256i _mm256_maskz_cvtepu32_epi64( __mmask8 k, __m128i a);
VPMOVZXWD __m256i _mm256_cvtepu16_epi32(__m128i a);
VPMOVZXWD __m256i _mm256_mask_cvtepu16_epi32(__m256i a, __mmask16 k, __m128i b);
VPMOVZXWD __m256i _mm256_maskz_cvtepu16_epi32(__mmask16 k, __m128i a);
VPMOVZXWQ __m256i _mm256_cvtepu16_epi64(__m128i a);
VPMOVZXWQ __m256i _mm256_mask_cvtepu16_epi64(__m256i a, __mmask8 k, __m128i b);
VPMOVZXWQ __m256i _mm256_maskz_cvtepu16_epi64( __mmask8 k, __m128i a);
VPMOVZXBW __m128i _mm_mask_cvtepu8_epi16(__m128i a, __mmask8 k, __m128i b);
VPMOVZXBW __m128i _mm_maskz_cvtepu8_epi16( __mmask8 k, __m128i b);
VPMOVZXBD __m128i _mm_mask_cvtepu8_epi32(__m128i a, __mmask8 k, __m128i b);
VPMOVZXBD __m128i _mm_maskz_cvtepu8_epi32( __mmask8 k, __m128i b);
VPMOVZXBQ __m128i _mm_mask_cvtepu8_epi64(__m128i a, __mmask8 k, __m128i b);
VPMOVZXBQ __m128i _mm_maskz_cvtepu8_epi64( __mmask8 k, __m128i a);
VPMOVZXDQ __m128i _mm_mask_cvtepu32_epi64(__m128i a, __mmask8 k, __m128i b);
VPMOVZXDQ __m128i _mm_maskz_cvtepu32_epi64( __mmask8 k, __m128i a);
VPMOVZXWD __m128i _mm_mask_cvtepu16_epi32(__m128i a, __mmask16 k, __m128i b);
VPMOVZXWD __m128i _mm_maskz_cvtepu16_epi32(__mmask8 k, __m128i a);
VPMOVZXWQ __m128i _mm_mask_cvtepu16_epi64(__m128i a, __mmask8 k, __m128i b);
VPMOVZXWQ __m128i _mm_maskz_cvtepu16_epi64( __mmask8 k, __m128i a);
PMOVZXBW __m128i _mm_ cvtepu8_epi16 ( __m128i a);
PMOVZXBD __m128i _mm_ cvtepu8_epi32 ( __m128i a);
PMOVZXBQ __m128i _mm_ cvtepu8_epi64 ( __m128i a);
PMOVZXWD __m128i _mm_ cvtepu16_epi32 ( __m128i a);
PMOVZXWQ __m128i _mm_ cvtepu16_epi64 ( __m128i a);
PMOVZXDQ __m128i _mm_ cvtepu32_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.

来源