Fix up the HostThread interface

[zturner]

Summary

• Removes GetState / SetState
• Adds a method IsJoinable()

There is no need for a distinction between IsHandleValid and IsThreadRunning, because even if a thread has run to completion, you are still required to Join on it. So a better function simply checks whether a thread is joinable. This is equivalent to checking if the handle is valid, because the Join() operation can reset the handle to an invalid handle after it has been performed.

[zturner]

Closed by commit rL218325 (authored by @zturner).

lldb/trunk/include/lldb/Core/Debugger.h

public:
     EnableForwardEvents (const lldb::ListenerSP &listener_sp);
 
     void
     CancelForwardEvents (const lldb::ListenerSP &listener_sp);
     
     bool
     IsHandlingEvents () const
     {
-        return m_event_handler_thread.GetState() == eThreadStateRunning;
+        return m_event_handler_thread.IsJoinable();
     }
 
 protected:
 
     friend class CommandInterpreter;
 
     bool
     StartEventHandlerThread();

lldb/trunk/include/lldb/Host/HostNativeThreadBase.h

 //===-- HostNativeThreadBase.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_Host_HostNativeThreadBase_h_
 #define lldb_Host_HostNativeThreadBase_h_
 
 #include "lldb/Core/Error.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-types.h"
-#include "lldb/lldb-private-enumerations.h"
 
 namespace lldb_private
 {
 
 #if defined(_WIN32)
 #define THREAD_ROUTINE __stdcall
 #else
 #define THREAD_ROUTINE
 #endif
 
 class HostNativeThreadBase
 {
     friend class ThreadLauncher;
     DISALLOW_COPY_AND_ASSIGN(HostNativeThreadBase);
 
   public:
     HostNativeThreadBase();
     explicit HostNativeThreadBase(lldb::thread_t thread);
     virtual ~HostNativeThreadBase() {}
 
     virtual Error Join(lldb::thread_result_t *result) = 0;
     virtual Error Cancel() = 0;
+    virtual bool IsJoinable() const;
     virtual void Reset();
     lldb::thread_t Release();
 
-    void SetState(ThreadState state);
-    ThreadState GetState() const;
     lldb::thread_t GetSystemHandle() const;
     lldb::thread_result_t GetResult() const;
 
   protected:
     static lldb::thread_result_t THREAD_ROUTINE ThreadCreateTrampoline(lldb::thread_arg_t arg);
 
     lldb::thread_t m_thread;
-    ThreadState m_state;
     lldb::thread_result_t m_result;
 };
 }
 
 #endif

lldb/trunk/include/lldb/Host/HostThread.h

public:
     HostThread();
     HostThread(lldb::thread_t thread);
 
     Error Join(lldb::thread_result_t *result);
     Error Cancel();
     void Reset();
     lldb::thread_t Release();
 
-    void SetState(ThreadState state);
-    ThreadState GetState() const;
+    bool IsJoinable() const;
     HostNativeThreadBase &GetNativeThread();
     const HostNativeThreadBase &GetNativeThread() const;
     lldb::thread_result_t GetResult() const;
 
     bool EqualsThread(lldb::thread_t thread) const;
 
   private:
     std::shared_ptr<HostNativeThreadBase> m_native_thread;
 };
 }
 
 #endif

lldb/trunk/include/lldb/Host/posix/HostThreadPosix.h

-//===-- HostThreadWindows.h -------------------------------------*- C++ -*-===//
+//===-- HostThreadPosix.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

lldb/trunk/include/lldb/Target/Process.h

protected:
     HijackPrivateProcessEvents (Listener *listener);
     
     void 
     RestorePrivateProcessEvents ();
     
     bool
     PrivateStateThreadIsValid () const
     {
-        return m_private_state_thread.GetState() != eThreadStateInvalid;
+        return m_private_state_thread.IsJoinable();
     }
     
     void
     ForceNextEventDelivery()
     {
         m_force_next_event_delivery = true;
     }
 

