second pass over removal of Mutex and Condition

[compnerd]

Summary

A second pass to remove use of Mutex and Condition. This removes cases where the mutex may be shared outside of the class or may be conditionally locked. With this patch applied the current remaining uses are limited to uses involving Condition and in the GDBCommunication code path where there is a helper mutex class. The third class of usage is DenseSet and DenseMap which allow the user to specify the mutex type (this may require a bit more tweak, template parameter is the approach which comes to mind).

The Condition changes will require changing TimeVal to chromo::duration, but we should be able to do that as well.

After this patch, I believe that there are only a handful of instances where we use the lldb_private::Mutex (~5) and the associated locations for Mutex::Locker.

[zturner]

Looks good on Windows with the two suggested fixes.

source/Interpreter/CommandObject.cpp

339

if (m_api_locker)
    m_api_locker.unlock();

Otherwise this is undefined behavior. Also make sure you do this check anywhere else in the patch where you do manual unlocking / locking like this.

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

404

change this to auto interpreter_lock so it doesn't redefine lock from line 186

[compnerd]

source/Interpreter/CommandObject.cpp

339

Yeah, this was the only place where the lock was unlocked and there wasn't a comment indicating that the assumption was that the lock will be held. A few places where there were unlocks were early releases of the unique_lock. A couple of places indicated that the lock must have been acquired prior to the destructor running.

[compnerd]

SVN r270024.

include/lldb/Breakpoint/BreakpointList.h

 // C Includes
 // C++ Includes
 #include <list>
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/Breakpoint.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_breakpoints.size(); 
     }
 

     ///   The locker object that is set.
     //------------------------------------------------------------------
     void
-    GetListMutex (lldb_private::Mutex::Locker &locker);
+    GetListMutex(std::unique_lock<std::recursive_mutex> &lock);
 
 protected:
     typedef std::list<lldb::BreakpointSP> bp_collection;

     bp_collection::const_iterator
     GetBreakpointIDConstIterator(lldb::break_id_t breakID) const;
 
-    Mutex &
-    GetMutex () const
+    std::recursive_mutex &
+    GetMutex() const
     {
         return m_mutex;
     }
 
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
     bp_collection m_breakpoints;  // The breakpoint list, currently a list.
     lldb::break_id_t m_next_break_id;
     bool m_is_internal;
 
 public:
-    typedef LockingAdaptedIterable<bp_collection, lldb::BreakpointSP, list_adapter> BreakpointIterable;
+    typedef LockingAdaptedIterable<bp_collection, lldb::BreakpointSP, list_adapter, std::recursive_mutex>
+        BreakpointIterable;
     BreakpointIterable
     Breakpoints()
     {

include/lldb/Breakpoint/BreakpointLocation.h

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

 #include "lldb/Breakpoint/StoppointLocation.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/UserID.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     std::unique_ptr<BreakpointOptions> m_options_ap; ///< Breakpoint options pointer, nullptr if we're using our breakpoint's options.
     lldb::BreakpointSiteSP m_bp_site_sp; ///< Our breakpoint site (it may be shared by more than one location.)
     lldb::UserExpressionSP m_user_expression_sp; ///< The compiled expression to use in testing our condition.
-    Mutex m_condition_mutex; ///< Guards parsing and evaluation of the condition, which could be evaluated by multiple processes.
+    std::mutex m_condition_mutex; ///< Guards parsing and evaluation of the condition, which could be evaluated by
+                                  /// multiple processes.
     size_t m_condition_hash; ///< For testing whether the condition source code changed.
 
     void

include/lldb/Breakpoint/WatchpointList.h

 // C Includes
 // C++ Includes
 #include <list>
+#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"
 
 namespace lldb_private {
 

     size_t
     GetSize() const
     {
-        Mutex::Locker locker(m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         return m_watchpoints.size();
     }
 

     ///   The locker object that is set.
     //------------------------------------------------------------------
     void
-    GetListMutex (lldb_private::Mutex::Locker &locker);
+    GetListMutex(std::unique_lock<std::recursive_mutex> &lock);
 
 protected:
     typedef std::list<lldb::WatchpointSP> wp_collection;

     GetIDConstIterator(lldb::watch_id_t watchID) const;
 
     wp_collection m_watchpoints;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
 
     lldb::watch_id_t m_next_wp_id;
 };

include/lldb/Core/IOHandler.h

 #include "lldb/Core/Stream.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Core/ValueObjectList.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/Predicate.h"
 
 namespace curses

include/lldb/Core/ModuleList.h

 // C++ Includes
 #include <functional>
 #include <list>
+#include <mutex>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Utility/Iterable.h"
 #include "llvm/ADT/DenseSet.h"
 

 
     void
     LogUUIDAndPaths (Log *log, const char *prefix_cstr);
-                     
-    Mutex &
-    GetMutex () const
+    std::recursive_mutex &
+    GetMutex() const
     {
         return m_modules_mutex;
     }
-    
     size_t
     GetIndexForModule (const Module *module) const;
 

     // Member variables.
     //------------------------------------------------------------------
     collection m_modules; ///< The collection of modules.
-    mutable Mutex m_modules_mutex;
+    mutable std::recursive_mutex m_modules_mutex;
 
     Notifier* m_notifier;
     
 public:
-    typedef LockingAdaptedIterable<collection, lldb::ModuleSP, vector_adapter> ModuleIterable;
+    typedef LockingAdaptedIterable<collection, lldb::ModuleSP, vector_adapter, std::recursive_mutex> ModuleIterable;
     ModuleIterable
     Modules()
     {

include/lldb/Host/OptionParser.h

 #ifndef liblldb_OptionParser_h_
 #define liblldb_OptionParser_h_
 
+#include <mutex>
 #include <string>
-#include "lldb/Host/Mutex.h"
 
 struct option;
 

         eOptionalArgument
     };
 
-    static void Prepare(Mutex::Locker &locker);
+    static void
+    Prepare(std::unique_lock<std::mutex> &lock);
 
     static void EnableError(bool error);
 

include/lldb/Interpreter/CommandObject.h

 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Core/StringList.h"
 #include "lldb/Core/Flags.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/ExecutionContext.h"
 
 namespace lldb_private {

 
     CommandInterpreter &m_interpreter;
     ExecutionContext m_exe_ctx;
-    Mutex::Locker m_api_locker;
+    std::unique_lock<std::recursive_mutex> m_api_locker;
     std::string m_cmd_name;
     std::string m_cmd_help_short;
     std::string m_cmd_help_long;

include/lldb/Symbol/CompactUnwindInfo.h

 #ifndef liblldb_CompactUnwindInfo_h_
 #define liblldb_CompactUnwindInfo_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/RangeMap.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/lldb-private.h"

     lldb::SectionSP             m_section_sp;
     lldb::DataBufferSP          m_section_contents_if_encrypted; // if the binary is encrypted, read the sect contents
                                                                  // out of live memory and cache them here
-    Mutex                       m_mutex;
+    std::mutex m_mutex;
     std::vector<UnwindIndex>    m_indexes;
 
     LazyBool                    m_indexes_computed;         // eLazyBoolYes once we've tried to parse the unwind info

include/lldb/Symbol/DWARFCallFrameInfo.h

 #define liblldb_DWARFCallFrameInfo_h_
 
 #include <map>
+#include <mutex>
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/DataExtractor.h"

 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/VMRange.h"
 #include "lldb/Core/dwarf.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/lldb-private.h"

 
     FDEEntryMap                 m_fde_index;
     bool                        m_fde_index_initialized;  // only scan the section for FDEs once
-    Mutex                       m_fde_index_mutex;        // and isolate the thread that does it
+    std::mutex m_fde_index_mutex;                         // and isolate the thread that does it
 
     bool                        m_is_eh_frame;
 

include/lldb/Symbol/Symtab.h

 #ifndef liblldb_Symtab_h_
 #define liblldb_Symtab_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/Symbol.h"
 
 namespace lldb_private {

             void        Dump(Stream *s, Target *target, SortOrder sort_type);
             void        Dump(Stream *s, Target *target, std::vector<uint32_t>& indexes) const;
             uint32_t    GetIndexForSymbol (const Symbol *symbol) const;
-            Mutex &     GetMutex ()
-                        {
-                            return m_mutex;
-                        }
+            std::recursive_mutex &
+            GetMutex()
+            {
+                return m_mutex;
+            }
             Symbol *    FindSymbolByID (lldb::user_id_t uid) const;
             Symbol *    SymbolAtIndex (size_t idx);
     const   Symbol *    SymbolAtIndex (size_t idx) const;

     UniqueCStringMap<uint32_t> m_basename_to_index;
     UniqueCStringMap<uint32_t> m_method_to_index;
     UniqueCStringMap<uint32_t> m_selector_to_index;
-    mutable Mutex       m_mutex; // Provide thread safety for this symbol table
+    mutable std::recursive_mutex m_mutex; // Provide thread safety for this symbol table
     bool                m_file_addr_to_index_computed:1,
                         m_name_indexes_computed:1;
 private:

include/lldb/Symbol/TypeSystem.h

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

 #include "lldb/lldb-private.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 

         AddToMap (lldb::LanguageType language, lldb::TypeSystemSP const &type_system_sp);
 
         typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection;
-        mutable Mutex m_mutex; ///< A mutex to keep this object happy in multi-threaded environments.
+        mutable std::mutex m_mutex; ///< A mutex to keep this object happy in multi-threaded environments.
         collection m_map;
         bool m_clear_in_progress;
     };

include/lldb/Symbol/UnwindTable.h

 #define liblldb_UnwindTable_h
 
 #include <map>
+#include <mutex>
 
 #include "lldb/lldb-private.h" 
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
 

     collection          m_unwinds;
 
     bool                m_initialized;  // delay some initialization until ObjectFile is set up
-    Mutex               m_mutex;
+    std::mutex m_mutex;
 
     std::unique_ptr<DWARFCallFrameInfo> m_eh_frame_up;
     std::unique_ptr<CompactUnwindInfo>  m_compact_unwind_up;

include/lldb/Target/ExecutionContext.h

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

     
     // These two variants take in a locker, and grab the target, lock the API mutex into locker, then
     // fill in the rest of the shared pointers.
-    ExecutionContext (const ExecutionContextRef &exe_ctx_ref, Mutex::Locker &locker);
-    ExecutionContext (const ExecutionContextRef *exe_ctx_ref, Mutex::Locker &locker);
+    ExecutionContext(const ExecutionContextRef &exe_ctx_ref, std::unique_lock<std::recursive_mutex> &locker);
+    ExecutionContext(const ExecutionContextRef *exe_ctx_ref, std::unique_lock<std::recursive_mutex> &locker);
     //------------------------------------------------------------------
     // Create execution contexts from execution context scopes
     //------------------------------------------------------------------

include/lldb/Target/Memory.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/RangeMap.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
     //----------------------------------------------------------------------

         //------------------------------------------------------------------
         // Classes that inherit from MemoryCache can see and modify these
         //------------------------------------------------------------------
-        Mutex m_mutex;
+        std::recursive_mutex m_mutex;
         BlockMap m_L1_cache; // A first level memory cache whose chunk sizes vary that will be used only if the memory read fits entirely in a chunk
         BlockMap m_L2_cache; // A memory cache of fixed size chinks (m_L2_cache_line_byte_size bytes in size each)
         InvalidRanges m_invalid_ranges;

         // Classes that inherit from MemoryCache can see and modify these
         //------------------------------------------------------------------
         Process &m_process;
-        Mutex m_mutex;
+        std::recursive_mutex m_mutex;
         typedef std::multimap<uint32_t, AllocatedBlockSP> PermissionsToBlockMap;
         PermissionsToBlockMap m_memory_map;
         

include/lldb/Target/Process.h

     std::map<uint64_t, uint32_t> m_thread_id_to_index_id_map;
     int                         m_exit_status;          ///< The exit status of the process, or -1 if not set.
     std::string                 m_exit_string;          ///< A textual description of why a process exited.
-    Mutex                       m_exit_status_mutex;    ///< Mutex so m_exit_status m_exit_string can be safely accessed from multiple threads
-    Mutex                       m_thread_mutex;
+    std::mutex
+        m_exit_status_mutex; ///< Mutex so m_exit_status m_exit_string can be safely accessed from multiple threads
+    std::recursive_mutex m_thread_mutex;
     ThreadList                  m_thread_list_real;     ///< The threads for this process as are known to the protocol we are debugging with
     ThreadList                  m_thread_list;          ///< The threads for this process as the user will see them. This is usually the same as
                                                         ///< m_thread_list_real, but might be different if there is an OS plug-in creating memory threads

     lldb::ABISP                 m_abi_sp;
     lldb::IOHandlerSP           m_process_input_reader;
     Communication               m_stdio_communication;
-    Mutex                       m_stdio_communication_mutex;
+    std::recursive_mutex m_stdio_communication_mutex;
     bool                        m_stdin_forward;           /// Remember if stdin must be forwarded to remote debug server
     std::string                 m_stdout_data;
     std::string                 m_stderr_data;
-    Mutex                       m_profile_data_comm_mutex;
+    std::recursive_mutex m_profile_data_comm_mutex;
     std::vector<std::string>    m_profile_data;
     Predicate<uint32_t>         m_iohandler_sync;
     MemoryCache                 m_memory_cache;

include/lldb/Target/QueueList.h

 #ifndef liblldb_QueueList_h_
 #define liblldb_QueueList_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/lldb-private.h"

     GetQueueAtIndex (uint32_t idx);
 
     typedef std::vector<lldb::QueueSP> collection;
-    typedef LockingAdaptedIterable<collection, lldb::QueueSP, vector_adapter> QueueIterable;
+    typedef LockingAdaptedIterable<collection, lldb::QueueSP, vector_adapter, std::mutex> QueueIterable;
 
     //------------------------------------------------------------------
     /// Iterate over the list of queues

     lldb::QueueSP
     FindQueueByIndexID (uint32_t index_id);
 
-    lldb_private::Mutex &
-    GetMutex ();
+    std::mutex &
+    GetMutex();
 
 protected:
 

     Process *m_process; ///< The process that manages this queue list.
     uint32_t m_stop_id; ///< The process stop ID that this queue list is valid for.
     collection m_queues; ///< The queues for this process.
-    Mutex   m_mutex;
+    std::mutex m_mutex;
 
 private:
     QueueList ();

include/lldb/Target/StackFrame.h

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

     lldb::VariableListSP m_variable_list_sp;
     ValueObjectList m_variable_list_value_objects;  // Value objects for each variable in m_variable_list_sp
     StreamString m_disassembly;
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
 
     DISALLOW_COPY_AND_ASSIGN (StackFrame);
 };

include/lldb/Target/StackFrameList.h

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

 
     Thread &m_thread;
     lldb::StackFrameListSP m_prev_frames_sp;
-    mutable Mutex m_mutex;
+    mutable std::recursive_mutex m_mutex;
     collection m_frames;
     uint32_t m_selected_frame_idx;
     uint32_t m_concrete_frames_fetched;

include/lldb/Target/Target.h

     static const lldb::TargetPropertiesSP &
     GetGlobalProperties();
 
-    Mutex &
-    GetAPIMutex ()
+    std::recursive_mutex &
+    GetAPIMutex()
     {
         return m_mutex;
     }

     //------------------------------------------------------------------
     Debugger &      m_debugger;
     lldb::PlatformSP m_platform_sp;     ///< The platform for this target.
-    Mutex           m_mutex;            ///< An API mutex that is used by the lldb::SB* classes make the SB interface thread safe
+    std::recursive_mutex
+        m_mutex; ///< An API mutex that is used by the lldb::SB* classes make the SB interface thread safe
     ArchSpec        m_arch;
     ModuleList      m_images;           ///< The list of images for this process (shared libraries and anything dynamically loaded).
     SectionLoadHistory m_section_load_history;

include/lldb/Target/ThreadCollection.h

 #ifndef liblldb_ThreadCollection_h_
 #define liblldb_ThreadCollection_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Utility/Iterable.h"
 
 namespace lldb_private {

 {
 public:
     typedef std::vector<lldb::ThreadSP> collection;
-    typedef LockingAdaptedIterable<collection, lldb::ThreadSP, vector_adapter> ThreadIterable;
-    
+    typedef LockingAdaptedIterable<collection, lldb::ThreadSP, vector_adapter, std::recursive_mutex> ThreadIterable;
     ThreadCollection();
     
     ThreadCollection(collection threads);

     {
         return ThreadIterable(m_threads, GetMutex());
     }
-    
-    virtual Mutex &
+    virtual std::recursive_mutex &
     GetMutex()
     {
         return m_mutex;
     }
-    
 protected:
     collection m_threads;
-    Mutex m_mutex;
+    std::recursive_mutex m_mutex;
 };
     
 } // namespace lldb_private

include/lldb/Target/ThreadList.h

 #ifndef liblldb_ThreadList_h_
 #define liblldb_ThreadList_h_
 
+#include <mutex>
 #include <vector>
 
 #include "lldb/lldb-private.h"

     void
     SetStopID (uint32_t stop_id);
 
-    Mutex &
+    std::recursive_mutex &
     GetMutex() override;
-    
     void
     Update (ThreadList &rhs);
     

include/lldb/Utility/Iterable.h

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

         return AdaptedConstIterator<C, E, A>(m_container.end());
     }
 };
