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
33using namespace llvm;
34
35#define DEBUG_TYPE "ir"
36
37//===----------------------------------------------------------------------===//
38// Pass Implementation
39//
40
41// Force out-of-line virtual method.
42Pass::~Pass() {
43  delete Resolver;
44}
45
46// Force out-of-line virtual method.
47ModulePass::~ModulePass() = default;
48
49Pass *ModulePass::createPrinterPass(raw_ostream &OS,
50                                    const std::string &Banner) const {
51  return createPrintModulePass(OS, Banner);
52}
53
54PassManagerType ModulePass::getPotentialPassManagerType() const {
55  return PMT_ModulePassManager;
56}
57
58static std::string getDescription(const Module &M) {
59  return "module (" + M.getName().str() + ")";
60}
61
62bool ModulePass::skipModule(Module &M) const {
63  OptPassGate &Gate = M.getContext().getOptPassGate();
64  return Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(M));
65}
66
67bool Pass::mustPreserveAnalysisID(char &AID) const {
68  return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr;
69}
70
71// dumpPassStructure - Implement the -debug-pass=Structure option
72void 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.
79StringRef 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
87void Pass::preparePassManager(PMStack &) {
88  // By default, don't do anything.
89}
90
91PassManagerType Pass::getPotentialPassManagerType() const {
92  // Default implementation.
93  return PMT_Unknown;
94}
95
96void Pass::getAnalysisUsage(AnalysisUsage &) const {
97  // By default, no analysis results are used, all are invalidated.
98}
99
100void Pass::releaseMemory() {
101  // By default, don't do anything.
102}
103
104void Pass::verifyAnalysis() const {
105  // By default, don't do anything.
106}
107
108void *Pass::getAdjustedAnalysisPointer(AnalysisID AID) {
109  return this;
110}
111
112ImmutablePass *Pass::getAsImmutablePass() {
113  return nullptr;
114}
115
116PMDataManager *Pass::getAsPMDataManager() {
117  return nullptr;
118}
119
120void 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.
128void 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);
134LLVM_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.
143ImmutablePass::~ImmutablePass() = default;
144
145void ImmutablePass::initializePass() {
146  // By default, don't do anything.
147}
148
149//===----------------------------------------------------------------------===//
150// FunctionPass Implementation
151//
152
153Pass *FunctionPass::createPrinterPass(raw_ostream &OS,
154                                      const std::string &Banner) const {
155  return createPrintFunctionPass(OS, Banner);
156}
157
158PassManagerType FunctionPass::getPotentialPassManagerType() const {
159  return PMT_FunctionPassManager;
160}
161
162static std::string getDescription(const Function &F) {
163  return "function (" + F.getName().str() + ")";
164}
165
166bool 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
179const PassInfo *Pass::lookupPassInfo(const void *TI) {
180  return PassRegistry::getPassRegistry()->getPassInfo(TI);
181}
182
183const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
184  return PassRegistry::getPassRegistry()->getPassInfo(Arg);
185}
186
187Pass *Pass::createPass(AnalysisID ID) {
188  const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID);
189  if (!PI)
190    return nullptr;
191  return PI->createPass();
192}
193
194//===----------------------------------------------------------------------===//
195//                  Analysis Group Implementation Code
196//===----------------------------------------------------------------------===//
197
198// RegisterAGBase implementation
199
200RegisterAGBase::RegisterAGBase(StringRef Name, const void *InterfaceID,
201                               const void *PassID, bool isDefault)
202    : PassInfo(Name, InterfaceID) {
203  PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID,
204                                                         *this, isDefault);
205}
206
207//===----------------------------------------------------------------------===//
208// PassRegistrationListener implementation
209//
210
211// enumeratePasses - Iterate over the registered passes, calling the
212// passEnumerate callback on each PassInfo object.
213void PassRegistrationListener::enumeratePasses() {
214  PassRegistry::getPassRegistry()->enumerateWith(this);
215}
216
217PassNameParser::PassNameParser(cl::Option &O)
218    : cl::parser<const PassInfo *>(O) {
219  PassRegistry::getPassRegistry()->addRegistrationListener(this);
220}
221
222// This only gets called during static destruction, in which case the
223// PassRegistry will have already been destroyed by llvm_shutdown().  So
224// attempting to remove the registration listener is an error.
225PassNameParser::~PassNameParser() = default;
226
227//===----------------------------------------------------------------------===//
228//   AnalysisUsage Class Implementation
229//
230
231namespace {
232
233struct GetCFGOnlyPasses : public PassRegistrationListener {
234  using VectorType = AnalysisUsage::VectorType;
235
236  VectorType &CFGOnlyList;
237
238  GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
239
240  void passEnumerate(const PassInfo *P) override {
241    if (P->isCFGOnlyPass())
242      CFGOnlyList.push_back(P->getTypeInfo());
243  }
244};
245
246} // end anonymous namespace
247
248// setPreservesCFG - This function should be called to by the pass, iff they do
249// not:
250//
251//  1. Add or remove basic blocks from the function
252//  2. Modify terminator instructions in any way.
253//
254// This function annotates the AnalysisUsage info object to say that analyses
255// that only depend on the CFG are preserved by this pass.
256void AnalysisUsage::setPreservesCFG() {
257  // Since this transformation doesn't modify the CFG, it preserves all analyses
258  // that only depend on the CFG (like dominators, loop info, etc...)
259  GetCFGOnlyPasses(Preserved).enumeratePasses();
260}
261
262AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) {
263  const PassInfo *PI = Pass::lookupPassInfo(Arg);
264  // If the pass exists, preserve it. Otherwise silently do nothing.
265  if (PI) Preserved.push_back(PI->getTypeInfo());
266  return *this;
267}
268
269AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) {
270  Required.push_back(ID);
271  return *this;
272}
273
274AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) {
275  Required.push_back(&ID);
276  return *this;
277}
278
279AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) {
280  Required.push_back(&ID);
281  RequiredTransitive.push_back(&ID);
282  return *this;
283}
284