Remove shared_pointer from NativeThreadProtocol

[labath]

Summary

The NativeThread class is useless without the containing process (and in
some places it is already assuming the process is always around). This
makes it clear that the NativeProcessProtocol is the object owning the
threads, and makes the destruction order deterministic (first threads,
then process). The NativeProcess is the only thing holding a thread
unique_ptr, and methods that used to hand out thread shared pointers now
return raw pointers or references.

[krytarowski]

I don't have particular opinion. This change makes code cleaner.

lldb/trunk/include/lldb/Host/common/NativeProcessProtocol.h

 //===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessProtocol_h_
 #define liblldb_NativeProcessProtocol_h_
 
+#include "NativeBreakpointList.h"
+#include "NativeThreadProtocol.h"
+#include "NativeWatchpointList.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/TraceOptions.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <vector>
 
-#include "NativeBreakpointList.h"
-#include "NativeWatchpointList.h"
-
 namespace lldb_private {
 class MemoryRegionInfo;
 class ResumeActionList;
 
 //------------------------------------------------------------------
 // NativeProcessProtocol
 //------------------------------------------------------------------
 class NativeProcessProtocol {
public:
   //----------------------------------------------------------------------
   virtual llvm::Optional<WaitStatus> GetExitStatus();
 
   virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange);
 
   //----------------------------------------------------------------------
   // Access to threads
   //----------------------------------------------------------------------
-  NativeThreadProtocolSP GetThreadAtIndex(uint32_t idx);
+  NativeThreadProtocol *GetThreadAtIndex(uint32_t idx);
 
-  NativeThreadProtocolSP GetThreadByID(lldb::tid_t tid);
+  NativeThreadProtocol *GetThreadByID(lldb::tid_t tid);
 
   void SetCurrentThreadID(lldb::tid_t tid) { m_current_thread_id = tid; }
 
   lldb::tid_t GetCurrentThreadID() { return m_current_thread_id; }
 
-  NativeThreadProtocolSP GetCurrentThread() {
+  NativeThreadProtocol *GetCurrentThread() {
     return GetThreadByID(m_current_thread_id);
   }
 
   //----------------------------------------------------------------------
   // Access to inferior stdio
   //----------------------------------------------------------------------
   virtual int GetTerminalFileDescriptor() { return m_terminal_fd; }
 
public:
   //------------------------------------------------------------------
   virtual Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) {
     return Status("Not implemented");
   }
 
 protected:
   lldb::pid_t m_pid;
 
-  std::vector<NativeThreadProtocolSP> m_threads;
+  std::vector<std::unique_ptr<NativeThreadProtocol>> m_threads;
   lldb::tid_t m_current_thread_id = LLDB_INVALID_THREAD_ID;
   mutable std::recursive_mutex m_threads_mutex;
 
   lldb::StateType m_state = lldb::eStateInvalid;
   mutable std::recursive_mutex m_state_mutex;
 
   llvm::Optional<WaitStatus> m_exit_status;
 
protected:
   // -----------------------------------------------------------
   /// Notify the delegate that an exec occurred.
   ///
   /// Provide a mechanism for a delegate to clear out any exec-
   /// sensitive data.
   // -----------------------------------------------------------
   void NotifyDidExec();
 
-  NativeThreadProtocolSP GetThreadByIDUnlocked(lldb::tid_t tid);
+  NativeThreadProtocol *GetThreadByIDUnlocked(lldb::tid_t tid);
 
   // -----------------------------------------------------------
   // Static helper methods for derived classes.
   // -----------------------------------------------------------
   static Status ResolveProcessArchitecture(lldb::pid_t pid, ArchSpec &arch);
 
 private:
   void SynchronouslyNotifyProcessStateChanged(lldb::StateType state);
 };
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessProtocol_h_

lldb/trunk/include/lldb/Host/common/NativeThreadProtocol.h

 #include "lldb/Host/Debug.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 //------------------------------------------------------------------
 // NativeThreadProtocol
 //------------------------------------------------------------------
-class NativeThreadProtocol
-    : public std::enable_shared_from_this<NativeThreadProtocol> {
+class NativeThreadProtocol {
 public:
   NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid);
 
   virtual ~NativeThreadProtocol() {}
 
   virtual std::string GetName() = 0;
 
   virtual lldb::StateType GetState() = 0;

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

 class UnixSignals;
 
 // ---------------------------------------------------------------
 // SP/WP decls.
 // ---------------------------------------------------------------
 typedef std::shared_ptr<NativeBreakpoint> NativeBreakpointSP;
 typedef std::shared_ptr<lldb_private::NativeRegisterContext>
     NativeRegisterContextSP;
-typedef std::shared_ptr<lldb_private::NativeThreadProtocol>
-    NativeThreadProtocolSP;
 }
 
 #endif // #if defined(__cplusplus)
 #endif // #ifndef LLDB_lldb_private_forward_h_

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

bool NativeProcessProtocol::SetExitStatus(WaitStatus status,
   m_exit_status = status;
 
   if (bNotifyStateChange)
     SynchronouslyNotifyProcessStateChanged(lldb::eStateExited);
 
   return true;
 }
 
