diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index f4ea64d46db..3b6d1a15ab6 100644
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -311,34 +311,14 @@ public:
                        SDOperand Op1, SDOperand Op2);
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
                        SDOperand Op1, SDOperand Op2, SDOperand Op3);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
-                       SDOperand Op1, SDOperand Op2, SDOperand Op3, 
-                       SDOperand Op4);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
-                       SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                       SDOperand Op4, SDOperand Op5);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
-                       SDOperand Op1, SDOperand Op2, SDOperand Op3, 
-                       SDOperand Op4, SDOperand Op5, SDOperand Op6);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
-                       SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                       SDOperand Op4, SDOperand Op5, SDOperand Op6,
-                       SDOperand Op7);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT, 
-                       SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                       SDOperand Op4, SDOperand Op5, SDOperand Op6,
-                       SDOperand Op7, SDOperand Op8);
+  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT,
+                        const SDOperand *Ops, unsigned NumOps);
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1, 
                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2);
   SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1,
                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
                        SDOperand Op3);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1,
-                       MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
-                       SDOperand Op3, SDOperand Op4);
-  SDNode *SelectNodeTo(SDNode *N, unsigned TargetOpc, MVT::ValueType VT1,
-                       MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
-                       SDOperand Op3, SDOperand Op4, SDOperand Op5);
+
 
   /// getTargetNode - These are used for target selectors to create a new node
   /// with specified return type(s), target opcode, and operands.
@@ -353,23 +333,6 @@ public:
                         SDOperand Op1, SDOperand Op2);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
                         SDOperand Op1, SDOperand Op2, SDOperand Op3);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                        SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                        SDOperand Op4);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                        SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                        SDOperand Op4, SDOperand Op5);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                        SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                        SDOperand Op4, SDOperand Op5, SDOperand Op6);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                        SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                        SDOperand Op4, SDOperand Op5, SDOperand Op6,
-                        SDOperand Op7);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                        SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                        SDOperand Op4, SDOperand Op5, SDOperand Op6,
-                        SDOperand Op7, SDOperand Op8);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT,
                         const SDOperand *Ops, unsigned NumOps);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
@@ -379,39 +342,14 @@ public:
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
                         MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
                         SDOperand Op3);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4, SDOperand Op5);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4, SDOperand Op5,
-                        SDOperand Op6);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4, SDOperand Op5,
-                        SDOperand Op6, SDOperand Op7);
+  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
+                        MVT::ValueType VT2,
+                        const SDOperand *Ops, unsigned NumOps);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
                         MVT::ValueType VT2, MVT::ValueType VT3,
                         SDOperand Op1, SDOperand Op2);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, MVT::ValueType VT3,
-                        SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4, SDOperand Op5);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, MVT::ValueType VT3,
-                        SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4, SDOperand Op5,
-                        SDOperand Op6);
-  SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                        MVT::ValueType VT2, MVT::ValueType VT3,
-                        SDOperand Op1, SDOperand Op2,
-                        SDOperand Op3, SDOperand Op4, SDOperand Op5,
-                        SDOperand Op6, SDOperand Op7);
   SDNode *getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
-                        MVT::ValueType VT2,
+                        MVT::ValueType VT2, MVT::ValueType VT3,
                         const SDOperand *Ops, unsigned NumOps);
   
   /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.
diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index ad4ae4a3f86..f1cdb633e16 100644
--- a/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -945,80 +945,16 @@ protected:
     Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
     Op2.Val->Uses.push_back(this);
   }
