Teach TableGen to understand X.Y notation in the TSFlagsFields strings.

Remove much horribleness from X86InstrFormats as a result. Similar
simplifications are probably possible for other targets.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@99539 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Target/X86/X86.td b/lib/Target/X86/X86.td
index 5788e2a71f647e626682bf37baa682d87cad87b6..b0847a854361dc6614145949657fa4e5a8c34026 100644 (file)
--- a/lib/Target/X86/X86.td
+++ b/lib/Target/X86/X86.td
@@ -160,11 +160,11 @@ def X86InstrInfo : InstrInfo {
                        "hasAdSizePrefix",
                        "Prefix",
                        "hasREX_WPrefix",
-                       "ImmTypeBits",
-                       "FPFormBits",
+                       "ImmT.Value",
+                       "FPForm.Value",
                        "hasLockPrefix",
                        "SegOvrBits",
-                       "DomainBits",
+                       "ExeDomain.Value",
                        "Opcode"];
   let TSFlagsShifts = [0,
                        6,

diff --git a/lib/Target/X86/X86InstrFormats.td b/lib/Target/X86/X86InstrFormats.td
index a811638c39ef2f5d8f4a1844d6cec82302705655..31dc5956e86c3fd80801a67639eeb98e45d502a8 100644 (file)
--- a/lib/Target/X86/X86InstrFormats.td
+++ b/lib/Target/X86/X86InstrFormats.td
@@ -111,7 +111,6 @@ class X86Inst<bits<8> opcod, Format f, ImmType i, dag outs, dag ins,
   Format Form = f;
   bits<6> FormBits = Form.Value;
   ImmType ImmT = i;
-  bits<3> ImmTypeBits = ImmT.Value;
 
   dag OutOperandList = outs;
   dag InOperandList = ins;
@@ -125,12 +124,10 @@ class X86Inst<bits<8> opcod, Format f, ImmType i, dag outs, dag ins,
 
   bits<4> Prefix = 0;       // Which prefix byte does this inst have?
   bit hasREX_WPrefix  = 0;  // Does this inst requires the REX.W prefix?
-  FPFormat FPForm;          // What flavor of FP instruction is this?
-  bits<3> FPFormBits = 0;
+  FPFormat FPForm = NotFP;  // What flavor of FP instruction is this?
   bit hasLockPrefix = 0;    // Does this inst have a 0xF0 prefix?
   bits<2> SegOvrBits = 0;   // Segment override prefix.
-  Domain Dom = d;
-  bits<2> DomainBits = Dom.Value;
+  Domain ExeDomain = d;
 }
 
 class I<bits<8> o, Format f, dag outs, dag ins, string asm,
@@ -179,7 +176,7 @@ class FPI<bits<8> o, Format F, dag outs, dag ins, string asm>
 // FpI_ - Floating Point Psuedo Instruction template. Not Predicated.
 class FpI_<dag outs, dag ins, FPFormat fp, list<dag> pattern>
   : X86Inst<0, Pseudo, NoImm, outs, ins, ""> {
-  let FPForm = fp; let FPFormBits = FPForm.Value;
+  let FPForm = fp;
   let Pattern = pattern;
 }
 

diff --git a/lib/Target/X86/X86InstrInfo.td b/lib/Target/X86/X86InstrInfo.td
index 67d935a669cda46e15bc4b376ddb0e8b4f8e0cff..a029a24f8b636cf08020df7b1cfe8668f7667806 100644 (file)
--- a/lib/Target/X86/X86InstrInfo.td
+++ b/lib/Target/X86/X86InstrInfo.td
@@ -587,7 +587,7 @@ let neverHasSideEffects = 1, isNotDuplicable = 1, Uses = [ESP] in
 
 // Return instructions.
 let isTerminator = 1, isReturn = 1, isBarrier = 1,
-    hasCtrlDep = 1, FPForm = SpecialFP, FPFormBits = SpecialFP.Value in {
+    hasCtrlDep = 1, FPForm = SpecialFP in {
   def RET    : I   <0xC3, RawFrm, (outs), (ins variable_ops),
                     "ret",
                     [(X86retflag 0)]>;

diff --git a/utils/TableGen/InstrInfoEmitter.cpp b/utils/TableGen/InstrInfoEmitter.cpp
index 8f7550b84810cf52fa48d24ee42fcb58071dd13a..9bc545928d9b57e3aa4d3979941d8a8a61de1925 100644 (file)
--- a/utils/TableGen/InstrInfoEmitter.cpp
+++ b/utils/TableGen/InstrInfoEmitter.cpp
@@ -337,7 +337,7 @@ void InstrInfoEmitter::emitShiftedValue(Record *R, StringInit *Val,
                                         IntInit *ShiftInt, raw_ostream &OS) {
   if (Val == 0 || ShiftInt == 0)
     throw std::string("Illegal value or shift amount in TargetInfo*!");
-  RecordVal *RV = R->getValue(Val->getValue());
+  RecordVal *RV = R->getDottedValue(Val->getValue());
   int Shift = ShiftInt->getValue();
 
   if (RV == 0 || RV->getValue() == 0) {

diff --git a/utils/TableGen/Record.cpp b/utils/TableGen/Record.cpp
index 0e3593b6a11ff2cc1eb8e864176bc75a625bab7b..55c998926c0ae0400f5556dd6b1d7e0c50fac96f 100644 (file)
--- a/utils/TableGen/Record.cpp
+++ b/utils/TableGen/Record.cpp
@@ -1307,6 +1307,16 @@ void Record::resolveReferencesTo(const RecordVal *RV) {
   }
 }
 
+RecordVal *Record::getDottedValue(StringRef Name) {
+  size_t pos = Name.find('.');
+  if (pos == StringRef::npos)
+    return getValue(Name);
+  RecordVal *RV = getValue(Name.substr(0, pos));
+  if (!RV) return 0;
+  DefInit *DI = dynamic_cast<DefInit*>(RV->getValue());
+  if (!DI) return 0;
+  return DI->getDef()->getDottedValue(Name.substr(pos+1));
+}
 
 void Record::dump() const { errs() << *this; }
 

diff --git a/utils/TableGen/Record.h b/utils/TableGen/Record.h
index 55c1a80f9b6a048d3297f6044d3235b9191e0f7c..41373c799a0dc67b0caf0ef92e5fba5aba80c738 100644 (file)
--- a/utils/TableGen/Record.h
+++ b/utils/TableGen/Record.h
@@ -1262,6 +1262,9 @@ public:
     return 0;
   }
 
+  // Like getValue, but allow dotting into members: X.Y
+  RecordVal *getDottedValue(StringRef Name);
+
   void addTemplateArg(StringRef Name) {
     assert(!isTemplateArg(Name) && "Template arg already defined!");
     TemplateArgs.push_back(Name);