Vesta
Español
Código fuente

VPSLLVW, VPSLLVD, VPSLLVQ

Cambio de bits variable izquierda lógica

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
VEX.128.66.0F38.W0 47 /rVPSLLVD xmm1, xmm2, xmm3/m128AValidoValidoEspadas dobles en xmm2 izquierda por cantidad especificada en el elemento correspondiente de xmm3/m128 mientras se desplaza en 0s.
VEX.128.66.0F38.W1 47 /rVPSLLVQ xmm1, xmm2, xmm3/m128AValidoValidoEscudo de cuádwords en xmm2 dejado por la cantidad especificada en el elemento correspondiente de xmm3/m128 mientras se desplaza en 0s.
VEX.256.66.0F38.W0 47 /rVPSLLVD ymm1, ymm2, ymm3/m256AValidoValidoEspadas dobles en ymm2 izquierda por cantidad especificada en el elemento correspondiente de ymm3/m256 mientras se desplaza en 0s.
VEX.256.66.0F38.W1 47 /rVPSLLVQ ymm1, ymm2, ymm3/m256AValidoValidoEscudo de cuádwords en ymm2 dejado por la cantidad especificada en el elemento correspondiente de ymm3/m256 mientras se desplaza en 0s.
EVEX.128.66.0F38.W1 12 /rVPSLLVW xmm1 {k1}{z}, xmm2, xmm3/m128BValidoValidoPalabras clave en xmm2 izquierda por cantidad especificada en AVX512BW) O el elemento correspondiente de xmm3/m128 mientras que AVX10.1 desplazando en 0s utilizando máscara de escritura k1.
EVEX.256.66.0F38.W1 12 /rVPSLLVW ymm1 {k1}{z}, ymm2, ymm3/m256BValidoValidoPalabras clave en ymm2 izquierda por cantidad especificada en AVX512BW) O el elemento correspondiente de ymm3/m256 mientras que AVX10.1 desplazando en 0s utilizando máscara de escritura k1.
EVEX.512.66.0F38.W1 12 /rVPSLLVW zmm1 {k1}{z}, zmm2, zmm3/m512BValidoValidoPalabras de cambio en zmm2 izquierda por cantidad especificada en OR AVX10.1 el elemento correspondiente de zmm3/m512 mientras se desplaza en 0s utilizando máscara de escritura k1.
EVEX.128.66.0F38.W0 47 /rVPSLLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstCValidoValidoEspadas dobles en xmm2 izquierda por la cantidad AVX512F) OR especificadas en el elemento correspondiente de AVX10.1 xmm3/m128/m32bcst al cambiar en 0s utilizando máscara de escritura k1.
EVEX.256.66.0F38.W0 47 /rVPSLLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstCValidoValidoEspadas dobles en ymm2 izquierda por la cantidad AVX512F) OR especificadas en el elemento correspondiente de AVX10.1 ymm3/m256/m32bcst al cambiar en 0s utilizando máscara de escritura k1.
EVEX.512.66.0F38.W0 47 /rVPSLLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstCValidoValidoEspadas dobles en zmm2 izquierda por cantidad OR AVX10.1 especificadas en el elemento correspondiente de zmm3/m512/m32bcst al cambiar en 0s utilizando máscara de escritura k1.
EVEX.128.66.0F38.W1 47 /rVPSLLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstCValidoValidoEscudo de cuádwords en xmm2 dejado por la cantidad especificada AVX512F) OR en el elemento correspondiente de AVX10.1 xmm3/m128/m64bcst al cambiar en 0s utilizando máscara de escritura k1.
EVEX.256.66.0F38.W1 47 /rVPSLLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstCValidoValidoEscudo de cuádwords en ymm2 dejado por la cantidad especificada AVX512F) OR en el elemento correspondiente de AVX10.1 ymm3/m256/m64bcst al cambiar en 0s utilizando máscara de escritura k1.
EVEX.512.66.0F38.W1 47 /rVPSLLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstCValidoValidoEscudo de cuádwords en zmm2 dejado por la cantidad especificada OR AVX10.1 en el elemento correspondiente de zmm3/m512/m64bcst al cambiar en 0s 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 (palabras, palabras dobles o cuadwords) en el primer operando de origen a la izquierda por el valor contable de los elementos de datos respectivos en el segundo operando de origen. A medida que los bits de los elementos de datos se desplazan a la izquierda, los bits vacíos de baja orden se limpian (configurados a 0).

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 respectivo del segundo operando de origen es mayor de 15 (por palabra), 31 (para palabras dobles), o 63 (para un quadword), entonces el elemento de datos de destino se escribe con 0.

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 ZMM correspondiente se ponen a cero.

EVEX codificado VPSLLVD/Q: El destino y el primer operandos de origen son los registros ZMM/YMM/XMM. El recuento operando puede ser un ZMM/YMM/XMM registrado, una ubicación de memoria de 512/256/128 bits o un vector de 512 bits emitido desde una ubicación de memoria de 32/64 bits. El destino está actualizado condicionalmente con máscara de escritura k1.

EVEX codificado VPSLLVW: 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