-  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3) {
+  void setOperands(const SDOperand *Ops, unsigned NumOps) {
     assert(NumOperands == 0 && "Should not have operands yet!");
-    OperandList = new SDOperand[4];
-    OperandList[0] = Op0;
-    OperandList[1] = Op1;
-    OperandList[2] = Op2;
-    OperandList[3] = Op3;
-    NumOperands = 4;
-    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
-    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
-  }
-  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                   SDOperand Op4) {
-    assert(NumOperands == 0 && "Should not have operands yet!");
-    OperandList = new SDOperand[5];
-    OperandList[0] = Op0;
-    OperandList[1] = Op1;
-    OperandList[2] = Op2;
-    OperandList[3] = Op3;
-    OperandList[4] = Op4;
-    NumOperands = 5;
-    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
-    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
-    Op4.Val->Uses.push_back(this);
-  }
-  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                   SDOperand Op4, SDOperand Op5) {
-    assert(NumOperands == 0 && "Should not have operands yet!");
-    OperandList = new SDOperand[6];
-    OperandList[0] = Op0;
-    OperandList[1] = Op1;
-    OperandList[2] = Op2;
-    OperandList[3] = Op3;
-    OperandList[4] = Op4;
-    OperandList[5] = Op5;
-    NumOperands = 6;
-    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
-    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
-    Op4.Val->Uses.push_back(this); Op5.Val->Uses.push_back(this);
-  }
-  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                   SDOperand Op4, SDOperand Op5, SDOperand Op6) {
-    assert(NumOperands == 0 && "Should not have operands yet!");
-    OperandList = new SDOperand[7];
-    OperandList[0] = Op0;
-    OperandList[1] = Op1;
-    OperandList[2] = Op2;
-    OperandList[3] = Op3;
-    OperandList[4] = Op4;
-    OperandList[5] = Op5;
-    OperandList[6] = Op6;
-    NumOperands = 7;
-    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
-    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
-    Op4.Val->Uses.push_back(this); Op5.Val->Uses.push_back(this);
-    Op6.Val->Uses.push_back(this);
-  }
-  void setOperands(SDOperand Op0, SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                   SDOperand Op4, SDOperand Op5, SDOperand Op6, SDOperand Op7) {
-    assert(NumOperands == 0 && "Should not have operands yet!");
-    OperandList = new SDOperand[8];
-    OperandList[0] = Op0;
-    OperandList[1] = Op1;
-    OperandList[2] = Op2;
-    OperandList[3] = Op3;
-    OperandList[4] = Op4;
-    OperandList[5] = Op5;
-    OperandList[6] = Op6;
-    OperandList[7] = Op7;
-    NumOperands = 8;
-    Op0.Val->Uses.push_back(this); Op1.Val->Uses.push_back(this);
-    Op2.Val->Uses.push_back(this); Op3.Val->Uses.push_back(this);
-    Op4.Val->Uses.push_back(this); Op5.Val->Uses.push_back(this);
-    Op6.Val->Uses.push_back(this); Op7.Val->Uses.push_back(this);
+    NumOperands = NumOps;
+    OperandList = new SDOperand[NumOperands];
+
+    for (unsigned i = 0, e = NumOps; i != e; ++i) {
+      OperandList[i] = Ops[i];
+      SDNode *N = OperandList[i].Val;
+      N->Uses.push_back(this);
+    }
   }
 
   void addUser(SDNode *User) {
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index f4055b2de3e..cb9ad98550b 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -1908,40 +1908,13 @@ SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
 }
 
 SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT, SDOperand Op1,
-                                   SDOperand Op2, SDOperand Op3,
-                                   SDOperand Op4) {
+                                   MVT::ValueType VT, const SDOperand *Ops,
+                                   unsigned NumOps) {
   // If an identical node already exists, use it.
   SDVTList VTs = getVTList(VT);
   SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  void *IP = 0;
-  if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
-    return ON;
-  
-  RemoveNodeFromCSEMaps(N);
-  N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
-  N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4);
-
-  CSEMap.InsertNode(N, IP);   // Memoize the new node.
-  return N;
-}
-
-SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT, SDOperand Op1,
-                                   SDOperand Op2, SDOperand Op3,
-                                   SDOperand Op4, SDOperand Op5) {
-  SDVTList VTs = getVTList(VT);
-  SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  ID.AddOperand(Op5);
+  for (unsigned i = 0; i != NumOps; ++i)
+    ID.AddOperand(Ops[i]);
   void *IP = 0;
   if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
     return ON;
@@ -1949,88 +1922,7 @@ SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
   RemoveNodeFromCSEMaps(N);
   N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
   N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4, Op5);
