Line data Source code
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.
43 10492158 : Pass::~Pass() {
44 9914451 : delete Resolver;
45 5246073 : }
46 0 :
47 : // Force out-of-line virtual method.
48 0 : ModulePass::~ModulePass() = default;
49 10492158 :
50 9914451 : Pass *ModulePass::createPrinterPass(raw_ostream &OS,
51 5246073 : const std::string &Banner) const {
52 : return createPrintModulePass(OS, Banner);
53 : }
54 :
55 : PassManagerType ModulePass::getPotentialPassManagerType() const {
56 23 : return PMT_ModulePassManager;
57 : }
58 23 :
59 : bool ModulePass::skipModule(Module &M) const {
60 : return !M.getContext().getOptPassGate().shouldRunPass(this, M);
61 377295 : }
62 377295 :
63 : bool Pass::mustPreserveAnalysisID(char &AID) const {
64 : return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr;
65 23444 : }
66 23444 :
67 : // dumpPassStructure - Implement the -debug-pass=Structure option
68 : void Pass::dumpPassStructure(unsigned Offset) {
69 442777 : dbgs().indent(Offset*2) << getPassName() << "\n";
70 442777 : }
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 4541 : /// Registration templates, but can be overloaded directly.
75 4541 : StringRef Pass::getPassName() const {
76 4541 : 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 880809 : }
82 880809 :
83 880809 : void Pass::preparePassManager(PMStack &) {
84 880809 : // By default, don't do anything.
85 880530 : }
86 279 :
87 : PassManagerType Pass::getPotentialPassManagerType() const {
88 : // Default implementation.
89 4530593 : return PMT_Unknown;
90 : }
91 4530593 :
92 : void Pass::getAnalysisUsage(AnalysisUsage &) const {
93 0 : // By default, no analysis results are used, all are invalidated.
94 : }
95 0 :
96 : void Pass::releaseMemory() {
97 : // By default, don't do anything.
98 2913128 : }
99 :
100 2913128 : void Pass::verifyAnalysis() const {
101 : // By default, don't do anything.
102 36534894 : }
103 :
104 36534894 : void *Pass::getAdjustedAnalysisPointer(AnalysisID AID) {
105 : return this;
106 0 : }
107 :
108 0 : ImmutablePass *Pass::getAsImmutablePass() {
109 : return nullptr;
110 96483880 : }
111 96483880 :
112 : PMDataManager *Pass::getAsPMDataManager() {
113 : return nullptr;
114 83555283 : }
115 83555283 :
116 : void Pass::setResolver(AnalysisResolver *AR) {
117 : assert(!Resolver && "Resolver is already set");
118 5338021 : Resolver = AR;
119 5338021 : }
120 :
121 : // print - Print out the internal state of the pass. This is called by Analyze
122 4695071 : // to print out the contents of an analysis. Otherwise it is not necessary to
123 : // implement this method.
124 4695071 : void Pass::print(raw_ostream &OS, const Module *) const {
125 4695071 : OS << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
126 : }
127 :
128 : #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
129 : // dump - call print(cerr);
130 735 : LLVM_DUMP_METHOD void Pass::dump() const {
131 735 : print(dbgs(), nullptr);
132 735 : }
133 : #endif
134 :
135 : //===----------------------------------------------------------------------===//
136 : // ImmutablePass Implementation
137 : //
138 : // Force out-of-line virtual method.
139 : ImmutablePass::~ImmutablePass() = default;
140 :
141 : void ImmutablePass::initializePass() {
142 : // By default, don't do anything.
143 : }
144 :
145 : //===----------------------------------------------------------------------===//
146 : // FunctionPass Implementation
147 420670 : //
148 :
149 420670 : Pass *FunctionPass::createPrinterPass(raw_ostream &OS,
150 : const std::string &Banner) const {
151 : return createPrintFunctionPass(OS, Banner);
152 : }
153 :
154 : PassManagerType FunctionPass::getPotentialPassManagerType() const {
155 159 : return PMT_FunctionPassManager;
156 : }
157 159 :
158 : bool FunctionPass::skipFunction(const Function &F) const {
159 : if (!F.getContext().getOptPassGate().shouldRunPass(this, F))
160 3342960 : return true;
161 3342960 :
162 : if (F.hasFnAttribute(Attribute::OptimizeNone)) {
163 : LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
164 9311498 : << F.getName() << "\n");
165 9311498 : return true;
166 : }
167 : return false;
168 9310783 : }
169 :
170 : //===----------------------------------------------------------------------===//
171 201740 : // BasicBlockPass Implementation
172 : //
173 :
174 : Pass *BasicBlockPass::createPrinterPass(raw_ostream &OS,
175 : const std::string &Banner) const {
176 : return createPrintBasicBlockPass(OS, Banner);
177 : }
178 :
179 : bool BasicBlockPass::doInitialization(Function &) {
180 0 : // By default, don't do anything.
181 : return false;
182 0 : }
183 :
184 : bool BasicBlockPass::doFinalization(Function &) {
185 1169 : // By default, don't do anything.
186 : return false;
187 1169 : }
188 :
189 : bool BasicBlockPass::skipBasicBlock(const BasicBlock &BB) const {
190 1169 : const Function *F = BB.getParent();
191 : if (!F)
192 1169 : return false;
193 : if (!F->getContext().getOptPassGate().shouldRunPass(this, BB))
194 : return true;
195 1331 : if (F->hasFnAttribute(Attribute::OptimizeNone)) {
196 1331 : // Report this only once per function.
197 1331 : if (&BB == &F->getEntryBlock())
198 : LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName()
199 1331 : << "' on function " << F->getName() << "\n");
200 : return true;
201 1331 : }
202 : return false;
203 : }
204 :
205 : PassManagerType BasicBlockPass::getPotentialPassManagerType() const {
206 0 : return PMT_BasicBlockPassManager;
207 : }
208 :
209 : const PassInfo *Pass::lookupPassInfo(const void *TI) {
210 : return PassRegistry::getPassRegistry()->getPassInfo(TI);
211 0 : }
212 0 :
213 : const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
214 : return PassRegistry::getPassRegistry()->getPassInfo(Arg);
215 1033 : }
216 1033 :
217 : Pass *Pass::createPass(AnalysisID ID) {
218 : const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID);
219 0 : if (!PI)
220 0 : return nullptr;
221 : return PI->createPass();
222 : }
223 937787 :
224 937787 : //===----------------------------------------------------------------------===//
225 937787 : // Analysis Group Implementation Code
226 : //===----------------------------------------------------------------------===//
227 937787 :
228 : // RegisterAGBase implementation
229 :
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 0 :
237 : //===----------------------------------------------------------------------===//
238 0 : // PassRegistrationListener implementation
239 0 : //
240 :
241 0 : // enumeratePasses - Iterate over the registered passes, calling the
242 : // passEnumerate callback on each PassInfo object.
243 : void PassRegistrationListener::enumeratePasses() {
244 : PassRegistry::getPassRegistry()->enumerateWith(this);
245 : }
246 :
247 : PassNameParser::PassNameParser(cl::Option &O)
248 : : cl::parser<const PassInfo *>(O) {
249 1102206 : PassRegistry::getPassRegistry()->addRegistrationListener(this);
250 1102206 : }
251 1102206 :
252 : // This only gets called during static destruction, in which case the
253 238670 : // PassRegistry will have already been destroyed by llvm_shutdown(). So
254 238670 : // attempting to remove the registration listener is an error.
255 238670 : PassNameParser::~PassNameParser() = default;
256 238670 :
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 :
268 : GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
269 :
270 : void passEnumerate(const PassInfo *P) override {
271 : if (P->isCFGOnlyPass())
272 : CFGOnlyList.push_back(P->getTypeInfo());
273 : }
274 863536 : };
275 :
276 303439090 : } // end anonymous namespace
277 303439090 :
278 17586435 : // setPreservesCFG - This function should be called to by the pass, iff they do
279 303439064 : // 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.
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 :
292 863536 : AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) {
293 : const PassInfo *PI = Pass::lookupPassInfo(Arg);
294 : // If the pass exists, preserve it. Otherwise silently do nothing.
295 863536 : if (PI) Preserved.push_back(PI->getTypeInfo());
296 863536 : return *this;
297 : }
298 0 :
299 0 : AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) {
300 : Required.push_back(ID);
301 0 : return *this;
302 0 : }
303 :
304 : AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) {
305 3273 : Required.push_back(&ID);
306 3273 : return *this;
307 3273 : }
308 :
309 : AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) {
310 7929064 : Required.push_back(&ID);
311 7929064 : RequiredTransitive.push_back(&ID);
312 7929066 : return *this;
313 : }
|
