Pass.cpp revision 353358
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 179//===----------------------------------------------------------------------===// 180// BasicBlockPass Implementation 181// 182 183Pass *BasicBlockPass::createPrinterPass(raw_ostream &OS, 184 const std::string &Banner) const { 185 return createPrintBasicBlockPass(OS, Banner); 186} 187 188bool BasicBlockPass::doInitialization(Function &) { 189 // By default, don't do anything. 190 return false; 191} 192 193bool BasicBlockPass::doFinalization(Function &) { 194 // By default, don't do anything. 195 return false; 196} 197 198static std::string getDescription(const BasicBlock &BB) { 199 return "basic block (" + BB.getName().str() + ") in function (" + 200 BB.getParent()->getName().str() + ")"; 201} 202 203bool BasicBlockPass::skipBasicBlock(const BasicBlock &BB) const { 204 const Function *F = BB.getParent(); 205 if (!F) 206 return false; 207 OptPassGate &Gate = F->getContext().getOptPassGate(); 208 if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(BB))) 209 return true; 210 if (F->hasOptNone()) { 211 // Report this only once per function. 212 if (&BB == &F->getEntryBlock()) 213 LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() 214 << "' on function " << F->getName() << "\n"); 215 return true; 216 } 217 return false; 218} 219 220PassManagerType BasicBlockPass::getPotentialPassManagerType() const { 221 return PMT_BasicBlockPassManager; 222} 223 224const PassInfo *Pass::lookupPassInfo(const void *TI) { 225 return PassRegistry::getPassRegistry()->getPassInfo(TI); 226} 227 228const PassInfo *Pass::lookupPassInfo(StringRef Arg) { 229 return PassRegistry::getPassRegistry()->getPassInfo(Arg); 230} 231 232Pass *Pass::createPass(AnalysisID ID) { 233 const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID); 234 if (!PI) 235 return nullptr; 236 return PI->createPass(); 237} 238 239//===----------------------------------------------------------------------===// 240// Analysis Group Implementation Code 241//===----------------------------------------------------------------------===// 242 243// RegisterAGBase implementation 244 245RegisterAGBase::RegisterAGBase(StringRef Name, const void *InterfaceID, 246 const void *PassID, bool isDefault) 247 : PassInfo(Name, InterfaceID) { 248 PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID, 249 *this, isDefault); 250} 251 252//===----------------------------------------------------------------------===// 253// PassRegistrationListener implementation 254// 255 256// enumeratePasses - Iterate over the registered passes, calling the 257// passEnumerate callback on each PassInfo object. 258void PassRegistrationListener::enumeratePasses() { 259 PassRegistry::getPassRegistry()->enumerateWith(this); 260} 261 262PassNameParser::PassNameParser(cl::Option &O) 263 : cl::parser<const PassInfo *>(O) { 264 PassRegistry::getPassRegistry()->addRegistrationListener(this); 265} 266 267// This only gets called during static destruction, in which case the 268// PassRegistry will have already been destroyed by llvm_shutdown(). So 269// attempting to remove the registration listener is an error. 270PassNameParser::~PassNameParser() = default; 271 272//===----------------------------------------------------------------------===// 273// AnalysisUsage Class Implementation 274// 275 276namespace { 277 278struct GetCFGOnlyPasses : public PassRegistrationListener { 279 using VectorType = AnalysisUsage::VectorType; 280 281 VectorType &CFGOnlyList; 282 283 GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {} 284 285 void passEnumerate(const PassInfo *P) override { 286 if (P->isCFGOnlyPass()) 287 CFGOnlyList.push_back(P->getTypeInfo()); 288 } 289}; 290 291} // end anonymous namespace 292 293// setPreservesCFG - This function should be called to by the pass, iff they do 294// not: 295// 296// 1. Add or remove basic blocks from the function 297// 2. Modify terminator instructions in any way. 298// 299// This function annotates the AnalysisUsage info object to say that analyses 300// that only depend on the CFG are preserved by this pass. 301void AnalysisUsage::setPreservesCFG() { 302 // Since this transformation doesn't modify the CFG, it preserves all analyses 303 // that only depend on the CFG (like dominators, loop info, etc...) 304 GetCFGOnlyPasses(Preserved).enumeratePasses(); 305} 306 307AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) { 308 const PassInfo *PI = Pass::lookupPassInfo(Arg); 309 // If the pass exists, preserve it. Otherwise silently do nothing. 310 if (PI) Preserved.push_back(PI->getTypeInfo()); 311 return *this; 312} 313 314AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) { 315 Required.push_back(ID); 316 return *this; 317} 318 319AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) { 320 Required.push_back(&ID); 321 return *this; 322} 323 324AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) { 325 Required.push_back(&ID); 326 RequiredTransitive.push_back(&ID); 327 return *this; 328} 329