[x86][icelake]GFNI

[coby]

Summary

galios field arithmetic (GF(2^8)) insns:
gf2p8affineinvqb
gf2p8affineqb
gf2p8mulb

[craig.topper]

lib/Support/Host.cpp

1479

This needs to be rebased. The current code is here is ordered by bit position and nicely formatted. Please insert this bit in the correct position in the code

lib/Target/X86/X86ISelLowering.cpp

19568

I have trouble believing you need a 2OP_MASKZ. Can't the caller pass the zero vector to the mask version like we do for everything else? The reason we have OP3_MASKZ is because the OP3_MASK uses the passthru input in both the select op and the operation. So we needed a separate intrinsic to define the zero semantics of the select independent of the operation.

19652

Again I think you can pass the zero vector to the masked intrinsic when its called.

[craig.topper]

lib/Target/X86/X86InstrAVX512.td

9813

This requires BWI in order to make v64i8 a legal type.

[craig.topper]

lib/Target/X86/X86ISelLowering.cpp

19568

sorry that should have said FMA_MASKZ not OP3_MASKZ.

[coby]

lib/Target/X86/X86ISelLowering.cpp

19568

interesting
is this logic applies to anywhere else a MASKZ variant is being used?
nevertheless you are correct, i'll remove the (self) added Z variants

[coby]

lib/Target/X86/X86InstrAVX512.td

9813

just noted i've nonchalantly added to the test but omitted it here
thanks

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1356

Please sync the GCCBuiltin names with gcc.

[craig.topper]

lib/Target/X86/X86InstrAVX512.td

9816

Go ahead and add BWI here too. It may not be strictly necessary, but a lot of the masking support for bytes and words is dependent on it. It's also consistent with gcc.

[coby]

include/llvm/IR/IntrinsicsX86.td

1356

basically does weren't yet introduced to gcc, so the closest we can get is Julia Kovel's GFNI respective ongoing patch(s), i.e. https://gcc.gnu.org/ml/gcc-patches/2017-10/msg01043/0002-GF2P8AFFINEINVQB-instruction.patch

[coby]

include/llvm/IR/IntrinsicsX86.td

1356

does ~~> those

[craig.topper]

k

include/llvm/IR/IntrinsicsX86.td

1356

They look to have been committed to gcc on Nov. 16. svn revision 254795

[coby]

include/llvm/IR/IntrinsicsX86.td

1356

Oh, I see. kyukhin.
i'll match against it, thanks

[coby]

adopted changes proposed by Craig:
maskz variants are out in favor of explicit passing of the additive identity
BWI dependency is explicitly stated
GCC builtins counterparts are matched
+ nice formatting of feature recognition

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1355

Can we use builtin_ia32_selectb_512 and builtin_ia32_vgf2p8affineinvqb_v16qi to implement these in the clang header instead of adding a separate masked intrinsic?

Its different than gcc, but consistent with other intrinsics in clang/llvm.

You should add __builtin_ia32_vgf2p8affineinvqb_v64qi without masking so that it can be consistent.

1415

I'd prefer to see this named int_x86_gf2p8affineqb_128 and the 256-bit one named int_x86_gf2p8affineqb_256.

1431

Name this _256 and the one above _128.

lib/Target/X86/X86.td

158

Isn't it Galois not Galios

lib/Target/X86/X86ISelLowering.h

560

Galois

lib/Target/X86/X86InstrFragmentsSIMD.td

603

galois

lib/Target/X86/X86InstrSSE.td

8470

NoVLX should be NoVLX_Or_NoBWI

[coby]

include/llvm/IR/IntrinsicsX86.td

1355

certainly
so you propose introducing only non-masked variants on the llvm-side for gfni as a whole?

[coby]

lib/Target/X86/X86.td

158

Evariste *Galois*, indeed.
thx

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1355

Yep that's what I'm proposing.

[coby]

addressed Craig's comments

[craig.topper]

LGTM, but can you also add tests with select instructions for testing that merge masking and zero masking behavior either as part of this or as a follow up.

include/llvm/IR/IntrinsicsX86.td

let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
 
   def int_x86_avx512_mask_shuf_i64x2 :
          GCCBuiltin<"__builtin_ia32_shuf_i64x2_mask">,
           Intrinsic<[llvm_v8i64_ty],
           [llvm_v8i64_ty, llvm_v8i64_ty, llvm_i32_ty, llvm_v8i64_ty, llvm_i8_ty],
           [IntrNoMem]>;
 }
 
