fix rdar://7653908, a crash on a case where we would fold a load

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

diff --git a/utils/TableGen/DAGISelMatcherGen.cpp b/utils/TableGen/DAGISelMatcherGen.cpp
index 3ed076c7c7ec4019b3690c5941dda755df67dc75..d32d3a7b132d957322b98fa19d25c9091e66f611 100644 (file)
--- a/utils/TableGen/DAGISelMatcherGen.cpp
+++ b/utils/TableGen/DAGISelMatcherGen.cpp
@@ -186,38 +186,32 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
   // If this node has a chain, then the chain is operand #0 is the SDNode, and
   // the child numbers of the node are all offset by one.
   unsigned OpNo = 0;
-  if (N->NodeHasProperty(SDNPHasChain, CGP))
+  if (N->NodeHasProperty(SDNPHasChain, CGP)) {
     OpNo = 1;
 
-  // If this node is not the root and the subtree underneath it produces a
-  // chain, then the result of matching the node is also produce a chain.
-  // Beyond that, this means that we're also folding (at least) the root node
-  // into the node that produce the chain (for example, matching
-  // "(add reg, (load ptr))" as a add_with_memory on X86).  This is problematic,
-  // if the 'reg' node also uses the load (say, its chain).  Graphically:
-  //
-  //         [LD]
-  //         ^  ^
-  //         |  \                              DAG's like cheese.
-  //        /    |
-  //       /    [YY]
-  //       |     ^
-  //      [XX]--/
-  //
-  // It would be invalid to fold XX and LD.  In this case, folding the two
-  // nodes together would induce a cycle in the DAG, making it a cyclic DAG (!).
-  // To prevent this, we emit a dynamic check for legality before allowing this
-  // to be folded.
-  //
-  const TreePatternNode *Root = Pattern.getSrcPattern();
-  if (N != Root &&                             // Not the root of the pattern.
-      N->TreeHasProperty(SDNPHasChain, CGP)) { // Has a chain somewhere in tree.
-    
-    AddMatcherNode(new CheckProfitableToFoldMatcherNode());
-    
-    // If this non-root node produces a chain, we may need to emit a validity
-    // check.
-    if (OpNo != 0) {
+    // If this node is not the root and the subtree underneath it produces a
+    // chain, then the result of matching the node is also produce a chain.
+    // Beyond that, this means that we're also folding (at least) the root node
+    // into the node that produce the chain (for example, matching
+    // "(add reg, (load ptr))" as a add_with_memory on X86).  This is
+    // problematic, if the 'reg' node also uses the load (say, its chain).
+    // Graphically:
+    //
+    //         [LD]
+    //         ^  ^
+    //         |  \                              DAG's like cheese.
+    //        /    |
+    //       /    [YY]
+    //       |     ^
+    //      [XX]--/
+    //
+    // It would be invalid to fold XX and LD.  In this case, folding the two
+    // nodes together would induce a cycle in the DAG, making it a 'cyclic DAG'
+    // To prevent this, we emit a dynamic check for legality before allowing
+    // this to be folded.
+    //
+    const TreePatternNode *Root = Pattern.getSrcPattern();
+    if (N != Root) {                             // Not the root of the pattern.
       // If there is a node between the root and this node, then we definitely
       // need to emit the check.
       bool NeedCheck = !Root->hasChild(N);
@@ -239,12 +233,10 @@ void MatcherGen::EmitOperatorMatchCode(const TreePatternNode *N,
       }
       
       if (NeedCheck)
-        AddMatcherNode(new CheckLegalToFoldMatcherNode());
+        AddMatcherNode(new CheckFoldableChainNodeMatcherNode());
     }
   }
       
-  // FIXME: Handle EmittedUseCheck & Flags & .hasOneUse()
-  
   for (unsigned i = 0, e = N->getNumChildren(); i != e; ++i, ++OpNo) {
     // Get the code suitable for matching this child.  Move to the child, check
     // it then move back to the parent.