PSHUFHW

Shuffle Packed High Words

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`F3 0F 70 /r ib`	`PSHUFHW xmm1, xmm2/m128, imm8`	A	Valido	Valido	Sustitúyase las palabras altas en xmm2/m128 basadas en la codificación en imm8 y almacene el resultado en xmm1.
`VEX.128.F3.0F.WIG 70 /r ib`	`VPSHUFHW xmm1, xmm2/m128, imm8`	A	Valido	Valido	Sustitúyase las palabras altas en xmm2/m128 basadas en la codificación en imm8 y almacene el resultado en xmm1.
`VEX.256.F3.0F.WIG 70 /r ib`	`VPSHUFHW ymm1, ymm2/m256, imm8`	A	Valido	Valido	Sustitúyase las palabras altas en ymm2/m256 basadas en la codificación en imm8 y almacene el resultado en ymm1.
`EVEX.128.F3.0F.WIG 70 /r ib`	`VPSHUFHW xmm1 {k1}{z}, xmm2/m128, imm8`	B	Valido	Valido	Sustitúyase las palabras altas en xmm2/m128 basado AVX512BW) O en la codificación en imm8 y almacene el resultado en AVX10.1 xmm1 bajo máscara de escritura k1.
`EVEX.256.F3.0F.WIG 70 /r ib`	`VPSHUFHW ymm1 {k1}{z}, ymm2/m256, imm8`	B	Valido	Valido	Sustitúyase las palabras altas en ymm2/m256 basado AVX512BW) O en la codificación en imm8 y almacene el resultado en AVX10.1 ymm1 bajo máscara de escritura k1.
`EVEX.512.F3.0F.WIG 70 /r ib`	`VPSHUFHW zmm1 {k1}{z}, zmm2/m512, imm8`	B	Valido	Valido	Deslizar las palabras altas en zmm2/m512 basado OR AVX10.1 en la codificación en imm8 y almacenar el resultado en zmm1 bajo 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

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
imm8byte inmediato que sigue a la instruccion

B

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
imm8byte inmediato que sigue a la instruccion

Tupla: Full Mem

Coste medido

Cargando las mediciones de arch-data...

Descripción

Copia las palabras del cuádpago alto de un carril de 128 bits del operando de origen e inserta en el cuádpalo alto del operando de destino en las ubicaciones de palabras (de la carril respectiva) seleccionadas con el operando inmediato. Esta operación de 256 bits es similar a la operación en línea utilizada por la instrucción VPSHUFD de 256 bits, que se ilustra en la Figura 4-16. Para la operación de 128 bits, sólo el carril bajo de 128 bits está operativo. Cada campo de 2 bits en el operando inmediato selecciona el contenido de una palabra ubicación en el cuadripado alto del operando de destino. Las codificacións binarias de los campos el operando inmediato seleccionan palabras (0, 1, 2 o 3, 4) de la alta cuádpalabra del operando de origen para ser copiado al operando de destino. El cuádpago bajo del operando de origen es copiado al bajo cuádpago del operando de destino, por cada carril de 128 bits.

Tenga en cuenta que esta instrucción permite que una palabra en el cuadword alto del operando de origen sea copiada a más de una palabra localización en el cuaderno alto del operando de destino.

En modo de 64 bits y no codificado con VEX/EVEX, utilizando un prefijo REX en forma de REX.R permite esta instrucción para acceder a registros adicionales (XMM8-XMM15).

128-bit Legacy SSE versión: El operando de destino es un registro XMM. El operando de origen puede ser un registro XMM o una ubicación de memoria de 128 bits. Bits (MAXVL-1:128) del correspondiente registro de destino YMM no se modifican.

VEX.128 versión codificada: El operando de destino es un registro XMM. El operando de origen puede ser un registro XMM o una ubicación de memoria de 128 bits. Bits (MAXVL-1:128) del destino YMM registro se ponen a cero. VEX.vvvv está reservado y debe ser 1111b, VEX.L debe ser 0, de lo contrario la instrucción será #UD.

VEX.256 versión codificada: El operando de destino es un registro YMM. El operando de origen puede ser un registro YMM o una ubicación de memoria de 256 bits.

EVEX versión codificada: El operando de destino es un registro ZMM/YMM/XMM. El operando de origen puede ser un registro ZMM/YMM/XMM, un 512/256/128-bit ubicación de memoria. El destino se actualiza según la máscara de escritura.

Nota: En VEX versiones codificadas, VEX.vvvv está reservado y debe ser 1111b instrucciones de lo contrario #UD.

Operación

PSHUFHW (128-bit Legacy SSE Version)
DEST[63:0] := SRC[63:0]
DEST[79:64] := (SRC >> (imm[1:0] *16))[79:64]
DEST[95:80] := (SRC >> (imm[3:2] * 16))[79:64]
DEST[111:96] := (SRC >> (imm[5:4] * 16))[79:64]
DEST[127:112] := (SRC >> (imm[7:6] * 16))[79:64]
DEST[MAXVL-1:128] (Unmodified)

