Vesta
Español
Código fuente

VPMOVDW, VPMOVSDW, VPMOVUSDW

Down Convertir DWord en Word

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
EVEX.128.F3.0F38.W0 33 /rVPMOVDW xmm1/m64 {k1}{z}, xmm2AValidoValidoConvierte 4 enteros de doble palabra embalados AVX512F) OR AVX10.1 de xmm2 en 4 enteros de palabras en xmm1/m64 con truncación bajo máscara de escritura k1.
EVEX.128.F3.0F38.W0 23 /rVPMOVSDW xmm1/m64 {k1}{z}, xmm2AValidoValidoConvierte 4 integers de doble palabra firmados AVX512F) OR AVX10.1 de xmm2 en 4 enteros de palabra firmados en ymm1/m64 usando saturación firmada bajo máscara de escritura k1.
EVEX.128.F3.0F38.W0 13 /rVPMOVUSDW xmm1/m64 {k1}{z}, xmm2AValidoValidoConvierte 4 integers de doble palabra sin firmar AVX512F) OR AVX10.1 de xmm2 en 4 enteros de palabras sin firmar en xmm1/m64 usando saturación sin firmar bajo máscara de escritura k1.
EVEX.256.F3.0F38.W0 33 /rVPMOVDW xmm1/m128 {k1}{z}, ymm2AValidoValidoConvierte 8 enteros de doble palabra empaquetados AVX512F) OR AVX10.1 de ymm2 en 8 enteros de palabras empaquetadas en xmm1/m128 con truncación bajo máscara de escritura k1.
EVEX.256.F3.0F38.W0 23 /rVPMOVSDW xmm1/m128 {k1}{z}, ymm2AValidoValidoConvierte 8 integers de doble palabra firmados AVX512F) OR AVX10.1 de ymm2 en 8 enteros de palabra firmados en xmm1/m128 usando saturación firmada bajo máscara de escritura k1.
EVEX.256.F3.0F38.W0 13 /rVPMOVUSDW xmm1/m128 {k1}{z}, ymm2AValidoValidoConvierte 8 integers de doble palabra sin firmar AVX512F) O de ymm2 en 8 enteros de palabra AVX10.1 sin firmar en xmm1/m128 usando saturación sin firmar bajo máscara de escritura k1.
EVEX.512.F3.0F38.W0 33 /rVPMOVDW ymm1/m256 {k1}{z}, zmm2AValidoValidoConvierte 16 enteros de doble palabra envasados OR AVX10.1 de zmm2 en 16 enteros de palabra en ymm1/m256 con truncación bajo máscara de escritura k1.
EVEX.512.F3.0F38.W0 23 /rVPMOVSDW ymm1/m256 {k1}{z}, zmm2AValidoValidoConvierte 16 enteros firmados de doble palabra OR AVX10.1 de zmm2 en 16 enteros de palabra firmados en ymm1/m256 usando saturación firmada bajo máscara de escritura k1.
EVEX.512.F3.0F38.W0 13 /rVPMOVUSDW ymm1/m256 {k1}{z}, zmm2AValidoValidoConvierte 16 integers de doble palabra sin firmar OR AVX10.1 de zmm2 en 16 enteros de palabras sin firmar en ymm1/m256 usando saturación sin firmar bajo 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

VPMOVDW abajo convierte elementos enteros de 32 bits en el operando de origen (el segundo operando) en palabras empaquetadas utilizando truncación. VPMOVSDW convierte integers de 32 bits en palabras firmadas empaquetadas usando saturación firmada. VPMOVUSDW convierte valores de doble palabra no firmados en valores de palabras 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 palabras de baja conversión se escriben al operando de destino (el primer operando) de la palabra menos significativa. Los elementos de palabras 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

VPMOVDW instruction (EVEX encoded versions) when dest is a register

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

FOR j := 0 TO KL-1

i := j * 16

m := j * 32

IF k1[j] OR *no writemask*

           THEN DEST[i+15:i] := TruncateDoubleWordToWord (SRC[m+31:m])

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

VPMOVDW instruction (EVEX encoded versions) when dest is memory
    (KL, VL) = (4, 128), (8, 256), (16, 512)
    FOR j := 0 TO KL-1
          i := j * 16
          m := j * 32
          IF k1[j] OR *no writemask*
                THEN DEST[i+15:i] := TruncateDoubleWordToWord (SRC[m+31:m])
                ELSE
                      *DEST[i+15:i] remains unchanged* ; merging-masking
          FI;
    ENDFOR

VPMOVSDW instruction (EVEX encoded versions) when dest is a register

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

FOR j := 0 TO KL-1

i := j * 16

m := j * 32

IF k1[j] OR *no writemask*

           THEN DEST[i+15:i] := SaturateSignedDoubleWordToWord (SRC[m+31:m])

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

VPMOVSDW instruction (EVEX encoded versions) when dest is memory
    (KL, VL) = (4, 128), (8, 256), (16, 512)
    FOR j := 0 TO KL-1
          i := j * 16
          m := j * 32
          IF k1[j] OR *no writemask*
                THEN DEST[i+15:i] := SaturateSignedDoubleWordToWord (SRC[m+31:m])
                ELSE
                      *DEST[i+15:i] remains unchanged* ; merging-masking
          FI;
    ENDFOR

