Vesta
Español
Código fuente

PADDB, PADDW, PADDD, PADDQ

Añadir Packed Integers

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F FC /r1PADDB mm, mm/m64AValidoValidoAñadir los enteros de byte empaquetados de mm/m64 y mm.
NP 0F FD /r1PADDW mm, mm/m64AValidoValidoAñadir enteros de palabras empaquetadas de mm/m64 y mm.
NP 0F FE /r1PADDD mm, mm/m64AValidoValidoAgregue los enteros de doble palabra empaquetados de mm/m64 y mm.
NP 0F D4 /r1PADDQ mm, mm/m64AValidoValidoAgregue los enteros de cuádrupla embalados de mm/m64 y mm.
66 0F FC /rPADDB xmm1, xmm2/m128AValidoValidoAñadir los enteros de byte empaquetados de xmm2/m128 y xmm1.
66 0F FD /rPADDW xmm1, xmm2/m128AValidoValidoAñadir enteros de palabras empaquetados de xmm2/m128 y xmm1.
66 0F FE /rPADDD xmm1, xmm2/m128AValidoValidoAgregue los enteros de doble palabra empaquetados de xmm2/m128 y xmm1.
66 0F D4 /rPADDQ xmm1, xmm2/m128AValidoValidoAñadir los enteros de cuádpago empaquetados de xmm2/m128 y xmm1.
VEX.128.66.0F.WIG FC /rVPADDB xmm1, xmm2, xmm3/m128BValidoValidoAñadir los enteros de byte empaquetados de xmm2, y xmm3/m128 y almacenar en xmm1.
VEX.128.66.0F.WIG FD /rVPADDW xmm1, xmm2, xmm3/m128BValidoValidoAñadir enteros de palabras empaquetadas de xmm2, xmm3/m128 y almacenar en xmm1.
VEX.128.66.0F.WIG FE /rVPADDD xmm1, xmm2, xmm3/m128BValidoValidoAgregue enteros de doble palabra empaquetados de xmm2, xmm3/m128 y almacene en xmm1.
VEX.128.66.0F.WIG D4 /rVPADDQ xmm1, xmm2, xmm3/m128BValidoValidoAgregue los enteros de cuádruple llenos de xmm2, xmm3/m128 y almacene en xmm1.
VEX.256.66.0F.WIG FC /rVPADDB ymm1, ymm2, ymm3/m256BValidoValidoAñadir los enteros de byte empaquetados de ymm2, y ymm3/m256 y almacenar en ymm1.
VEX.256.66.0F.WIG FD /rVPADDW ymm1, ymm2, ymm3/m256BValidoValidoAñadir enteros de palabras empaquetadas de ymm2, ymm3/m256 y almacenar en ymm1.
VEX.256.66.0F.WIG FE /rVPADDD ymm1, ymm2, ymm3/m256BValidoValidoAgregue enteros de doble palabra empaquetados de ymm2, ymm3/m256 y almacene en ymm1.
VEX.256.66.0F.WIG D4 /rVPADDQ ymm1, ymm2, ymm3/m256BValidoValidoAgregue los enteros de cuádruple llenos de ymm2, ymm3/m256 y almacene en ymm1.
EVEX.128.66.0F.WIG FC /rVPADDB xmm1 {k1}{z}, xmm2, xmm3/m128CValidoValidoAñadir los enteros empacados de byte de xmm2, y AVX512BW) OR xmm3/m128 y almacenar en xmm1 utilizando máscara de escritura AVX10.1 k1.
EVEX.128.66.0F.WIG FD /rVPADDW xmm1 {k1}{z}, xmm2, xmm3/m128CValidoValidoAñadir enteros de palabras empaquetadas de xmm2, y AVX512BW) OR xmm3/m128 y almacenar en xmm1 utilizando máscara de escritura AVX10.1 k1.
EVEX.128.66.0F.W0 FE /rVPADDD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstDValidoValidoAgregue los enteros de doble palabra de xmm2 y AVX512F) OR xmm3/m128/m32bcst y almacene en xmm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.128.66.0F.W1 D4 /rVPADDQ xmm1 {k1}{z}, xmm2, xmm3/m128/m64bcst Opcode/ Op Instruction EnDValidoValidoAñadir los enteros de cuadrapado de xmm2 y AVX512F) OR xmm3/m128/m64bcst y almacenar en xmm1 utilizando AVX10.1 máscara de escritura k1. / 64/32 bit CPUID Característica Descripción Modo Soporte Bandera de soporte
EVEX.256.66.0F.WIG FC /rVPADDB ymm1 {k1}{z}, ymm2, ymm3/m256CValidoValidoAñadir los enteros empacados de byte de ymm2, y AVX512BW) OR ymm3/m256 y almacenar en ymm1 utilizando máscara de escritura AVX10.1 k1.
EVEX.256.66.0F.WIG FD /rVPADDW ymm1 {k1}{z}, ymm2, ymm3/m256CValidoValidoAñadir enteros de palabras empaquetadas de ymm2, y AVX512BW) OR ymm3/m256 y almacenar en ymm1 utilizando máscara de escritura AVX10.1 k1.
EVEX.256.66.0F.W0 FE /rVPADDD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstDValidoValidoAñada los enteros de doble palabra empaquetados de ymm2, AVX512F) OR ymm3/m256/m32bcst y almacene en ymm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.256.66.0F.W1 D4 /rVPADDQ ymm1 {k1}{z}, ymm2, ymm3/m256/m64bcstDValidoValidoAgregue los enteros de cuadriláteros de ymm2, AVX512F) OR ymm3/m256/m64bcst y almacene en ymm1 utilizando AVX10.1 máscara de escritura k1.
EVEX.512.66.0F.WIG FC /rVPADDB zmm1 {k1}{z}, zmm2, zmm3/m512CValidoValidoAgregue los enteros empaquetados de zmm2 y OR AVX10.1 zmm3/m512 y almacene en zmm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.WIG FD /rVPADDW zmm1 {k1}{z}, zmm2, zmm3/m512CValidoValidoAñadir enteros de palabras empaquetadas de zmm2, y OR AVX10.1 zmm3/m512 y almacenar en zmm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.W0 FE /rVPADDD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstDValidoValidoAgregue los enteros de doble palabra empaquetados de zmm2, OR AVX10.1 zmm3/m512/m32bcst y almacene en zmm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.W1 D4 /rVPADDQ zmm1 {k1}{z}, zmm2, zmm3/m512/m64bcstDValidoValidoAgregue los enteros de cuadriláteros de zmm2, OR AVX10.1 zmm3/m512/m64bcst y almacene en zmm1 utilizando má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

  1. modrm.reg lectura y escriturabyte ModRM, campo reg (bits 5-3)
  2. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