+// GFNI Instructions
+let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
+  // AVX512
+  def int_x86_avx512_mask_vgf2p8affineinvqb_128 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_128_mask">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i16_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_mask_vgf2p8affineinvqb_256 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_256_mask">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty, llvm_v32i8_ty, llvm_i32_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_mask_vgf2p8affineinvqb_512 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_512_mask">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i32_ty, llvm_v64i8_ty, llvm_i64_ty],
+          [IntrNoMem]>;
+
+  def int_x86_avx512_mask_vgf2p8affineqb_128 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_128_mask">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i16_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_mask_vgf2p8affineqb_256 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_256_mask">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty, llvm_v32i8_ty, llvm_i32_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_mask_vgf2p8affineqb_512 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_512_mask">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i32_ty, llvm_v64i8_ty, llvm_i64_ty],
+          [IntrNoMem]>;
+
+  def int_x86_avx512_mask_vgf2p8mulb_128     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_128_mask">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty, llvm_i16_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_mask_vgf2p8mulb_256     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_256_mask">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_mask_vgf2p8mulb_512     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_512_mask">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_v64i8_ty, llvm_i64_ty],
+          [IntrNoMem]>;
+
+  def int_x86_avx512_maskz_vgf2p8affineinvqb_128 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_128_maskz">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i16_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_maskz_vgf2p8affineinvqb_256 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_256_maskz">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty, llvm_v32i8_ty, llvm_i32_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_maskz_vgf2p8affineinvqb_512 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_512_maskz">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i32_ty, llvm_v64i8_ty, llvm_i64_ty],
+          [IntrNoMem]>;
+
+  def int_x86_avx512_maskz_vgf2p8affineqb_128 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_128_maskz">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i32_ty, llvm_v16i8_ty, llvm_i16_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_maskz_vgf2p8affineqb_256 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_256_maskz">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty, llvm_v32i8_ty, llvm_i32_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_maskz_vgf2p8affineqb_512 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_512_maskz">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i32_ty, llvm_v64i8_ty, llvm_i64_ty],
+          [IntrNoMem]>;
+
+  def int_x86_avx512_maskz_vgf2p8mulb_128     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_128_maskz">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_v16i8_ty, llvm_i16_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_maskz_vgf2p8mulb_256     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_256_maskz">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_v32i8_ty, llvm_i32_ty],
+          [IntrNoMem]>;
+  def int_x86_avx512_maskz_vgf2p8mulb_512     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_512_maskz">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_v64i8_ty, llvm_i64_ty],
+          [IntrNoMem]>;
+
+  // SSE, AVX
+  def int_x86_gf2p8affineinvqb  :
+          GCCBuiltin<"__builtin_ia32_gf2p8affineinvqb">,
+           Intrinsic<[llvm_v16i8_ty],
+           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+  def int_x86_vgf2p8affineinvqb :
+          GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb">,
+           Intrinsic<[llvm_v32i8_ty],
+           [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+
+  def int_x86_gf2p8affineqb     :
+          GCCBuiltin<"__builtin_ia32_gf2p8affineqb">,
+           Intrinsic<[llvm_v16i8_ty],
+           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+  def int_x86_vgf2p8affineqb    :
+          GCCBuiltin<"__builtin_ia32_vgf2p8affineqb">,
+           Intrinsic<[llvm_v32i8_ty],
+           [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+
+  def int_x86_gf2p8mulb         :
+          GCCBuiltin<"__builtin_ia32_gf2p8mulb">,
+           Intrinsic<[llvm_v16i8_ty],
+           [llvm_v16i8_ty, llvm_v16i8_ty],
+           [IntrNoMem]>;
+  def int_x86_vgf2p8mulb        :
+          GCCBuiltin<"__builtin_ia32_vgf2p8mulb_256">,
+           Intrinsic<[llvm_v32i8_ty],
+           [llvm_v32i8_ty, llvm_v32i8_ty],
+           [IntrNoMem]>;
+}
+
 // Vector blend
 let TargetPrefix = "x86" in {  // All intrinsics start with "llvm.x86.".
   def int_x86_avx_blendv_pd_256 : GCCBuiltin<"__builtin_ia32_blendvpd256">,
         Intrinsic<[llvm_v4f64_ty], [llvm_v4f64_ty,
                   llvm_v4f64_ty, llvm_v4f64_ty], [IntrNoMem]>;
   def int_x86_avx_blendv_ps_256 : GCCBuiltin<"__builtin_ia32_blendvps256">,
         Intrinsic<[llvm_v8f32_ty], [llvm_v8f32_ty,
                   llvm_v8f32_ty, llvm_v8f32_ty], [IntrNoMem]>;

lib/Support/Host.cpp

bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
   Features["avx512vl"] = HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save;
 
   Features["prefetchwt1"] = HasLeaf7 && (ECX & 1);
   Features["avx512vbmi"] = HasLeaf7 && ((ECX >> 1) & 1) && HasAVX512Save;
   Features["avx512vpopcntdq"] = HasLeaf7 && ((ECX >> 14) & 1) && HasAVX512Save;
   // Enable protection keys
   Features["pku"] = HasLeaf7 && ((ECX >> 4) & 1);
 
+  // Enable Galios Field Arithmetics
+  Features["gfni"] = HasLeaf7 && ((ECX >> 8) & 1);
+
   bool HasLeafD = MaxLevel >= 0xd &&
                   !getX86CpuIDAndInfoEx(0xd, 0x1, &EAX, &EBX, &ECX, &EDX);
 
   // Only enable XSAVE if OS has enabled support for saving YMM state.
   Features["xsaveopt"] = HasAVXSave && HasLeafD && ((EAX >> 0) & 1);
   Features["xsavec"] = HasAVXSave && HasLeafD && ((EAX >> 1) & 1);
   Features["xsaves"] = HasAVXSave && HasLeafD && ((EAX >> 3) & 1);
 

lib/Target/X86/X86.td

 def FeatureIFMA     : SubtargetFeature<"avx512ifma", "HasIFMA", "true",
                       "Enable AVX-512 Integer Fused Multiple-Add",
                                       [FeatureAVX512]>;
 def FeaturePKU   : SubtargetFeature<"pku", "HasPKU", "true",
                       "Enable protection keys">;
 def FeaturePCLMUL  : SubtargetFeature<"pclmul", "HasPCLMUL", "true",
                          "Enable packed carry-less multiplication instructions",
                                [FeatureSSE2]>;
+def FeatureGFNI    : SubtargetFeature<"gfni", "HasGFNI", "true",
+                         "Enable Galios Field Arithmetic Instructions",
+                               [FeatureSSE2]>;
 def FeatureFMA     : SubtargetFeature<"fma", "HasFMA", "true",
                                       "Enable three-operand fused multiple-add",
                                       [FeatureAVX]>;
 def FeatureFMA4    : SubtargetFeature<"fma4", "HasFMA4", "true",
                                       "Enable four-operand fused multiple-add",
                                       [FeatureAVX, FeatureSSE4A]>;
 def FeatureXOP     : SubtargetFeature<"xop", "HasXOP", "true",
                                       "Enable XOP instructions",

lib/Target/X86/X86ISelLowering.h

enum NodeType : unsigned {
       XTEST,
 
       // ERI instructions.
       RSQRT28, RSQRT28S, RCP28, RCP28S, EXP2,
 
       // Conversions between float and half-float.
       CVTPS2PH, CVTPH2PS,
 
+      // Galios Field Arithmetic Instructions
+      GF2P8AFFINEINVQB, GF2P8AFFINEQB, GF2P8MULB,
+
       // LWP insert record.
       LWPINS,
 
       // Compare and swap.
       LCMPXCHG_DAG = ISD::FIRST_TARGET_MEMORY_OPCODE,
       LCMPXCHG8_DAG,
       LCMPXCHG16_DAG,
       LCMPXCHG8_SAVE_EBX_DAG,

lib/Target/X86/X86ISelLowering.cpp

case INTR_TYPE_SCALAR_MASK_RM: {
       assert(Op.getNumOperands() == 7 && "Unexpected intrinsic form");
       SDValue RoundingMode  = Op.getOperand(5);
       SDValue Sae  = Op.getOperand(6);
       return getScalarMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT, Src1, Src2,
                                               RoundingMode, Sae),
                                   Mask, Src0, Subtarget, DAG);
     }
     case INTR_TYPE_2OP_MASK:
+    case INTR_TYPE_2OP_MASKZ:
     case INTR_TYPE_2OP_IMM8_MASK: {
       SDValue Src1 = Op.getOperand(1);
       SDValue Src2 = Op.getOperand(2);
-      SDValue PassThru = Op.getOperand(3);
+      SDValue PassThru = IntrData->Type == INTR_TYPE_2OP_MASKZ ?
+        getZeroVector(Op.getSimpleValueType(), Subtarget, DAG, dl)  :
+        Op.getOperand(3);
       SDValue Mask = Op.getOperand(4);
 
       if (IntrData->Type == INTR_TYPE_2OP_IMM8_MASK)
         Src2 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Src2);
 
       // We specify 2 possible opcodes for intrinsics with rounding modes.
       // First, we check if the intrinsic may have non-default rounding mode,
       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
case INTR_TYPE_3OP_MASK_RM: {
         Rnd = Op.getOperand(6);
       else
         Rnd = DAG.getConstant(X86::STATIC_ROUNDING::CUR_DIRECTION, dl, MVT::i32);
       return getVectorMaskingNode(DAG.getNode(IntrData->Opc0, dl, VT,
                                               Src1, Src2, Imm, Rnd),
                                   Mask, PassThru, Subtarget, DAG);
     }
     case INTR_TYPE_3OP_IMM8_MASK:
+    case INTR_TYPE_3OP_IMM8_MASKZ:
     case INTR_TYPE_3OP_MASK: {
       SDValue Src1 = Op.getOperand(1);
       SDValue Src2 = Op.getOperand(2);
       SDValue Src3 = Op.getOperand(3);
-      SDValue PassThru = Op.getOperand(4);
+      SDValue PassThru = IntrData->Type == INTR_TYPE_3OP_IMM8_MASKZ ?
+        getZeroVector(Op.getSimpleValueType(), Subtarget, DAG, dl)  :
+        Op.getOperand(4);
       SDValue Mask = Op.getOperand(5);
 
       if (IntrData->Type == INTR_TYPE_3OP_IMM8_MASK)
         Src3 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i8, Src3);
 
       // We specify 2 possible opcodes for intrinsics with rounding modes.
       // First, we check if the intrinsic may have non-default rounding mode,
       // (IntrData->Opc1 != 0), then we check the rounding mode operand.
const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
   case X86ISD::CVTP2SI:            return "X86ISD::CVTP2SI";
   case X86ISD::CVTP2UI:            return "X86ISD::CVTP2UI";
   case X86ISD::CVTP2SI_RND:        return "X86ISD::CVTP2SI_RND";
   case X86ISD::CVTP2UI_RND:        return "X86ISD::CVTP2UI_RND";
   case X86ISD::CVTS2SI_RND:        return "X86ISD::CVTS2SI_RND";
   case X86ISD::CVTS2UI_RND:        return "X86ISD::CVTS2UI_RND";
   case X86ISD::LWPINS:             return "X86ISD::LWPINS";
   case X86ISD::MGATHER:            return "X86ISD::MGATHER";
+  case X86ISD::GF2P8AFFINEINVQB:   return "X86ISD::GF2P8AFFINEINVQB";
+  case X86ISD::GF2P8AFFINEQB:      return "X86ISD::GF2P8AFFINEQB";
+  case X86ISD::GF2P8MULB:          return "X86ISD::GF2P8MULB";
   }
   return nullptr;
 }
 
 /// Return true if the addressing mode represented by AM is legal for this
 /// target, for a load/store of the specified type.
 bool X86TargetLowering::isLegalAddressingMode(const DataLayout &DL,
                                               const AddrMode &AM, Type *Ty,

lib/Target/X86/X86InstrAVX512.td

def : Pat<(X86Movsd (v2f64 VR128X:$src1),
           (COPY_TO_REGCLASS FR64X:$src2, VR128X))>;
   }
 }
 
 defm : AVX512_scalar_math_f64_patterns<fadd, "ADD">;
 defm : AVX512_scalar_math_f64_patterns<fsub, "SUB">;
 defm : AVX512_scalar_math_f64_patterns<fmul, "MUL">;
 defm : AVX512_scalar_math_f64_patterns<fdiv, "DIV">;
