Vesta
Español
Código fuente

PACKUSWB

Paquete con saturación no firmada

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
NP 0F 67 /r1PACKUSWB mm, mm/m64AValidoValidoConvierte 4 enteros de palabra firmados de mm y 4 enteros de palabra firmados de mm/m64 en 8 enteros de byte sin firma en mm utilizando saturación no firmada.
66 0F 67 /rPACKUSWB xmm1, xmm2/m128AValidoValidoConvierte 8 enteros de palabra firmados de xmm1 y 8 enteros de palabra firmados de xmm2/m128 en 16 enteros de byte sin firma en xmm1 usando saturación sin firma.
VEX.128.66.0F.WIG 67 /rVPACKUSWB xmm1, xmm2, xmm3/m128BValidoValidoConvierte 8 enteros de palabra firmados de xmm2 y 8 enteros de palabra firmados de xmm3/m128 en 16 enteros de byte sin firma en xmm1 usando saturación sin firma.
VEX.256.66.0F.WIG 67 /rVPACKUSWB ymm1, ymm2, ymm3/m256BValidoValidoConvierte 16 enteros de palabras firmados de ymm2 y 16 enteros de palabras firmadas de ymm3/m256 en 32 enteros de byte no firmados en ymm1 usando saturación no firmada.
EVEX.128.66.0F.WIG 67 /rVPACKUSWB xmm1{k1}{z}, xmm2, xmm3/m128CValidoValidoConvierte los enteros de palabras firmados dexmm2yAVX512BW) O firmada palabra números enteros dexmm3/m128enAVX10.1integers byte insigned inxmm1usando saturación insignia bajomáscara de escritura k1.
EVEX.256.66.0F.WIG 67 /rVPACKUSWB ymm1{k1}{z}, ymm2, ymm3/m256CValidoValidoConvierte los enteros de palabras firmados deymm2yAVX512BW) O firmada palabra números enteros deymm3/m256enAVX10.1integers byte insigned inymm1usando saturación insignia bajomáscara de escritura k1.
EVEX.512.66.0F.WIG 67 /rVPACKUSWB zmm1{k1}{z}, zmm2, zmm3/m512CValidoValidoConvierte los enteros de palabra firmados de zmm2 y OR AVX10.1 firmaron enteros de palabra de zmm3/m512 en enteros de byte sin firma en zmm1 usando saturación sin firma bajo 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

Coste medido

Cargando las mediciones de arch-data...

Descripción

Convierte 4, 8, 16, o 32 enteros de palabras firmados del operando de destino (primer operando) y 4, 8, 16, o 32 enteros de palabras firmados del operando de origen (segundo operando) en 8, 16, 32 o 64 números de byte no firmados y almacena el resultado en el operando de destino. (Ver Figura 4-6 para un ejemplo de la operación de embalaje.) Si una palabra firmada valor entero está más allá de la gama de un entero de byte sin firma (es decir, mayor que FFH o menos que 00H), el valor entero de byte saturado sin señal de FFH o 00H, respectivamente, se almacena en el destino.

EVEX.512 versión codificada: El primer operando de origen es un registro ZMM. El segundo operando de origen es un registro ZMM o una ubicación de memoria de 512 bits. El operando de destino es un registro ZMM.

VEX.256 y EVEX.256 versiones codificadas: 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 de registro ZMM correspondiente se ponen a cero.

VEX.128 y EVEX.128 versiones codificadas: 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 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 correspondiente son sin modificar.

Operación

PACKUSWB (With 64-bit Operands)
    DEST[7:0] := SaturateSignedWordToUnsignedByte DEST[15:0];
    DEST[15:8] := SaturateSignedWordToUnsignedByte DEST[31:16];
    DEST[23:16] := SaturateSignedWordToUnsignedByte DEST[47:32];
    DEST[31:24] := SaturateSignedWordToUnsignedByte DEST[63:48];
    DEST[39:32] := SaturateSignedWordToUnsignedByte SRC[15:0];
    DEST[47:40] := SaturateSignedWordToUnsignedByte SRC[31:16];
    DEST[55:48] := SaturateSignedWordToUnsignedByte SRC[47:32];
    DEST[63:56] := SaturateSignedWordToUnsignedByte SRC[63:48];

