VFNMADD132PS, VFNMADD213PS, VFNMADD231PS

Fused Negative Multiply-Add of Packed

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`VEX.128.66.0F38.W0 9C /r`	`VFNMADD132PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple 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.W0 AC /r`	`VFNMADD213PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple 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.W0 BC /r`	`VFNMADD231PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple 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.W0 9C /r`	`VFNMADD132PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple 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.W0 AC /r`	`VFNMADD213PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple 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.0 BC /r`	`VFNMADD231PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple 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.W0 9C /r`	`VFNMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados AVX512F) OR de xmm1 y xmm3/m128/m32bcst, niega el resultado de multiplicación AVX10.1 y añadir a xmm2 y dar resultado en xmm1.
`EVEX.128.66.0F38.W0 AC /r`	`VFNMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados AVX512F) OR de xmm1 y xmm2, niega la multiplicación AVX10.1 resultado y añadir a xmm3/m128/m32bcst y poner resultado en xmm1.
`EVEX.128.66.0F38.W0 BC /r`	`VFNMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados AVX512F) OR de xmm2 y xmm3/m128/m32bcst, niega el resultado de multiplicación AVX10.1 y añadir a xmm1 y dar resultado en xmm1.
`EVEX.256.66.0F38.W0 9C /r`	`VFNMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst`	B	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados AVX512F) OR de ymm1 y ymm3/m256/m32bcst, niega el resultado de multiplicación AVX10.1 y añadir a ymm2 y dar resultado en ymm1.
`EVEX.256.66.0F38.W0 AC /r`	`VFNMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst`	B	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados AVX512F) OR de ymm1 y ymm2, niega la multiplicación AVX10.1 resultado y añadir a ymm3/m256/m32bcst y poner resultado en ymm1.
`EVEX.256.66.0F38.W0 BC /r`	`VFNMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst Opcode/ Instruction`	B	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados AVX512F) OR de ymm2 y ymm3/m256/m32bcst, niega el resultado de multiplicación AVX10.1 y añadir a ymm1 y dar resultado en ymm1. Op/ 64/3 2 CPUID Fea ture Descripción En Bit Supp Mode Bandera ort
`EVEX.512.66.0F38.W0 9C /r`	`VFNMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`		b v	Valido	AND Multiply valores en coma flotante de precisión simple empaquetados AVX512F) O de zmm1 y zmm3/m512/m32bcst, niega el resultado de la multiplicación AVX10.1 y añadir a zmm2 y dar resultado en zmm1.
`EVEX.512.66.0F38.W0 AC /r`	`VFNMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`		b v	Valido	R Multiply valores en coma flotante de precisión simple empaquetados AVX10.1 de zmm1 y zmm2, negar el resultado de la multiplicación y añadir a zmm3/m512/m32bcst y poner resultado en zmm1.
`EVEX.512.66.0F38.W0 BC /r`	`VFNMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`		b v	Valido	R Multiply valores en coma flotante de precisión simple empaquetados AVX10.1 de zmm2 y zmm3/m512/m32bcst, negar el resultado de la multiplicación y añadir a zmm1 y dar 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

VFNMADD132PS: Multiplica los valores de cuatro, ocho o dieciséis puntos flotantes de precisión única empaquetados de la primera fuente operando a los cuatro, ocho o dieciséis valores de punto flotante de precisión único en la tercera fuente operando, agrega el resultado intermedio de precisión infinita negada a los cuatro, ocho o dieciséis valores de punto flotante de precisión único empaquetado en la segunda fuente operanda, realiza redondeo y almacena los valores resultantes de precisión, ocho o dieciséis destino único empaquetado.

VFNMADD213PS: Multiplica los cuatro, ocho o dieciséis valores de punto flotante de precisión único empaquetados de la segunda fuente operand a los cuatro, ocho o dieciséis valores de punto flotante de precisión único en la primera fuente operand, añade el resultado intermedio de precisión infinita negada a los cuatro, ocho o dieciséis valores de punto flotante de precisión único en la tercera fuente operante, realiza redondeo y almacena los valores resultantes del destino de cuatro, ocho o dieciséis puntos.

VFNMADD231PS: Multiplica los cuatro, ocho o dieciséis valores de punto flotante de precisión único empaquetados de la segunda fuente operand a los cuatro, ocho o dieciséis valores de punto flotante de precisión única en la tercera fuente operand, añade el resultado intermedio de precisión infinita negada a los cuatro, ocho o dieciséis valores de punto flotante de precisión único empaquetado en la primera fuente operante, realiza redondeo y almacena los cuatro, ocho o dieciséis valores de precisión resultantes o dieciséis destinos y un solo empaquetados.

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 32 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 addition with infinite precision inputs and outputs (no
rounding).


VFNMADD132PS 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 := 32*i;
    DEST[n+31:n] := RoundFPControl_MXCSR(- (DEST[n+31:n]*SRC3[n+31:n]) + SRC2[n+31:n])
}
IF (VEX.128) THEN
    DEST[MAXVL-1:128] := 0
ELSEIF (VEX.256)
    DEST[MAXVL-1:256] := 0
FI
VFNMADD213PS 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 := 32*i;
    DEST[n+31:n] := RoundFPControl_MXCSR(- (SRC2[n+31:n]*DEST[n+31:n]) + SRC3[n+31:n])
}
IF (VEX.128) THEN
    DEST[MAXVL-1:128] := 0
ELSEIF (VEX.256)
    DEST[MAXVL-1:256] := 0
FI

VFNMADD231PS 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 := 32*i;
    DEST[n+31:n] := RoundFPControl_MXCSR(- (SRC2[n+31:n]*SRC3[n+31:n]) + DEST[n+31:n])
}
IF (VEX.128) THEN
    DEST[MAXVL-1:128] := 0
ELSEIF (VEX.256)
    DEST[MAXVL-1:256] := 0
FI


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

(KL, VL) = (4, 128), (8, 256), (16, 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 * 32

     IF k1[j] OR *no writemask*

          THEN DEST[i+31:i] :=

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

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

FOR j := 0 TO KL-1
    i := j * 32
    IF k1[j] OR *no writemask*
          THEN
                IF (EVEX.b = 1)
                      THEN
                            DEST[i+31:i] :=
                RoundFPControl_MXCSR(-(DEST[i+31:i]*SRC3[31:0]) + SRC2[i+31:i])
                      ELSE
                            DEST[i+31:i] :=
                RoundFPControl_MXCSR(-(DEST[i+31:i]*SRC3[i+31:i]) + SRC2[i+31:i])
                FI;

          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


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

(KL, VL) = (4, 128), (8, 256), (16, 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 * 32

     IF k1[j] OR *no writemask*

          THEN DEST[i+31:i] :=

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

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

FOR j := 0 TO KL-1
    i := j * 32
    IF k1[j] OR *no writemask*
          THEN
                IF (EVEX.b = 1)
                      THEN
                            DEST[i+31:i] :=
                RoundFPControl_MXCSR(-(SRC2[i+31:i]*DEST[i+31:i]) + SRC3[31:0])

                       ELSE

                       DEST[i+31:i] :=

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

                  FI;

          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


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

(KL, VL) = (4, 128), (8, 256), (16, 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 * 32

     IF k1[j] OR *no writemask*

          THEN DEST[i+31:i] :=

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

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

FOR j := 0 TO KL-1

     i := j * 32

     IF k1[j] OR *no writemask*

          THEN

                  IF (EVEX.b = 1)

                       THEN

                       DEST[i+31:i] :=

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

                       ELSE

                       DEST[i+31:i] :=

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

                  FI;

          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

Intel C/C++ compilador intrínseco

VFNMADDxxxPS __m512 _mm512_fnmadd_ps(__m512 a, __m512 b, __m512 c);
VFNMADDxxxPS __m512 _mm512_fnmadd_round_ps(__m512 a, __m512 b, __m512 c, int r);
VFNMADDxxxPS __m512 _mm512_mask_fnmadd_ps(__m512 a, __mmask16 k, __m512 b, __m512 c);
VFNMADDxxxPS __m512 _mm512_maskz_fnmadd_ps(__mmask16 k, __m512 a, __m512 b, __m512 c);
VFNMADDxxxPS __m512 _mm512_mask3_fnmadd_ps(__m512 a, __m512 b, __m512 c, __mmask16 k);
VFNMADDxxxPS __m512 _mm512_mask_fnmadd_round_ps(__m512 a, __mmask16 k, __m512 b, __m512 c, int r);
VFNMADDxxxPS __m512 _mm512_maskz_fnmadd_round_ps(__mmask16 k, __m512 a, __m512 b, __m512 c, int r);
VFNMADDxxxPS __m512 _mm512_mask3_fnmadd_round_ps(__m512 a, __m512 b, __m512 c, __mmask16 k, int r);
VFNMADDxxxPS __m256 _mm256_mask_fnmadd_ps(__m256 a, __mmask8 k, __m256 b, __m256 c);
VFNMADDxxxPS __m256 _mm256_maskz_fnmadd_ps(__mmask8 k, __m256 a, __m256 b, __m256 c);
VFNMADDxxxPS __m256 _mm256_mask3_fnmadd_ps(__m256 a, __m256 b, __m256 c, __mmask8 k);
VFNMADDxxxPS __m128 _mm_mask_fnmadd_ps(__m128 a, __mmask8 k, __m128 b, __m128 c);
VFNMADDxxxPS __m128 _mm_maskz_fnmadd_ps(__mmask8 k, __m128 a, __m128 b, __m128 c);
VFNMADDxxxPS __m128 _mm_mask3_fnmadd_ps(__m128 a, __m128 b, __m128 c, __mmask8 k);
VFNMADDxxxPS __m128 _mm_fnmadd_ps (__m128 a, __m128 b, __m128 c);
VFNMADDxxxPS __m256 _mm256_fnmadd_ps (__m256 a, __m256 b, __m256 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."

VFNMADD132PS, VFNMADD213PS, VFNMADD231PS

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