Vesta
Español
Código fuente

VPSRAVW, VPSRAVD, VPSRAVQ

Cambio de bits variable derecha Aritmetic

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
VEX.128.66.0F38.W0 46 /rVPSRAVD xmm1, xmm2, xmm3/m128AValidoValidoEspadas dobles en xmm2 derecha por cantidad especificada en el elemento correspondiente de xmm3/m128 mientras se desplaza en bits de signos.
VEX.256.66.0F38.W0 46 /rVPSRAVD ymm1, ymm2, ymm3/m256AValidoValidoEspadas dobles en ymm2 derecha por cantidad especificada en el elemento correspondiente de ymm3/m256 mientras se desplaza en bits de signos.
EVEX.128.66.0F38.W1 11 /rVPSRAVW xmm1 {k1}{z}, xmm2, xmm3/m128BValidoValidoPalabras clave en xmm2 derecho por cantidad especificada AVX512BW) OR en el elemento correspondiente de xmm3/m128 AVX10.1 mientras se desplaza en bits de signos utilizando máscara de escritura k1.
EVEX.256.66.0F38.W1 11 /rVPSRAVW ymm1 {k1}{z}, ymm2, ymm3/m256BValidoValidoPalabras clave en ymm2 derecho por cantidad especificada AVX512BW) OR en el elemento correspondiente de ymm3/m256 AVX10.1 mientras se desplaza en bits de signos utilizando máscara de escritura k1.
EVEX.512.66.0F38.W1 11 /rVPSRAVW zmm1 {k1}{z}, zmm2, zmm3/m512BValidoValidoPalabras de cambio en zmm2 derecho por cantidad especificada en OR AVX10.1 el elemento correspondiente de zmm3/m512 mientras se desplaza en bits de signos utilizando máscara de escritura k1.
EVEX.128.66.0F38.W0 46 /rVPSRAVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstCValidoValidoEspadas dobles en xmm2 derecho por cantidad AVX512F) O especificadas en el elemento correspondiente de AVX10.1 xmm3/m128/m32bcst al cambiar en bits de signos utilizando máscara de escritura k1.
EVEX.256.66.0F38.W0 46 /rVPSRAVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstCValidoValidoEspadas dobles en ymm2 derecho por cantidad AVX512F) O especificadas en el elemento correspondiente de AVX10.1 ymm3/m256/m32bcst al cambiar en bits de signos utilizando máscara de escritura k1.
EVEX.512.66.0F38.W0 46 /rVPSRAVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstCValidoValidoEspadas dobles en zmm2 derecho por cantidad OR AVX10.1 especificadas en el elemento correspondiente de zmm3/m512/m32bcst al cambiar en bits de signos utilizando máscara de escritura k1.
EVEX.128.66.0F38.W1 46 /rVPSRAVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstCValidoValidoEscudo de cuádwords en xmm2 derecho por cantidad AVX512F) O especificado en el elemento correspondiente de AVX10.1 xmm3/m128/m64bcst mientras se desplaza en bits de señal utilizando máscara de escritura k1.
EVEX.256.66.0F38.W1 46 /rVPSRAVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstCValidoValidoEscudo de cuádwords en ymm2 derecho por cantidad AVX512F) O especificado en el elemento correspondiente de AVX10.1 ymm3/m256/m64bcst mientras se desplaza en bits de señal utilizando máscara de escritura k1.
EVEX.512.66.0F38.W1 46 /rVPSRAVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstCValidoValidoEscudo de cuádwords en zmm2 derecho por cantidad OR AVX10.1 especificado en el elemento correspondiente de zmm3/m512/m64bcst al cambiar en bits de signos utilizando 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. vex.vvvv lecturaprefijo VEX, campo vvvv (invertido)
  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

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

Tupla: Full Mem

C

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

Tupla: Full

Coste medido

Cargando las mediciones de arch-data...

Descripción

Cambia los bits en los elementos de datos individuales (palabra/doblewords/quadword) en el primer operando de origen (el segundo operando) a la derecha por el número de bits especificados en el valor de cuenta de los elementos de datos respectivos en el segundo operando de origen (el tercer operando). A medida que los bits en los elementos de datos se desplazan a la derecha, los bits vacíos de alto orden se fijan en el MSB (extensión de firma).

