Abstract out the Nodes collection. Instead of providing a getNodes() method,

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

diff --git a/include/llvm/Analysis/DataStructure/DSGraph.h b/include/llvm/Analysis/DataStructure/DSGraph.h
index e81f139fb5f949be67135d435680e2ce3a1a7cb8..7e19212abefbcfa6c890a0a9261d1b5bd96ffa3a 100644 (file)
--- a/include/llvm/Analysis/DataStructure/DSGraph.h
+++ b/include/llvm/Analysis/DataStructure/DSGraph.h
@@ -32,10 +32,12 @@ class GlobalValue;
 /// of DSA.  In all of these cases, the DSA phase is really trying to identify 
 /// globals or unique node handles active in the function.
 ///
-
 class DSScalarMap {
   typedef hash_map<Value*, DSNodeHandle> ValueMapTy;
   ValueMapTy ValueMap;
+
+  typedef hash_set<GlobalValue*> GlobalSetTy;
+  GlobalSetTy GlobalSet;
 public:
 
   // Compatibility methods: provide an interface compatible with a map of 
@@ -50,15 +52,35 @@ public:
   const_iterator find(Value *V) const { return ValueMap.find(V); }
   unsigned count(Value *V) const { return ValueMap.count(V); }
 
-  void erase(iterator I) { ValueMap.erase(I); }
-  void erase(Value *V) { ValueMap.erase(V); }
+  void erase(Value *V) { erase(find(V)); }
 
-  DSNodeHandle &operator[](Value *V) { return ValueMap[V]; }
+  DSNodeHandle &operator[](Value *V) {
+    std::pair<iterator,bool> IP = 
+      ValueMap.insert(std::make_pair(V, DSNodeHandle()));
+    if (IP.second) {  // Inserted the new entry into the map.
+      if (GlobalValue *GV = dyn_cast<GlobalValue>(V))
+        GlobalSet.insert(GV);
+    }
+    return IP.first->second;
+  }
+
+  void erase(iterator I) { 
+    assert(I != ValueMap.end() && "Cannot erase end!");
+    if (GlobalValue *GV = dyn_cast<GlobalValue>(I->first))
+      GlobalSet.erase(GV);
+    ValueMap.erase(I); 
+  }
 
   void clear() {
     ValueMap.clear();
+    GlobalSet.clear();
   }
 
+  // Access to the global set: the set of all globals currently in the
+  // scalar map.
+  typedef GlobalSetTy::const_iterator global_iterator;
+  global_iterator global_begin() const { return GlobalSet.begin(); }
+  global_iterator global_end() const { return GlobalSet.end(); }
 };
 
 
@@ -70,6 +92,7 @@ struct DSGraph {
   typedef DSScalarMap ScalarMapTy;
   typedef hash_map<Function*, DSNodeHandle> ReturnNodesTy;
   typedef hash_set<GlobalValue*> GlobalSetTy;
+  typedef std::vector<DSNode*> NodeListTy;
 
   /// 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
@@ -79,7 +102,7 @@ private:
   DSGraph *GlobalsGraph;   // Pointer to the common graph of global objects
   bool PrintAuxCalls;      // Should this graph print the Aux calls vector?
 
-  std::vector<DSNode*> Nodes;
+  NodeListTy Nodes;
   ScalarMapTy ScalarMap;
 
   // ReturnNodes - A return value for every function merged into this graph.
@@ -148,8 +171,9 @@ public:
 
   /// getNodes - Get a vector of all the nodes in the graph
   /// 
-  const std::vector<DSNode*> &getNodes() const { return Nodes; }
-        std::vector<DSNode*> &getNodes()       { return Nodes; }
+  typedef NodeListTy::const_iterator node_iterator;
+  node_iterator node_begin() const { return Nodes.begin(); }
+  node_iterator node_end()   const { return Nodes.end(); }
 
   /// getFunctionNames - Return a space separated list of the name of the
   /// functions in this graph (if any)