-    
-template <typename C, typename E, E (*A)(typename C::const_iterator &)> class LockingAdaptedIterable : public AdaptedIterable<C, E, A>
+template <typename C, typename E, E (*A)(typename C::const_iterator &), typename MutexType>
+class LockingAdaptedIterable : public AdaptedIterable<C, E, A>
 {
 public:
-    LockingAdaptedIterable (C &container, Mutex &mutex) :
-        AdaptedIterable<C,E,A>(container),
-        m_mutex(&mutex)
+    LockingAdaptedIterable(C &container, MutexType &mutex) : AdaptedIterable<C, E, A>(container), m_mutex(&mutex)
     {
-        m_mutex->Lock();
+        m_mutex->lock();
     }
-    
-    LockingAdaptedIterable (LockingAdaptedIterable &&rhs) :
-        AdaptedIterable<C,E,A>(rhs),
-        m_mutex(rhs.m_mutex)
+    LockingAdaptedIterable(LockingAdaptedIterable &&rhs) : AdaptedIterable<C, E, A>(rhs), m_mutex(rhs.m_mutex)
     {
         rhs.m_mutex = nullptr;
     }
-    
-    ~LockingAdaptedIterable ()
+    ~LockingAdaptedIterable()
     {
         if (m_mutex)
-            m_mutex->Unlock();
+            m_mutex->unlock();
     }
-    
 private:
-    Mutex *m_mutex = nullptr;
+    MutexType *m_mutex = nullptr;
 
     DISALLOW_COPY_AND_ASSIGN(LockingAdaptedIterable);
 };
-    
 } // namespace lldb_private
 
 #endif // liblldb_Iterable_h_

source/API/SBAddress.cpp

 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Symbol/LineEntry.h"
 #include "lldb/Target/Target.h"
 

     {
         if (m_opaque_ap->IsValid())
         {
-            Mutex::Locker api_locker (target_sp->GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
             addr = m_opaque_ap->GetLoadAddress (target_sp.get());
         }
     }

source/API/SBBreakpoint.cpp

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->ClearAllBreakpointSites ();
     }
 }

     {
         if (vm_addr != LLDB_INVALID_ADDRESS)
         {
-            Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
             Address address;
             Target &target = m_opaque_sp->GetTarget();
             if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address))

 
     if (m_opaque_sp && vm_addr != LLDB_INVALID_ADDRESS)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         Address address;
         Target &target = m_opaque_sp->GetTarget();
         if (!target.GetSectionLoadList().ResolveLoadAddress(vm_addr, address))

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         sb_bp_location.SetLocation (m_opaque_sp->FindLocationByID (bp_loc_id));
     }
 

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         sb_bp_location.SetLocation (m_opaque_sp->GetLocationAtIndex (index));
     }
 

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetEnabled (enable);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->IsEnabled();
     }
     else

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetOneShot (one_shot);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->IsOneShot();
     }
     else

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->IsInternal();
     }
     else

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetIgnoreCount (count);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetCondition (condition);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetConditionText ();
     }
     return nullptr;

     uint32_t count = 0;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         count = m_opaque_sp->GetHitCount();
     }
 

     uint32_t count = 0;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         count = m_opaque_sp->GetIgnoreCount();
     }
 

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetThreadID (tid);
     }
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));

     tid_t tid = LLDB_INVALID_THREAD_ID;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         tid = m_opaque_sp->GetThreadID();
     }
 

                      static_cast<void*>(m_opaque_sp.get()), index);
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->GetOptions()->GetThreadSpec()->SetIndex (index);
     }
 }

     uint32_t thread_idx = UINT32_MAX;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         const ThreadSpec *thread_spec = m_opaque_sp->GetOptions()->GetThreadSpecNoCreate();
         if (thread_spec != nullptr)
             thread_idx = thread_spec->GetIndex();

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->GetOptions()->GetThreadSpec()->SetName (thread_name);
     }
 }

     const char *name = nullptr;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         const ThreadSpec *thread_spec = m_opaque_sp->GetOptions()->GetThreadSpecNoCreate();
         if (thread_spec != nullptr)
             name = thread_spec->GetName();

                      static_cast<void*>(m_opaque_sp.get()), queue_name);
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->GetOptions()->GetThreadSpec()->SetQueueName (queue_name);
     }
 }

     const char *name = nullptr;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         const ThreadSpec *thread_spec = m_opaque_sp->GetOptions()->GetThreadSpecNoCreate();
         if (thread_spec)
             name = thread_spec->GetQueueName();

     size_t num_resolved = 0;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         num_resolved = m_opaque_sp->GetNumResolvedLocations();
     }
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));

     size_t num_locs = 0;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         num_locs = m_opaque_sp->GetNumLocations();
     }
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         s.Printf("SBBreakpoint: id = %i, ", m_opaque_sp->GetID());
         m_opaque_sp->GetResolverDescription (s.get());
         m_opaque_sp->GetFilterDescription (s.get());

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         BatonSP baton_sp(new SBBreakpointCallbackBaton (callback, baton));
         m_opaque_sp->SetCallback (SBBreakpoint::PrivateBreakpointHitCallback, baton_sp, false);
     }

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         BreakpointOptions *bp_options = m_opaque_sp->GetOptions();
         m_opaque_sp->GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallbackFunction (bp_options,
                                                                                                                                                    callback_function_name);

     SBError sb_error;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         BreakpointOptions *bp_options = m_opaque_sp->GetOptions();
         Error error =  m_opaque_sp->GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
                                                                                                                                     callback_body_text);

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         Error error;  // Think I'm just going to swallow the error here, it's probably more annoying to have to provide it.
         return m_opaque_sp->AddName(new_name, error);
     }

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->RemoveName(name_to_remove);
     }
 }

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->MatchesName(name);
     }
 

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         std::vector<std::string> names_vec;
         m_opaque_sp->GetNames(names_vec);
         for (std::string name : names_vec)

source/API/SBBreakpointLocation.cpp

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         ret_addr = m_opaque_sp->GetLoadAddress();
     }
 

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetEnabled (enabled);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->IsEnabled();
     }
     else

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetIgnoreCount();
     }
     else

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetIgnoreCount (n);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetCondition (condition);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetConditionText ();
     }
     return NULL;

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
         m_opaque_sp->GetBreakpoint().GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallbackFunction (bp_options,
                                                                                                                                      callback_function_name);

     SBError sb_error;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         BreakpointOptions *bp_options = m_opaque_sp->GetLocationOptions();
         Error error = m_opaque_sp->GetBreakpoint().GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter()->SetBreakpointCommandCallback (bp_options,
                                                                                                                                                            callback_body_text);

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetThreadID (thread_id);
     }
 }

     tid_t tid = LLDB_INVALID_THREAD_ID;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetThreadID();
     }
     return tid;

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetThreadIndex (index);
     }
 }

     uint32_t thread_idx = UINT32_MAX;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetThreadIndex();
     }
     return thread_idx;

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetThreadName (thread_name);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetThreadName();
     }
     return NULL;

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->SetQueueName (queue_name);
     }
 }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->GetQueueName ();
     }
     return NULL;

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->IsResolved();
     }
     return false;

 
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         m_opaque_sp->GetDescription (&strm, level);
         strm.EOL();
     }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         return m_opaque_sp->GetID ();
     }
     else

     SBBreakpoint sb_bp;
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker (m_opaque_sp->GetBreakpoint().GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_opaque_sp->GetTarget().GetAPIMutex());
         *sb_bp = m_opaque_sp->GetBreakpoint ().shared_from_this();
     }
 

source/API/SBCommandInterpreter.cpp

         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
         if (target_sp)
         {
-            Mutex::Locker api_locker(target_sp->GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
             process_sp = target_sp->GetProcessSP();
             sb_process.SetSP(process_sp);
         }

     if (IsValid())
     {
         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
-        Mutex::Locker api_locker;
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
-            api_locker.Lock(target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
         m_opaque_ptr->SourceInitFile (false, result.ref());
     }
     else

     if (IsValid())
     {
         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
-        Mutex::Locker api_locker;
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
-            api_locker.Lock(target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
         m_opaque_ptr->SourceInitFile (true, result.ref());
     }
     else

source/API/SBDebugger.cpp

     if (m_opaque_sp)
     {
         TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
-        Mutex::Locker api_locker;
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
-            api_locker.Lock(target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 
         SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
         SBCommandReturnObject result;

     char stdio_buffer[1024];
     size_t len;
 
-    Mutex::Locker api_locker (target_sp->GetAPIMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged))
     {
         // Drain stdout when we stop just in case we have any bytes

source/API/SBFrame.cpp

 bool
 SBFrame::IsValid() const
 {
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     Target *target = exe_ctx.GetTargetPtr();
     Process *process = exe_ctx.GetProcessPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBSymbolContext sb_sym_ctx;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBModule sb_module;
     ModuleSP module_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBCompileUnit sb_comp_unit;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBFunction sb_function;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBSymbol sb_symbol;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBBlock sb_block;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 SBFrame::GetFrameBlock () const
 {
     SBBlock sb_block;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBLineEntry sb_line_entry;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     addr_t addr = LLDB_INVALID_ADDRESS;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     bool ret_val = false;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     addr_t addr = LLDB_INVALID_ADDRESS;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     addr_t addr = LLDB_INVALID_ADDRESS;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBAddress sb_addr;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = exe_ctx.GetFramePtr();
     Target *target = exe_ctx.GetTargetPtr();

 SBFrame::GetValueForVariablePath (const char *var_path, DynamicValueType use_dynamic)
 {
     SBValue sb_value;
-    Mutex::Locker api_locker;
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     if (var_path == nullptr || var_path[0] == '\0')
     {

             log->Printf ("SBFrame::GetValueForVariablePath called with empty variable path.");
         return sb_value;
     }
-    
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

     }
 
     ValueObjectSP value_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

     }
 
     ValueObjectSP value_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 {
     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     const char *disassembly = nullptr;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
     SBValueList value_list;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
     SBValueList value_list;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

 
     SBValue result;
     ValueObjectSP value_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame = nullptr;
     Target *target = exe_ctx.GetTargetPtr();

     Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     Stream &strm = description.ref();
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrame *frame;
     Target *target = exe_ctx.GetTargetPtr();

 
     ValueObjectSP expr_value_sp;
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBFrame()::EvaluateExpression (expr=\"%s\")...", expr);

source/API/SBFunction.cpp

     SBInstructionList sb_instructions;
     if (m_opaque_ptr)
     {
-        Mutex::Locker api_locker;
         ExecutionContext exe_ctx;
         TargetSP target_sp (target.GetSP());
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
         {
-            api_locker.Lock (target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }

source/API/SBInstruction.cpp

 {
     if (m_opaque_sp)
     {        
-        Mutex::Locker api_locker;
         ExecutionContext exe_ctx;
         TargetSP target_sp (target.GetSP());
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
         {
-            api_locker.Lock (target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker;
         ExecutionContext exe_ctx;
         TargetSP target_sp (target.GetSP());
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
         {
-            api_locker.Lock (target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }

 {
     if (m_opaque_sp)
     {
-        Mutex::Locker api_locker;
         ExecutionContext exe_ctx;
         TargetSP target_sp (target.GetSP());
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
         {
-            api_locker.Lock (target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+
             target_sp->CalculateExecutionContext (exe_ctx);
             exe_ctx.SetProcessSP(target_sp->GetProcessSP());
         }

source/API/SBProcess.cpp

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         if (process_sp->GetState() == eStateConnected)
         {
             if (stop_at_entry)

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         if (process_sp->GetState() == eStateConnected)
         {
             ProcessAttachInfo attach_info;

         Process::StopLocker stop_locker;
 
         const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         num_threads = process_sp->GetThreadList().GetSize(can_update);
     }
 

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         thread_sp = process_sp->GetThreadList().GetSelectedThread();
         sb_thread.SetThread (thread_sp);
     }

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         thread_sp = process_sp->CreateOSPluginThread(tid, context);
         sb_thread.SetThread (thread_sp);
     }

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         return process_sp->GetThreadList().SetSelectedThreadByID (thread.GetThreadID());
     }
     return false;

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         ret_val = process_sp->GetThreadList().SetSelectedThreadByID (tid);
     }
 

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID (index_id);
     }
 

     {
         Process::StopLocker stop_locker;
         const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
         sb_thread.SetThread (thread_sp);
     }

     {
         Process::StopLocker stop_locker;
 
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         num_queues = process_sp->GetQueueList().GetSize();
     }
 

     if (process_sp)
     {
         Process::StopLocker stop_locker;
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
         sb_queue.SetQueue (queue_sp);
     }

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         if (include_expression_stops)
             return process_sp->GetStopID();
         else

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         event_sp = process_sp->GetStopEventForStopID(stop_id);
         sb_event.reset(event_sp);
     }

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         ret_val = process_sp->GetState();
     }
 

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         exit_status = process_sp->GetExitStatus ();
     }
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         exit_desc = process_sp->GetExitDescription ();
     }
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));

 
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
 
         if (process_sp->GetTarget().GetDebugger().GetAsyncExecution ())
             sb_error.ref() = process_sp->Resume ();

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         sb_error.SetError(process_sp->Destroy(false));
     }
     else

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         sb_error.SetError (process_sp->Halt());
     }
     else

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         sb_error.SetError (process_sp->Destroy(true));
     }
     else

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         sb_error.SetError (process_sp->Detach(keep_stopped));
     }
     else

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         sb_error.SetError (process_sp->Signal (signo));
     }
     else

     {
         Process::StopLocker stop_locker;
         const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         thread_sp = process_sp->GetThreadList().FindThreadByID (tid, can_update);
         sb_thread.SetThread (thread_sp);
     }

     {
         Process::StopLocker stop_locker;
         const bool can_update = stop_locker.TryLock(&process_sp->GetRunLock());
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         thread_sp = process_sp->GetThreadList().FindThreadByIndexID (index_id, can_update);
         sb_thread.SetThread (thread_sp);
     }

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             bytes_read = process_sp->ReadMemory (addr, dst, dst_len, sb_error.ref());
         }
         else

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             bytes_read = process_sp->ReadCStringFromMemory (addr, (char *)buf, size, sb_error.ref());
         }
         else

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             value = process_sp->ReadUnsignedIntegerFromMemory (addr, byte_size, 0, sb_error.ref());
         }
         else

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             ptr = process_sp->ReadPointerFromMemory (addr, sb_error.ref());
         }
         else

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             bytes_written = process_sp->WriteMemory (addr, src, src_len, sb_error.ref());
         }
         else

     ProcessSP process_sp(GetSP());
     if (process_sp)
     {
-        Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
         sb_error.SetError(process_sp->GetWatchpointSupportInfo (num));
         if (log)
             log->Printf ("SBProcess(%p)::GetNumSupportedHardwareWatchpoints () => %u",

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
             return platform_sp->LoadImage (process_sp.get(),
                                            *sb_local_image_spec,

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
             sb_error.SetError (platform_sp->UnloadImage (process_sp.get(), image_token));
         }

         Process::StopLocker stop_locker;
         if (stop_locker.TryLock(&process_sp->GetRunLock()))
         {
-            Mutex::Locker api_locker (process_sp->GetTarget().GetAPIMutex());
+            std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
             sb_error.SetError (process_sp->SendEventData (event_data));
         }
         else

         return error;
     }
 
-    Mutex::Locker api_locker(process_sp->GetTarget().GetAPIMutex());
+    std::lock_guard<std::recursive_mutex> guard(process_sp->GetTarget().GetAPIMutex());
 
     if (process_sp->GetState() != eStateStopped)
     {

source/API/SBSymbol.cpp

     SBInstructionList sb_instructions;
     if (m_opaque_ptr)
     {
-        Mutex::Locker api_locker;
         ExecutionContext exe_ctx;
         TargetSP target_sp (target.GetSP());
+        std::unique_lock<std::recursive_mutex> lock;
         if (target_sp)
         {
-            api_locker.Lock (target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
+
             target_sp->CalculateExecutionContext (exe_ctx);
         }
         if (m_opaque_ptr->ValueIsAddress())

source/API/SBTarget.cpp

 Error
 AttachToProcess (ProcessAttachInfo &attach_info, Target &target)
 {
-    Mutex::Locker api_locker (target.GetAPIMutex ());
+    std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
 
     auto process_sp = target.GetProcessSP ();
     if (process_sp)

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         sb_error.ref() = target_sp->Install(NULL);
     }
     return sb_error;

 
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
         if (stop_at_entry)
             launch_flags |= eLaunchFlagStopAtEntry;

 
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         StateType state = eStateInvalid;
         {
             ProcessSP process_sp = target_sp->GetProcessSP();

 
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         if (listener.IsValid())
             process_sp = target_sp->CreateProcess (listener.m_opaque_sp, plugin_name, NULL);
         else

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         if (target_sp->ResolveLoadAddress (vm_addr, addr))
             return sb_addr;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         if (target_sp->ResolveFileAddress (file_addr, addr))
             return sb_addr;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         if (target_sp->ResolveLoadAddress (vm_addr, addr))
             return sb_addr;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         bytes_read = target_sp->ReadMemory(addr.ref(), false, buf, size, sb_error.ref());
     }
     else

     TargetSP target_sp(GetSP());
     if (target_sp && line != 0)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
         const LazyBool check_inlines = eLazyBoolCalculate;
         const LazyBool skip_prologue = eLazyBoolCalculate;

     TargetSP target_sp(GetSP());
     if (target_sp.get())
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
         const bool internal = false;
         const bool hardware = false;

         const bool internal = false;
         const bool hardware = false;
         const LazyBool skip_prologue = eLazyBoolCalculate;
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         *sb_bp = target_sp->CreateBreakpoint (module_list.get(), 
                                               comp_unit_list.get(),
                                               symbol_name,

     TargetSP target_sp(GetSP());
     if (target_sp && num_names > 0)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         const bool internal = false;
         const bool hardware = false;
         const LazyBool skip_prologue = eLazyBoolCalculate;

     TargetSP target_sp(GetSP());
     if (target_sp && symbol_name_regex && symbol_name_regex[0])
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         RegularExpression regexp(symbol_name_regex);
         const bool internal = false;
         const bool hardware = false;

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         const bool hardware = false;
         *sb_bp = target_sp->CreateBreakpoint (address, false, hardware);
     }

     
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         const bool hardware = false;
         *sb_bp = target_sp->CreateBreakpoint (sb_address.ref(), false, hardware);
     }

     TargetSP target_sp(GetSP());
     if (target_sp && source_regex && source_regex[0])
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         const bool hardware = false;
         const LazyBool move_to_nearest_code = eLazyBoolCalculate;
         RegularExpression regexp(source_regex);

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         const bool hardware = false;
         *sb_bp = target_sp->CreateExceptionBreakpoint (language, catch_bp, throw_bp, hardware);
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         result = target_sp->RemoveBreakpointByID (bp_id);
     }
 

     TargetSP target_sp(GetSP());
     if (target_sp && bp_id != LLDB_INVALID_BREAK_ID)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         *sb_breakpoint = target_sp->GetBreakpointByID (bp_id);
     }
 

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         target_sp->EnableAllBreakpoints ();
         return true;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         target_sp->DisableAllBreakpoints ();
         return true;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         target_sp->RemoveAllBreakpoints ();
         return true;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
-        Mutex::Locker locker;
-        target_sp->GetWatchpointList().GetListMutex(locker);
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+        std::unique_lock<std::recursive_mutex> lock;
+        target_sp->GetWatchpointList().GetListMutex(lock);
         result = target_sp->RemoveWatchpointByID (wp_id);
     }
 

     TargetSP target_sp(GetSP());
     if (target_sp && wp_id != LLDB_INVALID_WATCH_ID)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
