[x86] Introduce the pconfig/enclv instructions

[GBuella]

Summary

Two new instructions: pconfig and enclv. Four new LLVM
intrinsics for pconfig and for encl[u|s|v].

[craig.topper]

lib/Support/Host.cpp

1268

Did you mean -march=native?

lib/Target/X86/X86ISelLowering.cpp

21163

Variable names should be uppercase.

lib/Target/X86/X86ISelLowering.h

567

These aren't used by your patch since you selected the machine node directly.

lib/Target/X86/X86IntrinsicsInfo.h

337

You're not really using the X86ISD opcodes listed in the table here. You're probably better off not putting these in the table and putting the intrinsics in the earlier switch that's used when the table doesn't have an entry. The one that handles Intrinsic::x86_lwpins64

utils/TableGen/X86RecognizableInstr.cpp

681

We should just add all of C8-FF into this switch. They are all defined not sure why they aren't already here. I'll go ahead and do that ahead of this patch.

[GBuella]

utils/TableGen/X86RecognizableInstr.cpp

681

Thanks, I rebased it on top of your change.

[GBuella]

Rebased the patch.
Added pconfig to Icelake Server.

include/llvm/IR/IntrinsicsX86.td

 }
 
 //===----------------------------------------------------------------------===//
 // Cache-line zero
 let TargetPrefix = "x86" in {
   def int_x86_clzero : GCCBuiltin<"__builtin_ia32_clzero">,
       Intrinsic<[], [llvm_ptr_ty], []>;
 }
