diff options
Diffstat (limited to 'lib/VMCore/PassRegistry.cpp')
| -rw-r--r-- | lib/VMCore/PassRegistry.cpp | 173 |
1 files changed, 111 insertions, 62 deletions
diff --git a/lib/VMCore/PassRegistry.cpp b/lib/VMCore/PassRegistry.cpp index 21dba56aad72..c97a170f501f 100644 --- a/lib/VMCore/PassRegistry.cpp +++ b/lib/VMCore/PassRegistry.cpp @@ -16,93 +16,125 @@ #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 <vector> using namespace llvm; -static PassRegistry *PassRegistryObj = 0; -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; -} - -namespace { - -// FIXME: We use ManagedCleanup to erase the pass registrar on shutdown. +// 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 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; - } +static ManagedStatic<PassRegistry> PassRegistryObj; +PassRegistry *PassRegistry::getPassRegistry() { + return &*PassRegistryObj; } -ManagedCleanup<&cleanupPassRegistry> registryCleanup ATTRIBUTE_USED; +static ManagedStatic<sys::SmartMutex<true> > Lock; + +//===----------------------------------------------------------------------===// +// PassRegistryImpl +// + +namespace { +struct PassRegistryImpl { + /// PassInfoMap - Keep track of the PassInfo object for each registered pass. + typedef DenseMap<const void*, const PassInfo*> MapType; + MapType PassInfoMap; + + typedef StringMap<const PassInfo*> StringMapType; + StringMapType PassInfoStringMap; + + /// AnalysisGroupInfo - Keep track of information for each analysis group. + struct AnalysisGroupInfo { + SmallPtrSet<const PassInfo *, 8> Implementations; + }; + DenseMap<const PassInfo*, AnalysisGroupInfo> AnalysisGroupInfoMap; + + std::vector<const PassInfo*> ToFree; + std::vector<PassRegistrationListener*> Listeners; +}; +} // end anonymous namespace + +void *PassRegistry::getImpl() const { + if (!pImpl) + pImpl = new PassRegistryImpl(); + return pImpl; +} + +//===----------------------------------------------------------------------===// +// Accessors +// + +PassRegistry::~PassRegistry() { + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(pImpl); + + for (std::vector<const PassInfo*>::iterator I = Impl->ToFree.begin(), + E = Impl->ToFree.end(); I != E; ++I) + delete *I; + + delete Impl; + pImpl = 0; } const PassInfo *PassRegistry::getPassInfo(const void *TI) const { - sys::SmartScopedLock<true> Guard(Lock); - MapType::const_iterator I = PassInfoMap.find(TI); - return I != PassInfoMap.end() ? I->second : 0; + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(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<true> Guard(Lock); - StringMapType::const_iterator I = PassInfoStringMap.find(Arg); - return I != PassInfoStringMap.end() ? I->second : 0; + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(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<true> Guard(Lock); +void PassRegistry::registerPass(const PassInfo &PI, bool ShouldFree) { + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(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<PassRegistrationListener*>::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<true> Guard(Lock); - MapType::iterator I = PassInfoMap.find(PI.getTypeInfo()); - assert(I != PassInfoMap.end() && "Pass registered but not in map!"); + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(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<true> Guard(Lock); - for (MapType::const_iterator I = PassInfoMap.begin(), - E = PassInfoMap.end(); I != E; ++I) + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); + for (PassRegistryImpl::MapType::const_iterator I = Impl->PassInfoMap.begin(), + E = Impl->PassInfoMap.end(); I != E; ++I) L->passEnumerate(I->second); } @@ -111,7 +143,8 @@ void PassRegistry::enumerateWith(PassRegistrationListener *L) { void PassRegistry::registerAnalysisGroup(const void *InterfaceID, const void *PassID, PassInfo& Registeree, - bool isDefault) { + bool isDefault, + bool ShouldFree) { PassInfo *InterfaceInfo = const_cast<PassInfo*>(getPassInfo(InterfaceID)); if (InterfaceInfo == 0) { // First reference to Interface, register it now. @@ -126,12 +159,15 @@ void PassRegistry::registerAnalysisGroup(const void *InterfaceID, assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); + sys::SmartScopedLock<true> Guard(*Lock); + // Make sure we keep track of the fact that the implementation implements // the interface. ImplementationInfo->addInterfaceImplemented(InterfaceInfo); - sys::SmartScopedLock<true> Guard(Lock); - AnalysisGroupInfo &AGI = AnalysisGroupInfoMap[InterfaceInfo]; + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(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 +179,30 @@ void PassRegistry::registerAnalysisGroup(const void *InterfaceID, InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); } } + + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); + if (ShouldFree) Impl->ToFree.push_back(&Registeree); } void PassRegistry::addRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock<true> Guard(Lock); - Listeners.push_back(L); + sys::SmartScopedLock<true> Guard(*Lock); + PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl()); + Impl->Listeners.push_back(L); } void PassRegistry::removeRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock<true> Guard(Lock); + sys::SmartScopedLock<true> 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<PassRegistryImpl*>(getImpl()); std::vector<PassRegistrationListener*>::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); } |