[NativeProcessLinux] Pass around threads by reference

[labath]

Summary

Most NPL private functions took (shared) pointers to threads as arguments. This meant that the
callee could not be sure if the pointer was valid and so most functions were peppered with
null-checks. Now, I move the check closer to the source, and pass around the threads as
references (which are then assumed to be valid).

[tberghammer]

Looks good (I assume when you dropped const from the argument it was intentional)

source/Plugins/Process/Linux/NativeProcessLinux.h

private:
 
         void
         MonitorCallback(lldb::pid_t pid, bool exited, int signal, int status);
 
         void
         WaitForNewThread(::pid_t tid);
 
         void
-        MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
+        MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread);
 
         void
-        MonitorTrace(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp);
+        MonitorTrace(NativeThreadLinux &thread);
 
         void
-        MonitorBreakpoint(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp);
+        MonitorBreakpoint(NativeThreadLinux &thread);
 
         void
         MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index);
 
         void
-        MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited);
+        MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread, bool exited);
 
         bool
         SupportHardwareSingleStepping() const;
 
         Error
-        SetupSoftwareSingleStepping(NativeThreadProtocolSP thread_sp);
+        SetupSoftwareSingleStepping(NativeThreadLinux &thread);
 
 #if 0
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGSEGV(const siginfo_t *info);
 
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGILL(const siginfo_t *info);
 
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGFPE(const siginfo_t *info);
 
         static ::ProcessMessage::CrashReason
         GetCrashReasonForSIGBUS(const siginfo_t *info);
 #endif
 
         bool
         HasThreadNoLock (lldb::tid_t thread_id);
 
-        NativeThreadProtocolSP
-        MaybeGetThreadNoLock (lldb::tid_t thread_id);
-
         bool
         StopTrackingThread (lldb::tid_t thread_id);
 
         NativeThreadLinuxSP
         AddThread (lldb::tid_t thread_id);
 
         Error
-        GetSoftwareBreakpointPCOffset (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size);
+        GetSoftwareBreakpointPCOffset(uint32_t &actual_opcode_size);
 
         Error
-        FixupBreakpointPCAsNeeded(const NativeThreadLinuxSP &thread_sp);
+        FixupBreakpointPCAsNeeded(NativeThreadLinux &thread);
 
         /// Writes a siginfo_t structure corresponding to the given thread ID to the
         /// memory region pointed to by @p siginfo.
         Error
         GetSignalInfo(lldb::tid_t tid, void *siginfo);
 
         /// Writes the raw event message code (vis-a-vis PTRACE_GETEVENTMSG)
         /// corresponding to the given thread ID to the memory pointed to by @p
#endif
         StopRunningThreads(lldb::tid_t triggering_tid);
 
         // Notify the delegate if all threads have stopped.
         void SignalIfAllThreadsStopped();
 
         // Resume the given thread, optionally passing it the given signal. The type of resume
         // operation (continue, single-step) depends on the state parameter.
         Error
-        ResumeThread(const NativeThreadLinuxSP &thread_sp, lldb::StateType state, int signo);
+        ResumeThread(NativeThreadLinux &thread, lldb::StateType state, int signo);
 
         void
         ThreadWasCreated(NativeThreadLinux &thread);
 
         void
         SigchldHandler();
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (exited)
             // thread exit, we would already have received the SIGTRAP | (PTRACE_EVENT_EXIT << 8) signal,
             // and we would have done an all-stop then.
             if (log)
                 log->Printf ("NativeProcessLinux::%s() tid = %"  PRIu64 " handling non-main thread exit (%s)", __FUNCTION__, pid, thread_found ? "stopped tracking thread metadata" : "thread metadata not found");
         }
         return;
     }
 
-    // Get details on the signal raised.
     siginfo_t info;
