VBROADCAST

Carga con datos coma flotante de radiodifusión

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`VEX.128.66.0F38.W0 18 /r`	`VBROADCASTSS xmm1, m32`	A	Valido	Valido	Broadcast coma flotante de precisión simple elemento en mem a cuatro lugares en xmm1.
`VEX.256.66.0F38.W0 18 /r`	`VBROADCASTSS ymm1, m32`	A	Valido	Valido	Broadcast coma flotante de precisión simple elemento en mem a ocho lugares en ymm1.
`VEX.256.66.0F38.W0 19 /r`	`VBROADCASTSD ymm1, m64`	A	Valido	Valido	Broadcast coma flotante de precisión doble elemento en mem a cuatro lugares en ymm1.
`VEX.256.66.0F38.W0 1A /r`	`VBROADCASTF128 ymm1, m128`	A	Valido	Valido	Transmite 128 bits de datos coma flotante en mem a bajo y alto 128 bits en ymm1.
`VEX.128.66.0F38.W0 18/r`	`VBROADCASTSS xmm1, xmm2`	A	Valido	Valido	Transmite el elemento coma flotante de precisión simple bajo en el operando de origen a cuatro ubicaciones en xmm1.
`VEX.256.66.0F38.W0 18 /r`	`VBROADCASTSS ymm1, xmm2`	A	Valido	Valido	Difusión de bajo coma flotante de precisión simple elemento en el operando de origen a ocho lugares en ymm1.
`VEX.256.66.0F38.W0 19 /r`	`VBROADCASTSD ymm1, xmm2`	A	Valido	Valido	Difusión de bajo coma flotante de precisión doble elemento en el operando de origen a cuatro lugares en ymm1.
`EVEX.256.66.0F38.W1 19 /r`	`VBROADCASTSD ymm1 {k1}{z}, xmm2/m64`	B	Valido	Valido	Broadcast bajo coma flotante de precisión doble AVX512F) O elemento en xmm2/m64 a cuatro ubicaciones en AVX10.1 ymm1 usando máscara de escritura k1.
`EVEX.512.66.0F38.W1 19 /r`	`VBROADCASTSD zmm1 {k1}{z}, xmm2/m64`	B	Valido	Valido	Broadcast bajo coma flotante de precisión doble OR AVX10.1 elemento en xmm2/m64 a ocho lugares en zmm1 utilizando máscara de escritura k1.
`EVEX.256.66.0F38.W0 19 /r`	`VBROADCASTF32X2 ymm1 {k1}{z}, xmm2/m64`	C	Valido	Valido	Transmisión de dos elementos coma flotante de precisión simple AVX512DQ) OR en xmm2/m64 a lugares en ymm1 AVX10.1 utilizando máscara de escritura k1.
`EVEX.512.66.0F38.W0 19 /r`	`VBROADCASTF32X2 zmm1 {k1}{z}, xmm2/m64`	C	Valido	Valido	Transmite dos elementos coma flotante de precisión simple OR AVX10.1 en xmm2/m64 a lugares en zmm1 utilizando máscara de escritura k1.
`EVEX.128.66.0F38.W0 18 /r`	`VBROADCASTSS xmm1 {k1}{z}, xmm2/m32`	B	Valido	Valido	Broadcast bajo coma flotante de precisión simple AVX512F) O elemento en xmm2/m32 a todos los lugares en xmm1 AVX10.1 utilizando máscara de escritura k1.
`EVEX.256.66.0F38.W0 18 /r`	`VBROADCASTSS ymm1 {k1}{z}, xmm2/m32`	B	Valido	Valido	Broadcast bajo coma flotante de precisión simple AVX512F) O elemento en xmm2/m32 a todos los lugares en ymm1 AVX10.1 utilizando máscara de escritura k1.
`EVEX.512.66.0F38.W0 18 /r`	`VBROADCASTSS zmm1 {k1}{z}, xmm2/m32`	B	Valido	Valido	Broadcast bajo coma flotante de precisión simple OR AVX10.1 elemento en xmm2/m32 a todos los lugares en zmm1 utilizando máscara de escritura k1.
`EVEX.256.66.0F38.W0 1A /r`	`VBROADCASTF32X4 ymm1 {k1}{z}, m128`	D	Valido	Valido	Transmite 128 bits de 4 datos AVX512F de precisión simple) OR coma flotante en mem a ubicaciones en ymm1 AVX10.1 utilizando máscara de escritura k1.
`EVEX.512.66.0F38.W0 1A /r`	`VBROADCASTF32X4 zmm1 {k1}{z}, m128`	D	Valido	Valido	Transmite 128 bits de 4 datos de precisión simple OR AVX10.1 coma flotante en mem a ubicaciones en zmm1 utilizando máscara de escritura k1.
`EVEX.256.66.0F38.W1 1A /r`	`VBROADCASTF64X2 ymm1 {k1}{z}, m128 Opcode/ Instruction`	C	Valido	Valido	Transmisión 128 bits de 2 datos de doble precisión AVX512DQ) OR coma flotante en mem a ubicaciones en ymm1 AVX10.1 usando máscara de escritura k1. Op / 64/32 CPUID Característica Descripción En Modo de bits Soporte Bandera de soporte
`EVEX.512.66.0F38.W1 1A /r`	`VBROADCASTF64X2 zmm1 {k1}{z}, m128`	C	Valido	Valido	Transmite 128 bits de 2 datos de doble precisión OR AVX10.1 coma flotante en mem a ubicaciones en zmm1 usando máscara de escritura k1.
`EVEX.512.66.0F38.W0 1B /r`	`VBROADCASTF32X8 zmm1 {k1}{z}, m256`	E	Valido	Valido	Broadcast 256 bits of 8 single accuracy OR AVX10.1 datos de punto flotante en mem a ubicaciones en zmm1 usando Writemask k1.
`EVEX.512.66.0F38.W1 1B /r`	`VBROADCASTF64X4 zmm1 {k1}{z}, m256`	D	Valido	Valido	Transmitir 256 bits de 4 datos de doble precisión OR AVX10.1 de punto flotante en mem a ubicaciones en zmm1 utilizando scriptmask 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

modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
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 escriturabyte ModRM, campo reg (bits 5-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: Tuple1 Scalar

C

modrm.reg escriturabyte ModRM, campo reg (bits 5-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: Tuple2

D

modrm.reg escriturabyte ModRM, campo reg (bits 5-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: Tuple4

E

modrm.reg escriturabyte ModRM, campo reg (bits 5-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: Tuple8

Coste medido

Sin medir: no se ejecuta en procesadores de 64 bits.

Descripción

VBROADCASTSD/VBROADCASTSS/VBROADCASTF128 carga valores en coma flotante como un tuple del operando de origen (segundo operando) en memoria y transmitido a todos los elementos del operando de destino (primer operando).

VEX256-versiones codificadas: El operando de destino es un registro YMM. El operando de origen es una ubicación de memoria de 32 bits, 64 bits o 128 bits. Las codificación de fuentes registradas están reservadas y #UD. Bits (MAXVL-1:256) del registro de destino se ponen a cero.

EVEX-versiones codificadas: El operando de destino es un registro ZMM/YMM/XMM actualizado según la máscara de escritura k1. El operando de origen es una ubicación de memoria de 32 bits, de 64 bits o el elemento de palabra doble/cuadword baja de un registro XMM.

VBROADCASTF32X2/VBROADCASTF32X4/VBROADCASTF64X2/VBROADCASTF32X8/VBROADCASTF64X4 carga valores en coma flotante como tuples del operando de origen (el segundo operando) en memoria o registro y transmisión a todos los elementos del operando de destino (el primer operando). El operando de destino es un registro YMM/ZMM actualizado según la máscara de escritura k1. El operando de origen es un registro o 64-bit/128-bit/256-bit ubicación de memoria.

VBROADCASTSD y VBROADCASTF128,F32x4 y F64x2 solo están soportados como versiones de 256 bits y 512 bits de ancho y arriba. VBROADCASTSS es compatible con versiones de 128 bits, 256 bits y 512 bits de ancho. F32x8 y F64x4 solo son compatibles con versiones de 512 bits de ancho.

VBROADCASTF32X2/VBROADCASTF32X4/VBROADCASTF32X8 have 32-bit granularity. VBROADCASTF64X2 and VBROADCASTF64X4 have 64-bit granularity.

Nota: VEX.vvvv y EVEX.vvvv están reservados y deben ser 1111b instrucciones de lo contrario #UD.

Si VBROADCASTSD o VBROADCASTF128 está codificado con VEX.L= 0, un intento de ejecutar la instrucción codificada con VEX.L= 0 causará una excepción #UD.

                                                                            m32          X0

DEST X0 X0 X0 X0 X0 X0 X0 X0

Figura 5-1. VBROADCASTSS Operación (VEX.256 versión codificada)

                                                                            m32          X0

DEST 0 0 0 0 X0 X0 X0 X0

Figura 5-2. Operación VBROADCASTSS (versión VEX.128-bit)

                                                                   m64               X0

DEST X0 X0 X0 X0

Figura 5-3. Operación VBROADCASTSD (versión VEX.256-bit)

                                                         m128           X0

DEST X0 X0

Figure 5-4. VBROADCASTF128 Operation (VEX.256-bit version)

                                                        m256            X0

                    DEST                 X0                             X0

Figura 5-5. VBROADCASTF64X4 Operación (512-bit versión con máscara de escritura todos 1s)

Operación

VBROADCASTSS (128-bit Version VEX and Legacy)
temp := SRC[31:0]
DEST[31:0] := temp
DEST[63:32] := temp
DEST[95:64] := temp
DEST[127:96] := temp
DEST[MAXVL-1:128] := 0

VBROADCASTSS (VEX.256 Encoded Version)
temp := SRC[31:0]
DEST[31:0] := temp
DEST[63:32] := temp
DEST[95:64] := temp
DEST[127:96] := temp
DEST[159:128] := temp
DEST[191:160] := temp
DEST[223:192] := temp
DEST[255:224] := temp
DEST[MAXVL-1:256] := 0

VBROADCASTSS (EVEX Encoded Versions)

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

FOR j := 0 TO KL-1

i := j * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := SRC[31:0]

     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


VBROADCASTSD (VEX.256 Encoded Version)
temp := SRC[63:0]
DEST[63:0] := temp
DEST[127:64] := temp
DEST[191:128] := temp
DEST[255:192] := temp
DEST[MAXVL-1:256] := 0

VBROADCASTSD (EVEX Encoded Versions)

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

FOR j := 0 TO KL-1

i := j * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := SRC[63:0]

     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

VBROADCASTF32x2 (EVEX Encoded Versions)

(KL, VL) = (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j * 32

n := (j mod 2) * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := SRC[n+31:n]

     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

VBROADCASTF128 (VEX.256 Encoded Version)
temp := SRC[127:0]
DEST[127:0] := temp
DEST[255:128] := temp
DEST[MAXVL-1:256] := 0


VBROADCASTF32X4 (EVEX Encoded Versions)

(KL, VL) = (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j* 32

n := (j modulo 4) * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := SRC[n+31:n]

     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

VBROADCASTF64X2 (EVEX Encoded Versions)

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

FOR j := 0 TO KL-1

i := j * 64

n := (j modulo 2) * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := SRC[n+63:n]

     ELSE

             IF *merging-masking*                    ; merging-masking

                  THEN *DEST[i+63:i] remains unchanged*

                  ELSE                               ; zeroing-masking

                    DEST[i+63:i] = 0

             FI

FI;

ENDFOR;

VBROADCASTF32X8 (EVEX.U1.512 Encoded Version)

FOR j := 0 TO 15

i := j * 32

n := (j modulo 8) * 32

IF k1[j] OR *no writemask*

     THEN DEST[i+31:i] := SRC[n+31:n]

     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


VBROADCASTF64X4 (EVEX.512 Encoded Version)

FOR j := 0 TO 7

i := j * 64

n := (j modulo 4) * 64

IF k1[j] OR *no writemask*

     THEN DEST[i+63:i] := SRC[n+63:n]

     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

VBROADCASTF32x2 __m512 _mm512_broadcast_f32x2( __m128 a);
VBROADCASTF32x2 __m512 _mm512_mask_broadcast_f32x2(__m512 s, __mmask16 k, __m128 a);
VBROADCASTF32x2 __m512 _mm512_maskz_broadcast_f32x2( __mmask16 k, __m128 a);
VBROADCASTF32x2 __m256 _mm256_broadcast_f32x2( __m128 a);
VBROADCASTF32x2 __m256 _mm256_mask_broadcast_f32x2(__m256 s, __mmask8 k, __m128 a);
VBROADCASTF32x2 __m256 _mm256_maskz_broadcast_f32x2( __mmask8 k, __m128 a);
VBROADCASTF32x4 __m512 _mm512_broadcast_f32x4( __m128 a);
VBROADCASTF32x4 __m512 _mm512_mask_broadcast_f32x4(__m512 s, __mmask16 k, __m128 a);
VBROADCASTF32x4 __m512 _mm512_maskz_broadcast_f32x4( __mmask16 k, __m128 a);
VBROADCASTF32x4 __m256 _mm256_broadcast_f32x4( __m128 a);
VBROADCASTF32x4 __m256 _mm256_mask_broadcast_f32x4(__m256 s, __mmask8 k, __m128 a);
VBROADCASTF32x4 __m256 _mm256_maskz_broadcast_f32x4( __mmask8 k, __m128 a);
VBROADCASTF32x8 __m512 _mm512_broadcast_f32x8( __m256 a);
VBROADCASTF32x8 __m512 _mm512_mask_broadcast_f32x8(__m512 s, __mmask16 k, __m256 a);
VBROADCASTF32x8 __m512 _mm512_maskz_broadcast_f32x8( __mmask16 k, __m256 a);
VBROADCASTF64x2 __m512d _mm512_broadcast_f64x2( __m128d a);
VBROADCASTF64x2 __m512d _mm512_mask_broadcast_f64x2(__m512d s, __mmask8 k, __m128d a);
VBROADCASTF64x2 __m512d _mm512_maskz_broadcast_f64x2( __mmask8 k, __m128d a);
VBROADCASTF64x2 __m256d _mm256_broadcast_f64x2( __m128d a);
VBROADCASTF64x2 __m256d _mm256_mask_broadcast_f64x2(__m256d s, __mmask8 k, __m128d a);
VBROADCASTF64x2 __m256d _mm256_maskz_broadcast_f64x2( __mmask8 k, __m128d a);
VBROADCASTF64x4 __m512d _mm512_broadcast_f64x4( __m256d a);
VBROADCASTF64x4 __m512d _mm512_mask_broadcast_f64x4(__m512d s, __mmask8 k, __m256d a);
VBROADCASTF64x4 __m512d _mm512_maskz_broadcast_f64x4( __mmask8 k, __m256d a);
VBROADCASTSD __m512d _mm512_broadcastsd_pd( __m128d a);
VBROADCASTSD __m512d _mm512_mask_broadcastsd_pd(__m512d s, __mmask8 k, __m128d a);
VBROADCASTSD __m512d _mm512_maskz_broadcastsd_pd(__mmask8 k, __m128d a);
VBROADCASTSD __m256d _mm256_broadcastsd_pd(__m128d a);
VBROADCASTSD __m256d _mm256_mask_broadcastsd_pd(__m256d s, __mmask8 k, __m128d a);
VBROADCASTSD __m256d _mm256_maskz_broadcastsd_pd( __mmask8 k, __m128d a);
VBROADCASTSD __m256d _mm256_broadcast_sd(double *a);
VBROADCASTSS __m512 _mm512_broadcastss_ps( __m128 a);
VBROADCASTSS __m512 _mm512_mask_broadcastss_ps(__m512 s, __mmask16 k, __m128 a);
VBROADCASTSS __m512 _mm512_maskz_broadcastss_ps( __mmask16 k, __m128 a);
VBROADCASTSS __m256 _mm256_broadcastss_ps(__m128 a);
VBROADCASTSS __m256 _mm256_mask_broadcastss_ps(__m256 s, __mmask8 k, __m128 a);
VBROADCASTSS __m256 _mm256_maskz_broadcastss_ps( __mmask8 k, __m128 a);
VBROADCASTSS __m128 _mm_broadcastss_ps(__m128 a);
VBROADCASTSS __m128 _mm_mask_broadcastss_ps(__m128 s, __mmask8 k, __m128 a);
VBROADCASTSS __m128 _mm_maskz_broadcastss_ps( __mmask8 k, __m128 a);
VBROADCASTSS __m128 _mm_broadcast_ss(float *a);
VBROADCASTSS __m256 _mm256_broadcast_ss(float *a);
VBROADCASTF128 __m256 _mm256_broadcast_ps(__m128 * a);
VBROADCASTF128 __m256d _mm256_broadcast_pd(__m128d * a);

Fuentes

Esta instruccion en el manual de Intel