remove use of Mutex in favour of std::{,recursive_}mutex

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

llvm-svn: 269877

19 files changed, 202 insertions, 203 deletions

diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
index 69b527a513f..debad980a31 100644
--- a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
+++ b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp
@@ -229,7 +229,7 @@ ProcessFreeBSD::WillResume()
 void
 ProcessFreeBSD::SendMessage(const ProcessMessage &message)
 {
-    Mutex::Locker lock(m_message_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 
     switch (message.GetKind())
     {
@@ -274,7 +274,7 @@ ProcessFreeBSD::ProcessFreeBSD(lldb::TargetSP target_sp, lldb::ListenerSP listen
       m_byte_order(endian::InlHostByteOrder()),
       m_monitor(NULL),
       m_module(NULL),
-      m_message_mutex (Mutex::eMutexTypeRecursive),
+      m_message_mutex(),
       m_exit_now(false),
       m_seen_initial_stop(),
       m_resume_signo(0)
@@ -603,7 +603,7 @@ ProcessFreeBSD::RefreshStateAfterStop()
     if (log && log->GetMask().Test(POSIX_LOG_VERBOSE))
         log->Printf ("ProcessFreeBSD::%s(), message_queue size = %d", __FUNCTION__, (int)m_message_queue.size());
 
-    Mutex::Locker lock(m_message_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_message_mutex);
 
     // This method used to only handle one message.  Changing it to loop allows
     // it to handle the case where we hit a breakpoint while handling a different
diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h
index a1d255c34cb..888e2a90ad7 100644
--- a/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h
+++ b/lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.h
@@ -13,8 +13,9 @@
 // C Includes
 
 // C++ Includes
-#include <set>
+#include <mutex>
 #include <queue>
+#include <set>
 
 // Other libraries and framework includes
 #include "lldb/Target/Process.h"
@@ -212,7 +213,7 @@ protected:
     lldb_private::Module *m_module;
 
     /// Message queue notifying this instance of inferior process state changes.
-    lldb_private::Mutex m_message_mutex;
+    std::recursive_mutex m_message_mutex;
     std::queue<ProcessMessage> m_message_queue;
 
     /// Drive any exit events to completion.
diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
index 2318a657578..16707a5c8b9 100644
--- a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
+++ b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.cpp
@@ -1348,7 +1348,7 @@ ProcessMonitor::ServeOperation(OperationArgs *args)
 void
 ProcessMonitor::DoOperation(Operation *op)
 {
-    Mutex::Locker lock(m_operation_mutex);
+    std::lock_guard<std::mutex> guard(m_operation_mutex);
 
     m_operation = op;
 
diff --git a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h
index 27cdd3e7000..93f6be11136 100644
--- a/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h
+++ b/lldb/source/Plugins/Process/FreeBSD/ProcessMonitor.h
@@ -15,11 +15,12 @@
 #include <signal.h>
 
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 #include "lldb/lldb-types.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/HostThread.h"
-#include "lldb/Host/Mutex.h"
 
 namespace lldb_private
 {
@@ -223,7 +224,7 @@ private:
 
     // current operation which must be executed on the privileged thread
     Operation *m_operation;
-    lldb_private::Mutex m_operation_mutex;
+    std::mutex m_operation_mutex;
 
     // semaphores notified when Operation is ready to be processed and when
     // the operation is complete.
diff --git a/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp b/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
index 2cbd94a2f96..813c810bff9 100644
--- a/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
+++ b/lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp
@@ -284,8 +284,8 @@ bool
 CommunicationKDP::CheckForPacket (const uint8_t *src, size_t src_len, DataExtractor &packet)
 {
     // Put the packet data into the buffer in a thread safe fashion
-    Mutex::Locker locker(m_bytes_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
+
     Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PACKETS));
 
     if (src && src_len > 0)
diff --git a/lldb/source/Plugins/Process/Utility/HistoryThread.cpp b/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
index 206b8290c5f..20a10106c2a 100644
--- a/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
+++ b/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
@@ -22,28 +22,24 @@ using namespace lldb_private;
 
 //  Constructor
 
-HistoryThread::HistoryThread (lldb_private::Process &process, 
-                              lldb::tid_t tid,
-                              std::vector<lldb::addr_t> pcs, 
-                              uint32_t stop_id, 
-                              bool stop_id_is_valid) : 
-        Thread (process, tid, true),
-        m_framelist_mutex(),
-        m_framelist(),
-        m_pcs (pcs),
-        m_stop_id (stop_id),
-        m_stop_id_is_valid (stop_id_is_valid),
-        m_extended_unwind_token (LLDB_INVALID_ADDRESS),
-        m_queue_name (),
-        m_thread_name (),
-        m_originating_unique_thread_id (tid),
-        m_queue_id (LLDB_INVALID_QUEUE_ID)
+HistoryThread::HistoryThread(lldb_private::Process &process, lldb::tid_t tid, std::vector<lldb::addr_t> pcs,
+                             uint32_t stop_id, bool stop_id_is_valid)
+    : Thread(process, tid, true),
+      m_framelist_mutex(),
+      m_framelist(),
+      m_pcs(pcs),
+      m_stop_id(stop_id),
+      m_stop_id_is_valid(stop_id_is_valid),
+      m_extended_unwind_token(LLDB_INVALID_ADDRESS),
+      m_queue_name(),
+      m_thread_name(),
+      m_originating_unique_thread_id(tid),
+      m_queue_id(LLDB_INVALID_QUEUE_ID)
 {
-    m_unwinder_ap.reset (new HistoryUnwind (*this, pcs, stop_id_is_valid));
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+    m_unwinder_ap.reset(new HistoryUnwind(*this, pcs, stop_id_is_valid));
+    Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
     if (log)
-        log->Printf ("%p HistoryThread::HistoryThread",
-                     static_cast<void*>(this));
+        log->Printf("%p HistoryThread::HistoryThread", static_cast<void *>(this));
 }
 
 //  Destructor
@@ -78,7 +74,9 @@ HistoryThread::CreateRegisterContextForFrame (StackFrame *frame)
 lldb::StackFrameListSP
 HistoryThread::GetStackFrameList ()
 {
-    Mutex::Locker (m_framelist_mutex);   // FIXME do not throw away the lock after we acquire it..
+    // FIXME do not throw away the lock after we acquire it..
+    std::unique_lock<std::mutex> lock(m_framelist_mutex);
+    lock.release();
     if (m_framelist.get() == NULL)
     {
         m_framelist.reset (new StackFrameList (*this, StackFrameListSP(), true));
diff --git a/lldb/source/Plugins/Process/Utility/HistoryThread.h b/lldb/source/Plugins/Process/Utility/HistoryThread.h
index e87f6496134..43ac13c2d8b 100644
--- a/lldb/source/Plugins/Process/Utility/HistoryThread.h
+++ b/lldb/source/Plugins/Process/Utility/HistoryThread.h
@@ -12,10 +12,11 @@
 
 // C Includes
 // C++ Includes
+#include <mutex>
+
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/UserID.h"
@@ -125,7 +126,7 @@ protected:
     virtual lldb::StackFrameListSP
     GetStackFrameList ();
 
-    mutable Mutex               m_framelist_mutex;
+    mutable std::mutex m_framelist_mutex;
     lldb::StackFrameListSP      m_framelist;
     std::vector<lldb::addr_t>   m_pcs;
     uint32_t                    m_stop_id;
diff --git a/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp b/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp
index 14afcbee0b4..62e4bc0a347 100644
--- a/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp
+++ b/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp
@@ -40,7 +40,7 @@ HistoryUnwind::~HistoryUnwind ()
 void
 HistoryUnwind::DoClear ()
 {
-    Mutex::Locker locker(m_unwind_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
     m_pcs.clear();
     m_stop_id_is_valid = false;
 }
@@ -64,7 +64,9 @@ HistoryUnwind::DoCreateRegisterContextForFrame (StackFrame *frame)
 bool
 HistoryUnwind::DoGetFrameInfoAtIndex (uint32_t frame_idx, lldb::addr_t& cfa, lldb::addr_t& pc)
 {
-    Mutex::Locker (m_unwind_mutex);   // FIXME do not throw away the lock after we acquire it..
+    // FIXME do not throw away the lock after we acquire it..
+    std::unique_lock<std::recursive_mutex> guard(m_unwind_mutex);
+    guard.release();
     if (frame_idx < m_pcs.size())
     {
         cfa = frame_idx;
diff --git a/lldb/source/Plugins/Process/Utility/HistoryUnwind.h b/lldb/source/Plugins/Process/Utility/HistoryUnwind.h
index 2cb78bc1dc6..890604fcb68 100644
--- a/lldb/source/Plugins/Process/Utility/HistoryUnwind.h
+++ b/lldb/source/Plugins/Process/Utility/HistoryUnwind.h
@@ -17,7 +17,6 @@
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Unwind.h"
 
 namespace lldb_private {
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
index 891cc22fec7..4689e0bc299 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
@@ -793,8 +793,8 @@ GDBRemoteCommunication::PacketType
 GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, StringExtractorGDBRemote &packet)
 {
     // Put the packet data into the buffer in a thread safe fashion
-    Mutex::Locker locker(m_bytes_mutex);
-    
+    std::lock_guard<std::recursive_mutex> guard(m_bytes_mutex);
+
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 
     if (src && src_len > 0)
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
index 1a109307b88..5f2678d24cf 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
@@ -55,79 +55,79 @@ using namespace lldb_private::process_gdb_remote;
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationClient constructor
 //----------------------------------------------------------------------
-GDBRemoteCommunicationClient::GDBRemoteCommunicationClient() :
-    GDBRemoteCommunication("gdb-remote.client", "gdb-remote.client.rx_packet"),
-    m_supports_not_sending_acks (eLazyBoolCalculate),
-    m_supports_thread_suffix (eLazyBoolCalculate),
-    m_supports_threads_in_stop_reply (eLazyBoolCalculate),
-    m_supports_vCont_all (eLazyBoolCalculate),
-    m_supports_vCont_any (eLazyBoolCalculate),
-    m_supports_vCont_c (eLazyBoolCalculate),
-    m_supports_vCont_C (eLazyBoolCalculate),
-    m_supports_vCont_s (eLazyBoolCalculate),
-    m_supports_vCont_S (eLazyBoolCalculate),
-    m_qHostInfo_is_valid (eLazyBoolCalculate),
-    m_curr_pid_is_valid (eLazyBoolCalculate),
-    m_qProcessInfo_is_valid (eLazyBoolCalculate),
-    m_qGDBServerVersion_is_valid (eLazyBoolCalculate),
-    m_supports_alloc_dealloc_memory (eLazyBoolCalculate),
-    m_supports_memory_region_info  (eLazyBoolCalculate),
-    m_supports_watchpoint_support_info  (eLazyBoolCalculate),
-    m_supports_detach_stay_stopped (eLazyBoolCalculate),
-    m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
-    m_attach_or_wait_reply(eLazyBoolCalculate),
-    m_prepare_for_reg_writing_reply (eLazyBoolCalculate),
-    m_supports_p (eLazyBoolCalculate),
-    m_supports_x (eLazyBoolCalculate),
-    m_avoid_g_packets (eLazyBoolCalculate),
-    m_supports_QSaveRegisterState (eLazyBoolCalculate),
-    m_supports_qXfer_auxv_read (eLazyBoolCalculate),
-    m_supports_qXfer_libraries_read (eLazyBoolCalculate),
-    m_supports_qXfer_libraries_svr4_read (eLazyBoolCalculate),
-    m_supports_qXfer_features_read (eLazyBoolCalculate),
-    m_supports_augmented_libraries_svr4_read (eLazyBoolCalculate),
-    m_supports_jThreadExtendedInfo (eLazyBoolCalculate),
-    m_supports_jLoadedDynamicLibrariesInfos (eLazyBoolCalculate),
-    m_supports_qProcessInfoPID (true),
-    m_supports_qfProcessInfo (true),
-    m_supports_qUserName (true),
-    m_supports_qGroupName (true),
-    m_supports_qThreadStopInfo (true),
-    m_supports_z0 (true),
-    m_supports_z1 (true),
-    m_supports_z2 (true),
-    m_supports_z3 (true),
-    m_supports_z4 (true),
-    m_supports_QEnvironment (true),
-    m_supports_QEnvironmentHexEncoded (true),
-    m_supports_qSymbol (true),
-    m_qSymbol_requests_done (false),
-    m_supports_qModuleInfo (true),
-    m_supports_jThreadsInfo (true),
-    m_curr_pid (LLDB_INVALID_PROCESS_ID),
-    m_curr_tid (LLDB_INVALID_THREAD_ID),
-    m_curr_tid_run (LLDB_INVALID_THREAD_ID),
-    m_num_supported_hardware_watchpoints (0),
-    m_async_mutex (Mutex::eMutexTypeRecursive),
-    m_async_packet_predicate (false),
-    m_async_packet (),
-    m_async_result (PacketResult::Success),
-    m_async_response (),
-    m_async_signal (-1),
-    m_interrupt_sent (false),
-    m_thread_id_to_used_usec_map (),
-    m_host_arch(),
-    m_process_arch(),
-    m_os_version_major (UINT32_MAX),
-    m_os_version_minor (UINT32_MAX),
-    m_os_version_update (UINT32_MAX),
-    m_os_build (),
-    m_os_kernel (),
-    m_hostname (),
-    m_gdb_server_name(),
-    m_gdb_server_version(UINT32_MAX),
-    m_default_packet_timeout (0),
-    m_max_packet_size (0)
+GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
+    : GDBRemoteCommunication("gdb-remote.client", "gdb-remote.client.rx_packet"),
+      m_supports_not_sending_acks(eLazyBoolCalculate),
+      m_supports_thread_suffix(eLazyBoolCalculate),
+      m_supports_threads_in_stop_reply(eLazyBoolCalculate),
+      m_supports_vCont_all(eLazyBoolCalculate),
+      m_supports_vCont_any(eLazyBoolCalculate),
+      m_supports_vCont_c(eLazyBoolCalculate),
+      m_supports_vCont_C(eLazyBoolCalculate),
+      m_supports_vCont_s(eLazyBoolCalculate),
+      m_supports_vCont_S(eLazyBoolCalculate),
+      m_qHostInfo_is_valid(eLazyBoolCalculate),
+      m_curr_pid_is_valid(eLazyBoolCalculate),
+      m_qProcessInfo_is_valid(eLazyBoolCalculate),
+      m_qGDBServerVersion_is_valid(eLazyBoolCalculate),
+      m_supports_alloc_dealloc_memory(eLazyBoolCalculate),
+      m_supports_memory_region_info(eLazyBoolCalculate),
+      m_supports_watchpoint_support_info(eLazyBoolCalculate),
+      m_supports_detach_stay_stopped(eLazyBoolCalculate),
+      m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
+      m_attach_or_wait_reply(eLazyBoolCalculate),
+      m_prepare_for_reg_writing_reply(eLazyBoolCalculate),
+      m_supports_p(eLazyBoolCalculate),
+      m_supports_x(eLazyBoolCalculate),
+      m_avoid_g_packets(eLazyBoolCalculate),
+      m_supports_QSaveRegisterState(eLazyBoolCalculate),
+      m_supports_qXfer_auxv_read(eLazyBoolCalculate),
+      m_supports_qXfer_libraries_read(eLazyBoolCalculate),
+      m_supports_qXfer_libraries_svr4_read(eLazyBoolCalculate),
+      m_supports_qXfer_features_read(eLazyBoolCalculate),
+      m_supports_augmented_libraries_svr4_read(eLazyBoolCalculate),
+      m_supports_jThreadExtendedInfo(eLazyBoolCalculate),
+      m_supports_jLoadedDynamicLibrariesInfos(eLazyBoolCalculate),
+      m_supports_qProcessInfoPID(true),
+      m_supports_qfProcessInfo(true),
+      m_supports_qUserName(true),
+      m_supports_qGroupName(true),
+      m_supports_qThreadStopInfo(true),
+      m_supports_z0(true),
+      m_supports_z1(true),
+      m_supports_z2(true),
+      m_supports_z3(true),
+      m_supports_z4(true),
+      m_supports_QEnvironment(true),
+      m_supports_QEnvironmentHexEncoded(true),
+      m_supports_qSymbol(true),
+      m_qSymbol_requests_done(false),
+      m_supports_qModuleInfo(true),
+      m_supports_jThreadsInfo(true),
+      m_curr_pid(LLDB_INVALID_PROCESS_ID),
+      m_curr_tid(LLDB_INVALID_THREAD_ID),
+      m_curr_tid_run(LLDB_INVALID_THREAD_ID),
+      m_num_supported_hardware_watchpoints(0),
+      m_async_mutex(),
+      m_async_packet_predicate(false),
+      m_async_packet(),
+      m_async_result(PacketResult::Success),
+      m_async_response(),
+      m_async_signal(-1),
+      m_interrupt_sent(false),
+      m_thread_id_to_used_usec_map(),
+      m_host_arch(),
+      m_process_arch(),
+      m_os_version_major(UINT32_MAX),
+      m_os_version_minor(UINT32_MAX),
+      m_os_version_update(UINT32_MAX),
+      m_os_build(),
+      m_os_kernel(),
+      m_hostname(),
+      m_gdb_server_name(),
+      m_gdb_server_version(UINT32_MAX),
+      m_default_packet_timeout(0),
+      m_max_packet_size(0)
 {
 }
 
@@ -820,7 +820,7 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
         {
             if (IsRunning())
             {
-                Mutex::Locker async_locker (m_async_mutex);
+                std::lock_guard<std::recursive_mutex> guard(m_async_mutex);
                 m_async_packet.assign(payload, payload_length);
                 m_async_response.CopyResponseValidator(response);
                 m_async_packet_predicate.SetValue (true, eBroadcastNever);
@@ -1372,7 +1372,7 @@ GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
 bool
 GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
 {
-    Mutex::Locker async_locker (m_async_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_async_mutex);
     m_async_signal = signo;
     bool timed_out = false;
     Mutex::Locker locker;
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
index 33114d2611f..096c4cf8101 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
@@ -13,6 +13,7 @@
 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -631,7 +632,7 @@ protected:
 
     // If we need to send a packet while the target is running, the m_async_XXX
     // member variables take care of making this happen.
-    Mutex m_async_mutex;
+    std::recursive_mutex m_async_mutex;
     Predicate<bool> m_async_packet_predicate;
     std::string m_async_packet;
     PacketResult m_async_result;
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h
index f55b2eb3f4d..d2fd70042cc 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h
@@ -17,7 +17,6 @@
 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private-forward.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 
 #include "GDBRemoteCommunicationServer.h"
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
index 0274aa89acc..66e300a519f 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
@@ -76,23 +76,22 @@ namespace
 //----------------------------------------------------------------------
 // GDBRemoteCommunicationServerLLGS constructor
 //----------------------------------------------------------------------
-GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
-        const lldb::PlatformSP& platform_sp,
-        MainLoop &mainloop) :
-    GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
-    m_platform_sp (platform_sp),
-    m_mainloop (mainloop),
-    m_current_tid (LLDB_INVALID_THREAD_ID),
-    m_continue_tid (LLDB_INVALID_THREAD_ID),
-    m_debugged_process_mutex (Mutex::eMutexTypeRecursive),
-    m_debugged_process_sp (),
-    m_stdio_communication ("process.stdio"),
-    m_inferior_prev_state (StateType::eStateInvalid),
-    m_active_auxv_buffer_sp (),
-    m_saved_registers_mutex (),
-    m_saved_registers_map (),
-    m_next_saved_registers_id (1),
-    m_handshake_completed (false)
+GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(const lldb::PlatformSP &platform_sp,
+                                                                   MainLoop &mainloop)
+    : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
+      m_platform_sp(platform_sp),
+      m_mainloop(mainloop),
+      m_current_tid(LLDB_INVALID_THREAD_ID),
+      m_continue_tid(LLDB_INVALID_THREAD_ID),
+      m_debugged_process_mutex(),
+      m_debugged_process_sp(),
+      m_stdio_communication("process.stdio"),
+      m_inferior_prev_state(StateType::eStateInvalid),
+      m_active_auxv_buffer_sp(),
+      m_saved_registers_mutex(),
+      m_saved_registers_map(),
+      m_next_saved_registers_id(1),
+      m_handshake_completed(false)
 {
     assert(platform_sp);
     RegisterPacketHandlers();
@@ -210,7 +209,7 @@ GDBRemoteCommunicationServerLLGS::LaunchProcess ()
 
     Error error;
     {
-        Mutex::Locker locker (m_debugged_process_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
         assert (!m_debugged_process_sp && "lldb-gdbserver creating debugged process but one already exists");
         error = NativeProcessProtocol::Launch(
             m_process_launch_info,
@@ -2593,7 +2592,7 @@ GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState (StringExtractorGDBR
 
     // Save the register data buffer under the save id.
     {
-        Mutex::Locker locker (m_saved_registers_mutex);
+        std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
         m_saved_registers_map[save_id] = register_data_sp;
     }
 
@@ -2643,7 +2642,7 @@ GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState (StringExtractorG
     // Retrieve register state buffer, then remove from the list.
     DataBufferSP register_data_sp;
     {
-        Mutex::Locker locker (m_saved_registers_mutex);
+        std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
 
         // Find the register set buffer for the given save id.
         auto it = m_saved_registers_map.find (save_id);
@@ -2947,7 +2946,7 @@ GDBRemoteCommunicationServerLLGS::GetCurrentThreadID () const
 uint32_t
 GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID ()
 {
-    Mutex::Locker locker (m_saved_registers_mutex);
+    std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
     return m_next_saved_registers_id++;
 }
 
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h
index f16057781dd..066e4985062 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h
@@ -12,12 +12,12 @@
 
 // C Includes
 // C++ Includes
+#include <mutex>
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/lldb-private-forward.h"
 #include "lldb/Core/Communication.h"
-#include "lldb/Host/Mutex.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/MainLoop.h"
 
@@ -119,7 +119,7 @@ protected:
     MainLoop::ReadHandleUP m_network_handle_up;
     lldb::tid_t m_current_tid;
     lldb::tid_t m_continue_tid;
-    Mutex m_debugged_process_mutex;
+    std::recursive_mutex m_debugged_process_mutex;
     NativeProcessProtocolSP m_debugged_process_sp;
 
     Communication m_stdio_communication;
@@ -127,7 +127,7 @@ protected:
 
     lldb::StateType m_inferior_prev_state;
     lldb::DataBufferSP m_active_auxv_buffer_sp;
-    Mutex m_saved_registers_mutex;
+    std::mutex m_saved_registers_mutex;
     std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
     uint32_t m_next_saved_registers_id;
     bool m_handshake_completed : 1;
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
index b2969746ce1..e16e9e4a3b8 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp
@@ -48,14 +48,14 @@ using namespace lldb_private::process_gdb_remote;
 // GDBRemoteCommunicationServerPlatform constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const Socket::SocketProtocol socket_protocol,
-                                                                           const char* socket_scheme) :
-    GDBRemoteCommunicationServerCommon ("gdb-remote.server", "gdb-remote.server.rx_packet"),
-    m_socket_protocol(socket_protocol),
-    m_socket_scheme(socket_scheme),
-    m_spawned_pids_mutex (Mutex::eMutexTypeRecursive),
-    m_platform_sp (Platform::GetHostPlatform ()),
-    m_port_map (),
-    m_port_offset(0)
+                                                                           const char *socket_scheme)
+    : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
+      m_socket_protocol(socket_protocol),
+      m_socket_scheme(socket_scheme),
+      m_spawned_pids_mutex(),
+      m_platform_sp(Platform::GetHostPlatform()),
+      m_port_map(),
+      m_port_offset(0)
 {
     m_pending_gdb_server.pid = LLDB_INVALID_PROCESS_ID;
     m_pending_gdb_server.port = 0;
@@ -78,11 +78,7 @@ GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(const
                                   &GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo);
 
     RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_interrupt,
-                          [this](StringExtractorGDBRemote packet,
-                                 Error &error,
-                                 bool &interrupt,
-                                 bool &quit)
-                          {
+                          [this](StringExtractorGDBRemote packet, Error &error, bool &interrupt, bool &quit) {
                               error.SetErrorString("interrupt received");
                               interrupt = true;
                               return PacketResult::Success;
@@ -156,7 +152,7 @@ GDBRemoteCommunicationServerPlatform::LaunchGDBServer(const lldb_private::Args&
     pid = debugserver_launch_info.GetProcessID();
     if (pid != LLDB_INVALID_PROCESS_ID)
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         m_spawned_pids.insert(pid);
         if (port > 0)
             AssociatePortWithProcess(port, pid);
@@ -261,7 +257,7 @@ GDBRemoteCommunicationServerPlatform::Handle_qKillSpawnedProcess (StringExtracto
     // verify that we know anything about this pid.
     // Scope for locker
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
         {
             // not a pid we know about
@@ -281,7 +277,7 @@ GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid)
 {
     // make sure we know about this process
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             return false;
     }
@@ -293,7 +289,7 @@ GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid)
     for (size_t i=0; i<10; ++i)
     {
         {
-            Mutex::Locker locker (m_spawned_pids_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
             if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             {
                 // it is now killed
@@ -305,7 +301,7 @@ GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid)
 
     // check one more time after the final usleep
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             return true;
     }
@@ -317,7 +313,7 @@ GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid)
     for (size_t i=0; i<10; ++i)
     {
         {
-            Mutex::Locker locker (m_spawned_pids_mutex);
+            std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
             if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             {
                 // it is now killed
@@ -330,7 +326,7 @@ GDBRemoteCommunicationServerPlatform::KillSpawnedProcess (lldb::pid_t pid)
     // check one more time after the final usleep
     // Scope for locker
     {
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         if (m_spawned_pids.find(pid) == m_spawned_pids.end())
             return true;
     }
@@ -444,7 +440,7 @@ GDBRemoteCommunicationServerPlatform::Handle_jSignalsInfo(StringExtractorGDBRemo
 bool
 GDBRemoteCommunicationServerPlatform::DebugserverProcessReaped (lldb::pid_t pid)
 {
-    Mutex::Locker locker (m_spawned_pids_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
     FreePortForProcess(pid);
     m_spawned_pids.erase(pid);
     return true;
@@ -479,7 +475,7 @@ GDBRemoteCommunicationServerPlatform::LaunchProcess ()
     if (pid != LLDB_INVALID_PROCESS_ID)
     {
         // add to spawned pids
-        Mutex::Locker locker (m_spawned_pids_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_spawned_pids_mutex);
         m_spawned_pids.insert(pid);
     }
 
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h
index 1e948d4d5c6..646d267dcb9 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.h
@@ -13,6 +13,7 @@
 // C Includes
 // C++ Includes
 #include <map>
+#include <mutex>
 #include <set>
 
 // Other libraries and framework includes
@@ -82,7 +83,7 @@ public:
 protected:
     const Socket::SocketProtocol m_socket_protocol;
     const std::string m_socket_scheme;
-    Mutex m_spawned_pids_mutex;
+    std::recursive_mutex m_spawned_pids_mutex;
     std::set<lldb::pid_t> m_spawned_pids;
     lldb::PlatformSP m_platform_sp;
 
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index d9d551421f4..47a861042cd 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -267,39 +267,39 @@ ProcessGDBRemote::CanDebug (lldb::TargetSP target_sp, bool plugin_specified_by_n
 //----------------------------------------------------------------------
 // ProcessGDBRemote constructor
 //----------------------------------------------------------------------
-ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener_sp) :
-    Process (target_sp, listener_sp),
-    m_flags (0),
-    m_gdb_comm (),
-    m_debugserver_pid (LLDB_INVALID_PROCESS_ID),
-    m_last_stop_packet_mutex (Mutex::eMutexTypeRecursive),
-    m_register_info (),
-    m_async_broadcaster (NULL, "lldb.process.gdb-remote.async-broadcaster"),
-    m_async_listener_sp(Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
-    m_async_thread_state_mutex(Mutex::eMutexTypeRecursive),
-    m_thread_ids (),
-    m_thread_pcs (),
-    m_jstopinfo_sp (),
-    m_jthreadsinfo_sp (),
-    m_continue_c_tids (),
-    m_continue_C_tids (),
-    m_continue_s_tids (),
-    m_continue_S_tids (),
-    m_max_memory_size (0),
-    m_remote_stub_max_memory_size (0),
-    m_addr_to_mmap_size (),
-    m_thread_create_bp_sp (),
-    m_waiting_for_attach (false),
-    m_destroy_tried_resuming (false),
-    m_command_sp (),
-    m_breakpoint_pc_offset (0),
-    m_initial_tid (LLDB_INVALID_THREAD_ID)
+ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener_sp)
+    : Process(target_sp, listener_sp),
+      m_flags(0),
+      m_gdb_comm(),
+      m_debugserver_pid(LLDB_INVALID_PROCESS_ID),
+      m_last_stop_packet_mutex(),
+      m_register_info(),
+      m_async_broadcaster(NULL, "lldb.process.gdb-remote.async-broadcaster"),
+      m_async_listener_sp(Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
+      m_async_thread_state_mutex(),
+      m_thread_ids(),
+      m_thread_pcs(),
+      m_jstopinfo_sp(),
+      m_jthreadsinfo_sp(),
+      m_continue_c_tids(),
+      m_continue_C_tids(),
+      m_continue_s_tids(),
+      m_continue_S_tids(),
+      m_max_memory_size(0),
+      m_remote_stub_max_memory_size(0),
+      m_addr_to_mmap_size(),
+      m_thread_create_bp_sp(),
+      m_waiting_for_attach(false),
+      m_destroy_tried_resuming(false),
+      m_command_sp(),
+      m_breakpoint_pc_offset(0),
+      m_initial_tid(LLDB_INVALID_THREAD_ID)
 {
-    m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadShouldExit,   "async thread should exit");
-    m_async_broadcaster.SetEventName (eBroadcastBitAsyncContinue,           "async thread continue");
-    m_async_broadcaster.SetEventName (eBroadcastBitAsyncThreadDidExit,      "async thread did exit");
+    m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit, "async thread should exit");
+    m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue, "async thread continue");
+    m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadDidExit, "async thread did exit");
 
-    Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_ASYNC));
+    Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_ASYNC));
 
     const uint32_t async_event_mask = eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit;
 
@@ -309,8 +309,8 @@ ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener
             log->Printf("ProcessGDBRemote::%s failed to listen for m_async_broadcaster events", __FUNCTION__);
     }
 
-    const uint32_t gdb_event_mask = Communication::eBroadcastBitReadThreadDidExit |
-                                    GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify;
+    const uint32_t gdb_event_mask =
+        Communication::eBroadcastBitReadThreadDidExit | GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify;
     if (m_async_listener_sp->StartListeningForEvents(&m_gdb_comm, gdb_event_mask) != gdb_event_mask)
     {
         if (log)
@@ -1729,8 +1729,8 @@ ProcessGDBRemote::UpdateThreadIDList ()
 
         // Lock the thread stack while we access it
         //Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
-        Mutex::Locker stop_stack_lock;
-        if (stop_stack_lock.TryLock(m_last_stop_packet_mutex))
+        std::unique_lock<std::recursive_mutex> stop_stack_lock(m_last_stop_packet_mutex, std::defer_lock);
+        if (stop_stack_lock.try_lock())
         {
             // Get the number of stop packets on the stack
             int nItems = m_stop_packet_stack.size();
@@ -2673,7 +2673,7 @@ ProcessGDBRemote::RefreshStateAfterStop ()
     // Scope for the lock
     {
         // Lock the thread stack while we access it
-        Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
         // Get the number of stop packets on the stack
         int nItems = m_stop_packet_stack.size();
         // Iterate over them
@@ -2975,7 +2975,7 @@ ProcessGDBRemote::SetLastStopPacket (const StringExtractorGDBRemote &response)
     // Scope the lock
     {
         // Lock the thread stack while we access it
-        Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
+        std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
 
         // We are are not using non-stop mode, there can only be one last stop
         // reply packet, so clear the list.
@@ -3761,7 +3761,7 @@ ProcessGDBRemote::StartAsyncThread ()
     if (log)
         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
 
-    Mutex::Locker start_locker(m_async_thread_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
     if (!m_async_thread.IsJoinable())
     {
         // Create a thread that watches our internal state and controls which
@@ -3783,7 +3783,7 @@ ProcessGDBRemote::StopAsyncThread ()
     if (log)
         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
 
-    Mutex::Locker start_locker(m_async_thread_state_mutex);
+    std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
     if (m_async_thread.IsJoinable())
     {
         m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
index 815435c0f74..6d373965fc4 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
@@ -14,6 +14,7 @@
 // C++ Includes
 #include <atomic>
 #include <map>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -279,12 +280,12 @@ protected:
     GDBRemoteCommunicationClient m_gdb_comm;
     std::atomic<lldb::pid_t> m_debugserver_pid;
     std::vector<StringExtractorGDBRemote> m_stop_packet_stack;  // The stop packet stack replaces the last stop packet variable
-    Mutex m_last_stop_packet_mutex;
+    std::recursive_mutex m_last_stop_packet_mutex;
     GDBRemoteDynamicRegisterInfo m_register_info;
     Broadcaster m_async_broadcaster;
     lldb::ListenerSP m_async_listener_sp;
     HostThread m_async_thread;
-    Mutex m_async_thread_state_mutex;
+    std::recursive_mutex m_async_thread_state_mutex;
     typedef std::vector<lldb::tid_t> tid_collection;
     typedef std::vector< std::pair<lldb::tid_t,int> > tid_sig_collection;
     typedef std::map<lldb::addr_t, lldb::addr_t> MMapMap;