Vesta
Español
Código fuente

PMOVSX

Mover empaquetado con la extensión de la señal

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
66 0f 38 20 /rPMOVSXBW xmm1, xmm2/m64AValidoValidoSign extend 8 enteros de 8 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 8 enteros de 16 bits empaquetados en xmm1.
66 0f 38 21 /rPMOVSXBD xmm1, xmm2/m32AValidoValidoSeñalar 4 enteros de 8 bits empaquetados en los 4 bytes bajos de xmm2/m32 a 4 enteros de 32 bits empaquetados en xmm1.
66 0f 38 22 /rPMOVSXBQ xmm1, xmm2/m16AValidoValidoSeñalar 2 enteros de 8 bits empaquetados en los 2 bytes bajos de xmm2/m16 a 2 enteros de 64 bits empaquetados en xmm1.
66 0f 38 23/rPMOVSXWD xmm1, xmm2/m64AValidoValidoSeñalar 4 enteros de 16 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 4 enteros de 32 bits empaquetados en xmm1.
66 0f 38 24 /rPMOVSXWQ xmm1, xmm2/m32AValidoValidoSeñalar 2 enteros de 16 bits empaquetados en los 4 bytes bajos de xmm2/m32 a 2 enteros de 64 bits empaquetados en xmm1.
66 0f 38 25 /rPMOVSXDQ xmm1, xmm2/m64AValidoValidoSeñalar 2 enteros de 32 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 20 /rVPMOVSXBW xmm1, xmm2/m64AValidoValidoSign extend 8 enteros de 8 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 8 enteros de 16 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 21 /rVPMOVSXBD xmm1, xmm2/m32AValidoValidoSeñalar 4 enteros de 8 bits empaquetados en los 4 bytes bajos de xmm2/m32 a 4 enteros de 32 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 22 /rVPMOVSXBQ xmm1, xmm2/m16AValidoValidoSeñalar 2 enteros de 8 bits empaquetados en los 2 bytes bajos de xmm2/m16 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 23 /rVPMOVSXWD xmm1, xmm2/m64AValidoValidoSeñalar 4 enteros de 16 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 4 enteros de 32 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 24 /rVPMOVSXWQ xmm1, xmm2/m32AValidoValidoSeñalar 2 enteros de 16 bits empaquetados en los 4 bytes bajos de xmm2/m32 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.128.66.0F38.WIG 25 /rVPMOVSXDQ xmm1, xmm2/m64AValidoValidoSeñalar 2 enteros de 32 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 2 enteros de 64 bits empaquetados en xmm1.
VEX.256.66.0F38.WIG 20 /rVPMOVSXBW ymm1, xmm2/m128AValidoValidoSeñalar 16 enteros de 8 bits en xmm2/m128 a 16 enteros de 16 bits en ymm1.
VEX.256.66.0F38.WIG 21 /rVPMOVSXBD ymm1, xmm2/m64AValidoValidoSign extend 8 enteros de 8 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 8 enteros de 32 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 22 /rVPMOVSXBQ ymm1, xmm2/m32AValidoValidoSeñalar 4 enteros de 8 bits empaquetados en los 4 bytes bajos de xmm2/m32 a 4 enteros de 64 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 23 /rVPMOVSXWD ymm1, xmm2/m128AValidoValidoSeñalar 8 enteros de 16 bits empaquetados en los 16 bytes bajos de xmm2/m128 a 8 enteros de 32 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 24 /rVPMOVSXWQ ymm1, xmm2/m64AValidoValidoSeñalar 4 enteros de 16 bits empaquetados en los 8 bytes bajos de xmm2/m64 a 4 enteros de 64 bits empaquetados en ymm1.
VEX.256.66.0F38.WIG 25 /rVPMOVSXDQ ymm1, xmm2/m128 Opcode/ InstructionAValidoValidoSign extend 4 enteros de 32 bits empacados en los 16 bytes bajos de xmm2/m128 a 4 enteros de 64 bits empaquetados en ymm1. Op / 64/32 bit CPUID Característica Descripción En Mode Soporte Bandera
EVEX.128.66.0F38.WIG 20 /rVPMOVSXBW xmm1 {k1}{z}, xmm2/m64BValidoValidoExtensión de 8 enteros de 8 bits en xmm2/m64 a AVX512BW) OR 8 enteros de 16 bits en zmm1. AVX10.1
EVEX.256.66.0F38.WIG 20 /rVPMOVSXBW ymm1 {k1}{z}, xmm2/m128BValidoValidoSeñalar 16 enteros de 8 bits en xmm2/m128 AVX512BW) O a 16 enteros de 16 bits en ymm1. AVX10.1
EVEX.512.66.0F38.WIG 20 /rVPMOVSXBW zmm1 {k1}{z}, ymm2/m256BValidoValidoSeñalar 32 enteros de 8 bits empaquetados en ymm2/m256 OR AVX10.1 a 32 enteros de 16 bits empaquetados en zmm1.
EVEX.128.66.0F38.WIG 21 /rVPMOVSXBD xmm1 {k1}{z}, xmm2/m32CValidoValidoSeñalar 4 enteros de 8 bits empaquetados en los 4 bytes bajos AVX512F) OR de xmm2/m32 a 4 enteros de 32 bits empaquetados en xmm1 AVX10.1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 21 /rVPMOVSXBD ymm1 {k1}{z}, xmm2/m64CValidoValidoSeñalar extender 8 enteros de 8 bits en los 8 bytes bajos AVX512F) O de xmm2/m64 a 8 enteros de 32 bits empaquetados en ymm1 AVX10.1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 21 /rVPMOVSXBD zmm1 {k1}{z}, xmm2/m128CValidoValidoSeñalar 16 enteros de 8 bits empaquetados en los bajos 16 OR AVX10.1 bytes de xmm2/m128 a 16 enteros de 32 bits empaquetados en zmm1 sujetos a máscara de escritura k1.
EVEX.128.66.0F38.WIG 22 /rVPMOVSXBQ xmm1 {k1}{z}, xmm2/m16DValidoValidoSeñalar 2 enteros de 8 bits empaquetados en los 2 bytes bajos AVX512F) OR de xmm2/m16 a 2 enteros de 64 bits empaquetados en xmm1 AVX10.1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 22 /rVPMOVSXBQ ymm1 {k1}{z}, xmm2/m32DValidoValidoSeñalar 4 enteros de 8 bits empaquetados en los 4 bytes bajos AVX512F) OR de xmm2/m32 a 4 enteros de 64 bits empaquetados en ymm1 AVX10.1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 22 /rVPMOVSXBQ zmm1 {k1}{z}, xmm2/m64DValidoValidoSeñalar extender 8 enteros de 8 bits en los 8 bytes bajos OR AVX10.1 de xmm2/m64 a 8 enteros de 64 bits empaquetados en zmm1 sujeto a máscara de escritura k1.
EVEX.128.66.0F38.WIG 23 /rVPMOVSXWD xmm1 {k1}{z}, xmm2/m64BValidoValidoSeñalar 4 enteros de 16 bits empaquetados en los bajos 8 AVX512F) O de ymm2/mem a 4 enteros de 32 bits en AVX10.1 xmm1 sujetos a máscara de escritura k1.
EVEX.256.66.0F38.WIG 23 /rVPMOVSXWD ymm1 {k1}{z}, xmm2/m128BValidoValidoSeñalar extender 8 enteros de 16 bits en los bajos 16 AVX512F) O de ymm2/m128 a 8 enteros de 32 bits empaquetados en AVX10.1 ymm1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 23 /rVPMOVSXWD zmm1 {k1}{z}, ymm2/m256BValidoValidoSeñalar 16 enteros de 16 bits en los bajos 32 OR AVX10.1 bytes de ymm2/m256 a 16 enteros de 32 bits empaquetados en zmm1 sujetos a máscara de escritura k1.
EVEX.128.66.0F38.WIG 24 /rVPMOVSXWQ xmm1 {k1}{z}, xmm2/m32CValidoValidoSeñalar 2 enteros de 16 bits empaquetados 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 24 /rVPMOVSXWQ ymm1 {k1}{z}, xmm2/m64CValidoValidoSeñalar 4 enteros de 16 bits empaquetados en los bajos 8 AVX512F) O de xmm2/m64 a 4 enteros de 64 bits empaquetados en AVX10.1 ymm1 sujetos a máscara de escritura k1.
EVEX.512.66.0F38.WIG 24 /rVPMOVSXWQ zmm1 {k1}{z}, xmm2/m128CValidoValidoSeñalar extender 8 enteros de 16 bits en los bajos 16 OR AVX10.1 bytes de xmm2/m128 a 8 enteros de 64 bits empaquetados en zmm1 sujeto a máscara de escritura k1.
EVEX.128.66.0F38.W0 25 /rVPMOVSXDQ xmm1 {k1}{z}, xmm2/m64 Opcode/ InstructionBValidoValidoSeñalar 2 enteros de 32 bits empaquetados en los bajos 8 AVX512F) O de xmm2/m64 a 2 enteros de 64 bits empaquetados en AVX10.1 zmm1 utilizando máscara de escritura k1. Op / 64/32 bit CPUID Destacar e Descripción En Mode Soporte Bandera
EVEX.256.66.0F38.W0 25 /rVPMOVSXDQ ymm1 {k1}{z}, xmm2/m128BValidoValidoD Sign extend 4 enteros de 32 bits empaquetados en los bajos 16 AVX512F) O bytes de xmm2/m128 a 4 enteros de 64 bits empaquetados en AVX10.1 zmm1 utilizando máscara de escritura k1.
EVEX.512.66.0F38.W0 25 /rVPMOVSXDQ zmm1 {k1}{z}, ymm2/m256BValidoValidoSeñalar 8 enteros de 32 bits empaquetados en los bajos 32 O AVX10.1 bytes de 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 y VEX versiones codificadas: Los enteros de byte, palabra o dword empaquetados en los bytes bajos del operando de origen (segundo operando) son signos extendidos a los enteros de palabras, dwords o cuádwords y almacenados en los bytes firmados empaquetados el operando de destino.

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

VEX.128 y EVEX.128 versiones codificadas: Bits (MAXVL-1:128) del registro de destino correspondiente se ponen a cero.

VEX.256 y EVEX.256 versiones codificadas: Bits (MAXVL-1:256) del registro de destino correspondiente se ponen a cero.

EVEX versiones codificadas: Los enteros de byte, palabra o dword a partir de los bytes bajos del operando de origen (segundo operando) son signos extendidos a los enteros de palabra, dword o cuadword y almacenados al operando de destino bajo la máscara de escritura. El registro de destino es XMM, YMM o ZMM Register.

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

Operación

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

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