-NativeThreadProtocolSP NativeProcessProtocol::GetThreadAtIndex(uint32_t idx) {
+NativeThreadProtocol *NativeProcessProtocol::GetThreadAtIndex(uint32_t idx) {
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
   if (idx < m_threads.size())
-    return m_threads[idx];
-  return NativeThreadProtocolSP();
+    return m_threads[idx].get();
+  return nullptr;
 }
 
-NativeThreadProtocolSP
+NativeThreadProtocol *
 NativeProcessProtocol::GetThreadByIDUnlocked(lldb::tid_t tid) {
-  for (auto thread_sp : m_threads) {
-    if (thread_sp->GetID() == tid)
-      return thread_sp;
+  for (const auto &thread : m_threads) {
+    if (thread->GetID() == tid)
+      return thread.get();
   }
-  return NativeThreadProtocolSP();
+  return nullptr;
 }
 
-NativeThreadProtocolSP NativeProcessProtocol::GetThreadByID(lldb::tid_t tid) {
+NativeThreadProtocol *NativeProcessProtocol::GetThreadByID(lldb::tid_t tid) {
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
   return GetThreadByIDUnlocked(tid);
 }
 
 bool NativeProcessProtocol::IsAlive() const {
   return m_state != eStateDetached && m_state != eStateExited &&
          m_state != eStateInvalid && m_state != eStateUnloaded;
 }
NativeProcessProtocol::GetWatchpointMap() const {
   return m_watchpoint_list.GetWatchpointMap();
 }
 
 llvm::Optional<std::pair<uint32_t, uint32_t>>
 NativeProcessProtocol::GetHardwareDebugSupportInfo() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // get any thread
-  NativeThreadProtocolSP thread_sp(
+  NativeThreadProtocol *thread(
       const_cast<NativeProcessProtocol *>(this)->GetThreadAtIndex(0));
-  if (!thread_sp) {
-    if (log)
-      log->Warning("NativeProcessProtocol::%s (): failed to find a thread to "
-                   "grab a NativeRegisterContext!",
-                   __FUNCTION__);
+  if (!thread) {
+    LLDB_LOG(log, "failed to find a thread to grab a NativeRegisterContext!");
     return llvm::None;
   }
 
-  NativeRegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
+  NativeRegisterContextSP reg_ctx_sp(thread->GetRegisterContext());
   if (!reg_ctx_sp) {
-    if (log)
-      log->Warning("NativeProcessProtocol::%s (): failed to get a "
-                   "RegisterContextNativeProcess from the first thread!",
-                   __FUNCTION__);
+    LLDB_LOG(
+        log,
+        "failed to get a RegisterContextNativeProcess from the first thread!");
     return llvm::None;
   }
 
   return std::make_pair(reg_ctx_sp->NumSupportedHardwareBreakpoints(),
                         reg_ctx_sp->NumSupportedHardwareWatchpoints());
 }
 
 Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
 
   // Update the thread list
   UpdateThreads();
 
   // Keep track of the threads we successfully set the watchpoint
   // for.  If one of the thread watchpoint setting operations fails,
   // back off and remove the watchpoint for all the threads that
   // were successfully set so we get back to a consistent state.
-  std::vector<NativeThreadProtocolSP> watchpoint_established_threads;
+  std::vector<NativeThreadProtocol *> watchpoint_established_threads;
 
   // Tell each thread to set a watchpoint.  In the event that
   // hardware watchpoints are requested but the SetWatchpoint fails,
   // try to set a software watchpoint as a fallback.  It's
   // conceivable that if there are more threads than hardware
   // watchpoints available, some of the threads will fail to set
   // hardware watchpoints while software ones may be available.
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not have a NULL thread!");
-    if (!thread_sp)
-      continue;
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not have a NULL thread!");
 
     Status thread_error =
-        thread_sp->SetWatchpoint(addr, size, watch_flags, hardware);
+        thread->SetWatchpoint(addr, size, watch_flags, hardware);
     if (thread_error.Fail() && hardware) {
       // Try software watchpoints since we failed on hardware watchpoint setting
       // and we may have just run out of hardware watchpoints.
-      thread_error = thread_sp->SetWatchpoint(addr, size, watch_flags, false);
-      if (thread_error.Success()) {
-        if (log)
-          log->Warning(
+      thread_error = thread->SetWatchpoint(addr, size, watch_flags, false);
+      if (thread_error.Success())
+        LLDB_LOG(log,
                  "hardware watchpoint requested but software watchpoint set");
-      }
-    }
 
     if (thread_error.Success()) {
       // Remember that we set this watchpoint successfully in
       // case we need to clear it later.
-      watchpoint_established_threads.push_back(thread_sp);
+      watchpoint_established_threads.push_back(thread.get());
     } else {
       // Unset the watchpoint for each thread we successfully
       // set so that we get back to a consistent state of "not
       // set" for the watchpoint.
       for (auto unwatch_thread_sp : watchpoint_established_threads) {
         Status remove_error = unwatch_thread_sp->RemoveWatchpoint(addr);
-        if (remove_error.Fail() && log) {
-          log->Warning("NativeProcessProtocol::%s (): RemoveWatchpoint failed "
-                       "for pid=%" PRIu64 ", tid=%" PRIu64 ": %s",
-                       __FUNCTION__, GetID(), unwatch_thread_sp->GetID(),
-                       remove_error.AsCString());
-        }
+        if (remove_error.Fail())
+          LLDB_LOG(log, "RemoveWatchpoint failed for pid={0}, tid={1}: {2}",
+                   GetID(), unwatch_thread_sp->GetID(), remove_error);
       }
 
       return thread_error;
     }
   }
   return m_watchpoint_list.Add(addr, size, watch_flags, hardware);
 }
 
 Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) {
   // Update the thread list
   UpdateThreads();
 
   Status overall_error;
 
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not have a NULL thread!");
-    if (!thread_sp)
-      continue;
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not have a NULL thread!");
 
-    const Status thread_error = thread_sp->RemoveWatchpoint(addr);
+    const Status thread_error = thread->RemoveWatchpoint(addr);
     if (thread_error.Fail()) {
       // Keep track of the first thread error if any threads
       // fail. We want to try to remove the watchpoint from
       // every thread, though, even if one or more have errors.
       if (!overall_error.Fail())
         overall_error = thread_error;
     }
   }
Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
   if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
       hw_debug_cap->first <= m_hw_breakpoints_map.size())
     return Status("Target does not have required no of hardware breakpoints");
 
   // Vector below stores all thread pointer for which we have we successfully
   // set this hardware breakpoint. If any of the current process threads fails
   // to set this hardware breakpoint then roll back and remove this breakpoint
   // for all the threads that had already set it successfully.
-  std::vector<NativeThreadProtocolSP> breakpoint_established_threads;
+  std::vector<NativeThreadProtocol *> breakpoint_established_threads;
 
   // Request to set a hardware breakpoint for each of current process threads.
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not have a NULL thread!");
-    if (!thread_sp)
-      continue;
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not have a NULL thread!");
 
-    Status thread_error = thread_sp->SetHardwareBreakpoint(addr, size);
+    Status thread_error = thread->SetHardwareBreakpoint(addr, size);
     if (thread_error.Success()) {
       // Remember that we set this breakpoint successfully in
       // case we need to clear it later.
-      breakpoint_established_threads.push_back(thread_sp);
+      breakpoint_established_threads.push_back(thread.get());
     } else {
       // Unset the breakpoint for each thread we successfully
       // set so that we get back to a consistent state of "not
       // set" for this hardware breakpoint.
       for (auto rollback_thread_sp : breakpoint_established_threads) {
         Status remove_error =
             rollback_thread_sp->RemoveHardwareBreakpoint(addr);
-        if (remove_error.Fail() && log) {
-          log->Warning("NativeProcessProtocol::%s (): RemoveHardwareBreakpoint"
-                       " failed for pid=%" PRIu64 ", tid=%" PRIu64 ": %s",
-                       __FUNCTION__, GetID(), rollback_thread_sp->GetID(),
-                       remove_error.AsCString());
-        }
+        if (remove_error.Fail())
+          LLDB_LOG(log,
+                   "RemoveHardwareBreakpoint failed for pid={0}, tid={1}: {2}",
+                   GetID(), rollback_thread_sp->GetID(), remove_error);
       }
 
       return thread_error;
     }
   }
 
   // Register new hardware breakpoint into hardware breakpoints map of current
   // process.
   m_hw_breakpoints_map[addr] = {addr, size};
 
   return Status();
 }
 
 Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
   // Update the thread list
   UpdateThreads();
 
   Status error;
 
   std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not have a NULL thread!");
-    if (!thread_sp)
-      continue;
-
-    error = thread_sp->RemoveHardwareBreakpoint(addr);
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not have a NULL thread!");
+    error = thread->RemoveHardwareBreakpoint(addr);
   }
 
   // Also remove from hardware breakpoint map of current process.
   m_hw_breakpoints_map.erase(addr);
 
   return error;
 }
 

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

public:
   void DoStopIDBumped(uint32_t newBumpId) override;
 
   Status GetLoadedModuleFileSpec(const char *module_path,
                                  FileSpec &file_spec) override;
 
   Status GetFileLoadAddress(const llvm::StringRef &file_name,
                             lldb::addr_t &load_addr) override;
 
-  NativeThreadLinuxSP GetThreadByID(lldb::tid_t id);
+  NativeThreadLinux *GetThreadByID(lldb::tid_t id);
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const override {
     return getProcFile(GetID(), "auxv");
   }
 
   lldb::user_id_t StartTrace(const TraceOptions &config,
                              Status &error) override;
#if 0
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGBUS(const siginfo_t *info);
 #endif
 
   bool HasThreadNoLock(lldb::tid_t thread_id);
 
   bool StopTrackingThread(lldb::tid_t thread_id);
 
-  NativeThreadLinuxSP AddThread(lldb::tid_t thread_id);
+  NativeThreadLinux &AddThread(lldb::tid_t thread_id);
 
   Status GetSoftwareBreakpointPCOffset(uint32_t &actual_opcode_size);
 
   Status FixupBreakpointPCAsNeeded(NativeThreadLinux &thread);
 
   /// Writes a siginfo_t structure corresponding to the given thread ID to the
   /// memory region pointed to by @p siginfo.
   Status GetSignalInfo(lldb::tid_t tid, void *siginfo);

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

NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);
   assert(m_sigchld_handle && status.Success());
 
   for (const auto &tid : tids) {
-    NativeThreadLinuxSP thread_sp = AddThread(tid);
-    assert(thread_sp && "AddThread() returned a nullptr thread");
-    thread_sp->SetStoppedBySignal(SIGSTOP);
-    ThreadWasCreated(*thread_sp);
+    NativeThreadLinux &thread = AddThread(tid);
+    thread.SetStoppedBySignal(SIGSTOP);
+    ThreadWasCreated(thread);
   }
 
   // Let our process instance know the thread has stopped.
   SetCurrentThreadID(tids[0]);
   SetState(StateType::eStateStopped, false);
 
   // Proccess any signals we received before installing our handler
   SigchldHandler();
if (info_err.Fail()) {
                "Ingoring this notification.",
                pid, info_err);
       return;
     }
 
     LLDB_LOG(log, "tid {0}, si_code: {1}, si_pid: {2}", pid, info.si_code,
              info.si_pid);
 
-    auto thread_sp = AddThread(pid);
+    NativeThreadLinux &thread = AddThread(pid);
 
     // Resume the newly created thread.
-    ResumeThread(*thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
-    ThreadWasCreated(*thread_sp);
+    ResumeThread(thread, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
+    ThreadWasCreated(thread);
     return;
   }
 
   // Get details on the signal raised.
   if (info_err.Success()) {
     // We have retrieved the signal info.  Dispatch appropriately.
     if (info.si_signo == SIGTRAP)
       MonitorSIGTRAP(info, *thread_sp);
if (info_err.GetError() == EINVAL) {
       }
     }
   }
 }
 
 void NativeProcessLinux::WaitForNewThread(::pid_t tid) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
