PSRLW, PSRLD, PSRLQ

Cambio de datos empaquetados derecho lógico

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`NP 0F D1 /r1`	`PSRLW mm, mm/m64`	A	Valido	Valido	Palabras de desplazamiento en mm derecha por cantidad especificada en mm/m64 mientras se desplaza en 0s.
`66 0F D1 /r`	`PSRLW xmm1, xmm2/m128`	A	Valido	Valido	Palabras de cambio en xmm1 derecho por cantidad especificada en xmm2/m128 mientras se desplaza en 0s.
`NP 0F 71 /2 ib1`	`PSRLW mm, imm8`	B	Valido	Valido	Palabras de cambio en mm derecha por imm8 mientras se desplaza en 0s.
`66 0F 71 /2 ib`	`PSRLW xmm1, imm8`	B	Valido	Valido	Palabras de cambio en xmm1 derecha por imm8 mientras se desplaza en 0s.
`NP 0F D2 /r1`	`PSRLD mm, mm/m64`	A	Valido	Valido	Espadas dobles en mm derecha por cantidad especificada en mm/m64 mientras se desplaza en 0s.
`66 0F D2 /r`	`PSRLD xmm1, xmm2/m128`	A	Valido	Valido	Espadas dobles en xmm1 derecha por cantidad especificada en xmm2 /m128 mientras se desplaza en 0s.
`NP 0F 72 /2 ib1`	`PSRLD mm, imm8`	B	Valido	Valido	Espadas dobles en mm derecha por imm8 mientras se desplaza en 0s.
`66 0F 72 /2 ib`	`PSRLD xmm1, imm8`	B	Valido	Valido	Espadas dobles en xmm1 a la derecha por imm8 mientras se desplaza en 0s.
`NP 0F D3 /r1`	`PSRLQ mm, mm/m64`	A	Valido	Valido	Modo derecho por la cantidad especificada en mm/m64 mientras se desplaza en 0s.
`66 0F D3 /r`	`PSRLQ xmm1, xmm2/m128`	A	Valido	Valido	Shift quadwords en xmm1 derecho por cantidad especificada en xmm2/m128 mientras se desplaza en 0s.
`NP 0F 73 /2 ib1`	`PSRLQ mm, imm8`	B	Valido	Valido	Shift mm derecho por imm8 mientras se desplaza en 0s.
`66 0F 73 /2 ib`	`PSRLQ xmm1, imm8`	B	Valido	Valido	Shift quadwords en xmm1 a la derecha por imm8 mientras se desplaza en 0s.
`VEX.128.66.0F.WIG D1 /r`	`VPSRLW xmm1, xmm2, xmm3/m128`	C	Valido	Valido	Palabras de cambio en xmm2 derecho por cantidad especificada en xmm3/m128 mientras se desplaza en 0s.
`VEX.128.66.0F.WIG 71 /2 ib`	`VPSRLW xmm1, xmm2, imm8`	D	Valido	Valido	Palabras de cambio en xmm2 derecha por imm8 mientras se desplaza en 0s.
`VEX.128.66.0F.WIG D2 /r`	`VPSRLD xmm1, xmm2, xmm3/m128`	C	Valido	Valido	Espadas dobles en xmm2 derecha por cantidad especificada en xmm3/m128 mientras se desplaza en 0s.
`VEX.128.66.0F.WIG 72 /2 ib`	`VPSRLD xmm1, xmm2, imm8`	D	Valido	Valido	Espadas dobles en xmm2 a la derecha por imm8 mientras se desplaza en 0s.
`VEX.128.66.0F.WIG D3 /r`	`VPSRLQ xmm1, xmm2, xmm3/m128`	C	Valido	Valido	Shift quadwords en xmm2 derecho por cantidad especificada en xmm3/m128 mientras se desplaza en 0s.
`VEX.128.66.0F.WIG 73 /2 ib`	`VPSRLQ xmm1, xmm2, imm8`	D	Valido	Valido	Shift quadwords en xmm2 a la derecha por imm8 mientras se desplaza en 0s.
`VEX.256.66.0F.WIG D1 /r`	`VPSRLW ymm1, ymm2, xmm3/m128`	C	Valido	Valido	Palabras de cambio en ymm2 derecho por cantidad especificada en xmm3/m128 mientras se desplaza en 0s.
`VEX.256.66.0F.WIG 71 /2 ib`	`VPSRLW ymm1, ymm2, imm8 Opcode/ Instruction`	D	Valido	Valido	Palabras de cambio enymm2derechoimm8durante el cambio en 0s. Op/ 64/32 bitCPUIDCaracterísticas Descripción En Modo Soporte Bandera
`VEX.256.66.0F.WIG D2 /r`	`VPSRLD ymm1, ymm2, xmm3/m128`	C	Valido	Valido	Espadas dobles en ymm2 derecha por cantidad especificada en xmm3/m128 mientras se desplaza en 0s.
`VEX.256.66.0F.WIG 72 /2 ib`	`VPSRLD ymm1, ymm2, imm8`	D	Valido	Valido	Espadas dobles en ymm2 a la derecha por imm8 mientras se desplaza en 0s.
`VEX.256.66.0F.WIG D3 /r`	`VPSRLQ ymm1, ymm2, xmm3/m128`	C	Valido	Valido	Shift quadwords en ymm2 derecho por cantidad especificada en xmm3/m128 mientras se desplaza en 0s.
`VEX.256.66.0F.WIG 73 /2 ib`	`VPSRLQ ymm1, ymm2, imm8`	D	Valido	Valido	Shift quadwords en ymm2 a la derecha por imm8 mientras se desplaza en 0s.
`EVEX.128.66.0F.WIG D1 /r`	`VPSRLW xmm1 {k1}{z}, xmm2, xmm3/m128`	G	Valido	Valido	Palabras clave en xmm2 derecho por cantidad especificada AVX512BW) OR AVX10.1 en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.256.66.0F.WIG D1 /r`	`VPSRLW ymm1 {k1}{z}, ymm2, xmm3/m128`	G	Valido	Valido	Palabras clave en ymm2 derecho por cantidad especificada AVX512BW) OR AVX10.1 en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.512.66.0F.WIG D1 /r`	`VPSRLW zmm1 {k1}{z}, zmm2, xmm3/m128`	G	Valido	Valido	Palabras de cambio en zmm2 derecho por cantidad especificada AVX10.1 en xmm3/m128 mientras que el cambio en 0s usando Writemask k1.
`EVEX.128.66.0F.WIG 71 /2 ib`	`VPSRLW xmm1 {k1}{z}, xmm2/m128, imm8`	E	Valido	Valido	Shift words in xmm2/m128 right by imm8 AVX512BW) OR AVX10.1 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.256.66.0F.WIG 71 /2 ib`	`VPSRLW ymm1 {k1}{z}, ymm2/m256, imm8`	E	Valido	Valido	Shift words in ymm2/m256 right by imm8 AVX512BW) OR AVX10.1 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.512.66.0F.WIG 71 /2 ib`	`VPSRLW zmm1 {k1}{z}, zmm2/m512, imm8`	E	Valido	Valido	Palabras de cambio enzmm2/m512derechoimm8 AVX10.1mientras que el cambio en 0smáscara de escritura k1.
`EVEX.128.66.0F.W0 D2 /r`	`VPSRLD xmm1 {k1}{z}, xmm2, xmm3/m128`	G	Valido	Valido	Espadas dobles en xmm2 derecho por cantidad AVX512F) OR AVX10.1 especificadas en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.256.66.0F.W0 D2 /r`	`VPSRLD ymm1 {k1}{z}, ymm2, xmm3/m128`	G	Valido	Valido	Espadas dobles en ymm2 derecho por cantidad AVX512F) OR AVX10.1 especificadas en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.512.66.0F.W0 D2 /r`	`VPSRLD zmm1 {k1}{z}, zmm2, xmm3/m128`	G	Valido	Valido	Espadas dobles en zmm2 derecho por cantidad OR AVX10.1 especificadas en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.128.66.0F.W0 72 /2 ib`	`VPSRLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8`	F	Valido	Valido	Espadas dobles en xmm2/m128/m32bcst AVX512F) O derecha por imm8 mientras se desplaza en 0s utilizando AVX10.1 máscara de escritura k1.
`EVEX.256.66.0F.W0 72 /2 ib`	`VPSRLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8`	F	Valido	Valido	Espadas dobles en ymm2/m256/m32bcst AVX512F) O derecha por imm8 mientras se desplaza en 0s utilizando AVX10.1 máscara de escritura k1.
`EVEX.512.66.0F.W0 72 /2 ib`	`VPSRLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8`	F	Valido	Valido	Espadas dobles en zmm2/m512/m32bcst OR AVX10.1 derecha por imm8 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.128.66.0F.W1 D3 /r`	`VPSRLQ xmm1 {k1}{z}, xmm2, xmm3/m128 Opcode/ Instruction`	G	Valido	Valido	Shift quadwords en xmm2 derecho por cantidad AVX512F) OR AVX10.1 especificado en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1. Op/ 64/32 bit CPUID Característica Descripción En Mode Soporte Bandera de soporte
`EVEX.256.66.0F.W1 D3 /r`	`VPSRLQ ymm1 {k1}{z}, ymm2, xmm3/m128`	G	Valido	Valido	Shift quadwords en ymm2 derecho por cantidad AVX512F) OR AVX10.1 especificado en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.512.66.0F.W1 D3 /r`	`VPSRLQ zmm1 {k1}{z}, zmm2, xmm3/m128`	G	Valido	Valido	Shift quadwords en zmm2 derecho por cantidad OR AVX10.1 especificado en xmm3/m128 mientras se desplaza en 0s utilizando máscara de escritura k1.
`EVEX.128.66.0F.W1 73 /2 ib`	`VPSRLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8`	F	Valido	Valido	Shift quadwords en xmm2/m128/m64bcst AVX512F) OR right by imm8 mientras se desplaza en 0s utilizando AVX10.1 máscara de escritura k1.
`EVEX.256.66.0F.W1 73 /2 ib`	`VPSRLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8`	F	Valido	Valido	Shift quadwords en ymm2/m256/m64bcst AVX512F) OR right by imm8 mientras se desplaza en 0s utilizando AVX10.1 máscara de escritura k1.
`EVEX.512.66.0F.W1 73 /2 ib`	`VPSRLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8`	F	Valido	Valido	Shift quadwords en zmm2/m512/m64bcst OR AVX10.1 a la derecha por imm8 mientras que el cambio en 0s usando Writemask 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 lectura y 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

B

modrm.rm lectura y escriturabyte 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

C

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

D

vex.vvvv escrituraprefijo VEX, campo vvvv (invertido)
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

E

evex.vvvv escrituraprefijo EVEX, campo vvvv (invertido)
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

F

evex.vvvv escrituraprefijo EVEX, campo vvvv (invertido)
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

G

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

Tupla: Mem128

Coste medido

Cargando las mediciones de arch-data...

Descripción

Cambia los bits en los elementos de datos individuales (palabras, palabras dobles o cuádwords) en el operando de destino (primero operando) a la derecha por el número de bits especificados en el conteo operando (segundo operando). A medida que los bits de los elementos de datos se desplazan a la derecha, los bits vacíos de alto orden se limpian (configurado a 0). Si el valor especificado por el conteo operando es mayor de 15 (para palabras), 31 (para palabras dobles), o 63 (para un cuádpago), entonces el operando de destino se establece a todos los 0s. La Figura 4-19 da un ejemplo de cambio de palabras en un operando de 64 bits.

Tenga en cuenta que sólo los 64 bits bajos de un conteo de 128 bits operando se verifican para calcular el conteo.

Pre-Shift X3 X2 X1 X0 DEST

Cambio justo con la extensión cero

Post-Shift X3>> COUNT X2 >> COUNT X1 >> COUNT X0 >> COUNT DEST

Figura 4-19. PSRLW, PSRLD y PSRLQ Instrucción Operación Usando Operand de 64 bits

La instrucción (V)PSRLW cambia cada una de las palabras en el operando de destino a la derecha por el número de bits especificados en el recuento operando; la instrucción (V)PSRLD cambia cada una de las palabras dobles en el operando de destino; y la instrucción PSRLQ cambia el cuádword (o cuádwords) en el 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).

Legacy SSE instrucción 64-bit operando: El operando de destino es un registro de tecnología MMX; el conteo operando puede ser un registro de tecnología MMX o una ubicación de memoria de 64 bits.

128-bit Legacy SSE versión: El operando de destino es un registro XMM; el conteo operando puede ser un registro XMM o una ubicación de memoria de 128 bits, o de 8 bits inmediatamente. Si el conteo operando es una dirección de memoria, 128 bits están cargados pero los 64 bits superiores son ignorados. 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 conteo operando puede ser un registro XMM o una ubicación de memoria de 128 bits, o de 8 bits inmediatamente. Si el conteo operando es una dirección de memoria, 128 bits están cargados pero los 64 bits superiores son ignorados. Bits (MAXVL-1:128) del destino YMM registro se ponen a cero.

VEX.256 versión codificada: El operando de destino es un registro YMM. El operando de origen es un registro YMM o una ubicación de memoria. El conteo operando puede venir ya sea de un registro XMM o una ubicación de memoria o de 8 bits inmediatamente. Bits (MAXVL-1:256) del registro ZMM correspondiente se ponen a cero.

EVEX versiones codificadas: El operando de destino es un registro ZMM actualizado según la máscara de escritura. El recuento operando es un inmediato de 8 bits (la versión de cuenta inmediata) o un valor de 8 bits de un registro XMM o una ubicación de memoria (la versión de cuenta variable). Para la versión de cuenta inmediata, el operando de origen (el segundo operando) puede ser un registro ZMM, una ubicación de memoria de 512 bits o un vector de 512 bits emitido desde una ubicación de memoria de 32/64 bits. Para la versión de cuenta variable, el primer operando de origen (el segundo operando) es un registro ZMM, el segundo operando de origen (el tercer operando, conteo variable de 8 bits) puede ser un registro XMM o una ubicación de memoria.

Nota: En VEX/EVEX versiones codificadas de turnos con un recuento inmediato, vvvv de VEX/EVEX codifica el registro de destino, y VEX.B/EVEX.B + ModRM.r/m codifica el registro de origen.

Nota: Para los turnos con un conteo inmediato (VEX.128.66.0F 71-73 /2, o EVEX.128.66.0F 71-73 /2), VEX.vvvv/EVEX.vvvv codifica el registro de destino.

Operación

PSRLW (With 64-bit Operand)
    IF (COUNT > 15)
    THEN
          DEST[64:0] := 0000000000000000H
    ELSE
         DEST[15:0] := ZeroExtend(DEST[15:0] >> COUNT);
          (* Repeat shift operation for 2nd and 3rd words *)
         DEST[63:48] := ZeroExtend(DEST[63:48] >> COUNT);
    FI;


PSRLD (With 64-bit Operand)
    IF (COUNT > 31)
    THEN
          DEST[64:0] := 0000000000000000H
    ELSE
         DEST[31:0] := ZeroExtend(DEST[31:0] >> COUNT);
         DEST[63:32] := ZeroExtend(DEST[63:32] >> COUNT);
    FI;

PSRLQ (With 64-bit Operand)
    IF (COUNT > 63)
    THEN
          DEST[64:0] := 0000000000000000H
    ELSE
         DEST := ZeroExtend(DEST >> COUNT);
    FI;

LOGICAL_RIGHT_SHIFT_DWORDS1(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[31:0] := 0
ELSE

    DEST[31:0] := ZeroExtend(SRC[31:0] >> COUNT);
FI;

LOGICAL_RIGHT_SHIFT_QWORDS1(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN

    DEST[63:0] := 0
ELSE

    DEST[63:0] := ZeroExtend(SRC[63:0] >> COUNT);
FI;
LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 15)
THEN

    DEST[255:0] := 0
ELSE

    DEST[15:0] := ZeroExtend(SRC[15:0] >> COUNT);
    (* Repeat shift operation for 2nd through 15th words *)
    DEST[255:240] := ZeroExtend(SRC[255:240] >> COUNT);
FI;

LOGICAL_RIGHT_SHIFT_WORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 15)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
ELSE

    DEST[15:0] := ZeroExtend(SRC[15:0] >> COUNT);
    (* Repeat shift operation for 2nd through 7th words *)
    DEST[127:112] := ZeroExtend(SRC[127:112] >> COUNT);
FI;


LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[255:0] := 0
ELSE

    DEST[31:0] := ZeroExtend(SRC[31:0] >> COUNT);
    (* Repeat shift operation for 2nd through 3rd words *)
    DEST[255:224] := ZeroExtend(SRC[255:224] >> COUNT);
FI;

LOGICAL_RIGHT_SHIFT_DWORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 31)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
ELSE

    DEST[31:0] := ZeroExtend(SRC[31:0] >> COUNT);
    (* Repeat shift operation for 2nd through 3rd words *)
    DEST[127:96] := ZeroExtend(SRC[127:96] >> COUNT);
FI;
LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN
    DEST[255:0] := 0
ELSE
    DEST[63:0] := ZeroExtend(SRC[63:0] >> COUNT);
    DEST[127:64] := ZeroExtend(SRC[127:64] >> COUNT);
    DEST[191:128] := ZeroExtend(SRC[191:128] >> COUNT);
    DEST[255:192] := ZeroExtend(SRC[255:192] >> COUNT);
FI;

LOGICAL_RIGHT_SHIFT_QWORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC[63:0];
IF (COUNT > 63)
THEN

    DEST[127:0] := 00000000000000000000000000000000H
ELSE

    DEST[63:0] := ZeroExtend(SRC[63:0] >> COUNT);
    DEST[127:64] := ZeroExtend(SRC[127:64] >> COUNT);
FI;

VPSRLW (EVEX Versions, xmm/m128)
(KL, VL) = (8, 128), (16, 256), (32, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_RIGHT_SHIFT_WORDS_128b(SRC1[127:0], SRC2)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], SRC2)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], SRC2)


    TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[511:256], SRC2)
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

VPSRLW (EVEX Versions, imm8)
(KL, VL) = (8, 128), (16, 256), (32, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_RIGHT_SHIFT_WORDS_128b(SRC1[127:0], imm8)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], imm8)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[255:0], imm8)
    TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1[511:256], imm8)
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

VPSRLW (ymm, ymm, xmm/m128) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0;

VPSRLW (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_WORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;


VPSRLW (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_WORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSRLW (xmm, imm8) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_WORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSRLW (xmm, xmm, xmm/m128)
DEST[127:0] := LOGICAL_RIGHT_SHIFT_WORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)

PSRLW (xmm, imm8)
DEST[127:0] := LOGICAL_RIGHT_SHIFT_WORDS(DEST, imm8)
DEST[MAXVL-1:128] (Unmodified)

VPSRLD (EVEX Versions, xmm/m128)
(KL, VL) = (4, 128), (8, 256), (16, 512)
IF VL = 128

    TMP_DEST[127:0] := LOGICAL_RIGHT_SHIFT_DWORDS_128b(SRC1[127:0], SRC2)
FI;
IF VL = 256

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC1[255:0], SRC2)
FI;
IF VL = 512

    TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC1[255:0], SRC2)
    TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC1[511:256], SRC2)
FI;

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask*

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

VPSRLD (EVEX Versions, imm8)

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

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask* THEN

             IF (EVEX.b = 1) AND (SRC1 *is memory*)

                  THEN DEST[i+31:i] := LOGICAL_RIGHT_SHIFT_DWORDS1(SRC1[31:0], imm8)

                  ELSE DEST[i+31:i] := LOGICAL_RIGHT_SHIFT_DWORDS1(SRC1[i+31:i], imm8)

             FI;

     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

VPSRLD (ymm, ymm, xmm/m128) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0;

VPSRLD (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_DWORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;

VPSRLD (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_DWORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSRLD (xmm, imm8) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_DWORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSRLD (xmm, xmm, xmm/m128)
DEST[127:0] := LOGICAL_RIGHT_SHIFT_DWORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)

PSRLD (xmm, imm8)
DEST[127:0] := LOGICAL_RIGHT_SHIFT_DWORDS(DEST, imm8)
DEST[MAXVL-1:128] (Unmodified)

VPSRLQ (EVEX Versions, xmm/m128)

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

TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)

TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[511:256], SRC2)

IF VL = 128

     TMP_DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS_128b(SRC1[127:0], SRC2)

FI;

IF VL = 256

     TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)

FI;

IF VL = 512

     TMP_DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[255:0], SRC2)

     TMP_DEST[511:256] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1[511:256], SRC2)

FI;

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

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

VPSRLQ (EVEX Versions, imm8)

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

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask* THEN

             IF (EVEX.b = 1) AND (SRC1 *is memory*)

                  THEN DEST[i+63:i] := LOGICAL_RIGHT_SHIFT_QWORDS1(SRC1[63:0], imm8)

                  ELSE DEST[i+63:i] := LOGICAL_RIGHT_SHIFT_QWORDS1(SRC1[i+63:i], imm8)

             FI;

     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

VPSRLQ (ymm, ymm, xmm/m128) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1, SRC2)
DEST[MAXVL-1:256] := 0;

VPSRLQ (ymm, imm8) - VEX.256 Encoding
DEST[255:0] := LOGICAL_RIGHT_SHIFT_QWORDS_256b(SRC1, imm8)
DEST[MAXVL-1:256] := 0;
VPSRLQ (xmm, xmm, xmm/m128) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS(SRC1, SRC2)
DEST[MAXVL-1:128] := 0

VPSRLQ (xmm, imm8) - VEX.128 Encoding
DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS(SRC1, imm8)
DEST[MAXVL-1:128] := 0

PSRLQ (xmm, xmm, xmm/m128)
DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS(DEST, SRC)
DEST[MAXVL-1:128] (Unmodified)

PSRLQ (xmm, imm8)
DEST[127:0] := LOGICAL_RIGHT_SHIFT_QWORDS(DEST, imm8)
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ compilador intrínseco

VPSRLD __m512i _mm512_srli_epi32(__m512i a, unsigned int imm);
VPSRLD __m512i _mm512_mask_srli_epi32(__m512i s, __mmask16 k, __m512i a, unsigned int imm);
VPSRLD __m512i _mm512_maskz_srli_epi32( __mmask16 k, __m512i a, unsigned int imm);
VPSRLD __m256i _mm256_mask_srli_epi32(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSRLD __m256i _mm256_maskz_srli_epi32( __mmask8 k, __m256i a, unsigned int imm);
VPSRLD __m128i _mm_mask_srli_epi32(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRLD __m128i _mm_maskz_srli_epi32( __mmask8 k, __m128i a, unsigned int imm);
VPSRLD __m512i _mm512_srl_epi32(__m512i a, __m128i cnt);
VPSRLD __m512i _mm512_mask_srl_epi32(__m512i s, __mmask16 k, __m512i a, __m128i cnt);
VPSRLD __m512i _mm512_maskz_srl_epi32( __mmask16 k, __m512i a, __m128i cnt);
VPSRLD __m256i _mm256_mask_srl_epi32(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRLD __m256i _mm256_maskz_srl_epi32( __mmask8 k, __m256i a, __m128i cnt);
VPSRLD __m128i _mm_mask_srl_epi32(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRLD __m128i _mm_maskz_srl_epi32( __mmask8 k, __m128i a, __m128i cnt);
VPSRLQ __m512i _mm512_srli_epi64(__m512i a, unsigned int imm);
VPSRLQ __m512i _mm512_mask_srli_epi64(__m512i s, __mmask8 k, __m512i a, unsigned int imm);
VPSRLQ __m512i _mm512_mask_srli_epi64( __mmask8 k, __m512i a, unsigned int imm);
VPSRLQ __m256i _mm256_mask_srli_epi64(__m256i s, __mmask8 k, __m256i a, unsigned int imm);
VPSRLQ __m256i _mm256_maskz_srli_epi64( __mmask8 k, __m256i a, unsigned int imm);
VPSRLQ __m128i _mm_mask_srli_epi64(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRLQ __m128i _mm_maskz_srli_epi64( __mmask8 k, __m128i a, unsigned int imm);
VPSRLQ __m512i _mm512_srl_epi64(__m512i a, __m128i cnt);
VPSRLQ __m512i _mm512_mask_srl_epi64(__m512i s, __mmask8 k, __m512i a, __m128i cnt);
VPSRLQ __m512i _mm512_mask_srl_epi64( __mmask8 k, __m512i a, __m128i cnt);
VPSRLQ __m256i _mm256_mask_srl_epi64(__m256i s, __mmask8 k, __m256i a, __m128i cnt);
VPSRLQ __m256i _mm256_maskz_srl_epi64( __mmask8 k, __m256i a, __m128i cnt);
VPSRLQ __m128i _mm_mask_srl_epi64(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRLQ __m128i _mm_maskz_srl_epi64( __mmask8 k, __m128i a, __m128i cnt);
VPSRLW __m512i _mm512_srli_epi16(__m512i a, unsigned int imm);
VPSRLW __m512i _mm512_mask_srli_epi16(__m512i s, __mmask32 k, __m512i a, unsigned int imm);
VPSRLW __m512i _mm512_maskz_srli_epi16( __mmask32 k, __m512i a, unsigned int imm);
VPSRLW __m256i _mm256_mask_srli_epi16(__m256i s, __mmask16 k, __m256i a, unsigned int imm);
VPSRLW __m256i _mm256_maskz_srli_epi16( __mmask16 k, __m256i a, unsigned int imm);
VPSRLW __m128i _mm_mask_srli_epi16(__m128i s, __mmask8 k, __m128i a, unsigned int imm);
VPSRLW __m128i _mm_maskz_srli_epi16( __mmask8 k, __m128i a, unsigned int imm);
VPSRLW __m512i _mm512_srl_epi16(__m512i a, __m128i cnt);
VPSRLW __m512i _mm512_mask_srl_epi16(__m512i s, __mmask32 k, __m512i a, __m128i cnt);
VPSRLW __m512i _mm512_maskz_srl_epi16( __mmask32 k, __m512i a, __m128i cnt);
VPSRLW __m256i _mm256_mask_srl_epi16(__m256i s, __mmask16 k, __m256i a, __m128i cnt);
VPSRLW __m256i _mm256_maskz_srl_epi16( __mmask8 k, __mmask16 a, __m128i cnt);
VPSRLW __m128i _mm_mask_srl_epi16(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSRLW __m128i _mm_maskz_srl_epi16( __mmask8 k, __m128i a, __m128i cnt);
PSRLW __m64 _mm_srli_pi16(__m64 m, int count) PSRLW __m64 _mm_srl_pi16 (__m64 m, __m64 count) (V)PSRLW __m128i _mm_srli_epi16 (__m128i m, int count) (V)PSRLW __m128i _mm_srl_epi16 (__m128i m, __m128i count) VPSRLW __m256i _mm256_srli_epi16 (__m256i m, int count) VPSRLW __m256i _mm256_srl_epi16 (__m256i m, __m128i count) PSRLD __m64 _mm_srli_pi32 (__m64 m, int count) PSRLD __m64 _mm_srl_pi32 (__m64 m, __m64 count) (V)PSRLD __m128i _mm_srli_epi32 (__m128i m, int count) (V)PSRLD __m128i _mm_srl_epi32 (__m128i m, __m128i count) VPSRLD __m256i _mm256_srli_epi32 (__m256i m, int count) VPSRLD __m256i _mm256_srl_epi32 (__m256i m, __m128i count) PSRLQ __m64 _mm_srli_si64 (__m64 m, int count) PSRLQ __m64 _mm_srl_si64 (__m64 m, __m64 count) (V)PSRLQ __m128i _mm_srli_epi64 (__m128i m, int count) (V)PSRLQ __m128i _mm_srl_epi64 (__m128i m, __m128i count) VPSRLQ __m256i _mm256_srli_epi64 (__m256i m, int count) VPSRLQ __m256i _mm256_srl_epi64 (__m256i m, __m128i count);

Banderas afectadas

None.

Excepciones numéricas

None.

Otras excepciones

Instrucciones codificadas por VEX:

-- Sintaxis con codificación RM/RVM operando (A/C en mesa de codificación el operando), véase Tabla 2-21, "Tipo 4 Condiciones de Excepción".

-- Sintaxis con la codificación MI/VMI operando (B/D en la tabla de codificación el operando), ver Tabla 2-24, "Tipo 7 Condiciones de Excepción".

EVEX-encoded VPSRLW (E en la tabla de codificación el operando), ver Excepciones Tipo E4NF.nb en la tabla 2-52, "Tipo

Condiciones de Excepción de Clase E4NF."

EVEX-encoded VPSRLD/Q:

-- Sintaxis con el tipo de tuple Mem128 (G en la tabla de codificación el operando), ver Excepciones Tipo E4NF.nb en la tabla 2-52, "Tipo E4NF Condiciones de Excepción".

-- Sintaxis con tipo de tuple completo (F en la tabla de codificación el operando), ver Tabla 2-51, "Tipo E4 Condiciones de Excepción Clase".

PSRLW, PSRLD, PSRLQ

Codificaciones

Codificacion de operandos

A

B

C

D

E

F

G

Coste medido

Descripción#

Operación#

Intel C/C++ compilador intrínseco#

Banderas afectadas#

Excepciones numéricas#