Los valores de cuenta se especifican individualmente en cada elemento de datos del segundo operando de origen. Si el valor entero no firmado especificado en el elemento de datos correspondiente del segundo operando de origen es superior a 15 (para palabras), 31 (para palabras dobles), o 63 (para un cuadpacio), entonces el elemento de datos de destino se llena con el signo correspondiente del elemento fuente.

VEX.128 versión codificada: El destino y el primer operandos de origen son los registros XMM. El conteo operando puede ser un registro XMM o una ubicación de memoria de 128 bits. Bits (MAXVL-1:128) del registro de destino correspondiente se ponen a cero.

VEX.256 versión codificada: El destino y el primer operandos de origen son los registros YMM. El conteo operando puede ser un registro YMM o una memoria de 256 bits. Bits (MAXVL-1:256) del registro de destino correspondiente se ponen a cero.

EVEX.512/256/128 codificado VPSRAVD/W: El destino y el primer operandos de origen son los registros ZMM/YMM/XMM. El conteo operando puede ser un ZMM/YMM/XMM registro, una ubicación de memoria 512/256/128-bit ubicación de memoria o un vector 512/256/128-bit transmitido desde una ubicación de memoria de 32/64-bit. El destino está actualizado condicionalmente con máscara de escritura k1.

EVEX.512/256/128 codificado VPSRAVQ: El destino y el primer operandos de origen son los registros ZMM/YMM/XMM. El conteo operando puede ser un ZMM/YMM/XMM registro, un 512/256/128-bit ubicación de memoria. El destino está actualizado condicionalmente con máscara de escritura k1.

Operación

VPSRAVW (EVEX encoded version)
(KL, VL) = (8, 128), (16, 256), (32, 512)

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

     THEN

             COUNT := SRC2[i+3:i]

             IF COUNT < 16

                 THEN DEST[i+15:i] := SignExtend(SRC1[i+15:i] >> COUNT)

                 ELSE

                    FOR k := 0 TO 15

                        DEST[i+k] := SRC1[i+15]

                    ENDFOR;

             FI

     ELSE

             IF *merging-masking*      ; merging-masking

                 THEN *DEST[i+15:i] remains unchanged*

                 ELSE                  ; zeroing-masking

                    DEST[i+15:i] := 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0;

VPSRAVD (VEX.128 version)
COUNT_0 := SRC2[31 : 0]

    (* Repeat Each COUNT_i for the 2nd through 4th dwords of SRC2*)
COUNT_3 := SRC2[127 : 96];
DEST[31:0] := SignExtend(SRC1[31:0] >> COUNT_0);


    (* Repeat shift operation for 2nd through 4th dwords *)
DEST[127:96] := SignExtend(SRC1[127:96] >> COUNT_3);
DEST[MAXVL-1:128] := 0;

VPSRAVD (VEX.256 version)
COUNT_0 := SRC2[31 : 0];

    (* Repeat Each COUNT_i for the 2nd through 8th dwords of SRC2*)
COUNT_7 := SRC2[255 : 224];
DEST[31:0] := SignExtend(SRC1[31:0] >> COUNT_0);

    (* Repeat shift operation for 2nd through 7th dwords *)
DEST[255:224] := SignExtend(SRC1[255:224] >> COUNT_7);
DEST[MAXVL-1:256] := 0;

VPSRAVD (EVEX encoded version)

