X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPass.cpp;h=d04f90c127a295f342da38ac58d8c59eb21977f6;hb=629c1a3f78494d0dd769fe82bd2bd17df0555843;hp=b6e222d98aae1e3681011c800f858696e790d78f;hpb=221d688a5ef21a22c2368c9fff0e92d7966c95e5;p=oota-llvm.git diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index b6e222d98aa..d04f90c127a 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -1,4 +1,11 @@ -//===- Pass.cpp - LLVM Pass Infrastructure Impementation ------------------===// +//===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// // // This file implements the LLVM Pass infrastructure. It is primarily // responsible with ensuring that passes are executed and batched together @@ -6,171 +13,310 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Pass.h" #include "llvm/PassManager.h" #include "llvm/Module.h" -#include "llvm/Method.h" -#include "llvm/BasicBlock.h" -#include "Support/STLExtras.h" +#include "llvm/ModuleProvider.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/Support/ManagedStatic.h" #include +#include +#include +using namespace llvm; -// Source of unique analysis ID #'s. -unsigned AnalysisID::NextID = 0; +//===----------------------------------------------------------------------===// +// Pass Implementation +// -void AnalysisResolver::setAnalysisResolver(Pass *P, AnalysisResolver *AR) { - assert(P->Resolver == 0 && "Pass already in a PassManager!"); - P->Resolver = AR; +// Force out-of-line virtual method. +Pass::~Pass() { + delete Resolver; } +// Force out-of-line virtual method. +ModulePass::~ModulePass() { } -// Pass debugging information. Often it is useful to find out what pass is -// running when a crash occurs in a utility. When this library is compiled with -// debugging on, a command line option (--debug-pass) is enabled that causes the -// pass name to be printed before it executes. -// -#ifndef NDEBUG -#include "Support/CommandLine.h" -#include -#include +bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const { + return Resolver->getAnalysisToUpdate(AnalysisID, true) != 0; +} -// Different debug levels that can be enabled... -enum PassDebugLevel { - None, PassStructure, PassExecutions, PassDetails -}; +// dumpPassStructure - Implement the -debug-passes=Structure option +void Pass::dumpPassStructure(unsigned Offset) { + cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; +} -static cl::Enum PassDebugging("debug-pass", cl::Hidden, - "Print PassManager debugging information", - clEnumVal(None , "disable debug output"), - clEnumVal(PassStructure , "print pass structure before run()"), - clEnumVal(PassExecutions, "print pass name before it is executed"), - clEnumVal(PassDetails , "print pass details when it is executed"), 0); - -void PMDebug::PrintPassStructure(Pass *P) { - if (PassDebugging >= PassStructure) - P->dumpPassStructure(); -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, Value *V) { - if (PassDebugging >= PassExecutions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << typeid(*P).name(); - if (V) { - std::cerr << "' on "; - switch (V->getValueType()) { - case Value::ModuleVal: - std::cerr << "Module\n"; return; - case Value::MethodVal: - std::cerr << "Method '" << V->getName(); break; - case Value::BasicBlockVal: - std::cerr << "BasicBlock '" << V->getName(); break; - default: - std::cerr << typeid(*V).name() << " '" << V->getName(); break; - } - } - std::cerr << "'...\n"; - } +/// getPassName - Return a nice clean name for a pass. This usually +/// implemented in terms of the name that is registered by one of the +/// Registration templates, but can be overloaded directly. +/// +const char *Pass::getPassName() const { + if (const PassInfo *PI = getPassInfo()) + return PI->getPassName(); + return "Unnamed pass: implement Pass::getPassName()"; } -void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg, - Pass *P, const Pass::AnalysisSet &Set) { - if (PassDebugging >= PassDetails && !Set.empty()) { - std::cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:"; - for (unsigned i = 0; i < Set.size(); ++i) { - Pass *P = Set[i].createPass(); // Good thing this is just debug code... - std::cerr << " " << typeid(*P).name(); - delete P; - } - std::cerr << "\n"; - } +// print - Print out the internal state of the pass. This is called by Analyze +// to print out the contents of an analysis. Otherwise it is not necessary to +// implement this method. +// +void Pass::print(std::ostream &O,const Module*) const { + O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; } -// dumpPassStructure - Implement the -debug-passes=PassStructure option -void Pass::dumpPassStructure(unsigned Offset = 0) { - std::cerr << std::string(Offset*2, ' ') << typeid(*this).name() << "\n"; +// dump - call print(cerr); +void Pass::dump() const { + print(*cerr.stream(), 0); } -#endif +//===----------------------------------------------------------------------===// +// ImmutablePass Implementation +// +// Force out-of-line virtual method. +ImmutablePass::~ImmutablePass() { } //===----------------------------------------------------------------------===// -// Pass Implementation +// FunctionPass Implementation // -void Pass::addToPassManager(PassManagerT *PM, AnalysisSet &Required, - AnalysisSet &Destroyed, AnalysisSet &Provided) { - PM->addPass(this, Required, Destroyed, Provided); +// run - On a module, we run this pass by initializing, runOnFunction'ing once +// for every function in the module, then by finalizing. +// +bool FunctionPass::runOnModule(Module &M) { + bool Changed = doInitialization(M); + + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + if (!I->isDeclaration()) // Passes are not run on external functions! + Changed |= runOnFunction(*I); + + return Changed | doFinalization(M); +} + +// run - On a function, we simply initialize, run the function, then finalize. +// +bool FunctionPass::run(Function &F) { + // Passes are not run on external functions! + if (F.isDeclaration()) return false; + + bool Changed = doInitialization(*F.getParent()); + Changed |= runOnFunction(F); + return Changed | doFinalization(*F.getParent()); } //===----------------------------------------------------------------------===// -// MethodPass Implementation +// BasicBlockPass Implementation // -// run - On a module, we run this pass by initializing, ronOnMethod'ing once -// for every method in the module, then by finalizing. +// To run this pass on a function, we simply call runOnBasicBlock once for each +// function. // -bool MethodPass::run(Module *M) { - bool Changed = doInitialization(M); +bool BasicBlockPass::runOnFunction(Function &F) { + bool Changed = doInitialization(F); + for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) + Changed |= runOnBasicBlock(*I); + return Changed | doFinalization(F); +} + +//===----------------------------------------------------------------------===// +// Pass Registration mechanism +// +namespace { +class PassRegistrar { + /// PassInfoMap - Keep track of the passinfo object for each registered llvm + /// pass. + typedef std::map MapType; + MapType PassInfoMap; - for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) - if (!(*I)->isExternal()) // Passes are not run on external methods! - Changed |= runOnMethod(*I); + /// AnalysisGroupInfo - Keep track of information for each analysis group. + struct AnalysisGroupInfo { + const PassInfo *DefaultImpl; + std::set Implementations; + AnalysisGroupInfo() : DefaultImpl(0) {} + }; - return Changed | doFinalization(M); + /// AnalysisGroupInfoMap - Information for each analysis group. + std::map AnalysisGroupInfoMap; + +public: + + const PassInfo *GetPassInfo(intptr_t TI) const { + MapType::const_iterator I = PassInfoMap.find(TI); + return I != PassInfoMap.end() ? I->second : 0; + } + + void RegisterPass(const PassInfo &PI) { + bool Inserted = + PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; + assert(Inserted && "Pass registered multiple times!"); Inserted=Inserted; + } + + void UnregisterPass(const PassInfo &PI) { + MapType::iterator I = PassInfoMap.find(PI.getTypeInfo()); + assert(I != PassInfoMap.end() && "Pass registered but not in map!"); + + // Remove pass from the map. + PassInfoMap.erase(I); + } + + void EnumerateWith(PassRegistrationListener *L) { + for (MapType::const_iterator I = PassInfoMap.begin(), + E = PassInfoMap.end(); I != E; ++I) + L->passEnumerate(I->second); + } + + + /// Analysis Group Mechanisms. + void RegisterAnalysisGroup(PassInfo *InterfaceInfo, + const PassInfo *ImplementationInfo, + bool isDefault) { + AnalysisGroupInfo &AGI = AnalysisGroupInfoMap[InterfaceInfo]; + assert(AGI.Implementations.count(ImplementationInfo) == 0 && + "Cannot add a pass to the same analysis group more than once!"); + AGI.Implementations.insert(ImplementationInfo); + if (isDefault) { + assert(AGI.DefaultImpl == 0 && InterfaceInfo->getNormalCtor() == 0 && + "Default implementation for analysis group already specified!"); + assert(ImplementationInfo->getNormalCtor() && + "Cannot specify pass as default if it does not have a default ctor"); + AGI.DefaultImpl = ImplementationInfo; + InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); + } + } +}; } -// run - On a method, we simply initialize, run the method, then finalize. -// -bool MethodPass::run(Method *M) { - if (M->isExternal()) return false; // Passes are not run on external methods! +static std::vector *Listeners = 0; - return doInitialization(M->getParent()) | runOnMethod(M) - | doFinalization(M->getParent()); +// FIXME: This should use ManagedStatic to manage the pass registrar. +// Unfortunately, we can't do this, because passes are registered with static +// ctors, and having llvm_shutdown clear this map prevents successful +// ressurection after llvm_shutdown is run. +static PassRegistrar *getPassRegistrar() { + static PassRegistrar *PassRegistrarObj = 0; + if (!PassRegistrarObj) + PassRegistrarObj = new PassRegistrar(); + return PassRegistrarObj; } -void MethodPass::addToPassManager(PassManagerT *PM, - AnalysisSet &Required, AnalysisSet &Destroyed, - AnalysisSet &Provided) { - PM->addPass(this, Required, Destroyed, Provided); +// getPassInfo - Return the PassInfo data structure that corresponds to this +// pass... +const PassInfo *Pass::getPassInfo() const { + return lookupPassInfo(PassID); } -void MethodPass::addToPassManager(PassManagerT *PM, - AnalysisSet &Required, AnalysisSet &Destroyed, - AnalysisSet &Provided) { - PM->addPass(this, Required, Destroyed, Provided); +const PassInfo *Pass::lookupPassInfo(intptr_t TI) { + return getPassRegistrar()->GetPassInfo(TI); +} + +void PassInfo::registerPass() { + getPassRegistrar()->RegisterPass(*this); + + // Notify any listeners. + if (Listeners) + for (std::vector::iterator + I = Listeners->begin(), E = Listeners->end(); I != E; ++I) + (*I)->passRegistered(this); +} + +void PassInfo::unregisterPass() { + getPassRegistrar()->UnregisterPass(*this); } //===----------------------------------------------------------------------===// -// BasicBlockPass Implementation +// Analysis Group Implementation Code +//===----------------------------------------------------------------------===// + +// RegisterAGBase implementation // +RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID, + intptr_t PassID, bool isDefault) + : PassInfo(Name, InterfaceID), + ImplementationInfo(0), isDefaultImplementation(isDefault) { + + InterfaceInfo = const_cast(Pass::lookupPassInfo(InterfaceID)); + if (InterfaceInfo == 0) { + // First reference to Interface, register it now. + registerPass(); + InterfaceInfo = this; + } + assert(isAnalysisGroup() && + "Trying to join an analysis group that is a normal pass!"); -// To run this pass on a method, we simply call runOnBasicBlock once for each -// method. + if (PassID) { + ImplementationInfo = Pass::lookupPassInfo(PassID); + assert(ImplementationInfo && + "Must register pass before adding to AnalysisGroup!"); + + // Make sure we keep track of the fact that the implementation implements + // the interface. + PassInfo *IIPI = const_cast(ImplementationInfo); + IIPI->addInterfaceImplemented(InterfaceInfo); + + getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault); + } +} + + +//===----------------------------------------------------------------------===// +// PassRegistrationListener implementation // -bool BasicBlockPass::runOnMethod(Method *M) { - bool Changed = false; - for (Method::iterator I = M->begin(), E = M->end(); I != E; ++I) - Changed |= runOnBasicBlock(*I); - return Changed; + +// PassRegistrationListener ctor - Add the current object to the list of +// PassRegistrationListeners... +PassRegistrationListener::PassRegistrationListener() { + if (!Listeners) Listeners = new std::vector(); + Listeners->push_back(this); +} + +// dtor - Remove object from list of listeners... +PassRegistrationListener::~PassRegistrationListener() { + std::vector::iterator I = + std::find(Listeners->begin(), Listeners->end(), this); + assert(Listeners && I != Listeners->end() && + "PassRegistrationListener not registered!"); + Listeners->erase(I); + + if (Listeners->empty()) { + delete Listeners; + Listeners = 0; + } } -// To run directly on the basic block, we initialize, runOnBasicBlock, then -// finalize. +// enumeratePasses - Iterate over the registered passes, calling the +// passEnumerate callback on each PassInfo object. // -bool BasicBlockPass::run(BasicBlock *BB) { - Module *M = BB->getParent()->getParent(); - return doInitialization(M) | runOnBasicBlock(BB) | doFinalization(M); +void PassRegistrationListener::enumeratePasses() { + getPassRegistrar()->EnumerateWith(this); } -void BasicBlockPass::addToPassManager(PassManagerT *PM, - AnalysisSet &Required, - AnalysisSet &Destroyed, - AnalysisSet &Provided) { - PM->addPass(this, Required, Destroyed, Provided); +//===----------------------------------------------------------------------===// +// AnalysisUsage Class Implementation +// + +namespace { + struct GetCFGOnlyPasses : public PassRegistrationListener { + std::vector &CFGOnlyList; + GetCFGOnlyPasses(std::vector &L) : CFGOnlyList(L) {} + + void passEnumerate(const PassInfo *P) { + if (P->isCFGOnlyPass()) + CFGOnlyList.push_back(P); + } + }; } -void BasicBlockPass::addToPassManager(PassManagerT *PM, - AnalysisSet &Required, - AnalysisSet &Destroyed, - AnalysisSet &Provided) { - PM->addPass(this, Required, Destroyed, Provided); +// setPreservesCFG - This function should be called to by the pass, iff they do +// not: +// +// 1. Add or remove basic blocks from the function +// 2. Modify terminator instructions in any way. +// +// This function annotates the AnalysisUsage info object to say that analyses +// that only depend on the CFG are preserved by this pass. +// +void AnalysisUsage::setPreservesCFG() { + // Since this transformation doesn't modify the CFG, it preserves all analyses + // that only depend on the CFG (like dominators, loop info, etc...) + GetCFGOnlyPasses(Preserved).enumeratePasses(); } +