[TableGen] Use std::set_intersection to merge TypeSets. NFC

[oota-llvm.git] / utils / TableGen / DFAPacketizerEmitter.cpp

diff --git a/utils/TableGen/DFAPacketizerEmitter.cpp b/utils/TableGen/DFAPacketizerEmitter.cpp
index 4e6961eb87702415edb1e82bcd40f8414f509548..77afff7ab5c230cbe80e893ae092711cbd5865ae 100644 (file)
--- a/utils/TableGen/DFAPacketizerEmitter.cpp
+++ b/utils/TableGen/DFAPacketizerEmitter.cpp
@@ -21,7 +21,6 @@
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
-#include "llvm/CodeGen/DFAPacketizerDefs.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 #include "llvm/Support/Debug.h"
@@ -31,6 +30,53 @@
 #include <queue>
 using namespace llvm;
 
+// --------------------------------------------------------------------
+// Definitions shared between DFAPacketizer.cpp and DFAPacketizerEmitter.cpp
+
+// DFA_MAX_RESTERMS * DFA_MAX_RESOURCES must fit within sizeof DFAInput.
+// This is verified in DFAPacketizer.cpp:DFAPacketizer::DFAPacketizer.
+//
+// e.g. terms x resource bit combinations that fit in uint32_t:
+//      4 terms x 8  bits = 32 bits
+//      3 terms x 10 bits = 30 bits
+//      2 terms x 16 bits = 32 bits
+//
+// e.g. terms x resource bit combinations that fit in uint64_t:
+//      8 terms x 8  bits = 64 bits
+//      7 terms x 9  bits = 63 bits
+//      6 terms x 10 bits = 60 bits
+//      5 terms x 12 bits = 60 bits
+//      4 terms x 16 bits = 64 bits <--- current
+//      3 terms x 21 bits = 63 bits
+//      2 terms x 32 bits = 64 bits
+//
+#define DFA_MAX_RESTERMS        4   // The max # of AND'ed resource terms.
+#define DFA_MAX_RESOURCES       16  // The max # of resource bits in one term.
+
+typedef uint64_t                DFAInput;
+typedef int64_t                 DFAStateInput;
+#define DFA_TBLTYPE             "int64_t" // For generating DFAStateInputTable.
+
+namespace {
+  DFAInput addDFAFuncUnits(DFAInput Inp, unsigned FuncUnits) {
+    return (Inp << DFA_MAX_RESOURCES) | FuncUnits;
+  }
+
+  /// Return the DFAInput for an instruction class input vector.
+  /// This function is used in both DFAPacketizer.cpp and in
+  /// DFAPacketizerEmitter.cpp.
+  DFAInput getDFAInsnInput(const std::vector<unsigned> &InsnClass) {
+    DFAInput InsnInput = 0;
+    assert ((InsnClass.size() <= DFA_MAX_RESTERMS) &&
+            "Exceeded maximum number of DFA terms");
+    for (auto U : InsnClass)
+      InsnInput = addDFAFuncUnits(InsnInput, U);
+    return InsnInput;
+  }
+}
+// --------------------------------------------------------------------
+
+#ifndef NDEBUG
 // To enable debugging, run llvm-tblgen with: "-debug-only dfa-emitter".
 //
 // dbgsInsnClass - When debugging, print instruction class stages.
@@ -44,6 +90,7 @@ void dbgsStateInfo(const std::set<unsigned> &stateInfo);
 // dbgsIndent - When debugging, indent by the specified amount.
 //
 void dbgsIndent(unsigned indent);
+#endif
 
 //
 // class DFAPacketizerEmitter: class that generates and prints out the DFA
