Change base mutex implementations to use STL-provided mutexes

[zturner]

Summary

This is a re-submission of an earlier broken patch.

Change llvm::sys::Mutex implementation to use std::mutex and std::recursive_mutex.

This patch deletes the platform specific mutex implementations, and delegates to the underlying STL implementation. Because STL mutex and recursive_mutex are implemented as separate classes, it is no longer possible to specify as a runtime param whether a recursive mutex is desired, and instead the decision must be made at compile time.

As part of this refactor, the ScopedLock class is deleted in favor of MutexGuard, which provides equivalent functionality.

To make reviewing easier, you can refer to the following table of equivalences in the format (old_type -> new_type)

SmartMutex<true>([true]) -> RecursiveDebugMutex

SmartMutex<false>([true]) -> RecursiveMutex
sys::Mutex -> SmartMutex<false>() -> RecursiveMutex

SmartMutex<true>(false) -> NonRecursiveDebugMutex
SmartMutex<false>(false) -> NonRecursiveMutex

One caveat of note is that on Windows std::*mutex cannot be used during an atexit handler. To get around this, a new type AtexitSafeMutex is defined, and on Windows this is typedefed to a critical section.

[aaron.ballman]

Is there a clang companion patch as well?

~Aaron

[zturner]

Yes, but that one hasn't changed since the last time so I didn't bother re-uploading it. The old one is still up. It's mentioned in the Testing section, but it's D3961

[zturner]

Also make sure you're clang repo is up-to-date at least to r210225. That fixes the test failures we saw last time.

[zturner]

Remove the Mutex.h dependency on windows.h, and address various other review comments.

This solution is still less than ideal, because we need to include some windows preprocessor checks inside of Mutex.h. The best solution in my opinion would require allowing some platform specific headers to be in the include tree (for example, include\llvm\Support\Windows\CriticalSectionMutex.h). This would remove all of the preprocessor code from Mutex.h, and allow anyone who needs this to simply write #include "llvm/Support/Windows/CriticalSectionMutex.h".

[chandlerc]

Backing up a second, and setting aside all aspects of windows.h, I think
this patch is going in the wrong direction at a very fundamental level.

I think it is a really huge mistake for LLVM to continue to use its own
Mutex class. I don't think you should change it, I think you should remove
it, and use std::mutex. I understand that this may be hard, but I think
time would be better spent working on those hard problems. I see a few
elements that you'll need to address:

1. Fixing the code in atexit handlers. I'm not 100% certain of the right

approach here, but my strong suspicion is that they should not be using a
mutex *at all*. LLVM should have *very* little code in atexit handlers as a
library, and that code really should be customized for the single threaded
and strange circumstance in which it runs. I know you've already started
down this path. In general, that should be a nice separable bit.

2. You or someone else should start a discussion on llvmdev@ about whether

or not we need to avoid the *overhead* of an uncontended mutex lock when
LLVM is not multithreaded. I think that the answer is "no" based on a lot
of experience with reasonably good mutex implementations, but we need to
collect more opinions about this and understand the specific use cases. If
there are mutexes which materially impact the performance of LLVM when
running in a single thread, they will also be performance problems for
multithreaded code (by virtue of crazy amounts of contention) and should be
fixed directly.

3. Perhaps even before doing #2, we should sort out whether the

multithreaded support in LLVM should be a compile time or runtime
parameter. While I strongly feel it should be compile time if present at
all, this isn't a discussion for a long, twisty patch review thread. =] It
needs its own discussion and a wider audience.

I also suspect you could go ahead and convert some users of mutexes to
std::mutex while these things are in-flight. For example, I agree with Greg
who said on the LLDB list that he would prefer LLDB just use std::mutex --
why not go ahead and start that migration? If LLD still uses something
else, that would be another good candidate. Both of those have a decent
history of being multithreaded always, and so it seems uncontentious there
even while we try to sort out exactly what is right for the core libraries
that support JITs and other more complex users.

-Chandler

