lib/IR/Pass.cpp

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