Vesta
Español
Código fuente

PSUBB, PSUBW, PSUBD

Subtract Packed Integers

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F F8 /r1PSUBB mm, mm/m64AValidoValidoExtractos de byte empaquetados en mm/m64 de enteros empaquetados en mm.
66 0F F8 /rPSUBB xmm1, xmm2/m128AValidoValidoExtracto embalado de enteros de byte en xmm2/m128 a partir de enteros de byte embalados en xmm1.
NP 0F F9 /r1PSUBW mm, mm/m64AValidoValidoExtracto enteros de palabras empaquetadas en mm/m64 de enteros de palabras empaquetadas en mm.
66 0F F9 /rPSUBW xmm1, xmm2/m128AValidoValidoExtracto enteros de palabras empaquetadas en xmm2/m128 de enteros de palabras empaquetadas en xmm1.
NP 0F FA /r1PSUBD mm, mm/m64AValidoValidoExtracto de los enteros de doble palabra empaquetados en mm/m64 de los enteros de doble palabra empaquetados en mm.
66 0F FA /rPSUBD xmm1, xmm2/m128AValidoValidoSubtract packed doubleword integers in xmm2/mem128 de packed doubleword integers in xmm1.
VEX.128.66.0F.WIG F8 /rVPSUBB xmm1, xmm2, xmm3/m128BValidoValidoExtractos de byte empaquetados en xmm3/m128 de xmm2.
VEX.128.66.0F.WIG F9 /rVPSUBW xmm1, xmm2, xmm3/m128BValidoValidoExtractos de palabras empaquetadas en xmm3/m128 de xmm2.
VEX.128.66.0F.WIG FA /rVPSUBD xmm1, xmm2, xmm3/m128BValidoValidoSubtract packed doubleword integers in xmm3/m128 de xmm2.
VEX.256.66.0F.WIG F8 /rVPSUBB ymm1, ymm2, ymm3/m256BValidoValidoExtractos de byte empaquetados en ymm3/m256 de ymm2.
VEX.256.66.0F.WIG F9 /rVPSUBW ymm1, ymm2, ymm3/m256BValidoValidoExtractos de palabras empaquetadas en ymm3/m256 de ymm2.
VEX.256.66.0F.WIG FA /rVPSUBD ymm1, ymm2, ymm3/m256BValidoValidoSubtract packed doubleword integers in ymm3/m256 de ymm2.
EVEX.128.66.0F.WIG F8 /rVPSUBB xmm1 {k1}{z}, xmm2, xmm3/m128CValidoValidoExtractos de byte empaquetados en xmm3/m128 AVX512BW) OR AVX10.1 de xmm2 y almacén en xmm1 utilizando máscara de escritura k1.
EVEX.256.66.0F.WIG F8 /rVPSUBB ymm1 {k1}{z}, ymm2, ymm3/m256CValidoValidoExtractos de byte empaquetados en ymm3/m256 AVX512BW) OR AVX10.1 de ymm2 y almacén en ymm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.WIG F8 /rVPSUBB zmm1 {k1}{z}, zmm2, zmm3/m512CValidoValidoExtractos de byte empaquetados en zmm3/m512 OR AVX10.1 de zmm2 y almacén en zmm1 utilizando máscara de escritura k1.
EVEX.128.66.0F.WIG F9 /rVPSUBW xmm1 {k1}{z}, xmm2, xmm3/m128CValidoValidoSubtract packed word integers in AVX512BW) OR AVX10.1 xmm3/m128 de xmm2 y almacén en xmm1 utilizando máscara de escritura k1.
EVEX.256.66.0F.WIG F9 /rVPSUBW ymm1 {k1}{z}, ymm2, ymm3/m256CValidoValidoSubtract packed word integers in AVX512BW) OR AVX10.1 ymm3/m256 de ymm2 y almacén en ymm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.WIG F9 /rVPSUBW zmm1 {k1}{z}, zmm2, zmm3/m512 Opcode/ InstructionCValidoValidoExtractos de palabras empaquetadas en ORAVX10.1 zmm3/m512desdezmm2y almacenar enzmm1utilizandomáscara de escritura k1. Op/ 64/32 bitCPUIDCaracterísticas Descripción En Modo Soporte Bandera
EVEX.128.66.0F.W0 FA /rVPSUBD xmm1 {k1}{z}, xmm2, xmm3/m128/m32bcstDValidoValidoSubtract packed doubleword integers in AVX512F) OR xmm3/m128/m32bcst de xmm2 y almacenar AVX10.1 en xmm1 utilizando máscara de escritura k1.
EVEX.256.66.0F.W0 FA /rVPSUBD ymm1 {k1}{z}, ymm2, ymm3/m256/m32bcstDValidoValidoSubtract packed doubleword integers in AVX512F) OR ymm3/m256/m32bcst de ymm2 y almacenar AVX10.1 en ymm1 utilizando máscara de escritura k1.
EVEX.512.66.0F.W0 FA /rVPSUBD zmm1 {k1}{z}, zmm2, zmm3/m512/m32bcstDValidoValidoSubtract packed doubleword integers in OR AVX10.1 zmm3/m512/m32bcst de zmm2 y almacén 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 un subtracto SIMD de los enteros empaquetados del operando de origen (segundo operando) de los enteros empaquetados del 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.