VPMOVUSDW instruction (EVEX encoded versions) when dest is a register

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

FOR j := 0 TO KL-1

i := j * 16

m := j * 32

IF k1[j] OR *no writemask*

        THEN DEST[i+15:i] := SaturateUnsignedDoubleWordToWord (SRC[m+31:m])

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

VPMOVUSDW instruction (EVEX encoded versions) when dest is memory
    (KL, VL) = (4, 128), (8, 256), (16, 512)
    FOR j := 0 TO KL-1
          i := j * 16
          m := j * 32
          IF k1[j] OR *no writemask*
                THEN DEST[i+15:i] := SaturateUnsignedDoubleWordToWord (SRC[m+31:m])
                ELSE
                      *DEST[i+15:i] remains unchanged* ; merging-masking
          FI;
    ENDFOR

Intel C/C++ compilador intrínseco

VPMOVDW __m256i _mm512_cvtepi32_epi16( __m512i a);
VPMOVDW __m256i _mm512_mask_cvtepi32_epi16(__m256i s, __mmask16 k, __m512i a);
VPMOVDW __m256i _mm512_maskz_cvtepi32_epi16( __mmask16 k, __m512i a);
VPMOVDW void _mm512_mask_cvtepi32_storeu_epi16(void * d, __mmask16 k, __m512i a);
VPMOVSDW __m256i _mm512_cvtsepi32_epi16( __m512i a);
VPMOVSDW __m256i _mm512_mask_cvtsepi32_epi16(__m256i s, __mmask16 k, __m512i a);
VPMOVSDW __m256i _mm512_maskz_cvtsepi32_epi16( __mmask16 k, __m512i a);
VPMOVSDW void _mm512_mask_cvtsepi32_storeu_epi16(void * d, __mmask16 k, __m512i a);
VPMOVUSDW __m256i _mm512_mask_cvtusepi32_epi16(__m256i s, __mmask16 k, __m512i a);
VPMOVUSDW __m256i _mm512_maskz_cvtusepi32_epi16( __mmask16 k, __m512i a);
VPMOVUSDW void _mm512_mask_cvtusepi32_storeu_epi16(void * d, __mmask16 k, __m512i a);
VPMOVUSDW __m128i _mm256_cvtusepi32_epi16(__m256i a);
VPMOVUSDW __m128i _mm256_mask_cvtusepi32_epi16(__m128i a, __mmask8 k, __m256i b);
VPMOVUSDW __m128i _mm256_maskz_cvtusepi32_epi16( __mmask8 k, __m256i b);
VPMOVUSDW void _mm256_mask_cvtusepi32_storeu_epi16(void * , __mmask8 k, __m256i b);
VPMOVUSDW __m128i _mm_cvtusepi32_epi16(__m128i a);
VPMOVUSDW __m128i _mm_mask_cvtusepi32_epi16(__m128i a, __mmask8 k, __m128i b);
VPMOVUSDW __m128i _mm_maskz_cvtusepi32_epi16( __mmask8 k, __m128i b);
VPMOVUSDW void _mm_mask_cvtusepi32_storeu_epi16(void * , __mmask8 k, __m128i b);
VPMOVSDW __m128i _mm256_cvtsepi32_epi16(__m256i a);
VPMOVSDW __m128i _mm256_mask_cvtsepi32_epi16(__m128i a, __mmask8 k, __m256i b);
VPMOVSDW __m128i _mm256_maskz_cvtsepi32_epi16( __mmask8 k, __m256i b);
VPMOVSDW void _mm256_mask_cvtsepi32_storeu_epi16(void * , __mmask8 k, __m256i b);
VPMOVSDW __m128i _mm_cvtsepi32_epi16(__m128i a);
VPMOVSDW __m128i _mm_mask_cvtsepi32_epi16(__m128i a, __mmask8 k, __m128i b);
VPMOVSDW __m128i _mm_maskz_cvtsepi32_epi16( __mmask8 k, __m128i b);
VPMOVSDW void _mm_mask_cvtsepi32_storeu_epi16(void * , __mmask8 k, __m128i b);
VPMOVDW __m128i _mm256_cvtepi32_epi16(__m256i a);
VPMOVDW __m128i _mm256_mask_cvtepi32_epi16(__m128i a, __mmask8 k, __m256i b);
VPMOVDW __m128i _mm256_maskz_cvtepi32_epi16( __mmask8 k, __m256i b);
VPMOVDW void _mm256_mask_cvtepi32_storeu_epi16(void * , __mmask8 k, __m256i b);
VPMOVDW __m128i _mm_cvtepi32_epi16(__m128i a);
VPMOVDW __m128i _mm_mask_cvtepi32_epi16(__m128i a, __mmask8 k, __m128i b);
VPMOVDW __m128i _mm_maskz_cvtepi32_epi16( __mmask8 k, __m128i b);
VPMOVDW void _mm_mask_cvtepi32_storeu_epi16(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