VPBROADCAST

Carga Integer y Radiodifusión

estableVMJITAOTinstruccion

Codificaciones

Opcode	Instruccion	Op/En	64 bits	Compat/Legacy	Descripcion
`VEX.128.66.0F38.W0 78 /r`	`VPBROADCASTB xmm1, xmm2/m8`	A	Valido	Valido	Difusión de un entero de byte en el operando de origen a dieciséis lugares en xmm1.
`VEX.256.66.0F38.W0 78 /r`	`VPBROADCASTB ymm1, xmm2/m8`	A	Valido	Valido	Transmite un entero de byte en el operando de origen a treinta y dos lugares en ymm1.
`EVEX.128.66.0F38.W0 78 /r`	`VPBROADCASTB xmm1{k1}{z}, xmm2/m8`	B	Valido	Valido	Transmite un entero de byte en la fuente AVX512BW) OR AVX10.1 operando a lugares en xmm1 sujetos a máscara de escritura k1.
`EVEX.256.66.0F38.W0 78 /r`	`VPBROADCASTB ymm1{k1}{z}, xmm2/m8`	B	Valido	Valido	Transmite un entero de byte en la fuente AVX512BW) OR AVX10.1 operando a lugares en ymm1 sujetos a máscara de escritura k1.
`EVEX.512.66.0F38.W0 78 /r`	`VPBROADCASTB zmm1{k1}{z}, xmm2/m8`	B	Valido	Valido	Transmite un entero de byte en la fuente OR AVX10.1 operando a 64 lugares en zmm1 sujeto a máscara de escritura k1.
`VEX.128.66.0F38.W0 79 /r`	`VPBROADCASTW xmm1, xmm2/m16`	A	Valido	Valido	Transmite una palabra entero en el operando de origen a ocho lugares en xmm1.
`VEX.256.66.0F38.W0 79 /r`	`VPBROADCASTW ymm1, xmm2/m16`	A	Valido	Valido	Transmite una palabra entero en el operando de origen a dieciséis lugares en ymm1.
`EVEX.128.66.0F38.W0 79 /r`	`VPBROADCASTW xmm1{k1}{z}, xmm2/m16`	B	Valido	Valido	Transmite una palabra entero en la fuente AVX512BW) OR AVX10.1 operando a lugares en xmm1 sujetos a máscara de escritura k1.
`EVEX.256.66.0F38.W0 79 /r`	`VPBROADCASTW ymm1{k1}{z}, xmm2/m16`	B	Valido	Valido	Transmite una palabra entero en la fuente AVX512BW) OR AVX10.1 operando a lugares en ymm1 sujetos a máscara de escritura k1.
`EVEX.512.66.0F38.W0 79 /r`	`VPBROADCASTW zmm1{k1}{z}, xmm2/m16`	B	Valido	Valido	Transmitir una palabra entero en la fuente OR AVX10.1 operando a 32 lugares en zmm1 sujeto a máscara de escritura k1.
`VEX.128.66.0F38.W0 58 /r`	`VPBROADCASTD xmm1, xmm2/m32`	A	Valido	Valido	Difundir un número entero de palabras en el operando de origen a cuatro lugares en xmm1.
`VEX.256.66.0F38.W0 58 /r`	`VPBROADCASTD ymm1, xmm2/m32`	A	Valido	Valido	Difundir un número entero de palabras en el operando de origen a ocho lugares en ymm1.
`EVEX.128.66.0F38.W0 58 /r`	`VPBROADCASTD xmm1 {k1}{z}, xmm2/m32`	B	Valido	Valido	Difundir un número entero de palabras en la fuente AVX512F) OR AVX10.1 operand a lugares en xmm1 sujeto a escrituramask k1.
`EVEX.256.66.0F38.W0 58 /r`	`VPBROADCASTD ymm1 {k1}{z}, xmm2/m32`	B	Valido	Valido	Difundir un número entero de palabras en la fuente AVX512F) OR AVX10.1 operand a lugares en ymm1 sujeto a escrituramask k1.
`EVEX.512.66.0F38.W0 58 /r`	`VPBROADCASTD zmm1 {k1}{z}, xmm2/m32`	B	Valido	Valido	Transmitir un número entero de palabras en la fuente OR AVX10.1 operando a lugares en zmm1 sujeto a máscara de escritura k1.
`VEX.128.66.0F38.W0 59 /r`	`VPBROADCASTQ xmm1, xmm2/m64`	A	Valido	Valido	Difundir un elemento qword en operando de origen a dos lugares en xmm1.
`VEX.256.66.0F38.W0 59 /r`	`VPBROADCASTQ ymm1, xmm2/m64`	A	Valido	Valido	Difundir un elemento qword en operando de origen a cuatro lugares en ymm1.
`EVEX.128.66.0F38.W1 59 /r`	`VPBROADCASTQ xmm1 {k1}{z}, xmm2/m64 Opcode/ Instruction`	B	Valido	Valido	Transmite un elemento qword en la fuente AVX512F) OR AVX10.1 operando a lugares en xmm1 sujeto a máscara de escritura k1. Op / 64/32 CPUID Feat ure Descripción En bit M Suppo ode Flag rt
`EVEX.256.66.0F38.W1 59 /r`	`VPBROADCASTQ ymm1 {k1}{z}, xmm2/m64`	B	Valido	Valido	AND Broadcast un elemento qword en fuente AVX512F) O AVX10.1 R operand a lugares en ymm1 sujeto a escrituramask k1.
`EVEX.512.66.0F38.W1 59 /r`	`VPBROADCASTQ zmm1 {k1}{z}, xmm2/m64`	B	Valido	Valido	Difundir un elemento qword en la fuente OR AVX10.1 operando a lugares en zmm1 sujeto a máscara de escritura k1.
`EVEX.128.66.0F38.W0 59 /r`	`VBROADCASTI32x2 xmm1 {k1}{z}, xmm2/m64`	C	Valido	Valido	AND Broadcast dos elementos dword en fuente AVX512DQ) OR operando a lugares en xmm1 sujeto a AVX10.1 máscara de escritura k1.
`EVEX.256.66.0F38.W0 59 /r`	`VBROADCASTI32x2 ymm1 {k1}{z}, xmm2/m64`	C	Valido	Valido	AND Broadcast dos elementos dword en fuente AVX512DQ) OR operando a lugares en ymm1 sujeto a AVX10.1 máscara de escritura k1.
`EVEX.512.66.0F38.W0 59 /r`	`VBROADCASTI32x2 zmm1 {k1}{z}, xmm2/m64`	C	Valido	Valido	Difundir dos elementos dword en fuente OR AVX10.1 operando a lugares en zmm1 sujeto a máscara de escritura k1.
`VEX.256.66.0F38.W0 5A /r`	`VBROADCASTI128 ymm1, m128`	A	Valido	Valido	Transmite 128 bits de datos enteros en mem a bajo y alto 128 bits en ymm1.
`EVEX.256.66.0F38.W0 5A /r`	`VBROADCASTI32X4 ymm1 {k1}{z}, m128`	D	Valido	Valido	ANDTransmisión 128 bits de 4 integer de doble palabraAVX512F) O AVX10.1R data in mem to locations in memymm1utilizandomáscara de escritura k1.
`EVEX.512.66.0F38.W0 5A /r`	`VBROADCASTI32X4 zmm1 {k1}{z}, m128`	D	Valido	Valido	Transmitir 128 bits de 4 datos integer de doble palabra OR AVX10.1 en mem a ubicaciones en zmm1 usando máscara de escritura k1.
`EVEX.256.66.0F38.W1 5A /r`	`VBROADCASTI64X2 ymm1 {k1}{z}, m128`	C	Valido	Valido	ANDRadiodifusión 128 bits de 2 cuadword integerAVX512DQ) AVX10.1OR data in mem to locations in memymm1utilizandomáscara de escritura k1.
`EVEX.512.66.0F38.W1 5A /r`	`VBROADCASTI64X2 zmm1 {k1}{z}, m128`	C	Valido	Valido	Transmitir 128 bits de 2 datos integer OR AVX10.1 en mem a ubicaciones en zmm1 utilizando máscara de escritura k1.
`EVEX.512.66.0F38.W0 5B /r`	`VBROADCASTI32X8 zmm1 {k1}{z}, m256`	E	Valido	Valido	Radiodifusión 256 bits de 8 integer de doble palabra ORAVX10.1datos en mem a ubicaciones enzmm1utilizandomáscara de escritura k1.
`EVEX.512.66.0F38.W1 5B /r`	`VBROADCASTI64X4 zmm1 {k1}{z}, m256`	D	Valido	Valido	Radiodifusión 256 bits de 4 cuadword integer ORAVX10.1datos en mem a ubicaciones enzmm1utilizandomáscara de escritura 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

