[NativeProcessLinux] Reduce the number of casts

[labath]

Summary

NPL used to be peppered with casts of the NativeThreadProtocol objects into NativeThreadLinux. I
move these closer to the source where we obtain these objects. This way, the rest of the code can
assume we are working with the correct type of objects.

[tberghammer]

Looks good.

One inconsistency what might worth a change is that you usually pass NPL as a shared_ptr (or a reference to a shared_ptr) but you created a few function where it isn't true (e.g. ThreadWasCreated). I would prefer to always pass it by shared_ptr (possibly as a reference) for consistency.

[ovyalov]

LGTM

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2834 ↗

(On Diff #32673)

You may use std::make_shared

[labath]

Passing around pointers (shared or otherwise) encourages people to litter the code with null pointer checks. For the next cleanup, I would like to move these checks to a single place and then convert more of these functions to take references.

[tberghammer]

Thanks for the info about the plans. If you plan to move to this direction then it make sense to leave these functions with reference arguments.

Side note: Why we use a shared_ptr for NTL? I would expect a unique_ptr would be sufficient in NPL (or possibly a store by value with move constructors).

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

public:
         DoStopIDBumped (uint32_t newBumpId) override;
 
         Error
         GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec) override;
 
         Error
         GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr) override;
 
+        NativeThreadLinuxSP
+        GetThreadByID(lldb::tid_t id);
+
         // ---------------------------------------------------------------------
         // Interface used by NativeRegisterContext-derived classes.
         // ---------------------------------------------------------------------
         static Error
         PtraceWrapper(int req,
                       lldb::pid_t pid,
                       void *addr = nullptr,
                       void *data = nullptr,
private:
 
         void
         WaitForNewThread(::pid_t tid);
 
         void
         MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid);
 
         void
-        MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
+        MonitorTrace(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp);
 
         void
-        MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp);
+        MonitorBreakpoint(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp);
 
         void
-        MonitorWatchpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp, uint32_t wp_index);
+        MonitorWatchpoint(NativeThreadLinux &thread, uint32_t wp_index);
 
         void
         MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited);
 
         bool
         SupportHardwareSingleStepping() const;
 
         Error
#endif
         HasThreadNoLock (lldb::tid_t thread_id);
 
         NativeThreadProtocolSP
         MaybeGetThreadNoLock (lldb::tid_t thread_id);
 
         bool
         StopTrackingThread (lldb::tid_t thread_id);
 
-        NativeThreadProtocolSP
+        NativeThreadLinuxSP
         AddThread (lldb::tid_t thread_id);
 
         Error
         GetSoftwareBreakpointPCOffset (NativeRegisterContextSP context_sp, uint32_t &actual_opcode_size);
 
         Error
-        FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp);
+        FixupBreakpointPCAsNeeded(const NativeThreadLinuxSP &thread_sp);
 
         /// 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
         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);
 
         void
-        ThreadWasCreated (lldb::tid_t tid);
+        ThreadWasCreated(NativeThreadLinux &thread);
 
         void
         SigchldHandler();
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeProcessLinux_H_

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

NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
     const char **argv = args->m_argv;
     const char **envp = args->m_envp;
     const FileSpec working_dir = args->m_working_dir;
 
     lldb_utility::PseudoTerminal terminal;
     const size_t err_len = 1024;
     char err_str[err_len];
     lldb::pid_t pid;