lldb/trunk/include/lldb/lldb-private-enumerations.h

 typedef enum ExitType {
     eExitTypeInvalid,
     eExitTypeExit,    // The exit status represents the return code from normal program exit (i.e. WIFEXITED() was true)
     eExitTypeSignal,  // The exit status represents the signal number that caused the program to exit (i.e. WIFSIGNALED() was true)
     eExitTypeStop,    // The exit status represents the stop signal that caused the program to exit (i.e. WIFSTOPPED() was true)
 } ExitType;
 
 //----------------------------------------------------------------------
-// State for running threads
-//----------------------------------------------------------------------
-enum ThreadState
-{
-    eThreadStateInvalid,    // The thread does not represent a current or past thread.
-    eThreadStateRunning,    // The thread is currently running.
-    eThreadStateExited,     // The thread's start routine returned normally.
-    eThreadStateCancelling, // The thread has been sent a cancellation request.
-    eThreadStateCancelled   // The thread was cancelled before completing normally.
-};
-
-//----------------------------------------------------------------------
 // Boolean result of running a Type Validator
 //----------------------------------------------------------------------
 enum class TypeValidatorResult : bool {
     Success = true,
     Failure = false
 };
     
 } // namespace lldb_private
 
 
 #endif  // LLDB_lldb_private_enumerations_h_

lldb/trunk/source/Core/Communication.cpp

 
 
 bool
 Communication::StartReadThread (Error *error_ptr)
 {
     if (error_ptr)
         error_ptr->Clear();
 
-    if (m_read_thread.GetState() == eThreadStateRunning)
+    if (m_read_thread.IsJoinable())
         return true;
 
     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
                                  "%p Communication::StartReadThread ()", this);
 
 
     char thread_name[1024];
     snprintf(thread_name, sizeof(thread_name), "<lldb.comm.%s>", m_broadcaster_name.AsCString());
 
     m_read_thread_enabled = true;
     m_read_thread = ThreadLauncher::LaunchThread(thread_name, Communication::ReadThread, this, error_ptr);
