Vesta
Español
Código fuente

CVTPS2PD

Convertir valores en coma flotante de precisión simple empaquetados en Precisión doble embalada

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F 5A /rCVTPS2PD xmm1, xmm2/m64AValidoValidoConvertir dos valores en coma flotante de precisión simple empaquetados en xmm2/m64 en dos valores en coma flotante de precisión doble empaquetados en xmm1.
VEX.128.0F.WIG 5A /rVCVTPS2PD xmm1, xmm2/m64AValidoValidoConvertir dos valores en coma flotante de precisión simple empaquetados en xmm2/m64 en dos valores en coma flotante de precisión doble empaquetados en xmm1.
VEX.256.0F.WIG 5A /rVCVTPS2PD ymm1, xmm2/m128AValidoValidoConvertir cuatro valores en coma flotante de precisión simple empaquetados en xmm2/m128 a cuatro valores en coma flotante de precisión doble empaquetados en ymm1.
EVEX.128.0F.W0 5A /rVCVTPS2PD xmm1 {k1}{z}, xmm2/m64/m32bcstBValidoValidoConvertir dos valores de coma flotante de precisión simple AVX512F) OR en xmm2/m64/m32bcst para empaquetar doble AVX10.1 de precisión valores en coma flotante en xmm1 con máscara de escritura k1.
EVEX.256.0F.W0 5A /rVCVTPS2PD ymm1 {k1}{z}, xmm2/m128/m32bcstBValidoValidoConvertir cuatro valores de coma flotante de precisión simple AVX512F) OR en xmm2/m128/m32bcst para empaquetar doble AVX10.1 de precisión valores en coma flotante en ymm1 con máscara de escritura k1.
EVEX.512.0F.W0 5A /rVCVTPS2PD zmm1 {k1}{z}, ymm2/m256/m32bcst {sae}BValidoValidoConvertir ocho valores de coma flotante de precisión simple OR AVX10.1 en ymm2/m256/b32bcst a ocho valores en coma flotante de precisión doble empaquetados en zmm1 con 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. 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. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

Tupla: Half

Coste medido

Cargando las mediciones de arch-data...

Descripción

Convierte dos, cuatro o ocho valores en coma flotante de precisión simple empaquetados en el operando de origen (segundo operando) a dos, cuatro o ocho valores en coma flotante de precisión doble empaquetados en el operando de destino (primer operando).

EVEX versiones codificadas: El operando de origen es un registro YMM/XMM/XMM (bajo 64-bits) de 256/128/64-bit ubicación de memoria o un vector de 256/128/64-bit transmitido desde una ubicación de memoria de 32 bits. El operando de destino es un ZMM/YMM/XMM registro actualizado condicionalmente con máscara de escritura k1.

VEX.256 versión codificada: El operando de origen es un registro XMM o 128 bits ubicación de memoria. El operando de destino es un registro YMM. Bits (MAXVL-1:256) del destino correspondiente ZMM registro se ponen a cero.

VEX.128 versión codificada: El operando de origen es un registro XMM o ubicación de memoria de 64 bits. El operando de destino es un registro XMM. Los Bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente se ponen a cero.

128-bit Legacy SSE versión: El operando de origen es un registro XMM o ubicación de memoria de 64 bits. El operando de destino es un registro XMM. Los bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente son sin modificar.

Nota: VEX.vvvv y EVEX.vvvv están reservados y deben ser 1111b instrucciones de lo contrario #UD.

                 SRC                                    X3        X2   X1                     X0
                 DEST  X3                X2                 X1                            X0

Figura 3-9. CVTPS2PD (VEX.256 versión codificada)

Operación

VCVTPS2PD (EVEX Encoded Versions) When SRC Operand is a Register

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

FOR j := 0 TO KL-1

i := j * 64

k := j * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] :=

             Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[k+31:k])

     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

VCVTPS2PD (EVEX Encoded Versions) When SRC Operand is a Memory Source
(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1
    i := j * 64
    k := j * 32
    IF k1[j] OR *no writemask*
          THEN
                IF (EVEX.b = 1)
                      THEN
                            DEST[i+63:i] :=
                Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[31:0])
                      ELSE
                            DEST[i+63:i] :=
                Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[k+31:k])
                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

VCVTPS2PD (VEX.256 Encoded Version)
DEST[63:0] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[31:0])
DEST[127:64] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[63:32])
DEST[191:128] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[95:64])
DEST[255:192] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[127:96)
DEST[MAXVL-1:256] := 0

VCVTPS2PD (VEX.128 Encoded Version)
DEST[63:0] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[31:0])
DEST[127:64] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[63:32])
DEST[MAXVL-1:128] := 0

CVTPS2PD (128-bit Legacy SSE Version)
DEST[63:0] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[31:0])
DEST[127:64] := Convert_Single_Precision_To_Double_Precision_Floating_Point(SRC[63:32])
DEST[MAXVL-1:128] (unmodified)

Intel C/C++ compilador intrínseco

VCVTPS2PD __m512d _mm512_cvtps_pd( __m256 a);
VCVTPS2PD __m512d _mm512_mask_cvtps_pd( __m512d s, __mmask8 k, __m256 a);
VCVTPS2PD __m512d _mm512_maskz_cvtps_pd( __mmask8 k, __m256 a);
VCVTPS2PD __m512d _mm512_cvt_roundps_pd( __m256 a, int sae);
VCVTPS2PD __m512d _mm512_mask_cvt_roundps_pd( __m512d s, __mmask8 k, __m256 a, int sae);
VCVTPS2PD __m512d _mm512_maskz_cvt_roundps_pd( __mmask8 k, __m256 a, int sae);
VCVTPS2PD __m256d _mm256_mask_cvtps_pd( __m256d s, __mmask8 k, __m128 a);
VCVTPS2PD __m256d _mm256_maskz_cvtps_pd( __mmask8 k, __m128a);
VCVTPS2PD __m128d _mm_mask_cvtps_pd( __m128d s, __mmask8 k, __m128 a);
VCVTPS2PD __m128d _mm_maskz_cvtps_pd( __mmask8 k, __m128 a);
VCVTPS2PD __m256d _mm256_cvtps_pd (__m128 a) CVTPS2PD __m128d _mm_cvtps_pd (__m128 a);

SIMD coma flotante Excepciones

Invalid, Denormal.

Otras excepciones

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

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

Additionally: If VEX.vvvv != 1111B or EVEX.vvvv != 1111B.

#UD

Fuentes