-        Mutex::Locker locker;
-        target_sp->GetWatchpointList().GetListMutex(locker);
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+        std::unique_lock<std::recursive_mutex> lock;
+        target_sp->GetWatchpointList().GetListMutex(lock);
         watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
         sb_watchpoint.SetSP (watchpoint_sp);
     }

     TargetSP target_sp(GetSP());
     if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS && size > 0)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         uint32_t watch_type = 0;
         if (read)
             watch_type |= LLDB_WATCH_TYPE_READ;

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
-        Mutex::Locker locker;
-        target_sp->GetWatchpointList().GetListMutex(locker);
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+        std::unique_lock<std::recursive_mutex> lock;
+        target_sp->GetWatchpointList().GetListMutex(lock);
         target_sp->EnableAllWatchpoints ();
         return true;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
-        Mutex::Locker locker;
-        target_sp->GetWatchpointList().GetListMutex(locker);
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+        std::unique_lock<std::recursive_mutex> lock;
+        target_sp->GetWatchpointList().GetListMutex(lock);
         target_sp->DisableAllWatchpoints ();
         return true;
     }

     TargetSP target_sp(GetSP());
     if (target_sp)
     {
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
-        Mutex::Locker locker;
-        target_sp->GetWatchpointList().GetListMutex(locker);
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
+        std::unique_lock<std::recursive_mutex> lock;
+        target_sp->GetWatchpointList().GetListMutex(lock);
         target_sp->RemoveAllWatchpoints ();
         return true;
     }

             return expr_result;
         }
 
-        Mutex::Locker api_locker (target_sp->GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
         ExecutionContext exe_ctx (m_opaque_sp.get());
 
         if (log)

source/API/SBThread.cpp

 {
     SBQueue sb_queue;
     QueueSP queue_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     if (exe_ctx.HasThreadScope())

 bool
 SBThread::IsValid() const
 {
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     Target *target = exe_ctx.GetTargetPtr();
     Process *process = exe_ctx.GetProcessPtr();

     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
     StopReason reason = eStopReasonInvalid;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 size_t
 SBThread::GetStopReasonDataCount ()
 {
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 uint64_t
 SBThread::GetStopReasonDataAtIndex (uint32_t idx)
 {
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     ValueObjectSP return_valobj_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     const char *name = NULL;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 SBThread::GetQueueName () const
 {
     const char *name = NULL;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     if (exe_ctx.HasThreadScope())

 SBThread::GetQueueID () const
 {
     queue_id_t id = LLDB_INVALID_QUEUE_ID;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     if (exe_ctx.HasThreadScope())

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     bool success = false;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
-
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::StepOver (stop_other_threads='%s')",

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::StepInto (target_name='%s', stop_other_threads='%s')",

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::StepOut ()",

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (!sb_frame.IsValid())
     {

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
-
-
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::StepInstruction (step_over=%i)",

 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
-
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::RunToAddress (addr=0x%" PRIx64 ")",

     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     char path[PATH_MAX];
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     StackFrameSP frame_sp (sb_frame.GetFrameSP());
 

     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBError sb_error;
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
     {

     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
     SBError sb_error;
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::JumpToLine (file+line = %s:%u)",

 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
-
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (log)
         log->Printf ("SBThread(%p)::ReturnFromFrame (frame=%d)",

     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
     uint32_t num_frames = 0;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 
     SBFrame sb_frame;
     StackFrameSP frame_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 
     SBFrame sb_frame;
     StackFrameSP frame_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 
     SBFrame sb_frame;
     StackFrameSP frame_sp;
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
 
     if (exe_ctx.HasThreadScope())
     {

 SBThread::GetExtendedBacktraceThread (const char *type)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
-    Mutex::Locker api_locker;
-    ExecutionContext exe_ctx (m_opaque_sp.get(), api_locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    ExecutionContext exe_ctx(m_opaque_sp.get(), lock);
     SBThread sb_origin_thread;
 
     if (exe_ctx.HasThreadScope())

source/API/SBValue.cpp

     }
 
     lldb::ValueObjectSP
-    GetSP (Process::StopLocker &stop_locker, Mutex::Locker &api_locker, Error &error)
+    GetSP(Process::StopLocker &stop_locker, std::unique_lock<std::recursive_mutex> &lock, Error &error)
     {
         Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
         if (!m_valobj_sp)

         lldb::ValueObjectSP value_sp = m_valobj_sp;
 
         Target *target = value_sp->GetTargetSP().get();
-        if (target)
-            api_locker.Lock(target->GetAPIMutex());
-        else
+        if (!target)
             return ValueObjectSP();
 
+        lock = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
+
         ProcessSP process_sp(value_sp->GetProcessSP());
         if (process_sp && !stop_locker.TryLock (&process_sp->GetRunLock()))
         {

     ValueLocker ()
     {
     }
-    
     ValueObjectSP
     GetLockedSP(ValueImpl &in_value)
     {
-        return in_value.GetSP(m_stop_locker, m_api_locker, m_lock_error);
+        return in_value.GetSP(m_stop_locker, m_lock, m_lock_error);
     }
-    
     Error &
     GetError()
     {

     
 private:
     Process::StopLocker m_stop_locker;
-    Mutex::Locker m_api_locker;
+    std::unique_lock<std::recursive_mutex> m_lock;
     Error m_lock_error;
-    
 };
 
 SBValue::SBValue () :

source/API/SBWatchpoint.cpp

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         hw_index = watchpoint_sp->GetHardwareIndex();
     }
 

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         ret_addr = watchpoint_sp->GetLoadAddress();
     }
 

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         watch_size = watchpoint_sp->GetByteSize();
     }
 

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         watchpoint_sp->GetTarget().DisableWatchpointByID(watchpoint_sp->GetID());
     }
 }

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         return watchpoint_sp->IsEnabled();
     }
     else

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         count = watchpoint_sp->GetHitCount();
     }
 

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         return watchpoint_sp->GetIgnoreCount();
     }
     else

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         watchpoint_sp->SetIgnoreCount (n);
     }
 }

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         return watchpoint_sp->GetConditionText ();
     }
     return NULL;

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         watchpoint_sp->SetCondition (condition);
     }
 }

     lldb::WatchpointSP watchpoint_sp(GetSP());
     if (watchpoint_sp)
     {
-        Mutex::Locker api_locker (watchpoint_sp->GetTarget().GetAPIMutex());
+        std::lock_guard<std::recursive_mutex> guard(watchpoint_sp->GetTarget().GetAPIMutex());
         watchpoint_sp->GetDescription (&strm, level);
         strm.EOL();
     }

source/Breakpoint/Breakpoint.cpp

     if (log)
         log->Printf ("Breakpoint::ModulesChanged: num_modules: %zu load: %i delete_locations: %i\n",
                      module_list.GetSize(), load, delete_locations);
-    
-    Mutex::Locker modules_mutex(module_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
     if (load)
     {
         // The logic for handling new modules is:

source/Breakpoint/BreakpointList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointList::BreakpointList (bool is_internal) :
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_breakpoints(),
-    m_next_break_id (0),
-    m_is_internal (is_internal)
+BreakpointList::BreakpointList(bool is_internal)
+    : m_mutex(), m_breakpoints(), m_next_break_id(0), m_is_internal(is_internal)
 {
 }
 

 break_id_t
 BreakpointList::Add (BreakpointSP &bp_sp, bool notify)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // Internal breakpoint IDs are negative, normal ones are positive
     bp_sp->SetID (m_is_internal ? --m_next_break_id : ++m_next_break_id);
     

 bool
 BreakpointList::Remove (break_id_t break_id, bool notify)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     bp_collection::iterator pos = GetBreakpointIDIterator(break_id);    // Predicate
     if (pos != m_breakpoints.end())
     {

 void
 BreakpointList::RemoveInvalidLocations (const ArchSpec &arch)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     for (const auto &bp_sp : m_breakpoints)
         bp_sp->RemoveInvalidLocations(arch);
 }

 void
 BreakpointList::SetEnabledAll (bool enabled)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     for (const auto &bp_sp : m_breakpoints)
         bp_sp->SetEnabled (enabled);
 }

 void
 BreakpointList::RemoveAll (bool notify)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     ClearAllBreakpointSites ();
 
     if (notify)

 BreakpointSP
 BreakpointList::FindBreakpointByID (break_id_t break_id)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointSP stop_sp;
     bp_collection::iterator pos = GetBreakpointIDIterator(break_id);
     if (pos != m_breakpoints.end())

 const BreakpointSP
 BreakpointList::FindBreakpointByID (break_id_t break_id) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointSP stop_sp;
     bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id);
     if (pos != m_breakpoints.end())

 void
 BreakpointList::Dump (Stream *s) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     s->Printf("%p: ", static_cast<const void*>(this));
     s->Indent();
     s->Printf("BreakpointList with %u Breakpoints:\n", (uint32_t)m_breakpoints.size());

 BreakpointSP
 BreakpointList::GetBreakpointAtIndex (size_t i)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointSP stop_sp;
     bp_collection::iterator end = m_breakpoints.end();
     bp_collection::iterator pos;

 const BreakpointSP
 BreakpointList::GetBreakpointAtIndex (size_t i) const
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     BreakpointSP stop_sp;
     bp_collection::const_iterator end = m_breakpoints.end();
     bp_collection::const_iterator pos;

 void
 BreakpointList::UpdateBreakpoints (ModuleList& module_list, bool added, bool delete_locations)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     for (const auto &bp_sp : m_breakpoints)
         bp_sp->ModulesChanged (module_list, added, delete_locations);
 

 void
 BreakpointList::UpdateBreakpointsWhenModuleIsReplaced (ModuleSP old_module_sp, ModuleSP new_module_sp)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     for (const auto &bp_sp : m_breakpoints)
         bp_sp->ModuleReplaced (old_module_sp, new_module_sp);
 

 void
 BreakpointList::ClearAllBreakpointSites ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     for (const auto &bp_sp : m_breakpoints)
         bp_sp->ClearAllBreakpointSites ();
 
 }
 
 void
-BreakpointList::GetListMutex (Mutex::Locker &locker)
+BreakpointList::GetListMutex(std::unique_lock<std::recursive_mutex> &lock)
 {
-    return locker.Lock (m_mutex);
+    lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 }

source/Breakpoint/BreakpointLocation.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-BreakpointLocation::BreakpointLocation
-(
-    break_id_t loc_id,
-    Breakpoint &owner,
-    const Address &addr,
-    lldb::tid_t tid,
-    bool hardware,
-    bool check_for_resolver
-) :
-    StoppointLocation (loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), hardware),
-    m_being_created(true),
-    m_should_resolve_indirect_functions (false),
-    m_is_reexported (false),
-    m_is_indirect (false),
-    m_address (addr),
-    m_owner (owner),
-    m_options_ap (),
-    m_bp_site_sp (),
-    m_condition_mutex ()
+BreakpointLocation::BreakpointLocation(break_id_t loc_id, Breakpoint &owner, const Address &addr, lldb::tid_t tid,
+                                       bool hardware, bool check_for_resolver)
+    : StoppointLocation(loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), hardware),
+      m_being_created(true),
+      m_should_resolve_indirect_functions(false),
+      m_is_reexported(false),
+      m_is_indirect(false),
+      m_address(addr),
+      m_owner(owner),
+      m_options_ap(),
+      m_bp_site_sp(),
+      m_condition_mutex()
 {
     if (check_for_resolver)
     {
         Symbol *symbol = m_address.CalculateSymbolContextSymbol();
         if (symbol && symbol->IsIndirect())
         {
-            SetShouldResolveIndirectFunctions (true);
+            SetShouldResolveIndirectFunctions(true);
         }
     }
-    
-    SetThreadID (tid);
+    SetThreadID(tid);
     m_being_created = false;
 }
 

 BreakpointLocation::ConditionSaysStop (ExecutionContext &exe_ctx, Error &error)
 {
     Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS);
- 
-    Mutex::Locker evaluation_locker(m_condition_mutex);
-    
+    std::lock_guard<std::mutex> guard(m_condition_mutex);
     size_t condition_hash;
     const char *condition_text = GetConditionText(&condition_hash);
     

source/Breakpoint/WatchpointList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-WatchpointList::WatchpointList() :
-    m_watchpoints (),
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_next_wp_id (0)
+WatchpointList::WatchpointList() : m_watchpoints(), m_mutex(), m_next_wp_id(0)
 {
 }
 

 lldb::watch_id_t
 WatchpointList::Add (const WatchpointSP &wp_sp, bool notify)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     wp_sp->SetID(++m_next_wp_id);
     m_watchpoints.push_back(wp_sp);
     if (notify)

 void
 WatchpointList::DumpWithLevel (Stream *s, lldb::DescriptionLevel description_level) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     s->Printf("%p: ", static_cast<const void*>(this));
     //s->Indent();
     s->Printf("WatchpointList with %" PRIu64 " Watchpoints:\n",

 WatchpointList::FindByAddress (lldb::addr_t addr) const
 {
     WatchpointSP wp_sp;
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_watchpoints.empty())
     {
         wp_collection::const_iterator pos, end = m_watchpoints.end();

 WatchpointList::FindBySpec (std::string spec) const
 {
     WatchpointSP wp_sp;
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_watchpoints.empty())
     {
         wp_collection::const_iterator pos, end = m_watchpoints.end();

 WatchpointList::FindByID (lldb::watch_id_t watch_id) const
 {
     WatchpointSP wp_sp;
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     wp_collection::const_iterator pos = GetIDConstIterator(watch_id);
     if (pos != m_watchpoints.end())
         wp_sp = *pos;

 WatchpointSP
 WatchpointList::GetByIndex (uint32_t i)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     WatchpointSP wp_sp;
     if (i < m_watchpoints.size())
     {

 const WatchpointSP
 WatchpointList::GetByIndex (uint32_t i) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     WatchpointSP wp_sp;
     if (i < m_watchpoints.size())
     {

 bool
 WatchpointList::Remove (lldb::watch_id_t watch_id, bool notify)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     wp_collection::iterator pos = GetIDIterator(watch_id);
     if (pos != m_watchpoints.end())
     {

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

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

 void
 WatchpointList::SetEnabledAll (bool enabled)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     wp_collection::iterator pos, end = m_watchpoints.end();
     for (pos = m_watchpoints.begin(); pos != end; ++pos)

 void
 WatchpointList::RemoveAll (bool notify)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (notify)
     {
         

 }
 
 void
-WatchpointList::GetListMutex (Mutex::Locker &locker)
+WatchpointList::GetListMutex(std::unique_lock<std::recursive_mutex> &lock)
 {
-    return locker.Lock (m_mutex);
+    lock = std::unique_lock<std::recursive_mutex>(m_mutex);
 }

source/Commands/CommandObjectBreakpoint.cpp

             return false;
         }
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
         BreakpointIDList valid_bp_ids;
 
         CommandObjectMultiwordBreakpoint::VerifyBreakpointOrLocationIDs (command, target, result, &valid_bp_ids);

             return false;
         }
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
 
         const BreakpointList &breakpoints = target->GetBreakpointList();
 

             return false;
         }
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
 
         const BreakpointList &breakpoints = target->GetBreakpointList();
         size_t num_breakpoints = breakpoints.GetSize();

         }
 
         const BreakpointList &breakpoints = target->GetBreakpointList(m_options.m_internal);
-        Mutex::Locker locker;
-        target->GetBreakpointList(m_options.m_internal).GetListMutex(locker);
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList(m_options.m_internal).GetListMutex(lock);
 
         size_t num_breakpoints = breakpoints.GetSize();
 

         if (m_options.m_line_num != 0)
             break_type = eClearTypeFileAndLine;
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
 
         BreakpointList &breakpoints = target->GetBreakpointList();
         size_t num_breakpoints = breakpoints.GetSize();

             return false;
         }
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
         const BreakpointList &breakpoints = target->GetBreakpointList();
 
         size_t num_breakpoints = breakpoints.GetSize();

             return false;
         }
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
         const BreakpointList &breakpoints = target->GetBreakpointList();
 
         size_t num_breakpoints = breakpoints.GetSize();

             return false;
         }
 