PACKUSWB (Legacy SSE Instruction)
    DEST[7:0] := SaturateSignedWordToUnsignedByte (DEST[15:0]);
    DEST[15:8] := SaturateSignedWordToUnsignedByte (DEST[31:16]);
    DEST[23:16] := SaturateSignedWordToUnsignedByte (DEST[47:32]);
    DEST[31:24] := SaturateSignedWordToUnsignedByte (DEST[63:48]);
    DEST[39:32] := SaturateSignedWordToUnsignedByte (DEST[79:64]);
    DEST[47:40] := SaturateSignedWordToUnsignedByte (DEST[95:80]);
    DEST[55:48] := SaturateSignedWordToUnsignedByte (DEST[111:96]);
    DEST[63:56] := SaturateSignedWordToUnsignedByte (DEST[127:112]);
    DEST[71:64] := SaturateSignedWordToUnsignedByte (SRC[15:0]);
    DEST[79:72] := SaturateSignedWordToUnsignedByte (SRC[31:16]);
    DEST[87:80] := SaturateSignedWordToUnsignedByte (SRC[47:32]);
    DEST[95:88] := SaturateSignedWordToUnsignedByte (SRC[63:48]);
    DEST[103:96] := SaturateSignedWordToUnsignedByte (SRC[79:64]);
    DEST[111:104] := SaturateSignedWordToUnsignedByte (SRC[95:80]);
    DEST[119:112] := SaturateSignedWordToUnsignedByte (SRC[111:96]);
    DEST[127:120] := SaturateSignedWordToUnsignedByte (SRC[127:112]);

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


    DEST[119:112] := SaturateSignedWordToUnsignedByte (SRC2[111:96]);
    DEST[127:120] := SaturateSignedWordToUnsignedByte (SRC2[127:112]);
    DEST[MAXVL-1:128] := 0;

VPACKUSWB (VEX.256 Encoded Version)
    DEST[7:0] := SaturateSignedWordToUnsignedByte (SRC1[15:0]);
    DEST[15:8] := SaturateSignedWordToUnsignedByte (SRC1[31:16]);
    DEST[23:16] := SaturateSignedWordToUnsignedByte (SRC1[47:32]);
    DEST[31:24] := SaturateSignedWordToUnsignedByte (SRC1[63:48]);
    DEST[39:32] := SaturateSignedWordToUnsignedByte (SRC1[79:64]);
    DEST[47:40] := SaturateSignedWordToUnsignedByte (SRC1[95:80]);
    DEST[55:48] := SaturateSignedWordToUnsignedByte (SRC1[111:96]);
    DEST[63:56] := SaturateSignedWordToUnsignedByte (SRC1[127:112]);
    DEST[71:64] := SaturateSignedWordToUnsignedByte (SRC2[15:0]);
    DEST[79:72] := SaturateSignedWordToUnsignedByte (SRC2[31:16]);
    DEST[87:80] := SaturateSignedWordToUnsignedByte (SRC2[47:32]);
    DEST[95:88] := SaturateSignedWordToUnsignedByte (SRC2[63:48]);
    DEST[103:96] := SaturateSignedWordToUnsignedByte (SRC2[79:64]);
    DEST[111:104] := SaturateSignedWordToUnsignedByte (SRC2[95:80]);
    DEST[119:112] := SaturateSignedWordToUnsignedByte (SRC2[111:96]);
    DEST[127:120] := SaturateSignedWordToUnsignedByte (SRC2[127:112]);
    DEST[135:128] := SaturateSignedWordToUnsignedByte (SRC1[143:128]);
    DEST[143:136] := SaturateSignedWordToUnsignedByte (SRC1[159:144]);
    DEST[151:144] := SaturateSignedWordToUnsignedByte (SRC1[175:160]);
    DEST[159:152] := SaturateSignedWordToUnsignedByte (SRC1[191:176]);
    DEST[167:160] := SaturateSignedWordToUnsignedByte (SRC1[207:192]);
    DEST[175:168] := SaturateSignedWordToUnsignedByte (SRC1[223:208]);
    DEST[183:176] := SaturateSignedWordToUnsignedByte (SRC1[239:224]);
    DEST[191:184] := SaturateSignedWordToUnsignedByte (SRC1[255:240]);
    DEST[199:192] := SaturateSignedWordToUnsignedByte (SRC2[143:128]);
    DEST[207:200] := SaturateSignedWordToUnsignedByte (SRC2[159:144]);
    DEST[215:208] := SaturateSignedWordToUnsignedByte (SRC2[175:160]);
    DEST[223:216] := SaturateSignedWordToUnsignedByte (SRC2[191:176]);
    DEST[231:224] := SaturateSignedWordToUnsignedByte (SRC2[207:192]);
    DEST[239:232] := SaturateSignedWordToUnsignedByte (SRC2[223:208]);
    DEST[247:240] := SaturateSignedWordToUnsignedByte (SRC2[239:224]);
    DEST[255:248] := SaturateSignedWordToUnsignedByte (SRC2[255:240]);

