//
// 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 file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/ADT/STLExtras.h"
#include "llvm/Pass.h"
#include "llvm/Support/CallSite.h"
+#include "llvm/System/IncludeFile.h"
+#include <map>
namespace llvm {
FunctionMapTy FunctionMap; // Map from a function to its node
public:
- static const char ID; // Class identification, replacement for typeinfo
+ static char ID; // Class identification, replacement for typeinfo
//===---------------------------------------------------------------------
// Accessors...
//
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.
/// 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);
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();
};
CallGraphNode(const CallGraphNode &); // Do not implement
public:
+ typedef std::vector<CallRecord> CalledFunctionsVector;
+
//===---------------------------------------------------------------------
// Accessor methods...
//
inline iterator end() { return CalledFunctions.end(); }
inline const_iterator begin() const { return CalledFunctions.begin(); }
inline const_iterator end() const { return CalledFunctions.end(); }
- inline unsigned size() const { return CalledFunctions.size(); }
+ inline bool empty() const { return CalledFunctions.empty(); }
+ inline unsigned size() const { return (unsigned)CalledFunctions.size(); }
// Subscripting operator - Return the i'th called function...
//
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.
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*> {