first pass for removing Mutex for std::{,recursive_}mutex

[compnerd]

Summary

This is a pretty straightforward first pass over removing a number of uses of Mutex in favor of std::mutex or std::recursive_mutex. The problem is that there are interfaces which take Mutex::Locker & to lock internal locks. This patch cleans up most of the easy cases. The only non-trivial change is in CommandObjectTarget.cpp where a Mutex::Locker was split into two.

Although the patch is trivial, the question that I have is whether we should go ahead with this change and if doing it in multiple passes is reasonable.

[zturner]

Personally I'm strongly in favor of standardizing on builtin language
constructs.

We already use std mutex in some places, and llvm does too, so i see no
issue with compiler support. I can't review the patch at the moment, but
please do make sure it's clang formatted

[compnerd]

I don't think I can write code without clang-format anymore (so, yes, it is clang-formatted).

[zturner]

Figured as much, just making sure. What platforms did you run the test
suite on to confirm no breakages?

[krytarowski]

Looks good, however could we merge firstly Plugins/Process/NetBSD http://reviews.llvm.org/D20274 ? Otherwise I will need to keep syncing my patch forever for generic changes.

Thanks!

[zturner]

Looking at the 2 patches, they seem to be completely independent of each
other. Would this patch going in break you somehow?

[krytarowski]

There is Mutex:: used in my code. And it's going to be removed soon.

[labath]

In D20278#430658, @krytarowski wrote:

Looks good, however could we merge firstly Plugins/Process/NetBSD http://reviews.llvm.org/D20274 ? Otherwise I will need to keep syncing my patch forever for generic changes.

Thanks!

I don't think we should connect these two patches in any way. What you are asking for here amounts to "let me merge my patch first, so that you can deal with the merge conflicts".

Also, I think merge conflicts for this patch, if we let it go stale, will be more painful that for the netbsd process plugin, as that localized to a certain set of files.

I gave the patch a quick run, and I've noticed no regressions on Linux (after fixing up a couple of compile errors in Linux-specific code), so +100 on the patch from me.

As for the compile errors, I'm going to prepare NativeProcessLinux ahead of time for this patch, to avoid breakage.

[zturner]

To be clear, I don't think this patch actually deletes LLDB's mutex. It just deletes uses of LLDB's mutex. So the NetBSD code should continue to work after merging this patch in. Sure it introduces another use of lldb's Mutex, but we can always remove that later. 5 is easier to remove than 500 :)

[clayborg]

Looks good. We should work toward remove Mutex.cpp and Mutex.h completely and also switch over to using std::condition_variable.

[compnerd]

Zach is correct, this doesn't *remove* the Mutex and Condition types, merely starts reducing the easier uses of it.

My thinking is to do this piecemeal, slowly reducing the local usage until the real uses remain in the cases where we need to actually change the structure of the code. In particular, it seems that there are places where we have Mutex::Locker passed in by reference to get a lock.

I agree that we want to start moving towards using std::condition_variable, however, that was a bit more involved as that will require adding a conversion operator for TimeValue. Switching to std::condition_variable requires the switch to std::mutex as std::conditional_variable::wait requires a std::unique_lock<std::mutex>.

I wanted to get as much of the mechanical change out of the way as possible so that when the rest of the uses are removed, it is easier to actually review the change to ensure that no subtle bugs are being introduced since it won't be as mechanical.

[zturner]

Which platforms did you run the test suite on?

[compnerd]

I ran it on Darwin while I was working on this. Ill run it on Linux once before I commit the first pass.

[zturner]

If you haven't or can't run it on Windows, then give me a chance to test it
on Windows before you commit. I can do it tomorrow unless you are set up
to do it instead.

[compnerd]

If you can run the test that would be wonderful. Im going to upload a slight update to this tonight that catches a few more of the trivial cases. I think minimizing the second pass is ideal since that is going to be much more involved (changing APIs and such).

[zturner]

This looks good, no probelms on Windows that I can see. I ran clang-format on your patch just to confirm, and it fixed up some trailing whitespace at the end of lines. I'm not sure if the problem was in the generation of the patch on your end, the application of the patch on my end, or if the whitespace is really there on your end too, but just make sure it's all clean. Quick example just so you can look at this specific line and see if it's on your end:

 // Other libraries and framework includes
 // Project includes
diff --git a/include/lldb/Core/History.h b/include/lldb/Core/History.h
index 001ad3e..164d1bf 100644
--- a/include/lldb/Core/History.h
+++ b/include/lldb/Core/History.h
@@ -46,7 +46,7 @@ public:
     // onto the end of the history stack.

     virtual HistoryEvent
-    CreateHistoryEvent () = 0;
+    CreateHistoryEvent () = 0;

This line had whitespace at the end when I applied the patch.

[compnerd]

Ah, I just ran git-clang-format, and that found a few additional things. Incorporated that; Ill commit this tonight and hopefully have the second pass done soon.

[compnerd]

SVN r269877

include/lldb/Breakpoint/BreakpointLocationList.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/Address.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Utility/Iterable.h"
 
 namespace lldb_private {

     Breakpoint &m_owner;
     collection m_locations;         // Vector of locations, sorted by ID 
     addr_map m_address_to_location;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
     lldb::break_id_t m_next_id;
     BreakpointLocationCollection *m_new_location_recorder;
 

include/lldb/Breakpoint/BreakpointSite.h

 
 // C++ Includes
 #include <list>
+#include <mutex>
 
 // Other libraries and framework includes
 
 // Project includes
 #include "lldb/lldb-forward.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Core/UserID.h"
 #include "lldb/Breakpoint/StoppointLocation.h"
 #include "lldb/Breakpoint/BreakpointLocationCollection.h"

     // Consider adding an optimization where if there is only one
     // owner, we don't store a list.  The usual case will be only one owner...
     BreakpointLocationCollection m_owners; ///< This has the BreakpointLocations that share this breakpoint site.
-    Mutex m_owners_mutex;      ///< This mutex protects the owners collection. 
+    std::recursive_mutex m_owners_mutex;   ///< This mutex protects the owners collection.
 
     static lldb::break_id_t
     GetNextID();

include/lldb/Breakpoint/BreakpointSiteList.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <functional>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointSite.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     size_t
     GetSize() const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         return m_bp_site_list.size();
     }
 
     bool
     IsEmpty() const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         return m_bp_site_list.empty();
     }
+
 protected:
     typedef std::map<lldb::addr_t, lldb::BreakpointSiteSP> collection;
 

     collection::const_iterator
     GetIDConstIterator(lldb::break_id_t breakID) const;
 
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
     collection m_bp_site_list;  // The breakpoint site list.
 };
 

include/lldb/Core/Broadcaster.h

 #include <functional>
 #include <list>
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 

 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ConstString.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     typedef std::set<lldb::ListenerSP> listener_collection;
     collection m_event_map;
     listener_collection m_listeners;
-    
-    Mutex m_manager_mutex;
+    mutable std::recursive_mutex m_manager_mutex;
 
     // A couple of comparator classes for find_if:
     

         Broadcaster &m_broadcaster;                     ///< The broadcsater that this implements
         event_names_map m_event_names;                  ///< Optionally define event names for readability and logging for each event bit
         collection m_listeners;                         ///< A list of Listener / event_mask pairs that are listening to this broadcaster.
-        Mutex m_listeners_mutex;                        ///< A mutex that protects \a m_listeners.
+        std::recursive_mutex m_listeners_mutex;         ///< A mutex that protects \a m_listeners.
         std::vector<lldb::ListenerSP> m_hijacking_listeners;  // A simple mechanism to intercept events from a broadcaster
         std::vector<uint32_t> m_hijacking_masks;        // At some point we may want to have a stack or Listener
                                                         // collections, but for now this is just for private hijacking.

include/lldb/Core/Communication.h

 // C Includes
 // C++ Includes
 #include <atomic>
+#include <mutex>
 #include <string>
 
 // Other libraries and framework includes

 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {

     HostThread m_read_thread;           ///< The read thread handle in case we need to cancel the thread.
     std::atomic<bool> m_read_thread_enabled;
     std::atomic<bool> m_read_thread_did_exit;
-    std::string m_bytes;    ///< A buffer to cache bytes read in the ReadThread function.
-    Mutex m_bytes_mutex;    ///< A mutex to protect multi-threaded access to the cached bytes.
-    Mutex m_write_mutex;    ///< Don't let multiple threads write at the same time...
-    Mutex m_synchronize_mutex;
+    std::string m_bytes;                ///< A buffer to cache bytes read in the ReadThread function.
+    std::recursive_mutex m_bytes_mutex; ///< A mutex to protect multi-threaded access to the cached bytes.
+    std::mutex m_write_mutex;           ///< Don't let multiple threads write at the same time...
+    std::mutex m_synchronize_mutex;
     ReadThreadBytesReceived m_callback;
     void *m_callback_baton;
     bool m_close_on_eof;

include/lldb/Core/History.h

 #include <stdint.h>
 
 // C++ Includes
+#include <mutex>
 #include <stack>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

 public:
     typedef const void * HistoryEvent;
 
-    HistorySource () :
-        m_mutex (Mutex::eMutexTypeRecursive),
-        m_events ()
-    {
-    }
+    HistorySource() : m_mutex(), m_events() {}
 
     virtual 
     ~HistorySource()

 
     virtual HistoryEvent
     CreateHistoryEvent () = 0; 
-    
     virtual void
     DeleteHistoryEvent (HistoryEvent event) = 0;
-    
     virtual void
     DumpHistoryEvent (Stream &strm, HistoryEvent event) = 0;
 
     virtual size_t
     GetHistoryEventCount() = 0;
-    
     virtual HistoryEvent
     GetHistoryEventAtIndex (uint32_t idx) = 0;
-    
     virtual HistoryEvent
     GetCurrentHistoryEvent () = 0;
 

     virtual int
     CompareHistoryEvents (const HistoryEvent lhs, 
                           const HistoryEvent rhs) = 0;
-    
     virtual bool
     IsCurrentHistoryEvent (const HistoryEvent event) = 0;
 
 private:
     typedef std::stack<HistoryEvent> collection;
 
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
     collection m_events;
-    
     DISALLOW_COPY_AND_ASSIGN (HistorySource);
 };
     

include/lldb/Core/IOHandler.h

 
 // C++ Includes
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 

     class IOHandlerStack
     {
     public:
-        IOHandlerStack () :
-            m_stack(),
-            m_mutex(Mutex::eMutexTypeRecursive),
-            m_top (nullptr)
-        {
-        }
-        
+        IOHandlerStack() : m_stack(), m_mutex(), m_top(nullptr) {}
+
         ~IOHandlerStack() = default;
-        
         size_t
-        GetSize () const
+        GetSize() const
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             return m_stack.size();
         }
-        
         void
-        Push (const lldb::IOHandlerSP& sp)
+        Push(const lldb::IOHandlerSP &sp)
         {
             if (sp)
             {
-                Mutex::Locker locker (m_mutex);
-                sp->SetPopped (false);
-                m_stack.push_back (sp);
+                std::lock_guard<std::recursive_mutex> guard(m_mutex);
+                sp->SetPopped(false);
+                m_stack.push_back(sp);
                 // Set m_top the non-locking IsTop() call
                 m_top = sp.get();
             }
         }
-        
         bool
-        IsEmpty () const
+        IsEmpty() const
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             return m_stack.empty();
         }
-        
         lldb::IOHandlerSP
-        Top ()
+        Top()
         {
             lldb::IOHandlerSP sp;
             {
-                Mutex::Locker locker (m_mutex);
+                std::lock_guard<std::recursive_mutex> guard(m_mutex);
                 if (!m_stack.empty())
                     sp = m_stack.back();
             }
             return sp;
         }
-        
         void
-        Pop ()
+        Pop()
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             if (!m_stack.empty())
             {
-                lldb::IOHandlerSP sp (m_stack.back());
+                lldb::IOHandlerSP sp(m_stack.back());
                 m_stack.pop_back();
-                sp->SetPopped (true);
+                sp->SetPopped(true);
             }
             // Set m_top the non-locking IsTop() call
 
             m_top = (m_stack.empty() ? nullptr : m_stack.back().get());
         }
 
-        Mutex &
+        std::recursive_mutex &
         GetMutex()
         {
             return m_mutex;
         }
-      
         bool
         IsTop (const lldb::IOHandlerSP &io_handler_sp) const
         {

         }
 
         bool
-        CheckTopIOHandlerTypes (IOHandler::Type top_type, IOHandler::Type second_top_type)
+        CheckTopIOHandlerTypes(IOHandler::Type top_type, IOHandler::Type second_top_type)
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             const size_t num_io_handlers = m_stack.size();
-            return (num_io_handlers >= 2 &&
-                    m_stack[num_io_handlers-1]->GetType() == top_type &&
-                    m_stack[num_io_handlers-2]->GetType() == second_top_type);
+            return (num_io_handlers >= 2 && m_stack[num_io_handlers - 1]->GetType() == top_type &&
+                    m_stack[num_io_handlers - 2]->GetType() == second_top_type);
         }
 
         ConstString

     protected:
         typedef std::vector<lldb::IOHandlerSP> collection;
         collection m_stack;
-        mutable Mutex m_mutex;
+        mutable std::recursive_mutex m_mutex;
         IOHandler *m_top;
-        
     private:
         DISALLOW_COPY_AND_ASSIGN (IOHandlerStack);
     };

include/lldb/Core/Listener.h

 // C++ Includes
 #include <list>
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 

 
     std::string m_name;
     broadcaster_collection m_broadcasters;
-    Mutex m_broadcasters_mutex; // Protects m_broadcasters
+    std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
     event_collection m_events;
     Mutex m_events_mutex; // Protects m_broadcasters and m_events
     Condition m_events_condition;

include/lldb/Core/Module.h

 // C Includes
 // C++ Includes
 #include <atomic>
+#include <mutex>
 #include <string>
 #include <vector>
 

 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/TypeSystem.h"

     static Module *
     GetAllocatedModuleAtIndex (size_t idx);
 
-    static Mutex *
+    static std::recursive_mutex &
     GetAllocationModuleCollectionMutex();
 
     //------------------------------------------------------------------

     // SymbolVendor, SymbolFile and ObjectFile member objects should
     // lock the module mutex to avoid deadlocks.
     //------------------------------------------------------------------
-    Mutex &
-    GetMutex () const
+    std::recursive_mutex &
+    GetMutex() const
     {
         return m_mutex;
     }

     //------------------------------------------------------------------
     // Member Variables
     //------------------------------------------------------------------
-    mutable Mutex               m_mutex;        ///< A mutex to keep this object happy in multi-threaded environments.
+    mutable std::recursive_mutex m_mutex;       ///< A mutex to keep this object happy in multi-threaded environments.
     TimeValue                   m_mod_time;     ///< The modification time for this module when it was created.
     ArchSpec                    m_arch;         ///< The architecture for this module.
     UUID                        m_uuid;         ///< Each module is assumed to have a unique identifier to help match it up to debug symbols.

include/lldb/Core/ModuleSpec.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes

 #include "lldb/Core/Stream.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/PathMappingList.h"
 
 namespace lldb_private {

 class ModuleSpecList
 {
 public:
-    ModuleSpecList () :
-        m_specs(),
-        m_mutex(Mutex::eMutexTypeRecursive) 
-    {
-    }
+    ModuleSpecList() : m_specs(), m_mutex() {}
 
-    ModuleSpecList (const ModuleSpecList &rhs) :
-        m_specs(),
-        m_mutex(Mutex::eMutexTypeRecursive)
+    ModuleSpecList(const ModuleSpecList &rhs) : m_specs(), m_mutex()
     {
-        Mutex::Locker lhs_locker(m_mutex);
-        Mutex::Locker rhs_locker(rhs.m_mutex);
+        std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
+        std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
         m_specs = rhs.m_specs;
     }
 
     ~ModuleSpecList() = default;
 
     ModuleSpecList &
-    operator = (const ModuleSpecList &rhs)
+    operator=(const ModuleSpecList &rhs)
     {
         if (this != &rhs)
         {
-            Mutex::Locker lhs_locker(m_mutex);
-            Mutex::Locker rhs_locker(rhs.m_mutex);
+            std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
+            std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
             m_specs = rhs.m_specs;
         }
         return *this;

     size_t
     GetSize() const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         return m_specs.size();
     }
 
     void
-    Clear ()
+    Clear()
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         m_specs.clear();
     }
 
     void
-    Append (const ModuleSpec &spec)
+    Append(const ModuleSpec &spec)
     {
-        Mutex::Locker locker(m_mutex);
-        m_specs.push_back (spec);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
+        m_specs.push_back(spec);
     }
 
     void
-    Append (const ModuleSpecList &rhs)
+    Append(const ModuleSpecList &rhs)
     {
-        Mutex::Locker lhs_locker(m_mutex);
-        Mutex::Locker rhs_locker(rhs.m_mutex);
+        std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
+        std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
         m_specs.insert(m_specs.end(), rhs.m_specs.begin(), rhs.m_specs.end());
     }
 

     }
 
     bool
-    GetModuleSpecAtIndex (size_t i, ModuleSpec &module_spec) const
+    GetModuleSpecAtIndex(size_t i, ModuleSpec &module_spec) const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (i < m_specs.size())
         {
             module_spec = m_specs[i];

     }
 
     bool
-    FindMatchingModuleSpec (const ModuleSpec &module_spec, ModuleSpec &match_module_spec) const
+    FindMatchingModuleSpec(const ModuleSpec &module_spec, ModuleSpec &match_module_spec) const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         bool exact_arch_match = true;
-        for (auto spec: m_specs)
+        for (auto spec : m_specs)
         {
             if (spec.Matches(module_spec, exact_arch_match))
             {

                 return true;
             }
         }
-        
         // If there was an architecture, retry with a compatible arch
         if (module_spec.GetArchitecturePtr())
         {
             exact_arch_match = false;
-            for (auto spec: m_specs)
+            for (auto spec : m_specs)
             {
                 if (spec.Matches(module_spec, exact_arch_match))
                 {

         match_module_spec.Clear();
         return false;
     }
-    
     size_t
-    FindMatchingModuleSpecs (const ModuleSpec &module_spec, ModuleSpecList &matching_list) const
+    FindMatchingModuleSpecs(const ModuleSpec &module_spec, ModuleSpecList &matching_list) const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         bool exact_arch_match = true;
         const size_t initial_match_count = matching_list.GetSize();
-        for (auto spec: m_specs)
+        for (auto spec : m_specs)
         {
             if (spec.Matches(module_spec, exact_arch_match))
-                matching_list.Append (spec);
+                matching_list.Append(spec);
         }
-        
         // If there was an architecture, retry with a compatible arch if no matches were found
         if (module_spec.GetArchitecturePtr() && (initial_match_count == matching_list.GetSize()))
         {
             exact_arch_match = false;
-            for (auto spec: m_specs)
+            for (auto spec : m_specs)
             {
                 if (spec.Matches(module_spec, exact_arch_match))
-                    matching_list.Append (spec);
+                    matching_list.Append(spec);
             }
         }
         return matching_list.GetSize() - initial_match_count;
     }
 
     void
-    Dump (Stream &strm)
+    Dump(Stream &strm)
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         uint32_t idx = 0;
-        for (auto spec: m_specs)
+        for (auto spec : m_specs)
         {
             strm.Printf("[%u] ", idx);
-            spec.Dump (strm);
+            spec.Dump(strm);
             strm.EOL();
             ++idx;
         }

 protected:
     typedef std::vector<ModuleSpec> collection; ///< The module collection type.
     collection m_specs; ///< The collection of modules.
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 };
 
 } // namespace lldb_private

include/lldb/Core/StreamCallback.h

 #ifndef liblldb_StreamCallback_h_
 #define liblldb_StreamCallback_h_
 
+#include <mutex>
 #include <string>
 
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamString.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     lldb::LogOutputCallback m_callback;
     void *m_baton;
     collection m_accumulated_data;
-    Mutex m_collection_mutex;
-    
+    std::mutex m_collection_mutex;
     StreamString &FindStreamForThread(lldb::tid_t cur_tid);
 };
 

include/lldb/Core/StreamTee.h

 
 #include <limits.h>
 
+#include <mutex>
+
 #include "lldb/Core/Stream.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 
 class StreamTee : public Stream
 {
 public:
-    StreamTee () :
-        Stream (),
-        m_streams_mutex (Mutex::eMutexTypeRecursive),
-        m_streams ()
-    {
-    }
+    StreamTee() : Stream(), m_streams_mutex(), m_streams() {}
 
-    StreamTee (lldb::StreamSP &stream_sp):
-        Stream (),
-        m_streams_mutex (Mutex::eMutexTypeRecursive),
-        m_streams ()
+    StreamTee(lldb::StreamSP &stream_sp) : Stream(), m_streams_mutex(), m_streams()
     {
         // No need to lock mutex during construction
         if (stream_sp)
-            m_streams.push_back (stream_sp);
+            m_streams.push_back(stream_sp);
     }
-    
 
-    StreamTee (lldb::StreamSP &stream_sp, lldb::StreamSP &stream_2_sp) :
-        Stream (),
-        m_streams_mutex (Mutex::eMutexTypeRecursive),
-        m_streams ()
+    StreamTee(lldb::StreamSP &stream_sp, lldb::StreamSP &stream_2_sp) : Stream(), m_streams_mutex(), m_streams()
     {
         // No need to lock mutex during construction
         if (stream_sp)
-            m_streams.push_back (stream_sp);
+            m_streams.push_back(stream_sp);
         if (stream_2_sp)
-            m_streams.push_back (stream_2_sp);
+            m_streams.push_back(stream_2_sp);
     }
-    
-    StreamTee (const StreamTee &rhs) :
-        Stream (rhs),
-        m_streams_mutex (Mutex::eMutexTypeRecursive),
-        m_streams() // Don't copy until we lock down "rhs"
+    StreamTee(const StreamTee &rhs) : Stream(rhs), m_streams_mutex(), m_streams()
     {
-        Mutex::Locker locker (rhs.m_streams_mutex);
+        // Don't copy until we lock down "rhs"
+        std::lock_guard<std::recursive_mutex> guard(rhs.m_streams_mutex);
         m_streams = rhs.m_streams;
     }
 

     }
 
     StreamTee &
-    operator = (const StreamTee &rhs)
+    operator=(const StreamTee &rhs)
     {
-        if (this != &rhs) {
+        if (this != &rhs)
+        {
             Stream::operator=(rhs);
-            Mutex::Locker lhs_locker (m_streams_mutex);
-            Mutex::Locker rhs_locker (rhs.m_streams_mutex);
-            m_streams = rhs.m_streams;            
+            std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex);
+            std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex);
+            m_streams = rhs.m_streams;
         }
         return *this;
     }
 
     void
-    Flush () override
+    Flush() override
     {
-        Mutex::Locker locker (m_streams_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
         collection::iterator pos, end;
         for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)
         {

             // to valid values.
             Stream *strm = pos->get();
             if (strm)
-                strm->Flush ();
+                strm->Flush();
         }
     }
 
     size_t
-    Write (const void *s, size_t length) override
+    Write(const void *s, size_t length) override
     {
-        Mutex::Locker locker (m_streams_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
         if (m_streams.empty())
             return 0;
-    
         size_t min_bytes_written = SIZE_MAX;
         collection::iterator pos, end;
         for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)

             Stream *strm = pos->get();
             if (strm)
             {
-                const size_t bytes_written = strm->Write (s, length);
+                const size_t bytes_written = strm->Write(s, length);
                 if (min_bytes_written > bytes_written)
                     min_bytes_written = bytes_written;
             }

     }
 
     size_t
-    AppendStream (const lldb::StreamSP &stream_sp)
+    AppendStream(const lldb::StreamSP &stream_sp)
     {
         size_t new_idx = m_streams.size();
-        Mutex::Locker locker (m_streams_mutex);
-        m_streams.push_back (stream_sp);
+        std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
+        m_streams.push_back(stream_sp);
         return new_idx;
     }
 
     size_t
-    GetNumStreams () const
+    GetNumStreams() const
     {
         size_t result = 0;
         {
-            Mutex::Locker locker (m_streams_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
             result = m_streams.size();
         }
         return result;
     }
 
     lldb::StreamSP
-    GetStreamAtIndex (uint32_t idx)
+    GetStreamAtIndex(uint32_t idx)
     {
         lldb::StreamSP stream_sp;
-        Mutex::Locker locker (m_streams_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
         if (idx < m_streams.size())
             stream_sp = m_streams[idx];
         return stream_sp;
     }
 
     void
-    SetStreamAtIndex (uint32_t idx, const lldb::StreamSP& stream_sp)
+    SetStreamAtIndex(uint32_t idx, const lldb::StreamSP &stream_sp)
     {
-        Mutex::Locker locker (m_streams_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_streams_mutex);
         // Resize our stream vector as necessary to fit as many streams
         // as needed. This also allows this class to be used with hard
         // coded indexes that can be used contain many streams, not all

             m_streams.resize(idx + 1);
         m_streams[idx] = stream_sp;
     }
-    
 protected:
     typedef std::vector<lldb::StreamSP> collection;
-    mutable Mutex m_streams_mutex;
+    mutable std::recursive_mutex m_streams_mutex;
     collection m_streams;
 };
 

include/lldb/Core/ThreadSafeSTLMap.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-defines.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    ThreadSafeSTLMap() :
-        m_collection (),
-        m_mutex (Mutex::eMutexTypeRecursive)
-    {
-    }
+    ThreadSafeSTLMap() : m_collection(), m_mutex() {}
 
     ~ThreadSafeSTLMap()
     {

     bool
     IsEmpty() const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         return m_collection.empty();
     }
-    
     void
     Clear()
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         return m_collection.clear();
     }
 
     size_t
-    Erase (const _Key& key)
+    Erase(const _Key &key)
     {
-        Mutex::Locker locker(m_mutex);
-        return EraseNoLock (key);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
+        return EraseNoLock(key);
     }
 
     size_t

     }
 
     bool
-    GetValueForKey (const _Key& key, _Tp &value) const
+    GetValueForKey(const _Key &key, _Tp &value) const
     {
-        Mutex::Locker locker(m_mutex);
-        return GetValueForKeyNoLock (key, value);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
+        return GetValueForKeyNoLock(key, value);
     }
 
     // Call this if you have already manually locked the mutex using the

     }
 
     bool
-    GetFirstKeyForValue (const _Tp &value, _Key& key) const
+    GetFirstKeyForValue(const _Tp &value, _Key &key) const
     {
-        Mutex::Locker locker(m_mutex);
-        return GetFirstKeyForValueNoLock (value, key);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
+        return GetFirstKeyForValueNoLock(value, key);
     }
 
     bool

     }
 
     bool
-    LowerBound (const _Key& key,
-                _Key& match_key,
-                _Tp &match_value,
-                bool decrement_if_not_equal) const
+    LowerBound(const _Key &key, _Key &match_key, _Tp &match_value, bool decrement_if_not_equal) const
     {
-        Mutex::Locker locker(m_mutex);
-        return LowerBoundNoLock (key, match_key, match_value, decrement_if_not_equal);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
+        return LowerBoundNoLock(key, match_key, match_value, decrement_if_not_equal);
     }
 
     bool

     }
 
     void
-    SetValueForKey (const _Key& key, const _Tp &value)
+    SetValueForKey(const _Key &key, const _Tp &value)
     {
-        Mutex::Locker locker(m_mutex);
-        SetValueForKeyNoLock (key, value);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
+        SetValueForKeyNoLock(key, value);
     }
 
     // Call this if you have already manually locked the mutex using the

         m_collection[key] = value;
     }
 
-    Mutex &
-    GetMutex ()
+    std::recursive_mutex &
+    GetMutex()
     {
         return m_mutex;
     }
 
 private:
     collection m_collection;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 
     //------------------------------------------------------------------
     // For ThreadSafeSTLMap only

include/lldb/Core/ThreadSafeValue.h

 #define liblldb_ThreadSafeValue_h_
 
 // C Includes
+
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    ThreadSafeValue() :
-        m_value (),
-        m_mutex (Mutex::eMutexTypeRecursive)
-    {
-    }
+    ThreadSafeValue() : m_value(), m_mutex() {}
 
-    ThreadSafeValue(const T& value) :
-        m_value (value),
-        m_mutex (Mutex::eMutexTypeRecursive)
-    {
-    }
+    ThreadSafeValue(const T &value) : m_value(value), m_mutex() {}
 
     ~ThreadSafeValue()
     {
     }
 
     T
-    GetValue () const
+    GetValue() const
     {
         T value;
         {
-            Mutex::Locker locker(m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             value = m_value;
         }
         return value;

     }
 
     void
-    SetValue (const T& value)
+    SetValue(const T &value)
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         m_value = value;
     }
 

         m_value = value;
     }
 
-    Mutex &
-    GetMutex ()
+    std::recursive_mutex &
+    GetMutex()
     {
         return m_mutex;
     }
 
 private:
     T m_value;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 
     //------------------------------------------------------------------
     // For ThreadSafeValue only

