diff --git a/utils/TableGen/DAGISelEmitter.cpp b/utils/TableGen/DAGISelEmitter.cpp
index 5e2b07d..2ea8bf0 100644
--- a/utils/TableGen/DAGISelEmitter.cpp
+++ b/utils/TableGen/DAGISelEmitter.cpp
@@ -1966,7 +1966,7 @@
   Matcher *TheMatcher = new ScopeMatcher(&PatternMatchers[0],
                                          PatternMatchers.size());
 
-  TheMatcher = OptimizeMatcher(TheMatcher);
+  TheMatcher = OptimizeMatcher(TheMatcher, CGP);
   //Matcher->dump();
   EmitMatcherTable(TheMatcher, OS);
   delete TheMatcher;
diff --git a/utils/TableGen/DAGISelMatcher.cpp b/utils/TableGen/DAGISelMatcher.cpp
index d939edb..085682f 100644
--- a/utils/TableGen/DAGISelMatcher.cpp
+++ b/utils/TableGen/DAGISelMatcher.cpp
@@ -39,8 +39,12 @@
 
 void ScopeMatcher::printImpl(raw_ostream &OS, unsigned indent) const {
   OS.indent(indent) << "Scope\n";
-  for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
-    getChild(i)->print(OS, indent+2);
+  for (unsigned i = 0, e = getNumChildren(); i != e; ++i) {
+    if (getChild(i) == 0)
+      OS.indent(indent+1) << "NULL POINTER\n";
+    else
+      getChild(i)->print(OS, indent+2);
+  }
 }
 
 void RecordMatcher::printImpl(raw_ostream &OS, unsigned indent) const {
diff --git a/utils/TableGen/DAGISelMatcher.h b/utils/TableGen/DAGISelMatcher.h
index b91b591..0d674c5 100644
--- a/utils/TableGen/DAGISelMatcher.h
+++ b/utils/TableGen/DAGISelMatcher.h
@@ -27,7 +27,7 @@
 
 Matcher *ConvertPatternToMatcher(const PatternToMatch &Pattern,
                                  const CodeGenDAGPatterns &CGP);
-Matcher *OptimizeMatcher(Matcher *Matcher);
+Matcher *OptimizeMatcher(Matcher *Matcher, const CodeGenDAGPatterns &CGP);
 void EmitMatcherTable(const Matcher *Matcher, raw_ostream &OS);
 
   
@@ -900,12 +900,25 @@
     assert(i < VTs.size());
     return VTs[i];
   }
+
+  /// getNumNonChainFlagVTs - Return the number of normal results that this node
+  /// will have, ignoring flag and chain results.
+  unsigned getNumNonChainFlagVTs() const {
+    for (unsigned i = 0, e = getNumVTs(); i != e; ++i)
+      if (VTs[i] == MVT::Flag || VTs[i] == MVT::Other)
+        return i;
+    return getNumVTs();
+  }
   
   unsigned getNumOperands() const { return Operands.size(); }
   unsigned getOperand(unsigned i) const {
     assert(i < Operands.size());
     return Operands[i];
-  }  
+  }
+  
+  const SmallVectorImpl<MVT::SimpleValueType> &getVTList() const { return VTs; }
+  const SmallVectorImpl<unsigned> &getOperandList() const { return Operands; }
+
   
   bool hasChain() const { return HasChain; }
   bool hasFlag() const { return HasFlag; }
@@ -999,7 +1012,7 @@
   const PatternToMatch &Pattern;
 public:
   CompleteMatchMatcher(const unsigned *results, unsigned numresults,
-                           const PatternToMatch &pattern)
+                       const PatternToMatch &pattern)
   : Matcher(CompleteMatch), Results(results, results+numresults),
     Pattern(pattern) {}
 