-    const auto err = GetSignalInfo(pid, &info);
-    if (err.Success())
+    const auto info_err = GetSignalInfo(pid, &info);
+    auto thread_sp = GetThreadByID(pid);
+
+    if (! thread_sp)
+    {
+        // Normally, the only situation when we cannot find the thread is if we have just
+        // received a new thread notification. This is indicated by GetSignalInfo() returning
+        // si_code == SI_USER and si_pid == 0
+        if (log)
+            log->Printf("NativeProcessLinux::%s received notification about an unknown tid %" PRIu64 ".", __FUNCTION__, pid);
+
+        if (info_err.Fail())
+        {
+            if (log)
+                log->Printf("NativeProcessLinux::%s (tid %" PRIu64 ") GetSignalInfo failed (%s). Ingoring this notification.", __FUNCTION__, pid, info_err.AsCString());
+            return;
+        }
+
+        if (log && (info.si_code != SI_USER || info.si_pid != 0))
+            log->Printf("NativeProcessLinux::%s (tid %" PRIu64 ") unexpected signal info (si_code: %d, si_pid: %d). Treating as a new thread notification anyway.", __FUNCTION__, pid, info.si_code, info.si_pid);
+
+        auto thread_sp = AddThread(pid);
+        // Resume the newly created thread.
+        ResumeThread(*thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
+        ThreadWasCreated(*thread_sp);
+        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, pid);
+            MonitorSIGTRAP(info, *thread_sp);
         else
-            MonitorSignal(&info, pid, exited);
+            MonitorSignal(info, *thread_sp, exited);
     }
     else
     {
-        if (err.GetError() == EINVAL)
+        if (info_err.GetError() == EINVAL)
         {
             // This is a group stop reception for this tid.
             // We can reach here if we reinject SIGSTOP, SIGSTP, SIGTTIN or SIGTTOU into the
             // tracee, triggering the group-stop mechanism. Normally receiving these would stop
             // the process, pending a SIGCONT. Simulating this state in a debugger is hard and is
             // generally not needed (one use case is debugging background task being managed by a
             // shell). For general use, it is sufficient to stop the process in a signal-delivery
             // stop which happens before the group stop. This done by MonitorSignal and works
             // correctly for all signals.
             if (log)
                 log->Printf("NativeProcessLinux::%s received a group stop for pid %" PRIu64 " tid %" PRIu64 ". Transparent handling of group stops not supported, resuming the thread.", __FUNCTION__, GetID (), pid);
-            Resume(pid, signal);
+            ResumeThread(*thread_sp, thread_sp->GetState(), LLDB_INVALID_SIGNAL_NUMBER);
         }
         else
         {
             // ptrace(GETSIGINFO) failed (but not due to group-stop).
 
             // A return value of ESRCH means the thread/process is no longer on the system,
             // so it was killed somehow outside of our control.  Either way, we can't do anything
             // with it anymore.
 
             // Stop tracking the metadata for the thread since it's entirely off the system now.
             const bool thread_found = StopTrackingThread (pid);
 
             if (log)
                 log->Printf ("NativeProcessLinux::%s GetSignalInfo failed: %s, tid = %" PRIu64 ", signal = %d, status = %d (%s, %s, %s)",
-                             __FUNCTION__, err.AsCString(), pid, signal, status, err.GetError() == ESRCH ? "thread/process killed" : "unknown reason", is_main_thread ? "is main thread" : "is not main thread", thread_found ? "thread metadata removed" : "thread metadata not found");
+                             __FUNCTION__, info_err.AsCString(), pid, signal, status, info_err.GetError() == ESRCH ? "thread/process killed" : "unknown reason", is_main_thread ? "is main thread" : "is not main thread", thread_found ? "thread metadata removed" : "thread metadata not found");
 
             if (is_main_thread)
             {
                 // Notify the delegate - our process is not available but appears to have been killed outside
                 // our control.  Is eStateExited the right exit state in this case?
                 SetExitStatus (convert_pid_status_to_exit_type (status), convert_pid_status_to_return_code (status), nullptr, true);
                 SetState (StateType::eStateExited, true);
             }
if (((info.si_pid != 0) || (info.si_code != SI_USER)) && log)
         log->Printf ("NativeProcessLinux::%s() GetSignalInfo for tid %" PRIu32 " received unexpected signal with code %d from pid %d.", __FUNCTION__, tid, info.si_code, info.si_pid);
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 ": tracking new thread tid %" PRIu32,
                  __FUNCTION__, GetID (), tid);
 
     new_thread_sp = AddThread(tid);