-    NativeThreadProtocolSP thread_sp;
-
-    lldb::ThreadSP inferior;
 
     // Propagate the environment if one is not supplied.
     if (envp == NULL || envp[0] == NULL)
         envp = const_cast<const char **>(environ);
 
     if ((pid = terminal.Fork(err_str, err_len)) == static_cast<lldb::pid_t> (-1))
     {
         error.SetErrorToGenericError();
if (error.Fail())
         SetState (StateType::eStateInvalid);
 
         return -1;
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() adding pid = %" PRIu64, __FUNCTION__, pid);
 
-    thread_sp = AddThread (pid);
+    NativeThreadLinuxSP thread_sp = AddThread(pid);
     assert (thread_sp && "AddThread() returned a nullptr thread");
-    std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGSTOP);
-    ThreadWasCreated(pid);
+    thread_sp->SetStoppedBySignal(SIGSTOP);
+    ThreadWasCreated(*thread_sp);
 
     // Let our process instance know the thread has stopped.
     SetCurrentThreadID (thread_sp->GetID ());
     SetState (StateType::eStateStopped);
 
     if (log)
     {
         if (error.Success ())
         {
             log->Printf ("NativeProcessLinux::%s inferior launching succeeded", __FUNCTION__);
         }
         else
         {
             log->Printf ("NativeProcessLinux::%s inferior launching failed: %s",
                 __FUNCTION__, error.AsCString ());
             return -1;
         }
     }
     return pid;
 }
 
 ::pid_t
 NativeProcessLinux::Attach(lldb::pid_t pid, Error &error)
 {
-    lldb::ThreadSP inferior;
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
     // Use a map to keep track of the threads which we have attached/need to attach.
     Host::TidMap tids_to_attach;
     if (pid <= 1)
     {
         error.SetErrorToGenericError();
         error.SetErrorString("Attaching to process 1 is not allowed.");
while (Host::FindProcessThreads(pid, tids_to_attach))
                     return -1;
 
                 if (log)
                     log->Printf ("NativeProcessLinux::%s() adding tid = %" PRIu64, __FUNCTION__, tid);
 
                 it->second = true;
 
                 // Create the thread, mark it as stopped.
-                NativeThreadProtocolSP thread_sp (AddThread (static_cast<lldb::tid_t> (tid)));
+                NativeThreadLinuxSP thread_sp (AddThread(static_cast<lldb::tid_t>(tid)));
                 assert (thread_sp && "AddThread() returned a nullptr");
 
                 // This will notify this is a new thread and tell the system it is stopped.
-                std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal (SIGSTOP);
-                ThreadWasCreated(tid);
+                thread_sp->SetStoppedBySignal(SIGSTOP);
+                ThreadWasCreated(*thread_sp);
                 SetCurrentThreadID (thread_sp->GetID ());
             }
 
             // move the loop forward
             ++it;
         }
     }
 
NativeProcessLinux::MonitorCallback(lldb::pid_t pid,
     }
 }
 
 void
 NativeProcessLinux::WaitForNewThread(::pid_t tid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
 
-    NativeThreadLinuxSP new_thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
+    NativeThreadLinuxSP new_thread_sp = GetThreadByID(tid);
 
     if (new_thread_sp)
     {
         // We are already tracking the thread - we got the event on the new thread (see
         // MonitorSignal) before this one. We are done.
         return;
     }
 
if (((info.si_pid != 0) || (info.si_code != SI_USER)) && log)
         // created properly.
         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 = std::static_pointer_cast<NativeThreadLinux>(AddThread(tid));
+    new_thread_sp = AddThread(tid);
     ResumeThread(new_thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER);
-    ThreadWasCreated(tid);
+    ThreadWasCreated(*new_thread_sp);
 }
 
 void
 NativeProcessLinux::MonitorSIGTRAP(const siginfo_t *info, lldb::pid_t pid)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     const bool is_main_thread = (pid == GetID ());
 
     assert(info && info->si_signo == SIGTRAP && "Unexpected child signal!");
     if (!info)
         return;
 
     Mutex::Locker locker (m_threads_mutex);
 
     // See if we can find a thread for this signal.
-    NativeThreadLinuxSP thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(pid));
+    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)
     {
case (SIGTRAP | (PTRACE_EVENT_CLONE << 8)):
             WaitForNewThread(event_message);
 
         ResumeThread(thread_sp, thread_sp->GetState(), LLDB_INVALID_SIGNAL_NUMBER);
         break;
     }
 
     case (SIGTRAP | (PTRACE_EVENT_EXEC << 8)):
     {
-        NativeThreadProtocolSP main_thread_sp;
+        NativeThreadLinuxSP main_thread_sp;
         if (log)
             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__);
 
         for (auto thread_sp : m_threads)
         {
             const bool is_main_thread = thread_sp && thread_sp->GetID () == GetID ();
             if (is_main_thread)
             {
-                main_thread_sp = thread_sp;
+                main_thread_sp = std::static_pointer_cast<NativeThreadLinux>(thread_sp);
                 if (log)
                     log->Printf ("NativeProcessLinux::%s found main thread with tid %" PRIu64 ", keeping", __FUNCTION__, main_thread_sp->GetID ());
             }
             else
             {
-                // Tell thread coordinator this thread is dead.
                 if (log)
                     log->Printf ("NativeProcessLinux::%s discarding non-main-thread tid %" PRIu64 " due to exec", __FUNCTION__, thread_sp->GetID ());
             }
         }
 
         m_threads.clear ();
 
         if (main_thread_sp)
         {
             m_threads.push_back (main_thread_sp);
             SetCurrentThreadID (main_thread_sp->GetID ());
-            std::static_pointer_cast<NativeThreadLinux> (main_thread_sp)->SetStoppedByExec ();
+            main_thread_sp->SetStoppedByExec();
         }
         else
         {
             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.
-        const lldb::tid_t main_thread_tid = GetID ();
-        ThreadWasCreated(main_thread_tid);
+        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");
case TRAP_HWBKPT: // We receive this on watchpoint hit
             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(pid, thread_sp, wp_index);
+                MonitorWatchpoint(*thread_sp, wp_index);
                 break;
             }
         }
         // Otherwise, report step over
         MonitorTrace(pid, thread_sp);
         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(pid, thread_sp, wp_index);