-    if (m_read_thread.GetState() != eThreadStateRunning)
+    if (!m_read_thread.IsJoinable())
         m_read_thread_enabled = false;
     return m_read_thread_enabled;
 }
 
 bool
 Communication::StopReadThread (Error *error_ptr)
 {
-    if (m_read_thread.GetState() != eThreadStateRunning)
+    if (!m_read_thread.IsJoinable())
         return true;
 
     lldb_private::LogIfAnyCategoriesSet (LIBLLDB_LOG_COMMUNICATION,
                                  "%p Communication::StopReadThread ()", this);
 
     m_read_thread_enabled = false;
 
     BroadcastEvent (eBroadcastBitReadThreadShouldExit, NULL);
 
     // error = m_read_thread.Cancel();
 
     Error error = m_read_thread.Join(nullptr);
-    m_read_thread.Reset();
     return error.Success();
 }
 
 bool
 Communication::JoinReadThread (Error *error_ptr)
 {
-    if (m_read_thread.GetState() != eThreadStateRunning)
+    if (!m_read_thread.IsJoinable())
         return true;
 
     Error error = m_read_thread.Join(nullptr);
-    m_read_thread.Reset();
     return error.Success();
 }
 
 size_t
 Communication::GetCachedBytes (void *dst, size_t dst_len)
 {
     Mutex::Locker locker(m_bytes_mutex);
     if (m_bytes.size() > 0)

lldb/trunk/source/Core/Debugger.cpp

 {
     ((Debugger *)arg)->DefaultEventHandler();
     return NULL;
 }
 
 bool
 Debugger::StartEventHandlerThread()
 {
-    if (m_event_handler_thread.GetState() != eThreadStateRunning)
+    if (!m_event_handler_thread.IsJoinable())
         m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler", EventHandlerThread, this, NULL);
-    return m_event_handler_thread.GetState() == eThreadStateRunning;
+    return m_event_handler_thread.IsJoinable();
 }
 
 void
 Debugger::StopEventHandlerThread()
 {
-    if (m_event_handler_thread.GetState() == eThreadStateRunning)
+    if (m_event_handler_thread.IsJoinable())
     {
         GetCommandInterpreter().BroadcastEvent(CommandInterpreter::eBroadcastBitQuitCommandReceived);
         m_event_handler_thread.Join(nullptr);
-        m_event_handler_thread.Reset();
     }
 }
 
 
 lldb::thread_result_t
 Debugger::IOHandlerThread (lldb::thread_arg_t arg)
 {
     Debugger *debugger = (Debugger *)arg;
     debugger->ExecuteIOHanders();
     debugger->StopEventHandlerThread();
     return NULL;
 }
 
 bool
 Debugger::StartIOHandlerThread()
 {
-    if (m_io_handler_thread.GetState() != eThreadStateRunning)
+    if (!m_io_handler_thread.IsJoinable())
         m_io_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.io-handler", IOHandlerThread, this, NULL);
-    return m_io_handler_thread.GetState() == eThreadStateRunning;
+    return m_io_handler_thread.IsJoinable();
 }
 
 void
 Debugger::StopIOHandlerThread()
 {
-    if (m_io_handler_thread.GetState() == eThreadStateRunning)
+    if (m_io_handler_thread.IsJoinable())
     {
         if (m_input_file_sp)
             m_input_file_sp->GetFile().Close();
         m_io_handler_thread.Join(nullptr);
-        m_io_handler_thread.Reset();
     }
 }
 
 

lldb/trunk/source/Host/common/HostNativeThreadBase.cpp

 #include "lldb/Host/ThreadLauncher.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 HostNativeThreadBase::HostNativeThreadBase()
     : m_thread(LLDB_INVALID_HOST_THREAD)
-    , m_state(eThreadStateInvalid)
     , m_result(0)
 {
 }
 
 HostNativeThreadBase::HostNativeThreadBase(thread_t thread)
     : m_thread(thread)
-    , m_state((thread == LLDB_INVALID_HOST_THREAD) ? eThreadStateInvalid : eThreadStateRunning)
     , m_result(0)
 {
 }
 
-void
-HostNativeThreadBase::SetState(ThreadState state)
-{
-    m_state = state;
-}
-
-ThreadState
-HostNativeThreadBase::GetState() const
-{
-    return m_state;
-}
-
 lldb::thread_t
 HostNativeThreadBase::GetSystemHandle() const
 {
     return m_thread;
 }
 
 lldb::thread_result_t
 HostNativeThreadBase::GetResult() const
 {
     return m_result;
 }
 
+bool
+HostNativeThreadBase::IsJoinable() const
+{
+    return m_thread != LLDB_INVALID_HOST_THREAD;
+}
+
 void
 HostNativeThreadBase::Reset()
 {
     m_thread = LLDB_INVALID_HOST_THREAD;
-    m_state = eThreadStateInvalid;
     m_result = 0;
 }
 
 lldb::thread_t
 HostNativeThreadBase::Release()
 {
     lldb::thread_t result = m_thread;
     m_thread = LLDB_INVALID_HOST_THREAD;
-    m_state = eThreadStateInvalid;
     m_result = 0;
 
     return result;
 }
 
 lldb::thread_result_t
 HostNativeThreadBase::ThreadCreateTrampoline(lldb::thread_arg_t arg)
 {

lldb/trunk/source/Host/common/HostThread.cpp

 }
 
 lldb::thread_t
 HostThread::Release()
 {
     return m_native_thread->Release();
 }
 
-void
-HostThread::SetState(ThreadState state)
-{
-    m_native_thread->SetState(state);
-}
-
-ThreadState
-HostThread::GetState() const
+bool
+HostThread::IsJoinable() const
 {
-    return m_native_thread->GetState();
+    return m_native_thread->IsJoinable();
 }
 
 HostNativeThreadBase &
 HostThread::GetNativeThread()
 {
     return *m_native_thread;
 }
 

lldb/trunk/source/Host/posix/HostThreadPosix.cpp

 //===-- HostThreadPosix.cpp -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Error.h"
 #include "lldb/Host/posix/HostThreadPosix.h"
 
+#include <errno.h>
 #include <pthread.h>
 
+using namespace lldb;
 using namespace lldb_private;
 
 HostThreadPosix::HostThreadPosix()
 {
 }
 
 HostThreadPosix::HostThreadPosix(lldb::thread_t thread)
     : HostNativeThreadBase(thread)
 {
 }
 
 HostThreadPosix::~HostThreadPosix()
 {
 }
 
 Error
 HostThreadPosix::Join(lldb::thread_result_t *result)
 {
     Error error;
+    if (IsJoinable())
+    {
         lldb::thread_result_t thread_result;
         int err = ::pthread_join(m_thread, &thread_result);
         error.SetError(err, lldb::eErrorTypePOSIX);
-    if (err == 0)
-    {
-        m_state = (m_state == eThreadStateCancelling) ? eThreadStateCancelled : eThreadStateExited;
     }
+    else
+        error.SetError(EINVAL, eErrorTypePOSIX);
+
+    Reset();
     return error;
 }
 
 Error
 HostThreadPosix::Cancel()
 {
     Error error;
     int err = ::pthread_cancel(m_thread);
-    error.SetError(err, lldb::eErrorTypePOSIX);
-    if (err == 0)
-        m_state = eThreadStateCancelling;
+    error.SetError(err, eErrorTypePOSIX);
 
     return error;
 }
 
 Error
 HostThreadPosix::Detach()
 {
     Error error;
     int err = ::pthread_detach(m_thread);
-    error.SetError(err, lldb::eErrorTypePOSIX);
+    error.SetError(err, eErrorTypePOSIX);
+    Reset();
     return error;
 }

lldb/trunk/source/Host/windows/HostThreadWindows.cpp

 {
     Reset();
 }
 
 Error
 HostThreadWindows::Join(lldb::thread_result_t *result)
 {
     Error error;
-    if (WAIT_OBJECT_0 != ::WaitForSingleObject(m_thread, INFINITE))
+    if (IsJoinable())
     {
-        error.SetError(::GetLastError(), lldb::eErrorTypeWin32);
-        return error;
-    }
-
-    m_state = (m_state == eThreadStateCancelling) ? eThreadStateCancelled : eThreadStateExited;
-
-    if (result)
+        DWORD wait_result = ::WaitForSingleObject(m_thread, INFINITE);
+        if (WAIT_OBJECT_0 == wait_result && result)
         {
-        DWORD dword_result = 0;
-        if (!::GetExitCodeThread(m_thread, &dword_result))
+            DWORD exit_code = 0;
+            if (!::GetExitCodeThread(m_thread, &exit_code))
                 *result = 0;
-        *result = dword_result;
+            *result = exit_code;
+        }
+        else if (WAIT_OBJECT_0 != wait_result)
+            error.SetError(::GetLastError(), eErrorTypeWin32);
     }
+    else
+        error.SetError(ERROR_INVALID_HANDLE, eErrorTypeWin32);
     return error;
 }
 
 Error
 HostThreadWindows::Cancel()
 {
     Error error;
 

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (!args->m_error.Success())
         StopOpThread();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
     m_monitor_thread = Host::StartMonitoringChildProcess(
         NativeProcessLinux::MonitorCallback, this, GetID(), true);
-    if (m_monitor_thread.GetState() != eThreadStateRunning)
+    if (!m_monitor_thread.IsJoinable())
     {
         error.SetErrorToGenericError();
         error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback.");
         return;
     }
 }
 
 void
if (!args->m_error.Success ())
         StopOpThread ();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
     m_monitor_thread = Host::StartMonitoringChildProcess (
         NativeProcessLinux::MonitorCallback, this, GetID (), true);
-    if (m_monitor_thread.GetState() != eThreadStateRunning)
+    if (!m_monitor_thread.IsJoinable())
     {
         error.SetErrorToGenericError ();
         error.SetErrorString ("Process attach failed to create monitor thread for NativeProcessLinux::MonitorCallback.");
         return;
     }
 }
 
 NativeProcessLinux::~NativeProcessLinux()
 {
     StopMonitor();
 }
 
 //------------------------------------------------------------------------------
 // Thread setup and tear down.
 
 void
 NativeProcessLinux::StartLaunchOpThread(LaunchArgs *args, Error &error)
 {
     static const char *g_thread_name = "lldb.process.nativelinux.operation";
 
-    if (m_operation_thread.GetState() == eThreadStateRunning)
+    if (m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args, &error);
 }
 
 void *
 NativeProcessLinux::LaunchOpThread(void *arg)
 {
FINISH:
     return args->m_error.Success();
 }
 
 void
 NativeProcessLinux::StartAttachOpThread(AttachArgs *args, lldb_private::Error &error)
 {
     static const char *g_thread_name = "lldb.process.linux.operation";
 
-    if (m_operation_thread.GetState() == eThreadStateRunning)
+    if (m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error);
 }
 
 void *
 NativeProcessLinux::AttachOpThread(void *arg)
 {
if (target_fd == -1)
         return false;
 
     return (dup2(target_fd, fd) == -1) ? false : true;
 }
 
 void
 NativeProcessLinux::StopMonitoringChildProcess()
 {
-    if (m_monitor_thread.GetState() == eThreadStateRunning)
+    if (m_monitor_thread.IsJoinable())
     {
         m_monitor_thread.Cancel();
         m_monitor_thread.Join(nullptr);
-        m_monitor_thread.Reset();
     }
 }
 
 void
 NativeProcessLinux::StopMonitor()
 {
     StopMonitoringChildProcess();
     StopOpThread();
     sem_destroy(&m_operation_pending);
     sem_destroy(&m_operation_done);
 
     // TODO: validate whether this still holds, fix up comment.
     // Note: ProcessPOSIX passes the m_terminal_fd file descriptor to
     // Process::SetSTDIOFileDescriptor, which in turn transfers ownership of
     // the descriptor to a ConnectionFileDescriptor object.  Consequently
     // even though still has the file descriptor, we shouldn't close it here.
 }
 
 void
 NativeProcessLinux::StopOpThread()
 {
-    if (m_operation_thread.GetState() != eThreadStateRunning)
+    if (!m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread.Cancel();
     m_operation_thread.Join(nullptr);
-    m_operation_thread.Reset();
 }
 
 bool
 NativeProcessLinux::HasThreadNoLock (lldb::tid_t thread_id)
 {
     for (auto thread_sp : m_threads)
     {
         assert (thread_sp && "thread list should not contain NULL threads");

lldb/trunk/source/Plugins/Process/Linux/ProcessMonitor.cpp

if (!args->m_error.Success())
         StopOpThread();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
     m_monitor_thread = Host::StartMonitoringChildProcess(
         ProcessMonitor::MonitorCallback, this, GetPID(), true);
-    if (m_monitor_thread.GetState() != eThreadStateRunning)
+    if (!m_monitor_thread.IsJoinable())
     {
         error.SetErrorToGenericError();
         error.SetErrorString("Process launch failed.");
         return;
     }
 }
 
 ProcessMonitor::ProcessMonitor(ProcessPOSIX *process,
if (!args->m_error.Success())
         StopOpThread();
         error = args->m_error;
         return;
     }
 
     // Finally, start monitoring the child process for change in state.
     m_monitor_thread = Host::StartMonitoringChildProcess(
         ProcessMonitor::MonitorCallback, this, GetPID(), true);
-    if (m_monitor_thread.GetState() != eThreadStateRunning)
+    if (!m_monitor_thread.IsJoinable())
     {
         error.SetErrorToGenericError();
         error.SetErrorString("Process attach failed.");
         return;
     }
 }
 
 ProcessMonitor::~ProcessMonitor()
 {
     StopMonitor();
 }
 
 //------------------------------------------------------------------------------
 // Thread setup and tear down.
 void
 ProcessMonitor::StartLaunchOpThread(LaunchArgs *args, Error &error)
 {
     static const char *g_thread_name = "lldb.process.linux.operation";
 
-    if (m_operation_thread.GetState() == eThreadStateRunning)
+    if (m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, LaunchOpThread, args, &error);
 }
 
 void *
 ProcessMonitor::LaunchOpThread(void *arg)
 {
FINISH:
     return args->m_error.Success();
 }
 
 void
 ProcessMonitor::StartAttachOpThread(AttachArgs *args, lldb_private::Error &error)
 {
     static const char *g_thread_name = "lldb.process.linux.operation";
 
-    if (m_operation_thread.GetState() == eThreadStateRunning)
+    if (m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread = ThreadLauncher::LaunchThread(g_thread_name, AttachOpThread, args, &error);
 }
 
 void *
 ProcessMonitor::AttachOpThread(void *arg)
 {
if (target_fd == -1)
         return false;
 
     return (dup2(target_fd, fd) == -1) ? false : true;
 }
 
 void
 ProcessMonitor::StopMonitoringChildProcess()
 {
-    if (m_monitor_thread.GetState() == eThreadStateRunning)
+    if (m_monitor_thread.IsJoinable())
     {
         m_monitor_thread.Cancel();
         m_monitor_thread.Join(nullptr);
-        m_monitor_thread.Reset();
     }
 }
 
 void
 ProcessMonitor::StopMonitor()
 {
     StopMonitoringChildProcess();
     StopOpThread();
     sem_destroy(&m_operation_pending);
     sem_destroy(&m_operation_done);
 
     // Note: ProcessPOSIX passes the m_terminal_fd file descriptor to
     // Process::SetSTDIOFileDescriptor, which in turn transfers ownership of
     // the descriptor to a ConnectionFileDescriptor object.  Consequently
     // even though still has the file descriptor, we shouldn't close it here.
 }
 
 void
 ProcessMonitor::StopOpThread()
 {
-    if (m_operation_thread.GetState() != eThreadStateRunning)
+    if (!m_operation_thread.IsJoinable())
         return;
 
     m_operation_thread.Cancel();
     m_operation_thread.Join(nullptr);
-    m_operation_thread.Reset();
 }

lldb/trunk/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 }
 
 Error
 ProcessKDP::DoResume ()
 {
     Error error;
     Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet (KDP_LOG_PROCESS));
     // Only start the async thread if we try to do any process control
-    if (m_async_thread.GetState() != eThreadStateRunning)
+    if (!m_async_thread.IsJoinable())
         StartAsyncThread();
 
     bool resume = false;
     
     // With KDP there is only one thread we can tell what to do
     ThreadSP kernel_thread_sp (m_thread_list.FindThreadByProtocolID(g_kernel_tid));
                             
     if (kernel_thread_sp)

 bool
 ProcessKDP::StartAsyncThread ()
 {
     Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
     
     if (log)
         log->Printf ("ProcessKDP::StartAsyncThread ()");
 
-    if (m_async_thread.GetState() == eThreadStateRunning)
+    if (m_async_thread.IsJoinable())
         return true;
 
     m_async_thread = ThreadLauncher::LaunchThread("<lldb.process.kdp-remote.async>", ProcessKDP::AsyncThread, this, NULL);
-    return m_async_thread.GetState() == eThreadStateRunning;
+    return m_async_thread.IsJoinable();
 }
 
 void
 ProcessKDP::StopAsyncThread ()
 {
     Log *log (ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
     
     if (log)
         log->Printf ("ProcessKDP::StopAsyncThread ()");
     
     m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);
     
     // Stop the stdio thread
-    if (m_async_thread.GetState() == eThreadStateRunning)
-    {
+    if (m_async_thread.IsJoinable())
         m_async_thread.Join(nullptr);
-        m_async_thread.Reset();
-    }
 }
 
 
 void *
 ProcessKDP::AsyncThread (void *arg)
 {
     ProcessKDP *process = (ProcessKDP*) arg;
     

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

GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, StringExtractorGDBRemote &packet)
     packet.Clear();
     return false;
 }
 
 Error
 GDBRemoteCommunication::StartListenThread (const char *hostname, uint16_t port)
 {
     Error error;
-    if (m_listen_thread.GetState() == eThreadStateRunning)
+    if (m_listen_thread.IsJoinable())
     {
         error.SetErrorString("listen thread already running");
     }
     else
     {
         char listen_url[512];
         if (hostname && hostname[0])
             snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname, port);
         else
             snprintf(listen_url, sizeof(listen_url), "listen://%i", port);
         m_listen_url = listen_url;
         SetConnection(new ConnectionFileDescriptor());
         m_listen_thread = ThreadLauncher::LaunchThread(listen_url, GDBRemoteCommunication::ListenThread, this, &error);
     }
     return error;
 }
 
 bool
 GDBRemoteCommunication::JoinListenThread ()
 {
-    if (m_listen_thread.GetState() == eThreadStateRunning)
-    {
+    if (m_listen_thread.IsJoinable())
         m_listen_thread.Join(nullptr);
-        m_listen_thread.Reset();
-    }
     return true;
 }
 
 lldb::thread_result_t
 GDBRemoteCommunication::ListenThread (lldb::thread_arg_t arg)
 {
     GDBRemoteCommunication *comm = (GDBRemoteCommunication *)arg;
     Error error;

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

if (listener.StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent))
             error.SetErrorString ("can't make continue packet for this resume");
         }
         else
         {
             EventSP event_sp;
             TimeValue timeout;
             timeout = TimeValue::Now();
             timeout.OffsetWithSeconds (5);
-            if (m_async_thread.GetState() != eThreadStateRunning)
+            if (!m_async_thread.IsJoinable())
             {
                 error.SetErrorString ("Trying to resume but the async thread is dead.");
                 if (log)
                     log->Printf ("ProcessGDBRemote::DoResume: Trying to resume but the async thread is dead.");
                 return error;
             }
             
             m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (continue_packet.GetData(), continue_packet.GetSize()));

 ProcessGDBRemote::StartAsyncThread ()
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
 
     if (log)
         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
     
     Mutex::Locker start_locker(m_async_thread_state_mutex);