VPSLLVW (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 DEST[i+15:i] := ZeroExtend(SRC1[i+15:i] << SRC2[i+15:i])

     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;


VPSLLVD (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];
IF COUNT_0 < 32 THEN
DEST[31:0] := ZeroExtend(SRC1[31:0] << COUNT_0);
ELSE
DEST[31:0] := 0;

    (* Repeat shift operation for 2nd through 4th dwords *)
IF COUNT_3 < 32 THEN
DEST[127:96] := ZeroExtend(SRC1[127:96] << COUNT_3);
ELSE
DEST[127:96] := 0;
DEST[MAXVL-1:128] := 0;

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

    (* Repeat Each COUNT_i for the 2nd through 7th dwords of SRC2*)
COUNT_7 := SRC2[255 : 224];
IF COUNT_0 < 32 THEN
DEST[31:0] := ZeroExtend(SRC1[31:0] << COUNT_0);
ELSE
DEST[31:0] := 0;

    (* Repeat shift operation for 2nd through 7th dwords *)
IF COUNT_7 < 32 THEN
DEST[255:224] := ZeroExtend(SRC1[255:224] << COUNT_7);
ELSE
DEST[255:224] := 0;
DEST[MAXVL-1:256] := 0;

VPSLLVD (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 DEST[i+31:i] := ZeroExtend(SRC1[i+31:i] << SRC2[31:0])

                  ELSE DEST[i+31:i] := ZeroExtend(SRC1[i+31:i] << SRC2[i+31:i])

             FI;

     ELSE

             IF *merging-masking*         ; merging-masking

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

                  ELSE                    ; zeroing-masking

                    DEST[i+31:i] := 0

             FI

FI;

ENDFOR;

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


VPSLLVQ (VEX.128 version)
COUNT_0 := SRC2[63 : 0];
COUNT_1 := SRC2[127 : 64];
IF COUNT_0 < 64THEN
DEST[63:0] := ZeroExtend(SRC1[63:0] << COUNT_0);
ELSE
DEST[63:0] := 0;
IF COUNT_1 < 64 THEN
DEST[127:64] := ZeroExtend(SRC1[127:64] << COUNT_1);
ELSE
DEST[127:96] := 0;
DEST[MAXVL-1:128] := 0;

VPSLLVQ (VEX.256 version)
COUNT_0 := SRC2[63 : 0];

    (* Repeat Each COUNT_i for the 2nd through 4th dwords of SRC2*)
COUNT_3 := SRC2[255 : 192];
IF COUNT_0 < 64THEN
DEST[63:0] := ZeroExtend(SRC1[63:0] << COUNT_0);
ELSE
DEST[63:0] := 0;

    (* Repeat shift operation for 2nd through 4th dwords *)
IF COUNT_3 < 64 THEN
DEST[255:192] := ZeroExtend(SRC1[255:192] << COUNT_3);
ELSE
DEST[255:192] := 0;
DEST[MAXVL-1:256] := 0;

VPSLLVQ (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 DEST[i+63:i] := ZeroExtend(SRC1[i+63:i] << SRC2[63:0])

                  ELSE DEST[i+63:i] := ZeroExtend(SRC1[i+63:i] << SRC2[i+63:i])

             FI;

     ELSE

             IF *merging-masking*        ; merging-masking

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

                  ELSE                   ; zeroing-masking

                    DEST[i+63:i] := 0

             FI

FI;

ENDFOR;

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

Intel C/C++ compilador intrínseco

VPSLLVW __m512i _mm512_sllv_epi16(__m512i a, __m512i cnt);
VPSLLVW __m512i _mm512_mask_sllv_epi16(__m512i s, __mmask32 k, __m512i a, __m512i cnt);
VPSLLVW __m512i _mm512_maskz_sllv_epi16( __mmask32 k, __m512i a, __m512i cnt);
VPSLLVW __m256i _mm256_mask_sllv_epi16(__m256i s, __mmask16 k, __m256i a, __m256i cnt);
VPSLLVW __m256i _mm256_maskz_sllv_epi16( __mmask16 k, __m256i a, __m256i cnt);
VPSLLVW __m128i _mm_mask_sllv_epi16(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSLLVW __m128i _mm_maskz_sllv_epi16( __mmask8 k, __m128i a, __m128i cnt);
VPSLLVD __m512i _mm512_sllv_epi32(__m512i a, __m512i cnt);
VPSLLVD __m512i _mm512_mask_sllv_epi32(__m512i s, __mmask16 k, __m512i a, __m512i cnt);
VPSLLVD __m512i _mm512_maskz_sllv_epi32( __mmask16 k, __m512i a, __m512i cnt);
VPSLLVD __m256i _mm256_mask_sllv_epi32(__m256i s, __mmask8 k, __m256i a, __m256i cnt);
VPSLLVD __m256i _mm256_maskz_sllv_epi32( __mmask8 k, __m256i a, __m256i cnt);
VPSLLVD __m128i _mm_mask_sllv_epi32(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSLLVD __m128i _mm_maskz_sllv_epi32( __mmask8 k, __m128i a, __m128i cnt);
VPSLLVQ __m512i _mm512_sllv_epi64(__m512i a, __m512i cnt);
VPSLLVQ __m512i _mm512_mask_sllv_epi64(__m512i s, __mmask8 k, __m512i a, __m512i cnt);
VPSLLVQ __m512i _mm512_maskz_sllv_epi64( __mmask8 k, __m512i a, __m512i cnt);
VPSLLVD __m256i _mm256_mask_sllv_epi64(__m256i s, __mmask8 k, __m256i a, __m256i cnt);
VPSLLVD __m256i _mm256_maskz_sllv_epi64( __mmask8 k, __m256i a, __m256i cnt);
VPSLLVD __m128i _mm_mask_sllv_epi64(__m128i s, __mmask8 k, __m128i a, __m128i cnt);
VPSLLVD __m128i _mm_maskz_sllv_epi64( __mmask8 k, __m128i a, __m128i cnt);
VPSLLVD __m256i _mm256_sllv_epi32 (__m256i m, __m256i count) VPSLLVQ __m256i _mm256_sllv_epi64 (__m256i m, __m256i count);

SIMD coma flotante Excepciones

None.

Otras excepciones

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

EVEX-encoded VPSLLVD/VPSLLVQ, ver Tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

EVEX-encoded VPSLLVW, ver Excepciones Tipo E4.nb en la tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

Fuentes