-    ResumeThread(new_thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
+    ResumeThread(*new_thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
     ThreadWasCreated(*new_thread_sp);
 }
 
 void
-NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
+NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
-    const bool is_main_thread = (pid == GetID ());
+    const bool is_main_thread = (thread.GetID() == GetID ());
 
-    assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
-    if (!info)
-        return;
+    assert(info.si_signo == SIGTRAP && "Unexpected child signal!");
 
     Mutex::Locker locker (m_threads_mutex);
 
-    // See if we can find a thread for this signal.
-    NativeThreadLinuxSP thread_sp = GetThreadByID(pid);
-    if (!thread_sp)
-    {
-        if (log)
-            log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " no thread found for tid %" PRIu64, __FUNCTION__, GetID (), pid);
-    }
-
-    switch (info->si_code)
+    switch (info.si_code)
     {
     // TODO: these two cases are required if we want to support tracing of the inferiors' children.  We'd need this to debug a monitor.
     // case (SIGTRAP | (PTRACE_EVENT_FORK << 8)):
     // case (SIGTRAP | (PTRACE_EVENT_VFORK << 8)):
 
     case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)):
     {
         // This is the notification on the parent thread which informs us of new thread
         // creation.
         // We don't want to do anything with the parent thread so we just resume it. In case we
         // want to implement "break on thread creation" functionality, we would need to stop
         // here.
 
         unsigned long event_message = 0;
-        if (GetEventMessage (pid, &event_message).Fail())
+        if (GetEventMessage(thread.GetID(), &event_message).Fail())
         {
             if (log)
-                log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " received thread creation event but GetEventMessage failed so we don't know the new tid", __FUNCTION__, pid);
+                log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " received thread creation event but GetEventMessage failed so we don't know the new tid", __FUNCTION__, thread.GetID());
         } else 
             WaitForNewThread(event_message);
 
-        ResumeThread(thread_sp, thread_sp->GetState(), LLDB_INVALID_SIGNAL_NUMBER);
+        ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
     {
         NativeThreadLinuxSP main_thread_sp;
         if (log)
-            log->Printf ("NativeProcessLinux::%s() received exec event, code = %d", __FUNCTION__, info->si_code ^ SIGTRAP);
+            log->Printf ("NativeProcessLinux::%s() received exec event, code = %d", __FUNCTION__, 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.  Mutexes are in undefined state.
         if (log)
             log->Printf ("NativeProcessLinux::%s exec received, stop tracking all but main thread", __FUNCTION__);
 
case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
             SetCurrentThreadID (LLDB_INVALID_THREAD_ID);
             if (log)
                 log->Printf ("NativeProcessLinux::%s pid %" PRIu64 "no main thread found, discarded all threads, we're in a no-thread state!", __FUNCTION__, GetID ());
         }
 
         // Tell coordinator about about the "new" (since exec) stopped main thread.
         ThreadWasCreated(*main_thread_sp);
 
-        // NOTE: ideally these next statements would execute at the same time as the coordinator thread create was executed.
-        // Consider a handler that can execute when that happens.
         // 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 (pid);
+        StopRunningThreads(main_thread_sp->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
         // want to implement "break on thread exit" functionality, we would need to stop
         // here.
 
         unsigned long data = 0;
-        if (GetEventMessage(pid, &data).Fail())
+        if (GetEventMessage(thread.GetID(), &data).Fail())
             data = -1;
 
         if (log)
         {
             log->Printf ("NativeProcessLinux::%s() received PTRACE_EVENT_EXIT, data = %lx (WIFEXITED=%s,WIFSIGNALED=%s), pid = %" PRIu64 " (%s)",
                          __FUNCTION__,
                          data, WIFEXITED (data) ? "true" : "false", WIFSIGNALED (data) ? "true" : "false",
-                         pid,
+                         thread.GetID(),
                     is_main_thread ? "is main thread" : "not main thread");
         }
 
         if (is_main_thread)
         {
             SetExitStatus (convert_pid_status_to_exit_type (data), convert_pid_status_to_return_code (data), nullptr, true);
         }
 
-        ResumeThread(thread_sp, thread_sp->GetState(), LLDB_INVALID_SIGNAL_NUMBER);
+        ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
 
         break;
     }
 
     case 0:
     case TRAP_TRACE:  // We receive this on single stepping.
     case TRAP_HWBKPT: // We receive this on watchpoint hit
-        if (thread_sp)
-        {
-            // If a watchpoint was hit, report it
-            uint32_t wp_index;
-            Error error = thread_sp->GetRegisterContext()->GetWatchpointHitIndex(wp_index, (lldb::addr_t)info->si_addr);
-            if (error.Fail() && log)
-                log->Printf("NativeProcessLinux::%s() "
-                            "received error while checking for watchpoint hits, "
-                            "pid = %" PRIu64 " error = %s",
-                            __FUNCTION__, pid, error.AsCString());
-            if (wp_index != LLDB_INVALID_INDEX32)
-            {
-                MonitorWatchpoint(*thread_sp, wp_index);
-                break;
-            }
-        }
+        Error error = thread.GetRegisterContext()->GetWatchpointHitIndex(wp_index, (lldb::addr_t)info.si_addr);
+                        __FUNCTION__, thread.GetID(), error.AsCString());
+            MonitorWatchpoint(thread, wp_index);
+
         // Otherwise, report step over
