[x86][icelake]GFNI

[coby]

Summary

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

[craig.topper]

lib/Support/Host.cpp

1479 ↗

(On Diff #123993)

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 ↗

(On Diff #123993)

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 ↗

(On Diff #123993)

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

[craig.topper]

lib/Target/X86/X86InstrAVX512.td

9813 ↗

(On Diff #123993)

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

[craig.topper]

lib/Target/X86/X86ISelLowering.cpp

19568 ↗

(On Diff #123993)

sorry that should have said FMA_MASKZ not OP3_MASKZ.

[coby]

lib/Target/X86/X86ISelLowering.cpp

19568 ↗

(On Diff #123993)

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 ↗

(On Diff #123993)

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

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1356 ↗

(On Diff #123993)

Please sync the GCCBuiltin names with gcc.

[craig.topper]

lib/Target/X86/X86InstrAVX512.td

9816 ↗

(On Diff #123993)

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 ↗

(On Diff #123993)

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 ↗

(On Diff #123993)

does ~~> those

[craig.topper]

k

include/llvm/IR/IntrinsicsX86.td

1356 ↗

(On Diff #123993)

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

[coby]

include/llvm/IR/IntrinsicsX86.td

1356 ↗

(On Diff #123993)

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 ↗

(On Diff #124047)

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 ↗

(On Diff #124047)

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

1423 ↗

(On Diff #124047)

Name this _256 and the one above _128.

lib/Target/X86/X86.td

173 ↗

(On Diff #124047)

Isn't it Galois not Galios

lib/Target/X86/X86ISelLowering.h

582 ↗

(On Diff #124047)

Galois

lib/Target/X86/X86InstrFragmentsSIMD.td

659 ↗

(On Diff #124047)

galois

lib/Target/X86/X86InstrSSE.td

8523 ↗

(On Diff #124047)

NoVLX should be NoVLX_Or_NoBWI

[coby]

include/llvm/IR/IntrinsicsX86.td

1347 ↗

(On Diff #124047)

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 ↗

(On Diff #124047)

Evariste *Galois*, indeed.
thx

[craig.topper]

include/llvm/IR/IntrinsicsX86.td

1347 ↗

(On Diff #124047)

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.

llvm/trunk/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.".
+  def int_x86_vgf2p8affineinvqb_128 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v16qi">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
+          [IntrNoMem]>;
+  def int_x86_vgf2p8affineinvqb_256 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v32qi">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
+          [IntrNoMem]>;
+  def int_x86_vgf2p8affineinvqb_512 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineinvqb_v64qi">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i8_ty],
+          [IntrNoMem]>;
+
+  def int_x86_vgf2p8affineqb_128 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v16qi">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty, llvm_i8_ty],
+          [IntrNoMem]>;
+  def int_x86_vgf2p8affineqb_256 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v32qi">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty, llvm_i8_ty],
+          [IntrNoMem]>;
+  def int_x86_vgf2p8affineqb_512 :
+         GCCBuiltin<"__builtin_ia32_vgf2p8affineqb_v64qi">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_ty, llvm_i8_ty],
+          [IntrNoMem]>;
+
+  def int_x86_vgf2p8mulb_128     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_v16qi">,
+          Intrinsic<[llvm_v16i8_ty],
+          [llvm_v16i8_ty, llvm_v16i8_ty],
+          [IntrNoMem]>;
+  def int_x86_vgf2p8mulb_256     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_v32qi">,
+          Intrinsic<[llvm_v32i8_ty],
+          [llvm_v32i8_ty, llvm_v32i8_ty],
+          [IntrNoMem]>;
+  def int_x86_vgf2p8mulb_512     :
+         GCCBuiltin<"__builtin_ia32_vgf2p8mulb_v64qi">,
+          Intrinsic<[llvm_v64i8_ty],
+          [llvm_v64i8_ty, llvm_v64i8_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]>;

llvm/trunk/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);

llvm/trunk/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 Galois 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",

 def : CannonlakeProc<"cannonlake">;
 
 def ICLFeatures : ProcessorFeatures<CNLFeatures.Value, [
   FeatureBITALG,
   FeatureVAES,
   FeatureVBMI2,
   FeatureVNNI,
   FeatureVPCLMULQDQ,
-  FeatureVPOPCNTDQ
-  // TODO: Add GFNI when it is implemented.
+  FeatureVPOPCNTDQ,
+  FeatureGFNI
 ]>;
 
 class IcelakeProc<string Name> : ProcModel<Name, SkylakeServerModel,
                                            ICLFeatures.Value, [
   ProcIntelICL,
   FeatureHasFastGather
 ]>;
 def : IcelakeProc<"icelake">;

llvm/trunk/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,
 
+      // Galois 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,

llvm/trunk/lib/Target/X86/X86ISelLowering.cpp

const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
   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::VPSHUFBITQMB:       return "X86ISD::VPSHUFBITQMB";
+  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,

llvm/trunk/lib/Target/X86/X86InstrAVX512.td

multiclass VPSHUFBITQMB_common<AVX512VLVectorVTInfo VTI> {
   let Predicates = [HasBITALG, HasVLX] in {
     defm Z256 : VPSHUFBITQMB_rm<VTI.info256>, EVEX_V256;
     defm Z128 : VPSHUFBITQMB_rm<VTI.info128>, EVEX_V128;
   }
 }
 
 defm VPSHUFBITQMB : VPSHUFBITQMB_common<avx512vl_i8_info>;
 
+//===----------------------------------------------------------------------===//
+// 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;
+

llvm/trunk/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>;
 
+// galois 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", [],

llvm/trunk/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 NoFMA4       : 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()">;

llvm/trunk/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, ValueType OpVT,
+                        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, (OpVT (X86GF2P8mulb 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, (OpVT (X86GF2P8mulb 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, ValueType OpVT,
+                           SDNode OpNode, 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, (OpVT (OpNode 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, (OpVT (OpNode 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, SDNode OpNode> {
+  let Constraints = "$src1 = $dst",
+      Predicates  = [HasGFNI, UseSSE2] in
+  defm NAME         : GF2P8AFFINE_rmi<Op, OpStr, v16i8, OpNode,
+                                      VR128, loadv2i64, i128mem, 1>;
+  let Predicates  = [HasGFNI, HasAVX, NoVLX_Or_NoBWI] in {
+    defm V##NAME    : GF2P8AFFINE_rmi<Op, "v"##OpStr, v16i8, OpNode, VR128,
+                                      loadv2i64, i128mem>, VEX_4V, VEX_W;
+    defm V##NAME##Y : GF2P8AFFINE_rmi<Op, "v"##OpStr, v32i8, OpNode, VR256,
+                                      loadv4i64, i256mem>, VEX_4V, VEX_L, VEX_W;
+  }
+}
+
+// GF2P8MULB
+let Constraints = "$src1 = $dst",
+    Predicates  = [HasGFNI, UseSSE2] in
+defm GF2P8MULB      : GF2P8MULB_rm<"gf2p8mulb", v16i8, VR128, memopv2i64,
+                                    i128mem, 1>;
+let Predicates  = [HasGFNI, HasAVX, NoVLX_Or_NoBWI] in {
+  defm VGF2P8MULB   : GF2P8MULB_rm<"vgf2p8mulb", v16i8, VR128, loadv2i64,
+                                   i128mem>, VEX_4V;
+  defm VGF2P8MULBY  : GF2P8MULB_rm<"vgf2p8mulb", v32i8, VR256, loadv4i64,
+                                   i256mem>, VEX_4V, VEX_L;
+}
+// GF2P8AFFINEINVQB, GF2P8AFFINEQB
+let isCommutable = 0 in {
+  defm GF2P8AFFINEINVQB : GF2P8AFFINE_common<0xCF, "gf2p8affineinvqb",
+                                             X86GF2P8affineinvqb>, TAPD;
+  defm GF2P8AFFINEQB    : GF2P8AFFINE_common<0xCE, "gf2p8affineqb",
+                                             X86GF2P8affineqb>, TAPD;
+}
+

llvm/trunk/lib/Target/X86/X86IntrinsicsInfo.h

static const IntrinsicData  IntrinsicsWithoutChain[] = {
   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,
X86_INTRINSIC_DATA(avx512_mask_vpermi2var_d_128, VPERM_3OP_MASK,
   X86_INTRINSIC_DATA(ssse3_phsub_w_128, INTR_TYPE_2OP, X86ISD::HSUB, 0),
   X86_INTRINSIC_DATA(ssse3_pmadd_ub_sw_128, INTR_TYPE_2OP, X86ISD::VPMADDUBSW, 0),
   X86_INTRINSIC_DATA(ssse3_pmul_hr_sw_128, INTR_TYPE_2OP, X86ISD::MULHRS, 0),
   X86_INTRINSIC_DATA(ssse3_pshuf_b_128, INTR_TYPE_2OP, X86ISD::PSHUFB, 0),
   X86_INTRINSIC_DATA(vcvtph2ps_128,     INTR_TYPE_1OP, X86ISD::CVTPH2PS, 0),
   X86_INTRINSIC_DATA(vcvtph2ps_256,     INTR_TYPE_1OP, X86ISD::CVTPH2PS, 0),
   X86_INTRINSIC_DATA(vcvtps2ph_128,     INTR_TYPE_2OP, X86ISD::CVTPS2PH, 0),
   X86_INTRINSIC_DATA(vcvtps2ph_256,     INTR_TYPE_2OP, X86ISD::CVTPS2PH, 0),
+
+  X86_INTRINSIC_DATA(vgf2p8affineinvqb_128, INTR_TYPE_3OP,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(vgf2p8affineinvqb_256, INTR_TYPE_3OP,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(vgf2p8affineinvqb_512, INTR_TYPE_3OP,
+                     X86ISD::GF2P8AFFINEINVQB, 0),
+  X86_INTRINSIC_DATA(vgf2p8affineqb_128, INTR_TYPE_3OP,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(vgf2p8affineqb_256, INTR_TYPE_3OP,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(vgf2p8affineqb_512, INTR_TYPE_3OP,
+                     X86ISD::GF2P8AFFINEQB, 0),
+  X86_INTRINSIC_DATA(vgf2p8mulb_128, INTR_TYPE_2OP,
+                     X86ISD::GF2P8MULB, 0),
+  X86_INTRINSIC_DATA(vgf2p8mulb_256, INTR_TYPE_2OP,
+                     X86ISD::GF2P8MULB, 0),
+  X86_INTRINSIC_DATA(vgf2p8mulb_512, INTR_TYPE_2OP,
+                     X86ISD::GF2P8MULB, 0),
+
   X86_INTRINSIC_DATA(xop_vpcomb,        INTR_TYPE_3OP, X86ISD::VPCOM, 0),
   X86_INTRINSIC_DATA(xop_vpcomd,        INTR_TYPE_3OP, X86ISD::VPCOM, 0),
   X86_INTRINSIC_DATA(xop_vpcomq,        INTR_TYPE_3OP, X86ISD::VPCOM, 0),
   X86_INTRINSIC_DATA(xop_vpcomub,       INTR_TYPE_3OP, X86ISD::VPCOMU, 0),
   X86_INTRINSIC_DATA(xop_vpcomud,       INTR_TYPE_3OP, X86ISD::VPCOMU, 0),
   X86_INTRINSIC_DATA(xop_vpcomuq,       INTR_TYPE_3OP, X86ISD::VPCOMU, 0),
   X86_INTRINSIC_DATA(xop_vpcomuw,       INTR_TYPE_3OP, X86ISD::VPCOMU, 0),
   X86_INTRINSIC_DATA(xop_vpcomw,        INTR_TYPE_3OP, X86ISD::VPCOM, 0),

llvm/trunk/lib/Target/X86/X86Subtarget.h

protected:
 
   /// Target has XSAVES instructions
   bool HasXSAVES;
 
   /// Target has carry-less multiplication
   bool HasPCLMUL;
   bool HasVPCLMULQDQ;
 
+  /// Target has Galois 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; }
   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; }

llvm/trunk/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;

llvm/trunk/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.vgf2p8affineinvqb.128(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_vgf2p8affineinvqb_128(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8affineinvqb_128:
+; 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.vgf2p8affineinvqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8affineinvqb.256(<32 x i8>, <32 x i8>, i8)
+define <32 x i8> @test_vgf2p8affineinvqb_256(<32 x i8> %src1, <32 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8affineinvqb_256:
+; 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.256(<32 x i8> %src1, <32 x i8> %src2, i8 11)
+  ret <32 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_vgf2p8affineqb(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8affineqb:
+; 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.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8>, <32 x i8>, i8)
+define <32 x i8> @test_vgf2p8affineqb_256(<32 x i8> %src1, <32 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8affineqb_256:
+; 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.256(<32 x i8> %src1, <32 x i8> %src2, i8 11)
+  ret <32 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.vgf2p8mulb.128(<16 x i8>, <16 x i8>)
+define <16 x i8> @test_vgf2p8mulb_128(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8mulb_128:
+; 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.vgf2p8mulb.128(<16 x i8> %src1, <16 x i8> %src2)
+  ret <16 x i8> %1
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8mulb.256(<32 x i8>, <32 x i8>)
+define <32 x i8> @test_vgf2p8mulb_256(<32 x i8> %src1, <32 x i8> %src2) {
+; CHECK-LABEL: test_vgf2p8mulb_256:
+; 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.256(<32 x i8> %src1, <32 x i8> %src2)
+  ret <32 x i8> %1
+}
+

llvm/trunk/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.vgf2p8affineinvqb.128(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_vgf2p8affineinvqb_128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %passthru, i16 %mask) {
+; CHECK-LABEL: test_vgf2p8affineinvqb_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %xmm1, %xmm0, %xmm3 ## EVEX TO VEX Compression encoding: [0xc4,0xe3,0xf9,0xcf,0xd9,0x03]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %xmm1, %xmm0, %xmm4 {%k1} {z} ## encoding: [0x62,0xf3,0xfd,0x89,0xcf,0xe1,0x03]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf3,0xfd,0x09,0xcf,0xd1,0x03]
+; CHECK-NEXT:    vpxor %xmm3, %xmm2, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xe9,0xef,0xc3]
+; CHECK-NEXT:    vpxor %xmm0, %xmm4, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xd9,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i16 %mask to <16 x i1>
+  %2 = call <16 x i8> @llvm.x86.vgf2p8affineinvqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 3)
+  %3 = select <16 x i1> %1, <16 x i8> %2, <16 x i8> zeroinitializer
+  %4 = select <16 x i1> %1, <16 x i8> %2, <16 x i8> %passthru
+  %5 = xor <16 x i8> %3, %4
+  %6 = xor <16 x i8> %5, %2
+  ret <16 x i8> %6
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8affineinvqb.256(<32 x i8>, <32 x i8>, i8)
+define <32 x i8> @test_vgf2p8affineinvqb_256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> %passthru, i32 %mask) {
+; CHECK-LABEL: test_vgf2p8affineinvqb_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %ymm1, %ymm0, %ymm3 ## EVEX TO VEX Compression encoding: [0xc4,0xe3,0xfd,0xcf,0xd9,0x03]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %ymm1, %ymm0, %ymm4 {%k1} {z} ## encoding: [0x62,0xf3,0xfd,0xa9,0xcf,0xe1,0x03]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf3,0xfd,0x29,0xcf,0xd1,0x03]
+; CHECK-NEXT:    vpxor %ymm3, %ymm2, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xed,0xef,0xc3]
+; CHECK-NEXT:    vpxor %ymm0, %ymm4, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xdd,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i32 %mask to <32 x i1>
+  %2 = call <32 x i8> @llvm.x86.vgf2p8affineinvqb.256(<32 x i8> %src1, <32 x i8> %src2, i8 3)
+  %3 = select <32 x i1> %1, <32 x i8> %2, <32 x i8> zeroinitializer
+  %4 = select <32 x i1> %1, <32 x i8> %2, <32 x i8> %passthru
+  %5 = xor <32 x i8> %3, %4
+  %6 = xor <32 x i8> %5, %2
+  ret <32 x i8> %6
+}
+
+declare <64 x i8> @llvm.x86.vgf2p8affineinvqb.512(<64 x i8>, <64 x i8>, i8)
+define <64 x i8> @test_vgf2p8affineinvqb_512(<64 x i8> %src1, <64 x i8> %src2, <64 x i8> %passthru, i64 %mask) {
+; CHECK-LABEL: test_vgf2p8affineinvqb_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %zmm1, %zmm0, %zmm3 ## encoding: [0x62,0xf3,0xfd,0x48,0xcf,0xd9,0x03]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %zmm1, %zmm0, %zmm4 {%k1} {z} ## encoding: [0x62,0xf3,0xfd,0xc9,0xcf,0xe1,0x03]
+; CHECK-NEXT:    vgf2p8affineinvqb $3, %zmm1, %zmm0, %zmm2 {%k1} ## encoding: [0x62,0xf3,0xfd,0x49,0xcf,0xd1,0x03]
+; CHECK-NEXT:    vpxorq %zmm3, %zmm2, %zmm0 ## encoding: [0x62,0xf1,0xed,0x48,0xef,0xc3]
+; CHECK-NEXT:    vpxorq %zmm0, %zmm4, %zmm0 ## encoding: [0x62,0xf1,0xdd,0x48,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i64 %mask to <64 x i1>
+  %2 = call <64 x i8> @llvm.x86.vgf2p8affineinvqb.512(<64 x i8> %src1, <64 x i8> %src2, i8 3)
+  %3 = select <64 x i1> %1, <64 x i8> %2, <64 x i8> zeroinitializer
+  %4 = select <64 x i1> %1, <64 x i8> %2, <64 x i8> %passthru
+  %5 = xor <64 x i8> %3, %4
+  %6 = xor <64 x i8> %5, %2
+  ret <64 x i8> %6
+}
+
+declare <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_vgf2p8affineqb_128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %passthru, i16 %mask) {
+; CHECK-LABEL: test_vgf2p8affineqb_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %xmm1, %xmm0, %xmm3 ## EVEX TO VEX Compression encoding: [0xc4,0xe3,0xf9,0xce,0xd9,0x03]
+; CHECK-NEXT:    vgf2p8affineqb $3, %xmm1, %xmm0, %xmm4 {%k1} {z} ## encoding: [0x62,0xf3,0xfd,0x89,0xce,0xe1,0x03]
+; CHECK-NEXT:    vgf2p8affineqb $3, %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf3,0xfd,0x09,0xce,0xd1,0x03]
+; CHECK-NEXT:    vpxor %xmm3, %xmm2, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xe9,0xef,0xc3]
+; CHECK-NEXT:    vpxor %xmm0, %xmm4, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xd9,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i16 %mask to <16 x i1>
+  %2 = call <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 3)
+  %3 = select <16 x i1> %1, <16 x i8> %2, <16 x i8> zeroinitializer
+  %4 = select <16 x i1> %1, <16 x i8> %2, <16 x i8> %passthru
+  %5 = xor <16 x i8> %3, %4
+  %6 = xor <16 x i8> %5, %2
+  ret <16 x i8> %6
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8>, <32 x i8>, i8)
+define <32 x i8> @test_vgf2p8affineqb_256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> %passthru, i32 %mask) {
+; CHECK-LABEL: test_vgf2p8affineqb_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %ymm1, %ymm0, %ymm3 ## EVEX TO VEX Compression encoding: [0xc4,0xe3,0xfd,0xce,0xd9,0x03]
+; CHECK-NEXT:    vgf2p8affineqb $3, %ymm1, %ymm0, %ymm4 {%k1} {z} ## encoding: [0x62,0xf3,0xfd,0xa9,0xce,0xe1,0x03]
+; CHECK-NEXT:    vgf2p8affineqb $3, %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf3,0xfd,0x29,0xce,0xd1,0x03]
+; CHECK-NEXT:    vpxor %ymm3, %ymm2, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xed,0xef,0xc3]
+; CHECK-NEXT:    vpxor %ymm0, %ymm4, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xdd,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i32 %mask to <32 x i1>
+  %2 = call <32 x i8> @llvm.x86.vgf2p8affineqb.256(<32 x i8> %src1, <32 x i8> %src2, i8 3)
+  %3 = select <32 x i1> %1, <32 x i8> %2, <32 x i8> zeroinitializer
+  %4 = select <32 x i1> %1, <32 x i8> %2, <32 x i8> %passthru
+  %5 = xor <32 x i8> %3, %4
+  %6 = xor <32 x i8> %5, %2
+  ret <32 x i8> %6
+}
+
+declare <64 x i8> @llvm.x86.vgf2p8affineqb.512(<64 x i8>, <64 x i8>, i8)
+define <64 x i8> @test_vgf2p8affineqb_512(<64 x i8> %src1, <64 x i8> %src2, <64 x i8> %passthru, i64 %mask) {
+; CHECK-LABEL: test_vgf2p8affineqb_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8affineqb $3, %zmm1, %zmm0, %zmm3 ## encoding: [0x62,0xf3,0xfd,0x48,0xce,0xd9,0x03]
+; CHECK-NEXT:    vgf2p8affineqb $3, %zmm1, %zmm0, %zmm4 {%k1} {z} ## encoding: [0x62,0xf3,0xfd,0xc9,0xce,0xe1,0x03]
+; CHECK-NEXT:    vgf2p8affineqb $3, %zmm1, %zmm0, %zmm2 {%k1} ## encoding: [0x62,0xf3,0xfd,0x49,0xce,0xd1,0x03]
+; CHECK-NEXT:    vpxorq %zmm3, %zmm2, %zmm0 ## encoding: [0x62,0xf1,0xed,0x48,0xef,0xc3]
+; CHECK-NEXT:    vpxorq %zmm0, %zmm4, %zmm0 ## encoding: [0x62,0xf1,0xdd,0x48,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i64 %mask to <64 x i1>
+  %2 = call <64 x i8> @llvm.x86.vgf2p8affineqb.512(<64 x i8> %src1, <64 x i8> %src2, i8 3)
+  %3 = select <64 x i1> %1, <64 x i8> %2, <64 x i8> zeroinitializer
+  %4 = select <64 x i1> %1, <64 x i8> %2, <64 x i8> %passthru
+  %5 = xor <64 x i8> %3, %4
+  %6 = xor <64 x i8> %5, %2
+  ret <64 x i8> %6
+}
+
+declare <16 x i8> @llvm.x86.vgf2p8mulb.128(<16 x i8>, <16 x i8>)
+define <16 x i8> @test_vgf2p8mulb_128(<16 x i8> %src1, <16 x i8> %src2, <16 x i8> %passthru, i16 %mask) {
+; CHECK-LABEL: test_vgf2p8mulb_128:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %xmm1, %xmm0, %xmm3 ## EVEX TO VEX Compression encoding: [0xc4,0xe2,0x79,0xcf,0xd9]
+; CHECK-NEXT:    vgf2p8mulb %xmm1, %xmm0, %xmm4 {%k1} {z} ## encoding: [0x62,0xf2,0x7d,0x89,0xcf,0xe1]
+; CHECK-NEXT:    vgf2p8mulb %xmm1, %xmm0, %xmm2 {%k1} ## encoding: [0x62,0xf2,0x7d,0x09,0xcf,0xd1]
+; CHECK-NEXT:    vpxor %xmm3, %xmm2, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xe9,0xef,0xc3]
+; CHECK-NEXT:    vpxor %xmm0, %xmm4, %xmm0 ## EVEX TO VEX Compression encoding: [0xc5,0xd9,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i16 %mask to <16 x i1>
+  %2 = call <16 x i8> @llvm.x86.vgf2p8mulb.128(<16 x i8> %src1, <16 x i8> %src2)
+  %3 = select <16 x i1> %1, <16 x i8> %2, <16 x i8> zeroinitializer
+  %4 = select <16 x i1> %1, <16 x i8> %2, <16 x i8> %passthru
+  %5 = xor <16 x i8> %3, %4
+  %6 = xor <16 x i8> %5, %2
+  ret <16 x i8> %6
+}
+
+declare <32 x i8> @llvm.x86.vgf2p8mulb.256(<32 x i8>, <32 x i8>)
+define <32 x i8> @test_vgf2p8mulb_256(<32 x i8> %src1, <32 x i8> %src2, <32 x i8> %passthru, i32 %mask) {
+; CHECK-LABEL: test_vgf2p8mulb_256:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovd %edi, %k1 ## encoding: [0xc5,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %ymm1, %ymm0, %ymm3 ## EVEX TO VEX Compression encoding: [0xc4,0xe2,0x7d,0xcf,0xd9]
+; CHECK-NEXT:    vgf2p8mulb %ymm1, %ymm0, %ymm4 {%k1} {z} ## encoding: [0x62,0xf2,0x7d,0xa9,0xcf,0xe1]
+; CHECK-NEXT:    vgf2p8mulb %ymm1, %ymm0, %ymm2 {%k1} ## encoding: [0x62,0xf2,0x7d,0x29,0xcf,0xd1]
+; CHECK-NEXT:    vpxor %ymm3, %ymm2, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xed,0xef,0xc3]
+; CHECK-NEXT:    vpxor %ymm0, %ymm4, %ymm0 ## EVEX TO VEX Compression encoding: [0xc5,0xdd,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i32 %mask to <32 x i1>
+  %2 = call <32 x i8> @llvm.x86.vgf2p8mulb.256(<32 x i8> %src1, <32 x i8> %src2)
+  %3 = select <32 x i1> %1, <32 x i8> %2, <32 x i8> zeroinitializer
+  %4 = select <32 x i1> %1, <32 x i8> %2, <32 x i8> %passthru
+  %5 = xor <32 x i8> %3, %4
+  %6 = xor <32 x i8> %5, %2
+  ret <32 x i8> %6
+}
+
+declare <64 x i8> @llvm.x86.vgf2p8mulb.512(<64 x i8>, <64 x i8>)
+define <64 x i8> @test_vgf2p8mulb_512(<64 x i8> %src1, <64 x i8> %src2, <64 x i8> %passthru, i64 %mask) {
+; CHECK-LABEL: test_vgf2p8mulb_512:
+; CHECK:       ## BB#0:
+; CHECK-NEXT:    kmovq %rdi, %k1 ## encoding: [0xc4,0xe1,0xfb,0x92,0xcf]
+; CHECK-NEXT:    vgf2p8mulb %zmm1, %zmm0, %zmm3 ## encoding: [0x62,0xf2,0x7d,0x48,0xcf,0xd9]
+; CHECK-NEXT:    vgf2p8mulb %zmm1, %zmm0, %zmm4 {%k1} {z} ## encoding: [0x62,0xf2,0x7d,0xc9,0xcf,0xe1]
+; CHECK-NEXT:    vgf2p8mulb %zmm1, %zmm0, %zmm2 {%k1} ## encoding: [0x62,0xf2,0x7d,0x49,0xcf,0xd1]
+; CHECK-NEXT:    vpxorq %zmm3, %zmm2, %zmm0 ## encoding: [0x62,0xf1,0xed,0x48,0xef,0xc3]
+; CHECK-NEXT:    vpxorq %zmm0, %zmm4, %zmm0 ## encoding: [0x62,0xf1,0xdd,0x48,0xef,0xc0]
+; CHECK-NEXT:    retq ## encoding: [0xc3]
+  %1 = bitcast i64 %mask to <64 x i1>
+  %2 = call <64 x i8> @llvm.x86.vgf2p8mulb.512(<64 x i8> %src1, <64 x i8> %src2)
+  %3 = select <64 x i1> %1, <64 x i8> %2, <64 x i8> zeroinitializer
+  %4 = select <64 x i1> %1, <64 x i8> %2, <64 x i8> %passthru
+  %5 = xor <64 x i8> %3, %4
+  %6 = xor <64 x i8> %5, %2
+  ret <64 x i8> %6
+}
+

llvm/trunk/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.vgf2p8affineinvqb.128(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_gf2p8affineinvqb_128(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8affineinvqb_128:
+; 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.vgf2p8affineinvqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+ ret <16 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.vgf2p8affineqb.128(<16 x i8>, <16 x i8>, i8)
+define <16 x i8> @test_gf2p8affineqb_128(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8affineqb_128:
+; 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.vgf2p8affineqb.128(<16 x i8> %src1, <16 x i8> %src2, i8 11)
+ ret <16 x i8> %1
+}
+
+declare <16 x i8> @llvm.x86.vgf2p8mulb.128(<16 x i8>, <16 x i8>)
+define <16 x i8> @test_gf2p8mulb_128(<16 x i8> %src1, <16 x i8> %src2) {
+; CHECK-LABEL: test_gf2p8mulb_128:
+; 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.vgf2p8mulb.128(<16 x i8> %src1, <16 x i8> %src2)
+  ret <16 x i8> %1
+}
+

llvm/trunk/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
+

llvm/trunk/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
+

llvm/trunk/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
+