Replace all standard mutexes with equivalent stl mutexes.

[zturner]

Summary

No functionality change, but I'm posting this for wider review before submitting.

This is a re-attempt at getting D4033 in. The suggestions from that thread have been taken into consideration, and all pre-requisite tasks have been implemented as separate changelists.

This patch should be fairly uncontroversial, as there are no semantic changes involved. The only replacements here are replacing always-acquired mutexes with different always-acquired mutexes. Still, since it's kind of a sweeping change, I'll leave it up for a day or two to give people a chance to comment.

[chandlerc]

Any particular reason for universally using recursive_mutex? I feel like a lot of these would be pretty easily switched to mutex.

lib/ExecutionEngine/OProfileJIT/OProfileWrapper.cpp

34–35

This is entertainingly unlikely to be correct (both before and after your change)

lib/Support/ErrorHandling.cpp

43

And another likely place we need a managed static.

lib/Support/Unix/Process.inc

268

This looks like a bug on Windows, might be worth moving to a managed static.

lib/Target/NVPTX/NVPTXUtilities.cpp

37

And here.

[zturner]

In D4223#6, @chandlerc wrote:

Any particular reason for universally using recursive_mutex? I feel like a lot of these would be pretty easily switched to mutex.

I actually had the same thought, but I felt that a secondary pass in a separate patch would be better for dealing with this. The idea with this patch is to not change any behavior anywhere, only the mutex implementation. So recursive mutexes are replaced with recursive mutexes, and non-recursive mutexes (which ironically there's only 1 of, and in a unittest no less) are replaced with non-recursive mutexes.

[zturner]

lib/Support/Unix/Process.inc

268

If you mean because of MSVC's lack of thread-safe function local statics, this is a unix-specific file.

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/raw_ostream.h"
 #include <map>
+#include <mutex>
 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.
+  std::recursive_mutex 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);
+  std::lock_guard<std::recursive_mutex> 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/ExecutionEngine/Interpreter/ExternalFunctions.cpp

 #elif HAVE_FFI_FFI_H
 #include <ffi/ffi.h>
 #define USE_LIBFFI
 #endif
 #endif
 
 using namespace llvm;
 
-static ManagedStatic<sys::Mutex> FunctionsLock;
+static ManagedStatic<std::recursive_mutex> 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);
+  std::lock_guard<std::recursive_mutex> 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 bool ffiInvoke(RawFunc Fn, Function *F,
   return false;
 }
 #endif // USE_LIBFFI
 
 GenericValue Interpreter::callExternalFunction(Function *F,
                                      const std::vector<GenericValue> &ArgVals) {
   TheInterpreter = this;
 
-  FunctionsLock->acquire();
+  FunctionsLock->lock();
 
   // Do a lookup to see if the function is in our cache... this should just be a
   // deferred annotation!
   std::map<const Function *, ExFunc>::iterator FI = ExportedFunctions->find(F);
   if (ExFunc Fn = (FI == ExportedFunctions->end()) ? lookupFunction(F)
                                                    : FI->second) {
-    FunctionsLock->release();
+    FunctionsLock->unlock();
     return Fn(F->getFunctionType(), ArgVals);
   }
 
 #ifdef USE_LIBFFI
   std::map<const Function *, RawFunc>::iterator RF = RawFunctions->find(F);
   RawFunc RawFn;
   if (RF == RawFunctions->end()) {
     RawFn = (RawFunc)(intptr_t)
       sys::DynamicLibrary::SearchForAddressOfSymbol(F->getName());
     if (!RawFn)
       RawFn = (RawFunc)(intptr_t)getPointerToGlobalIfAvailable(F);
     if (RawFn != 0)
       RawFunctions->insert(std::make_pair(F, RawFn));  // Cache for later
   } else {
     RawFn = RF->second;
   }
 
-  FunctionsLock->release();
+  FunctionsLock->unlock();
 
   GenericValue Result;
   if (RawFn != 0 && ffiInvoke(RawFn, F, ArgVals, getDataLayout(), Result))
     return Result;
 #endif // USE_LIBFFI
 
   if (F->getName() == "__main")
     errs() << "Tried to execute an unknown external function: "
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);
+  std::lock_guard<std::recursive_mutex> 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/OProfileJIT/OProfileWrapper.cpp

 // function occurs.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/OProfileWrapper.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/DynamicLibrary.h"