La instrucción (V)PSUBB subtracts packed byte integers. Cuando un resultado individual es demasiado grande o demasiado pequeño para ser representado en un byte, el resultado se envuelve alrededor y los bajos 8 bits se escriben al elemento de destino.

La instrucción (V)PSUBW subtracts packed word integers. Cuando un resultado individual es demasiado grande o demasiado pequeño para ser representado en una palabra, el resultado se envuelve alrededor y los 16 bits bajos se escriben al elemento de destino.

La instrucción (V)PSUBD subtracts packed doubleword integers. Cuando un resultado individual es demasiado grande o demasiado pequeño para ser representado en una palabra doble, el resultado se envuelve alrededor y los 32 bits bajos se escriben al elemento de destino.

Tenga en cuenta que las instrucciones (V)PSUBB, (V)PSUBW, y (V)PSUBD pueden operar 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 en los que opera.

En modo de 64 bits y no codificado con VEX/EVEX, utilizando un prefijo REX en forma de REX.R permite esta instrucción para acceder a registros adicionales (XMM8-XMM15).

Legacy SSE versión 64-bit operando: El operando de destino debe ser un registro de tecnología MMX y el operando de origen puede ser un registro de tecnología MMX o una ubicación de memoria de 64 bits.

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

VEX.128 versión codificada: El segundo operando de origen es un registro XMM o una ubicación de memoria de 128 bits. El primer operando de origen y operandos de destino son registros XMM. Bits (MAXVL-1:128) del destino YMM registro se ponen a cero.

VEX.256 versiones codificadas: El segundo operando de origen es un registro YMM o una ubicación de memoria de 256 bits. El primer operando de origen y operandos de destino son registros YMM. Bits (MAXVL-1:256) del registro ZMM correspondiente se ponen a cero.

EVEX codificado VPSUBD: 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 primer operando de origen y operandos de destino son los registros ZMM/YMM/XMM. El destino está actualizado condicionalmente con máscara de escritura k1.

EVEX codificado VPSUBB/W: El segundo operando de origen es un registro ZMM/YMM/XMM, un 512/256/128-bit ubicación de memoria. El primer operando de origen y operandos de destino son los registros ZMM/YMM/XMM. El destino está actualizado condicionalmente con máscara de escritura k1.

Operación

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

PSUBW (With 64-bit Operands)
    DEST[15:0] := DEST[15:0] - SRC[15:0];
    (* Repeat subtract operation for 2nd and 3rd word *)
    DEST[63:48] := DEST[63:48] - SRC[63:48];

PSUBD (With 64-bit Operands)

    DEST[31:0] := DEST[31:0] - SRC[31:0];
    DEST[63:32] := DEST[63:32] - SRC[63:32];

PSUBD (With 128-bit Operands)
    DEST[31:0] := DEST[31:0] - SRC[31:0];
    (* Repeat subtract operation for 2nd and 3rd doubleword *)
    DEST[127:96] := DEST[127:96] - SRC[127:96];

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


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

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

VPSUBB (VEX.256 Encoded Version)
DEST[7:0] := SRC1[7:0]-SRC2[7:0]
DEST[15:8] := SRC1[15:8]-SRC2[15:8]
DEST[23:16] := SRC1[23:16]-SRC2[23:16]
DEST[31:24] := SRC1[31:24]-SRC2[31:24]
DEST[39:32] := SRC1[39:32]-SRC2[39:32]
DEST[47:40] := SRC1[47:40]-SRC2[47:40]
DEST[55:48] := SRC1[55:48]-SRC2[55:48]
DEST[63:56] := SRC1[63:56]-SRC2[63:56]
DEST[71:64] := SRC1[71:64]-SRC2[71:64]
DEST[79:72] := SRC1[79:72]-SRC2[79:72]
DEST[87:80] := SRC1[87:80]-SRC2[87:80]
DEST[95:88] := SRC1[95:88]-SRC2[95:88]
DEST[103:96] := SRC1[103:96]-SRC2[103:96]
DEST[111:104] := SRC1[111:104]-SRC2[111:104]
DEST[119:112] := SRC1[119:112]-SRC2[119:112]
DEST[127:120] := SRC1[127:120]-SRC2[127:120]
DEST[135:128] := SRC1[135:128]-SRC2[135:128]
DEST[143:136] := SRC1[143:136]-SRC2[143:136]


