UNPCKLPD

Mochila e Interleave Low valores en coma flotante de precisión doble empaquetados

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`66 0F 14 /r`	`UNPCKLPD xmm1, xmm2/m128`	A	Valido	Valido	Mochilas e Interleaves valores en coma flotante de precisión doble a partir de cuádwords bajas de xmm1 y xmm2/m128.
`VEX.128.66.0F.WIG 14 /r`	`VUNPCKLPD xmm1,xmm2, xmm3/m128`	B	Valido	Valido	Mochilas e Interleaves valores en coma flotante de precisión doble a partir de cuádwords bajas de xmm2 y xmm3/m128.
`VEX.256.66.0F.WIG 14 /r`	`VUNPCKLPD ymm1,ymm2, ymm3/m256`	B	Valido	Valido	Mochilas e Interleaves valores en coma flotante de precisión doble a partir de cuádwords bajas de ymm2 y ymm3/m256.
`EVEX.128.66.0F.W1 14 /r`	`VUNPCKLPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst`	C	Valido	Valido	Mochilas e Interleaves coma flotante de precisión doble AVX512F) Valores de OR de cuádpagos bajos de xmm2 y AVX10.1 xmm3/m128/m64bcst sujeto a escribir máscara k1.
`EVEX.256.66.0F.W1 14 /r`	`VUNPCKLPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst`	C	Valido	Valido	Mochilas e Interleaves coma flotante de precisión doble AVX512F) Valores de OR de cuádpagos bajos de ymm2 y AVX10.1 ymm3/m256/m64bcst sujeto a escribir máscara k1.
`EVEX.512.66.0F.W1 14 /r`	`VUNPCKLPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst`	C	Valido	Valido	Mochilas e Interleaves coma flotante de precisión doble OR AVX10.1 valores de cuádpatos bajos de zmm2 y zmm3/m512/m64bcst sujeto a escribir máscara 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

modrm.reg lectura y escriturabyte ModRM, campo reg (bits 5-3)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

B

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
vex.vvvv lecturaprefijo VEX, campo vvvv (invertido)
modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

C

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
evex.vvvv lecturaprefijo EVEX, campo vvvv (invertido)
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

Realiza un paquete entrelazado de los valores en coma flotante de precisión doble baja del primer operando de origen y el segundo operando de origen.

128-bit Legacy SSE versión: La segunda fuente puede ser un registro XMM o una ubicación de memoria de 128 bits. El destino no es distinto del registro XMM de primera fuente y los bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente no son modificados. Al desempacar desde un operando de memoria, una implementación puede buscar sólo los 64 bits apropiados; sin embargo, la alineación a los límites de 16 bytes y la comprobación normal de segmentos seguirá siendo aplicada.

VEX.128 versión codificada: El primer operando de origen es un registro XMM. El segundo operando de origen puede ser un registro XMM o una ubicación de memoria de 128 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.

VEX.256 versión codificada: El primer operando de origen es un registro YMM. El segundo operando de origen puede ser un registro YMM o una ubicación de memoria de 256 bits. El operando de destino es un registro YMM.

EVEX.512 versión codificada: El primer operando de origen es un registro ZMM. El segundo operando de origen 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 de 64 bits. El operando de destino es un registro ZMM, actualizado condicionalmente utilizando máscara de escritura k1.

EVEX.256 versión codificada: El primer operando de origen es un registro YMM. El segundo operando de origen es un registro YMM, una ubicación de memoria de 256 bits, o un vector de 256 bits emitido desde una ubicación de memoria de 64 bits. El operando de destino es un registro YMM, actualizado condicionalmente utilizando máscara de escritura k1.

EVEX.128 versión codificada: El primer operando de origen es un registro XMM. El segundo operando de origen es un registro XMM, una ubicación de memoria de 128 bits, o un vector de 128 bits emitido desde una ubicación de memoria de 64 bits. El operando de destino es un registro XMM, actualizado condicionalmente utilizando máscara de escritura k1.

Operación

