X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FAnalysis%2FCallGraph.h;h=de839694dc8a3d812635c6321eeab54683856d45;hb=7714285efd2a7f4e503f0f600667193e63ee6d08;hp=e8d45cf94377c6c6f429c5aa78d49fd3cf8df074;hpb=7ed47a13356daed2a34cd2209a31f92552e3bdd8;p=oota-llvm.git

diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h
index e8d45cf9437..de839694dc8 100644
--- a/include/llvm/Analysis/CallGraph.h
+++ b/include/llvm/Analysis/CallGraph.h
@@ -55,6 +55,8 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/CallSite.h"
+#include "llvm/System/IncludeFile.h"
+#include <map>
 
 namespace llvm {
 
@@ -102,16 +104,16 @@ public:
     return I->second;
   }
 
-  //Returns the CallGraphNode which is used to represent undetermined calls 
-  // into the callgraph.  Override this if you want behavioural inheritance.
+  /// 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 behavioural 
-  // inheritance.
+
+  /// Return the root/main method in the module, or some other root node, such
+  /// 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.
@@ -138,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);
@@ -156,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();
 };
@@ -175,6 +174,8 @@ class CallGraphNode {
 
   CallGraphNode(const CallGraphNode &);           // Do not implement
 public:
+  typedef std::vector<CallRecord> CalledFunctionsVector;
+
   //===---------------------------------------------------------------------
   // Accessor methods...
   //
@@ -190,7 +191,7 @@ public:
   inline const_iterator begin() const { return CalledFunctions.begin(); }
   inline const_iterator end()   const { return CalledFunctions.end();   }
   inline bool empty() const { return CalledFunctions.empty(); }
-  inline unsigned size() const { return CalledFunctions.size(); }
+  inline unsigned size() const { return (unsigned)CalledFunctions.size(); }
 
   // Subscripting operator - Return the i'th called function...
   //
@@ -215,22 +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.
@@ -249,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*> {