-        MonitorTrace(pid, thread_sp);
+        MonitorTrace(thread);
         break;
+    }
 
     case SI_KERNEL:
 #if defined __mips__
         // For mips there is no special signal for watchpoint
         // So we check for watchpoint in kernel trap
-        if (thread_sp)
-        {
-            // If a watchpoint was hit, report it
-            uint32_t wp_index;
-            Error error = thread_sp->GetRegisterContext()->GetWatchpointHitIndex(wp_index, LLDB_INVALID_ADDRESS);
-            if (error.Fail() && log)
-                log->Printf("NativeProcessLinux::%s() "
-                            "received error while checking for watchpoint hits, "
-                            "pid = %" PRIu64 " error = %s",
-                            __FUNCTION__, pid, error.AsCString());
-            if (wp_index != LLDB_INVALID_INDEX32)
-            {
-                MonitorWatchpoint(*thread_sp, wp_index);
-                break;
-            }
-        }
+        Error error = thread.GetRegisterContext()->GetWatchpointHitIndex(wp_index, LLDB_INVALID_ADDRESS);
+            MonitorWatchpoint(thread, wp_index);
         // NO BREAK
 #endif
     case TRAP_BRKPT:
-        MonitorBreakpoint(pid, thread_sp);
+        MonitorBreakpoint(thread);
         break;
 
     case SIGTRAP:
     case (SIGTRAP | 0x80):
         if (log)
-            log->Printf ("NativeProcessLinux::%s() received unknown SIGTRAP system call stop event, pid %" PRIu64 "tid %" PRIu64 ", resuming", __FUNCTION__, GetID (), pid);
+            log->Printf ("NativeProcessLinux::%s() received unknown SIGTRAP system call stop event, pid %" PRIu64 "tid %" PRIu64 ", resuming", __FUNCTION__, GetID (), thread.GetID());
 
         // Ignore these signals until we know more about them.
-        ResumeThread(thread_sp, thread_sp->GetState(), LLDB_INVALID_SIGNAL_NUMBER);
+        ResumeThread(thread, thread.GetState(), LLDB_INVALID_SIGNAL_NUMBER);
         break;
 
     default:
         assert(false && "Unexpected SIGTRAP code!");
         if (log)
             log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 "tid %" PRIu64 " received unhandled SIGTRAP code: 0x%d",
-                    __FUNCTION__, GetID (), pid, info->si_code);
+                    __FUNCTION__, GetID(), thread.GetID(), info.si_code);
         break;
         
     }
 }
 
 void
-NativeProcessLinux::MonitorTrace(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp)
+NativeProcessLinux::MonitorTrace(NativeThreadLinux &thread)
 {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received trace event, pid = %" PRIu64 " (single stepping)",
-                __FUNCTION__, pid);
+                __FUNCTION__, thread.GetID());
 
     // This thread is currently stopped.
-    if (thread_sp)
-        thread_sp->SetStoppedByTrace();
+    thread.SetStoppedByTrace();
 
-    // Here we don't have to request the rest of the threads to stop or request a deferred stop.
-    // This would have already happened at the time the Resume() with step operation was signaled.
-    // At this point, we just need to say we stopped, and the deferred notifcation will fire off
-    // once all running threads have checked in as stopped.
-    SetCurrentThreadID(pid);
-    // Tell the process we have a stop (from software breakpoint).
-    StopRunningThreads(pid);
+    StopRunningThreads(thread.GetID());
 }
 
 void
-NativeProcessLinux::MonitorBreakpoint(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp)
+NativeProcessLinux::MonitorBreakpoint(NativeThreadLinux &thread)
 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_BREAKPOINTS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received breakpoint event, pid = %" PRIu64,
-                __FUNCTION__, pid);
+                __FUNCTION__, thread.GetID());
 
     // Mark the thread as stopped at breakpoint.
-    if (thread_sp)
-    {
-        thread_sp->SetStoppedByBreakpoint();
-        Error error = FixupBreakpointPCAsNeeded(thread_sp);
-        if (error.Fail())
-            if (log)
-                log->Printf("NativeProcessLinux::%s() pid = %" PRIu64 " fixup: %s",
-                        __FUNCTION__, pid, error.AsCString());
+    thread.SetStoppedByBreakpoint();
+    Error error = FixupBreakpointPCAsNeeded(thread);
+                    __FUNCTION__, thread.GetID(), error.AsCString());
 
