X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPass.cpp;h=d04f90c127a295f342da38ac58d8c59eb21977f6;hb=629c1a3f78494d0dd769fe82bd2bd17df0555843;hp=0097fbdd3117bfcdf781c59487df8df025821e7d;hpb=baf2ecda5fc2b94b0f40bd8780ebaf71410ca2e5;p=oota-llvm.git diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index 0097fbdd311..d04f90c127a 100644 --- a/lib/VMCore/Pass.cpp +++ b/lib/VMCore/Pass.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -13,176 +13,46 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Pass.h" #include "llvm/PassManager.h" -#include "PassManagerT.h" // PassManagerT implementation #include "llvm/Module.h" #include "llvm/ModuleProvider.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/TypeInfo.h" -#include +#include +#include #include using namespace llvm; -//===----------------------------------------------------------------------===// -// AnalysisResolver Class Implementation -// - -AnalysisResolver::~AnalysisResolver() { -} -void AnalysisResolver::setAnalysisResolver(Pass *P, AnalysisResolver *AR) { - assert(P->Resolver == 0 && "Pass already in a PassManager!"); - P->Resolver = AR; -} - -//===----------------------------------------------------------------------===// -// PassManager implementation - The PassManager class is a simple Pimpl class -// that wraps the PassManagerT template. -// -PassManager::PassManager() : PM(new ModulePassManager()) {} -PassManager::~PassManager() { delete PM; } -void PassManager::add(Pass *P) { - ModulePass *MP = dynamic_cast(P); - assert(MP && "Not a modulepass?"); - PM->add(MP); -} -bool PassManager::run(Module &M) { return PM->runOnModule(M); } - -//===----------------------------------------------------------------------===// -// FunctionPassManager implementation - The FunctionPassManager class -// is a simple Pimpl class that wraps the PassManagerT template. It -// is like PassManager, but only deals in FunctionPasses. -// -FunctionPassManager::FunctionPassManager(ModuleProvider *P) : - PM(new FunctionPassManagerT()), MP(P) {} -FunctionPassManager::~FunctionPassManager() { delete PM; } -void FunctionPassManager::add(FunctionPass *P) { PM->add(P); } -void FunctionPassManager::add(ImmutablePass *IP) { PM->add(IP); } - -/// doInitialization - Run all of the initializers for the function passes. -/// -bool FunctionPassManager::doInitialization() { - return PM->doInitialization(*MP->getModule()); -} - -bool FunctionPassManager::run(Function &F) { - std::string errstr; - if (MP->materializeFunction(&F, &errstr)) { - std::cerr << "Error reading bytecode file: " << errstr << "\n"; - abort(); - } - return PM->runOnFunction(F); -} - -/// doFinalization - Run all of the initializers for the function passes. -/// -bool FunctionPassManager::doFinalization() { - return PM->doFinalization(*MP->getModule()); -} - - -//===----------------------------------------------------------------------===// -// TimingInfo Class - This class is used to calculate information about the -// amount of time each pass takes to execute. This only happens with -// -time-passes is enabled on the command line. -// -bool llvm::TimePassesIsEnabled = false; -static cl::opt -EnableTiming("time-passes", cl::location(TimePassesIsEnabled), - cl::desc("Time each pass, printing elapsed time for each on exit")); - -// createTheTimeInfo - This method either initializes the TheTimeInfo pointer to -// a non null value (if the -time-passes option is enabled) or it leaves it -// null. It may be called multiple times. -void TimingInfo::createTheTimeInfo() { - if (!TimePassesIsEnabled || TheTimeInfo) return; - - // Constructed the first time this is called, iff -time-passes is enabled. - // This guarantees that the object will be constructed before static globals, - // thus it will be destroyed before them. - static TimingInfo TTI; - TheTimeInfo = &TTI; -} - -void PMDebug::PrintArgumentInformation(const Pass *P) { - // Print out passes in pass manager... - if (const AnalysisResolver *PM = dynamic_cast(P)) { - for (unsigned i = 0, e = PM->getNumContainedPasses(); i != e; ++i) - PrintArgumentInformation(PM->getContainedPass(i)); - - } else { // Normal pass. Print argument information... - // Print out arguments for registered passes that are _optimizations_ - if (const PassInfo *PI = P->getPassInfo()) - if (!PI->isAnalysisGroup()) - std::cerr << " -" << PI->getPassArgument(); - } -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, Module *M) { - if (PassDebugging >= Executions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << P->getPassName(); - if (M) std::cerr << "' on Module '" << M->getModuleIdentifier() << "'\n"; - std::cerr << "'...\n"; - } -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, Function *F) { - if (PassDebugging >= Executions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << P->getPassName(); - if (F) std::cerr << "' on Function '" << F->getName(); - std::cerr << "'...\n"; - } -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, BasicBlock *BB) { - if (PassDebugging >= Executions) { - std::cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << P->getPassName(); - if (BB) std::cerr << "' on BasicBlock '" << BB->getName(); - std::cerr << "'...\n"; - } -} - -void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg, - Pass *P, const std::vector &Set){ - if (PassDebugging >= Details && !Set.empty()) { - std::cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:"; - for (unsigned i = 0; i != Set.size(); ++i) { - if (i) std::cerr << ","; - std::cerr << " " << Set[i]->getPassName(); - } - std::cerr << "\n"; - } -} - //===----------------------------------------------------------------------===// // Pass Implementation // -void ModulePass::addToPassManager(ModulePassManager *PM, AnalysisUsage &AU) { - PM->addPass(this, AU); +// Force out-of-line virtual method. +Pass::~Pass() { + delete Resolver; } +// Force out-of-line virtual method. +ModulePass::~ModulePass() { } + bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const { - return Resolver->getAnalysisToUpdate(AnalysisID) != 0; + return Resolver->getAnalysisToUpdate(AnalysisID, true) != 0; } // dumpPassStructure - Implement the -debug-passes=Structure option void Pass::dumpPassStructure(unsigned Offset) { - std::cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; + cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; } -// getPassName - Use C++ RTTI to get a SOMEWHAT intelligible name for the pass. -// +/// 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 typeid(*this).name(); + return "Unnamed pass: implement Pass::getPassName()"; } // print - Print out the internal state of the pass. This is called by Analyze @@ -193,19 +63,16 @@ void Pass::print(std::ostream &O,const Module*) const { O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; } -// dump - call print(std::cerr); +// dump - call print(cerr); void Pass::dump() const { - print(std::cerr, 0); + print(*cerr.stream(), 0); } //===----------------------------------------------------------------------===// // ImmutablePass Implementation // -void ImmutablePass::addToPassManager(ModulePassManager *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); -} - +// Force out-of-line virtual method. +ImmutablePass::~ImmutablePass() { } //===----------------------------------------------------------------------===// // FunctionPass Implementation @@ -218,7 +85,7 @@ bool FunctionPass::runOnModule(Module &M) { bool Changed = doInitialization(M); for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - if (!I->isExternal()) // Passes are not run on external functions! + if (!I->isDeclaration()) // Passes are not run on external functions! Changed |= runOnFunction(*I); return Changed | doFinalization(M); @@ -227,23 +94,14 @@ bool FunctionPass::runOnModule(Module &M) { // run - On a function, we simply initialize, run the function, then finalize. // bool FunctionPass::run(Function &F) { - if (F.isExternal()) return false;// Passes are not run on external functions! + // 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()); } -void FunctionPass::addToPassManager(ModulePassManager *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); -} - -void FunctionPass::addToPassManager(FunctionPassManagerT *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); -} - //===----------------------------------------------------------------------===// // BasicBlockPass Implementation // @@ -258,52 +116,41 @@ bool BasicBlockPass::runOnFunction(Function &F) { return Changed | doFinalization(F); } -// To run directly on the basic block, we initialize, runOnBasicBlock, then -// finalize. -// -bool BasicBlockPass::runPass(BasicBlock &BB) { - Function &F = *BB.getParent(); - Module &M = *F.getParent(); - bool Changed = doInitialization(M); - Changed |= doInitialization(F); - Changed |= runOnBasicBlock(BB); - Changed |= doFinalization(F); - Changed |= doFinalization(M); - return Changed; -} - -void BasicBlockPass::addToPassManager(FunctionPassManagerT *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); -} - -void BasicBlockPass::addToPassManager(BasicBlockPassManager *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); -} - - //===----------------------------------------------------------------------===// // Pass Registration mechanism // +namespace { class PassRegistrar { - std::map PassInfoMap; + /// PassInfoMap - Keep track of the passinfo object for each registered llvm + /// pass. + typedef std::map MapType; + MapType PassInfoMap; + + /// AnalysisGroupInfo - Keep track of information for each analysis group. + struct AnalysisGroupInfo { + const PassInfo *DefaultImpl; + std::set Implementations; + AnalysisGroupInfo() : DefaultImpl(0) {} + }; + + /// AnalysisGroupInfoMap - Information for each analysis group. + std::map AnalysisGroupInfoMap; + public: - const PassInfo *GetPassInfo(const std::type_info &TI) const { - std::map::const_iterator I = PassInfoMap.find(TI); + const PassInfo *GetPassInfo(intptr_t TI) const { + MapType::const_iterator I = PassInfoMap.find(TI); return I != PassInfoMap.end() ? I->second : 0; } - void RegisterPass(PassInfo &PI) { + void RegisterPass(const PassInfo &PI) { bool Inserted = - PassInfoMap.insert(std::make_pair(TypeInfo(PI.getTypeInfo()),&PI)).second; - assert(Inserted && "Pass registered multiple times!"); + PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; + assert(Inserted && "Pass registered multiple times!"); Inserted=Inserted; } - void UnregisterPass(PassInfo &PI) { - std::map::iterator I = - PassInfoMap.find(PI.getTypeInfo()); + 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. @@ -311,71 +158,91 @@ public: } void EnumerateWith(PassRegistrationListener *L) { - for (std::map::const_iterator I = PassInfoMap.begin(), + 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()); + } + } }; +} - -static ManagedStatic PassRegistrarObj; static std::vector *Listeners = 0; +// 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; +} + // getPassInfo - Return the PassInfo data structure that corresponds to this // pass... const PassInfo *Pass::getPassInfo() const { - if (PassInfoCache) return PassInfoCache; - return lookupPassInfo(typeid(*this)); + return lookupPassInfo(PassID); } -const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) { - return PassRegistrarObj->GetPassInfo(TI); +const PassInfo *Pass::lookupPassInfo(intptr_t TI) { + return getPassRegistrar()->GetPassInfo(TI); } -void RegisterPassBase::registerPass() { - PassRegistrarObj->RegisterPass(PIObj); +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(&PIObj); + (*I)->passRegistered(this); } -void RegisterPassBase::unregisterPass() { - PassRegistrarObj->UnregisterPass(PIObj); +void PassInfo::unregisterPass() { + getPassRegistrar()->UnregisterPass(*this); } //===----------------------------------------------------------------------===// // Analysis Group Implementation Code //===----------------------------------------------------------------------===// -struct AnalysisGroupInfo { - const PassInfo *DefaultImpl; - std::set Implementations; - AnalysisGroupInfo() : DefaultImpl(0) {} -}; - -static std::map *AnalysisGroupInfoMap = 0; - // RegisterAGBase implementation // -RegisterAGBase::RegisterAGBase(const std::type_info &Interface, - const std::type_info *Pass, bool isDefault) - : RegisterPassBase(Interface), +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(Interface)); + InterfaceInfo = const_cast(Pass::lookupPassInfo(InterfaceID)); if (InterfaceInfo == 0) { // First reference to Interface, register it now. registerPass(); - InterfaceInfo = &PIObj; + InterfaceInfo = this; } - assert(PIObj.isAnalysisGroup() && + assert(isAnalysisGroup() && "Trying to join an analysis group that is a normal pass!"); - if (Pass) { - ImplementationInfo = Pass::lookupPassInfo(*Pass); + if (PassID) { + ImplementationInfo = Pass::lookupPassInfo(PassID); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); @@ -383,58 +250,9 @@ RegisterAGBase::RegisterAGBase(const std::type_info &Interface, // the interface. PassInfo *IIPI = const_cast(ImplementationInfo); IIPI->addInterfaceImplemented(InterfaceInfo); - - // Lazily allocate to avoid nasty initialization order dependencies - if (AnalysisGroupInfoMap == 0) - AnalysisGroupInfoMap = new std::map(); - - 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()); - } - } -} - -void RegisterAGBase::setGroupName(const char *Name) { - assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!"); - InterfaceInfo->setPassName(Name); -} - -RegisterAGBase::~RegisterAGBase() { - if (ImplementationInfo) { - assert(AnalysisGroupInfoMap && "Inserted into map, but map doesn't exist?"); - AnalysisGroupInfo &AGI = (*AnalysisGroupInfoMap)[InterfaceInfo]; - - assert(AGI.Implementations.count(ImplementationInfo) && - "Pass not a member of analysis group?"); - - if (AGI.DefaultImpl == ImplementationInfo) - AGI.DefaultImpl = 0; - - AGI.Implementations.erase(ImplementationInfo); - - // Last member of this analysis group? Unregister PassInfo, delete map entry - if (AGI.Implementations.empty()) { - assert(AGI.DefaultImpl == 0 && - "Default implementation didn't unregister?"); - AnalysisGroupInfoMap->erase(InterfaceInfo); - if (AnalysisGroupInfoMap->empty()) { // Delete map if empty - delete AnalysisGroupInfoMap; - AnalysisGroupInfoMap = 0; - } - } + + getPassRegistrar()->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault); } - - if (InterfaceInfo == &PIObj) - unregisterPass(); } @@ -467,7 +285,7 @@ PassRegistrationListener::~PassRegistrationListener() { // passEnumerate callback on each PassInfo object. // void PassRegistrationListener::enumeratePasses() { - PassRegistrarObj->EnumerateWith(this); + getPassRegistrar()->EnumerateWith(this); } //===----------------------------------------------------------------------===//