Vesta
Español
Código fuente

VPMOVQD, VPMOVSQD, VPMOVUSQD

Down Convertir QWord en DWord

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
EVEX.128.F3.0F38.W0 35 /rVPMOVQD xmm1/m128 {k1}{z}, xmm2AValidoValidoConvierte 2 enteros de palabras cuádruples de AVX512F) OR AVX10.1 xmm2 en 2 enteros de doble palabra empaquetados en xmm1/m128 con truncación sujeto a máscara de escritura k1.
EVEX.128.F3.0F38.W0 25 /rVPMOVSQD xmm1/m64 {k1}{z}, xmm2AValidoValidoConvierte 2 integers de cuádruple firmados AVX512F) OR AVX10.1 de xmm2 en 2 enteros de doble palabra firmados en xmm1/m64 usando sujeto de saturación firmado a máscara de escritura k1.
EVEX.128.F3.0F38.W0 15 /rVPMOVUSQD xmm1/m64 {k1}{z}, xmm2AValidoValidoConvierte 2 integers de cuádruple sin firmar AVX512F) OR de xmm2 en 2 enteros de doble palabra AVX10.1 sin firmar en xmm1/m64 usando saturación no firmada sujeta a máscara de escritura k1.
EVEX.256.F3.0F38.W0 35 /rVPMOVQD xmm1/m128 {k1}{z}, ymm2AValidoValidoConvierte 4 enteros de palabras cuádruples de AVX512F) OR AVX10.1 ymm2 en 4 enteros de doble palabra empaquetados en xmm1/m128 con truncación sujeto a máscara de escritura k1.
EVEX.256.F3.0F38.W0 25 /rVPMOVSQD xmm1/m128 {k1}{z}, ymm2AValidoValidoConvierte 4 integers de cuádruple firmados AVX512F) OR AVX10.1 de ymm2 en 4 enteros de doble palabra firmados en xmm1/m128 usando sujeto de saturación firmado a máscara de escritura k1.
EVEX.256.F3.0F38.W0 15 /rVPMOVUSQD xmm1/m128 {k1}{z}, ymm2AValidoValidoConvierte 4 integers de cuádruple sin firmar AVX512F) OR de ymm2 en 4 enteros de doble palabra AVX10.1 sin firmar en xmm1/m128 usando saturación no firmada sujeta a máscara de escritura k1.
EVEX.512.F3.0F38.W0 35 /rVPMOVQD ymm1/m256 {k1}{z}, zmm2AValidoValidoConvierte 8 enteros de palabras cuádruples de OR AVX10.1 zmm2 en 8 enteros de doble palabra embalados en ymm1/m256 con truncation sujeto a máscara de escritura k1.
EVEX.512.F3.0F38.W0 25 /rVPMOVSQD ymm1/m256 {k1}{z}, zmm2AValidoValidoConvierte 8 enteros de palabras cuádruples firmados o AVX10.1 de zmm2 en 8 enteros de doble palabra firmados en ymm1/m256 usando el sujeto de saturación firmado a máscara de escritura k1.
EVEX.512.F3.0F38.W0 15 /rVPMOVUSQD ymm1/m256 {k1}{z}, zmm2AValidoValidoConvierte 8 enteros de palabras cuádruples sin firmar O AVX10.1 de zmm2 en 8 enteros de doble palabra sin asignar en ymm1/m256 usando saturación no firmada sujeta a 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.rm escriturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide
  2. modrm.reg lecturabyte ModRM, campo reg (bits 5-3)

Tupla: Half Mem

Coste medido

Cargando las mediciones de arch-data...

Descripción

VPMOVQW abajo convierte elementos enteros de 64 bits en el operando de origen (el segundo operando) en palabras dobles empaquetadas usando truncation. VPMOVSQW convierte integers firmados de 64 bits en doblepalabras firmadas con saturación firmada. VPMOVUSQW convierte los valores de cuádruple no firmados en valores de doble palabra no firmados usando saturación no firmada.

El operando de origen es un registro ZMM/YMM/XMM. El operando de destino es un registro YMM/XMM/XMM o 256/128/64-bit ubicación de memoria.

Los elementos de doble palabra convertidos en fondos son escritos al operando de destino (el primer operando) de la palabra doble menos significativa. Los elementos de doble palabra del operando de destino se actualizan según la máscara de escritura. Bits (MAXVL-1:256/128/64) del destino de registro se ponen a cero.

EVEX.vvvv está reservado y debe ser 1111b instrucciones de lo contrario #UD.

Operación

VPMOVQD instruction (EVEX encoded version) reg-reg form

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

FOR j := 0 TO KL-1

i := j * 32

m := j * 64

IF k1[j] OR *no writemask*

           THEN DEST[i+31:i] := TruncateQuadWordToDWord (SRC[m+63:m])

           ELSE *zeroing-masking*           ; zeroing-masking

                    DEST[i+31:i] := 0

             FI

FI;

ENDFOR

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

VPMOVQD instruction (EVEX encoded version) memory form

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

FOR j := 0 TO KL-1

i := j * 32

m := j * 64

IF k1[j] OR *no writemask*

           THEN DEST[i+31:i] := TruncateQuadWordToDWord (SRC[m+63:m])

           ELSE *DEST[i+31:i] remains unchanged*  ; merging-masking

FI;

ENDFOR

VPMOVSQD instruction (EVEX encoded version) reg-reg form

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

FOR j := 0 TO KL-1

i := j * 32

m := j * 64

IF k1[j] OR *no writemask*

           THEN DEST[i+31:i] := SaturateSignedQuadWordToDWord (SRC[m+63:m])

           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/2] := 0;