Cargando las mediciones de arch-data...

Descripción

Cargar datos enteros del operando de origen (el segundo operando) y transmitir a todos los elementos del operando de destino (el primer operando).

VEX256 codificado VPBROADCASTB/W/D/Q: El operando de origen es 8-bit, 16-bit, 32-bit, 64-bit ubicación de memoria o los datos bajos de 8-bit, 16-bit 32-bit, 64-bit en un registro XMM. El operando de destino es un registro YMM. VPBROAD- CASTI128 soporte el operando de origen de 128-bit ubicación de memoria. Registro código fuente para VPBROADCAS- TI128 está reservado y #UD. Bits (MAXVL-1:256) del registro de destino se ponen a cero.

EVEX-encoded VPBROADCASTD/Q: El operando de origen es una ubicación de memoria de 32 bits de 64 bits o los datos bajos de 32 bits de 64 bits en un registro XMM. El operando de destino es un registro ZMM/YMM/XMM actualizado según la máscara de escritura k1.

VPBROADCASTI32X4 y VPBROADCASTI64X4: El operando de destino es un registro ZMM y actualizado según la máscara de escritura k1. El operando de origen es 128-bit o 256-bit ubicación de memoria. Se reservan códigos fuente para VBROADCASTI32X4 y VBROADCASTI64X4 y #UD.

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