(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 (SRC2 *is memory*)

                  THEN

                    COUNT := SRC2[4:0]

                    IF COUNT < 32

                        THEN DEST[i+31:i] := SignExtend(SRC1[i+31:i] >> COUNT)

                        ELSE

                           FOR k := 0 TO 31

                                   DEST[i+k] := SRC1[i+31]

                           ENDFOR;

                    FI

                  ELSE

                    COUNT := SRC2[i+4:i]

                    IF COUNT < 32

                        THEN DEST[i+31:i] := SignExtend(SRC1[i+31:i] >> COUNT)

                        ELSE

                           FOR k := 0 TO 31

                                   DEST[i+k] := SRC1[i+31]

                           ENDFOR;

                    FI

             FI;

ELSE

     IF *merging-masking*                 ; merging-masking

             THEN *DEST[31:0] remains unchanged*

             ELSE                         ; zeroing-masking

                  DEST[31:0] := 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0;

VPSRAVQ (EVEX encoded version)
(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 (SRC2 *is memory*)


              THEN

               COUNT := SRC2[5:0]

               IF COUNT < 64

                        THEN DEST[i+63:i] := SignExtend(SRC1[i+63:i] >> COUNT)

                        ELSE

                           FOR k := 0 TO 63

                               DEST[i+k] := SRC1[i+63]

                           ENDFOR;

               FI

              ELSE

               COUNT := SRC2[i+5:i]

               IF COUNT < 64

                        THEN DEST[i+63:i] := SignExtend(SRC1[i+63:i] >> COUNT)

                        ELSE

                           FOR k := 0 TO 63

                               DEST[i+k] := SRC1[i+63]

                           ENDFOR;

               FI

         FI;

ELSE

     IF *merging-masking*            ; merging-masking

         THEN *DEST[63:0] remains unchanged*

         ELSE                        ; zeroing-masking

              DEST[63:0] := 0

         FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0;

Intel C/C++ compilador intrínseco

VPSRAVD __m512i _mm512_srav_epi32(__m512i a, __m512i cnt);
VPSRAVD __m512i _mm512_mask_srav_epi32(__m512i s, __mmask16 m, __m512i a, __m512i cnt);
VPSRAVD __m512i _mm512_maskz_srav_epi32(__mmask16 m, __m512i a, __m512i cnt);
VPSRAVD __m256i _mm256_srav_epi32(__m256i a, __m256i cnt);
VPSRAVD __m256i _mm256_mask_srav_epi32(__m256i s, __mmask8 m, __m256i a, __m256i cnt);
VPSRAVD __m256i _mm256_maskz_srav_epi32(__mmask8 m, __m256i a, __m256i cnt);
VPSRAVD __m128i _mm_srav_epi32(__m128i a, __m128i cnt);
VPSRAVD __m128i _mm_mask_srav_epi32(__m128i s, __mmask8 m, __m128i a, __m128i cnt);
VPSRAVD __m128i _mm_maskz_srav_epi32(__mmask8 m, __m128i a, __m128i cnt);
VPSRAVQ __m512i _mm512_srav_epi64(__m512i a, __m512i cnt);
VPSRAVQ __m512i _mm512_mask_srav_epi64(__m512i s, __mmask8 m, __m512i a, __m512i cnt);
VPSRAVQ __m512i _mm512_maskz_srav_epi64( __mmask8 m, __m512i a, __m512i cnt);
VPSRAVQ __m256i _mm256_srav_epi64(__m256i a, __m256i cnt);
VPSRAVQ __m256i _mm256_mask_srav_epi64(__m256i s, __mmask8 m, __m256i a, __m256i cnt);
VPSRAVQ __m256i _mm256_maskz_srav_epi64( __mmask8 m, __m256i a, __m256i cnt);
VPSRAVQ __m128i _mm_srav_epi64(__m128i a, __m128i cnt);
VPSRAVQ __m128i _mm_mask_srav_epi64(__m128i s, __mmask8 m, __m128i a, __m128i cnt);
VPSRAVQ __m128i _mm_maskz_srav_epi64( __mmask8 m, __m128i a, __m128i cnt);
VPSRAVW __m512i _mm512_srav_epi16(__m512i a, __m512i cnt);
VPSRAVW __m512i _mm512_mask_srav_epi16(__m512i s, __mmask32 m, __m512i a, __m512i cnt);
VPSRAVW __m512i _mm512_maskz_srav_epi16(__mmask32 m, __m512i a, __m512i cnt);
VPSRAVW __m256i _mm256_srav_epi16(__m256i a, __m256i cnt);
VPSRAVW __m256i _mm256_mask_srav_epi16(__m256i s, __mmask16 m, __m256i a, __m256i cnt);
VPSRAVW __m256i _mm256_maskz_srav_epi16(__mmask16 m, __m256i a, __m256i cnt);
VPSRAVW __m128i _mm_srav_epi16(__m128i a, __m128i cnt);
VPSRAVW __m128i _mm_mask_srav_epi16(__m128i s, __mmask8 m, __m128i a, __m128i cnt);
VPSRAVW __m128i _mm_maskz_srav_epi32(__mmask8 m, __m128i a, __m128i cnt);
VPSRAVD __m256i _mm256_srav_epi32 (__m256i m, __m256i count);

SIMD coma flotante Excepciones

None.

Otras excepciones

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

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

Fuentes