Add a way to construct an arbitrary node, cleanly.

[oota-llvm.git] / include / llvm / CodeGen / SelectionDAG.h

diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index 4bb1739ec12cc9a194e9ad70f304c9ed572e8955..26e792221725ce5ea5a4a751798b51b81897e45c 100644 (file)
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -1,15 +1,15 @@
 //===-- llvm/CodeGen/SelectionDAG.h - InstSelection DAG ---------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
-// 
+//
 // This file declares the SelectionDAG class, and transitively defines the
 // SDNode class and subclasses.
-//   
+//
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_SELECTIONDAG_H
@@ -44,6 +44,10 @@ class SelectionDAG {
 
   // AllNodes - All of the nodes in the DAG
   std::vector<SDNode*> AllNodes;
+
+  // ValueNodes - track SrcValue nodes
+  std::map<std::pair<const Value*, int>, SDNode*> ValueNodes;
+
 public:
   SelectionDAG(TargetLowering &tli, MachineFunction &mf) : TLI(tli), MF(mf) {
     EntryNode = Root = getNode(ISD::EntryToken, MVT::Other);
@@ -62,7 +66,7 @@ public:
   typedef std::vector<SDNode*>::const_iterator allnodes_iterator;
   allnodes_iterator allnodes_begin() const { return AllNodes.begin(); }
   allnodes_iterator allnodes_end() const { return AllNodes.end(); }
-  
+
   /// getRoot - Return the root tag of the SelectionDAG.
   ///
   const SDOperand &getRoot() const { return Root; }
@@ -125,8 +129,9 @@ public:
   /// getCall - Note that this destroys the vector of RetVals passed in.
   ///
   SDNode *getCall(std::vector<MVT::ValueType> &RetVals, SDOperand Chain,
-                  SDOperand Callee) {
-    SDNode *NN = new SDNode(ISD::CALL, Chain, Callee);
+                  SDOperand Callee, bool isTailCall = false) {
+    SDNode *NN = new SDNode(isTailCall ? ISD::TAILCALL : ISD::CALL, Chain,
+                            Callee);
     NN->setValueTypes(RetVals);
     AllNodes.push_back(NN);
     return NN;
@@ -136,10 +141,11 @@ public:
   /// where arguments are passed in physical registers.  This destroys the
   /// RetVals and ArgsInRegs vectors.
   SDNode *getCall(std::vector<MVT::ValueType> &RetVals, SDOperand Chain,
-                  SDOperand Callee, std::vector<SDOperand> &ArgsInRegs) {
+                  SDOperand Callee, std::vector<SDOperand> &ArgsInRegs,
+                  bool isTailCall = false) {
     ArgsInRegs.insert(ArgsInRegs.begin(), Callee);
     ArgsInRegs.insert(ArgsInRegs.begin(), Chain);
-    SDNode *NN = new SDNode(ISD::CALL, ArgsInRegs);
+    SDNode *NN = new SDNode(isTailCall ? ISD::TAILCALL : ISD::CALL, ArgsInRegs);
     NN->setValueTypes(RetVals);
     AllNodes.push_back(NN);
     return NN;
@@ -149,6 +155,10 @@ public:
   SDOperand getSetCC(ISD::CondCode, MVT::ValueType VT,
                      SDOperand LHS, SDOperand RHS);
 
+  /// getZeroExtendInReg - Return the expression required to zero extend the Op
+  /// value assuming it was the smaller SrcTy value.
+  SDOperand getZeroExtendInReg(SDOperand Op, MVT::ValueType SrcTy);
+
   /// getNode - Gets or creates the specified node.
   ///
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT);
@@ -157,8 +167,12 @@ public:
                     SDOperand N1, SDOperand N2);
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
                     SDOperand N1, SDOperand N2, SDOperand N3);
+  SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
+                    SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4);
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT,
                     std::vector<SDOperand> &Children);
+  SDOperand getNode(unsigned Opcode, std::vector<MVT::ValueType> &ResultTys,
+                    std::vector<SDOperand> &Ops);
 
   // getNode - These versions take an extra value type for extending and
   // truncating loads, stores, rounds, extends etc.
@@ -168,11 +182,19 @@ public:
                     SDOperand N, MVT::ValueType EVT);
   SDOperand getNode(unsigned Opcode, MVT::ValueType VT, SDOperand N1,
                     SDOperand N2, SDOperand N3, MVT::ValueType EVT);
+  SDOperand getNode(unsigned Opcode, MVT::ValueType VT, SDOperand N1,
+                    SDOperand N2, SDOperand N3, SDOperand N4,
+                    MVT::ValueType EVT);
+
 
   /// getLoad - Loads are not normal binary operators: their result type is not
   /// determined by their operands, and they produce a value AND a token chain.
   ///
-  SDOperand getLoad(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr);
+  SDOperand getLoad(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr,
+                    SDOperand SV);
+
+  // getSrcValue - construct a node to track a Value* through the backend
+  SDOperand getSrcValue(const Value* I, int offset = 0);
 
   void replaceAllUsesWith(SDOperand Old, SDOperand New) {
     assert(Old != New && "RAUW self!");
@@ -203,6 +225,11 @@ private:
   std::map<int, SDNode*> FrameIndices;
   std::map<unsigned, SDNode*> ConstantPoolIndices;
   std::map<MachineBasicBlock *, SDNode*> BBNodes;
+  std::map<std::pair<unsigned,
+                     std::pair<std::vector<MVT::ValueType>,
+                               std::vector<SDOperand> > >,
+           SDNode*> ArbitraryNodes;
+
   std::map<std::string, SDNode*> ExternalSymbols;
   struct EVTStruct {
     unsigned Opcode;