X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FIR%2FPassRegistry.cpp;h=b879fef3f4a725128f0fea00b36c91f0c1e9a3dd;hb=6bd5df3900d97112aa35f6457e4ab8e66a08afe3;hp=a0b64ed78f5f13d5dc070efe2b2cc478f40eb5e7;hpb=0b8c9a80f20772c3793201ab5b251d3520b9cea3;p=oota-llvm.git diff --git a/lib/IR/PassRegistry.cpp b/lib/IR/PassRegistry.cpp index a0b64ed78f5..b879fef3f4a 100644 --- a/lib/IR/PassRegistry.cpp +++ b/lib/IR/PassRegistry.cpp @@ -13,14 +13,11 @@ //===----------------------------------------------------------------------===// #include "llvm/PassRegistry.h" -#include "llvm/ADT/DenseMap.h" -#include "llvm/ADT/SmallPtrSet.h" -#include "llvm/ADT/StringMap.h" #include "llvm/IR/Function.h" #include "llvm/PassSupport.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/Mutex.h" +#include "llvm/Support/RWMutex.h" #include using namespace llvm; @@ -35,67 +32,22 @@ PassRegistry *PassRegistry::getPassRegistry() { return &*PassRegistryObj; } -static ManagedStatic > Lock; - -//===----------------------------------------------------------------------===// -// 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; -} - //===----------------------------------------------------------------------===// // 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; -} +PassRegistry::~PassRegistry() {} 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; + sys::SmartScopedReader Guard(Lock); + MapType::const_iterator I = PassInfoMap.find(TI); + return I != PassInfoMap.end() ? I->second : nullptr; } const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const { - 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; + sys::SmartScopedReader Guard(Lock); + StringMapType::const_iterator I = PassInfoStringMap.find(Arg); + return I != PassInfoStringMap.end() ? I->second : nullptr; } //===----------------------------------------------------------------------===// @@ -103,107 +55,76 @@ const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const { // void PassRegistry::registerPass(const PassInfo &PI, bool ShouldFree) { - sys::SmartScopedLock Guard(*Lock); - PassRegistryImpl *Impl = static_cast(getImpl()); + sys::SmartScopedWriter Guard(Lock); bool Inserted = - Impl->PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; + PassInfoMap.insert(std::make_pair(PI.getTypeInfo(), &PI)).second; assert(Inserted && "Pass registered multiple times!"); (void)Inserted; - Impl->PassInfoStringMap[PI.getPassArgument()] = Π - + PassInfoStringMap[PI.getPassArgument()] = Π + // Notify any listeners. - for (std::vector::iterator - I = Impl->Listeners.begin(), E = Impl->Listeners.end(); I != E; ++I) - (*I)->passRegistered(&PI); - - if (ShouldFree) Impl->ToFree.push_back(&PI); -} + for (auto *Listener : Listeners) + Listener->passRegistered(&PI); -void PassRegistry::unregisterPass(const PassInfo &PI) { - 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. - Impl->PassInfoMap.erase(I); - Impl->PassInfoStringMap.erase(PI.getPassArgument()); + if (ShouldFree) + ToFree.push_back(std::unique_ptr(&PI)); } void PassRegistry::enumerateWith(PassRegistrationListener *L) { - 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); + sys::SmartScopedReader Guard(Lock); + for (auto PassInfoPair : PassInfoMap) + L->passEnumerate(PassInfoPair.second); } - /// Analysis Group Mechanisms. -void PassRegistry::registerAnalysisGroup(const void *InterfaceID, +void PassRegistry::registerAnalysisGroup(const void *InterfaceID, const void *PassID, - PassInfo& Registeree, - bool isDefault, + PassInfo &Registeree, bool isDefault, bool ShouldFree) { - PassInfo *InterfaceInfo = const_cast(getPassInfo(InterfaceID)); - if (InterfaceInfo == 0) { + PassInfo *InterfaceInfo = const_cast(getPassInfo(InterfaceID)); + if (!InterfaceInfo) { // First reference to Interface, register it now. registerPass(Registeree); InterfaceInfo = &Registeree; } - assert(Registeree.isAnalysisGroup() && + assert(Registeree.isAnalysisGroup() && "Trying to join an analysis group that is a normal pass!"); if (PassID) { - PassInfo *ImplementationInfo = const_cast(getPassInfo(PassID)); + PassInfo *ImplementationInfo = const_cast(getPassInfo(PassID)); assert(ImplementationInfo && "Must register pass before adding to AnalysisGroup!"); - sys::SmartScopedLock Guard(*Lock); - + sys::SmartScopedWriter Guard(Lock); + // Make sure we keep track of the fact that the implementation implements // the interface. ImplementationInfo->addInterfaceImplemented(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); if (isDefault) { - assert(InterfaceInfo->getNormalCtor() == 0 && + assert(InterfaceInfo->getNormalCtor() == nullptr && "Default implementation for analysis group already specified!"); - assert(ImplementationInfo->getNormalCtor() && - "Cannot specify pass as default if it does not have a default ctor"); + assert( + ImplementationInfo->getNormalCtor() && + "Cannot specify pass as default if it does not have a default ctor"); InterfaceInfo->setNormalCtor(ImplementationInfo->getNormalCtor()); + InterfaceInfo->setTargetMachineCtor( + ImplementationInfo->getTargetMachineCtor()); } } - - PassRegistryImpl *Impl = static_cast(getImpl()); - if (ShouldFree) Impl->ToFree.push_back(&Registeree); + + if (ShouldFree) + ToFree.push_back(std::unique_ptr(&Registeree)); } void PassRegistry::addRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock Guard(*Lock); - PassRegistryImpl *Impl = static_cast(getImpl()); - Impl->Listeners.push_back(L); + sys::SmartScopedWriter Guard(Lock); + Listeners.push_back(L); } void PassRegistry::removeRegistrationListener(PassRegistrationListener *L) { - 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(Impl->Listeners.begin(), Impl->Listeners.end(), L); - assert(I != Impl->Listeners.end() && - "PassRegistrationListener not registered!"); - Impl->Listeners.erase(I); + sys::SmartScopedWriter Guard(Lock); + + auto I = std::find(Listeners.begin(), Listeners.end(), L); + Listeners.erase(I); }