@@ -326,11 +373,13 @@ void State::AddInsnClassStages(std::vector<unsigned> &InsnClass,
   assert((chkstage < numstages) && "AddInsnClassStages: stage out of range");
   unsigned thisStage = InsnClass[chkstage];
 
-  dbgsIndent((1 + numstages - chkstage) << 1);
-  DEBUG(dbgs() << "AddInsnClassStages " << chkstage
-               << " (0x" << utohexstr(thisStage) << ") from ");
-  dbgsInsnClass(InsnClass);
-  DEBUG(dbgs() << "\n");
+  DEBUG({
+    dbgsIndent((1 + numstages - chkstage) << 1);
+    dbgs() << "AddInsnClassStages " << chkstage << " (0x"
+           << utohexstr(thisStage) << ") from ";
+    dbgsInsnClass(InsnClass);
+    dbgs() << "\n";
+  });
 
   //
   // Iterate over all possible resources used in thisStage.
@@ -351,13 +400,14 @@ void State::AddInsnClassStages(std::vector<unsigned> &InsnClass,
       // resource state if that resource was used.
       //
       unsigned ResultingResourceState = prevState | resourceMask | combo;
-      dbgsIndent((2 + numstages - chkstage) << 1);
-      DEBUG(dbgs() << "0x" << utohexstr(prevState)
-                   << " | 0x" << utohexstr(resourceMask));
-      if (combo) {
-        DEBUG(dbgs() << " | 0x" << utohexstr(combo));
-      }
-      DEBUG(dbgs() << " = 0x" << utohexstr(ResultingResourceState) << " ");
+      DEBUG({
+        dbgsIndent((2 + numstages - chkstage) << 1);
+        dbgs() << "0x" << utohexstr(prevState)
+               << " | 0x" << utohexstr(resourceMask);
+        if (combo)
+          dbgs() << " | 0x" << utohexstr(combo);
+        dbgs() << " = 0x" << utohexstr(ResultingResourceState) << " ";
+      });
 
       //
       // If this is the final stage for this class
@@ -741,9 +791,11 @@ int DFAPacketizerEmitter::collectOneInsnClass(const std::string &ProcName,
   if (UnitBits.size() > 0)
     allInsnClasses.push_back(UnitBits);
 
-  DEBUG(dbgs() << "        ");
-  dbgsInsnClass(UnitBits);
-  DEBUG(dbgs() << "\n");
+  DEBUG({
+    dbgs() << "        ";
+    dbgsInsnClass(UnitBits);
+    dbgs() << "\n";
+  });
 
   return NStages;
 }
@@ -867,15 +919,19 @@ void DFAPacketizerEmitter::run(raw_ostream &OS) {
   //
   while (!WorkList.empty()) {
     const State *current = WorkList.pop_back_val();
-    DEBUG(dbgs() << "---------------------\n");
-    DEBUG(dbgs() << "Processing state: " << current->stateNum << " - ");
-    dbgsStateInfo(current->stateInfo);
-    DEBUG(dbgs() << "\n");
+    DEBUG({
+      dbgs() << "---------------------\n";
+      dbgs() << "Processing state: " << current->stateNum << " - ";
+      dbgsStateInfo(current->stateInfo);
+      dbgs() << "\n";
+    });
     for (unsigned i = 0; i < allInsnClasses.size(); i++) {
       std::vector<unsigned> InsnClass = allInsnClasses[i];
-      DEBUG(dbgs() << i << " ");
-      dbgsInsnClass(InsnClass);
-      DEBUG(dbgs() << "\n");
+      DEBUG({
+        dbgs() << i << " ";
+        dbgsInsnClass(InsnClass);
+        dbgs() << "\n";
+      });
 
       std::set<unsigned> NewStateResources;
       //
@@ -891,9 +947,11 @@ void DFAPacketizerEmitter::run(raw_ostream &OS) {
           continue;
         }
 
-        DEBUG(dbgs() << "\t");
-        dbgsStateInfo(NewStateResources);
-        DEBUG(dbgs() << "\n");
+        DEBUG({
+          dbgs() << "\t";
+          dbgsStateInfo(NewStateResources);
+          dbgs() << "\n";
+        });
 
         //
         // If we have seen this state before, then do not create a new state.
@@ -901,19 +959,22 @@ void DFAPacketizerEmitter::run(raw_ostream &OS) {
         auto VI = Visited.find(NewStateResources);
         if (VI != Visited.end()) {
           NewState = VI->second;
-          DEBUG(dbgs() << "\tFound existing state: "
-                       << NewState->stateNum << " - ");
-          dbgsStateInfo(NewState->stateInfo);
-          DEBUG(dbgs() << "\n");
+          DEBUG({
+            dbgs() << "\tFound existing state: " << NewState->stateNum
+                   << " - ";
+            dbgsStateInfo(NewState->stateInfo);
+            dbgs() << "\n";
+          });
         } else {
           NewState = &D.newState();
           NewState->stateInfo = NewStateResources;
           Visited[NewStateResources] = NewState;
           WorkList.push_back(NewState);
-          DEBUG(dbgs() << "\tAccepted new state: "
-                       << NewState->stateNum << " - ");
-          dbgsStateInfo(NewState->stateInfo);
-          DEBUG(dbgs() << "\n");
+          DEBUG({
+            dbgs() << "\tAccepted new state: " << NewState->stateNum << " - ";
+            dbgsStateInfo(NewState->stateInfo);
+            dbgs() << "\n";
+          });
         }
 
         current->addTransition(InsnClass, NewState);