-        if (m_threads_stepping_with_breakpoint.find(pid) != m_threads_stepping_with_breakpoint.end())
-            thread_sp->SetStoppedByTrace();
-    }
-    else
-        if (log)
-            log->Printf("NativeProcessLinux::%s()  pid = %" PRIu64 ": "
-                    "warning, cannot process software breakpoint since no thread metadata",
-                    __FUNCTION__, pid);
+    if (m_threads_stepping_with_breakpoint.find(thread.GetID()) != m_threads_stepping_with_breakpoint.end())
+        thread.SetStoppedByTrace();
 
-
-    // We need to tell all other running threads before we notify the delegate about this stop.
-    StopRunningThreads(pid);
+    StopRunningThreads(thread.GetID());
 }
 
 void
 NativeProcessLinux::MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index)
 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_WATCHPOINTS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received watchpoint event, "
                     "pid = %" PRIu64 ", wp_index = %" PRIu32,
                     __FUNCTION__, thread.GetID(), wp_index);
 
     // Mark the thread as stopped at watchpoint.
     // The address is at (lldb::addr_t)info->si_addr if we need it.
     thread.SetStoppedByWatchpoint(wp_index);
 
     // We need to tell all other running threads before we notify the delegate about this stop.
     StopRunningThreads(thread.GetID());
 }
 
 void
-NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
+NativeProcessLinux::MonitorSignal(const siginfo_t &info, NativeThreadLinux &thread, bool exited)
 {
-    assert (info && "null info");
-    if (!info)
-        return;
-
-    const int signo = info->si_signo;
-    const bool is_from_llgs = info->si_pid == getpid ();
+    const int signo = info.si_signo;
+    const bool is_from_llgs = info.si_pid == getpid ();
 
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     // POSIX says that process behaviour is undefined after it ignores a SIGFPE,
     // SIGILL, SIGSEGV, or SIGBUS *unless* that signal was generated by a
     // kill(2) or raise(3).  Similarly for tgkill(2) on Linux.
     //
     // IOW, user generated signals never generate what we consider to be a
     // "crash".
     //
     // Similarly, ACK signals generated by this monitor.
 
     Mutex::Locker locker (m_threads_mutex);
 
-    // See if we can find a thread for this signal.
-    NativeThreadLinuxSP thread_sp = GetThreadByID(pid);
-    if (!thread_sp)
-    {
-        if (log)
-            log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " no thread found for tid %" PRIu64, __FUNCTION__, GetID (), pid);
-    }
-
     // Handle the signal.
-    if (info->si_code == SI_TKILL || info->si_code == SI_USER)
+    if (info.si_code == SI_TKILL || info.si_code == SI_USER)
     {
         if (log)
             log->Printf ("NativeProcessLinux::%s() received signal %s (%d) with code %s, (siginfo pid = %d (%s), waitpid pid = %" PRIu64 ")",
                             __FUNCTION__,
                             Host::GetSignalAsCString(signo),
                             signo,
-                            (info->si_code == SI_TKILL ? "SI_TKILL" : "SI_USER"),
-                            info->si_pid,
+                            (info.si_code == SI_TKILL ? "SI_TKILL" : "SI_USER"),
+                            info.si_pid,
                             is_from_llgs ? "from llgs" : "not from llgs",
-                            pid);
-    }
-
-    // Check for new thread notification.
-    if ((info->si_pid == 0) && (info->si_code == SI_USER))
-    {
-        // A new thread creation is being signaled. This is one of two parts that come in
-        // a non-deterministic order. This code handles the case where the new thread event comes
-        // before the event on the parent thread. For the opposite case see code in
-        // MonitorSIGTRAP.
-        if (log)
-            log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " tid %" PRIu64 ": new thread notification",
-                     __FUNCTION__, GetID (), pid);
-
-        thread_sp = AddThread(pid);
-        assert (thread_sp.get() && "failed to create the tracking data for newly created inferior thread");
-        // We can now resume the newly created thread.
-        ResumeThread(thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
-        ThreadWasCreated(*thread_sp);
-        // Done handling.
-        return;
+                            thread.GetID());
     }
 
     // Check for thread stop notification.
