LLVM  15.0.0git
CallPrinter.cpp
Go to the documentation of this file.
1 //===- CallPrinter.cpp - DOT printer for call graph -----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines '-dot-callgraph', which emit a callgraph.<fnname>.dot
10 // containing the call graph of a module.
11 //
12 // There is also a pass available to directly call dotty ('-view-callgraph').
13 //
14 //===----------------------------------------------------------------------===//
15 
17 #include "llvm/ADT/DenseMap.h"
18 #include "llvm/ADT/SmallSet.h"
22 #include "llvm/IR/Instructions.h"
23 #include "llvm/InitializePasses.h"
27 
28 using namespace llvm;
29 
30 namespace llvm {
31 template <class GraphType> struct GraphTraits;
32 }
33 
34 // This option shows static (relative) call counts.
35 // FIXME:
36 // Need to show real counts when profile data is available
37 static cl::opt<bool> ShowHeatColors("callgraph-heat-colors", cl::init(false),
38  cl::Hidden,
39  cl::desc("Show heat colors in call-graph"));
40 
41 static cl::opt<bool>
42  ShowEdgeWeight("callgraph-show-weights", cl::init(false), cl::Hidden,
43  cl::desc("Show edges labeled with weights"));
44 
45 static cl::opt<bool>
46  CallMultiGraph("callgraph-multigraph", cl::init(false), cl::Hidden,
47  cl::desc("Show call-multigraph (do not remove parallel edges)"));
48 
50  "callgraph-dot-filename-prefix", cl::Hidden,
51  cl::desc("The prefix used for the CallGraph dot file names."));
52 
53 namespace llvm {
54 
56 private:
57  Module *M;
58  CallGraph *CG;
60  uint64_t MaxFreq;
61 
62 public:
64 
67  : M(M), CG(CG), LookupBFI(LookupBFI) {
68  MaxFreq = 0;
69 
70  for (Function &F : M->getFunctionList()) {
71  uint64_t localSumFreq = 0;
73  for (User *U : F.users())
74  if (isa<CallInst>(U))
75  Callers.insert(cast<Instruction>(U)->getFunction());
76  for (Function *Caller : Callers)
77  localSumFreq += getNumOfCalls(*Caller, F);
78  if (localSumFreq >= MaxFreq)
79  MaxFreq = localSumFreq;
80  Freq[&F] = localSumFreq;
81  }
82  if (!CallMultiGraph)
83  removeParallelEdges();
84  }
85 
86  Module *getModule() const { return M; }
87 
88  CallGraph *getCallGraph() const { return CG; }
89 
90  uint64_t getFreq(const Function *F) { return Freq[F]; }
91 
92  uint64_t getMaxFreq() { return MaxFreq; }
93 
94 private:
95  void removeParallelEdges() {
96  for (auto &I : (*CG)) {
97  CallGraphNode *Node = I.second.get();
98 
99  bool FoundParallelEdge = true;
100  while (FoundParallelEdge) {
101  SmallSet<Function *, 16> Visited;
102  FoundParallelEdge = false;
103  for (auto CI = Node->begin(), CE = Node->end(); CI != CE; CI++) {
104  if (!(Visited.insert(CI->second->getFunction())).second) {
105  FoundParallelEdge = true;
106  Node->removeCallEdge(CI);
107  break;
108  }
109  }
110  }
111  }
112  }
113 };
114 
115 template <>
119  // Start at the external node!
120  return CGInfo->getCallGraph()->getExternalCallingNode();
121  }
122 
123  typedef std::pair<const Function *const, std::unique_ptr<CallGraphNode>>
125  static const CallGraphNode *CGGetValuePtr(const PairTy &P) {
126  return P.second.get();
127  }
128 
129  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
130  typedef mapped_iterator<CallGraph::const_iterator, decltype(&CGGetValuePtr)>
132 
134  return nodes_iterator(CGInfo->getCallGraph()->begin(), &CGGetValuePtr);
135  }
137  return nodes_iterator(CGInfo->getCallGraph()->end(), &CGGetValuePtr);
138  }
139 };
140 
141 template <>
143 
145 
146  static std::string getGraphName(CallGraphDOTInfo *CGInfo) {
147  return "Call graph: " +
148  std::string(CGInfo->getModule()->getModuleIdentifier());
149  }
150 
151  static bool isNodeHidden(const CallGraphNode *Node,
152  const CallGraphDOTInfo *CGInfo) {
153  if (CallMultiGraph || Node->getFunction())
154  return false;
155  return true;
156  }
157 
158  std::string getNodeLabel(const CallGraphNode *Node,
159  CallGraphDOTInfo *CGInfo) {
160  if (Node == CGInfo->getCallGraph()->getExternalCallingNode())
161  return "external caller";
162  if (Node == CGInfo->getCallGraph()->getCallsExternalNode())
163  return "external callee";
164 
165  if (Function *Func = Node->getFunction())
166  return std::string(Func->getName());
167  return "external node";
168  }
170  return P.second;
171  }
172 
173  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
175  decltype(&CGGetValuePtr)>
177 
179  CallGraphDOTInfo *CGInfo) {
180  if (!ShowEdgeWeight)
181  return "";
182 
183  Function *Caller = Node->getFunction();
184  if (Caller == nullptr || Caller->isDeclaration())
185  return "";
186 
187  Function *Callee = (*I)->getFunction();
188  if (Callee == nullptr)
189  return "";
190 
191  uint64_t Counter = getNumOfCalls(*Caller, *Callee);
192  double Width =
193  1 + 2 * (double(Counter) / CGInfo->getMaxFreq());
194  std::string Attrs = "label=\"" + std::to_string(Counter) +
195  "\" penwidth=" + std::to_string(Width);
196  return Attrs;
197  }
198 
199  std::string getNodeAttributes(const CallGraphNode *Node,
200  CallGraphDOTInfo *CGInfo) {
201  Function *F = Node->getFunction();
202  if (F == nullptr)
203  return "";
204  std::string attrs;
205  if (ShowHeatColors) {
206  uint64_t freq = CGInfo->getFreq(F);
207  std::string color = getHeatColor(freq, CGInfo->getMaxFreq());
208  std::string edgeColor = (freq <= (CGInfo->getMaxFreq() / 2))
209  ? getHeatColor(0)
210  : getHeatColor(1);
211  attrs = "color=\"" + edgeColor + "ff\", style=filled, fillcolor=\"" +
212  color + "80\"";
213  }
214  return attrs;
215  }
216 };
217 
218 } // end llvm namespace
219 
220 namespace {
221 void doCallGraphDOTPrinting(
222  Module &M, function_ref<BlockFrequencyInfo *(Function &)> LookupBFI) {
223  std::string Filename;
224  if (!CallGraphDotFilenamePrefix.empty())
225  Filename = (CallGraphDotFilenamePrefix + ".callgraph.dot");
226  else
227  Filename = (std::string(M.getModuleIdentifier()) + ".callgraph.dot");
228  errs() << "Writing '" << Filename << "'...";
229 
230  std::error_code EC;
231  raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
232 
233  CallGraph CG(M);
234  CallGraphDOTInfo CFGInfo(&M, &CG, LookupBFI);
235 
236  if (!EC)
237  WriteGraph(File, &CFGInfo);
238  else
239  errs() << " error opening file for writing!";
240  errs() << "\n";
241 }
242 
243 void viewCallGraph(Module &M,
244  function_ref<BlockFrequencyInfo *(Function &)> LookupBFI) {
245  CallGraph CG(M);
246  CallGraphDOTInfo CFGInfo(&M, &CG, LookupBFI);
247 
248  std::string Title =
250  ViewGraph(&CFGInfo, "callgraph", true, Title);
251 }
252 } // namespace
253 
254 namespace llvm {
256  ModuleAnalysisManager &AM) {
259 
260  auto LookupBFI = [&FAM](Function &F) {
262  };
263 
264  doCallGraphDOTPrinting(M, LookupBFI);
265 
266  return PreservedAnalyses::all();
267 }
268 
270  ModuleAnalysisManager &AM) {
271 
274 
275  auto LookupBFI = [&FAM](Function &F) {
277  };
278 
279  viewCallGraph(M, LookupBFI);
280 
281  return PreservedAnalyses::all();
282 }
283 } // namespace llvm
284 
285 namespace {
286 // Viewer
287 class CallGraphViewer : public ModulePass {
288 public:
289  static char ID;
290  CallGraphViewer() : ModulePass(ID) {}
291 
292  void getAnalysisUsage(AnalysisUsage &AU) const override;
293  bool runOnModule(Module &M) override;
294 };
295 
296 void CallGraphViewer::getAnalysisUsage(AnalysisUsage &AU) const {
297  ModulePass::getAnalysisUsage(AU);
299  AU.setPreservesAll();
300 }
301 
302 bool CallGraphViewer::runOnModule(Module &M) {
303  auto LookupBFI = [this](Function &F) {
304  return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
305  };
306 
307  viewCallGraph(M, LookupBFI);
308 
309  return false;
310 }
311 
312 // DOT Printer
313 
314 class CallGraphDOTPrinter : public ModulePass {
315 public:
316  static char ID;
317  CallGraphDOTPrinter() : ModulePass(ID) {}
318 
319  void getAnalysisUsage(AnalysisUsage &AU) const override;
320  bool runOnModule(Module &M) override;
321 };
322 
323 void CallGraphDOTPrinter::getAnalysisUsage(AnalysisUsage &AU) const {
324  ModulePass::getAnalysisUsage(AU);
326  AU.setPreservesAll();
327 }
328 
329 bool CallGraphDOTPrinter::runOnModule(Module &M) {
330  auto LookupBFI = [this](Function &F) {
331  return &this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
332  };
333 
334  doCallGraphDOTPrinting(M, LookupBFI);
335 
336  return false;
337 }
338 
339 } // end anonymous namespace
340 
341 char CallGraphViewer::ID = 0;
342 INITIALIZE_PASS(CallGraphViewer, "view-callgraph", "View call graph", false,
343  false)
344 
345 char CallGraphDOTPrinter::ID = 0;
346 INITIALIZE_PASS(CallGraphDOTPrinter, "dot-callgraph",
347  "Print call graph to 'dot' file", false, false)
348 
349 // Create methods available outside of this file, to use them
350 // "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
351 // the link time optimization.
352 
353 ModulePass *llvm::createCallGraphViewerPass() { return new CallGraphViewer(); }
354 
356  return new CallGraphDOTPrinter();
357 }
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::DOTGraphTraits< CallGraphDOTInfo * >::DOTGraphTraits
DOTGraphTraits(bool isSimple=false)
Definition: CallPrinter.cpp:144
llvm::CallGraphDOTPrinterPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: CallPrinter.cpp:255
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::CallGraph::getExternalCallingNode
CallGraphNode * getExternalCallingNode() const
Returns the CallGraphNode which is used to represent undetermined calls into the callgraph.
Definition: CallGraph.h:127
llvm::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:248
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:780
llvm::Function
Definition: Function.h:60
getFunction
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:236
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::BlockFrequencyInfoWrapperPass
Legacy analysis pass which computes BlockFrequencyInfo.
Definition: BlockFrequencyInfo.h:138
llvm::CallGraphNode::CallRecord
std::pair< Optional< WeakTrackingVH >, CallGraphNode * > CallRecord
A pair of the calling instruction (a call or invoke) and the call graph node being called.
Definition: CallGraph.h:178
double
into xmm2 addss xmm2 xmm1 xmm3 addss xmm3 movaps xmm0 unpcklps xmm0 ret seems silly when it could just be one addps Expand libm rounding functions main should enable SSE DAZ mode and other fast SSE modes Think about doing i64 math in SSE regs on x86 This testcase should have no SSE instructions in and only one load from a constant double
Definition: README-SSE.txt:85
llvm::CallGraphDOTInfo
Definition: CallPrinter.cpp:55
llvm::CallGraphDOTInfo::LookupBFI
std::function< BlockFrequencyInfo *(Function &)> LookupBFI
Definition: CallPrinter.cpp:63
llvm::CallGraphDOTInfo::CallGraphDOTInfo
CallGraphDOTInfo(Module *M, CallGraph *CG, function_ref< BlockFrequencyInfo *(Function &)> LookupBFI)
Definition: CallPrinter.cpp:65
llvm::CallGraph
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:72
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:139
to
Should compile to
Definition: README.txt:449
DenseMap.h
llvm::DOTGraphTraits< CallGraphDOTInfo * >::CGGetValuePtr
static const CallGraphNode * CGGetValuePtr(CallGraphNode::CallRecord P)
Definition: CallPrinter.cpp:169
llvm::CallGraphDOTInfo::getFreq
uint64_t getFreq(const Function *F)
Definition: CallPrinter.cpp:90
llvm::SmallSet
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:136
llvm::mapped_iterator
Definition: STLExtras.h:298
ShowEdgeWeight
static cl::opt< bool > ShowEdgeWeight("callgraph-show-weights", cl::init(false), cl::Hidden, cl::desc("Show edges labeled with weights"))
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
llvm::ViewGraph
void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)
ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file, then cleanup.
Definition: GraphWriter.h:427
freq
block freq
Definition: BlockFrequencyInfo.cpp:300
llvm::getHeatColor
std::string getHeatColor(uint64_t freq, uint64_t maxFreq)
Definition: HeatUtils.cpp:61
attrs
function attrs
Definition: FunctionAttrs.cpp:1941
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::GraphTraits< CallGraphDOTInfo * >::PairTy
std::pair< const Function *const, std::unique_ptr< CallGraphNode > > PairTy
Definition: CallPrinter.cpp:124
CommandLine.h
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
llvm::GraphTraits< CallGraphDOTInfo * >::CGGetValuePtr
static const CallGraphNode * CGGetValuePtr(const PairTy &P)
Definition: CallPrinter.cpp:125
llvm::createCallGraphViewerPass
ModulePass * createCallGraphViewerPass()
llvm::User
Definition: User.h:44
llvm::CallGraph::end
iterator end()
Definition: CallGraph.h:107
callgraph
print callgraph
Definition: CallGraph.cpp:388
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
false
Definition: StackSlotColoring.cpp:141
llvm::DOTGraphTraits< CallGraphDOTInfo * >::getNodeAttributes
std::string getNodeAttributes(const CallGraphNode *Node, CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:199
llvm::CallGraph::const_iterator
FunctionMapTy::const_iterator const_iterator
Definition: CallGraph.h:98
llvm::CallGraphNode
A node in the call graph for a module.
Definition: CallGraph.h:166
llvm::BlockFrequencyAnalysis
Analysis pass which computes BlockFrequencyInfo.
Definition: BlockFrequencyInfo.h:112
llvm::DOTGraphTraits< CallGraphDOTInfo * >::nodes_iterator
mapped_iterator< CallGraphNode::const_iterator, decltype(&CGGetValuePtr)> nodes_iterator
Definition: CallPrinter.cpp:176
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
CallMultiGraph
static cl::opt< bool > CallMultiGraph("callgraph-multigraph", cl::init(false), cl::Hidden, cl::desc("Show call-multigraph (do not remove parallel edges)"))
llvm::DOTGraphTraits
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
Definition: DOTGraphTraits.h:166
llvm::DOTGraphTraits< CallGraphDOTInfo * >::getEdgeAttributes
std::string getEdgeAttributes(const CallGraphNode *Node, nodes_iterator I, CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:178
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::DOTGraphTraits< CallGraphDOTInfo * >::getGraphName
static std::string getGraphName(CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:146
llvm::GraphTraits< CallGraphDOTInfo * >::nodes_begin
static nodes_iterator nodes_begin(CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:133
llvm::cl::opt< bool >
file
dot regions Print regions of function to dot file(with no function bodies)"
CallPrinter.h
uint64_t
llvm::sys::fs::OF_Text
@ OF_Text
The file should be opened in text mode on platforms like z/OS that make this distinction.
Definition: FileSystem.h:761
llvm::DenseMap
Definition: DenseMap.h:716
llvm::DefaultDOTGraphTraits::getGraphName
static std::string getGraphName(const GraphType &)
getGraphName - Return the label for the graph as a whole.
Definition: DOTGraphTraits.h:44
I
#define I(x, y, z)
Definition: MD5.cpp:58
call
S is passed via registers r2 But gcc stores them to the and then reload them to and r3 before issuing the call(r0 contains the address of the format string)
Definition: README.txt:190
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
CallGraphDotFilenamePrefix
static cl::opt< std::string > CallGraphDotFilenamePrefix("callgraph-dot-filename-prefix", cl::Hidden, cl::desc("The prefix used for the CallGraph dot file names."))
HeatUtils.h
llvm::GraphTraits< CallGraphDOTInfo * >::nodes_iterator
mapped_iterator< CallGraph::const_iterator, decltype(&CGGetValuePtr)> nodes_iterator
Definition: CallPrinter.cpp:131
llvm::ModulePass::runOnModule
virtual bool runOnModule(Module &M)=0
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
llvm::codeview::CompileSym2Flags::EC
@ EC
llvm::WriteGraph
raw_ostream & WriteGraph(raw_ostream &O, const GraphType &G, bool ShortNames=false, const Twine &Title="")
Definition: GraphWriter.h:359
llvm::Module::getModuleIdentifier
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:228
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::CallGraphNode::const_iterator
std::vector< CallRecord >::const_iterator const_iterator
Definition: CallGraph.h:194
BlockFrequencyInfo.h
llvm::SmallSet::insert
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:182
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:444
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:186
llvm::tgtok::dot
@ dot
Definition: TGLexer.h:43
llvm::DOTGraphTraits< CallGraphDOTInfo * >::isNodeHidden
static bool isNodeHidden(const CallGraphNode *Node, const CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:151
GraphWriter.h
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
llvm::CallGraphDOTInfo::getCallGraph
CallGraph * getCallGraph() const
Definition: CallPrinter.cpp:88
llvm::createCallGraphDOTPrinterPass
ModulePass * createCallGraphDOTPrinterPass()
Definition: CallPrinter.cpp:355
llvm::DOTGraphTraits< CallGraphDOTInfo * >::getNodeLabel
std::string getNodeLabel(const CallGraphNode *Node, CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:158
DOTGraphTraits.h
ShowHeatColors
static cl::opt< bool > ShowHeatColors("callgraph-heat-colors", cl::init(false), cl::Hidden, cl::desc("Show heat colors in call-graph"))
llvm::CallGraphDOTInfo::getModule
Module * getModule() const
Definition: CallPrinter.cpp:86
isSimple
static bool isSimple(Instruction *I)
Definition: SLPVectorizer.cpp:664
llvm::AMDGPU::Hwreg::Width
Width
Definition: SIDefines.h:439
CallGraph.h
llvm::GraphTraits< const CallGraphNode * >
Definition: CallGraph.h:438
llvm::GraphTraits< CallGraphDOTInfo * >::nodes_end
static nodes_iterator nodes_end(CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:136
Instructions.h
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:85
llvm::DefaultDOTGraphTraits
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
Definition: DOTGraphTraits.h:28
llvm::Pass::getAnalysisUsage
virtual void getAnalysisUsage(AnalysisUsage &) const
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: Pass.cpp:97
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::InnerAnalysisManagerProxy
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:937
llvm::CallGraphDOTInfo::getMaxFreq
uint64_t getMaxFreq()
Definition: CallPrinter.cpp:92
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::GraphTraits
Definition: GraphTraits.h:37
llvm::CallGraphViewerPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: CallPrinter.cpp:269
llvm::cl::desc
Definition: CommandLine.h:405
graph
print Print a call graph
Definition: CallGraph.cpp:389
llvm::ARMBuildAttrs::File
@ File
Definition: ARMBuildAttributes.h:36
llvm::GraphTraits< CallGraphDOTInfo * >::getEntryNode
static NodeRef getEntryNode(CallGraphDOTInfo *CGInfo)
Definition: CallPrinter.cpp:118
llvm::CallGraph::getCallsExternalNode
CallGraphNode * getCallsExternalNode() const
Definition: CallGraph.h:129
llvm::CallGraph::begin
iterator begin()
Definition: CallGraph.h:106
INITIALIZE_PASS
INITIALIZE_PASS(CallGraphViewer, "view-callgraph", "View call graph", false, false) char CallGraphDOTPrinter INITIALIZE_PASS(CallGraphDOTPrinter, "dot-callgraph", "Print call graph to 'dot' file", false, false) ModulePass *llvm
Definition: CallPrinter.cpp:346
InitializePasses.h
llvm::getNumOfCalls
uint64_t getNumOfCalls(Function &callerFunction, Function &calledFunction)
Definition: HeatUtils.cpp:39
SmallSet.h
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
INITIALIZE_PASS
TargetPassConfig.
Definition: TargetPassConfig.cpp:367