Vesta
Español
Código fuente

PMOVZX

Mover empaquetado con Zero Extend

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
66 0f 38 30 /rPMOVZXBW xmm1, xmm2/m64AValidoValidoZero extiende 8 enteros de 8 bits en los 8 bytes bajos de xmm2/m64 a 8 enteros de 16 bits empaquetados en xmm1.
66 0f 38 31 /rPMOVZXBD xmm1, xmm2/m32AValidoValidoZero extiende 4 enteros de 8 bits en los 4 bytes bajos de xmm2/m32 a 4 enteros de 32 bits empaquetados en xmm1.
66 0f 38 32 /rPMOVZXBQ xmm1, xmm2/m16AValidoValidoZero extiende 2 enteros de 8 bits en los 2 bytes bajos de xmm2/m16 a 2 enteros de 64 bits empaquetados en xmm1.
66 0f 38 33 /rPMOVZXWD xmm1, xmm2/m64AValidoValidoZero extiende 4 enteros de 16 bits en los 8 bytes bajos de xmm2/m64 a 4 enteros de 32 bits empaquetados en xmm1.
66 0f 38 34 /rPMOVZXWQ xmm1, xmm2/m32AValidoValidoZero extiende 2 enteros de 16 bits en los 4 bytes bajos de xmm2/m32 a 2 enteros de 64 bits empaquetados en xmm1.
66 0f 38 35 /rPMOVZXDQ xmm1, xmm2/m64AValidoValidoZero extiende 2 enteros de 32 bits en los 8 bytes bajos de xmm2/m64 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 30 /rVPMOVZXBW xmm1, xmm2/m64AValidoValidoZero extiende 8 enteros de 8 bits en los 8 bytes bajos de xmm2/m64 a 8 enteros de 16 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 31 /rVPMOVZXBD xmm1, xmm2/m32AValidoValidoZero extiende 4 enteros de 8 bits en los 4 bytes bajos de xmm2/m32 a 4 enteros de 32 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 32 /rVPMOVZXBQ xmm1, xmm2/m16AValidoValidoZero extiende 2 enteros de 8 bits en los 2 bytes bajos de xmm2/m16 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 33 /rVPMOVZXWD xmm1, xmm2/m64AValidoValidoZero extiende 4 enteros de 16 bits en los 8 bytes bajos de xmm2/m64 a 4 enteros de 32 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 34 /rVPMOVZXWQ xmm1, xmm2/m32AValidoValidoZero extiende 2 enteros de 16 bits en los 4 bytes bajos de xmm2/m32 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.128.66.0F 38.WIG 35 /rVPMOVZXDQ xmm1, xmm2/m64AValidoValidoZero extiende 2 enteros de 32 bits en los 8 bytes bajos de xmm2/m64 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.256.66.0F38.WIG 30 /rVPMOVZXBW ymm1, xmm2/m128AValidoValidoZero extiende 16 enteros de 8 bits en xmm2/m128 a 16 enteros de 16 bits en ymm1.
VEX.256.66.0F38.WIG 31 /rVPMOVZXBD ymm1, xmm2/m64AValidoValidoZero extiende 8 enteros de 8 bits en los 8 bytes bajos de xmm2/m64 a 8 enteros de 32 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 32 /rVPMOVZXBQ ymm1, xmm2/m32AValidoValidoZero extiende 4 enteros de 8 bits en los 4 bytes bajos de xmm2/m32 a 4 enteros de 64 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 33 /rVPMOVZXWD ymm1, xmm2/m128 Opcode/ InstructionAValidoValidoZero extend 8 enteros de 16 bits xmm2/m128 a 8 enteros de 32 bits empaquetados en ymm1. Op / 64/32 bit CPUID Característica Descripción En Mode Soporte Bandera
VEX.256.66.0F38.WIG 34 /rVPMOVZXWQ ymm1, xmm2/m64AValidoValidoZero extiende 4 enteros de 16 bits en los 8 bytes bajos de xmm2/m64 a 4 enteros de 64 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 35 /rVPMOVZXDQ ymm1, xmm2/m128AValidoValidoZero extiende 4 enteros de 32 bits en xmm2/m128 a 4 enteros de 64 bits en ymm1.
EVEX.128.66.0F38 30.WIG /rVPMOVZXBW xmm1 {k1}{z}, xmm2/m64BValidoValidoZero extiende 8 enteros de 8 bits en los bajos 8 AVX512BW) O de xmm2/m64 a 8 enteros de 16 bits empaquetados en AVX10.1 xmm1.
EVEX.256.66.0F38.WIG 30 /rVPMOVZXBW ymm1 {k1}{z}, xmm2/m128BValidoValidoZero extiende 16 enteros de 8 bits en AVX512BW) OR xmm2/m128 a 16 enteros de 16 bits en ymm1. AVX10.1
EVEX.512.66.0F38.WIG 30 /rVPMOVZXBW zmm1 {k1}{z}, ymm2/m256BValidoValidoZero extiende 32 enteros de 8 bits en OR AVX10.1 ymm2/m256 a 32 enteros de 16 bits empaquetados en zmm1.
EVEX.128.66.0F38.WIG 31 /rVPMOVZXBD xmm1 {k1}{z}, xmm2/m32CValidoValidoZero extiende 4 enteros de 8 bits en los bajos 4 AVX512F) O de xmm2/m32 a 4 enteros de 32 bits empaquetados en AVX10.1 xmm1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 31 /rVPMOVZXBD ymm1 {k1}{z}, xmm2/m64CValidoValidoZero extend 8 enteros de 8 bits en los bajos 8 AVX512F) O de xmm2/m64 a 8 enteros de 32 bits empaquetados en AVX10.1 ymm1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 31 /rVPMOVZXBD zmm1 {k1}{z}, xmm2/m128CValidoValidoZero extiende 16 enteros de 8 bits en OR AVX10.1 xmm2/m128 a 16 enteros de 32 bits empaquetados en zmm1 sujetos a máscara de escritura k1.
EVEX.128.66.0F38.WIG 32 /rVPMOVZXBQ xmm1 {k1}{z}, xmm2/m16DValidoValidoZero extiende 2 enteros de 8 bits en los bajos 2 AVX512F) O de xmm2/m16 a 2 enteros de 64 bits empaquetados en AVX10.1 xmm1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 32 /rVPMOVZXBQ ymm1 {k1}{z}, xmm2/m32DValidoValidoZero extiende 4 enteros de 8 bits en los bajos 4 AVX512F) O de xmm2/m32 a 4 enteros de 64 bits empaquetados en AVX10.1 ymm1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 32 /rVPMOVZXBQ zmm1 {k1}{z}, xmm2/m64DValidoValidoZero extend 8 enteros de 8 bits empaquetados en los bajos 8 OR AVX10.1 bytes de xmm2/m64 a 8 enteros de 64 bits empaquetados en zmm1 sujetos a máscara de escritura k1.
EVEX.128.66.0F38.WIG 33 /rVPMOVZXWD xmm1 {k1}{z}, xmm2/m64BValidoValidoZero extiende 4 enteros de 16 bits en los bajos 8 AVX512F) O de xmm2/m64 a 4 enteros de 32 bits empaquetados en AVX10.1 xmm1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 33 /rVPMOVZXWD ymm1 {k1}{z}, xmm2/m128BValidoValidoZero extend 8 enteros de 16 bits en AVX512F) OR xmm2/m128 a 8 enteros de 32 bits empaquetados en zmm1 AVX10.1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 33 /rVPMOVZXWD zmm1 {k1}{z}, ymm2/m256BValidoValidoZero extiende 16 enteros de 16 bits en OR AVX10.1 ymm2/m256 a 16 enteros de 32 bits empaquetados en zmm1 sujetos a máscara de escritura k1.
EVEX.128.66.0F38.WIG 34 /rVPMOVZXWQ xmm1 {k1}{z}, xmm2/m32CValidoValidoZero extiende 2 enteros de 16 bits en los bajos 4 AVX512F) O de xmm2/m32 a 2 enteros de 64 bits empaquetados en AVX10.1 xmm1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 34 /rVPMOVZXWQ ymm1 {k1}{z}, xmm2/m64 Opcode/ InstructionCValidoValidoZero extend 4 enteros de 16 bits en los bajos 8 AVX512F) O bytes de xmm2/m64 a 4 enteros de 64 bits empacados en AVX10.1 ymm1 sujetos a máscara de escritura k1. Op / 64/32 bi t CPUID Featur e Descripción En Mode Support Flag
EVEX.512.66.0F38.WIG 34 /rVPMOVZXWQ zmm1 {k1}{z}, xmm2/m128CValidoValidoZero extend 8 enteros de 16 bits empaquetados en OR AVX10.1 xmm2/m128 a 8 enteros de 64 bits empaquetados en zmm1 sujetos a máscara de escritura k1.
EVEX.128.66.0F38.W0 35 /rVPMOVZXDQ xmm1 {k1}{z}, xmm2/m64BValidoValidoD Zero extiende 2 enteros de 32 bits empaquetados en los bajos 8 AVX512F) O bytes de xmm2/m64 a 2 enteros de 64 bits empaquetados en AVX10.1 zmm1 utilizando máscara de escritura k1.
EVEX.256.66.0F38.W0 35 /rVPMOVZXDQ ymm1 {k1}{z}, xmm2/m128BValidoValidoD Zero extiende 4 enteros de 32 bits en AVX512F) OR xmm2/m128 a 4 enteros de 64 bits empaquetados en zmm1 AVX10.1 usando máscara de escritura k1.
EVEX.512.66.0F38.W0 35 /rVPMOVZXDQ zmm1 {k1}{z}, ymm2/m256BValidoValidoZero extiende 8 enteros de 32 bits empaquetados en OR AVX10.1 ymm2/m256 a 8 enteros de 64 bits empaquetados en zmm1 usando máscara de escritura k1.

