LLVM  16.0.0git
CFGPrinter.h
Go to the documentation of this file.
1 //===-- CFGPrinter.h - CFG printer external interface -----------*- C++ -*-===//
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 a 'dot-cfg' analysis pass, which emits the
10 // cfg.<fnname>.dot file for each function in the program, with a graph of the
11 // CFG for that function.
12 //
13 // This file defines external functions that can be called to explicitly
14 // instantiate the CFG printer.
15 //
16 //===----------------------------------------------------------------------===//
17 
18 #ifndef LLVM_ANALYSIS_CFGPRINTER_H
19 #define LLVM_ANALYSIS_CFGPRINTER_H
20 
24 #include "llvm/IR/CFG.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/Function.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/PassManager.h"
31 
32 namespace llvm {
33 template <class GraphType> struct GraphTraits;
34 class CFGViewerPass : public PassInfoMixin<CFGViewerPass> {
35 public:
37 };
38 
39 class CFGOnlyViewerPass : public PassInfoMixin<CFGOnlyViewerPass> {
40 public:
42 };
43 
44 class CFGPrinterPass : public PassInfoMixin<CFGPrinterPass> {
45 public:
47 };
48 
49 class CFGOnlyPrinterPass : public PassInfoMixin<CFGOnlyPrinterPass> {
50 public:
52 };
53 
54 class DOTFuncInfo {
55 private:
56  const Function *F;
57  const BlockFrequencyInfo *BFI;
58  const BranchProbabilityInfo *BPI;
59  uint64_t MaxFreq;
60  bool ShowHeat;
61  bool EdgeWeights;
62  bool RawWeights;
63 
64 public:
65  DOTFuncInfo(const Function *F) : DOTFuncInfo(F, nullptr, nullptr, 0) {}
66 
67  DOTFuncInfo(const Function *F, const BlockFrequencyInfo *BFI,
68  const BranchProbabilityInfo *BPI, uint64_t MaxFreq)
69  : F(F), BFI(BFI), BPI(BPI), MaxFreq(MaxFreq) {
70  ShowHeat = false;
71  EdgeWeights = !!BPI; // Print EdgeWeights when BPI is available.
72  RawWeights = !!BFI; // Print RawWeights when BFI is available.
73  }
74 
75  const BlockFrequencyInfo *getBFI() const { return BFI; }
76 
77  const BranchProbabilityInfo *getBPI() const { return BPI; }
78 
79  const Function *getFunction() const { return this->F; }
80 
81  uint64_t getMaxFreq() const { return MaxFreq; }
82 
83  uint64_t getFreq(const BasicBlock *BB) const {
84  return BFI->getBlockFreq(BB).getFrequency();
85  }
86 
87  void setHeatColors(bool ShowHeat) { this->ShowHeat = ShowHeat; }
88 
89  bool showHeatColors() { return ShowHeat; }
90 
91  void setRawEdgeWeights(bool RawWeights) { this->RawWeights = RawWeights; }
92 
93  bool useRawEdgeWeights() { return RawWeights; }
94 
95  void setEdgeWeights(bool EdgeWeights) { this->EdgeWeights = EdgeWeights; }
96 
97  bool showEdgeWeights() { return EdgeWeights; }
98 };
99 
100 template <>
102  static NodeRef getEntryNode(DOTFuncInfo *CFGInfo) {
103  return &(CFGInfo->getFunction()->getEntryBlock());
104  }
105 
106  // nodes_iterator/begin/end - Allow iteration over all nodes in the graph
108 
110  return nodes_iterator(CFGInfo->getFunction()->begin());
111  }
112 
114  return nodes_iterator(CFGInfo->getFunction()->end());
115  }
116 
117  static size_t size(DOTFuncInfo *CFGInfo) {
118  return CFGInfo->getFunction()->size();
119  }
120 };
121 
122 template <typename BasicBlockT>
123 std::string SimpleNodeLabelString(const BasicBlockT *Node) {
124  if (!Node->getName().empty())
125  return Node->getName().str();
126 
127  std::string Str;
128  raw_string_ostream OS(Str);
129 
130  Node->printAsOperand(OS, false);
131  return OS.str();
132 }
133 
134 template <typename BasicBlockT>
136  const BasicBlockT *Node,
137  function_ref<void(raw_string_ostream &, const BasicBlockT &)>
138  HandleBasicBlock,
139  function_ref<void(std::string &, unsigned &, unsigned)>
140  HandleComment) {
141 
142  enum { MaxColumns = 80 };
143  std::string Str;
144  raw_string_ostream OS(Str);
145 
146  if (Node->getName().empty()) {
147  Node->printAsOperand(OS, false);
148  OS << ':';
149  }
150 
151  HandleBasicBlock(OS, *Node);
152  std::string OutStr = OS.str();
153  if (OutStr[0] == '\n')
154  OutStr.erase(OutStr.begin());
155 
156  unsigned ColNum = 0;
157  unsigned LastSpace = 0;
158  for (unsigned i = 0; i != OutStr.length(); ++i) {
159  if (OutStr[i] == '\n') { // Left justify
160  OutStr[i] = '\\';
161  OutStr.insert(OutStr.begin() + i + 1, 'l');
162  ColNum = 0;
163  LastSpace = 0;
164  } else if (OutStr[i] == ';') { // Delete comments!
165  unsigned Idx = OutStr.find('\n', i + 1); // Find end of line
166  HandleComment(OutStr, i, Idx);
167  } else if (ColNum == MaxColumns) { // Wrap lines.
168  // Wrap very long names even though we can't find a space.
169  if (!LastSpace)
170  LastSpace = i;
171  OutStr.insert(LastSpace, "\\l...");
172  ColNum = i - LastSpace;
173  LastSpace = 0;
174  i += 3; // The loop will advance 'i' again.
175  } else
176  ++ColNum;
177  if (OutStr[i] == ' ')
178  LastSpace = i;
179  }
180  return OutStr;
181 }
182 
183 template <>
185 
186  // Cache for is hidden property
188 
190 
191  static void eraseComment(std::string &OutStr, unsigned &I, unsigned Idx) {
192  OutStr.erase(OutStr.begin() + I, OutStr.begin() + Idx);
193  --I;
194  }
195 
196  static std::string getGraphName(DOTFuncInfo *CFGInfo) {
197  return "CFG for '" + CFGInfo->getFunction()->getName().str() + "' function";
198  }
199 
200  static std::string getSimpleNodeLabel(const BasicBlock *Node, DOTFuncInfo *) {
201  return SimpleNodeLabelString(Node);
202  }
203 
204  static std::string getCompleteNodeLabel(
205  const BasicBlock *Node, DOTFuncInfo *,
206  function_ref<void(raw_string_ostream &, const BasicBlock &)>
207  HandleBasicBlock = [](raw_string_ostream &OS,
208  const BasicBlock &Node) -> void { OS << Node; },
209  function_ref<void(std::string &, unsigned &, unsigned)>
210  HandleComment = eraseComment) {
211  return CompleteNodeLabelString(Node, HandleBasicBlock, HandleComment);
212  }
213 
214  std::string getNodeLabel(const BasicBlock *Node, DOTFuncInfo *CFGInfo) {
215 
216  if (isSimple())
217  return getSimpleNodeLabel(Node, CFGInfo);
218  else
219  return getCompleteNodeLabel(Node, CFGInfo);
220  }
221 
222  static std::string getEdgeSourceLabel(const BasicBlock *Node,
224  // Label source of conditional branches with "T" or "F"
225  if (const BranchInst *BI = dyn_cast<BranchInst>(Node->getTerminator()))
226  if (BI->isConditional())
227  return (I == succ_begin(Node)) ? "T" : "F";
228 
229  // Label source of switch edges with the associated value.
230  if (const SwitchInst *SI = dyn_cast<SwitchInst>(Node->getTerminator())) {
231  unsigned SuccNo = I.getSuccessorIndex();
232 
233  if (SuccNo == 0)
234  return "def";
235 
236  std::string Str;
237  raw_string_ostream OS(Str);
238  auto Case = *SwitchInst::ConstCaseIt::fromSuccessorIndex(SI, SuccNo);
239  OS << Case.getCaseValue()->getValue();
240  return OS.str();
241  }
242  return "";
243  }
244 
245  /// Display the raw branch weights from PGO.
247  DOTFuncInfo *CFGInfo) {
248  if (!CFGInfo->showEdgeWeights())
249  return "";
250 
251  const Instruction *TI = Node->getTerminator();
252  if (TI->getNumSuccessors() == 1)
253  return "penwidth=2";
254 
255  unsigned OpNo = I.getSuccessorIndex();
256 
257  if (OpNo >= TI->getNumSuccessors())
258  return "";
259 
260  BasicBlock *SuccBB = TI->getSuccessor(OpNo);
261  auto BranchProb = CFGInfo->getBPI()->getEdgeProbability(Node, SuccBB);
262  double WeightPercent = ((double)BranchProb.getNumerator()) /
263  ((double)BranchProb.getDenominator());
264  double Width = 1 + WeightPercent;
265 
266  if (!CFGInfo->useRawEdgeWeights())
267  return formatv("label=\"{0:P}\" penwidth={1}", WeightPercent, Width)
268  .str();
269 
270  // Prepend a 'W' to indicate that this is a weight rather than the actual
271  // profile count (due to scaling).
272 
273  uint64_t Freq = CFGInfo->getFreq(Node);
274  std::string Attrs = formatv("label=\"W:{0}\" penwidth={1}",
275  (uint64_t)(Freq * WeightPercent), Width);
276  if (Attrs.size())
277  return Attrs;
278 
279  MDNode *WeightsNode = TI->getMetadata(LLVMContext::MD_prof);
280  if (!WeightsNode)
281  return "";
282 
283  MDString *MDName = cast<MDString>(WeightsNode->getOperand(0));
284  if (MDName->getString() != "branch_weights")
285  return "";
286 
287  OpNo = I.getSuccessorIndex() + 1;
288  if (OpNo >= WeightsNode->getNumOperands())
289  return "";
290  ConstantInt *Weight =
291  mdconst::dyn_extract<ConstantInt>(WeightsNode->getOperand(OpNo));
292  if (!Weight)
293  return "";
294  return ("label=\"W:" + std::to_string(Weight->getZExtValue()) +
295  "\" penwidth=" + std::to_string(Width));
296  }
297 
298  std::string getNodeAttributes(const BasicBlock *Node, DOTFuncInfo *CFGInfo) {
299 
300  if (!CFGInfo->showHeatColors())
301  return "";
302 
303  uint64_t Freq = CFGInfo->getFreq(Node);
304  std::string Color = getHeatColor(Freq, CFGInfo->getMaxFreq());
305  std::string EdgeColor = (Freq <= (CFGInfo->getMaxFreq() / 2))
306  ? (getHeatColor(0))
307  : (getHeatColor(1));
308 
309  std::string Attrs = "color=\"" + EdgeColor + "ff\", style=filled," +
310  " fillcolor=\"" + Color + "70\"";
311  return Attrs;
312  }
313  bool isNodeHidden(const BasicBlock *Node, const DOTFuncInfo *CFGInfo);
314  void computeDeoptOrUnreachablePaths(const Function *F);
315 };
316 } // End llvm namespace
317 
318 namespace llvm {
319 class FunctionPass;
320 FunctionPass *createCFGPrinterLegacyPassPass();
321 FunctionPass *createCFGOnlyPrinterLegacyPassPass();
322 } // End llvm namespace
323 
324 #endif
llvm::DOTGraphTraits< DOTFuncInfo * >::isOnDeoptOrUnreachablePath
DenseMap< const BasicBlock *, bool > isOnDeoptOrUnreachablePath
Definition: CFGPrinter.h:187
llvm::SuccIterator
Definition: CFG.h:138
i
i
Definition: README.txt:29
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm::createCFGOnlyPrinterLegacyPassPass
FunctionPass * createCFGOnlyPrinterLegacyPassPass()
Definition: CFGPrinter.cpp:289
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::Instruction::getNumSuccessors
unsigned getNumSuccessors() const LLVM_READONLY
Return the number of successors that this instruction has.
Definition: Instruction.cpp:807
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::Function::end
iterator end()
Definition: Function.h:709
llvm::DOTFuncInfo::DOTFuncInfo
DOTFuncInfo(const Function *F, const BlockFrequencyInfo *BFI, const BranchProbabilityInfo *BPI, uint64_t MaxFreq)
Definition: CFGPrinter.h:67
llvm::PassInfoMixin
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:371
llvm::Function
Definition: Function.h:60
llvm::DOTFuncInfo::showHeatColors
bool showHeatColors()
Definition: CFGPrinter.h:89
llvm::DOTFuncInfo::setHeatColors
void setHeatColors(bool ShowHeat)
Definition: CFGPrinter.h:87
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:628
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::Function::getEntryBlock
const BasicBlock & getEntryBlock() const
Definition: Function.h:691
llvm::CFGPrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
llvm::DOTGraphTraits< DOTFuncInfo * >::getCompleteNodeLabel
static std::string getCompleteNodeLabel(const BasicBlock *Node, DOTFuncInfo *, function_ref< void(raw_string_ostream &, const BasicBlock &)> HandleBasicBlock=[](raw_string_ostream &OS, const BasicBlock &Node) -> void { OS<< Node;}, function_ref< void(std::string &, unsigned &, unsigned)> HandleComment=eraseComment)
Definition: CFGPrinter.h:204
llvm::DOTFuncInfo::getBFI
const BlockFrequencyInfo * getBFI() const
Definition: CFGPrinter.h:75
llvm::DOTFuncInfo::setEdgeWeights
void setEdgeWeights(bool EdgeWeights)
Definition: CFGPrinter.h:95
llvm::CFGOnlyPrinterPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
llvm::getHeatColor
std::string getHeatColor(uint64_t freq, uint64_t maxFreq)
Definition: HeatUtils.cpp:63
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
llvm::DOTGraphTraits< DOTFuncInfo * >::getGraphName
static std::string getGraphName(DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:196
llvm::MDNode::getNumOperands
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1298
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:251
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
Constants.h
llvm::GraphTraits< DOTFuncInfo * >::nodes_begin
static nodes_iterator nodes_begin(DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:109
llvm::CFGOnlyViewerPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
llvm::BranchProbabilityInfo
Analysis providing branch probability information.
Definition: BranchProbabilityInfo.h:113
SI
@ SI
Definition: SIInstrInfo.cpp:7882
llvm::CFGViewerPass
Definition: CFGPrinter.h:34
llvm::Instruction
Definition: Instruction.h:42
llvm::SwitchInst::CaseIteratorImpl::fromSuccessorIndex
static CaseIteratorImpl fromSuccessorIndex(SwitchInstT *SI, unsigned SuccessorIndex)
Initializes case iterator for given SwitchInst and for given successor index.
Definition: Instructions.h:3417
FormatVariadic.h
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:271
llvm::GraphTraits< DOTFuncInfo * >::getEntryNode
static NodeRef getEntryNode(DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:102
CFG.h
llvm::DOTGraphTraits
DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...
Definition: DOTGraphTraits.h:166
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::MDNode::getOperand
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1292
llvm::DOTFuncInfo::getMaxFreq
uint64_t getMaxFreq() const
Definition: CFGPrinter.h:81
llvm::pointer_iterator
Definition: iterator.h:344
llvm::Instruction::getSuccessor
BasicBlock * getSuccessor(unsigned Idx) const LLVM_READONLY
Return the specified successor. This instruction must be a terminator.
Definition: Instruction.cpp:819
BranchProbabilityInfo.h
uint64_t
llvm::createCFGPrinterLegacyPassPass
FunctionPass * createCFGPrinterLegacyPassPass()
Definition: CFGPrinter.cpp:285
llvm::DOTFuncInfo::useRawEdgeWeights
bool useRawEdgeWeights()
Definition: CFGPrinter.h:93
llvm::DenseMap< const BasicBlock *, bool >
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::succ_begin
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:99
HeatUtils.h
llvm::GraphTraits< DOTFuncInfo * >::nodes_end
static nodes_iterator nodes_end(DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:113
llvm::GraphTraits< const BasicBlock * >
Definition: CFG.h:309
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::BranchProbabilityInfo::getEdgeProbability
BranchProbability getEdgeProbability(const BasicBlock *Src, unsigned IndexInSuccessors) const
Get an edge's probability, relative to other out-edges of the Src.
Definition: BranchProbabilityInfo.cpp:1100
llvm::DOTGraphTraits< DOTFuncInfo * >::getNodeLabel
std::string getNodeLabel(const BasicBlock *Node, DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:214
BlockFrequencyInfo.h
Node
Definition: ItaniumDemangle.h:156
llvm::GraphTraits< DOTFuncInfo * >::size
static size_t size(DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:117
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
llvm::Function::begin
iterator begin()
Definition: Function.h:707
llvm::ConstantInt::getZExtValue
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:142
llvm::DOTGraphTraits< DOTFuncInfo * >::getEdgeAttributes
std::string getEdgeAttributes(const BasicBlock *Node, const_succ_iterator I, DOTFuncInfo *CFGInfo)
Display the raw branch weights from PGO.
Definition: CFGPrinter.h:246
llvm::CFGOnlyViewerPass
Definition: CFGPrinter.h:39
llvm::DOTFuncInfo
Definition: CFGPrinter.h:54
llvm::DOTGraphTraits< DOTFuncInfo * >::getEdgeSourceLabel
static std::string getEdgeSourceLabel(const BasicBlock *Node, const_succ_iterator I)
Definition: CFGPrinter.h:222
Function.h
DOTGraphTraits.h
PassManager.h
llvm::DOTFuncInfo::getFreq
uint64_t getFreq(const BasicBlock *BB) const
Definition: CFGPrinter.h:83
llvm::DOTGraphTraits< DOTFuncInfo * >::getNodeAttributes
std::string getNodeAttributes(const BasicBlock *Node, DOTFuncInfo *CFGInfo)
Definition: CFGPrinter.h:298
isSimple
static bool isSimple(Instruction *I)
Definition: SLPVectorizer.cpp:786
llvm::AMDGPU::Hwreg::Width
Width
Definition: SIDefines.h:439
llvm::CFGOnlyPrinterPass
Definition: CFGPrinter.h:49
llvm::CompleteNodeLabelString
std::string CompleteNodeLabelString(const BasicBlockT *Node, function_ref< void(raw_string_ostream &, const BasicBlockT &)> HandleBasicBlock, function_ref< void(std::string &, unsigned &, unsigned)> HandleComment)
Definition: CFGPrinter.h:135
Instructions.h
Node::printAsOperand
void printAsOperand(OutputBuffer &OB, Prec P=Prec::Default, bool StrictlyWorse=false) const
Definition: ItaniumDemangle.h:263
llvm::CFGViewerPass::run
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
llvm::to_string
std::string to_string(const T &Value)
Definition: ScopedPrinter.h:85
llvm::CFGPrinterPass
Definition: CFGPrinter.h:44
llvm::DOTFuncInfo::getBPI
const BranchProbabilityInfo * getBPI() const
Definition: CFGPrinter.h:77
llvm::DefaultDOTGraphTraits
DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...
Definition: DOTGraphTraits.h:28
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::StringRef::str
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:221
llvm::DOTFuncInfo::showEdgeWeights
bool showEdgeWeights()
Definition: CFGPrinter.h:97
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::GraphTraits
Definition: GraphTraits.h:37
llvm::SwitchInst
Multiway switch.
Definition: Instructions.h:3277
llvm::SimpleNodeLabelString
std::string SimpleNodeLabelString(const BasicBlockT *Node)
Definition: CFGPrinter.h:123
llvm::DOTFuncInfo::getFunction
const Function * getFunction() const
Definition: CFGPrinter.h:79
llvm::MDString::getString
StringRef getString() const
Definition: Metadata.cpp:508
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3133
llvm::MDString
A single uniqued string.
Definition: Metadata.h:612
llvm::DOTFuncInfo::setRawEdgeWeights
void setRawEdgeWeights(bool RawWeights)
Definition: CFGPrinter.h:91
llvm::raw_string_ostream::str
std::string & str()
Returns the string's reference.
Definition: raw_ostream.h:646
llvm::DOTGraphTraits< DOTFuncInfo * >::DOTGraphTraits
DOTGraphTraits(bool isSimple=false)
Definition: CFGPrinter.h:189
llvm::DOTGraphTraits< DOTFuncInfo * >::getSimpleNodeLabel
static std::string getSimpleNodeLabel(const BasicBlock *Node, DOTFuncInfo *)
Definition: CFGPrinter.h:200
llvm::Function::size
size_t size() const
Definition: Function.h:712
llvm::DOTGraphTraits< DOTFuncInfo * >::eraseComment
static void eraseComment(std::string &OutStr, unsigned &I, unsigned Idx)
Definition: CFGPrinter.h:191
llvm::DOTFuncInfo::DOTFuncInfo
DOTFuncInfo(const Function *F)
Definition: CFGPrinter.h:65