Fix initialization problems with PassRegistry

[zturner]

Summary

(Not sure who the best reviewer is, so I've put chandlerc based on CODE_OWNERS and dblaikie based on llvm-dev discussion).

The following trace is taken from Visual Studio by putting Watchpoints in ManagedStaticBase::RegisterManagedStatic, ManagedStaticBase::destroy, and llvm_shutdown

Allocating ManagedStatic 0x0x04ab19d0 {ManagedStatic<llvm::PassRegistry> PassRegistryObj}
Allocating ManagedStatic 0x0x04ab19dc {ManagedStatic<llvm::sys::SmartRWMutex<1> > Lock}
Allocating ManagedStatic 0x0x04ab2d34 {ManagedStatic<llvm::SmallPtrSet<llvm::cl::OptionCategory *,16> > RegisteredOptionCategories}
Allocating ManagedStatic 0x0x04ab2f08 {ManagedStatic<std::string> LibSupportInfoOutputFilename}
Allocating ManagedStatic 0x0x04ab2dd8 {ManagedStatic<llvm::sys::ThreadLocal<llvm::PrettyStackTraceEntry const > > PrettyStackTraceHead}
Allocating ManagedStatic 0x0x04ab2f14 {ManagedStatic<llvm::sys::SmartMutex<1> > TimerLock}
llvm_shutdown
Destroying ManagedStatic 0x0x04ab2f14 {ManagedStatic<llvm::sys::SmartMutex<1> > TimerLock}
Destroying ManagedStatic 0x0x04ab2dd8 {ManagedStatic<llvm::sys::ThreadLocal<llvm::PrettyStackTraceEntry const > > PrettyStackTraceHead} {...}
Destroying ManagedStatic 0x0x04ab2f08 {ManagedStatic<std::string> LibSupportInfoOutputFilename}
Destroying ManagedStatic 0x0x04ab2d34 {ManagedStatic<llvm::SmallPtrSet<llvm::cl::OptionCategory *,16> > RegisteredOptionCategories}
Destroying ManagedStatic 0x0x04ab19dc {ManagedStatic<llvm::sys::SmartRWMutex<1> > Lock}
Destroying ManagedStatic 0x0x04ab19d0 {ManagedStatic<llvm::PassRegistry> PassRegistryObj}
Allocating ManagedStatic 0x0x04ab19dc {ManagedStatic<llvm::sys::SmartRWMutex<1> > Lock}
Destroying ManagedStatic 0x0x04ab19dc {ManagedStatic<llvm::sys::SmartRWMutex<1> > Lock}
Allocating ManagedStatic 0x0x04ab19d0 {ManagedStatic<llvm::PassRegistry> PassRegistryObj}
Allocating ManagedStatic 0x0x04ab19dc {ManagedStatic<llvm::sys::SmartRWMutex<1> > Lock}

From this you can see that ManagedStatics are allocated during llvm_shutdown, and that one of them is the PassRegistry, which has already been allocated and destroyed.

This patch addresses this by introducing a StaticPassRegistry, and having RegisterPass<> write its entries to the StaticPassRegistry. Once main is entered, StaticPassRegistry becomes immutable and its entries are transferred over to the PassRegistry. By doing this, we can guarantee that PassRegistry won't be access during static initialization, and thus we can change PassRegistry's mutex to be a raw static instead of a ManagedStatic.

Eventually, the goal here is to get to a point where ManagedStatic can enforce true once-only initialization of ManagedStatics using std::call_once, guaranteeing that once a ManagedStatic is destroyed it is never allocated again, and also fixing existing race conditions in the implementation of ManagedStatic.

[rnk]

I think Owen was the original author for this code back in 2010. Maybe he has thoughts on how this should work. In particular, the commit logs of r114130 and r114131 look suspicious.

[chandlerc]

(Just as an FYI, this is in my queue, but requires more thinking.)

One unfortunate thing about the patch is that it mixes both refactorings and the bug fix which makes it more noisy. I don't think we should call it "PassCallback" either way, and I would just avoid doing the renaming and such in the same patch unless strictly necessary to implement it.

[zturner]

Renamed PassCallback back to PassRegistrationListener, and removed some other superfluous changes to reduce the size of the review.

[dblaikie]

This still seems to be doing multiple things for possibly distinct reasons & might be clearer (to me - whether that matters is a fair question) in separate patches.

The original problem you demonstrate with the traces is due to the use of global PassRegistrationListener's that have self-deregistration, right?

So just removing self PassRegistrationListener's automatic registration/deregistration would be sufficient to fix that issue, right? No need to change the Pass registration itself, or introduce the StaticPassregistry.

We could even maintain the ability to automatically register PassRegistrationListeners if we just had a separate wrapper type that handled their registration in global contexts and wouldn't try to deregister them (since the PassRegistry is going to cleanup itself, there would be no need to deregister). That way we could preserve the existing automatic attachment/removal of PassRegistrationListeners (or not... they might need some other wrapper type to do local scope attachment and detachment)

Does any of that rambling make sense?

[zturner]

There are a couple of things that lead to the original issue. Another one is the use of the Mutex. Mutex is locked in the destructor of the PassRegistry, and the PassRegistry itself is a ManagedStatic. So the PassRegistry is allocated lazily, then the first time a method is called the Mutex is allocated. Then during shutdown Mutex is freed, then PassRegistry is freed, calling PassRegistry's destructor, locking the mutex again.

Also, I'm not sure if it's as easy as removing PassRegistrationListener's automatic registration / deregistration. I tried that and ran into some problems somewhere else, although the details escape me. If needed I can go back and do some digging to figure out what it was. That being said, I don't want to spend too much additional time on this, as it was mostly intended to be a drive-by cleanup task tangential to my original goal.

[dblaikie]

Ah, right, the PassRegistry's dtor accesses the lock. Why? It's running as a global dtor - do they ever run concurrently? (I know at Google we have a rule of no global dtors since you might be in the middle of a thread, holding a lock, when the process gets shutdown - at which point you'll deadlock in your global ctor. I'm not sure if we want to go that far & not sure how that'd work with llvm_shutdown)

It still seems a bit error prone to have a global object (PassRegistry) access another global (its lock) in a dtor without any guarantee that PassRegistry is initialized after the lock...

If the PassRegistry's dtor actually needs to lock, then it sounds like the program will have a race on the lock (since it's handling the lock in some other thread during destruction and the lock will be destroyed at some point here) - so I'm not sure if your change actually makes any of this actually safe?

[zturner]

I might be able to solve the lock problem by just deleting the lock access from the destructor, as you mention, or making the lock an instance variable of the PassRegistry class. But I still think the way I've done is the only real way to solve the problem with the PassRegistrationListener.

Ultimately, the root of the problem is that ManagedStatics are being accessed during static initialization and shutdown. This needs to be prevented, and I think we need to try to get to a point where we can actually enforce, by way of asserts, that you cannot touch a ManagedStatic before main is entered or after it returns.

include/llvm/IR/LegacyPassNameParser.h

 // PassNameParser class - Make use of the pass registration mechanism to
 // automatically add a command line argument to opt for each pass.
 //
 class PassNameParser : public PassRegistrationListener,
                        public cl::parser<const PassInfo*> {
   cl::Option *Opt;
 public:
   PassNameParser() : Opt(nullptr) {}
-  virtual ~PassNameParser();
+  virtual ~PassNameParser() {}
 
   void initialize(cl::Option &O) {
     Opt = &O;
     cl::parser<const PassInfo*>::initialize(O);
-
-    // Add all of the passes to the map that got initialized before 'this' did.
-    enumeratePasses();
   }
 
   // ignorablePassImpl - Can be overriden in subclasses to refine the list of
   // which passes we want to include.
   //
   virtual bool ignorablePassImpl(const PassInfo *P) const { return false; }
 
   inline bool ignorablePass(const PassInfo *P) const {

include/llvm/PassRegistry.h

 class PassRegistry {
   mutable void *pImpl;
   void *getImpl() const;
    
 public:
   PassRegistry() : pImpl(nullptr) { }
   ~PassRegistry();
   
-  /// getPassRegistry - Access the global registry object, which is 
-  /// automatically initialized at application launch and destroyed by
-  /// llvm_shutdown.
+  /// initializePassRegistry - Creates the global pass registry object.  This
+  /// is typically called very early in main, and must be called before any call
+  /// to getPassRegistry.
+  static void initializePassRegistry();
+
+  /// getPassRegistry - Access the global registry object, which is
+  /// automatically initialized when you call initializePassRegistry(), and
+  /// destroyed by llvm_shutdown.
   static PassRegistry *getPassRegistry();
   
   /// getPassInfo - Look up a pass' corresponding PassInfo, indexed by the pass'
   /// type identifier (&MyPass::ID).
   const PassInfo *getPassInfo(const void *TI) const;
   
   /// getPassInfo - Look up a pass' corresponding PassInfo, indexed by the pass'
   /// argument string.

include/llvm/PassSupport.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_PASSSUPPORT_H
 #define LLVM_PASSSUPPORT_H
 
 #include "Pass.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/PassRegistry.h"
+#include "llvm/StaticPassRegistry.h"
 #include "llvm/Support/Atomic.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Valgrind.h"
 #include <vector>
 
 namespace llvm {
 
 class TargetMachine;
 //===---------------------------------------------------------------------------
 /// PassInfo class - An instance of this class exists for every pass known by

 struct RegisterPass : public PassInfo {
 
   // Register Pass using default constructor...
   RegisterPass(const char *PassArg, const char *Name, bool CFGOnly = false,
                bool is_analysis = false)
     : PassInfo(Name, PassArg, &passName::ID,
                PassInfo::NormalCtor_t(callDefaultCtor<passName>),
                CFGOnly, is_analysis) {
-    PassRegistry::getPassRegistry()->registerPass(*this);
-  }
-};
-
-
-/// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_.
-/// Analysis groups are used to define an interface (which need not derive from
-/// Pass) that is required by passes to do their job.  Analysis Groups differ
-/// from normal analyses because any available implementation of the group will
-/// be used if it is available.
-///
-/// If no analysis implementing the interface is available, a default
-/// implementation is created and added.  A pass registers itself as the default
-/// implementation by specifying 'true' as the second template argument of this
-/// class.
-///
-/// In addition to registering itself as an analysis group member, a pass must
-/// register itself normally as well.  Passes may be members of multiple groups
-/// and may still be "required" specifically by name.
-///
-/// The actual interface may also be registered as well (by not specifying the
-/// second template argument).  The interface should be registered to associate
-/// a nice name with the interface.
-///
-class RegisterAGBase : public PassInfo {
-public:
-  RegisterAGBase(const char *Name,
-                 const void *InterfaceID,
-                 const void *PassID = nullptr,
-                 bool isDefault = false);
-};
-
-template<typename Interface, bool Default = false>
-struct RegisterAnalysisGroup : public RegisterAGBase {
-  explicit RegisterAnalysisGroup(PassInfo &RPB)
-    : RegisterAGBase(RPB.getPassName(),
-                     &Interface::ID, RPB.getTypeInfo(),
-                     Default) {
-  }
-
-  explicit RegisterAnalysisGroup(const char *Name)
-    : RegisterAGBase(Name, &Interface::ID) {
+    StaticPassRegistry::getStaticPassRegistry()->registerPass(*this);
   }
 };
 
 #define INITIALIZE_ANALYSIS_GROUP(agName, name, defaultPass) \
   static void* initialize##agName##AnalysisGroupOnce(PassRegistry &Registry) { \
     initialize##defaultPass##Pass(Registry); \
     PassInfo *AI = new PassInfo(name, & agName :: ID); \
     Registry.registerAnalysisGroup(& agName ::ID, 0, *AI, false, true); \
#define INITIALIZE_AG_PASS_END(passName, agName, arg, n, cfg, analysis, def) \
   } \
   void llvm::initialize##passName##Pass(PassRegistry &Registry) { \
     CALL_ONCE_INITIALIZATION(initialize##passName##PassOnce) \
   }
 
 //===---------------------------------------------------------------------------
 /// PassRegistrationListener class - This class is meant to be derived from by
 /// clients that are interested in which passes get registered and unregistered
-/// at runtime (which can be because of the RegisterPass constructors being run
-/// as the program starts up, or may be because a shared object just got
-/// loaded).  Deriving from the PassRegistrationListener class automatically
-/// registers your object to receive callbacks indicating when passes are loaded
-/// and removed.
+/// at runtime due to a a shared object just having been loaded.  Deriving from
+/// PassRegistrationListener doesn't automatically register your object to
+/// receive callbacks indicating when passes are loaded and removed.
 ///
 struct PassRegistrationListener {
-
-  /// PassRegistrationListener ctor - Add the current object to the list of
-  /// PassRegistrationListeners...
-  PassRegistrationListener();
-
-  /// dtor - Remove object from list of listeners...
-  ///
-  virtual ~PassRegistrationListener();
+  virtual ~PassRegistrationListener() { }
 
   /// Callback functions - These functions are invoked whenever a pass is loaded
   /// or removed from the current executable.
   ///
   virtual void passRegistered(const PassInfo *) {}
 
-  /// enumeratePasses - Iterate over the registered passes, calling the
-  /// passEnumerate callback on each PassInfo object.
-  ///
-  void enumeratePasses();
+  virtual void passUnregistered(const PassInfo *) {}
 
-  /// passEnumerate - Callback function invoked when someone calls
-  /// enumeratePasses on this PassRegistrationListener object.
-  ///
   virtual void passEnumerate(const PassInfo *) {}
 };
 
-
 } // End llvm namespace
 
 #endif

include/llvm/StaticPassRegistry.h

+//===- llvm/StaticPassRegistry.h - Pass Information Registry ----*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines StaticPassRegistry, a class that is used in the
+// initialization and registration of passes.  During static program
+// initialization, passes are registered with the StaticPassRegistry by 
+// declaring instances of the RegisterPass<> template.  Once main() begins, the
+// application must call PassRegistry::initializePassRegistry() to load the
+// statically initialized passes.  Note that StaticPassRegistry is intended to
+// be immutable after main() is entered.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_STATIC_PASSREGISTRY_H
+#define LLVM_STATIC_PASSREGISTRY_H
+
+#include <list>
+
+namespace llvm {
+
+class PassInfo;
+
+class StaticPassRegistry {
+  friend class PassRegistry;
+private:
+  /// PassInfoMap - Keep track of the PassInfo object for each registered pass.
+  typedef std::list<const PassInfo*> ListType;
+  ListType PassInfoList;
+
+public: 
+  /// registerPass - Register a pass (by means of its PassInfo) with the
+  /// registry.  
+  void registerPass(const PassInfo &PI);
+
+  /// getStaticPassRegistry - Access the global registry object, which is 
+  /// automatically initialized at application launch.
+  static StaticPassRegistry *getStaticPassRegistry();
+};
+
+}
+
+#endif
 No newline at end of file

lib/IR/CMakeLists.txt

add_llvm_library(LLVMCore
   LegacyPassManager.cpp
   MDBuilder.cpp
   Mangler.cpp
   Metadata.cpp
   Module.cpp
   Pass.cpp
   PassManager.cpp
   PassRegistry.cpp
+  StaticPassRegistry.cpp
   Type.cpp
   TypeFinder.cpp
   Use.cpp
   User.cpp
   Value.cpp
   ValueSymbolTable.cpp
   ValueTypes.cpp
   Verifier.cpp
   )
 
 add_dependencies(LLVMCore intrinsics_gen)

lib/IR/Pass.cpp

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();
 }
 
 //===----------------------------------------------------------------------===//
-//                  Analysis Group Implementation Code
-//===----------------------------------------------------------------------===//
-
-// RegisterAGBase implementation
-//
-RegisterAGBase::RegisterAGBase(const char *Name, const void *InterfaceID,
-                               const void *PassID, bool isDefault)
-    : PassInfo(Name, InterfaceID) {
-  PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID,
-                                                         *this, isDefault);
-}
-
-//===----------------------------------------------------------------------===//
-// PassRegistrationListener implementation
-//
-
-// PassRegistrationListener ctor - Add the current object to the list of
-// PassRegistrationListeners...
-PassRegistrationListener::PassRegistrationListener() {
-  PassRegistry::getPassRegistry()->addRegistrationListener(this);
-}
-
-// dtor - Remove object from list of listeners...
-PassRegistrationListener::~PassRegistrationListener() {
-  PassRegistry::getPassRegistry()->removeRegistrationListener(this);
-}
-
-// enumeratePasses - Iterate over the registered passes, calling the
-// passEnumerate callback on each PassInfo object.
-//
-void PassRegistrationListener::enumeratePasses() {
-  PassRegistry::getPassRegistry()->enumerateWith(this);
-}
-
-PassNameParser::~PassNameParser() {}
-
-//===----------------------------------------------------------------------===//
 //   AnalysisUsage Class Implementation
 //
 
 namespace {
   struct GetCFGOnlyPasses : public PassRegistrationListener {
     typedef AnalysisUsage::VectorType VectorType;
     VectorType &CFGOnlyList;
     GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {}

 //  2. Modify terminator instructions in any way.
 //
 // This function annotates the AnalysisUsage info object to say that analyses
 // that only depend on the CFG are preserved by this pass.
 //
 void AnalysisUsage::setPreservesCFG() {
   // Since this transformation doesn't modify the CFG, it preserves all analyses
   // that only depend on the CFG (like dominators, loop info, etc...)
-  GetCFGOnlyPasses(Preserved).enumeratePasses();
+  GetCFGOnlyPasses callback(Preserved);
+  PassRegistry::getPassRegistry()->enumerateWith(&callback);
 }
 
 AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) {
   const PassInfo *PI = Pass::lookupPassInfo(Arg);
   // If the pass exists, preserve it. Otherwise silently do nothing.
   if (PI) Preserved.push_back(PI->getTypeInfo());
   return *this;
 }

lib/IR/PassRegistry.cpp

 //===- PassRegistry.cpp - Pass Registration Implementation ----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the PassRegistry, with which passes are registered on
-// initialization, and supports the PassManager in dependency resolution.
+// This file implements the PassRegistry, with which passes are registered at
+// runtime, and supports the PassManager in dependency resolution.
 //
 //===----------------------------------------------------------------------===//
 
 #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/StaticPassRegistry.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/RWMutex.h"
 #include <vector>
 
 using namespace llvm;
 
-// 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 sys::SmartRWMutex<true> Lock;
 static ManagedStatic<PassRegistry> PassRegistryObj;
 PassRegistry *PassRegistry::getPassRegistry() {
+  assert(PassRegistryObj.isConstructed() && "initializePassRegistry not called!");
   return &*PassRegistryObj;
 }
 
-static ManagedStatic<sys::SmartRWMutex<true> > Lock;
+void PassRegistry::initializePassRegistry() {
+  assert(!PassRegistryObj.isConstructed() && "initializePassRegistry called twice!");
+
+  // Manually construct the ManagedStatic here.
+  PassRegistry &registry = *PassRegistryObj;
+
+  StaticPassRegistry *staticRegistry = StaticPassRegistry::getStaticPassRegistry();
+  for (auto it=staticRegistry->PassInfoList.begin(); it!=staticRegistry->PassInfoList.end(); ++it)
+    registry.registerPass(**it);
+}
 
 //===----------------------------------------------------------------------===//
 // 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<std::unique_ptr<const PassInfo>> ToFree;
-  std::vector<PassRegistrationListener*> Listeners;
+  std::vector<PassRegistrationListener*> RegistrationListeners;
 };
 } // end anonymous namespace
 
 void *PassRegistry::getImpl() const {
   if (!pImpl)
     pImpl = new PassRegistryImpl();
   return pImpl;
 }
 
 //===----------------------------------------------------------------------===//
 // Accessors
 //
 
 PassRegistry::~PassRegistry() {
-  sys::SmartScopedWriter<true> Guard(*Lock);
+  sys::SmartScopedWriter<true> Guard(Lock);
   PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(pImpl);
   delete Impl;
   pImpl = nullptr;
 }
 
 const PassInfo *PassRegistry::getPassInfo(const void *TI) const {
-  sys::SmartScopedReader<true> Guard(*Lock);
+  sys::SmartScopedReader<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 : nullptr;
 }
 
 const PassInfo *PassRegistry::getPassInfo(StringRef Arg) const {
-  sys::SmartScopedReader<true> Guard(*Lock);
+  sys::SmartScopedReader<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 : nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // Pass Registration mechanism
 //
 
 void PassRegistry::registerPass(const PassInfo &PI, bool ShouldFree) {
-  sys::SmartScopedWriter<true> Guard(*Lock);
+  sys::SmartScopedWriter<true> Guard(Lock);
   PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl());
   bool Inserted =
     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 = Impl->Listeners.begin(), E = Impl->Listeners.end(); I != E; ++I)