-  
-  CSEMap.InsertNode(N, IP);   // Memoize the new node.
-  return N;
-}
-
-SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT, SDOperand Op1,
-                                   SDOperand Op2, SDOperand Op3, SDOperand Op4,
-                                   SDOperand Op5, SDOperand Op6) {
-  SDVTList VTs = getVTList(VT);
-  SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  ID.AddOperand(Op5);
-  ID.AddOperand(Op6);
-  void *IP = 0;
-  if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
-    return ON;
-                                       
-  RemoveNodeFromCSEMaps(N);
-  N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
-  N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4, Op5, Op6);
-  
-  CSEMap.InsertNode(N, IP);   // Memoize the new node.
-  return N;
-}
-
-SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT, SDOperand Op1,
-                                   SDOperand Op2, SDOperand Op3,SDOperand Op4,
-                                   SDOperand Op5, SDOperand Op6,
-                                   SDOperand Op7) {
-  SDVTList VTs = getVTList(VT);
-  // If an identical node already exists, use it.
-  SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  ID.AddOperand(Op5);
-  ID.AddOperand(Op6);
-  ID.AddOperand(Op7);
-  void *IP = 0;
-  if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
-    return ON;
-                                       
-  RemoveNodeFromCSEMaps(N);
-  N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
-  N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4, Op5, Op6, Op7);
-  
-  CSEMap.InsertNode(N, IP);   // Memoize the new node.
-  return N;
-}
-SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT, SDOperand Op1,
-                                   SDOperand Op2, SDOperand Op3,SDOperand Op4,
-                                   SDOperand Op5, SDOperand Op6,
-                                   SDOperand Op7, SDOperand Op8) {
-  // If an identical node already exists, use it.
-  SDVTList VTs = getVTList(VT);
-  SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  ID.AddOperand(Op5);
-  ID.AddOperand(Op6);
-  ID.AddOperand(Op7);
-  ID.AddOperand(Op8);
-  void *IP = 0;
-  if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
-    return ON;
-                                       
-  RemoveNodeFromCSEMaps(N);
-  N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
-  N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8);
+  N->setOperands(Ops, NumOps);
   
   CSEMap.InsertNode(N, IP);   // Memoize the new node.
   return N;
@@ -2075,55 +1967,6 @@ SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
   return N;
 }
 
-SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT1, MVT::ValueType VT2,
-                                   SDOperand Op1, SDOperand Op2,
-                                   SDOperand Op3, SDOperand Op4) {
-  // If an identical node already exists, use it.
-  SDVTList VTs = getVTList(VT1, VT2);
-  SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  void *IP = 0;
-  if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
-    return ON;
-                                       
-  RemoveNodeFromCSEMaps(N);
-  N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
-  N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4);
-
-  CSEMap.InsertNode(N, IP);   // Memoize the new node.
-  return N;
-}
-
-SDNode *SelectionDAG::SelectNodeTo(SDNode *N, unsigned TargetOpc,
-                                   MVT::ValueType VT1, MVT::ValueType VT2,
-                                   SDOperand Op1, SDOperand Op2,
-                                   SDOperand Op3, SDOperand Op4, 
-                                   SDOperand Op5) {
-  // If an identical node already exists, use it.
-  SDVTList VTs = getVTList(VT1, VT2);
-  SelectionDAGCSEMap::NodeID ID(ISD::BUILTIN_OP_END+TargetOpc, VTs);
-  ID.AddOperand(Op1);
-  ID.AddOperand(Op2);
-  ID.AddOperand(Op3);
-  ID.AddOperand(Op4);
-  ID.AddOperand(Op5);
-  void *IP = 0;
-  if (SDNode *ON = CSEMap.FindNodeOrInsertPos(ID, IP))
-    return ON;
-                                       
-  RemoveNodeFromCSEMaps(N);
-  N->MorphNodeTo(ISD::BUILTIN_OP_END+TargetOpc);
-  N->setValueTypes(VTs);
-  N->setOperands(Op1, Op2, Op3, Op4, Op5);
-  
-  CSEMap.InsertNode(N, IP);   // Memoize the new node.
-  return N;
-}
 
 /// getTargetNode - These are used for target selectors to create a new node
 /// with specified return type(s), target opcode, and operands.
