Vesta
Español
Código fuente

VPROLD, VPROLVD, VPROLQ, VPROLVQ

Un poco de rotación izquierda

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
EVEX.128.66.0F38.W0 15 /rVPROLVD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstBValidoValidoPalabras dobles rotativas en xmm2 izquierda por cuenta en el AVX512F) O elemento correspondiente de xmm3/m128/m32bcst. AVX10.1 Resultado escrito a xmm1 bajo máscara de escritura k1.
EVEX.128.66.0F.W0 72 /1 ibVPROLD xmm1 {k1}{z}, xmm2/m128/m32bcst, imm8AValidoValidoPalabras dobles rotativas en xmm2/m128/m32bcst AVX512F) O izquierda por imm8. Resultado escrito a xmm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.128.66.0F38.W1 15 /rVPROLVQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstBValidoValidoQuadwords rotativas en xmm2 izquierda por cuenta en el AVX512F) O elemento correspondiente de xmm3/m128/m64bcst. AVX10.1 Resultado escrito a xmm1 bajo máscara de escritura k1.
EVEX.128.66.0F.W1 72 /1 ibVPROLQ xmm1 {k1}{z}, xmm2/m128/m64bcst, imm8AValidoValidoQuadwords rotativas en xmm2/m128/m64bcst izquierda AVX512F) OR por imm8. Resultado escrito a xmm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.256.66.0F38.W0 15 /rVPROLVD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstBValidoValidoPalabras dobles rotativas en ymm2 izquierda por cuenta en el AVX512F) O elemento correspondiente de ymm3/m256/m32bcst. AVX10.1 Resultado escrito a ymm1 bajo máscara de escritura k1.
EVEX.256.66.0F.W0 72 /1 ibVPROLD ymm1 {k1}{z}, ymm2/m256/m32bcst, imm8AValidoValidoPalabras dobles rotativas en ymm2/m256/m32bcst AVX512F) O izquierda por imm8. Resultado escrito a ymm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.256.66.0F38.W1 15 /rVPROLVQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstBValidoValidoQuadwords rotativas en ymm2 izquierda por cuenta en el AVX512F) O elemento correspondiente de ymm3/m256/m64bcst. AVX10.1 Resultado escrito a ymm1 bajo máscara de escritura k1.
EVEX.256.66.0F.W1 72 /1 ibVPROLQ ymm1 {k1}{z}, ymm2/m256/m64bcst, imm8AValidoValidoQuadwords rotativas en ymm2/m256/m64bcst izquierda AVX512F) OR por imm8. Resultado escrito a ymm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.512.66.0F38.W0 15 /rVPROLVD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstBValidoValidoGirar a la izquierda de las palabras dobles en zmm2 por cuenta en el elemento correspondiente de zmm3/m512/m32bcst. Resultado escrito a zmm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.W0 72 /1 ibVPROLD zmm1 {k1}{z}, zmm2/m512/m32bcst, imm8AValidoValidoGirar a la izquierda de las palabras dobles en OR AVX10.1 zmm3/m512/m32bcst por imm8. Resultado escrito a zmm1 utilizando máscara de escritura k1.
EVEX.512.66.0F38.W1 15 /rVPROLVQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstBValidoValidoQuadwords rotativas en zmm2 izquierda por cuenta en el elemento correspondiente OR AVX10.1 de zmm3/m512/m64bcst. Resultado escrito a zmm1under máscara de escritura k1.
EVEX.512.66.0F.W1 72 /1 ibVPROLQ zmm1 {k1}{z}, zmm2/m512/m64bcst, imm8AValidoValidoQuadwords rotativas en zmm2/m512/m64bcst izquierdo OR AVX10.1 por imm8. Resultado escrito a zmm1 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. vex.vvvv escrituraprefijo VEX, campo vvvv (invertido)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
  3. imm8byte inmediato que sigue a la instruccion

Tupla: Full

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

Coste medido

Cargando las mediciones de arch-data...

Descripción

Rota los bits en los elementos de datos individuales (doblewords, o quadword) en el primer operando de origen a la izquierda por el número de bits especificados en el conteo operando. Si el valor especificado por el conteo operando es mayor que 31 (para las palabras dobles), o 63 (para un cuadword), entonces se utiliza el conteo operando modulo del tamaño de los datos (32 o 64).

EVEX.128 versión codificada: El operando de destino es un registro XMM. El operando de origen es un registro XMM o una ubicación de memoria (para forma inmediata). 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:128) del registro ZMM correspondiente se ponen a cero.

EVEX.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 (para forma inmediata). 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.512 versión codificada: El operando de destino es un registro ZMM actualizado según la máscara de escritura. Para el conteo operando en forma inmediata, el operando de origen puede ser un registro ZMM, una ubicación de memoria de 512 bits o un vector de 512 bits transmitido desde una ubicación de memoria de 32/64 bits, el conteo operando es un vector de 8 bits inmediato. Para el recuento operando en forma variable, el primer operando de origen (el segundo operando) es un registro ZMM y el contador operando (el tercero operando) es un registro ZMM, una ubicación de memoria de 512 bits o un vector de 512 bits emitido desde una ubicación de memoria

Operación

LEFT_ROTATE_DWORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC modulo 32;
DEST[31:0] := (SRC << COUNT) | (SRC >> (32 - COUNT));