B

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. vex.vvvv lecturaprefijo VEX, campo vvvv (invertido)
  3. modrm.rm lecturabyte ModRM, campo r/m (bits 2-0); con el byte SIB y el desplazamiento cuando el campo mod los pide

C

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. evex.vvvv lecturaprefijo EVEX, campo vvvv (invertido)
  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: Full Mem

D

  1. modrm.reg escriturabyte ModRM, campo reg (bits 5-3)
  2. evex.vvvv lecturaprefijo EVEX, campo vvvv (invertido)
  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: Full

Coste medido

Cargando las mediciones de arch-data...

Descripción

Realiza una adición SIMD de los enteros empaquetados del operando de origen (segundo operando) y el operando de destino (primer operando), y almacena los resultados del entero empaquetado en el operando de destino. Ver Figura 9-4 en Intel(R) 64 e IA-32 Architectures Software Developer's Manual, Volumen 1, para una ilustración de una operación SIMD. El desbordamiento se maneja con envoltura, como se describe en los párrafos siguientes.

Las instrucciones PADDB y VPADDB añaden enteros de byte del primer operando de origen y segundo operando de origen y almacenan los resultados de enteros empaquetados en el operando de destino. Cuando un resultado individual es demasiado grande para ser representado en 8 bits (sobreflujo), el resultado se envuelve alrededor y los 8 bits bajos se escriben al operando de destino (es decir, el porte es ignorado).

Las instrucciones PADDW y VPADDW añaden enteros de palabras empaquetados del primer operando de origen y segundo operando de origen y almacenan los resultados de enteros empaquetados en el operando de destino. Cuando un resultado individual es demasiado grande

estar representado en 16 bits (sobreflujo), el resultado se envuelve alrededor y los 16 bits bajos se escriben al operando de destino (es decir, el porte es ignorado).

