From 6bcd3a02653c45b87094577517547b7eb9f76395 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Tue, 7 Sep 2010 19:16:25 +0000 Subject: [PATCH] Clean up some of the PassRegistry implementation, and pImpl-ize it to reduce #include clutter and exposing internal details. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@113252 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/PassRegistry.h | 37 +++++--------- include/llvm/PassSupport.h | 1 + lib/Analysis/LazyValueInfo.cpp | 2 + lib/VMCore/PassRegistry.cpp | 90 ++++++++++++++++++++++++---------- 4 files changed, 79 insertions(+), 51 deletions(-) diff --git a/include/llvm/PassRegistry.h b/include/llvm/PassRegistry.h index adaccf37659..8c1be67069f 100644 --- a/include/llvm/PassRegistry.h +++ b/include/llvm/PassRegistry.h @@ -8,9 +8,9 @@ //===----------------------------------------------------------------------===// // // This file defines PassRegistry, a class that is used in the initialization -// and registration of passes. At initialization, passes are registered with -// the PassRegistry, which is later provided to the PassManager for dependency -// resolution and similar tasks. +// and registration of passes. At application startup, passes are registered +// with the PassRegistry, which is later provided to the PassManager for +// dependency resolution and similar tasks. // //===----------------------------------------------------------------------===// @@ -19,35 +19,22 @@ #include "llvm/ADT/StringMap.h" #include "llvm/System/DataTypes.h" -#include "llvm/System/Mutex.h" -#include -#include -#include namespace llvm { class PassInfo; struct PassRegistrationListener; +/// PassRegistry - This class manages the registration and intitialization of +/// the pass subsystem as application startup, and assists the PassManager +/// in resolving pass dependencies. +/// NOTE: PassRegistry is NOT thread-safe. If you want to use LLVM on multiple +/// threads simultaneously, you will need to use a separate PassRegistry on +/// each thread. class PassRegistry { - /// Guards the contents of this class. - mutable sys::SmartMutex Lock; - - /// PassInfoMap - Keep track of the PassInfo object for each registered pass. - typedef std::map MapType; - MapType PassInfoMap; - - typedef StringMap StringMapType; - StringMapType PassInfoStringMap; - - /// AnalysisGroupInfo - Keep track of information for each analysis group. - struct AnalysisGroupInfo { - std::set Implementations; - }; - std::map AnalysisGroupInfoMap; - - std::vector Listeners; - + mutable void *pImpl; + void *getImpl() const; + public: static PassRegistry *getPassRegistry(); diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h index 0f559d6df73..aac6a4c8887 100644 --- a/include/llvm/PassSupport.h +++ b/include/llvm/PassSupport.h @@ -23,6 +23,7 @@ #include "Pass.h" #include "llvm/PassRegistry.h" +#include namespace llvm { diff --git a/lib/Analysis/LazyValueInfo.cpp b/lib/Analysis/LazyValueInfo.cpp index 2c25f80dbea..74267e045ae 100644 --- a/lib/Analysis/LazyValueInfo.cpp +++ b/lib/Analysis/LazyValueInfo.cpp @@ -26,6 +26,8 @@ #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseSet.h" #include "llvm/ADT/STLExtras.h" +#include +#include using namespace llvm; char LazyValueInfo::ID = 0; diff --git a/lib/VMCore/PassRegistry.cpp b/lib/VMCore/PassRegistry.cpp index 21dba56aad7..562c58c0b95 100644 --- a/lib/VMCore/PassRegistry.cpp +++ b/lib/VMCore/PassRegistry.cpp @@ -16,6 +16,9 @@ #include "llvm/PassSupport.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/ManagedStatic.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/SmallPtrSet.h" +#include using namespace llvm; @@ -60,16 +63,48 @@ ManagedCleanup<&cleanupPassRegistry> registryCleanup ATTRIBUTE_USED; } +//===----------------------------------------------------------------------===// +// PassRegistryImpl +// + +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 Listeners; +}; + +void *PassRegistry::getImpl() const { + if (!pImpl) + pImpl = new PassRegistryImpl(); + return pImpl; +} + +//===----------------------------------------------------------------------===// +// Accessors +// + const PassInfo *PassRegistry::getPassInfo(const void *TI) const { - sys::SmartScopedLock Guard(Lock); - MapType::const_iterator I = PassInfoMap.find(TI); - return I != PassInfoMap.end() ? I->second : 0; + 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; + PassRegistryImpl *Impl = static_cast(getImpl()); + PassRegistryImpl::StringMapType::const_iterator + I = Impl->PassInfoStringMap.find(Arg); + return I != Impl->PassInfoStringMap.end() ? I->second : 0; } //===----------------------------------------------------------------------===// @@ -77,32 +112,33 @@ const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const { // void PassRegistry::registerPass(const PassInfo &PI) { - sys::SmartScopedLock Guard(Lock); + PassRegistryImpl *Impl = static_cast(getImpl()); bool Inserted = - PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; + Impl->PassInfoMap.insert(std::make_pair(PI.getTypeInfo(),&PI)).second; assert(Inserted && "Pass registered multiple times!"); Inserted=Inserted; - PassInfoStringMap[PI.getPassArgument()] = &PI; + 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); } 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!"); + 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) + 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); } @@ -130,8 +166,9 @@ void PassRegistry::registerAnalysisGroup(const void *InterfaceID, // 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); @@ -146,14 +183,15 @@ void PassRegistry::registerAnalysisGroup(const void *InterfaceID, } void PassRegistry::addRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock Guard(Lock); - Listeners.push_back(L); + PassRegistryImpl *Impl = static_cast(getImpl()); + Impl->Listeners.push_back(L); } void PassRegistry::removeRegistrationListener(PassRegistrationListener *L) { - sys::SmartScopedLock Guard(Lock); + 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); }