-    if (is_from_llgs && (info->si_code == SI_TKILL) && (signo == SIGSTOP))
+    if (is_from_llgs && (info.si_code == SI_TKILL) && (signo == SIGSTOP))
     {
         // This is a tgkill()-based stop.
-        if (thread_sp)
-        {
-            if (log)
-                log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ", thread stopped",
-                             __FUNCTION__,
-                             GetID (),
-                             pid);
+                         thread.GetID());
 
-            // Check that we're not already marked with a stop reason.
-            // Note this thread really shouldn't already be marked as stopped - if we were, that would imply that
-            // the kernel signaled us with the thread stopping which we handled and marked as stopped,
-            // and that, without an intervening resume, we received another stop.  It is more likely
-            // that we are missing the marking of a run state somewhere if we find that the thread was
-            // marked as stopped.
-            const StateType thread_state = thread_sp->GetState();
-            if (!StateIsStoppedState (thread_state, false))
-            {
-                // An inferior thread has stopped because of a SIGSTOP we have sent it.
-                // Generally, these are not important stops and we don't want to report them as
-                // they are just used to stop other threads when one thread (the one with the
-                // *real* stop reason) hits a breakpoint (watchpoint, etc...). However, in the
-                // case of an asynchronous Interrupt(), this *is* the real stop reason, so we
-                // leave the signal intact if this is the thread that was chosen as the
-                // triggering thread.
-                if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID)
-                {
-                    if (m_pending_notification_tid == pid)
-                        thread_sp->SetStoppedBySignal(SIGSTOP, info);
-                    else
-                        thread_sp->SetStoppedWithNoReason();
+        const StateType thread_state = thread.GetState();
+                if (m_pending_notification_tid == thread.GetID())
+                    thread.SetStoppedBySignal(SIGSTOP, &info);
+                    thread.SetStoppedWithNoReason();
 
-                    SetCurrentThreadID (thread_sp->GetID ());
-                    SignalIfAllThreadsStopped();
-                }
-                else
-                {
-                    // We can end up here if stop was initiated by LLGS but by this time a
-                    // thread stop has occurred - maybe initiated by another event.
-                    Error error = ResumeThread(thread_sp, thread_sp->GetState(), 0);
-                    if (error.Fail() && log)
-                    {
-                        log->Printf("NativeProcessLinux::%s failed to resume thread tid  %" PRIu64 ": %s",
-                                __FUNCTION__, thread_sp->GetID(), error.AsCString());
-                    }
-                }
-            }
-            else
-            {
-                if (log)
-                {
-                    // Retrieve the signal name if the thread was stopped by a signal.
-                    int stop_signo = 0;
-                    const bool stopped_by_signal = thread_sp->IsStopped(&stop_signo);
-                    const char *signal_name = stopped_by_signal ? Host::GetSignalAsCString(stop_signo) : "<not stopped by signal>";
-                    if (!signal_name)
-                        signal_name = "<no-signal-name>";
+                SetCurrentThreadID (thread.GetID ());
+                Error error = ResumeThread(thread, thread.GetState(), 0);
+                            __FUNCTION__, thread.GetID(), error.AsCString());
+                const bool stopped_by_signal = thread.IsStopped(&stop_signo);
 
-                    log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 " tid %" PRIu64 ", thread was already marked as a stopped state (state=%s, signal=%d (%s)), leaving stop signal as is",
-                                 __FUNCTION__,
-                                 GetID (),
-                                 thread_sp->GetID(),
-                                 StateAsCString (thread_state),
-                                 stop_signo,
-                                 signal_name);
-                }
-                SignalIfAllThreadsStopped();
-            }
-        }
+                             thread.GetID(),
 
         // Done handling.
         return;
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, Host::GetSignalAsCString(signo));
 
     // This thread is stopped.
-    if (thread_sp)
-        thread_sp->SetStoppedBySignal(signo, info);
+    thread.SetStoppedBySignal(signo, &info);
 
     // Send a stop to the debugger after we get all other threads to stop.