Si VPBROADCASTI128 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-16. VPBROADCASTD Operación (VEX.256 versión codificada)

                                                             m32      X0

DEST 0 0 0 0 X0 X0 X0 X0

Figura 5-17. VPBROADCASTD Operación (128-bit versión)

                                                       m64      X0

DEST X0 X0 X0 X0

Figura 5-18. VPBROADCASTQ Operación (256-bit versión)

                                                 m128       X0

DEST X0 X0

Figure 5-19. VBROADCASTI128 Operation (256-bit version)

                                                 m256       X0

DEST X0 X0

Figure 5-20. VBROADCASTI256 Operation (512-bit version)

Operación

VPBROADCASTB (EVEX encoded versions)

(KL, VL) = (16, 128), (32, 256), (64, 512)

FOR j := 0 TO KL-1

i := j * 8

IF k1[j] OR *no writemask*

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

     ELSE

             IF *merging-masking*           ; merging-masking

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

                 ELSE                       ; zeroing-masking

                    DEST[i+7:i] := 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPBROADCASTW (EVEX encoded versions)

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

FOR j := 0 TO KL-1

i := j * 16

IF k1[j] OR *no writemask*

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

     ELSE

             IF *merging-masking*           ; merging-masking

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

                 ELSE                       ; zeroing-masking

                    DEST[i+15:i] := 0

             FI

FI;

ENDFOR

DEST[MAXVL-1:VL] := 0

VPBROADCASTD (128 bit version)
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

