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

[Chris Lattner]

Changes in directory llvm/utils/TableGen:

InstrSelectorEmitter.cpp updated: 1.19 -> 1.20
Record.h updated: 1.35 -> 1.36

---
Log message:

Implement autopromotion of leaf trees from arguments to nodes of their own,
making it easier to write patterns without lots of extraneous parens


---
Diffs of the changes:

Index: llvm/utils/TableGen/InstrSelectorEmitter.cpp
diff -u llvm/utils/TableGen/InstrSelectorEmitter.cpp:1.19 llvm/utils/TableGen/InstrSelectorEmitter.cpp:1.20
--- llvm/utils/TableGen/InstrSelectorEmitter.cpp:1.19	Sun Aug 10 17:14:13 2003
+++ llvm/utils/TableGen/InstrSelectorEmitter.cpp	Sun Aug 10 17:38:36 2003
@@ -167,19 +167,20 @@
     return MVT::Other;
   }
 
-  throw "Error: Unknown value used: " + R->getName();
+  error("Unknown value used: " + R->getName());
+  return MVT::Other;
 }
 
-TreePatternNode *Pattern::ParseTreePattern(DagInit *DI) {
-  Record *Operator = DI->getNodeType();
+TreePatternNode *Pattern::ParseTreePattern(DagInit *Dag) {
+  Record *Operator = Dag->getNodeType();
 
   if (Operator->isSubClassOf("ValueType")) {
     // If the operator is a ValueType, then this must be "type cast" of a leaf
     // node.
-    if (DI->getNumArgs() != 1)
+    if (Dag->getNumArgs() != 1)
       error("Type cast only valid for a leaf node!");
     
-    Init *Arg = DI->getArg(0);
+    Init *Arg = Dag->getArg(0);
     TreePatternNode *New;
     if (DefInit *DI = dynamic_cast<DefInit*>(Arg)) {
       New = new TreePatternNode(DI);
@@ -200,14 +201,22 @@
 
   std::vector<TreePatternNode*> Children;
   
-  for (unsigned i = 0, e = DI->getNumArgs(); i != e; ++i) {
-    Init *Arg = DI->getArg(i);
+  for (unsigned i = 0, e = Dag->getNumArgs(); i != e; ++i) {
+    Init *Arg = Dag->getArg(i);
     if (DagInit *DI = dynamic_cast<DagInit*>(Arg)) {
       Children.push_back(ParseTreePattern(DI));
-    } else if (DefInit *DI = dynamic_cast<DefInit*>(Arg)) {
-      Children.push_back(new TreePatternNode(DI));
-      // If it's a regclass or something else known, set the type.
-      Children.back()->setType(getIntrinsicType(DI->getDef()));
+    } else if (DefInit *DefI = dynamic_cast<DefInit*>(Arg)) {
+      Record *R = DefI->getDef();
+      // Direct reference to a leaf DagNode?  Turn it into a DagNode if its own.
+      if (R->isSubClassOf("DagNode")) {
+        Dag->setArg(i, new DagInit(R,
+                                std::vector<std::pair<Init*, std::string> >()));
+        --i;  // Revisit this node...
+      } else {
+        Children.push_back(new TreePatternNode(DefI));
+        // If it's a regclass or something else known, set the type.
+        Children.back()->setType(getIntrinsicType(R));
+      }
     } else {
       Arg->dump();
       error("Unknown leaf value for tree pattern!");
@@ -524,8 +533,15 @@
   // Loop over all of the patterns, adding them to the ComputableValues map
   for (std::map<Record*, Pattern*>::iterator I = Patterns.begin(),
          E = Patterns.end(); I != E; ++I)
-    if (I->second->isResolved())
-      ComputableValues.addPattern(I->second);
+    if (I->second->isResolved()) {
+      // We don't want to add patterns like R32 = R32.  This is a hack working
+      // around a special case of a general problem, but for now we explicitly
+      // forbid these patterns.  They can never match anyway.
+      Pattern *P = I->second;
+      if (!P->getResult() || !P->getTree()->isLeaf() ||
+          P->getResult() != P->getTree()->getValueRecord())
+        ComputableValues.addPattern(P);
+    }
 }
 
 #if 0


Index: llvm/utils/TableGen/Record.h
diff -u llvm/utils/TableGen/Record.h:1.35 llvm/utils/TableGen/Record.h:1.36
--- llvm/utils/TableGen/Record.h:1.35	Sun Aug 10 17:14:13 2003
+++ llvm/utils/TableGen/Record.h	Sun Aug 10 17:38:36 2003
@@ -619,6 +619,11 @@
     return ArgNames[Num];
   }
 
+  void setArg(unsigned Num, Init *I) {
+    assert(Num < Args.size() && "Arg number out of range!");
+    Args[Num] = I;
+  }
+
   virtual void print(std::ostream &OS) const;
 };