-  NativeThreadLinuxSP new_thread_sp = GetThreadByID(tid);
-
-  if (new_thread_sp) {
+  if (GetThreadByID(tid)) {
     // We are already tracking the thread - we got the event on the new thread
-    // (see
-    // MonitorSignal) before this one. We are done.
+    // (see MonitorSignal) before this one. We are done.
     return;
   }
 
   // The thread is not tracked yet, let's wait for it to appear.
   int status = -1;
   LLDB_LOG(log,
            "received thread creation event for tid {0}. tid not tracked "
            "yet, waiting for thread to appear...",
LLDB_LOG(log,
              "waiting for tid {0} returned an 'exited' event. Not "
              "tracking the thread.",
              tid);
     // Also a very improbable event.
     return;
   }
 
   LLDB_LOG(log, "pid = {0}: tracking new thread tid {1}", GetID(), tid);
-  new_thread_sp = AddThread(tid);
+  NativeThreadLinux &new_thread = AddThread(tid);
 
-  ResumeThread(*new_thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
-  ThreadWasCreated(*new_thread_sp);
+  ResumeThread(new_thread, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
+  ThreadWasCreated(new_thread);
 }
 
 void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info,
                                         NativeThreadLinux &thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   const bool is_main_thread = (thread.GetID() == GetID());
 
   assert(info.si_signo == SIGTRAP && "Unexpected child signal!");
case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)): {
     } else
       WaitForNewThread(event_message);
 
     ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
     break;
   }
 
   case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)): {
-    NativeThreadLinuxSP main_thread_sp;
     LLDB_LOG(log, "received exec event, code = {0}", info.si_code ^ SIGTRAP);
 
     // Exec clears any pending notifications.
     m_pending_notification_tid = LLDB_INVALID_THREAD_ID;
 
     // Remove all but the main thread here.  Linux fork creates a new process
     // which only copies the main thread.
     LLDB_LOG(log, "exec received, stop tracking all but main thread");
 
-    for (auto thread_sp : m_threads) {
-      const bool is_main_thread = thread_sp && thread_sp->GetID() == GetID();
-      if (is_main_thread) {
-        main_thread_sp = std::static_pointer_cast<NativeThreadLinux>(thread_sp);
-        LLDB_LOG(log, "found main thread with tid {0}, keeping",
-                 main_thread_sp->GetID());
-      } else {
-        LLDB_LOG(log, "discarding non-main-thread tid {0} due to exec",
-                 thread_sp->GetID());
-      }
+    for (auto i = m_threads.begin(); i != m_threads.end();) {
+      if ((*i)->GetID() == GetID())
+        i = m_threads.erase(i);
+      else
+        ++i;
     }
+    assert(m_threads.size() == 1);
+    auto *main_thread = static_cast<NativeThreadLinux *>(m_threads[0].get());
 
-    m_threads.clear();
-
-    if (main_thread_sp) {
-      m_threads.push_back(main_thread_sp);
-      SetCurrentThreadID(main_thread_sp->GetID());
-      main_thread_sp->SetStoppedByExec();
-    } else {
-      SetCurrentThreadID(LLDB_INVALID_THREAD_ID);
-      LLDB_LOG(log,
-               "pid {0} no main thread found, discarded all threads, "
-               "we're in a no-thread state!",
-               GetID());
-    }
+    SetCurrentThreadID(main_thread->GetID());
+    main_thread->SetStoppedByExec();
 
     // Tell coordinator about about the "new" (since exec) stopped main thread.
-    ThreadWasCreated(*main_thread_sp);
+    ThreadWasCreated(*main_thread);
 
     // Let our delegate know we have just exec'd.
     NotifyDidExec();
 
-    // If we have a main thread, indicate we are stopped.
-    assert(main_thread_sp && "exec called during ptraced process but no main "
-                             "thread metadata tracked");
-
     // Let the process know we're stopped.
-    StopRunningThreads(main_thread_sp->GetID());
+    StopRunningThreads(main_thread->GetID());
 
     break;
   }
 
   case (SIGTRAP | (PTRACE_EVENT_EXIT << 8)): {
     // The inferior process or one of its threads is about to exit.
     // We don't want to do anything with the thread so we just resume it. In
     // case we

 
 Status NativeProcessLinux::Resume(const ResumeActionList &resume_actions) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   LLDB_LOG(log, "pid {0}", GetID());
 
   bool software_single_step = !SupportHardwareSingleStepping();
 
   if (software_single_step) {
-    for (auto thread_sp : m_threads) {
-      assert(thread_sp && "thread list should not contain NULL threads");
+    for (const auto &thread : m_threads) {
+      assert(thread && "thread list should not contain NULL threads");
 
       const ResumeAction *const action =
-          resume_actions.GetActionForThread(thread_sp->GetID(), true);
+          resume_actions.GetActionForThread(thread->GetID(), true);
       if (action == nullptr)
         continue;
 
       if (action->state == eStateStepping) {
         Status error = SetupSoftwareSingleStepping(
-            static_cast<NativeThreadLinux &>(*thread_sp));
+            static_cast<NativeThreadLinux &>(*thread));
         if (error.Fail())
           return error;
       }
     }
   }
 
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not contain NULL threads");
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not contain NULL threads");
 
     const ResumeAction *const action =
-        resume_actions.GetActionForThread(thread_sp->GetID(), true);
+        resume_actions.GetActionForThread(thread->GetID(), true);
 
     if (action == nullptr) {
       LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
-               thread_sp->GetID());
+               thread->GetID());
       continue;
     }
 
     LLDB_LOG(log, "processing resume action state {0} for pid {1} tid {2}",
-             action->state, GetID(), thread_sp->GetID());
+             action->state, GetID(), thread->GetID());
 
     switch (action->state) {
     case eStateRunning:
     case eStateStepping: {
       // Run the thread, possibly feeding it the signal.
       const int signo = action->signal;
-      ResumeThread(static_cast<NativeThreadLinux &>(*thread_sp), action->state,
+      ResumeThread(static_cast<NativeThreadLinux &>(*thread), action->state,
                    signo);
       break;
     }
 
     case eStateSuspended:
     case eStateStopped:
       llvm_unreachable("Unexpected state");
 
     default:
       return Status("NativeProcessLinux::%s (): unexpected state %s specified "
                     "for pid %" PRIu64 ", tid %" PRIu64,
                     __FUNCTION__, StateAsCString(action->state), GetID(),
-                    thread_sp->GetID());
+                    thread->GetID());
     }
   }
 
   return Status();
 }
 
 Status NativeProcessLinux::Halt() {
   Status error;
Status NativeProcessLinux::Detach() {
 
   // Stop monitoring the inferior.
   m_sigchld_handle.reset();
 
   // Tell ptrace to detach from the process.
   if (GetID() == LLDB_INVALID_PROCESS_ID)
     return error;
 
-  for (auto thread_sp : m_threads) {
-    Status e = Detach(thread_sp->GetID());
+  for (const auto &thread : m_threads) {
+    Status e = Detach(thread->GetID());
     if (e.Fail())
       error =
           e; // Save the error, but still attempt to detach from other threads.
   }
 
   m_processor_trace_monitor.clear();
   m_pt_proces_trace_id = LLDB_INVALID_UID;
 
Status NativeProcessLinux::Signal(int signo) {
   return error;
 }
 
 Status NativeProcessLinux::Interrupt() {
   // Pick a running thread (or if none, a not-dead stopped thread) as
   // the chosen thread that will be the stop-reason thread.
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
-  NativeThreadProtocolSP running_thread_sp;
-  NativeThreadProtocolSP stopped_thread_sp;
+  NativeThreadProtocol *running_thread = nullptr;
+  NativeThreadProtocol *stopped_thread = nullptr;
 
   LLDB_LOG(log, "selecting running thread for interrupt target");
-  for (auto thread_sp : m_threads) {
-    // The thread shouldn't be null but lets just cover that here.
-    if (!thread_sp)
-      continue;
-
+  for (const auto &thread : m_threads) {
     // If we have a running or stepping thread, we'll call that the
     // target of the interrupt.
-    const auto thread_state = thread_sp->GetState();
+    const auto thread_state = thread->GetState();
     if (thread_state == eStateRunning || thread_state == eStateStepping) {
-      running_thread_sp = thread_sp;
+      running_thread = thread.get();
       break;
-    } else if (!stopped_thread_sp && StateIsStoppedState(thread_state, true)) {
+    } else if (!stopped_thread && StateIsStoppedState(thread_state, true)) {
       // Remember the first non-dead stopped thread.  We'll use that as a backup
       // if there are no running threads.
-      stopped_thread_sp = thread_sp;
+      stopped_thread = thread.get();
     }
   }
 
-  if (!running_thread_sp && !stopped_thread_sp) {
+  if (!running_thread && !stopped_thread) {
     Status error("found no running/stepping or live stopped threads as target "
                  "for interrupt");
     LLDB_LOG(log, "skipping due to error: {0}", error);
 
     return error;
   }
 
-  NativeThreadProtocolSP deferred_signal_thread_sp =
-      running_thread_sp ? running_thread_sp : stopped_thread_sp;
+  NativeThreadProtocol *deferred_signal_thread =
+      running_thread ? running_thread : stopped_thread;
 
   LLDB_LOG(log, "pid {0} {1} tid {2} chosen for interrupt target", GetID(),
-           running_thread_sp ? "running" : "stopped",
-           deferred_signal_thread_sp->GetID());
+           running_thread ? "running" : "stopped",
+           deferred_signal_thread->GetID());
 
-  StopRunningThreads(deferred_signal_thread_sp->GetID());
+  StopRunningThreads(deferred_signal_thread->GetID());
 
   return Status();
 }
 
 Status NativeProcessLinux::Kill() {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   LLDB_LOG(log, "pid {0}", GetID());
 

 Status NativeProcessLinux::Detach(lldb::tid_t tid) {
   if (tid == LLDB_INVALID_THREAD_ID)
     return Status();
 
   return PtraceWrapper(PTRACE_DETACH, tid);
 }
 
 bool NativeProcessLinux::HasThreadNoLock(lldb::tid_t thread_id) {
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not contain NULL threads");
-    if (thread_sp->GetID() == thread_id) {
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not contain NULL threads");
+    if (thread->GetID() == thread_id) {
       // We have this thread.
       return true;
     }
   }
 
   // We don't have this thread.
   return false;
 }
bool NativeProcessLinux::StopTrackingThread(lldb::tid_t thread_id) {
   }
 
   if (found)
     StopTracingForThread(thread_id);
   SignalIfAllThreadsStopped();
   return found;
 }
 
-NativeThreadLinuxSP NativeProcessLinux::AddThread(lldb::tid_t thread_id) {
+NativeThreadLinux &NativeProcessLinux::AddThread(lldb::tid_t thread_id) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
   LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id);
 
   assert(!HasThreadNoLock(thread_id) &&
          "attempted to add a thread by id that already exists");
 
   // If this is the first thread, save it as the current thread
   if (m_threads.empty())
     SetCurrentThreadID(thread_id);
 
-  auto thread_sp = std::make_shared<NativeThreadLinux>(*this, thread_id);
-  m_threads.push_back(thread_sp);
+  m_threads.push_back(llvm::make_unique<NativeThreadLinux>(*this, thread_id));
 
   if (m_pt_proces_trace_id != LLDB_INVALID_UID) {
     auto traceMonitor = ProcessorTraceMonitor::Create(
         GetID(), thread_id, m_pt_process_trace_config, true);
     if (traceMonitor) {
       m_pt_traced_thread_group.insert(thread_id);
       m_processor_trace_monitor.insert(
           std::make_pair(thread_id, std::move(*traceMonitor)));
     } else {
       LLDB_LOG(log, "failed to start trace on thread {0}", thread_id);
       Status error(traceMonitor.takeError());
       LLDB_LOG(log, "error {0}", error);
     }
   }
 
-  return thread_sp;
+  return static_cast<NativeThreadLinux &>(*m_threads.back());
 }
 
 Status
 NativeProcessLinux::FixupBreakpointPCAsNeeded(NativeThreadLinux &thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
 
   Status error;
 
for (const auto &it : m_mem_region_cache) {
     if (it.second == file) {
       load_addr = it.first.GetRange().GetRangeBase();
       return Status();
     }
   }
   return Status("No load address found for specified file.");
 }
 
-NativeThreadLinuxSP NativeProcessLinux::GetThreadByID(lldb::tid_t tid) {
-  return std::static_pointer_cast<NativeThreadLinux>(
+NativeThreadLinux *NativeProcessLinux::GetThreadByID(lldb::tid_t tid) {
+  return static_cast<NativeThreadLinux *>(
       NativeProcessProtocol::GetThreadByID(tid));
 }
 
 Status NativeProcessLinux::ResumeThread(NativeThreadLinux &thread,
                                         lldb::StateType state, int signo) {
   Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD);
   LLDB_LOG(log, "tid: {0}", thread.GetID());
 
void NativeProcessLinux::StopRunningThreads(const lldb::tid_t triggering_tid) {
   Log *const log = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD);
   LLDB_LOG(log, "about to process event: (triggering_tid: {0})",
            triggering_tid);
 
   m_pending_notification_tid = triggering_tid;
 
   // Request a stop for all the thread stops that need to be stopped
   // and are not already known to be stopped.
-  for (const auto &thread_sp : m_threads) {
-    if (StateIsRunningState(thread_sp->GetState()))
-      static_pointer_cast<NativeThreadLinux>(thread_sp)->RequestStop();
+  for (const auto &thread : m_threads) {
+    if (StateIsRunningState(thread->GetState()))
+      static_cast<NativeThreadLinux *>(thread.get())->RequestStop();
   }
 
   SignalIfAllThreadsStopped();
   LLDB_LOG(log, "event processing done");
 }
 
 void NativeProcessLinux::SignalIfAllThreadsStopped() {
   if (m_pending_notification_tid == LLDB_INVALID_THREAD_ID)

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

private:
   ThreadStopInfo m_stop_info;
   NativeRegisterContextSP m_reg_context_sp;
   std::string m_stop_description;
   using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
   WatchpointIndexMap m_watchpoint_index_map;
   WatchpointIndexMap m_hw_break_index_map;
   std::unique_ptr<SingleStepWorkaround> m_step_workaround;
 };
-
-typedef std::shared_ptr<NativeThreadLinux> NativeThreadLinuxSP;
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

private:
   // ---------------------------------------------------------------------
   // Private Instance Methods
   // ---------------------------------------------------------------------
   NativeProcessNetBSD(::pid_t pid, int terminal_fd, NativeDelegate &delegate,
                       const ArchSpec &arch, MainLoop &mainloop);
 
   bool HasThreadNoLock(lldb::tid_t thread_id);
 
-  NativeThreadNetBSDSP AddThread(lldb::tid_t thread_id);
+  NativeThreadNetBSD &AddThread(lldb::tid_t thread_id);
 
   void MonitorCallback(lldb::pid_t pid, int signal);
   void MonitorExited(lldb::pid_t pid, WaitStatus status);
   void MonitorSIGSTOP(lldb::pid_t pid);
   void MonitorSIGTRAP(lldb::pid_t pid);
   void MonitorSignal(lldb::pid_t pid, int signal);
 
   Status GetSoftwareBreakpointPCOffset(uint32_t &actual_opcode_size);

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

NativeProcessNetBSD::Factory::Launch(ProcessLaunchInfo &launch_info,
   std::unique_ptr<NativeProcessNetBSD> process_up(new NativeProcessNetBSD(
       pid, launch_info.GetPTY().ReleaseMasterFileDescriptor(), native_delegate,
       arch, mainloop));
 
   status = process_up->ReinitializeThreads();
   if (status.Fail())
     return status.ToError();
 
-  for (const auto &thread_sp : process_up->m_threads) {
-    static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedBySignal(
-        SIGSTOP);
-  }
+  for (const auto &thread : process_up->m_threads)
+    static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
   process_up->SetState(StateType::eStateStopped);
 
   return std::move(process_up);
 }
 
 llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
 NativeProcessNetBSD::Factory::Attach(
     lldb::pid_t pid, NativeProcessProtocol::NativeDelegate &native_delegate,
void NativeProcessNetBSD::MonitorSIGSTOP(lldb::pid_t pid) {
   const auto siginfo_err =
       PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info));
 
   // Get details on the signal raised.
   if (siginfo_err.Success()) {
     // Handle SIGSTOP from LLGS (LLDB GDB Server)
     if (info.psi_siginfo.si_code == SI_USER &&
         info.psi_siginfo.si_pid == ::getpid()) {
-      /* Stop Tracking All Threads attached to Process */
-      for (const auto &thread_sp : m_threads) {
-        static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedBySignal(
+      /* Stop Tracking all Threads attached to Process */
+      for (const auto &thread : m_threads) {
+        static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(
             SIGSTOP, &info.psi_siginfo);
       }
     }
   }
 }
 
 void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   ptrace_siginfo_t info;
 
   const auto siginfo_err =
       PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info));
 
   // Get details on the signal raised.
   if (siginfo_err.Fail()) {
     return;
   }
 
   switch (info.psi_siginfo.si_code) {
   case TRAP_BRKPT:
-    for (const auto &thread_sp : m_threads) {
-      static_pointer_cast<NativeThreadNetBSD>(thread_sp)
-          ->SetStoppedByBreakpoint();
-      FixupBreakpointPCAsNeeded(
-          *static_pointer_cast<NativeThreadNetBSD>(thread_sp));
+    for (const auto &thread : m_threads) {
+      static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByBreakpoint();
+      FixupBreakpointPCAsNeeded(static_cast<NativeThreadNetBSD &>(*thread));
     }
     SetState(StateType::eStateStopped, true);
     break;
   case TRAP_TRACE:
-    for (const auto &thread_sp : m_threads) {
-      static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedByTrace();
-    }
+    for (const auto &thread : m_threads)
+      static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByTrace();
     SetState(StateType::eStateStopped, true);
     break;
   case TRAP_EXEC: {
     Status error = ReinitializeThreads();
     if (error.Fail()) {
       SetState(StateType::eStateInvalid);
       return;
     }
 
     // Let our delegate know we have just exec'd.
     NotifyDidExec();
 
-    for (const auto &thread_sp : m_threads) {
-      static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedByExec();
-    }
+    for (const auto &thread : m_threads)
+      static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByExec();
     SetState(StateType::eStateStopped, true);
   } break;
   case TRAP_DBREG: {
     // If a watchpoint was hit, report it
     uint32_t wp_index;
-    Status error =
-        static_pointer_cast<NativeThreadNetBSD>(m_threads[info.psi_lwpid])
-            ->GetRegisterContext()
-            ->GetWatchpointHitIndex(wp_index,
-                                    (uintptr_t)info.psi_siginfo.si_addr);
+    Status error = static_cast<NativeThreadNetBSD &>(*m_threads[info.psi_lwpid])
+                       .GetRegisterContext()
+                       ->GetWatchpointHitIndex(
+                           wp_index, (uintptr_t)info.psi_siginfo.si_addr);
     if (error.Fail())
       LLDB_LOG(log,
                "received error while checking for watchpoint hits, pid = "
                "{0}, LWP = {1}, error = {2}",
                GetID(), info.psi_lwpid, error);
     if (wp_index != LLDB_INVALID_INDEX32) {
-      for (const auto &thread_sp : m_threads) {
-        static_pointer_cast<NativeThreadNetBSD>(thread_sp)
-            ->SetStoppedByWatchpoint(wp_index);
-      }
+      for (const auto &thread : m_threads)
+        static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByWatchpoint(
+            wp_index);
       SetState(StateType::eStateStopped, true);
       break;
     }
 
     // If a breakpoint was hit, report it
     uint32_t bp_index;
-    error = static_pointer_cast<NativeThreadNetBSD>(m_threads[info.psi_lwpid])
-                ->GetRegisterContext()
+    error = static_cast<NativeThreadNetBSD &>(*m_threads[info.psi_lwpid])
+                .GetRegisterContext()
                 ->GetHardwareBreakHitIndex(bp_index,
                                            (uintptr_t)info.psi_siginfo.si_addr);
     if (error.Fail())
       LLDB_LOG(log,
                "received error while checking for hardware "
                "breakpoint hits, pid = {0}, LWP = {1}, error = {2}",
                GetID(), info.psi_lwpid, error);
     if (bp_index != LLDB_INVALID_INDEX32) {
-      for (const auto &thread_sp : m_threads) {
-        static_pointer_cast<NativeThreadNetBSD>(thread_sp)
-            ->SetStoppedByBreakpoint();
-      }
+      for (const auto &thread : m_threads)
+        static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByBreakpoint();
       SetState(StateType::eStateStopped, true);
       break;
     }
   } break;
   }
 }
 
 void NativeProcessNetBSD::MonitorSignal(lldb::pid_t pid, int signal) {
   ptrace_siginfo_t info;
   const auto siginfo_err =
       PtraceWrapper(PT_GET_SIGINFO, pid, &info, sizeof(info));
 
-  for (const auto &thread_sp : m_threads) {
-    static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedBySignal(
+  for (const auto &thread : m_threads) {
+    static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(
         info.psi_siginfo.si_signo, &info.psi_siginfo);
   }
   SetState(StateType::eStateStopped, true);
 }
 
 Status NativeProcessNetBSD::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
                                           int data, int *result) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PTRACE));
NativeProcessNetBSD::FixupBreakpointPCAsNeeded(NativeThreadNetBSD &thread) {
   }
   return error;
 }
 
 Status NativeProcessNetBSD::Resume(const ResumeActionList &resume_actions) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
   LLDB_LOG(log, "pid {0}", GetID());
 
-  const auto &thread_sp = m_threads[0];
+  const auto &thread = m_threads[0];
   const ResumeAction *const action =
-      resume_actions.GetActionForThread(thread_sp->GetID(), true);
+      resume_actions.GetActionForThread(thread->GetID(), true);
 
   if (action == nullptr) {
     LLDB_LOG(log, "no action specified for pid {0} tid {1}", GetID(),
-             thread_sp->GetID());
+             thread->GetID());
     return Status();
   }
 
   Status error;
 
   switch (action->state) {
   case eStateRunning: {
     // Run the thread, possibly feeding it the signal.
     error = NativeProcessNetBSD::PtraceWrapper(PT_CONTINUE, GetID(), (void *)1,
                                                action->signal);
     if (!error.Success())
       return error;
-    for (const auto &thread_sp : m_threads) {
-      static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetRunning();
-    }
+    for (const auto &thread : m_threads)
+      static_cast<NativeThreadNetBSD &>(*thread).SetRunning();
     SetState(eStateRunning, true);
     break;
   }
   case eStateStepping:
     // Run the thread, possibly feeding it the signal.
     error = NativeProcessNetBSD::PtraceWrapper(PT_STEP, GetID(), (void *)1,
                                                action->signal);
     if (!error.Success())
       return error;
-    for (const auto &thread_sp : m_threads) {
-      static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStepping();
-    }
+    for (const auto &thread : m_threads)
+      static_cast<NativeThreadNetBSD &>(*thread).SetStepping();
     SetState(eStateStepping, true);
     break;
 
   case eStateSuspended:
   case eStateStopped:
     llvm_unreachable("Unexpected state");
 
   default:
     return Status("NativeProcessNetBSD::%s (): unexpected state %s specified "
                   "for pid %" PRIu64 ", tid %" PRIu64,
                   __FUNCTION__, StateAsCString(action->state), GetID(),
-                  thread_sp->GetID());
+                  thread->GetID());
   }
 
   return Status();
 }
 
 Status NativeProcessNetBSD::Halt() {
   Status error;
 
if (exited)
     MonitorExited(wait_pid, wait_status);
   else {
     assert(wait_status.type == WaitStatus::Stop);
     MonitorCallback(wait_pid, wait_status.status);
   }
 }
 
 bool NativeProcessNetBSD::HasThreadNoLock(lldb::tid_t thread_id) {
-  for (auto thread_sp : m_threads) {
-    assert(thread_sp && "thread list should not contain NULL threads");
-    if (thread_sp->GetID() == thread_id) {
+  for (const auto &thread : m_threads) {
+    assert(thread && "thread list should not contain NULL threads");
+    if (thread->GetID() == thread_id) {
       // We have this thread.
       return true;
     }
   }
 
   // We don't have this thread.
   return false;
 }
 
-NativeThreadNetBSDSP NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) {
+NativeThreadNetBSD &NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) {
 
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
   LLDB_LOG(log, "pid {0} adding thread with tid {1}", GetID(), thread_id);
 
   assert(!HasThreadNoLock(thread_id) &&
          "attempted to add a thread by id that already exists");
 
   // If this is the first thread, save it as the current thread
   if (m_threads.empty())
     SetCurrentThreadID(thread_id);
 
-  auto thread_sp = std::make_shared<NativeThreadNetBSD>(*this, thread_id);
-  m_threads.push_back(thread_sp);
-  return thread_sp;
+  m_threads.push_back(llvm::make_unique<NativeThreadNetBSD>(*this, thread_id));
+  return static_cast<NativeThreadNetBSD &>(*m_threads.back());
 }
 
 Status NativeProcessNetBSD::Attach() {
   // Attach to the requested process.
   // An attach will cause the thread to stop with a SIGSTOP.
   Status status = PtraceWrapper(PT_ATTACH, m_pid);
   if (status.Fail())
     return status;
 
   int wstatus;
   // Need to use WALLSIG otherwise we receive an error with errno=ECHLD
   // At this point we should have a thread stopped if waitpid succeeds.
   if ((wstatus = waitpid(m_pid, NULL, WALLSIG)) < 0)
     return Status(errno, eErrorTypePOSIX);
 
   /* Initialize threads */
   status = ReinitializeThreads();
   if (status.Fail())
     return status;
 
-  for (const auto &thread_sp : m_threads) {
-    static_pointer_cast<NativeThreadNetBSD>(thread_sp)->SetStoppedBySignal(
-        SIGSTOP);
-  }
+  for (const auto &thread : m_threads)
+    static_cast<NativeThreadNetBSD &>(*thread).SetStoppedBySignal(SIGSTOP);
 
   // Let our process instance know the thread has stopped.
   SetState(StateType::eStateStopped);
   return Status();
 }
 
 Status NativeProcessNetBSD::ReadMemory(lldb::addr_t addr, void *buf,
                                        size_t size, size_t &bytes_read) {
Status NativeProcessNetBSD::ReinitializeThreads() {
   // Initialize new thread
   struct ptrace_lwpinfo info = {};
   Status error = PtraceWrapper(PT_LWPINFO, GetID(), &info, sizeof(info));
   if (error.Fail()) {
     return error;
   }
   // Reinitialize from scratch threads and register them in process
   while (info.pl_lwpid != 0) {
-    NativeThreadNetBSDSP thread_sp = AddThread(info.pl_lwpid);
+    AddThread(info.pl_lwpid);
     error = PtraceWrapper(PT_LWPINFO, GetID(), &info, sizeof(info));
     if (error.Fail()) {
       return error;
     }
   }
 
   return error;
 }

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

protected:
   FileSpec FindModuleFile(const std::string &module_path,
                           const ArchSpec &arch) override;
 
 private:
   void HandleInferiorState_Exited(NativeProcessProtocol *process);
 
   void HandleInferiorState_Stopped(NativeProcessProtocol *process);
 
-  NativeThreadProtocolSP GetThreadFromSuffix(StringExtractorGDBRemote &packet);
+  NativeThreadProtocol *GetThreadFromSuffix(StringExtractorGDBRemote &packet);
 
   uint32_t GetNextSavedRegistersID();
 
   void MaybeCloseInferiorTerminalConnection();
 
   void ClearProcessSpecificData();
 
   void RegisterPacketHandlers();

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

 static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process,
                                         bool abridged) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 
   JSONArray::SP threads_array_sp = std::make_shared<JSONArray>();
 
   // Ensure we can get info on the given thread.
   uint32_t thread_idx = 0;
-  for (NativeThreadProtocolSP thread_sp;
-       (thread_sp = process.GetThreadAtIndex(thread_idx)) != nullptr;
+  for (NativeThreadProtocol *thread;
+       (thread = process.GetThreadAtIndex(thread_idx)) != nullptr;
        ++thread_idx) {
 
-    lldb::tid_t tid = thread_sp->GetID();
+    lldb::tid_t tid = thread->GetID();
 
     // Grab the reason this thread stopped.
     struct ThreadStopInfo tid_stop_info;
     std::string description;
-    if (!thread_sp->GetStopReason(tid_stop_info, description))
+    if (!thread->GetStopReason(tid_stop_info, description))
       return nullptr;
 
     const int signum = tid_stop_info.details.signal.signo;
     if (log) {
       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
                   " tid %" PRIu64
                   " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
                   __FUNCTION__, process.GetID(), tid, signum,
                   tid_stop_info.reason, tid_stop_info.details.exception.type);
     }
 
     JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
     threads_array_sp->AppendObject(thread_obj_sp);
 
     if (!abridged) {
-      if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp))
+      if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread))
         thread_obj_sp->SetObject("registers", registers_sp);
     }
 
     thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
     if (signum != 0)
       thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum));
 
