Vesta
Español
Código fuente

PHSUBW, PHSUBD

Subtracto horizontal envasado

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F 38 05 /r1PHSUBW mm1, mm2/m64RMValidoValidoSubterráneo de 16 bits enteros con signo horizontalmente, paquete a mm1.
66 0F 38 05 /rPHSUBW xmm1, xmm2/m128RMValidoValidoSubterráneo de 16 bits enteros con signo horizontalmente, paquete a xmm1.
NP 0F 38 06 /rPHSUBD mm1, mm2/m64RMValidoValidoExtracto 32-bit enteros con signo horizontalmente, empaquetar a mm1.
66 0F 38 06 /rPHSUBD xmm1, xmm2/m128RMValidoValidoExtracto 32-bit enteros con signo horizontalmente, empaquetar a xmm1.
VEX.128.66.0F38.WIG 05 /rVPHSUBW xmm1, xmm2, xmm3/m128RVMValidoValidoSubterráneo de 16 bits enteros con signo horizontalmente, paquete a xmm1.
VEX.128.66.0F38.WIG 06 /rVPHSUBD xmm1, xmm2, xmm3/m128RVMValidoValidoExtracto 32-bit enteros con signo horizontalmente, empaquetar a xmm1.
VEX.256.66.0F38.WIG 05 /rVPHSUBW ymm1, ymm2, ymm3/m256RVMValidoValidoSubterráneo de 16 bits enteros con signo horizontalmente, paquete a ymm1.
VEX.256.66.0F38.WIG 06 /rVPHSUBD ymm1, ymm2, ymm3/m256RVMValidoValidoExtracto 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 lectura y 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)PHSUBW realiza la resta horizontal en cada par adyacente de 16 bits enteros con signo restando la palabra mas significativo de la palabra menos significativo de cada par en la fuente y operandos de destino, y empaca los resultados firmados de 16 bits al operando de destino (primer operando). (V)PHSUBD realiza la resta horizontal en cada par adyacente de 32 bits enteros con signo restando la palabra doble mas significativo de la palabra doble menos significativo de cada par, y empaqueta el resultado de 32 bits firmado al operando de destino. 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á.

Legacy SSE versión: 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 es 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 es un registro XMM o una ubicación de memoria de 128 bits. Bits (MAXVL-1:128) del destino YMM registro se ponen a cero.

VEX.256 versión codificada: 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.

Operación

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

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

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

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

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


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

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

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

Intel C/C++ compilador intrínseco

PHSUBW __m64 _mm_hsub_pi16 (__m64 a, __m64 b) PHSUBD __m64 _mm_hsub_pi32 (__m64 a, __m64 b) (V)PHSUBW __m128i _mm_hsub_epi16 (__m128i a, __m128i b) (V)PHSUBD __m128i _mm_hsub_epi32 (__m128i a, __m128i b) VPHSUBW __m256i _mm256_hsub_epi16 (__m256i a, __m256i b) VPHSUBD __m256i _mm256_hsub_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