+       I = Impl->RegistrationListeners.begin(), E = Impl->RegistrationListeners.end(); I != E; ++I)
     (*I)->passRegistered(&PI);
   
   if (ShouldFree) Impl->ToFree.push_back(std::unique_ptr<const PassInfo>(&PI));
 }
 
 void PassRegistry::unregisterPass(const PassInfo &PI) {
-  sys::SmartScopedWriter<true> Guard(*Lock);
+  sys::SmartScopedWriter<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.
   Impl->PassInfoMap.erase(I);
   Impl->PassInfoStringMap.erase(PI.getPassArgument());
 }
 
 void PassRegistry::enumerateWith(PassRegistrationListener *L) {
-  sys::SmartScopedReader<true> Guard(*Lock);
+  sys::SmartScopedReader<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);
 }
 
 
 /// Analysis Group Mechanisms.
void PassRegistry::registerAnalysisGroup(const void *InterfaceID,
   assert(Registeree.isAnalysisGroup() && 
          "Trying to join an analysis group that is a normal pass!");
 
   if (PassID) {
     PassInfo *ImplementationInfo = const_cast<PassInfo*>(getPassInfo(PassID));
     assert(ImplementationInfo &&
            "Must register pass before adding to AnalysisGroup!");
 
-    sys::SmartScopedWriter<true> Guard(*Lock);
+    sys::SmartScopedWriter<true> Guard(Lock);
     
     // Make sure we keep track of the fact that the implementation implements
     // the interface.
     ImplementationInfo->addInterfaceImplemented(InterfaceInfo);
 
     PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl());
     PassRegistryImpl::AnalysisGroupInfo &AGI =
       Impl->AnalysisGroupInfoMap[InterfaceInfo];
void PassRegistry::registerAnalysisGroup(const void *InterfaceID,
   }
   
   PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl());
   if (ShouldFree)
     Impl->ToFree.push_back(std::unique_ptr<const PassInfo>(&Registeree));
 }
 
 void PassRegistry::addRegistrationListener(PassRegistrationListener *L) {
-  sys::SmartScopedWriter<true> Guard(*Lock);
+  sys::SmartScopedWriter<true> Guard(Lock);
   PassRegistryImpl *Impl = static_cast<PassRegistryImpl*>(getImpl());
-  Impl->Listeners.push_back(L);
+  Impl->RegistrationListeners.push_back(L);
 }
 
 void PassRegistry::removeRegistrationListener(PassRegistrationListener *L) {
-  sys::SmartScopedWriter<true> Guard(*Lock);
+  sys::SmartScopedWriter<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(Impl->Listeners.begin(), Impl->Listeners.end(), L);
-  assert(I != Impl->Listeners.end() &&
-         "PassRegistrationListener not registered!");
-  Impl->Listeners.erase(I);
+    std::find(Impl->RegistrationListeners.begin(), Impl->RegistrationListeners.end(), L);
+  assert(I != Impl->RegistrationListeners.end() &&
+         "Pass registration listener not registered!");
+  Impl->RegistrationListeners.erase(I);
 }