-    if (m_async_thread.GetState() != eThreadStateRunning)
+    if (!m_async_thread.IsJoinable())
     {
         // Create a thread that watches our internal state and controls which
         // events make it to clients (into the DCProcess event queue).
 
         m_async_thread = ThreadLauncher::LaunchThread("<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this, NULL);
     }
-    else
-    {
-        // Somebody tried to start the async thread while it was either being started or stopped.  If the former, and
-        // it started up successfully, then say all's well.  Otherwise it is an error, since we aren't going to restart it.
-        if (log)
-            log->Printf("ProcessGDBRemote::%s () - Called when Async thread was in state: %d.", __FUNCTION__, m_async_thread.GetState());
-    }
+    else if (log)
+        log->Printf("ProcessGDBRemote::%s () - Called when Async thread was already running.", __FUNCTION__);
 
-    return (m_async_thread.GetState() == eThreadStateRunning);
+    return m_async_thread.IsJoinable();
 }
 
 void
 ProcessGDBRemote::StopAsyncThread ()
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
 
     if (log)
         log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__);
 
     Mutex::Locker start_locker(m_async_thread_state_mutex);
-    if (m_async_thread.GetState() == eThreadStateRunning)
+    if (m_async_thread.IsJoinable())
     {
         m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit);
         
         //  This will shut down the async thread.
         m_gdb_comm.Disconnect();    // Disconnect from the debug server.
 
         // Stop the stdio thread
         m_async_thread.Join(nullptr);
     }
