Vesta
Español
Código fuente

DIVPD

Divide valores en coma flotante de precisión doble empaquetados

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
66 0F 5E /rDIVPD xmm1, xmm2/m128AValidoValidoDivide valores en coma flotante de precisión doble empaquetados en xmm1 por valores en coma flotante de precisión doble empaquetados en xmm2/mem.
VEX.128.66.0F.WIG 5E /rVDIVPD xmm1, xmm2, xmm3/m128BValidoValidoDivide valores en coma flotante de precisión doble empaquetados en xmm2 por valores en coma flotante de precisión doble empaquetados en xmm3/mem.
VEX.256.66.0F.WIG 5E /rVDIVPD ymm1, ymm2, ymm3/m256BValidoValidoDivide valores en coma flotante de precisión doble empaquetados en ymm2 por valores en coma flotante de precisión doble empaquetados en ymm3/mem.
EVEX.128.66.0F.W1 5E /rVDIVPD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcstCValidoValidoDivide los valores de coma flotante de precisión doble AVX512F) OR en xmm2 empaquetados por AVX10.1 valores en coma flotante en xmm3/m128/m64bcst y escriba los resultados a xmm1 sujeto a máscara de escritura k1.
EVEX.256.66.0F.W1 5E /rVDIVPD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstCValidoValidoDivide los valores de coma flotante de precisión doble AVX512F) OR en ymm2 empaquetados por AVX10.1 valores en coma flotante en ymm3/m256/m64bcst y escriba los resultados a ymm1 sujeto a máscara de escritura k1.
EVEX.512.66.0F.W1 5E /rVDIVPD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}CValidoValidoDivide los valores de coma flotante de precisión doble OR AVX10.1 en zmm2 por valores en coma flotante de precisión doble empaquetados en zmm3/m512/m64bcst y escriba los resultados a zmm1 sujeto a 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: Full

Coste medido

Cargando las mediciones de arch-data...

Descripción

Realiza una división SIMD de los valores en coma flotante de precisión doble en el primer operando de origen por los valores de punto flotante en el segundo operando de origen (el tercer operando). Los resultados están escritos al operando de destino (el primer operando).

EVEX versiones codificadas: El primer operando de origen (el segundo operando) es un registro ZMM/YMM/XMM. El segundo operando de origen puede ser un registro ZMM/YMM/XMM, un 512/256/128-bit ubicación de memoria o un vector 512/256/128-bit transmitido desde una ubicación de memoria de 64 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 primer operando de origen (el segundo operando) 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. Los bits superiores (MAXVL-1:256) del destino correspondiente se ponen a cero.

VEX.128 versión codificada: El primer operando de origen (el segundo operando) 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 correspondiente se ponen a cero.

128-bit Legacy SSE versión: El segundo operando de origen (el segundo operando) puede ser un registro XMM o una ubicación de memoria de 128 bits. El destino es el mismo que el primer operando de origen. Los bits superiores (MAXVL-1:128) del destino correspondiente son sin modificar.

Operación

VDIVPD (EVEX Encoded Versions)

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

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

     THEN

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(EVEX.RC); ; refer to Table 15-4 in the Intel(R) 64 and IA-32 Architectures

Software Developer's Manual, Volume 1

     ELSE

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(MXCSR.RC);

FI;

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

          THEN

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

                       THEN

                       DEST[i+63:i] := SRC1[i+63:i] / SRC2[63:0]

                       ELSE

                       DEST[i+63:i] := SRC1[i+63:i] / SRC2[i+63:i]

                  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

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

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

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

Intel C/C++ compilador intrínseco

VDIVPD __m512d _mm512_div_pd( __m512d a, __m512d b);
VDIVPD __m512d _mm512_mask_div_pd(__m512d s, __mmask8 k, __m512d a, __m512d b);
VDIVPD __m512d _mm512_maskz_div_pd( __mmask8 k, __m512d a, __m512d b);
VDIVPD __m256d _mm256_mask_div_pd(__m256d s, __mmask8 k, __m256d a, __m256d b);
VDIVPD __m256d _mm256_maskz_div_pd( __mmask8 k, __m256d a, __m256d b);
VDIVPD __m128d _mm_mask_div_pd(__m128d s, __mmask8 k, __m128d a, __m128d b);
VDIVPD __m128d _mm_maskz_div_pd( __mmask8 k, __m128d a, __m128d b);
VDIVPD __m512d _mm512_div_round_pd( __m512d a, __m512d b, int);
VDIVPD __m512d _mm512_mask_div_round_pd(__m512d s, __mmask8 k, __m512d a, __m512d b, int);
VDIVPD __m512d _mm512_maskz_div_round_pd( __mmask8 k, __m512d a, __m512d b, int);
VDIVPD __m256d _mm256_div_pd (__m256d a, __m256d b);
DIVPD __m128d _mm_div_pd (__m128d a, __m128d b);

SIMD coma flotante Excepciones

Overflow, Underflow, Invalid, Divide-by-Zero, Precision, Denormal.

Otras excepciones

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

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

Fuentes