-#include "llvm/Support/Mutex.h"
-#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstring>
 #include <dirent.h>
 #include <fcntl.h>
+#include <mutex>
 #include <sstream>
 #include <stddef.h>
 #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;
+std::recursive_mutex OProfileInitializationMutex;
 
 } // anonymous namespace
 
 namespace llvm {
 
 OProfileWrapper::OProfileWrapper()
 : Agent(0),
   OpenAgentFunc(0),
   CloseAgentFunc(0),
   WriteNativeCodeFunc(0),
   WriteDebugLineInfoFunc(0),
   UnloadNativeCodeFunc(0),
   MajorVersionFunc(0),
   MinorVersionFunc(0),
   IsOProfileRunningFunc(0),
   Initialized(false) {
 }
 
 bool OProfileWrapper::initialize() {
   using namespace llvm;
   using namespace llvm::sys;
 
-  MutexGuard Guard(OProfileInitializationMutex);
+  std::lock_guard<std::recursive_mutex> Guard(OProfileInitializationMutex);
 
   if (Initialized)
     return OpenAgentFunc != 0;
 
   Initialized = true;
 
   // If the oprofile daemon is not running, don't load the opagent library
   if (!isOProfileRunning()) {

lib/ExecutionEngine/RuntimeDyld/GDBRegistrar.cpp

 //===-- GDBRegistrar.cpp - Registers objects with GDB ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "JITRegistrar.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/Mutex.h"
-#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/ManagedStatic.h"
+#include <mutex>
 
 using namespace llvm;
 
 // This must be kept in sync with gdb/gdb/jit.h .
 extern "C" {
 
   typedef enum {
     JIT_NOACTION = 0,
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;
+std::recursive_mutex 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;
   JITCodeEntry->next_entry = NextEntry;
   if (NextEntry) {
     NextEntry->prev_entry = JITCodeEntry;
   }
   __jit_debug_descriptor.first_entry = JITCodeEntry;
   __jit_debug_descriptor.relevant_entry = JITCodeEntry;
   __jit_debug_register_code();
 }
 
 GDBJITRegistrar::~GDBJITRegistrar() {
   // Free all registered object files.
-  llvm::MutexGuard locked(JITDebugLock);
+  std::lock_guard<std::recursive_mutex> locked(JITDebugLock);
   for (RegisteredObjectBufferMap::iterator I = ObjectBufferMap.begin(), E = ObjectBufferMap.end();
        I != E; ++I) {
     // Call the private method that doesn't update the map so our iterator
     // doesn't break.
     deregisterObjectInternal(I);
   }
   ObjectBufferMap.clear();
 }
 
 void GDBJITRegistrar::registerObject(const ObjectBuffer &Object) {
 
   const char *Buffer = Object.getBufferStart();
   size_t      Size = Object.getBufferSize();
 
   assert(Buffer && "Attempt to register a null object with a debugger.");
-  llvm::MutexGuard locked(JITDebugLock);
+  std::lock_guard<std::recursive_mutex> locked(JITDebugLock);
   assert(ObjectBufferMap.find(Buffer) == ObjectBufferMap.end() &&
          "Second attempt to perform debug registration.");
   jit_code_entry* JITCodeEntry = new jit_code_entry();
 
   if (!JITCodeEntry) {
     llvm::report_fatal_error(
       "Allocation failed when registering a JIT entry!\n");
   } else {
     JITCodeEntry->symfile_addr = Buffer;
     JITCodeEntry->symfile_size = Size;
 
     ObjectBufferMap[Buffer] = std::make_pair(Size, JITCodeEntry);
     NotifyDebugger(JITCodeEntry);
   }
 }
 
 bool GDBJITRegistrar::deregisterObject(const ObjectBuffer& Object) {
   const char *Buffer = Object.getBufferStart();
-  llvm::MutexGuard locked(JITDebugLock);
+  std::lock_guard<std::recursive_mutex> locked(JITDebugLock);
   RegisteredObjectBufferMap::iterator I = ObjectBufferMap.find(Buffer);
 
   if (I != ObjectBufferMap.end()) {
     deregisterObjectInternal(I);
     ObjectBufferMap.erase(I);
     return true;
   }
   return false;

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "JITRegistrar.h"
 #include "ObjectImageCommon.h"
 #include "RuntimeDyldELF.h"
 #include "RuntimeDyldImpl.h"
 #include "RuntimeDyldMachO.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/MathExtras.h"
-#include "llvm/Support/MutexGuard.h"
+#include <mutex>
 
 using namespace llvm;
 using namespace llvm::object;
 
 #define DEBUG_TYPE "dyld"
 
 // Empty out-of-line virtual destructor as the key function.
 RuntimeDyldImpl::~RuntimeDyldImpl() {}
 
 // Pin the JITRegistrar's and ObjectImage*'s vtables to this file.
 void JITRegistrar::anchor() {}
 void ObjectImage::anchor() {}
 void ObjectImageCommon::anchor() {}
 
 namespace llvm {
 
 void RuntimeDyldImpl::registerEHFrames() {}
 
 void RuntimeDyldImpl::deregisterEHFrames() {}
 
 // Resolve the relocations for all symbols we currently know about.
 void RuntimeDyldImpl::resolveRelocations() {
-  MutexGuard locked(lock);
+  std::lock_guard<std::recursive_mutex> locked(lock);
 
   // First, resolve relocations associated with external symbols.
   resolveExternalSymbols();
 
   // Just iterate over the sections we have and resolve all the relocations
   // in them. Gross overkill, but it gets the job done.
   for (int i = 0, e = Sections.size(); i != e; ++i) {
     // The Section here (Sections[i]) refers to the section in which the
     // symbol for the relocation is located.  The SectionID in the relocation
     // entry provides the section to which the relocation will be applied.
     uint64_t Addr = Sections[i].LoadAddress;
     DEBUG(dbgs() << "Resolving relocations Section #" << i << "\t"
                  << format("%p", (uint8_t *)Addr) << "\n");
     resolveRelocationList(Relocations[i], Addr);
     Relocations.erase(i);
   }
 }
 
 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
                                         uint64_t TargetAddress) {
-  MutexGuard locked(lock);
+  std::lock_guard<std::recursive_mutex> locked(lock);
   for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
     if (Sections[i].Address == LocalAddress) {
       reassignSectionAddress(i, TargetAddress);
       return;
     }
   }
   llvm_unreachable("Attempting to remap address of unknown section!");
 }
if (SecI == Obj->section_end()) {
   if (std::error_code EC = SecI->getAddress(SectionAddress))
     return EC;
 
   Result = Address - SectionAddress;
   return object_error::success;
 }
 
 ObjectImage *RuntimeDyldImpl::loadObject(ObjectImage *InputObject) {
-  MutexGuard locked(lock);
+  std::lock_guard<std::recursive_mutex> locked(lock);
 
   std::unique_ptr<ObjectImage> Obj(InputObject);
   if (!Obj)
     return nullptr;
 
   // Save information about our target
   Arch = (Triple::ArchType)Obj->getArch();
   IsTargetLittleEndian = Obj->getObjectFile()->isLittleEndian();

lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h

 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/ObjectImage.h"
 #include "llvm/ExecutionEngine/RuntimeDyld.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Host.h"
-#include "llvm/Support/Mutex.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include "llvm/Support/raw_ostream.h"
 #include <map>
+#include <mutex>
 #include <system_error>
 
 using namespace llvm;
 using namespace llvm::object;
 
 namespace llvm {
 
 class ObjectBuffer;
#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;
+  std::recursive_mutex lock;
 
   virtual unsigned getMaxStubSize() = 0;
   virtual unsigned getStubAlignment() = 0;
 
   bool HasError;
   std::string ErrorStr;
 
   // Set the error state and record an error string.

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/ThreadLocal.h"
 #include <cstdio>
+#include <mutex>
 #include <setjmp.h>
 using namespace llvm;
 
 namespace {
 
 struct CrashRecoveryContextImpl;
 
 static ManagedStatic<
void HandleCrash() {
 
     // Jump back to the RunSafely we were called under.
     longjmp(JumpBuffer, 1);
   }
 };
 
 }
 
-static ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
+static ManagedStatic<std::recursive_mutex> 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);
+  std::lock_guard<std::recursive_mutex> 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);
+  std::lock_guard<std::recursive_mutex> 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);
+  std::lock_guard<std::recursive_mutex> 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);
+  std::lock_guard<std::recursive_mutex> L(*gCrashRecoveryContextMutex);
 
   if (!gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = false;
 
   // Restore the previous signal handlers.
   for (unsigned i = 0; i != NumSignals; ++i)

lib/Support/ErrorHandling.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm-c/Core.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Signals.h"
-#include "llvm/Support/Mutex.h"
-#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/WindowsError.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
+#include <mutex>
 
 #if defined(HAVE_UNISTD_H)
 # include <unistd.h>
 #endif
 #if defined(_MSC_VER)
 # include <io.h>
 # include <fcntl.h>
 #endif
 
 using namespace llvm;
 
 static fatal_error_handler_t ErrorHandler = nullptr;
 static void *ErrorHandlerUserData = nullptr;
 
-static sys::Mutex ErrorHandlerMutex;
+static std::recursive_mutex ErrorHandlerMutex;
 
 void llvm::install_fatal_error_handler(fatal_error_handler_t handler,
                                        void *user_data) {
-  llvm::MutexGuard Lock(ErrorHandlerMutex);
+  std::lock_guard<std::recursive_mutex> Lock(ErrorHandlerMutex);
   assert(!ErrorHandler && "Error handler already registered!\n");
   ErrorHandler = handler;
   ErrorHandlerUserData = user_data;
 }
 
 void llvm::remove_fatal_error_handler() {
-  llvm::MutexGuard Lock(ErrorHandlerMutex);
+  std::lock_guard<std::recursive_mutex> Lock(ErrorHandlerMutex);
   ErrorHandler = nullptr;
   ErrorHandlerUserData = nullptr;
 }
 
 void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag) {
   report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
 void llvm::report_fatal_error(const std::string &Reason, bool GenCrashDiag) {
   report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
 void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag) {
   report_fatal_error(Twine(Reason), GenCrashDiag);
 }
 
 void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {
   llvm::fatal_error_handler_t handler = nullptr;
   void* handlerData = nullptr;
   {
     // Only acquire the mutex while reading the handler, so as not to invoke a
     // user-supplied callback under a lock.
-    llvm::MutexGuard Lock(ErrorHandlerMutex);
+    std::lock_guard<std::recursive_mutex> Lock(ErrorHandlerMutex);
     handler = ErrorHandler;
     handlerData = ErrorHandlerUserData;
   }
 
   if (handler) {
     handler(handlerData, Reason.str(), GenCrashDiag);
   } else {
     // Blast the result out to stderr.  We don't try hard to make sure this

lib/Support/Unix/Process.inc

 //===- Unix/Process.cpp - Unix Process 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 provides the generic Unix implementation of the Process class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Unix.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Mutex.h"
-#include "llvm/Support/MutexGuard.h"
 #include "llvm/Support/TimeValue.h"
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
 #ifdef HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
 #endif
 // DragonFlyBSD, OpenBSD, and Bitrig have deprecated <malloc.h> for
 // <stdlib.h> instead. Unix.h includes this for us already.
 #if defined(HAVE_MALLOC_H) && !defined(__DragonFly__) && \
     !defined(__OpenBSD__) && !defined(__Bitrig__)
 #include <malloc.h>
 #endif
 #ifdef HAVE_MALLOC_MALLOC_H
 #include <malloc/malloc.h>
 #endif
 #ifdef HAVE_SYS_IOCTL_H
 #  include <sys/ioctl.h>
 #endif
 #ifdef HAVE_TERMIOS_H
 #  include <termios.h>
 #endif
+#include <mutex>
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on *all* UNIX variants.
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 using namespace sys;

 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;
-  MutexGuard G(M);
+  static std::recursive_mutex M;
+  std::lock_guard<std::recursive_mutex> 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;
 
   // Test whether the terminal as set up supports color output. How to do this

lib/Target/NVPTX/NVPTXUtilities.cpp

 // This file contains miscellaneous utility functions
 //===----------------------------------------------------------------------===//
 
 #include "NVPTXUtilities.h"
 #include "NVPTX.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
+#include "llvm/Support/ManagedStatic.h"
+
 #include <algorithm>
 #include <cstring>
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
-#include "llvm/Support/ManagedStatic.h"
-#include "llvm/IR/InstIterator.h"
-#include "llvm/Support/MutexGuard.h"
 
 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 std::recursive_mutex Lock;
 
 void llvm::clearAnnotationCache(const llvm::Module *Mod) {
-  MutexGuard Guard(Lock);
+  std::lock_guard<std::recursive_mutex> Guard(Lock);
   annotationCache->erase(Mod);
 }
 
 static void cacheAnnotationFromMD(const MDNode *md, key_val_pair_t &retval) {
-  MutexGuard Guard(Lock);
+  std::lock_guard<std::recursive_mutex> Guard(Lock);
   assert(md && "Invalid mdnode for annotation");
   assert((md->getNumOperands() % 2) == 1 && "Invalid number of operands");
   // start index = 1, to skip the global variable key
   // increment = 2, to skip the value for each property-value pairs
   for (unsigned i = 1, e = md->getNumOperands(); i != e; i += 2) {
     // property
     const MDString *prop = dyn_cast<MDString>(md->getOperand(i));
     assert(prop && "Annotation property not a string");
else {
       std::vector<unsigned> tmp;
       tmp.push_back(Val->getZExtValue());
       retval[keyname] = tmp;
     }
   }
 }
 
 static void cacheAnnotationFromMD(const Module *m, const GlobalValue *gv) {
-  MutexGuard Guard(Lock);
+  std::lock_guard<std::recursive_mutex> Guard(Lock);
   NamedMDNode *NMD = m->getNamedMetadata(llvm::NamedMDForAnnotations);
   if (!NMD)
     return;
   key_val_pair_t tmp;
   for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
     const MDNode *elem = NMD->getOperand(i);
 
     Value *entity = elem->getOperand(0);
else {
     global_val_annot_t tmp1;
     tmp1[gv] = tmp;
     (*annotationCache)[m] = tmp1;
   }
 }
 
 bool llvm::findOneNVVMAnnotation(const GlobalValue *gv, std::string prop,
                                  unsigned &retval) {
-  MutexGuard Guard(Lock);
+  std::lock_guard<std::recursive_mutex> Guard(Lock);
   const Module *m = gv->getParent();
   if ((*annotationCache).find(m) == (*annotationCache).end())
     cacheAnnotationFromMD(m, gv);
   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
     cacheAnnotationFromMD(m, gv);
   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
     return false;
   retval = (*annotationCache)[m][gv][prop][0];
   return true;
 }
 
 bool llvm::findAllNVVMAnnotation(const GlobalValue *gv, std::string prop,
                                  std::vector<unsigned> &retval) {
-  MutexGuard Guard(Lock);
+  std::lock_guard<std::recursive_mutex> Guard(Lock);
   const Module *m = gv->getParent();
   if ((*annotationCache).find(m) == (*annotationCache).end())
     cacheAnnotationFromMD(m, gv);
   else if ((*annotationCache)[m].find(gv) == (*annotationCache)[m].end())
     cacheAnnotationFromMD(m, gv);
   if ((*annotationCache)[m][gv].find(prop) == (*annotationCache)[m][gv].end())
     return false;
   retval = (*annotationCache)[m][gv][prop];