Rename loop preheaders pass to loop simplify

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

diff --git a/include/llvm/Analysis/DataStructure.h b/include/llvm/Analysis/DataStructure.h
index 930b58df599f51e614536cc8e5069e254a83f334..4a9ca1af75906a180b5ab18c5cbae72ca683d1cb 100644 (file)
--- a/include/llvm/Analysis/DataStructure.h
+++ b/include/llvm/Analysis/DataStructure.h
@@ -8,12 +8,12 @@
 #define LLVM_ANALYSIS_DATA_STRUCTURE_H
 
 #include "llvm/Pass.h"
-#include <set>
+#include "Support/hash_set"
 
 class Type;
+class Instruction;
 class DSGraph;
 class DSNode;
-class DSCallSite;
 
 // FIXME: move this stuff to a private header
 namespace DataStructureAnalysis {
@@ -32,7 +32,7 @@ namespace DataStructureAnalysis {
 //
 class LocalDataStructures : public Pass {
   // DSInfo, one graph for each function
-  std::map<const Function*, DSGraph*> DSInfo;
+  hash_map<Function*, DSGraph*> DSInfo;
   DSGraph *GlobalsGraph;
 public:
   ~LocalDataStructures() { releaseMemory(); }
@@ -40,12 +40,13 @@ public:
   virtual bool run(Module &M);
 
   bool hasGraph(const Function &F) const {
-    return DSInfo.find(&F) != DSInfo.end();
+    return DSInfo.find(const_cast<Function*>(&F)) != DSInfo.end();
   }
 
   // getDSGraph - Return the data structure graph for the specified function.
   DSGraph &getDSGraph(const Function &F) const {
-    std::map<const Function*, DSGraph*>::const_iterator I = DSInfo.find(&F);
+    hash_map<Function*, DSGraph*>::const_iterator I =
+      DSInfo.find(const_cast<Function*>(&F));
     assert(I != DSInfo.end() && "Function not in module!");
     return *I->second;
   }
@@ -71,20 +72,22 @@ public:
 //
 class BUDataStructures : public Pass {
   // DSInfo, one graph for each function
-  std::map<const Function*, DSGraph*> DSInfo;
+  hash_map<Function*, DSGraph*> DSInfo;
   DSGraph *GlobalsGraph;
+  hash_multimap<Instruction*, Function*> ActualCallees;
 public:
   ~BUDataStructures() { releaseMemory(); }
 
   virtual bool run(Module &M);
 
   bool hasGraph(const Function &F) const {
-    return DSInfo.find(&F) != DSInfo.end();
+    return DSInfo.find(const_cast<Function*>(&F)) != DSInfo.end();
   }
 
   // getDSGraph - Return the data structure graph for the specified function.
   DSGraph &getDSGraph(const Function &F) const {
-    std::map<const Function*, DSGraph*>::const_iterator I = DSInfo.find(&F);
+    hash_map<Function*, DSGraph*>::const_iterator I =
+      DSInfo.find(const_cast<Function*>(&F));
     assert(I != DSInfo.end() && "Function not in module!");
     return *I->second;
   }
@@ -101,11 +104,23 @@ public:
     AU.setPreservesAll();
     AU.addRequired<LocalDataStructures>();
   }
+
+  typedef hash_multimap<Instruction*, Function*> ActualCalleesTy;
+  const ActualCalleesTy &getActualCallees() const {
+    return ActualCallees;
+  }
+
 private:
-  DSGraph &calculateGraph(Function &F, unsigned Indent);
-  bool ResolveFunctionCalls(DSGraph &G, unsigned &FirstResolvableCall,
-                            std::map<Function*, DSCallSite> &InProcess,
-                            unsigned Indent);
+  void calculateGraph(DSGraph &G);
+
+  void calculateReachableGraphs(Function *F);
+
+
+  DSGraph &getOrCreateGraph(Function *F);
+
+  unsigned calculateGraphs(Function *F, std::vector<Function*> &Stack,
+                           unsigned &NextID, 
+                           hash_map<Function*, unsigned> &ValMap);
 };
 
 
@@ -115,21 +130,22 @@ private:
 //
 class TDDataStructures : public Pass {
   // DSInfo, one graph for each function
-  std::map<const Function*, DSGraph*> DSInfo;
-  std::set<const Function*> GraphDone;
+  hash_map<Function*, DSGraph*> DSInfo;
+  hash_set<Function*> ArgsRemainIncomplete;
   DSGraph *GlobalsGraph;
 public:
-  ~TDDataStructures() { releaseMemory(); }
+  ~TDDataStructures() { releaseMyMemory(); }
 
   virtual bool run(Module &M);
 
   bool hasGraph(const Function &F) const {
-    return DSInfo.find(&F) != DSInfo.end();
+    return DSInfo.find(const_cast<Function*>(&F)) != DSInfo.end();
   }
 
   // getDSGraph - Return the data structure graph for the specified function.
   DSGraph &getDSGraph(const Function &F) const {
-    std::map<const Function*, DSGraph*>::const_iterator I = DSInfo.find(&F);
+    hash_map<Function*, DSGraph*>::const_iterator I =
+      DSInfo.find(const_cast<Function*>(&F));
     assert(I != DSInfo.end() && "Function not in module!");
     return *I->second;
   }
@@ -140,18 +156,23 @@ public:
   void print(std::ostream &O, const Module *M) const;
 
   // If the pass pipeline is done with this pass, we can release our memory...
-  virtual void releaseMemory();
+  virtual void releaseMyMemory();
 
   // getAnalysisUsage - This obviously provides a data structure graph.
   virtual void getAnalysisUsage(AnalysisUsage &AU) const {
     AU.setPreservesAll();
     AU.addRequired<BUDataStructures>();
   }
+
 private:
-  void calculateGraph(Function &F);
-  DSGraph &getOrCreateDSGraph(Function &F);
+  void markReachableFunctionsExternallyAccessible(DSNode *N,
+                                                  hash_set<DSNode*> &Visited);
 
-  void ResolveCallSite(DSGraph &Graph, const DSCallSite &CallSite);
+  void inlineGraphIntoCallees(DSGraph &G);
+  DSGraph &getOrCreateDSGraph(Function &F);
+  void ComputePostOrder(Function &F, hash_set<DSGraph*> &Visited,
+                        std::vector<DSGraph*> &PostOrder,
+                        const BUDataStructures::ActualCalleesTy &ActualCallees);
 };
 
 #endif