X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPass.cpp;h=255be38cd6d4cd31c19f7bd031872b3c5d0f4798;hb=aac07eaeef0b29690f18061abc148a2608cd77de;hp=2e27015c3ac37aaf40566537e4868a3d5f2bb0c8;hpb=5cbf985dcbc89fba3208e7baf8b6f488b06d3ec9;p=oota-llvm.git diff --git a/lib/VMCore/Pass.cpp b/lib/VMCore/Pass.cpp index 2e27015c3ac..255be38cd6d 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,12 +13,22 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Pass.h" #include "llvm/PassManager.h" +#include "llvm/PassRegistry.h" #include "llvm/Module.h" -#include "llvm/ModuleProvider.h" #include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "llvm/Support/Debug.h" #include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/TypeInfo.h" +#include "llvm/Support/PassNameParser.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/System/Atomic.h" +#include "llvm/System/Mutex.h" +#include "llvm/System/Threading.h" +#include +#include #include using namespace llvm; @@ -26,37 +36,100 @@ using namespace llvm; // Pass Implementation // +Pass::Pass(PassKind K, intptr_t pid) : Resolver(0), PassID(pid), Kind(K) { + assert(pid && "pid cannot be 0"); +} + +Pass::Pass(PassKind K, const void *pid) + : Resolver(0), PassID((intptr_t)pid), Kind(K) { + assert(pid && "pid cannot be 0"); +} + +// Force out-of-line virtual method. +Pass::~Pass() { + delete Resolver; +} + // Force out-of-line virtual method. ModulePass::~ModulePass() { } +Pass *ModulePass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + return createPrintModulePass(&O, false, Banner); +} + +PassManagerType ModulePass::getPotentialPassManagerType() const { + return PMT_ModulePassManager; +} + bool Pass::mustPreserveAnalysisID(const PassInfo *AnalysisID) const { - return Resolver->getAnalysisToUpdate(AnalysisID, true) != 0; + return Resolver->getAnalysisIfAvailable(AnalysisID, true) != 0; } // dumpPassStructure - Implement the -debug-passes=Structure option void Pass::dumpPassStructure(unsigned Offset) { - cerr << std::string(Offset*2, ' ') << getPassName() << "\n"; + dbgs().indent(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()"; +} + +void Pass::preparePassManager(PMStack &) { + // By default, don't do anything. +} + +PassManagerType Pass::getPotentialPassManagerType() const { + // Default implementation. + return PMT_Unknown; +} + +void Pass::getAnalysisUsage(AnalysisUsage &) const { + // By default, no analysis results are used, all are invalidated. +} + +void Pass::releaseMemory() { + // By default, don't do anything. +} + +void Pass::verifyAnalysis() const { + // By default, don't do anything. +} + +void *Pass::getAdjustedAnalysisPointer(const PassInfo *) { + return this; +} + +ImmutablePass *Pass::getAsImmutablePass() { + return 0; +} + +PMDataManager *Pass::getAsPMDataManager() { + return 0; +} + +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); } //===----------------------------------------------------------------------===// @@ -65,10 +138,19 @@ void Pass::dump() const { // Force out-of-line virtual method. ImmutablePass::~ImmutablePass() { } +void ImmutablePass::initializePass() { + // By default, don't do anything. +} + //===----------------------------------------------------------------------===// // FunctionPass Implementation // +Pass *FunctionPass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + return createPrintFunctionPass(Banner, &O); +} + // run - On a module, we run this pass by initializing, runOnFunction'ing once // for every function in the module, then by finalizing. // @@ -85,17 +167,39 @@ bool FunctionPass::runOnModule(Module &M) { // run - On a function, we simply initialize, run the function, then finalize. // bool FunctionPass::run(Function &F) { - if (F.isDeclaration()) 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()); } +bool FunctionPass::doInitialization(Module &) { + // By default, don't do anything. + return false; +} + +bool FunctionPass::doFinalization(Module &) { + // By default, don't do anything. + return false; +} + +PassManagerType FunctionPass::getPotentialPassManagerType() const { + return PMT_FunctionPassManager; +} + //===----------------------------------------------------------------------===// // BasicBlockPass Implementation // +Pass *BasicBlockPass::createPrinterPass(raw_ostream &O, + const std::string &Banner) const { + + llvm_unreachable("BasicBlockPass printing unsupported."); + return 0; +} + // To run this pass on a function, we simply call runOnBasicBlock once for each // function. // @@ -106,114 +210,72 @@ 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; +bool BasicBlockPass::doInitialization(Module &) { + // By default, don't do anything. + return false; +} + +bool BasicBlockPass::doInitialization(Function &) { + // By default, don't do anything. + return false; +} + +bool BasicBlockPass::doFinalization(Function &) { + // By default, don't do anything. + return false; +} + +bool BasicBlockPass::doFinalization(Module &) { + // By default, don't do anything. + return false; +} + +PassManagerType BasicBlockPass::getPotentialPassManagerType() const { + return PMT_BasicBlockPassManager; } //===----------------------------------------------------------------------===// // 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()); - } - } -}; -} -static ManagedStatic PassRegistrarObj; static std::vector *Listeners = 0; +static sys::SmartMutex ListenersLock; // 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(intptr_t TI) { + return PassRegistry::getPassRegistry()->getPassInfo(TI); } -const PassInfo *Pass::lookupPassInfo(const std::type_info &TI) { - return PassRegistrarObj->GetPassInfo(TI); +const PassInfo *Pass::lookupPassInfo(StringRef Arg) { + return PassRegistry::getPassRegistry()->getPassInfo(Arg); } -void RegisterPassBase::registerPass() { - PassRegistrarObj->RegisterPass(PIObj); +void PassInfo::registerPass() { + PassRegistry::getPassRegistry()->registerPass(*this); // Notify any listeners. + sys::SmartScopedLock Lock(ListenersLock); if (Listeners) for (std::vector::iterator I = Listeners->begin(), E = Listeners->end(); I != E; ++I) - (*I)->passRegistered(&PIObj); + (*I)->passRegistered(this); +} + +void PassInfo::unregisterPass() { + PassRegistry::getPassRegistry()->unregisterPass(*this); } -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(); } //===----------------------------------------------------------------------===// @@ -222,22 +284,22 @@ 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) { +RegisterAGBase::RegisterAGBase(const char *Name, intptr_t InterfaceID, + intptr_t PassID, bool isDefault) + : PassInfo(Name, InterfaceID) { - InterfaceInfo = const_cast(Pass::lookupPassInfo(Interface)); + PassInfo *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) { + const PassInfo *ImplementationInfo = Pass::lookupPassInfo(PassID); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); @@ -246,15 +308,10 @@ RegisterAGBase::RegisterAGBase(const std::type_info &Interface, PassInfo *IIPI = const_cast(ImplementationInfo); IIPI->addInterfaceImplemented(InterfaceInfo); - PassRegistrarObj->RegisterAnalysisGroup(InterfaceInfo, IIPI, isDefault); + PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceInfo, IIPI, isDefault); } } -void RegisterAGBase::setGroupName(const char *Name) { - assert(InterfaceInfo->getPassName()[0] == 0 && "Interface Name already set!"); - InterfaceInfo->setPassName(Name); -} - //===----------------------------------------------------------------------===// // PassRegistrationListener implementation @@ -263,12 +320,14 @@ void RegisterAGBase::setGroupName(const char *Name) { // PassRegistrationListener ctor - Add the current object to the list of // PassRegistrationListeners... PassRegistrationListener::PassRegistrationListener() { + sys::SmartScopedLock Lock(ListenersLock); if (!Listeners) Listeners = new std::vector(); Listeners->push_back(this); } // dtor - Remove object from list of listeners... PassRegistrationListener::~PassRegistrationListener() { + sys::SmartScopedLock Lock(ListenersLock); std::vector::iterator I = std::find(Listeners->begin(), Listeners->end(), this); assert(Listeners && I != Listeners->end() && @@ -285,17 +344,20 @@ PassRegistrationListener::~PassRegistrationListener() { // 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()) @@ -319,4 +381,15 @@ void AnalysisUsage::setPreservesCFG() { GetCFGOnlyPasses(Preserved).enumeratePasses(); } +AnalysisUsage &AnalysisUsage::addRequiredID(AnalysisID ID) { + assert(ID && "Pass class not registered!"); + Required.push_back(ID); + return *this; +} +AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(AnalysisID ID) { + assert(ID && "Pass class not registered!"); + Required.push_back(ID); + RequiredTransitive.push_back(ID); + return *this; +}