1 //===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===//
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 // This file implements the LLVM Pass infrastructure. It is primarily
11 // responsible with ensuring that passes are executed and batched together
12 // optimally.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "llvm/Pass.h"
17 #include "llvm/Config/llvm-config.h"
18 #include "llvm/IR/Attributes.h"
19 #include "llvm/IR/BasicBlock.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/IRPrintingPasses.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/IR/LegacyPassNameParser.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/IR/OptBisect.h"
26 #include "llvm/PassInfo.h"
27 #include "llvm/PassRegistry.h"
28 #include "llvm/PassSupport.h"
29 #include "llvm/Support/Compiler.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/raw_ostream.h"
32 #include <cassert>
33
34 using namespace llvm;
35
36 #define DEBUG_TYPE "ir"
37
38 //===----------------------------------------------------------------------===//
39 // Pass Implementation
40 //
41
42 // Force out-of-line virtual method.
~Pass()43 Pass::~Pass() {
44 delete Resolver;
45 }
46
47 // Force out-of-line virtual method.
48 ModulePass::~ModulePass() = default;
49
createPrinterPass(raw_ostream & OS,const std::string & Banner) const50 Pass *ModulePass::createPrinterPass(raw_ostream &OS,
51 const std::string &Banner) const {
52 return createPrintModulePass(OS, Banner);
53 }
54
getPotentialPassManagerType() const55 PassManagerType ModulePass::getPotentialPassManagerType() const {
56 return PMT_ModulePassManager;
57 }
58
skipModule(Module & M) const59 bool ModulePass::skipModule(Module &M) const {
60 return !M.getContext().getOptPassGate().shouldRunPass(this, M);
61 }
62
mustPreserveAnalysisID(char & AID) const63 bool Pass::mustPreserveAnalysisID(char &AID) const {
64 return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr;
65 }
66
67 // dumpPassStructure - Implement the -debug-pass=Structure option
dumpPassStructure(unsigned Offset)68 void Pass::dumpPassStructure(unsigned Offset) {
69 dbgs().indent(Offset*2) << getPassName() << "\n";
70 }
71
72 /// getPassName - Return a nice clean name for a pass. This usually
73 /// implemented in terms of the name that is registered by one of the
74 /// Registration templates, but can be overloaded directly.
getPassName() const75 StringRef Pass::getPassName() const {
76 AnalysisID AID = getPassID();
77 const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID);
78 if (PI)
79 return PI->getPassName();
80 return "Unnamed pass: implement Pass::getPassName()";
81 }
82
preparePassManager(PMStack &)83 void Pass::preparePassManager(PMStack &) {
84 // By default, don't do anything.
85 }
86
getPotentialPassManagerType() const87 PassManagerType Pass::getPotentialPassManagerType() const {
88 // Default implementation.
89 return PMT_Unknown;
90 }
91
getAnalysisUsage(AnalysisUsage &) const92 void Pass::getAnalysisUsage(AnalysisUsage &) const {
93 // By default, no analysis results are used, all are invalidated.
94 }
95
releaseMemory()96 void Pass::releaseMemory() {
97 // By default, don't do anything.
98 }
99
verifyAnalysis() const100 void Pass::verifyAnalysis() const {
101 // By default, don't do anything.
102 }
103
getAdjustedAnalysisPointer(AnalysisID AID)104 void *Pass::getAdjustedAnalysisPointer(AnalysisID AID) {
105 return this;
106 }
107
getAsImmutablePass()108 ImmutablePass *Pass::getAsImmutablePass() {
109 return nullptr;
110 }
111
getAsPMDataManager()112 PMDataManager *Pass::getAsPMDataManager() {
113 return nullptr;
114 }
115
setResolver(AnalysisResolver * AR)116 void Pass::setResolver(AnalysisResolver *AR) {
117 assert(!Resolver && "Resolver is already set");
118 Resolver = AR;
119 }
120
121 // print - Print out the internal state of the pass. This is called by Analyze
122 // to print out the contents of an analysis. Otherwise it is not necessary to
123 // implement this method.
print(raw_ostream & OS,const Module *) const124 void Pass::print(raw_ostream &OS, const Module *) const {
125 OS << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
126 }
127
128 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
129 // dump - call print(cerr);
dump() const130 LLVM_DUMP_METHOD void Pass::dump() const {
131 print(dbgs(), nullptr);
132 }
133 #endif
134
135 //===----------------------------------------------------------------------===//
136 // ImmutablePass Implementation
137 //
138 // Force out-of-line virtual method.
139 ImmutablePass::~ImmutablePass() = default;
140
initializePass()141 void ImmutablePass::initializePass() {
142 // By default, don't do anything.
143 }
144
145 //===----------------------------------------------------------------------===//
146 // FunctionPass Implementation
147 //
148
createPrinterPass(raw_ostream & OS,const std::string & Banner) const149 Pass *FunctionPass::createPrinterPass(raw_ostream &OS,
150 const std::string &Banner) const {
151 return createPrintFunctionPass(OS, Banner);
152 }
153
getPotentialPassManagerType() const154 PassManagerType FunctionPass::getPotentialPassManagerType() const {
155 return PMT_FunctionPassManager;
156 }
157
skipFunction(const Function & F) const158 bool FunctionPass::skipFunction(const Function &F) const {
159 if (!F.getContext().getOptPassGate().shouldRunPass(this, F))
160 return true;
161
162 if (F.hasFnAttribute(Attribute::OptimizeNone)) {
163 LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
164 << F.getName() << "\n");
165 return true;
166 }
167 return false;
168 }
169
170 //===----------------------------------------------------------------------===//
171 // BasicBlockPass Implementation
172 //
173
createPrinterPass(raw_ostream & OS,const std::string & Banner) const174 Pass *BasicBlockPass::createPrinterPass(raw_ostream &OS,
175 const std::string &Banner) const {
176 return createPrintBasicBlockPass(OS, Banner);
177 }
178
doInitialization(Function &)179 bool BasicBlockPass::doInitialization(Function &) {
180 // By default, don't do anything.
181 return false;
182 }
183
doFinalization(Function &)184 bool BasicBlockPass::doFinalization(Function &) {
185 // By default, don't do anything.
186 return false;
187 }
188
skipBasicBlock(const BasicBlock & BB) const189 bool BasicBlockPass::skipBasicBlock(const BasicBlock &BB) const {
190 const Function *F = BB.getParent();
191 if (!F)
192 return false;
193 if (!F->getContext().getOptPassGate().shouldRunPass(this, BB))
194 return true;
195 if (F->hasFnAttribute(Attribute::OptimizeNone)) {
196 // Report this only once per function.
197 if (&BB == &F->getEntryBlock())
198 LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName()
199 << "' on function " << F->getName() << "\n");
200 return true;
201 }
202 return false;
203 }
204
getPotentialPassManagerType() const205 PassManagerType BasicBlockPass::getPotentialPassManagerType() const {
206 return PMT_BasicBlockPassManager;
207 }
208
lookupPassInfo(const void * TI)209 const PassInfo *Pass::lookupPassInfo(const void *TI) {
210 return PassRegistry::getPassRegistry()->getPassInfo(TI);
211 }
212
lookupPassInfo(StringRef Arg)213 const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
214 return PassRegistry::getPassRegistry()->getPassInfo(Arg);
215 }
216
createPass(AnalysisID ID)217 Pass *Pass::createPass(AnalysisID ID) {
218 const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID);
219 if (!PI)
220 return nullptr;
221 return PI->createPass();
222 }
223
224 //===----------------------------------------------------------------------===//
225 // Analysis Group Implementation Code
226 //===----------------------------------------------------------------------===//
227
228 // RegisterAGBase implementation
229
RegisterAGBase(StringRef Name,const void * InterfaceID,const void * PassID,bool isDefault)230 RegisterAGBase::RegisterAGBase(StringRef Name, const void *InterfaceID,
231 const void *PassID, bool isDefault)
232 : PassInfo(Name, InterfaceID) {
233 PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID,
234 *this, isDefault);
235 }
236
237 //===----------------------------------------------------------------------===//
238 // PassRegistrationListener implementation
239 //
240
241 // enumeratePasses - Iterate over the registered passes, calling the
242 // passEnumerate callback on each PassInfo object.
enumeratePasses()243 void PassRegistrationListener::enumeratePasses() {
244 PassRegistry::getPassRegistry()->enumerateWith(this);
245 }
246
PassNameParser(cl::Option & O)247 PassNameParser::PassNameParser(cl::Option &O)
248 : cl::parser<const PassInfo *>(O) {
249 PassRegistry::getPassRegistry()->addRegistrationListener(this);
250 }
251
252 // This only gets called during static destruction, in which case the
253 // PassRegistry will have already been destroyed by llvm_shutdown(). So
254 // attempting to remove the registration listener is an error.
255 PassNameParser::~PassNameParser() = default;
256
257 //===----------------------------------------------------------------------===//
258 // AnalysisUsage Class Implementation
259 //
260
261 namespace {
262
263 struct GetCFGOnlyPasses : public PassRegistrationListener {
264 using VectorType = AnalysisUsage::VectorType;
265
266 VectorType &CFGOnlyList;
267
GetCFGOnlyPasses__anon672d7e750111::GetCFGOnlyPasses268 GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
269
passEnumerate__anon672d7e750111::GetCFGOnlyPasses270 void passEnumerate(const PassInfo *P) override {
271 if (P->isCFGOnlyPass())
272 CFGOnlyList.push_back(P->getTypeInfo());
273 }
274 };
275
276 } // end anonymous namespace
277
278 // setPreservesCFG - This function should be called to by the pass, iff they do
279 // not:
280 //
281 // 1. Add or remove basic blocks from the function
282 // 2. Modify terminator instructions in any way.
283 //
284 // This function annotates the AnalysisUsage info object to say that analyses
285 // that only depend on the CFG are preserved by this pass.
setPreservesCFG()286 void AnalysisUsage::setPreservesCFG() {
287 // Since this transformation doesn't modify the CFG, it preserves all analyses
288 // that only depend on the CFG (like dominators, loop info, etc...)
289 GetCFGOnlyPasses(Preserved).enumeratePasses();
290 }
291
addPreserved(StringRef Arg)292 AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) {
293 const PassInfo *PI = Pass::lookupPassInfo(Arg);
294 // If the pass exists, preserve it. Otherwise silently do nothing.
295 if (PI) Preserved.push_back(PI->getTypeInfo());
296 return *this;
297 }
298
addRequiredID(const void * ID)299 AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) {
300 Required.push_back(ID);
301 return *this;
302 }
303
addRequiredID(char & ID)304 AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) {
305 Required.push_back(&ID);
306 return *this;
307 }
308
addRequiredTransitiveID(char & ID)309 AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) {
310 Required.push_back(&ID);
311 RequiredTransitive.push_back(&ID);
312 return *this;
313 }
314