contrib/llvm/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/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 Pass::~Pass() {
  44   delete Resolver;
  45 }
  46
  47 // Force out-of-line virtual method.
  48 ModulePass::~ModulePass() = default;
  49
  50 Pass *ModulePass::createPrinterPass(raw_ostream &OS,
  51                                     const std::string &Banner) const {
  52   return createPrintModulePass(OS, Banner);
  53 }
  54
  55 PassManagerType ModulePass::getPotentialPassManagerType() const {
  56   return PMT_ModulePassManager;
  57 }
  58
  59 bool ModulePass::skipModule(Module &M) const {
  60   return !M.getContext().getOptPassGate().shouldRunPass(this, M);
  61 }
  62
  63 bool Pass::mustPreserveAnalysisID(char &AID) const {
  64   return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr;
  65 }
  66
  67 // dumpPassStructure - Implement the -debug-pass=Structure option
  68 void Pass::dumpPassStructure(unsigned Offset) {
  69   dbgs().indent(Offset*2) << getPassName() << "\n";
  70 }
  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 /// Registration templates, but can be overloaded directly.
  75 StringRef Pass::getPassName() const {
  76   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 }
  82
  83 void Pass::preparePassManager(PMStack &) {
  84   // By default, don't do anything.
  85 }
  86
  87 PassManagerType Pass::getPotentialPassManagerType() const {
  88   // Default implementation.
  89   return PMT_Unknown;
  90 }
  91
  92 void Pass::getAnalysisUsage(AnalysisUsage &) const {
  93   // By default, no analysis results are used, all are invalidated.
  94 }
  95
  96 void Pass::releaseMemory() {
  97   // By default, don't do anything.
  98 }
  99
 100 void Pass::verifyAnalysis() const {
 101   // By default, don't do anything.
 102 }
 103
 104 void *Pass::getAdjustedAnalysisPointer(AnalysisID AID) {
 105   return this;
 106 }
 107
 108 ImmutablePass *Pass::getAsImmutablePass() {
 109   return nullptr;
 110 }
 111
 112 PMDataManager *Pass::getAsPMDataManager() {
 113   return nullptr;
 114 }
 115
 116 void Pass::setResolver(AnalysisResolver *AR) {
 117   assert(!Resolver && "Resolver is already set");
 118   Resolver = AR;
 119 }
 120
 121 // print - Print out the internal state of the pass.  This is called by Analyze
 122 // to print out the contents of an analysis.  Otherwise it is not necessary to
 123 // implement this method.
 124 void Pass::print(raw_ostream &OS, const Module *) const {
 125   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 LLVM_DUMP_METHOD void Pass::dump() const {
 131   print(dbgs(), nullptr);
 132 }
 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 //
 148
 149 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   return PMT_FunctionPassManager;
 156 }
 157
 158 bool FunctionPass::skipFunction(const Function &F) const {
 159   if (!F.getContext().getOptPassGate().shouldRunPass(this, F))
 160     return true;
 161
 162   if (F.hasFnAttribute(Attribute::OptimizeNone)) {
 163     LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function "
 164                       << F.getName() << "\n");
 165     return true;
 166   }
 167   return false;
 168 }
 169
 170 //===----------------------------------------------------------------------===//
 171 // 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   // By default, don't do anything.
 181   return false;
 182 }
 183
 184 bool BasicBlockPass::doFinalization(Function &) {
 185   // By default, don't do anything.
 186   return false;
 187 }
 188
 189 bool BasicBlockPass::skipBasicBlock(const BasicBlock &BB) const {
 190   const Function *F = BB.getParent();
 191   if (!F)
 192     return false;
 193   if (!F->getContext().getOptPassGate().shouldRunPass(this, BB))
 194     return true;
 195   if (F->hasFnAttribute(Attribute::OptimizeNone)) {
 196     // Report this only once per function.
 197     if (&BB == &F->getEntryBlock())
 198       LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName()
 199                         << "' on function " << F->getName() << "\n");
 200     return true;
 201   }
 202   return false;
 203 }
 204
 205 PassManagerType BasicBlockPass::getPotentialPassManagerType() const {
 206   return PMT_BasicBlockPassManager;
 207 }
 208
 209 const PassInfo *Pass::lookupPassInfo(const void *TI) {
 210   return PassRegistry::getPassRegistry()->getPassInfo(TI);
 211 }
 212
 213 const PassInfo *Pass::lookupPassInfo(StringRef Arg) {
 214   return PassRegistry::getPassRegistry()->getPassInfo(Arg);
 215 }
 216
 217 Pass *Pass::createPass(AnalysisID ID) {
 218   const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID);
 219   if (!PI)
 220     return nullptr;
 221   return PI->createPass();
 222 }
 223
 224 //===----------------------------------------------------------------------===//
 225 //                  Analysis Group Implementation Code
 226 //===----------------------------------------------------------------------===//
 227
 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
 237 //===----------------------------------------------------------------------===//
 238 // PassRegistrationListener implementation
 239 //
 240
 241 // 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   PassRegistry::getPassRegistry()->addRegistrationListener(this);
 250 }
 251
 252 // This only gets called during static destruction, in which case the
 253 // PassRegistry will have already been destroyed by llvm_shutdown().  So
 254 // attempting to remove the registration listener is an error.
 255 PassNameParser::~PassNameParser() = default;
 256
 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 };
 275
 276 } // end anonymous namespace
 277
 278 // setPreservesCFG - This function should be called to by the pass, iff they do
 279 // 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 AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) {
 293   const PassInfo *PI = Pass::lookupPassInfo(Arg);
 294   // If the pass exists, preserve it. Otherwise silently do nothing.
 295   if (PI) Preserved.push_back(PI->getTypeInfo());
 296   return *this;
 297 }
 298
 299 AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) {
 300   Required.push_back(ID);
 301   return *this;
 302 }
 303
 304 AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) {
 305   Required.push_back(&ID);
 306   return *this;
 307 }
 308
 309 AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) {
 310   Required.push_back(&ID);
 311   RequiredTransitive.push_back(&ID);
 312   return *this;
 313 }