Pass.cpp revision 327952
1249259Sdim//===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===//
2249259Sdim//
3249259Sdim//                     The LLVM Compiler Infrastructure
4249259Sdim//
5249259Sdim// This file is distributed under the University of Illinois Open Source
6249259Sdim// License. See LICENSE.TXT for details.
7249259Sdim//
8249259Sdim//===----------------------------------------------------------------------===//
9249259Sdim//
10249259Sdim// This file implements the LLVM Pass infrastructure.  It is primarily
11249259Sdim// responsible with ensuring that passes are executed and batched together
12249259Sdim// optimally.
13249259Sdim//
14249259Sdim//===----------------------------------------------------------------------===//
15249259Sdim
16249259Sdim#include "llvm/Pass.h"
17327952Sdim#include "llvm/IR/Attributes.h"
18327952Sdim#include "llvm/IR/BasicBlock.h"
19276479Sdim#include "llvm/IR/Function.h"
20276479Sdim#include "llvm/IR/IRPrintingPasses.h"
21327952Sdim#include "llvm/IR/LLVMContext.h"
22276479Sdim#include "llvm/IR/LegacyPassNameParser.h"
23309124Sdim#include "llvm/IR/Module.h"
24309124Sdim#include "llvm/IR/OptBisect.h"
25327952Sdim#include "llvm/PassInfo.h"
26249259Sdim#include "llvm/PassRegistry.h"
27327952Sdim#include "llvm/PassSupport.h"
28327952Sdim#include "llvm/Support/Compiler.h"
29249259Sdim#include "llvm/Support/Debug.h"
30249259Sdim#include "llvm/Support/raw_ostream.h"
31327952Sdim#include <cassert>
32327952Sdim
33249259Sdimusing namespace llvm;
34249259Sdim
35276479Sdim#define DEBUG_TYPE "ir"
36276479Sdim
37249259Sdim//===----------------------------------------------------------------------===//
38249259Sdim// Pass Implementation
39249259Sdim//
40249259Sdim
41249259Sdim// Force out-of-line virtual method.
42249259SdimPass::~Pass() {
43249259Sdim  delete Resolver;
44249259Sdim}
45249259Sdim
46249259Sdim// Force out-of-line virtual method.
47327952SdimModulePass::~ModulePass() = default;
48249259Sdim
49327952SdimPass *ModulePass::createPrinterPass(raw_ostream &OS,
50249259Sdim                                    const std::string &Banner) const {
51327952Sdim  return createPrintModulePass(OS, Banner);
52249259Sdim}
53249259Sdim
54249259SdimPassManagerType ModulePass::getPotentialPassManagerType() const {
55249259Sdim  return PMT_ModulePassManager;
56249259Sdim}
57249259Sdim
58309124Sdimbool ModulePass::skipModule(Module &M) const {
59309124Sdim  return !M.getContext().getOptBisect().shouldRunPass(this, M);
60309124Sdim}
61309124Sdim
62249259Sdimbool Pass::mustPreserveAnalysisID(char &AID) const {
63276479Sdim  return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr;
64249259Sdim}
65249259Sdim
66249259Sdim// dumpPassStructure - Implement the -debug-pass=Structure option
67249259Sdimvoid Pass::dumpPassStructure(unsigned Offset) {
68249259Sdim  dbgs().indent(Offset*2) << getPassName() << "\n";
69249259Sdim}
70249259Sdim
71249259Sdim/// getPassName - Return a nice clean name for a pass.  This usually
72249259Sdim/// implemented in terms of the name that is registered by one of the
73249259Sdim/// Registration templates, but can be overloaded directly.
74314564SdimStringRef Pass::getPassName() const {
75249259Sdim  AnalysisID AID =  getPassID();
76249259Sdim  const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID);
77249259Sdim  if (PI)
78249259Sdim    return PI->getPassName();
79249259Sdim  return "Unnamed pass: implement Pass::getPassName()";
80249259Sdim}
81249259Sdim
82249259Sdimvoid Pass::preparePassManager(PMStack &) {
83249259Sdim  // By default, don't do anything.
84249259Sdim}
85249259Sdim
86249259SdimPassManagerType Pass::getPotentialPassManagerType() const {
87249259Sdim  // Default implementation.
88249259Sdim  return PMT_Unknown;
89249259Sdim}
90249259Sdim
91249259Sdimvoid Pass::getAnalysisUsage(AnalysisUsage &) const {
92249259Sdim  // By default, no analysis results are used, all are invalidated.
93249259Sdim}
94249259Sdim
95249259Sdimvoid Pass::releaseMemory() {
96249259Sdim  // By default, don't do anything.
97249259Sdim}
98249259Sdim
99249259Sdimvoid Pass::verifyAnalysis() const {
100249259Sdim  // By default, don't do anything.
101249259Sdim}
102249259Sdim
103249259Sdimvoid *Pass::getAdjustedAnalysisPointer(AnalysisID AID) {
104249259Sdim  return this;
105249259Sdim}
106249259Sdim
107249259SdimImmutablePass *Pass::getAsImmutablePass() {
108276479Sdim  return nullptr;
109249259Sdim}
110249259Sdim
111249259SdimPMDataManager *Pass::getAsPMDataManager() {
112276479Sdim  return nullptr;
113249259Sdim}
114249259Sdim
115249259Sdimvoid Pass::setResolver(AnalysisResolver *AR) {
116249259Sdim  assert(!Resolver && "Resolver is already set");
117249259Sdim  Resolver = AR;
118249259Sdim}
119249259Sdim
120249259Sdim// print - Print out the internal state of the pass.  This is called by Analyze
121249259Sdim// to print out the contents of an analysis.  Otherwise it is not necessary to
122249259Sdim// implement this method.
123327952Sdimvoid Pass::print(raw_ostream &OS, const Module *) const {
124327952Sdim  OS << "Pass::print not implemented for pass: '" << getPassName() << "'!\n";
125249259Sdim}
126249259Sdim
127321369Sdim#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
128249259Sdim// dump - call print(cerr);
129309124SdimLLVM_DUMP_METHOD void Pass::dump() const {
130276479Sdim  print(dbgs(), nullptr);
131249259Sdim}
132321369Sdim#endif
133249259Sdim
134249259Sdim//===----------------------------------------------------------------------===//
135249259Sdim// ImmutablePass Implementation
136249259Sdim//
137249259Sdim// Force out-of-line virtual method.
138327952SdimImmutablePass::~ImmutablePass() = default;
139249259Sdim
140249259Sdimvoid ImmutablePass::initializePass() {
141249259Sdim  // By default, don't do anything.
142249259Sdim}
143249259Sdim
144249259Sdim//===----------------------------------------------------------------------===//
145249259Sdim// FunctionPass Implementation
146249259Sdim//
147249259Sdim
148327952SdimPass *FunctionPass::createPrinterPass(raw_ostream &OS,
149249259Sdim                                      const std::string &Banner) const {
150327952Sdim  return createPrintFunctionPass(OS, Banner);
151249259Sdim}
152249259Sdim
153249259SdimPassManagerType FunctionPass::getPotentialPassManagerType() const {
154249259Sdim  return PMT_FunctionPassManager;
155249259Sdim}
156249259Sdim
157309124Sdimbool FunctionPass::skipFunction(const Function &F) const {
158309124Sdim  if (!F.getContext().getOptBisect().shouldRunPass(this, F))
159309124Sdim    return true;
160309124Sdim
161276479Sdim  if (F.hasFnAttribute(Attribute::OptimizeNone)) {
162309124Sdim    DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
163309124Sdim                 << F.getName() << "\n");
164276479Sdim    return true;
165276479Sdim  }
166276479Sdim  return false;
167276479Sdim}
168276479Sdim
169249259Sdim//===----------------------------------------------------------------------===//
170249259Sdim// BasicBlockPass Implementation
171249259Sdim//
172249259Sdim
173327952SdimPass *BasicBlockPass::createPrinterPass(raw_ostream &OS,
174249259Sdim                                        const std::string &Banner) const {
175327952Sdim  return createPrintBasicBlockPass(OS, Banner);
176249259Sdim}
177249259Sdim
178249259Sdimbool BasicBlockPass::doInitialization(Function &) {
179249259Sdim  // By default, don't do anything.
180249259Sdim  return false;
181249259Sdim}
182249259Sdim
183249259Sdimbool BasicBlockPass::doFinalization(Function &) {
184249259Sdim  // By default, don't do anything.
185249259Sdim  return false;
186249259Sdim}
187249259Sdim
188309124Sdimbool BasicBlockPass::skipBasicBlock(const BasicBlock &BB) const {
189276479Sdim  const Function *F = BB.getParent();
190309124Sdim  if (!F)
191309124Sdim    return false;
192309124Sdim  if (!F->getContext().getOptBisect().shouldRunPass(this, BB))
193309124Sdim    return true;
194309124Sdim  if (F->hasFnAttribute(Attribute::OptimizeNone)) {
195276479Sdim    // Report this only once per function.
196276479Sdim    if (&BB == &F->getEntryBlock())
197276479Sdim      DEBUG(dbgs() << "Skipping pass '" << getPassName()
198276479Sdim            << "' on function " << F->getName() << "\n");
199276479Sdim    return true;
200276479Sdim  }
201276479Sdim  return false;
202276479Sdim}
203276479Sdim
204249259SdimPassManagerType BasicBlockPass::getPotentialPassManagerType() const {
205249259Sdim  return PMT_BasicBlockPassManager;
206249259Sdim}
207249259Sdim
208249259Sdimconst PassInfo *Pass::lookupPassInfo(const void *TI) {
209249259Sdim  return PassRegistry::getPassRegistry()->getPassInfo(TI);
210249259Sdim}
211249259Sdim
212249259Sdimconst PassInfo *Pass::lookupPassInfo(StringRef Arg) {
213249259Sdim  return PassRegistry::getPassRegistry()->getPassInfo(Arg);
214249259Sdim}
215249259Sdim
216249259SdimPass *Pass::createPass(AnalysisID ID) {
217249259Sdim  const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID);
218249259Sdim  if (!PI)
219276479Sdim    return nullptr;
220249259Sdim  return PI->createPass();
221249259Sdim}
222249259Sdim
223249259Sdim//===----------------------------------------------------------------------===//
224249259Sdim//                  Analysis Group Implementation Code
225249259Sdim//===----------------------------------------------------------------------===//
226249259Sdim
227249259Sdim// RegisterAGBase implementation
228327952Sdim
229314564SdimRegisterAGBase::RegisterAGBase(StringRef Name, const void *InterfaceID,
230249259Sdim                               const void *PassID, bool isDefault)
231249259Sdim    : PassInfo(Name, InterfaceID) {
232249259Sdim  PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID,
233249259Sdim                                                         *this, isDefault);
234249259Sdim}
235249259Sdim
236249259Sdim//===----------------------------------------------------------------------===//
237249259Sdim// PassRegistrationListener implementation
238249259Sdim//
239249259Sdim
240249259Sdim// enumeratePasses - Iterate over the registered passes, calling the
241249259Sdim// passEnumerate callback on each PassInfo object.
242249259Sdimvoid PassRegistrationListener::enumeratePasses() {
243249259Sdim  PassRegistry::getPassRegistry()->enumerateWith(this);
244249259Sdim}
245249259Sdim
246288943SdimPassNameParser::PassNameParser(cl::Option &O)
247288943Sdim    : cl::parser<const PassInfo *>(O) {
248276479Sdim  PassRegistry::getPassRegistry()->addRegistrationListener(this);
249276479Sdim}
250249259Sdim
251327952Sdim// This only gets called during static destruction, in which case the
252327952Sdim// PassRegistry will have already been destroyed by llvm_shutdown().  So
253327952Sdim// attempting to remove the registration listener is an error.
254327952SdimPassNameParser::~PassNameParser() = default;
255276479Sdim
256249259Sdim//===----------------------------------------------------------------------===//
257249259Sdim//   AnalysisUsage Class Implementation
258249259Sdim//
259249259Sdim
260249259Sdimnamespace {
261249259Sdim
262327952Sdimstruct GetCFGOnlyPasses : public PassRegistrationListener {
263327952Sdim  using VectorType = AnalysisUsage::VectorType;
264249259Sdim
265327952Sdim  VectorType &CFGOnlyList;
266327952Sdim
267327952Sdim  GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}
268327952Sdim
269327952Sdim  void passEnumerate(const PassInfo *P) override {
270327952Sdim    if (P->isCFGOnlyPass())
271327952Sdim      CFGOnlyList.push_back(P->getTypeInfo());
272327952Sdim  }
273327952Sdim};
274327952Sdim
275327952Sdim} // end anonymous namespace
276327952Sdim
277249259Sdim// setPreservesCFG - This function should be called to by the pass, iff they do
278249259Sdim// not:
279249259Sdim//
280249259Sdim//  1. Add or remove basic blocks from the function
281249259Sdim//  2. Modify terminator instructions in any way.
282249259Sdim//
283249259Sdim// This function annotates the AnalysisUsage info object to say that analyses
284249259Sdim// that only depend on the CFG are preserved by this pass.
285249259Sdimvoid AnalysisUsage::setPreservesCFG() {
286249259Sdim  // Since this transformation doesn't modify the CFG, it preserves all analyses
287249259Sdim  // that only depend on the CFG (like dominators, loop info, etc...)
288249259Sdim  GetCFGOnlyPasses(Preserved).enumeratePasses();
289249259Sdim}
290249259Sdim
291249259SdimAnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) {
292249259Sdim  const PassInfo *PI = Pass::lookupPassInfo(Arg);
293249259Sdim  // If the pass exists, preserve it. Otherwise silently do nothing.
294249259Sdim  if (PI) Preserved.push_back(PI->getTypeInfo());
295249259Sdim  return *this;
296249259Sdim}
297249259Sdim
298249259SdimAnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) {
299249259Sdim  Required.push_back(ID);
300249259Sdim  return *this;
301249259Sdim}
302249259Sdim
303249259SdimAnalysisUsage &AnalysisUsage::addRequiredID(char &ID) {
304249259Sdim  Required.push_back(&ID);
305249259Sdim  return *this;
306249259Sdim}
307249259Sdim
308249259SdimAnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) {
309249259Sdim  Required.push_back(&ID);
310249259Sdim  RequiredTransitive.push_back(&ID);
311249259Sdim  return *this;
312249259Sdim}
313