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/// \brief Utilities to print analysis info for various kinds of passes.
12///
13//===----------------------------------------------------------------------===//
14#include "PassPrinters.h"
15#include "llvm/Analysis/CallGraphSCCPass.h"
16#include "llvm/Analysis/LoopPass.h"
17#include "llvm/Analysis/RegionPass.h"
18#include "llvm/IR/Function.h"
19#include "llvm/Pass.h"
20#include <string>
21
22using namespace llvm;
23
24namespace {
25
26struct FunctionPassPrinter : public FunctionPass {
27  const PassInfo *PassToPrint;
28  raw_ostream &Out;
29  static char ID;
30  std::string PassName;
31  bool QuietPass;
32
33  FunctionPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
34      : FunctionPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
35    std::string PassToPrintName = PassToPrint->getPassName();
36    PassName = "FunctionPass Printer: " + PassToPrintName;
37  }
38
39  bool runOnFunction(Function &F) override {
40    if (!QuietPass)
41      Out << "Printing analysis '" << PassToPrint->getPassName()
42          << "' for function '" << F.getName() << "':\n";
43
44    // Get and print pass...
45    getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, F.getParent());
46    return false;
47  }
48
49  const char *getPassName() const override { return PassName.c_str(); }
50
51  void getAnalysisUsage(AnalysisUsage &AU) const override {
52    AU.addRequiredID(PassToPrint->getTypeInfo());
53    AU.setPreservesAll();
54  }
55};
56
57char FunctionPassPrinter::ID = 0;
58
59struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
60  static char ID;
61  const PassInfo *PassToPrint;
62  raw_ostream &Out;
63  std::string PassName;
64  bool QuietPass;
65
66  CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
67      : CallGraphSCCPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
68    std::string PassToPrintName = PassToPrint->getPassName();
69    PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
70  }
71
72  bool runOnSCC(CallGraphSCC &SCC) override {
73    if (!QuietPass)
74      Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
75
76    // Get and print pass...
77    for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
78      Function *F = (*I)->getFunction();
79      if (F)
80        getAnalysisID<Pass>(PassToPrint->getTypeInfo())
81            .print(Out, F->getParent());
82    }
83    return false;
84  }
85
86  const char *getPassName() const override { return PassName.c_str(); }
87
88  void getAnalysisUsage(AnalysisUsage &AU) const override {
89    AU.addRequiredID(PassToPrint->getTypeInfo());
90    AU.setPreservesAll();
91  }
92};
93
94char CallGraphSCCPassPrinter::ID = 0;
95
96struct ModulePassPrinter : public ModulePass {
97  static char ID;
98  const PassInfo *PassToPrint;
99  raw_ostream &Out;
100  std::string PassName;
101  bool QuietPass;
102
103  ModulePassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
104      : ModulePass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
105    std::string PassToPrintName = PassToPrint->getPassName();
106    PassName = "ModulePass Printer: " + PassToPrintName;
107  }
108
109  bool runOnModule(Module &M) override {
110    if (!QuietPass)
111      Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
112
113    // Get and print pass...
114    getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M);
115    return false;
116  }
117
118  const char *getPassName() const override { return PassName.c_str(); }
119
120  void getAnalysisUsage(AnalysisUsage &AU) const override {
121    AU.addRequiredID(PassToPrint->getTypeInfo());
122    AU.setPreservesAll();
123  }
124};
125
126char ModulePassPrinter::ID = 0;
127
128struct LoopPassPrinter : public LoopPass {
129  static char ID;
130  const PassInfo *PassToPrint;
131  raw_ostream &Out;
132  std::string PassName;
133  bool QuietPass;
134
135  LoopPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
136      : LoopPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
137    std::string PassToPrintName = PassToPrint->getPassName();
138    PassName = "LoopPass Printer: " + PassToPrintName;
139  }
140
141  bool runOnLoop(Loop *L, LPPassManager &LPM) override {
142    if (!QuietPass)
143      Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
144
145    // Get and print pass...
146    getAnalysisID<Pass>(PassToPrint->getTypeInfo())
147        .print(Out, L->getHeader()->getParent()->getParent());
148    return false;
149  }
150
151  const char *getPassName() const override { return PassName.c_str(); }
152
153  void getAnalysisUsage(AnalysisUsage &AU) const override {
154    AU.addRequiredID(PassToPrint->getTypeInfo());
155    AU.setPreservesAll();
156  }
157};
158
159char LoopPassPrinter::ID = 0;
160
161struct RegionPassPrinter : public RegionPass {
162  static char ID;
163  const PassInfo *PassToPrint;
164  raw_ostream &Out;
165  std::string PassName;
166  bool QuietPass;
167
168  RegionPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
169      : RegionPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
170    std::string PassToPrintName = PassToPrint->getPassName();
171    PassName = "RegionPass Printer: " + PassToPrintName;
172  }
173
174  bool runOnRegion(Region *R, RGPassManager &RGM) override {
175    if (!QuietPass) {
176      Out << "Printing analysis '" << PassToPrint->getPassName() << "' for "
177          << "region: '" << R->getNameStr() << "' in function '"
178          << R->getEntry()->getParent()->getName() << "':\n";
179    }
180    // Get and print pass...
181    getAnalysisID<Pass>(PassToPrint->getTypeInfo())
182        .print(Out, R->getEntry()->getParent()->getParent());
183    return false;
184  }
185
186  const char *getPassName() const override { return PassName.c_str(); }
187
188  void getAnalysisUsage(AnalysisUsage &AU) const override {
189    AU.addRequiredID(PassToPrint->getTypeInfo());
190    AU.setPreservesAll();
191  }
192};
193
194char RegionPassPrinter::ID = 0;
195
196struct BasicBlockPassPrinter : public BasicBlockPass {
197  const PassInfo *PassToPrint;
198  raw_ostream &Out;
199  static char ID;
200  std::string PassName;
201  bool QuietPass;
202
203  BasicBlockPassPrinter(const PassInfo *PI, raw_ostream &out, bool Quiet)
204      : BasicBlockPass(ID), PassToPrint(PI), Out(out), QuietPass(Quiet) {
205    std::string PassToPrintName = PassToPrint->getPassName();
206    PassName = "BasicBlockPass Printer: " + PassToPrintName;
207  }
208
209  bool runOnBasicBlock(BasicBlock &BB) override {
210    if (!QuietPass)
211      Out << "Printing Analysis info for BasicBlock '" << BB.getName()
212          << "': Pass " << PassToPrint->getPassName() << ":\n";
213
214    // Get and print pass...
215    getAnalysisID<Pass>(PassToPrint->getTypeInfo())
216        .print(Out, BB.getParent()->getParent());
217    return false;
218  }
219
220  const char *getPassName() const override { return PassName.c_str(); }
221
222  void getAnalysisUsage(AnalysisUsage &AU) const override {
223    AU.addRequiredID(PassToPrint->getTypeInfo());
224    AU.setPreservesAll();
225  }
226};
227
228char BasicBlockPassPrinter::ID = 0;
229}
230
231FunctionPass *llvm::createFunctionPassPrinter(const PassInfo *PI,
232                                              raw_ostream &OS, bool Quiet) {
233  return new FunctionPassPrinter(PI, OS, Quiet);
234}
235
236CallGraphSCCPass *llvm::createCallGraphPassPrinter(const PassInfo *PI,
237                                                   raw_ostream &OS,
238                                                   bool Quiet) {
239  return new CallGraphSCCPassPrinter(PI, OS, Quiet);
240}
241
242ModulePass *llvm::createModulePassPrinter(const PassInfo *PI, raw_ostream &OS,
243                                          bool Quiet) {
244  return new ModulePassPrinter(PI, OS, Quiet);
245}
246
247LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS,
248                                      bool Quiet) {
249  return new LoopPassPrinter(PI, OS, Quiet);
250}
251
252RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS,
253                                          bool Quiet) {
254  return new RegionPassPrinter(PI, OS, Quiet);
255}
256
257BasicBlockPass *llvm::createBasicBlockPassPrinter(const PassInfo *PI,
258                                                  raw_ostream &OS, bool Quiet) {
259  return new BasicBlockPassPrinter(PI, OS, Quiet);
260}
261