+                MonitorWatchpoint(*thread_sp, wp_index);
                 break;
             }
         }
         // NO BREAK
 #endif
     case TRAP_BRKPT:
         MonitorBreakpoint(pid, thread_sp);
         break;
default:
             log->Printf ("NativeProcessLinux::%s() pid %" PRIu64 "tid %" PRIu64 " received unhandled SIGTRAP code: 0x%d",
                     __FUNCTION__, GetID (), pid, info->si_code);
         break;
         
     }
 }
 
 void
-NativeProcessLinux::MonitorTrace(lldb::pid_t pid, NativeThreadProtocolSP thread_sp)
+NativeProcessLinux::MonitorTrace(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp)
 {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received trace event, pid = %" PRIu64 " (single stepping)",
                 __FUNCTION__, pid);
 
     // This thread is currently stopped.
     if (thread_sp)
-        std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByTrace();
+        thread_sp->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);
 }
 
 void
-NativeProcessLinux::MonitorBreakpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp)
+NativeProcessLinux::MonitorBreakpoint(lldb::pid_t pid, const NativeThreadLinuxSP &thread_sp)
 {
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_BREAKPOINTS));
     if (log)
         log->Printf("NativeProcessLinux::%s() received breakpoint event, pid = %" PRIu64,
                 __FUNCTION__, pid);
 
     // Mark the thread as stopped at breakpoint.
     if (thread_sp)
     {
-        std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByBreakpoint();
+        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());
 
         if (m_threads_stepping_with_breakpoint.find(pid) != m_threads_stepping_with_breakpoint.end())
-            std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByTrace();
+            thread_sp->SetStoppedByTrace();
     }
     else
         if (log)
             log->Printf("NativeProcessLinux::%s()  pid = %" PRIu64 ": "
                     "warning, cannot process software breakpoint since no thread metadata",
                     __FUNCTION__, pid);
 
 
     // We need to tell all other running threads before we notify the delegate about this stop.
     StopRunningThreads(pid);
 }
 
 void
-NativeProcessLinux::MonitorWatchpoint(lldb::pid_t pid, NativeThreadProtocolSP thread_sp, uint32_t wp_index)
+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__, pid, wp_index);
+                    __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.
-    lldbassert(thread_sp && "thread_sp cannot be NULL");
-    std::static_pointer_cast<NativeThreadLinux>(thread_sp)->SetStoppedByWatchpoint(wp_index);
+    thread.SetStoppedByWatchpoint(wp_index);
 
     // We need to tell all other running threads before we notify the delegate about this stop.
-    StopRunningThreads(pid);
+    StopRunningThreads(thread.GetID());
 }
 
 void
 NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
 {
     assert (info && "null info");
     if (!info)
         return;
NativeProcessLinux::MonitorSignal(const siginfo_t *info, lldb::pid_t pid, bool exited)
     // 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 = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(pid));
+    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_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 = std::static_pointer_cast<NativeThreadLinux>(AddThread(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(pid);
+        ThreadWasCreated(*thread_sp);
         // Done handling.
         return;
     }
 
     // Check for thread stop notification.
     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);
 
             // 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.
-            std::shared_ptr<NativeThreadLinux> linux_thread_sp = std::static_pointer_cast<NativeThreadLinux> (thread_sp);
-            assert (linux_thread_sp && "linux_thread_sp is null!");
-
-            const StateType thread_state = linux_thread_sp->GetState ();
+            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)
-                        linux_thread_sp->SetStoppedBySignal(SIGSTOP, info);
+                        thread_sp->SetStoppedBySignal(SIGSTOP, info);
                     else
-                        linux_thread_sp->SetStoppedWithNoReason();
+                        thread_sp->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(linux_thread_sp, linux_thread_sp->GetState(), 0);
+                    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__, linux_thread_sp->GetID(), error.AsCString ());
+                                __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 = linux_thread_sp->IsStopped (&stop_signo);
+                    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>";
 
                     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 (),