include/lldb/Core/UserSettingsController.h

 #include "lldb/Core/StringList.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StreamString.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Interpreter/OptionValue.h"
 
 namespace lldb_private {

include/lldb/Core/ValueObject.h

     class ChildrenManager
     {
     public:
-        ChildrenManager() :
-            m_mutex(Mutex::eMutexTypeRecursive),
-            m_children(),
-            m_children_count(0)
-        {}
-        
+        ChildrenManager() : m_mutex(), m_children(), m_children_count(0) {}
+
         bool
-        HasChildAtIndex (size_t idx)
+        HasChildAtIndex(size_t idx)
         {
-            Mutex::Locker locker(m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             return (m_children.find(idx) != m_children.end());
         }
-        
-        ValueObject*
-        GetChildAtIndex (size_t idx)
+        ValueObject *
+        GetChildAtIndex(size_t idx)
         {
-            Mutex::Locker locker(m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             const auto iter = m_children.find(idx);
             return ((iter == m_children.end()) ? nullptr : iter->second);
         }
-        
         void
-        SetChildAtIndex (size_t idx, ValueObject* valobj)
+        SetChildAtIndex(size_t idx, ValueObject *valobj)
         {
-            ChildrenPair pair(idx,valobj); // we do not need to be mutex-protected to make a pair
-            Mutex::Locker locker(m_mutex);
+            // we do not need to be mutex-protected to make a pair
+            ChildrenPair pair(idx, valobj);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             m_children.insert(pair);
         }
-        
         void
         SetChildrenCount (size_t count)
         {

         {
             return m_children_count;
         }
-        
         void
         Clear(size_t new_count = 0)
         {
-            Mutex::Locker locker(m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             m_children_count = new_count;
             m_children.clear();
         }
-        
     private:
         typedef std::map<size_t, ValueObject*> ChildrenMap;
         typedef ChildrenMap::iterator ChildrenIterator;
         typedef ChildrenMap::value_type ChildrenPair;
-        Mutex m_mutex;
+        std::recursive_mutex m_mutex;
         ChildrenMap m_children;
         size_t m_children_count;
     };

include/lldb/DataFormatters/FormatCache.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/ConstString.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 class FormatCache

     };
     typedef std::map<ConstString,Entry> CacheMap;
     CacheMap m_map;
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
     
     uint64_t m_cache_hits;
     uint64_t m_cache_misses;

include/lldb/DataFormatters/FormatManager.h

 #include <atomic>
 #include <initializer_list>
 #include <map>
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes

 
     std::atomic<uint32_t> m_last_revision;
     FormatCache m_format_cache;
-    Mutex m_language_categories_mutex;
+    std::recursive_mutex m_language_categories_mutex;
     LanguageCategories m_language_categories_map;
     NamedSummariesMap m_named_summaries_map;
     TypeCategoryMap m_categories_map;

include/lldb/DataFormatters/FormattersContainer.h

 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <string>
 
 // Other libraries and framework includes

     typedef std::map<KeyType, ValueSP> MapType;
     typedef typename MapType::iterator MapIterator;
     typedef std::function<bool(KeyType, const ValueSP&)> ForEachCallback;
-    
-    FormatMap(IFormatChangeListener* lst) :
-    m_map(),
-    m_map_mutex(Mutex::eMutexTypeRecursive),
-    listener(lst)
-    {
-    }
-    
+    FormatMap(IFormatChangeListener *lst) : m_map(), m_map_mutex(), listener(lst) {}
+
     void
-    Add(KeyType name,
-        const ValueSP& entry)
+    Add(KeyType name, const ValueSP &entry)
     {
         if (listener)
             entry->GetRevision() = listener->GetCurrentRevision();
         else
             entry->GetRevision() = 0;
 
-        Mutex::Locker locker(m_map_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         m_map[name] = entry;
         if (listener)
             listener->Changed();
     }
-    
     bool
-    Delete (KeyType name)
+    Delete(KeyType name)
     {
-        Mutex::Locker locker(m_map_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         MapIterator iter = m_map.find(name);
         if (iter == m_map.end())
             return false;

             listener->Changed();
         return true;
     }
-    
     void
-    Clear ()
+    Clear()
     {
-        Mutex::Locker locker(m_map_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         m_map.clear();
         if (listener)
             listener->Changed();
     }
-    
     bool
-    Get(KeyType name,
-        ValueSP& entry)
+    Get(KeyType name, ValueSP &entry)
     {
-        Mutex::Locker locker(m_map_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         MapIterator iter = m_map.find(name);
         if (iter == m_map.end())
             return false;
         entry = iter->second;
         return true;
     }
-    
     void
-    ForEach (ForEachCallback callback)
+    ForEach(ForEachCallback callback)
     {
         if (callback)
         {
-            Mutex::Locker locker(m_map_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
             MapIterator pos, end = m_map.end();
             for (pos = m_map.begin(); pos != end; pos++)
             {

             }
         }
     }
-    
     uint32_t
     GetCount ()
     {
         return m_map.size();
     }
-    
     ValueSP
-    GetValueAtIndex (size_t index)
+    GetValueAtIndex(size_t index)
     {
-        Mutex::Locker locker(m_map_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         MapIterator iter = m_map.begin();
         MapIterator end = m_map.end();
         while (index > 0)

         }
         return iter->second;
     }
-    
     KeyType
-    GetKeyAtIndex (size_t index)
+    GetKeyAtIndex(size_t index)
     {
-        Mutex::Locker locker(m_map_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         MapIterator iter = m_map.begin();
         MapIterator end = m_map.end();
         while (index > 0)

         }
         return iter->first;
     }
-    
 protected:
-    MapType m_map;    
-    Mutex m_map_mutex;
+    MapType m_map;
+    std::recursive_mutex m_map_mutex;
     IFormatChangeListener* listener;
-    
     MapType&
     map ()
     {
         return m_map;
     }
-    
-    Mutex&
-    mutex ()
+    std::recursive_mutex &
+    mutex()
     {
         return m_map_mutex;
     }
-    
     friend class FormattersContainer<KeyType, ValueType>;
     friend class FormatManager;
 };

     }
 
     bool
-    Delete_Impl (ConstString type, lldb::RegularExpressionSP *dummy)
-    {
-       Mutex& x_mutex = m_format_map.mutex();
-        lldb_private::Mutex::Locker locker(x_mutex);
-       MapIterator pos, end = m_format_map.map().end();
-       for (pos = m_format_map.map().begin(); pos != end; pos++)
-       {
-           lldb::RegularExpressionSP regex = pos->first;
-           if ( ::strcmp(type.AsCString(),regex->GetText()) == 0)
-           {
-               m_format_map.map().erase(pos);
-               if (m_format_map.listener)
-                   m_format_map.listener->Changed();
-               return true;
-           }
-       }
-       return false;
-    }    
+    Delete_Impl(ConstString type, lldb::RegularExpressionSP *dummy)
+    {
+        std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
+        MapIterator pos, end = m_format_map.map().end();
+        for (pos = m_format_map.map().begin(); pos != end; pos++)
+        {
+            lldb::RegularExpressionSP regex = pos->first;
+            if (::strcmp(type.AsCString(), regex->GetText()) == 0)
+            {
+                m_format_map.map().erase(pos);
+                if (m_format_map.listener)
+                    m_format_map.listener->Changed();
+                return true;
+            }
+        return false;
+    }
 
     bool
     Get_Impl (ConstString type, MapValueType& entry, ConstString *dummy)

     }
 
     bool
-    Get_Impl (ConstString key, MapValueType& value, lldb::RegularExpressionSP *dummy)
-    {
-       const char* key_cstr = key.AsCString();
+    Get_Impl(ConstString key, MapValueType &value, lldb::RegularExpressionSP *dummy)
+    {
+        const char *key_cstr = key.AsCString();
         if (!key_cstr)
             return false;
-       Mutex& x_mutex = m_format_map.mutex();
-       lldb_private::Mutex::Locker locker(x_mutex);
-       MapIterator pos, end = m_format_map.map().end();
-       for (pos = m_format_map.map().begin(); pos != end; pos++)
-       {
-           lldb::RegularExpressionSP regex = pos->first;
-           if (regex->Execute(key_cstr))
-           {
-               value = pos->second;
-               return true;
-           }
-       }
-       return false;
+        std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
+        MapIterator pos, end = m_format_map.map().end();
+        for (pos = m_format_map.map().begin(); pos != end; pos++)
+        {
+            lldb::RegularExpressionSP regex = pos->first;
+            if (regex->Execute(key_cstr))
+            {
+                value = pos->second;
+                return true;
+            }
+        return false;
     }
-    
     bool
-    GetExact_Impl (ConstString key, MapValueType& value, lldb::RegularExpressionSP *dummy)
+    GetExact_Impl(ConstString key, MapValueType &value, lldb::RegularExpressionSP *dummy)
     {
-        Mutex& x_mutex = m_format_map.mutex();
-        lldb_private::Mutex::Locker locker(x_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_format_map.mutex());
         MapIterator pos, end = m_format_map.map().end();
         for (pos = m_format_map.map().begin(); pos != end; pos++)
         {
             lldb::RegularExpressionSP regex = pos->first;
-            if (strcmp(regex->GetText(),key.AsCString()) == 0)
+            if (strcmp(regex->GetText(), key.AsCString()) == 0)
             {
                 value = pos->second;
                 return true;

include/lldb/DataFormatters/TypeCategory.h

 // C++ Includes
 #include <initializer_list>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 

         bool m_enabled;
         
         IFormatChangeListener* m_change_listener;
-        
-        Mutex m_mutex;
-        
+        std::recursive_mutex m_mutex;
         ConstString m_name;
         
         std::vector<lldb::LanguageType> m_languages;

include/lldb/DataFormatters/TypeCategoryMap.h

 #include <functional>
 #include <list>
 #include <map>
+#include <mutex>
 
 // Other libraries and framework includes
 // Project includes

                 return ptr.get() == other.get();
             }
         };
-        
-        Mutex m_map_mutex;
+        std::recursive_mutex m_map_mutex;
         IFormatChangeListener* listener;
         
         MapType m_map;

         {
             return m_active_categories;
         }
-        
-        Mutex& mutex ()
+        std::recursive_mutex &
+        mutex()
         {
             return m_map_mutex;
         }
-        
         friend class FormattersContainer<KeyType, ValueType>;
         friend class FormatManager;
     };

include/lldb/Expression/IRExecutionUnit.h

 #include "lldb/lldb-private.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Expression/IRMemoryMap.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 

include/lldb/Host/Editline.h

 #endif
 #endif
 
+#include <mutex>
 #include <string>
 #include <vector>
 
 #include "lldb/Host/Condition.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/Predicate.h"
 
 namespace lldb_private {

         CompleteCallbackType m_completion_callback = nullptr;
         void * m_completion_callback_baton = nullptr;
 
-        Mutex m_output_mutex;
+        std::mutex m_output_mutex;
     };
 }
 

include/lldb/Host/ProcessRunLock.h

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-defines.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/Condition.h"
 
 //----------------------------------------------------------------------

include/lldb/Host/common/NativeBreakpointList.h

 
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Host/Mutex.h"
 // #include "lldb/Host/NativeBreakpoint.h"
 
 #include <functional>
 #include <map>
+#include <mutex>
 
 namespace lldb_private
 {

     private:
         typedef std::map<lldb::addr_t, NativeBreakpointSP> BreakpointMap;
 
-        Mutex m_mutex;
+        std::recursive_mutex m_mutex;
         BreakpointMap m_breakpoints;
     };
 }

include/lldb/Host/common/NativeProcessProtocol.h

 #ifndef liblldb_NativeProcessProtocol_h_
 #define liblldb_NativeProcessProtocol_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/MainLoop.h"
 #include "llvm/ADT/StringRef.h"
 

 
         std::vector<NativeThreadProtocolSP> m_threads;
         lldb::tid_t m_current_thread_id;
-        mutable Mutex m_threads_mutex;
+        mutable std::recursive_mutex m_threads_mutex;
 
         lldb::StateType m_state;
-        mutable Mutex m_state_mutex;
+        mutable std::recursive_mutex m_state_mutex;
 
         lldb_private::ExitType m_exit_type;
         int m_exit_status;
         std::string m_exit_description;
-        Mutex m_delegates_mutex;
+        std::recursive_mutex m_delegates_mutex;
         std::vector<NativeDelegate*> m_delegates;
         NativeBreakpointList m_breakpoint_list;
         NativeWatchpointList m_watchpoint_list;

include/lldb/Host/posix/ConnectionFileDescriptorPosix.h

 // C++ Includes
 #include <atomic>
 #include <memory>
+#include <mutex>
 
 #include "lldb/lldb-forward.h"
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Connection.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Host/IOObject.h"

                                           // the port number.
 
     Pipe m_pipe;
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
     std::atomic<bool> m_shutting_down; // This marks that we are shutting down so if we get woken up from
                                        // BytesAvailable to disconnect, we won't try to read again.
     bool m_waiting_for_accept;

include/lldb/Initialization/SystemLifetimeManager.h

 #define LLDB_INITIALIZATION_SYSTEM_LIFETIME_MANAGER_H
 
 #include "lldb/lldb-private-types.h"
-#include "lldb/Host/Mutex.h"
 
 #include <memory>
+#include <mutex>
 
 namespace lldb_private
 {

     void Terminate();
 
   private:
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
     std::unique_ptr<SystemInitializer> m_initializer;
     bool m_initialized;
 

include/lldb/Interpreter/CommandHistory.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <string>
 #include <vector>
 

 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/Stream.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
     

     DISALLOW_COPY_AND_ASSIGN(CommandHistory);
     
     typedef std::vector<std::string> History;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
     History m_history;
 };
 

include/lldb/Symbol/ArmUnwindInfo.h

 
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/RangeMap.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/lldb-private.h"
 

include/lldb/Symbol/FuncUnwinders.h

 #ifndef liblldb_FuncUnwinders_h
 #define liblldb_FuncUnwinders_h
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/AddressRange.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     UnwindTable& m_unwind_table;
     AddressRange m_range;
 
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
 
     lldb::UnwindPlanSP              m_unwind_plan_assembly_sp;
     lldb::UnwindPlanSP              m_unwind_plan_eh_frame_sp;

include/lldb/Target/JITLoaderList.h

 #ifndef liblldb_JITLoaderList_h_
 #define liblldb_JITLoaderList_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/lldb-forward.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

 
 private:
     std::vector<lldb::JITLoaderSP> m_jit_loaders_vec;
-    lldb_private::Mutex m_jit_loaders_mutex;
+    std::recursive_mutex m_jit_loaders_mutex;
 };
 
 } // namespace lldb_private

include/lldb/Target/Platform.h

 #include <functional>
 #include <map>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 

 #include "lldb/Core/UserSettingsController.h"
 #include "lldb/Interpreter/Options.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Mutex.h"
 
 // TODO pull NativeDelegate class out of NativeProcessProtocol so we
 // can just forward ref the NativeDelegate rather than include it here.

         uint32_t m_update_os_version;
         ArchSpec m_system_arch; // The architecture of the kernel or the remote platform
         typedef std::map<uint32_t, ConstString> IDToNameMap;
-        Mutex m_mutex; // Mutex for modifying Platform data structures that should only be used for non-reentrant code
+        // Mutex for modifying Platform data structures that should only be used for non-reentrant code
+        std::mutex m_mutex;
         IDToNameMap m_uid_map;
         IDToNameMap m_gid_map;
         size_t m_max_uid_name_len;

         CalculateTrapHandlerSymbolNames () = 0;
 
         const char *
-        GetCachedUserName (uint32_t uid)
+        GetCachedUserName(uint32_t uid)
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             // return the empty string if our string is NULL
             // so we can tell when things were in the negative
             // cached (didn't find a valid user name, don't keep

         }
 
         const char *
-        SetCachedUserName (uint32_t uid, const char *name, size_t name_len)
+        SetCachedUserName(uint32_t uid, const char *name, size_t name_len)
         {
-            Mutex::Locker locker (m_mutex);
-            ConstString const_name (name);
+            std::lock_guard<std::mutex> guard(m_mutex);
+            ConstString const_name(name);
             m_uid_map[uid] = const_name;
             if (m_max_uid_name_len < name_len)
                 m_max_uid_name_len = name_len;
             // Const strings lives forever in our const string pool, so we can return the const char *
-            return const_name.GetCString(); 
+            return const_name.GetCString();
         }
 
         void
-        SetUserNameNotFound (uint32_t uid)
+        SetUserNameNotFound(uint32_t uid)
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             m_uid_map[uid] = ConstString();
         }
 
         void
-        ClearCachedUserNames ()
+        ClearCachedUserNames()
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             m_uid_map.clear();
         }
-    
         const char *
-        GetCachedGroupName (uint32_t gid)
+        GetCachedGroupName(uint32_t gid)
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             // return the empty string if our string is NULL
             // so we can tell when things were in the negative
             // cached (didn't find a valid group name, don't keep

         }
 
         const char *
-        SetCachedGroupName (uint32_t gid, const char *name, size_t name_len)
+        SetCachedGroupName(uint32_t gid, const char *name, size_t name_len)
         {
-            Mutex::Locker locker (m_mutex);
-            ConstString const_name (name);
+            std::lock_guard<std::mutex> guard(m_mutex);
+            ConstString const_name(name);
             m_gid_map[gid] = const_name;
             if (m_max_gid_name_len < name_len)
                 m_max_gid_name_len = name_len;
             // Const strings lives forever in our const string pool, so we can return the const char *
-            return const_name.GetCString(); 
+            return const_name.GetCString();
         }
 
         void
-        SetGroupNameNotFound (uint32_t gid)
+        SetGroupNameNotFound(uint32_t gid)
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             m_gid_map[gid] = ConstString();
         }
 
         void
-        ClearCachedGroupNames ()
+        ClearCachedGroupNames()
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             m_gid_map.clear();
         }
 

     class PlatformList
     {
     public:
-        PlatformList() :
-            m_mutex (Mutex::eMutexTypeRecursive),
-            m_platforms (),
-            m_selected_platform_sp()
-        {
-        }
+        PlatformList() : m_mutex(), m_platforms(), m_selected_platform_sp() {}
 
         ~PlatformList() = default;
 
         void
-        Append (const lldb::PlatformSP &platform_sp, bool set_selected)
+        Append(const lldb::PlatformSP &platform_sp, bool set_selected)
         {
-            Mutex::Locker locker (m_mutex);
-            m_platforms.push_back (platform_sp);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
+            m_platforms.push_back(platform_sp);
             if (set_selected)
                 m_selected_platform_sp = m_platforms.back();
         }

         size_t
         GetSize()
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             return m_platforms.size();
         }
 
         lldb::PlatformSP
-        GetAtIndex (uint32_t idx)
+        GetAtIndex(uint32_t idx)
         {
             lldb::PlatformSP platform_sp;
             {
-                Mutex::Locker locker (m_mutex);
+                std::lock_guard<std::recursive_mutex> guard(m_mutex);
                 if (idx < m_platforms.size())
                     platform_sp = m_platforms[idx];
             }

         /// processes.
         //------------------------------------------------------------------
         lldb::PlatformSP
-        GetSelectedPlatform ()
+        GetSelectedPlatform()
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             if (!m_selected_platform_sp && !m_platforms.empty())
                 m_selected_platform_sp = m_platforms.front();
-            
             return m_selected_platform_sp;
         }
 
         void
-        SetSelectedPlatform (const lldb::PlatformSP &platform_sp)
+        SetSelectedPlatform(const lldb::PlatformSP &platform_sp)
         {
             if (platform_sp)
             {
-                Mutex::Locker locker (m_mutex);
+                std::lock_guard<std::recursive_mutex> guard(m_mutex);
                 const size_t num_platforms = m_platforms.size();
-                for (size_t idx=0; idx<num_platforms; ++idx)
+                for (size_t idx = 0; idx < num_platforms; ++idx)
                 {
                     if (m_platforms[idx].get() == platform_sp.get())
                     {

                         return;
                     }
                 }
-                m_platforms.push_back (platform_sp);
+                m_platforms.push_back(platform_sp);
                 m_selected_platform_sp = m_platforms.back();
             }
         }
 
     protected:
         typedef std::vector<lldb::PlatformSP> collection;
-        mutable Mutex m_mutex;
+        mutable std::recursive_mutex m_mutex;
         collection m_platforms;
         lldb::PlatformSP m_selected_platform_sp;
 
     private:
         DISALLOW_COPY_AND_ASSIGN (PlatformList);
     };
-    
     class OptionGroupPlatformRSync : public lldb_private::OptionGroup
     {
     public:

include/lldb/Target/SectionLoadHistory.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 
 // Project includes
 #include "lldb/lldb-public.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    SectionLoadHistory () :
-        m_stop_id_to_section_load_list(),
-        m_mutex (Mutex::eMutexTypeRecursive)
-    {
-    }
+    SectionLoadHistory() : m_stop_id_to_section_load_list(), m_mutex() {}
 
     ~SectionLoadHistory()
     {

 
     typedef std::map<uint32_t, lldb::SectionLoadListSP> StopIDToSectionLoadList;
     StopIDToSectionLoadList m_stop_id_to_section_load_list;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 
 private:
     DISALLOW_COPY_AND_ASSIGN (SectionLoadHistory);

include/lldb/Target/SectionLoadList.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 
 // Other libraries and framework includes
 #include "llvm/ADT/DenseMap.h"
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    SectionLoadList () :
-        m_addr_to_sect (),
-        m_sect_to_addr (),
-        m_mutex (Mutex::eMutexTypeRecursive)
-
-    {
-    }
+    SectionLoadList() : m_addr_to_sect(), m_sect_to_addr(), m_mutex() {}
 
     SectionLoadList (const SectionLoadList& rhs);
 

     typedef llvm::DenseMap<const Section *, lldb::addr_t> sect_to_addr_collection;
     addr_to_sect_collection m_addr_to_sect;
     sect_to_addr_collection m_sect_to_addr;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 };
 
 } // namespace lldb_private