VPACKUSWB (EVEX Encoded Versions)
(KL, VL) = (16, 128), (32, 256), (64, 512)
TMP_DEST[7:0] := SaturateSignedWordToUnsignedByte (SRC1[15:0]);
TMP_DEST[15:8] := SaturateSignedWordToUnsignedByte (SRC1[31:16]);
TMP_DEST[23:16] := SaturateSignedWordToUnsignedByte (SRC1[47:32]);
TMP_DEST[31:24] := SaturateSignedWordToUnsignedByte (SRC1[63:48]);
TMP_DEST[39:32] := SaturateSignedWordToUnsignedByte (SRC1[79:64]);
TMP_DEST[47:40] := SaturateSignedWordToUnsignedByte (SRC1[95:80]);
TMP_DEST[55:48] := SaturateSignedWordToUnsignedByte (SRC1[111:96]);
TMP_DEST[63:56] := SaturateSignedWordToUnsignedByte (SRC1[127:112]);
TMP_DEST[71:64] := SaturateSignedWordToUnsignedByte (SRC2[15:0]);
TMP_DEST[79:72] := SaturateSignedWordToUnsignedByte (SRC2[31:16]);
TMP_DEST[87:80] := SaturateSignedWordToUnsignedByte (SRC2[47:32]);
TMP_DEST[95:88] := SaturateSignedWordToUnsignedByte (SRC2[63:48]);
TMP_DEST[103:96] := SaturateSignedWordToUnsignedByte (SRC2[79:64]);
TMP_DEST[111:104] := SaturateSignedWordToUnsignedByte (SRC2[95:80]);


TMP_DEST[119:112] := SaturateSignedWordToUnsignedByte (SRC2[111:96]);
TMP_DEST[127:120] := SaturateSignedWordToUnsignedByte (SRC2[127:112]);
IF VL >= 256

    TMP_DEST[135:128] := SaturateSignedWordToUnsignedByte (SRC1[143:128]);
    TMP_DEST[143:136] := SaturateSignedWordToUnsignedByte (SRC1[159:144]);
    TMP_DEST[151:144] := SaturateSignedWordToUnsignedByte (SRC1[175:160]);
    TMP_DEST[159:152] := SaturateSignedWordToUnsignedByte (SRC1[191:176]);
    TMP_DEST[167:160] := SaturateSignedWordToUnsignedByte (SRC1[207:192]);
    TMP_DEST[175:168] := SaturateSignedWordToUnsignedByte (SRC1[223:208]);
    TMP_DEST[183:176] := SaturateSignedWordToUnsignedByte (SRC1[239:224]);
    TMP_DEST[191:184] := SaturateSignedWordToUnsignedByte (SRC1[255:240]);
    TMP_DEST[199:192] := SaturateSignedWordToUnsignedByte (SRC2[143:128]);
    TMP_DEST[207:200] := SaturateSignedWordToUnsignedByte (SRC2[159:144]);
    TMP_DEST[215:208] := SaturateSignedWordToUnsignedByte (SRC2[175:160]);
    TMP_DEST[223:216] := SaturateSignedWordToUnsignedByte (SRC2[191:176]);
    TMP_DEST[231:224] := SaturateSignedWordToUnsignedByte (SRC2[207:192]);
    TMP_DEST[239:232] := SaturateSignedWordToUnsignedByte (SRC2[223:208]);
    TMP_DEST[247:240] := SaturateSignedWordToUnsignedByte (SRC2[239:224]);
    TMP_DEST[255:248] := SaturateSignedWordToUnsignedByte (SRC2[255:240]);
