[x86][icelake]GFNI

[coby]

Summary

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

[craig.topper]

lib/Support/Host.cpp

1227

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

19835

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.

19922

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

[craig.topper]

lib/Target/X86/X86InstrAVX512.td

10028

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

[craig.topper]

lib/Target/X86/X86ISelLowering.cpp

19835

sorry that should have said FMA_MASKZ not OP3_MASKZ.

[coby]

lib/Target/X86/X86ISelLowering.cpp

19835

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

10028

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

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1348

Please sync the GCCBuiltin names with gcc.

[craig.topper]

lib/Target/X86/X86InstrAVX512.td

10031

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

1348

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

1348

does ~~> those

[craig.topper]

k

include/llvm/IR/IntrinsicsX86.td

1348

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

[coby]

include/llvm/IR/IntrinsicsX86.td

1348

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

1347

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.

1407

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

1423

Name this _256 and the one above _128.

lib/Target/X86/X86.td

173

Isn't it Galois not Galios

lib/Target/X86/X86ISelLowering.h

582

Galois

lib/Target/X86/X86InstrFragmentsSIMD.td

659

galois

lib/Target/X86/X86InstrSSE.td

8523

NoVLX should be NoVLX_Or_NoBWI

[coby]

include/llvm/IR/IntrinsicsX86.td

1347

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

[coby]

lib/Target/X86/X86.td

173