VUNPCKLPD (EVEX Encoded Versions When SRC2 is a Register)
(KL, VL) = (2, 128), (4, 256), (8, 512)
IF VL >= 128

    TMP_DEST[63:0] := SRC1[63:0]
    TMP_DEST[127:64] := SRC2[63:0]
FI;
IF VL >= 256
    TMP_DEST[191:128] := SRC1[191:128]
    TMP_DEST[255:192] := SRC2[191:128]
FI;
IF VL >= 512
    TMP_DEST[319:256] := SRC1[319:256]
    TMP_DEST[383:320] := SRC2[319:256]
    TMP_DEST[447:384] := SRC1[447:384]
    TMP_DEST[511:448] := SRC2[447:384]
FI;

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := TMP_DEST[i+63:i]

     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


VUNPCKLPD (EVEX Encoded Version When SRC2 is Memory)

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

FOR j := 0 TO KL-1

     i := j * 64

     IF (EVEX.b = 1)

          THEN TMP_SRC2[i+63:i] := SRC2[63:0]

          ELSE TMP_SRC2[i+63:i] := SRC2[i+63:i]

     FI;

ENDFOR;

IF VL >= 128

     TMP_DEST[63:0] := SRC1[63:0]

     TMP_DEST[127:64] := TMP_SRC2[63:0]

FI;

IF VL >= 256

     TMP_DEST[191:128] := SRC1[191:128]

     TMP_DEST[255:192] := TMP_SRC2[191:128]

FI;

IF VL >= 512

     TMP_DEST[319:256] := SRC1[319:256]

     TMP_DEST[383:320] := TMP_SRC2[319:256]

     TMP_DEST[447:384] := SRC1[447:384]

     TMP_DEST[511:448] := TMP_SRC2[447:384]

FI;

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

          THEN DEST[i+63:i] := TMP_DEST[i+63:i]

          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

VUNPCKLPD (VEX.256 Encoded Version)
DEST[63:0] := SRC1[63:0]
DEST[127:64] := SRC2[63:0]
DEST[191:128] := SRC1[191:128]
DEST[255:192] := SRC2[191:128]
DEST[MAXVL-1:256] := 0

VUNPCKLPD (VEX.128 Encoded Version)
DEST[63:0] := SRC1[63:0]
DEST[127:64] := SRC2[63:0]
DEST[MAXVL-1:128] := 0

UNPCKLPD (128-bit Legacy SSE Version)
DEST[63:0] := SRC1[63:0]
DEST[127:64] := SRC2[63:0]
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ compilador intrínseco

VUNPCKLPD __m512d _mm512_unpacklo_pd( __m512d a, __m512d b);
VUNPCKLPD __m512d _mm512_mask_unpacklo_pd(__m512d s, __mmask8 k, __m512d a, __m512d b);
VUNPCKLPD __m512d _mm512_maskz_unpacklo_pd(__mmask8 k, __m512d a, __m512d b);
VUNPCKLPD __m256d _mm256_unpacklo_pd(__m256d a, __m256d b) VUNPCKLPD __m256d _mm256_mask_unpacklo_pd(__m256d s, __mmask8 k, __m256d a, __m256d b);
VUNPCKLPD __m256d _mm256_maskz_unpacklo_pd(__mmask8 k, __m256d a, __m256d b);
UNPCKLPD __m128d _mm_unpacklo_pd(__m128d a, __m128d b) VUNPCKLPD __m128d _mm_mask_unpacklo_pd(__m128d s, __mmask8 k, __m128d a, __m128d b);
VUNPCKLPD __m128d _mm_maskz_unpacklo_pd(__mmask8 k, __m128d a, __m128d b);

SIMD coma flotante Excepciones

None.

Otras excepciones

Instrucciones no código EVEX, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase".

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

UNPCKLPD

Codificaciones

Codificacion de operandos

A

B

C

Coste medido

Descripción#

Operación#

Intel C/C++ compilador intrínseco#

SIMD coma flotante Excepciones#

Otras excepciones#

Fuentes

Descripción

Operación

Intel C/C++ compilador intrínseco

SIMD coma flotante Excepciones

Otras excepciones