-    else
-    {
-        if (log)
-            log->Printf("ProcessGDBRemote::%s () - Called when Async thread was in state: %d.", __FUNCTION__, m_async_thread.GetState());
-    }
+    else if (log)
+        log->Printf("ProcessGDBRemote::%s () - Called when Async thread was not running.", __FUNCTION__);
 }
 
 
 thread_result_t
 ProcessGDBRemote::AsyncThread (void *arg)
 {
     ProcessGDBRemote *process = (ProcessGDBRemote*) arg;
 

lldb/trunk/source/Target/Process.cpp

else
         if (already_running)
             snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state-override(pid=%" PRIu64 ")>", GetID());
         else
             snprintf(thread_name, sizeof(thread_name), "<lldb.process.internal-state(pid=%" PRIu64 ")>", GetID());
     }
 
     // Create the private state thread, and start it running.
     m_private_state_thread = ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, this, NULL);
-    if (m_private_state_thread.GetState() == eThreadStateRunning)
+    if (m_private_state_thread.IsJoinable())
     {
         ResumePrivateStateThread();
         return true;
     }
     else
         return false;
 }
 
Process::ControlPrivateStateThread (uint32_t signal)
 
     if (log)
         log->Printf ("Process::%s (signal = %d)", __FUNCTION__, signal);
 
     // Signal the private state thread. First we should copy this is case the
     // thread starts exiting since the private state thread will NULL this out
     // when it exits
     HostThread private_state_thread(m_private_state_thread);
