1 //===- PassPrinters.cpp - Utilities to print analysis info for passes -----===//
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 /// \file
10 /// Utilities to print analysis info for various kinds of passes.
11 ///
12 //===----------------------------------------------------------------------===//
13
14 #include "PassPrinters.h"
15 #include "llvm/Analysis/CallGraph.h"
16 #include "llvm/Analysis/CallGraphSCCPass.h"
17 #include "llvm/Analysis/LoopInfo.h"
18 #include "llvm/Analysis/LoopPass.h"
19 #include "llvm/Analysis/RegionInfo.h"
20 #include "llvm/Analysis/RegionPass.h"
21 #include "llvm/IR/BasicBlock.h"
22 #include "llvm/IR/Function.h"
23 #include "llvm/Pass.h"
24 #include "llvm/Support/raw_ostream.h"
25 #include <string>
26
27 using namespace llvm;
28
29 namespace {
30
31 struct FunctionPassPrinter : public FunctionPass {
32 const PassInfo *PassToPrint;
33 raw_ostream &Out;
34 static char ID;
35 std::string PassName;
36
FunctionPassPrinter__anond8297d850111::FunctionPassPrinter37 FunctionPassPrinter(const PassInfo *PI, raw_ostream &out)
38 : FunctionPass(ID), PassToPrint(PI), Out(out) {
39 std::string PassToPrintName = std::string(PassToPrint->getPassName());
40 PassName = "FunctionPass Printer: " + PassToPrintName;
41 }
42
runOnFunction__anond8297d850111::FunctionPassPrinter43 bool runOnFunction(Function &F) override {
44 Out << "Printing analysis '" << PassToPrint->getPassName()
45 << "' for function '" << F.getName() << "':\n";
46
47 // Get and print pass...
48 getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, F.getParent());
49 return false;
50 }
51
getPassName__anond8297d850111::FunctionPassPrinter52 StringRef getPassName() const override { return PassName; }
53
getAnalysisUsage__anond8297d850111::FunctionPassPrinter54 void getAnalysisUsage(AnalysisUsage &AU) const override {
55 AU.addRequiredID(PassToPrint->getTypeInfo());
56 AU.setPreservesAll();
57 }
58 };
59
60 char FunctionPassPrinter::ID = 0;
61
62 struct CallGraphSCCPassPrinter : public CallGraphSCCPass {
63 static char ID;
64 const PassInfo *PassToPrint;
65 raw_ostream &Out;
66 std::string PassName;
67
CallGraphSCCPassPrinter__anond8297d850111::CallGraphSCCPassPrinter68 CallGraphSCCPassPrinter(const PassInfo *PI, raw_ostream &out)
69 : CallGraphSCCPass(ID), PassToPrint(PI), Out(out) {
70 std::string PassToPrintName = std::string(PassToPrint->getPassName());
71 PassName = "CallGraphSCCPass Printer: " + PassToPrintName;
72 }
73
runOnSCC__anond8297d850111::CallGraphSCCPassPrinter74 bool runOnSCC(CallGraphSCC &SCC) override {
75 Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
76
77 // Get and print pass...
78 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) {
79 Function *F = (*I)->getFunction();
80 if (F)
81 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
82 .print(Out, F->getParent());
83 }
84 return false;
85 }
86
getPassName__anond8297d850111::CallGraphSCCPassPrinter87 StringRef getPassName() const override { return PassName; }
88
getAnalysisUsage__anond8297d850111::CallGraphSCCPassPrinter89 void getAnalysisUsage(AnalysisUsage &AU) const override {
90 AU.addRequiredID(PassToPrint->getTypeInfo());
91 AU.setPreservesAll();
92 }
93 };
94
95 char CallGraphSCCPassPrinter::ID = 0;
96
97 struct ModulePassPrinter : public ModulePass {
98 static char ID;
99 const PassInfo *PassToPrint;
100 raw_ostream &Out;
101 std::string PassName;
102
ModulePassPrinter__anond8297d850111::ModulePassPrinter103 ModulePassPrinter(const PassInfo *PI, raw_ostream &out)
104 : ModulePass(ID), PassToPrint(PI), Out(out) {
105 std::string PassToPrintName = std::string(PassToPrint->getPassName());
106 PassName = "ModulePass Printer: " + PassToPrintName;
107 }
108
runOnModule__anond8297d850111::ModulePassPrinter109 bool runOnModule(Module &M) override {
110 Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
111
112 // Get and print pass...
113 getAnalysisID<Pass>(PassToPrint->getTypeInfo()).print(Out, &M);
114 return false;
115 }
116
getPassName__anond8297d850111::ModulePassPrinter117 StringRef getPassName() const override { return PassName; }
118
getAnalysisUsage__anond8297d850111::ModulePassPrinter119 void getAnalysisUsage(AnalysisUsage &AU) const override {
120 AU.addRequiredID(PassToPrint->getTypeInfo());
121 AU.setPreservesAll();
122 }
123 };
124
125 char ModulePassPrinter::ID = 0;
126
127 struct LoopPassPrinter : public LoopPass {
128 static char ID;
129 const PassInfo *PassToPrint;
130 raw_ostream &Out;
131 std::string PassName;
132
LoopPassPrinter__anond8297d850111::LoopPassPrinter133 LoopPassPrinter(const PassInfo *PI, raw_ostream &out)
134 : LoopPass(ID), PassToPrint(PI), Out(out) {
135 std::string PassToPrintName = std::string(PassToPrint->getPassName());
136 PassName = "LoopPass Printer: " + PassToPrintName;
137 }
138
runOnLoop__anond8297d850111::LoopPassPrinter139 bool runOnLoop(Loop *L, LPPassManager &LPM) override {
140 Out << "Printing analysis '" << PassToPrint->getPassName() << "':\n";
141
142 // Get and print pass...
143 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
144 .print(Out, L->getHeader()->getParent()->getParent());
145 return false;
146 }
147
getPassName__anond8297d850111::LoopPassPrinter148 StringRef getPassName() const override { return PassName; }
149
getAnalysisUsage__anond8297d850111::LoopPassPrinter150 void getAnalysisUsage(AnalysisUsage &AU) const override {
151 AU.addRequiredID(PassToPrint->getTypeInfo());
152 AU.setPreservesAll();
153 }
154 };
155
156 char LoopPassPrinter::ID = 0;
157
158 struct RegionPassPrinter : public RegionPass {
159 static char ID;
160 const PassInfo *PassToPrint;
161 raw_ostream &Out;
162 std::string PassName;
163
RegionPassPrinter__anond8297d850111::RegionPassPrinter164 RegionPassPrinter(const PassInfo *PI, raw_ostream &out)
165 : RegionPass(ID), PassToPrint(PI), Out(out) {
166 std::string PassToPrintName = std::string(PassToPrint->getPassName());
167 PassName = "RegionPass Printer: " + PassToPrintName;
168 }
169
runOnRegion__anond8297d850111::RegionPassPrinter170 bool runOnRegion(Region *R, RGPassManager &RGM) override {
171 Out << "Printing analysis '" << PassToPrint->getPassName() << "' for "
172 << "region: '" << R->getNameStr() << "' in function '"
173 << R->getEntry()->getParent()->getName() << "':\n";
174 // Get and print pass...
175 getAnalysisID<Pass>(PassToPrint->getTypeInfo())
176 .print(Out, R->getEntry()->getParent()->getParent());
177 return false;
178 }
179
getPassName__anond8297d850111::RegionPassPrinter180 StringRef getPassName() const override { return PassName; }
181
getAnalysisUsage__anond8297d850111::RegionPassPrinter182 void getAnalysisUsage(AnalysisUsage &AU) const override {
183 AU.addRequiredID(PassToPrint->getTypeInfo());
184 AU.setPreservesAll();
185 }
186 };
187
188 char RegionPassPrinter::ID = 0;
189
190 } // end anonymous namespace
191
createFunctionPassPrinter(const PassInfo * PI,raw_ostream & OS)192 FunctionPass *llvm::createFunctionPassPrinter(const PassInfo *PI,
193 raw_ostream &OS) {
194 return new FunctionPassPrinter(PI, OS);
195 }
196
createCallGraphPassPrinter(const PassInfo * PI,raw_ostream & OS)197 CallGraphSCCPass *llvm::createCallGraphPassPrinter(const PassInfo *PI,
198 raw_ostream &OS) {
199 return new CallGraphSCCPassPrinter(PI, OS);
200 }
201
createModulePassPrinter(const PassInfo * PI,raw_ostream & OS)202 ModulePass *llvm::createModulePassPrinter(const PassInfo *PI, raw_ostream &OS) {
203 return new ModulePassPrinter(PI, OS);
204 }
205
createLoopPassPrinter(const PassInfo * PI,raw_ostream & OS)206 LoopPass *llvm::createLoopPassPrinter(const PassInfo *PI, raw_ostream &OS) {
207 return new LoopPassPrinter(PI, OS);
208 }
209
createRegionPassPrinter(const PassInfo * PI,raw_ostream & OS)210 RegionPass *llvm::createRegionPassPrinter(const PassInfo *PI, raw_ostream &OS) {
211 return new RegionPassPrinter(PI, OS);
212 }
213