-    StopRunningThreads (pid);
+    StopRunningThreads(thread.GetID());
 }
 
 namespace {
 
 struct EmulatorBaton
 {
     NativeProcessLinux* m_process;
     NativeRegisterContext* m_reg_context;

 ReadFlags (NativeRegisterContext* regsiter_context)
 {
     const RegisterInfo* flags_info = regsiter_context->GetRegisterInfo(
             eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
     return regsiter_context->ReadRegisterAsUnsigned(flags_info, LLDB_INVALID_ADDRESS);
 }
 
 Error
-NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadProtocolSP thread_sp)
+NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadLinux &thread)
 {
     Error error;
-    NativeRegisterContextSP register_context_sp = thread_sp->GetRegisterContext();
+    NativeRegisterContextSP register_context_sp = thread.GetRegisterContext();
 
     std::unique_ptr<EmulateInstruction> emulator_ap(
         EmulateInstruction::FindPlugin(m_arch, eInstructionTypePCModifying, nullptr));
 
     if (emulator_ap == nullptr)
         return Error("Instruction emulator not found!");
 
     EmulatorBaton baton(this, register_context_sp.get());
NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadLinux &thread)
     {
         // No size hint is given for the next breakpoint
         error = SetSoftwareBreakpoint(next_pc, 0);
     }
 
     if (error.Fail())
         return error;
 
-    m_threads_stepping_with_breakpoint.insert({thread_sp->GetID(), next_pc});
+    m_threads_stepping_with_breakpoint.insert({thread.GetID(), next_pc});
 
     return Error();
 }
 
 bool
 NativeProcessLinux::SupportHardwareSingleStepping() const
 {
     if (m_arch.GetMachine() == llvm::Triple::arm
if (software_single_step)
             assert (thread_sp && "thread list should not contain NULL threads");
 
             const ResumeAction *const action = resume_actions.GetActionForThread (thread_sp->GetID (), true);
             if (action == nullptr)
                 continue;
 
             if (action->state == eStateStepping)
             {
-                Error error = SetupSoftwareSingleStepping(thread_sp);
+                Error error = SetupSoftwareSingleStepping(static_cast<NativeThreadLinux &>(*thread_sp));
                 if (error.Fail())
                     return error;
             }
         }
     }
 
     for (auto thread_sp : m_threads)
     {
for (auto thread_sp : m_threads)
 
         switch (action->state)
         {
         case eStateRunning:
         case eStateStepping:
         {
             // Run the thread, possibly feeding it the signal.
             const int signo = action->signal;
-            ResumeThread(std::static_pointer_cast<NativeThreadLinux>(thread_sp), action->state, signo);
+            ResumeThread(static_cast<NativeThreadLinux &>(*thread_sp), action->state, signo);
             break;
         }
 
         case eStateSuspended:
         case eStateStopped:
             lldbassert(0 && "Unexpected state");
 
         default:

 bool
 NativeProcessLinux::GetArchitecture (ArchSpec &arch) const
 {
     arch = m_arch;
     return true;
 }
 
 Error
-NativeProcessLinux::GetSoftwareBreakpointPCOffset (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size)
+NativeProcessLinux::GetSoftwareBreakpointPCOffset(uint32_t &actual_opcode_size)
 {
     // FIXME put this behind a breakpoint protocol class that can be
     // set per architecture.  Need ARM, MIPS support here.
     static const uint8_t g_i386_opcode [] = { 0xCC };
 
     switch (m_arch.GetMachine ())
     {
         case llvm::Triple::x86:
for (auto thread_sp : m_threads)
             return true;
         }
     }
 
     // We don't have this thread.
     return false;
 }
 
-NativeThreadProtocolSP
-NativeProcessLinux::MaybeGetThreadNoLock (lldb::tid_t thread_id)
-{
-    // CONSIDER organize threads by map - we can do better than linear.
-    for (auto thread_sp : m_threads)
-    {
-        if (thread_sp->GetID () == thread_id)
-            return thread_sp;
-    }
-
-    // We don't have this thread.
-    return NativeThreadProtocolSP ();
-}
-
 bool
 NativeProcessLinux::StopTrackingThread (lldb::tid_t thread_id)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
 
     if (log)
         log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")", __FUNCTION__, thread_id);
 
if (m_threads.empty ())
         SetCurrentThreadID (thread_id);
 
     auto thread_sp = std::make_shared<NativeThreadLinux>(this, thread_id);
     m_threads.push_back (thread_sp);
     return thread_sp;
 }
 
 Error
-NativeProcessLinux::FixupBreakpointPCAsNeeded(const NativeThreadLinuxSP &thread_sp)
+NativeProcessLinux::FixupBreakpointPCAsNeeded(NativeThreadLinux &thread)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 
     Error error;
 
-    if (!thread_sp)
-    {
-        error.SetErrorString ("null thread_sp");
-        if (log)
-            log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ());
-        return error;
-    }
-
     // Find out the size of a breakpoint (might depend on where we are in the code).
