2002-03-07 02:00:49 +08:00
|
|
|
//===- CallGraph.cpp - Build a Module's call graph ------------------------===//
|
2005-04-22 05:13:18 +08:00
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2005-04-22 05:13:18 +08:00
|
|
|
//
|
2003-10-21 03:43:21 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-09-28 08:08:15 +08:00
|
|
|
|
|
|
|
#include "llvm/Analysis/CallGraph.h"
|
2017-07-25 07:16:33 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2018-04-30 22:59:11 +08:00
|
|
|
#include "llvm/Config/llvm-config.h"
|
2017-07-25 07:16:33 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/Intrinsics.h"
|
Sink all InitializePasses.h includes
This file lists every pass in LLVM, and is included by Pass.h, which is
very popular. Every time we add, remove, or rename a pass in LLVM, it
caused lots of recompilation.
I found this fact by looking at this table, which is sorted by the
number of times a file was changed over the last 100,000 git commits
multiplied by the number of object files that depend on it in the
current checkout:
recompiles touches affected_files header
342380 95 3604 llvm/include/llvm/ADT/STLExtras.h
314730 234 1345 llvm/include/llvm/InitializePasses.h
307036 118 2602 llvm/include/llvm/ADT/APInt.h
213049 59 3611 llvm/include/llvm/Support/MathExtras.h
170422 47 3626 llvm/include/llvm/Support/Compiler.h
162225 45 3605 llvm/include/llvm/ADT/Optional.h
158319 63 2513 llvm/include/llvm/ADT/Triple.h
140322 39 3598 llvm/include/llvm/ADT/StringRef.h
137647 59 2333 llvm/include/llvm/Support/Error.h
131619 73 1803 llvm/include/llvm/Support/FileSystem.h
Before this change, touching InitializePasses.h would cause 1345 files
to recompile. After this change, touching it only causes 550 compiles in
an incremental rebuild.
Reviewers: bkramer, asbirlea, bollu, jdoerfert
Differential Revision: https://reviews.llvm.org/D70211
2019-11-14 05:15:01 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2017-07-25 07:16:33 +08:00
|
|
|
#include "llvm/IR/PassManager.h"
|
Sink all InitializePasses.h includes
This file lists every pass in LLVM, and is included by Pass.h, which is
very popular. Every time we add, remove, or rename a pass in LLVM, it
caused lots of recompilation.
I found this fact by looking at this table, which is sorted by the
number of times a file was changed over the last 100,000 git commits
multiplied by the number of object files that depend on it in the
current checkout:
recompiles touches affected_files header
342380 95 3604 llvm/include/llvm/ADT/STLExtras.h
314730 234 1345 llvm/include/llvm/InitializePasses.h
307036 118 2602 llvm/include/llvm/ADT/APInt.h
213049 59 3611 llvm/include/llvm/Support/MathExtras.h
170422 47 3626 llvm/include/llvm/Support/Compiler.h
162225 45 3605 llvm/include/llvm/ADT/Optional.h
158319 63 2513 llvm/include/llvm/ADT/Triple.h
140322 39 3598 llvm/include/llvm/ADT/StringRef.h
137647 59 2333 llvm/include/llvm/Support/Error.h
131619 73 1803 llvm/include/llvm/Support/FileSystem.h
Before this change, touching InitializePasses.h would cause 1345 files
to recompile. After this change, touching it only causes 550 compiles in
an incremental rebuild.
Reviewers: bkramer, asbirlea, bollu, jdoerfert
Differential Revision: https://reviews.llvm.org/D70211
2019-11-14 05:15:01 +08:00
|
|
|
#include "llvm/InitializePasses.h"
|
2017-07-25 07:16:33 +08:00
|
|
|
#include "llvm/Pass.h"
|
|
|
|
#include "llvm/Support/Compiler.h"
|
2009-12-24 04:03:58 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-08-23 14:03:38 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2017-07-25 07:16:33 +08:00
|
|
|
#include <algorithm>
|
|
|
|
#include <cassert>
|
|
|
|
|
2004-04-12 13:36:32 +08:00
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2013-11-26 12:19:30 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implementations of the CallGraph class methods.
|
|
|
|
//
|
|
|
|
|
|
|
|
CallGraph::CallGraph(Module &M)
|
2017-05-12 07:59:05 +08:00
|
|
|
: M(M), ExternalCallingNode(getOrInsertFunction(nullptr)),
|
2019-08-15 23:54:37 +08:00
|
|
|
CallsExternalNode(std::make_unique<CallGraphNode>(nullptr)) {
|
2013-11-26 12:19:30 +08:00
|
|
|
// Add every function to the call graph.
|
2015-06-12 13:15:27 +08:00
|
|
|
for (Function &F : M)
|
|
|
|
addToCallGraph(&F);
|
2013-11-26 12:19:30 +08:00
|
|
|
}
|
|
|
|
|
2015-08-16 14:35:19 +08:00
|
|
|
CallGraph::CallGraph(CallGraph &&Arg)
|
2017-05-12 07:59:05 +08:00
|
|
|
: M(Arg.M), FunctionMap(std::move(Arg.FunctionMap)),
|
2015-08-16 14:35:19 +08:00
|
|
|
ExternalCallingNode(Arg.ExternalCallingNode),
|
|
|
|
CallsExternalNode(std::move(Arg.CallsExternalNode)) {
|
|
|
|
Arg.FunctionMap.clear();
|
|
|
|
Arg.ExternalCallingNode = nullptr;
|
|
|
|
}
|
|
|
|
|
2013-11-26 12:19:30 +08:00
|
|
|
CallGraph::~CallGraph() {
|
|
|
|
// CallsExternalNode is not in the function map, delete it explicitly.
|
2015-08-06 04:55:50 +08:00
|
|
|
if (CallsExternalNode)
|
|
|
|
CallsExternalNode->allReferencesDropped();
|
2013-11-26 12:19:30 +08:00
|
|
|
|
|
|
|
// Reset all node's use counts to zero before deleting them to prevent an
|
|
|
|
// assertion from firing.
|
|
|
|
#ifndef NDEBUG
|
2015-06-12 13:15:27 +08:00
|
|
|
for (auto &I : FunctionMap)
|
|
|
|
I.second->allReferencesDropped();
|
2013-11-26 12:19:30 +08:00
|
|
|
#endif
|
2013-10-31 11:03:55 +08:00
|
|
|
}
|
2005-12-22 14:07:52 +08:00
|
|
|
|
2020-01-16 06:05:56 +08:00
|
|
|
bool CallGraph::invalidate(Module &, const PreservedAnalyses &PA,
|
|
|
|
ModuleAnalysisManager::Invalidator &) {
|
|
|
|
// Check whether the analysis, all analyses on functions, or the function's
|
|
|
|
// CFG have been preserved.
|
|
|
|
auto PAC = PA.getChecker<CallGraphAnalysis>();
|
|
|
|
return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Module>>() ||
|
|
|
|
PAC.preservedSet<CFGAnalyses>());
|
|
|
|
}
|
|
|
|
|
2013-10-31 11:03:55 +08:00
|
|
|
void CallGraph::addToCallGraph(Function *F) {
|
|
|
|
CallGraphNode *Node = getOrInsertFunction(F);
|
2005-12-22 14:07:52 +08:00
|
|
|
|
2017-05-12 07:59:05 +08:00
|
|
|
// If this function has external linkage or has its address taken, anything
|
|
|
|
// could call it.
|
|
|
|
if (!F->hasLocalLinkage() || F->hasAddressTaken())
|
2019-04-19 13:59:42 +08:00
|
|
|
ExternalCallingNode->addCalledFunction(nullptr, Node);
|
2013-10-31 11:03:55 +08:00
|
|
|
|
2019-11-30 03:11:24 +08:00
|
|
|
populateCallGraphNode(Node);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CallGraph::populateCallGraphNode(CallGraphNode *Node) {
|
|
|
|
Function *F = Node->getFunction();
|
|
|
|
|
2013-10-31 11:03:55 +08:00
|
|
|
// If this function is not defined in this translation unit, it could call
|
|
|
|
// anything.
|
|
|
|
if (F->isDeclaration() && !F->isIntrinsic())
|
2019-04-19 13:59:42 +08:00
|
|
|
Node->addCalledFunction(nullptr, CallsExternalNode.get());
|
2013-10-31 11:03:55 +08:00
|
|
|
|
|
|
|
// Look for calls by this function.
|
2016-06-27 01:27:42 +08:00
|
|
|
for (BasicBlock &BB : *F)
|
|
|
|
for (Instruction &I : BB) {
|
2019-04-19 13:59:42 +08:00
|
|
|
if (auto *Call = dyn_cast<CallBase>(&I)) {
|
|
|
|
const Function *Callee = Call->getCalledFunction();
|
2019-08-16 18:59:18 +08:00
|
|
|
if (!Callee || !Intrinsic::isLeaf(Callee->getIntrinsicID()))
|
2013-10-31 11:03:55 +08:00
|
|
|
// Indirect calls of intrinsics are not allowed so no need to check.
|
2015-06-19 03:28:26 +08:00
|
|
|
// We can be more precise here by using TargetArg returned by
|
|
|
|
// Intrinsic::isLeaf.
|
2019-04-19 13:59:42 +08:00
|
|
|
Node->addCalledFunction(Call, CallsExternalNode.get());
|
2013-10-31 11:03:55 +08:00
|
|
|
else if (!Callee->isIntrinsic())
|
2019-04-19 13:59:42 +08:00
|
|
|
Node->addCalledFunction(Call, getOrInsertFunction(Callee));
|
2005-12-22 14:07:52 +08:00
|
|
|
}
|
|
|
|
}
|
2013-10-31 11:03:55 +08:00
|
|
|
}
|
2005-12-22 14:07:52 +08:00
|
|
|
|
2013-11-26 12:19:30 +08:00
|
|
|
void CallGraph::print(raw_ostream &OS) const {
|
2015-06-20 07:20:31 +08:00
|
|
|
// Print in a deterministic order by sorting CallGraphNodes by name. We do
|
|
|
|
// this here to avoid slowing down the non-printing fast path.
|
|
|
|
|
|
|
|
SmallVector<CallGraphNode *, 16> Nodes;
|
|
|
|
Nodes.reserve(FunctionMap.size());
|
|
|
|
|
2016-06-27 01:27:42 +08:00
|
|
|
for (const auto &I : *this)
|
|
|
|
Nodes.push_back(I.second.get());
|
2015-06-20 07:20:31 +08:00
|
|
|
|
llvm::sort(C.begin(), C.end(), ...) -> llvm::sort(C, ...)
Summary: The convenience wrapper in STLExtras is available since rL342102.
Reviewers: dblaikie, javed.absar, JDevlieghere, andreadb
Subscribers: MatzeB, sanjoy, arsenm, dschuff, mehdi_amini, sdardis, nemanjai, jvesely, nhaehnle, sbc100, jgravelle-google, eraman, aheejin, kbarton, JDevlieghere, javed.absar, gbedwell, jrtc27, mgrang, atanasyan, steven_wu, george.burgess.iv, dexonsmith, kristina, jsji, llvm-commits
Differential Revision: https://reviews.llvm.org/D52573
llvm-svn: 343163
2018-09-27 10:13:45 +08:00
|
|
|
llvm::sort(Nodes, [](CallGraphNode *LHS, CallGraphNode *RHS) {
|
2015-06-20 07:20:31 +08:00
|
|
|
if (Function *LF = LHS->getFunction())
|
|
|
|
if (Function *RF = RHS->getFunction())
|
|
|
|
return LF->getName() < RF->getName();
|
|
|
|
|
|
|
|
return RHS->getFunction() != nullptr;
|
|
|
|
});
|
|
|
|
|
|
|
|
for (CallGraphNode *CN : Nodes)
|
|
|
|
CN->print(OS);
|
2004-08-08 11:27:49 +08:00
|
|
|
}
|
2013-11-26 12:19:30 +08:00
|
|
|
|
2017-10-15 22:32:27 +08:00
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
2017-01-28 10:02:38 +08:00
|
|
|
LLVM_DUMP_METHOD void CallGraph::dump() const { print(dbgs()); }
|
|
|
|
#endif
|
2004-08-08 11:27:49 +08:00
|
|
|
|
2002-07-18 12:43:16 +08: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-27 02:51:25 +08:00
|
|
|
// is to dropAllReferences before calling this.
|
|
|
|
//
|
2002-07-18 12:43:16 +08:00
|
|
|
Function *CallGraph::removeFunctionFromModule(CallGraphNode *CGN) {
|
2009-08-31 10:24:20 +08:00
|
|
|
assert(CGN->empty() && "Cannot remove function from call "
|
2002-07-18 12:43:16 +08:00
|
|
|
"graph if it references other functions!");
|
2003-09-01 04:36:52 +08:00
|
|
|
Function *F = CGN->getFunction(); // Get the function for the call graph node
|
|
|
|
FunctionMap.erase(F); // Remove the call graph node from the map
|
2001-11-27 02:51:25 +08:00
|
|
|
|
2013-11-26 12:19:30 +08:00
|
|
|
M.getFunctionList().remove(F);
|
2003-09-01 04:36:52 +08:00
|
|
|
return F;
|
2001-11-27 02:51:25 +08:00
|
|
|
}
|
|
|
|
|
2011-01-03 11:19:35 +08: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);
|
2015-08-06 04:55:50 +08:00
|
|
|
FunctionMap[To] = std::move(I->second);
|
2011-01-03 11:19:35 +08:00
|
|
|
FunctionMap.erase(I);
|
|
|
|
}
|
|
|
|
|
2006-01-15 04:03:00 +08: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) {
|
2015-08-06 04:55:50 +08:00
|
|
|
auto &CGN = FunctionMap[F];
|
2013-11-26 12:19:30 +08:00
|
|
|
if (CGN)
|
2015-08-06 04:55:50 +08:00
|
|
|
return CGN.get();
|
2013-11-26 12:19:30 +08:00
|
|
|
|
|
|
|
assert((!F || F->getParent() == &M) && "Function not in current module!");
|
2019-08-15 23:54:37 +08:00
|
|
|
CGN = std::make_unique<CallGraphNode>(const_cast<Function *>(F));
|
2015-08-06 04:55:50 +08:00
|
|
|
return CGN.get();
|
2006-01-15 04:03:00 +08:00
|
|
|
}
|
|
|
|
|
2013-11-26 12:19:30 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implementations of the CallGraphNode class methods.
|
|
|
|
//
|
|
|
|
|
2009-08-23 14:03:38 +08:00
|
|
|
void CallGraphNode::print(raw_ostream &OS) const {
|
2005-12-22 14:07:52 +08:00
|
|
|
if (Function *F = getFunction())
|
2009-08-31 11:15:49 +08:00
|
|
|
OS << "Call graph node for function: '" << F->getName() << "'";
|
2005-12-22 14:07:52 +08:00
|
|
|
else
|
2009-08-31 11:15:49 +08:00
|
|
|
OS << "Call graph node <<null function>>";
|
2018-07-31 03:41:25 +08:00
|
|
|
|
2010-04-24 02:23:40 +08:00
|
|
|
OS << "<<" << this << ">> #uses=" << getNumReferences() << '\n';
|
2005-12-22 14:07:52 +08:00
|
|
|
|
2016-06-27 01:27:42 +08:00
|
|
|
for (const auto &I : *this) {
|
|
|
|
OS << " CS<" << I.first << "> calls ";
|
|
|
|
if (Function *FI = I.second->getFunction())
|
2010-04-24 02:23:40 +08:00
|
|
|
OS << "function '" << FI->getName() <<"'\n";
|
|
|
|
else
|
2019-08-16 18:59:18 +08:00
|
|
|
OS << "external node\n";
|
2010-04-24 02:23:40 +08:00
|
|
|
}
|
|
|
|
OS << '\n';
|
2005-12-22 14:07:52 +08:00
|
|
|
}
|
|
|
|
|
2017-10-15 22:32:27 +08:00
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
2017-01-28 10:02:38 +08:00
|
|
|
LLVM_DUMP_METHOD void CallGraphNode::dump() const { print(dbgs()); }
|
|
|
|
#endif
|
2005-12-22 14:07:52 +08:00
|
|
|
|
2008-04-14 03:41:25 +08: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.
|
2019-04-19 13:59:42 +08:00
|
|
|
void CallGraphNode::removeCallEdgeFor(CallBase &Call) {
|
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.
llvm-svn: 80566
2009-08-31 15:23:46 +08:00
|
|
|
for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
|
|
|
|
assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
|
2019-04-19 13:59:42 +08:00
|
|
|
if (I->first == &Call) {
|
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.
llvm-svn: 80566
2009-08-31 15:23:46 +08:00
|
|
|
I->second->DropRef();
|
|
|
|
*I = CalledFunctions.back();
|
|
|
|
CalledFunctions.pop_back();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-09-19 05:34:34 +08: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-20 03:01:06 +08:00
|
|
|
for (unsigned i = 0, e = CalledFunctions.size(); i != e; ++i)
|
2006-07-13 02:29:36 +08:00
|
|
|
if (CalledFunctions[i].second == Callee) {
|
2009-08-31 11:15:49 +08:00
|
|
|
Callee->DropRef();
|
2004-09-20 03:01:06 +08:00
|
|
|
CalledFunctions[i] = CalledFunctions.back();
|
|
|
|
CalledFunctions.pop_back();
|
|
|
|
--i; --e;
|
2004-09-19 05:34:34 +08:00
|
|
|
}
|
|
|
|
}
|
2006-06-08 06:00:26 +08:00
|
|
|
|
2008-10-03 15:36:09 +08: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-18 03:46:01 +08:00
|
|
|
for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
|
|
|
|
assert(I != CalledFunctions.end() && "Cannot find callee to remove!");
|
|
|
|
CallRecord &CR = *I;
|
2014-04-24 14:44:33 +08:00
|
|
|
if (CR.second == Callee && CR.first == nullptr) {
|
2009-08-31 11:15:49 +08:00
|
|
|
Callee->DropRef();
|
|
|
|
*I = CalledFunctions.back();
|
|
|
|
CalledFunctions.pop_back();
|
2008-10-03 15:36:09 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-09-15 13:40:35 +08: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.
|
2019-04-19 13:59:42 +08:00
|
|
|
void CallGraphNode::replaceCallEdge(CallBase &Call, CallBase &NewCall,
|
|
|
|
CallGraphNode *NewNode) {
|
2009-09-15 13:40:35 +08:00
|
|
|
for (CalledFunctionsVector::iterator I = CalledFunctions.begin(); ; ++I) {
|
|
|
|
assert(I != CalledFunctions.end() && "Cannot find callsite to remove!");
|
2019-04-19 13:59:42 +08:00
|
|
|
if (I->first == &Call) {
|
2009-09-15 13:40:35 +08:00
|
|
|
I->second->DropRef();
|
2019-04-19 13:59:42 +08:00
|
|
|
I->first = &NewCall;
|
2009-09-15 13:40:35 +08:00
|
|
|
I->second = NewNode;
|
|
|
|
NewNode->AddRef();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-10 22:33:10 +08:00
|
|
|
// Provide an explicit template instantiation for the static ID.
|
2016-11-24 01:53:26 +08:00
|
|
|
AnalysisKey CallGraphAnalysis::Key;
|
2016-03-10 22:33:10 +08:00
|
|
|
|
2016-03-10 19:24:11 +08:00
|
|
|
PreservedAnalyses CallGraphPrinterPass::run(Module &M,
|
2016-08-09 08:28:38 +08:00
|
|
|
ModuleAnalysisManager &AM) {
|
2016-03-11 19:05:24 +08:00
|
|
|
AM.getResult<CallGraphAnalysis>(M).print(OS);
|
2016-03-10 19:24:11 +08:00
|
|
|
return PreservedAnalyses::all();
|
|
|
|
}
|
|
|
|
|
2015-08-16 14:35:19 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Out-of-line definitions of CallGraphAnalysis class members.
|
|
|
|
//
|
|
|
|
|
2013-11-26 12:19:30 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implementations of the CallGraphWrapperPass class methods.
|
|
|
|
//
|
|
|
|
|
|
|
|
CallGraphWrapperPass::CallGraphWrapperPass() : ModulePass(ID) {
|
|
|
|
initializeCallGraphWrapperPassPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
2017-07-25 07:16:33 +08:00
|
|
|
CallGraphWrapperPass::~CallGraphWrapperPass() = default;
|
2013-11-26 12:19:30 +08:00
|
|
|
|
|
|
|
void CallGraphWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CallGraphWrapperPass::runOnModule(Module &M) {
|
|
|
|
// All the real work is done in the constructor for the CallGraph.
|
|
|
|
G.reset(new CallGraph(M));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
INITIALIZE_PASS(CallGraphWrapperPass, "basiccg", "CallGraph Construction",
|
|
|
|
false, true)
|
|
|
|
|
|
|
|
char CallGraphWrapperPass::ID = 0;
|
|
|
|
|
2014-07-19 09:05:11 +08:00
|
|
|
void CallGraphWrapperPass::releaseMemory() { G.reset(); }
|
2013-11-26 12:19:30 +08:00
|
|
|
|
|
|
|
void CallGraphWrapperPass::print(raw_ostream &OS, const Module *) const {
|
|
|
|
if (!G) {
|
|
|
|
OS << "No call graph has been built!\n";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Just delegate.
|
|
|
|
G->print(OS);
|
|
|
|
}
|
|
|
|
|
2017-10-15 22:32:27 +08:00
|
|
|
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
|
2015-11-23 10:58:42 +08:00
|
|
|
LLVM_DUMP_METHOD
|
2014-04-28 12:05:08 +08:00
|
|
|
void CallGraphWrapperPass::dump() const { print(dbgs(), nullptr); }
|
2017-01-28 10:02:38 +08:00
|
|
|
#endif
|
2016-03-10 19:08:44 +08:00
|
|
|
|
|
|
|
namespace {
|
2017-07-25 07:16:33 +08:00
|
|
|
|
2016-03-10 19:08:44 +08:00
|
|
|
struct CallGraphPrinterLegacyPass : public ModulePass {
|
|
|
|
static char ID; // Pass ID, replacement for typeid
|
2017-07-25 07:16:33 +08:00
|
|
|
|
2016-03-10 19:08:44 +08:00
|
|
|
CallGraphPrinterLegacyPass() : ModulePass(ID) {
|
|
|
|
initializeCallGraphPrinterLegacyPassPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
|
|
AU.setPreservesAll();
|
|
|
|
AU.addRequiredTransitive<CallGraphWrapperPass>();
|
|
|
|
}
|
2017-07-25 07:16:33 +08:00
|
|
|
|
2016-03-10 19:08:44 +08:00
|
|
|
bool runOnModule(Module &M) override {
|
|
|
|
getAnalysis<CallGraphWrapperPass>().print(errs(), &M);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
};
|
2017-07-25 07:16:33 +08:00
|
|
|
|
|
|
|
} // end anonymous namespace
|
2016-03-10 19:08:44 +08:00
|
|
|
|
|
|
|
char CallGraphPrinterLegacyPass::ID = 0;
|
|
|
|
|
|
|
|
INITIALIZE_PASS_BEGIN(CallGraphPrinterLegacyPass, "print-callgraph",
|
|
|
|
"Print a call graph", true, true)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(CallGraphWrapperPass)
|
|
|
|
INITIALIZE_PASS_END(CallGraphPrinterLegacyPass, "print-callgraph",
|
|
|
|
"Print a call graph", true, true)
|