1 //===- PassPrinters.cpp - Utilities to print analysis info for passes -----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// Utilities to print analysis info for various kinds of passes.
12 ///
13 //===----------------------------------------------------------------------===//
14
15 #include "PassPrinters.h"
16 #include "llvm/Analysis/CallGraph.h"
17 #include "llvm/Analysis/CallGraphSCCPass.h"
18 #include "llvm/Analysis/LoopInfo.h"
19 #include "llvm/Analysis/LoopPass.h"
20 #include "llvm/Analysis/RegionInfo.h"
21 #include "llvm/Analysis/RegionPass.h"
22 #include "llvm/IR/BasicBlock.h"
23 #include "llvm/IR/Function.h"
24 #include "llvm/Pass.h"
25 #include "llvm/Support/raw_ostream.h"
26 #include <string>
27
28 using namespace llvm;
29
30 namespace {
31
32 struct FunctionPassPrinter : public FunctionPass {
33 const PassInfo *PassToPrint;
34 raw_ostream &Out;
35 static char ID;
36 std::string PassName;
37 bool QuietPass;
38
FunctionPassPrinter__anond259ae5e0111::FunctionPassPrinter39 FunctionPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
40 : FunctionPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
41 std::string PassToPrintName = PassToPrint->getPassName();
42 PassName = "FunctionPass Printer: " + PassToPrintName;
43 }
44
runOnFunction__anond259ae5e0111::FunctionPassPrinter45 bool runOnFunction(Function &F) override {
46 if (!QuietPass)
47 Out << "Printing analysis '" << PassToPrint->getPassName()
48 << "' for function '" << F.getName() << "':\n";
49
50 // Get and print pass...
51 getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, F.getParent());
52 return false;
53 }
54
getPassName__anond259ae5e0111::FunctionPassPrinter55 StringRef getPassName() const override { return PassName; }
56
getAnalysisUsage__anond259ae5e0111::FunctionPassPrinter57 void getAnalysisUsage(AnalysisUsage &AU) const override {
58 AU.addRequiredID(PassToPrint->getTypeInfo());
59 AU.setPreservesAll();
60 }
61 };
62
63 char FunctionPassPrinter::ID = 0;
64
65 struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
66 static char ID;
67 const PassInfo *PassToPrint;
68 raw_ostream &Out;
69 std::string PassName;
70 bool QuietPass;
71
CallGraphSCCPassPrinter__anond259ae5e0111::CallGraphSCCPassPrinter72 CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
73 : CallGraphSCCPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
74 std::string PassToPrintName = PassToPrint->getPassName();
75 PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
76 }
77
runOnSCC__anond259ae5e0111::CallGraphSCCPassPrinter78 bool runOnSCC(CallGraphSCC &SCC) override {
79 if (!QuietPass)
80 Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
81
82 // Get and print pass...
83 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
84 Function *F = (*I)->getFunction();
85 if (F)
86 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
87 .print(Out, F->getParent());
88 }
89 return false;
90 }
91
getPassName__anond259ae5e0111::CallGraphSCCPassPrinter92 StringRef getPassName() const override { return PassName; }
93
getAnalysisUsage__anond259ae5e0111::CallGraphSCCPassPrinter94 void getAnalysisUsage(AnalysisUsage &AU) const override {
95 AU.addRequiredID(PassToPrint->getTypeInfo());
96 AU.setPreservesAll();
97 }
98 };
99
100 char CallGraphSCCPassPrinter::ID = 0;
101
102 struct ModulePassPrinter : public ModulePass {
103 static char ID;
104 const PassInfo *PassToPrint;
105 raw_ostream &Out;
106 std::string PassName;
107 bool QuietPass;
108
ModulePassPrinter__anond259ae5e0111::ModulePassPrinter109 ModulePassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
110 : ModulePass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
111 std::string PassToPrintName = PassToPrint->getPassName();
112 PassName = "ModulePass Printer: " + PassToPrintName;
113 }
114
runOnModule__anond259ae5e0111::ModulePassPrinter115 bool runOnModule(Module &M) override {
116 if (!QuietPass)
117 Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
118
119 // Get and print pass...
120 getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M);
121 return false;
122 }
123
getPassName__anond259ae5e0111::ModulePassPrinter124 StringRef getPassName() const override { return PassName; }
125
getAnalysisUsage__anond259ae5e0111::ModulePassPrinter126 void getAnalysisUsage(AnalysisUsage &AU) const override {
127 AU.addRequiredID(PassToPrint->getTypeInfo());
128 AU.setPreservesAll();
129 }
130 };
131
132 char ModulePassPrinter::ID = 0;
133
134 struct LoopPassPrinter : public LoopPass {
135 static char ID;
136 const PassInfo *PassToPrint;
137 raw_ostream &Out;
138 std::string PassName;
139 bool QuietPass;
140
LoopPassPrinter__anond259ae5e0111::LoopPassPrinter141 LoopPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
142 : LoopPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
143 std::string PassToPrintName = PassToPrint->getPassName();
144 PassName = "LoopPass Printer: " + PassToPrintName;
145 }
146
runOnLoop__anond259ae5e0111::LoopPassPrinter147 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
148 if (!QuietPass)
149 Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
150
151 // Get and print pass...
152 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
153 .print(Out, L->getHeader()->getParent()->getParent());
154 return false;
155 }
156
getPassName__anond259ae5e0111::LoopPassPrinter157 StringRef getPassName() const override { return PassName; }
158
getAnalysisUsage__anond259ae5e0111::LoopPassPrinter159 void getAnalysisUsage(AnalysisUsage &AU) const override {
160 AU.addRequiredID(PassToPrint->getTypeInfo());
161 AU.setPreservesAll();
162 }
163 };
164
165 char LoopPassPrinter::ID = 0;
166
167 struct RegionPassPrinter : public RegionPass {
168 static char ID;
169 const PassInfo *PassToPrint;
170 raw_ostream &Out;
171 std::string PassName;
172 bool QuietPass;
173
RegionPassPrinter__anond259ae5e0111::RegionPassPrinter174 RegionPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
175 : RegionPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
176 std::string PassToPrintName = PassToPrint->getPassName();
177 PassName = "RegionPass Printer: " + PassToPrintName;
178 }
179
runOnRegion__anond259ae5e0111::RegionPassPrinter180 bool runOnRegion(Region *R, RGPassManager &RGM) override {
181 if (!QuietPass) {
182 Out << "Printing analysis '" << PassToPrint->getPassName() << "' for "
183 << "region: '" << R->getNameStr() << "' in function '"
184 << R->getEntry()->getParent()->getName() << "':\n";
185 }
186 // Get and print pass...
187 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
188 .print(Out, R->getEntry()->getParent()->getParent());
189 return false;
190 }
191
getPassName__anond259ae5e0111::RegionPassPrinter192 StringRef getPassName() const override { return PassName; }
193
getAnalysisUsage__anond259ae5e0111::RegionPassPrinter194 void getAnalysisUsage(AnalysisUsage &AU) const override {
195 AU.addRequiredID(PassToPrint->getTypeInfo());
196 AU.setPreservesAll();
197 }
198 };
199
200 char RegionPassPrinter::ID = 0;
201
202 struct BasicBlockPassPrinter : public BasicBlockPass {
203 const PassInfo *PassToPrint;
204 raw_ostream &Out;
205 static char ID;
206 std::string PassName;
207 bool QuietPass;
208
BasicBlockPassPrinter__anond259ae5e0111::BasicBlockPassPrinter209 BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
210 : BasicBlockPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
211 std::string PassToPrintName = PassToPrint->getPassName();
212 PassName = "BasicBlockPass Printer: " + PassToPrintName;
213 }
214
runOnBasicBlock__anond259ae5e0111::BasicBlockPassPrinter215 bool runOnBasicBlock(BasicBlock &BB) override {
216 if (!QuietPass)
217 Out << "Printing Analysis info for BasicBlock '" << BB.getName()
218 << "': Pass " << PassToPrint->getPassName() << ":\n";
219
220 // Get and print pass...
221 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
222 .print(Out, BB.getParent()->getParent());
223 return false;
224 }
225
getPassName__anond259ae5e0111::BasicBlockPassPrinter226 StringRef getPassName() const override { return PassName; }
227
getAnalysisUsage__anond259ae5e0111::BasicBlockPassPrinter228 void getAnalysisUsage(AnalysisUsage &AU) const override {
229 AU.addRequiredID(PassToPrint->getTypeInfo());
230 AU.setPreservesAll();
231 }
232 };
233
234 char BasicBlockPassPrinter::ID = 0;
235
236 } // end anonymous namespace
237
createFunctionPassPrinter(const PassInfo * PI,raw_ostream & OS,bool Quiet)238 FunctionPass *llvm::createFunctionPassPrinter(const PassInfo *PI,
239 raw_ostream &OS, bool Quiet) {
240 return new FunctionPassPrinter(PI, OS, Quiet);
241 }
242
createCallGraphPassPrinter(const PassInfo * PI,raw_ostream & OS,bool Quiet)243 CallGraphSCCPass *llvm::createCallGraphPassPrinter(const PassInfo *PI,
244 raw_ostream &OS,
245 bool Quiet) {
246 return new CallGraphSCCPassPrinter(PI, OS, Quiet);
247 }
248
createModulePassPrinter(const PassInfo * PI,raw_ostream & OS,bool Quiet)249 ModulePass *llvm::createModulePassPrinter(const PassInfo *PI, raw_ostream &OS,
250 bool Quiet) {
251 return new ModulePassPrinter(PI, OS, Quiet);
252 }
253
createLoopPassPrinter(const PassInfo * PI,raw_ostream & OS,bool Quiet)254 LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS,
255 bool Quiet) {
256 return new LoopPassPrinter(PI, OS, Quiet);
257 }
258
createRegionPassPrinter(const PassInfo * PI,raw_ostream & OS,bool Quiet)259 RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS,
260 bool Quiet) {
261 return new RegionPassPrinter(PI, OS, Quiet);
262 }
263
createBasicBlockPassPrinter(const PassInfo * PI,raw_ostream & OS,bool Quiet)264 BasicBlockPass *llvm::createBasicBlockPassPrinter(const PassInfo *PI,
265 raw_ostream &OS, bool Quiet) {
266 return new BasicBlockPassPrinter(PI, OS, Quiet);
267 }
268