-    NativeRegisterContextSP context_sp = thread_sp->GetRegisterContext();
+    NativeRegisterContextSP context_sp = thread.GetRegisterContext();
     if (!context_sp)
     {
         error.SetErrorString ("cannot get a NativeRegisterContext for the thread");
         if (log)
             log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ());
         return error;
     }
 
     uint32_t breakpoint_size = 0;
-    error = GetSoftwareBreakpointPCOffset (context_sp, breakpoint_size);
+    error = GetSoftwareBreakpointPCOffset(breakpoint_size);
     if (error.Fail ())
     {
         if (log)
             log->Printf ("NativeProcessLinux::%s GetBreakpointSize() failed: %s", __FUNCTION__, error.AsCString ());
         return error;
     }
     else
     {
if (breakpoint_size == 0)
         // Nothing to do!  How did we get here?
         if (log)
             log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " breakpoint found at 0x%" PRIx64 ", it is software, but the size is zero, nothing to do (unexpected)", __FUNCTION__, GetID (), breakpoint_addr);
         return Error ();
     }
 
     // Change the program counter.
     if (log)
-        log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": changing PC from 0x%" PRIx64 " to 0x%" PRIx64, __FUNCTION__, GetID(), thread_sp->GetID(), initial_pc_addr, breakpoint_addr);
+        log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": changing PC from 0x%" PRIx64 " to 0x%" PRIx64, __FUNCTION__, GetID(), thread.GetID(), initial_pc_addr, breakpoint_addr);
 
     error = context_sp->SetPC (breakpoint_addr);
     if (error.Fail ())
     {
         if (log)
-            log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": failed to set PC: %s", __FUNCTION__, GetID(), thread_sp->GetID(), error.AsCString ());
+            log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": failed to set PC: %s", __FUNCTION__, GetID(), thread.GetID(), error.AsCString ());
         return error;
     }
 
     return error;
 }
 
 Error
 NativeProcessLinux::GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec)

 
 NativeThreadLinuxSP
 NativeProcessLinux::GetThreadByID(lldb::tid_t tid)
 {
     return std::static_pointer_cast<NativeThreadLinux>(NativeProcessProtocol::GetThreadByID(tid));
 }
 
 Error
-NativeProcessLinux::ResumeThread(const NativeThreadLinuxSP &thread_sp, lldb::StateType state, int signo)
+NativeProcessLinux::ResumeThread(NativeThreadLinux &thread, lldb::StateType state, int signo)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
 
     if (log)
         log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")",
-                __FUNCTION__, thread_sp->GetID());
+                __FUNCTION__, thread.GetID());
     
     // Before we do the resume below, first check if we have a pending
     // stop notification that is currently waiting for
     // all threads to stop.  This is potentially a buggy situation since
     // we're ostensibly waiting for threads to stop before we send out the
     // pending notification, and here we are resuming one before we send
     // out the pending stop notification.
     if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID && log)
     {
-        log->Printf("NativeProcessLinux::%s about to resume tid %" PRIu64 " per explicit request but we have a pending stop notification (tid %" PRIu64 ") that is actively waiting for this thread to stop. Valid sequence of events?", __FUNCTION__, thread_sp->GetID(), m_pending_notification_tid);
+        log->Printf("NativeProcessLinux::%s about to resume tid %" PRIu64 " per explicit request but we have a pending stop notification (tid %" PRIu64 ") that is actively waiting for this thread to stop. Valid sequence of events?", __FUNCTION__, thread.GetID(), m_pending_notification_tid);
     }
 
     // Request a resume.  We expect this to be synchronous and the system
     // to reflect it is running after this completes.
     switch (state)
     {
     case eStateRunning:
     {
-        thread_sp->SetRunning();
-        const auto resume_result = Resume(thread_sp->GetID(), signo);
+        thread.SetRunning();
+        const auto resume_result = Resume(thread.GetID(), signo);
         if (resume_result.Success())
             SetState(eStateRunning, true);
         return resume_result;
     }
     case eStateStepping:
     {
-        thread_sp->SetStepping();
-        const auto step_result = SingleStep(thread_sp->GetID(), signo);
+        thread.SetStepping();
+        const auto step_result = SingleStep(thread.GetID(), signo);
         if (step_result.Success())
             SetState(eStateRunning, true);
         return step_result;
     }
     default:
         if (log)
             log->Printf("NativeProcessLinux::%s Unhandled state %s.",
                     __FUNCTION__, StateAsCString(state));