VFNMADD132PD, VFNMADD213PD, VFNMADD231PD

Fused Negative Multiply-Add of Packed

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`VEX.128.66.0F38.W1 9C /r`	`VFNMADD132PD xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión doble empaquetados de xmm1 y xmm3/mem, negar el resultado de la multiplicación y añadir a xmm2 y poner resultado en xmm1.
`VEX.128.66.0F38.W1 AC /r`	`VFNMADD213PD xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión doble empaquetados de xmm1 y xmm2, niega el resultado de la multiplicación y añade a xmm3/mem y da resultado en xmm1.
`VEX.128.66.0F38.W1 BC /r`	`VFNMADD231PD xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión doble empaquetados de xmm2 y xmm3/mem, negar el resultado de la multiplicación y añadir a xmm1 y poner resultado en xmm1.
`VEX.256.66.0F38.W1 9C /r`	`VFNMADD132PD ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión doble empaquetados de ymm1 y ymm3/mem, negar el resultado de la multiplicación y añadir a ymm2 y poner resultado en ymm1.
`VEX.256.66.0F38.W1 AC /r`	`VFNMADD213PD ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión doble empaquetados de ymm1 y ymm2, niega el resultado de la multiplicación y añade a ymm3/mem y da resultado en ymm1.
`VEX.256.66.0F38.W1 BC /r`	`VFNMADD231PD ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión doble empaquetados de ymm2 y ymm3/mem, negar el resultado de la multiplicación y añadir a ymm1 y poner resultado en ymm1.
`EVEX.128.66.0F38.W1 9C /r`	`VFNMADD132PD xmm0 {k1}{z}, xmm1, xmm2/m128/m64bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión doble AVX512F) Los valores OR de xmm1 y xmm3/m128/m64bcst, AVX10.1 niegan el resultado de la multiplicación y añaden a xmm2 y ponen resultado en xmm1.
`EVEX.128.66.0F38.W1 AC /r`	`VFNMADD213PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión doble AVX512F) Los valores OR de xmm1 y xmm2, niegan el resultado de la multiplicación AVX10.1 y añaden a xmm3/m128/m64bcst y ponen resultado en xmm1.
`EVEX.128.66.0F38.W1 BC /r`	`VFNMADD231PD xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión doble AVX512F) Los valores OR de xmm2 y xmm3/m128/m64bcst, AVX10.1 niegan el resultado de la multiplicación y añaden a xmm1 y ponen resultado en xmm1.
`EVEX.256.66.0F38.W1 9C /r`	`VFNMADD132PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión doble AVX512F) Los valores OR de ymm1 y ymm3/m256/m64bcst, AVX10.1 niegan el resultado de la multiplicación y añaden a ymm2 y ponen resultado en ymm1.
`EVEX.256.66.0F38.W1 AC /r`	`VFNMADD213PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión doble AVX512F) Los valores OR de ymm1 y ymm2, niegan el resultado de la multiplicación AVX10.1 y añaden a ymm3/m256/m64bcst y ponen resultado en ymm1.
`EVEX.256.66.0F38.W1 BC /r`	`VFNMADD231PD ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcst Opcode/ Instruction`	B	Valido	Valido	Multiply packed coma flotante de precisión doble AVX512F) Los valores OR de ymm2 y ymm3/m256/m64bcst, AVX10.1 niegan el resultado de la multiplicación y añaden a ymm1 y ponen el resultado en ymm1. Op/ 64/3 2 CPUID Fea ture Descripción En Bit Supp Mode Flag ort
`EVEX.512.66.0F38.W1 9C /r`	`VFNMADD132PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}`		b v	Valido	Multiply packed coma flotante de precisión doble OR AVX10. 1 valores de zmm1 y zmm3/m512/m64bcst, negar el resultado de la multiplicación y añadir a zmm2 y poner el resultado en zmm1.
`EVEX.512.66.0F38.W1 AC /r`	`VFNMADD213PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}`		b v	Valido	Multiply packed coma flotante de precisión doble OR AVX10. 1 valores de zmm1 y zmm2, niega el resultado de la multiplicación y añadir a zmm3/m512/m64bcst y poner el resultado en zmm1.
`EVEX.512.66.0F38.W1 BC /r`	`VFNMADD231PD zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcst{er}`		b v	Valido	Multiply packed coma flotante de precisión doble OR AVX10. 1 valores de zmm2 y zmm3/m512/m64bcst, negar el resultado de la multiplicación y añadir a zmm1 y poner el resultado en zmm1.

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)
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

B

modrm.reg lectura y 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

VFNMADD132PD: Multiplica los dos, cuatro o ocho valores de doble precisión empaquetados de punto flotante de la primera fuente operando a los dos, cuatro o ocho valores de doble precisión flotante en el tercer operado de la tercera fuente, añade el resultado intermedio de precisión infinita negada a los dos, cuatro o ocho valores de doble precisión flotante de doble precisión en el operado de la segunda fuente, realiza la fuente redondeada y almacena los dos, cuatro o ocho valores empaquetados de doble precisión de destino flotante.

VFNMADD213PD: Multiplica los dos, cuatro o ocho valores de doble precisión empaquetados de punto flotante de la segunda fuente operand a los dos, cuatro o ocho valores de doble precisión flotante de doble precisión en la primera fuente operand, añade el resultado intermedio de precisión infinita negada a los dos, cuatro o ocho valores de doble precisión flotante de doble precisión en el operado de la tercera fuente, realiza la fuente redondeada y almacena los dos, cuatro o ocho valores empaquetados de doble precisión de destino flotante.

VFNMADD231PD: Multiplica los dos, cuatro o ocho valores de doble precisión empaquetados de punto flotante de la segunda fuente a los dos, cuatro o ocho valores de doble precisión flotante en el operado de la tercera fuente, el resultado intermedio de precisión infinita negada a los dos, cuatro o ocho valores de doble precisión flotante-punto empaquetado en la primera fuente operando, realiza redondeo y almacena los dos, cuatro o ocho valores de doble precisión operado en el destino principal fuente.

EVEX versiones codificadas: El operando de destino (también primer operando de origen) y el segundo operando de origen son ZMM/YMM/XMM registro. El tercer operando de origen es un ZMM/YMM/XMM registrado, 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 está actualizado condicionalmente con máscara de escritura k1.

VEX.256 versión codificada: El operando de destino (también primer operando de origen) es un registro YMM y codificado en reg field. El segundo operando de origen es un registro YMM y codificado en VEX.vvvv. El tercer operando de origen es un registro YMM o una ubicación de memoria de 256 bits y codificado en rm field.

VEX.128 versión codificada: El operando de destino (también primer operando de origen) es un registro XMM y codificado en reg field. El segundo operando de origen es un registro XMM y codificado en VEX.vvvv. El tercer operando de origen es un registro XMM o una ubicación de memoria de 128 bits y codificado en rm field. Los 128 bits superiores del destino YMM registran se ponen a cero.

Operación

In the operations below, "*" and "-" symbols represent multiplication and subtraction with infinite precision inputs and outputs (no
rounding).


VFNMADD132PD DEST, SRC2, SRC3 (VEX encoded version)
IF (VEX.128) THEN

    MAXNUM := 2
ELSEIF (VEX.256)

    MAXNUM := 4
FI
For i = 0 to MAXNUM-1 {

    n := 64*i;
    DEST[n+63:n] := RoundFPControl_MXCSR(-(DEST[n+63:n]*SRC3[n+63:n]) + SRC2[n+63:n])
}
IF (VEX.128) THEN
    DEST[MAXVL-1:128] := 0
ELSEIF (VEX.256)
    DEST[MAXVL-1:256] := 0
FI

VFNMADD213PD DEST, SRC2, SRC3 (VEX encoded version)
IF (VEX.128) THEN

    MAXNUM := 2
ELSEIF (VEX.256)

    MAXNUM := 4
FI
For i = 0 to MAXNUM-1 {

    n := 64*i;
    DEST[n+63:n] := RoundFPControl_MXCSR(-(SRC2[n+63:n]*DEST[n+63:n]) + SRC3[n+63:n])
}
IF (VEX.128) THEN
    DEST[MAXVL-1:128] := 0
ELSEIF (VEX.256)
    DEST[MAXVL-1:256] := 0
FI

VFNMADD231PD DEST, SRC2, SRC3 (VEX encoded version)
IF (VEX.128) THEN

    MAXNUM := 2
ELSEIF (VEX.256)

    MAXNUM := 4
FI
For i = 0 to MAXNUM-1 {

    n := 64*i;
    DEST[n+63:n] := RoundFPControl_MXCSR(-(SRC2[n+63:n]*SRC3[n+63:n]) + DEST[n+63:n])
}
IF (VEX.128) THEN
    DEST[MAXVL-1:128] := 0
ELSEIF (VEX.256)
    DEST[MAXVL-1:256] := 0
FI


VFNMADD132PD DEST, SRC2, SRC3 (EVEX encoded version, when src3 operand is a register)

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

IF (VL = 512) AND (EVEX.b = 1)

     THEN

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(EVEX.RC);

     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 DEST[i+63:i] :=

                  RoundFPControl(-(DEST[i+63:i]*SRC3[i+63:i]) + SRC2[i+63:i])

          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

VFNMADD132PD DEST, SRC2, SRC3 (EVEX encoded version, when src3 operand is a memory source)
(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

          THEN

                  IF (EVEX.b = 1)

                       THEN

                       DEST[i+63:i] :=

                  RoundFPControl_MXCSR(-(DEST[i+63:i]*SRC3[63:0]) + SRC2[i+63:i])

                       ELSE

                       DEST[i+63:i] :=

                  RoundFPControl_MXCSR(-(DEST[i+63:i]*SRC3[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


VFNMADD213PD DEST, SRC2, SRC3 (EVEX encoded version, when src3 operand is a register)

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

IF (VL = 512) AND (EVEX.b = 1)

     THEN

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(EVEX.RC);

     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 DEST[i+63:i] :=

                  RoundFPControl(-(SRC2[i+63:i]*DEST[i+63:i]) + SRC3[i+63:i])

          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

VFNMADD213PD DEST, SRC2, SRC3 (EVEX encoded version, when src3 operand is a memory source)
(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

          THEN

                  IF (EVEX.b = 1)

                       THEN

                       DEST[i+63:i] :=

                  RoundFPControl_MXCSR(-(SRC2[i+63:i]*DEST[i+63:i]) + SRC3[63:0])

                       ELSE

                       DEST[i+63:i] :=

                  RoundFPControl_MXCSR(-(SRC2[i+63:i]*DEST[i+63:i]) + SRC3[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


VFNMADD231PD DEST, SRC2, SRC3 (EVEX encoded version, when src3 operand is a register)

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

IF (VL = 512) AND (EVEX.b = 1)

     THEN

          SET_ROUNDING_MODE_FOR_THIS_INSTRUCTION(EVEX.RC);

     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 DEST[i+63:i] :=

                  RoundFPControl(-(SRC2[i+63:i]*SRC3[i+63:i]) + DEST[i+63:i])

          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

VFNMADD231PD DEST, SRC2, SRC3 (EVEX encoded version, when src3 operand is a memory source)
(KL, VL) = (2, 128), (4, 256), (8, 512)

FOR j := 0 TO KL-1

     i := j * 64

     IF k1[j] OR *no writemask*

          THEN

                  IF (EVEX.b = 1)

                       THEN

                       DEST[i+63:i] :=

                  RoundFPControl_MXCSR(-(SRC2[i+63:i]*SRC3[63:0]) + DEST[i+63:i])

                       ELSE

                       DEST[i+63:i] :=

                  RoundFPControl_MXCSR(-(SRC2[i+63:i]*SRC3[i+63:i]) + DEST[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

Intel C/C++ compilador intrínseco

VFNMADDxxxPD __m512d _mm512_fnmadd_pd(__m512d a, __m512d b, __m512d c);
VFNMADDxxxPD __m512d _mm512_fnmadd_round_pd(__m512d a, __m512d b, __m512d c, int r);
VFNMADDxxxPD __m512d _mm512_mask_fnmadd_pd(__m512d a, __mmask8 k, __m512d b, __m512d c);
VFNMADDxxxPD __m512d _mm512_maskz_fnmadd_pd(__mmask8 k, __m512d a, __m512d b, __m512d c);
VFNMADDxxxPD __m512d _mm512_mask3_fnmadd_pd(__m512d a, __m512d b, __m512d c, __mmask8 k);
VFNMADDxxxPD __m512d _mm512_mask_fnmadd_round_pd(__m512d a, __mmask8 k, __m512d b, __m512d c, int r);
VFNMADDxxxPD __m512d _mm512_maskz_fnmadd_round_pd(__mmask8 k, __m512d a, __m512d b, __m512d c, int r);
VFNMADDxxxPD __m512d _mm512_mask3_fnmadd_round_pd(__m512d a, __m512d b, __m512d c, __mmask8 k, int r);
VFNMADDxxxPD __m256d _mm256_mask_fnmadd_pd(__m256d a, __mmask8 k, __m256d b, __m256d c);
VFNMADDxxxPD __m256d _mm256_maskz_fnmadd_pd(__mmask8 k, __m256d a, __m256d b, __m256d c);
VFNMADDxxxPD __m256d _mm256_mask3_fnmadd_pd(__m256d a, __m256d b, __m256d c, __mmask8 k);
VFNMADDxxxPD __m128d _mm_mask_fnmadd_pd(__m128d a, __mmask8 k, __m128d b, __m128d c);
VFNMADDxxxPD __m128d _mm_maskz_fnmadd_pd(__mmask8 k, __m128d a, __m128d b, __m128d c);
VFNMADDxxxPD __m128d _mm_mask3_fnmadd_pd(__m128d a, __m128d b, __m128d c, __mmask8 k);
VFNMADDxxxPD __m128d _mm_fnmadd_pd (__m128d a, __m128d b, __m128d c);
VFNMADDxxxPD __m256d _mm256_fnmadd_pd (__m256d a, __m256d b, __m256d c);

SIMD coma flotante Excepciones

Overflow, Underflow, Invalid, 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."

VFNMADD132PD, VFNMADD213PD, VFNMADD231PD

Codificaciones

Codificacion de operandos

A

B

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