-    const std::string thread_name = thread_sp->GetName();
+    const std::string thread_name = thread->GetName();
     if (!thread_name.empty())
       thread_obj_sp->SetObject("name",
                                std::make_shared<JSONString>(thread_name));
 
     if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
       thread_obj_sp->SetObject("reason",
                                std::make_shared<JSONString>(stop_reason_str));
 
GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(50);
 
   LLDB_LOG(log, "preparing packet for pid {0} tid {1}",
            m_debugged_process_up->GetID(), tid);
 
   // Ensure we can get info on the given thread.
-  NativeThreadProtocolSP thread_sp(m_debugged_process_up->GetThreadByID(tid));
-  if (!thread_sp)
+  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
+  if (!thread)
     return SendErrorResponse(51);
 
   // Grab the reason this thread stopped.
   struct ThreadStopInfo tid_stop_info;
   std::string description;
-  if (!thread_sp->GetStopReason(tid_stop_info, description))
+  if (!thread->GetStopReason(tid_stop_info, description))
     return SendErrorResponse(52);
 
   // FIXME implement register handling for exec'd inferiors.
   // if (tid_stop_info.reason == eStopReasonExec)
   // {
   //     const bool force = true;
   //     InitializeRegisters(force);
   // }
GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
 
   // Print the signal number.
   response.PutHex8(signum & 0xff);
 
   // Include the tid.
   response.Printf("thread:%" PRIx64 ";", tid);
 
   // Include the thread name if there is one.
