Added LLVM copyright header (for lack of a better term).

[oota-llvm.git] / include / llvm / Analysis / DSGraph.h

diff --git a/include/llvm/Analysis/DSGraph.h b/include/llvm/Analysis/DSGraph.h
index 81979cf74ec28216c5165d19cdf6e49c15aaeaec..fae11f4abe2ff32b79b5efdd24e30ac47214e914 100644 (file)
--- a/include/llvm/Analysis/DSGraph.h
+++ b/include/llvm/Analysis/DSGraph.h
@@ -1,4 +1,11 @@
 //===- DSGraph.h - Represent a collection of data structures ----*- 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 header defines the data structure graph.
 //
@@ -8,6 +15,7 @@
 #define LLVM_ANALYSIS_DSGRAPH_H
 
 #include "llvm/Analysis/DSNode.h"
+class GlobalValue;
 
 //===----------------------------------------------------------------------===//
 /// DSGraph - The graph that represents a function.
@@ -16,6 +24,7 @@ struct DSGraph {
   // Public data-type declarations...
   typedef hash_map<Value*, DSNodeHandle> ScalarMapTy;
   typedef hash_map<Function*, DSNodeHandle> ReturnNodesTy;
+  typedef hash_set<const GlobalValue*> GlobalSetTy;
 
   /// NodeMapTy - This data type is used when cloning one graph into another to
   /// keep track of the correspondence between the nodes in the old and new
@@ -48,7 +57,13 @@ private:
   //
   std::vector<DSCallSite> AuxFunctionCalls;
 
+  // InlinedGlobals - This set records which globals have been inlined from
+  // other graphs (callers or callees, depending on the pass) into this one.
+  // 
+  GlobalSetTy InlinedGlobals;
+
   void operator=(const DSGraph &); // DO NOT IMPLEMENT
+
 public:
   // Create a new, empty, DSGraph.
   DSGraph() : GlobalsGraph(0), PrintAuxCalls(false) {}
@@ -92,7 +107,7 @@ public:
   /// function point to...
   ///
   ScalarMapTy &getScalarMap() { return ScalarMap; }
-  const ScalarMapTy &getScalarMap() const {return ScalarMap;}
+  const ScalarMapTy &getScalarMap() const { return ScalarMap; }
 
   /// getFunctionCalls - Return the list of call sites in the original local
   /// graph...
@@ -111,6 +126,13 @@ public:
     return AuxFunctionCalls;
   }
 
+  /// getInlinedGlobals - Get the set of globals that are have been inlined
+  /// (from callees in BU or from callers in TD) into the current graph.
+  ///
+  GlobalSetTy& getInlinedGlobals() {
+    return InlinedGlobals;
+  }
+
   /// getNodeForValue - Given a value that is used or defined in the body of the
   /// current function, return the DSNode that it points to.
   ///
@@ -136,6 +158,12 @@ public:
     return I->second;
   }
 
+  const DSNodeHandle &getReturnNodeFor(Function &F) const {
+    ReturnNodesTy::const_iterator I = ReturnNodes.find(&F);
+    assert(I != ReturnNodes.end() && "F not in this DSGraph!");
+    return I->second;
+  }
+
   /// getGraphSize - Return the number of nodes in this graph.
   ///
   unsigned getGraphSize() const {
@@ -193,12 +221,28 @@ public:
   /// CloneFlags enum - Bits that may be passed into the cloneInto method to
   /// specify how to clone the function graph.
   enum CloneFlags {
-    StripAllocaBit        = 1 << 0, KeepAllocaBit     = 0 << 0,
-    DontCloneCallNodes    = 1 << 1, CloneCallNodes    = 0 << 0,
-    DontCloneAuxCallNodes = 1 << 2, CloneAuxCallNodes = 0 << 0,
-    StripModRefBits       = 1 << 3, KeepModRefBits    = 0 << 0,
+    StripAllocaBit        = 1 << 0, KeepAllocaBit     = 0,
+    DontCloneCallNodes    = 1 << 1, CloneCallNodes    = 0,
+    DontCloneAuxCallNodes = 1 << 2, CloneAuxCallNodes = 0,
+    StripModRefBits       = 1 << 3, KeepModRefBits    = 0,
+    StripIncompleteBit    = 1 << 4, KeepIncompleteBit = 0,
   };
 
+private:
+  void cloneReachableNodes(const DSNode*  Node,
+                           unsigned BitsToClear,
+                           NodeMapTy& OldNodeMap,
+                           NodeMapTy& CompletedNodeMap);
+
+public:
+  void updateFromGlobalGraph();
+
+  void cloneReachableSubgraph(const DSGraph& G,
+                              const hash_set<const DSNode*>& RootNodes,
+                              NodeMapTy& OldNodeMap,
+                              NodeMapTy& CompletedNodeMap,
+                              unsigned CloneFlags = 0);
+
   /// cloneInto - Clone the specified DSGraph into the current graph.  The
   /// translated ScalarMap for the old function is filled into the OldValMap
   /// member, and the translated ReturnNodes map is returned into ReturnNodes.
@@ -218,6 +262,12 @@ public:
   void mergeInGraph(const DSCallSite &CS, Function &F, const DSGraph &Graph,
                     unsigned CloneFlags);
 
+
+  /// getCallSiteForArguments - Get the arguments and return value bindings for
+  /// the specified function in the current graph.
+  ///
+  DSCallSite getCallSiteForArguments(Function &F) const;
+
   // Methods for checking to make sure graphs are well formed...
   void AssertNodeInGraph(const DSNode *N) const {
     assert((!N || find(Nodes.begin(), Nodes.end(), N) != Nodes.end()) &&
@@ -247,12 +297,18 @@ public:
 
   void AssertGraphOK() const;
 
-public:
-  // removeTriviallyDeadNodes - After the graph has been constructed, this
-  // method removes all unreachable nodes that are created because they got
-  // merged with other nodes in the graph.  This is used as the first step of
-  // removeDeadNodes.
-  //
+  /// mergeInGlobalsGraph - This method is useful for clients to incorporate the
+  /// globals graph into the DS, BU or TD graph for a function.  This code
+  /// retains all globals, i.e., does not delete unreachable globals after they
+  /// are inlined.
+  ///
+  void mergeInGlobalsGraph();
+
+  /// removeTriviallyDeadNodes - After the graph has been constructed, this
+  /// method removes all unreachable nodes that are created because they got
+  /// merged with other nodes in the graph.  This is used as the first step of
+  /// removeDeadNodes.
+  ///
   void removeTriviallyDeadNodes();
 };