VFMADD132PS, VFMADD213PS, VFMADD231PS

Fused Multiply-Add of Packed Single

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`VEX.128.66.0F38.W0 98 /r`	`VFMADD132PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de xmm1 y xmm3/mem, añadir a xmm2 y poner resultado en xmm1.
`VEX.128.66.0F38.W0 A8 /r`	`VFMADD213PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de xmm1 y xmm2, añadir a xmm3/mem y poner resultado en xmm1.
`VEX.128.66.0F38.W0 B8 /r`	`VFMADD231PS xmm1, xmm2, xmm3/m128`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de xmm2 y xmm3/mem, añadir a xmm1 y poner resultado en xmm1.
`VEX.256.66.0F38.W0 98 /r`	`VFMADD132PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de ymm1 y ymm3/mem, añadir a ymm2 y poner resultado en ymm1.
`VEX.256.66.0F38.W0 A8 /r`	`VFMADD213PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de ymm1 y ymm2, añadir a ymm3/mem y poner resultado en ymm1.
`VEX.256.66.0F38.0 B8 /r`	`VFMADD231PS ymm1, ymm2, ymm3/m256`	A	Valido	Valido	Multiply valores en coma flotante de precisión simple empaquetados de ymm2 y ymm3/mem, añadir a ymm1 y poner resultado en ymm1.
`EVEX.128.66.0F38.W0 98 /r`	`VFMADD132PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión simple AND AVX512F) valores de xmm1 y xmm3/m128/m32bcst, OR AVX10.1 añadir a xmm2 y poner resultado en xmm1.
`EVEX.128.66.0F38.W0 A8 /r`	`VFMADD213PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión simple AND AVX512F) los valores de xmm1 y xmm2, añadir a OR AVX10.1 xmm3/m128/m32bcst y poner el resultado en xmm1.
`EVEX.128.66.0F38.W0 B8 /r`	`VFMADD231PS xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión simple AND AVX512F) valores de xmm2 y xmm3/m128/m32bcst, OR AVX10.1 añadir a xmm1 y poner resultado en xmm1.
`EVEX.256.66.0F38.W0 98 /r`	`VFMADD132PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión simple AND AVX512F) valores de ymm1 y ymm3/m256/m32bcst, OR AVX10.1 añadir a ymm2 y poner resultado en ymm1.
`EVEX.256.66.0F38.W0 A8 /r`	`VFMADD213PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión simple AND AVX512F) los valores de ymm1 y ymm2, añadir a OR AVX10.1 ymm3/m256/m32bcst y poner el resultado en ymm1.
`EVEX.256.66.0F38.W0 B8 /r`	`VFMADD231PS ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcst`	B	Valido	Valido	Multiply packed coma flotante de precisión simple AND AVX512F) valores de ymm2 y ymm3/m256/m32bcst, OR AVX10.1 añadir a ymm1 y poner resultado en ymm1.
`EVEX.512.66.0F38.W0 98 /r`	`VFMADD132PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`	B	Valido	Valido	Multiply packed coma flotante de precisión simple OR AVX10.1 valores de zmm1 y zmm3/m512/m32bcst, añadir a zmm2 y dar resultado en zmm1.
`EVEX.512.66.0F38.W0 A8 /r`	`VFMADD213PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`	B	Valido	Valido	Multiply packed coma flotante de precisión simple OR AVX10.1 valores de zmm1 y zmm2, añadir a zmm3/m512/m32bcst y dar resultado en zmm1.
`EVEX.512.66.0F38.W0 B8 /r`	`VFMADD231PS zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcst{er}`	B	Valido	Valido	Multiply packed coma flotante de precisión simple OR AVX10.1 valores de zmm2 y zmm3/m512/m32bcst, 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

Realiza un conjunto de computación de SIMD multiadd en valores en coma flotante de precisión simple empaquetados usando tres operandos de origen y escribe los resultados multiadd en el operando de destino. El operando de destino es también el primer operando de origen. El segundo operando debe ser un registro SIMD. El tercer operando de origen puede ser un registro SIMD o una ubicación de memoria.

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

VFMADD213PS: Multiplica los cuatro, ocho o dieciséis valores de punto flotante de precisión individual empaquetados de la segunda fuente operand a los cuatro, ocho o dieciséis valores de punto flotante de precisión única en la primera fuente operand, añade el resultado intermedio de precisión infinita a los cuatro, ocho o dieciséis valores de punto flotante de precisión único empaquetado en la tercera fuente operante, realiza redondeo y almacena el resultado de los cuatro, ocho o dieciséis valores de precisión monopado a destino flotante

VFMADD231PS: Multiplica los cuatro, ocho o dieciséis valores de punto flotante de precisión individual empaquetados de la segunda fuente operand a los cuatro, ocho o dieciséis valores de punto flotante de precisión único en la tercera fuente operand, añade el resultado intermedio de precisión infinita 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 empaquetados de destino flotante de precisión.

EVEX versiones codificadas: El operando de destino (también primer operando de origen) es un registro ZMM y codificado en reg field. El segundo operando de origen es un registro ZMM y codificado en EVEX.vvvv. El tercer operando de origen es un registro ZMM, una ubicación de memoria de 512 bits, o un vector de 512 bits emitido 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).

VFMADD132PS DEST, SRC2, SRC3
IF (VEX.128) THEN

    MAXNUM := 4
ELSEIF (VEX.256)

    MAXNUM := 8
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

VFMADD213PS DEST, SRC2, SRC3
IF (VEX.128) THEN

    MAXNUM := 4
ELSEIF (VEX.256)

    MAXNUM := 8
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

VFMADD231PS DEST, SRC2, SRC3
IF (VEX.128) THEN

    MAXNUM := 4
ELSEIF (VEX.256)

    MAXNUM := 8
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

VFMADD132PS 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

VFMADD132PS 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

VFMADD213PS 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

VFMADD213PS 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

VFMADD231PS 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

VFMADD231PS 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

VFMADDxxxPS __m512 _mm512_fmadd_ps(__m512 a, __m512 b, __m512 c);
VFMADDxxxPS __m512 _mm512_fmadd_round_ps(__m512 a, __m512 b, __m512 c, int r);
VFMADDxxxPS __m512 _mm512_mask_fmadd_ps(__m512 a, __mmask16 k, __m512 b, __m512 c);
VFMADDxxxPS __m512 _mm512_maskz_fmadd_ps(__mmask16 k, __m512 a, __m512 b, __m512 c);
VFMADDxxxPS __m512 _mm512_mask3_fmadd_ps(__m512 a, __m512 b, __m512 c, __mmask16 k);
VFMADDxxxPS __m512 _mm512_mask_fmadd_round_ps(__m512 a, __mmask16 k, __m512 b, __m512 c, int r);
VFMADDxxxPS __m512 _mm512_maskz_fmadd_round_ps(__mmask16 k, __m512 a, __m512 b, __m512 c, int r);
VFMADDxxxPS __m512 _mm512_mask3_fmadd_round_ps(__m512 a, __m512 b, __m512 c, __mmask16 k, int r);
VFMADDxxxPS __m256 _mm256_mask_fmadd_ps(__m256 a, __mmask8 k, __m256 b, __m256 c);
VFMADDxxxPS __m256 _mm256_maskz_fmadd_ps(__mmask8 k, __m256 a, __m256 b, __m256 c);
VFMADDxxxPS __m256 _mm256_mask3_fmadd_ps(__m256 a, __m256 b, __m256 c, __mmask8 k);
VFMADDxxxPS __m128 _mm_mask_fmadd_ps(__m128 a, __mmask8 k, __m128 b, __m128 c);
VFMADDxxxPS __m128 _mm_maskz_fmadd_ps(__mmask8 k, __m128 a, __m128 b, __m128 c);
VFMADDxxxPS __m128 _mm_mask3_fmadd_ps(__m128 a, __m128 b, __m128 c, __mmask8 k);
VFMADDxxxPS __m128 _mm_fmadd_ps (__m128 a, __m128 b, __m128 c);
VFMADDxxxPS __m256 _mm256_fmadd_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."

VFMADD132PS, VFMADD213PS, VFMADD231PS

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