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