X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FCallGraph.h;h=de839694dc8a3d812635c6321eeab54683856d45;hb=b679de2a21f5ecbae81b444290d72af93aa5b0b3;hp=88449ab2580f2e08cd2502b586ca7027d5dd61e5;hpb=34cd4a484e532cc463fd5a4bf59b88d13c5467c1;p=oota-llvm.git

diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index 88449ab2580..de839694dc8 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -55,6 +55,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CallSite.h"
+#include "llvm/System/IncludeFile.h"
 #include <map>
 
 namespace llvm {
@@ -103,16 +104,16 @@ public:
     return I->second;
   }
 
-  /// Returns the CallGraphNode which is used to represent undetermined calls 
+  /// Returns the CallGraphNode which is used to represent undetermined calls
   /// into the callgraph.  Override this if you want behavioral inheritance.
   virtual CallGraphNode* getExternalCallingNode() const { return 0; }
-  
+
   /// Return the root/main method in the module, or some other root node, such
-  /// as the externalcallingnode.  Overload these if you behavioral 
+  /// as the externalcallingnode.  Overload these if you behavioral
   /// inheritance.
   virtual CallGraphNode* getRoot() { return 0; }
   virtual const CallGraphNode* getRoot() const { return 0; }
-  
+
   //===---------------------------------------------------------------------
   // Functions to keep a call graph up to date with a function that has been
   // modified.
@@ -139,17 +140,17 @@ public:
   /// it will insert a new CallGraphNode for the specified function if one does
   /// not already exist.
   CallGraphNode *getOrInsertFunction(const Function *F);
-  
+
   //===---------------------------------------------------------------------
   // Pass infrastructure interface glue code...
   //
 protected:
   CallGraph() {}
-  
+
 public:
   virtual ~CallGraph() { destroy(); }
 
-  /// initialize - Call this method before calling other methods, 
+  /// initialize - Call this method before calling other methods,
   /// re/initializes the state of the CallGraph.
   ///
   void initialize(Module &M);
@@ -157,11 +158,8 @@ public:
   virtual void print(std::ostream &o, const Module *M) const;
   void print(std::ostream *o, const Module *M) const { if (o) print(*o, M); }
   void dump() const;
-  
-  // stub - dummy function, just ignore it
-  static int stub;
-protected:
 
+protected:
   // destroy - Release memory for the call graph
   virtual void destroy();
 };
@@ -176,6 +174,8 @@ class CallGraphNode {
 
   CallGraphNode(const CallGraphNode &);           // Do not implement
 public:
+  typedef std::vector<CallRecord> CalledFunctionsVector;
+
   //===---------------------------------------------------------------------
   // Accessor methods...
   //
@@ -216,27 +216,31 @@ public:
     CalledFunctions.clear();
   }
 
-  /// addCalledFunction add a function to the list of functions called by this
+  /// addCalledFunction - Add a function to the list of functions called by this
   /// one.
   void addCalledFunction(CallSite CS, CallGraphNode *M) {
     CalledFunctions.push_back(std::make_pair(CS, M));
   }
 
-  /// removeCallEdgeTo - This method removes a *single* edge to the specified
-  /// callee function.  Note that this method takes linear time, so it should be
-  /// used sparingly.
-  void removeCallEdgeTo(CallGraphNode *Callee);
-
   /// removeCallEdgeFor - This method removes the edge in the node for the
   /// specified call site.  Note that this method takes linear time, so it
   /// should be used sparingly.
   void removeCallEdgeFor(CallSite CS);
-  
-  /// removeAnyCallEdgeTo - This method removes any call edges from this node to
-  /// the specified callee function.  This takes more time to execute than
+
+  /// removeAnyCallEdgeTo - This method removes all call edges from this node
+  /// to the specified callee function.  This takes more time to execute than
   /// removeCallEdgeTo, so it should not be used unless necessary.
   void removeAnyCallEdgeTo(CallGraphNode *Callee);
 
+  /// removeOneAbstractEdgeTo - Remove one edge associated with a null callsite
+  /// from this node to the specified callee function.
+  void removeOneAbstractEdgeTo(CallGraphNode *Callee);
+
+  /// replaceCallSite - Make the edge in the node for Old CallSite be for
+  /// New CallSite instead.  Note that this method takes linear time, so it
+  /// should be used sparingly.
+  void replaceCallSite(CallSite Old, CallSite New);
+
   friend class CallGraph;
 
   // CallGraphNode ctor - Create a node for the specified function.
@@ -255,22 +259,22 @@ template <> struct GraphTraits<CallGraphNode*> {
 
   typedef std::pair<CallSite, CallGraphNode*> CGNPairTy;
   typedef std::pointer_to_unary_function<CGNPairTy, CallGraphNode*> CGNDerefFun;
-  
+
   static NodeType *getEntryNode(CallGraphNode *CGN) { return CGN; }
-  
+
   typedef mapped_iterator<NodeType::iterator, CGNDerefFun> ChildIteratorType;
-  
+
   static inline ChildIteratorType child_begin(NodeType *N) {
     return map_iterator(N->begin(), CGNDerefFun(CGNDeref));
   }
   static inline ChildIteratorType child_end  (NodeType *N) {
     return map_iterator(N->end(), CGNDerefFun(CGNDeref));
   }
-  
+
   static CallGraphNode *CGNDeref(CGNPairTy P) {
     return P.second;
   }
-  
+
 };
 
 template <> struct GraphTraits<const CallGraphNode*> {