include/lldb/Target/TargetList.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Broadcaster.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Target.h"
 
 namespace lldb_private {

     //------------------------------------------------------------------
     collection m_target_list;
     lldb::TargetSP m_dummy_target_sp;
-    mutable Mutex m_target_list_mutex;
+    mutable std::recursive_mutex m_target_list_mutex;
     uint32_t m_selected_target_idx;
 
 private:

include/lldb/Target/Thread.h

 // C Includes
 // C++ Includes
 #include <memory>
+#include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/StructuredData.h"

     const uint32_t      m_index_id;             ///< A unique 1 based index assigned to each thread for easy UI/command line access.
     lldb::RegisterContextSP m_reg_context_sp;   ///< The register context for this thread's current register state.
     lldb::StateType     m_state;                ///< The state of our process.
-    mutable Mutex       m_state_mutex;          ///< Multithreaded protection for m_state.
+    mutable std::recursive_mutex m_state_mutex; ///< Multithreaded protection for m_state.
     plan_stack          m_plan_stack;           ///< The stack of plans this thread is executing.
     plan_stack          m_completed_plan_stack; ///< Plans that have been completed by this stop.  They get deleted when the thread resumes.
     plan_stack          m_discarded_plan_stack; ///< Plans that have been discarded by this stop.  They get deleted when the thread resumes.
-    mutable Mutex       m_frame_mutex;          ///< Multithreaded protection for m_state.
+    mutable std::recursive_mutex m_frame_mutex; ///< Multithreaded protection for m_state.
     lldb::StackFrameListSP m_curr_frames_sp;    ///< The stack frames that get lazily populated after a thread stops.
     lldb::StackFrameListSP m_prev_frames_sp;    ///< The previous stack frames from the last time this thread stopped.
     int                 m_resume_signal;        ///< The signal that should be used when continuing this thread.

include/lldb/Target/ThreadPlan.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <string>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/UserID.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"

 
     ThreadPlanKind m_kind;
     std::string m_name;
-    Mutex m_plan_complete_mutex;
+    std::recursive_mutex m_plan_complete_mutex;
     LazyBool m_cached_plan_explains_stop;
     bool m_plan_complete;
     bool m_plan_private;

include/lldb/Target/ThreadPlanPython.h

 #include "lldb/lldb-private.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UserID.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"

include/lldb/Target/Unwind.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     //------------------------------------------------------------------
     // Classes that inherit from Unwind can see and modify these
     //------------------------------------------------------------------
-    Unwind(Thread &thread) :
-        m_thread (thread),
-        m_unwind_mutex(Mutex::eMutexTypeRecursive)
-    {
-    }
+    Unwind(Thread &thread) : m_thread(thread), m_unwind_mutex() {}
 
 public:
     virtual

     void
     Clear()
     {
-        Mutex::Locker locker(m_unwind_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
         DoClear();
-    
     }
 
     uint32_t
     GetFrameCount()
     {
-        Mutex::Locker locker(m_unwind_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
         return DoGetFrameCount();
     }
-    
     uint32_t
     GetFramesUpTo (uint32_t end_idx)
     {

     }
 
     bool
-    GetFrameInfoAtIndex (uint32_t frame_idx,
-                         lldb::addr_t& cfa, 
-                         lldb::addr_t& pc)
+    GetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa, lldb::addr_t &pc)
     {
-        Mutex::Locker locker(m_unwind_mutex);
-        return DoGetFrameInfoAtIndex (frame_idx, cfa, pc);
+        std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
+        return DoGetFrameInfoAtIndex(frame_idx, cfa, pc);
     }
-    
     lldb::RegisterContextSP
-    CreateRegisterContextForFrame (StackFrame *frame)
+    CreateRegisterContextForFrame(StackFrame *frame)
     {
-        Mutex::Locker locker(m_unwind_mutex);
-        return DoCreateRegisterContextForFrame (frame);
+        std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
+        return DoCreateRegisterContextForFrame(frame);
     }
-    
     Thread &
     GetThread()
     {

     DoCreateRegisterContextForFrame (StackFrame *frame) = 0;
 
     Thread &m_thread;
-    Mutex  m_unwind_mutex;
+    std::recursive_mutex m_unwind_mutex;
+
 private:
     DISALLOW_COPY_AND_ASSIGN (Unwind);
 };

include/lldb/Utility/SharedCluster.h

 #define utility_SharedCluster_h_
 
 #include "lldb/Utility/SharingPtr.h"
-#include "lldb/Host/Mutex.h"
 
 #include "llvm/ADT/SmallPtrSet.h"
 

 class ClusterManager
 {
 public:
-    ClusterManager () : 
-        m_objects(),
-        m_external_ref(0),
-        m_mutex(Mutex::eMutexTypeNormal) {}
-    
-    ~ClusterManager ()
+    ClusterManager() : m_objects(), m_external_ref(0), m_mutex() {}
+
+    ~ClusterManager()
     {
-        for (typename llvm::SmallPtrSet<T *, 16>::iterator pos = m_objects.begin(), end = m_objects.end(); pos != end; ++pos)
+        for (typename llvm::SmallPtrSet<T *, 16>::iterator pos = m_objects.begin(), end = m_objects.end(); pos != end;
+             ++pos)
         {
             T *object = *pos;
             delete object;

         // Decrement refcount should have been called on this ClusterManager,
         // and it should have locked the mutex, now we will unlock it before
         // we destroy it...
-        m_mutex.Unlock();
+        m_mutex.unlock();
     }
-    
-    void ManageObject (T *new_object)
+    void
+    ManageObject(T *new_object)
     {
-        Mutex::Locker locker (m_mutex);
-        m_objects.insert (new_object);
+        std::lock_guard<std::mutex> guard(m_mutex);
+        m_objects.insert(new_object);
     }
-    
-    typename lldb_private::SharingPtr<T> GetSharedPointer(T *desired_object)
+    typename lldb_private::SharingPtr<T>
+    GetSharedPointer(T *desired_object)
     {
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::mutex> guard(m_mutex);
             m_external_ref++;
-            assert (m_objects.count(desired_object));
+            assert(m_objects.count(desired_object));
         }
-        return typename lldb_private::SharingPtr<T> (desired_object, new imp::shared_ptr_refcount<ClusterManager> (this));
+        return typename lldb_private::SharingPtr<T>(desired_object, new imp::shared_ptr_refcount<ClusterManager>(this));
     }
-    
 private:
-    
-    void DecrementRefCount () 
+    void
+    DecrementRefCount()
     {
-        m_mutex.Lock();
+        m_mutex.lock();
         m_external_ref--;
         if (m_external_ref == 0)
             delete this;
         else
-            m_mutex.Unlock();
+            m_mutex.unlock();
     }
-    
     friend class imp::shared_ptr_refcount<ClusterManager>;
-    
     llvm::SmallPtrSet<T *, 16> m_objects;
     int m_external_ref;
-    Mutex m_mutex;
+    std::mutex m_mutex;
 };
 
 } // namespace lldb_private

source/API/SBDebugger.cpp

     // uses global collections and having two threads parsing the .lldbinit files can cause
     // mayhem. So to get around this for now we need to use a mutex to prevent bad things
     // from happening.
-    static Mutex g_mutex(Mutex::eMutexTypeRecursive);
-    Mutex::Locker locker(g_mutex);
+    static std::recursive_mutex g_mutex;
+    std::lock_guard<std::recursive_mutex> guard(g_mutex);
 
     debugger.reset(Debugger::CreateInstance(callback, baton));
 

source/Breakpoint/BreakpointLocationList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointLocationList::BreakpointLocationList(Breakpoint &owner) :
-    m_owner (owner),
-    m_locations(),
-    m_address_to_location (),
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_next_id (0),
-    m_new_location_recorder (nullptr)
+BreakpointLocationList::BreakpointLocationList(Breakpoint &owner)
+    : m_owner(owner), m_locations(), m_address_to_location(), m_mutex(), m_next_id(0), m_new_location_recorder(nullptr)
 {
 }
 

 BreakpointLocationSP
 BreakpointLocationList::Create (const Address &addr, bool resolve_indirect_symbols)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // The location ID is just the size of the location list + 1
     lldb::break_id_t bp_loc_id = ++m_next_id;
     BreakpointLocationSP bp_loc_sp (new BreakpointLocation (bp_loc_id, m_owner, addr, LLDB_INVALID_THREAD_ID, m_owner.IsHardware(), resolve_indirect_symbols));

 BreakpointLocationSP
 BreakpointLocationList::FindByID (lldb::break_id_t break_id) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::const_iterator end = m_locations.end();
     collection::const_iterator pos = std::lower_bound(m_locations.begin(), end, break_id, Compare);
     if (pos != end && (*pos)->GetID() == break_id)

 BreakpointLocationList::FindInModule (Module *module,
                                       BreakpointLocationCollection& bp_loc_list)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const size_t orig_size = bp_loc_list.GetSize();
     collection::iterator pos, end = m_locations.end();
 

 const BreakpointLocationSP
 BreakpointLocationList::FindByAddress (const Address &addr) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointLocationSP bp_loc_sp;
     if (!m_locations.empty())
     {

 {
     s->Printf("%p: ", static_cast<const void*>(this));
     //s->Indent();
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     s->Printf("BreakpointLocationList with %" PRIu64 " BreakpointLocations:\n", (uint64_t)m_locations.size());
     s->IndentMore();
     collection::const_iterator pos, end = m_locations.end();

 BreakpointLocationSP
 BreakpointLocationList::GetByIndex (size_t i)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointLocationSP bp_loc_sp;
     if (i < m_locations.size())
         bp_loc_sp = m_locations[i];

 const BreakpointLocationSP
 BreakpointLocationList::GetByIndex (size_t i) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointLocationSP bp_loc_sp;
     if (i < m_locations.size())
         bp_loc_sp = m_locations[i];

 void
 BreakpointLocationList::ClearAllBreakpointSites ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator pos, end = m_locations.end();
     for (pos = m_locations.begin(); pos != end; ++pos)
         (*pos)->ClearBreakpointSite();

 void
 BreakpointLocationList::ResolveAllBreakpointSites ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator pos, end = m_locations.end();
 
     for (pos = m_locations.begin(); pos != end; ++pos)

 BreakpointLocationList::GetHitCount () const
 {
     uint32_t hit_count = 0;
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::const_iterator pos, end = m_locations.end();
     for (pos = m_locations.begin(); pos != end; ++pos)
         hit_count += (*pos)->GetHitCount();

 size_t
 BreakpointLocationList::GetNumResolvedLocations() const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     size_t resolve_count = 0;
     collection::const_iterator pos, end = m_locations.end();
     for (pos = m_locations.begin(); pos != end; ++pos)

 void
 BreakpointLocationList::GetDescription (Stream *s, lldb::DescriptionLevel level)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator pos, end = m_locations.end();
 
     for (pos = m_locations.begin(); pos != end; ++pos)

 BreakpointLocationSP
 BreakpointLocationList::AddLocation (const Address &addr, bool resolve_indirect_symbols, bool *new_location)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (new_location)
         *new_location = false;

 {
     if (bp_loc_sp)
     {
-        Mutex::Locker locker (m_mutex);
-        
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         m_address_to_location.erase (bp_loc_sp->GetAddress());
 
         collection::iterator pos, end = m_locations.end();

 void
 BreakpointLocationList::RemoveInvalidLocations (const ArchSpec &arch)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     size_t idx = 0;
     // Don't cache m_location.size() as it will change since we might
     // remove locations from our vector...

 void
 BreakpointLocationList::StartRecordingNewLocations (BreakpointLocationCollection &new_locations)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     assert(m_new_location_recorder == nullptr);
     m_new_location_recorder = &new_locations;
 }

 void
 BreakpointLocationList::StopRecordingNewLocations ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_new_location_recorder = nullptr;
 }
 

source/Breakpoint/BreakpointSite.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointSite::BreakpointSite(BreakpointSiteList *list,
-                               const BreakpointLocationSP& owner,
-                               lldb::addr_t addr,
-                               bool use_hardware) :
-    StoppointLocation(GetNextID(), addr, 0, use_hardware),
-    m_type (eSoftware), // Process subclasses need to set this correctly using SetType()
-    m_saved_opcode(),
-    m_trap_opcode(),
-    m_enabled(false), // Need to create it disabled, so the first enable turns it on.
-    m_owners(),
-    m_owners_mutex(Mutex::eMutexTypeRecursive)
+BreakpointSite::BreakpointSite(BreakpointSiteList *list, const BreakpointLocationSP &owner, lldb::addr_t addr,
+                               bool use_hardware)
+    : StoppointLocation(GetNextID(), addr, 0, use_hardware),
+      m_type(eSoftware), // Process subclasses need to set this correctly using SetType()
+      m_saved_opcode(),
+      m_trap_opcode(),
+      m_enabled(false), // Need to create it disabled, so the first enable turns it on.
+      m_owners(),
+      m_owners_mutex()
 {
     m_owners.Add(owner);
 }

 bool
 BreakpointSite::ShouldStop (StoppointCallbackContext *context)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     IncrementHitCount();
     return m_owners.ShouldStop (context);
 }

 bool
 BreakpointSite::IsBreakpointAtThisSite (lldb::break_id_t bp_id)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     const size_t owner_count = m_owners.GetSize();
     for (size_t i = 0; i < owner_count; i++)
     {

 void
 BreakpointSite::GetDescription (Stream *s, lldb::DescriptionLevel level)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     if (level != lldb::eDescriptionLevelBrief)
         s->Printf ("breakpoint site: %d at 0x%8.8" PRIx64, GetID(), GetLoadAddress());
     m_owners.GetDescription (s, level);

 void
 BreakpointSite::AddOwner (const BreakpointLocationSP &owner)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     m_owners.Add(owner);
 }
 
 size_t
 BreakpointSite::RemoveOwner (lldb::break_id_t break_id, lldb::break_id_t break_loc_id)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     m_owners.Remove(break_id, break_loc_id);
     return m_owners.GetSize();
 }

 size_t
 BreakpointSite::GetNumberOfOwners ()
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     return m_owners.GetSize();
 }
 
 BreakpointLocationSP
 BreakpointSite::GetOwnerAtIndex (size_t index)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     return m_owners.GetByIndex (index);
 }
 
 bool
 BreakpointSite::ValidForThisThread (Thread *thread)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     return m_owners.ValidForThisThread(thread);
 }
 
 void
 BreakpointSite::BumpHitCounts()
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations())
     {
         loc_sp->BumpHitCount();

 size_t
 BreakpointSite::CopyOwnersList (BreakpointLocationCollection &out_collection)
 {
-    Mutex::Locker locker(m_owners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
     for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations())
     {
         out_collection.Add(loc_sp);

source/Breakpoint/BreakpointSiteList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointSiteList::BreakpointSiteList() :
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_bp_site_list()
+BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list()
 {
 }
 

 BreakpointSiteList::Add(const BreakpointSiteSP &bp)
 {
     lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator iter = m_bp_site_list.find (bp_site_load_addr);
 
     if (iter == m_bp_site_list.end())

 bool
 BreakpointSiteList::Remove (lldb::break_id_t break_id)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator pos = GetIDIterator(break_id);    // Predicate
     if (pos != m_bp_site_list.end())
     {

 bool
 BreakpointSiteList::RemoveByAddress (lldb::addr_t address)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator pos =  m_bp_site_list.find(address);
     if (pos != m_bp_site_list.end())
     {

 BreakpointSiteList::collection::iterator
 BreakpointSiteList::GetIDIterator (lldb::break_id_t break_id)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return std::find_if(m_bp_site_list.begin(), m_bp_site_list.end(),   // Search full range
                         BreakpointSiteIDMatches(break_id));             // Predicate
 }

 BreakpointSiteList::collection::const_iterator
 BreakpointSiteList::GetIDConstIterator (lldb::break_id_t break_id) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return std::find_if(m_bp_site_list.begin(), m_bp_site_list.end(),   // Search full range
                         BreakpointSiteIDMatches(break_id));             // Predicate
 }

 BreakpointSiteSP
 BreakpointSiteList::FindByID (lldb::break_id_t break_id)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointSiteSP stop_sp;
     collection::iterator pos = GetIDIterator(break_id);
     if (pos != m_bp_site_list.end())

 const BreakpointSiteSP
 BreakpointSiteList::FindByID (lldb::break_id_t break_id) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointSiteSP stop_sp;
     collection::const_iterator pos = GetIDConstIterator(break_id);
     if (pos != m_bp_site_list.end())

 BreakpointSiteList::FindByAddress (lldb::addr_t addr)
 {
     BreakpointSiteSP found_sp;
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::iterator iter =  m_bp_site_list.find(addr);
     if (iter != m_bp_site_list.end())
         found_sp = iter->second;

 bool
 BreakpointSiteList::BreakpointSiteContainsBreakpoint (lldb::break_id_t bp_site_id, lldb::break_id_t bp_id)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::const_iterator pos = GetIDConstIterator(bp_site_id);
     if (pos != m_bp_site_list.end())
         return pos->second->IsBreakpointAtThisSite (bp_id);

 void
 BreakpointSiteList::ForEach (std::function <void(BreakpointSite *)> const &callback)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     for (auto pair : m_bp_site_list)
         callback (pair.second.get());
 }

 {
     if (lower_bound > upper_bound)
         return false;
-    
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     collection::const_iterator lower, upper, pos;
     lower = m_bp_site_list.lower_bound(lower_bound);
     if (lower == m_bp_site_list.end()

source/Commands/CommandObjectTarget.cpp

     if (check_global_list)
     {
         // Check the global list
-        Mutex::Locker locker(Module::GetAllocationModuleCollectionMutex());
+        std::lock_guard<std::recursive_mutex> guard(Module::GetAllocationModuleCollectionMutex());
         const size_t num_modules = Module::GetNumberAllocatedModules();
         ModuleSP module_sp;
         for (size_t image_idx = 0; image_idx<num_modules; ++image_idx)

                     else
                     {
                         // Check the global list
-                        Mutex::Locker locker(Module::GetAllocationModuleCollectionMutex());
+                        std::lock_guard<std::recursive_mutex> guard(Module::GetAllocationModuleCollectionMutex());
 
                         result.AppendWarningWithFormat("Unable to find an image that matches '%s'.\n", arg_cstr);
                     }

             }
 
             size_t num_modules = 0;
-            Mutex::Locker locker;      // This locker will be locked on the mutex in module_list_ptr if it is non-nullptr.
-                                       // Otherwise it will lock the AllocationModuleCollectionMutex when accessing
-                                       // the global module list directly.
+
+            // This locker will be locked on the mutex in module_list_ptr if it is non-nullptr.
+            // Otherwise it will lock the AllocationModuleCollectionMutex when accessing
+            // the global module list directly.
+            std::unique_lock<std::recursive_mutex> guard(Module::GetAllocationModuleCollectionMutex(), std::defer_lock);
+            Mutex::Locker locker;
+
             const ModuleList *module_list_ptr = nullptr;
             const size_t argc = command.GetArgumentCount();
             if (argc == 0)
             {
                 if (use_global_module_list)
                 {
-                    locker.Lock (Module::GetAllocationModuleCollectionMutex());
+                    guard.lock();
                     num_modules = Module::GetNumberAllocatedModules();
                 }
                 else

 
             if (module_list_ptr != nullptr)
             {
+                assert(use_global_module_list == false && "locking violation");
                 locker.Lock(module_list_ptr->GetMutex());
                 num_modules = module_list_ptr->GetSize();
             }

source/Core/Broadcaster.cpp

                      static_cast<void*>(this), GetBroadcasterName().AsCString());
 }
 
-Broadcaster::BroadcasterImpl::BroadcasterImpl (Broadcaster &broadcaster) :
-    m_broadcaster(broadcaster),
-    m_listeners (),
-    m_listeners_mutex (Mutex::eMutexTypeRecursive),
-    m_hijacking_listeners(),
-    m_hijacking_masks()
+Broadcaster::BroadcasterImpl::BroadcasterImpl(Broadcaster &broadcaster)
+    : m_broadcaster(broadcaster), m_listeners(), m_listeners_mutex(), m_hijacking_listeners(), m_hijacking_masks()
 {
 }
 

 void
 Broadcaster::BroadcasterImpl::Clear()
 {
-    Mutex::Locker listeners_locker(m_listeners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
     
     // Make sure the listener forgets about this broadcaster. We do
     // this in the broadcaster in case the broadcaster object initiates

     if (!listener_sp)
         return 0;
 
-    Mutex::Locker locker(m_listeners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 
     // See if we already have this listener, and if so, update its mask
 

 bool
 Broadcaster::BroadcasterImpl::EventTypeHasListeners (uint32_t event_type)
 {
-    Mutex::Locker locker (m_listeners_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
     if (!m_hijacking_listeners.empty() && event_type & m_hijacking_masks.back())
         return true;
         

 {
     if (listener)
     {
-        Mutex::Locker locker(m_listeners_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
         collection::iterator pos = m_listeners.begin();
         // See if we already have this listener, and if so, update its mask
         while (pos != m_listeners.end())

 
     const uint32_t event_type = event_sp->GetType();
 
-    Mutex::Locker locker(m_listeners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 
     ListenerSP hijacking_listener_sp;
 

 bool
 Broadcaster::BroadcasterImpl::HijackBroadcaster (const lldb::ListenerSP &listener_sp, uint32_t event_mask)
 {
-    Mutex::Locker locker(m_listeners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
     if (log)

 bool
 Broadcaster::BroadcasterImpl::IsHijackedForEvent (uint32_t event_mask)
 {
-    Mutex::Locker locker(m_listeners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 
     if (!m_hijacking_listeners.empty())
         return (event_mask & m_hijacking_masks.back()) != 0;

 void
 Broadcaster::BroadcasterImpl::RestoreBroadcaster ()
 {
-    Mutex::Locker locker(m_listeners_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_listeners_mutex);
 
     if (!m_hijacking_listeners.empty())
     {

 BroadcastEventSpec &
 BroadcastEventSpec::operator=(const BroadcastEventSpec &rhs) = default;
 
-BroadcasterManager::BroadcasterManager() :
-    m_manager_mutex(Mutex::eMutexTypeRecursive)
+BroadcasterManager::BroadcasterManager() : m_manager_mutex()
 {
 }
 

 uint32_t
 BroadcasterManager::RegisterListenerForEvents (const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec)
 {
-    Mutex::Locker locker(m_manager_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
     uint32_t available_bits = event_spec.GetEventBits();
     

 bool
 BroadcasterManager::UnregisterListenerForEvents (const lldb::ListenerSP &listener_sp, BroadcastEventSpec event_spec)
 {
-    Mutex::Locker locker(m_manager_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     bool removed_some = false;
     
     if (m_listeners.erase(listener_sp) == 0)

 ListenerSP
 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
 {
-    Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));
-    
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     collection::const_iterator iter, end_iter = m_event_map.end();
     iter = find_if (m_event_map.begin(), end_iter, BroadcastEventSpecMatches (event_spec));
     if (iter != end_iter)

 void
 BroadcasterManager::RemoveListener(Listener *listener)
 {
-    Mutex::Locker locker(m_manager_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     ListenerMatchesPointer predicate (listener);
     listener_collection::iterator iter = m_listeners.begin(), end_iter = m_listeners.end();
     

 void
 BroadcasterManager::RemoveListener (const lldb::ListenerSP &listener_sp)
 {
-    Mutex::Locker locker(m_manager_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     ListenerMatches predicate (listener_sp);
 
     if (m_listeners.erase (listener_sp) == 0)

 void
 BroadcasterManager::SignUpListenersForBroadcaster (Broadcaster &broadcaster)
 {
-    Mutex::Locker locker(m_manager_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
     
     while (iter != end_iter 

 void
 BroadcasterManager::Clear ()
 {
-    Mutex::Locker locker(m_manager_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
     listener_collection::iterator end_iter = m_listeners.end();
     
     for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)

source/Core/Communication.cpp

     return class_name;
 }
 
-Communication::Communication(const char *name) :
-    Broadcaster(nullptr, name),
+Communication::Communication(const char *name)
+    : Broadcaster(nullptr, name),
       m_connection_sp(),
       m_read_thread_enabled(false),
       m_read_thread_did_exit(false),
       m_bytes(),
-    m_bytes_mutex(Mutex::eMutexTypeRecursive),
-    m_write_mutex(Mutex::eMutexTypeNormal),
-    m_synchronize_mutex(Mutex::eMutexTypeNormal),
+      m_bytes_mutex(),
+      m_write_mutex(),
+      m_synchronize_mutex(),
       m_callback(nullptr),
       m_callback_baton(nullptr),
       m_close_on_eof(true)
 
 {
-    lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION,
-                                 "%p Communication::Communication (name = %s)",
-                                 this, name);
-
-    SetEventName (eBroadcastBitDisconnected, "disconnected");
-    SetEventName (eBroadcastBitReadThreadGotBytes, "got bytes");
-    SetEventName (eBroadcastBitReadThreadDidExit, "read thread did exit");
-    SetEventName (eBroadcastBitReadThreadShouldExit, "read thread should exit");
-    SetEventName (eBroadcastBitPacketAvailable, "packet available");
-    SetEventName (eBroadcastBitNoMorePendingInput, "no more pending input");
-    
+    lldb_private::LogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_COMMUNICATION,
+                                        "%p Communication::Communication (name = %s)", this, name);
+
+    SetEventName(eBroadcastBitDisconnected, "disconnected");
+    SetEventName(eBroadcastBitReadThreadGotBytes, "got bytes");
+    SetEventName(eBroadcastBitReadThreadDidExit, "read thread did exit");
+    SetEventName(eBroadcastBitReadThreadShouldExit, "read thread should exit");
+    SetEventName(eBroadcastBitPacketAvailable, "packet available");
+    SetEventName(eBroadcastBitNoMorePendingInput, "no more pending input");
+
     CheckInWithManager();
 }
 

 {
     lldb::ConnectionSP connection_sp (m_connection_sp);
 
-    Mutex::Locker locker(m_write_mutex);
+    std::lock_guard<std::mutex> guard(m_write_mutex);
     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
                                          "%p Communication::Write (src = %p, src_len = %" PRIu64 ") connection = %p",
                                          this, 

 size_t
 Communication::GetCachedBytes (void *dst, size_t dst_len)
 {
-    Mutex::Locker locker(m_bytes_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
     if (!m_bytes.empty())
     {
         // If DST is nullptr and we have a thread, then return the number

     }
     else if (bytes != nullptr && len > 0)
     {
-        Mutex::Locker locker(m_bytes_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
         m_bytes.append ((const char *)bytes, len);
         if (broadcast)
             BroadcastEventIfUnique (eBroadcastBitReadThreadGotBytes);

 Communication::SynchronizeWithReadThread ()
 {
     // Only one thread can do the synchronization dance at a time.
-    Mutex::Locker locker(m_synchronize_mutex);
+    std::lock_guard<std::mutex> guard(m_synchronize_mutex);
 
     // First start listening for the synchronization event.
     ListenerSP listener_sp(Listener::MakeListener("Communication::SyncronizeWithReadThread"));

source/Core/Debugger.cpp

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 
 // Other libraries and framework includes
 #include "llvm/ADT/StringRef.h"

 
 #pragma mark Static Functions
 
-static Mutex &
-GetDebuggerListMutex ()
+static std::recursive_mutex &
+GetDebuggerListMutex()
 {
-    static Mutex g_mutex(Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_mutex;
     return g_mutex;
 }
 

     assert(lldb_initialized && "Debugger::Terminate called without a matching Debugger::Initialize!");
 
     // Clear our master list of debugger objects
-    Mutex::Locker locker (GetDebuggerListMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
     auto& debuggers = GetDebuggerList();
     for (const auto& debugger: debuggers)
         debugger->Clear();

     DebuggerSP debugger_sp (new Debugger(log_callback, baton));
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         GetDebuggerList().push_back(debugger_sp);
     }
     debugger_sp->InstanceInitialize ();

 
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         DebuggerList &debugger_list = GetDebuggerList ();
         DebuggerList::iterator pos, end = debugger_list.end();
         for (pos = debugger_list.begin (); pos != end; ++pos)

     DebuggerSP debugger_sp;
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         DebuggerList &debugger_list = GetDebuggerList();
         DebuggerList::iterator pos, end = debugger_list.end();
 

     TargetSP target_sp;
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         DebuggerList &debugger_list = GetDebuggerList();
         DebuggerList::iterator pos, end = debugger_list.end();
         for (pos = debugger_list.begin(); pos != end; ++pos)

     TargetSP target_sp;
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         DebuggerList &debugger_list = GetDebuggerList();
         DebuggerList::iterator pos, end = debugger_list.end();
         for (pos = debugger_list.begin(); pos != end; ++pos)

 }
 
 void
-Debugger::DispatchInputInterrupt ()
+Debugger::DispatchInputInterrupt()
 {
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
-    IOHandlerSP reader_sp (m_input_reader_stack.Top());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
+    IOHandlerSP reader_sp(m_input_reader_stack.Top());
     if (reader_sp)
         reader_sp->Interrupt();
 }
 
 void
-Debugger::DispatchInputEndOfFile ()
+Debugger::DispatchInputEndOfFile()
 {
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
-    IOHandlerSP reader_sp (m_input_reader_stack.Top());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
+    IOHandlerSP reader_sp(m_input_reader_stack.Top());
     if (reader_sp)
         reader_sp->GotEOF();
 }
 
 void
-Debugger::ClearIOHandlers ()
+Debugger::ClearIOHandlers()
 {
     // The bottom input reader should be the main debugger input reader.  We do not want to close that one here.
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
     while (m_input_reader_stack.GetSize() > 1)
     {
-        IOHandlerSP reader_sp (m_input_reader_stack.Top());
+        IOHandlerSP reader_sp(m_input_reader_stack.Top());
         if (reader_sp)
-            PopIOHandler (reader_sp);
+            PopIOHandler(reader_sp);
     }
 }
 

 }
 
 void
-Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out, StreamFileSP &err)
+Debugger::AdoptTopIOHandlerFilesIfInvalid(StreamFileSP &in, StreamFileSP &out, StreamFileSP &err)
 {
     // Before an IOHandler runs, it must have in/out/err streams.
     // This function is called when one ore more of the streams
     // are nullptr. We use the top input reader's in/out/err streams,
     // or fall back to the debugger file handles, or we fall back
     // onto stdin/stdout/stderr as a last resort.
-    
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
-    IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
+    IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
     // If no STDIN has been set, then set it appropriately
     if (!in)
     {

             in = top_reader_sp->GetInputStreamFile();
         else
             in = GetInputFile();
-        
         // If there is nothing, use stdin
         if (!in)
             in = StreamFileSP(new StreamFile(stdin, false));

             out = top_reader_sp->GetOutputStreamFile();
         else
             out = GetOutputFile();
-        
         // If there is nothing, use stdout
         if (!out)
             out = StreamFileSP(new StreamFile(stdout, false));

             err = top_reader_sp->GetErrorStreamFile();
         else
             err = GetErrorFile();
-        
         // If there is nothing, use stderr
         if (!err)
             err = StreamFileSP(new StreamFile(stdout, false));
-        
     }
 }
 
 void
-Debugger::PushIOHandler (const IOHandlerSP& reader_sp)
+Debugger::PushIOHandler(const IOHandlerSP &reader_sp)
 {
     if (!reader_sp)
         return;
- 
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 
     // Get the current top input reader...
-    IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
-    
+    IOHandlerSP top_reader_sp(m_input_reader_stack.Top());
     // Don't push the same IO handler twice...
     if (reader_sp == top_reader_sp)
         return;
 
     // Push our new input reader
-    m_input_reader_stack.Push (reader_sp);
+    m_input_reader_stack.Push(reader_sp);
     reader_sp->Activate();
 
     // Interrupt the top input reader to it will exit its Run() function

 }
 
 bool
-Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp)
+Debugger::PopIOHandler(const IOHandlerSP &pop_reader_sp)
 {
-    if (! pop_reader_sp)
+    if (!pop_reader_sp)
         return false;
 
-    Mutex::Locker locker (m_input_reader_stack.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_input_reader_stack.GetMutex());
 
     // The reader on the stop of the stack is done, so let the next
     // read on the stack refresh its prompt and if there is one...

 
     reader_sp->Deactivate();
     reader_sp->Cancel();
-    m_input_reader_stack.Pop ();
+    m_input_reader_stack.Pop();
 
     reader_sp = m_input_reader_stack.Top();
     if (reader_sp)

 {
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         return GetDebuggerList().size();
     }
     return 0;

     
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         DebuggerList &debugger_list = GetDebuggerList();
-        
         if (index < debugger_list.size())
             debugger_sp = debugger_list[index];
     }

 
     if (lldb_initialized)
     {
-        Mutex::Locker locker (GetDebuggerListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDebuggerListMutex());
         DebuggerList &debugger_list = GetDebuggerList();
         DebuggerList::iterator pos, end = debugger_list.end();
         for (pos = debugger_list.begin(); pos != end; ++pos)

source/Core/IOHandler.cpp

 }
 
 void
-IOHandlerStack::PrintAsync (Stream *stream, const char *s, size_t len)
+IOHandlerStack::PrintAsync(Stream *stream, const char *s, size_t len)
 {
     if (stream)
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (m_top)
-            m_top->PrintAsync (stream, s, len);
+            m_top->PrintAsync(stream, s, len);
     }
 }
 

source/Core/Listener.cpp

     };
 } // anonymous namespace
 
-Listener::Listener(const char *name) :
-    m_name (name),
-    m_broadcasters(),
-    m_broadcasters_mutex (Mutex::eMutexTypeRecursive),
-    m_events (),
-    m_events_mutex (Mutex::eMutexTypeNormal)
+Listener::Listener(const char *name)
+    : m_name(name), m_broadcasters(), m_broadcasters_mutex(), m_events(), m_events_mutex(Mutex::eMutexTypeNormal)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log != nullptr)

 Listener::Clear()
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
-    Mutex::Locker locker(m_broadcasters_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
     broadcaster_collection::iterator pos, end = m_broadcasters.end();
     for (pos = m_broadcasters.begin(); pos != end; ++pos)
     {

         // Scope for "locker"
         // Tell the broadcaster to add this object as a listener
         {
-            Mutex::Locker locker(m_broadcasters_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
             Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
             m_broadcasters.insert(std::make_pair(impl_wp, BroadcasterInfo(event_mask)));
         }

         // Scope for "locker"
         // Tell the broadcaster to add this object as a listener
         {
-            Mutex::Locker locker(m_broadcasters_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
             Broadcaster::BroadcasterImplWP impl_wp(broadcaster->GetBroadcasterImpl());
             m_broadcasters.insert(std::make_pair(impl_wp,
                                                  BroadcasterInfo(event_mask, callback, callback_user_data)));

     {
         // Scope for "locker"
         {
-            Mutex::Locker locker(m_broadcasters_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
             m_broadcasters.erase (broadcaster->GetBroadcasterImpl());
         }
         // Remove the broadcaster from our set of broadcasters

 {
     // Scope for "broadcasters_locker"
     {
-        Mutex::Locker broadcasters_locker(m_broadcasters_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
         m_broadcasters.erase (broadcaster->GetBroadcasterImpl());
     }
 

 Listener::HandleBroadcastEvent (EventSP &event_sp)
 {
     size_t num_handled = 0;
-    Mutex::Locker locker(m_broadcasters_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
     Broadcaster *broadcaster = event_sp->GetBroadcaster();
     if (!broadcaster)
         return 0;

     
     // The BroadcasterManager mutex must be locked before m_broadcasters_mutex 
     // to avoid violating the lock hierarchy (manager before broadcasters).
-    Mutex::Locker manager_locker(manager_sp->m_manager_mutex);
-    Mutex::Locker locker(m_broadcasters_mutex);
+    std::lock_guard<std::recursive_mutex> manager_guard(manager_sp->m_manager_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
 
     uint32_t bits_acquired = manager_sp->RegisterListenerForEvents(this->shared_from_this(), event_spec);
     if (bits_acquired)

 {
     if (!manager_sp)
         return false;
-    
-    Mutex::Locker locker(m_broadcasters_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
     return manager_sp->UnregisterListenerForEvents (this->shared_from_this(), event_spec);
 }
     

source/Core/Log.cpp

 #include <cstdarg>
 #include <cstdlib>
 #include <map>
+#include <mutex>
 #include <string>
 
 // Other libraries and framework includes

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/ThisThread.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Interpreter/Args.h"

 
         if (m_options.Test(LLDB_LOG_OPTION_THREADSAFE))
         {
-            static Mutex g_LogThreadedMutex(Mutex::eMutexTypeRecursive);
-            Mutex::Locker locker(g_LogThreadedMutex);
+            static std::recursive_mutex g_LogThreadedMutex;
+            std::lock_guard<std::recursive_mutex> guard(g_LogThreadedMutex);
             stream_sp->PutCString(header.GetString().c_str());
             stream_sp->Flush();
         }

source/Core/Module.cpp

     return *g_module_collection;
 }
 
-Mutex *
+std::recursive_mutex &
 Module::GetAllocationModuleCollectionMutex()
 {
     // NOTE: The mutex below must be leaked since the global module list in

     // if it will tear itself down before the "g_module_collection_mutex" below
     // will. So we leak a Mutex object below to safeguard against that
 
-    static Mutex *g_module_collection_mutex = nullptr;
+    static std::recursive_mutex *g_module_collection_mutex = nullptr;
     if (g_module_collection_mutex == nullptr)
-        g_module_collection_mutex = new Mutex (Mutex::eMutexTypeRecursive); // NOTE: known leak
-    return g_module_collection_mutex;
+        g_module_collection_mutex = new std::recursive_mutex; // NOTE: known leak
+    return *g_module_collection_mutex;
 }
 
 size_t
 Module::GetNumberAllocatedModules ()
 {
-    Mutex::Locker locker (GetAllocationModuleCollectionMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetAllocationModuleCollectionMutex());
     return GetModuleCollection().size();
 }
 
 Module *
 Module::GetAllocatedModuleAtIndex (size_t idx)
 {
-    Mutex::Locker locker (GetAllocationModuleCollectionMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetAllocationModuleCollectionMutex());
     ModuleCollection &modules = GetModuleCollection();
     if (idx < modules.size())
         return modules[idx];

 
 #endif
 
-Module::Module (const ModuleSpec &module_spec) :
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_mod_time (),
-    m_arch (),
-    m_uuid (),
-    m_file (),
+Module::Module(const ModuleSpec &module_spec)
+    : m_mutex(),
+      m_mod_time(),
+      m_arch(),
+      m_uuid(),
+      m_file(),
       m_platform_file(),
       m_remote_install_file(),
-    m_symfile_spec (),
-    m_object_name (),
-    m_object_offset (),
-    m_object_mod_time (),
-    m_objfile_sp (),
-    m_symfile_ap (),
+      m_symfile_spec(),
+      m_object_name(),
+      m_object_offset(),
+      m_object_mod_time(),
+      m_objfile_sp(),
+      m_symfile_ap(),
       m_type_system_map(),
-    m_source_mappings (),
+      m_source_mappings(),
       m_sections_ap(),
-    m_did_load_objfile (false),
-    m_did_load_symbol_vendor (false),
-    m_did_parse_uuid (false),
-    m_file_has_changed (false),
-    m_first_file_changed_log (false)
+      m_did_load_objfile(false),
+      m_did_load_symbol_vendor(false),
+      m_did_parse_uuid(false),
+      m_file_has_changed(false),
+      m_first_file_changed_log(false)
 {
     // Scope for locker below...
     {
-        Mutex::Locker locker (GetAllocationModuleCollectionMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetAllocationModuleCollectionMutex());
         GetModuleCollection().push_back(this);
     }
 
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT|LIBLLDB_LOG_MODULES));
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES));
     if (log != nullptr)
-        log->Printf ("%p Module::Module((%s) '%s%s%s%s')",
-                     static_cast<void*>(this),
-                     module_spec.GetArchitecture().GetArchitectureName(),
-                     module_spec.GetFileSpec().GetPath().c_str(),
-                     module_spec.GetObjectName().IsEmpty() ? "" : "(",
-                     module_spec.GetObjectName().IsEmpty() ? "" : module_spec.GetObjectName().AsCString(""),
-                     module_spec.GetObjectName().IsEmpty() ? "" : ")");
+        log->Printf("%p Module::Module((%s) '%s%s%s%s')", static_cast<void *>(this),
+                    module_spec.GetArchitecture().GetArchitectureName(), module_spec.GetFileSpec().GetPath().c_str(),
+                    module_spec.GetObjectName().IsEmpty() ? "" : "(",
+                    module_spec.GetObjectName().IsEmpty() ? "" : module_spec.GetObjectName().AsCString(""),
+                    module_spec.GetObjectName().IsEmpty() ? "" : ")");
 
     // First extract all module specifications from the file using the local
     // file path. If there are no specifications, then don't fill anything in

     ModuleSpec matching_module_spec;
     if (modules_specs.FindMatchingModuleSpec(module_spec, matching_module_spec) == 0)
         return;
-    
     if (module_spec.GetFileSpec())
         m_mod_time = module_spec.GetFileSpec().GetModificationTime();
     else if (matching_module_spec.GetFileSpec())
         m_mod_time = matching_module_spec.GetFileSpec().GetModificationTime();
-    
     // Copy the architecture from the actual spec if we got one back, else use the one that was specified
     if (matching_module_spec.GetArchitecture().IsValid())
         m_arch = matching_module_spec.GetArchitecture();
     else if (module_spec.GetArchitecture().IsValid())
         m_arch = module_spec.GetArchitecture();
-    
     // Copy the file spec over and use the specified one (if there was one) so we
     // don't use a path that might have gotten resolved a path in 'matching_module_spec'
     if (module_spec.GetFileSpec())

         m_platform_file = module_spec.GetPlatformFileSpec();
     else if (matching_module_spec.GetPlatformFileSpec())
         m_platform_file = matching_module_spec.GetPlatformFileSpec();
-    
     // Copy the symbol file spec over
     if (module_spec.GetSymbolFileSpec())
         m_symfile_spec = module_spec.GetSymbolFileSpec();
     else if (matching_module_spec.GetSymbolFileSpec())
         m_symfile_spec = matching_module_spec.GetSymbolFileSpec();
-    
     // Copy the object name over
     if (matching_module_spec.GetObjectName())
         m_object_name = matching_module_spec.GetObjectName();
     else
         m_object_name = module_spec.GetObjectName();
-    
     // Always trust the object offset (file offset) and object modification
     // time (for mod time in a BSD static archive) of from the matching
     // module specification
     m_object_offset = matching_module_spec.GetObjectOffset();
     m_object_mod_time = matching_module_spec.GetObjectModificationTime();
-    
 }
 
-Module::Module(const FileSpec& file_spec, 
-               const ArchSpec& arch, 
-               const ConstString *object_name, 
-               lldb::offset_t object_offset,
-               const TimeValue *object_mod_time_ptr) :
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_mod_time (file_spec.GetModificationTime()),
-    m_arch (arch),
-    m_uuid (),
-    m_file (file_spec),
-    m_platform_file(),
-    m_remote_install_file (),
-    m_symfile_spec (),
-    m_object_name (),
-    m_object_offset (object_offset),
-    m_object_mod_time (),
-    m_objfile_sp (),
-    m_symfile_ap (),
-    m_type_system_map(),
-    m_source_mappings (),
-    m_sections_ap(),
-    m_did_load_objfile (false),
-    m_did_load_symbol_vendor (false),
-    m_did_parse_uuid (false),
-    m_file_has_changed (false),
-    m_first_file_changed_log (false)
+Module::Module(const FileSpec &file_spec, const ArchSpec &arch, const ConstString *object_name,
+               lldb::offset_t object_offset, const TimeValue *object_mod_time_ptr)
+    : m_mutex(),
+      m_mod_time(file_spec.GetModificationTime()),
+      m_arch(arch),
+      m_uuid(),
+      m_file(file_spec),
+      m_platform_file(),
+      m_remote_install_file(),
+      m_symfile_spec(),
+      m_object_name(),
+      m_object_offset(object_offset),
+      m_object_mod_time(),
+      m_objfile_sp(),
+      m_symfile_ap(),
+      m_type_system_map(),
+      m_source_mappings(),
+      m_sections_ap(),
+      m_did_load_objfile(false),
+      m_did_load_symbol_vendor(false),
+      m_did_parse_uuid(false),
+      m_file_has_changed(false),
+      m_first_file_changed_log(false)
 {
     // Scope for locker below...
     {
-        Mutex::Locker locker (GetAllocationModuleCollectionMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetAllocationModuleCollectionMutex());
         GetModuleCollection().push_back(this);
     }
 

     if (object_mod_time_ptr)
         m_object_mod_time = *object_mod_time_ptr;
 
-    Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_OBJECT|LIBLLDB_LOG_MODULES));
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_OBJECT | LIBLLDB_LOG_MODULES));
     if (log != nullptr)
-        log->Printf ("%p Module::Module((%s) '%s%s%s%s')",
-                     static_cast<void*>(this), m_arch.GetArchitectureName(),
-                     m_file.GetPath().c_str(),
-                     m_object_name.IsEmpty() ? "" : "(",
-                     m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""),
-                     m_object_name.IsEmpty() ? "" : ")");
-}
-
-Module::Module () :
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_mod_time (),
-    m_arch (),
-    m_uuid (),
-    m_file (),
-    m_platform_file(),
-    m_remote_install_file (),
-    m_symfile_spec (),
-    m_object_name (),
-    m_object_offset (0),
-    m_object_mod_time (),
-    m_objfile_sp (),
-    m_symfile_ap (),
-    m_type_system_map(),
-    m_source_mappings (),
-    m_sections_ap(),
-    m_did_load_objfile (false),
-    m_did_load_symbol_vendor (false),
-    m_did_parse_uuid (false),
-    m_file_has_changed (false),
-    m_first_file_changed_log (false)
-{
-    Mutex::Locker locker (GetAllocationModuleCollectionMutex());
+        log->Printf("%p Module::Module((%s) '%s%s%s%s')", static_cast<void *>(this), m_arch.GetArchitectureName(),
+                    m_file.GetPath().c_str(), m_object_name.IsEmpty() ? "" : "(",
+                    m_object_name.IsEmpty() ? "" : m_object_name.AsCString(""), m_object_name.IsEmpty() ? "" : ")");
+}
+
+Module::Module()
+    : m_mutex(),
+      m_mod_time(),
+      m_arch(),
+      m_uuid(),
+      m_file(),
+      m_platform_file(),
+      m_remote_install_file(),
+      m_symfile_spec(),
+      m_object_name(),
+      m_object_offset(0),
+      m_object_mod_time(),
+      m_objfile_sp(),
+      m_symfile_ap(),
+      m_type_system_map(),
+      m_source_mappings(),
+      m_sections_ap(),
+      m_did_load_objfile(false),
+      m_did_load_symbol_vendor(false),
+      m_did_parse_uuid(false),
+      m_file_has_changed(false),
+      m_first_file_changed_log(false)
+{
+    std::lock_guard<std::recursive_mutex> guard(GetAllocationModuleCollectionMutex());
     GetModuleCollection().push_back(this);
 }
 

 {
     // Lock our module down while we tear everything down to make sure
     // we don't get any access to the module while it is being destroyed
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // Scope for locker below...
     {
-        Mutex::Locker locker (GetAllocationModuleCollectionMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetAllocationModuleCollectionMutex());
         ModuleCollection &modules = GetModuleCollection();
         ModuleCollection::iterator end = modules.end();
         ModuleCollection::iterator pos = std::find(modules.begin(), end, this);

     }
     else
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (process_sp)
         {
             m_did_load_objfile = true;

 {
     if (!m_did_parse_uuid.load())
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (!m_did_parse_uuid.load())
         {
             ObjectFile * obj_file = GetObjectFile ();

 void
 Module::ParseAllDebugSymbols()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     size_t num_comp_units = GetNumCompileUnits();
     if (num_comp_units == 0)
         return;

 size_t
 Module::GetNumCompileUnits()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     Timer scoped_timer(__PRETTY_FUNCTION__,
                        "Module::GetNumCompileUnits (module = %p)",
                        static_cast<void*>(this));

 CompUnitSP
 Module::GetCompileUnitAtIndex (size_t index)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     size_t num_comp_units = GetNumCompileUnits ();
     CompUnitSP cu_sp;
 

 bool
 Module::ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     Timer scoped_timer(__PRETTY_FUNCTION__, "Module::ResolveFileAddress (vm_addr = 0x%" PRIx64 ")", vm_addr);
     SectionList *section_list = GetSectionList();
     if (section_list)

 Module::ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc,
                                         bool resolve_tail_call_address)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     uint32_t resolved_flags = 0;
 
     // Clear the result symbol context in case we don't find anything, but don't clear the target

 uint32_t
 Module::ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     Timer scoped_timer(__PRETTY_FUNCTION__,
                        "Module::ResolveSymbolContextForFilePath (%s:%u, check_inlines = %s, resolve_scope = 0x%8.8x)",
                        file_spec.GetPath().c_str(),

 {
     if (!m_did_load_symbol_vendor.load())
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (!m_did_load_symbol_vendor.load() && can_create)
         {
             ObjectFile *obj_file = GetObjectFile ();

 void
 Module::GetDescription (Stream *s, lldb::DescriptionLevel level)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (level >= eDescriptionLevelFull)
     {

 void
 Module::Dump(Stream *s)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     //s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
     s->Indent();
     s->Printf("Module %s%s%s%s\n",

 {
     if (!m_did_load_objfile.load())
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         if (!m_did_load_objfile.load())
         {
             Timer scoped_timer(__PRETTY_FUNCTION__,

 bool
 Module::FindSourceFile (const FileSpec &orig_spec, FileSpec &new_spec) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_source_mappings.FindFile (orig_spec, new_spec);
 }
 
 bool
 Module::RemapSourceFile (const char *path, std::string &new_path) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_source_mappings.RemapPath(path, new_path);
 }
 

source/Core/PluginManager.cpp

 // C Includes
 // C++ Includes
 #include <climits>
+#include <mutex>
 #include <string>
 #include <vector>
 

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 using namespace lldb;

 
 typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
 
-static Mutex &
-GetPluginMapMutex ()
+static std::recursive_mutex &
+GetPluginMapMutex()
 {
-    static Mutex g_plugin_map_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_plugin_map_mutex;
     return g_plugin_map_mutex;
 }
 

 static bool
 PluginIsLoaded (const FileSpec &plugin_file_spec)
 {
-    Mutex::Locker locker (GetPluginMapMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
     PluginTerminateMap &plugin_map = GetPluginMap ();
     return plugin_map.find (plugin_file_spec) != plugin_map.end();
 }

 static void
 SetPluginInfo (const FileSpec &plugin_file_spec, const PluginInfo &plugin_info)
 {
-    Mutex::Locker locker (GetPluginMapMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
     PluginTerminateMap &plugin_map = GetPluginMap ();
     assert (plugin_map.find (plugin_file_spec) == plugin_map.end());
     plugin_map[plugin_file_spec] = plugin_info;

 void
 PluginManager::Terminate ()
 {
-    Mutex::Locker locker (GetPluginMapMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetPluginMapMutex());
     PluginTerminateMap &plugin_map = GetPluginMap ();
     
     PluginTerminateMap::const_iterator pos, end = plugin_map.end();

 
 typedef std::vector<ABIInstance> ABIInstances;
 
-static Mutex &
-GetABIInstancesMutex ()
+static std::recursive_mutex &
+GetABIInstancesMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetABIInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
         GetABIInstances ().push_back (instance);
         return true;
     }

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetABIInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
         ABIInstances &instances = GetABIInstances ();
 
         ABIInstances::iterator pos, end = instances.end();

 ABICreateInstance
 PluginManager::GetABICreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetABIInstancesMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
     ABIInstances &instances = GetABIInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetABIInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
         ABIInstances &instances = GetABIInstances ();
 
         ABIInstances::iterator pos, end = instances.end();

 
 typedef std::vector<DisassemblerInstance> DisassemblerInstances;
 
-static Mutex &
-GetDisassemblerMutex ()
+static std::recursive_mutex &
+GetDisassemblerMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetDisassemblerMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
         GetDisassemblerInstances ().push_back (instance);
         return true;
     }

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetDisassemblerMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
         DisassemblerInstances &instances = GetDisassemblerInstances ();
         
         DisassemblerInstances::iterator pos, end = instances.end();

 DisassemblerCreateInstance
 PluginManager::GetDisassemblerCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetDisassemblerMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
     DisassemblerInstances &instances = GetDisassemblerInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetDisassemblerMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
         DisassemblerInstances &instances = GetDisassemblerInstances ();
         
         DisassemblerInstances::iterator pos, end = instances.end();

 
 typedef std::vector<DynamicLoaderInstance> DynamicLoaderInstances;
 
-static Mutex &
-GetDynamicLoaderMutex ()
+static std::recursive_mutex &
+GetDynamicLoaderMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.debugger_init_callback = debugger_init_callback;
-        Mutex::Locker locker (GetDynamicLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
         GetDynamicLoaderInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetDynamicLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
         
         DynamicLoaderInstances::iterator pos, end = instances.end();

 DynamicLoaderCreateInstance
 PluginManager::GetDynamicLoaderCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetDynamicLoaderMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
     DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetDynamicLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
         
         DynamicLoaderInstances::iterator pos, end = instances.end();

 
 typedef std::vector<JITLoaderInstance> JITLoaderInstances;
 
-static Mutex &
-GetJITLoaderMutex ()
+static std::recursive_mutex &
+GetJITLoaderMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.debugger_init_callback = debugger_init_callback;
-        Mutex::Locker locker (GetJITLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
         GetJITLoaderInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetJITLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
         JITLoaderInstances &instances = GetJITLoaderInstances ();
         
         JITLoaderInstances::iterator pos, end = instances.end();

 JITLoaderCreateInstance
 PluginManager::GetJITLoaderCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetJITLoaderMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
     JITLoaderInstances &instances = GetJITLoaderInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetJITLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
         JITLoaderInstances &instances = GetJITLoaderInstances ();
         
         JITLoaderInstances::iterator pos, end = instances.end();

 
 typedef std::vector<EmulateInstructionInstance> EmulateInstructionInstances;
 
-static Mutex &
-GetEmulateInstructionMutex ()
+static std::recursive_mutex &
+GetEmulateInstructionMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetEmulateInstructionMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
         GetEmulateInstructionInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetEmulateInstructionMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
         EmulateInstructionInstances &instances = GetEmulateInstructionInstances ();
         
         EmulateInstructionInstances::iterator pos, end = instances.end();

 EmulateInstructionCreateInstance
 PluginManager::GetEmulateInstructionCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetEmulateInstructionMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
     EmulateInstructionInstances &instances = GetEmulateInstructionInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetEmulateInstructionMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
         EmulateInstructionInstances &instances = GetEmulateInstructionInstances ();
         
         EmulateInstructionInstances::iterator pos, end = instances.end();

 
 typedef std::vector<OperatingSystemInstance> OperatingSystemInstances;
 
-static Mutex &
-GetOperatingSystemMutex ()
+static std::recursive_mutex &
+GetOperatingSystemMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.debugger_init_callback = debugger_init_callback;
-        Mutex::Locker locker (GetOperatingSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
         GetOperatingSystemInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetOperatingSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
         OperatingSystemInstances &instances = GetOperatingSystemInstances ();
         
         OperatingSystemInstances::iterator pos, end = instances.end();

 OperatingSystemCreateInstance
 PluginManager::GetOperatingSystemCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetOperatingSystemMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
     OperatingSystemInstances &instances = GetOperatingSystemInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetOperatingSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
         OperatingSystemInstances &instances = GetOperatingSystemInstances ();
         
         OperatingSystemInstances::iterator pos, end = instances.end();

 
 typedef std::vector<LanguageInstance> LanguageInstances;
 
-static Mutex &
-GetLanguageMutex ()
+static std::recursive_mutex &
+GetLanguageMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetLanguageMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
         GetLanguageInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetLanguageMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
         LanguageInstances &instances = GetLanguageInstances ();
         
         LanguageInstances::iterator pos, end = instances.end();

 LanguageCreateInstance
 PluginManager::GetLanguageCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetLanguageMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
     LanguageInstances &instances = GetLanguageInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetLanguageMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
         LanguageInstances &instances = GetLanguageInstances ();
         
         LanguageInstances::iterator pos, end = instances.end();

 
 typedef std::vector<LanguageRuntimeInstance> LanguageRuntimeInstances;
 
-static Mutex &
-GetLanguageRuntimeMutex ()
+static std::recursive_mutex &
+GetLanguageRuntimeMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.command_callback = command_callback;
-        Mutex::Locker locker (GetLanguageRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
         GetLanguageRuntimeInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetLanguageRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
         LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
         
         LanguageRuntimeInstances::iterator pos, end = instances.end();

 LanguageRuntimeCreateInstance
 PluginManager::GetLanguageRuntimeCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetLanguageRuntimeMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 LanguageRuntimeGetCommandObject
 PluginManager::GetLanguageRuntimeGetCommandObjectAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetLanguageRuntimeMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
     LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
     if (idx < instances.size())
         return instances[idx].command_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetLanguageRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
         LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances ();
         
         LanguageRuntimeInstances::iterator pos, end = instances.end();

 
 typedef std::vector<SystemRuntimeInstance> SystemRuntimeInstances;
 
-static Mutex &
-GetSystemRuntimeMutex ()
+static std::recursive_mutex &
+GetSystemRuntimeMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetSystemRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
         GetSystemRuntimeInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetSystemRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
         SystemRuntimeInstances &instances = GetSystemRuntimeInstances ();
         
         SystemRuntimeInstances::iterator pos, end = instances.end();

 SystemRuntimeCreateInstance
 PluginManager::GetSystemRuntimeCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetSystemRuntimeMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
     SystemRuntimeInstances &instances = GetSystemRuntimeInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetSystemRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
         SystemRuntimeInstances &instances = GetSystemRuntimeInstances ();
         
         SystemRuntimeInstances::iterator pos, end = instances.end();

 
 typedef std::vector<ObjectFileInstance> ObjectFileInstances;
 
-static Mutex &
-GetObjectFileMutex ()
+static std::recursive_mutex &
+GetObjectFileMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         instance.create_memory_callback = create_memory_callback;
         instance.save_core = save_core;
         instance.get_module_specifications = get_module_specifications;
-        Mutex::Locker locker (GetObjectFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
         GetObjectFileInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetObjectFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
         ObjectFileInstances &instances = GetObjectFileInstances ();
         
         ObjectFileInstances::iterator pos, end = instances.end();

 ObjectFileCreateInstance
 PluginManager::GetObjectFileCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetObjectFileMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
     ObjectFileInstances &instances = GetObjectFileInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 ObjectFileCreateMemoryInstance
 PluginManager::GetObjectFileCreateMemoryCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetObjectFileMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
     ObjectFileInstances &instances = GetObjectFileInstances ();
     if (idx < instances.size())
         return instances[idx].create_memory_callback;

 ObjectFileGetModuleSpecifications
 PluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetObjectFileMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
     ObjectFileInstances &instances = GetObjectFileInstances ();
     if (idx < instances.size())
         return instances[idx].get_module_specifications;

 {
     if (name)
     {
-        Mutex::Locker locker (GetObjectFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
         ObjectFileInstances &instances = GetObjectFileInstances ();
         
         ObjectFileInstances::iterator pos, end = instances.end();

 {
     if (name)
     {
-        Mutex::Locker locker (GetObjectFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
         ObjectFileInstances &instances = GetObjectFileInstances ();
         
         ObjectFileInstances::iterator pos, end = instances.end();

 PluginManager::SaveCore (const lldb::ProcessSP &process_sp, const FileSpec &outfile)
 {
     Error error;
-    Mutex::Locker locker (GetObjectFileMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
     ObjectFileInstances &instances = GetObjectFileInstances ();
     
     ObjectFileInstances::iterator pos, end = instances.end();

 
 typedef std::vector<ObjectContainerInstance> ObjectContainerInstances;
 
-static Mutex &
-GetObjectContainerMutex ()
+static std::recursive_mutex &
+GetObjectContainerMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.get_module_specifications = get_module_specifications;
-        Mutex::Locker locker (GetObjectContainerMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
         GetObjectContainerInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetObjectContainerMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
         ObjectContainerInstances &instances = GetObjectContainerInstances ();
         
         ObjectContainerInstances::iterator pos, end = instances.end();

 ObjectContainerCreateInstance
 PluginManager::GetObjectContainerCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetObjectContainerMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
     ObjectContainerInstances &instances = GetObjectContainerInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetObjectContainerMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
         ObjectContainerInstances &instances = GetObjectContainerInstances ();
         
         ObjectContainerInstances::iterator pos, end = instances.end();

 ObjectFileGetModuleSpecifications
 PluginManager::GetObjectContainerGetModuleSpecificationsCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetObjectContainerMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
     ObjectContainerInstances &instances = GetObjectContainerInstances ();
     if (idx < instances.size())
         return instances[idx].get_module_specifications;

 
 typedef std::vector<LogInstance> LogInstances;
 
-static Mutex &
-GetLogMutex ()
+static std::recursive_mutex &
+GetLogMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetLogMutex ());
+        std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
         GetLogInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetLogMutex ());
+        std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
         LogInstances &instances = GetLogInstances ();
         
         LogInstances::iterator pos, end = instances.end();

 const char *
 PluginManager::GetLogChannelCreateNameAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetLogMutex ());
+    std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
     LogInstances &instances = GetLogInstances ();
     if (idx < instances.size())
         return instances[idx].name.GetCString();

 LogChannelCreateInstance
 PluginManager::GetLogChannelCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetLogMutex ());
+    std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
     LogInstances &instances = GetLogInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetLogMutex ());
+        std::lock_guard<std::recursive_mutex> gard(GetLogMutex());
         LogInstances &instances = GetLogInstances ();
         
         LogInstances::iterator pos, end = instances.end();

 
 typedef std::vector<PlatformInstance> PlatformInstances;
 
-static Mutex &
-GetPlatformInstancesMutex ()
+static std::recursive_mutex &
+GetPlatformInstancesMutex()
 {
-    static Mutex g_platform_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_platform_instances_mutex;
     return g_platform_instances_mutex;
 }
 

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetPlatformInstancesMutex ());
-        
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
         PlatformInstance instance;
         assert ((bool)name);
         instance.name = name;

 const char *
 PluginManager::GetPlatformPluginNameAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetPlatformInstancesMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
     PlatformInstances &instances = GetPlatformInstances ();
     if (idx < instances.size())
         return instances[idx].name.GetCString();

 const char *
 PluginManager::GetPlatformPluginDescriptionAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetPlatformInstancesMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
     PlatformInstances &instances = GetPlatformInstances ();
     if (idx < instances.size())
         return instances[idx].description.c_str();

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetPlatformInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
         PlatformInstances &instances = GetPlatformInstances ();
 
         PlatformInstances::iterator pos, end = instances.end();

 PlatformCreateInstance
 PluginManager::GetPlatformCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetPlatformInstancesMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
     PlatformInstances &instances = GetPlatformInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetPlatformInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
         PlatformInstances &instances = GetPlatformInstances ();
 
         PlatformInstances::iterator pos, end = instances.end();

 {
     if (name)
     {
-        Mutex::Locker locker (GetPlatformInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
         PlatformInstances &instances = GetPlatformInstances ();
         llvm::StringRef name_sref(name);
 

 
 typedef std::vector<ProcessInstance> ProcessInstances;
 
-static Mutex &
-GetProcessMutex ()
+static std::recursive_mutex &
+GetProcessMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.debugger_init_callback = debugger_init_callback;
-        Mutex::Locker locker (GetProcessMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
         GetProcessInstances ().push_back (instance);
     }
     return false;

 const char *
 PluginManager::GetProcessPluginNameAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetProcessMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
     ProcessInstances &instances = GetProcessInstances ();
     if (idx < instances.size())
         return instances[idx].name.GetCString();

 const char *
 PluginManager::GetProcessPluginDescriptionAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetProcessMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
     ProcessInstances &instances = GetProcessInstances ();
     if (idx < instances.size())
         return instances[idx].description.c_str();

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetProcessMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
         ProcessInstances &instances = GetProcessInstances ();
         
         ProcessInstances::iterator pos, end = instances.end();

 ProcessCreateInstance
 PluginManager::GetProcessCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetProcessMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
     ProcessInstances &instances = GetProcessInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetProcessMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
         ProcessInstances &instances = GetProcessInstances ();
         
         ProcessInstances::iterator pos, end = instances.end();

 
 typedef std::vector<ScriptInterpreterInstance> ScriptInterpreterInstances;
 
-static Mutex &
+static std::recursive_mutex &
 GetScriptInterpreterMutex()
 {
-    static Mutex g_instances_mutex(Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         instance.description = description;
     instance.create_callback = create_callback;
     instance.language = script_language;
-    Mutex::Locker locker(GetScriptInterpreterMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
     GetScriptInterpreterInstances().push_back(instance);
     return false;
 }

 {
     if (!create_callback)
         return false;
-    Mutex::Locker locker(GetScriptInterpreterMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
     ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
 
     ScriptInterpreterInstances::iterator pos, end = instances.end();

 ScriptInterpreterCreateInstance
 PluginManager::GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx)
 {
-    Mutex::Locker locker(GetScriptInterpreterMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
     ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
     if (idx < instances.size())
         return instances[idx].create_callback;

 lldb::ScriptInterpreterSP
 PluginManager::GetScriptInterpreterForLanguage(lldb::ScriptLanguage script_lang, CommandInterpreter &interpreter)
 {
-    Mutex::Locker locker(GetScriptInterpreterMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetScriptInterpreterMutex());
     ScriptInterpreterInstances &instances = GetScriptInterpreterInstances();
 
     ScriptInterpreterInstances::iterator pos, end = instances.end();

 
 typedef std::vector<SymbolFileInstance> SymbolFileInstances;
 
-static Mutex &
-GetSymbolFileMutex ()
+static std::recursive_mutex &
+GetSymbolFileMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.debugger_init_callback = debugger_init_callback;
-        Mutex::Locker locker (GetSymbolFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
         GetSymbolFileInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetSymbolFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
         SymbolFileInstances &instances = GetSymbolFileInstances ();
         
         SymbolFileInstances::iterator pos, end = instances.end();

 SymbolFileCreateInstance
 PluginManager::GetSymbolFileCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetSymbolFileMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
     SymbolFileInstances &instances = GetSymbolFileInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetSymbolFileMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
         SymbolFileInstances &instances = GetSymbolFileInstances ();
         
         SymbolFileInstances::iterator pos, end = instances.end();

 
 typedef std::vector<SymbolVendorInstance> SymbolVendorInstances;
 
-static Mutex &
-GetSymbolVendorMutex ()
+static std::recursive_mutex &
+GetSymbolVendorMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetSymbolVendorMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
         GetSymbolVendorInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetSymbolVendorMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
         SymbolVendorInstances &instances = GetSymbolVendorInstances ();
         
         SymbolVendorInstances::iterator pos, end = instances.end();

 SymbolVendorCreateInstance
 PluginManager::GetSymbolVendorCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetSymbolVendorMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
     SymbolVendorInstances &instances = GetSymbolVendorInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetSymbolVendorMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
         SymbolVendorInstances &instances = GetSymbolVendorInstances ();
         
         SymbolVendorInstances::iterator pos, end = instances.end();

 
 typedef std::vector<UnwindAssemblyInstance> UnwindAssemblyInstances;
 
-static Mutex &
-GetUnwindAssemblyMutex ()
+static std::recursive_mutex &
+GetUnwindAssemblyMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetUnwindAssemblyMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
         GetUnwindAssemblyInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetUnwindAssemblyMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
         UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances ();
         
         UnwindAssemblyInstances::iterator pos, end = instances.end();

 UnwindAssemblyCreateInstance
 PluginManager::GetUnwindAssemblyCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetUnwindAssemblyMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
     UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetUnwindAssemblyMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
         UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances ();
         
         UnwindAssemblyInstances::iterator pos, end = instances.end();

 
 typedef std::vector<MemoryHistoryInstance> MemoryHistoryInstances;
 
-static Mutex &
-GetMemoryHistoryMutex ()
+static std::recursive_mutex &
+GetMemoryHistoryMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

         if (description && description[0])
             instance.description = description;
         instance.create_callback = create_callback;
-        Mutex::Locker locker (GetMemoryHistoryMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
         GetMemoryHistoryInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetMemoryHistoryMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
         MemoryHistoryInstances &instances = GetMemoryHistoryInstances ();
         
         MemoryHistoryInstances::iterator pos, end = instances.end();

 MemoryHistoryCreateInstance
 PluginManager::GetMemoryHistoryCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetMemoryHistoryMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
     MemoryHistoryInstances &instances = GetMemoryHistoryInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetMemoryHistoryMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
         MemoryHistoryInstances &instances = GetMemoryHistoryInstances ();
         
         MemoryHistoryInstances::iterator pos, end = instances.end();

 
 typedef std::vector<InstrumentationRuntimeInstance> InstrumentationRuntimeInstances;
 
-static Mutex &
-GetInstrumentationRuntimeMutex ()
+static std::recursive_mutex &
+GetInstrumentationRuntimeMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.get_type_callback = get_type_callback;
-        Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
         GetInstrumentationRuntimeInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
         InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
         
         InstrumentationRuntimeInstances::iterator pos, end = instances.end();

 InstrumentationRuntimeGetType
 PluginManager::GetInstrumentationRuntimeGetTypeCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
     InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
     if (idx < instances.size())
         return instances[idx].get_type_callback;

 InstrumentationRuntimeCreateInstance
 PluginManager::GetInstrumentationRuntimeCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
     InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetInstrumentationRuntimeMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetInstrumentationRuntimeMutex());
         InstrumentationRuntimeInstances &instances = GetInstrumentationRuntimeInstances ();
         
         InstrumentationRuntimeInstances::iterator pos, end = instances.end();

 
 typedef std::vector<TypeSystemInstance> TypeSystemInstances;
 
-static Mutex &
-GetTypeSystemMutex ()
+static std::recursive_mutex &
+GetTypeSystemMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.enumerate_callback = enumerate_supported_languages_callback;
-        Mutex::Locker locker (GetTypeSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
         GetTypeSystemInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetTypeSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
         TypeSystemInstances &instances = GetTypeSystemInstances ();
 
         TypeSystemInstances::iterator pos, end = instances.end();

 TypeSystemCreateInstance
 PluginManager::GetTypeSystemCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetTypeSystemMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
     TypeSystemInstances &instances = GetTypeSystemInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetTypeSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
         TypeSystemInstances &instances = GetTypeSystemInstances ();
 
         TypeSystemInstances::iterator pos, end = instances.end();

 TypeSystemEnumerateSupportedLanguages
 PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetTypeSystemMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
     TypeSystemInstances &instances = GetTypeSystemInstances ();
     if (idx < instances.size())
         return instances[idx].enumerate_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetTypeSystemMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
         TypeSystemInstances &instances = GetTypeSystemInstances ();
         
         TypeSystemInstances::iterator pos, end = instances.end();

 
 typedef std::vector<REPLInstance> REPLInstances;
 
-static Mutex &
-GetREPLMutex ()
+static std::recursive_mutex &
+GetREPLMutex()
 {
-    static Mutex g_instances_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_instances_mutex;
     return g_instances_mutex;
 }
 

             instance.description = description;
         instance.create_callback = create_callback;
         instance.enumerate_languages_callback = enumerate_languages_callback;
-        Mutex::Locker locker (GetREPLMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
         GetREPLInstances ().push_back (instance);
     }
     return false;

 {
     if (create_callback)
     {
-        Mutex::Locker locker (GetREPLMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
         REPLInstances &instances = GetREPLInstances ();
         
         REPLInstances::iterator pos, end = instances.end();

 REPLCreateInstance
 PluginManager::GetREPLCreateCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetREPLMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
     REPLInstances &instances = GetREPLInstances ();
     if (idx < instances.size())
         return instances[idx].create_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetREPLMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
         REPLInstances &instances = GetREPLInstances ();
         
         REPLInstances::iterator pos, end = instances.end();

 REPLEnumerateSupportedLanguages
 PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (GetREPLMutex ());
+    std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
     REPLInstances &instances = GetREPLInstances ();
     if (idx < instances.size())
         return instances[idx].enumerate_languages_callback;

 {
     if (name)
     {
-        Mutex::Locker locker (GetREPLMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
         REPLInstances &instances = GetREPLInstances ();
         
         REPLInstances::iterator pos, end = instances.end();

 {
     // Initialize the DynamicLoader plugins
     {
-        Mutex::Locker locker (GetDynamicLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
         DynamicLoaderInstances &instances = GetDynamicLoaderInstances ();
     
         DynamicLoaderInstances::iterator pos, end = instances.end();

 
     // Initialize the JITLoader plugins
     {
-        Mutex::Locker locker (GetJITLoaderMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
         JITLoaderInstances &instances = GetJITLoaderInstances ();
     
         JITLoaderInstances::iterator pos, end = instances.end();

 
     // Initialize the Platform plugins
     {
-        Mutex::Locker locker (GetPlatformInstancesMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
         PlatformInstances &instances = GetPlatformInstances ();
     
         PlatformInstances::iterator pos, end = instances.end();

 
     // Initialize the Process plugins
     {
-        Mutex::Locker locker (GetProcessMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
         ProcessInstances &instances = GetProcessInstances();
         
         ProcessInstances::iterator pos, end = instances.end();

 
     // Initialize the SymbolFile plugins
     {
-        Mutex::Locker locker (GetSymbolFileMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
         for (auto& sym_file: GetSymbolFileInstances())
         {
             if (sym_file.debugger_init_callback)

 
     // Initialize the OperatingSystem plugins
     {
-        Mutex::Locker locker(GetOperatingSystemMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
         for (auto &os : GetOperatingSystemInstances())
         {
             if (os.debugger_init_callback)

source/Core/StreamCallback.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-
-StreamCallback::StreamCallback (lldb::LogOutputCallback callback, void *baton) :
-    Stream (0, 4, eByteOrderBig),
-    m_callback (callback),
-    m_baton (baton),
-    m_accumulated_data (),
-    m_collection_mutex ()
+StreamCallback::StreamCallback(lldb::LogOutputCallback callback, void *baton)
+    : Stream(0, 4, eByteOrderBig), m_callback(callback), m_baton(baton), m_accumulated_data(), m_collection_mutex()
 {
 }
 

 StreamString &
 StreamCallback::FindStreamForThread(lldb::tid_t cur_tid)
 {
-    Mutex::Locker locker(m_collection_mutex);
+    std::lock_guard<std::mutex> guard(m_collection_mutex);
     collection::iterator iter = m_accumulated_data.find (cur_tid);
     if (iter == m_accumulated_data.end())
     {

source/Core/Timer.cpp

 #include "lldb/Core/Timer.h"
 
 #include <map>
+#include <mutex>
 #include <vector>
 #include <algorithm>
 
 #include "lldb/Core/Stream.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/Host.h"
 
 #include <stdio.h>

     return *g_file_mutex_ptr;
 }
 
-
-static Mutex &
+static std::mutex &
 GetCategoryMutex()
 {
-    static Mutex g_category_mutex(Mutex::eMutexTypeNormal);
+    static std::mutex g_category_mutex;
     return g_category_mutex;
 }
 

         }
 
         // Keep total results for each category so we can dump results.
-        Mutex::Locker locker (GetCategoryMutex());
+        std::lock_guard<std::mutex> guard(GetCategoryMutex());
         TimerCategoryMap &category_map = GetCategoryMap();
         category_map[m_category] += timer_nsec_uint;
     }

 void
 Timer::ResetCategoryTimes ()
 {
-    Mutex::Locker locker (GetCategoryMutex());
+    std::lock_guard<std::mutex> guard(GetCategoryMutex());
     TimerCategoryMap &category_map = GetCategoryMap();
     category_map.clear();
 }

 void
 Timer::DumpCategoryTimes (Stream *s)
 {
-    Mutex::Locker locker (GetCategoryMutex());
+    std::lock_guard<std::mutex> guard(GetCategoryMutex());
     TimerCategoryMap &category_map = GetCategoryMap();
     std::vector<TimerCategoryMap::const_iterator> sorted_iterators;
     TimerCategoryMap::const_iterator pos, end = category_map.end();

source/DataFormatters/FormatCache.cpp

     m_validator_sp = validator_sp;
 }
 
-FormatCache::FormatCache () :
-m_map(),
-m_mutex (Mutex::eMutexTypeRecursive)
+FormatCache::FormatCache()
+    : m_map(),
+      m_mutex()
 #ifdef LLDB_CONFIGURATION_DEBUG
-,m_cache_hits(0),m_cache_misses(0)
+      ,
+      m_cache_hits(0),
+      m_cache_misses(0)
 #endif
 {
 }

 bool
 FormatCache::GetFormat (const ConstString& type,lldb::TypeFormatImplSP& format_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     auto entry = GetEntry(type);
     if (entry.IsFormatCached())
     {

 bool
 FormatCache::GetSummary (const ConstString& type,lldb::TypeSummaryImplSP& summary_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     auto entry = GetEntry(type);
     if (entry.IsSummaryCached())
     {

 bool
 FormatCache::GetSynthetic (const ConstString& type,lldb::SyntheticChildrenSP& synthetic_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     auto entry = GetEntry(type);
     if (entry.IsSyntheticCached())
     {

 bool
 FormatCache::GetValidator (const ConstString& type,lldb::TypeValidatorImplSP& validator_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     auto entry = GetEntry(type);
     if (entry.IsValidatorCached())
     {

 void
 FormatCache::SetFormat (const ConstString& type,lldb::TypeFormatImplSP& format_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     GetEntry(type).SetFormat(format_sp);
 }
 
 void
 FormatCache::SetSummary (const ConstString& type,lldb::TypeSummaryImplSP& summary_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     GetEntry(type).SetSummary(summary_sp);
 }
 
 void
 FormatCache::SetSynthetic (const ConstString& type,lldb::SyntheticChildrenSP& synthetic_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     GetEntry(type).SetSynthetic(synthetic_sp);
 }
 
 void
 FormatCache::SetValidator (const ConstString& type,lldb::TypeValidatorImplSP& validator_sp)
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     GetEntry(type).SetValidator(validator_sp);
 }
 
 void
 FormatCache::Clear ()
 {
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_map.clear();
 }
 

source/DataFormatters/FormatManager.cpp

 {
     ++m_last_revision;
     m_format_cache.Clear ();
-    Mutex::Locker lang_locker(m_language_categories_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
     for (auto& iter : m_language_categories_map)
     {
         if (iter.second)

 FormatManager::EnableAllCategories ()
 {
     m_categories_map.EnableAllCategories ();
-    Mutex::Locker lang_locker(m_language_categories_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
     for (auto& iter : m_language_categories_map)
     {
         if (iter.second)

 FormatManager::DisableAllCategories ()
 {
     m_categories_map.DisableAllCategories ();
-    Mutex::Locker lang_locker(m_language_categories_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
     for (auto& iter : m_language_categories_map)
     {
         if (iter.second)

 FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback)
 {
     m_categories_map.ForEach(callback);
-    Mutex::Locker locker(m_language_categories_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
     for (const auto& entry : m_language_categories_map)
     {
         if (auto category_sp = entry.second->GetCategory())

 LanguageCategory*
 FormatManager::GetCategoryForLanguage (lldb::LanguageType lang_type)
 {
-    Mutex::Locker locker(m_language_categories_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
     auto iter = m_language_categories_map.find(lang_type), end = m_language_categories_map.end();
     if (iter != end)
         return iter->second.get();

     return retval_sp;
 }
 
-FormatManager::FormatManager() :
-    m_last_revision(0),
+FormatManager::FormatManager()
+    : m_last_revision(0),
       m_format_cache(),
-    m_language_categories_mutex(Mutex::eMutexTypeRecursive),
+      m_language_categories_mutex(),
       m_language_categories_map(),
       m_named_summaries_map(this),
       m_categories_map(this),
       m_default_category_name(ConstString("default")),
-    m_system_category_name(ConstString("system")), 
+      m_system_category_name(ConstString("system")),
       m_vectortypes_category_name(ConstString("VectorTypes"))
 {
     LoadSystemFormatters();
     LoadVectorFormatters();
-    
-    EnableCategory(m_vectortypes_category_name,TypeCategoryMap::Last, lldb::eLanguageTypeObjC_plus_plus);
-    EnableCategory(m_system_category_name,TypeCategoryMap::Last, lldb::eLanguageTypeObjC_plus_plus);
+    EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last, lldb::eLanguageTypeObjC_plus_plus);
+    EnableCategory(m_system_category_name, TypeCategoryMap::Last, lldb::eLanguageTypeObjC_plus_plus);
 }
 
 void

source/DataFormatters/TypeCategory.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener* clist,
-                                   ConstString name,
-                                   std::initializer_list<lldb::LanguageType> langs) :
-m_format_cont("format","regex-format",clist),
-m_summary_cont("summary","regex-summary",clist),
-m_filter_cont("filter","regex-filter",clist),
+TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener *clist, ConstString name,
+                                   std::initializer_list<lldb::LanguageType> langs)
+    : m_format_cont("format", "regex-format", clist),
+      m_summary_cont("summary", "regex-summary", clist),
+      m_filter_cont("filter", "regex-filter", clist),
 #ifndef LLDB_DISABLE_PYTHON
-m_synth_cont("synth","regex-synth",clist),
+      m_synth_cont("synth", "regex-synth", clist),
 #endif
-m_validator_cont("validator","regex-validator",clist),
+      m_validator_cont("validator", "regex-validator", clist),
       m_enabled(false),
       m_change_listener(clist),
-m_mutex(Mutex::eMutexTypeRecursive),
+      m_mutex(),
       m_name(name),
       m_languages()
 {
     for (const lldb::LanguageType lang : langs)
         AddLanguage(lang);

 void
 TypeCategoryImpl::Enable (bool value, uint32_t position)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if ( (m_enabled = value) )
         m_enabled_position = position;
     if (m_change_listener)

source/DataFormatters/TypeCategoryMap.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-TypeCategoryMap::TypeCategoryMap (IFormatChangeListener* lst) :
-m_map_mutex(Mutex::eMutexTypeRecursive),
-listener(lst),
-m_map(),
-m_active_categories()
+TypeCategoryMap::TypeCategoryMap(IFormatChangeListener *lst)
+    : m_map_mutex(), listener(lst), m_map(), m_active_categories()
 {
     ConstString default_cs("default");
     lldb::TypeCategoryImplSP default_sp = lldb::TypeCategoryImplSP(new TypeCategoryImpl(listener, default_cs));
-    Add(default_cs,default_sp);
-    Enable(default_cs,First);
+    Add(default_cs, default_sp);
+    Enable(default_cs, First);
 }
 
 void
 TypeCategoryMap::Add (KeyType name, const ValueSP& entry)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     m_map[name] = entry;
     if (listener)
         listener->Changed();

 bool
 TypeCategoryMap::Delete (KeyType name)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator iter = m_map.find(name);
     if (iter == m_map.end())
         return false;

 bool
 TypeCategoryMap::Enable (KeyType category_name, Position pos)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     ValueSP category;
     if (!Get(category_name,category))
         return false;

 bool
 TypeCategoryMap::Disable (KeyType category_name)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     ValueSP category;
     if (!Get(category_name,category))
         return false;

 bool
 TypeCategoryMap::Enable (ValueSP category, Position pos)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     if (category.get())
     {
         Position pos_w = pos;

 bool
 TypeCategoryMap::Disable (ValueSP category)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     if (category.get())
     {
         m_active_categories.remove_if(delete_matching_categories(category));

 void
 TypeCategoryMap::EnableAllCategories ()
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     std::vector<ValueSP> sorted_categories(m_map.size(), ValueSP());
     MapType::iterator iter = m_map.begin(), end = m_map.end();
     for (; iter != end; ++iter)

 void
 TypeCategoryMap::DisableAllCategories ()
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     Position p = First;
     for (; false == m_active_categories.empty(); p++)
     {

 void
 TypeCategoryMap::Clear ()
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     m_map.clear();
     m_active_categories.clear();
     if (listener)

 bool
 TypeCategoryMap::Get (KeyType name, ValueSP& entry)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator iter = m_map.find(name);
     if (iter == m_map.end())
         return false;

 bool
 TypeCategoryMap::Get (uint32_t pos, ValueSP& entry)
 {
-    Mutex::Locker locker(m_map_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator iter = m_map.begin();
     MapIterator end = m_map.end();
     while (pos > 0)

                              const char** matching_category,
                              TypeCategoryImpl::FormatCategoryItems* matching_type)
 {
-    Mutex::Locker locker(m_map_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     MapIterator pos, end = m_map.end();
     for (pos = m_map.begin(); pos != end; pos++)
     {

 lldb::TypeFormatImplSP
 TypeCategoryMap::GetFormat (FormattersMatchData& match_data)
 {
-    Mutex::Locker locker(m_map_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     uint32_t reason_why;
     ActiveCategoriesIterator begin, end = m_active_categories.end();
     

 lldb::TypeSummaryImplSP
 TypeCategoryMap::GetSummaryFormat (FormattersMatchData& match_data)
 {
-    Mutex::Locker locker(m_map_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     uint32_t reason_why;
     ActiveCategoriesIterator begin, end = m_active_categories.end();
     

 lldb::SyntheticChildrenSP
 TypeCategoryMap::GetSyntheticChildren (FormattersMatchData& match_data)
 {
-    Mutex::Locker locker(m_map_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     uint32_t reason_why;
     
     ActiveCategoriesIterator begin, end = m_active_categories.end();

 lldb::TypeValidatorImplSP
 TypeCategoryMap::GetValidator (FormattersMatchData& match_data)
 {
-    Mutex::Locker locker(m_map_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     uint32_t reason_why;
     ActiveCategoriesIterator begin, end = m_active_categories.end();
     

 {
     if (callback)
     {
-        Mutex::Locker locker(m_map_mutex);
-        
+        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
         // loop through enabled categories in respective order
         {
             ActiveCategoriesIterator begin, end = m_active_categories.end();

 TypeCategoryImplSP
 TypeCategoryMap::GetAtIndex (uint32_t index)
 {
-    Mutex::Locker locker(m_map_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     if (index < m_map.size())
     {
         MapIterator pos, end = m_map.end();

source/Expression/IRExecutionUnit.cpp

 {
     lldb::ProcessSP process_sp(GetProcessWP().lock());
 
-    static Mutex s_runnable_info_mutex(Mutex::Type::eMutexTypeRecursive);
+    static std::recursive_mutex s_runnable_info_mutex;
 
     func_addr = LLDB_INVALID_ADDRESS;
     func_end = LLDB_INVALID_ADDRESS;

         return;
     };
 
-    Mutex::Locker runnable_info_mutex_locker(s_runnable_info_mutex);
+    std::lock_guard<std::recursive_mutex> guard(s_runnable_info_mutex);
 
     m_did_jit = true;
 

source/Host/common/Editline.cpp

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Utility/LLDBAssert.h"
 
 using namespace lldb_private;

             GetHistory (const std::string &prefix)
             {
                 typedef std::map<std::string, EditlineHistoryWP> WeakHistoryMap;
-                static Mutex g_mutex (Mutex::eMutexTypeRecursive);
+                static std::recursive_mutex g_mutex;
                 static WeakHistoryMap g_weak_map;
-                Mutex::Locker locker (g_mutex);
+                std::lock_guard<std::recursive_mutex> guard(g_mutex);
                 WeakHistoryMap::const_iterator pos = g_weak_map.find (prefix);
                 EditlineHistorySP history_sp;
                 if (pos != g_weak_map.end())

         // (blocking operation), so we do not hold the mutex indefinitely. This gives a chance
         // for someone to interrupt us. After Read returns, immediately lock the mutex again and
         // check if we were interrupted.
-        m_output_mutex.Unlock();
+        m_output_mutex.unlock();
         int read_count = m_input_connection.Read(&ch, 1, UINT32_MAX, status, NULL);
-        m_output_mutex.Lock();
+        m_output_mutex.lock();
         if (m_editor_status == EditorStatus::Interrupted)
         {
             while (read_count > 0 && status == lldb::eConnectionStatusSuccess)

 Editline::Interrupt()
 {
     bool result = true;
-    Mutex::Locker locker(m_output_mutex);
+    std::lock_guard<std::mutex> guard(m_output_mutex);
     if (m_editor_status == EditorStatus::Editing) {
         fprintf(m_output_file, "^C\n");
         result = m_input_connection.InterruptRead();

 Editline::Cancel()
 {
     bool result = true;
-    Mutex::Locker locker(m_output_mutex);
+    std::lock_guard<std::mutex> guard(m_output_mutex);
     if (m_editor_status == EditorStatus::Editing) {
         MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockStart);
         fprintf(m_output_file, ANSI_CLEAR_BELOW);

     ConfigureEditor (false);
     m_input_lines = std::vector<EditLineStringType>();
     m_input_lines.insert (m_input_lines.begin(), EditLineConstString(""));
-    
-    Mutex::Locker locker(m_output_mutex);
+    std::lock_guard<std::mutex> guard(m_output_mutex);
 
     lldbassert(m_editor_status != EditorStatus::Editing);
     if (m_editor_status == EditorStatus::Interrupted)

     SetBaseLineNumber (first_line_number);
     m_input_lines = std::vector<EditLineStringType>();
     m_input_lines.insert (m_input_lines.begin(), EditLineConstString(""));
-    
-    Mutex::Locker locker(m_output_mutex);
+    std::lock_guard<std::mutex> guard(m_output_mutex);
     // Begin the line editing loop
     DisplayInput();
     SetCurrentLine (0);

 void
 Editline::PrintAsync (Stream *stream, const char *s, size_t len)
 {
-    Mutex::Locker locker(m_output_mutex);
+    std::lock_guard<std::mutex> guard(m_output_mutex);
     if (m_editor_status == EditorStatus::Editing)
     {
         MoveCursor(CursorLocation::EditingCursor, CursorLocation::BlockStart);

source/Host/common/NativeBreakpointList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-NativeBreakpointList::NativeBreakpointList () :
-    m_mutex (Mutex::eMutexTypeRecursive)
+NativeBreakpointList::NativeBreakpointList() : m_mutex()
 {
 }
 

     if (log)
         log->Printf ("NativeBreakpointList::%s addr = 0x%" PRIx64 ", size_hint = %lu, hardware = %s", __FUNCTION__, addr, size_hint, hardware ? "true" : "false");
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Check if the breakpoint is already set.
     auto iter = m_breakpoints.find (addr);

     if (log)
         log->Printf ("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Check if the breakpoint is already set.
     auto iter = m_breakpoints.find (addr);

     if (log)
         log->Printf ("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Ensure we have said breakpoint.
     auto iter = m_breakpoints.find (addr);

     if (log)
         log->Printf ("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Ensure we have said breakpoint.
     auto iter = m_breakpoints.find (addr);

     if (log)
         log->Printf ("NativeBreakpointList::%s addr = 0x%" PRIx64, __FUNCTION__, addr);
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Ensure we have said breakpoint.
     auto iter = m_breakpoints.find (addr);

source/Host/common/NativeProcessProtocol.cpp

 // NativeProcessProtocol Members
 // -----------------------------------------------------------------------------
 
-NativeProcessProtocol::NativeProcessProtocol (lldb::pid_t pid) :
-    m_pid (pid),
-    m_threads (),
-    m_current_thread_id (LLDB_INVALID_THREAD_ID),
-    m_threads_mutex (Mutex::eMutexTypeRecursive),
-    m_state (lldb::eStateInvalid),
-    m_state_mutex (Mutex::eMutexTypeRecursive),
-    m_exit_type (eExitTypeInvalid),
-    m_exit_status (0),
-    m_exit_description (),
-    m_delegates_mutex (Mutex::eMutexTypeRecursive),
-    m_delegates (),
-    m_breakpoint_list (),
-    m_watchpoint_list (),
-    m_terminal_fd (-1),
-    m_stop_id (0)
+NativeProcessProtocol::NativeProcessProtocol(lldb::pid_t pid)
+    : m_pid(pid),
+      m_threads(),
+      m_current_thread_id(LLDB_INVALID_THREAD_ID),
+      m_threads_mutex(),
+      m_state(lldb::eStateInvalid),
+      m_state_mutex(),
+      m_exit_type(eExitTypeInvalid),
+      m_exit_status(0),
+      m_exit_description(),
+      m_delegates_mutex(),
+      m_delegates(),
+      m_breakpoint_list(),
+      m_watchpoint_list(),
+      m_terminal_fd(-1),
+      m_stop_id(0)
 {
 }
 

 NativeThreadProtocolSP
 NativeProcessProtocol::GetThreadAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (m_threads_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
     if (idx < m_threads.size ())
         return m_threads[idx];
     return NativeThreadProtocolSP ();

 NativeThreadProtocolSP
 NativeProcessProtocol::GetThreadByID (lldb::tid_t tid)
 {
-    Mutex::Locker locker (m_threads_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
     return GetThreadByIDUnlocked (tid);
 }
 

     // conceivable that if there are more threads than hardware
     // watchpoints available, some of the threads will fail to set
     // hardware watchpoints while software ones may be available.
-    Mutex::Locker locker (m_threads_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
     for (auto thread_sp : m_threads)
     {
         assert (thread_sp && "thread list should not have a NULL thread!");

 
     Error overall_error;
 
-    Mutex::Locker locker (m_threads_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
     for (auto thread_sp : m_threads)
     {
         assert (thread_sp && "thread list should not have a NULL thread!");

 bool
 NativeProcessProtocol::RegisterNativeDelegate (NativeDelegate &native_delegate)
 {
-    Mutex::Locker locker (m_delegates_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
     if (std::find (m_delegates.begin (), m_delegates.end (), &native_delegate) != m_delegates.end ())
         return false;
 

 bool
 NativeProcessProtocol::UnregisterNativeDelegate (NativeDelegate &native_delegate)
 {
-    Mutex::Locker locker (m_delegates_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
 
     const auto initial_size = m_delegates.size ();
     m_delegates.erase (remove (m_delegates.begin (), m_delegates.end (), &native_delegate), m_delegates.end ());

 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
-    Mutex::Locker locker (m_delegates_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
     for (auto native_delegate: m_delegates)
         native_delegate->ProcessStateChanged (this, state);
 

         log->Printf ("NativeProcessProtocol::%s - preparing to call delegates", __FUNCTION__);
 
     {
-        Mutex::Locker locker (m_delegates_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
         for (auto native_delegate: m_delegates)
             native_delegate->DidExec (this);
     }

 lldb::StateType
 NativeProcessProtocol::GetState () const
 {
-    Mutex::Locker locker (m_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
     return m_state;
 }
 
 void
 NativeProcessProtocol::SetState (lldb::StateType state, bool notify_delegates)
 {
-    Mutex::Locker locker (m_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
 
     if (state == m_state)
         return;

 
 uint32_t NativeProcessProtocol::GetStopID () const
 {
-   Mutex::Locker locker (m_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
     return m_stop_id;
 }
 
 void

source/Host/common/SoftwareBreakpoint.cpp

 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Host/Debug.h"
-#include "lldb/Host/Mutex.h"
 
 #include "lldb/Host/common/NativeProcessProtocol.h"
 

source/Host/macosx/Host.mm

 // On MacOSX CrashReporter will display a string for each shared library if
 // the shared library has an exported symbol named "__crashreporter_info__".
 
-static Mutex&
-GetCrashReporterMutex ()
+static std::mutex &
+GetCrashReporterMutex()
 {
-    static Mutex g_mutex;
+    static std::mutex g_mutex;
     return g_mutex;
 }
 

 Host::SetCrashDescriptionWithFormat (const char *format, ...)
 {
     static StreamString g_crash_description;
-    Mutex::Locker locker (GetCrashReporterMutex ());
-    
+    std::lock_guard<std::mutex> guard(GetCrashReporterMutex());
     if (format)
     {
         va_list args;

 void
 Host::SetCrashDescription (const char *cstr)
 {
-    Mutex::Locker locker (GetCrashReporterMutex ());
+    std::lock_guard<std::mutex> guard(GetCrashReporterMutex());
     static std::string g_crash_description;
     if (cstr)
     {

source/Host/posix/ConnectionFileDescriptorPosix.cpp

 }
 
 ConnectionFileDescriptor::ConnectionFileDescriptor(bool child_processes_inherit)
-    : Connection()
-    , m_pipe()
-    , m_mutex(Mutex::eMutexTypeRecursive)
-    , m_shutting_down(false)
-    , m_waiting_for_accept(false)
-    , m_child_processes_inherit(child_processes_inherit)
+    : Connection(),
+      m_pipe(),
+      m_mutex(),
+      m_shutting_down(false),
+      m_waiting_for_accept(false),
+      m_child_processes_inherit(child_processes_inherit)
 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
     if (log)

 }
 
 ConnectionFileDescriptor::ConnectionFileDescriptor(int fd, bool owns_fd)
-    : Connection()
-    , m_pipe()
-    , m_mutex(Mutex::eMutexTypeRecursive)
-    , m_shutting_down(false)
-    , m_waiting_for_accept(false)
-    , m_child_processes_inherit(false)
+    : Connection(),
+      m_pipe(),
+      m_mutex(),
+      m_shutting_down(false),
+      m_waiting_for_accept(false),
+      m_child_processes_inherit(false)
 {
     m_write_sp.reset(new File(fd, owns_fd));
     m_read_sp.reset(new File(fd, false));
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION | LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = %i, owns_fd = %i)", static_cast<void *>(this), fd,
-                    owns_fd);
+        log->Printf("%p ConnectionFileDescriptor::ConnectionFileDescriptor (fd = %i, owns_fd = %i)",
+                    static_cast<void *>(this), fd, owns_fd);
     OpenCommandPipe();
 }
 
-ConnectionFileDescriptor::ConnectionFileDescriptor(Socket* socket)
-    : Connection()
-    , m_pipe()
-    , m_mutex(Mutex::eMutexTypeRecursive)
-    , m_shutting_down(false)
-    , m_waiting_for_accept(false)
-    , m_child_processes_inherit(false)
+ConnectionFileDescriptor::ConnectionFileDescriptor(Socket *socket)
+    : Connection(),
+      m_pipe(),
+      m_mutex(),
+      m_shutting_down(false),
+      m_waiting_for_accept(false),
+      m_child_processes_inherit(false)
 {
     InitializeSocket(socket);
 }

 ConnectionStatus
 ConnectionFileDescriptor::Connect(const char *s, Error *error_ptr)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
     if (log)
         log->Printf("%p ConnectionFileDescriptor::Connect (url = '%s')", static_cast<void *>(this), s);

 
     m_shutting_down = true;
 
-    Mutex::Locker locker;
-    bool got_lock = locker.TryLock(m_mutex);
-
-    if (!got_lock)
+    std::unique_lock<std::recursive_mutex> locker(m_mutex, std::defer_lock);
+    if (!locker.try_lock())
     {
         if (m_pipe.CanWrite())
         {

             log->Printf("%p ConnectionFileDescriptor::Disconnect(): Couldn't get the lock, but no command pipe is available.",
                         static_cast<void *>(this));
         }
-        locker.Lock(m_mutex);
+        locker.lock();
     }
 
     Error error = m_read_sp->Close();

 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_CONNECTION));
 
-    Mutex::Locker locker;
-    bool got_lock = locker.TryLock(m_mutex);
-    if (!got_lock)
+    std::unique_lock<std::recursive_mutex> locker(m_mutex, std::defer_lock);
+    if (!locker.try_lock())
     {
         if (log)
             log->Printf("%p ConnectionFileDescriptor::Read () failed to get the connection lock.", static_cast<void *>(this));

source/Initialization/SystemLifetimeManager.cpp

 #include "lldb/Initialization/SystemLifetimeManager.h"
 
 #include "lldb/Core/Debugger.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Initialization/SystemInitializer.h"
 
 #include <utility>
 
 using namespace lldb_private;
 
-SystemLifetimeManager::SystemLifetimeManager()
-    : m_mutex(Mutex::eMutexTypeRecursive)
-    , m_initialized(false)
+SystemLifetimeManager::SystemLifetimeManager() : m_mutex(), m_initialized(false)
 {
 }
 

 SystemLifetimeManager::Initialize(std::unique_ptr<SystemInitializer> initializer,
                                   LoadPluginCallbackType plugin_callback)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_initialized)
     {
         assert(!m_initializer &&

 void
 SystemLifetimeManager::Terminate()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (m_initialized)
     {

source/Interpreter/CommandHistory.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-
-CommandHistory::CommandHistory () :
-    m_mutex(Mutex::eMutexTypeRecursive),
-    m_history()
+CommandHistory::CommandHistory() : m_mutex(), m_history()
 {}
 
 CommandHistory::~CommandHistory ()

 size_t
 CommandHistory::GetSize () const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_history.size();
 }
 
 bool
 CommandHistory::IsEmpty () const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_history.empty();
 }
 
 const char*
 CommandHistory::FindString (const char* input_str) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!input_str)
         return nullptr;
     if (input_str[0] != g_repeat_char)

 const char*
 CommandHistory::GetStringAtIndex (size_t idx) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (idx < m_history.size())
         return m_history[idx].c_str();
     return nullptr;

 const char*
 CommandHistory::GetRecentmostString () const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_history.empty())
         return nullptr;
     return m_history.back().c_str();

 CommandHistory::AppendString (const std::string& str,
                               bool reject_if_dupe)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (reject_if_dupe)
     {
         if (!m_history.empty())

 void
 CommandHistory::Clear ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_history.clear();
 }
 

                       size_t start_idx,
                       size_t stop_idx) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     stop_idx = std::min(stop_idx + 1, m_history.size());
     for (size_t counter = start_idx;
          counter < stop_idx;

source/Plugins/Disassembler/llvm/DisassemblerLLVMC.h

 // C Includes
 // C++ Includes
 #include <memory>
+#include <mutex>
 #include <string>
 
 // Other libraries and framework includes

 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/PluginManager.h"
-#include "lldb/Host/Mutex.h"
 
 // Opaque references to C++ Objects in LLVM's MC.
 namespace llvm

     void Lock(InstructionLLVMC *inst,
               const lldb_private::ExecutionContext *exe_ctx)
     {
-        m_mutex.Lock();
+        m_mutex.lock();
         m_inst = inst;
         m_exe_ctx = exe_ctx;
     }

     {
         m_inst = NULL;
         m_exe_ctx = NULL;
-        m_mutex.Unlock();
+        m_mutex.unlock();
     }
 
     const lldb_private::ExecutionContext *m_exe_ctx;
     InstructionLLVMC *m_inst;
-    lldb_private::Mutex m_mutex;
+    std::mutex m_mutex;
     bool m_data_from_file;
 
     std::unique_ptr<LLVMCDisassembler> m_disasm_ap;

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <vector>
 #include <string>
 

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Core/UUID.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 class DynamicLoaderDarwinKernel : public lldb_private::DynamicLoader

     lldb_private::Address          m_kext_summary_header_addr;
     OSKextLoadedKextSummaryHeader  m_kext_summary_header;
     KextImageInfo::collection      m_known_kexts;
-    mutable lldb_private::Mutex    m_mutex;
+    mutable std::recursive_mutex   m_mutex;
     lldb::user_id_t                m_break_id;
 
 private:

source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
-DynamicLoaderDarwinKernel::DynamicLoaderDarwinKernel (Process* process, lldb::addr_t kernel_addr) :
-    DynamicLoader(process),
-    m_kernel_load_address (kernel_addr),
+DynamicLoaderDarwinKernel::DynamicLoaderDarwinKernel(Process *process, lldb::addr_t kernel_addr)
+    : DynamicLoader(process),
+      m_kernel_load_address(kernel_addr),
       m_kernel(),
-    m_kext_summary_header_ptr_addr (),
-    m_kext_summary_header_addr (),
-    m_kext_summary_header (),
-    m_known_kexts (),
-    m_mutex(Mutex::eMutexTypeRecursive),
-    m_break_id (LLDB_INVALID_BREAK_ID)
+      m_kext_summary_header_ptr_addr(),
+      m_kext_summary_header_addr(),
+      m_kext_summary_header(),
+      m_known_kexts(),
+      m_mutex(),
+      m_break_id(LLDB_INVALID_BREAK_ID)
 {
     Error error;
     PlatformSP platform_sp(Platform::Create(PlatformDarwinKernel::GetPluginNameStatic(), error));

     // shouldn't be done if kext loading is explicitly disabled.
     if (platform_sp.get() && GetGlobalProperties()->GetLoadKexts())
     {
-        process->GetTarget().SetPlatform (platform_sp);
+        process->GetTarget().SetPlatform(platform_sp);
     }
 }
 

 void
 DynamicLoaderDarwinKernel::Clear (bool clear_process)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (m_process->IsAlive() && LLDB_BREAK_ID_IS_VALID(m_break_id))
         m_process->ClearBreakpointSiteByID(m_break_id);

 bool
 DynamicLoaderDarwinKernel::ReadKextSummaryHeader ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // the all image infos is already valid for this process stop ID
 

     Log *log(GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER));
     if (log)
         log->Printf ("Kexts-changed breakpoint hit, there are %d kexts currently.\n", count);
-        
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (!ReadKextSummaries (kext_summary_addr, count, kext_summaries))
         return false;

 bool
 DynamicLoaderDarwinKernel::ReadAllKextSummaries ()
 {
-    Mutex::Locker locker(m_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (ReadKextSummaryHeader ())
     {
         if (m_kext_summary_header.entry_count > 0 && m_kext_summary_header_addr.IsValid())

     if (log == NULL)
         return;
 
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     log->Printf("gLoadedKextSummaries = 0x%16.16" PRIx64 " { version=%u, entry_size=%u, entry_count=%u }",
                 m_kext_summary_header_addr.GetFileAddress(),
                 m_kext_summary_header.version,

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes

 #include "lldb/Host/FileSpec.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UUID.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/SafeMachO.h"
 

     lldb::user_id_t m_break_id;
     DYLDImageInfo::collection m_dyld_image_infos;   // Current shared libraries information
     uint32_t m_dyld_image_infos_stop_id;    // The process stop ID that "m_dyld_image_infos" is valid for
-    mutable lldb_private::Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
     lldb_private::Process::Notifications m_notification_callbacks;
     bool m_process_image_addr_is_all_images_infos;
 

source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.cpp

 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
-DynamicLoaderMacOSXDYLD::DynamicLoaderMacOSXDYLD (Process* process) :
-    DynamicLoader(process),
+DynamicLoaderMacOSXDYLD::DynamicLoaderMacOSXDYLD(Process *process)
+    : DynamicLoader(process),
       m_dyld(),
       m_dyld_module_wp(),
       m_dyld_all_image_infos_addr(LLDB_INVALID_ADDRESS),
       m_dyld_all_image_infos(),
-    m_dyld_all_image_infos_stop_id (UINT32_MAX),
+      m_dyld_all_image_infos_stop_id(UINT32_MAX),
       m_break_id(LLDB_INVALID_BREAK_ID),
       m_dyld_image_infos(),
-    m_dyld_image_infos_stop_id (UINT32_MAX),
-    m_mutex(Mutex::eMutexTypeRecursive),
-    m_process_image_addr_is_all_images_infos (false)
+      m_dyld_image_infos_stop_id(UINT32_MAX),
+      m_mutex(),
+      m_process_image_addr_is_all_images_infos(false)
 {
 }
 

 void
 DynamicLoaderMacOSXDYLD::Clear (bool clear_process)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (LLDB_BREAK_ID_IS_VALID(m_break_id))
         m_process->GetTarget().RemoveBreakpointByID (m_break_id);

 bool
 DynamicLoaderMacOSXDYLD::ReadAllImageInfosStructure ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // the all image infos is already valid for this process stop ID
     if (m_process->GetStopID() == m_dyld_all_image_infos_stop_id)

     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER));
     if (log)
         log->Printf ("Adding %d modules.\n", image_infos_count);
-        
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_process->GetStopID() == m_dyld_image_infos_stop_id)
         return true;
 

 {
     DYLDImageInfo::collection image_infos;
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER));
-    
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_process->GetStopID() == m_dyld_image_infos_stop_id)
         return true;
 

 DynamicLoaderMacOSXDYLD::InitializeFromAllImageInfos ()
 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_DYNAMIC_LOADER));
-    
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_process->GetStopID() == m_dyld_image_infos_stop_id
           || m_dyld_image_infos.size() != 0)
         return false;

     if (log == NULL)
         return;
 
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     log->Printf("dyld_all_image_infos = { version=%d, count=%d, addr=0x%8.8" PRIx64 ", notify=0x%8.8" PRIx64 " }",
                     m_dyld_all_image_infos.version,
                     m_dyld_all_image_infos.dylib_info_count,

source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.h

 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Core/UUID.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 class DynamicLoaderStatic : public lldb_private::DynamicLoader

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "AppleObjCRuntimeV2.h"
 

     private:
         bool m_filled;
         std::vector<iVarDescriptor> m_ivars;
-        Mutex m_mutex;
+        std::recursive_mutex m_mutex;
     };
     
     // The constructor should only be invoked by the runtime as it builds its caches

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

     return 0;
 }
 
-ClassDescriptorV2::iVarsStorage::iVarsStorage ():
-m_filled(false),
-m_ivars(),
-m_mutex(Mutex::eMutexTypeRecursive)
-{}
+ClassDescriptorV2::iVarsStorage::iVarsStorage() : m_filled(false), m_ivars(), m_mutex()
+{
+}
 
 size_t
 ClassDescriptorV2::iVarsStorage::size ()

 {
     if (m_filled)
         return;
-    Mutex::Locker lock(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_TYPES | LIBLLDB_LOG_VERBOSE));
     if (log)
         log->Printf("[ClassDescriptorV2::iVarsStorage::fill] class_name = %s", descriptor.GetClassName().AsCString("<unknown"));

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <memory>
 
 // Other libraries and framework includes

 
     std::unique_ptr<UtilityFunction>        m_get_class_info_code;
     lldb::addr_t                            m_get_class_info_args;
-    Mutex                                   m_get_class_info_args_mutex;
+    std::mutex                              m_get_class_info_args_mutex;
 
     std::unique_ptr<UtilityFunction>        m_get_shared_cache_class_info_code;
     lldb::addr_t                            m_get_shared_cache_class_info_args;
-    Mutex                                   m_get_shared_cache_class_info_args_mutex;
+    std::mutex                              m_get_shared_cache_class_info_args_mutex;
 
     std::unique_ptr<DeclVendor>             m_decl_vendor_ap;
     lldb::addr_t                            m_isa_hash_table_ptr;

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

     }
 }
 
-AppleObjCRuntimeV2::AppleObjCRuntimeV2 (Process *process,
-                                        const ModuleSP &objc_module_sp) :
-    AppleObjCRuntime (process),
-    m_get_class_info_code(),
-    m_get_class_info_args (LLDB_INVALID_ADDRESS),
-    m_get_class_info_args_mutex (Mutex::eMutexTypeNormal),
-    m_get_shared_cache_class_info_code(),
-    m_get_shared_cache_class_info_args (LLDB_INVALID_ADDRESS),
-    m_get_shared_cache_class_info_args_mutex (Mutex::eMutexTypeNormal),
-    m_decl_vendor_ap (),
-    m_isa_hash_table_ptr (LLDB_INVALID_ADDRESS),
-    m_hash_signature (),
-    m_has_object_getClass (false),
-    m_loaded_objc_opt (false),
-    m_non_pointer_isa_cache_ap(NonPointerISACache::CreateInstance(*this,objc_module_sp)),
-    m_tagged_pointer_vendor_ap(TaggedPointerVendorV2::CreateInstance(*this,objc_module_sp)),
-    m_encoding_to_type_sp(),
-    m_noclasses_warning_emitted(false)
+AppleObjCRuntimeV2::AppleObjCRuntimeV2(Process *process, const ModuleSP &objc_module_sp)
+    : AppleObjCRuntime(process),
+      m_get_class_info_code(),
+      m_get_class_info_args(LLDB_INVALID_ADDRESS),
+      m_get_class_info_args_mutex(),
+      m_get_shared_cache_class_info_code(),
+      m_get_shared_cache_class_info_args(LLDB_INVALID_ADDRESS),
+      m_get_shared_cache_class_info_args_mutex(),
+      m_decl_vendor_ap(),
+      m_isa_hash_table_ptr(LLDB_INVALID_ADDRESS),
+      m_hash_signature(),
+      m_has_object_getClass(false),
+      m_loaded_objc_opt(false),
+      m_non_pointer_isa_cache_ap(NonPointerISACache::CreateInstance(*this, objc_module_sp)),
+      m_tagged_pointer_vendor_ap(TaggedPointerVendorV2::CreateInstance(*this, objc_module_sp)),
+      m_encoding_to_type_sp(),
+      m_noclasses_warning_emitted(false)
 {
     static const ConstString g_gdb_object_getClass("gdb_object_getClass");
-    m_has_object_getClass = (objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_object_getClass, eSymbolTypeCode) != NULL);
+    m_has_object_getClass =
+        (objc_module_sp->FindFirstSymbolWithNameAndType(g_gdb_object_getClass, eSymbolTypeCode) != NULL);
 }
 
 bool

     
     if (class_infos_addr == LLDB_INVALID_ADDRESS)
         return false;
-    
-    Mutex::Locker locker(m_get_class_info_args_mutex);
+    std::lock_guard<std::mutex> guard(m_get_class_info_args_mutex);
 
     // Fill in our function argument values
     arguments.GetValueAtIndex(0)->GetScalar() = hash_table.GetTableLoadAddress();

     
     if (class_infos_addr == LLDB_INVALID_ADDRESS)
         return DescriptorMapUpdateResult::Fail();
-    
-    Mutex::Locker locker(m_get_shared_cache_class_info_args_mutex);
-    
+    std::lock_guard<std::mutex> guard(m_get_shared_cache_class_info_args_mutex);
     // Fill in our function argument values
     arguments.GetValueAtIndex(0)->GetScalar() = objc_opt_ptr;
     arguments.GetValueAtIndex(1)->GetScalar() = class_infos_addr;

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Expression/UtilityFunction.h"
 
 namespace lldb_private

     lldb::ProcessWP m_process_wp;
     lldb::ModuleSP m_objc_module_sp;
     std::unique_ptr<UtilityFunction> m_impl_code;
-    Mutex m_impl_function_mutex;
+    std::mutex m_impl_function_mutex;
     lldb::addr_t m_impl_fn_addr;
     lldb::addr_t m_impl_stret_fn_addr;
     lldb::addr_t m_msg_forward_addr;

source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTrampolineHandler.cpp

 
     // Scope for mutex locker:
     {
-        Mutex::Locker locker(m_impl_function_mutex);
-        
+        std::lock_guard<std::mutex> guard(m_impl_function_mutex);
         // First stage is to make the ClangUtility to hold our injected function:
 
         if (!m_impl_code.get())

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Symbol/ObjectContainer.h"

         static Map &
         GetArchiveCache ();
 
-        static lldb_private::Mutex &
-        GetArchiveCacheMutex ();
+        static std::recursive_mutex &
+        GetArchiveCacheMutex();
 
         static Archive::shared_ptr
         FindCachedArchive (const lldb_private::FileSpec &file,

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 #include "lldb/Core/Timer.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 using namespace lldb;

 ObjectContainerBSDArchive::Archive::shared_ptr
 ObjectContainerBSDArchive::Archive::FindCachedArchive (const FileSpec &file, const ArchSpec &arch, const TimeValue &time, lldb::offset_t file_offset)
 {
-    Mutex::Locker locker(Archive::GetArchiveCacheMutex ());
+    std::lock_guard<std::recursive_mutex> guard(Archive::GetArchiveCacheMutex());
     shared_ptr archive_sp;
     Archive::Map &archive_map = Archive::GetArchiveCache ();
     Archive::Map::iterator pos = archive_map.find (file);

         const size_t num_objects = archive_sp->ParseObjects ();
         if (num_objects > 0)
         {
-            Mutex::Locker locker(Archive::GetArchiveCacheMutex ());
+            std::lock_guard<std::recursive_mutex> guard(Archive::GetArchiveCacheMutex());
             Archive::GetArchiveCache().insert(std::make_pair(file, archive_sp));
         }
         else

     return g_archive_map;
 }
 
-Mutex &
-ObjectContainerBSDArchive::Archive::GetArchiveCacheMutex ()
+std::recursive_mutex &
+ObjectContainerBSDArchive::Archive::GetArchiveCacheMutex()
 {
-    static Mutex g_archive_map_mutex (Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_archive_map_mutex;
     return g_archive_map_mutex;
 }
 
-
 void
 ObjectContainerBSDArchive::Initialize()
 {

source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

             return NULL;
 
         uint64_t symbol_id = 0;
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
         // Sharable objects and dynamic executables usually have 2 distinct symbol
         // tables, one named ".symtab", and the other ".dynsym". The dynsym is a smaller

         return;
     }
 
-    lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
     s->Printf("%p: ", static_cast<void *>(this));
     s->Indent();
     s->PutCString("ObjectFileELF");

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_symtab_ap.get() == NULL)
         {
             m_symtab_ap.reset(new Symtab(this));

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         s->Printf("%p: ", static_cast<void*>(this));
         s->Indent();
         s->PutCString("ObjectFileJIT");

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
 
 //----------------------------------------------------------------------

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         bool can_parse = false;
         lldb::offset_t offset = 0;
         m_data.SetByteOrder (endian::InlHostByteOrder());

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_symtab_ap.get() == NULL)
         {
             m_symtab_ap.reset(new Symtab(this));

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         s->Printf("%p: ", static_cast<void*>(this));
         s->Indent();
         if (m_header.magic == MH_MAGIC_64 || m_header.magic == MH_CIGAM_64)

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
         return GetUUID (m_header, m_data, offset, *uuid);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         struct load_command load_cmd;
         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
         std::vector<std::string> rpath_paths;

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         struct load_command load_cmd;
         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
         uint32_t i;

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (!m_thread_context_offsets_valid)
         {
             m_thread_context_offsets_valid = true;

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (!m_thread_context_offsets_valid)
             GetNumThreadContexts ();
 

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         struct dylib_command load_cmd;
         lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
         uint32_t version_cmd = 0;

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         return GetArchitecture (m_header, m_data, MachHeaderSizeFromMagic(m_header.magic), arch);
     }
     return false;

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         m_sect_headers.clear();
         m_data.SetByteOrder (eByteOrderLittle);
         lldb::offset_t offset = 0;

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_symtab_ap.get() == NULL)
         {
             SectionList *sect_list = GetSectionList();

         ModuleSP module_sp(GetModule());
         if (module_sp)
         {
-            lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+            std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
             const uint32_t nsects = m_sect_headers.size();
             ModuleSP module_sp (GetModule());
             for (uint32_t idx = 0; idx<nsects; ++idx)

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         s->Printf("%p: ", static_cast<void*>(this));
         s->Indent();
         s->PutCString("ObjectFilePECOFF");

source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

 PlatformAppleSimulator::GetCoreSimulatorPath()
 {
 #if defined(__APPLE__)
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (!m_core_simulator_framework_path.hasValue())
     {
         const char *developer_dir = GetDeveloperDirectory();

source/Plugins/Platform/MacOSX/PlatformAppleTVSimulator.cpp

 const char *
 PlatformAppleTVSimulator::GetSDKDirectoryAsCString()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (m_sdk_directory.empty())
     {
         const char *developer_dir = GetDeveloperDirectory();

source/Plugins/Platform/MacOSX/PlatformAppleWatchSimulator.cpp

 const char *
 PlatformAppleWatchSimulator::GetSDKDirectoryAsCString()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (m_sdk_directory.empty())
     {
         const char *developer_dir = GetDeveloperDirectory();

source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

 const char *
 PlatformDarwin::GetDeveloperDirectory()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (m_developer_directory.empty())
     {
         bool developer_dir_path_valid = false;

     FileSpec sysroot_spec;
     // Scope for mutex locker below
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::mutex> guard(m_mutex);
         sysroot_spec = GetSDKDirectoryForModules(sdk_type);
     }
-    
     if (sysroot_spec.IsDirectory())
     {
         options.push_back("-isysroot");

source/Plugins/Platform/MacOSX/PlatformiOSSimulator.cpp

 const char *
 PlatformiOSSimulator::GetSDKDirectoryAsCString()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (m_sdk_directory.empty())
     {
         const char *developer_dir = GetDeveloperDirectory();

source/Plugins/Process/FreeBSD/ProcessFreeBSD.h

 // C Includes
 
 // C++ Includes
+#include <mutex>
 #include <set>
 #include <queue>
 

     lldb_private::Module *m_module;
 
     /// Message queue notifying this instance of inferior process state changes.
-    lldb_private::Mutex m_message_mutex;
+    std::recursive_mutex m_message_mutex;
     std::queue<ProcessMessage> m_message_queue;
 
     /// Drive any exit events to completion.

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 void
 ProcessFreeBSD::SendMessage(const ProcessMessage &message)
 {
-    Mutex::Locker lock(m_message_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 
     switch (message.GetKind())
     {

       m_byte_order(endian::InlHostByteOrder()),
       m_monitor(NULL),
       m_module(NULL),
-      m_message_mutex (Mutex::eMutexTypeRecursive),
+      m_message_mutex(),
       m_exit_now(false),
       m_seen_initial_stop(),
       m_resume_signo(0)

     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
         log->Printf ("ProcessFreeBSD::%s(), message_queue size = %d", __FUNCTION__, (int)m_message_queue.size());
 
-    Mutex::Locker lock(m_message_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 
     // This method used to only handle one message.  Changing it to loop allows
     // it to handle the case where we hit a breakpoint while handling a different

source/Plugins/Process/FreeBSD/ProcessMonitor.h

 #include <signal.h>
 
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 #include "lldb/lldb-types.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private
 {

 
     // current operation which must be executed on the privileged thread
     Operation *m_operation;
-    lldb_private::Mutex m_operation_mutex;
+    std::mutex m_operation_mutex;
 
     // semaphores notified when Operation is ready to be processed and when
     // the operation is complete.

source/Plugins/Process/FreeBSD/ProcessMonitor.cpp

 void
 ProcessMonitor::DoOperation(Operation *op)
 {
-    Mutex::Locker lock(m_operation_mutex);
+    std::lock_guard<std::mutex> guard(m_operation_mutex);
 
     m_operation = op;
 

source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp

 CommunicationKDP::CheckForPacket (const uint8_t *src, size_t src_len, DataExtractor &packet)
 {
     // Put the packet data into the buffer in a thread safe fashion
-    Mutex::Locker locker(m_bytes_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
     Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PACKETS));
 
     if (src && src_len > 0)

source/Plugins/Process/Utility/HistoryThread.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/UserID.h"

     virtual lldb::StackFrameListSP
     GetStackFrameList ();
 
-    mutable Mutex               m_framelist_mutex;
+    mutable std::mutex          m_framelist_mutex;
     lldb::StackFrameListSP      m_framelist;
     std::vector<lldb::addr_t>   m_pcs;
     uint32_t                    m_stop_id;

source/Plugins/Process/Utility/HistoryThread.cpp

 
 //  Constructor
 
-HistoryThread::HistoryThread (lldb_private::Process &process, 
-                              lldb::tid_t tid,
-                              std::vector<lldb::addr_t> pcs, 
-                              uint32_t stop_id, 
-                              bool stop_id_is_valid) : 
-        Thread (process, tid, true),
-        m_framelist_mutex(),
-        m_framelist(),
-        m_pcs (pcs),
-        m_stop_id (stop_id),
-        m_stop_id_is_valid (stop_id_is_valid),
-        m_extended_unwind_token (LLDB_INVALID_ADDRESS),
-        m_queue_name (),
-        m_thread_name (),
-        m_originating_unique_thread_id (tid),
-        m_queue_id (LLDB_INVALID_QUEUE_ID)
+HistoryThread::HistoryThread(lldb_private::Process &process, lldb::tid_t tid, std::vector<lldb::addr_t> pcs,
+                             uint32_t stop_id, bool stop_id_is_valid)
+    : Thread(process, tid, true),
+      m_framelist_mutex(),
+      m_framelist(),
+      m_pcs(pcs),
+      m_stop_id(stop_id),
+      m_stop_id_is_valid(stop_id_is_valid),
+      m_extended_unwind_token(LLDB_INVALID_ADDRESS),
+      m_queue_name(),
+      m_thread_name(),
+      m_originating_unique_thread_id(tid),
+      m_queue_id(LLDB_INVALID_QUEUE_ID)
 {
-    m_unwinder_ap.reset (new HistoryUnwind (*this, pcs, stop_id_is_valid));
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+    m_unwinder_ap.reset(new HistoryUnwind(*this, pcs, stop_id_is_valid));
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf ("%p HistoryThread::HistoryThread",
-                     static_cast<void*>(this));
+        log->Printf("%p HistoryThread::HistoryThread", static_cast<void *>(this));
 }
 
 //  Destructor

 lldb::StackFrameListSP
 HistoryThread::GetStackFrameList ()
 {
-    Mutex::Locker (m_framelist_mutex);   // FIXME do not throw away the lock after we acquire it..
+    // FIXME do not throw away the lock after we acquire it..
+    std::unique_lock<std::mutex> lock(m_framelist_mutex);
+    lock.release();
     if (m_framelist.get() == NULL)
     {
         m_framelist.reset (new StackFrameList (*this, StackFrameListSP(), true));

source/Plugins/Process/Utility/HistoryUnwind.h

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Unwind.h"
 
 namespace lldb_private {

source/Plugins/Process/Utility/HistoryUnwind.cpp

 void
 HistoryUnwind::DoClear ()
 {
-    Mutex::Locker locker(m_unwind_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
     m_pcs.clear();
     m_stop_id_is_valid = false;
 }

 bool
 HistoryUnwind::DoGetFrameInfoAtIndex (uint32_t frame_idx, lldb::addr_t& cfa, lldb::addr_t& pc)
 {
-    Mutex::Locker (m_unwind_mutex);   // FIXME do not throw away the lock after we acquire it..
+    // FIXME do not throw away the lock after we acquire it..
+    std::unique_lock<std::recursive_mutex> guard(m_unwind_mutex);
+    guard.release();
     if (frame_idx < m_pcs.size())
     {
         cfa = frame_idx;

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, StringExtractorGDBRemote &packet)
 {
     // Put the packet data into the buffer in a thread safe fashion
-    Mutex::Locker locker(m_bytes_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 
     if (src && src_len > 0)

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 

 
     // If we need to send a packet while the target is running, the m_async_XXX
     // member variables take care of making this happen.
-    Mutex m_async_mutex;
+    std::recursive_mutex m_async_mutex;
     Predicate<bool> m_async_packet_predicate;
     std::string m_async_packet;
     PacketResult m_async_result;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 //----------------------------------------------------------------------
 // GDBRemoteCommunicationClient constructor
 //----------------------------------------------------------------------
-GDBRemoteCommunicationClient::GDBRemoteCommunicationClient() :
-    GDBRemoteCommunication("gdb-remote.client", "gdb-remote.client.rx_packet"),
-    m_supports_not_sending_acks (eLazyBoolCalculate),
-    m_supports_thread_suffix (eLazyBoolCalculate),
-    m_supports_threads_in_stop_reply (eLazyBoolCalculate),
-    m_supports_vCont_all (eLazyBoolCalculate),
-    m_supports_vCont_any (eLazyBoolCalculate),
-    m_supports_vCont_c (eLazyBoolCalculate),
-    m_supports_vCont_C (eLazyBoolCalculate),
-    m_supports_vCont_s (eLazyBoolCalculate),
-    m_supports_vCont_S (eLazyBoolCalculate),
-    m_qHostInfo_is_valid (eLazyBoolCalculate),
-    m_curr_pid_is_valid (eLazyBoolCalculate),
-    m_qProcessInfo_is_valid (eLazyBoolCalculate),
-    m_qGDBServerVersion_is_valid (eLazyBoolCalculate),
-    m_supports_alloc_dealloc_memory (eLazyBoolCalculate),
-    m_supports_memory_region_info  (eLazyBoolCalculate),
-    m_supports_watchpoint_support_info  (eLazyBoolCalculate),
-    m_supports_detach_stay_stopped (eLazyBoolCalculate),
+GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
+    : GDBRemoteCommunication("gdb-remote.client", "gdb-remote.client.rx_packet"),
+      m_supports_not_sending_acks(eLazyBoolCalculate),
+      m_supports_thread_suffix(eLazyBoolCalculate),
+      m_supports_threads_in_stop_reply(eLazyBoolCalculate),
+      m_supports_vCont_all(eLazyBoolCalculate),
+      m_supports_vCont_any(eLazyBoolCalculate),
+      m_supports_vCont_c(eLazyBoolCalculate),
+      m_supports_vCont_C(eLazyBoolCalculate),
+      m_supports_vCont_s(eLazyBoolCalculate),
+      m_supports_vCont_S(eLazyBoolCalculate),
+      m_qHostInfo_is_valid(eLazyBoolCalculate),
+      m_curr_pid_is_valid(eLazyBoolCalculate),
+      m_qProcessInfo_is_valid(eLazyBoolCalculate),
+      m_qGDBServerVersion_is_valid(eLazyBoolCalculate),
+      m_supports_alloc_dealloc_memory(eLazyBoolCalculate),
+      m_supports_memory_region_info(eLazyBoolCalculate),
+      m_supports_watchpoint_support_info(eLazyBoolCalculate),
+      m_supports_detach_stay_stopped(eLazyBoolCalculate),
       m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
       m_attach_or_wait_reply(eLazyBoolCalculate),
-    m_prepare_for_reg_writing_reply (eLazyBoolCalculate),
-    m_supports_p (eLazyBoolCalculate),
-    m_supports_x (eLazyBoolCalculate),
-    m_avoid_g_packets (eLazyBoolCalculate),
-    m_supports_QSaveRegisterState (eLazyBoolCalculate),
-    m_supports_qXfer_auxv_read (eLazyBoolCalculate),
-    m_supports_qXfer_libraries_read (eLazyBoolCalculate),
-    m_supports_qXfer_libraries_svr4_read (eLazyBoolCalculate),
-    m_supports_qXfer_features_read (eLazyBoolCalculate),
-    m_supports_augmented_libraries_svr4_read (eLazyBoolCalculate),
-    m_supports_jThreadExtendedInfo (eLazyBoolCalculate),
-    m_supports_jLoadedDynamicLibrariesInfos (eLazyBoolCalculate),
-    m_supports_qProcessInfoPID (true),
-    m_supports_qfProcessInfo (true),
-    m_supports_qUserName (true),
-    m_supports_qGroupName (true),
-    m_supports_qThreadStopInfo (true),
-    m_supports_z0 (true),
-    m_supports_z1 (true),
-    m_supports_z2 (true),
-    m_supports_z3 (true),
-    m_supports_z4 (true),
-    m_supports_QEnvironment (true),
-    m_supports_QEnvironmentHexEncoded (true),
-    m_supports_qSymbol (true),
-    m_qSymbol_requests_done (false),
-    m_supports_qModuleInfo (true),
-    m_supports_jThreadsInfo (true),
-    m_curr_pid (LLDB_INVALID_PROCESS_ID),
-    m_curr_tid (LLDB_INVALID_THREAD_ID),
-    m_curr_tid_run (LLDB_INVALID_THREAD_ID),
-    m_num_supported_hardware_watchpoints (0),
-    m_async_mutex (Mutex::eMutexTypeRecursive),
-    m_async_packet_predicate (false),
-    m_async_packet (),
-    m_async_result (PacketResult::Success),
-    m_async_response (),
-    m_async_signal (-1),
-    m_interrupt_sent (false),
-    m_thread_id_to_used_usec_map (),
+      m_prepare_for_reg_writing_reply(eLazyBoolCalculate),
+      m_supports_p(eLazyBoolCalculate),
+      m_supports_x(eLazyBoolCalculate),
+      m_avoid_g_packets(eLazyBoolCalculate),
+      m_supports_QSaveRegisterState(eLazyBoolCalculate),
+      m_supports_qXfer_auxv_read(eLazyBoolCalculate),
+      m_supports_qXfer_libraries_read(eLazyBoolCalculate),
+      m_supports_qXfer_libraries_svr4_read(eLazyBoolCalculate),
+      m_supports_qXfer_features_read(eLazyBoolCalculate),
+      m_supports_augmented_libraries_svr4_read(eLazyBoolCalculate),
+      m_supports_jThreadExtendedInfo(eLazyBoolCalculate),
+      m_supports_jLoadedDynamicLibrariesInfos(eLazyBoolCalculate),
+      m_supports_qProcessInfoPID(true),
+      m_supports_qfProcessInfo(true),
+      m_supports_qUserName(true),
+      m_supports_qGroupName(true),
+      m_supports_qThreadStopInfo(true),
+      m_supports_z0(true),
+      m_supports_z1(true),
+      m_supports_z2(true),
+      m_supports_z3(true),
+      m_supports_z4(true),
+      m_supports_QEnvironment(true),
+      m_supports_QEnvironmentHexEncoded(true),
+      m_supports_qSymbol(true),
+      m_qSymbol_requests_done(false),
+      m_supports_qModuleInfo(true),
+      m_supports_jThreadsInfo(true),
+      m_curr_pid(LLDB_INVALID_PROCESS_ID),
+      m_curr_tid(LLDB_INVALID_THREAD_ID),
+      m_curr_tid_run(LLDB_INVALID_THREAD_ID),
+      m_num_supported_hardware_watchpoints(0),
+      m_async_mutex(),
+      m_async_packet_predicate(false),
+      m_async_packet(),
+      m_async_result(PacketResult::Success),
+      m_async_response(),
+      m_async_signal(-1),
+      m_interrupt_sent(false),
+      m_thread_id_to_used_usec_map(),
       m_host_arch(),
       m_process_arch(),
-    m_os_version_major (UINT32_MAX),
-    m_os_version_minor (UINT32_MAX),
-    m_os_version_update (UINT32_MAX),
-    m_os_build (),
-    m_os_kernel (),
-    m_hostname (),
+      m_os_version_major(UINT32_MAX),
+      m_os_version_minor(UINT32_MAX),
+      m_os_version_update(UINT32_MAX),
+      m_os_build(),
+      m_os_kernel(),
+      m_hostname(),
       m_gdb_server_name(),
       m_gdb_server_version(UINT32_MAX),
-    m_default_packet_timeout (0),
-    m_max_packet_size (0)
+      m_default_packet_timeout(0),
+      m_max_packet_size(0)
 {
 }
 

         {
             if (IsRunning())
             {
-                Mutex::Locker async_locker (m_async_mutex);
+                std::lock_guard<std::recursive_mutex> guard(m_async_mutex);
                 m_async_packet.assign(payload, payload_length);
                 m_async_response.CopyResponseValidator(response);
                 m_async_packet_predicate.SetValue (true, eBroadcastNever);

 bool
 GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
 {
-    Mutex::Locker async_locker (m_async_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_async_mutex);
     m_async_signal = signo;
     bool timed_out = false;
     Mutex::Locker locker;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private-forward.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 #include "GDBRemoteCommunicationServer.h"

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Core/Communication.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/MainLoop.h"
 

     MainLoop::ReadHandleUP m_network_handle_up;
     lldb::tid_t m_current_tid;
     lldb::tid_t m_continue_tid;
-    Mutex m_debugged_process_mutex;
+    std::recursive_mutex m_debugged_process_mutex;
     NativeProcessProtocolSP m_debugged_process_sp;
 
     Communication m_stdio_communication;

 
     lldb::StateType m_inferior_prev_state;
     lldb::DataBufferSP m_active_auxv_buffer_sp;
-    Mutex m_saved_registers_mutex;
+    std::mutex m_saved_registers_mutex;
     std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
     uint32_t m_next_saved_registers_id;
     bool m_handshake_completed : 1;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerLLGS constructor
 //----------------------------------------------------------------------
-GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
-        const lldb::PlatformSP& platform_sp,
-        MainLoop &mainloop) :
-    GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
-    m_platform_sp (platform_sp),
-    m_mainloop (mainloop),
-    m_current_tid (LLDB_INVALID_THREAD_ID),
-    m_continue_tid (LLDB_INVALID_THREAD_ID),
-    m_debugged_process_mutex (Mutex::eMutexTypeRecursive),
-    m_debugged_process_sp (),
-    m_stdio_communication ("process.stdio"),
-    m_inferior_prev_state (StateType::eStateInvalid),
-    m_active_auxv_buffer_sp (),
-    m_saved_registers_mutex (),
-    m_saved_registers_map (),
-    m_next_saved_registers_id (1),
-    m_handshake_completed (false)
+GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP &platform_sp,
+                                                                   MainLoop &mainloop)
+    : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
+      m_platform_sp(platform_sp),
+      m_mainloop(mainloop),
+      m_current_tid(LLDB_INVALID_THREAD_ID),
+      m_continue_tid(LLDB_INVALID_THREAD_ID),
+      m_debugged_process_mutex(),
+      m_debugged_process_sp(),
+      m_stdio_communication("process.stdio"),
+      m_inferior_prev_state(StateType::eStateInvalid),
+      m_active_auxv_buffer_sp(),
+      m_saved_registers_mutex(),
+      m_saved_registers_map(),
+      m_next_saved_registers_id(1),
+      m_handshake_completed(false)
 {
     assert(platform_sp);
     RegisterPacketHandlers();

 
     Error error;
     {
-        Mutex::Locker locker (m_debugged_process_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
         assert (!m_debugged_process_sp && "lldb-gdbserver creating debugged process but one already exists");
         error = NativeProcessProtocol::Launch(
             m_process_launch_info,

 
     // Save the register data buffer under the save id.
     {
-        Mutex::Locker locker (m_saved_registers_mutex);
+        std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
         m_saved_registers_map[save_id] = register_data_sp;
     }
 

     // Retrieve register state buffer, then remove from the list.
     DataBufferSP register_data_sp;
     {
-        Mutex::Locker locker (m_saved_registers_mutex);
+        std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
 
         // Find the register set buffer for the given save id.
         auto it = m_saved_registers_map.find (save_id);

 uint32_t
 GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID ()
 {
-    Mutex::Locker locker (m_saved_registers_mutex);
+    std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
     return m_next_saved_registers_id++;
 }
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <set>
 
 // Other libraries and framework includes

 protected:
     const Socket::SocketProtocol m_socket_protocol;
     const std::string m_socket_scheme;
-    Mutex m_spawned_pids_mutex;
+    std::recursive_mutex m_spawned_pids_mutex;
     std::set<lldb::pid_t> m_spawned_pids;
     lldb::PlatformSP m_platform_sp;
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,
-                                                                           const char* socket_scheme) :
-    GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
+                                                                           const char *socket_scheme)
+    : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
       m_socket_protocol(socket_protocol),
       m_socket_scheme(socket_scheme),
-    m_spawned_pids_mutex (Mutex::eMutexTypeRecursive),
-    m_platform_sp (Platform::GetHostPlatform ()),
-    m_port_map (),
+      m_spawned_pids_mutex(),
+      m_platform_sp(Platform::GetHostPlatform()),
+      m_port_map(),
       m_port_offset(0)
 {
     m_pending_gdb_server.pid = LLDB_INVALID_PROCESS_ID;
     m_pending_gdb_server.port = 0;

                                   &GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo);
 
     RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_interrupt,
-                          [this](StringExtractorGDBRemote packet,
-                                 Error &error,
-                                 bool &interrupt,
-                                 bool &quit)
-                          {
+                          [this](StringExtractorGDBRemote packet, Error &error, bool &interrupt, bool &quit) {
                               error.SetErrorString("interrupt received");
                               interrupt = true;
                               return PacketResult::Success;

     pid = debugserver_launch_info.GetProcessID();
     if (pid != LLDB_INVALID_PROCESS_ID)
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         m_spawned_pids.insert(pid);
         if (port > 0)
             AssociatePortWithProcess(port, pid);

     // verify that we know anything about this pid.
     // Scope for locker
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
         {
             // not a pid we know about

 {
     // make sure we know about this process
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             return false;
     }

     for (size_t i=0; i<10; ++i)
     {
         {
-            Mutex::Locker locker (m_spawned_pids_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
             if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             {
                 // it is now killed

 
     // check one more time after the final usleep
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             return true;
     }

     for (size_t i=0; i<10; ++i)
     {
         {
-            Mutex::Locker locker (m_spawned_pids_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
             if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             {
                 // it is now killed

     // check one more time after the final usleep
     // Scope for locker
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             return true;
     }

 bool
 GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped (lldb::pid_t pid)
 {
-    Mutex::Locker locker (m_spawned_pids_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
     FreePortForProcess(pid);
     m_spawned_pids.erase(pid);
     return true;

     if (pid != LLDB_INVALID_PROCESS_ID)
     {
         // add to spawned pids
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         m_spawned_pids.insert(pid);
     }
 

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

 // C++ Includes
 #include <atomic>
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 

     GDBRemoteCommunicationClient m_gdb_comm;
     std::atomic<lldb::pid_t> m_debugserver_pid;
     std::vector<StringExtractorGDBRemote> m_stop_packet_stack;  // The stop packet stack replaces the last stop packet variable
-    Mutex m_last_stop_packet_mutex;
+    std::recursive_mutex m_last_stop_packet_mutex;
     GDBRemoteDynamicRegisterInfo m_register_info;
     Broadcaster m_async_broadcaster;
     lldb::ListenerSP m_async_listener_sp;
     HostThread m_async_thread;
-    Mutex m_async_thread_state_mutex;
+    std::recursive_mutex m_async_thread_state_mutex;
     typedef std::vector<lldb::tid_t> tid_collection;
     typedef std::vector< std::pair<lldb::tid_t,int> > tid_sig_collection;
     typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 //----------------------------------------------------------------------
 // ProcessGDBRemote constructor
 //----------------------------------------------------------------------
-ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener_sp) :
-    Process (target_sp, listener_sp),
-    m_flags (0),
-    m_gdb_comm (),
-    m_debugserver_pid (LLDB_INVALID_PROCESS_ID),
-    m_last_stop_packet_mutex (Mutex::eMutexTypeRecursive),
-    m_register_info (),
-    m_async_broadcaster (NULL, "lldb.process.gdb-remote.async-broadcaster"),
+ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener_sp)
+    : Process(target_sp, listener_sp),
+      m_flags(0),
+      m_gdb_comm(),
+      m_debugserver_pid(LLDB_INVALID_PROCESS_ID),
+      m_last_stop_packet_mutex(),
+      m_register_info(),
+      m_async_broadcaster(NULL, "lldb.process.gdb-remote.async-broadcaster"),
       m_async_listener_sp(Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
-    m_async_thread_state_mutex(Mutex::eMutexTypeRecursive),
-    m_thread_ids (),
-    m_thread_pcs (),
-    m_jstopinfo_sp (),
-    m_jthreadsinfo_sp (),
-    m_continue_c_tids (),
-    m_continue_C_tids (),
-    m_continue_s_tids (),
-    m_continue_S_tids (),
-    m_max_memory_size (0),
-    m_remote_stub_max_memory_size (0),
-    m_addr_to_mmap_size (),
-    m_thread_create_bp_sp (),
-    m_waiting_for_attach (false),
-    m_destroy_tried_resuming (false),
-    m_command_sp (),
-    m_breakpoint_pc_offset (0),
-    m_initial_tid (LLDB_INVALID_THREAD_ID)
+      m_async_thread_state_mutex(),
+      m_thread_ids(),
+      m_thread_pcs(),
+      m_jstopinfo_sp(),
+      m_jthreadsinfo_sp(),
+      m_continue_c_tids(),
+      m_continue_C_tids(),
+      m_continue_s_tids(),
+      m_continue_S_tids(),
+      m_max_memory_size(0),
+      m_remote_stub_max_memory_size(0),
+      m_addr_to_mmap_size(),
+      m_thread_create_bp_sp(),
+      m_waiting_for_attach(false),
+      m_destroy_tried_resuming(false),
+      m_command_sp(),
+      m_breakpoint_pc_offset(0),
+      m_initial_tid(LLDB_INVALID_THREAD_ID)
 {
-    m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadShouldExit,   "async thread should exit");
-    m_async_broadcaster.SetEventName (eBroadcastBitAsyncContinue,           "async thread continue");
-    m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadDidExit,      "async thread did exit");
+    m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit, "async thread should exit");
+    m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue, "async thread continue");
+    m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadDidExit, "async thread did exit");
 
-    Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_ASYNC));
+    Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_ASYNC));
 
     const uint32_t async_event_mask = eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
 

             log->Printf("ProcessGDBRemote::%s failed to listen for m_async_broadcaster events", __FUNCTION__);
     }
 
-    const uint32_t gdb_event_mask = Communication::eBroadcastBitReadThreadDidExit |
-                                    GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify;
+    const uint32_t gdb_event_mask =
+        Communication::eBroadcastBitReadThreadDidExit | GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify;
     if (m_async_listener_sp->StartListeningForEvents(&m_gdb_comm, gdb_event_mask) != gdb_event_mask)
     {
         if (log)

 
         // Lock the thread stack while we access it
         //Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
-        Mutex::Locker stop_stack_lock;
-        if (stop_stack_lock.TryLock(m_last_stop_packet_mutex))
+        std::unique_lock<std::recursive_mutex> stop_stack_lock(m_last_stop_packet_mutex, std::defer_lock);
+        if (stop_stack_lock.try_lock())
         {
             // Get the number of stop packets on the stack
             int nItems = m_stop_packet_stack.size();

     // Scope for the lock
     {
         // Lock the thread stack while we access it
-        Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
         // Get the number of stop packets on the stack
         int nItems = m_stop_packet_stack.size();
         // Iterate over them

     // Scope the lock
     {
         // Lock the thread stack while we access it
-        Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
 
         // We are are not using non-stop mode, there can only be one last stop
         // reply packet, so clear the list.

     if (log)
         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
 
-    Mutex::Locker start_locker(m_async_thread_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
     if (!m_async_thread.IsJoinable())
     {
         // Create a thread that watches our internal state and controls which

     if (log)
         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
 
-    Mutex::Locker start_locker(m_async_thread_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
     if (m_async_thread.IsJoinable())
     {
         m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 {
     SymbolFileDWARF *dwarf = die.GetDWARF();
 
-    lldb_private::Mutex::Locker locker(dwarf->GetObjectFile()->GetModule()->GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(dwarf->GetObjectFile()->GetModule()->GetMutex());
 
     // Disable external storage for this type so we don't get anymore
     // clang::ExternalASTSource queries for this type.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 bool
 SymbolFileDWARF::CompleteType (CompilerType &compiler_type)
 {
-    lldb_private::Mutex::Locker locker(GetObjectFile()->GetModule()->GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetObjectFile()->GetModule()->GetMutex());
 
     ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
     if (clang_type_system)

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

             ObjectFile *oso_objfile = GetObjectFile ();
             if (oso_objfile)
             {
-                Mutex::Locker locker (m_mutex);
+                std::lock_guard<std::recursive_mutex> guard(m_mutex);
                 SymbolVendor* symbol_vendor = Module::GetSymbolVendor(can_create, feedback_strm);
                 if (symbol_vendor)
                 {

source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Expression/UtilityFunction.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/CompilerType.h"
 
 // This class will insert a UtilityFunction into the inferior process for

 
     lldb_private::Process *m_process;
     std::unique_ptr<UtilityFunction> m_get_item_info_impl_code;
-    Mutex m_get_item_info_function_mutex;
+    std::mutex m_get_item_info_function_mutex;
 
     lldb::addr_t m_get_item_info_return_buffer_addr;
-    Mutex m_get_item_info_retbuffer_mutex;
+    std::mutex m_get_item_info_retbuffer_mutex;
 
 };
 

source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

 }                                                                                                               \n\
 ";
 
-AppleGetItemInfoHandler::AppleGetItemInfoHandler (Process *process) :
-    m_process (process),
-    m_get_item_info_impl_code (),
+AppleGetItemInfoHandler::AppleGetItemInfoHandler(Process *process)
+    : m_process(process),
+      m_get_item_info_impl_code(),
       m_get_item_info_function_mutex(),
-    m_get_item_info_return_buffer_addr (LLDB_INVALID_ADDRESS),
+      m_get_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_item_info_retbuffer_mutex()
 {
 }
 

 }
 
 void
-AppleGetItemInfoHandler::Detach ()
+AppleGetItemInfoHandler::Detach()
 {
 
     if (m_process && m_process->IsAlive() && m_get_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS)
     {
-        Mutex::Locker locker;
-        locker.TryLock (m_get_item_info_retbuffer_mutex);  // Even if we don't get the lock, deallocate the buffer
-        m_process->DeallocateMemory (m_get_item_info_return_buffer_addr);
+        std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex, std::defer_lock);
+        lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
+        m_process->DeallocateMemory(m_get_item_info_return_buffer_addr);
     }
 }
 

 
     // Scope for mutex locker:
     {
-        Mutex::Locker locker(m_get_item_info_function_mutex);
-        
+        std::lock_guard<std::mutex> guard(m_get_item_info_function_mutex);
         // First stage is to make the UtilityFunction to hold our injected function:
 
         if (!m_get_item_info_impl_code.get())

     page_to_free_size_value.SetValueType (Value::eValueTypeScalar);
     page_to_free_size_value.SetCompilerType (clang_uint64_type);
 
-
-    Mutex::Locker locker(m_get_item_info_retbuffer_mutex);
+    std::lock_guard<std::mutex> guard(m_get_item_info_retbuffer_mutex);
     if (m_get_item_info_return_buffer_addr == LLDB_INVALID_ADDRESS)
     {
         addr_t bufaddr = process_sp->AllocateMemory (32, ePermissionsReadable | ePermissionsWritable, error);

source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/CompilerType.h"
 
 // This class will insert a UtilityFunction into the inferior process for

 
     lldb_private::Process *m_process;
     std::unique_ptr<UtilityFunction> m_get_pending_items_impl_code;
-    Mutex m_get_pending_items_function_mutex;
+    std::mutex m_get_pending_items_function_mutex;
 
     lldb::addr_t m_get_pending_items_return_buffer_addr;
-    Mutex m_get_pending_items_retbuffer_mutex;
-
+    std::mutex m_get_pending_items_retbuffer_mutex;
 };
 
 }  // using namespace lldb_private

source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

 }                                                                                                               \n\
 ";
 
-AppleGetPendingItemsHandler::AppleGetPendingItemsHandler (Process *process) :
-    m_process (process),
-    m_get_pending_items_impl_code (),
+AppleGetPendingItemsHandler::AppleGetPendingItemsHandler(Process *process)
+    : m_process(process),
+      m_get_pending_items_impl_code(),
       m_get_pending_items_function_mutex(),
-    m_get_pending_items_return_buffer_addr (LLDB_INVALID_ADDRESS),
+      m_get_pending_items_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_pending_items_retbuffer_mutex()
 {
 }
 

 }
 
 void
-AppleGetPendingItemsHandler::Detach ()
+AppleGetPendingItemsHandler::Detach()
 {
-
     if (m_process && m_process->IsAlive() && m_get_pending_items_return_buffer_addr != LLDB_INVALID_ADDRESS)
     {
-        Mutex::Locker locker;
-        locker.TryLock (m_get_pending_items_retbuffer_mutex);  // Even if we don't get the lock, deallocate the buffer
-        m_process->DeallocateMemory (m_get_pending_items_return_buffer_addr);
+        std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex, std::defer_lock);
+        lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
+        m_process->DeallocateMemory(m_get_pending_items_return_buffer_addr);
     }
 }
 

 
     // Scope for mutex locker:
     {
-        Mutex::Locker locker(m_get_pending_items_function_mutex);
-        
+        std::lock_guard<std::mutex> guard(m_get_pending_items_function_mutex);
         // First stage is to make the ClangUtility to hold our injected function:
 
         if (!m_get_pending_items_impl_code.get())

     page_to_free_size_value.SetValueType (Value::eValueTypeScalar);
     page_to_free_size_value.SetCompilerType (clang_uint64_type);
 
-
-    Mutex::Locker locker(m_get_pending_items_retbuffer_mutex);
+    std::lock_guard<std::mutex> guard(m_get_pending_items_retbuffer_mutex);
     if (m_get_pending_items_return_buffer_addr == LLDB_INVALID_ADDRESS)
     {
         addr_t bufaddr = process_sp->AllocateMemory (32, ePermissionsReadable | ePermissionsWritable, error);

source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/CompilerType.h"
 
 // This class will insert a UtilityFunction into the inferior process for

 
     lldb_private::Process *m_process;
     std::unique_ptr<UtilityFunction> m_get_queues_impl_code_up;
-    Mutex m_get_queues_function_mutex;
+    std::mutex m_get_queues_function_mutex;
 
     lldb::addr_t m_get_queues_return_buffer_addr;
-    Mutex m_get_queues_retbuffer_mutex;
+    std::mutex m_get_queues_retbuffer_mutex;
 
 };
 

source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

 }                                                                                                               \n\
 ";
 
-AppleGetQueuesHandler::AppleGetQueuesHandler (Process *process) :
-    m_process (process),
-    m_get_queues_impl_code_up (),
+AppleGetQueuesHandler::AppleGetQueuesHandler(Process *process)
+    : m_process(process),
+      m_get_queues_impl_code_up(),
       m_get_queues_function_mutex(),
-    m_get_queues_return_buffer_addr (LLDB_INVALID_ADDRESS),
+      m_get_queues_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_queues_retbuffer_mutex()
 {
 }
 

 }
 
 void
-AppleGetQueuesHandler::Detach ()
+AppleGetQueuesHandler::Detach()
 {
 
     if (m_process && m_process->IsAlive() && m_get_queues_return_buffer_addr != LLDB_INVALID_ADDRESS)
     {
-        Mutex::Locker locker;
-        locker.TryLock (m_get_queues_retbuffer_mutex);  // Even if we don't get the lock, deallocate the buffer
-        m_process->DeallocateMemory (m_get_queues_return_buffer_addr);
+        std::unique_lock<std::mutex> lock(m_get_queues_retbuffer_mutex, std::defer_lock);
+        lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
+        m_process->DeallocateMemory(m_get_queues_return_buffer_addr);
     }
 }
 

 
     // Scope for mutex locker:
     {
-        Mutex::Locker locker(m_get_queues_function_mutex);
-        
+        std::lock_guard<std::mutex> guard(m_get_queues_function_mutex);
         // First stage is to make the ClangUtility to hold our injected function:
 
         if (!m_get_queues_impl_code_up.get())

     page_to_free_size_value.SetValueType (Value::eValueTypeScalar);
     page_to_free_size_value.SetCompilerType (clang_uint64_type);
 
-
-    Mutex::Locker locker(m_get_queues_retbuffer_mutex);
+    std::lock_guard<std::mutex> guard(m_get_queues_retbuffer_mutex);
     if (m_get_queues_return_buffer_addr == LLDB_INVALID_ADDRESS)
     {
         addr_t bufaddr = process_sp->AllocateMemory (32, ePermissionsReadable | ePermissionsWritable, error);

source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h

 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <vector>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-public.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/CompilerType.h"
 
 // This class will insert a UtilityFunction into the inferior process for

 
     lldb_private::Process *m_process;
     std::unique_ptr<UtilityFunction> m_get_thread_item_info_impl_code;
-    Mutex m_get_thread_item_info_function_mutex;
+    std::mutex m_get_thread_item_info_function_mutex;
 
     lldb::addr_t m_get_thread_item_info_return_buffer_addr;
-    Mutex m_get_thread_item_info_retbuffer_mutex;
-
+    std::mutex m_get_thread_item_info_retbuffer_mutex;
 };
 
 }  // using namespace lldb_private

source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

 }                                                                                                               \n\
 ";
 
-AppleGetThreadItemInfoHandler::AppleGetThreadItemInfoHandler (Process *process) :
-    m_process (process),
-    m_get_thread_item_info_impl_code (),
+AppleGetThreadItemInfoHandler::AppleGetThreadItemInfoHandler(Process *process)
+    : m_process(process),
+      m_get_thread_item_info_impl_code(),
       m_get_thread_item_info_function_mutex(),
-    m_get_thread_item_info_return_buffer_addr (LLDB_INVALID_ADDRESS),
+      m_get_thread_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
       m_get_thread_item_info_retbuffer_mutex()
 {
 }
 

 }
 
 void
-AppleGetThreadItemInfoHandler::Detach ()
+AppleGetThreadItemInfoHandler::Detach()
 {
 
     if (m_process && m_process->IsAlive() && m_get_thread_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS)
     {
-        Mutex::Locker locker;
-        locker.TryLock (m_get_thread_item_info_retbuffer_mutex);  // Even if we don't get the lock, deallocate the buffer
-        m_process->DeallocateMemory (m_get_thread_item_info_return_buffer_addr);
+        std::unique_lock<std::mutex> lock(m_get_thread_item_info_retbuffer_mutex, std::defer_lock);
+        lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
+        m_process->DeallocateMemory(m_get_thread_item_info_return_buffer_addr);
     }
 }
 

 
     // Scope for mutex locker:
     {
-        Mutex::Locker locker(m_get_thread_item_info_function_mutex);
-        
+        std::lock_guard<std::mutex> guard(m_get_thread_item_info_function_mutex);
         // First stage is to make the ClangUtility to hold our injected function:
 
         if (!m_get_thread_item_info_impl_code.get())

     page_to_free_size_value.SetValueType (Value::eValueTypeScalar);
     page_to_free_size_value.SetCompilerType (clang_uint64_type);
 
-
-    Mutex::Locker locker(m_get_thread_item_info_retbuffer_mutex);
+    std::lock_guard<std::mutex> guard(m_get_thread_item_info_retbuffer_mutex);
     if (m_get_thread_item_info_return_buffer_addr == LLDB_INVALID_ADDRESS)
     {
         addr_t bufaddr = process_sp->AllocateMemory (32, ePermissionsReadable | ePermissionsWritable, error);

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <vector>
 #include <string>
 

 #include "lldb/Core/StructuredData.h"
 #include "lldb/Core/UUID.h"
 #include "lldb/Host/FileSpec.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/QueueItem.h"
 

 
 protected:
     lldb::user_id_t m_break_id;
-    mutable lldb_private::Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 
 private:
     struct libBacktraceRecording_info {

source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.cpp

 //----------------------------------------------------------------------
 // Constructor
 //----------------------------------------------------------------------
-SystemRuntimeMacOSX::SystemRuntimeMacOSX (Process* process) :
-    SystemRuntime(process),
+SystemRuntimeMacOSX::SystemRuntimeMacOSX(Process *process)
+    : SystemRuntime(process),
       m_break_id(LLDB_INVALID_BREAK_ID),
-    m_mutex(Mutex::eMutexTypeRecursive),
+      m_mutex(),
       m_get_queues_handler(process),
       m_get_pending_items_handler(process),
       m_get_item_info_handler(process),
       m_get_thread_item_info_handler(process),
       m_page_to_free(LLDB_INVALID_ADDRESS),
       m_page_to_free_size(0),
       m_lib_backtrace_recording_info(),
-    m_dispatch_queue_offsets_addr (LLDB_INVALID_ADDRESS),
+      m_dispatch_queue_offsets_addr(LLDB_INVALID_ADDRESS),
       m_libdispatch_offsets(),
-    m_libpthread_layout_offsets_addr (LLDB_INVALID_ADDRESS),
+      m_libpthread_layout_offsets_addr(LLDB_INVALID_ADDRESS),
       m_libpthread_offsets(),
-    m_dispatch_tsd_indexes_addr (LLDB_INVALID_ADDRESS),
+      m_dispatch_tsd_indexes_addr(LLDB_INVALID_ADDRESS),
       m_libdispatch_tsd_indexes(),
-    m_dispatch_voucher_offsets_addr (LLDB_INVALID_ADDRESS),
+      m_dispatch_voucher_offsets_addr(LLDB_INVALID_ADDRESS),
       m_libdispatch_voucher_offsets()
 {
 }
 

 void
 SystemRuntimeMacOSX::Clear (bool clear_process)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (m_process->IsAlive() && LLDB_BREAK_ID_IS_VALID(m_break_id))
         m_process->ClearBreakpointSiteByID(m_break_id);

source/Symbol/FuncUnwinders.cpp

 /// constructor
 //------------------------------------------------
 
-FuncUnwinders::FuncUnwinders (UnwindTable& unwind_table, AddressRange range) : 
-    m_unwind_table (unwind_table), 
-    m_range (range), 
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_unwind_plan_assembly_sp (),
-    m_unwind_plan_eh_frame_sp (),
-    m_unwind_plan_eh_frame_augmented_sp (),
-    m_unwind_plan_compact_unwind (),
-    m_unwind_plan_arm_unwind_sp (),
-    m_unwind_plan_fast_sp (), 
-    m_unwind_plan_arch_default_sp (), 
-    m_unwind_plan_arch_default_at_func_entry_sp (),
-    m_tried_unwind_plan_assembly (false),
-    m_tried_unwind_plan_eh_frame (false),
-    m_tried_unwind_plan_eh_frame_augmented (false),
-    m_tried_unwind_plan_compact_unwind (false),
-    m_tried_unwind_plan_arm_unwind (false),
-    m_tried_unwind_fast (false),
-    m_tried_unwind_arch_default (false),
-    m_tried_unwind_arch_default_at_func_entry (false),
-    m_first_non_prologue_insn ()
+FuncUnwinders::FuncUnwinders(UnwindTable &unwind_table, AddressRange range)
+    : m_unwind_table(unwind_table),
+      m_range(range),
+      m_mutex(),
+      m_unwind_plan_assembly_sp(),
+      m_unwind_plan_eh_frame_sp(),
+      m_unwind_plan_eh_frame_augmented_sp(),
+      m_unwind_plan_compact_unwind(),
+      m_unwind_plan_arm_unwind_sp(),
+      m_unwind_plan_fast_sp(),
+      m_unwind_plan_arch_default_sp(),
+      m_unwind_plan_arch_default_at_func_entry_sp(),
+      m_tried_unwind_plan_assembly(false),
+      m_tried_unwind_plan_eh_frame(false),
+      m_tried_unwind_plan_eh_frame_augmented(false),
+      m_tried_unwind_plan_compact_unwind(false),
+      m_tried_unwind_plan_arm_unwind(false),
+      m_tried_unwind_fast(false),
+      m_tried_unwind_arch_default(false),
+      m_tried_unwind_arch_default_at_func_entry(false),
+      m_first_non_prologue_insn()
 {
 }
 

 UnwindPlanSP
 FuncUnwinders::GetUnwindPlanAtCallSite (Target &target, int current_offset)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     UnwindPlanSP unwind_plan_sp = GetEHFrameUnwindPlan (target, current_offset);
     if (unwind_plan_sp)

     if (m_tried_unwind_plan_compact_unwind)
         return UnwindPlanSP();
 
-    Mutex::Locker lock (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_plan_compact_unwind = true;
     if (m_range.GetBaseAddress().IsValid())
     {

     if (m_unwind_plan_eh_frame_sp.get() || m_tried_unwind_plan_eh_frame)
         return m_unwind_plan_eh_frame_sp;
 
-    Mutex::Locker lock (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_plan_eh_frame = true;
     if (m_range.GetBaseAddress().IsValid())
     {

     if (m_unwind_plan_arm_unwind_sp.get() || m_tried_unwind_plan_arm_unwind)
         return m_unwind_plan_arm_unwind_sp;
 
-    Mutex::Locker lock (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_plan_arm_unwind = true;
     if (m_range.GetBaseAddress().IsValid())
     {

             return m_unwind_plan_eh_frame_augmented_sp;
     }
 
-    Mutex::Locker lock (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_plan_eh_frame_augmented = true;
 
     UnwindPlanSP eh_frame_plan = GetEHFrameUnwindPlan (target, current_offset);

         return m_unwind_plan_assembly_sp;
     }
 
-    Mutex::Locker lock (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_plan_assembly = true;
 
     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));

     if (m_unwind_plan_fast_sp.get() || m_tried_unwind_fast)
         return m_unwind_plan_fast_sp;
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_fast = true;
 
     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));

     if (m_unwind_plan_arch_default_sp.get() || m_tried_unwind_arch_default)
         return m_unwind_plan_arch_default_sp;
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_arch_default = true;
 
     Address current_pc;

     if (m_unwind_plan_arch_default_at_func_entry_sp.get() || m_tried_unwind_arch_default_at_func_entry)
         return m_unwind_plan_arch_default_at_func_entry_sp;
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_tried_unwind_arch_default_at_func_entry = true;
 
     Address current_pc;

     if (m_first_non_prologue_insn.IsValid())
         return m_first_non_prologue_insn;
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     ExecutionContext exe_ctx (target.shared_from_this(), false);
     UnwindAssemblySP assembly_profiler_sp (GetUnwindAssemblyProfiler(target));
     if (assembly_profiler_sp)

source/Symbol/ObjectFile.cpp

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
         if (log)
             log->Printf ("%p ObjectFile::ClearSymtab () symtab = %p",

             ModuleSP module_sp(GetModule());
             if (module_sp)
             {
-                lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
                 CreateSections(*module_sp->GetUnifiedSectionList());
             }
         }

source/Symbol/SymbolVendor.cpp

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (objfile_sp)
         {
             m_objfile_sp = objfile_sp;

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         const size_t num_compile_units = GetNumCompileUnits();
         if (idx < num_compile_units)
         {

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_compile_units.empty())
         {
             if (m_sym_file_ap.get())

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitLanguage(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitFunctions(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitLineTable(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitDebugMacros(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseCompileUnitSupportFiles(sc, support_files);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseImportedModules(sc, imported_modules);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseFunctionBlocks(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseTypes(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ParseVariablesForContext(sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ResolveTypeUID(type_uid);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ResolveSymbolContext(so_addr, resolve_scope, sc);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, sc_list);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindGlobalVariables(name, parent_decl_ctx, append, max_matches, variables);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindGlobalVariables(regex, append, max_matches, variables);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindFunctions(name, parent_decl_ctx, name_type_mask, include_inlines, append, sc_list);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindFunctions(regex, include_inlines, append, sc_list);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, append, max_matches, searched_symbol_files, types);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindTypes(context, append, types);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->GetTypes (sc_scope, type_mask, type_list);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             namespace_decl_ctx = m_sym_file_ap->FindNamespace (sc, name, parent_decl_ctx);
     }

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
         bool show_context = false;
 

     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
-        lldb_private::Mutex::Locker locker(module_sp->GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
         const size_t num_compile_units = GetNumCompileUnits();
         if (idx < num_compile_units)
         {

source/Target/JITLoaderList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-JITLoaderList::JITLoaderList()
-    : m_jit_loaders_vec(), m_jit_loaders_mutex(Mutex::eMutexTypeRecursive)
+JITLoaderList::JITLoaderList() : m_jit_loaders_vec(), m_jit_loaders_mutex()
 {
 }
 

 void
 JITLoaderList::Append (const JITLoaderSP &jit_loader_sp)
 {
-    Mutex::Locker locker(m_jit_loaders_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
     m_jit_loaders_vec.push_back(jit_loader_sp);
 }
 
 void
 JITLoaderList::Remove (const JITLoaderSP &jit_loader_sp)
 {
-    Mutex::Locker locker(m_jit_loaders_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
     m_jit_loaders_vec.erase(std::remove(m_jit_loaders_vec.begin(),
                                         m_jit_loaders_vec.end(), jit_loader_sp),
                             m_jit_loaders_vec.end());

 JITLoaderSP
 JITLoaderList::GetLoaderAtIndex (size_t idx)
 {
-    Mutex::Locker locker(m_jit_loaders_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
     return m_jit_loaders_vec[idx];
 }
 
 void
 JITLoaderList::DidLaunch()
 {
-    Mutex::Locker locker(m_jit_loaders_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
     for (auto const &jit_loader : m_jit_loaders_vec)
         jit_loader->DidLaunch();
 }

 void
 JITLoaderList::DidAttach()
 {
-    Mutex::Locker locker(m_jit_loaders_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
     for (auto const &jit_loader : m_jit_loaders_vec)
         jit_loader->DidAttach();
 }

 void
 JITLoaderList::ModulesDidLoad(ModuleList &module_list)
 {
-    Mutex::Locker locker(m_jit_loaders_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
     for (auto const &jit_loader : m_jit_loaders_vec)
         jit_loader->ModulesDidLoad(module_list);
 }

source/Target/Language.cpp

     
     return *g_map;
 }
-static Mutex&
-GetLanguagesMutex ()
+static std::mutex &
+GetLanguagesMutex()
 {
-    static Mutex *g_mutex = nullptr;
+    static std::mutex *g_mutex = nullptr;
     static std::once_flag g_initialize;
-    
     std::call_once(g_initialize, [] {
-        g_mutex = new Mutex(); // NOTE: INTENTIONAL LEAK due to global destructor chain
+        g_mutex = new std::mutex(); // NOTE: INTENTIONAL LEAK due to global destructor chain
     });
-    
     return *g_mutex;
 }
 
 Language*
 Language::FindPlugin (lldb::LanguageType language)
 {
-    Mutex::Locker locker(GetLanguagesMutex());
+    std::lock_guard<std::mutex> guard(GetLanguagesMutex());
     LanguagesMap& map(GetLanguagesMap());
     auto iter = map.find(language), end = map.end();
     if (iter != end)

 void
 Language::ForEach (std::function<bool(Language*)> callback)
 {
-    Mutex::Locker locker(GetLanguagesMutex());
+    std::lock_guard<std::mutex> guard(GetLanguagesMutex());
     LanguagesMap& map(GetLanguagesMap());
     for (const auto& entry : map)
     {

source/Target/Platform.cpp

     return g_platform_list;
 }
 
-static Mutex &
-GetPlatformListMutex ()
+static std::recursive_mutex &
+GetPlatformListMutex()
 {
-    static Mutex g_mutex(Mutex::eMutexTypeRecursive);
+    static std::recursive_mutex g_mutex;
     return g_mutex;
 }
 

     {
         if (--g_initialize_count == 0)
         {
-            Mutex::Locker locker(GetPlatformListMutex ());
+            std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
             GetPlatformList().clear();
         }
     }

 
     if (platform_sp)
     {
-        Mutex::Locker locker(GetPlatformListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
         GetPlatformList().push_back(platform_sp);
     }
 }

         if (name == g_host_platform_name)
             return GetHostPlatform();
 
-        Mutex::Locker locker(GetPlatformListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
         for (const auto &platform_sp : GetPlatformList())
         {
             if (platform_sp->GetName() == name)

 
     if (platform_sp)
     {
-        Mutex::Locker locker(GetPlatformListMutex ());
+        std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
         GetPlatformList().push_back(platform_sp);
     }
 

         // Scope for locker
         {
             // First try exact arch matches across all platforms already created
-            Mutex::Locker locker(GetPlatformListMutex ());
+            std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
             for (const auto &platform_sp : GetPlatformList())
             {
                 if (platform_sp->IsCompatibleArchitecture(arch, true, platform_arch_ptr))

                 platform_sp = create_callback(false, &arch);
                 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, true, platform_arch_ptr))
                 {
-                    Mutex::Locker locker(GetPlatformListMutex ());
+                    std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
                     GetPlatformList().push_back(platform_sp);
                     return platform_sp;
                 }

                 platform_sp = create_callback(false, &arch);
                 if (platform_sp && platform_sp->IsCompatibleArchitecture(arch, false, platform_arch_ptr))
                 {
-                    Mutex::Locker locker(GetPlatformListMutex ());
+                    std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
                     GetPlatformList().push_back(platform_sp);
                     return platform_sp;
                 }

 //------------------------------------------------------------------
 /// Default Constructor
 //------------------------------------------------------------------
-Platform::Platform (bool is_host) :
-    m_is_host (is_host),
-    m_os_version_set_while_connected (false),
-    m_system_arch_set_while_connected (false),
-    m_sdk_sysroot (),
-    m_sdk_build (),
-    m_working_dir (),
-    m_remote_url (),
-    m_name (),
-    m_major_os_version (UINT32_MAX),
-    m_minor_os_version (UINT32_MAX),
-    m_update_os_version (UINT32_MAX),
+Platform::Platform(bool is_host)
+    : m_is_host(is_host),
+      m_os_version_set_while_connected(false),
+      m_system_arch_set_while_connected(false),
+      m_sdk_sysroot(),
+      m_sdk_build(),
+      m_working_dir(),
+      m_remote_url(),
+      m_name(),
+      m_major_os_version(UINT32_MAX),
+      m_minor_os_version(UINT32_MAX),
+      m_update_os_version(UINT32_MAX),
       m_system_arch(),
-    m_mutex (Mutex::eMutexTypeRecursive),
+      m_mutex(),
       m_uid_map(),
       m_gid_map(),
-    m_max_uid_name_len (0),
-    m_max_gid_name_len (0),
-    m_supports_rsync (false),
-    m_rsync_opts (),
-    m_rsync_prefix (),
-    m_supports_ssh (false),
-    m_ssh_opts (),
-    m_ignores_remote_hostname (false),
+      m_max_uid_name_len(0),
+      m_max_gid_name_len(0),
+      m_supports_rsync(false),
+      m_rsync_opts(),
+      m_rsync_prefix(),
+      m_supports_ssh(false),
+      m_ssh_opts(),
+      m_ignores_remote_hostname(false),
       m_trap_handlers(),
-    m_calculated_trap_handlers (false),
-    m_module_cache (llvm::make_unique<ModuleCache> ())
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+      m_calculated_trap_handlers(false),
+      m_module_cache(llvm::make_unique<ModuleCache>())
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf ("%p Platform::Platform()", static_cast<void*>(this));
+        log->Printf("%p Platform::Platform()", static_cast<void *>(this));
 }
 
 //------------------------------------------------------------------

                         uint32_t &update,
                         Process *process)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
 
     bool success = m_major_os_version != UINT32_MAX;
     if (IsHost())

 {
     if (!m_calculated_trap_handlers)
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::mutex> guard(m_mutex);
         if (!m_calculated_trap_handlers)
         {
             CalculateTrapHandlerSymbolNames();

source/Target/Process.cpp

         log->Printf("Process::SetPrivateState (%s)", StateAsCString(new_state));
 
     Mutex::Locker thread_locker(m_thread_list.GetMutex());
-    Mutex::Locker locker(m_private_state.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_private_state.GetMutex());
 
     const StateType old_state = m_private_state.GetValueNoLock ();
     state_changed = old_state != new_state;

source/Target/SectionLoadHistory.cpp

 bool
 SectionLoadHistory::IsEmpty() const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_stop_id_to_section_load_list.empty();
 }
 
 void
 SectionLoadHistory::Clear ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_stop_id_to_section_load_list.clear();
 }
 
 uint32_t
 SectionLoadHistory::GetLastStopID() const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_stop_id_to_section_load_list.empty())
         return 0;
     else

 SectionLoadHistory::GetCurrentSectionLoadList ()
 {
     const bool read_only = true;
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     SectionLoadList *section_load_list = GetSectionLoadListForStopID (eStopIDNow, read_only);
     assert(section_load_list != NULL);
     return *section_load_list;

 addr_t
 SectionLoadHistory::GetSectionLoadAddress (uint32_t stop_id, const lldb::SectionSP &section_sp)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const bool read_only = true;
     SectionLoadList *section_load_list = GetSectionLoadListForStopID (stop_id, read_only);
     return section_load_list->GetSectionLoadAddress(section_sp);

 SectionLoadHistory::ResolveLoadAddress (uint32_t stop_id, addr_t load_addr, Address &so_addr)
 {
     // First find the top level section that this load address exists in
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const bool read_only = true;
     SectionLoadList *section_load_list = GetSectionLoadListForStopID (stop_id, read_only);
     return section_load_list->ResolveLoadAddress (load_addr, so_addr);

                                            addr_t load_addr,
                                            bool warn_multiple)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const bool read_only = false;
     SectionLoadList *section_load_list = GetSectionLoadListForStopID (stop_id, read_only);
     return section_load_list->SetSectionLoadAddress(section_sp, load_addr, warn_multiple);

 size_t
 SectionLoadHistory::SetSectionUnloaded (uint32_t stop_id, const lldb::SectionSP &section_sp)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const bool read_only = false;
     SectionLoadList *section_load_list = GetSectionLoadListForStopID (stop_id, read_only);
     return section_load_list->SetSectionUnloaded (section_sp);

 bool
 SectionLoadHistory::SetSectionUnloaded (uint32_t stop_id, const lldb::SectionSP &section_sp, addr_t load_addr)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const bool read_only = false;
     SectionLoadList *section_load_list = GetSectionLoadListForStopID (stop_id, read_only);
     return section_load_list->SetSectionUnloaded (section_sp, load_addr);

 void
 SectionLoadHistory::Dump (Stream &s, Target *target)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     StopIDToSectionLoadList::iterator pos, end = m_stop_id_to_section_load_list.end();
     for (pos = m_stop_id_to_section_load_list.begin(); pos != end; ++pos)
     {

source/Target/SectionLoadList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-
-SectionLoadList::SectionLoadList (const SectionLoadList& rhs) :
-    m_addr_to_sect(),
-    m_sect_to_addr(),
-    m_mutex (Mutex::eMutexTypeRecursive)
+SectionLoadList::SectionLoadList(const SectionLoadList &rhs) : m_addr_to_sect(), m_sect_to_addr(), m_mutex()
 {
-    Mutex::Locker locker(rhs.m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(rhs.m_mutex);
     m_addr_to_sect = rhs.m_addr_to_sect;
     m_sect_to_addr = rhs.m_sect_to_addr;
 }

 void
 SectionLoadList::operator=(const SectionLoadList &rhs)
 {
-    Mutex::Locker lhs_locker (m_mutex);
-    Mutex::Locker rhs_locker (rhs.m_mutex);
+    std::lock_guard<std::recursive_mutex> lhs_guard(m_mutex);
+    std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_mutex);
     m_addr_to_sect = rhs.m_addr_to_sect;
     m_sect_to_addr = rhs.m_sect_to_addr;
 }

 bool
 SectionLoadList::IsEmpty() const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_addr_to_sect.empty();
 }
 
 void
 SectionLoadList::Clear ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_addr_to_sect.clear();
     m_sect_to_addr.clear();
 }

     addr_t section_load_addr = LLDB_INVALID_ADDRESS;
     if (section)
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         sect_to_addr_collection::const_iterator pos = m_sect_to_addr.find (section.get());
         
         if (pos != m_sect_to_addr.end())

             return false; // No change
 
         // Fill in the section -> load_addr map
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section.get());
         if (sta_pos != m_sect_to_addr.end())
         {

                          section_sp->GetName().AsCString());
         }
 
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
         sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
         if (sta_pos != m_sect_to_addr.end())

                      section_sp->GetName().AsCString(), load_addr);
     }
     bool erased = false;
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     sect_to_addr_collection::iterator sta_pos = m_sect_to_addr.find(section_sp.get());
     if (sta_pos != m_sect_to_addr.end())
     {

 SectionLoadList::ResolveLoadAddress (addr_t load_addr, Address &so_addr) const
 {
     // First find the top level section that this load address exists in    
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_addr_to_sect.empty())
     {
         addr_to_sect_collection::const_iterator pos = m_addr_to_sect.lower_bound (load_addr);

 void
 SectionLoadList::Dump (Stream &s, Target *target)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     addr_to_sect_collection::const_iterator pos, end;
     for (pos = m_addr_to_sect.begin(), end = m_addr_to_sect.end(); pos != end; ++pos)
     {

source/Target/Target.cpp

 ClangModulesDeclVendor *
 Target::GetClangModulesDeclVendor ()
 {
-    static Mutex s_clang_modules_decl_vendor_mutex; // If this is contended we can make it per-target
-    
+    static std::mutex s_clang_modules_decl_vendor_mutex; // If this is contended we can make it per-target
     {
-        Mutex::Locker clang_modules_decl_vendor_locker(s_clang_modules_decl_vendor_mutex);
-        
+        std::lock_guard<std::mutex> guard(s_clang_modules_decl_vendor_mutex);
         if (!m_clang_modules_decl_vendor_ap)
         {
             m_clang_modules_decl_vendor_ap.reset(ClangModulesDeclVendor::Create(*this));

source/Target/TargetList.cpp

 //----------------------------------------------------------------------
 // TargetList constructor
 //----------------------------------------------------------------------
-TargetList::TargetList(Debugger &debugger) :
-    Broadcaster(debugger.GetBroadcasterManager(), TargetList::GetStaticBroadcasterClass().AsCString()),
+TargetList::TargetList(Debugger &debugger)
+    : Broadcaster(debugger.GetBroadcasterManager(), TargetList::GetStaticBroadcasterClass().AsCString()),
       m_target_list(),
-    m_target_list_mutex (Mutex::eMutexTypeRecursive),
-    m_selected_target_idx (0)
+      m_target_list_mutex(),
+      m_selected_target_idx(0)
 {
     CheckInWithManager();
 }

 //----------------------------------------------------------------------
 TargetList::~TargetList()
 {
-    Mutex::Locker locker(m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     m_target_list.clear();
 }
 

         // Don't put the dummy target in the target list, it's held separately.
         if (!is_dummy_target)
         {
-            Mutex::Locker locker(m_target_list_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
             m_selected_target_idx = m_target_list.size();
             m_target_list.push_back(target_sp);
             // Now prime this from the dummy target:

 bool
 TargetList::DeleteTarget (TargetSP &target_sp)
 {
-    Mutex::Locker locker(m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     collection::iterator pos, end = m_target_list.end();
 
     for (pos = m_target_list.begin(); pos != end; ++pos)

 TargetList::FindTargetWithExecutableAndArchitecture(const FileSpec &exe_file_spec,
                                                     const ArchSpec *exe_arch_ptr) const
 {
-    Mutex::Locker locker (m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     TargetSP target_sp;
     bool full_match = (bool)exe_file_spec.GetDirectory();
 

 TargetSP
 TargetList::FindTargetWithProcessID (lldb::pid_t pid) const
 {
-    Mutex::Locker locker(m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     TargetSP target_sp;
     collection::const_iterator pos, end = m_target_list.end();
     for (pos = m_target_list.begin(); pos != end; ++pos)

     TargetSP target_sp;
     if (process)
     {
-        Mutex::Locker locker(m_target_list_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
         collection::const_iterator pos, end = m_target_list.end();
         for (pos = m_target_list.begin(); pos != end; ++pos)
         {

     TargetSP target_sp;
     if (target)
     {
-        Mutex::Locker locker(m_target_list_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
         collection::const_iterator pos, end = m_target_list.end();
         for (pos = m_target_list.begin(); pos != end; ++pos)
         {

     if (pid == LLDB_INVALID_PROCESS_ID)
     {
         // Signal all processes with signal
-        Mutex::Locker locker(m_target_list_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
         collection::iterator pos, end = m_target_list.end();
         for (pos = m_target_list.begin(); pos != end; ++pos)
         {

 int
 TargetList::GetNumTargets () const
 {
-    Mutex::Locker locker (m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     return m_target_list.size();
 }
 

 TargetList::GetTargetAtIndex (uint32_t idx) const
 {
     TargetSP target_sp;
-    Mutex::Locker locker (m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     if (idx < m_target_list.size())
         target_sp = m_target_list[idx];
     return target_sp;

 uint32_t
 TargetList::GetIndexOfTarget (lldb::TargetSP target_sp) const
 {
-    Mutex::Locker locker (m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     size_t num_targets = m_target_list.size();
     for (size_t idx = 0; idx < num_targets; idx++)
     {

 uint32_t
 TargetList::SetSelectedTarget (Target* target)
 {
-    Mutex::Locker locker (m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     collection::const_iterator pos,
         begin = m_target_list.begin(),
         end = m_target_list.end();

 lldb::TargetSP
 TargetList::GetSelectedTarget ()
 {
-    Mutex::Locker locker (m_target_list_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_target_list_mutex);
     if (m_selected_target_idx >= m_target_list.size())
         m_selected_target_idx = 0;
     return GetTargetAtIndex (m_selected_target_idx);

source/Target/Thread.cpp

 
 // C Includes
 // C++ Includes
-#include <mutex>
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"

     return class_name;
 }
 
-Thread::Thread (Process &process, lldb::tid_t tid, bool use_invalid_index_id) :
-    ThreadProperties (false),
-    UserID (tid),
-    Broadcaster(process.GetTarget().GetDebugger().GetBroadcasterManager(), Thread::GetStaticBroadcasterClass().AsCString()),
-    m_process_wp (process.shared_from_this()),
-    m_stop_info_sp (),
-    m_stop_info_stop_id (0),
-    m_stop_info_override_stop_id (0),
-    m_index_id (use_invalid_index_id ? LLDB_INVALID_INDEX32 : process.GetNextThreadIndexID(tid)),
-    m_reg_context_sp (),
-    m_state (eStateUnloaded),
-    m_state_mutex (Mutex::eMutexTypeRecursive),
-    m_plan_stack (),
-    m_completed_plan_stack(),
-    m_frame_mutex (Mutex::eMutexTypeRecursive),
-    m_curr_frames_sp (),
-    m_prev_frames_sp (),
-    m_resume_signal (LLDB_INVALID_SIGNAL_NUMBER),
-    m_resume_state (eStateRunning),
-    m_temporary_resume_state (eStateRunning),
-    m_unwinder_ap (),
-    m_destroy_called (false),
-    m_override_should_notify (eLazyBoolCalculate),
-    m_extended_info_fetched (false),
-    m_extended_info ()
-{
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+Thread::Thread(Process &process, lldb::tid_t tid, bool use_invalid_index_id)
+    : ThreadProperties(false),
+      UserID(tid),
+      Broadcaster(process.GetTarget().GetDebugger().GetBroadcasterManager(),
+                  Thread::GetStaticBroadcasterClass().AsCString()),
+      m_process_wp(process.shared_from_this()),
+      m_stop_info_sp(),
+      m_stop_info_stop_id(0),
+      m_stop_info_override_stop_id(0),
+      m_index_id(use_invalid_index_id ? LLDB_INVALID_INDEX32 : process.GetNextThreadIndexID(tid)),
+      m_reg_context_sp(),
+      m_state(eStateUnloaded),
+      m_state_mutex(),
+      m_plan_stack(),
+      m_completed_plan_stack(),
+      m_frame_mutex(),
+      m_curr_frames_sp(),
+      m_prev_frames_sp(),
+      m_resume_signal(LLDB_INVALID_SIGNAL_NUMBER),
+      m_resume_state(eStateRunning),
+      m_temporary_resume_state(eStateRunning),
+      m_unwinder_ap(),
+      m_destroy_called(false),
+      m_override_should_notify(eLazyBoolCalculate),
+      m_extended_info_fetched(false),
+      m_extended_info()
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf ("%p Thread::Thread(tid = 0x%4.4" PRIx64 ")",
-                     static_cast<void*>(this), GetID());
+        log->Printf("%p Thread::Thread(tid = 0x%4.4" PRIx64 ")", static_cast<void *>(this), GetID());
 
     CheckInWithManager();
     QueueFundamentalPlan(true);

     m_stop_info_sp.reset();
     m_reg_context_sp.reset();
     m_unwinder_ap.reset();
-    Mutex::Locker locker(m_frame_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
     m_curr_frames_sp.reset();
     m_prev_frames_sp.reset();
 }

 Thread::GetState() const
 {
     // If any other threads access this we will need a mutex for it
-    Mutex::Locker locker(m_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
     return m_state;
 }
 
 void
 Thread::SetState(StateType state)
 {
-    Mutex::Locker locker(m_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_state_mutex);
     m_state = state;
 }
 

 Thread::GetStackFrameList ()
 {
     StackFrameListSP frame_list_sp;
-    Mutex::Locker locker(m_frame_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
     if (m_curr_frames_sp)
     {
         frame_list_sp = m_curr_frames_sp;

 void
 Thread::ClearStackFrames ()
 {
-    Mutex::Locker locker(m_frame_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_frame_mutex);
 
     Unwind *unwinder = GetUnwinder ();
     if (unwinder)

source/Target/ThreadPlan.cpp

 //----------------------------------------------------------------------
 // ThreadPlan constructor
 //----------------------------------------------------------------------
-ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread, Vote stop_vote, Vote run_vote) :
-    m_thread (thread),
-    m_stop_vote (stop_vote),
-    m_run_vote (run_vote),
-    m_kind (kind),
-    m_name (name),
-    m_plan_complete_mutex (Mutex::eMutexTypeRecursive),
-    m_cached_plan_explains_stop (eLazyBoolCalculate),
-    m_plan_complete (false),
-    m_plan_private (false),
-    m_okay_to_discard (true),
-    m_is_master_plan (false),
+ThreadPlan::ThreadPlan(ThreadPlanKind kind, const char *name, Thread &thread, Vote stop_vote, Vote run_vote)
+    : m_thread(thread),
+      m_stop_vote(stop_vote),
+      m_run_vote(run_vote),
+      m_kind(kind),
+      m_name(name),
+      m_plan_complete_mutex(),
+      m_cached_plan_explains_stop(eLazyBoolCalculate),
+      m_plan_complete(false),
+      m_plan_private(false),
+      m_okay_to_discard(true),
+      m_is_master_plan(false),
       m_plan_succeeded(true)
 {
-    SetID (GetNextID());
+    SetID(GetNextID());
 }
 
 //----------------------------------------------------------------------

 bool
 ThreadPlan::IsPlanComplete ()
 {
-    Mutex::Locker locker(m_plan_complete_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
     return m_plan_complete;
 }
 
 void
 ThreadPlan::SetPlanComplete (bool success)
 {
-    Mutex::Locker locker(m_plan_complete_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
     m_plan_complete = true;
     m_plan_succeeded = success;
 }

 bool
 ThreadPlan::MischiefManaged ()
 {
-    Mutex::Locker locker(m_plan_complete_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_plan_complete_mutex);
     // Mark the plan is complete, but don't override the success flag.
     m_plan_complete = true;
     return true;

source/Utility/SharingPtr.cpp

 // If ENABLE_SP_LOGGING is defined, then log all shared pointer assignments
 // and allow them to be queried using a pointer by a call to:
 #include <execinfo.h>
-#include <map>
 #include <assert.h>
-#include "lldb/Host/Mutex.h"
 
 #include "llvm/ADT/STLExtras.h"
 
+#include <map>
+#include <mutex>
 #include <vector>
 
 class Backtrace

 {
     typedef std::pair<void *, Backtrace> PtrBacktracePair;
     typedef std::map<void *, PtrBacktracePair> PtrToBacktraceMap;
-    static lldb_private::Mutex g_mutex(lldb_private::Mutex::eMutexTypeNormal);
-    lldb_private::Mutex::Locker locker (g_mutex);
+    static std::mutex g_mutex;
+    std::lock_guard<std::mutex> guard(g_mutex);
     static PtrToBacktraceMap g_map;
 
     if (sp_this)