+
+//===----------------------------------------------------------------------===//
+// Platform Configuration
+let TargetPrefix = "x86" in {
+  def int_x86_pconfig_32 :
+      Intrinsic<[llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []>;
+  def int_x86_pconfig_64 :
+      Intrinsic<[llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty],
+                [llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty], []>;
+}
+
+//===----------------------------------------------------------------------===//
+// SGX Intrinsics
+let TargetPrefix = "x86" in {
+  def int_x86_encls_32 :
+      Intrinsic<[llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []>;
+  def int_x86_encls_64 :
+      Intrinsic<[llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty],
+                [llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty], []>;
+  def int_x86_enclu_32 :
+      Intrinsic<[llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []>;
+  def int_x86_enclu_64 :
+      Intrinsic<[llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty],
+                [llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty], []>;
+  def int_x86_enclv_32 :
+      Intrinsic<[llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                [llvm_i32_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], []>;
+  def int_x86_enclv_64 :
+      Intrinsic<[llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty],
+                [llvm_i32_ty, llvm_i64_ty, llvm_i64_ty, llvm_i64_ty], []>;
+}

lib/Support/Host.cpp

bool sys::getHostCPUFeatures(StringMap<bool> &Features) {
   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;
   Features["rdpid"]           = HasLeaf7 && ((ECX >> 22) & 1);
 
   Features["ibt"] = HasLeaf7 && ((EDX >> 20) & 1);
 
+  // There are two CPUID leafs which information associated with the pconfig
+  // instruction:
+  // EAX=0x7, ECX=0x0 indicates the availability of the instruction (via the 18th
+  // bit of EDX), while the EAX=0x1b leaf returns information on the
+  // availability of specific pconfig leafs.
+  // The target feature here only refers to the the first of these two.
+  // Users might need to check for the availability of specific pconfig
+  // leaves using cpuid, since that information is ignored while
+  // detecting features using the "-mnative" flag.
+  // For more info, see X86 ISA docs.
+  Features["pconfig"] = HasLeaf7 && ((EDX >> 18) & 1);
+
   bool HasLeafD = MaxLevel >= 0xd &&
                   !getX86CpuIDAndInfoEx(0xd, 0x1, &EAX, &EBX, &ECX, &EDX);
 
   // Only enable XSAVE if OS has enabled support for saving YMM state.
   Features["xsaveopt"] = 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 FeatureSoftFloat
     : SubtargetFeature<"soft-float", "UseSoftFloat", "true",
                        "Use software floating point features.">;
 def FeaturePOPCNTFalseDeps : SubtargetFeature<"false-deps-popcnt",
                                      "HasPOPCNTFalseDeps", "true",
                                      "POPCNT has a false dependency on dest register">;
 def FeatureLZCNTFalseDeps : SubtargetFeature<"false-deps-lzcnt-tzcnt",
                                      "HasLZCNTFalseDeps", "true",
                                      "LZCNT/TZCNT have a false dependency on dest register">;
+def FeaturePCONFIG : SubtargetFeature<"pconfig", "HasPCONFIG", "true",
+                                      "platform configuration instruction">;
 // On recent X86 (port bound) processors, its preferable to combine to a single shuffle
 // using a variable mask over multiple fixed shuffles.
 def FeatureFastVariableShuffle
     : SubtargetFeature<"fast-variable-shuffle",
                        "HasFastVariableShuffle",
                        "true", "Shuffles with variable masks are fast">;
 // On some X86 processors, there is no performance hazard to writing only the
 // lower parts of a YMM or ZMM register without clearing the upper part.

lib/Target/X86/X86ISelLowering.h

enum NodeType : unsigned {
       FNSTSW16r,
 
       // Store contents of %ah into %eflags.
       SAHF,
 
       // Get a random integer and indicate whether it is valid in CF.
       RDRAND,
 
+      // Platform Configuration
+      PCONFIG,
+
+      // SGX Intrinsics
+      ENCLS,
+      ENCLU,
+      ENCLV,
+
       // Get a NIST SP800-90B & C compliant random integer and
       // indicate whether it is valid in CF.
       RDSEED,
 
       // SSE42 string comparisons.
       PCMPISTRI,
       PCMPESTRI,
 

lib/Target/X86/X86ISelLowering.cpp

static SDValue getPrefetchNode(unsigned Opc, SDValue Op, SelectionDAG &DAG,
   MVT MaskVT =
     MVT::getVectorVT(MVT::i1, Index.getSimpleValueType().getVectorNumElements());
   SDValue VMask = getMaskNode(Mask, MaskVT, Subtarget, DAG, dl);
   SDValue Ops[] = {VMask, Base, Scale, Index, Disp, Segment, Chain};
   SDNode *Res = DAG.getMachineNode(Opc, dl, MVT::Other, Ops);
   return SDValue(Res, 0);
 }
 
+static SDValue getInstrWFourImplicitOps(SDValue Op, SelectionDAG &DAG,
+                                        const X86Subtarget &Subtarget,
+                                        unsigned Opcode) {
+  SDLoc dl(Op);
+  SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
+  SDValue Chain = Op.getOperand(0);
+  unsigned ArgReg1 = Subtarget.is64Bit() ? X86::RBX : X86::EBX;
+  unsigned ArgReg2 = Subtarget.is64Bit() ? X86::RCX : X86::ECX;
+  unsigned ArgReg3 = Subtarget.is64Bit() ? X86::RDX : X86::EDX;
+  auto ArgVT = Subtarget.is64Bit() ? MVT::i64 : MVT::i32;
+
+  Chain = DAG.getCopyToReg(Chain, dl, X86::EAX, Op->getOperand(2));
+  Chain = DAG.getCopyToReg(Chain, dl, ArgReg1, Op->getOperand(3));
+  Chain = DAG.getCopyToReg(Chain, dl, ArgReg2, Op->getOperand(4));
+  Chain = DAG.getCopyToReg(Chain, dl, ArgReg3, Op->getOperand(5));
+
+  SDNode *Res = DAG.getMachineNode(Opcode, dl, Tys, Chain);
+
+  SDValue a = DAG.getCopyFromReg(SDValue(Res, 0), dl, X86::EAX, MVT::i32, SDValue(Res, 1));
+  SDValue b = DAG.getCopyFromReg(a.getValue(1), dl, ArgReg1, ArgVT, a.getValue(2));
+  SDValue c = DAG.getCopyFromReg(b.getValue(1), dl, ArgReg2, ArgVT, b.getValue(2));
+  SDValue d = DAG.getCopyFromReg(c.getValue(1), dl, ArgReg3, ArgVT, c.getValue(2));
+
+  return DAG.getMergeValues({a, b, c, d, SDValue(Res, 0)}, dl);
+}
+
 /// Handles the lowering of builtin intrinsic that return the value
 /// of the extended control register.
 static void getExtendedControlRegister(SDNode *N, const SDLoc &DL,
                                        SelectionDAG &DAG,
                                        const X86Subtarget &Subtarget,
                                        SmallVectorImpl<SDValue> &Results) {
   assert(N->getNumOperands() == 3 && "Unexpected number of operands!");
   SDVTList Tys = DAG.getVTList(MVT::Other, MVT::Glue);
SDValue Ops[] = { DAG.getZExtOrTrunc(Result, dl, Op->getValueType(1)),
                       DAG.getConstant(X86::COND_B, dl, MVT::i8),
                       SDValue(Result.getNode(), 1) };
     SDValue isValid = DAG.getNode(X86ISD::CMOV, dl, Op->getValueType(1), Ops);
 
     // Return { result, isValid, chain }.
     return DAG.getNode(ISD::MERGE_VALUES, dl, Op->getVTList(), Result, isValid,
                        SDValue(Result.getNode(), 2));
   }
+
+  case PCONFIG:
+    return getInstrWFourImplicitOps(Op, DAG, Subtarget, X86::PCONFIG);
+
+  case ENCLS:
+    return getInstrWFourImplicitOps(Op, DAG, Subtarget, X86::ENCLS);
+  case ENCLU:
+    return getInstrWFourImplicitOps(Op, DAG, Subtarget, X86::ENCLU);
+  case ENCLV:
+    return getInstrWFourImplicitOps(Op, DAG, Subtarget, X86::ENCLV);
+
   case GATHER_AVX2: {
     SDValue Chain = Op.getOperand(0);
     SDValue Src   = Op.getOperand(2);
     SDValue Base  = Op.getOperand(3);
     SDValue Index = Op.getOperand(4);
     SDValue Mask  = Op.getOperand(5);
     SDValue Scale = Op.getOperand(6);
     return getAVX2GatherNode(IntrData->Opc0, Op, DAG, Src, Mask, Base, Index,
case ISD::MGATHER: {
     break;
   }
   }
 }
 
 const char *X86TargetLowering::getTargetNodeName(unsigned Opcode) const {
   switch ((X86ISD::NodeType)Opcode) {
   case X86ISD::FIRST_NUMBER:       break;
+  case X86ISD::ENCLS:              return "X86ISD::ENCLS";
+  case X86ISD::ENCLU:              return "X86ISD::ENCLU";
+  case X86ISD::ENCLV:              return "X86ISD::ENCLV";
+  case X86ISD::PCONFIG:            return "X86ISD::PCONFIG";
   case X86ISD::BSF:                return "X86ISD::BSF";
   case X86ISD::BSR:                return "X86ISD::BSR";
   case X86ISD::SHLD:               return "X86ISD::SHLD";
   case X86ISD::SHRD:               return "X86ISD::SHRD";
   case X86ISD::FAND:               return "X86ISD::FAND";
   case X86ISD::FANDN:              return "X86ISD::FANDN";
   case X86ISD::FOR:                return "X86ISD::FOR";
   case X86ISD::FXOR:               return "X86ISD::FXOR";

lib/Target/X86/X86InstrInfo.td

 def HasBMI2      : Predicate<"Subtarget->hasBMI2()">;
 def NoBMI2       : Predicate<"!Subtarget->hasBMI2()">;
 def HasVBMI      : Predicate<"Subtarget->hasVBMI()">;
 def HasVBMI2     : Predicate<"Subtarget->hasVBMI2()">;
 def HasIFMA      : Predicate<"Subtarget->hasIFMA()">;
 def HasRTM       : Predicate<"Subtarget->hasRTM()">;
 def HasADX       : Predicate<"Subtarget->hasADX()">;
 def HasSHA       : Predicate<"Subtarget->hasSHA()">;
+def HasSGX       : Predicate<"Subtarget->hasSGX()">;
 def HasPRFCHW    : Predicate<"Subtarget->hasPRFCHW()">;
 def HasRDSEED    : Predicate<"Subtarget->hasRDSEED()">;
 def HasSSEPrefetch : Predicate<"Subtarget->hasSSEPrefetch()">;
 def NoSSEPrefetch : Predicate<"!Subtarget->hasSSEPrefetch()">;
 def HasPrefetchW : Predicate<"Subtarget->hasPRFCHW()">;
 def HasPREFETCHWT1 : Predicate<"Subtarget->hasPREFETCHWT1()">;
 def HasLAHFSAHF  : Predicate<"Subtarget->hasLAHFSAHF()">;
 def HasMWAITX    : Predicate<"Subtarget->hasMWAITX()">;
 def HasCLZERO    : Predicate<"Subtarget->hasCLZERO()">;
 def FPStackf32   : Predicate<"!Subtarget->hasSSE1()">;
 def FPStackf64   : Predicate<"!Subtarget->hasSSE2()">;
 def HasMPX       : Predicate<"Subtarget->hasMPX()">;
 def HasSHSTK     : Predicate<"Subtarget->hasSHSTK()">;
 def HasIBT       : Predicate<"Subtarget->hasIBT()">;
 def HasCLFLUSHOPT : Predicate<"Subtarget->hasCLFLUSHOPT()">;
 def HasCLWB      : Predicate<"Subtarget->hasCLWB()">;
 def HasRDPID     : Predicate<"Subtarget->hasRDPID()">;
 def HasCmpxchg16b: Predicate<"Subtarget->hasCmpxchg16b()">;
+def HasPCONFIG   : Predicate<"Subtarget->hasPCONFIG()">;
 def Not64BitMode : Predicate<"!Subtarget->is64Bit()">,
                              AssemblerPredicate<"!Mode64Bit", "Not 64-bit mode">;
 def In64BitMode  : Predicate<"Subtarget->is64Bit()">,
                              AssemblerPredicate<"Mode64Bit", "64-bit mode">;
 def IsLP64  : Predicate<"Subtarget->isTarget64BitLP64()">;
 def NotLP64 : Predicate<"!Subtarget->isTarget64BitLP64()">;
 def In16BitMode  : Predicate<"Subtarget->is16Bit()">,
                              AssemblerPredicate<"Mode16Bit", "16-bit mode">;

lib/Target/X86/X86InstrSGX.td

 // This file describes the instructions that make up the Intel SGX instruction
 // set.
 //
 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 // SGX instructions
 
-let SchedRW = [WriteSystem] in {
+let SchedRW = [WriteSystem], Predicates = [HasSGX] in {
 // ENCLS - Execute an Enclave System Function of Specified Leaf Number
 def ENCLS : I<0x01, MRM_CF, (outs), (ins),
              "encls", []>, TB;
 
 // ENCLU - Execute an Enclave User Function of Specified Leaf Number
 def ENCLU : I<0x01, MRM_D7, (outs), (ins),
              "enclu", []>, TB;
+
+// ENCLV - Execute an Enclave VMM Function of Specified Leaf Number
+def ENCLV : I<0x01, MRM_C0, (outs), (ins),
+             "enclv", []>, TB;
 } // SchedRW

lib/Target/X86/X86InstrSystem.td

def PTWRITE64m : RI<0xAE, MRM4m, (outs), (ins i64mem:$dst),
                     Requires<[In64BitMode]>;
 
 def PTWRITEr : I<0xAE, MRM4r, (outs), (ins GR32:$dst),
                  "ptwrite{l}\t$dst", [], IIC_PTWRITE>, XS;
 def PTWRITE64r : RI<0xAE, MRM4r, (outs), (ins GR64:$dst),
                     "ptwrite{q}\t$dst", [], IIC_PTWRITE>, XS,
                     Requires<[In64BitMode]>;
 } // SchedRW
+
+//===----------------------------------------------------------------------===//
+// Platform Configuration instruction
+
+// From ISA docs:
+//  "This instruction is used to execute functions for configuring platform
+//   features.
+//   EAX: Leaf function to be invoked.
+//   RBX/RCX/RDX: Leaf-specific purpose."
+//  "Successful execution of the leaf clears RAX (set to zero) and ZF, CF, PF,
+//   AF, OF, and SF are cleared. In case of failure, the failure reason is
+//   indicated in RAX with ZF set to 1 and CF, PF, AF, OF, and SF are cleared."
+// Thus all these mentioned registers are considered clobbered.
+
+let Uses = [RAX, RBX, RCX, RDX], Defs = [RAX, RBX, RCX, RDX, EFLAGS] in
+    def PCONFIG : I<0x01, MRM_C5, (outs), (ins), "pconfig", []>, TB,
+                  Requires<[HasPCONFIG]>;

lib/Target/X86/X86IntrinsicsInfo.h

enum IntrinsicType : uint16_t {
   IFMA_OP_MASK, IFMA_OP_MASKZ,
   VPERM_2OP_MASK, VPERM_3OP_MASK, VPERM_3OP_MASKZ, INTR_TYPE_SCALAR_MASK,
   INTR_TYPE_SCALAR_MASK_RM, INTR_TYPE_3OP_SCALAR_MASK,
   COMPRESS_EXPAND_IN_REG, COMPRESS_TO_MEM,
   TRUNCATE_TO_MEM_VI8, TRUNCATE_TO_MEM_VI16, TRUNCATE_TO_MEM_VI32,
   EXPAND_FROM_MEM,
   TERLOG_OP_MASK, TERLOG_OP_MASKZ, FIXUPIMM, FIXUPIMM_MASKZ, FIXUPIMMS,
   FIXUPIMMS_MASKZ, GATHER_AVX2,
-  ROUNDP, ROUNDS
+  ROUNDP, ROUNDS,
+  PCONFIG, ENCLS, ENCLU, ENCLV
 };
 
 struct IntrinsicData {
 
   uint16_t      Id;
   IntrinsicType Type;
   uint16_t      Opc0;
   uint16_t      Opc1;
static const IntrinsicData IntrinsicsWithChain[] = {
   X86_INTRINSIC_DATA(avx512_scattersiv2_df, SCATTER, X86::VSCATTERDPDZ128mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv2_di, SCATTER, X86::VPSCATTERDQZ128mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv4_df, SCATTER, X86::VSCATTERDPDZ256mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv4_di, SCATTER, X86::VPSCATTERDQZ256mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv4_sf, SCATTER, X86::VSCATTERDPSZ128mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv4_si, SCATTER, X86::VPSCATTERDDZ128mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv8_sf, SCATTER, X86::VSCATTERDPSZ256mr, 0),
   X86_INTRINSIC_DATA(avx512_scattersiv8_si, SCATTER, X86::VPSCATTERDDZ256mr, 0),
+  X86_INTRINSIC_DATA(encls_32, ENCLS, X86ISD::ENCLS, 0),
+  X86_INTRINSIC_DATA(encls_64, ENCLS, X86ISD::ENCLS, 0),
+  X86_INTRINSIC_DATA(enclu_32, ENCLU, X86ISD::ENCLU, 0),
+  X86_INTRINSIC_DATA(enclu_64, ENCLU, X86ISD::ENCLU, 0),
+  X86_INTRINSIC_DATA(enclv_32, ENCLV, X86ISD::ENCLV, 0),
+  X86_INTRINSIC_DATA(enclv_64, ENCLV, X86ISD::ENCLV, 0),
+  X86_INTRINSIC_DATA(pconfig_32, PCONFIG, X86ISD::PCONFIG, 0),
+  X86_INTRINSIC_DATA(pconfig_64, PCONFIG, X86ISD::PCONFIG, 0),
   X86_INTRINSIC_DATA(rdpmc,     RDPMC,  X86ISD::RDPMC_DAG, 0),
   X86_INTRINSIC_DATA(rdrand_16, RDRAND, X86ISD::RDRAND, 0),
   X86_INTRINSIC_DATA(rdrand_32, RDRAND, X86ISD::RDRAND, 0),
   X86_INTRINSIC_DATA(rdrand_64, RDRAND, X86ISD::RDRAND, 0),
   X86_INTRINSIC_DATA(rdseed_16, RDSEED, X86ISD::RDSEED, 0),
   X86_INTRINSIC_DATA(rdseed_32, RDSEED, X86ISD::RDSEED, 0),
   X86_INTRINSIC_DATA(rdseed_64, RDSEED, X86ISD::RDSEED, 0),
   X86_INTRINSIC_DATA(rdtsc,     RDTSC,  X86ISD::RDTSC_DAG, 0),

lib/Target/X86/X86Subtarget.h

protected:
   bool HasCLFLUSHOPT;
 
   /// Processor supports Cache Line Write Back instruction
   bool HasCLWB;
 
   /// Processor support RDPID instruction
   bool HasRDPID;
 
+  /// Processor supports PCONFIG instruction
+  bool HasPCONFIG;
+
   /// Use a retpoline thunk rather than indirect calls to block speculative
   /// execution.
   bool UseRetpoline;
 
   /// When using a retpoline thunk, call an externally provided thunk rather
   /// than emitting one inside the compiler.
   bool UseRetpolineExternalThunk;
 
public:
   bool hasVNNI() const { return HasVNNI; }
   bool hasBITALG() const { return HasBITALG; }
   bool hasMPX() const { return HasMPX; }
   bool hasSHSTK() const { return HasSHSTK; }
   bool hasIBT() const { return HasIBT; }
   bool hasCLFLUSHOPT() const { return HasCLFLUSHOPT; }
   bool hasCLWB() const { return HasCLWB; }
   bool hasRDPID() const { return HasRDPID; }
+  bool hasPCONFIG() const { return HasPCONFIG; }
+  bool hasSGX() const { return HasSGX; }
   bool useRetpoline() const { return UseRetpoline; }
   bool useRetpolineExternalThunk() const { return UseRetpolineExternalThunk; }
 
   unsigned getPreferVectorWidth() const { return PreferVectorWidth; }
   unsigned getRequiredVectorWidth() const { return RequiredVectorWidth; }
 
   // Helper functions to determine when we should allow widening to 512-bit
   // during codegen.

lib/Target/X86/X86Subtarget.cpp

void X86Subtarget::initializeEnvironment() {
   HasRDSEED = false;
   HasLAHFSAHF = false;
   HasMWAITX = false;
   HasCLZERO = false;
   HasMPX = false;
   HasSHSTK = false;
   HasIBT = false;
   HasSGX = false;
+  HasPCONFIG = false;
   HasCLFLUSHOPT = false;
   HasCLWB = false;
   HasRDPID = false;
   UseRetpoline = false;
   UseRetpolineExternalThunk = false;
   IsPMULLDSlow = false;
   IsSHLDSlow = false;
   IsUAMem16Slow = false;

test/CodeGen/X86/SGX32-intrinsics.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=i686-unknown-unknown -mattr=+sgx | FileCheck %s
+
+; Function Attrs: nounwind
+define i32 @test_encls(i32 %leaf, i32* nocapture %d) local_unnamed_addr #0 {
+; CHECK-LABEL: test_encls:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushl %ebx
+; CHECK-NEXT:    .cfi_def_cfa_offset 8
+; CHECK-NEXT:    pushl %esi
+; CHECK-NEXT:    .cfi_def_cfa_offset 12
+; CHECK-NEXT:    .cfi_offset %esi, -12
+; CHECK-NEXT:    .cfi_offset %ebx, -8
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %esi
+; CHECK-NEXT:    movl (%esi), %ebx
+; CHECK-NEXT:    movl 4(%esi), %ecx
+; CHECK-NEXT:    movl 8(%esi), %edx
+; CHECK-NEXT:    encls
+; CHECK-NEXT:    movl %ebx, (%esi)
+; CHECK-NEXT:    movl %ecx, 4(%esi)
+; CHECK-NEXT:    movl %edx, 8(%esi)
+; CHECK-NEXT:    popl %esi
+; CHECK-NEXT:    popl %ebx
+; CHECK-NEXT:    retl
+entry:
+  %add.ptr.i = getelementptr inbounds i32, i32* %d, i32 1
+  %add.ptr1.i = getelementptr inbounds i32, i32* %d, i32 2
+  %0 = load i32, i32* %d, align 4
+  %1 = load i32, i32* %add.ptr.i, align 4
+  %2 = load i32, i32* %add.ptr1.i, align 4
+  %3 = tail call { i32, i32, i32, i32 } @llvm.x86.encls.32(i32 %leaf, i32 %0, i32 %1, i32 %2) #1
+  %4 = extractvalue { i32, i32, i32, i32 } %3, 1
+  store i32 %4, i32* %d, align 4
+  %5 = extractvalue { i32, i32, i32, i32 } %3, 2
+  store i32 %5, i32* %add.ptr.i, align 4
+  %6 = extractvalue { i32, i32, i32, i32 } %3, 3
+  store i32 %6, i32* %add.ptr1.i, align 4
+  %7 = extractvalue { i32, i32, i32, i32 } %3, 0
+  ret i32 %7
+}
+
+declare { i32, i32, i32, i32 } @llvm.x86.encls.32(i32, i32, i32, i32) #1
+
+; Function Attrs: nounwind
+define i32 @test_enclu(i32 %leaf, i32* nocapture %d) local_unnamed_addr #0 {
+; CHECK-LABEL: test_enclu:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushl %ebx
+; CHECK-NEXT:    .cfi_def_cfa_offset 8
+; CHECK-NEXT:    pushl %esi
+; CHECK-NEXT:    .cfi_def_cfa_offset 12
+; CHECK-NEXT:    .cfi_offset %esi, -12
+; CHECK-NEXT:    .cfi_offset %ebx, -8
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %esi
+; CHECK-NEXT:    movl (%esi), %ebx
+; CHECK-NEXT:    movl 4(%esi), %ecx
+; CHECK-NEXT:    movl 8(%esi), %edx
+; CHECK-NEXT:    enclu
+; CHECK-NEXT:    movl %ebx, (%esi)
+; CHECK-NEXT:    movl %ecx, 4(%esi)
+; CHECK-NEXT:    movl %edx, 8(%esi)
+; CHECK-NEXT:    popl %esi
+; CHECK-NEXT:    popl %ebx
+; CHECK-NEXT:    retl
+entry:
+  %add.ptr.i = getelementptr inbounds i32, i32* %d, i32 1
+  %add.ptr1.i = getelementptr inbounds i32, i32* %d, i32 2
+  %0 = load i32, i32* %d, align 4
+  %1 = load i32, i32* %add.ptr.i, align 4
+  %2 = load i32, i32* %add.ptr1.i, align 4
+  %3 = tail call { i32, i32, i32, i32 } @llvm.x86.enclu.32(i32 %leaf, i32 %0, i32 %1, i32 %2) #1
+  %4 = extractvalue { i32, i32, i32, i32 } %3, 1
+  store i32 %4, i32* %d, align 4
+  %5 = extractvalue { i32, i32, i32, i32 } %3, 2
+  store i32 %5, i32* %add.ptr.i, align 4
+  %6 = extractvalue { i32, i32, i32, i32 } %3, 3
+  store i32 %6, i32* %add.ptr1.i, align 4
+  %7 = extractvalue { i32, i32, i32, i32 } %3, 0
+  ret i32 %7
+}
+
+declare { i32, i32, i32, i32 } @llvm.x86.enclu.32(i32, i32, i32, i32) #1
+
+; Function Attrs: nounwind
+define i32 @test_enclv(i32 %leaf, i32* nocapture %d) local_unnamed_addr #0 {
+; CHECK-LABEL: test_enclv:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushl %ebx
+; CHECK-NEXT:    .cfi_def_cfa_offset 8
+; CHECK-NEXT:    pushl %esi
+; CHECK-NEXT:    .cfi_def_cfa_offset 12
+; CHECK-NEXT:    .cfi_offset %esi, -12
+; CHECK-NEXT:    .cfi_offset %ebx, -8
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %esi
+; CHECK-NEXT:    movl (%esi), %ebx
+; CHECK-NEXT:    movl 4(%esi), %ecx
+; CHECK-NEXT:    movl 8(%esi), %edx
+; CHECK-NEXT:    enclv
+; CHECK-NEXT:    movl %ebx, (%esi)
+; CHECK-NEXT:    movl %ecx, 4(%esi)
+; CHECK-NEXT:    movl %edx, 8(%esi)
+; CHECK-NEXT:    popl %esi
+; CHECK-NEXT:    popl %ebx
+; CHECK-NEXT:    retl
+entry:
+  %add.ptr.i = getelementptr inbounds i32, i32* %d, i32 1
+  %add.ptr1.i = getelementptr inbounds i32, i32* %d, i32 2
+  %0 = load i32, i32* %d, align 4
+  %1 = load i32, i32* %add.ptr.i, align 4
+  %2 = load i32, i32* %add.ptr1.i, align 4
+  %3 = tail call { i32, i32, i32, i32 } @llvm.x86.enclv.32(i32 %leaf, i32 %0, i32 %1, i32 %2) #1
+  %4 = extractvalue { i32, i32, i32, i32 } %3, 1
+  store i32 %4, i32* %d, align 4
+  %5 = extractvalue { i32, i32, i32, i32 } %3, 2
+  store i32 %5, i32* %add.ptr.i, align 4
+  %6 = extractvalue { i32, i32, i32, i32 } %3, 3
+  store i32 %6, i32* %add.ptr1.i, align 4
+  %7 = extractvalue { i32, i32, i32, i32 } %3, 0
+  ret i32 %7
+}
+
+declare { i32, i32, i32, i32 } @llvm.x86.enclv.32(i32, i32, i32, i32) #1

test/CodeGen/X86/SGX64-intrinsics.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+sgx | FileCheck %s
+
+define i32 @test_encls(i32 %leaf, i64* nocapture %arguments) local_unnamed_addr #0 {
+; CHECK-LABEL: test_encls:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushq %rbx
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    .cfi_offset %rbx, -16
+; CHECK-NEXT:    movq (%rsi), %rbx
+; CHECK-NEXT:    movq 8(%rsi), %rcx
+; CHECK-NEXT:    movq 16(%rsi), %rdx
+; CHECK-NEXT:    encls
+; CHECK-NEXT:    movq %rbx, (%rsi)
+; CHECK-NEXT:    movq %rcx, 8(%rsi)
+; CHECK-NEXT:    movq %rdx, 16(%rsi)
+; CHECK-NEXT:    movl %edi, %eax
+; CHECK-NEXT:    popq %rbx
+; CHECK-NEXT:    retq
+entry:
+  %add.ptr.i = getelementptr inbounds i64, i64* %arguments, i64 1
+  %add.ptr1.i = getelementptr inbounds i64, i64* %arguments, i64 2
+  %0 = load i64, i64* %arguments, align 8
+  %1 = load i64, i64* %add.ptr.i, align 8
+  %2 = load i64, i64* %add.ptr1.i, align 8
+  %3 = tail call { i32, i64, i64, i64 } @llvm.x86.encls.64(i32 %leaf, i64 %0, i64 %1, i64 %2) #1
+  %4 = extractvalue { i32, i64, i64, i64 } %3, 1
+  store i64 %4, i64* %arguments, align 8
+  %5 = extractvalue { i32, i64, i64, i64 } %3, 2
+  store i64 %5, i64* %add.ptr.i, align 8
+  %6 = extractvalue { i32, i64, i64, i64 } %3, 3
+  store i64 %6, i64* %add.ptr1.i, align 8
+  %7 = extractvalue { i32, i64, i64, i64 } %3, 0
+  ret i32 %7
+}
+
+; Function Attrs: nounwind
+define i32 @test_enclu(i32 %leaf, i64* nocapture %arguments) local_unnamed_addr #0 {
+; CHECK-LABEL: test_enclu:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushq %rbx
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    .cfi_offset %rbx, -16
+; CHECK-NEXT:    movq (%rsi), %rbx
+; CHECK-NEXT:    movq 8(%rsi), %rcx
+; CHECK-NEXT:    movq 16(%rsi), %rdx
+; CHECK-NEXT:    enclu
+; CHECK-NEXT:    movq %rbx, (%rsi)
+; CHECK-NEXT:    movq %rcx, 8(%rsi)
+; CHECK-NEXT:    movq %rdx, 16(%rsi)
+; CHECK-NEXT:    movl %edi, %eax
+; CHECK-NEXT:    popq %rbx
+; CHECK-NEXT:    retq
+entry:
+  %add.ptr.i = getelementptr inbounds i64, i64* %arguments, i64 1
+  %add.ptr1.i = getelementptr inbounds i64, i64* %arguments, i64 2
+  %0 = load i64, i64* %arguments, align 8
+  %1 = load i64, i64* %add.ptr.i, align 8
+  %2 = load i64, i64* %add.ptr1.i, align 8
+  %3 = tail call { i32, i64, i64, i64 } @llvm.x86.enclu.64(i32 %leaf, i64 %0, i64 %1, i64 %2) #1
+  %4 = extractvalue { i32, i64, i64, i64 } %3, 1
+  store i64 %4, i64* %arguments, align 8
+  %5 = extractvalue { i32, i64, i64, i64 } %3, 2
+  store i64 %5, i64* %add.ptr.i, align 8
+  %6 = extractvalue { i32, i64, i64, i64 } %3, 3
+  store i64 %6, i64* %add.ptr1.i, align 8
+  %7 = extractvalue { i32, i64, i64, i64 } %3, 0
+  ret i32 %7
+}
+
+define i32 @test_enclv(i32 %leaf, i64* nocapture %arguments) local_unnamed_addr #0 {
+; CHECK-LABEL: test_enclv:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushq %rbx
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    .cfi_offset %rbx, -16
+; CHECK-NEXT:    movq (%rsi), %rbx
+; CHECK-NEXT:    movq 8(%rsi), %rcx
+; CHECK-NEXT:    movq 16(%rsi), %rdx
+; CHECK-NEXT:    enclv
+; CHECK-NEXT:    movq %rbx, (%rsi)
+; CHECK-NEXT:    movq %rcx, 8(%rsi)
+; CHECK-NEXT:    movq %rdx, 16(%rsi)
+; CHECK-NEXT:    movl %edi, %eax
+; CHECK-NEXT:    popq %rbx
+; CHECK-NEXT:    retq
+entry:
+  %add.ptr.i = getelementptr inbounds i64, i64* %arguments, i64 1
+  %add.ptr1.i = getelementptr inbounds i64, i64* %arguments, i64 2
+  %0 = load i64, i64* %arguments, align 8
+  %1 = load i64, i64* %add.ptr.i, align 8
+  %2 = load i64, i64* %add.ptr1.i, align 8
+  %3 = tail call { i32, i64, i64, i64 } @llvm.x86.enclv.64(i32 %leaf, i64 %0, i64 %1, i64 %2) #1
+  %4 = extractvalue { i32, i64, i64, i64 } %3, 1
+  store i64 %4, i64* %arguments, align 8
+  %5 = extractvalue { i32, i64, i64, i64 } %3, 2
+  store i64 %5, i64* %add.ptr.i, align 8
+  %6 = extractvalue { i32, i64, i64, i64 } %3, 3
+  store i64 %6, i64* %add.ptr1.i, align 8
+  %7 = extractvalue { i32, i64, i64, i64 } %3, 0
+  ret i32 %7
+}
+
+declare { i32, i64, i64, i64 } @llvm.x86.encls.64(i32, i64, i64, i64) #1
+declare { i32, i64, i64, i64 } @llvm.x86.enclu.64(i32, i64, i64, i64) #1
+declare { i32, i64, i64, i64 } @llvm.x86.enclv.64(i32, i64, i64, i64) #1

test/CodeGen/X86/pconfig32-intrinsic.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=i686-unknown-unknown -mattr=+pconfig | FileCheck %s
+
+; Function Attrs: nounwind
+define i32 @test_pconfig(i32 %leaf, i32* nocapture %d) local_unnamed_addr #0 {
+; CHECK-LABEL: test_pconfig:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushl %ebx
+; CHECK-NEXT:    .cfi_def_cfa_offset 8
+; CHECK-NEXT:    pushl %esi
+; CHECK-NEXT:    .cfi_def_cfa_offset 12
+; CHECK-NEXT:    .cfi_offset %esi, -12
+; CHECK-NEXT:    .cfi_offset %ebx, -8
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %eax
+; CHECK-NEXT:    movl {{[0-9]+}}(%esp), %esi
+; CHECK-NEXT:    movl (%esi), %ebx
+; CHECK-NEXT:    movl 4(%esi), %ecx
+; CHECK-NEXT:    movl 8(%esi), %edx
+; CHECK-NEXT:    # kill: def %eax killed %eax def %rax
+; CHECK-NEXT:    # kill: def %ebx killed %ebx def %rbx
+; CHECK-NEXT:    # kill: def %ecx killed %ecx def %rcx
+; CHECK-NEXT:    # kill: def %edx killed %edx def %rdx
+; CHECK-NEXT:    pconfig
+; CHECK-NEXT:    movl %ebx, (%esi)
+; CHECK-NEXT:    movl %ecx, 4(%esi)
+; CHECK-NEXT:    movl %edx, 8(%esi)
+; CHECK-NEXT:    popl %esi
+; CHECK-NEXT:    popl %ebx
+; CHECK-NEXT:    retl
+entry:
+  %add.ptr.i = getelementptr inbounds i32, i32* %d, i32 1
+  %add.ptr1.i = getelementptr inbounds i32, i32* %d, i32 2
+  %0 = load i32, i32* %d, align 4
+  %1 = load i32, i32* %add.ptr.i, align 4
+  %2 = load i32, i32* %add.ptr1.i, align 4
+  %3 = tail call { i32, i32, i32, i32 } @llvm.x86.pconfig.32(i32 %leaf, i32 %0, i32 %1, i32 %2) #1
+  %4 = extractvalue { i32, i32, i32, i32 } %3, 1
+  store i32 %4, i32* %d, align 4
+  %5 = extractvalue { i32, i32, i32, i32 } %3, 2
+  store i32 %5, i32* %add.ptr.i, align 4
+  %6 = extractvalue { i32, i32, i32, i32 } %3, 3
+  store i32 %6, i32* %add.ptr1.i, align 4
+  %7 = extractvalue { i32, i32, i32, i32 } %3, 0
+  ret i32 %7
+}
+
+; Function Attrs: nounwind
+declare { i32, i32, i32, i32 } @llvm.x86.pconfig.32(i32, i32, i32, i32) #1

test/CodeGen/X86/pconfig64-intrinsic.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=x86_64-unknown-unknown -mattr=+pconfig | FileCheck %s
+
+; Function Attrs: nounwind
+define i32 @test_pconfig(i32 %leaf, i64* nocapture %d) local_unnamed_addr #0 {
+; CHECK-LABEL: test_pconfig:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    pushq %rbx
+; CHECK-NEXT:    .cfi_def_cfa_offset 16
+; CHECK-NEXT:    .cfi_offset %rbx, -16
+; CHECK-NEXT:    movq (%rsi), %rbx
+; CHECK-NEXT:    movq 8(%rsi), %rcx
+; CHECK-NEXT:    movq 16(%rsi), %rdx
+; CHECK-NEXT:    movl %edi, %eax
+; CHECK-NEXT:    pconfig
+; CHECK-NEXT:    movq %rbx, (%rsi)
+; CHECK-NEXT:    movq %rcx, 8(%rsi)
+; CHECK-NEXT:    movq %rdx, 16(%rsi)
+; CHECK-NEXT:    popq %rbx
+; CHECK-NEXT:    retq
+entry:
+  %add.ptr.i = getelementptr inbounds i64, i64* %d, i64 1
+  %add.ptr1.i = getelementptr inbounds i64, i64* %d, i64 2
+  %0 = load i64, i64* %d, align 8
+  %1 = load i64, i64* %add.ptr.i, align 8
+  %2 = load i64, i64* %add.ptr1.i, align 8
+  %3 = tail call { i32, i64, i64, i64 } @llvm.x86.pconfig.64(i32 %leaf, i64 %0, i64 %1, i64 %2) #1
+  %4 = extractvalue { i32, i64, i64, i64 } %3, 1
+  store i64 %4, i64* %d, align 8
+  %5 = extractvalue { i32, i64, i64, i64 } %3, 2
+  store i64 %5, i64* %add.ptr.i, align 8
+  %6 = extractvalue { i32, i64, i64, i64 } %3, 3
+  store i64 %6, i64* %add.ptr1.i, align 8
+  %7 = extractvalue { i32, i64, i64, i64 } %3, 0
+  ret i32 %7
+}
+
+; Function Attrs: nounwind
+declare { i32, i64, i64, i64 } @llvm.x86.pconfig.64(i32, i64, i64, i64) #1

test/MC/X86/sgx-encoding.s

 // RUN: llvm-mc -triple x86_64-unknown-unknown --show-encoding %s | FileCheck %s
 
 // CHECK: encls
 // CHECK: encoding: [0x0f,0x01,0xcf]
   encls
 
 // CHECK: enclu
 // CHECK: encoding: [0x0f,0x01,0xd7]
   enclu
+
+// CHECK: enclv
+// CHECK: encoding: [0x0f,0x01,0xc0]
+  enclv

test/MC/X86/x86-32-coverage.s

 // CHECK:  encoding: [0x0f,0x01,0xfc]
           clzero
 
 // CHECK: lock addl %esi, (%edi)
 // INTEL: lock add dword ptr [edi], esi
 // CHECK:  encoding: [0xf0,0x01,0x37]
           lock add %esi, (%edi)
 
+// CHECK: pconfig
+// CHECK:  encoding: [0x0f,0x01,0xc5]
+                pconfig

test/MC/X86/x86-64.s

 // CHECK: ptwriteq 3735928559(%rbx,%rcx,8)
 // CHECK:  encoding: [0xf3,0x48,0x0f,0xae,0xa4,0xcb,0xef,0xbe,0xad,0xde]
 ptwriteq 0xdeadbeef(%rbx,%rcx,8)
 
 // CHECK: ptwriteq %rax
 // CHECK:  encoding: [0xf3,0x48,0x0f,0xae,0xe0]
 ptwriteq %rax
 
+// CHECK: pconfig
+// CHECK:  encoding: [0x0f,0x01,0xc5]
+pconfig
+
 //  __asm __volatile(
 //    "pushf        \n\t"
 //    "popf       \n\t"
 //    "rep        \n\t"
 //    ".byte  0x0f, 0xa7, 0xd0"
 //  );
 // CHECK: pushfq
 // CHECK-NEXT: popfq

utils/TableGen/X86RecognizableInstr.cpp

if (Opcode == 0xc6) {
       HANDLE_OPERAND(immediate)
     } else if (Opcode == 0xc7) {
       assert(numPhysicalOperands == 1 &&
              "Unexpected number of operands for X86Local::MRM_F8");
       HANDLE_OPERAND(relocation)
     }
     break;
   case X86Local::MRM_C0: case X86Local::MRM_C1: case X86Local::MRM_C2:
-  case X86Local::MRM_C3: case X86Local::MRM_C4: case X86Local::MRM_C8:
-  case X86Local::MRM_C9: case X86Local::MRM_CA: case X86Local::MRM_CB:
-  case X86Local::MRM_CF: case X86Local::MRM_D0: case X86Local::MRM_D1:
-  case X86Local::MRM_D4: case X86Local::MRM_D5: case X86Local::MRM_D6:
-  case X86Local::MRM_D7: case X86Local::MRM_D8: case X86Local::MRM_D9:
-  case X86Local::MRM_DA: case X86Local::MRM_DB: case X86Local::MRM_DC:
-  case X86Local::MRM_DD: case X86Local::MRM_DE: case X86Local::MRM_DF:
-  case X86Local::MRM_E0: case X86Local::MRM_E1: case X86Local::MRM_E2:
-  case X86Local::MRM_E3: case X86Local::MRM_E4: case X86Local::MRM_E5:
-  case X86Local::MRM_E8: case X86Local::MRM_E9: case X86Local::MRM_EA:
-  case X86Local::MRM_EB: case X86Local::MRM_EC: case X86Local::MRM_ED:
-  case X86Local::MRM_EE: case X86Local::MRM_EF: case X86Local::MRM_F0:
-  case X86Local::MRM_F1: case X86Local::MRM_F2: case X86Local::MRM_F3:
-  case X86Local::MRM_F4: case X86Local::MRM_F5: case X86Local::MRM_F6:
-  case X86Local::MRM_F7: case X86Local::MRM_F9: case X86Local::MRM_FA:
-  case X86Local::MRM_FB: case X86Local::MRM_FC: case X86Local::MRM_FD:
-  case X86Local::MRM_FE: case X86Local::MRM_FF:
+  case X86Local::MRM_C3: case X86Local::MRM_C4: case X86Local::MRM_C5:
+  case X86Local::MRM_C8: case X86Local::MRM_C9: case X86Local::MRM_CA:
+  case X86Local::MRM_CB: case X86Local::MRM_CF: case X86Local::MRM_D0:
+  case X86Local::MRM_D1: case X86Local::MRM_D4: case X86Local::MRM_D5:
+  case X86Local::MRM_D6: case X86Local::MRM_D7: case X86Local::MRM_D8:
+  case X86Local::MRM_D9: case X86Local::MRM_DA: case X86Local::MRM_DB:
+  case X86Local::MRM_DC: case X86Local::MRM_DD: case X86Local::MRM_DE:
+  case X86Local::MRM_DF: case X86Local::MRM_E0: case X86Local::MRM_E1:
+  case X86Local::MRM_E2: case X86Local::MRM_E3: case X86Local::MRM_E4:
+  case X86Local::MRM_E5: case X86Local::MRM_E8: case X86Local::MRM_E9:
+  case X86Local::MRM_EA: case X86Local::MRM_EB: case X86Local::MRM_EC:
+  case X86Local::MRM_ED: case X86Local::MRM_EE: case X86Local::MRM_EF:
+  case X86Local::MRM_F0: case X86Local::MRM_F1: case X86Local::MRM_F2:
+  case X86Local::MRM_F3: case X86Local::MRM_F4: case X86Local::MRM_F5:
+  case X86Local::MRM_F6: case X86Local::MRM_F7: case X86Local::MRM_F9:
+  case X86Local::MRM_FA: case X86Local::MRM_FB: case X86Local::MRM_FC:
+  case X86Local::MRM_FD: case X86Local::MRM_FE: case X86Local::MRM_FF:
     // Ignored.
     break;
   }
 
   #undef HANDLE_OPERAND
   #undef HANDLE_OPTIONAL
 }