Las instrucciones de PADDD y VPADDD añaden enteros de doble palabra del primer operando de origen y segundo operando de origen y almacenan los resultados del entero empaquetado en el operando de destino. Cuando un resultado individual es demasiado grande para ser representado en 32 bits (sobreflujo), el resultado se envuelve alrededor y los 32 bits bajos se escriben al operando de destino (es decir, el porte es ignorado).

Las instrucciones de PADDQ y VPADDQ agregan enteros de cuadripado del primer operando de origen y segundo operando de origen y almacenan los resultados de enteros empaquetados en el operando de destino. Cuando un resultado de cuádword es demasiado grande para ser representado en 64 bits (sobreflujo), el resultado se envuelve alrededor y los 64 bits bajos se escriben al operando de destino (es decir, el porte es ignorado).

Tenga en cuenta que las instrucciones (V)PADDB, (V)PADDW, (V)PADDD y (V)PADDQ pueden funcionar en los enteros empaquetados o no firmados (notación de dos complementos), sin embargo, no establece bits en el registro EFLAGS para indicar el desbordamiento y/o una carga. Para evitar condiciones de desbordamiento no detectadas, el software debe controlar los rangos de valores operados en.

EVEX codificado VPADDD/Q: El primer operando de origen es un registro ZMM/YMM/XMM. El segundo operando de origen es un registro ZMM/YMM/XMM, 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/64-bit. El operando de destino es un registro ZMM/YMM/XMM actualizado según la máscara de escritura.

EVEX codificado VPADDB/W: El primer operando de origen es un registro ZMM/YMM/XMM. El segundo operando de origen es un registro ZMM/YMM/XMM, un 512/256/128-bit ubicación de memoria. El operando de destino es un registro ZMM/YMM/XMM actualizado según la máscara de escritura.

VEX.256 versión codificada: El primer operando de origen es un registro YMM. El segundo operando de origen es un registro YMM o una ubicación de memoria de 256 bits. El operando de destino es un registro YMM. los bits superiores (MAXVL-1:256) del destino se limpian.

VEX.128 versión codificada: El primer operando de origen es un registro XMM. El segundo operando de origen es un registro XMM o 128 bits ubicación de memoria. El operando de destino es un registro XMM. Los bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente se ponen a cero.

128-bit Legacy SSE versión: El primer operando de origen es un registro XMM. El segundo operando puede ser un registro XMM o una ubicación de memoria de 128 bits. El destino no es distinto del registro XMM de primera fuente y los bits superiores (MAXVL-1:128) del destino de registro ZMM correspondiente no son modificados.

Operación

PADDB (With 64-bit Operands)
    DEST[7:0] := DEST[7:0] + SRC[7:0];
    (* Repeat add operation for 2nd through 7th byte *)
    DEST[63:56] := DEST[63:56] + SRC[63:56];

PADDW (With 64-bit Operands)
    DEST[15:0] := DEST[15:0] + SRC[15:0];
    (* Repeat add operation for 2nd and 3th word *)
    DEST[63:48] := DEST[63:48] + SRC[63:48];

PADDD (With 64-bit Operands)
    DEST[31:0] := DEST[31:0] + SRC[31:0];
    DEST[63:32] := DEST[63:32] + SRC[63:32];

PADDQ (With 64-Bit Operands)
    DEST[63:0] := DEST[63:0] + SRC[63:0];


PADDB (Legacy SSE Instruction)
    DEST[7:0] := DEST[7:0] + SRC[7:0];
    (* Repeat add operation for 2nd through 15th byte *)
    DEST[127:120] := DEST[127:120] + SRC[127:120];
    DEST[MAXVL-1:128] (Unmodified)

PADDW (Legacy SSE Instruction)
    DEST[15:0] := DEST[15:0] + SRC[15:0];
    (* Repeat add operation for 2nd through 7th word *)
    DEST[127:112] := DEST[127:112] + SRC[127:112];
    DEST[MAXVL-1:128] (Unmodified)

PADDD (Legacy SSE Instruction)
    DEST[31:0] := DEST[31:0] + SRC[31:0];
    (* Repeat add operation for 2nd and 3th doubleword *)
    DEST[127:96] := DEST[127:96] + SRC[127:96];
    DEST[MAXVL-1:128] (Unmodified)