lib/IR/StaticPassRegistry.cpp

+//===- StaticPassRegistry.cpp - Pass Registration Implementation ----------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the StaticPassRegistry, with which static passes are 
+// registered during program initialization.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/StaticPassRegistry.h"
+#include "llvm/PassSupport.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ManagedStatic.h"
+#include <vector>
+
+using namespace llvm;
+
+static ManagedStatic<StaticPassRegistry> PassRegistryObj;
+
+StaticPassRegistry *StaticPassRegistry::getStaticPassRegistry() {
+  return &*PassRegistryObj;
+}
+
+void StaticPassRegistry::registerPass(const PassInfo &PI) {
+  PassInfoList.push_back(&PI);
+}
 No newline at end of file

tools/bugpoint/bugpoint.cpp

 int main(int argc, char **argv) {
 #ifndef DEBUG_BUGPOINT
   llvm::sys::PrintStackTraceOnErrorSignal();
   llvm::PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 #endif
 
   // Initialize passes
+  PassRegistry::initializePassRegistry();
   PassRegistry &Registry = *PassRegistry::getPassRegistry();
+  // Add a registration listener to catch dynamically loaded pass registrations,
+  // and do an enumeration to catch existing pass registrations done during 
+  // static program initialization.
+  Registry.addRegistrationListener(&PassList.getParser());
+  Registry.enumerateWith(&PassList.getParser());
+
   initializeCore(Registry);
   initializeScalarOpts(Registry);
   initializeObjCARCOpts(Registry);
   initializeVectorization(Registry);
   initializeIPO(Registry);
   initializeAnalysis(Registry);
   initializeIPA(Registry);
   initializeTransformUtils(Registry);

tools/llc/llc.cpp

 // main - Entry point for the llc compiler.
 //
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
+  PassRegistry::initializePassRegistry();
 
   LLVMContext &Context = getGlobalContext();
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   // Initialize targets first, so that --version shows registered targets.
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();

tools/opt/opt.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/LinkAllIR.h"
 #include "llvm/LinkAllPasses.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/PassManager.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/SystemUtils.h"

 
 //===----------------------------------------------------------------------===//
 // main for opt
 //
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   llvm::PrettyStackTraceProgram X(argc, argv);
 
+  PassRegistry::initializePassRegistry();
+  PassRegistry &Registry = *PassRegistry::getPassRegistry();
+  // Add a registration listener to catch dynamically loaded pass registrations,
+  // and do an enumeration to catch existing pass registrations done during 
+  // static program initialization.
+  Registry.addRegistrationListener(&PassList.getParser());
+  Registry.enumerateWith(&PassList.getParser());
+
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
 
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
   LLVMContext &Context = getGlobalContext();
 
   InitializeAllTargets();
   InitializeAllTargetMCs();
 
   // Initialize passes
-  PassRegistry &Registry = *PassRegistry::getPassRegistry();
   initializeCore(Registry);
   initializeDebugIRPass(Registry);
   initializeScalarOpts(Registry);
   initializeObjCARCOpts(Registry);
   initializeVectorization(Registry);
   initializeIPO(Registry);
   initializeAnalysis(Registry);
   initializeIPA(Registry);