DEST[151:144] := SRC1[151:144]-SRC2[151:144]
DEST[159:152] := SRC1[159:152]-SRC2[159:152]
DEST[167:160] := SRC1[167:160]-SRC2[167:160]
DEST[175:168] := SRC1[175:168]-SRC2[175:168]
DEST[183:176] := SRC1[183:176]-SRC2[183:176]
DEST[191:184] := SRC1[191:184]-SRC2[191:184]
DEST[199:192] := SRC1[199:192]-SRC2[199:192]
DEST[207:200] := SRC1[207:200]-SRC2[207:200]
DEST[215:208] := SRC1[215:208]-SRC2[215:208]
DEST[223:216] := SRC1[223:216]-SRC2[223:216]
DEST[231:224] := SRC1[231:224]-SRC2[231:224]
DEST[239:232] := SRC1[239:232]-SRC2[239:232]
DEST[247:240] := SRC1[247:240]-SRC2[247:240]
DEST[255:248] := SRC1[255:248]-SRC2[255:248]
DEST[MAXVL-1:256] := 0

VPSUBB (VEX.128 Encoded Version)
DEST[7:0] := SRC1[7:0]-SRC2[7:0]
DEST[15:8] := SRC1[15:8]-SRC2[15:8]
DEST[23:16] := SRC1[23:16]-SRC2[23:16]
DEST[31:24] := SRC1[31:24]-SRC2[31:24]
DEST[39:32] := SRC1[39:32]-SRC2[39:32]
DEST[47:40] := SRC1[47:40]-SRC2[47:40]
DEST[55:48] := SRC1[55:48]-SRC2[55:48]
DEST[63:56] := SRC1[63:56]-SRC2[63:56]
DEST[71:64] := SRC1[71:64]-SRC2[71:64]
DEST[79:72] := SRC1[79:72]-SRC2[79:72]
DEST[87:80] := SRC1[87:80]-SRC2[87:80]
DEST[95:88] := SRC1[95:88]-SRC2[95:88]
DEST[103:96] := SRC1[103:96]-SRC2[103:96]
DEST[111:104] := SRC1[111:104]-SRC2[111:104]
DEST[119:112] := SRC1[119:112]-SRC2[119:112]
DEST[127:120] := SRC1[127:120]-SRC2[127:120]
DEST[MAXVL-1:128] := 0

PSUBB (128-bit Legacy SSE Version)
DEST[7:0] := DEST[7:0]-SRC[7:0]
DEST[15:8] := DEST[15:8]-SRC[15:8]
DEST[23:16] := DEST[23:16]-SRC[23:16]
DEST[31:24] := DEST[31:24]-SRC[31:24]
DEST[39:32] := DEST[39:32]-SRC[39:32]
DEST[47:40] := DEST[47:40]-SRC[47:40]
DEST[55:48] := DEST[55:48]-SRC[55:48]
DEST[63:56] := DEST[63:56]-SRC[63:56]
DEST[71:64] := DEST[71:64]-SRC[71:64]
DEST[79:72] := DEST[79:72]-SRC[79:72]
DEST[87:80] := DEST[87:80]-SRC[87:80]
DEST[95:88] := DEST[95:88]-SRC[95:88]
DEST[103:96] := DEST[103:96]-SRC[103:96]
DEST[111:104] := DEST[111:104]-SRC[111:104]
DEST[119:112] := DEST[119:112]-SRC[119:112]
DEST[127:120] := DEST[127:120]-SRC[127:120]
DEST[MAXVL-1:128] (Unmodified)


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

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