-        Mutex::Locker locker;
-        target->GetBreakpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetBreakpointList().GetListMutex(lock);
         const BreakpointList &breakpoints = target->GetBreakpointList();
 
         size_t num_breakpoints = breakpoints.GetSize();

         if (m_name_options.m_name.OptionWasSet())
         {
             const char *name = m_name_options.m_name.GetCurrentValue();
-            Mutex::Locker locker;
-            target->GetBreakpointList().GetListMutex(locker);
-            
+            std::unique_lock<std::recursive_mutex> lock;
+            target->GetBreakpointList().GetListMutex(lock);
             BreakpointList &breakpoints = target->GetBreakpointList();
             for (BreakpointSP bp_sp : breakpoints.Breakpoints())
             {

source/Commands/CommandObjectProcess.cpp

             }
             
             {  // Scope for thread list mutex:
-                Mutex::Locker locker (process->GetThreadList().GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(process->GetThreadList().GetMutex());
                 const uint32_t num_threads = process->GetThreadList().GetSize();
 
                 // Set the actions that the threads should each take when resuming

source/Commands/CommandObjectTarget.cpp

 DumpModuleObjfileHeaders(Stream &strm, ModuleList &module_list)
 {
     size_t num_dumped = 0;
-    Mutex::Locker modules_locker(module_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
     const size_t num_modules = module_list.GetSize();
     if (num_modules > 0)
     {

             if (command.GetArgumentCount() == 0)
             {
                 // Dump all sections for all modules images
-                Mutex::Locker modules_locker(target->GetImages().GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(target->GetImages().GetMutex());
                 const size_t num_modules = target->GetImages().GetSize();
                 if (num_modules > 0)
                 {

             {
                 // Dump all sections for all modules images
                 const ModuleList &target_modules = target->GetImages();
-                Mutex::Locker modules_locker (target_modules.GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
                 const size_t num_modules = target_modules.GetSize();
                 if (num_modules > 0)
                 {

                 FileSpec file_spec(arg_cstr, false);
 
                 const ModuleList &target_modules = target->GetImages();
-                Mutex::Locker modules_locker(target_modules.GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
                 const size_t num_modules = target_modules.GetSize();
                 if (num_modules > 0)
                 {

             // 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();

                 module_list_ptr = &module_list;
             }
 
+            std::unique_lock<std::recursive_mutex> lock;
             if (module_list_ptr != nullptr)
             {
-                assert(use_global_module_list == false && "locking violation");
-                locker.Lock(module_list_ptr->GetMutex());
+                lock = std::unique_lock<std::recursive_mutex>(module_list_ptr->GetMutex());
+
                 num_modules = module_list_ptr->GetSize();
             }
 

                 // Dump all sections for all other modules
 
                 const ModuleList &target_modules = target->GetImages();
-                Mutex::Locker modules_locker(target_modules.GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
                 const size_t num_modules = target_modules.GetSize();
                 if (num_modules > 0)
                 {

source/Commands/CommandObjectThread.cpp

             const size_t num_args = command.GetArgumentCount();
             Process *process = m_exe_ctx.GetProcessPtr();
 
-            Mutex::Locker locker (process->GetThreadList().GetMutex());
+            std::lock_guard<std::recursive_mutex> guard(process->GetThreadList().GetMutex());
 
             for (size_t i = 0; i < num_args; i++)
             {

                 // These two lines appear at the beginning of both blocks in
                 // this if..else, but that is because we need to release the
                 // lock before calling process->Resume below.
-                Mutex::Locker locker (process->GetThreadList().GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(process->GetThreadList().GetMutex());
                 const uint32_t num_threads = process->GetThreadList().GetSize();
                 std::vector<Thread *> resume_threads;
                 for (uint32_t i = 0; i < argc; ++i)

                 // These two lines appear at the beginning of both blocks in
                 // this if..else, but that is because we need to release the
                 // lock before calling process->Resume below.
-                Mutex::Locker locker (process->GetThreadList().GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(process->GetThreadList().GetMutex());
                 const uint32_t num_threads = process->GetThreadList().GetSize();
                 Thread *current_thread = GetDefaultThread();
                 if (current_thread == nullptr)

source/Commands/CommandObjectWatchpoint.cpp

         }
 
         const WatchpointList &watchpoints = target->GetWatchpointList();
-        Mutex::Locker locker;
-        target->GetWatchpointList().GetListMutex(locker);
+
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetWatchpointList().GetListMutex(lock);
 
         size_t num_watchpoints = watchpoints.GetSize();
 

         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
-        Mutex::Locker locker;
-        target->GetWatchpointList().GetListMutex(locker);
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetWatchpointList().GetListMutex(lock);
 
         const WatchpointList &watchpoints = target->GetWatchpointList();
 

         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
-        Mutex::Locker locker;
-        target->GetWatchpointList().GetListMutex(locker);
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetWatchpointList().GetListMutex(lock);
 
         const WatchpointList &watchpoints = target->GetWatchpointList();
         size_t num_watchpoints = watchpoints.GetSize();

         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
-        Mutex::Locker locker;
-        target->GetWatchpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetWatchpointList().GetListMutex(lock);
         const WatchpointList &watchpoints = target->GetWatchpointList();
 
         size_t num_watchpoints = watchpoints.GetSize();

         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
-        Mutex::Locker locker;
-        target->GetWatchpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetWatchpointList().GetListMutex(lock);
         const WatchpointList &watchpoints = target->GetWatchpointList();
 
         size_t num_watchpoints = watchpoints.GetSize();

         if (!CheckTargetForWatchpointOperations(target, result))
             return false;
 
-        Mutex::Locker locker;
-        target->GetWatchpointList().GetListMutex(locker);
-        
+        std::unique_lock<std::recursive_mutex> lock;
+        target->GetWatchpointList().GetListMutex(lock);
         const WatchpointList &watchpoints = target->GetWatchpointList();
 
         size_t num_watchpoints = watchpoints.GetSize();

source/Core/IOHandler.cpp

                 if (thread_sp)
                 {
                     ThreadList &thread_list = thread_sp->GetProcess()->GetThreadList();
-                    Mutex::Locker locker (thread_list.GetMutex());
+                    std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex());
                     ThreadSP selected_thread_sp = thread_list.GetSelectedThread();
                     if (selected_thread_sp->GetID() != thread_sp->GetID())
                     {

                 
                 TreeItem t (&item, *m_thread_delegate_sp, false);
                 ThreadList &threads = process_sp->GetThreadList();
-                Mutex::Locker locker (threads.GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
                 size_t num_threads = threads.GetSize();
                 item.Resize (num_threads, t);
                 for (size_t i = 0; i < num_threads; ++i)

                             submenus.erase (submenus.begin() + 8, submenus.end());
                         
                         ThreadList &threads = process->GetThreadList();
-                        Mutex::Locker locker (threads.GetMutex());
+                        std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
                         size_t num_threads = threads.GetSize();
                         for (size_t i = 0; i < num_threads; ++i)
                         {

source/Core/ModuleList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-ModuleList::ModuleList() :
-    m_modules(),
-    m_modules_mutex (Mutex::eMutexTypeRecursive),
-    m_notifier(nullptr)
+ModuleList::ModuleList() : m_modules(), m_modules_mutex(), m_notifier(nullptr)
 {
 }
 
-ModuleList::ModuleList(const ModuleList& rhs) :
-    m_modules(),
-    m_modules_mutex (Mutex::eMutexTypeRecursive),
-    m_notifier(nullptr)
+ModuleList::ModuleList(const ModuleList &rhs) : m_modules(), m_modules_mutex(), m_notifier(nullptr)
 {
-    Mutex::Locker lhs_locker(m_modules_mutex);
-    Mutex::Locker rhs_locker(rhs.m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
     m_modules = rhs.m_modules;
 }
 
-ModuleList::ModuleList (ModuleList::Notifier* notifier) :
-    m_modules(),
-    m_modules_mutex (Mutex::eMutexTypeRecursive),
-    m_notifier(notifier)
+ModuleList::ModuleList(ModuleList::Notifier *notifier) : m_modules(), m_modules_mutex(), m_notifier(notifier)
 {
 }
 

         // avoids priority inversion.
         if (uintptr_t(this) > uintptr_t(&rhs))
         {
-            Mutex::Locker lhs_locker(m_modules_mutex);
-            Mutex::Locker rhs_locker(rhs.m_modules_mutex);
+            std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
+            std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
             m_modules = rhs.m_modules;
         }
         else
         {
-            Mutex::Locker rhs_locker(rhs.m_modules_mutex);
-            Mutex::Locker lhs_locker(m_modules_mutex);
+            std::lock_guard<std::recursive_mutex> lhs_guard(m_modules_mutex);
+            std::lock_guard<std::recursive_mutex> rhs_guard(rhs.m_modules_mutex);
             m_modules = rhs.m_modules;
         }
     }

 {
     if (module_sp)
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         m_modules.push_back(module_sp);
         if (use_notifier && m_notifier)
             m_notifier->ModuleAdded(*this, module_sp);

 {
     if (module_sp)
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 
         // First remove any equivalent modules. Equivalent modules are modules
         // whose path, platform path and architecture match.

 {
     if (module_sp)
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

 {
     if (module_sp)
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

 {
     if (module_ptr)
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

 size_t
 ModuleList::RemoveOrphans (bool mandatory)
 {
-    Mutex::Locker locker;
-    
+    std::unique_lock<std::recursive_mutex> lock(m_modules_mutex, std::defer_lock);
     if (mandatory)
     {
-        locker.Lock (m_modules_mutex);
+        lock.lock();
     }
     else
     {
         // Not mandatory, remove orphans if we can get the mutex
-        if (!locker.TryLock(m_modules_mutex))
+        if (!lock.try_lock())
             return 0;
     }
     collection::iterator pos = m_modules.begin();

 size_t
 ModuleList::Remove (ModuleList &module_list)
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     size_t num_removed = 0;
     collection::iterator pos, end = module_list.m_modules.end();
     for (pos = module_list.m_modules.begin(); pos != end; ++pos)

 void
 ModuleList::ClearImpl (bool use_notifier)
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     if (use_notifier && m_notifier)
         m_notifier->WillClearList(*this);
     m_modules.clear();

 Module*
 ModuleList::GetModulePointerAtIndex (size_t idx) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     return GetModulePointerAtIndexUnlocked(idx);
 }
 

 ModuleSP
 ModuleList::GetModuleAtIndex(size_t idx) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     return GetModuleAtIndexUnlocked(idx);
 }
 

                                               lookup_name,
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
-    
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

     }
     else
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

                                               lookup_name,
                                               lookup_name_type_mask,
                                               match_name_after_lookup);
-    
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

     }
     else
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

 {
     const size_t old_size = sc_list.GetSize();
 
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

 {
     if (!append)
         sc_list.Clear();
-    
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

                                  VariableList& variable_list) const
 {
     size_t initial_size = variable_list.GetSize();
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

                                  VariableList& variable_list) const
 {
     size_t initial_size = variable_list.GetSize();
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

                                         SymbolContextList &sc_list,
                                         bool append) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     if (!append)
         sc_list.Clear();
     size_t initial_size = sc_list.GetSize();

                                              SymbolContextList &sc_list,
                                              bool append) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     if (!append)
         sc_list.Clear();
     size_t initial_size = sc_list.GetSize();

 {
     size_t existing_matches = matching_module_list.GetSize();
 
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

 
     // Scope for "locker"
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
 
         for (pos = m_modules.begin(); pos != end; ++pos)

     
     if (uuid.IsValid())
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         
         for (pos = m_modules.begin(); pos != end; ++pos)

 size_t
 ModuleList::FindTypes (const SymbolContext& sc, const ConstString &name, bool name_is_fully_qualified, size_t max_matches, llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeList& types) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
 
     size_t total_matches = 0;
     collection::const_iterator pos, end = m_modules.end();

 bool
 ModuleList::FindSourceFile (const FileSpec &orig_spec, FileSpec &new_spec) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

                                   Function *function,
                                   std::vector<Address> &output_local, std::vector<Address> &output_extern)
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

 ModuleList::FindFirstModule (const ModuleSpec &module_spec) const
 {
     ModuleSP module_sp;
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

 {
     size_t size = 0;
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         size = m_modules.size();
     }
     return size;

 void
 ModuleList::Dump(Stream *s) const
 {
     //  s.Printf("%.*p: ", (int)sizeof(void*) * 2, this);
     //  s.Indent();
     //  s << "ModuleList\n";
 
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

 ModuleList::LogUUIDAndPaths (Log *log, const char *prefix_cstr)
 {
     if (log != nullptr)
-    {   
-        Mutex::Locker locker(m_modules_mutex);
+    {
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, begin = m_modules.begin(), end = m_modules.end();
         for (pos = begin; pos != end; ++pos)
         {

 bool
 ModuleList::ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

     }
     else
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos, end = m_modules.end();
         for (pos = m_modules.begin(); pos != end; ++pos)
         {

 uint32_t
 ModuleList::ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     collection::const_iterator pos, end = m_modules.end();
     for (pos = m_modules.begin(); pos != end; ++pos)
     {

 {
     if (module)
     {
-        Mutex::Locker locker(m_modules_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
         collection::const_iterator pos;
         collection::const_iterator begin = m_modules.begin();
         collection::const_iterator end = m_modules.end();

                             bool always_create)
 {
     ModuleList &shared_module_list = GetSharedModuleList ();
-    Mutex::Locker locker(shared_module_list.m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(shared_module_list.m_modules_mutex);
     char path[PATH_MAX];
 
     Error error;

 {
     if (!target)
         return false;
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     for (auto module : m_modules)
     {
         Error error;

 void
 ModuleList::ForEach (std::function <bool (const ModuleSP &module_sp)> const &callback) const
 {
-    Mutex::Locker locker(m_modules_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
     for (const auto &module : m_modules)
     {
         // If the callback returns false, then stop iterating and break out

source/Core/SearchFilter.cpp

         searcher.SearchCallback(*this, empty_sc, nullptr, false);
     else
     {
-        Mutex::Locker modules_locker(modules.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(modules.GetMutex());
         const size_t numModules = modules.GetSize();
 
         for (size_t i = 0; i < numModules; i++)

         else
         {
             const ModuleList &target_images = m_target_sp->GetImages();
-            Mutex::Locker modules_locker(target_images.GetMutex());
-            
+            std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
             size_t n_modules = target_images.GetSize();
             for (size_t i = 0; i < n_modules; i++)
             {

     // find the ones that match the file name.
 
     const ModuleList &target_modules = m_target_sp->GetImages();
-    Mutex::Locker modules_locker (target_modules.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
     const size_t num_modules = target_modules.GetSize ();
     for (size_t i = 0; i < num_modules; i++)
     {

     // find the ones that match the file name.
 
     const ModuleList &target_modules = m_target_sp->GetImages();
-    Mutex::Locker modules_locker (target_modules.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
     const size_t num_modules = target_modules.GetSize ();
     for (size_t i = 0; i < num_modules; i++)
     {

 
     ModuleList matching_modules;
     const ModuleList &target_images = m_target_sp->GetImages();
-    Mutex::Locker modules_locker(target_images.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
     const size_t num_modules = target_images.GetSize ();
     bool no_modules_in_filter = m_module_spec_list.GetSize() == 0;
     for (size_t i = 0; i < num_modules; i++)

source/Host/common/OptionParser.cpp

 using namespace lldb_private;
 
 void
-OptionParser::Prepare(Mutex::Locker &locker)
+OptionParser::Prepare(std::unique_lock<std::mutex> &lock)
 {
-    static Mutex g_mutex(Mutex::eMutexTypeNormal);
-    locker.Lock(g_mutex);
+    static std::mutex g_mutex;
+    lock = std::unique_lock<std::mutex>(g_mutex);
 #ifdef __GLIBC__
     optind = 0;
 #else

source/Interpreter/Args.cpp

             }
         }
     }
-    Mutex::Locker options_locker(NULL);
-    OptionParser::Prepare(options_locker);
+    std::unique_lock<std::mutex> lock;
+    OptionParser::Prepare(lock);
     int val;
     while (1)
     {

         }
     }
 
-    Mutex::Locker options_locker(NULL);
-    OptionParser::Prepare(options_locker);
+    std::unique_lock<std::mutex> lock;
+    OptionParser::Prepare(lock);
     int val;
     while (1)
     {

         }
     }
 
-    Mutex::Locker options_locker(NULL);
-    OptionParser::Prepare(options_locker);
+    std::unique_lock<std::mutex> lock;
+    OptionParser::Prepare(lock);
     OptionParser::EnableError(false);
 
     int val;

source/Interpreter/CommandObject.cpp

         {
             Target *target = m_exe_ctx.GetTargetPtr();
             if (target)
-                m_api_locker.Lock (target->GetAPIMutex());
+                m_api_locker = std::unique_lock<std::recursive_mutex>(target->GetAPIMutex());
         }
     }
 

 CommandObject::Cleanup ()
 {
     m_exe_ctx.Clear();
-    m_api_locker.Unlock();
+    m_api_locker.unlock();
 }
 
 int

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

         Target &target = m_process->GetTarget();
         const ModuleList &target_modules = target.GetImages();
         ModuleList not_loaded_modules;
-        Mutex::Locker modules_locker(target_modules.GetMutex());
-        
+        std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
         size_t num_modules = target_modules.GetSize();
         for (size_t i = 0; i < num_modules; i++)
         {

source/Plugins/DynamicLoader/Static/DynamicLoaderStatic.cpp

     // Disable JIT for static dynamic loader targets
     m_process->SetCanJIT(false);
 
-    Mutex::Locker mutex_locker(module_list.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
     const size_t num_modules = module_list.GetSize();
     for (uint32_t idx = 0; idx < num_modules; ++idx)
     {

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

     else
     {
         const ModuleList &target_images = m_target->GetImages();
-        Mutex::Locker modules_locker (target_images.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
 
         for (size_t i = 0, e = target_images.GetSize(); i < e; ++i)
         {

     else
     {
         const ModuleList &target_images = m_target->GetImages();
-        Mutex::Locker modules_locker(target_images.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_images.GetMutex());
 
         CompilerDeclContext null_namespace_decl;
 

source/Plugins/InstrumentationRuntime/AddressSanitizer/AddressSanitizerRuntime.cpp

         Activate();
         return;
     }
-    
-    Mutex::Locker modules_locker(module_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
     const size_t num_modules = module_list.GetSize();
     for (size_t i = 0; i < num_modules; ++i)
     {

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

         return ObjCRuntimeVersions::eObjC_VersionUnknown;
 
     const ModuleList &target_modules = target.GetImages();
-    Mutex::Locker modules_locker(target_modules.GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> gaurd(target_modules.GetMutex());
     size_t num_images = target_modules.GetSize();
     for (size_t i = 0; i < num_images; i++)
     {

 {
     if (!HasReadObjCLibrary ())
     {
-        Mutex::Locker locker (module_list.GetMutex ());
+        std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
 
         size_t num_modules = module_list.GetSize();
         for (size_t i = 0; i < num_modules; i++)

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

         Target &target = process_sp->GetTarget();
         
         const ModuleList &target_modules = target.GetImages();
-        Mutex::Locker modules_locker(target_modules.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
         size_t num_modules = target_modules.GetSize();
         if (!m_objc_module_sp)
         {

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 void
 RenderScriptRuntime::ModulesDidLoad(const ModuleList &module_list)
 {
-    Mutex::Locker locker(module_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
 
     size_t num_modules = module_list.GetSize();
     for (size_t i = 0; i < num_modules; i++)

source/Plugins/MemoryHistory/asan/MemoryHistoryASan.cpp

     Target & target = process_sp->GetTarget();
 
     const ModuleList &target_modules = target.GetImages();
-    Mutex::Locker modules_locker(target_modules.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
     const size_t num_modules = target_modules.GetSize();
     for (size_t i = 0; i < num_modules; ++i)
     {

source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

         if (m_symtab_ap.get() == NULL)
         {
             m_symtab_ap.reset(new Symtab(this));
-            Mutex::Locker symtab_locker (m_symtab_ap->GetMutex());
+            std::lock_guard<std::recursive_mutex> symtab_guard(m_symtab_ap->GetMutex());
             ObjectFileJITDelegateSP delegate_sp (m_delegate_wp.lock());
             if (delegate_sp)
                 delegate_sp->PopulateSymtab(this, *m_symtab_ap);

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

         if (m_symtab_ap.get() == NULL)
         {
             m_symtab_ap.reset(new Symtab(this));
-            Mutex::Locker symtab_locker (m_symtab_ap->GetMutex());
+            std::lock_guard<std::recursive_mutex> symtab_guard(m_symtab_ap->GetMutex());
             ParseSymtab ();
             m_symtab_ap->Finalize ();
         }

source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

         {
             SectionList *sect_list = GetSectionList();
             m_symtab_ap.reset(new Symtab(this));
-            Mutex::Locker symtab_locker (m_symtab_ap->GetMutex());
-            
+            std::lock_guard<std::recursive_mutex> guard(m_symtab_ap->GetMutex());
             const uint32_t num_syms = m_coff_header.nsyms;
 
             if (num_syms > 0 && m_coff_header.symoff > 0)

source/Plugins/OperatingSystem/Go/OperatingSystemGo.cpp

         if (!target_sp)
             return nullptr;
         ModuleList &module_list = target_sp->GetImages();
-        Mutex::Locker modules_locker(module_list.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(module_list.GetMutex());
         const size_t num_modules = module_list.GetSize();
         bool found_go_runtime = false;
         for (size_t i = 0; i < num_modules; ++i)

source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

     // This is a recursive lock so we can grant it to any Python code called on
     // the stack below us.
     Target &target = m_process->GetTarget();
-    Mutex::Locker api_locker;
-    api_locker.TryLock(target.GetAPIMutex());
-    
+    std::unique_lock<std::recursive_mutex> lock(target.GetAPIMutex(), std::defer_lock);
+    lock.try_lock();
     if (log)
         log->Printf ("OperatingSystemPython::UpdateThreadList() fetching thread data from python for pid %" PRIu64, m_process->GetID());
 

     // content of the process, and we're going to use python, which requires the API lock to do it.
     // So get & hold that.  This is a recursive lock so we can grant it to any Python code called on the stack below us.
     Target &target = m_process->GetTarget();
-    Mutex::Locker api_locker (target.GetAPIMutex());
+    std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 

         // content of the process, and we're going to use python, which requires the API lock to do it.
         // So get & hold that.  This is a recursive lock so we can grant it to any Python code called on the stack below us.
         Target &target = m_process->GetTarget();
-        Mutex::Locker api_locker (target.GetAPIMutex());
-        
+        std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
         auto lock = m_interpreter->AcquireInterpreterLock(); // to make sure thread_info_dict stays alive
         StructuredData::DictionarySP thread_info_dict = m_interpreter->OSPlugin_CreateThread(m_python_object_sp, tid, context);
         std::vector<bool> core_used_map;

source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

 
     SetPrivateState(eStateRunning);
 
-    Mutex::Locker lock(m_thread_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
     bool do_step = false;
 
     for (tid_collection::const_iterator t_pos = m_run_tids.begin(), t_end = m_run_tids.end(); t_pos != t_end; ++t_pos)

             if (log)
                 log->Printf ("ProcessFreeBSD::%s() removing thread, tid = %" PRIi64, __FUNCTION__, tid);
 
-            Mutex::Locker lock(m_thread_list.GetMutex());
+            std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
 
             ThreadSP thread_sp = m_thread_list.RemoveThreadByID(tid, false);
             thread_sp.reset();

 
         // Try to find a vacant watchpoint slot in the inferiors' main thread
         uint32_t wp_hw_index = LLDB_INVALID_INDEX32;
-        Mutex::Locker lock(m_thread_list.GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
         FreeBSDThread *thread = static_cast<FreeBSDThread*>(
                                m_thread_list.GetThreadAtIndex(0, false).get());
 

         if (wp->IsHardware())
         {
             bool wp_disabled = true;
-            Mutex::Locker lock(m_thread_list.GetMutex());
+            std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
             uint32_t thread_count = m_thread_list.GetSize(false);
             for (uint32_t i = 0; i < thread_count; ++i)
             {

 ProcessFreeBSD::GetWatchpointSupportInfo(uint32_t &num)
 {
     Error error;
-    Mutex::Locker lock(m_thread_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
     FreeBSDThread *thread = static_cast<FreeBSDThread*>(
                           m_thread_list.GetThreadAtIndex(0, false).get());
     if (thread)

 uint32_t
 ProcessFreeBSD::UpdateThreadListIfNeeded()
 {
-    Mutex::Locker lock(m_thread_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
     // Do not allow recursive updates.
     return m_thread_list.GetSize(false);
 }

 ProcessFreeBSD::IsAThreadRunning()
 {
     bool is_running = false;
-    Mutex::Locker lock(m_thread_list.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
     uint32_t thread_count = m_thread_list.GetSize(false);
     for (uint32_t i = 0; i < thread_count; ++i)
     {

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

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

 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Core/StreamBuffer.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Host/TimeValue.h"
 

                                           uint32_t usec);
 
     bool
-    GetSequenceMutex(lldb_private::Mutex::Locker& locker);
+    GetSequenceMutex(std::unique_lock<std::recursive_mutex> &lock);
 
     bool
     CheckForPacket (const uint8_t *src, 

     uint32_t m_addr_byte_size;
     lldb::ByteOrder m_byte_order;
     uint32_t m_packet_timeout;
-    lldb_private::Mutex m_sequence_mutex;    // Restrict access to sending/receiving packets to a single thread at a time
+    std::recursive_mutex m_sequence_mutex; // Restrict access to sending/receiving packets to a single thread at a time
     lldb_private::Predicate<bool> m_is_running;
     uint32_t m_session_key;
     uint8_t m_request_sequence_id;

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

 //----------------------------------------------------------------------
 // CommunicationKDP constructor
 //----------------------------------------------------------------------
-CommunicationKDP::CommunicationKDP (const char *comm_name) :
-    Communication(comm_name),
-    m_addr_byte_size (4),
-    m_byte_order (eByteOrderLittle),
-    m_packet_timeout (5),
-    m_sequence_mutex (Mutex::eMutexTypeRecursive),
-    m_is_running (false),
-    m_session_key (0u),
-    m_request_sequence_id (0u),
-    m_exception_sequence_id (0u),
-    m_kdp_version_version (0u),
-    m_kdp_version_feature (0u),
-    m_kdp_hostinfo_cpu_mask (0u),
-    m_kdp_hostinfo_cpu_type (0u),
-    m_kdp_hostinfo_cpu_subtype (0u)
+CommunicationKDP::CommunicationKDP(const char *comm_name)
+    : Communication(comm_name),
+      m_addr_byte_size(4),
+      m_byte_order(eByteOrderLittle),
+      m_packet_timeout(5),
+      m_sequence_mutex(),
+      m_is_running(false),
+      m_session_key(0u),
+      m_request_sequence_id(0u),
+      m_exception_sequence_id(0u),
+      m_kdp_version_version(0u),
+      m_kdp_version_feature(0u),
+      m_kdp_hostinfo_cpu_mask(0u),
+      m_kdp_hostinfo_cpu_type(0u),
+      m_kdp_hostinfo_cpu_subtype(0u)
 {
 }
 

 bool
 CommunicationKDP::SendRequestPacket (const PacketStreamType &request_packet)
 {
-    Mutex::Locker locker(m_sequence_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
     return SendRequestPacketNoLock (request_packet);
 }
 

         return false;
     }
 
-    Mutex::Locker locker(m_sequence_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
 #ifdef LLDB_CONFIGURATION_DEBUG
     // NOTE: this only works for packets that are in native endian byte order
     assert (request_packet.GetSize() == *((uint16_t *)(request_packet.GetData() + 2)));

 }
 
 bool
-CommunicationKDP::GetSequenceMutex (Mutex::Locker& locker)
+CommunicationKDP::GetSequenceMutex(std::unique_lock<std::recursive_mutex> &lock)
 {
-    return locker.TryLock (m_sequence_mutex);
+    return (lock = std::unique_lock<std::recursive_mutex>(m_sequence_mutex, std::try_to_lock)).owns_lock();
 }
 
 

 size_t
 CommunicationKDP::WaitForPacketWithTimeoutMicroSeconds (DataExtractor &packet, uint32_t timeout_usec)
 {
-    Mutex::Locker locker(m_sequence_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_sequence_mutex);
     return WaitForPacketWithTimeoutMicroSecondsNoLock (packet, timeout_usec);
 }
 

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

 void
 ProcessGDBRemote::ClearThreadIDList ()
 {
-    Mutex::Locker locker(m_thread_list_real.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
     m_thread_ids.clear();
     m_thread_pcs.clear();
 }

 bool
 ProcessGDBRemote::UpdateThreadIDList ()
 {
-    Mutex::Locker locker(m_thread_list_real.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
 
     if (m_jthreadsinfo_sp)
     {

             // m_thread_list_real does have its own mutex, but we need to
             // hold onto the mutex between the call to m_thread_list_real.FindThreadByID(...)
             // and the m_thread_list_real.AddThread(...) so it doesn't change on us
-            Mutex::Locker locker (m_thread_list_real.GetMutex ());
+            std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
             thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
 
             if (!thread_sp)

                 }
                 else if (key.compare("threads") == 0)
                 {
-                    Mutex::Locker locker(m_thread_list_real.GetMutex());
+                    std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
+
                     m_thread_ids.clear();
                     // A comma separated list of all threads in the current
                     // process that includes the thread for this stop reply

 void
 ProcessGDBRemote::RefreshStateAfterStop ()
 {
-    Mutex::Locker locker(m_thread_list_real.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
+
     m_thread_ids.clear();
     m_thread_pcs.clear();
     // Set the thread stop info. It might have a "threads" key whose value is

                 ThreadList &threads = GetThreadList();
 
                 {
-                    Mutex::Locker locker(threads.GetMutex());
+                    std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
 
                     size_t num_threads = threads.GetSize();
                     for (size_t i = 0; i < num_threads; i++)

                     // have to run the risk of letting those threads proceed a bit.
 
                     {
-                        Mutex::Locker locker(threads.GetMutex());
+                        std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
 
                         size_t num_threads = threads.GetSize();
                         for (size_t i = 0; i < num_threads; i++)

source/Symbol/ClangExternalASTSourceCommon.cpp

 
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Core/Stream.h"
-#include "lldb/Host/Mutex.h"
 
 using namespace lldb_private;
 

source/Symbol/CompactUnwindInfo.cpp

 // constructor 
 //----------------------
 
-
-CompactUnwindInfo::CompactUnwindInfo(ObjectFile& objfile, SectionSP& section_sp) :
-    m_objfile (objfile),
-    m_section_sp (section_sp),
-    m_section_contents_if_encrypted (),
-    m_mutex (),
-    m_indexes (),
-    m_indexes_computed (eLazyBoolCalculate),
-    m_unwindinfo_data (),
-    m_unwindinfo_data_computed (false),
-    m_unwind_header ()
+CompactUnwindInfo::CompactUnwindInfo(ObjectFile &objfile, SectionSP &section_sp)
+    : m_objfile(objfile),
+      m_section_sp(section_sp),
+      m_section_contents_if_encrypted(),
+      m_mutex(),
+      m_indexes(),
+      m_indexes_computed(eLazyBoolCalculate),
+      m_unwindinfo_data(),
+      m_unwindinfo_data_computed(false),
+      m_unwind_header()
 {
-
 }
 
 //----------------------

 void
 CompactUnwindInfo::ScanIndex (const ProcessSP &process_sp)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (m_indexes_computed == eLazyBoolYes && m_unwindinfo_data_computed)
         return;
 

source/Symbol/DWARFCallFrameInfo.cpp

     
     if (m_fde_index_initialized)
         return;
-    
-    Mutex::Locker locker(m_fde_index_mutex);
-    
+    std::lock_guard<std::mutex> guard(m_fde_index_mutex);
     if (m_fde_index_initialized) // if two threads hit the locker
         return;
 

source/Symbol/Symtab.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-
-
-Symtab::Symtab(ObjectFile *objfile) :
-    m_objfile (objfile),
-    m_symbols (),
-    m_file_addr_to_index (),
-    m_name_to_index (),
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_file_addr_to_index_computed (false),
-    m_name_indexes_computed (false)
+Symtab::Symtab(ObjectFile *objfile)
+    : m_objfile(objfile),
+      m_symbols(),
+      m_file_addr_to_index(),
+      m_name_to_index(),
+      m_mutex(),
+      m_file_addr_to_index_computed(false),
+      m_name_indexes_computed(false)
 {
 }
 

 size_t
 Symtab::GetNumSymbols() const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_symbols.size();
 }
 

 void
 Symtab::Dump (Stream *s, Target *target, SortOrder sort_order)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     //    s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
     s->Indent();
     const FileSpec &file_spec = m_objfile->GetFileSpec();
     const char * object_name = nullptr;

 void
 Symtab::Dump(Stream *s, Target *target, std::vector<uint32_t>& indexes) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     const size_t num_symbols = GetNumSymbols();
     //s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);

 Symbol *
 Symtab::FindSymbolByID (lldb::user_id_t symbol_uid) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Symbol *symbol = (Symbol*)::bsearch (&symbol_uid, 
                                          &m_symbols[0], 

     if (add_demangled || add_mangled)
     {
         Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
         // Create the name index vector to be able to quickly search by name
         NameToIndexMap::Entry entry;

 uint32_t
 Symtab::AppendSymbolIndexesWithType (SymbolType symbol_type, std::vector<uint32_t>& indexes, uint32_t start_idx, uint32_t end_index) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     uint32_t prev_size = indexes.size();
 

 uint32_t
 Symtab::AppendSymbolIndexesWithTypeAndFlagsValue (SymbolType symbol_type, uint32_t flags_value, std::vector<uint32_t>& indexes, uint32_t start_idx, uint32_t end_index) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     uint32_t prev_size = indexes.size();
 

 uint32_t
 Symtab::AppendSymbolIndexesWithType (SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes, uint32_t start_idx, uint32_t end_index) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     uint32_t prev_size = indexes.size();
 

 void
 Symtab::SortSymbolIndexesByValue (std::vector<uint32_t>& indexes, bool remove_duplicates) const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__,__PRETTY_FUNCTION__);
     // No need to sort if we have zero or one items...

 uint32_t
 Symtab::AppendSymbolIndexesWithName (const ConstString& symbol_name, std::vector<uint32_t>& indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
     if (symbol_name)

 uint32_t
 Symtab::AppendSymbolIndexesWithName (const ConstString& symbol_name, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
     if (symbol_name)

 uint32_t
 Symtab::AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, SymbolType symbol_type, std::vector<uint32_t>& indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (AppendSymbolIndexesWithName(symbol_name, indexes) > 0)
     {

 uint32_t
 Symtab::AppendSymbolIndexesWithNameAndType (const ConstString& symbol_name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (AppendSymbolIndexesWithName(symbol_name, symbol_debug_type, symbol_visibility, indexes) > 0)
     {

 uint32_t
 Symtab::AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regexp, SymbolType symbol_type, std::vector<uint32_t>& indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     uint32_t prev_size = indexes.size();
     uint32_t sym_end = m_symbols.size();

 uint32_t
 Symtab::AppendSymbolIndexesMatchingRegExAndType (const RegularExpression &regexp, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     uint32_t prev_size = indexes.size();
     uint32_t sym_end = m_symbols.size();

 Symbol *
 Symtab::FindSymbolWithType (SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, uint32_t& start_idx)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     const size_t count = m_symbols.size();
     for (size_t idx = start_idx; idx < count; ++idx)

 size_t
 Symtab::FindAllSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, std::vector<uint32_t>& symbol_indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
     // Initialize all of the lookup by name indexes before converting NAME

 size_t
 Symtab::FindAllSymbolsWithNameAndType (const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
     // Initialize all of the lookup by name indexes before converting NAME

 size_t
 Symtab::FindAllSymbolsMatchingRexExAndType (const RegularExpression &regex, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility, std::vector<uint32_t>& symbol_indexes)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type, symbol_visibility, symbol_indexes);
     return symbol_indexes.size();

 Symbol *
 Symtab::FindFirstSymbolWithNameAndType (const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, Visibility symbol_visibility)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     Timer scoped_timer (__PRETTY_FUNCTION__, "%s", __PRETTY_FUNCTION__);
     if (!m_name_indexes_computed)

 void
 Symtab::CalculateSymbolSizes ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (!m_symbols.empty())
     {

 Symbol *
 Symtab::FindSymbolAtFileAddress (addr_t file_addr)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_file_addr_to_index_computed)
         InitAddressIndexes();
 

 Symbol *
 Symtab::FindSymbolContainingFileAddress (addr_t file_addr)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (!m_file_addr_to_index_computed)
         InitAddressIndexes();

 void
 Symtab::ForEachSymbolContainingFileAddress(addr_t file_addr, std::function<bool(Symbol *)> const &callback)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (!m_file_addr_to_index_computed)
         InitAddressIndexes();

         unsigned temp_symbol_indexes_size = temp_symbol_indexes.size();
         if (temp_symbol_indexes_size > 0)
         {
-            Mutex::Locker locker (m_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_mutex);
             for (unsigned i = 0; i < temp_symbol_indexes_size; i++)
             {
                 SymbolContext sym_ctx;

source/Symbol/TypeSystem.cpp

 
 #pragma mark TypeSystemMap
 
-TypeSystemMap::TypeSystemMap() :
-    m_mutex (),
-    m_map (),
-    m_clear_in_progress(false)
+TypeSystemMap::TypeSystemMap() : m_mutex(), m_map(), m_clear_in_progress(false)
 {
 }
 

 {
     collection map;
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::mutex> guard(m_mutex);
         map = m_map;
         m_clear_in_progress = true;
     }

     }
     map.clear();
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::mutex> guard(m_mutex);
         m_map.clear();
         m_clear_in_progress = false;
     }

 void
 TypeSystemMap::ForEach (std::function <bool(TypeSystem *)> const &callback)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     // Use a std::set so we only call the callback once for each unique
     // TypeSystem instance
     std::set<TypeSystem *> visited;

 TypeSystem *
 TypeSystemMap::GetTypeSystemForLanguage (lldb::LanguageType language, Module *module, bool can_create)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     collection::iterator pos = m_map.find(language);
     if (pos != m_map.end())
         return pos->second.get();

 TypeSystem *
 TypeSystemMap::GetTypeSystemForLanguage (lldb::LanguageType language, Target *target, bool can_create)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     collection::iterator pos = m_map.find(language);
     if (pos != m_map.end())
         return pos->second.get();

source/Symbol/UnwindTable.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-UnwindTable::UnwindTable (ObjectFile& objfile) : 
-    m_object_file (objfile), 
-    m_unwinds (),
-    m_initialized (false),
-    m_mutex (),
-    m_eh_frame_up (),
-    m_compact_unwind_up (),
-    m_arm_unwind_up ()
+UnwindTable::UnwindTable(ObjectFile &objfile)
+    : m_object_file(objfile),
+      m_unwinds(),
+      m_initialized(false),
+      m_mutex(),
+      m_eh_frame_up(),
+      m_compact_unwind_up(),
+      m_arm_unwind_up()
 {
 }
 

     if (m_initialized)
         return;
 
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
 
     if (m_initialized) // check again once we've acquired the lock
         return;

 
     Initialize();
 
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
 
     // There is an UnwindTable per object file, so we can safely use file handles
     addr_t file_addr = addr.GetFileAddress();

 void
 UnwindTable::Dump (Stream &s)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     s.Printf("UnwindTable for '%s':\n", m_object_file.GetFileSpec().GetPath().c_str());
     const_iterator begin = m_unwinds.begin();
     const_iterator end = m_unwinds.end();

source/Target/ExecutionContext.cpp

     }
 }
 
-ExecutionContext::ExecutionContext (const ExecutionContextRef *exe_ctx_ref_ptr, Mutex::Locker &locker) :
-    m_target_sp (),
-    m_process_sp (),
-    m_thread_sp (),
-    m_frame_sp ()
+ExecutionContext::ExecutionContext(const ExecutionContextRef *exe_ctx_ref_ptr,
+                                   std::unique_lock<std::recursive_mutex> &lock)
+    : m_target_sp(), m_process_sp(), m_thread_sp(), m_frame_sp()
 {
     if (exe_ctx_ref_ptr)
     {
-        m_target_sp  = exe_ctx_ref_ptr->GetTargetSP();
+        m_target_sp = exe_ctx_ref_ptr->GetTargetSP();
         if (m_target_sp)
         {
-            locker.Lock(m_target_sp->GetAPIMutex());
+            lock = std::unique_lock<std::recursive_mutex>(m_target_sp->GetAPIMutex());
+
             m_process_sp = exe_ctx_ref_ptr->GetProcessSP();
             m_thread_sp = exe_ctx_ref_ptr->GetThreadSP();
             m_frame_sp = exe_ctx_ref_ptr->GetFrameSP();

     }
 }
 
-ExecutionContext::ExecutionContext (const ExecutionContextRef &exe_ctx_ref, Mutex::Locker &locker) :
-    m_target_sp (exe_ctx_ref.GetTargetSP()),
-    m_process_sp (),
-    m_thread_sp (),
-    m_frame_sp ()
+ExecutionContext::ExecutionContext(const ExecutionContextRef &exe_ctx_ref, std::unique_lock<std::recursive_mutex> &lock)
+    : m_target_sp(exe_ctx_ref.GetTargetSP()), m_process_sp(), m_thread_sp(), m_frame_sp()
 {
     if (m_target_sp)
     {
-        locker.Lock(m_target_sp->GetAPIMutex());
+        lock = std::unique_lock<std::recursive_mutex>(m_target_sp->GetAPIMutex());
+
         m_process_sp = exe_ctx_ref.GetProcessSP();
-        m_thread_sp  = exe_ctx_ref.GetThreadSP();
-        m_frame_sp   = exe_ctx_ref.GetFrameSP();
+        m_thread_sp = exe_ctx_ref.GetThreadSP();
+        m_frame_sp = exe_ctx_ref.GetFrameSP();
     }
 }
 

source/Target/Language.cpp

 
 #include "lldb/Target/Language.h"
 
-#include "lldb/Host/Mutex.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Stream.h"
 

source/Target/Memory.cpp

 //----------------------------------------------------------------------
 // MemoryCache constructor
 //----------------------------------------------------------------------
-MemoryCache::MemoryCache(Process &process) :
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_L1_cache (),
-    m_L2_cache (),
-    m_invalid_ranges (),
-    m_process (process),
-    m_L2_cache_line_byte_size (process.GetMemoryCacheLineSize())
+MemoryCache::MemoryCache(Process &process)
+    : m_mutex(),
+      m_L1_cache(),
+      m_L2_cache(),
+      m_invalid_ranges(),
+      m_process(process),
+      m_L2_cache_line_byte_size(process.GetMemoryCacheLineSize())
 {
 }
 

 void
 MemoryCache::Clear(bool clear_invalid_ranges)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_L1_cache.clear();
     m_L2_cache.clear();
     if (clear_invalid_ranges)

 void
 MemoryCache::AddL1CacheData(lldb::addr_t addr, const DataBufferSP &data_buffer_sp)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_L1_cache[addr] = data_buffer_sp;
 }
 

     if (size == 0)
         return;
 
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     // Erase any blocks from the L1 cache that intersect with the flush range
     if (!m_L1_cache.empty())

 {
     if (byte_size > 0)
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         InvalidRanges::Entry range (base_addr, byte_size);
         m_invalid_ranges.Append(range);
         m_invalid_ranges.Sort();

 {
     if (byte_size > 0)
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         const uint32_t idx = m_invalid_ranges.FindEntryIndexThatContains(base_addr);
         if (idx != UINT32_MAX)
         {

     // m_L2_cache_line_byte_size bytes in size, so we don't try anything
     // tricky when reading from them (no partial reads from the L1 cache).
 
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_L1_cache.empty())
     {
         AddrRange read_range(addr, dst_len);

     return success;
 }
 
-
-AllocatedMemoryCache::AllocatedMemoryCache (Process &process) :
-    m_process (process),
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_memory_map()
+AllocatedMemoryCache::AllocatedMemoryCache(Process &process) : m_process(process), m_mutex(), m_memory_map()
 {
 }
 

 void
 AllocatedMemoryCache::Clear()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_process.IsAlive())
     {
         PermissionsToBlockMap::iterator pos, end = m_memory_map.end();

                                       uint32_t permissions, 
                                       Error &error)
 {
-    Mutex::Locker locker (m_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     addr_t addr = LLDB_INVALID_ADDRESS;
     std::pair<PermissionsToBlockMap::iterator, PermissionsToBlockMap::iterator> range = m_memory_map.equal_range (permissions);
 

 bool
 AllocatedMemoryCache::DeallocateMemory (lldb::addr_t addr)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     PermissionsToBlockMap::iterator pos, end = m_memory_map.end();
     bool success = false;

source/Target/Process.cpp

     // defaulting to using the Host's UnixSignals.
 }
 
-Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, const UnixSignalsSP &unix_signals_sp) :
-    ProcessProperties (this),
-    UserID (LLDB_INVALID_PROCESS_ID),
-    Broadcaster ((target_sp->GetDebugger().GetBroadcasterManager()), Process::GetStaticBroadcasterClass().AsCString()),
-    m_target_sp (target_sp),
-    m_public_state (eStateUnloaded),
-    m_private_state (eStateUnloaded),
+Process::Process(lldb::TargetSP target_sp, ListenerSP listener_sp, const UnixSignalsSP &unix_signals_sp)
+    : ProcessProperties(this),
+      UserID(LLDB_INVALID_PROCESS_ID),
+      Broadcaster((target_sp->GetDebugger().GetBroadcasterManager()), Process::GetStaticBroadcasterClass().AsCString()),
+      m_target_sp(target_sp),
+      m_public_state(eStateUnloaded),
+      m_private_state(eStateUnloaded),
       m_private_state_broadcaster(nullptr, "lldb.process.internal_state_broadcaster"),
       m_private_state_control_broadcaster(nullptr, "lldb.process.internal_state_control_broadcaster"),
-    m_private_state_listener_sp (Listener::MakeListener("lldb.process.internal_state_listener")),
-    m_mod_id (),
+      m_private_state_listener_sp(Listener::MakeListener("lldb.process.internal_state_listener")),
+      m_mod_id(),
       m_process_unique_id(0),
-    m_thread_index_id (0),
-    m_thread_id_to_index_id_map (),
-    m_exit_status (-1),
-    m_exit_string (),
+      m_thread_index_id(0),
+      m_thread_id_to_index_id_map(),
+      m_exit_status(-1),
+      m_exit_string(),
       m_exit_status_mutex(),
-    m_thread_mutex (Mutex::eMutexTypeRecursive),
-    m_thread_list_real (this),
-    m_thread_list (this),
-    m_extended_thread_list (this),
-    m_extended_thread_stop_id (0),
-    m_queue_list (this),
-    m_queue_list_stop_id (0),
-    m_notifications (),
-    m_image_tokens (),
-    m_listener_sp (listener_sp),
-    m_breakpoint_site_list (),
-    m_dynamic_checkers_ap (),
-    m_unix_signals_sp (unix_signals_sp),
-    m_abi_sp (),
-    m_process_input_reader (),
-    m_stdio_communication ("process.stdio"),
-    m_stdio_communication_mutex (Mutex::eMutexTypeRecursive),
-    m_stdin_forward (false),
-    m_stdout_data (),
-    m_stderr_data (),
-    m_profile_data_comm_mutex (Mutex::eMutexTypeRecursive),
-    m_profile_data (),
-    m_iohandler_sync (0),
-    m_memory_cache (*this),
-    m_allocated_memory_cache (*this),
-    m_should_detach (false),
+      m_thread_mutex(),
+      m_thread_list_real(this),
+      m_thread_list(this),
+      m_extended_thread_list(this),
+      m_extended_thread_stop_id(0),
+      m_queue_list(this),
+      m_queue_list_stop_id(0),
+      m_notifications(),
+      m_image_tokens(),
+      m_listener_sp(listener_sp),
+      m_breakpoint_site_list(),
+      m_dynamic_checkers_ap(),
+      m_unix_signals_sp(unix_signals_sp),
+      m_abi_sp(),
+      m_process_input_reader(),
+      m_stdio_communication("process.stdio"),
+      m_stdio_communication_mutex(),
+      m_stdin_forward(false),
+      m_stdout_data(),
+      m_stderr_data(),
+      m_profile_data_comm_mutex(),
+      m_profile_data(),
+      m_iohandler_sync(0),
+      m_memory_cache(*this),
+      m_allocated_memory_cache(*this),
+      m_should_detach(false),
       m_next_event_action_ap(),
-    m_public_run_lock (),
-    m_private_run_lock (),
+      m_public_run_lock(),
+      m_private_run_lock(),
       m_stop_info_override_callback(nullptr),
-    m_finalizing (false),
-    m_finalize_called (false),
-    m_clear_thread_plans_on_stop (false),
-    m_force_next_event_delivery (false),
-    m_last_broadcast_state (eStateInvalid),
-    m_destroy_in_process (false),
+      m_finalizing(false),
+      m_finalize_called(false),
+      m_clear_thread_plans_on_stop(false),
+      m_force_next_event_delivery(false),
+      m_last_broadcast_state(eStateInvalid),
+      m_destroy_in_process(false),
       m_can_interpret_function_calls(false),
-    m_warnings_issued (),
+      m_warnings_issued(),
       m_can_jit(eCanJITDontKnow)
-{
-    CheckInWithManager ();
-
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+{
+    CheckInWithManager();
+
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf ("%p Process::Process()", static_cast<void*>(this));
+        log->Printf("%p Process::Process()", static_cast<void *>(this));
 
     if (!m_unix_signals_sp)
         m_unix_signals_sp = std::make_shared<UnixSignals>();
 
-    SetEventName (eBroadcastBitStateChanged, "state-changed");
-    SetEventName (eBroadcastBitInterrupt, "interrupt");
-    SetEventName (eBroadcastBitSTDOUT, "stdout-available");
-    SetEventName (eBroadcastBitSTDERR, "stderr-available");
-    SetEventName (eBroadcastBitProfileData, "profile-data-available");
+    SetEventName(eBroadcastBitStateChanged, "state-changed");
+    SetEventName(eBroadcastBitInterrupt, "interrupt");
+    SetEventName(eBroadcastBitSTDOUT, "stdout-available");
+    SetEventName(eBroadcastBitSTDERR, "stderr-available");
+    SetEventName(eBroadcastBitProfileData, "profile-data-available");
 
-    m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlStop  , "control-stop"  );
-    m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlPause , "control-pause" );
-    m_private_state_control_broadcaster.SetEventName (eBroadcastInternalStateControlResume, "control-resume");
+    m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlStop, "control-stop");
+    m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlPause, "control-pause");
+    m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlResume, "control-resume");
 
-    m_listener_sp->StartListeningForEvents (this,
-                                      eBroadcastBitStateChanged |
-                                      eBroadcastBitInterrupt |
-                                      eBroadcastBitSTDOUT |
-                                      eBroadcastBitSTDERR |
-                                      eBroadcastBitProfileData);
+    m_listener_sp->StartListeningForEvents(this, eBroadcastBitStateChanged | eBroadcastBitInterrupt |
+                                                     eBroadcastBitSTDOUT | eBroadcastBitSTDERR |
+                                                     eBroadcastBitProfileData);
 
     m_private_state_listener_sp->StartListeningForEvents(&m_private_state_broadcaster,
-                                                     eBroadcastBitStateChanged |
-                                                     eBroadcastBitInterrupt);
+                                                         eBroadcastBitStateChanged | eBroadcastBitInterrupt);
 
-    m_private_state_listener_sp->StartListeningForEvents(&m_private_state_control_broadcaster,
-                                                     eBroadcastInternalStateControlStop |
-                                                     eBroadcastInternalStateControlPause |
-                                                     eBroadcastInternalStateControlResume);
+    m_private_state_listener_sp->StartListeningForEvents(
+        &m_private_state_control_broadcaster, eBroadcastInternalStateControlStop | eBroadcastInternalStateControlPause |
+                                                  eBroadcastInternalStateControlResume);
     // We need something valid here, even if just the default UnixSignalsSP.
-    assert (m_unix_signals_sp && "null m_unix_signals_sp after initialization");
+    assert(m_unix_signals_sp && "null m_unix_signals_sp after initialization");
 
     // Allow the platform to override the default cache line size
-    OptionValueSP value_sp =
-        m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)->GetValue();
+    OptionValueSP value_sp = m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)->GetValue();
     uint32_t platform_cache_line_size = target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();
-    if (! value_sp->OptionWasSet() && platform_cache_line_size != 0)
+    if (!value_sp->OptionWasSet() && platform_cache_line_size != 0)
         value_sp->SetUInt64Value(platform_cache_line_size);
 }
 

                 // Lock the thread list so it doesn't change on us, this is the scope for the locker:
                 {
                     ThreadList &thread_list = process_sp->GetThreadList();
-                    Mutex::Locker locker (thread_list.GetMutex());
+                    std::lock_guard<std::recursive_mutex> guard(thread_list.GetMutex());
 
                     ThreadSP curr_thread (thread_list.GetSelectedThread());
                     ThreadSP thread;

 int
 Process::GetExitStatus ()
 {
-    Mutex::Locker locker (m_exit_status_mutex);
+    std::lock_guard<std::mutex> guard(m_exit_status_mutex);
 
     if (m_public_state.GetValue() == eStateExited)
         return m_exit_status;

 const char *
 Process::GetExitDescription ()
 {
-    Mutex::Locker locker (m_exit_status_mutex);
+    std::lock_guard<std::mutex> guard(m_exit_status_mutex);
 
     if (m_public_state.GetValue() == eStateExited && !m_exit_string.empty())
         return m_exit_string.c_str();

 Process::SetExitStatus (int status, const char *cstr)
 {
     // Use a mutex to protect setting the exit status.
-    Mutex::Locker locker (m_exit_status_mutex);
+    std::lock_guard<std::mutex> guard(m_exit_status_mutex);
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_STATE | LIBLLDB_LOG_PROCESS));
     if (log)

         const StateType state = GetPrivateState();
         if (StateIsStoppedState (state, true))
         {
-            Mutex::Locker locker (m_thread_list.GetMutex ());
+            std::lock_guard<std::recursive_mutex> guard(m_thread_list.GetMutex());
             // m_thread_list does have its own mutex, but we need to
             // hold onto the mutex between the call to UpdateThreadList(...)
             // and the os->UpdateThreadList(...) so it doesn't change on us

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

     m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr));
     // Figure out which one is the executable, and set that in our target:
     const ModuleList &target_modules = GetTarget().GetImages();
-    Mutex::Locker modules_locker(target_modules.GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(target_modules.GetMutex());
     size_t num_modules = target_modules.GetSize();
     ModuleSP new_executable_module_sp;
     

 void
 Process::AppendSTDOUT (const char * s, size_t len)
 {
-    Mutex::Locker locker (m_stdio_communication_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
     m_stdout_data.append (s, len);
     BroadcastEventIfUnique (eBroadcastBitSTDOUT, new ProcessEventData (shared_from_this(), GetState()));
 }

 void
 Process::AppendSTDERR (const char * s, size_t len)
 {
-    Mutex::Locker locker (m_stdio_communication_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
     m_stderr_data.append (s, len);
     BroadcastEventIfUnique (eBroadcastBitSTDERR, new ProcessEventData (shared_from_this(), GetState()));
 }

 void
 Process::BroadcastAsyncProfileData(const std::string &one_profile_data)
 {
-    Mutex::Locker locker (m_profile_data_comm_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
     m_profile_data.push_back(one_profile_data);
     BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
 }

 size_t
 Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
 {
-    Mutex::Locker locker(m_profile_data_comm_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_profile_data_comm_mutex);
     if (m_profile_data.empty())
         return 0;
     

 size_t
 Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
 {
-    Mutex::Locker locker(m_stdio_communication_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_stdio_communication_mutex);
     size_t bytes_available = m_stdout_data.size();
     if (bytes_available > 0)
     {

 size_t
 Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
 {
-    Mutex::Locker locker(m_stdio_communication_mutex);
+    std::lock_guard<std::recursive_mutex> gaurd(m_stdio_communication_mutex);
     size_t bytes_available = m_stderr_data.size();
     if (bytes_available > 0)
     {

             if (GetThreadList().SetSelectedThreadByIndexID (selected_tid) && selected_stack_id.IsValid())
             {
                 // We were able to restore the selected thread, now restore the frame:
-                Mutex::Locker lock(GetThreadList().GetMutex());
+                std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex());
                 StackFrameSP old_frame_sp = GetThreadList().GetSelectedThread()->GetFrameWithStackID(selected_stack_id);
                 if (old_frame_sp)
                     GetThreadList().GetSelectedThread()->SetSelectedFrame(old_frame_sp.get());

     std::vector<lldb::tid_t> thread_id_array;
     //Scope for thread list locker;
     {
-        Mutex::Locker locker (GetThreadList().GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetThreadList().GetMutex());
         ThreadList &curr_thread_list = GetThreadList();
         num_threads = curr_thread_list.GetSize();
         uint32_t idx;

source/Target/QueueList.cpp

 using namespace lldb;
 using namespace lldb_private;
 
-QueueList::QueueList (Process *process) :
-    m_process (process),
-    m_stop_id (0),
-    m_queues (),
-    m_mutex ()
+QueueList::QueueList(Process *process) : m_process(process), m_stop_id(0), m_queues(), m_mutex()
 {
 }
 

 uint32_t
 QueueList::GetSize ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     return m_queues.size();
 }
 
 lldb::QueueSP
 QueueList::GetQueueAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (idx < m_queues.size())
     {
         return m_queues[idx];

 void
 QueueList::Clear ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     m_queues.clear();
 }
 
 void
 QueueList::AddQueue (QueueSP queue_sp)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::mutex> guard(m_mutex);
     if (queue_sp.get ())
     {
         m_queues.push_back (queue_sp);

     return ret;
 }
 
-lldb_private::Mutex &
-QueueList::GetMutex ()
+std::mutex &
+QueueList::GetMutex()
 {
     return m_mutex;
 }

source/Target/StackFrame.cpp

 #define RESOLVED_VARIABLES              (GOT_FRAME_BASE << 1)
 #define RESOLVED_GLOBAL_VARIABLES       (RESOLVED_VARIABLES << 1)
 
-StackFrame::StackFrame (const ThreadSP &thread_sp, 
-                        user_id_t frame_idx, 
-                        user_id_t unwind_frame_index, 
-                        addr_t cfa, 
-                        bool cfa_is_valid,
-                        addr_t pc, 
-                        uint32_t stop_id,
-                        bool stop_id_is_valid,
-                        bool is_history_frame,
-                        const SymbolContext *sc_ptr) :
-    m_thread_wp (thread_sp),
-    m_frame_index (frame_idx),
-    m_concrete_frame_index (unwind_frame_index),    
-    m_reg_context_sp (),
-    m_id(pc, cfa, nullptr),
-    m_frame_code_addr (pc),
-    m_sc (),
-    m_flags (),
-    m_frame_base (),
-    m_frame_base_error (),
-    m_cfa_is_valid (cfa_is_valid),
-    m_stop_id  (stop_id),
-    m_stop_id_is_valid (stop_id_is_valid),
-    m_is_history_frame (is_history_frame),
-    m_variable_list_sp (),
-    m_variable_list_value_objects (),
-    m_disassembly (),
-    m_mutex (Mutex::eMutexTypeRecursive)
+StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index, addr_t cfa,
+                       bool cfa_is_valid, addr_t pc, uint32_t stop_id, bool stop_id_is_valid, bool is_history_frame,
+                       const SymbolContext *sc_ptr)
+    : m_thread_wp(thread_sp),
+      m_frame_index(frame_idx),
+      m_concrete_frame_index(unwind_frame_index),
+      m_reg_context_sp(),
+      m_id(pc, cfa, nullptr),
+      m_frame_code_addr(pc),
+      m_sc(),
+      m_flags(),
+      m_frame_base(),
+      m_frame_base_error(),
+      m_cfa_is_valid(cfa_is_valid),
+      m_stop_id(stop_id),
+      m_stop_id_is_valid(stop_id_is_valid),
+      m_is_history_frame(is_history_frame),
+      m_variable_list_sp(),
+      m_variable_list_value_objects(),
+      m_disassembly(),
+      m_mutex()
 {
     // If we don't have a CFA value, use the frame index for our StackID so that recursive
     // functions properly aren't confused with one another on a history stack.
     if (m_is_history_frame && !m_cfa_is_valid)
     {
-        m_id.SetCFA (m_frame_index);
+        m_id.SetCFA(m_frame_index);
     }
 
     if (sc_ptr != nullptr)
     {
         m_sc = *sc_ptr;
-        m_flags.Set(m_sc.GetResolvedMask ());
+        m_flags.Set(m_sc.GetResolvedMask());
     }
 }
 
-StackFrame::StackFrame (const ThreadSP &thread_sp, 
-                        user_id_t frame_idx, 
-                        user_id_t unwind_frame_index, 
-                        const RegisterContextSP &reg_context_sp, 
-                        addr_t cfa, 
-                        addr_t pc, 
-                        const SymbolContext *sc_ptr) :
-    m_thread_wp (thread_sp),
-    m_frame_index (frame_idx),
-    m_concrete_frame_index (unwind_frame_index),    
-    m_reg_context_sp (reg_context_sp),
-    m_id(pc, cfa, nullptr),
-    m_frame_code_addr (pc),
-    m_sc (),
-    m_flags (),
-    m_frame_base (),
-    m_frame_base_error (),
-    m_cfa_is_valid (true),
-    m_stop_id  (0),
-    m_stop_id_is_valid (false),
-    m_is_history_frame (false),
-    m_variable_list_sp (),
-    m_variable_list_value_objects (),
-    m_disassembly (),
-    m_mutex (Mutex::eMutexTypeRecursive)
+StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index,
+                       const RegisterContextSP &reg_context_sp, addr_t cfa, addr_t pc, const SymbolContext *sc_ptr)
+    : m_thread_wp(thread_sp),
+      m_frame_index(frame_idx),
+      m_concrete_frame_index(unwind_frame_index),
+      m_reg_context_sp(reg_context_sp),
+      m_id(pc, cfa, nullptr),
+      m_frame_code_addr(pc),
+      m_sc(),
+      m_flags(),
+      m_frame_base(),
+      m_frame_base_error(),
+      m_cfa_is_valid(true),
+      m_stop_id(0),
+      m_stop_id_is_valid(false),
+      m_is_history_frame(false),
+      m_variable_list_sp(),
+      m_variable_list_value_objects(),
+      m_disassembly(),
+      m_mutex()
 {
     if (sc_ptr != nullptr)
     {
         m_sc = *sc_ptr;
-        m_flags.Set(m_sc.GetResolvedMask ());
+        m_flags.Set(m_sc.GetResolvedMask());
     }
-    
     if (reg_context_sp && !m_sc.target_sp)
     {
         m_sc.target_sp = reg_context_sp->CalculateTarget();
         if (m_sc.target_sp)
-            m_flags.Set (eSymbolContextTarget);
+            m_flags.Set(eSymbolContextTarget);
     }
 }
 
-StackFrame::StackFrame (const ThreadSP &thread_sp, 
-                        user_id_t frame_idx, 
-                        user_id_t unwind_frame_index, 
-                        const RegisterContextSP &reg_context_sp, 
-                        addr_t cfa, 
-                        const Address& pc_addr,
-                        const SymbolContext *sc_ptr) :
-    m_thread_wp (thread_sp),
-    m_frame_index (frame_idx),
-    m_concrete_frame_index (unwind_frame_index),    
-    m_reg_context_sp (reg_context_sp),
-    m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa, nullptr),
-    m_frame_code_addr (pc_addr),
-    m_sc (),
-    m_flags (),
-    m_frame_base (),
-    m_frame_base_error (),
-    m_cfa_is_valid (true),
-    m_stop_id  (0),
-    m_stop_id_is_valid (false),
-    m_is_history_frame (false),
-    m_variable_list_sp (),
-    m_variable_list_value_objects (),
-    m_disassembly (),
-    m_mutex (Mutex::eMutexTypeRecursive)
+StackFrame::StackFrame(const ThreadSP &thread_sp, user_id_t frame_idx, user_id_t unwind_frame_index,
+                       const RegisterContextSP &reg_context_sp, addr_t cfa, const Address &pc_addr,
+                       const SymbolContext *sc_ptr)
+    : m_thread_wp(thread_sp),
+      m_frame_index(frame_idx),
+      m_concrete_frame_index(unwind_frame_index),
+      m_reg_context_sp(reg_context_sp),
+      m_id(pc_addr.GetLoadAddress(thread_sp->CalculateTarget().get()), cfa, nullptr),
+      m_frame_code_addr(pc_addr),
+      m_sc(),
+      m_flags(),
+      m_frame_base(),
+      m_frame_base_error(),
+      m_cfa_is_valid(true),
+      m_stop_id(0),
+      m_stop_id_is_valid(false),
+      m_is_history_frame(false),
+      m_variable_list_sp(),
+      m_variable_list_value_objects(),
+      m_disassembly(),
+      m_mutex()
 {
     if (sc_ptr != nullptr)
     {
         m_sc = *sc_ptr;
-        m_flags.Set(m_sc.GetResolvedMask ());
+        m_flags.Set(m_sc.GetResolvedMask());
     }
-    
     if (!m_sc.target_sp && reg_context_sp)
     {
         m_sc.target_sp = reg_context_sp->CalculateTarget();
         if (m_sc.target_sp)
-            m_flags.Set (eSymbolContextTarget);
+            m_flags.Set(eSymbolContextTarget);
     }
-    
-    ModuleSP pc_module_sp (pc_addr.GetModule());
+    ModuleSP pc_module_sp(pc_addr.GetModule());
     if (!m_sc.module_sp || m_sc.module_sp != pc_module_sp)
     {
         if (pc_module_sp)
         {
             m_sc.module_sp = pc_module_sp;
-            m_flags.Set (eSymbolContextModule);
+            m_flags.Set(eSymbolContextModule);
         }
         else
         {

 StackID&
 StackFrame::GetStackID()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // Make sure we have resolved the StackID object's symbol context scope if
     // we already haven't looked it up.
 

 void
 StackFrame::SetSymbolContextScope (SymbolContextScope *symbol_scope)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_flags.Set (RESOLVED_FRAME_ID_SYMBOL_SCOPE);
     m_id.SetSymbolContextScope (symbol_scope);
 }

 const Address&
 StackFrame::GetFrameCodeAddress()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_flags.IsClear(RESOLVED_FRAME_CODE_ADDR) && !m_frame_code_addr.IsSectionOffset())
     {
         m_flags.Set (RESOLVED_FRAME_CODE_ADDR);

 bool
 StackFrame::ChangePC (addr_t pc)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // We can't change the pc value of a history stack frame - it is immutable.
     if (m_is_history_frame)
         return false;

 const char *
 StackFrame::Disassemble ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_disassembly.GetSize() == 0)
     {
         ExecutionContext exe_ctx (shared_from_this());

 const SymbolContext&
 StackFrame::GetSymbolContext (uint32_t resolve_scope)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // Copy our internal symbol context into "sc".
     if ((m_flags.Get() & resolve_scope) != resolve_scope)
     {

 VariableList *
 StackFrame::GetVariableList (bool get_file_globals)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_flags.IsClear(RESOLVED_VARIABLES))
     {
         m_flags.Set(RESOLVED_VARIABLES);

 VariableListSP
 StackFrame::GetInScopeVariableList (bool get_file_globals, bool must_have_valid_location)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     // We can't fetch variable information for a history stack frame.
     if (m_is_history_frame)
         return VariableListSP();

 bool
 StackFrame::GetFrameBaseValue (Scalar &frame_base, Error *error_ptr)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_cfa_is_valid)
     {
         m_frame_base_error.SetErrorString("No frame base available for this historical stack frame.");

 RegisterContextSP
 StackFrame::GetRegisterContext ()
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (!m_reg_context_sp)
     {
         ThreadSP thread_sp (GetThread());

 ValueObjectSP
 StackFrame::GetValueObjectForFrameVariable (const VariableSP &variable_sp, DynamicValueType use_dynamic)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     ValueObjectSP valobj_sp;
     if (m_is_history_frame)
     {

 ValueObjectSP
 StackFrame::TrackGlobalVariable (const VariableSP &variable_sp, DynamicValueType use_dynamic)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_is_history_frame)
         return ValueObjectSP();
 

 void
 StackFrame::UpdateCurrentFrameFromPreviousFrame (StackFrame &prev_frame)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     assert (GetStackID() == prev_frame.GetStackID());    // TODO: remove this after some testing
     m_variable_list_sp = prev_frame.m_variable_list_sp;
     m_variable_list_value_objects.Swap (prev_frame.m_variable_list_value_objects);

 void
 StackFrame::UpdatePreviousFrameFromCurrentFrame (StackFrame &curr_frame)
 {
-    Mutex::Locker locker(m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     assert (GetStackID() == curr_frame.GetStackID());        // TODO: remove this after some testing
     m_id.SetPC (curr_frame.m_id.GetPC());       // Update the Stack ID PC value
     assert (GetThread() == curr_frame.GetThread());

source/Target/StackFrameList.cpp

 //----------------------------------------------------------------------
 // StackFrameList constructor
 //----------------------------------------------------------------------
-StackFrameList::StackFrameList
-(
-    Thread &thread, 
-    const lldb::StackFrameListSP &prev_frames_sp, 
-    bool show_inline_frames
-) :
-    m_thread (thread),
-    m_prev_frames_sp (prev_frames_sp),
-    m_mutex (Mutex::eMutexTypeRecursive),
-    m_frames (),
-    m_selected_frame_idx (0),
-    m_concrete_frames_fetched (0),
-    m_current_inlined_depth (UINT32_MAX),
-    m_current_inlined_pc (LLDB_INVALID_ADDRESS),
-    m_show_inlined_frames (show_inline_frames)
+StackFrameList::StackFrameList(Thread &thread, const lldb::StackFrameListSP &prev_frames_sp, bool show_inline_frames)
+    : m_thread(thread),
+      m_prev_frames_sp(prev_frames_sp),
+      m_mutex(),
+      m_frames(),
+      m_selected_frame_idx(0),
+      m_concrete_frames_fetched(0),
+      m_current_inlined_depth(UINT32_MAX),
+      m_current_inlined_pc(LLDB_INVALID_ADDRESS),
+      m_show_inlined_frames(show_inline_frames)
 {
     if (prev_frames_sp)
     {
         m_current_inlined_depth = prev_frames_sp->m_current_inlined_depth;
-        m_current_inlined_pc =    prev_frames_sp->m_current_inlined_pc;
+        m_current_inlined_pc = prev_frames_sp->m_current_inlined_pc;
     }
 }
 

 void
 StackFrameList::ResetCurrentInlinedDepth ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (m_show_inlined_frames)
     {        

 uint32_t
 StackFrameList::GetNumFrames (bool can_create)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     if (can_create)
         GetFramesUpTo (UINT32_MAX);

 {
     if (s == nullptr)
         return;
-    Mutex::Locker locker (m_mutex);
+
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
     const_iterator pos, begin = m_frames.begin(), end = m_frames.end();
     for (pos = begin; pos != end; ++pos)

 StackFrameList::GetFrameAtIndex (uint32_t idx)
 {
     StackFrameSP frame_sp;
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     uint32_t original_idx = idx;
     
     uint32_t inlined_depth = GetCurrentInlinedDepth();

     
     if (stack_id.IsValid())
     {
-        Mutex::Locker locker (m_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_mutex);
         uint32_t frame_idx = 0;
         // Do a binary search in case the stack frame is already in our cache
         collection::const_iterator begin = m_frames.begin();

 uint32_t
 StackFrameList::GetSelectedFrameIndex () const
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     return m_selected_frame_idx;
 }
 
 uint32_t
 StackFrameList::SetSelectedFrame (lldb_private::StackFrame *frame)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     const_iterator pos;
     const_iterator begin = m_frames.begin();
     const_iterator end = m_frames.end();

 bool
 StackFrameList::SetSelectedFrameByIndex (uint32_t idx)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     StackFrameSP frame_sp (GetFrameAtIndex (idx));
     if (frame_sp)
     {

 void
 StackFrameList::Clear ()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_frames.clear();
     m_concrete_frames_fetched = 0;
 }

 void
 StackFrameList::InvalidateFrames (uint32_t start_idx)
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (m_show_inlined_frames)
     {
         Clear();

 void
 StackFrameList::Merge (std::unique_ptr<StackFrameList>& curr_ap, lldb::StackFrameListSP& prev_sp)
 {
-    Mutex::Locker curr_locker(curr_ap ? &curr_ap->m_mutex : nullptr);
-    Mutex::Locker prev_locker(prev_sp ? &prev_sp->m_mutex : nullptr);
+    std::unique_lock<std::recursive_mutex> current_lock, previous_lock;
+    if (curr_ap)
+        current_lock = std::unique_lock<std::recursive_mutex>(curr_ap->m_mutex);
+    if (prev_sp)
+        previous_lock = std::unique_lock<std::recursive_mutex>(prev_sp->m_mutex);
 
 #if defined (DEBUG_STACK_FRAMES)
     StreamFile s(stdout, false);

source/Target/Target.cpp

     return class_name;
 }
 
-Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target) :
-    TargetProperties (this),
-    Broadcaster (debugger.GetBroadcasterManager(), Target::GetStaticBroadcasterClass().AsCString()),
-    ExecutionContextScope (),
-    m_debugger (debugger),
-    m_platform_sp (platform_sp),
-    m_mutex (Mutex::eMutexTypeRecursive), 
-    m_arch (target_arch),
-    m_images (this),
-    m_section_load_history (),
-    m_breakpoint_list (false),
-    m_internal_breakpoint_list (true),
-    m_watchpoint_list (),
-    m_process_sp (),
-    m_search_filter_sp (),
-    m_image_search_paths (ImageSearchPathsChanged, this),
-    m_ast_importer_sp (),
-    m_source_manager_ap(),
-    m_stop_hooks (),
-    m_stop_hook_next_id (0),
-    m_valid (true),
-    m_suppress_stop_hooks (false),
-    m_is_dummy_target(is_dummy_target)
-
-{
-    SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed");
-    SetEventName (eBroadcastBitModulesLoaded, "modules-loaded");
-    SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded");
-    SetEventName (eBroadcastBitWatchpointChanged, "watchpoint-changed");
-    SetEventName (eBroadcastBitSymbolsLoaded, "symbols-loaded");
+Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp,
+               bool is_dummy_target)
+    : TargetProperties(this),
+      Broadcaster(debugger.GetBroadcasterManager(), Target::GetStaticBroadcasterClass().AsCString()),
+      ExecutionContextScope(),
+      m_debugger(debugger),
+      m_platform_sp(platform_sp),
+      m_mutex(),
+      m_arch(target_arch),
+      m_images(this),
+      m_section_load_history(),
+      m_breakpoint_list(false),
+      m_internal_breakpoint_list(true),
+      m_watchpoint_list(),
+      m_process_sp(),
+      m_search_filter_sp(),
+      m_image_search_paths(ImageSearchPathsChanged, this),
+      m_ast_importer_sp(),
+      m_source_manager_ap(),
+      m_stop_hooks(),
+      m_stop_hook_next_id(0),
+      m_valid(true),
+      m_suppress_stop_hooks(false),
+      m_is_dummy_target(is_dummy_target)
+
+{
+    SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed");
+    SetEventName(eBroadcastBitModulesLoaded, "modules-loaded");
+    SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
+    SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
+    SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
 
     CheckInWithManager();
 
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf ("%p Target::Target()", static_cast<void*>(this));
+        log->Printf("%p Target::Target()", static_cast<void *>(this));
     if (m_arch.IsValid())
     {
-        LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
+        LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)",
+                              m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
     }
 }
 

     m_breakpoint_list.ClearAllBreakpointSites();
     m_internal_breakpoint_list.ClearAllBreakpointSites();
     // Disable watchpoints just on the debugger side.
-    Mutex::Locker locker;
-    this->GetWatchpointList().GetListMutex(locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    this->GetWatchpointList().GetListMutex(lock);
     DisableAllWatchpoints(false);
     ClearAllWatchpointHitCounts();
     ClearAllWatchpointHistoricValues();

 void
 Target::Destroy()
 {
-    Mutex::Locker locker (m_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_mutex);
     m_valid = false;
     DeleteCurrentProcess ();
     m_platform_sp.reset();

 
     // Grab the list mutex while doing operations.
     const bool notify = false;   // Don't notify about all the state changes we do on creating the watchpoint.
-    Mutex::Locker locker;
-    this->GetWatchpointList().GetListMutex(locker);
+    std::unique_lock<std::recursive_mutex> lock;
+    this->GetWatchpointList().GetListMutex(lock);
     WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr);
     if (matched_sp)
     {

source/Target/ThreadCollection.cpp

 void
 ThreadCollection::AddThread (const ThreadSP &thread_sp)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     m_threads.push_back (thread_sp);
 }
 
 void
 ThreadCollection::InsertThread (const lldb::ThreadSP &thread_sp, uint32_t idx)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     if (idx < m_threads.size())
         m_threads.insert(m_threads.begin() + idx, thread_sp);
     else

 uint32_t
 ThreadCollection::GetSize ()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     return m_threads.size();
 }
 
 ThreadSP
 ThreadCollection::GetThreadAtIndex (uint32_t idx)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     ThreadSP thread_sp;
     if (idx < m_threads.size())
         thread_sp = m_threads[idx];

source/Target/ThreadList.cpp

     {
         // Lock both mutexes to make sure neither side changes anyone on us
         // while the assignment occurs
-        Mutex::Locker locker(GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetMutex());
+
         m_process = rhs.m_process;
         m_stop_id = rhs.m_stop_id;
         m_threads = rhs.m_threads;

 uint32_t
 ThreadList::GetSize (bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
+
     if (can_update)
         m_process->UpdateThreadListIfNeeded();
     return m_threads.size();

 ThreadSP
 ThreadList::GetThreadAtIndex (uint32_t idx, bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
+
     if (can_update)
         m_process->UpdateThreadListIfNeeded();
 

 ThreadSP
 ThreadList::FindThreadByID (lldb::tid_t tid, bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
     if (can_update)
         m_process->UpdateThreadListIfNeeded();

 ThreadSP
 ThreadList::FindThreadByProtocolID (lldb::tid_t tid, bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     if (can_update)
         m_process->UpdateThreadListIfNeeded();
     

 ThreadSP
 ThreadList::RemoveThreadByID (lldb::tid_t tid, bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     if (can_update)
         m_process->UpdateThreadListIfNeeded();
     

 ThreadSP
 ThreadList::RemoveThreadByProtocolID (lldb::tid_t tid, bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
-    
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     if (can_update)
         m_process->UpdateThreadListIfNeeded();
     

     ThreadSP thread_sp;
     if (thread_ptr)
     {
-        Mutex::Locker locker(GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
         uint32_t idx = 0;
         const uint32_t num_threads = m_threads.size();

 ThreadSP
 ThreadList::FindThreadByIndexID (uint32_t index_id, bool can_update)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
     if (can_update)
         m_process->UpdateThreadListIfNeeded();

     collection threads_copy;
     {
         // Scope for locker
-        Mutex::Locker locker(GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
         m_process->UpdateThreadListIfNeeded();
         for (lldb::ThreadSP thread_sp : m_threads)

 Vote
 ThreadList::ShouldReportStop (Event *event_ptr)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
     Vote result = eVoteNoOpinion;
     m_process->UpdateThreadListIfNeeded();

 void
 ThreadList::SetShouldReportStop (Vote vote)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
+
     m_process->UpdateThreadListIfNeeded();
     collection::iterator pos, end = m_threads.end();
     for (pos = m_threads.begin(); pos != end; ++pos)

 ThreadList::ShouldReportRun (Event *event_ptr)
 {
 
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
     Vote result = eVoteNoOpinion;
     m_process->UpdateThreadListIfNeeded();

 void
 ThreadList::Clear()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     m_stop_id = 0;
     m_threads.clear();
     m_selected_tid = LLDB_INVALID_THREAD_ID;

 void
 ThreadList::Destroy()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     const uint32_t num_threads = m_threads.size();
     for (uint32_t idx = 0; idx < num_threads; ++idx)
     {

 void
 ThreadList::RefreshStateAfterStop ()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
     m_process->UpdateThreadListIfNeeded();
     

 {
     // You don't need to update the thread list here, because only threads
     // that you currently know about have any thread plans.
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
 
     collection::iterator pos, end = m_threads.end();
     for (pos = m_threads.begin(); pos != end; ++pos)

     // But we only do this for threads that are running, user suspended
     // threads stay where they are.
 
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     m_process->UpdateThreadListIfNeeded();
 
     collection::iterator pos, end = m_threads.end();

 void
 ThreadList::DidResume ()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     collection::iterator pos, end = m_threads.end();
     for (pos = m_threads.begin(); pos != end; ++pos)
     {

 void
 ThreadList::DidStop ()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     collection::iterator pos, end = m_threads.end();
     for (pos = m_threads.begin(); pos != end; ++pos)
     {

 ThreadSP
 ThreadList::GetSelectedThread ()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     ThreadSP thread_sp = FindThreadByID(m_selected_tid);
     if (!thread_sp.get())
     {

 bool
 ThreadList::SetSelectedThreadByID (lldb::tid_t tid, bool notify)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     ThreadSP selected_thread_sp(FindThreadByID(tid));
     if  (selected_thread_sp)
     {

 bool
 ThreadList::SetSelectedThreadByIndexID (uint32_t index_id, bool notify)
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     ThreadSP selected_thread_sp (FindThreadByIndexID(index_id));
     if  (selected_thread_sp.get())
     {

     {
         // Lock both mutexes to make sure neither side changes anyone on us
         // while the assignment occurs
-        Mutex::Locker locker(GetMutex());
+        std::lock_guard<std::recursive_mutex> guard(GetMutex());
+
         m_process = rhs.m_process;
         m_stop_id = rhs.m_stop_id;
         m_threads.swap(rhs.m_threads);

 void
 ThreadList::Flush ()
 {
-    Mutex::Locker locker(GetMutex());
+    std::lock_guard<std::recursive_mutex> guard(GetMutex());
     collection::iterator pos, end = m_threads.end();
     for (pos = m_threads.begin(); pos != end; ++pos)
         (*pos)->Flush ();
 }
 
-Mutex &
-ThreadList::GetMutex ()
+std::recursive_mutex &
+ThreadList::GetMutex()
 {
     return m_process->m_thread_mutex;
 }