+
+//===----------------------------------------------------------------------===//
+// GFNI
+//===----------------------------------------------------------------------===//
+
+multiclass GF2P8MULB_avx512_common<bits<8> Op, string OpStr, SDNode OpNode> {
+  let Predicates = [HasGFNI, HasAVX512] in
+  defm Z      : avx512_binop_rm<Op, OpStr, OpNode, v64i8_info,
+                                SSE_INTALU_ITINS_P, 1>, EVEX_V512;
+  let Predicates = [HasGFNI, HasVLX] in {
+    defm Z256 : avx512_binop_rm<Op, OpStr, OpNode, v32i8x_info,
+                                SSE_INTALU_ITINS_P, 1>, EVEX_V256;
+    defm Z128 : avx512_binop_rm<Op, OpStr, OpNode, v16i8x_info,
+                                SSE_INTALU_ITINS_P, 1>, EVEX_V128;
+  }
+}
+
+defm GF2P8MULB : GF2P8MULB_avx512_common<0xCF, "vgf2p8mulb", X86GF2P8mulb>,
+                 EVEX_CD8<8, CD8VF>, T8PD;
+
+multiclass GF2P8AFFINE_avx512_rmb_imm<bits<8> Op, string OpStr, SDNode OpNode,
+                                      X86VectorVTInfo VTI,
+                                      X86VectorVTInfo BcstVTI>
+           : avx512_3Op_rm_imm8<Op, OpStr, OpNode, VTI, VTI> {
+  let ExeDomain = VTI.ExeDomain in
+  defm rmbi : AVX512_maskable<Op, MRMSrcMem, VTI, (outs VTI.RC:$dst),
+                (ins VTI.RC:$src1, VTI.ScalarMemOp:$src2, u8imm:$src3),
+                OpStr, "$src3, ${src2}"##BcstVTI.BroadcastStr##", $src1",
+                "$src1, ${src2}"##BcstVTI.BroadcastStr##", $src3",
+                (OpNode (VTI.VT VTI.RC:$src1),
+                 (bitconvert (BcstVTI.VT (X86VBroadcast (loadi64 addr:$src2)))),
+                 (i8 imm:$src3))>, EVEX_B;
+}
+
+multiclass GF2P8AFFINE_avx512_common<bits<8> Op, string OpStr, SDNode OpNode> {
+  let Predicates = [HasGFNI, HasAVX512] in
+  defm Z      : GF2P8AFFINE_avx512_rmb_imm<Op, OpStr, OpNode, v64i8_info,
+                                           v8i64_info>, EVEX_V512;
+  let Predicates = [HasGFNI, HasVLX] in {
+    defm Z256 : GF2P8AFFINE_avx512_rmb_imm<Op, OpStr, OpNode, v32i8x_info,
+                                           v4i64x_info>, EVEX_V256;
+    defm Z128 : GF2P8AFFINE_avx512_rmb_imm<Op, OpStr, OpNode, v16i8x_info,
+                                           v2i64x_info>, EVEX_V128;
+  }
+}
+
+defm GF2P8AFFINEINVQB : GF2P8AFFINE_avx512_common<0xCF, "vgf2p8affineinvqb",
+                                                  X86GF2P8affineinvqb>,
+                        EVEX_4V, EVEX_CD8<8, CD8VF>, VEX_W, AVX512AIi8Base;
+defm GF2P8AFFINEQB    : GF2P8AFFINE_avx512_common<0xCE, "vgf2p8affineqb",
+                                                  X86GF2P8affineqb>,
+                        EVEX_4V, EVEX_CD8<8, CD8VF>, VEX_W, AVX512AIi8Base;
+

lib/Target/X86/X86InstrFragmentsSIMD.td

 def X86vfproundRnd: SDNode<"X86ISD::VFPROUND_RND",
                         SDTypeProfile<1, 2, [SDTCVecEltisVT<0, f32>,
                                              SDTCVecEltisVT<1, f64>,
                                              SDTCisOpSmallerThanOp<0, 1>,
                                              SDTCisVT<2, i32>]>>;
 
 def X86cvt2mask   : SDNode<"X86ISD::CVT2MASK", SDTIntTruncOp>;
 
+// galios field arithmetic
+def X86GF2P8affineinvqb : SDNode<"X86ISD::GF2P8AFFINEINVQB", SDTBlend>;
+def X86GF2P8affineqb    : SDNode<"X86ISD::GF2P8AFFINEQB", SDTBlend>;
+def X86GF2P8mulb        : SDNode<"X86ISD::GF2P8MULB", SDTIntBinOp>;
+
 //===----------------------------------------------------------------------===//
 // SSE Complex Patterns
 //===----------------------------------------------------------------------===//
 
 // These are 'extloads' from a scalar to the low element of a vector, zeroing
 // the top elements.  These are used for the SSE 'ss' and 'sd' instruction
 // forms.
 def sse_load_f32 : ComplexPattern<v4f32, 5, "selectScalarSSELoad", [],

lib/Target/X86/X86InstrInfo.td

 def HasPOPCNT    : Predicate<"Subtarget->hasPOPCNT()">;
 def HasAES       : Predicate<"Subtarget->hasAES()">;
 def HasFXSR      : Predicate<"Subtarget->hasFXSR()">;
 def HasXSAVE     : Predicate<"Subtarget->hasXSAVE()">;
 def HasXSAVEOPT  : Predicate<"Subtarget->hasXSAVEOPT()">;
 def HasXSAVEC    : Predicate<"Subtarget->hasXSAVEC()">;
 def HasXSAVES    : Predicate<"Subtarget->hasXSAVES()">;
 def HasPCLMUL    : Predicate<"Subtarget->hasPCLMUL()">;
+def HasGFNI      : Predicate<"Subtarget->hasGFNI()">;
 def HasFMA       : Predicate<"Subtarget->hasFMA()">;
 def HasFMA4      : Predicate<"Subtarget->hasFMA4()">;
 def HasXOP       : Predicate<"Subtarget->hasXOP()">;
 def HasTBM       : Predicate<"Subtarget->hasTBM()">;
 def NoTBM        : Predicate<"!Subtarget->hasTBM()">;
 def HasLWP       : Predicate<"Subtarget->hasLWP()">;
 def HasMOVBE     : Predicate<"Subtarget->hasMOVBE()">;
 def HasRDRAND    : Predicate<"Subtarget->hasRDRAND()">;

lib/Target/X86/X86InstrSSE.td

