Refactor the constant folding code into it's own function. And call it from both

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

diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index 3f13663d51f9df71ec207b38eda9b515813624c9..6ca8a8c861f8f5431b37592a320033bf8bcd24fb 100644 (file)
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -36,7 +36,8 @@ class MachineFunction;
 class MachineConstantPoolValue;
 class FunctionLoweringInfo;
 
-template<> class ilist_traits<SDNode> : public ilist_default_traits<SDNode> {
+template<> struct ilist_traits<SDNode> : public ilist_default_traits<SDNode> {
+private:
   mutable SDNode Sentinel;
 public:
   ilist_traits() : Sentinel(ISD::DELETED_NODE, SDVTList()) {}
@@ -170,7 +171,7 @@ public:
   /// setRoot - Set the current root tag of the SelectionDAG.
   ///
   const SDValue &setRoot(SDValue N) {
-    assert((!N.Val || N.getValueType() == MVT::Other) &&
+    assert((!N.getNode() || N.getValueType() == MVT::Other) &&
            "DAG root value is not a chain!");
     return Root = N;
   }
@@ -231,6 +232,7 @@ public:
   //
   SDValue getConstant(uint64_t Val, MVT VT, bool isTarget = false);
   SDValue getConstant(const APInt &Val, MVT VT, bool isTarget = false);
+  SDValue getConstant(const ConstantInt &Val, MVT VT, bool isTarget = false);
   SDValue getIntPtrConstant(uint64_t Val, bool isTarget = false);
   SDValue getTargetConstant(uint64_t Val, MVT VT) {
     return getConstant(Val, VT, true);
@@ -238,14 +240,21 @@ public:
   SDValue getTargetConstant(const APInt &Val, MVT VT) {
     return getConstant(Val, VT, true);
   }
+  SDValue getTargetConstant(const ConstantInt &Val, MVT VT) {
+    return getConstant(Val, VT, true);
+  }
   SDValue getConstantFP(double Val, MVT VT, bool isTarget = false);
   SDValue getConstantFP(const APFloat& Val, MVT VT, bool isTarget = false);
+  SDValue getConstantFP(const ConstantFP &CF, MVT VT, bool isTarget = false);
   SDValue getTargetConstantFP(double Val, MVT VT) {
     return getConstantFP(Val, VT, true);
   }
   SDValue getTargetConstantFP(const APFloat& Val, MVT VT) {
     return getConstantFP(Val, VT, true);
   }
+  SDValue getTargetConstantFP(const ConstantFP &Val, MVT VT) {
+    return getConstantFP(Val, VT, true);
+  }
   SDValue getGlobalAddress(const GlobalValue *GV, MVT VT,
                              int offset = 0, bool isTargetGA = false);
   SDValue getTargetGlobalAddress(const GlobalValue *GV, MVT VT,
@@ -295,7 +304,7 @@ public:
                          SDValue Flag) {
     const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
     SDValue Ops[] = { Chain, getRegister(Reg, N.getValueType()), N, Flag };
-    return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.Val ? 4 : 3);
+    return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.getNode() ? 4 : 3);
   }
 
   // Similar to last getCopyToReg() except parameter Reg is a SDValue
@@ -303,7 +312,7 @@ public:
                          SDValue Flag) {
     const MVT *VTs = getNodeValueTypes(MVT::Other, MVT::Flag);
     SDValue Ops[] = { Chain, Reg, N, Flag };
-    return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.Val ? 4 : 3);
+    return getNode(ISD::CopyToReg, VTs, 2, Ops, Flag.getNode() ? 4 : 3);
   }
   
   SDValue getCopyFromReg(SDValue Chain, unsigned Reg, MVT VT) {
@@ -319,7 +328,7 @@ public:
                            SDValue Flag) {
     const MVT *VTs = getNodeValueTypes(VT, MVT::Other, MVT::Flag);
     SDValue Ops[] = { Chain, getRegister(Reg, VT), Flag };
-    return getNode(ISD::CopyFromReg, VTs, 3, Ops, Flag.Val ? 3 : 2);
+    return getNode(ISD::CopyFromReg, VTs, 3, Ops, Flag.getNode() ? 3 : 2);
   }
 
   SDValue getCondCode(ISD::CondCode Cond);
@@ -347,7 +356,7 @@ public:
     Ops.push_back(Op2);
     Ops.push_back(InFlag);
     return getNode(ISD::CALLSEQ_END, NodeTys, &Ops[0],
-                   (unsigned)Ops.size() - (InFlag.Val == 0 ? 1 : 0));
+                   (unsigned)Ops.size() - (InFlag.getNode() == 0 ? 1 : 0));
   }
 
   /// getNode - Gets or creates the specified node.
@@ -455,6 +464,11 @@ public:
     return getNode(ISD::MERGE_VALUES, VTs, Ops, NumOps);
   }
 
+  /// getCall - Create a CALL node from the given information.
+  ///
+  SDValue getCall(unsigned CallingConv, bool IsVarArgs, bool IsTailCall,
+                  SDVTList VTs, const SDValue *Operands, unsigned NumOperands);
+
   /// 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.
   ///
@@ -683,9 +697,15 @@ public:
   /// at least that alignment.
   SDValue CreateStackTemporary(MVT VT, unsigned minAlign = 1);
   
+  /// FoldConstantArithmetic - 
+  SDValue FoldConstantArithmetic(unsigned Opcode,
+                                 MVT VT,
+                                 ConstantSDNode *Cst1,
+                                 ConstantSDNode *Cst2);
+
   /// FoldSetCC - Constant fold a setcc to true or false.
   SDValue FoldSetCC(MVT VT, SDValue N1,
-                      SDValue N2, ISD::CondCode Cond);
+                    SDValue N2, ISD::CondCode Cond);
   
   /// SignBitIsZero - Return true if the sign bit of Op is known to be zero.  We
   /// use this predicate to simplify operations downstream.
@@ -723,7 +743,7 @@ public:
   SDValue getShuffleScalarElt(const SDNode *N, unsigned Idx);
   
 private:
-  void RemoveNodeFromCSEMaps(SDNode *N);
+  bool RemoveNodeFromCSEMaps(SDNode *N);
   SDNode *AddNonLeafNodeToCSEMaps(SDNode *N);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op, void *&InsertPos);
   SDNode *FindModifiedNodeSlot(SDNode *N, SDValue Op1, SDValue Op2,