PSUBW (128-bit Legacy SSE Version)
DEST[15:0] := DEST[15:0]-SRC[15:0]
DEST[31:16] := DEST[31:16]-SRC[31:16]
DEST[47:32] := DEST[47:32]-SRC[47:32]
DEST[63:48] := DEST[63:48]-SRC[63:48]
DEST[79:64] := DEST[79:64]-SRC[79:64]
DEST[95:80] := DEST[95:80]-SRC[95:80]
DEST[111:96] := DEST[111:96]-SRC[111:96]
DEST[127:112] := DEST[127:112]-SRC[127:112]
DEST[MAXVL-1:128] (Unmodified)

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


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

PSUBD (128-bit Legacy SSE Version)
DEST[31:0] := DEST[31:0]-SRC[31:0]
DEST[63:32] := DEST[63:32]-SRC[63:32]
DEST[95:64] := DEST[95:64]-SRC[95:64]
DEST[127:96] := DEST[127:96]-SRC[127:96]
DEST[MAXVL-1:128] (Unmodified)

Intel C/C++ compilador intrínseco

VPSUBB __m512i _mm512_sub_epi8(__m512i a, __m512i b);
VPSUBB __m512i _mm512_mask_sub_epi8(__m512i s, __mmask64 k, __m512i a, __m512i b);
VPSUBB __m512i _mm512_maskz_sub_epi8( __mmask64 k, __m512i a, __m512i b);
VPSUBB __m256i _mm256_mask_sub_epi8(__m256i s, __mmask32 k, __m256i a, __m256i b);
VPSUBB __m256i _mm256_maskz_sub_epi8( __mmask32 k, __m256i a, __m256i b);
VPSUBB __m128i _mm_mask_sub_epi8(__m128i s, __mmask16 k, __m128i a, __m128i b);
VPSUBB __m128i _mm_maskz_sub_epi8( __mmask16 k, __m128i a, __m128i b);
VPSUBW __m512i _mm512_sub_epi16(__m512i a, __m512i b);
VPSUBW __m512i _mm512_mask_sub_epi16(__m512i s, __mmask32 k, __m512i a, __m512i b);
VPSUBW __m512i _mm512_maskz_sub_epi16( __mmask32 k, __m512i a, __m512i b);
VPSUBW __m256i _mm256_mask_sub_epi16(__m256i s, __mmask16 k, __m256i a, __m256i b);
VPSUBW __m256i _mm256_maskz_sub_epi16( __mmask16 k, __m256i a, __m256i b);
VPSUBW __m128i _mm_mask_sub_epi16(__m128i s, __mmask8 k, __m128i a, __m128i b);
VPSUBW __m128i _mm_maskz_sub_epi16( __mmask8 k, __m128i a, __m128i b);
VPSUBD __m512i _mm512_sub_epi32(__m512i a, __m512i b);
VPSUBD __m512i _mm512_mask_sub_epi32(__m512i s, __mmask16 k, __m512i a, __m512i b);
VPSUBD __m512i _mm512_maskz_sub_epi32( __mmask16 k, __m512i a, __m512i b);
VPSUBD __m256i _mm256_mask_sub_epi32(__m256i s, __mmask8 k, __m256i a, __m256i b);
VPSUBD __m256i _mm256_maskz_sub_epi32( __mmask8 k, __m256i a, __m256i b);
VPSUBD __m128i _mm_mask_sub_epi32(__m128i s, __mmask8 k, __m128i a, __m128i b);
VPSUBD __m128i _mm_maskz_sub_epi32( __mmask8 k, __m128i a, __m128i b);
PSUBB __m64 _mm_sub_pi8(__m64 m1, __m64 m2) (V)PSUBB __m128i _mm_sub_epi8 ( __m128i a, __m128i b) VPSUBB __m256i _mm256_sub_epi8 ( __m256i a, __m256i b) PSUBW __m64 _mm_sub_pi16(__m64 m1, __m64 m2) (V)PSUBW __m128i _mm_sub_epi16 ( __m128i a, __m128i b) VPSUBW __m256i _mm256_sub_epi16 ( __m256i a, __m256i b) PSUBD __m64 _mm_sub_pi32(__m64 m1, __m64 m2) (V)PSUBD __m128i _mm_sub_epi32 ( __m128i a, __m128i b) VPSUBD __m256i _mm256_sub_epi32 ( __m256i a, __m256i b);

Banderas afectadas

None.

Excepciones numéricas

None.

Otras excepciones

Non-EVEX- instrucción codificada, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción".EVEX- codificadoVPSUBD, ver Tabla 2-51, "Tipo E4 Clase Condiciones de Excepción."EVEX- codificadoVPSUBB/W, ver Excepciones TipoE4.nben la tabla 2-51, "Tipo E4 Clase Condiciones de Excepción."

Fuentes