Vesta
Español
Código fuente

GF2P8MULB

Galois Field Multiply Bytes

estableVMJITAOTinstruccion

Codificaciones

OpcodeInstruccionOp/En64 bitsCompat/LegacyDescripcion
66 0F38 CF /rGF2P8MULB xmm1, xmm2/m128AValidoValidoMultiplica elementos en el campo finito GF(2^8).
VEX.128.66.0F38.W0 CF /rVGF2P8MULB xmm1, xmm2, xmm3/m128BValidoValidoMultiplica elementos en el campo finito GF(2^8). GFNI
VEX.256.66.0F38.W0 CF /rVGF2P8MULB ymm1, ymm2, ymm3/m256BValidoValidoMultiplica elementos en el campo finito GF(2^8). GFNI
EVEX.128.66.0F38.W0 CF /rVGF2P8MULB xmm1{k1}{z}, xmm2, xmm3/m128CValidoValidoMultiplica elementos en el campo finito GF(2^8). OR AVX10.1) GFNI
EVEX.256.66.0F38.W0 CF /rVGF2P8MULB ymm1{k1}{z}, ymm2, ymm3/m256CValidoValidoMultiplica elementos en el campo finito GF(2^8). OR AVX10.1) GFNI
EVEX.512.66.0F38.W0 CF /rVGF2P8MULB zmm1{k1}{z}, zmm2, zmm3/m512CValidoValidoMultiplica elementos en el campo finito GF(2^8). OR AVX10.1) GFNI

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

La instrucción multiplica elementos en el campo finito GF(28), operando en un byte (elemento de campo) en el primer operando de origen y el byte correspondiente en un segundo operando de origen. El campo GF(28) está representado en representación polinomio con la reducción polinomio x8 + x4 + x3 + x + 1.

Esta instrucción no apoya la transmisión.

La forma codificada EVEX de esta instrucción es compatible con la supresión de fallas de memoria. Las formas codificadas SSE de la instrucción requieren alineación16B en sus operaciones de memoria.

Operación

define gf2p8mul_byte(src1byte, src2byte):

tword := 0
FOR i := 0 to 7:

IF src2byte.bit[i]:

           tword := tword XOR (src1byte<< i)

* carry out polynomial reduction by the characteristic polynomial p*

FOR i := 14 downto 8:
p := 0x11B << (i-8)
                                        *0x11B = 0000_0001_0001_1011 in binary*

IF tword.bit[i]:

           tword := tword XOR p

return tword.byte[0]

VGF2P8MULB dest, src1, src2 (EVEX Encoded Version)

(KL, VL) = (16, 128), (32, 256), (64, 512)
FOR j := 0 TO KL-1:

    IF k1[j] OR *no writemask*:
         DEST.byte[j] := gf2p8mul_byte(SRC1.byte[j], SRC2.byte[j])

    ELSE IF *zeroing*:
         DEST.byte[j] := 0

    * ELSE DEST.byte[j] remains unchanged*
DEST[MAX_VL-1:VL] := 0

VGF2P8MULB dest, src1, src2 (128b and 256b VEX Encoded Versions)

(KL, VL) = (16, 128), (32, 256)
FOR j := 0 TO KL-1:

    DEST.byte[j] := gf2p8mul_byte(SRC1.byte[j], SRC2.byte[j])
DEST[MAX_VL-1:VL] := 0

GF2P8MULB srcdest, src1 (128b SSE Encoded Version)
FOR j := 0 TO 15:

    SRCDEST.byte[j] :=gf2p8mul_byte(SRCDEST.byte[j], SRC1.byte[j])

Intel C/C++ compilador intrínseco

(V)GF2P8MULB __m128i _mm_gf2p8mul_epi8(__m128i, __m128i);
(V)GF2P8MULB __m128i _mm_mask_gf2p8mul_epi8(__m128i, __mmask16, __m128i, __m128i);
(V)GF2P8MULB __m128i _mm_maskz_gf2p8mul_epi8(__mmask16, __m128i, __m128i);
VGF2P8MULB __m256i _mm256_gf2p8mul_epi8(__m256i, __m256i);
VGF2P8MULB __m256i _mm256_mask_gf2p8mul_epi8(__m256i, __mmask32, __m256i, __m256i);
VGF2P8MULB __m256i _mm256_maskz_gf2p8mul_epi8(__mmask32, __m256i, __m256i);
VGF2P8MULB __m512i _mm512_gf2p8mul_epi8(__m512i, __m512i);
VGF2P8MULB __m512i _mm512_mask_gf2p8mul_epi8(__m512i, __mmask64, __m512i, __m512i);
VGF2P8MULB __m512i _mm512_maskz_gf2p8mul_epi8(__mmask64, __m512i, __m512i);

SIMD coma flotante Excepciones

None.

Otras excepciones

Legacy-encoded and VEX-encoded: Ver Tabla 2-21, "Tipo 4 Condiciones de Excepción de Clase." EVEX-encoded: Ver Tabla 2-51, "Tipo E4 Clase Condiciones de Excepción".

Fuentes