-  const std::string thread_name = thread_sp->GetName();
+  const std::string thread_name = thread->GetName();
   if (!thread_name.empty()) {
     size_t thread_name_len = thread_name.length();
 
     if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) {
       response.PutCString("name:");
       response.PutCString(thread_name);
     } else {
       // The thread name contains special chars, send as hex bytes.
GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
   // This will save the debugger from having to send a pair of qfThreadInfo
   // and qsThreadInfo packets, but it also might take a lot of room in the
   // stop reply packet, so it must be enabled only on systems where there
   // are no limits on packet lengths.
   if (m_list_threads_in_stop_reply) {
     response.PutCString("threads:");
 
     uint32_t thread_index = 0;
-    NativeThreadProtocolSP listed_thread_sp;
-    for (listed_thread_sp =
-             m_debugged_process_up->GetThreadAtIndex(thread_index);
-         listed_thread_sp; ++thread_index,
-        listed_thread_sp = m_debugged_process_up->GetThreadAtIndex(
-            thread_index)) {
+    NativeThreadProtocol *listed_thread;
+    for (listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
+         listed_thread; ++thread_index,
+        listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
       if (thread_index > 0)
         response.PutChar(',');
-      response.Printf("%" PRIx64, listed_thread_sp->GetID());
+      response.Printf("%" PRIx64, listed_thread->GetID());
     }
     response.PutChar(';');
 
     // Include JSON info that describes the stop reason for any threads
     // that actually have stop reasons. We use the new "jstopinfo" key
     // whose values is hex ascii JSON that contains the thread IDs
     // thread stop info only for threads that have stop reasons. Only send
     // this if we have more than one thread otherwise this packet has all
if (thread_index > 0) {
       } else
         LLDB_LOG(log, "failed to prepare a jstopinfo field for pid {0}",
                  m_debugged_process_up->GetID());
     }
 
     uint32_t i = 0;
     response.PutCString("thread-pcs");
     char delimiter = ':';
-    for (NativeThreadProtocolSP thread_sp;
-         (thread_sp = m_debugged_process_up->GetThreadAtIndex(i)) != nullptr;
+    for (NativeThreadProtocol *thread;
+         (thread = m_debugged_process_up->GetThreadAtIndex(i)) != nullptr;
          ++i) {
-      NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
+      NativeRegisterContextSP reg_ctx_sp = thread->GetRegisterContext();
       if (!reg_ctx_sp)
         continue;
 
       uint32_t reg_to_read = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
       const RegisterInfo *const reg_info_p =
           reg_ctx_sp->GetRegisterInfoAtIndex(reg_to_read);
 
if (m_list_threads_in_stop_reply) {
     response.PutChar(';');
   }
 
   //
   // Expedite registers.
   //
 
   // Grab the register context.
-  NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
+  NativeRegisterContextSP reg_ctx_sp = thread->GetRegisterContext();
   if (reg_ctx_sp) {
     // Expedite all registers in the first register set (i.e. should be GPRs)
     // that are not contained in other registers.
     const RegisterSet *reg_set_p;
     if (reg_ctx_sp->GetRegisterSetCount() > 0 &&
         ((reg_set_p = reg_ctx_sp->GetRegisterSet(0)) != nullptr)) {
       if (log)
         log->Printf("GDBRemoteCommunicationServerLLGS::%s expediting registers "
if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(68);
 
   // Make sure we set the current thread so g and p packets return
   // the data the gdb will expect.
   lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
   SetCurrentThreadID(tid);
 
-  NativeThreadProtocolSP thread_sp = m_debugged_process_up->GetCurrentThread();
-  if (!thread_sp)
+  NativeThreadProtocol *thread = m_debugged_process_up->GetCurrentThread();
+  if (!thread)
     return SendErrorResponse(69);
 
   StreamString response;
-  response.Printf("QC%" PRIx64, thread_sp->GetID());
+  response.Printf("QC%" PRIx64, thread->GetID());
 
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 

 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
   if (!m_debugged_process_up ||
       (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
     return SendErrorResponse(68);
 
   // Ensure we have a thread.
-  NativeThreadProtocolSP thread_sp(m_debugged_process_up->GetThreadAtIndex(0));
-  if (!thread_sp)
+  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0);
+  if (!thread)
     return SendErrorResponse(69);
 
   // Get the register context for the first thread.
-  NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
+  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
   if (!reg_context_sp)
     return SendErrorResponse(69);
 
   // Parse out the register number from the request.
   packet.SetFilePos(strlen("qRegisterInfo"));
   const uint32_t reg_index =
       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
   if (reg_index == std::numeric_limits<uint32_t>::max())
LLDB_LOG(log, "no process ({0}), returning OK",
                                    : "null m_debugged_process_up");
     return SendOKResponse();
   }
 
   StreamGDBRemote response;
   response.PutChar('m');
 
   LLDB_LOG(log, "starting thread iteration");
-  NativeThreadProtocolSP thread_sp;
+  NativeThreadProtocol *thread;
   uint32_t thread_index;
   for (thread_index = 0,
-      thread_sp = m_debugged_process_up->GetThreadAtIndex(thread_index);
-       thread_sp; ++thread_index,
-      thread_sp = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
-    LLDB_LOG(log, "iterated thread {0}({1}, tid={2})", thread_index,
-             thread_sp ? "is not null" : "null",
-             thread_sp ? thread_sp->GetID() : LLDB_INVALID_THREAD_ID);
+      thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
+       thread; ++thread_index,
+      thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
+    LLDB_LOG(log, "iterated thread {0}(tid={2})", thread_index,
+             thread->GetID());
     if (thread_index > 0)
       response.PutChar(',');
-    response.Printf("%" PRIx64, thread_sp->GetID());
+    response.Printf("%" PRIx64, thread->GetID());
   }
 
   LLDB_LOG(log, "finished thread iteration");
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
if (reg_index == std::numeric_limits<uint32_t>::max()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
                   "parse register number from request \"%s\"",
                   __FUNCTION__, packet.GetStringRef().c_str());
     return SendErrorResponse(0x15);
   }
 
   // Get the thread to use.
-  NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
-  if (!thread_sp) {
-    if (log)
-      log->Printf(
-          "GDBRemoteCommunicationServerLLGS::%s failed, no thread available",
-          __FUNCTION__);
+  NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
+  if (!thread) {
+    LLDB_LOG(log, "failed, no thread available");
     return SendErrorResponse(0x15);
   }
 
   // Get the thread's register context.
-  NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
+  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
   if (!reg_context_sp) {
     LLDB_LOG(
         log,
         "pid {0} tid {1} failed, no register context available for the thread",
-        m_debugged_process_up->GetID(), thread_sp->GetID());
+        m_debugged_process_up->GetID(), thread->GetID());
     return SendErrorResponse(0x15);
   }
 
   // Return the end of registers response if we've iterated one past the end of
   // the register set.
   if (reg_index >= reg_context_sp->GetUserRegisterCount()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
if (!m_debugged_process_up ||
     return SendErrorResponse(0x49);
   }
 
   // Parse out the value.
   uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register
   size_t reg_size = packet.GetHexBytesAvail(reg_bytes);
 
   // Get the thread to use.
-  NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
-  if (!thread_sp) {
+  NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
+  if (!thread) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread "
                   "available (thread index 0)",
                   __FUNCTION__);
     return SendErrorResponse(0x28);
   }
 
   // Get the thread's register context.
-  NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
+  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
   if (!reg_context_sp) {
     if (log)
       log->Printf(
           "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64
           " failed, no register context available for the thread",
-          __FUNCTION__, m_debugged_process_up->GetID(), thread_sp->GetID());
+          __FUNCTION__, m_debugged_process_up->GetID(), thread->GetID());
     return SendErrorResponse(0x15);
   }
 
   const RegisterInfo *reg_info =
       reg_context_sp->GetRegisterInfoAtIndex(reg_index);
   if (!reg_info) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) {
   // Parse out the thread number.
   // FIXME return a parse success/fail value.  All values are valid here.
   const lldb::tid_t tid =
       packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max());
 
   // Ensure we have the given thread when not specifying -1 (all threads) or 0
   // (any thread).
   if (tid != LLDB_INVALID_THREAD_ID && tid != 0) {
-    NativeThreadProtocolSP thread_sp(m_debugged_process_up->GetThreadByID(tid));
-    if (!thread_sp) {
+    NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
+    if (!thread) {
       if (log)
         log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64
                     " not found",
                     __FUNCTION__, tid);
       return SendErrorResponse(0x15);
     }
   }
 
GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) {
   lldb::tid_t tid = GetContinueThreadID();
   if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
     tid = GetCurrentThreadID();
   if (tid == LLDB_INVALID_THREAD_ID)
     return SendErrorResponse(0x33);
 
   // Double check that we have such a thread.
   // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
-  NativeThreadProtocolSP thread_sp = m_debugged_process_up->GetThreadByID(tid);
-  if (!thread_sp || thread_sp->GetID() != tid)
+  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
+  if (!thread)
     return SendErrorResponse(0x33);
 
   // Create the step action for the given thread.
   ResumeAction action = {tid, eStateStepping, 0};
 
   // Setup the actions list.
   ResumeActionList actions;
   actions.Append(action);

 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState(
     StringExtractorGDBRemote &packet) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
   // Move past packet name.
   packet.SetFilePos(strlen("QSaveRegisterState"));
 
   // Get the thread to use.
-  NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
-  if (!thread_sp) {
+  NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
+  if (!thread) {
     if (m_thread_suffix_supported)
       return SendIllFormedResponse(
           packet, "No thread specified in QSaveRegisterState packet");
     else
       return SendIllFormedResponse(packet,
                                    "No thread was is set with the Hg packet");
   }
 
   // Grab the register context for the thread.
-  NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
+  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
   if (!reg_context_sp) {
     LLDB_LOG(
         log,
         "pid {0} tid {1} failed, no register context available for the thread",
-        m_debugged_process_up->GetID(), thread_sp->GetID());
+        m_debugged_process_up->GetID(), thread->GetID());
     return SendErrorResponse(0x15);
   }
 
   // Save registers to a buffer.
   DataBufferSP register_data_sp;
   Status error = reg_context_sp->ReadAllRegisterValues(register_data_sp);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} failed to save all register values: {1}",
GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState(
   const uint32_t save_id = packet.GetU32(0);
   if (save_id == 0) {
     LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, "
                   "expecting decimal uint32_t");
     return SendErrorResponse(0x76);
   }
 
   // Get the thread to use.
-  NativeThreadProtocolSP thread_sp = GetThreadFromSuffix(packet);
-  if (!thread_sp) {
+  NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
+  if (!thread) {
     if (m_thread_suffix_supported)
       return SendIllFormedResponse(
           packet, "No thread specified in QRestoreRegisterState packet");
     else
       return SendIllFormedResponse(packet,
                                    "No thread was is set with the Hg packet");
   }
 
   // Grab the register context for the thread.
-  NativeRegisterContextSP reg_context_sp(thread_sp->GetRegisterContext());
+  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
   if (!reg_context_sp) {
     LLDB_LOG(
         log,
         "pid {0} tid {1} failed, no register context available for the thread",
-        m_debugged_process_up->GetID(), thread_sp->GetID());
+        m_debugged_process_up->GetID(), thread->GetID());
     return SendErrorResponse(0x15);
   }
 
   // Retrieve register state buffer, then remove from the list.
   DataBufferSP register_data_sp;
   {
     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
 
if (connection) {
           log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
                       "terminal stdio - FAIL: %s",
                       __FUNCTION__, error.AsCString());
       }
     }
   }
 }
 