Evariste *Galois*, indeed.
thx

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1347

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_pshuf_b_512 :
         GCCBuiltin<"__builtin_ia32_pshufb512">,
           Intrinsic<[llvm_v64i8_ty], [llvm_v64i8_ty, llvm_v64i8_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_v16qi_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_v32qi_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_v64qi_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_v16qi_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_v32qi_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_v64qi_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_v16qi_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_v32qi_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_v64qi_mask">,
+          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_vgf2p8affineinvqb_v16qi">,
+           Intrinsic<[llvm_v16i8_ty],
+           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+  def int_x86_vgf2p8affineinvqb :
+          GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v32qi">,
+           Intrinsic<[llvm_v32i8_ty],
+           [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+
+  def int_x86_gf2p8affineqb     :
+          GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v16qi">,
+           Intrinsic<[llvm_v16i8_ty],
+           [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+  def int_x86_vgf2p8affineqb    :
+          GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v32qi">,
+           Intrinsic<[llvm_v32i8_ty],
+           [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
+           [IntrNoMem]>;
+
+  def int_x86_gf2p8mulb         :
+          GCCBuiltin<"__builtin_ia32_vgf2p8mulb_v16qi">,
+           Intrinsic<[llvm_v16i8_ty],
+           [llvm_v16i8_ty, llvm_v16i8_ty],
+           [IntrNoMem]>;
+  def int_x86_vgf2p8mulb        :
+          GCCBuiltin<"__builtin_ia32_vgf2p8mulb_v32qi">,
+           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["sha"]        = HasLeaf7 && ((EBX >> 29) & 1);
   Features["avx512bw"]   = HasLeaf7 && ((EBX >> 30) & 1) && HasAVX512Save;
   Features["avx512vl"]   = HasLeaf7 && ((EBX >> 31) & 1) && HasAVX512Save;
 
   Features["prefetchwt1"]     = HasLeaf7 && ((ECX >>  0) & 1);
   Features["avx512vbmi"]      = HasLeaf7 && ((ECX >>  1) & 1) && HasAVX512Save;
   Features["pku"]             = HasLeaf7 && ((ECX >>  4) & 1);
   Features["avx512vbmi2"]     = HasLeaf7 && ((ECX >>  6) & 1) && HasAVX512Save;
+  Features["gfni"]            = HasLeaf7 && ((ECX >>  8) & 1);
   Features["vaes"]            = HasLeaf7 && ((ECX >>  9) & 1) && HasAVXSave;
   Features["vpclmulqdq"]      = HasLeaf7 && ((ECX >> 10) & 1) && HasAVXSave;
   Features["avx512vnni"]      = HasLeaf7 && ((ECX >> 11) & 1) && HasAVX512Save;
   Features["avx512bitalg"]    = HasLeaf7 && ((ECX >> 12) & 1) && HasAVX512Save;
   Features["avx512vpopcntdq"] = HasLeaf7 && ((ECX >> 14) & 1) && HasAVX512Save;
 
+  
   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"] = HasLeafD && ((EAX >> 0) & 1) && HasAVXSave;
   Features["xsavec"]   = HasLeafD && ((EAX >> 1) & 1) && HasAVXSave;
   Features["xsaves"]   = HasLeafD && ((EAX >> 3) & 1) && HasAVXSave;
 

lib/Target/X86/X86.td

def FeatureVNNI    : SubtargetFeature<"avx512vnni", "HasVNNI", "true",
                           "Enable AVX-512 Vector Neural Network Instructions",
                                       [FeatureAVX512]>;
 def FeatureBITALG  : SubtargetFeature<"avx512bitalg", "HasBITALG", "true",
                        "Enable AVX-512 Bit Algorithms",
                         [FeatureBWI]>;
 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 FeatureVPCLMULQDQ : SubtargetFeature<"vpclmulqdq", "HasVPCLMULQDQ", "true",
                                          "Enable vpclmulqdq instructions",
                                          [FeatureAVX, FeaturePCLMUL]>;
 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, CVTPH2PS_RND,
 
+      // 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_IMM8_MASK: {
       SDValue Src1 = Op.getOperand(1);
       SDValue Src2 = Op.getOperand(2);
       SDValue PassThru = 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);
 
case INTR_TYPE_3OP_MASK_RM: {
                                               Src1, Src2, Imm, Rnd),
                                   Mask, PassThru, Subtarget, DAG);
     }
     case INTR_TYPE_3OP_IMM8_MASK:
     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 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::CVTS2UI_RND:        return "X86ISD::CVTS2UI_RND";
   case X86ISD::LWPINS:             return "X86ISD::LWPINS";
   case X86ISD::MGATHER:            return "X86ISD::MGATHER";
   case X86ISD::MSCATTER:           return "X86ISD::MSCATTER";
   case X86ISD::VPDPBUSD:           return "X86ISD::VPDPBUSD";
   case X86ISD::VPDPBUSDS:          return "X86ISD::VPDPBUSDS";
   case X86ISD::VPDPWSSD:           return "X86ISD::VPDPWSSD";
   case X86ISD::VPDPWSSDS:          return "X86ISD::VPDPWSSDS";
+  case X86ISD::GF2P8MULB:          return "X86ISD::GF2P8MULB";
+  case X86ISD::GF2P8AFFINEQB:      return "X86ISD::GF2P8AFFINEQB";
+  case X86ISD::GF2P8AFFINEINVQB:   return "X86ISD::GF2P8AFFINEINVQB";
   }
   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

 defm : AVX512_scalar_math_f64_patterns<fmul, "MUL">;
 defm : AVX512_scalar_math_f64_patterns<fdiv, "DIV">;
 
 //===----------------------------------------------------------------------===//
 // AES instructions
 //===----------------------------------------------------------------------===//
 
 multiclass avx512_vaes<bits<8> Op, string OpStr, string IntPrefix> {
   let Predicates = [HasVLX, HasVAES] in {
     defm Z128 : AESI_binop_rm_int<Op, OpStr,
                                   !cast<Intrinsic>(IntPrefix),
                                   loadv2i64, 0, VR128X, i128mem>,
                   EVEX_4V, EVEX_CD8<64, CD8VF>, EVEX_V128, VEX_WIG;
     defm Z256 : AESI_binop_rm_int<Op, OpStr,
                                   !cast<Intrinsic>(IntPrefix##"_256"),
                                   loadv4i64, 0, VR256X, i256mem>,
                   EVEX_4V, EVEX_CD8<64, CD8VF>, EVEX_V256, VEX_WIG;
     }
     let Predicates = [HasAVX512, HasVAES] in
     defm Z    : AESI_binop_rm_int<Op, OpStr,

 
 defm VPOPCNTB : avx512_unary_rm_vl<0x54, "vpopcntb", ctpop,
                                    avx512vl_i8_info, HasBITALG>,
                 avx512_unary_lowering<ctpop, avx512vl_i8_info, HasBITALG>;
 defm VPOPCNTW : avx512_unary_rm_vl<0x54, "vpopcntw", ctpop,
                                    avx512vl_i16_info, HasBITALG>,
                 avx512_unary_lowering<ctpop, avx512vl_i16_info, HasBITALG>, VEX_W;
 
+//===----------------------------------------------------------------------===//
+// GFNI
+//===----------------------------------------------------------------------===//
+
+multiclass GF2P8MULB_avx512_common<bits<8> Op, string OpStr, SDNode OpNode> {
+  let Predicates = [HasGFNI, HasAVX512, HasBWI] in
+  defm Z      : avx512_binop_rm<Op, OpStr, OpNode, v64i8_info,
+                                SSE_INTALU_ITINS_P, 1>, EVEX_V512;
+  let Predicates = [HasGFNI, HasVLX, HasBWI] 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, HasBWI] in
+  defm Z      : GF2P8AFFINE_avx512_rmb_imm<Op, OpStr, OpNode, v64i8_info,
+                                           v8i64_info>, EVEX_V512;
+  let Predicates = [HasGFNI, HasVLX, HasBWI] 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 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 NoVLX_Or_NoVPCLMULQDQ :
                     Predicate<"!Subtarget->hasVLX() || !Subtarget->hasVPCLMULQDQ()">;
 def HasVPCLMULQDQ : Predicate<"Subtarget->hasVPCLMULQDQ()">;
+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

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_vpdpbusd_128,  FMA_OP_MASK, X86ISD::VPDPBUSD, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpbusd_256,  FMA_OP_MASK, X86ISD::VPDPBUSD, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpbusd_512,  FMA_OP_MASK, X86ISD::VPDPBUSD, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpbusds_128, FMA_OP_MASK, X86ISD::VPDPBUSDS, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpbusds_256, FMA_OP_MASK, X86ISD::VPDPBUSDS, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpbusds_512, FMA_OP_MASK, X86ISD::VPDPBUSDS, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpwssd_128,  FMA_OP_MASK, X86ISD::VPDPWSSD, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpwssd_256,  FMA_OP_MASK, X86ISD::VPDPWSSD, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpwssd_512,  FMA_OP_MASK, X86ISD::VPDPWSSD, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpwssds_128, FMA_OP_MASK, X86ISD::VPDPWSSDS, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpwssds_256, FMA_OP_MASK, X86ISD::VPDPWSSDS, 0),
   X86_INTRINSIC_DATA(avx512_mask_vpdpwssds_512, FMA_OP_MASK, X86ISD::VPDPWSSDS, 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),
   X86_INTRINSIC_DATA(avx512_mask_vpermi2var_hi_256, VPERM_3OP_MASK,

lib/Target/X86/X86Subtarget.h

protected:
 
   /// Target has XSAVES instructions
   bool HasXSAVES;
 
   /// Target has carry-less multiplication
   bool HasPCLMUL;
   bool HasVPCLMULQDQ;
 
+  /// 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 hasVAES() const { return HasVAES; }
   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 hasVPCLMULQDQ() const { return HasVPCLMULQDQ; }
+  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 && !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() {
   HasVAES = false;
   HasFXSR = false;
   HasXSAVE = false;
   HasXSAVEOPT = false;
   HasXSAVEC = false;
   HasXSAVES = false;
   HasPCLMUL = false;
   HasVPCLMULQDQ = 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

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; 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

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; 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:    vgf2p8affineinvqb $3, %xmm2, %xmm1, %xmm1 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0x89,0xcf,0xca,0x03]
+; CHECK-NEXT:    vpxor %xmm1, %xmm0, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xf9,0xef,0xc1]
+; 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)
+  %2 = call <16 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.128(<16 x i8> %src1, <16 x i8> %src2, i32 3, <16 x i8> zeroinitializer, i16 %mask)
+  %3 = xor <16 x i8> %1, %2
+  ret <16 x i8> %3
+}
+
+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:    vgf2p8affineinvqb $3, %ymm2, %ymm1, %ymm1 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xa9,0xcf,0xca,0x03]
+; CHECK-NEXT:    vpxor %ymm1, %ymm0, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xfd,0xef,0xc1]
+; 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)
+  %2 = call <32 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.256(<32 x i8> %src1, <32 x i8> %src2, i32 3, <32 x i8> zeroinitializer, i32 %mask)
+  %3 = xor <32 x i8> %1, %2
+  ret <32 x i8> %3
+}
+
+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:    vgf2p8affineinvqb $3, %zmm2, %zmm1, %zmm1 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xc9,0xcf,0xca,0x03]
+; CHECK-NEXT:    vpxorq %zmm1, %zmm0, %zmm0 ## encoding: [0x62,0xf1,0xfd,0x48,0xef,0xc1]
+; 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)
+  %2 = call <64 x i8> @llvm.x86.avx512.mask.vgf2p8affineinvqb.512(<64 x i8> %src1, <64 x i8> %src2, i32 3, <64 x i8> zeroinitializer, i64 %mask)
+  %3 = xor <64 x i8> %1, %2
+  ret <64 x i8> %3
+}
+
+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:    vgf2p8affineqb $3, %xmm2, %xmm1, %xmm1 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0x89,0xce,0xca,0x03]
+; CHECK-NEXT:    vpxor %xmm1, %xmm0, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xf9,0xef,0xc1]
+; 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)
+  %2 = call <16 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i32 3, <16 x i8> zeroinitializer, i16 %mask)
+  %3 = xor <16 x i8> %1, %2
+  ret <16 x i8> %3
+}
+
+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:    vgf2p8affineqb $3, %ymm2, %ymm1, %ymm1 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xa9,0xce,0xca,0x03]
+; CHECK-NEXT:    vpxor %ymm1, %ymm0, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xfd,0xef,0xc1]
+; 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)
+  %2 = call <32 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.256(<32 x i8> %src1, <32 x i8> %src2, i32 3, <32 x i8> zeroinitializer, i32 %mask)
+  %3 = xor <32 x i8> %1, %2
+  ret <32 x i8> %3
+}
+
+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:    vgf2p8affineqb $3, %zmm2, %zmm1, %zmm1 {%k1} {z} ## encoding: [0x62,0xf3,0xf5,0xc9,0xce,0xca,0x03]
+; CHECK-NEXT:    vpxorq %zmm1, %zmm0, %zmm0 ## encoding: [0x62,0xf1,0xfd,0x48,0xef,0xc1]
+; 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)
+  %2 = call <64 x i8> @llvm.x86.avx512.mask.vgf2p8affineqb.512(<64 x i8> %src1, <64 x i8> %src2, i32 3, <64 x i8> zeroinitializer, i64 %mask)
+  %3 = xor <64 x i8> %1, %2
+  ret <64 x i8> %3
+}
+
+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:    vgf2p8mulb %xmm2, %xmm1, %xmm1 {%k1} {z} ## encoding: [0x62,0xf2,0x75,0x89,0xcf,0xca]
+; CHECK-NEXT:    vpxor %xmm1, %xmm0, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xf9,0xef,0xc1]
+; 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)
+  %2 = call <16 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> zeroinitializer, i16 %mask)
+  %3 = xor <16 x i8> %1, %2
+  ret <16 x i8> %3
+}
+
+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:    vgf2p8mulb %ymm2, %ymm1, %ymm1 {%k1} {z} ## encoding: [0x62,0xf2,0x75,0xa9,0xcf,0xca]
+; CHECK-NEXT:    vpxor %ymm1, %ymm0, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xfd,0xef,0xc1]
+; 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)
+  %2 = call <32 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> zeroinitializer, i32 %mask)
+  %3 = xor <32 x i8> %1, %2
+  ret <32 x i8> %3
+}
+
+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:    vgf2p8mulb %zmm2, %zmm1, %zmm1 {%k1} {z} ## encoding: [0x62,0xf2,0x75,0xc9,0xcf,0xca]
+; CHECK-NEXT:    vpxorq %zmm1, %zmm0, %zmm0 ## encoding: [0x62,0xf1,0xfd,0x48,0xef,0xc1]
+; 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)
+  %2 = call <64 x i8> @llvm.x86.avx512.mask.vgf2p8mulb.512(<64 x i8> %src1, <64 x i8> %src2, <64 x i8> zeroinitializer, i64 %mask)
+  %3 = xor <64 x i8> %1, %2
+  ret <64 x i8> %3
+}
+

test/CodeGen/X86/gfni-intrinsics.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; 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+avx512bw --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,+avx512bw --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
+