2002-03-06 18:00:49 +00:00
|
|
|
//===- CallGraph.cpp - Build a Module's call graph ------------------------===//
|
2005-04-21 21:13:18 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 21:13:18 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-09-28 00:08:15 +00:00
|
|
|
//
|
2005-12-22 06:07:52 +00:00
|
|
|
// This file implements the CallGraph class and provides the BasicCallGraph
|
|
|
|
// default implementation.
|
2001-10-13 06:33:19 +00:00
|
|
|
//
|
2001-09-28 00:08:15 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/CallGraph.h"
|
|
|
|
#include "llvm/Module.h"
|
2004-07-29 17:30:56 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2009-03-19 18:03:56 +00:00
|
|
|
#include "llvm/IntrinsicInst.h"
|
2003-10-31 21:05:12 +00:00
|
|
|
#include "llvm/Support/CallSite.h"
|
2009-12-23 20:03:58 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-08-23 06:03:38 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2004-04-12 05:36:32 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2005-12-22 06:07:52 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// BasicCallGraph class definition
|
2001-09-28 00:08:15 +00:00
|
|
|
//
|
2010-01-20 19:51:46 +00:00
|
|
|
class BasicCallGraph : public ModulePass, public CallGraph {
|
2005-12-22 06:07:52 +00:00
|
|
|
// Root is root of the call graph, or the external node if a 'main' function
|
|
|
|
// couldn't be found.
|
|
|
|
//
|
|
|
|
CallGraphNode *Root;
|
|
|
|
|
|
|
|
// ExternalCallingNode - This node has edges to all external functions and
|
|
|
|
// those internal functions that have their address taken.
|
|
|
|
CallGraphNode *ExternalCallingNode;
|
|
|
|
|
|
|
|
// CallsExternalNode - This node has edges to it from all functions making
|
|
|
|
// indirect calls or calling an external function.
|
|
|
|
CallGraphNode *CallsExternalNode;
|
|
|
|
|
|
|
|
public:
|
2007-05-03 01:11:54 +00:00
|
|
|
static char ID; // Class identification, replacement for typeinfo
|
2010-08-06 18:33:48 +00:00
|
|
|
BasicCallGraph() : ModulePass(ID), Root(0),
|
2010-10-19 17:21:58 +00:00
|
|
|
ExternalCallingNode(0), CallsExternalNode(0) {
|
|
|
|
initializeBasicCallGraphPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2005-12-22 06:07:52 +00:00
|
|
|
|
|
|
|
// runOnModule - Compute the call graph for the specified module.
|
|
|
|
virtual bool runOnModule(Module &M) {
|
|
|
|
CallGraph::initialize(M);
|
|
|
|
|
2006-01-14 20:03:00 +00:00
|
|
|
ExternalCallingNode = getOrInsertFunction(0);
|
2005-12-22 06:07:52 +00:00
|
|
|
CallsExternalNode = new CallGraphNode(0);
|
|
|
|
Root = 0;
|
|
|
|
|
2009-08-31 03:15:49 +00:00
|
|
|
// Add every function to the call graph.
|
2005-12-22 06:07:52 +00:00
|
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
|
|
|
|
addToCallGraph(I);
|
|
|
|
|
|
|
|
// If we didn't find a main function, use the external call graph node
|
|
|
|
if (Root == 0) Root = ExternalCallingNode;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
2002-03-06 20:19:35 +00:00
|
|
|
}
|
2005-04-21 21:13:18 +00:00
|
|
|
|
2009-08-23 06:03:38 +00:00
|
|
|
virtual void print(raw_ostream &OS, const Module *) const {
|
|
|
|
OS << "CallGraph Root is: ";
|
2005-12-22 06:07:52 +00:00
|
|
|
if (Function *F = getRoot()->getFunction())
|
2009-08-23 06:03:38 +00:00
|
|
|
OS << F->getName() << "\n";
|
|
|
|
else {
|
|
|
|
OS << "<<null function: 0x" << getRoot() << ">>\n";
|
|
|
|
}
|
2005-12-22 06:07:52 +00:00
|
|
|
|
2009-08-23 06:03:38 +00:00
|
|
|
CallGraph::print(OS, 0);
|
2005-12-22 06:07:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
virtual void releaseMemory() {
|
|
|
|
destroy();
|
|
|
|
}
|
|
|
|
|
2010-01-20 19:51:46 +00:00
|
|
|
/// getAdjustedAnalysisPointer - This method is used when a pass implements
|
|
|
|
/// an analysis interface through multiple inheritance. If needed, it should
|
|
|
|
/// override this to adjust the this pointer as needed for the specified pass
|
|
|
|
/// info.
|
2010-08-06 18:33:48 +00:00
|
|
|
virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
|
|
|
|
if (PI == &CallGraph::ID)
|
2010-01-20 19:51:46 +00:00
|
|
|
return (CallGraph*)this;
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2005-12-22 06:07:52 +00:00
|
|
|
CallGraphNode* getExternalCallingNode() const { return ExternalCallingNode; }
|
|
|
|
CallGraphNode* getCallsExternalNode() const { return CallsExternalNode; }
|
|
|
|
|
|
|
|
// getRoot - Return the root of the call graph, which is either main, or if
|
|
|
|
// main cannot be found, the external node.
|
2002-03-06 20:19:35 +00:00
|
|
|
//
|
2005-12-22 06:07:52 +00:00
|
|
|
CallGraphNode *getRoot() { return Root; }
|
|
|
|
const CallGraphNode *getRoot() const { return Root; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
//===---------------------------------------------------------------------
|
|
|
|
// Implementation of CallGraph construction
|
|
|
|
//
|
|
|
|
|
|
|
|
// addToCallGraph - Add a function to the call graph, and link the node to all
|
|
|
|
// of the functions that it calls.
|
|
|
|
//
|
|
|
|
void addToCallGraph(Function *F) {
|
2006-01-14 20:03:00 +00:00
|
|
|
CallGraphNode *Node = getOrInsertFunction(F);
|
2005-12-22 06:07:52 +00:00
|
|
|
|
2006-07-12 18:29:36 +00:00
|
|
|
// If this function has external linkage, anything could call it.
|
2009-01-15 20:18:42 +00:00
|
|
|
if (!F->hasLocalLinkage()) {
|
2006-07-12 18:29:36 +00:00
|
|
|
ExternalCallingNode->addCalledFunction(CallSite(), Node);
|
2005-12-22 06:07:52 +00:00
|
|
|
|
|
|
|
// Found the entry point?
|
|
|
|
if (F->getName() == "main") {
|
|
|
|
if (Root) // Found multiple external mains? Don't pick one.
|
|
|
|
Root = ExternalCallingNode;
|
|
|
|
else
|
|
|
|
Root = Node; // Found a main, keep track of it!
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-20 03:23:14 +00:00
|
|
|
// If this function has its address taken, anything could call it.
|
|
|
|
if (F->hasAddressTaken())
|
|
|
|
ExternalCallingNode->addCalledFunction(CallSite(), Node);
|
2008-09-09 19:56:34 +00:00
|
|
|
|
2005-12-22 06:07:52 +00:00
|
|
|
// If this function is not defined in this translation unit, it could call
|
|
|
|
// anything.
|
2007-12-03 20:06:50 +00:00
|
|
|
if (F->isDeclaration() && !F->isIntrinsic())
|
2006-07-12 18:29:36 +00:00
|
|
|
Node->addCalledFunction(CallSite(), CallsExternalNode);
|
2005-12-22 06:07:52 +00:00
|
|
|
|
2008-09-09 12:40:47 +00:00
|
|
|
// Look for calls by this function.
|
2005-12-22 06:07:52 +00:00
|
|
|
for (Function::iterator BB = F->begin(), BBE = F->end(); BB != BBE; ++BB)
|
|
|
|
for (BasicBlock::iterator II = BB->begin(), IE = BB->end();
|
|
|
|
II != IE; ++II) {
|
2010-07-28 12:19:46 +00:00
|
|
|
CallSite CS(cast<Value>(II));
|
2011-06-09 19:46:27 +00:00
|
|
|
if (CS && !isa<IntrinsicInst>(II)) {
|
2008-09-09 12:40:47 +00:00
|
|
|
const Function *Callee = CS.getCalledFunction();
|
|
|
|
if (Callee)
|
|
|
|
Node->addCalledFunction(CS, getOrInsertFunction(Callee));
|
|
|
|
else
|
|
|
|
Node->addCalledFunction(CS, CallsExternalNode);
|
|
|
|
}
|
2005-12-22 06:07:52 +00:00
|
|
|
}
|
|
|
|
}
|
2002-01-31 00:42:27 +00:00
|
|
|
|
2005-12-22 06:07:52 +00:00
|
|
|
//
|
|
|
|
// destroy - Release memory for the call graph
|
|
|
|
virtual void destroy() {
|
2006-12-05 19:46:12 +00:00
|
|
|
/// CallsExternalNode is not in the function map, delete it explicitly.
|
2010-04-20 12:16:50 +00:00
|
|
|
if (CallsExternalNode) {
|
|
|
|
CallsExternalNode->allReferencesDropped();
|
|
|
|
delete CallsExternalNode;
|
|
|
|
CallsExternalNode = 0;
|
|
|
|
}
|
2006-12-05 19:46:12 +00:00
|
|
|
CallGraph::destroy();
|
2005-12-22 06:07:52 +00:00
|
|
|
}
|
|
|
|
};
|
2001-11-26 18:51:25 +00:00
|
|
|
|
2005-12-22 06:07:52 +00:00
|
|
|
} //End anonymous namespace
|
2005-04-21 21:13:18 +00:00
|
|
|
|
2010-10-13 21:49:58 +00:00
|
|
|
INITIALIZE_ANALYSIS_GROUP(CallGraph, "Call Graph", BasicCallGraph)
|
2010-07-21 23:07:00 +00:00
|
|
|
INITIALIZE_AG_PASS(BasicCallGraph, CallGraph, "basiccg",
|
2010-10-07 22:25:06 +00:00
|
|
|
"Basic CallGraph Construction", false, true, true)
|
2008-05-13 00:00:25 +00:00
|
|
|
|
2007-05-03 01:11:54 +00:00
|
|
|
char CallGraph::ID = 0;
|
|
|
|
char BasicCallGraph::ID = 0;
|
2007-05-02 20:37:47 +00:00
|
|
|
|
2005-12-22 06:07:52 +00:00
|
|
|
void CallGraph::initialize(Module &M) {
|
|
|
|
Mod = &M;
|
2001-09-28 00:08:15 +00:00
|
|
|
}
|
|
|
|
|
2002-03-06 17:16:43 +00:00
|
|
|
void CallGraph::destroy() {
|
2009-08-31 03:15:49 +00:00
|
|
|
if (FunctionMap.empty()) return;
|
|
|
|
|
2010-04-20 00:47:34 +00:00
|
|
|
// Reset all node's use counts to zero before deleting them to prevent an
|
|
|
|
// assertion from firing.
|
|
|
|
#ifndef NDEBUG
|
|
|
|
for (FunctionMapTy::iterator I = FunctionMap.begin(), E = FunctionMap.end();
|
|
|
|
I != E; ++I)
|
|
|
|
I->second->allReferencesDropped();
|
|
|
|
#endif
|
|
|
|
|
2009-08-31 03:15:49 +00:00
|
|
|
for (FunctionMapTy::iterator I = FunctionMap.begin(), E = FunctionMap.end();
|
|
|
|
I != E; ++I)
|
|
|
|
delete I->second;
|
|
|
|
FunctionMap.clear();
|
2001-09-28 00:08:15 +00:00
|
|
|
}
|
|
|
|
|
2009-08-23 06:03:38 +00:00
|
|
|
void CallGraph::print(raw_ostream &OS, Module*) const {
|
2002-11-04 00:21:19 +00:00
|
|
|
for (CallGraph::const_iterator I = begin(), E = end(); I != E; ++I)
|
2004-08-08 03:27:49 +00:00
|
|
|
I->second->print(OS);
|
|
|
|
}
|
2012-09-06 19:55:56 +00:00
|
|
|
#ifndef NDEBUG
|
2009-08-30 22:24:32 +00:00
|
|
|
void CallGraph::dump() const {
|
2009-12-23 20:03:58 +00:00
|
|
|
print(dbgs(), 0);
|
2009-08-30 22:24:32 +00:00
|
|
|
}
|
2012-09-06 19:55:56 +00:00
|
|
|
#endif
|
2004-08-08 03:27:49 +00:00
|
|
|
|
2001-11-26 18:51:25 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implementations of public modification methods
|
|
|
|
//
|
|
|
|
|
2002-07-18 04:43:16 +00:00
|
|
|
// removeFunctionFromModule - Unlink the function from this module, returning
|
|
|
|
// it. Because this removes the function from the module, the call graph node
|
|
|
|
// is destroyed. This is only valid if the function does not call any other
|
|
|
|
// functions (ie, there are no edges in it's CGN). The easiest way to do this
|
2001-11-26 18:51:25 +00:00
|
|
|
// is to dropAllReferences before calling this.
|
|
|
|
//
|
2002-07-18 04:43:16 +00:00
|
|
|
Function *CallGraph::removeFunctionFromModule(CallGraphNode *CGN) {
|
2009-08-31 02:24:20 +00:00
|
|
|
assert(CGN->empty() && "Cannot remove function from call "
|
2002-07-18 04:43:16 +00:00
|
|
|
"graph if it references other functions!");
|
2003-08-31 20:36:52 +00:00
|
|
|
Function *F = CGN->getFunction(); // Get the function for the call graph node
|
2002-07-18 04:43:16 +00:00
|
|
|
delete CGN; // Delete the call graph node for this func
|
2003-08-31 20:36:52 +00:00
|
|
|
FunctionMap.erase(F); // Remove the call graph node from the map
|
2001-11-26 18:51:25 +00:00
|
|
|
|
2003-08-31 20:36:52 +00:00
|
|
|
Mod->getFunctionList().remove(F);
|
|
|
|
return F;
|
2001-11-26 18:51:25 +00:00
|
|
|
}
|
|
|
|
|
2011-01-03 03:19:35 +00:00
|
|
|
/// spliceFunction - Replace the function represented by this node by another.
|
|
|
|
/// This does not rescan the body of the function, so it is suitable when
|
|
|
|
/// splicing the body of the old function to the new while also updating all
|
|
|
|
/// callers from old to new.
|
|
|
|
///
|
|
|
|
void CallGraph::spliceFunction(const Function *From, const Function *To) {
|
|
|
|
assert(FunctionMap.count(From) && "No CallGraphNode for function!");
|
|
|
|
assert(!FunctionMap.count(To) &&
|
|
|
|
"Pointing CallGraphNode at a function that already exists");
|
|
|
|
FunctionMapTy::iterator I = FunctionMap.find(From);
|
|
|
|
I->second->F = const_cast<Function*>(To);
|
|
|
|
FunctionMap[To] = I->second;
|
|
|
|
FunctionMap.erase(I);
|
|
|
|
}
|
|
|
|
|
2006-01-14 20:03:00 +00:00
|
|
|
// getOrInsertFunction - This method is identical to calling operator[], but
|
|
|
|
// it will insert a new CallGraphNode for the specified function if one does
|
|
|
|
// not already exist.
|
|
|
|
CallGraphNode *CallGraph::getOrInsertFunction(const Function *F) {
|
|
|
|
CallGraphNode *&CGN = FunctionMap[F];
|
|
|
|
if (CGN) return CGN;
|
|
|
|
|
|
|
|
assert((!F || F->getParent() == Mod) && "Function not in current module!");
|
|
|
|
return CGN = new CallGraphNode(const_cast<Function*>(F));
|
|
|
|
}
|
|
|
|
|
2009-08-23 06:03:38 +00:00
|
|
|
void CallGraphNode::print(raw_ostream &OS) const {
|
2005-12-22 06:07:52 +00:00
|
|
|
if (Function *F = getFunction())
|
2009-08-31 03:15:49 +00:00
|
|
|
OS << "Call graph node for function: '" << F->getName() << "'";
|
2005-12-22 06:07:52 +00:00
|
|
|
else
|
2009-08-31 03:15:49 +00:00
|
|
|
OS << "Call graph node <<null function>>";
|
|
|
|
|
2010-04-23 18:23:40 +00:00
|
|
|
OS << "<<" << this << ">> #uses=" << getNumReferences() << '\n';
|
2005-12-22 06:07:52 +00:00
|
|
|
|
2010-04-23 18:23:40 +00:00
|
|
|
for (const_iterator I = begin(), E = end(); I != E; ++I) {
|
|
|
|
OS << " CS<" << I->first << "> calls ";
|
2009-01-14 17:09:04 +00:00
|
|
|
if (Function *FI = I->second->getFunction())
|
2010-04-23 18:23:40 +00:00
|
|
|
OS << "function '" << FI->getName() <<"'\n";
|
|
|
|
else
|
|
|
|
OS << "external node\n";
|
|
|
|
}
|
|
|
|
OS << '\n';
|
2005-12-22 06:07:52 +00:00
|
|
|
}
|
|
|
|
|
2012-09-06 19:55:56 +00:00
|
|
|
#ifndef NDEBUG
|
2009-12-23 20:03:58 +00:00
|
|
|
void CallGraphNode::dump() const { print(dbgs()); }
|
2012-09-06 19:55:56 +00:00
|
|
|
#endif
|
2005-12-22 06:07:52 +00:00
|
|
|
|
2008-04-13 19:41:25 +00:00
|
|
|
/// 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 CallGraphNode::removeCallEdgeFor(CallSite CS) {
|
Step #1 to giving Callgraph some sane invariants. The problems with callgraph
stem from the fact that we have two types of passes that need to update it:
1. callgraphscc and module passes that are explicitly aware of it
2. Functionpasses (and loop passes etc) that are interlaced with CGSCC passes
by the CGSCC Passmgr.
In the case of #1, we can reasonably expect the passes to update the call
graph just like any analysis. However, functionpasses are not and generally
should not be CG aware. This has caused us no end of problems, so this takes
a new approach. Logically, the CGSCC Pass manager can rescan every function
after it runs a function pass over it to see if the functionpass made any
updates to the IR that affect the callgraph. This allows it to catch new calls
introduced by the functionpass.
In practice, doing this would be slow. This implementation keeps track of
whether or not the current scc is dirtied by a function pass, and, if so,
delays updating the callgraph until it is actually needed again. This was
we avoid extraneous rescans, but we still have good invariants when the
callgraph is needed.
Step #2 of the "give Callgraph some sane invariants" is to change CallGraphNode
to use a CallBackVH for the callsite entry of the CallGraphNode. This way
we can immediately remove entries from the callgraph when a FunctionPass is
active instead of having dangling pointers. The current pass tries to tolerate
these dangling pointers, but it is just an evil hack.
This is related to PR3601/4835/4029. This also reverts r80541, a hack working
around the sad lack of invariants.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@80566 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-31 07:23:46 +00:00
|
|
|
for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
|
|
|
|
assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
|
2009-09-01 06:31:31 +00:00
|
|
|
if (I->first == CS.getInstruction()) {
|
Step #1 to giving Callgraph some sane invariants. The problems with callgraph
stem from the fact that we have two types of passes that need to update it:
1. callgraphscc and module passes that are explicitly aware of it
2. Functionpasses (and loop passes etc) that are interlaced with CGSCC passes
by the CGSCC Passmgr.
In the case of #1, we can reasonably expect the passes to update the call
graph just like any analysis. However, functionpasses are not and generally
should not be CG aware. This has caused us no end of problems, so this takes
a new approach. Logically, the CGSCC Pass manager can rescan every function
after it runs a function pass over it to see if the functionpass made any
updates to the IR that affect the callgraph. This allows it to catch new calls
introduced by the functionpass.
In practice, doing this would be slow. This implementation keeps track of
whether or not the current scc is dirtied by a function pass, and, if so,
delays updating the callgraph until it is actually needed again. This was
we avoid extraneous rescans, but we still have good invariants when the
callgraph is needed.
Step #2 of the "give Callgraph some sane invariants" is to change CallGraphNode
to use a CallBackVH for the callsite entry of the CallGraphNode. This way
we can immediately remove entries from the callgraph when a FunctionPass is
active instead of having dangling pointers. The current pass tries to tolerate
these dangling pointers, but it is just an evil hack.
This is related to PR3601/4835/4029. This also reverts r80541, a hack working
around the sad lack of invariants.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@80566 91177308-0d34-0410-b5e6-96231b3b80d8
2009-08-31 07:23:46 +00:00
|
|
|
I->second->DropRef();
|
|
|
|
*I = CalledFunctions.back();
|
|
|
|
CalledFunctions.pop_back();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-18 21:34:34 +00:00
|
|
|
// removeAnyCallEdgeTo - This method removes any 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 CallGraphNode::removeAnyCallEdgeTo(CallGraphNode *Callee) {
|
2004-09-19 19:01:06 +00:00
|
|
|
for (unsigned i = 0, e = CalledFunctions.size(); i != e; ++i)
|
2006-07-12 18:29:36 +00:00
|
|
|
if (CalledFunctions[i].second == Callee) {
|
2009-08-31 03:15:49 +00:00
|
|
|
Callee->DropRef();
|
2004-09-19 19:01:06 +00:00
|
|
|
CalledFunctions[i] = CalledFunctions.back();
|
|
|
|
CalledFunctions.pop_back();
|
|
|
|
--i; --e;
|
2004-09-18 21:34:34 +00:00
|
|
|
}
|
|
|
|
}
|
2006-06-07 22:00:26 +00:00
|
|
|
|
2008-10-03 07:36:09 +00:00
|
|
|
/// removeOneAbstractEdgeTo - Remove one edge associated with a null callsite
|
|
|
|
/// from this node to the specified callee function.
|
|
|
|
void CallGraphNode::removeOneAbstractEdgeTo(CallGraphNode *Callee) {
|
2009-01-17 19:46:01 +00:00
|
|
|
for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
|
|
|
|
assert(I != CalledFunctions.end() && "Cannot find callee to remove!");
|
|
|
|
CallRecord &CR = *I;
|
2009-09-01 06:31:31 +00:00
|
|
|
if (CR.second == Callee && CR.first == 0) {
|
2009-08-31 03:15:49 +00:00
|
|
|
Callee->DropRef();
|
|
|
|
*I = CalledFunctions.back();
|
|
|
|
CalledFunctions.pop_back();
|
2008-10-03 07:36:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-15 05:40:35 +00:00
|
|
|
/// replaceCallEdge - This method replaces the edge in the node for the
|
|
|
|
/// specified call site with a new one. Note that this method takes linear
|
|
|
|
/// time, so it should be used sparingly.
|
|
|
|
void CallGraphNode::replaceCallEdge(CallSite CS,
|
|
|
|
CallSite NewCS, CallGraphNode *NewNode){
|
|
|
|
for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
|
|
|
|
assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
|
|
|
|
if (I->first == CS.getInstruction()) {
|
|
|
|
I->second->DropRef();
|
|
|
|
I->first = NewCS.getInstruction();
|
|
|
|
I->second = NewNode;
|
|
|
|
NewNode->AddRef();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-06-07 22:00:26 +00:00
|
|
|
// Enuse that users of CallGraph.h also link with this file
|
|
|
|
DEFINING_FILE_FOR(CallGraph)
|