@@ -2146,37 +1989,6 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
                                     SDOperand Op1, SDOperand Op2, SDOperand Op3) {
   return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3).Val;
 }
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                                    SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                                    SDOperand Op4) {
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3, Op4).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                                    SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                                    SDOperand Op4, SDOperand Op5) {
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Op1, Op2, Op3, Op4, Op5).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                                    SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                                    SDOperand Op4, SDOperand Op5,
-                                    SDOperand Op6) {
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Ops, 6).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                                    SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                                    SDOperand Op4, SDOperand Op5, SDOperand Op6,
-                                    SDOperand Op7) {
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6, Op7 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Ops, 7).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
-                                    SDOperand Op1, SDOperand Op2, SDOperand Op3,
-                                    SDOperand Op4, SDOperand Op5, SDOperand Op6,
-                                    SDOperand Op7, SDOperand Op8) {
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6, Op7, Op8 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Ops, 8).Val;
-}
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT,
                                     const SDOperand *Ops, unsigned NumOps) {
   return getNode(ISD::BUILTIN_OP_END+Opcode, VT, Ops, NumOps).Val;
@@ -2200,38 +2012,11 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
   SDOperand Ops[] = { Op1, Op2, Op3 };
   return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, 3).Val;
 }
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, SDOperand Op1,
-                                    SDOperand Op2, SDOperand Op3, 
-                                    SDOperand Op4) {
+SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
+                                    MVT::ValueType VT2,
+                                    const SDOperand *Ops, unsigned NumOps) {
   const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, 4).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, SDOperand Op1,
-                                    SDOperand Op2, SDOperand Op3, SDOperand Op4,
-                                    SDOperand Op5) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, 5).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, SDOperand Op1,
-                                    SDOperand Op2, SDOperand Op3, SDOperand Op4,
-                                    SDOperand Op5, SDOperand Op6) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, 6).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, SDOperand Op1,
-                                    SDOperand Op2, SDOperand Op3, SDOperand Op4,
-                                    SDOperand Op5, SDOperand Op6,
-                                    SDOperand Op7) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6, Op7 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, 7).Val;
+  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, NumOps).Val;
 }
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
                                     MVT::ValueType VT2, MVT::ValueType VT3,
@@ -2240,38 +2025,11 @@ SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
   SDOperand Ops[] = { Op1, Op2 };
   return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 3, Ops, 2).Val;
 }
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, MVT::ValueType VT3,
-                                    SDOperand Op1, SDOperand Op2,
-                                    SDOperand Op3, SDOperand Op4,
-                                    SDOperand Op5) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2, VT3);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 3, Ops, 5).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, MVT::ValueType VT3,
-                                    SDOperand Op1, SDOperand Op2,
-                                    SDOperand Op3, SDOperand Op4, SDOperand Op5,
-                                    SDOperand Op6) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2, VT3);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 3, Ops, 6).Val;
-}
-SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1,
-                                    MVT::ValueType VT2, MVT::ValueType VT3,
-                                    SDOperand Op1, SDOperand Op2,
-                                    SDOperand Op3, SDOperand Op4, SDOperand Op5,
-                                    SDOperand Op6, SDOperand Op7) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2, VT3);
-  SDOperand Ops[] = { Op1, Op2, Op3, Op4, Op5, Op6, Op7 };
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 3, Ops, 7).Val;
-}
 SDNode *SelectionDAG::getTargetNode(unsigned Opcode, MVT::ValueType VT1, 
-                                    MVT::ValueType VT2,
+                                    MVT::ValueType VT2, MVT::ValueType VT3,
                                     const SDOperand *Ops, unsigned NumOps) {
-  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2);
-  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 2, Ops, NumOps).Val;
+  const MVT::ValueType *VTs = getNodeValueTypes(VT1, VT2, VT3);
+  return getNode(ISD::BUILTIN_OP_END+Opcode, VTs, 3, Ops, NumOps).Val;
 }
 
 /// ReplaceAllUsesWith - Modify anything using 'From' to use 'To' instead.