PADDQ (Legacy SSE Instruction)
    DEST[63:0] := DEST[63:0] + SRC[63:0];
    DEST[127:64] := DEST[127:64] + SRC[127:64];
    DEST[MAXVL-1:128] (Unmodified)

VPADDB (VEX.128 Encoded Instruction)
    DEST[7:0] := SRC1[7:0] + SRC2[7:0];
    (* Repeat add operation for 2nd through 15th byte *)
    DEST[127:120] := SRC1[127:120] + SRC2[127:120];
    DEST[MAXVL-1:128] := 0;

VPADDW (VEX.128 Encoded Instruction)
    DEST[15:0] := SRC1[15:0] + SRC2[15:0];
    (* Repeat add operation for 2nd through 7th word *)
    DEST[127:112] := SRC1[127:112] + SRC2[127:112];
    DEST[MAXVL-1:128] := 0;

VPADDD (VEX.128 Encoded Instruction)
    DEST[31:0] := SRC1[31:0] + SRC2[31:0];
    (* Repeat add operation for 2nd and 3th doubleword *)
    DEST[127:96] := SRC1[127:96] + SRC2[127:96];
    DEST[MAXVL-1:128] := 0;

VPADDQ (VEX.128 Encoded Instruction)
    DEST[63:0] := SRC1[63:0] + SRC2[63:0];
    DEST[127:64] := SRC1[127:64] + SRC2[127:64];
    DEST[MAXVL-1:128] := 0;

VPADDB (VEX.256 Encoded Instruction)
    DEST[7:0] := SRC1[7:0] + SRC2[7:0];
    (* Repeat add operation for 2nd through 31th byte *)
    DEST[255:248] := SRC1[255:248] + SRC2[255:248];


VPADDW (VEX.256 Encoded Instruction)
    DEST[15:0] := SRC1[15:0] + SRC2[15:0];
    (* Repeat add operation for 2nd through 15th word *)
    DEST[255:240] := SRC1[255:240] + SRC2[255:240];

VPADDD (VEX.256 Encoded Instruction)
    DEST[31:0] := SRC1[31:0] + SRC2[31:0];
    (* Repeat add operation for 2nd and 7th doubleword *)
    DEST[255:224] := SRC1[255:224] + SRC2[255:224];

VPADDQ (VEX.256 Encoded Instruction)
    DEST[63:0] := SRC1[63:0] + SRC2[63:0];
    DEST[127:64] := SRC1[127:64] + SRC2[127:64];
    DEST[191:128] := SRC1[191:128] + SRC2[191:128];
    DEST[255:192] := SRC1[255:192] + SRC2[255:192];

VPADDB (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] := SRC1[i+7:i] + SRC2[i+7:i]

     ELSE

             IF *merging-masking*             ; merging-masking

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

                 ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+7:i] = 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0

VPADDW (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] := SRC1[i+15:i] + SRC2[i+15:i]

     ELSE

             IF *merging-masking*             ; merging-masking

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

                 ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+15:i] = 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0


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

             IF (EVEX.b = 1) AND (SRC2 *is memory*)

                  THEN DEST[i+31:i] := SRC1[i+31:i] + SRC2[31:0]

                  ELSE DEST[i+31:i] := SRC1[i+31:i] + SRC2[i+31:i]

             FI;

     ELSE

             IF *merging-masking*             ; merging-masking

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

                  ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+31:i] := 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0

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

             IF (EVEX.b = 1) AND (SRC2 *is memory*)

                  THEN DEST[i+63:i] := SRC1[i+63:i] + SRC2[63:0]

                  ELSE DEST[i+63:i] := SRC1[i+63:i] + SRC2[i+63:i]

             FI;

     ELSE

             IF *merging-masking*             ; merging-masking

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

                  ELSE *zeroing-masking*             ; zeroing-masking

                    DEST[i+63:i] := 0

             FI

FI;

ENDFOR;

DEST[MAXVL-1:VL] := 0

Intel C/C++ compilador intrínseco

