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