-    if (private_state_thread.GetState() == eThreadStateRunning)
+    if (private_state_thread.IsJoinable())
     {
         TimeValue timeout_time;
         bool timed_out;
 
         m_private_state_control_broadcaster.BroadcastEvent (signal, NULL);
 
         timeout_time = TimeValue::Now();
         timeout_time.OffsetWithSeconds(2);
#endif
                 if (!back_to_top || try_halt_again > num_retries)
                     break;
                 else
                     continue;
             }
         }  // END WAIT LOOP
 
         // If we had to start up a temporary private state thread to run this thread plan, shut it down now.
-        if (backup_private_state_thread.GetState() != eThreadStateInvalid)
+        if (backup_private_state_thread.IsJoinable())
         {
             StopPrivateStateThread();
             Error error;
             m_private_state_thread = backup_private_state_thread;
             if (stopper_base_plan_sp)
             {
                 thread->DiscardThreadPlansUpToPlan(stopper_base_plan_sp);
             }

lldb/trunk/tools/lldb-gdbserver/lldb-gdbserver.cpp

ListenThread (lldb::thread_arg_t /* arg */)
     }
     return nullptr;
 }
 
 static Error
 StartListenThread (const char *hostname, uint16_t port)
 {
     Error error;
-    if (s_listen_thread.GetState() == eThreadStateRunning)
+    if (s_listen_thread.IsJoinable())
     {
         error.SetErrorString("listen thread already running");
     }
     else
     {
         char listen_url[512];
         if (hostname && hostname[0])
             snprintf(listen_url, sizeof(listen_url), "listen://%s:%i", hostname, port);
         else
             snprintf(listen_url, sizeof(listen_url), "listen://%i", port);
 
         s_listen_url = listen_url;
         s_listen_connection_up.reset (new ConnectionFileDescriptor ());
         s_listen_thread = ThreadLauncher::LaunchThread(listen_url, ListenThread, nullptr, &error);
     }
     return error;
 }
 
 static bool
 JoinListenThread ()
 {
-    if (s_listen_thread.GetState() == eThreadStateRunning)
-    {
+    if (s_listen_thread.IsJoinable())
         s_listen_thread.Join(nullptr);
-        s_listen_thread.Reset();
-    }
     return true;
 }
 
 void
 ConnectToRemote (GDBRemoteCommunicationServer &gdb_server, bool reverse_connect, const char *const host_and_port, const char *const progname, const char *const named_pipe_path)
 {
     Error error;