def : Pat<(X86fxor FR128:$src1, FR128:$src2),
           (COPY_TO_REGCLASS
            (XORPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
                     (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
 
 def : Pat<(xor FR128:$src1, FR128:$src2),
           (COPY_TO_REGCLASS
            (XORPSrr (COPY_TO_REGCLASS FR128:$src1, VR128),
                     (COPY_TO_REGCLASS FR128:$src2, VR128)), FR128)>;
+
+//===----------------------------------------------------------------------===//
+// GFNI instructions
+//===----------------------------------------------------------------------===//
+
+multiclass GF2P8MULB_rm<string OpcodeStr, Intrinsic IntId,
+                        RegisterClass RC, PatFrag MemOpFrag,
+                        X86MemOperand X86MemOp, bit Is2Addr = 0> {
+  let ExeDomain = SSEPackedInt,
+      AsmString = !if(Is2Addr,
+        OpcodeStr##"\t{$src2, $dst|$dst, $src2}",
+        OpcodeStr##"\t{$src2, $src1, $dst|$dst, $src1, $src2}") in {
+    let isCommutable = 1 in
+    def rr : PDI<0xCF, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2), "",
+                 [(set RC:$dst, (IntId RC:$src1, RC:$src2))],
+                 SSE_INTALU_ITINS_P.rr>,
+             Sched<[SSE_INTALU_ITINS_P.Sched]>, T8PD;
+
+    def rm : PDI<0xCF, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, X86MemOp:$src2), "",
+                 [(set RC:$dst, (IntId RC:$src1,
+                                 (bitconvert (MemOpFrag addr:$src2))))],
+                 SSE_INTALU_ITINS_P.rm>,
+             Sched<[SSE_INTALU_ITINS_P.Sched.Folded, ReadAfterLd]>, T8PD;
+  }
+}
+
+multiclass GF2P8AFFINE_rmi<bits<8> Op, string OpStr, Intrinsic IntId,
+                           RegisterClass RC, PatFrag MemOpFrag,
+                           X86MemOperand X86MemOp, bit Is2Addr = 0> {
+  let AsmString = !if(Is2Addr,
+      OpStr##"\t{$src3, $src2, $dst|$dst, $src2, $src3}",
+      OpStr##"\t{$src3, $src2, $src1, $dst|$dst, $src1, $src2, $src3}") in {
+  def rri : Ii8<Op, MRMSrcReg, (outs RC:$dst),
+              (ins RC:$src1, RC:$src2, u8imm:$src3), "",
+              [(set RC:$dst, (IntId RC:$src1, RC:$src2, imm:$src3))],
+              SSE_INTALU_ITINS_P.rr, SSEPackedInt>,
+              Sched<[WriteVecALU]>;
+  def rmi : Ii8<Op, MRMSrcMem, (outs RC:$dst),
+              (ins RC:$src1, X86MemOp:$src2, u8imm:$src3), "",
+              [(set RC:$dst, (IntId RC:$src1, (bitconvert (MemOpFrag addr:$src2)),
+                              imm:$src3))],
+              SSE_INTALU_ITINS_P.rm, SSEPackedInt>,
+              Sched<[WriteVecALU.Folded, ReadAfterLd]>;
+  }
+}
+
+multiclass GF2P8AFFINE_common<bits<8> Op, string OpStr> {
+  let Constraints = "$src1 = $dst",
+      Predicates  = [HasGFNI, UseSSE2] in
+  defm NAME         : GF2P8AFFINE_rmi<Op, OpStr,
+                                      !cast<Intrinsic>("int_x86_"##OpStr),
+                                      VR128, loadv2i64, i128mem, 1>;
+  let Predicates  = [HasGFNI, HasAVX, NoVLX] in {
+    defm V##NAME    : GF2P8AFFINE_rmi<Op, "v"##OpStr,
+                                      !cast<Intrinsic>("int_x86_"##OpStr),
+                                      VR128, loadv2i64, i128mem>, VEX_4V, VEX_W;
+    defm V##NAME##Y : GF2P8AFFINE_rmi<Op, "v"##OpStr,
+                                      !cast<Intrinsic>("int_x86_v"##OpStr), VR256,
+                                      loadv4i64, i256mem>, VEX_4V, VEX_L, VEX_W;
+  }
+}
+
+// GF2P8MULB
+let Constraints = "$src1 = $dst",
+    Predicates  = [HasGFNI, UseSSE2] in
+defm GF2P8MULB      : GF2P8MULB_rm<"gf2p8mulb", int_x86_gf2p8mulb, VR128,
+                                    memopv2i64, i128mem, 1>;
+let Predicates  = [HasGFNI, HasAVX, NoVLX] in {
+  defm VGF2P8MULB   : GF2P8MULB_rm<"vgf2p8mulb", int_x86_gf2p8mulb, VR128,
+                                   loadv2i64, i128mem>, VEX_4V;
+  defm VGF2P8MULBY  : GF2P8MULB_rm<"vgf2p8mulb", int_x86_vgf2p8mulb, VR256,
+                                   loadv4i64, i256mem>, VEX_4V, VEX_L;
+}
+// GF2P8AFFINEINVQB, GF2P8AFFINEQB
+let isCommutable = 0 in {
+  defm GF2P8AFFINEINVQB : GF2P8AFFINE_common<0xCF, "gf2p8affineinvqb">, TAPD;
+  defm GF2P8AFFINEQB    : GF2P8AFFINE_common<0xCE, "gf2p8affineqb">, TAPD;
+}
+

lib/Target/X86/X86IntrinsicsInfo.h

 
 enum IntrinsicType : uint16_t {
   INTR_NO_TYPE,
   GATHER, SCATTER, PREFETCH, RDSEED, RDRAND, RDPMC, RDTSC, XTEST, XGETBV, ADX, FPCLASS, FPCLASSS,
   INTR_TYPE_1OP, INTR_TYPE_2OP, INTR_TYPE_3OP, INTR_TYPE_4OP,
   CMP_MASK, CMP_MASK_CC,CMP_MASK_SCALAR_CC, VSHIFT, COMI, COMI_RM,
   CVTPD2PS, CVTPD2PS_MASK,
   INTR_TYPE_1OP_MASK, INTR_TYPE_1OP_MASK_RM,
-  INTR_TYPE_2OP_MASK, INTR_TYPE_2OP_MASK_RM, INTR_TYPE_2OP_IMM8_MASK,
-  INTR_TYPE_3OP_MASK, INTR_TYPE_3OP_MASK_RM, INTR_TYPE_3OP_IMM8_MASK,
+  INTR_TYPE_2OP_MASK, INTR_TYPE_2OP_MASKZ, INTR_TYPE_2OP_MASK_RM, INTR_TYPE_2OP_IMM8_MASK,
+  INTR_TYPE_3OP_MASK, INTR_TYPE_3OP_MASK_RM, INTR_TYPE_3OP_IMM8_MASK, INTR_TYPE_3OP_IMM8_MASKZ,
   FMA_OP_MASK, FMA_OP_MASKZ, FMA_OP_MASK3,
   FMA_OP_SCALAR_MASK, FMA_OP_SCALAR_MASKZ, FMA_OP_SCALAR_MASK3,
   IFMA_OP_MASK, IFMA_OP_MASKZ,
   VPERM_2OP_MASK, VPERM_3OP_MASK, VPERM_3OP_MASKZ, INTR_TYPE_SCALAR_MASK,
   INTR_TYPE_SCALAR_MASK_RM, INTR_TYPE_3OP_SCALAR_MASK_RM,
   COMPRESS_EXPAND_IN_REG, COMPRESS_TO_MEM, BRCST32x2_TO_VEC,
   TRUNCATE_TO_MEM_VI8, TRUNCATE_TO_MEM_VI16, TRUNCATE_TO_MEM_VI32,
   EXPAND_FROM_MEM,
static const IntrinsicData  IntrinsicsWithoutChain[] = {
   X86_INTRINSIC_DATA(avx512_mask_vfnmsub_pd_256, FMA_OP_MASK, X86ISD::FNMSUB, 0),
   X86_INTRINSIC_DATA(avx512_mask_vfnmsub_pd_512, FMA_OP_MASK, X86ISD::FNMSUB,
                      X86ISD::FNMSUB_RND),
   X86_INTRINSIC_DATA(avx512_mask_vfnmsub_ps_128, FMA_OP_MASK, X86ISD::FNMSUB, 0),
   X86_INTRINSIC_DATA(avx512_mask_vfnmsub_ps_256, FMA_OP_MASK, X86ISD::FNMSUB, 0),
   X86_INTRINSIC_DATA(avx512_mask_vfnmsub_ps_512, FMA_OP_MASK, X86ISD::FNMSUB,
                      X86ISD::FNMSUB_RND),
 
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8affineinvqb_128, INTR_TYPE_3OP_IMM8_MASK,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8affineinvqb_256, INTR_TYPE_3OP_IMM8_MASK,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8affineinvqb_512, INTR_TYPE_3OP_IMM8_MASK,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8affineqb_128, INTR_TYPE_3OP_IMM8_MASK,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8affineqb_256, INTR_TYPE_3OP_IMM8_MASK,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8affineqb_512, INTR_TYPE_3OP_IMM8_MASK,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8mulb_128, INTR_TYPE_2OP_MASK,
+                     X86ISD::GF2P8MULB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8mulb_256, INTR_TYPE_2OP_MASK,
+                     X86ISD::GF2P8MULB, 0),
+  X86_INTRINSIC_DATA(avx512_mask_vgf2p8mulb_512, INTR_TYPE_2OP_MASK,
+                     X86ISD::GF2P8MULB, 0),
+
   X86_INTRINSIC_DATA(avx512_mask_vpermi2var_d_128, VPERM_3OP_MASK,
                     X86ISD::VPERMIV3, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpermi2var_d_256, VPERM_3OP_MASK,
                     X86ISD::VPERMIV3, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpermi2var_d_512, VPERM_3OP_MASK,
                     X86ISD::VPERMIV3, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpermi2var_hi_128, VPERM_3OP_MASK,
                     X86ISD::VPERMIV3, 0),
static const IntrinsicData  IntrinsicsWithoutChain[] = {
   X86_INTRINSIC_DATA(avx512_maskz_vfmaddsub_pd_256, FMA_OP_MASKZ, X86ISD::FMADDSUB, 0),
   X86_INTRINSIC_DATA(avx512_maskz_vfmaddsub_pd_512, FMA_OP_MASKZ, X86ISD::FMADDSUB,
                      X86ISD::FMADDSUB_RND),
   X86_INTRINSIC_DATA(avx512_maskz_vfmaddsub_ps_128, FMA_OP_MASKZ, X86ISD::FMADDSUB, 0),
   X86_INTRINSIC_DATA(avx512_maskz_vfmaddsub_ps_256, FMA_OP_MASKZ, X86ISD::FMADDSUB, 0),
   X86_INTRINSIC_DATA(avx512_maskz_vfmaddsub_ps_512, FMA_OP_MASKZ, X86ISD::FMADDSUB,
                      X86ISD::FMADDSUB_RND),
 
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8affineinvqb_128, INTR_TYPE_3OP_IMM8_MASKZ,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8affineinvqb_256, INTR_TYPE_3OP_IMM8_MASKZ,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8affineinvqb_512, INTR_TYPE_3OP_IMM8_MASKZ,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8affineqb_128, INTR_TYPE_3OP_IMM8_MASKZ,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8affineqb_256, INTR_TYPE_3OP_IMM8_MASKZ,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8affineqb_512, INTR_TYPE_3OP_IMM8_MASKZ,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8mulb_128, INTR_TYPE_2OP_MASKZ,
+                     X86ISD::GF2P8MULB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8mulb_256, INTR_TYPE_2OP_MASKZ,
+                     X86ISD::GF2P8MULB, 0),
+  X86_INTRINSIC_DATA(avx512_maskz_vgf2p8mulb_512, INTR_TYPE_2OP_MASKZ,
+                     X86ISD::GF2P8MULB, 0),
+
   X86_INTRINSIC_DATA(avx512_maskz_vpermt2var_d_128, VPERM_3OP_MASKZ,
                      X86ISD::VPERMV3, 0),
   X86_INTRINSIC_DATA(avx512_maskz_vpermt2var_d_256, VPERM_3OP_MASKZ,
                      X86ISD::VPERMV3, 0),
   X86_INTRINSIC_DATA(avx512_maskz_vpermt2var_d_512, VPERM_3OP_MASKZ,
                      X86ISD::VPERMV3, 0),
   X86_INTRINSIC_DATA(avx512_maskz_vpermt2var_hi_128, VPERM_3OP_MASKZ,
                      X86ISD::VPERMV3, 0),

lib/Target/X86/X86Subtarget.h

protected:
   bool HasXSAVEC;
 
   /// Target has XSAVES instructions
   bool HasXSAVES;
 
   /// Target has carry-less multiplication
   bool HasPCLMUL;
 
+  /// Target has Galios Field Arithmetic instructions
+  bool HasGFNI;
+
   /// Target has 3-operand fused multiply-add
   bool HasFMA;
 
   /// Target has 4-operand fused multiply-add
   bool HasFMA4;
 
   /// Target has XOP instructions
   bool HasXOP;
public:
   bool hasPOPCNT() const { return HasPOPCNT; }
   bool hasAES() const { return HasAES; }
   bool hasFXSR() const { return HasFXSR; }
   bool hasXSAVE() const { return HasXSAVE; }
   bool hasXSAVEOPT() const { return HasXSAVEOPT; }
   bool hasXSAVEC() const { return HasXSAVEC; }
   bool hasXSAVES() const { return HasXSAVES; }
   bool hasPCLMUL() const { return HasPCLMUL; }
+  bool hasGFNI() const { return HasGFNI; }
   // Prefer FMA4 to FMA - its better for commutation/memory folding and
   // has equal or better performance on all supported targets.
   bool hasFMA() const { return (HasFMA || hasAVX512()) && !HasFMA4; }
   bool hasFMA4() const { return HasFMA4; }
   bool hasAnyFMA() const { return hasFMA() || hasFMA4(); }
   bool hasXOP() const { return HasXOP; }
   bool hasTBM() const { return HasTBM; }
   bool hasLWP() const { return HasLWP; }

lib/Target/X86/X86Subtarget.cpp

void X86Subtarget::initializeEnvironment() {
   HasSSE4A = false;
   HasAES = false;
   HasFXSR = false;
   HasXSAVE = false;
   HasXSAVEOPT = false;
   HasXSAVEC = false;
   HasXSAVES = false;
   HasPCLMUL = false;
+  HasGFNI = false;
   HasFMA = false;
   HasFMA4 = false;
   HasXOP = false;
   HasTBM = false;
   HasLWP = false;
   HasMOVBE = false;
   HasRDRAND = false;
   HasF16C = false;

test/CodeGen/X86/avx-gfni-intrinsics.ll

+; RUN: llc < %s -mtriple=i386-apple-darwin -mattr=+gfni,+avx -show-mc-encoding | FileCheck %s
+
+declare <16 x i8> @llvm.x86.gf2p8affineinvqb(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_gf2p8affineinvqb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8affineinvqb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    vgf2p8affineinvqb $11, %xmm1, %xmm0, %xmm0 ## encoding: [0xc4,0xe3,0xf9,0xcf,0xc1,0x0b]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.gf2p8affineinvqb(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8affineinvqb(<32 x i8>, <32 x i8>, i8)
+define <32 x i8> @test_vgf2p8affineinvqb(<32 x i8> %src1, <32 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8affineinvqb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    vgf2p8affineinvqb $11, %ymm1, %ymm0, %ymm0 ## encoding: [0xc4,0xe3,0xfd,0xcf,0xc1,0x0b]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.vgf2p8affineinvqb(<32 x i8> %src1, <32 x i8> %src2, i8 11)
+  ret <32 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.gf2p8affineqb(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_gf2p8affineqb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8affineqb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    vgf2p8affineqb $11, %xmm1, %xmm0, %xmm0 ## encoding: [0xc4,0xe3,0xf9,0xce,0xc1,0x0b]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.gf2p8affineqb(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8affineqb(<32 x i8>, <32 x i8>, i8)
+define <32 x i8> @test_vgf2p8affineqb(<32 x i8> %src1, <32 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8affineqb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    vgf2p8affineqb $11, %ymm1, %ymm0, %ymm0 ## encoding: [0xc4,0xe3,0xfd,0xce,0xc1,0x0b]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.vgf2p8affineqb(<32 x i8> %src1, <32 x i8> %src2, i8 11)
+  ret <32 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.gf2p8mulb(<16 x i8>, <16 x i8>)
+define <16 x i8> @test_gf2p8mulb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8mulb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    vgf2p8mulb %xmm1, %xmm0, %xmm0 ## encoding: [0xc4,0xe2,0x79,0xcf,0xc1]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.gf2p8mulb(<16 x i8> %src1, <16 x i8> %src2)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8mulb(<32 x i8>, <32 x i8>)
+define <32 x i8> @test_vgf2p8mulb(<32 x i8> %src1, <32 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8mulb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    vgf2p8mulb %ymm1, %ymm0, %ymm0 ## encoding: [0xc4,0xe2,0x7d,0xcf,0xc1]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.vgf2p8mulb(<32 x i8> %src1, <32 x i8> %src2)
+  ret <32 x i8> %1
+}
+

test/CodeGen/X86/avx512-gfni-intrinsics.ll

+; RUN: llc < %s -mtriple=x86_64-apple-darwin -mattr=+avx512vl,+gfni,+avx512bw --show-mc-encoding | FileCheck %s
+
+declare <16 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.128(<16 x i8>, <16 x i8>, i32, <16 x i8>, i16)
+define <16 x i8> @test_gf2p8affineinvqb_mask_128(<16 x i8> %passthru, <16 x i8> %src1, <16 x i8> %src2, i16 %mask) {
+; CHECK-LABEL: test_gf2p8affineinvqb_mask_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %xmm2, %xmm1, %xmm0 {%k1} ## encoding: [0x62,0xf3,0xf5,0x09,0xcf,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.128(<16 x i8> %src1, <16 x i8> %src2, i32 3, <16 x i8> %passthru, i16 %mask)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.256(<32 x i8>, <32 x i8>, i32, <32 x i8>, i32)
+define <32 x i8> @test_gf2p8affineinvqb_mask_256(<32 x i8> %passthru, <32 x i8> %src1, <32 x i8> %src2, i32 %mask) {
+; CHECK-LABEL: test_gf2p8affineinvqb_mask_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %ymm2, %ymm1, %ymm0 {%k1} ## encoding: [0x62,0xf3,0xf5,0x29,0xcf,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.256(<32 x i8> %src1, <32 x i8> %src2, i32 3, <32 x i8> %passthru, i32 %mask)
+  ret <32 x i8> %1
+}
+
+declare <64 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.512(<64 x i8>, <64 x i8>, i32, <64 x i8>, i64)
+define <64 x i8> @test_gf2p8affineinvqb_mask_512(<64 x i8> %passthru, <64 x i8> %src1, <64 x i8> %src2, i64 %mask) {
+; CHECK-LABEL: test_gf2p8affineinvqb_mask_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %zmm2, %zmm1, %zmm0 {%k1} ## encoding: [0x62,0xf3,0xf5,0x49,0xcf,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <64 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.512(<64 x i8> %src1, <64 x i8> %src2, i32 3, <64 x i8> %passthru, i64 %mask)
+  ret <64 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.avx512.maskz.vgf2p8affineinvqb.128(<16 x i8>, <16 x i8>, i32, <16 x i8>, i16)
+define <16 x i8> @test_gf2p8affineinvqb_maskz_128(<16 x i8> %passthru, <16 x i8> %src1, <16 x i8> %src2, i16 %mask) {
+; CHECK-LABEL: test_gf2p8affineinvqb_maskz_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %xmm2, %xmm1, %xmm0 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0x89,0xcf,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.avx512.maskz.vgf2p8affineinvqb.128(<16 x i8> %src1, <16 x i8> %src2, i32 3, <16 x i8> %passthru, i16 %mask)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.avx512.maskz.vgf2p8affineinvqb.256(<32 x i8>, <32 x i8>, i32, <32 x i8>, i32)
+define <32 x i8> @test_gf2p8affineinvqb_maskz_256(<32 x i8> %passthru, <32 x i8> %src1, <32 x i8> %src2, i32 %mask) {
+; CHECK-LABEL: test_gf2p8affineinvqb_maskz_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %ymm2, %ymm1, %ymm0 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xa9,0xcf,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.avx512.maskz.vgf2p8affineinvqb.256(<32 x i8> %src1, <32 x i8> %src2, i32 3, <32 x i8> %passthru, i32 %mask)
+  ret <32 x i8> %1
+}
+
+declare <64 x i8> @llvm.x86.avx512.maskz.vgf2p8affineinvqb.512(<64 x i8>, <64 x i8>, i32, <64 x i8>, i64)
+define <64 x i8> @test_gf2p8affineinvqb_maskz_512(<64 x i8> %passthru, <64 x i8> %src1, <64 x i8> %src2, i64 %mask) {
+; CHECK-LABEL: test_gf2p8affineinvqb_maskz_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %zmm2, %zmm1, %zmm0 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xc9,0xcf,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <64 x i8> @llvm.x86.avx512.maskz.vgf2p8affineinvqb.512(<64 x i8> %src1, <64 x i8> %src2, i32 3, <64 x i8> %passthru, i64 %mask)
+  ret <64 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.128(<16 x i8>, <16 x i8>, i32, <16 x i8>, i16)
+define <16 x i8> @test_gf2p8affineqb_mask_128(<16 x i8> %passthru, <16 x i8> %src1, <16 x i8> %src2, i16 %mask) {
+; CHECK-LABEL: test_gf2p8affineqb_mask_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %xmm2, %xmm1, %xmm0 {%k1} ## encoding: [0x62,0xf3,0xf5,0x09,0xce,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i32 3, <16 x i8> %passthru, i16 %mask)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.256(<32 x i8>, <32 x i8>, i32, <32 x i8>, i32)
+define <32 x i8> @test_gf2p8affineqb_mask_256(<32 x i8> %passthru, <32 x i8> %src1, <32 x i8> %src2, i32 %mask) {
+; CHECK-LABEL: test_gf2p8affineqb_mask_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %ymm2, %ymm1, %ymm0 {%k1} ## encoding: [0x62,0xf3,0xf5,0x29,0xce,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.256(<32 x i8> %src1, <32 x i8> %src2, i32 3, <32 x i8> %passthru, i32 %mask)
+  ret <32 x i8> %1
+}
+
+declare <64 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.512(<64 x i8>, <64 x i8>, i32, <64 x i8>, i64)
+define <64 x i8> @test_gf2p8affineqb_mask_512(<64 x i8> %passthru, <64 x i8> %src1, <64 x i8> %src2, i64 %mask) {
+; CHECK-LABEL: test_gf2p8affineqb_mask_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %zmm2, %zmm1, %zmm0 {%k1} ## encoding: [0x62,0xf3,0xf5,0x49,0xce,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <64 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.512(<64 x i8> %src1, <64 x i8> %src2, i32 3, <64 x i8> %passthru, i64 %mask)
+  ret <64 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.avx512.maskz.vgf2p8affineqb.128(<16 x i8>, <16 x i8>, i32, <16 x i8>, i16)
+define <16 x i8> @test_gf2p8affineqb_maskz_128(<16 x i8> %passthru, <16 x i8> %src1, <16 x i8> %src2, i16 %mask) {
+; CHECK-LABEL: test_gf2p8affineqb_maskz_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %xmm2, %xmm1, %xmm0 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0x89,0xce,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.avx512.maskz.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i32 3, <16 x i8> %passthru, i16 %mask)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.avx512.maskz.vgf2p8affineqb.256(<32 x i8>, <32 x i8>, i32, <32 x i8>, i32)
+define <32 x i8> @test_gf2p8affineqb_maskz_256(<32 x i8> %passthru, <32 x i8> %src1, <32 x i8> %src2, i32 %mask) {
+; CHECK-LABEL: test_gf2p8affineqb_maskz_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %ymm2, %ymm1, %ymm0 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xa9,0xce,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.avx512.maskz.vgf2p8affineqb.256(<32 x i8> %src1, <32 x i8> %src2, i32 3, <32 x i8> %passthru, i32 %mask)
+  ret <32 x i8> %1
+}
+
+declare <64 x i8> @llvm.x86.avx512.maskz.vgf2p8affineqb.512(<64 x i8>, <64 x i8>, i32, <64 x i8>, i64)
+define <64 x i8> @test_gf2p8affineqb_maskz_512(<64 x i8> %passthru, <64 x i8> %src1, <64 x i8> %src2, i64 %mask) {
+; CHECK-LABEL: test_gf2p8affineqb_maskz_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %zmm2, %zmm1, %zmm0 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xc9,0xce,0xc2,0x03]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <64 x i8> @llvm.x86.avx512.maskz.vgf2p8affineqb.512(<64 x i8> %src1, <64 x i8> %src2, i32 3, <64 x i8> %passthru, i64 %mask)
+  ret <64 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.128(<16 x i8>, <16 x i8>, <16 x i8>, i16)
+define <16 x i8> @test_gf2p8mulb_mask_128(<16 x i8> %passthru, <16 x i8> %src1, <16 x i8> %src2, i16 %mask) {
+; CHECK-LABEL: test_gf2p8mulb_mask_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %xmm2, %xmm1, %xmm0 {%k1} ## encoding: [0x62,0xf2,0x75,0x09,0xcf,0xc2]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %passthru, i16 %mask)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.256(<32 x i8>, <32 x i8>, <32 x i8>, i32)
+define <32 x i8> @test_gf2p8mulb_mask_256(<32 x i8> %passthru, <32 x i8> %src1, <32 x i8> %src2, i32 %mask) {
+; CHECK-LABEL: test_gf2p8mulb_mask_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %ymm2, %ymm1, %ymm0 {%k1} ## encoding: [0x62,0xf2,0x75,0x29,0xcf,0xc2]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> %passthru, i32 %mask)
+  ret <32 x i8> %1
+}
+
+declare <64 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.512(<64 x i8>, <64 x i8>, <64 x i8>, i64)
+define <64 x i8> @test_gf2p8mulb_mask_512(<64 x i8> %passthru, <64 x i8> %src1, <64 x i8> %src2, i64 %mask) {
+; CHECK-LABEL: test_gf2p8mulb_mask_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %zmm2, %zmm1, %zmm0 {%k1} ## encoding: [0x62,0xf2,0x75,0x49,0xcf,0xc2]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <64 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.512(<64 x i8> %src1, <64 x i8> %src2, <64 x i8> %passthru, i64 %mask)
+  ret <64 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.avx512.maskz.vgf2p8mulb.128(<16 x i8>, <16 x i8>, <16 x i8>, i16)
+define <16 x i8> @test_gf2p8mulb_maskz_128(<16 x i8> %passthru, <16 x i8> %src1, <16 x i8> %src2, i16 %mask) {
+; CHECK-LABEL: test_gf2p8mulb_maskz_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %xmm2, %xmm1, %xmm0 {%k1} {z} ## encoding: [0x62,0xf2,0x75,0x89,0xcf,0xc2]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.avx512.maskz.vgf2p8mulb.128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %passthru, i16 %mask)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.avx512.maskz.vgf2p8mulb.256(<32 x i8>, <32 x i8>, <32 x i8>, i32)
+define <32 x i8> @test_gf2p8mulb_maskz_256(<32 x i8> %passthru, <32 x i8> %src1, <32 x i8> %src2, i32 %mask) {
+; CHECK-LABEL: test_gf2p8mulb_maskz_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %ymm2, %ymm1, %ymm0 {%k1} {z} ## encoding: [0x62,0xf2,0x75,0xa9,0xcf,0xc2]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <32 x i8> @llvm.x86.avx512.maskz.vgf2p8mulb.256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> %passthru, i32 %mask)
+  ret <32 x i8> %1
+}
+
+declare <64 x i8> @llvm.x86.avx512.maskz.vgf2p8mulb.512(<64 x i8>, <64 x i8>, <64 x i8>, i64)
+define <64 x i8> @test_gf2p8mulb_maskz_512(<64 x i8> %passthru, <64 x i8> %src1, <64 x i8> %src2, i64 %mask) {
+; CHECK-LABEL: test_gf2p8mulb_maskz_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %zmm2, %zmm1, %zmm0 {%k1} {z} ## encoding: [0x62,0xf2,0x75,0xc9,0xcf,0xc2]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = call <64 x i8> @llvm.x86.avx512.maskz.vgf2p8mulb.512(<64 x i8> %src1, <64 x i8> %src2, <64 x i8> %passthru, i64 %mask)
+  ret <64 x i8> %1
+}
+

test/CodeGen/X86/gfni-intrinsics.ll

+; RUN: llc < %s -mtriple=i386-apple-darwin -mattr=+gfni -show-mc-encoding | FileCheck %s
+
+declare <16 x i8> @llvm.x86.gf2p8affineinvqb(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_gf2p8affineinvqb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8affineinvqb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    gf2p8affineinvqb $11, %xmm1, %xmm0 ## encoding: [0x66,0x0f,0x3a,0xcf,0xc1,0x0b]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.gf2p8affineinvqb(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+  ret <16 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.gf2p8affineqb(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_gf2p8affineqb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8affineqb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    gf2p8affineqb $11, %xmm1, %xmm0 ## encoding: [0x66,0x0f,0x3a,0xce,0xc1,0x0b]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.gf2p8affineqb(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+  ret <16 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.gf2p8mulb(<16 x i8>, <16 x i8>)
+define <16 x i8> @test_gf2p8mulb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8mulb:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    gf2p8mulb %xmm1, %xmm0 ## encoding: [0x66,0x0f,0x38,0xcf,0xc1]
+; CHECK-NEXT:    retl ## encoding: [0xc3]
+  %1 = call <16 x i8> @llvm.x86.gf2p8mulb(<16 x i8> %src1, <16 x i8> %src2)
+  ret <16 x i8> %1
+}
+

test/MC/X86/avx512gfni-encoding.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+gfni,+avx512f --show-encoding < %s | FileCheck %s
+
+// CHECK: vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %zmm2, %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %zmm2, %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -256(%rsp), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -256(%rsp), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb  $7, 256(%rsp), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 256(%rsp), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x40,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x40,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x40,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, -256(%rsp), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -256(%rsp), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, 256(%rsp), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x40,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 256(%rsp), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x40,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x40,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x40,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -256(%rsp), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -256(%rsp), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, 256(%rsp), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 256(%rsp), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x42,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x42,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x42,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -256(%rsp), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -256(%rsp), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, 256(%rsp), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x42,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 256(%rsp), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x42,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x42,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x42,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb %zmm2, %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x40,0xcf,0xca]
+          vgf2p8mulb %zmm2, %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb %zmm2, %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x42,0xcf,0xca]
+          vgf2p8mulb %zmm2, %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb  (%rcx), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x40,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb  -256(%rsp), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x40,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -256(%rsp), %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb  256(%rsp), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x40,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  256(%rsp), %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x40,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x40,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x40,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %zmm20, %zmm1
+
+// CHECK: vgf2p8mulb  (%rcx), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x42,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb  -256(%rsp), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x42,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -256(%rsp), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb  256(%rsp), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x42,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  256(%rsp), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x42,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x42,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x42,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %zmm20, %zmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb $7, (%rcx){1to8}, %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x50,0xcf,0x09,0x07]
+          vgf2p8affineinvqb $7, (%rcx){1to8}, %zmm20, %zmm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx){1to8}, %zmm20, %zmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x50,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx){1to8}, %zmm20, %zmm1
+

test/MC/X86/avx512vl_gfni-encoding.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+gfni,+avx512vl --show-encoding < %s | FileCheck %s
+
+// CHECK: vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %xmm2, %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %xmm2, %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -64(%rsp), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -64(%rsp), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, 64(%rsp), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 64(%rsp), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x00,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x00,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x00,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, -64(%rsp), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -64(%rsp), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, 64(%rsp), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x00,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 64(%rsp), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x00,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x00,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x00,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -64(%rsp), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -64(%rsp), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, 64(%rsp), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 64(%rsp), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x02,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x02,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x02,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -64(%rsp), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -64(%rsp), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, 64(%rsp), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x02,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 64(%rsp), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x02,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x02,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x02,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb $7, %ymm2, %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %ymm2, %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb $7, %ymm2, %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %ymm2, %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb $7, %ymm2, %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %ymm2, %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb $7, %ymm2, %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %ymm2, %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, -128(%rsp), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -128(%rsp), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, 128(%rsp), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 128(%rsp), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x20,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x20,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x20,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, -128(%rsp), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -128(%rsp), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, 128(%rsp), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x20,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 128(%rsp), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x20,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x20,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb3,0xdd,0x20,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -128(%rsp), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -128(%rsp), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, 128(%rsp), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 128(%rsp), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x22,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x22,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x22,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -128(%rsp), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -128(%rsp), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, 128(%rsp), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf3,0xdd,0x22,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 128(%rsp), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x22,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x22,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb3,0xdd,0x22,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb %xmm2, %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x00,0xcf,0xca]
+          vgf2p8mulb %xmm2, %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb %xmm2, %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x02,0xcf,0xca]
+          vgf2p8mulb %xmm2, %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb  (%rcx), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x00,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb  -64(%rsp), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x00,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -64(%rsp), %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb  64(%rsp), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x00,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  64(%rsp), %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x00,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x00,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x00,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %xmm20, %xmm1
+
+// CHECK: vgf2p8mulb  (%rcx), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x02,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb  -64(%rsp), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x02,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -64(%rsp), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb  64(%rsp), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x02,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  64(%rsp), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x02,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x02,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x02,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %xmm20, %xmm1 {%k2}
+
+// CHECK: vgf2p8mulb %ymm2, %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x20,0xcf,0xca]
+          vgf2p8mulb %ymm2, %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb %ymm2, %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x22,0xcf,0xca]
+          vgf2p8mulb %ymm2, %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb  (%rcx), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x20,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb  -128(%rsp), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x20,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -128(%rsp), %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb  128(%rsp), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf2,0x5d,0x20,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  128(%rsp), %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x20,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x20,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xb2,0x5d,0x20,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %ymm20, %ymm1
+
+// CHECK: vgf2p8mulb  (%rcx), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x22,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb  -128(%rsp), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x22,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -128(%rsp), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb  128(%rsp), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xf2,0x5d,0x22,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  128(%rsp), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x22,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x22,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+// CHECK: encoding: [0x62,0xb2,0x5d,0x22,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %ymm20, %ymm1 {%k2}
+
+// CHECK: vgf2p8affineinvqb $7, (%rcx){1to2}, %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x10,0xcf,0x09,0x07]
+          vgf2p8affineinvqb $7, (%rcx){1to2}, %xmm20, %xmm1
+
+// CHECK: vgf2p8affineinvqb $7, (%rcx){1to4}, %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x30,0xcf,0x09,0x07]
+          vgf2p8affineinvqb $7, (%rcx){1to4}, %ymm20, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx){1to2}, %xmm20, %xmm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x10,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx){1to2}, %xmm20, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx){1to4}, %ymm20, %ymm1
+// CHECK: encoding: [0x62,0xf3,0xdd,0x30,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx){1to4}, %ymm20, %ymm1
+

test/MC/X86/gfni-encoding.s

+// RUN: llvm-mc -triple x86_64-unknown-unknown -mattr=+gfni --show-encoding < %s | FileCheck %s
+
+// CHECK: gf2p8affineinvqb $7, %xmm2, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xcf,0xca,0x07]
+          gf2p8affineinvqb $7, %xmm2, %xmm1
+
+// CHECK: gf2p8affineqb $7, %xmm2, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xce,0xca,0x07]
+          gf2p8affineqb $7, %xmm2, %xmm1
+
+// CHECK: gf2p8affineinvqb  $7, (%rcx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xcf,0x09,0x07]
+          gf2p8affineinvqb  $7, (%rcx), %xmm1
+
+// CHECK: gf2p8affineinvqb  $7, -4(%rsp), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xcf,0x4c,0x24,0xfc,0x07]
+          gf2p8affineinvqb  $7, -4(%rsp), %xmm1
+
+// CHECK: gf2p8affineinvqb  $7, 4(%rsp), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xcf,0x4c,0x24,0x04,0x07]
+          gf2p8affineinvqb  $7, 4(%rsp), %xmm1
+
+// CHECK: gf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x3a,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          gf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x3a,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          gf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x3a,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          gf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8affineqb  $7, (%rcx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xce,0x09,0x07]
+          gf2p8affineqb  $7, (%rcx), %xmm1
+
+// CHECK: gf2p8affineqb  $7, -4(%rsp), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xce,0x4c,0x24,0xfc,0x07]
+          gf2p8affineqb  $7, -4(%rsp), %xmm1
+
+// CHECK: gf2p8affineqb  $7, 4(%rsp), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x3a,0xce,0x4c,0x24,0x04,0x07]
+          gf2p8affineqb  $7, 4(%rsp), %xmm1
+
+// CHECK: gf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x3a,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          gf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x3a,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          gf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x3a,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          gf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8mulb %xmm2, %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0xcf,0xca]
+          gf2p8mulb %xmm2, %xmm1
+
+// CHECK: gf2p8mulb  (%rcx), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0xcf,0x09]
+          gf2p8mulb  (%rcx), %xmm1
+
+// CHECK: gf2p8mulb  -4(%rsp), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0xcf,0x4c,0x24,0xfc]
+          gf2p8mulb  -4(%rsp), %xmm1
+
+// CHECK: gf2p8mulb  4(%rsp), %xmm1
+// CHECK: encoding: [0x66,0x0f,0x38,0xcf,0x4c,0x24,0x04]
+          gf2p8mulb  4(%rsp), %xmm1
+
+// CHECK: gf2p8mulb  268435456(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x38,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          gf2p8mulb  268435456(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8mulb  -536870912(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x38,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          gf2p8mulb  -536870912(%rcx,%r14,8), %xmm1
+
+// CHECK: gf2p8mulb  -536870910(%rcx,%r14,8), %xmm1
+// CHECK: encoding: [0x66,0x42,0x0f,0x38,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          gf2p8mulb  -536870910(%rcx,%r14,8), %xmm1
+
+// CHECK: vgf2p8affineinvqb $7, %xmm2, %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %xmm2, %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb $7, %xmm2, %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %xmm2, %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -4(%rsp), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -4(%rsp), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, 4(%rsp), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 4(%rsp), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa3,0xa9,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa3,0xa9,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa3,0xa9,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, -4(%rsp), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -4(%rsp), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, 4(%rsp), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe3,0xa9,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 4(%rsp), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa3,0xa9,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa3,0xa9,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa3,0xa9,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8affineinvqb $7, %ymm2, %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xcf,0xca,0x07]
+          vgf2p8affineinvqb $7, %ymm2, %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb $7, %ymm2, %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xce,0xca,0x07]
+          vgf2p8affineqb $7, %ymm2, %ymm10, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, (%rcx), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xcf,0x09,0x07]
+          vgf2p8affineinvqb  $7, (%rcx), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, -4(%rsp), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xcf,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineinvqb  $7, -4(%rsp), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, 4(%rsp), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xcf,0x4c,0x24,0x04,0x07]
+          vgf2p8affineinvqb  $7, 4(%rsp), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa3,0xad,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineinvqb  $7, 268435456(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa3,0xad,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870912(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa3,0xad,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineinvqb  $7, -536870910(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, (%rcx), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xce,0x09,0x07]
+          vgf2p8affineqb  $7, (%rcx), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, -4(%rsp), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xce,0x4c,0x24,0xfc,0x07]
+          vgf2p8affineqb  $7, -4(%rsp), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, 4(%rsp), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe3,0xad,0xce,0x4c,0x24,0x04,0x07]
+          vgf2p8affineqb  $7, 4(%rsp), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa3,0xad,0xce,0x8c,0xf1,0x00,0x00,0x00,0x10,0x07]
+          vgf2p8affineqb  $7, 268435456(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa3,0xad,0xce,0x8c,0xf1,0x00,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870912(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa3,0xad,0xce,0x8c,0xf1,0x02,0x00,0x00,0xe0,0x07]
+          vgf2p8affineqb  $7, -536870910(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb %xmm2, %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe2,0x29,0xcf,0xca]
+          vgf2p8mulb %xmm2, %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb  (%rcx), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe2,0x29,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb  -4(%rsp), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe2,0x29,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -4(%rsp), %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb  4(%rsp), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xe2,0x29,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  4(%rsp), %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa2,0x29,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa2,0x29,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %xmm10, %xmm1
+// CHECK: encoding: [0xc4,0xa2,0x29,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %xmm10, %xmm1
+
+// CHECK: vgf2p8mulb %ymm2, %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe2,0x2d,0xcf,0xca]
+          vgf2p8mulb %ymm2, %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb  (%rcx), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe2,0x2d,0xcf,0x09]
+          vgf2p8mulb  (%rcx), %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb  -4(%rsp), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe2,0x2d,0xcf,0x4c,0x24,0xfc]
+          vgf2p8mulb  -4(%rsp), %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb  4(%rsp), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xe2,0x2d,0xcf,0x4c,0x24,0x04]
+          vgf2p8mulb  4(%rsp), %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb  268435456(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa2,0x2d,0xcf,0x8c,0xf1,0x00,0x00,0x00,0x10]
+          vgf2p8mulb  268435456(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb  -536870912(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa2,0x2d,0xcf,0x8c,0xf1,0x00,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870912(%rcx,%r14,8), %ymm10, %ymm1
+
+// CHECK: vgf2p8mulb  -536870910(%rcx,%r14,8), %ymm10, %ymm1
+// CHECK: encoding: [0xc4,0xa2,0x2d,0xcf,0x8c,0xf1,0x02,0x00,0x00,0xe0]
+          vgf2p8mulb  -536870910(%rcx,%r14,8), %ymm10, %ymm1
+