diff --git a/utils/TableGen/DAGISelMatcherEmitter.cpp b/utils/TableGen/DAGISelMatcherEmitter.cpp
index 942a612..aec1e18 100644
--- a/utils/TableGen/DAGISelMatcherEmitter.cpp
+++ b/utils/TableGen/DAGISelMatcherEmitter.cpp
@@ -416,18 +416,23 @@
     
     // Print the result #'s for EmitNode.
     if (const EmitNodeMatcher *E = dyn_cast<EmitNodeMatcher>(EN)) {
-      if (EN->getVT(0) != MVT::Flag && EN->getVT(0) != MVT::Other) {
+      if (unsigned NumResults = EN->getNumNonChainFlagVTs()) {
         OS.PadToColumn(CommentIndent) << "// Results = ";
         unsigned First = E->getFirstResultSlot();
-        for (unsigned i = 0, e = EN->getNumVTs(); i != e; ++i) {
-          if (EN->getVT(0) == MVT::Flag || EN->getVT(0) == MVT::Other)
-            break;
+        for (unsigned i = 0; i != NumResults; ++i)
           OS << "#" << First+i << " ";
-        }
       }
     }
-    
     OS << '\n';
+    
+    if (const SelectNodeToMatcher *SNT = dyn_cast<SelectNodeToMatcher>(N)) {
+      OS.PadToColumn(Indent*2) << "// Src: "
+      << *SNT->getPattern().getSrcPattern() << '\n';
+      OS.PadToColumn(Indent*2) << "// Dst: " 
+      << *SNT->getPattern().getDstPattern() << '\n';
+      
+    }
+    
     return 6+EN->getNumVTs()+NumOperandBytes;
   }
   case Matcher::MarkFlagResults: {
diff --git a/utils/TableGen/DAGISelMatcherGen.cpp b/utils/TableGen/DAGISelMatcherGen.cpp
index 18735de..c558eba 100644
--- a/utils/TableGen/DAGISelMatcherGen.cpp
+++ b/utils/TableGen/DAGISelMatcherGen.cpp
@@ -741,10 +741,6 @@
   bool NodeHasMemRefs =
     isRoot && Pattern.getSrcPattern()->TreeHasProperty(SDNPMemOperand, CGP);
 
-  // FIXME: Eventually add a SelectNodeTo form.  It works if the new node has a
-  // superset of the results of the old node, in the same places.  E.g. turning
-  // (add (load)) -> add32rm is ok because result #0 is the result and result #1
-  // is new.
   AddMatcher(new EmitNodeMatcher(II.Namespace+"::"+II.TheDef->getName(),
                                  ResultVTs.data(), ResultVTs.size(),
                                  InstOps.data(), InstOps.size(),
@@ -757,9 +753,6 @@
     if (ResultVTs[i] == MVT::Other || ResultVTs[i] == MVT::Flag) break;
     OutputOps.push_back(NextRecordedOperandNo++);
   }
-  
-  // FIXME2: Kill off all the SelectionDAG::SelectNodeTo and getMachineNode
-  // variants.  Call MorphNodeTo instead of SelectNodeTo.
 }
 
 void MatcherGen::
@@ -851,7 +844,7 @@
 
 
 Matcher *llvm::ConvertPatternToMatcher(const PatternToMatch &Pattern,
-                                           const CodeGenDAGPatterns &CGP) {
+                                       const CodeGenDAGPatterns &CGP) {
   MatcherGen Gen(Pattern, CGP);
 
   // Generate the code for the matcher.
diff --git a/utils/TableGen/DAGISelMatcherOpt.cpp b/utils/TableGen/DAGISelMatcherOpt.cpp
index 12c4c1b..2ea178f 100644
--- a/utils/TableGen/DAGISelMatcherOpt.cpp
+++ b/utils/TableGen/DAGISelMatcherOpt.cpp
@@ -13,6 +13,7 @@
 
 #define DEBUG_TYPE "isel-opt"
 #include "DAGISelMatcher.h"
+#include "CodeGenDAGPatterns.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
@@ -21,7 +22,8 @@
 
 /// ContractNodes - Turn multiple matcher node patterns like 'MoveChild+Record'
 /// into single compound nodes like RecordChild.
-static void ContractNodes(OwningPtr<Matcher> &MatcherPtr) {
+static void ContractNodes(OwningPtr<Matcher> &MatcherPtr,
+                          const CodeGenDAGPatterns &CGP) {
   // If we reached the end of the chain, we're done.
   Matcher *N = MatcherPtr.get();
   if (N == 0) return;
@@ -30,7 +32,7 @@
   if (ScopeMatcher *Scope = dyn_cast<ScopeMatcher>(N)) {
     for (unsigned i = 0, e = Scope->getNumChildren(); i != e; ++i) {
       OwningPtr<Matcher> Child(Scope->takeChild(i));
-      ContractNodes(Child);
+      ContractNodes(Child, CGP);
       Scope->resetChild(i, Child.take());
     }
     return;
@@ -52,7 +54,7 @@
       MatcherPtr.reset(New);
       // Remove the old one.
       MC->setNext(MC->getNext()->takeNext());
-      return ContractNodes(MatcherPtr);
+      return ContractNodes(MatcherPtr, CGP);
     }
   }
   
@@ -61,17 +63,69 @@
     if (MoveParentMatcher *MP = 
           dyn_cast<MoveParentMatcher>(MC->getNext())) {
       MatcherPtr.reset(MP->takeNext());
-      return ContractNodes(MatcherPtr);
+      return ContractNodes(MatcherPtr, CGP);
     }
   
   // Turn EmitNode->CompleteMatch into SelectNodeTo if we can.
   if (EmitNodeMatcher *EN = dyn_cast<EmitNodeMatcher>(N))
     if (CompleteMatchMatcher *CM =
           dyn_cast<CompleteMatchMatcher>(EN->getNext())) {
-      (void)CM;
+      // We can only use SelectNodeTo if the result values match up.
+      unsigned RootResultFirst = EN->getFirstResultSlot();
+      bool ResultsMatch = true;
+      for (unsigned i = 0, e = CM->getNumResults(); i != e; ++i)
+        if (CM->getResult(i) != RootResultFirst+i)
+          ResultsMatch = false;
+      
+      // If the selected node defines a subset of the flag/chain results, we
+      // can't use SelectNodeTo.  For example, we can't use SelectNodeTo if the
+      // matched pattern has a chain but the root node doesn't.
+      const PatternToMatch &Pattern = CM->getPattern();
+      
+      if (!EN->hasChain() &&
+          Pattern.getSrcPattern()->NodeHasProperty(SDNPHasChain, CGP))
+        ResultsMatch = false;
+
+      // If the matched node has a flag and the output root doesn't, we can't
+      // use SelectNodeTo.
+      //
+      // NOTE: Strictly speaking, we don't have to check for the flag here
+      // because the code in the pattern generator doesn't handle it right.  We
+      // do it anyway for thoroughness.
+      if (!EN->hasFlag() &&
+          Pattern.getSrcPattern()->NodeHasProperty(SDNPOutFlag, CGP))
+        ResultsMatch = false;
+      
+      
+      // If the root result node defines more results than the source root node
+      // *and* has a chain or flag input, then we can't match it because it
+      // would end up replacing the extra result with the chain/flag.
+#if 0
+      if ((EN->hasFlag() || EN->hasChain()) &&
+          EN->getNumNonChainFlagVTs() > ... need to get no results reliably ...)
+        ResultMatch = false;
+#endif
+          
+      if (ResultsMatch) {
+        const SmallVectorImpl<MVT::SimpleValueType> &VTs = EN->getVTList();
+        const SmallVectorImpl<unsigned> &Operands = EN->getOperandList();
+        MatcherPtr.reset(new SelectNodeToMatcher(EN->getOpcodeName(),
+                                                 &VTs[0], VTs.size(),
+                                               Operands.data(), Operands.size(),
+                                                 EN->hasChain(), EN->hasFlag(),
+                                                 EN->hasMemRefs(),
+                                                 EN->getNumFixedArityOperands(),
+                                                 Pattern));
+        return;
+      }
+
+      // FIXME: Handle OPC_MarkFlagResults.
+      
+      // FIXME2: Kill off all the SelectionDAG::SelectNodeTo and getMachineNode
+      // variants.  Call MorphNodeTo instead of SelectNodeTo.
     }
   
-  ContractNodes(N->getNextPtr());
+  ContractNodes(N->getNextPtr(), CGP);
 }
 
 /// SinkPatternPredicates - Pattern predicates can be checked at any level of
@@ -253,6 +307,8 @@
 
   // Reassemble a new Scope node.
   assert(!NewOptionsToMatch.empty() && "where'd all our children go?");
+  if (NewOptionsToMatch.empty())
+    MatcherPtr.reset(0);
   if (NewOptionsToMatch.size() == 1)
     MatcherPtr.reset(NewOptionsToMatch[0]);
   else {
@@ -262,9 +318,10 @@
   }
 }
 
-Matcher *llvm::OptimizeMatcher(Matcher *TheMatcher) {
+Matcher *llvm::OptimizeMatcher(Matcher *TheMatcher,
+                               const CodeGenDAGPatterns &CGP) {
   OwningPtr<Matcher> MatcherPtr(TheMatcher);
-  ContractNodes(MatcherPtr);
+  ContractNodes(MatcherPtr, CGP);
   SinkPatternPredicates(MatcherPtr);
   FactorNodes(MatcherPtr);
   return MatcherPtr.take();