1249259Sdim//===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===// 2249259Sdim// 3353358Sdim// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4353358Sdim// See https://llvm.org/LICENSE.txt for license information. 5353358Sdim// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6249259Sdim// 7249259Sdim//===----------------------------------------------------------------------===// 8249259Sdim// 9249259Sdim// This file implements the LLVM Pass infrastructure. It is primarily 10249259Sdim// responsible with ensuring that passes are executed and batched together 11249259Sdim// optimally. 12249259Sdim// 13249259Sdim//===----------------------------------------------------------------------===// 14249259Sdim 15249259Sdim#include "llvm/Pass.h" 16341825Sdim#include "llvm/Config/llvm-config.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 58353358Sdimstatic std::string getDescription(const Module &M) { 59353358Sdim return "module (" + M.getName().str() + ")"; 60353358Sdim} 61353358Sdim 62309124Sdimbool ModulePass::skipModule(Module &M) const { 63353358Sdim OptPassGate &Gate = M.getContext().getOptPassGate(); 64353358Sdim return Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(M)); 65309124Sdim} 66309124Sdim 67249259Sdimbool Pass::mustPreserveAnalysisID(char &AID) const { 68276479Sdim return Resolver->getAnalysisIfAvailable(&AID, true) != nullptr; 69249259Sdim} 70249259Sdim 71249259Sdim// dumpPassStructure - Implement the -debug-pass=Structure option 72249259Sdimvoid Pass::dumpPassStructure(unsigned Offset) { 73249259Sdim dbgs().indent(Offset*2) << getPassName() << "\n"; 74249259Sdim} 75249259Sdim 76249259Sdim/// getPassName - Return a nice clean name for a pass. This usually 77249259Sdim/// implemented in terms of the name that is registered by one of the 78249259Sdim/// Registration templates, but can be overloaded directly. 79314564SdimStringRef Pass::getPassName() const { 80249259Sdim AnalysisID AID = getPassID(); 81249259Sdim const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID); 82249259Sdim if (PI) 83249259Sdim return PI->getPassName(); 84249259Sdim return "Unnamed pass: implement Pass::getPassName()"; 85249259Sdim} 86249259Sdim 87249259Sdimvoid Pass::preparePassManager(PMStack &) { 88249259Sdim // By default, don't do anything. 89249259Sdim} 90249259Sdim 91249259SdimPassManagerType Pass::getPotentialPassManagerType() const { 92249259Sdim // Default implementation. 93249259Sdim return PMT_Unknown; 94249259Sdim} 95249259Sdim 96249259Sdimvoid Pass::getAnalysisUsage(AnalysisUsage &) const { 97249259Sdim // By default, no analysis results are used, all are invalidated. 98249259Sdim} 99249259Sdim 100249259Sdimvoid Pass::releaseMemory() { 101249259Sdim // By default, don't do anything. 102249259Sdim} 103249259Sdim 104249259Sdimvoid Pass::verifyAnalysis() const { 105249259Sdim // By default, don't do anything. 106249259Sdim} 107249259Sdim 108249259Sdimvoid *Pass::getAdjustedAnalysisPointer(AnalysisID AID) { 109249259Sdim return this; 110249259Sdim} 111249259Sdim 112249259SdimImmutablePass *Pass::getAsImmutablePass() { 113276479Sdim return nullptr; 114249259Sdim} 115249259Sdim 116249259SdimPMDataManager *Pass::getAsPMDataManager() { 117276479Sdim return nullptr; 118249259Sdim} 119249259Sdim 120249259Sdimvoid Pass::setResolver(AnalysisResolver *AR) { 121249259Sdim assert(!Resolver && "Resolver is already set"); 122249259Sdim Resolver = AR; 123249259Sdim} 124249259Sdim 125249259Sdim// print - Print out the internal state of the pass. This is called by Analyze 126249259Sdim// to print out the contents of an analysis. Otherwise it is not necessary to 127249259Sdim// implement this method. 128327952Sdimvoid Pass::print(raw_ostream &OS, const Module *) const { 129327952Sdim OS << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; 130249259Sdim} 131249259Sdim 132321369Sdim#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) 133249259Sdim// dump - call print(cerr); 134309124SdimLLVM_DUMP_METHOD void Pass::dump() const { 135276479Sdim print(dbgs(), nullptr); 136249259Sdim} 137321369Sdim#endif 138249259Sdim 139249259Sdim//===----------------------------------------------------------------------===// 140249259Sdim// ImmutablePass Implementation 141249259Sdim// 142249259Sdim// Force out-of-line virtual method. 143327952SdimImmutablePass::~ImmutablePass() = default; 144249259Sdim 145249259Sdimvoid ImmutablePass::initializePass() { 146249259Sdim // By default, don't do anything. 147249259Sdim} 148249259Sdim 149249259Sdim//===----------------------------------------------------------------------===// 150249259Sdim// FunctionPass Implementation 151249259Sdim// 152249259Sdim 153327952SdimPass *FunctionPass::createPrinterPass(raw_ostream &OS, 154249259Sdim const std::string &Banner) const { 155327952Sdim return createPrintFunctionPass(OS, Banner); 156249259Sdim} 157249259Sdim 158249259SdimPassManagerType FunctionPass::getPotentialPassManagerType() const { 159249259Sdim return PMT_FunctionPassManager; 160249259Sdim} 161249259Sdim 162353358Sdimstatic std::string getDescription(const Function &F) { 163353358Sdim return "function (" + F.getName().str() + ")"; 164353358Sdim} 165353358Sdim 166309124Sdimbool FunctionPass::skipFunction(const Function &F) const { 167353358Sdim OptPassGate &Gate = F.getContext().getOptPassGate(); 168353358Sdim if (Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(F))) 169309124Sdim return true; 170309124Sdim 171353358Sdim if (F.hasOptNone()) { 172341825Sdim LLVM_DEBUG(dbgs() << "Skipping pass '" << getPassName() << "' on function " 173341825Sdim << F.getName() << "\n"); 174276479Sdim return true; 175276479Sdim } 176276479Sdim return false; 177276479Sdim} 178276479Sdim 179249259Sdimconst PassInfo *Pass::lookupPassInfo(const void *TI) { 180249259Sdim return PassRegistry::getPassRegistry()->getPassInfo(TI); 181249259Sdim} 182249259Sdim 183249259Sdimconst PassInfo *Pass::lookupPassInfo(StringRef Arg) { 184249259Sdim return PassRegistry::getPassRegistry()->getPassInfo(Arg); 185249259Sdim} 186249259Sdim 187249259SdimPass *Pass::createPass(AnalysisID ID) { 188249259Sdim const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID); 189249259Sdim if (!PI) 190276479Sdim return nullptr; 191249259Sdim return PI->createPass(); 192249259Sdim} 193249259Sdim 194249259Sdim//===----------------------------------------------------------------------===// 195249259Sdim// Analysis Group Implementation Code 196249259Sdim//===----------------------------------------------------------------------===// 197249259Sdim 198249259Sdim// RegisterAGBase implementation 199327952Sdim 200314564SdimRegisterAGBase::RegisterAGBase(StringRef Name, const void *InterfaceID, 201249259Sdim const void *PassID, bool isDefault) 202249259Sdim : PassInfo(Name, InterfaceID) { 203249259Sdim PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID, 204249259Sdim *this, isDefault); 205249259Sdim} 206249259Sdim 207249259Sdim//===----------------------------------------------------------------------===// 208249259Sdim// PassRegistrationListener implementation 209249259Sdim// 210249259Sdim 211249259Sdim// enumeratePasses - Iterate over the registered passes, calling the 212249259Sdim// passEnumerate callback on each PassInfo object. 213249259Sdimvoid PassRegistrationListener::enumeratePasses() { 214249259Sdim PassRegistry::getPassRegistry()->enumerateWith(this); 215249259Sdim} 216249259Sdim 217288943SdimPassNameParser::PassNameParser(cl::Option &O) 218288943Sdim : cl::parser<const PassInfo *>(O) { 219276479Sdim PassRegistry::getPassRegistry()->addRegistrationListener(this); 220276479Sdim} 221249259Sdim 222327952Sdim// This only gets called during static destruction, in which case the 223327952Sdim// PassRegistry will have already been destroyed by llvm_shutdown(). So 224327952Sdim// attempting to remove the registration listener is an error. 225327952SdimPassNameParser::~PassNameParser() = default; 226276479Sdim 227249259Sdim//===----------------------------------------------------------------------===// 228249259Sdim// AnalysisUsage Class Implementation 229249259Sdim// 230249259Sdim 231249259Sdimnamespace { 232249259Sdim 233327952Sdimstruct GetCFGOnlyPasses : public PassRegistrationListener { 234327952Sdim using VectorType = AnalysisUsage::VectorType; 235249259Sdim 236327952Sdim VectorType &CFGOnlyList; 237327952Sdim 238327952Sdim GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {} 239327952Sdim 240327952Sdim void passEnumerate(const PassInfo *P) override { 241327952Sdim if (P->isCFGOnlyPass()) 242327952Sdim CFGOnlyList.push_back(P->getTypeInfo()); 243327952Sdim } 244327952Sdim}; 245327952Sdim 246327952Sdim} // end anonymous namespace 247327952Sdim 248249259Sdim// setPreservesCFG - This function should be called to by the pass, iff they do 249249259Sdim// not: 250249259Sdim// 251249259Sdim// 1. Add or remove basic blocks from the function 252249259Sdim// 2. Modify terminator instructions in any way. 253249259Sdim// 254249259Sdim// This function annotates the AnalysisUsage info object to say that analyses 255249259Sdim// that only depend on the CFG are preserved by this pass. 256249259Sdimvoid AnalysisUsage::setPreservesCFG() { 257249259Sdim // Since this transformation doesn't modify the CFG, it preserves all analyses 258249259Sdim // that only depend on the CFG (like dominators, loop info, etc...) 259249259Sdim GetCFGOnlyPasses(Preserved).enumeratePasses(); 260249259Sdim} 261249259Sdim 262249259SdimAnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) { 263249259Sdim const PassInfo *PI = Pass::lookupPassInfo(Arg); 264249259Sdim // If the pass exists, preserve it. Otherwise silently do nothing. 265249259Sdim if (PI) Preserved.push_back(PI->getTypeInfo()); 266249259Sdim return *this; 267249259Sdim} 268249259Sdim 269249259SdimAnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) { 270249259Sdim Required.push_back(ID); 271249259Sdim return *this; 272249259Sdim} 273249259Sdim 274249259SdimAnalysisUsage &AnalysisUsage::addRequiredID(char &ID) { 275249259Sdim Required.push_back(&ID); 276249259Sdim return *this; 277249259Sdim} 278249259Sdim 279249259SdimAnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) { 280249259Sdim Required.push_back(&ID); 281249259Sdim RequiredTransitive.push_back(&ID); 282249259Sdim return *this; 283249259Sdim} 284