Vesta
Español
Código fuente

CVTSD2SS

Convertir valores en coma flotante de precisión doble escalares en escalar Precisión simple

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
F2 0F 5A /rCVTSD2SS xmm1, xmm2/m64AValidoValidoConvertir un valor en coma flotante de precisión doble en xmm2/m64 en un valor en coma flotante de precisión simple en xmm1.
VEX.LIG.F2.0F.WIG 5A /rVCVTSD2SS xmm1,xmm2, xmm3/m64BValidoValidoConvertir un valor en coma flotante de precisión doble en xmm3/m64 en un valor en coma flotante de precisión simple y combinar con pedazos altos en xmm2.
EVEX.LLIG.F2.0F.W1 5A /rVCVTSD2SS xmm1 {k1}{z}, xmm2, xmm3/m64{er}CValidoValidoConvertir un valor en coma flotante de precisión doble en OR AVX10.1 xmm3/m64 en un valor en coma flotante de precisión simple y fusionarse con trozos altos en xmm2 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.reg lectura y 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. 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

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: Tuple1 Scalar

Coste medido

Cargando las mediciones de arch-data...

Descripción

Convierte un valor en coma flotante de precisión doble en el "convertir-de" operando de origen (el segundo operando en SSE2 versión, de lo contrario el tercero operando) a un valor en coma flotante de precisión simple en el operando de destino.

Cuando el "convertir de" operando es un registro XMM, el valor en coma flotante de precisión doble está contenido en el bajo cuadword del registro. El resultado se almacena en la palabra doble baja del operando de destino. Cuando la conversión es inexacta, el valor devuelto se redondea según los bits de control de redondeo en el registro MXCSR.

128-bit Legacy SSE versión: El "converso de" operando de origen (el segundo operando) es un registro XMM o ubicación de memoria. Bits (MAXVL-1:32) del registro de destino correspondiente no se modifican. El operando de destino es un registro XMM.

VEX.128 y EVEX versiones codificadas: El "converso de" operando de origen (el tercer operando) puede ser un registro XMM o una ubicación de memoria de 64 bits. La primera fuente y operandos de destino son registros XMM. Los bits (127:32) del destino de registro XMM se copian de los bits correspondientes en el primer operando de origen. Bits (MAXVL- 1:128) del registro de destino se ponen a cero.

EVEX versión codificada: el resultado convertido en escrito al elemento de doble palabra bajo del destino bajo la máscara de escritura.

El software debe asegurar que VCVTSD2SS esté codificado con VEX.L=0. Codificar VCVTSD2SS con VEX.L=1 puede encontrar un comportamiento impredecible en diferentes generaciones de procesadores.

Operación

VCVTSD2SS (EVEX Encoded Version)

IF (SRC2 *is register*) AND (EVEX.b = 1)

     THEN

     SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(EVEX.RC);

     ELSE

     SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(MXCSR.RC);

FI;

IF k1[0] or *no writemask*

     THEN DEST[31:0] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC2[63:0]);

     ELSE

     IF *merging-masking*                 ; merging-masking

           THEN *DEST[31:0] remains unchanged*

           ELSE                           ; zeroing-masking

           THEN DEST[31:0] := 0

     FI;

FI;

DEST[127:32] := SRC1[127:32]

DEST[MAXVL-1:128] := 0

VCVTSD2SS (VEX.128 Encoded Version)
DEST[31:0] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC2[63:0]);
DEST[127:32] := SRC1[127:32]
DEST[MAXVL-1:128] := 0

CVTSD2SS (128-bit Legacy SSE Version)
DEST[31:0] := Convert_Double_Precision_To_Single_Precision_Floating_Point(SRC[63:0]);
(* DEST[MAXVL-1:32] Unmodified *)

Intel C/C++ compilador intrínseco

VCVTSD2SS __m128 _mm_mask_cvtsd_ss(__m128 s, __mmask8 k, __m128 a, __m128d b);
VCVTSD2SS __m128 _mm_maskz_cvtsd_ss( __mmask8 k, __m128 a,__m128d b);
VCVTSD2SS __m128 _mm_cvt_roundsd_ss(__m128 a, __m128d b, int r);
VCVTSD2SS __m128 _mm_mask_cvt_roundsd_ss(__m128 s, __mmask8 k, __m128 a, __m128d b, int r);
VCVTSD2SS __m128 _mm_maskz_cvt_roundsd_ss( __mmask8 k, __m128 a,__m128d b, int r);
CVTSD2SS __m128_mm_cvtsd_ss(__m128 a, __m128d b);

SIMD coma flotante Excepciones

Overflow, Underflow, Invalid, Precision, Denormal.

Otras excepciones

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

Fuentes