FI;
IF VL >= 512
    TMP_DEST[263:256] := SaturateSignedWordToUnsignedByte (SRC1[271:256]);
    TMP_DEST[271:264] := SaturateSignedWordToUnsignedByte (SRC1[287:272]);
    TMP_DEST[279:272] := SaturateSignedWordToUnsignedByte (SRC1[303:288]);
    TMP_DEST[287:280] := SaturateSignedWordToUnsignedByte (SRC1[319:304]);
    TMP_DEST[295:288] := SaturateSignedWordToUnsignedByte (SRC1[335:320]);
    TMP_DEST[303:296] := SaturateSignedWordToUnsignedByte (SRC1[351:336]);
    TMP_DEST[311:304] := SaturateSignedWordToUnsignedByte (SRC1[367:352]);
    TMP_DEST[319:312] := SaturateSignedWordToUnsignedByte (SRC1[383:368]);

    TMP_DEST[327:320] := SaturateSignedWordToUnsignedByte (SRC2[271:256]);
    TMP_DEST[335:328] := SaturateSignedWordToUnsignedByte (SRC2[287:272]);
    TMP_DEST[343:336] := SaturateSignedWordToUnsignedByte (SRC2[303:288]);
    TMP_DEST[351:344] := SaturateSignedWordToUnsignedByte (SRC2[319:304]);
    TMP_DEST[359:352] := SaturateSignedWordToUnsignedByte (SRC2[335:320]);
    TMP_DEST[367:360] := SaturateSignedWordToUnsignedByte (SRC2[351:336]);
    TMP_DEST[375:368] := SaturateSignedWordToUnsignedByte (SRC2[367:352]);
    TMP_DEST[383:376] := SaturateSignedWordToUnsignedByte (SRC2[383:368]);

    TMP_DEST[391:384] := SaturateSignedWordToUnsignedByte (SRC1[399:384]);
    TMP_DEST[399:392] := SaturateSignedWordToUnsignedByte (SRC1[415:400]);
    TMP_DEST[407:400] := SaturateSignedWordToUnsignedByte (SRC1[431:416]);
    TMP_DEST[415:408] := SaturateSignedWordToUnsignedByte (SRC1[447:432]);
    TMP_DEST[423:416] := SaturateSignedWordToUnsignedByte (SRC1[463:448]);
    TMP_DEST[431:424] := SaturateSignedWordToUnsignedByte (SRC1[479:464]);
    TMP_DEST[439:432] := SaturateSignedWordToUnsignedByte (SRC1[495:480]);
    TMP_DEST[447:440] := SaturateSignedWordToUnsignedByte (SRC1[511:496]);

    TMP_DEST[455:448] := SaturateSignedWordToUnsignedByte (SRC2[399:384]);
    TMP_DEST[463:456] := SaturateSignedWordToUnsignedByte (SRC2[415:400]);
    TMP_DEST[471:464] := SaturateSignedWordToUnsignedByte (SRC2[431:416]);
    TMP_DEST[479:472] := SaturateSignedWordToUnsignedByte (SRC2[447:432]);
    TMP_DEST[487:480] := SaturateSignedWordToUnsignedByte (SRC2[463:448]);
    TMP_DEST[495:488] := SaturateSignedWordToUnsignedByte (SRC2[479:464]);


     TMP_DEST[503:496] := SaturateSignedWordToUnsignedByte (SRC2[495:480]);

     TMP_DEST[511:504] := SaturateSignedWordToUnsignedByte (SRC2[511:496]);

FI;

FOR j := 0 TO KL-1

     i := j * 8

     IF k1[j] OR *no writemask*

          THEN

                 DEST[i+7:i] := TMP_DEST[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

Intel C/C++ compilador intrínseco

VPACKUSWB __m512i _mm512_packus_epi16(__m512i m1, __m512i m2);
VPACKUSWB __m512i _mm512_mask_packus_epi16(__m512i s, __mmask64 k, __m512i m1, __m512i m2);
VPACKUSWB __m512i _mm512_maskz_packus_epi16(__mmask64 k, __m512i m1, __m512i m2);
VPACKUSWB __m256i _mm256_mask_packus_epi16(__m256i s, __mmask32 k, __m256i m1, __m256i m2);
VPACKUSWB __m256i _mm256_maskz_packus_epi16(__mmask32 k, __m256i m1, __m256i m2);
VPACKUSWB __m128i _mm_mask_packus_epi16(__m128i s, __mmask16 k, __m128i m1, __m128i m2);
VPACKUSWB __m128i _mm_maskz_packus_epi16(__mmask16 k, __m128i m1, __m128i m2);
PACKUSWB __m64 _mm_packs_pu16(__m64 m1, __m64 m2) (V)PACKUSWB __m128i _mm_packus_epi16(__m128i m1, __m128i m2) VPACKUSWB __m256i _mm256_packus_epi16(__m256i m1, __m256i m2);

Banderas afectadas

None.

SIMD coma flotante Excepciones

None.

Otras excepciones

Instrucciones no codificadas por EVEX, ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase." Instruccion codificada por EVEX, ver Excepciones Tipo E4NF.nb en Tabla 2-52, "Tipo E4NF Condiciones de Excepción de Clase".

Fuentes