1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
//===- CFGPrinter.cpp - DOT printer for the control flow graph ------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// This file defines a `-dot-cfg` analysis pass, which emits the
// `<prefix>.<fnname>.dot` file for each function in the program, with a graph
// of the CFG for that function. The default value for `<prefix>` is `cfg` but
// can be customized as needed.
//
// The other main feature of this file is that it implements the
// Function::viewCFG method, which is useful for debugging passes which operate
// on the CFG.
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/CFGPrinter.h"
#include "llvm/ADT/PostOrderIterator.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/GraphWriter.h"
using namespace llvm;
static cl::opt<std::string>
CFGFuncName("cfg-func-name", cl::Hidden,
cl::desc("The name of a function (or its substring)"
" whose CFG is viewed/printed."));
static cl::opt<std::string> CFGDotFilenamePrefix(
"cfg-dot-filename-prefix", cl::Hidden,
cl::desc("The prefix used for the CFG dot file names."));
static cl::opt<bool> HideUnreachablePaths("cfg-hide-unreachable-paths",
cl::init(false));
static cl::opt<bool> HideDeoptimizePaths("cfg-hide-deoptimize-paths",
cl::init(false));
static cl::opt<double> HideColdPaths(
"cfg-hide-cold-paths", cl::init(0.0),
cl::desc("Hide blocks with relative frequency below the given value"));
static cl::opt<bool> ShowHeatColors("cfg-heat-colors", cl::init(true),
cl::Hidden,
cl::desc("Show heat colors in CFG"));
static cl::opt<bool> UseRawEdgeWeight("cfg-raw-weights", cl::init(false),
cl::Hidden,
cl::desc("Use raw weights for labels. "
"Use percentages as default."));
static cl::opt<bool>
ShowEdgeWeight("cfg-weights", cl::init(false), cl::Hidden,
cl::desc("Show edges labeled with weights"));
static void writeCFGToDotFile(Function &F, BlockFrequencyInfo *BFI,
BranchProbabilityInfo *BPI, uint64_t MaxFreq,
bool CFGOnly = false) {
std::string Filename =
(CFGDotFilenamePrefix + "." + F.getName() + ".dot").str();
errs() << "Writing '" << Filename << "'...";
std::error_code EC;
raw_fd_ostream File(Filename, EC, sys::fs::OF_Text);
DOTFuncInfo CFGInfo(&F, BFI, BPI, MaxFreq);
CFGInfo.setHeatColors(ShowHeatColors);
CFGInfo.setEdgeWeights(ShowEdgeWeight);
CFGInfo.setRawEdgeWeights(UseRawEdgeWeight);
if (!EC)
WriteGraph(File, &CFGInfo, CFGOnly);
else
errs() << " error opening file for writing!";
errs() << "\n";
}
static void viewCFG(Function &F, const BlockFrequencyInfo *BFI,
const BranchProbabilityInfo *BPI, uint64_t MaxFreq,
bool CFGOnly = false) {
DOTFuncInfo CFGInfo(&F, BFI, BPI, MaxFreq);
CFGInfo.setHeatColors(ShowHeatColors);
CFGInfo.setEdgeWeights(ShowEdgeWeight);
CFGInfo.setRawEdgeWeights(UseRawEdgeWeight);
ViewGraph(&CFGInfo, "cfg." + F.getName(), CFGOnly);
}
PreservedAnalyses CFGViewerPass::run(Function &F, FunctionAnalysisManager &AM) {
if (!CFGFuncName.empty() && !F.getName().contains(CFGFuncName))
return PreservedAnalyses::all();
auto *BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
auto *BPI = &AM.getResult<BranchProbabilityAnalysis>(F);
viewCFG(F, BFI, BPI, getMaxFreq(F, BFI));
return PreservedAnalyses::all();
}
PreservedAnalyses CFGOnlyViewerPass::run(Function &F,
FunctionAnalysisManager &AM) {
if (!CFGFuncName.empty() && !F.getName().contains(CFGFuncName))
return PreservedAnalyses::all();
auto *BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
auto *BPI = &AM.getResult<BranchProbabilityAnalysis>(F);
viewCFG(F, BFI, BPI, getMaxFreq(F, BFI), /*CFGOnly=*/true);
return PreservedAnalyses::all();
}
PreservedAnalyses CFGPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
if (!CFGFuncName.empty() && !F.getName().contains(CFGFuncName))
return PreservedAnalyses::all();
auto *BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
auto *BPI = &AM.getResult<BranchProbabilityAnalysis>(F);
writeCFGToDotFile(F, BFI, BPI, getMaxFreq(F, BFI));
return PreservedAnalyses::all();
}
PreservedAnalyses CFGOnlyPrinterPass::run(Function &F,
FunctionAnalysisManager &AM) {
if (!CFGFuncName.empty() && !F.getName().contains(CFGFuncName))
return PreservedAnalyses::all();
auto *BFI = &AM.getResult<BlockFrequencyAnalysis>(F);
auto *BPI = &AM.getResult<BranchProbabilityAnalysis>(F);
writeCFGToDotFile(F, BFI, BPI, getMaxFreq(F, BFI), /*CFGOnly=*/true);
return PreservedAnalyses::all();
}
/// viewCFG - This function is meant for use from the debugger. You can just
/// say 'call F->viewCFG()' and a ghostview window should pop up from the
/// program, displaying the CFG of the current function. This depends on there
/// being a 'dot' and 'gv' program in your path.
///
void Function::viewCFG() const { viewCFG(false, nullptr, nullptr); }
void Function::viewCFG(bool ViewCFGOnly, const BlockFrequencyInfo *BFI,
const BranchProbabilityInfo *BPI) const {
if (!CFGFuncName.empty() && !getName().contains(CFGFuncName))
return;
DOTFuncInfo CFGInfo(this, BFI, BPI, BFI ? getMaxFreq(*this, BFI) : 0);
ViewGraph(&CFGInfo, "cfg" + getName(), ViewCFGOnly);
}
/// viewCFGOnly - This function is meant for use from the debugger. It works
/// just like viewCFG, but it does not include the contents of basic blocks
/// into the nodes, just the label. If you are only interested in the CFG
/// this can make the graph smaller.
///
void Function::viewCFGOnly() const { viewCFGOnly(nullptr, nullptr); }
void Function::viewCFGOnly(const BlockFrequencyInfo *BFI,
const BranchProbabilityInfo *BPI) const {
viewCFG(true, BFI, BPI);
}
/// Find all blocks on the paths which terminate with a deoptimize or
/// unreachable (i.e. all blocks which are post-dominated by a deoptimize
/// or unreachable). These paths are hidden if the corresponding cl::opts
/// are enabled.
void DOTGraphTraits<DOTFuncInfo *>::computeDeoptOrUnreachablePaths(
const Function *F) {
auto evaluateBB = [&](const BasicBlock *Node) {
if (succ_empty(Node)) {
const Instruction *TI = Node->getTerminator();
isOnDeoptOrUnreachablePath[Node] =
(HideUnreachablePaths && isa<UnreachableInst>(TI)) ||
(HideDeoptimizePaths && Node->getTerminatingDeoptimizeCall());
return;
}
isOnDeoptOrUnreachablePath[Node] =
llvm::all_of(successors(Node), [this](const BasicBlock *BB) {
return isOnDeoptOrUnreachablePath[BB];
});
};
/// The post order traversal iteration is done to know the status of
/// isOnDeoptOrUnreachablePath for all the successors on the current BB.
llvm::for_each(post_order(&F->getEntryBlock()), evaluateBB);
}
bool DOTGraphTraits<DOTFuncInfo *>::isNodeHidden(const BasicBlock *Node,
const DOTFuncInfo *CFGInfo) {
if (HideColdPaths.getNumOccurrences() > 0)
if (auto *BFI = CFGInfo->getBFI()) {
BlockFrequency NodeFreq = BFI->getBlockFreq(Node);
BlockFrequency EntryFreq = BFI->getEntryFreq();
// Hide blocks with relative frequency below HideColdPaths threshold.
if ((double)NodeFreq.getFrequency() / EntryFreq.getFrequency() <
HideColdPaths)
return true;
}
if (HideUnreachablePaths || HideDeoptimizePaths) {
if (!isOnDeoptOrUnreachablePath.contains(Node))
computeDeoptOrUnreachablePaths(Node->getParent());
return isOnDeoptOrUnreachablePath[Node];
}
return false;
}
|