LEFT_ROTATE_QWORDS(SRC, COUNT_SRC)
COUNT := COUNT_SRC modulo 64;
DEST[63:0] := (SRC << COUNT) | (SRC >> (64 - COUNT));

VPROLD (EVEX encoded versions)

(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] := LEFT_ROTATE_DWORDS(SRC1[31:0], imm8)

                  ELSE DEST[i+31:i] := LEFT_ROTATE_DWORDS(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


VPROLVD (EVEX encoded versions)

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

                  ELSE DEST[i+31:i] := LEFT_ROTATE_DWORDS(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*             ; zeroing-masking

                    DEST[i+31:i] := 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPROLQ (EVEX encoded versions)

(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] := LEFT_ROTATE_QWORDS(SRC1[63:0], imm8)

                  ELSE DEST[i+63:i] := LEFT_ROTATE_QWORDS(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

VPROLVQ (EVEX encoded versions)

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

                  ELSE DEST[i+63:i] := LEFT_ROTATE_QWORDS(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*             ; zeroing-masking

                    DEST[i+63:i] := 0

             FI

FI;


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

Intel C/C++ compilador intrínseco

VPROLD __m512i _mm512_rol_epi32(__m512i a, int imm);
VPROLD __m512i _mm512_mask_rol_epi32(__m512i a, __mmask16 k, __m512i b, int imm);
VPROLD __m512i _mm512_maskz_rol_epi32( __mmask16 k, __m512i a, int imm);
VPROLD __m256i _mm256_rol_epi32(__m256i a, int imm);
VPROLD __m256i _mm256_mask_rol_epi32(__m256i a, __mmask8 k, __m256i b, int imm);
VPROLD __m256i _mm256_maskz_rol_epi32( __mmask8 k, __m256i a, int imm);
VPROLD __m128i _mm_rol_epi32(__m128i a, int imm);
VPROLD __m128i _mm_mask_rol_epi32(__m128i a, __mmask8 k, __m128i b, int imm);
VPROLD __m128i _mm_maskz_rol_epi32( __mmask8 k, __m128i a, int imm);
VPROLQ __m512i _mm512_rol_epi64(__m512i a, int imm);
VPROLQ __m512i _mm512_mask_rol_epi64(__m512i a, __mmask8 k, __m512i b, int imm);
VPROLQ __m512i _mm512_maskz_rol_epi64(__mmask8 k, __m512i a, int imm);
VPROLQ __m256i _mm256_rol_epi64(__m256i a, int imm);
VPROLQ __m256i _mm256_mask_rol_epi64(__m256i a, __mmask8 k, __m256i b, int imm);
VPROLQ __m256i _mm256_maskz_rol_epi64( __mmask8 k, __m256i a, int imm);
VPROLQ __m128i _mm_rol_epi64(__m128i a, int imm);
VPROLQ __m128i _mm_mask_rol_epi64(__m128i a, __mmask8 k, __m128i b, int imm);
VPROLQ __m128i _mm_maskz_rol_epi64( __mmask8 k, __m128i a, int imm);
VPROLVD __m512i _mm512_rolv_epi32(__m512i a, __m512i cnt);
VPROLVD __m512i _mm512_mask_rolv_epi32(__m512i a, __mmask16 k, __m512i b, __m512i cnt);
VPROLVD __m512i _mm512_maskz_rolv_epi32(__mmask16 k, __m512i a, __m512i cnt);
VPROLVD __m256i _mm256_rolv_epi32(__m256i a, __m256i cnt);
VPROLVD __m256i _mm256_mask_rolv_epi32(__m256i a, __mmask8 k, __m256i b, __m256i cnt);
VPROLVD __m256i _mm256_maskz_rolv_epi32(__mmask8 k, __m256i a, __m256i cnt);
VPROLVD __m128i _mm_rolv_epi32(__m128i a, __m128i cnt);
VPROLVD __m128i _mm_mask_rolv_epi32(__m128i a, __mmask8 k, __m128i b, __m128i cnt);
VPROLVD __m128i _mm_maskz_rolv_epi32(__mmask8 k, __m128i a, __m128i cnt);
VPROLVQ __m512i _mm512_rolv_epi64(__m512i a, __m512i cnt);
VPROLVQ __m512i _mm512_mask_rolv_epi64(__m512i a, __mmask8 k, __m512i b, __m512i cnt);
VPROLVQ __m512i _mm512_maskz_rolv_epi64( __mmask8 k, __m512i a, __m512i cnt);
VPROLVQ __m256i _mm256_rolv_epi64(__m256i a, __m256i cnt);
VPROLVQ __m256i _mm256_mask_rolv_epi64(__m256i a, __mmask8 k, __m256i b, __m256i cnt);
VPROLVQ __m256i _mm256_maskz_rolv_epi64(__mmask8 k, __m256i a, __m256i cnt);
VPROLVQ __m128i _mm_rolv_epi64(__m128i a, __m128i cnt);
VPROLVQ __m128i _mm_mask_rolv_epi64(__m128i a, __mmask8 k, __m128i b, __m128i cnt);
VPROLVQ __m128i _mm_maskz_rolv_epi64(__mmask8 k, __m128i a, __m128i cnt);

SIMD coma flotante Excepciones

None.

Otras excepciones

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

Fuentes