VFNMSUB132PS, VFNMSUB213PS, VFNMSUB231PS

Fused Negative Multiply-Subtract of

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`VEX.128.66.0F38.W0 9E /r`	`VFNMSUB132PS 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 restar xmm2 y poner resultado en xmm1.
`VEX.128.66.0F38.W0 AE /r`	`VFNMSUB213PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de xmm1 y xmm2, niegan el resultado de la multiplicación y restan xmm3/mem y ponen resultado en xmm1.
`VEX.128.66.0F38.W0 BE /r`	`VFNMSUB231PS 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 restar xmm1 y poner resultado en xmm1.
`VEX.256.66.0F38.W0 9E /r`	`VFNMSUB132PS 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 restar ymm2 y poner resultado en ymm1.
`VEX.256.66.0F38.W0 AE /r`	`VFNMSUB213PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de ymm1 y ymm2, niegan el resultado de la multiplicación y restan ymm3/mem y ponen resultado en ymm1.
`VEX.256.66.0F38.0 BE /r`	`VFNMSUB231PS 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 restar ymm1 y poner resultado en ymm1.
`EVEX.128.66.0F38.W0 9E /r`	`VFNMSUB132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiplyvalores en coma flotante de precisión simple empaquetados AVX512F) O dexmm1yxmm3/m128/m32bcst, negar elAVX10.1resultado de multiplicación y subtractoxmm2y poner resultado enxmm1.
`EVEX.128.66.0F38.W0 AE /r`	`VFNMSUB213PS 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 resultado AVX10.1 y restar xmm3/m128/m32bcst y poner resultado en xmm1.
`EVEX.128.66.0F38.W0 BE /r`	`VFNMSUB231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiplyvalores en coma flotante de precisión simple empaquetados AVX512F) O dexmm2yxmm3/m128/m32bcst, negar elAVX10.1multiplicación resultado subtract añadir axmm1y poner resultado enxmm1.
`EVEX.256.66.0F38.W0 9E /r`	`VFNMSUB132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst`	B	Valido	Valido	Multiplyvalores en coma flotante de precisión simple empaquetados AVX512F) O deymm1yymm3/m256/m32bcst, negar elAVX10.1resultado de multiplicación y subtractoymm2y poner resultado enymm1.
`EVEX.256.66.0F38.W0 AE /r`	`VFNMSUB213PS 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 resultado AVX10.1 y restar ymm3/m256/m32bcst y poner resultado en ymm1.
`EVEX.256.66.0F38.W0 BE /r`	`VFNMSUB231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst Opcode/ Instruction`	B	Valido	Valido	Multiplyvalores en coma flotante de precisión simple empaquetados AVX512F) O deymm2yymm3/m256/m32bcst, negar elAVX10.1multiplicación resultado subtract añadir aymm1y poner resultado enymm1. Op/ 64/3 2CPUIDMás información En Bit Supp Mode Flag ort
`EVEX.512.66.0F38.W0 9E /r`	`VFNMSUB132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`		b v	Valido	Multiply valores en coma flotante de precisión simple empaquetados OR AVX10. 1 de zmm1 y zmm3/m512/m32bcst, negar el resultado de la multiplicación y restar zmm2 y dar resultado en zmm1.
`EVEX.512.66.0F38.W0 AE /r`	`VFNMSUB213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`		b v	Valido	Multiply valores en coma flotante de precisión simple empaquetados OR AVX10. 1 de zmm1 y zmm2, negar el resultado de la multiplicación y restar zmm3/m512/m32bcst y poner resultado en zmm1.
`EVEX.512.66.0F38.W0 BE /r`	`VFNMSUB231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`		b v	Valido	Multiplyvalores en coma flotante de precisión simple empaquetadosOAVX10. 1 desdezmm2yzmm3/m512/m32bcst, negar el subtract del resultado de la multiplicación añadir azmm1y poner resultado enzmm1.

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

VFNMSUB132PS: Multiplica los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados del primer operando de origen a los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados en el tercer operando de origen. De los resultados intermedios de precisión infinita negada, resta los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados en el segundo operando de origen, realiza redondeo y almacena los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados al operando de destino (primer operando de origen).

VFNMSUB213PS: Multiplica los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados del segundo operando de origen a los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados en el primer operando de origen. De los resultados intermedios de precisión infinita negada, resta los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados en el tercer operando de origen, realiza redondeo y almacena los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados al operando de destino (primer operando de origen).

VFNMSUB231PS: Multiplica los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados de la segunda fuente a los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados en el tercer operando de origen. De los resultados intermedios de precisión infinita negada, resta los valores de cuatro, ocho o dieciséis puntos flotantes de precisión simple empaquetados en el primer operando de origen, realiza redondeo y almacena los cuatro, ocho o dieciséis valores en coma flotante de precisión simple empaquetados al operando de destino (primer operando de origen).

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


VFNMSUB132PS 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

VFNMSUB213PS 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

VFNMSUB231PS 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


VFNMSUB132PS 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

VFNMSUB132PS 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


VFNMSUB213PS 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_MXCSR(-(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

VFNMSUB213PS 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


VFNMSUB231PS 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_MXCSR(-(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

VFNMSUB231PS 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

VFNMSUBxxxPS __m512 _mm512_fnmsub_ps(__m512 a, __m512 b, __m512 c);
VFNMSUBxxxPS __m512 _mm512_fnmsub_round_ps(__m512 a, __m512 b, __m512 c, int r);
VFNMSUBxxxPS __m512 _mm512_mask_fnmsub_ps(__m512 a, __mmask16 k, __m512 b, __m512 c);
VFNMSUBxxxPS __m512 _mm512_maskz_fnmsub_ps(__mmask16 k, __m512 a, __m512 b, __m512 c);
VFNMSUBxxxPS __m512 _mm512_mask3_fnmsub_ps(__m512 a, __m512 b, __m512 c, __mmask16 k);
VFNMSUBxxxPS __m512 _mm512_mask_fnmsub_round_ps(__m512 a, __mmask16 k, __m512 b, __m512 c, int r);
VFNMSUBxxxPS __m512 _mm512_maskz_fnmsub_round_ps(__mmask16 k, __m512 a, __m512 b, __m512 c, int r);
VFNMSUBxxxPS __m512 _mm512_mask3_fnmsub_round_ps(__m512 a, __m512 b, __m512 c, __mmask16 k, int r);
VFNMSUBxxxPS __m256 _mm256_mask_fnmsub_ps(__m256 a, __mmask8 k, __m256 b, __m256 c);
VFNMSUBxxxPS __m256 _mm256_maskz_fnmsub_ps(__mmask8 k, __m256 a, __m256 b, __m256 c);
VFNMSUBxxxPS __m256 _mm256_mask3_fnmsub_ps(__m256 a, __m256 b, __m256 c, __mmask8 k);
VFNMSUBxxxPS __m128 _mm_mask_fnmsub_ps(__m128 a, __mmask8 k, __m128 b, __m128 c);
VFNMSUBxxxPS __m128 _mm_maskz_fnmsub_ps(__mmask8 k, __m128 a, __m128 b, __m128 c);
VFNMSUBxxxPS __m128 _mm_mask3_fnmsub_ps(__m128 a, __m128 b, __m128 c, __mmask8 k);
VFNMSUBxxxPS __m128 _mm_fnmsub_ps (__m128 a, __m128 b, __m128 c);
VFNMSUBxxxPS __m256 _mm256_fnmsub_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."

VFNMSUB132PS, VFNMSUB213PS, VFNMSUB231PS

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