Vesta
Español
Código fuente

PHADDW, PHADDD

Empaquetado Horizontal Añadir

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F 38 01 /r1PHADDW mm1, mm2/m64RMValidoValidoAñadir enteros de 16 bits horizontalmente, empaquetar a mm1.
66 0F 38 01 /rPHADDW xmm1, xmm2/m128RMValidoValidoAñadir enteros de 16 bits horizontalmente, empaquetar a xmm1.
NP 0F 38 02 /rPHADDD mm1, mm2/m64RMValidoValidoAñadir entradas de 32 bits horizontalmente, empaquetar a mm1.
66 0F 38 02 /rPHADDD xmm1, xmm2/m128RMValidoValidoAñadir entradas de 32 bits horizontalmente, empaquetar a xmm1.
VEX.128.66.0F38.WIG 01 /rVPHADDW xmm1, xmm2, xmm3/m128RVMValidoValidoAñadir enteros de 16 bits horizontalmente, empaquetar a xmm1.
VEX.128.66.0F38.WIG 02 /rVPHADDD xmm1, xmm2, xmm3/m128RVMValidoValidoAñadir entradas de 32 bits horizontalmente, empaquetar a xmm1.
VEX.256.66.0F38.WIG 01 /rVPHADDW ymm1, ymm2, ymm3/m256RVMValidoValidoAñadir 16-bit enteros con signo horizontalmente, empaquetar a ymm1.
VEX.256.66.0F38.WIG 02 /rVPHADDD ymm1, ymm2, ymm3/m256RVMValidoValidoAñadir 32-bit enteros con signo horizontalmente, empaquetar a ymm1.

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.

RM

  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

RVM

  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

Coste medido

Cargando las mediciones de arch-data...

Descripción

