X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPass.cpp;h=9afc540633219bb8ac6ff611f1682e7fa7a155ed;hb=13fd601e0f1c6d8558c4c2b027dacd148f19e6af;hp=650a7e6191a419180c02abd8d6d14fc6bfa1b205;hpb=45dc02d6f97447785ee7ffe08c36a34bc8921b0b;p=oota-llvm.git diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index 650a7e6191a..9afc5406332 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,383 +13,191 @@ // //===----------------------------------------------------------------------===// -#include "llvm/PassManager.h" -#ifdef USE_OLD_PASSMANAGER -#include "PassManagerT.h" // PassManagerT implementation -#endif -#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 "llvm/Pass.h" +#include "llvm/PassRegistry.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/PassNameParser.h" +#include "llvm/Support/raw_ostream.h" using namespace llvm; //===----------------------------------------------------------------------===// -// AnalysisResolver Class Implementation +// Pass Implementation // -AnalysisResolver::~AnalysisResolver() { +Pass::Pass(PassKind K, char &pid) : Resolver(0), PassID(&pid), Kind(K) { } + +// Force out-of-line virtual method. +Pass::~Pass() { + delete Resolver; } -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. +ModulePass::~ModulePass() { } + +Pass *ModulePass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + return createPrintModulePass(&O, false, Banner); } -#ifdef USE_OLD_PASSMANAGER -//===----------------------------------------------------------------------===// -// 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); +PassManagerType ModulePass::getPotentialPassManagerType() const { + return PMT_ModulePassManager; } -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); } +bool Pass::mustPreserveAnalysisID(char &AID) const { + return Resolver->getAnalysisIfAvailable(&AID, true) != 0; +} -/// doInitialization - Run all of the initializers for the function passes. +// dumpPassStructure - Implement the -debug-passes=Structure option +void Pass::dumpPassStructure(unsigned Offset) { + dbgs().indent(Offset*2) << getPassName() << "\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. /// -bool FunctionPassManager::doInitialization() { - return PM->doInitialization(*MP->getModule()); +const char *Pass::getPassName() const { + AnalysisID AID = getPassID(); + const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID); + if (PI) + return PI->getPassName(); + return "Unnamed pass: implement Pass::getPassName()"; } -bool FunctionPassManager::run(Function &F) { - std::string errstr; - if (MP->materializeFunction(&F, &errstr)) { - cerr << "Error reading bytecode file: " << errstr << "\n"; - abort(); - } - return PM->runOnFunction(F); +void Pass::preparePassManager(PMStack &) { + // By default, don't do anything. } -/// doFinalization - Run all of the initializers for the function passes. -/// -bool FunctionPassManager::doFinalization() { - return PM->doFinalization(*MP->getModule()); +PassManagerType Pass::getPotentialPassManagerType() const { + // Default implementation. + return PMT_Unknown; } +void Pass::getAnalysisUsage(AnalysisUsage &) const { + // By default, no analysis results are used, all are invalidated. +} -//===----------------------------------------------------------------------===// -// 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 ManagedStatic 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()) - cerr << " -" << PI->getPassArgument(); - } -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, Module *M) { - if (PassDebugging >= PDLExecutions) { - cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << P->getPassName(); - if (M) cerr << "' on Module '" << M->getModuleIdentifier() << "'\n"; - cerr << "'...\n"; - } -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, Function *F) { - if (PassDebugging >= PDLExecutions) { - cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << P->getPassName(); - if (F) cerr << "' on Function '" << F->getName(); - cerr << "'...\n"; - } -} - -void PMDebug::PrintPassInformation(unsigned Depth, const char *Action, - Pass *P, BasicBlock *BB) { - if (PassDebugging >= PDLExecutions) { - cerr << (void*)P << std::string(Depth*2+1, ' ') << Action << " '" - << P->getPassName(); - if (BB) cerr << "' on BasicBlock '" << BB->getName(); - cerr << "'...\n"; - } -} - -void PMDebug::PrintAnalysisSetInfo(unsigned Depth, const char *Msg, - Pass *P, const std::vector &Set){ - if (PassDebugging >= PDLDetails && !Set.empty()) { - cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:"; - for (unsigned i = 0; i != Set.size(); ++i) { - if (i) cerr << ","; - cerr << " " << Set[i]->getPassName(); - } - cerr << "\n"; - } +void Pass::releaseMemory() { + // By default, don't do anything. } -#endif -//===----------------------------------------------------------------------===// -// Pass Implementation -// +void Pass::verifyAnalysis() const { + // By default, don't do anything. +} -#ifdef USE_OLD_PASSMANAGER -void ModulePass::addToPassManager(ModulePassManager *PM, AnalysisUsage &AU) { - PM->addPass(this, AU); +void *Pass::getAdjustedAnalysisPointer(AnalysisID AID) { + return this; } -#endif -bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const { -#ifdef USE_OLD_PASSMANAGER - return Resolver->getAnalysisToUpdate(AnalysisID) != 0; -#else - return Resolver_New->getAnalysisToUpdate(AnalysisID, true) != 0; -#endif +ImmutablePass *Pass::getAsImmutablePass() { + return 0; } -// dumpPassStructure - Implement the -debug-passes=Structure option -void Pass::dumpPassStructure(unsigned Offset) { - cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; +PMDataManager *Pass::getAsPMDataManager() { + return 0; } -// getPassName - Use C++ RTTI to get a SOMEWHAT intelligible name for the pass. -// -const char *Pass::getPassName() const { - if (const PassInfo *PI = getPassInfo()) - return PI->getPassName(); - return typeid(*this).name(); +void Pass::setResolver(AnalysisResolver *AR) { + assert(!Resolver && "Resolver is already set"); + Resolver = AR; } // 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 { +void Pass::print(raw_ostream &O,const Module*) const { O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; } // dump - call print(cerr); void Pass::dump() const { - print(*cerr.stream(), 0); + print(dbgs(), 0); } //===----------------------------------------------------------------------===// // ImmutablePass Implementation // -#ifdef USE_OLD_PASSMANAGER -void ImmutablePass::addToPassManager(ModulePassManager *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); +// Force out-of-line virtual method. +ImmutablePass::~ImmutablePass() { } + +void ImmutablePass::initializePass() { + // By default, don't do anything. } -#endif //===----------------------------------------------------------------------===// // FunctionPass Implementation // -// 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->isExternal()) // Passes are not run on external functions! - Changed |= runOnFunction(*I); - - return Changed | doFinalization(M); +Pass *FunctionPass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + return createPrintFunctionPass(Banner, &O); } -// 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! - - bool Changed = doInitialization(*F.getParent()); - Changed |= runOnFunction(F); - return Changed | doFinalization(*F.getParent()); +bool FunctionPass::doInitialization(Module &) { + // By default, don't do anything. + return false; } -#ifdef USE_OLD_PASSMANAGER -void FunctionPass::addToPassManager(ModulePassManager *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); +bool FunctionPass::doFinalization(Module &) { + // By default, don't do anything. + return false; } -void FunctionPass::addToPassManager(FunctionPassManagerT *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); +PassManagerType FunctionPass::getPotentialPassManagerType() const { + return PMT_FunctionPassManager; } -#endif //===----------------------------------------------------------------------===// // BasicBlockPass Implementation // -// To run this pass on a function, we simply call runOnBasicBlock once for each -// function. -// -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 *BasicBlockPass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + + llvm_unreachable("BasicBlockPass printing unsupported."); + return 0; } -// 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; +bool BasicBlockPass::doInitialization(Module &) { + // By default, don't do anything. + return false; } -#ifdef USE_OLD_PASSMANAGER -void BasicBlockPass::addToPassManager(FunctionPassManagerT *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); +bool BasicBlockPass::doInitialization(Function &) { + // By default, don't do anything. + return false; } -void BasicBlockPass::addToPassManager(BasicBlockPassManager *PM, - AnalysisUsage &AU) { - PM->addPass(this, AU); +bool BasicBlockPass::doFinalization(Function &) { + // By default, don't do anything. + return false; } -#endif -//===----------------------------------------------------------------------===// -// Pass Registration mechanism -// -namespace { -class PassRegistrar { - /// PassInfoMap - Keep track of the passinfo object for each registered llvm - /// pass. - std::map 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); - return I != PassInfoMap.end() ? I->second : 0; - } - - void RegisterPass(PassInfo &PI) { - bool Inserted = - PassInfoMap.insert(std::make_pair(TypeInfo(PI.getTypeInfo()),&PI)).second; - assert(Inserted && "Pass registered multiple times!"); - } - - void UnregisterPass(PassInfo &PI) { - std::map::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 (std::map::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()); - } - } -}; +bool BasicBlockPass::doFinalization(Module &) { + // By default, don't do anything. + return false; } -static ManagedStatic PassRegistrarObj; -static std::vector *Listeners = 0; - -// getPassInfo - Return the PassInfo data structure that corresponds to this -// pass... -const PassInfo *Pass::getPassInfo() const { - if (PassInfoCache) return PassInfoCache; - return lookupPassInfo(typeid(*this)); +PassManagerType BasicBlockPass::getPotentialPassManagerType() const { + return PMT_BasicBlockPassManager; } -const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) { - return PassRegistrarObj->GetPassInfo(TI); +const PassInfo *Pass::lookupPassInfo(const void *TI) { + return PassRegistry::getPassRegistry()->getPassInfo(TI); } -void RegisterPassBase::registerPass() { - PassRegistrarObj->RegisterPass(PIObj); - - // Notify any listeners. - if (Listeners) - for (std::vector::iterator - I = Listeners->begin(), E = Listeners->end(); I != E; ++I) - (*I)->passRegistered(&PIObj); +const PassInfo *Pass::lookupPassInfo(StringRef Arg) { + return PassRegistry::getPassRegistry()->getPassInfo(Arg); } -void RegisterPassBase::unregisterPass() { - PassRegistrarObj->UnregisterPass(PIObj); +Pass *PassInfo::createPass() const { + assert((!isAnalysisGroup() || NormalCtor) && + "No default implementation found for analysis group!"); + assert(NormalCtor && + "Cannot call createPass on PassInfo without default ctor!"); + return NormalCtor(); } //===----------------------------------------------------------------------===// @@ -398,40 +206,13 @@ void RegisterPassBase::unregisterPass() { // RegisterAGBase implementation // -RegisterAGBase::RegisterAGBase(const std::type_info &Interface, - const std::type_info *Pass, bool isDefault) - : RegisterPassBase(Interface), - ImplementationInfo(0), isDefaultImplementation(isDefault) { - - InterfaceInfo = const_cast(Pass::lookupPassInfo(Interface)); - if (InterfaceInfo == 0) { - // First reference to Interface, register it now. - registerPass(); - InterfaceInfo = &PIObj; - } - assert(PIObj.isAnalysisGroup() && - "Trying to join an analysis group that is a normal pass!"); - - if (Pass) { - ImplementationInfo = Pass::lookupPassInfo(*Pass); - 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); - - PassRegistrarObj->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault); - } -} - -void RegisterAGBase::setGroupName(const char *Name) { - assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!"); - InterfaceInfo->setPassName(Name); +RegisterAGBase::RegisterAGBase(const char *Name, const void *InterfaceID, + const void *PassID, bool isDefault) + : PassInfo(Name, InterfaceID) { + PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID, + *this, isDefault); } - //===----------------------------------------------------------------------===// // PassRegistrationListener implementation // @@ -439,43 +220,36 @@ void RegisterAGBase::setGroupName(const char *Name) { // PassRegistrationListener ctor - Add the current object to the list of // PassRegistrationListeners... PassRegistrationListener::PassRegistrationListener() { - if (!Listeners) Listeners = new std::vector(); - Listeners->push_back(this); + PassRegistry::getPassRegistry()->addRegistrationListener(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; - } + PassRegistry::getPassRegistry()->removeRegistrationListener(this); } // enumeratePasses - Iterate over the registered passes, calling the // passEnumerate callback on each PassInfo object. // void PassRegistrationListener::enumeratePasses() { - PassRegistrarObj->EnumerateWith(this); + PassRegistry::getPassRegistry()->enumerateWith(this); } +PassNameParser::~PassNameParser() {} + //===----------------------------------------------------------------------===// // AnalysisUsage Class Implementation // namespace { struct GetCFGOnlyPasses : public PassRegistrationListener { - std::vector &CFGOnlyList; - GetCFGOnlyPasses(std::vector &L) : CFGOnlyList(L) {} + typedef AnalysisUsage::VectorType VectorType; + VectorType &CFGOnlyList; + GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {} void passEnumerate(const PassInfo *P) { if (P->isCFGOnlyPass()) - CFGOnlyList.push_back(P); + CFGOnlyList.push_back(P->getTypeInfo()); } }; } @@ -495,4 +269,25 @@ void AnalysisUsage::setPreservesCFG() { GetCFGOnlyPasses(Preserved).enumeratePasses(); } +AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) { + const PassInfo *PI = Pass::lookupPassInfo(Arg); + // If the pass exists, preserve it. Otherwise silently do nothing. + if (PI) Preserved.push_back(PI->getTypeInfo()); + return *this; +} + +AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) { + Required.push_back(ID); + return *this; +} + +AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) { + Required.push_back(&ID); + return *this; +} +AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) { + Required.push_back(&ID); + RequiredTransitive.push_back(&ID); + return *this; +}