-NativeThreadProtocolSP GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix(
+NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix(
     StringExtractorGDBRemote &packet) {
-  NativeThreadProtocolSP thread_sp;
-
   // We have no thread if we don't have a process.
   if (!m_debugged_process_up ||
       m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
-    return thread_sp;
+    return nullptr;
 
   // If the client hasn't asked for thread suffix support, there will not be a
   // thread suffix.
   // Use the current thread in that case.
   if (!m_thread_suffix_supported) {
     const lldb::tid_t current_tid = GetCurrentThreadID();
     if (current_tid == LLDB_INVALID_THREAD_ID)
-      return thread_sp;
+      return nullptr;
     else if (current_tid == 0) {
       // Pick a thread.
       return m_debugged_process_up->GetThreadAtIndex(0);
     } else
       return m_debugged_process_up->GetThreadByID(current_tid);
   }
 
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
   // Parse out the ';'.
   if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
                   "error: expected ';' prior to start of thread suffix: packet "
                   "contents = '%s'",
                   __FUNCTION__, packet.GetStringRef().c_str());
-    return thread_sp;
+    return nullptr;
   }
 
   if (!packet.GetBytesLeft())
-    return thread_sp;
+    return nullptr;
 
   // Parse out thread: portion.
   if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
                   "error: expected 'thread:' but not found, packet contents = "
                   "'%s'",
                   __FUNCTION__, packet.GetStringRef().c_str());
-    return thread_sp;
+    return nullptr;
   }
   packet.SetFilePos(packet.GetFilePos() + strlen("thread:"));
   const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
   if (tid != 0)
     return m_debugged_process_up->GetThreadByID(tid);
 
-  return thread_sp;
+  return nullptr;
 }
 
 lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const {
   if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) {
     // Use whatever the debug process says is the current thread id
     // since the protocol either didn't specify or specified we want
     // any/all threads marked as the current thread.
     if (!m_debugged_process_up)