VPMOVSQD instruction (EVEX encoded version) memory form

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

FOR j := 0 TO KL-1

i := j * 32

m := j * 64

IF k1[j] OR *no writemask*

        THEN DEST[i+31:i] := SaturateSignedQuadWordToDWord (SRC[m+63:m])

        ELSE *DEST[i+31:i] remains unchanged*  ; merging-masking

FI;

ENDFOR

VPMOVUSQD instruction (EVEX encoded version) reg-reg form

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

FOR j := 0 TO KL-1

i := j * 32

m := j * 64

IF k1[j] OR *no writemask*

        THEN DEST[i+31:i] := SaturateUnsignedQuadWordToDWord (SRC[m+63:m])

        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/2] := 0;

VPMOVUSQD instruction (EVEX encoded version) memory form

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

FOR j := 0 TO KL-1

i := j * 32

m := j * 64

IF k1[j] OR *no writemask*

        THEN DEST[i+31:i] := SaturateUnsignedQuadWordToDWord (SRC[m+63:m])

        ELSE *DEST[i+31:i] remains unchanged*  ; merging-masking

FI;

ENDFOR

Intel C/C++ compilador intrínseco

VPMOVQD __m256i _mm512_cvtepi64_epi32( __m512i a);
VPMOVQD __m256i _mm512_mask_cvtepi64_epi32(__m256i s, __mmask8 k, __m512i a);
VPMOVQD __m256i _mm512_maskz_cvtepi64_epi32( __mmask8 k, __m512i a);
VPMOVQD void _mm512_mask_cvtepi64_storeu_epi32(void * d, __mmask8 k, __m512i a);
VPMOVSQD __m256i _mm512_cvtsepi64_epi32( __m512i a);
VPMOVSQD __m256i _mm512_mask_cvtsepi64_epi32(__m256i s, __mmask8 k, __m512i a);
VPMOVSQD __m256i _mm512_maskz_cvtsepi64_epi32( __mmask8 k, __m512i a);
VPMOVSQD void _mm512_mask_cvtsepi64_storeu_epi32(void * d, __mmask8 k, __m512i a);
VPMOVUSQD __m256i _mm512_cvtusepi64_epi32( __m512i a);
VPMOVUSQD __m256i _mm512_mask_cvtusepi64_epi32(__m256i s, __mmask8 k, __m512i a);
VPMOVUSQD __m256i _mm512_maskz_cvtusepi64_epi32( __mmask8 k, __m512i a);
VPMOVUSQD void _mm512_mask_cvtusepi64_storeu_epi32(void * d, __mmask8 k, __m512i a);
VPMOVUSQD __m128i _mm256_cvtusepi64_epi32(__m256i a);
VPMOVUSQD __m128i _mm256_mask_cvtusepi64_epi32(__m128i a, __mmask8 k, __m256i b);
VPMOVUSQD __m128i _mm256_maskz_cvtusepi64_epi32( __mmask8 k, __m256i b);
VPMOVUSQD void _mm256_mask_cvtusepi64_storeu_epi32(void * , __mmask8 k, __m256i b);
VPMOVUSQD __m128i _mm_cvtusepi64_epi32(__m128i a);
VPMOVUSQD __m128i _mm_mask_cvtusepi64_epi32(__m128i a, __mmask8 k, __m128i b);
VPMOVUSQD __m128i _mm_maskz_cvtusepi64_epi32( __mmask8 k, __m128i b);
VPMOVUSQD void _mm_mask_cvtusepi64_storeu_epi32(void * , __mmask8 k, __m128i b);
VPMOVSQD __m128i _mm256_cvtsepi64_epi32(__m256i a);
VPMOVSQD __m128i _mm256_mask_cvtsepi64_epi32(__m128i a, __mmask8 k, __m256i b);
VPMOVSQD __m128i _mm256_maskz_cvtsepi64_epi32( __mmask8 k, __m256i b);
VPMOVSQD void _mm256_mask_cvtsepi64_storeu_epi32(void * , __mmask8 k, __m256i b);
VPMOVSQD __m128i _mm_cvtsepi64_epi32(__m128i a);
VPMOVSQD __m128i _mm_mask_cvtsepi64_epi32(__m128i a, __mmask8 k, __m128i b);
VPMOVSQD __m128i _mm_maskz_cvtsepi64_epi32( __mmask8 k, __m128i b);
VPMOVSQD void _mm_mask_cvtsepi64_storeu_epi32(void * , __mmask8 k, __m128i b);
VPMOVQD __m128i _mm256_cvtepi64_epi32(__m256i a);
VPMOVQD __m128i _mm256_mask_cvtepi64_epi32(__m128i a, __mmask8 k, __m256i b);
VPMOVQD __m128i _mm256_maskz_cvtepi64_epi32( __mmask8 k, __m256i b);
VPMOVQD void _mm256_mask_cvtepi64_storeu_epi32(void * , __mmask8 k, __m256i b);
VPMOVQD __m128i _mm_cvtepi64_epi32(__m128i a);
VPMOVQD __m128i _mm_mask_cvtepi64_epi32(__m128i a, __mmask8 k, __m128i b);
VPMOVQD __m128i _mm_maskz_cvtepi64_epi32( __mmask8 k, __m128i b);
VPMOVQD void _mm_mask_cvtepi64_storeu_epi32(void * , __mmask8 k, __m128i b);

SIMD coma flotante Excepciones

None.

Otras excepciones

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

Additionally: If EVEX.vvvv != 1111B.

#UD

Fuentes