(V)PHADDW añade dos enteros con signo adyacentes horizontalmente de la fuente y operandos de destino y empaca los resultados firmados de 16 bits al operando de destino (primer operando). (V)PHADDD añade dos enteros con signo adyacentes horizontalmente de la fuente y operandos de destino y empaca los resultados firmados de 32 bits al operando de destino (primer operando). Cuando el operando de origen es un operando de memoria de 128 bits, el operando debe estar alineado en un límite de 16 bytes o una excepción de protección general (#GP) se generará.

Tenga en cuenta que estas instrucciones pueden operar en enteros no firmados o 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 los valores operados en.

Legacy SSE instrucciones: Ambos operandos pueden ser registros MMX. El segundo operando de origen puede ser un registro MMX o una ubicación de memoria de 64 bits.

128-bit Legacy SSE versión: La primera fuente y operandos de destino son registros XMM. El segundo operando de origen puede ser un registro XMM o una ubicación de memoria de 128 bits. Bits (MAXVL-1:128) del correspondiente registro de destino YMM no se modifican.

En modo de 64 bits, utilice el prefijo REX para acceder a registros adicionales.

VEX.128 versión codificada: La primera fuente y operandos de destino son registros XMM. El segundo operando de origen puede ser un registro XMM o una ubicación de memoria de 128 bits. Bits (MAXVL-1:128) del registro YMM correspondiente se ponen a cero. VEX.256 versión codificada: La adición horizontal de dos elementos de datos adyacentes de los 16 bytes bajos de la primera y segunda operandos de origen están empaquetados en los 16 bytes bajos del operando de destino. La adición horizontal de dos elementos de datos adyacentes de los 16-bytes altos de la primera y segunda operandos de origen se embalan en los 16-bytes altos del operando de destino. La primera fuente y operandos de destino son registros YMM. El segundo operando de origen puede ser un registro YMM o una ubicación de memoria de 256 bits.

SRC2 Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 X7 X6 X5 X4 X3 X2 X1 X0 SRC1

S7 S3 S3 S4 S3 S2 S1 S0

            255              0

Dest

Figure 4-10. 256-bit VPHADDD Instruction Operation

Operación

PHADDW (With 64-bit Operands)
    mm1[15-0] = mm1[31-16] + mm1[15-0];
    mm1[31-16] = mm1[63-48] + mm1[47-32];
    mm1[47-32] = mm2/m64[31-16] + mm2/m64[15-0];
    mm1[63-48] = mm2/m64[63-48] + mm2/m64[47-32];

PHADDW (With 128-bit Operands)
    xmm1[15-0] = xmm1[31-16] + xmm1[15-0];
    xmm1[31-16] = xmm1[63-48] + xmm1[47-32];
    xmm1[47-32] = xmm1[95-80] + xmm1[79-64];
    xmm1[63-48] = xmm1[127-112] + xmm1[111-96];
    xmm1[79-64] = xmm2/m128[31-16] + xmm2/m128[15-0];
    xmm1[95-80] = xmm2/m128[63-48] + xmm2/m128[47-32];
    xmm1[111-96] = xmm2/m128[95-80] + xmm2/m128[79-64];
    xmm1[127-112] = xmm2/m128[127-112] + xmm2/m128[111-96];

VPHADDW (VEX.128 Encoded Version)
DEST[15:0] := SRC1[31:16] + SRC1[15:0]
DEST[31:16] := SRC1[63:48] + SRC1[47:32]
DEST[47:32] := SRC1[95:80] + SRC1[79:64]
DEST[63:48] := SRC1[127:112] + SRC1[111:96]
DEST[79:64] := SRC2[31:16] + SRC2[15:0]
DEST[95:80] := SRC2[63:48] + SRC2[47:32]
DEST[111:96] := SRC2[95:80] + SRC2[79:64]
DEST[127:112] := SRC2[127:112] + SRC2[111:96]
DEST[MAXVL-1:128] := 0


VPHADDW (VEX.256 Encoded Version)
DEST[15:0] := SRC1[31:16] + SRC1[15:0]
DEST[31:16] := SRC1[63:48] + SRC1[47:32]
DEST[47:32] := SRC1[95:80] + SRC1[79:64]
DEST[63:48] := SRC1[127:112] + SRC1[111:96]
DEST[79:64] := SRC2[31:16] + SRC2[15:0]
DEST[95:80] := SRC2[63:48] + SRC2[47:32]
DEST[111:96] := SRC2[95:80] + SRC2[79:64]
DEST[127:112] := SRC2[127:112] + SRC2[111:96]
DEST[143:128] := SRC1[159:144] + SRC1[143:128]
DEST[159:144] := SRC1[191:176] + SRC1[175:160]
DEST[175:160] := SRC1[223:208] + SRC1[207:192]
DEST[191:176] := SRC1[255:240] + SRC1[239:224]
DEST[207:192] := SRC2[127:112] + SRC2[143:128]
DEST[223:208] := SRC2[159:144] + SRC2[175:160]
DEST[239:224] := SRC2[191:176] + SRC2[207:192]
DEST[255:240] := SRC2[223:208] + SRC2[239:224]

PHADDD (With 64-bit Operands)
    mm1[31-0] = mm1[63-32] + mm1[31-0];
    mm1[63-32] = mm2/m64[63-32] + mm2/m64[31-0];

PHADDD (With 128-bit Operands)
    xmm1[31-0] = xmm1[63-32] + xmm1[31-0];
    xmm1[63-32] = xmm1[127-96] + xmm1[95-64];
    xmm1[95-64] = xmm2/m128[63-32] + xmm2/m128[31-0];
    xmm1[127-96] = xmm2/m128[127-96] + xmm2/m128[95-64];

VPHADDD (VEX.128 Encoded Version)
DEST[31-0] := SRC1[63-32] + SRC1[31-0]
DEST[63-32] := SRC1[127-96] + SRC1[95-64]
DEST[95-64] := SRC2[63-32] + SRC2[31-0]
DEST[127-96] := SRC2[127-96] + SRC2[95-64]
DEST[MAXVL-1:128] := 0

VPHADDD (VEX.256 Encoded Version)
DEST[31-0] := SRC1[63-32] + SRC1[31-0]
DEST[63-32] := SRC1[127-96] + SRC1[95-64]
DEST[95-64] := SRC2[63-32] + SRC2[31-0]
DEST[127-96] := SRC2[127-96] + SRC2[95-64]
DEST[159-128] := SRC1[191-160] + SRC1[159-128]
DEST[191-160] := SRC1[255-224] + SRC1[223-192]
DEST[223-192] := SRC2[191-160] + SRC2[159-128]
DEST[255-224] := SRC2[255-224] + SRC2[223-192]

Intel C/C++ compilador intrínseco

PHADDW __m64 _mm_hadd_pi16 (__m64 a, __m64 b) PHADDD __m64 _mm_hadd_pi32 (__m64 a, __m64 b) (V)PHADDW __m128i _mm_hadd_epi16 (__m128i a, __m128i b) (V)PHADDD __m128i _mm_hadd_epi32 (__m128i a, __m128i b) VPHADDW __m256i _mm256_hadd_epi16 (__m256i a, __m256i b) VPHADDD __m256i _mm256_hadd_epi32 (__m256i a, __m256i b);

SIMD coma flotante Excepciones

None.

Otras excepciones

Ver Tabla 2-21, "Tipo 4 Condiciones de Excepción", además:

#UD               If VEX.L = 1.

Fuentes