VPADDB__m512i _mm512_add_epi8 ( __m512i a, __m512i b) VPADDW__m512i _mm512_add_epi16 ( __m512i a, __m512i b) VPADDB__m512i _mm512_mask_add_epi8 ( __m512i s, __mmask64 m, __m512i a, __m512i b) VPADDW__m512i _mm512_mask_add_epi16 ( __m512i s, __mmask32 m, __m512i a, __m512i b) VPADDB__m512i _mm512_maskz_add_epi8 (__mmask64 m, __m512i a, __m512i b) VPADDW__m512i _mm512_maskz_add_epi16 (__mmask32 m, __m512i a, __m512i b) VPADDB__m256i _mm256_mask_add_epi8 (__m256i s, __mmask32 m, __m256i a, __m256i b) VPADDW__m256i _mm256_mask_add_epi16 (__m256i s, __mmask16 m, __m256i a, __m256i b) VPADDB__m256i _mm256_maskz_add_epi8 (__mmask32 m, __m256i a, __m256i b) VPADDW__m256i _mm256_maskz_add_epi16 (__mmask16 m, __m256i a, __m256i b) VPADDB__m128i _mm_mask_add_epi8 (__m128i s, __mmask16 m, __m128i a, __m128i b) VPADDW__m128i _mm_mask_add_epi16 (__m128i s, __mmask8 m, __m128i a, __m128i b) VPADDB__m128i _mm_maskz_add_epi8 (__mmask16 m, __m128i a, __m128i b) VPADDW__m128i _mm_maskz_add_epi16 (__mmask8 m, __m128i a, __m128i b) VPADDD __m512i _mm512_add_epi32( __m512i a, __m512i b);
VPADDD __m512i _mm512_mask_add_epi32(__m512i s, __mmask16 k, __m512i a, __m512i b);
VPADDD __m512i _mm512_maskz_add_epi32( __mmask16 k, __m512i a, __m512i b);
VPADDD __m256i _mm256_mask_add_epi32(__m256i s, __mmask8 k, __m256i a, __m256i b);
VPADDD __m256i _mm256_maskz_add_epi32( __mmask8 k, __m256i a, __m256i b);
VPADDD __m128i _mm_mask_add_epi32(__m128i s, __mmask8 k, __m128i a, __m128i b);
VPADDD __m128i _mm_maskz_add_epi32( __mmask8 k, __m128i a, __m128i b);
VPADDQ __m512i _mm512_add_epi64( __m512i a, __m512i b);
VPADDQ __m512i _mm512_mask_add_epi64(__m512i s, __mmask8 k, __m512i a, __m512i b);
VPADDQ __m512i _mm512_maskz_add_epi64( __mmask8 k, __m512i a, __m512i b);
VPADDQ __m256i _mm256_mask_add_epi64(__m256i s, __mmask8 k, __m256i a, __m256i b);
VPADDQ __m256i _mm256_maskz_add_epi64( __mmask8 k, __m256i a, __m256i b);
VPADDQ __m128i _mm_mask_add_epi64(__m128i s, __mmask8 k, __m128i a, __m128i b);
VPADDQ __m128i _mm_maskz_add_epi64( __mmask8 k, __m128i a, __m128i b);
PADDB __m128i _mm_add_epi8 (__m128i a,__m128i b );
PADDW __m128i _mm_add_epi16 ( __m128i a, __m128i b);
PADDD __m128i _mm_add_epi32 ( __m128i a, __m128i b);
PADDQ __m128i _mm_add_epi64 ( __m128i a, __m128i b);
VPADDB __m256i _mm256_add_epi8 (__m256ia,__m256i b );
VPADDW __m256i _mm256_add_epi16 ( __m256i a, __m256i b);
VPADDD __m256i _mm256_add_epi32 ( __m256i a, __m256i b);
VPADDQ __m256i _mm256_add_epi64 ( __m256i a, __m256i b);
PADDB __m64 _mm_add_pi8(__m64 m1, __m64 m2) PADDW __m64 _mm_add_pi16(__m64 m1, __m64 m2) PADDD __m64 _mm_add_pi32(__m64 m1, __m64 m2) PADDQ __m64 _mm_add_si64(__m64 m1, __m64 m2);

SIMD coma flotante Excepciones

None.

Otras excepciones

Instrucciones no codificadas por EVEX, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase".

EVEX-encoded VPADDD/Q, ver Tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

EVEX-encoded VPADDB/W, ver Excepciones Tipo E4.nb en la tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

Fuentes