X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassRegistry.cpp;h=2df65572c59298caac6065ee583bbc5ed5259a72;hb=1f9838347fdcc75cead228ec1758063074b89c6a;hp=844d82660b4241dcb988fdc1788c485b7c70e0e6;hpb=1f74590e9d1b9cf0f1f81a156efea73f76546e05;p=oota-llvm.git diff --git a/lib/VMCore/PassRegistry.cpp b/lib/VMCore/PassRegistry.cpp index 844d82660b4..2df65572c59 100644 --- a/lib/VMCore/PassRegistry.cpp +++ b/lib/VMCore/PassRegistry.cpp @@ -16,102 +16,136 @@ #include "llvm/PassSupport.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/Mutex.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/Function.h" +#include using namespace llvm; -static PassRegistry *PassRegistryObj = 0; +// FIXME: We use ManagedStatic to erase the pass registrar on shutdown. +// Unfortunately, passes are registered with static ctors, and having +// llvm_shutdown clear this map prevents successful resurrection after +// llvm_shutdown is run. Ideally we should find a solution so that we don't +// leak the map, AND can still resurrect after shutdown. +static ManagedStatic PassRegistryObj; PassRegistry *PassRegistry::getPassRegistry() { - // Use double-checked locking to safely initialize the registrar when - // we're running in multithreaded mode. - PassRegistry* tmp = PassRegistryObj; - if (llvm_is_multithreaded()) { - sys::MemoryFence(); - if (!tmp) { - llvm_acquire_global_lock(); - tmp = PassRegistryObj; - if (!tmp) { - tmp = new PassRegistry(); - sys::MemoryFence(); - PassRegistryObj = tmp; - } - llvm_release_global_lock(); - } - } else if (!tmp) { - PassRegistryObj = new PassRegistry(); - } - - return PassRegistryObj; + return &*PassRegistryObj; } -namespace { +static ManagedStatic > Lock; -// FIXME: We use ManagedCleanup to erase the pass registrar on shutdown. -// Unfortunately, passes are registered with static ctors, and having -// llvm_shutdown clear this map prevents successful ressurection after -// llvm_shutdown is run. Ideally we should find a solution so that we don't -// leak the map, AND can still resurrect after shutdown. -void cleanupPassRegistry(void*) { - if (PassRegistryObj) { - delete PassRegistryObj; - PassRegistryObj = 0; - } +//===----------------------------------------------------------------------===// +// PassRegistryImpl +// + +namespace { +struct PassRegistryImpl { + /// PassInfoMap - Keep track of the PassInfo object for each registered pass. + typedef DenseMap MapType; + MapType PassInfoMap; + + typedef StringMap StringMapType; + StringMapType PassInfoStringMap; + + /// AnalysisGroupInfo - Keep track of information for each analysis group. + struct AnalysisGroupInfo { + SmallPtrSet Implementations; + }; + DenseMap AnalysisGroupInfoMap; + + std::vector ToFree; + std::vector Listeners; +}; +} // end anonymous namespace + +void *PassRegistry::getImpl() const { + if (!pImpl) + pImpl = new PassRegistryImpl(); + return pImpl; } -ManagedCleanup<&cleanupPassRegistry> registryCleanup ATTRIBUTE_USED; +//===----------------------------------------------------------------------===// +// Accessors +// + +PassRegistry::~PassRegistry() { + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(pImpl); + + for (std::vector::iterator I = Impl->ToFree.begin(), + E = Impl->ToFree.end(); I != E; ++I) + delete *I; + + delete Impl; + pImpl = 0; } -const PassInfo *PassRegistry::getPassInfo(intptr_t TI) const { - sys::SmartScopedLock Guard(Lock); - MapType::const_iterator I = PassInfoMap.find(TI); - return I != PassInfoMap.end() ? I->second : 0; +const PassInfo *PassRegistry::getPassInfo(const void *TI) const { + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); + PassRegistryImpl::MapType::const_iterator I = Impl->PassInfoMap.find(TI); + return I != Impl->PassInfoMap.end() ? I->second : 0; } const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const { - sys::SmartScopedLock Guard(Lock); - StringMapType::const_iterator I = PassInfoStringMap.find(Arg); - return I != PassInfoStringMap.end() ? I->second : 0; + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); + PassRegistryImpl::StringMapType::const_iterator + I = Impl->PassInfoStringMap.find(Arg); + return I != Impl->PassInfoStringMap.end() ? I->second : 0; } //===----------------------------------------------------------------------===// // Pass Registration mechanism // -void PassRegistry::registerPass(const PassInfo &PI) { - sys::SmartScopedLock Guard(Lock); +void PassRegistry::registerPass(const PassInfo &PI, bool ShouldFree) { + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); bool Inserted = - PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; - assert(Inserted && "Pass registered multiple times!"); Inserted=Inserted; - PassInfoStringMap[PI.getPassArgument()] = &PI; + Impl->PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; + assert(Inserted && "Pass registered multiple times!"); + (void)Inserted; + Impl->PassInfoStringMap[PI.getPassArgument()] = &PI; // Notify any listeners. for (std::vector::iterator - I = Listeners.begin(), E = Listeners.end(); I != E; ++I) + I = Impl->Listeners.begin(), E = Impl->Listeners.end(); I != E; ++I) (*I)->passRegistered(&PI); + + if (ShouldFree) Impl->ToFree.push_back(&PI); } void PassRegistry::unregisterPass(const PassInfo &PI) { - sys::SmartScopedLock Guard(Lock); - MapType::iterator I = PassInfoMap.find(PI.getTypeInfo()); - assert(I != PassInfoMap.end() && "Pass registered but not in map!"); + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); + PassRegistryImpl::MapType::iterator I = + Impl->PassInfoMap.find(PI.getTypeInfo()); + assert(I != Impl->PassInfoMap.end() && "Pass registered but not in map!"); // Remove pass from the map. - PassInfoMap.erase(I); - PassInfoStringMap.erase(PI.getPassArgument()); + Impl->PassInfoMap.erase(I); + Impl->PassInfoStringMap.erase(PI.getPassArgument()); } void PassRegistry::enumerateWith(PassRegistrationListener *L) { - sys::SmartScopedLock Guard(Lock); - for (MapType::const_iterator I = PassInfoMap.begin(), - E = PassInfoMap.end(); I != E; ++I) + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); + for (PassRegistryImpl::MapType::const_iterator I = Impl->PassInfoMap.begin(), + E = Impl->PassInfoMap.end(); I != E; ++I) L->passEnumerate(I->second); } /// Analysis Group Mechanisms. -void PassRegistry::registerAnalysisGroup(intptr_t InterfaceID, - intptr_t PassID, +void PassRegistry::registerAnalysisGroup(const void *InterfaceID, + const void *PassID, PassInfo& Registeree, - bool isDefault) { + bool isDefault, + bool ShouldFree) { PassInfo *InterfaceInfo = const_cast(getPassInfo(InterfaceID)); if (InterfaceInfo == 0) { // First reference to Interface, register it now. @@ -126,12 +160,15 @@ void PassRegistry::registerAnalysisGroup(intptr_t InterfaceID, assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); + sys::SmartScopedLock Guard(*Lock); + // Make sure we keep track of the fact that the implementation implements // the interface. ImplementationInfo->addInterfaceImplemented(InterfaceInfo); - sys::SmartScopedLock Guard(Lock); - AnalysisGroupInfo &AGI = AnalysisGroupInfoMap[InterfaceInfo]; + PassRegistryImpl *Impl = static_cast(getImpl()); + PassRegistryImpl::AnalysisGroupInfo &AGI = + Impl->AnalysisGroupInfoMap[InterfaceInfo]; assert(AGI.Implementations.count(ImplementationInfo) == 0 && "Cannot add a pass to the same analysis group more than once!"); AGI.Implementations.insert(ImplementationInfo); @@ -143,17 +180,30 @@ void PassRegistry::registerAnalysisGroup(intptr_t InterfaceID, InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); } } + + PassRegistryImpl *Impl = static_cast(getImpl()); + if (ShouldFree) Impl->ToFree.push_back(&Registeree); } void PassRegistry::addRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock Guard(Lock); - Listeners.push_back(L); + sys::SmartScopedLock Guard(*Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); + Impl->Listeners.push_back(L); } void PassRegistry::removeRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock Guard(Lock); + sys::SmartScopedLock Guard(*Lock); + + // NOTE: This is necessary, because removeRegistrationListener() can be called + // as part of the llvm_shutdown sequence. Since we have no control over the + // order of that sequence, we need to gracefully handle the case where the + // PassRegistry is destructed before the object that triggers this call. + if (!pImpl) return; + + PassRegistryImpl *Impl = static_cast(getImpl()); std::vector::iterator I = - std::find(Listeners.begin(), Listeners.end(), L); - assert(I != Listeners.end() && "PassRegistrationListener not registered!"); - Listeners.erase(I); + std::find(Impl->Listeners.begin(), Impl->Listeners.end(), L); + assert(I != Impl->Listeners.end() && + "PassRegistrationListener not registered!"); + Impl->Listeners.erase(I); }