Vesta
Español
Código fuente

MOVSHDUP

Replicar valores en coma flotante de precisión simple

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
F3 0F 16 /rMOVSHDUP xmm1, xmm2/m128AValidoValidoMueva el índice extraño valores en coma flotante de precisión simple de xmm2/mem y duplica cada elemento en xmm1.
VEX.128.F3.0F.WIG 16 /rVMOVSHDUP xmm1, xmm2/m128AValidoValidoMueva el índice extraño valores en coma flotante de precisión simple de xmm2/mem y duplica cada elemento en xmm1.
VEX.256.F3.0F.WIG 16 /rVMOVSHDUP ymm1, ymm2/m256AValidoValidoMueva el índice extraño valores en coma flotante de precisión simple de ymm2/mem y duplica cada elemento en ymm1.
EVEX.128.F3.0F.W0 16 /rVMOVSHDUP xmm1 {k1}{z}, xmm2/m128BValidoValidoMover el índice extraño valores en coma flotante de precisión simple AVX512F) O de xmm2/m128 y duplicar cada elemento en AVX10.1 xmm1 bajo máscara de escritura.
EVEX.256.F3.0F.W0 16 /rVMOVSHDUP ymm1 {k1}{z}, ymm2/m256BValidoValidoMover el índice extraño valores en coma flotante de precisión simple AVX512F) O de ymm2/m256 y duplicar cada elemento en AVX10.1 ymm1 bajo máscara de escritura.
EVEX.512.F3.0F.W0 16 /rVMOVSHDUP zmm1 {k1}{z}, zmm2/m512BValidoValidoMover el índice extraño valores en coma flotante de precisión simple OR AVX10.1 de zmm2/m512 y duplicar cada elemento en zmm1 bajo máscara de escritura.

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: Full Mem

Coste medido

Cargando las mediciones de arch-data...

Descripción

Duplica valores en coma flotante de precisión simple del operando de origen (el segundo operando) al par de elementos adyacentes en el operando de destino (el primer operando). Véase la Figura 4-3. El operando de origen es un registro XMM, YMM o ZMM o 128, 256 o 512-bit ubicación de memoria y el operando de destino es un registro XMM, YMM o ZMM.

128-bit Legacy SSE versión: Bits (MAXVL-1:128) del registro de destino correspondiente no se modifican.

VEX.128 versión codificada: Bits (MAXVL-1:128) del registro de destino se ponen a cero.

VEX.256 versión codificada: Bits (MAXVL-1:256) del registro de destino se ponen a cero.

EVEX versión codificada: El operando de destino se actualiza en granularidad de 32 bits según la máscara de escritura.

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

                         SRC  X7     X6                     X5        X4    X3       X2  X1             X0
             DEST X7                 X7                     X5        X5    X3       X3  X1             X1

Figura 4-3. Operación MOVSHDUP

Operación

VMOVSHDUP (EVEX Encoded Versions)

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

TMP_SRC[31:0] := SRC[63:32]

TMP_SRC[63:32] := SRC[63:32]

TMP_SRC[95:64] := SRC[127:96]

TMP_SRC[127:96] := SRC[127:96]

IF VL >= 256

     TMP_SRC[159:128] := SRC[191:160]

     TMP_SRC[191:160] := SRC[191:160]

     TMP_SRC[223:192] := SRC[255:224]

     TMP_SRC[255:224] := SRC[255:224]

FI;

IF VL >= 512

     TMP_SRC[287:256] := SRC[319:288]

     TMP_SRC[319:288] := SRC[319:288]

     TMP_SRC[351:320] := SRC[383:352]

     TMP_SRC[383:352] := SRC[383:352]

     TMP_SRC[415:384] := SRC[447:416]

     TMP_SRC[447:416] := SRC[447:416]

     TMP_SRC[479:448] := SRC[511:480]

     TMP_SRC[511:480] := SRC[511:480]

FI;

FOR j := 0 TO KL-1

     i := j * 32

     IF k1[j] OR *no writemask*

          THEN DEST[i+31:i] := TMP_SRC[i+31:i]

          ELSE

                  IF *merging-masking*          ; merging-masking

                      THEN *DEST[i+31:i] remains unchanged*

                      ELSE                      ; zeroing-masking

                      DEST[i+31:i] := 0

                  FI

     FI;

ENDFOR

DEST[MAXVL-1:VL] := 0


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

VMOVSHDUP (VEX.128 Encoded Version)
DEST[31:0] := SRC[63:32]
DEST[63:32] := SRC[63:32]
DEST[95:64] := SRC[127:96]
DEST[127:96] := SRC[127:96]
DEST[MAXVL-1:128] := 0
MOVSHDUP (128-bit Legacy SSE Version)
DEST[31:0] := SRC[63:32]
DEST[63:32] := SRC[63:32]
DEST[95:64] := SRC[127:96]
DEST[127:96] := SRC[127:96]
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ compilador intrínseco

VMOVSHDUP __m512 _mm512_movehdup_ps( __m512 a);
VMOVSHDUP __m512 _mm512_mask_movehdup_ps(__m512 s, __mmask16 k, __m512 a);
VMOVSHDUP __m512 _mm512_maskz_movehdup_ps( __mmask16 k, __m512 a);
VMOVSHDUP __m256 _mm256_mask_movehdup_ps(__m256 s, __mmask8 k, __m256 a);
VMOVSHDUP __m256 _mm256_maskz_movehdup_ps( __mmask8 k, __m256 a);
VMOVSHDUP __m128 _mm_mask_movehdup_ps(__m128 s, __mmask8 k, __m128 a);
VMOVSHDUP __m128 _mm_maskz_movehdup_ps( __mmask8 k, __m128 a);
VMOVSHDUP __m256 _mm256_movehdup_ps (__m256 a);
VMOVSHDUP __m128 _mm_movehdup_ps (__m128 a);

SIMD coma flotante Excepciones

None.

Otras excepciones

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

EVEX-encoded instruction, ver Excepciones Tipo E4NF.nb en la tabla 2-52, "Tipo E4NF Clase Condiciones de Excepción."

Additionally:

#UD               If EVEX.vvvv != 1111B or VEX.vvvv != 1111B.

Fuentes