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