-                                 linux_thread_sp->GetID (),
+                                 thread_sp->GetID(),
                                  StateAsCString (thread_state),
                                  stop_signo,
                                  signal_name);
                 }
                 SignalIfAllThreadsStopped();
             }
         }
 
         // Done handling.
         return;
     }
 
     if (log)
         log->Printf ("NativeProcessLinux::%s() received signal %s", __FUNCTION__, Host::GetSignalAsCString(signo));
 
     // This thread is stopped.
     if (thread_sp)
-        std::static_pointer_cast<NativeThreadLinux> (thread_sp)->SetStoppedBySignal(signo, info);
+        thread_sp->SetStoppedBySignal(signo, info);
 
     // Send a stop to the debugger after we get all other threads to stop.
     StopRunningThreads (pid);
 }
 
 namespace {
 
 struct EmulatorBaton
for (auto it = m_threads.begin (); it != m_threads.end (); ++it)
         }
     }
 
     SignalIfAllThreadsStopped();
 
     return found;
 }
 
-NativeThreadProtocolSP
+NativeThreadLinuxSP
 NativeProcessLinux::AddThread (lldb::tid_t thread_id)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD));
 
     Mutex::Locker locker (m_threads_mutex);
 
     if (log)
     {
         log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " adding thread with tid %" PRIu64,
                 __FUNCTION__,
                 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);
 
-    NativeThreadProtocolSP thread_sp (new NativeThreadLinux (this, thread_id));
+    auto thread_sp = std::make_shared<NativeThreadLinux>(this, thread_id);
     m_threads.push_back (thread_sp);
-
     return thread_sp;
 }
 
 Error
-NativeProcessLinux::FixupBreakpointPCAsNeeded (NativeThreadProtocolSP &thread_sp)
+NativeProcessLinux::FixupBreakpointPCAsNeeded(const NativeThreadLinuxSP &thread_sp)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 
     Error error;
 
-    // Get a linux thread pointer.
     if (!thread_sp)
     {
         error.SetErrorString ("null thread_sp");
         if (log)
             log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ());
         return error;
     }
-    std::shared_ptr<NativeThreadLinux> linux_thread_sp = std::static_pointer_cast<NativeThreadLinux> (thread_sp);
 
     // Find out the size of a breakpoint (might depend on where we are in the code).
-    NativeRegisterContextSP context_sp = linux_thread_sp->GetRegisterContext ();
+    NativeRegisterContextSP context_sp = thread_sp->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;
     }
 
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 (), linux_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_sp->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 (), linux_thread_sp->GetID (), error.AsCString ());
+            log->Printf ("NativeProcessLinux::%s pid %" PRIu64 " tid %" PRIu64 ": failed to set PC: %s", __FUNCTION__, GetID(), thread_sp->GetID(), error.AsCString ());
         return error;
     }
 
     return error;
 }
 
 Error
 NativeProcessLinux::GetLoadedModuleFileSpec(const char* module_path, FileSpec& file_spec)
Error error = ProcFileReader::ProcessLineByLine (GetID (), "maps",
             }
  
             // Return true to continue reading the proc file
             return true;
         });
     return error; 
 }
 
+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)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
 
     if (log)
         log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")",
                 __FUNCTION__, thread_sp->GetID());
NativeProcessLinux::SignalIfAllThreadsStopped()
 
     // Notify the delegate about the stop
     SetCurrentThreadID(m_pending_notification_tid);
     SetState(StateType::eStateStopped, true);
     m_pending_notification_tid = LLDB_INVALID_THREAD_ID;
 }
 
 void
-NativeProcessLinux::ThreadWasCreated (lldb::tid_t tid)
+NativeProcessLinux::ThreadWasCreated(NativeThreadLinux &thread)
 {
     Log *const log = GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD);
 
     if (log)
-        log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")", __FUNCTION__, tid);
-
-    auto thread_sp = std::static_pointer_cast<NativeThreadLinux>(GetThreadByID(tid));
-    lldbassert(thread_sp != nullptr);
+        log->Printf("NativeProcessLinux::%s (tid: %" PRIu64 ")", __FUNCTION__, thread.GetID());
 
-    if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID && StateIsRunningState(thread_sp->GetState()))
+    if (m_pending_notification_tid != LLDB_INVALID_THREAD_ID && StateIsRunningState(thread.GetState()))
     {
         // We will need to wait for this new thread to stop as well before firing the
         // notification.
-        thread_sp->RequestStop();
+        thread.RequestStop();
     }
 }
 
 void
 NativeProcessLinux::SigchldHandler()
 {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     // Process all pending waitpid notifications.