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