Codificacion de operandos

Cada modo es un valor de la columna Op/En de arriba. Dice en que campo de la instruccion codificada va cada operando, en el orden en que se escriben, y si la instruccion lo lee, lo escribe o ambas cosas.

A

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

B

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Tupla: Half Mem

C

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Tupla: Quarter Mem

D

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Tupla: Eighth Mem

Coste medido

Sin medir: no se ejecuta en procesadores de 64 bits.

Descripción

Legacy, VEX y EVEX versiones codificadas: Los enteros de byte, palabra o dword a partir de los bytes bajos del operando de origen (segundo operando) son cero extendidos a los enteros de palabras, dwords o cuádwords y almacenados en los bytes firmados por el operando de destino.

128-bit Legacy SSE versión: Bits (MAXVL-1:128) del registro de destino correspondiente no se modifican.

VEX.128 versión codificada: Bits (MAXVL-1:128) del registro de destino correspondiente se ponen a cero.

VEX.256 versión codificada: Bits (MAXVL-1:256) del registro de destino correspondiente se ponen a cero.

EVEX versiones codificadas: Los enteros de dwords empaquetados a partir de los bytes bajos del operando de origen (segundo operando) son cero extendidos a los enteros de quadword y almacenados al operando de destino bajo la máscara de escritura.El registro de destino es XMM, YMM o ZMM Registro.

Nota: VEX.vvvv y EVEX.vvvv están reservados y deben ser 1111b instrucciones de lo contrario #UD.

Operación

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++ compilador intrínseco

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 coma flotante Excepciones

None.

Otras excepciones

Instrucciones no codificadas en EVEX, ver Tabla 2-22, "Tipo 5 Condiciones de Excepción de Clase".

Instrucciones codificadas por EVEX, ver Tabla 2-53, "Tipo E5 Clase Condiciones de Excepción."

Additionally:

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

Fuentes