VPSHUFHW (VEX.128 Encoded Version)
DEST[63:0] := SRC1[63:0]
DEST[79:64] := (SRC1 >> (imm[1:0] *16))[79:64]
DEST[95:80] := (SRC1 >> (imm[3:2] * 16))[79:64]
DEST[111:96] := (SRC1 >> (imm[5:4] * 16))[79:64]
DEST[127:112] := (SRC1 >> (imm[7:6] * 16))[79:64]
DEST[MAXVL-1:128] := 0

VPSHUFHW (VEX.256 Encoded Version)
DEST[63:0] := SRC1[63:0]
DEST[79:64] := (SRC1 >> (imm[1:0] *16))[79:64]
DEST[95:80] := (SRC1 >> (imm[3:2] * 16))[79:64]
DEST[111:96] := (SRC1 >> (imm[5:4] * 16))[79:64]
DEST[127:112] := (SRC1 >> (imm[7:6] * 16))[79:64]
DEST[191:128] := SRC1[191:128]
DEST[207192] := (SRC1 >> (imm[1:0] *16))[207:192]
DEST[223:208] := (SRC1 >> (imm[3:2] * 16))[207:192]
DEST[239:224] := (SRC1 >> (imm[5:4] * 16))[207:192]
DEST[255:240] := (SRC1 >> (imm[7:6] * 16))[207:192]
DEST[MAXVL-1:256] := 0

VPSHUFHW (EVEX Encoded Versions)
(KL, VL) = (8, 128), (16, 256), (32, 512)
IF VL >= 128

    TMP_DEST[63:0] := SRC1[63:0]
    TMP_DEST[79:64] := (SRC1 >> (imm[1:0] *16))[79:64]
    TMP_DEST[95:80] := (SRC1 >> (imm[3:2] * 16))[79:64]
    TMP_DEST[111:96] := (SRC1 >> (imm[5:4] * 16))[79:64]
    TMP_DEST[127:112] := (SRC1 >> (imm[7:6] * 16))[79:64]
FI;
IF VL >= 256
    TMP_DEST[191:128] := SRC1[191:128]
    TMP_DEST[207:192] := (SRC1 >> (imm[1:0] *16))[207:192]
    TMP_DEST[223:208] := (SRC1 >> (imm[3:2] * 16))[207:192]
    TMP_DEST[239:224] := (SRC1 >> (imm[5:4] * 16))[207:192]
    TMP_DEST[255:240] := (SRC1 >> (imm[7:6] * 16))[207:192]
FI;
IF VL >= 512
    TMP_DEST[319:256] := SRC1[319:256]
    TMP_DEST[335:320] := (SRC1 >> (imm[1:0] *16))[335:320]


    TMP_DEST[351:336] := (SRC1 >> (imm[3:2] * 16))[335:320]
    TMP_DEST[367:352] := (SRC1 >> (imm[5:4] * 16))[335:320]
    TMP_DEST[383:368] := (SRC1 >> (imm[7:6] * 16))[335:320]
    TMP_DEST[447:384] := SRC1[447:384]
    TMP_DEST[463:448] := (SRC1 >> (imm[1:0] *16))[463:448]
    TMP_DEST[479:464] := (SRC1 >> (imm[3:2] * 16))[463:448]
    TMP_DEST[495:480] := (SRC1 >> (imm[5:4] * 16))[463:448]
    TMP_DEST[511:496] := (SRC1 >> (imm[7:6] * 16))[463:448]
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

Intel C/C++ compilador intrínseco

VPSHUFHW __m512i _mm512_shufflehi_epi16(__m512i a, int n);
VPSHUFHW __m512i _mm512_mask_shufflehi_epi16(__m512i s, __mmask16 k, __m512i a, int n );
VPSHUFHW __m512i _mm512_maskz_shufflehi_epi16( __mmask16 k, __m512i a, int n );
VPSHUFHW __m256i _mm256_mask_shufflehi_epi16(__m256i s, __mmask8 k, __m256i a, int n );
VPSHUFHW __m256i _mm256_maskz_shufflehi_epi16( __mmask8 k, __m256i a, int n );
VPSHUFHW __m128i _mm_mask_shufflehi_epi16(__m128i s, __mmask8 k, __m128i a, int n );
VPSHUFHW __m128i _mm_maskz_shufflehi_epi16( __mmask8 k, __m128i a, int n );
(V)PSHUFHW __m128i _mm_shufflehi_epi16(__m128i a, int n) VPSHUFHW __m256i _mm256_shufflehi_epi16(__m256i a, const int n);

Banderas afectadas

None.

SIMD coma flotante Excepciones

None.

Otras excepciones

Instrucciones no codificadas por EVEX, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase".

EVEX-encoded instruction, ver Excepciones Tipo E4NF.nb en la tabla 2-52, "Tipo E4NF Clase Condiciones de Excepción."

Additionally:

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

PSHUFHW

Codificaciones

Codificacion de operandos

A

B

Coste medido

Descripción#

Operación#

Intel C/C++ compilador intrínseco#

Banderas afectadas#

SIMD coma flotante Excepciones#