[llvm-commits] CVS: llvm/utils/TableGen/DAGISelEmitter.cpp DAGISelEmitter.h

[Chris Lattner]

Changes in directory llvm/utils/TableGen:

DAGISelEmitter.cpp updated: 1.34 -> 1.35
DAGISelEmitter.h updated: 1.21 -> 1.22
---
Log message:

emit information about the order patterns are to be matched.


---
Diffs of the changes:  (+60 -1)

 DAGISelEmitter.cpp |   56 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 DAGISelEmitter.h   |    5 +++-
 2 files changed, 60 insertions(+), 1 deletion(-)


Index: llvm/utils/TableGen/DAGISelEmitter.cpp
diff -u llvm/utils/TableGen/DAGISelEmitter.cpp:1.34 llvm/utils/TableGen/DAGISelEmitter.cpp:1.35
--- llvm/utils/TableGen/DAGISelEmitter.cpp:1.34	Fri Sep 23 14:36:15 2005
+++ llvm/utils/TableGen/DAGISelEmitter.cpp	Fri Sep 23 15:52:47 2005
@@ -985,6 +985,51 @@
         });
 }
 
+void DAGISelEmitter::EmitCodeForPattern(PatternToMatch &Pattern,
+                                        std::ostream &OS) {
+  OS << "    // ";
+  Pattern.first->print(OS);
+  OS << "\n";
+  
+  
+  
+}
+
+/// getPatternSize - Return the 'size' of this pattern.  We want to match large
+/// patterns before small ones.  This is used to determine the size of a
+/// pattern.
+static unsigned getPatternSize(TreePatternNode *P) {
+  assert(MVT::isInteger(P->getType()) || MVT::isFloatingPoint(P->getType()) &&
+         "Not a valid pattern node to size!");
+  unsigned Size = 1;  // The node itself.
+  
+  // Count children in the count if they are also nodes.
+  for (unsigned i = 0, e = P->getNumChildren(); i != e; ++i) {
+    TreePatternNode *Child = P->getChild(i);
+    if (!Child->isLeaf() && Child->getType() != MVT::Other)
+      Size += getPatternSize(Child);
+  }
+  
+  return Size;
+}
+
+// PatternSortingPredicate - return true if we prefer to match LHS before RHS.
+// In particular, we want to match maximal patterns first and lowest cost within
+// a particular complexity first.
+struct PatternSortingPredicate {
+  bool operator()(DAGISelEmitter::PatternToMatch *LHS,
+                  DAGISelEmitter::PatternToMatch *RHS) {
+    unsigned LHSSize = getPatternSize(LHS->first);
+    unsigned RHSSize = getPatternSize(RHS->first);
+    if (LHSSize > RHSSize) return true;   // LHS -> bigger -> less cost
+    if (LHSSize < RHSSize) return false;
+    
+    // If they are equal, compare cost.
+    // FIXME: Compute cost!
+    return false;
+  }
+};
+
 void DAGISelEmitter::EmitInstructionSelector(std::ostream &OS) {
   // Emit boilerplate.
   OS << "// The main instruction selector code.\n"
@@ -1007,6 +1052,7 @@
     PatternsByOpcode[PatternsToMatch[i].first->getOperator()]
       .push_back(&PatternsToMatch[i]);
   
+  // Loop over all of the case statements.
   for (std::map<Record*, std::vector<PatternToMatch*> >::iterator
        PBOI = PatternsByOpcode.begin(), E = PatternsByOpcode.end(); PBOI != E;
        ++PBOI) {
@@ -1014,7 +1060,14 @@
     std::vector<PatternToMatch*> &Patterns = PBOI->second;
     
     OS << "  case " << OpcodeInfo.getEnumName() << ":\n";
+
+    // We want to emit all of the matching code now.  However, we want to emit
+    // the matches in order of minimal cost.  Sort the patterns so the least
+    // cost one is at the start.
+    std::sort(Patterns.begin(), Patterns.end(), PatternSortingPredicate());
     
+    for (unsigned i = 0, e = Patterns.size(); i != e; ++i)
+      EmitCodeForPattern(*Patterns[i], OS);
     OS << "    break;\n";
   }
   
@@ -1040,6 +1093,9 @@
   ParsePatternFragments(OS);
   ParseInstructions();
   ParsePatterns();
+  
+  // FIXME: Generate variants.  For example, commutative patterns can match
+  // multiple ways.  Add them to PatternsToMatch as well.
 
   // At this point, we have full information about the 'Patterns' we need to
   // parse, both implicitly from instructions as well as from explicit pattern


Index: llvm/utils/TableGen/DAGISelEmitter.h
diff -u llvm/utils/TableGen/DAGISelEmitter.h:1.21 llvm/utils/TableGen/DAGISelEmitter.h:1.22
--- llvm/utils/TableGen/DAGISelEmitter.h:1.21	Fri Sep 23 14:36:15 2005
+++ llvm/utils/TableGen/DAGISelEmitter.h	Fri Sep 23 15:52:47 2005
@@ -314,6 +314,9 @@
 /// and emission of the instruction selector.
 ///
 class DAGISelEmitter : public TableGenBackend {
+public:
+  typedef std::pair<TreePatternNode*, TreePatternNode*> PatternToMatch;
+private:
   RecordKeeper &Records;
   CodeGenTarget Target;
 
@@ -325,7 +328,6 @@
   /// PatternsToMatch - All of the things we are matching on the DAG.  The first
   /// value is the pattern to match, the second pattern is the result to
   /// emit.
-  typedef std::pair<TreePatternNode*, TreePatternNode*> PatternToMatch;
   std::vector<PatternToMatch> PatternsToMatch;
 public:
   DAGISelEmitter(RecordKeeper &R) : Records(R) {}
@@ -363,6 +365,7 @@
                                    std::map<std::string,
                                             TreePatternNode*> &InstInputs,
                                    std::map<std::string, Record*> &InstResults);
+  void EmitCodeForPattern(PatternToMatch &Pattern, std::ostream &OS);
   void EmitInstructionSelector(std::ostream &OS);
 };