include/llvm/ExecutionEngine/ExecutionEngine.h

 #include "llvm-c/ExecutionEngine.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/ValueHandle.h"
 #include "llvm/IR/ValueMap.h"
 #include "llvm/MC/MCCodeGenInfo.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <map>
 #include <string>
 #include <vector>
 
 namespace llvm {
 

 }
 
 /// \brief Helper class for helping synchronize access to the global address map
 /// table.
 class ExecutionEngineState {
 public:
   struct AddressMapConfig : public ValueMapConfig<const GlobalValue*> {
     typedef ExecutionEngineState *ExtraData;
-    static sys::Mutex *getMutex(ExecutionEngineState *EES);
+    static sys::MutexBase *getMutex(ExecutionEngineState *EES);
     static void onDelete(ExecutionEngineState *EES, const GlobalValue *Old);
     static void onRAUW(ExecutionEngineState *, const GlobalValue *,
                        const GlobalValue *);
   };
 
   typedef ValueMap<const GlobalValue *, void *, AddressMapConfig>
       GlobalAddressMapTy;
 
protected:
   /// pointer is invoked to create it.  If this returns null, the JIT will
   /// abort.
   void *(*LazyFunctionCreator)(const std::string &);
 
 public:
   /// lock - This lock protects the ExecutionEngine, MCJIT, JIT, JITResolver and
   /// JITEmitter classes.  It must be held while changing the internal state of
   /// any of those classes.
-  sys::Mutex lock;
+  sys::RecursiveMutex lock;
 
   //===--------------------------------------------------------------------===//
   //  ExecutionEngine Startup
   //===--------------------------------------------------------------------===//
 
   virtual ~ExecutionEngine();
 
   /// create - This is the factory method for creating an execution engine which

include/llvm/IR/ValueMap.h

struct ValueMapConfig {
   template<typename ExtraDataT>
   static void onDelete(const ExtraDataT &/*Data*/, KeyT /*Old*/) {}
 
   /// Returns a mutex that should be acquired around any changes to the map.
   /// This is only acquired from the CallbackVH (and held around calls to onRAUW
   /// and onDelete) and not inside other ValueMap methods.  NULL means that no
   /// mutex is necessary.
   template<typename ExtraDataT>
-  static sys::Mutex *getMutex(const ExtraDataT &/*Data*/) { return nullptr; }
+  static sys::MutexBase *getMutex(const ExtraDataT &/*Data*/) { return nullptr; }
 };
 
 /// See the file comment.
 template<typename KeyT, typename ValueT, typename Config =ValueMapConfig<KeyT> >
 class ValueMap {
   friend class ValueMapCallbackVH<KeyT, ValueT, Config>;
   typedef ValueMapCallbackVH<KeyT, ValueT, Config> ValueMapCVH;
   typedef DenseMap<ValueMapCVH, ValueT, DenseMapInfo<ValueMapCVH> > MapT;
ValueMapCallbackVH(KeyT Key, ValueMapT *Map)
         Map(Map) {}
 
 public:
   KeyT Unwrap() const { return cast_or_null<KeySansPointerT>(getValPtr()); }
 
   void deleted() override {
     // Make a copy that won't get changed even when *this is destroyed.
     ValueMapCallbackVH Copy(*this);
-    sys::Mutex *M = Config::getMutex(Copy.Map->Data);
+    sys::MutexBase *M = Config::getMutex(Copy.Map->Data);
     if (M)
       M->acquire();
     Config::onDelete(Copy.Map->Data, Copy.Unwrap());  // May destroy *this.
     Copy.Map->Map.erase(Copy);  // Definitely destroys *this.
     if (M)
       M->release();
   }
   void allUsesReplacedWith(Value *new_key) override {
     assert(isa<KeySansPointerT>(new_key) &&
            "Invalid RAUW on key of ValueMap<>");
     // Make a copy that won't get changed even when *this is destroyed.
     ValueMapCallbackVH Copy(*this);
-    sys::Mutex *M = Config::getMutex(Copy.Map->Data);
+    sys::MutexBase *M = Config::getMutex(Copy.Map->Data);
     if (M)
       M->acquire();
 
     KeyT typed_new_key = cast<KeySansPointerT>(new_key);
     // Can destroy *this:
     Config::onRAUW(Copy.Map->Data, Copy.Unwrap(), typed_new_key);
     if (Config::FollowRAUW) {
       typename ValueMapT::MapT::iterator I = Copy.Map->Map.find(Copy);

include/llvm/Support/Mutex.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MUTEX_H
 #define LLVM_SUPPORT_MUTEX_H
 
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Threading.h"
 #include <cassert>
+#include <mutex>
 
 namespace llvm
 {
   namespace sys
   {
-    /// @brief Platform agnostic Mutex class.
-    class MutexImpl
+    /// @brief Platform agnostic mutex interface.
+    class MutexBase
     {
     /// @name Constructors
     /// @{
     public:
-
-      /// Initializes the lock but doesn't acquire it. if \p recursive is set
-      /// to false, the lock will not be recursive which makes it cheaper but
-      /// also more likely to deadlock (same thread can't acquire more than
-      /// once).
-      /// @brief Default Constructor.
-      explicit MutexImpl(bool recursive = true);
+      /// Initializes the lock
+      /// @brief Constructor
+      MutexBase() {}
 
       /// Releases and removes the lock
       /// @brief Destructor
-      ~MutexImpl();
+      virtual ~MutexBase() {}
 
     /// @}
     /// @name Methods
     /// @{
     public:
 
       /// Attempts to unconditionally acquire the lock. If the lock is held by
       /// another thread, this method will wait until it can acquire the lock.
-      /// @returns false if any kind of error occurs, true otherwise.
       /// @brief Unconditionally acquire the lock.
-      bool acquire();
+      virtual void acquire() = 0;
 
       /// Attempts to release the lock. If the lock is held by the current
       /// thread, the lock is released allowing other threads to acquire the
       /// lock.
-      /// @returns false if any kind of error occurs, true otherwise.
       /// @brief Unconditionally release the lock.
-      bool release();
+      virtual void release() = 0;
 
       /// Attempts to acquire the lock without blocking. If the lock is not
       /// available, this function returns false quickly (without blocking). If
       /// the lock is available, it is acquired.
       /// @returns false if any kind of error occurs or the lock is not
       /// available, true otherwise.
       /// @brief Try to acquire the lock.
-      bool tryacquire();
-
-    //@}
-    /// @name Platform Dependent Data
-    /// @{
-    private:
-      void* data_; ///< We don't know what the data will be
+      virtual bool tryacquire() = 0;
 
     /// @}
     /// @name Do Not Implement
     /// @{
     private:
-      MutexImpl(const MutexImpl &) LLVM_DELETED_FUNCTION;
-      void operator=(const MutexImpl &) LLVM_DELETED_FUNCTION;
+      MutexBase(const MutexBase &) LLVM_DELETED_FUNCTION;
+      void operator=(const MutexBase &) LLVM_DELETED_FUNCTION;
     /// @}
     };
 
-
-    /// SmartMutex - A mutex with a compile time constant parameter that
+    /// Mutex - A mutex with a compile time constant parameter that
     /// indicates whether this mutex should become a no-op when we're not
     /// running in multithreaded mode.
-    template<bool mt_only>
-    class SmartMutex : public MutexImpl {
+    template<bool mt_only, bool recursive>
+    class Mutex : public MutexBase {
+    public:
+      typedef typename std::conditional<recursive,
+                                        std::recursive_mutex,
+                                        std::mutex>::type mutex_type;
+
+    private:
+      mutex_type mutex;
       unsigned acquired;
-      bool recursive;
+
     public:
-      explicit SmartMutex(bool rec = true) :
-        MutexImpl(rec), acquired(0), recursive(rec) { }
+      Mutex() : acquired(0) {}
 
-      bool acquire() {
-        if (!mt_only || llvm_is_multithreaded()) {
-          return MutexImpl::acquire();
-        } else {
+      mutex_type& native_mutex() { return mutex; }
+
+      virtual void acquire() {
+        if (!mt_only || llvm_is_multithreaded())
+          mutex.lock();
+        else {
           // Single-threaded debugging code.  This would be racy in
           // multithreaded mode, but provides not sanity checks in single
           // threaded mode.
           assert((recursive || acquired == 0) && "Lock already acquired!!");
           ++acquired;
-          return true;
         }
       }
 
-      bool release() {
-        if (!mt_only || llvm_is_multithreaded()) {
-          return MutexImpl::release();
-        } else {
+      virtual void release() {
+        if (!mt_only || llvm_is_multithreaded())
+          mutex.unlock();
+        else {
           // Single-threaded debugging code.  This would be racy in
           // multithreaded mode, but provides not sanity checks in single
           // threaded mode.
           assert(((recursive && acquired) || (acquired == 1)) &&
                   "Lock not acquired before release!");
           --acquired;
-          return true;
         }
       }
 
-      bool tryacquire() {
+      virtual bool tryacquire() {
         if (!mt_only || llvm_is_multithreaded())
-          return MutexImpl::tryacquire();
-        else return true;
+          return mutex.try_lock();
+        else {
+          bool can_lock = (recursive || acquired == 0);
+          if (can_lock)
+            ++acquired;
+          return can_lock;
+        }
       }
 
-      private:
-        SmartMutex(const SmartMutex<mt_only> & original);
-        void operator=(const SmartMutex<mt_only> &);
+      Mutex(const Mutex<mt_only, recursive> & original);
+      void operator=(const Mutex<mt_only, recursive> &);
     };
 
-    /// Mutex - A standard, always enforced mutex.
-    typedef SmartMutex<false> Mutex;
-
-    template<bool mt_only>
-    class SmartScopedLock  {
-      SmartMutex<mt_only>& mtx;
+#if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
+    class NullMutex : public MutexBase {
+      NullMutex() { }
+      virtual ~NullMutex() { }
+
+      void acquire() override { }
+      void release() override { }
+      bool tryacquire() override { return true; }
+    };
+#endif
 
+#if defined(LLVM_ON_WIN32)
+    class CriticalSectionMutex : public MutexBase {
+    private:
+      void* Impl;
     public:
-      SmartScopedLock(SmartMutex<mt_only>& m) : mtx(m) {
-        mtx.acquire();
-      }
+      CriticalSectionMutex();
+      virtual ~CriticalSectionMutex();
 
-      ~SmartScopedLock() {
-        mtx.release();
-      }
+      void acquire() override;
+      void release() override;
+      bool tryacquire() override;
     };
+#endif
+
+#if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
+    typedef NullMutex RecursiveMutex;
+    typedef NullMutex NonRecursiveMutex;
+
+    typedef NullMutex RecursiveDebugMutex;
+    typedef NullMutex NonRecursiveDebugMutex
+#else
+    /// RecursiveMutex, NonRecursiveMutex - Standard, always enforced mutexes.
+    typedef Mutex<false, true> RecursiveMutex;
+    typedef Mutex<false, false> NonRecursiveMutex;
+
+    /// RecursiveDebugMutex, NonRecursiveDebugMutex - Mutexes which are not
+    /// enforced and provide additional debug information when LLVM runs in
+    /// single-threaded mode.
+    typedef Mutex<true, true> RecursiveDebugMutex;
+    typedef Mutex<true, false> NonRecursiveDebugMutex;
+#endif
 
-    typedef SmartScopedLock<false> ScopedLock;
   }
 }
 
 #endif

include/llvm/Support/MutexGuard.h

 namespace llvm {
   /// Instances of this class acquire a given Mutex Lock when constructed and
   /// hold that lock until destruction. The intention is to instantiate one of
   /// these on the stack at the top of some scope to be assured that C++
   /// destruction of the object will always release the Mutex and thus avoid
   /// a host of nasty multi-threading problems in the face of exceptions, etc.
   /// @brief Guard a section of code with a Mutex.
   class MutexGuard {
-    sys::Mutex &M;
+    sys::MutexBase &M;
+
     MutexGuard(const MutexGuard &) LLVM_DELETED_FUNCTION;
     void operator=(const MutexGuard &) LLVM_DELETED_FUNCTION;
   public:
-    MutexGuard(sys::Mutex &m) : M(m) { M.acquire(); }
+    MutexGuard(sys::MutexBase &m) : M(m) { M.acquire(); }
     ~MutexGuard() { M.release(); }
     /// holds - Returns true if this locker instance holds the specified lock.
     /// This is mostly used in assertions to validate that the correct mutex
     /// is held.
-    bool holds(const sys::Mutex& lock) const { return &M == &lock; }
+    bool holds(const sys::MutexBase& Lock) const { return &M == &Lock; }
   };
 }
 
 #endif // LLVM_SUPPORT_MUTEXGUARD_H

lib/CodeGen/PseudoSourceValue.cpp

 
 #include "llvm/CodeGen/PseudoSourceValue.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
 using namespace llvm;
 
 namespace {
 struct PSVGlobalsTy {
   // PseudoSourceValues are immutable so don't need locking.
   const PseudoSourceValue PSVs[4];
-  sys::Mutex Lock;  // Guards FSValues, but not the values inside it.
+  sys::RecursiveMutex Lock;  // Guards FSValues, but not the values inside it.
   std::map<int, const PseudoSourceValue *> FSValues;
 
   PSVGlobalsTy() : PSVs() {}
   ~PSVGlobalsTy() {
     for (std::map<int, const PseudoSourceValue *>::iterator
            I = FSValues.begin(), E = FSValues.end(); I != E; ++I) {
       delete I->second;
     }

 PseudoSourceValue::~PseudoSourceValue() {}
 
 void PseudoSourceValue::printCustom(raw_ostream &O) const {
   O << PSVNames[this - PSVGlobals->PSVs];
 }
 
 const PseudoSourceValue *PseudoSourceValue::getFixedStack(int FI) {
   PSVGlobalsTy &PG = *PSVGlobals;
-  sys::ScopedLock locked(PG.Lock);
+  llvm::MutexGuard locked(PG.Lock);
   const PseudoSourceValue *&V = PG.FSValues[FI];
   if (!V)
     V = new FixedStackPseudoSourceValue(FI);
   return V;
 }
 
 bool PseudoSourceValue::isConstant(const MachineFrameInfo *) const {
   if (this == getStack())

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetInstrInfo.h"
 #include "llvm/Target/TargetIntrinsicInfo.h"
 #include "llvm/Target/TargetLowering.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegisterInfo.h"
 #include "llvm/Target/TargetSelectionDAGInfo.h"
EVTArray() {
       for (unsigned i = 0; i < MVT::LAST_VALUETYPE; ++i)
         VTs.push_back(MVT((MVT::SimpleValueType)i));
     }
   };
 }
 
 static ManagedStatic<std::set<EVT, EVT::compareRawBits> > EVTs;
 static ManagedStatic<EVTArray> SimpleVTArray;
-static ManagedStatic<sys::SmartMutex<true> > VTMutex;
+static ManagedStatic<sys::RecursiveDebugMutex> VTMutex;
 
 /// getValueTypeList - Return a pointer to the specified value type.
 ///
 const EVT *SDNode::getValueTypeList(EVT VT) {
   if (VT.isExtended()) {
-    sys::SmartScopedLock<true> Lock(*VTMutex);
+    llvm::MutexGuard Lock(*VTMutex);
     return &(*EVTs->insert(VT).first);
   } else {
     assert(VT.getSimpleVT() < MVT::LAST_VALUETYPE &&
            "Value type out of range!");
     return &SimpleVTArray->VTs[VT.getSimpleVT().SimpleTy];
   }
 }
 

lib/ExecutionEngine/ExecutionEngine.cpp

void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) {
   NumInitBytes += (unsigned)GVSize;
   ++NumGlobals;
 }
 
 ExecutionEngineState::ExecutionEngineState(ExecutionEngine &EE)
   : EE(EE), GlobalAddressMap(this) {
 }
 
-sys::Mutex *
+sys::MutexBase *
 ExecutionEngineState::AddressMapConfig::getMutex(ExecutionEngineState *EES) {
   return &EES->EE.lock;
 }
 
 void ExecutionEngineState::AddressMapConfig::onDelete(ExecutionEngineState *EES,
                                                       const GlobalValue *Old) {
   void *OldVal = EES->GlobalAddressMap.lookup(Old);
   EES->GlobalAddressReverseMap.erase(OldVal);
 }
 
 void ExecutionEngineState::AddressMapConfig::onRAUW(ExecutionEngineState *,
                                                     const GlobalValue *,
                                                     const GlobalValue *) {
   llvm_unreachable("The ExecutionEngine doesn't know how to handle a"
                    " RAUW on a value it has a global mapping for.");
 }

lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp

 #include "llvm/Config/config.h"     // Detect libffi
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include <cmath>
 #include <csignal>
 #include <cstdio>
 #include <cstring>
 #include <map>
 
 #ifdef HAVE_FFI_CALL
 #ifdef HAVE_FFI_H
 #include <ffi.h>
 #define USE_LIBFFI
 #elif HAVE_FFI_FFI_H
 #include <ffi/ffi.h>
 #define USE_LIBFFI
 #endif
 #endif
 
 using namespace llvm;
 
-static ManagedStatic<sys::Mutex> FunctionsLock;
+static ManagedStatic<sys::RecursiveMutex> FunctionsLock;
 
 typedef GenericValue (*ExFunc)(FunctionType *,
                                const std::vector<GenericValue> &);
 static ManagedStatic<std::map<const Function *, ExFunc> > ExportedFunctions;
 static std::map<std::string, ExFunc> FuncNames;
 
 #ifdef USE_LIBFFI
 typedef void (*RawFunc)();
static ExFunc lookupFunction(const Function *F) {
   // Function not found, look it up... start by figuring out what the
   // composite function name should be.
   std::string ExtName = "lle_";
   FunctionType *FT = F->getFunctionType();
   for (unsigned i = 0, e = FT->getNumContainedTypes(); i != e; ++i)
     ExtName += getTypeID(FT->getContainedType(i));
   ExtName += "_" + F->getName().str();
 
-  sys::ScopedLock Writer(*FunctionsLock);
+  llvm::MutexGuard Writer(*FunctionsLock);
   ExFunc FnPtr = FuncNames[ExtName];
   if (!FnPtr)
     FnPtr = FuncNames["lle_X_" + F->getName().str()];
   if (!FnPtr)  // Try calling a generic function... if it exists...
     FnPtr = (ExFunc)(intptr_t)
       sys::DynamicLibrary::SearchForAddressOfSymbol("lle_X_" +
                                                     F->getName().str());
   if (FnPtr)
static GenericValue lle_X_memcpy(FunctionType *FT,
   // llvm.memcpy* returns void, lle_X_* returns GenericValue,
   // so here we return GenericValue with IntVal set to zero
   GenericValue GV;
   GV.IntVal = 0;
   return GV;
 }
 
 void Interpreter::initializeExternalFunctions() {
-  sys::ScopedLock Writer(*FunctionsLock);
+  llvm::MutexGuard Writer(*FunctionsLock);
   FuncNames["lle_X_atexit"]       = lle_X_atexit;
   FuncNames["lle_X_exit"]         = lle_X_exit;
   FuncNames["lle_X_abort"]        = lle_X_abort;
 
   FuncNames["lle_X_printf"]       = lle_X_printf;
   FuncNames["lle_X_sprintf"]      = lle_X_sprintf;
   FuncNames["lle_X_sscanf"]       = lle_X_sscanf;
   FuncNames["lle_X_scanf"]        = lle_X_scanf;
   FuncNames["lle_X_fprintf"]      = lle_X_fprintf;
   FuncNames["lle_X_memset"]       = lle_X_memset;
   FuncNames["lle_X_memcpy"]       = lle_X_memcpy;
 }

lib/ExecutionEngine/JIT/JIT.cpp

ExecutionEngine *JIT::createJIT(Module *M,
   }
 }
 
 namespace {
 /// This class supports the global getPointerToNamedFunction(), which allows
 /// bugpoint or gdb users to search for a function by name without any context.
 class JitPool {
   SmallPtrSet<JIT*, 1> JITs;  // Optimize for process containing just 1 JIT.
-  mutable sys::Mutex Lock;
+  mutable sys::RecursiveMutex Lock;
 public:
   void Add(JIT *jit) {
     MutexGuard guard(Lock);
     JITs.insert(jit);
   }
   void Remove(JIT *jit) {
     MutexGuard guard(Lock);
     JITs.erase(jit);

lib/ExecutionEngine/JIT/JITEmitter.cpp

#endif
   class StubToResolverMapTy {
     /// Map a stub address to a specific instance of a JITResolver so that
     /// lazily-compiled functions can find the right resolver to use.
     ///
     /// Guarded by Lock.
     std::map<void*, JITResolver*> Map;
 
     /// Guards Map from concurrent accesses.
-    mutable sys::Mutex Lock;
+    mutable sys::RecursiveMutex Lock;
 
   public:
     /// Registers a Stub to be resolved by Resolver.
     void RegisterStubResolver(void *Stub, JITResolver *Resolver) {
       MutexGuard guard(Lock);
       Map.insert(std::make_pair(Stub, Resolver));
     }
     /// Unregisters the Stub when it's invalidated.

lib/ExecutionEngine/OProfileJIT/OProfileWrapper.cpp

 #include <sys/stat.h>
 #include <unistd.h>
 
 #define DEBUG_TYPE "oprofile-wrapper"
 
 namespace {
 
 // Global mutex to ensure a single thread initializes oprofile agent.
-llvm::sys::Mutex OProfileInitializationMutex;
+llvm::sys::RecursiveMutex OProfileInitializationMutex;
 
 } // anonymous namespace
 
 namespace llvm {
 
 OProfileWrapper::OProfileWrapper()
 : Agent(0),
   OpenAgentFunc(0),

lib/ExecutionEngine/RuntimeDyld/GDBRegistrar.cpp

private:
   /// Deregister the debug info for the given object file from the debugger
   /// and delete any temporary copies.  This private method does not remove
   /// the function from Map so that it can be called while iterating over Map.
   void deregisterObjectInternal(RegisteredObjectBufferMap::iterator I);
 };
 
 /// Lock used to serialize all jit registration events, since they
 /// modify global variables.
-llvm::sys::Mutex JITDebugLock;
+llvm::sys::RecursiveMutex JITDebugLock;
 
 /// Do the registration.
 void NotifyDebugger(jit_code_entry* JITCodeEntry) {
   __jit_debug_descriptor.action_flag = JIT_REGISTER_FN;
 
   // Insert this entry at the head of the list.
   JITCodeEntry->prev_entry = nullptr;
   jit_code_entry* NextEntry = __jit_debug_descriptor.first_entry;

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

#define RTDYLD_INVALID_SECTION_ID ((SID)(-1))
   // and guarantees that section allocation requests to the memory manager
   // won't be interleaved between modules.  It is also used in mapSectionAddress
   // and resolveRelocations to protect write access to internal data structures.
   //
   // loadObject may be called on the same thread during the handling of of
   // processRelocations, and that's OK.  The handling of the relocation lists
   // is written in such a way as to work correctly if new elements are added to
   // the end of the list while the list is being processed.
-  sys::Mutex lock;
+  sys::RecursiveMutex lock;
 
   virtual unsigned getMaxStubSize() = 0;
   virtual unsigned getStubAlignment() = 0;
 
   bool HasError;
   std::string ErrorStr;
 
   // Set the error state and record an error string.

lib/IR/LeakDetector.cpp

 
 #include "llvm/IR/LeakDetector.h"
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/Threading.h"
 using namespace llvm;
 
-static ManagedStatic<sys::SmartMutex<true> > ObjectsLock;
+static ManagedStatic<sys::RecursiveDebugMutex> ObjectsLock;
 static ManagedStatic<LeakDetectorImpl<void> > Objects;
 
 static void clearGarbage(LLVMContext &Context) {
   Objects->clear();
   Context.pImpl->LLVMObjects.clear();
 }
 
 void LeakDetector::addGarbageObjectImpl(void *Object) {
-  sys::SmartScopedLock<true> Lock(*ObjectsLock);
+  llvm::MutexGuard Lock(*ObjectsLock);
   Objects->addGarbage(Object);
 }
 
 void LeakDetector::addGarbageObjectImpl(const Value *Object) {
   LLVMContextImpl *pImpl = Object->getContext().pImpl;
   pImpl->LLVMObjects.addGarbage(Object);
 }
 
 void LeakDetector::removeGarbageObjectImpl(void *Object) {
-  sys::SmartScopedLock<true> Lock(*ObjectsLock);
+  llvm::MutexGuard Lock(*ObjectsLock);
   Objects->removeGarbage(Object);
 }
 
 void LeakDetector::removeGarbageObjectImpl(const Value *Object) {
   LLVMContextImpl *pImpl = Object->getContext().pImpl;
   pImpl->LLVMObjects.removeGarbage(Object);
 }
 
 void LeakDetector::checkForGarbageImpl(LLVMContext &Context, 
                                        const std::string &Message) {
   LLVMContextImpl *pImpl = Context.pImpl;
-  sys::SmartScopedLock<true> Lock(*ObjectsLock);
+  llvm::MutexGuard Lock(*ObjectsLock);
   
   Objects->setName("GENERIC");
   pImpl->LLVMObjects.setName("LLVM");
   
   // use non-short-circuit version so that both checks are performed
   if (Objects->hasGarbage(Message) |
       pImpl->LLVMObjects.hasGarbage(Message))
     errs() << "\nThis is probably because you removed an object, but didn't "
            << "delete it.  Please check your code for memory leaks.\n";
 
   // Clear out results so we don't get duplicate warnings on
   // next call...
   clearGarbage(Context);
 }

lib/IR/LegacyPassManager.cpp

 #include "llvm/IR/LegacyPassManagers.h"
 #include "llvm/IR/LegacyPassNameParser.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/TimeValue.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <map>
 using namespace llvm;
 using namespace llvm::legacy;
 

 namespace {
 
 //===----------------------------------------------------------------------===//
 /// TimingInfo Class - This class is used to calculate information about the
 /// amount of time each pass takes to execute.  This only happens when
 /// -time-passes is enabled on the command line.
 ///
 
-static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
+static ManagedStatic<sys::RecursiveDebugMutex> TimingInfoMutex;
 
 class TimingInfo {
   DenseMap<Pass*, Timer*> TimingData;
   TimerGroup TG;
 public:
   // Use 'create' member to get this.
   TimingInfo() : TG("... Pass execution timing report ...") {}
 
public:
   // null.  It may be called multiple times.
   static void createTheTimeInfo();
 
   /// getPassTimer - Return the timer for the specified pass if it exists.
   Timer *getPassTimer(Pass *P) {
     if (P->getAsPMDataManager())
       return nullptr;
 
-    sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
+    llvm::MutexGuard Lock(*TimingInfoMutex);
     Timer *&T = TimingData[P];
     if (!T)
       T = new Timer(P->getPassName(), TG);
     return T;
   }
 };
 
 } // End of anon namespace

lib/Support/CMakeLists.txt

# System
   Threading.cpp
   TimeValue.cpp
   Valgrind.cpp
   Watchdog.cpp
 
   ADDITIONAL_HEADERS
   Unix/Host.inc
   Unix/Memory.inc
-  Unix/Mutex.inc
   Unix/Path.inc
   Unix/Process.inc
   Unix/Program.inc
   Unix/RWMutex.inc
   Unix/Signals.inc
   Unix/system_error.inc
   Unix/ThreadLocal.inc
   Unix/TimeValue.inc
   Unix/Watchdog.inc
   Windows/DynamicLibrary.inc
   Windows/Host.inc
   Windows/Memory.inc
-  Windows/Mutex.inc
   Windows/Path.inc
   Windows/Process.inc
   Windows/Program.inc
   Windows/RWMutex.inc
   Windows/Signals.inc
   Windows/system_error.inc
   Windows/ThreadLocal.inc
   Windows/TimeValue.inc

lib/Support/CrashRecoveryContext.cpp

 //===--- CrashRecoveryContext.cpp - Crash Recovery ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/ThreadLocal.h"
 #include <cstdio>
 #include <setjmp.h>
 using namespace llvm;
 
 namespace {
 
 struct CrashRecoveryContextImpl;
void HandleCrash() {
 
     // Jump back to the RunSafely we were called under.
     longjmp(JumpBuffer, 1);
   }
 };
 
 }
 
-static ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
+static ManagedStatic<sys::RecursiveMutex> gCrashRecoveryContextMutex;
 static bool gCrashRecoveryEnabled = false;
 
 static ManagedStatic<sys::ThreadLocal<const CrashRecoveryContextCleanup> >
        tlIsRecoveringFromCrash;
 
 CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() {}
 
 CrashRecoveryContext::~CrashRecoveryContext() {

 // Because the Enable and Disable calls are static, it means that
 // there may not actually be an Impl available, or even a current
 // CrashRecoveryContext at all.  So we make use of a thread-local
 // exception table.  The handles contained in here will either be
 // non-NULL, valid VEH handles, or NULL.
 static sys::ThreadLocal<const void> sCurrentExceptionHandle;
 
 void CrashRecoveryContext::Enable() {
-  sys::ScopedLock L(*gCrashRecoveryContextMutex);
+  llvm::MutexGuard L(*gCrashRecoveryContextMutex);
 
   if (gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = true;
 
   // We can set up vectored exception handling now.  We will install our
   // handler as the front of the list, though there's no assurances that
   // it will remain at the front (another call could install itself before
   // our handler).  This 1) isn't likely, and 2) shouldn't cause problems.
   PVOID handle = ::AddVectoredExceptionHandler(1, ExceptionHandler);
   sCurrentExceptionHandle.set(handle);
 }
 
 void CrashRecoveryContext::Disable() {
-  sys::ScopedLock L(*gCrashRecoveryContextMutex);
+  llvm::MutexGuard L(*gCrashRecoveryContextMutex);
 
   if (!gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = false;
 
   PVOID currentHandle = const_cast<PVOID>(sCurrentExceptionHandle.get());
   if (currentHandle) {
static void CrashRecoverySignalHandler(int Signal) {
   sigaddset(&SigMask, Signal);
   sigprocmask(SIG_UNBLOCK, &SigMask, nullptr);
 
   if (CRCI)
     const_cast<CrashRecoveryContextImpl*>(CRCI)->HandleCrash();
 }
 
 void CrashRecoveryContext::Enable() {
-  sys::ScopedLock L(*gCrashRecoveryContextMutex);
+  llvm::MutexGuard L(*gCrashRecoveryContextMutex);
 
   if (gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = true;
 
   // Setup the signal handler.
   struct sigaction Handler;
   Handler.sa_handler = CrashRecoverySignalHandler;
   Handler.sa_flags = 0;
   sigemptyset(&Handler.sa_mask);
 
   for (unsigned i = 0; i != NumSignals; ++i) {
     sigaction(Signals[i], &Handler, &PrevActions[i]);
   }
 }
 
 void CrashRecoveryContext::Disable() {
-  sys::ScopedLock L(*gCrashRecoveryContextMutex);
+  llvm::MutexGuard L(*gCrashRecoveryContextMutex);
 
   if (!gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = false;
 
   // Restore the previous signal handlers.
   for (unsigned i = 0; i != NumSignals; ++i)

lib/Support/DynamicLibrary.cpp

 
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm-c/Support.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include <cstdio>
 #include <cstring>
 
 // Collection of symbol name/value pairs to be searched prior to any libraries.
 static llvm::ManagedStatic<llvm::StringMap<void *> > ExplicitSymbols;
-static llvm::ManagedStatic<llvm::sys::SmartMutex<true> > SymbolsMutex;
+static llvm::ManagedStatic<llvm::sys::RecursiveDebugMutex> SymbolsMutex;
 
 void llvm::sys::DynamicLibrary::AddSymbol(StringRef symbolName,
                                           void *symbolValue) {
-  SmartScopedLock<true> lock(*SymbolsMutex);
+  llvm::MutexGuard Lock(*SymbolsMutex);
   (*ExplicitSymbols)[symbolName] = symbolValue;
 }
 
 char llvm::sys::DynamicLibrary::Invalid = 0;
 
 #ifdef LLVM_ON_WIN32
 
 #include "Windows/DynamicLibrary.inc"

 //=== WARNING: Implementation here must contain only TRULY operating system
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
 static DenseSet<void *> *OpenedHandles = nullptr;
 
 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *filename,
                                                    std::string *errMsg) {
-  SmartScopedLock<true> lock(*SymbolsMutex);
+  llvm::MutexGuard Lock(*SymbolsMutex);
 
   void *handle = dlopen(filename, RTLD_LAZY|RTLD_GLOBAL);
   if (!handle) {
     if (errMsg) *errMsg = dlerror();
     return DynamicLibrary();
   }
 
 #ifdef __CYGWIN__

 
 #endif
 
 namespace llvm {
 void *SearchForAddressOfSpecialSymbol(const char* symbolName);
 }
 
 void* DynamicLibrary::SearchForAddressOfSymbol(const char *symbolName) {
-  SmartScopedLock<true> Lock(*SymbolsMutex);
+  llvm::MutexGuard Lock(*SymbolsMutex);
 
   // First check symbols added via AddSymbol().
   if (ExplicitSymbols.isConstructed()) {
     StringMap<void *>::iterator i = ExplicitSymbols->find(symbolName);
 
     if (i != ExplicitSymbols->end())
       return i->second;
   }

lib/Support/Mutex.cpp

 //===- Mutex.cpp - Mutual Exclusion Lock ------------------------*- C++ -*-===//
 //
 //                     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 llvm::sys::Mutex class.
+// This file implements mutex support classes.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Config/config.h"
 #include "llvm/Support/Mutex.h"
 
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only TRULY operating system
-//===          independent code.
-//===----------------------------------------------------------------------===//
-
-#if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
-// Define all methods as no-ops if threading is explicitly disabled
-namespace llvm {
-using namespace sys;
-MutexImpl::MutexImpl( bool recursive) { }
-MutexImpl::~MutexImpl() { }
-bool MutexImpl::acquire() { return true; }
-bool MutexImpl::release() { return true; }
-bool MutexImpl::tryacquire() { return true; }
-}
-#else
+#if defined(LLVM_ON_WIN32)
 
-#if defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_MUTEX_LOCK)
-
-#include <cassert>
-#include <pthread.h>
-#include <stdlib.h>
+#include "Windows/WindowsSupport.h"
 
 namespace llvm {
 using namespace sys;
 
-// Construct a Mutex using pthread calls
-MutexImpl::MutexImpl( bool recursive)
-  : data_(nullptr)
-{
-  // Declare the pthread_mutex data structures
-  pthread_mutex_t* mutex =
-    static_cast<pthread_mutex_t*>(malloc(sizeof(pthread_mutex_t)));
-  pthread_mutexattr_t attr;
-
-  // Initialize the mutex attributes
-  int errorcode = pthread_mutexattr_init(&attr);
-  assert(errorcode == 0); (void)errorcode;
-
-  // Initialize the mutex as a recursive mutex, if requested, or normal
-  // otherwise.
-  int kind = ( recursive  ? PTHREAD_MUTEX_RECURSIVE : PTHREAD_MUTEX_NORMAL );
-  errorcode = pthread_mutexattr_settype(&attr, kind);
-  assert(errorcode == 0);
-
-  // Initialize the mutex
-  errorcode = pthread_mutex_init(mutex, &attr);
-  assert(errorcode == 0);
-
-  // Destroy the attributes
-  errorcode = pthread_mutexattr_destroy(&attr);
-  assert(errorcode == 0);
-
-  // Assign the data member
-  data_ = mutex;
+#if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
+// Define all methods as no-ops if threading is explicitly disabled
+CriticalSectionMutex::CriticalSectionMutex() { }
+CriticalSectionMutex::~CriticalSectionMutex() { }
+void CriticalSectionMutex::acquire() { }
+void CriticalSectionMutex::release() { }
+bool CriticalSectionMutex::tryacquire() { return true; }
+#else
+CriticalSectionMutex::CriticalSectionMutex() {
+  Impl = new CRITICAL_SECTION();
+  ::InitializeCriticalSection(static_cast<CRITICAL_SECTION*>(Impl));
 }
 
-// Destruct a Mutex
-MutexImpl::~MutexImpl()
-{
-  pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
-  assert(mutex != nullptr);
-  pthread_mutex_destroy(mutex);
-  free(mutex);
+CriticalSectionMutex::~CriticalSectionMutex() {
+  ::DeleteCriticalSection(static_cast<CRITICAL_SECTION*>(Impl));
+  delete static_cast<CRITICAL_SECTION*>(Impl);
 }
 
-bool
-MutexImpl::acquire()
-{
-  pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
-  assert(mutex != nullptr);
-
-  int errorcode = pthread_mutex_lock(mutex);
-  return errorcode == 0;
+void CriticalSectionMutex::acquire() {
+  ::EnterCriticalSection(static_cast<CRITICAL_SECTION*>(Impl));
 }
 
-bool
-MutexImpl::release()
-{
-  pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
-  assert(mutex != nullptr);
-
-  int errorcode = pthread_mutex_unlock(mutex);
-  return errorcode == 0;
+void CriticalSectionMutex::release() {
+  ::LeaveCriticalSection(static_cast<CRITICAL_SECTION*>(Impl));
 }
 
-bool
-MutexImpl::tryacquire()
-{
-  pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
-  assert(mutex != nullptr);
-
-  int errorcode = pthread_mutex_trylock(mutex);
-  return errorcode == 0;
+bool CriticalSectionMutex::tryacquire() {
+  return ::TryEnterCriticalSection(static_cast<CRITICAL_SECTION*>(Impl));
 }
-
+#endif  // !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
+#endif  // LLVM_ON_WIN32
 }
-
-#elif defined(LLVM_ON_UNIX)
-#include "Unix/Mutex.inc"
-#elif defined( LLVM_ON_WIN32)
-#include "Windows/Mutex.inc"
-#else
-#warning Neither LLVM_ON_UNIX nor LLVM_ON_WIN32 was set in Support/Mutex.cpp
-#endif
-#endif

lib/Support/PluginLoader.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #define DONT_GET_PLUGIN_LOADER_OPTION
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include <vector>
 using namespace llvm;
 
 static ManagedStatic<std::vector<std::string> > Plugins;
-static ManagedStatic<sys::SmartMutex<true> > PluginsLock;
+static ManagedStatic<sys::RecursiveDebugMutex> PluginsLock;
 
 void PluginLoader::operator=(const std::string &Filename) {
-  sys::SmartScopedLock<true> Lock(*PluginsLock);
+  llvm::MutexGuard Lock(*PluginsLock);
   std::string Error;
   if (sys::DynamicLibrary::LoadLibraryPermanently(Filename.c_str(), &Error)) {
     errs() << "Error opening '" << Filename << "': " << Error
            << "\n  -load request ignored.\n";
   } else {
     Plugins->push_back(Filename);
   }
 }
 
 unsigned PluginLoader::getNumPlugins() {
-  sys::SmartScopedLock<true> Lock(*PluginsLock);
+  llvm::MutexGuard Lock(*PluginsLock);
   return Plugins.isConstructed() ? Plugins->size() : 0;
 }
 
 std::string &PluginLoader::getPlugin(unsigned num) {
-  sys::SmartScopedLock<true> Lock(*PluginsLock);
+  llvm::MutexGuard Lock(*PluginsLock);
   assert(Plugins.isConstructed() && num < Plugins->size() &&
          "Asking for an out of bounds plugin");
   return (*Plugins)[num];
 }

lib/Support/Statistic.cpp

 
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
 using namespace llvm;
 
 // CreateInfoOutputFile - Return a file stream to print our output on.
 namespace llvm { extern raw_ostream *CreateInfoOutputFile(); }
 
public:
 
   void addStatistic(const Statistic *S) {
     Stats.push_back(S);
   }
 };
 }
 
 static ManagedStatic<StatisticInfo> StatInfo;
-static ManagedStatic<sys::SmartMutex<true> > StatLock;
+static ManagedStatic<sys::RecursiveDebugMutex> StatLock;
 
 /// RegisterStatistic - The first time a statistic is bumped, this method is
 /// called.
 void Statistic::RegisterStatistic() {
   // If stats are enabled, inform StatInfo that this statistic should be
   // printed.
-  sys::SmartScopedLock<true> Writer(*StatLock);
+  llvm::MutexGuard Writer(*StatLock);
   if (!Initialized) {
     if (Enabled)
       StatInfo->addStatistic(this);
 
     TsanHappensBefore(this);
     sys::MemoryFence();
     // Remember we have been registered.
     TsanIgnoreWritesBegin();

lib/Support/Threading.cpp

 #include "llvm/Support/Atomic.h"
 #include "llvm/Support/Mutex.h"
 #include <cassert>
 
 using namespace llvm;
 
 static bool multithreaded_mode = false;
 
-static sys::Mutex* global_lock = nullptr;
+static sys::RecursiveMutex *global_lock = nullptr;
 
 bool llvm::llvm_start_multithreaded() {
 #if LLVM_ENABLE_THREADS != 0
   assert(!multithreaded_mode && "Already multithreaded!");
   multithreaded_mode = true;
-  global_lock = new sys::Mutex(true);
+  global_lock = new sys::RecursiveMutex;
 
   // We fence here to ensure that all initialization is complete BEFORE we
   // return from llvm_start_multithreaded().
   sys::MemoryFence();
   return true;
 #else
   return false;
 #endif
 }
 
 void llvm::llvm_stop_multithreaded() {
 #if LLVM_ENABLE_THREADS != 0
   assert(multithreaded_mode && "Not currently multithreaded!");
 
   // We fence here to insure that all threaded operations are complete BEFORE we
   // return from llvm_stop_multithreaded().
   sys::MemoryFence();
 
   multithreaded_mode = false;
   delete global_lock;
+  global_lock = nullptr;
 #endif
 }
 
 bool llvm::llvm_is_multithreaded() {
   return multithreaded_mode;
 }
 
 void llvm::llvm_acquire_global_lock() {

lib/Support/Timer.cpp

 #include "llvm/Support/Timer.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
+#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 // CreateInfoOutputFile - Return a file stream to print our output on.
 namespace llvm { extern raw_ostream *CreateInfoOutputFile(); }
 
 // getLibSupportInfoOutputFilename - This ugly hack is brought to you courtesy
 // of constructor/destructor ordering being unspecified by C++.  Basically the
 // problem is that a Statistic object gets destroyed, which ends up calling
 // 'GetLibSupportInfoOutputFile()' (below), which calls this function.
 // LibSupportInfoOutputFilename used to be a global variable, but sometimes it
 // would get destroyed before the Statistic, causing havoc to ensue.  We "fix"
 // this by creating the string the first time it is needed and never destroying
 // it.
 static ManagedStatic<std::string> LibSupportInfoOutputFilename;
 static std::string &getLibSupportInfoOutputFilename() {
   return *LibSupportInfoOutputFilename;
 }
 
-static ManagedStatic<sys::SmartMutex<true> > TimerLock;
+static ManagedStatic<sys::RecursiveDebugMutex> TimerLock;
 
 namespace {
   static cl::opt<bool>
   TrackSpace("track-memory", cl::desc("Enable -time-passes memory "
                                       "tracking (this may be slow)"),
              cl::Hidden);
 
   static cl::opt<std::string, true>

 public:
   ~Name2PairMap() {
     for (StringMap<std::pair<TimerGroup*, Name2TimerMap> >::iterator
          I = Map.begin(), E = Map.end(); I != E; ++I)
       delete I->second.first;
   }
   
   Timer &get(StringRef Name, StringRef GroupName) {
-    sys::SmartScopedLock<true> L(*TimerLock);
+    llvm::MutexGuard Lock(*TimerLock);
     
     std::pair<TimerGroup*, Name2TimerMap> &GroupEntry = Map[GroupName];
     
     if (!GroupEntry.first)
       GroupEntry.first = new TimerGroup(GroupName);
     
     Timer &T = GroupEntry.second[Name];
     if (!T.isInitialized())
       T.init(Name, *GroupEntry.first);
     return T;
   }
 };
 
 }
 
 static ManagedStatic<Name2TimerMap> NamedTimers;
 static ManagedStatic<Name2PairMap> NamedGroupedTimers;
 
 static Timer &getNamedRegionTimer(StringRef Name) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
   
   Timer &T = (*NamedTimers)[Name];
   if (!T.isInitialized())
     T.init(Name);
   return T;
 }
 
 NamedRegionTimer::NamedRegionTimer(StringRef Name,

 /// TimerGroupList - This is the global list of TimerGroups, maintained by the
 /// TimerGroup ctor/dtor and is protected by the TimerLock lock.
 static TimerGroup *TimerGroupList = nullptr;
 
 TimerGroup::TimerGroup(StringRef name)
   : Name(name.begin(), name.end()), FirstTimer(nullptr) {
     
   // Add the group to TimerGroupList.
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
   if (TimerGroupList)
     TimerGroupList->Prev = &Next;
   Next = TimerGroupList;
   Prev = &TimerGroupList;
   TimerGroupList = this;
 }
 
 TimerGroup::~TimerGroup() {
   // If the timer group is destroyed before the timers it owns, accumulate and
   // print the timing data.
   while (FirstTimer)
     removeTimer(*FirstTimer);
   
   // Remove the group from the TimerGroupList.
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
   *Prev = Next;
   if (Next)
     Next->Prev = Prev;
 }
 
 
 void TimerGroup::removeTimer(Timer &T) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
   
   // If the timer was started, move its data to TimersToPrint.
   if (T.Started)
     TimersToPrint.push_back(std::make_pair(T.Time, T.Name));
 
   T.TG = nullptr;
   
   // Unlink the timer from our list.
   *T.Prev = T.Next;
   if (T.Next)
     T.Next->Prev = T.Prev;
   
   // Print the report when all timers in this group are destroyed if some of
   // them were started.
   if (FirstTimer || TimersToPrint.empty())
     return;
   
   raw_ostream *OutStream = CreateInfoOutputFile();
   PrintQueuedTimers(*OutStream);
   delete OutStream;   // Close the file.
 }
 
 void TimerGroup::addTimer(Timer &T) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
   
   // Add the timer to our list.
   if (FirstTimer)
     FirstTimer->Prev = &T.Next;
   T.Next = FirstTimer;
   T.Prev = &FirstTimer;
   FirstTimer = &T;
 }
void TimerGroup::PrintQueuedTimers(raw_ostream &OS) {
   OS << "Total\n\n";
   OS.flush();
   
   TimersToPrint.clear();
 }
 
 /// print - Print any started timers in this group and zero them.
 void TimerGroup::print(raw_ostream &OS) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
 
   // See if any of our timers were started, if so add them to TimersToPrint and
   // reset them.
   for (Timer *T = FirstTimer; T; T = T->Next) {
     if (!T->Started) continue;
     TimersToPrint.push_back(std::make_pair(T->Time, T->Name));
     
     // Clear out the time.
     T->Started = 0;
     T->Time = TimeRecord();
   }
 
   // If any timers were started, print the group.
   if (!TimersToPrint.empty())
     PrintQueuedTimers(OS);
 }
 
 /// printAll - This static method prints all timers and clears them all out.
 void TimerGroup::printAll(raw_ostream &OS) {
-  sys::SmartScopedLock<true> L(*TimerLock);
+  llvm::MutexGuard Lock(*TimerLock);
 
   for (TimerGroup *TG = TimerGroupList; TG; TG = TG->Next)
     TG->print(OS);
 }

lib/Support/Unix/Mutex.inc

-//===- llvm/Support/Unix/Mutex.inc - Unix Mutex Implementation ---*- C++ -*-===//
-//
-//                     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 Unix specific (non-pthread) Mutex class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic UNIX code that
-//===          is guaranteed to work on *all* UNIX variants.
-//===----------------------------------------------------------------------===//
-
-namespace llvm
-{
-using namespace sys;
-
-MutexImpl::MutexImpl( bool recursive)
-{
-}
-
-MutexImpl::~MutexImpl()
-{
-}
-
-bool
-MutexImpl::release()
-{
-  return true;
-}
-
-bool
-MutexImpl::tryacquire( void )
-{
-  return true;
-}
-
-}

lib/Support/Unix/Process.inc

 extern "C" struct term *set_curterm(struct term *termp);
 extern "C" int del_curterm(struct term *termp);
 extern "C" int tigetnum(char *capname);
 #endif
 
 static bool terminalHasColors(int fd) {
 #ifdef HAVE_TERMINFO
   // First, acquire a global lock because these C routines are thread hostile.
-  static sys::Mutex M;
+  static sys::RecursiveMutex M;
   MutexGuard G(M);
 
   int errret = 0;
   if (setupterm((char *)nullptr, fd, &errret) != 0)
     // Regardless of why, if we can't get terminfo, we shouldn't try to print
     // colors.
     return false;
 

lib/Support/Unix/Signals.inc

 #if HAVE_MACH_MACH_H
 #include <mach/mach.h>
 #endif
 
 using namespace llvm;
 
 static RETSIGTYPE SignalHandler(int Sig);  // defined below.
 
-static SmartMutex<true> SignalsMutex;
+static llvm::sys::RecursiveDebugMutex SignalsMutex;
 
 /// InterruptFunction - The function to call if ctrl-c is pressed.
 static void (*InterruptFunction)() = nullptr;
 
 static std::vector<std::string> FilesToRemove;
 static std::vector<std::pair<void(*)(void*), void*> > CallBacksToRun;
 
 // IntSigs - Signals that represent requested termination. There's no bug

lib/Support/Windows/DynamicLibrary.inc

#endif
       OpenedHandles->insert((HMODULE)ModuleBase);
     }
     return TRUE;
   }
 }
 
 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *filename,
                                                    std::string *errMsg) {
-  SmartScopedLock<true> lock(*SymbolsMutex);
+  llvm::MutexGuard Lock(*SymbolsMutex);
 
   if (!filename) {
     // When no file is specified, enumerate all DLLs and EXEs in the process.
     if (OpenedHandles == 0)
       OpenedHandles = new DenseSet<HMODULE>();
 
     EnumerateLoadedModules(GetCurrentProcess(), ELM_Callback, 0);
     // Dummy library that represents "search all handles".

 #define EXPLICIT_SYMBOL2(SYMFROM, SYMTO) EXPLICIT_SYMBOL(SYMTO)
 
 #include "explicit_symbols.inc"
 
 #undef EXPLICIT_SYMBOL
 #undef EXPLICIT_SYMBOL2
 
 void* DynamicLibrary::SearchForAddressOfSymbol(const char* symbolName) {
-  SmartScopedLock<true> Lock(*SymbolsMutex);
+  llvm::MutexGuard Lock(*SymbolsMutex);
 
   // First check symbols added via AddSymbol().
   if (ExplicitSymbols.isConstructed()) {
     StringMap<void *>::iterator i = ExplicitSymbols->find(symbolName);
 
     if (i != ExplicitSymbols->end())
       return i->second;
   }

lib/Support/Windows/Mutex.inc

-//===- llvm/Support/Win32/Mutex.inc - Win32 Mutex Implementation -*- C++ -*-===//
-//
-//                     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 Win32 specific (non-pthread) Mutex class.
-//
-//===----------------------------------------------------------------------===//
-
-//===----------------------------------------------------------------------===//
-//=== WARNING: Implementation here must contain only generic Win32 code that
-//===          is guaranteed to work on *all* Win32 variants.
-//===----------------------------------------------------------------------===//
-
-#include "WindowsSupport.h"
-#include "llvm/Support/Mutex.h"
-
-namespace llvm {
-using namespace sys;
-
-MutexImpl::MutexImpl(bool /*recursive*/)
-{
-  data_ = new CRITICAL_SECTION;
-  InitializeCriticalSection((LPCRITICAL_SECTION)data_);
-}
-
-MutexImpl::~MutexImpl()
-{
-  DeleteCriticalSection((LPCRITICAL_SECTION)data_);
-  delete (LPCRITICAL_SECTION)data_;
-  data_ = 0;
-}
-
-bool
-MutexImpl::acquire()
-{
-  EnterCriticalSection((LPCRITICAL_SECTION)data_);
-  return true;
-}
-
-bool
-MutexImpl::release()
-{
-  LeaveCriticalSection((LPCRITICAL_SECTION)data_);
-  return true;
-}
-
-bool
-MutexImpl::tryacquire()
-{
-  return TryEnterCriticalSection((LPCRITICAL_SECTION)data_);
-}
-
-}

lib/Target/NVPTX/NVPTXUtilities.cpp

 
 using namespace llvm;
 
 typedef std::map<std::string, std::vector<unsigned> > key_val_pair_t;
 typedef std::map<const GlobalValue *, key_val_pair_t> global_val_annot_t;
 typedef std::map<const Module *, global_val_annot_t> per_module_annot_t;
 
 ManagedStatic<per_module_annot_t> annotationCache;
-static sys::Mutex Lock;
+static sys::RecursiveMutex Lock;
 
 void llvm::clearAnnotationCache(const llvm::Module *Mod) {
   MutexGuard Guard(Lock);
   annotationCache->erase(Mod);
 }
 
 static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval) {
   MutexGuard Guard(Lock);

unittests/IR/ValueMapTest.cpp

 
 TYPED_TEST(ValueMapTest, ConfiguredCollisionBehavior) {
   // TODO: Implement this when someone needs it.
 }
 
 template<typename KeyT>
 struct LockMutex : ValueMapConfig<KeyT> {
   struct ExtraData {
-    sys::Mutex *M;
+    sys::NonRecursiveMutex *M;
     bool *CalledRAUW;
     bool *CalledDeleted;
   };
   static void onRAUW(const ExtraData &Data, KeyT Old, KeyT New) {
     *Data.CalledRAUW = true;
     EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked.";
   }
   static void onDelete(const ExtraData &Data, KeyT Old) {
     *Data.CalledDeleted = true;
     EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked.";
   }
-  static sys::Mutex *getMutex(const ExtraData &Data) { return Data.M; }
+  static sys::NonRecursiveMutex *getMutex(const ExtraData &Data) { return Data.M; }
 };
 #if LLVM_ENABLE_THREADS
 TYPED_TEST(ValueMapTest, LocksMutex) {
-  sys::Mutex M(false);  // Not recursive.
+  sys::NonRecursiveMutex M;
   bool CalledRAUW = false, CalledDeleted = false;
   typename LockMutex<TypeParam*>::ExtraData Data =
     {&M, &CalledRAUW, &CalledDeleted};
   ValueMap<TypeParam*, int, LockMutex<TypeParam*> > VM(Data);
   VM[this->BitcastV.get()] = 7;
   this->BitcastV->replaceAllUsesWith(this->AddV.get());
   this->AddV.reset();
   EXPECT_TRUE(CalledRAUW);