VPBROADCASTD (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


VPBROADCASTD (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

VPBROADCASTQ (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

VPBROADCASTQ (EVEX encoded versions)

(KL, VL) = (2, 128), (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

VBROADCASTI32x2 (EVEX encoded versions)

(KL, VL) = (4, 128), (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

VBROADCASTI128 (VEX.256 encoded version)
temp := SRC[127:0]
DEST[127:0] := temp
DEST[255:128] := temp
DEST[MAXVL-1:256] := 0

VBROADCASTI32X4 (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

VBROADCASTI64X2 (EVEX encoded versions)

(KL, VL) = (8, 256), (16, 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;

VBROADCASTI32X8 (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

VBROADCASTI64X4 (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

VPBROADCASTB __m512i _mm512_broadcastb_epi8( __m128i a);
VPBROADCASTB __m512i _mm512_mask_broadcastb_epi8(__m512i s, __mmask64 k, __m128i a);
VPBROADCASTB __m512i _mm512_maskz_broadcastb_epi8( __mmask64 k, __m128i a);
VPBROADCASTB __m256i _mm256_broadcastb_epi8(__m128i a);
VPBROADCASTB __m256i _mm256_mask_broadcastb_epi8(__m256i s, __mmask32 k, __m128i a);
VPBROADCASTB __m256i _mm256_maskz_broadcastb_epi8( __mmask32 k, __m128i a);
VPBROADCASTB __m128i _mm_mask_broadcastb_epi8(__m128i s, __mmask16 k, __m128i a);
VPBROADCASTB __m128i _mm_maskz_broadcastb_epi8( __mmask16 k, __m128i a);
VPBROADCASTB __m128i _mm_broadcastb_epi8(__m128i a);
VPBROADCASTD __m512i _mm512_broadcastd_epi32( __m128i a);
VPBROADCASTD __m512i _mm512_mask_broadcastd_epi32(__m512i s, __mmask16 k, __m128i a);
VPBROADCASTD __m512i _mm512_maskz_broadcastd_epi32( __mmask16 k, __m128i a);
VPBROADCASTD __m256i _mm256_broadcastd_epi32( __m128i a);
VPBROADCASTD __m256i _mm256_mask_broadcastd_epi32(__m256i s, __mmask8 k, __m128i a);
VPBROADCASTD __m256i _mm256_maskz_broadcastd_epi32( __mmask8 k, __m128i a);
VPBROADCASTD __m128i _mm_broadcastd_epi32(__m128i a);
VPBROADCASTD __m128i _mm_mask_broadcastd_epi32(__m128i s, __mmask8 k, __m128i a);
VPBROADCASTD __m128i _mm_maskz_broadcastd_epi32( __mmask8 k, __m128i a);
VPBROADCASTQ __m512i _mm512_broadcastq_epi64( __m128i a);
VPBROADCASTQ __m512i _mm512_mask_broadcastq_epi64(__m512i s, __mmask8 k, __m128i a);
VPBROADCASTQ __m512i _mm512_maskz_broadcastq_epi64( __mmask8 k, __m128i a);
VPBROADCASTQ __m256i _mm256_broadcastq_epi64(__m128i a);
VPBROADCASTQ __m256i _mm256_mask_broadcastq_epi64(__m256i s, __mmask8 k, __m128i a);
VPBROADCASTQ __m256i _mm256_maskz_broadcastq_epi64( __mmask8 k, __m128i a);
VPBROADCASTQ __m128i _mm_broadcastq_epi64(__m128i a);
VPBROADCASTQ __m128i _mm_mask_broadcastq_epi64(__m128i s, __mmask8 k, __m128i a);
VPBROADCASTQ __m128i _mm_maskz_broadcastq_epi64( __mmask8 k, __m128i a);
VPBROADCASTW __m512i _mm512_broadcastw_epi16(__m128i a);
VPBROADCASTW __m512i _mm512_mask_broadcastw_epi16(__m512i s, __mmask32 k, __m128i a);
VPBROADCASTW __m512i _mm512_maskz_broadcastw_epi16( __mmask32 k, __m128i a);
VPBROADCASTW __m256i _mm256_broadcastw_epi16(__m128i a);
VPBROADCASTW __m256i _mm256_mask_broadcastw_epi16(__m256i s, __mmask16 k, __m128i a);
VPBROADCASTW __m256i _mm256_maskz_broadcastw_epi16( __mmask16 k, __m128i a);
VPBROADCASTW __m128i _mm_broadcastw_epi16(__m128i a);
VPBROADCASTW __m128i _mm_mask_broadcastw_epi16(__m128i s, __mmask8 k, __m128i a);
VPBROADCASTW __m128i _mm_maskz_broadcastw_epi16( __mmask8 k, __m128i a);
VBROADCASTI32x2 __m512i _mm512_broadcast_i32x2( __m128i a);
VBROADCASTI32x2 __m512i _mm512_mask_broadcast_i32x2(__m512i s, __mmask16 k, __m128i a);
VBROADCASTI32x2 __m512i _mm512_maskz_broadcast_i32x2( __mmask16 k, __m128i a);
VBROADCASTI32x2 __m256i _mm256_broadcast_i32x2( __m128i a);
VBROADCASTI32x2 __m256i _mm256_mask_broadcast_i32x2(__m256i s, __mmask8 k, __m128i a);
VBROADCASTI32x2 __m256i _mm256_maskz_broadcast_i32x2( __mmask8 k, __m128i a);
VBROADCASTI32x2 __m128i _mm_broadcast_i32x2(__m128i a);
VBROADCASTI32x2 __m128i _mm_mask_broadcast_i32x2(__m128i s, __mmask8 k, __m128i a);
VBROADCASTI32x2 __m128i _mm_maskz_broadcast_i32x2( __mmask8 k, __m128i a);
VBROADCASTI32x4 __m512i _mm512_broadcast_i32x4( __m128i a);
VBROADCASTI32x4 __m512i _mm512_mask_broadcast_i32x4(__m512i s, __mmask16 k, __m128i a);
VBROADCASTI32x4 __m512i _mm512_maskz_broadcast_i32x4( __mmask16 k, __m128i a);
VBROADCASTI32x4 __m256i _mm256_broadcast_i32x4( __m128i a);
VBROADCASTI32x4 __m256i _mm256_mask_broadcast_i32x4(__m256i s, __mmask8 k, __m128i a);
VBROADCASTI32x4 __m256i _mm256_maskz_broadcast_i32x4( __mmask8 k, __m128i a);
VBROADCASTI32x8 __m512i _mm512_broadcast_i32x8( __m256i a);
VBROADCASTI32x8 __m512i _mm512_mask_broadcast_i32x8(__m512i s, __mmask16 k, __m256i a);
VBROADCASTI32x8 __m512i _mm512_maskz_broadcast_i32x8( __mmask16 k, __m256i a);
VBROADCASTI64x2 __m512i _mm512_broadcast_i64x2( __m128i a);
VBROADCASTI64x2 __m512i _mm512_mask_broadcast_i64x2(__m512i s, __mmask8 k, __m128i a);
VBROADCASTI64x2 __m512i _mm512_maskz_broadcast_i64x2( __mmask8 k, __m128i a);
VBROADCASTI64x2 __m256i _mm256_broadcast_i64x2( __m128i a);
VBROADCASTI64x2 __m256i _mm256_mask_broadcast_i64x2(__m256i s, __mmask8 k, __m128i a);
VBROADCASTI64x2 __m256i _mm256_maskz_broadcast_i64x2( __mmask8 k, __m128i a);
VBROADCASTI64x4 __m512i _mm512_broadcast_i64x4( __m256i a);
VBROADCASTI64x4 __m512i _mm512_mask_broadcast_i64x4(__m512i s, __mmask8 k, __m256i a);
VBROADCASTI64x4 __m512i _mm512_maskz_broadcast_i64x4( __mmask8 k, __m256i a);

SIMD coma flotante Excepciones

None.

Otras excepciones

Instrucciones codificadas por EVEX, ver Tabla 2-23, "Tipo 6 Condiciones de Excepción".

Instrucciones codificadas por EVEX, sintaxis con reg/mem operando, ver Tabla 2-55, "Tipo E6 Condiciones de Excepción Clase".

Additionally:

#UD               If VEX.L = 0 for VPBROADCASTQ, VPBROADCASTI128.

If EVEX.L'L = 0 for VBROADCASTI32X4/VBROADCASTI64X2.

If EVEX.L'L < 10b for VBROADCASTI32X8/VBROADCASTI64X4.

VPBROADCAST

Codificaciones

Codificacion de operandos

A

B

C

D

E

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