Index: lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h =================================================================== --- lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h +++ lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h @@ -113,6 +113,9 @@ 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. // --------------------------------------------------------------------- @@ -225,13 +228,13 @@ 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); @@ -265,14 +268,14 @@ 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. @@ -317,7 +320,7 @@ ResumeThread(const NativeThreadLinuxSP &thread_sp, lldb::StateType state, int signo); void - ThreadWasCreated (lldb::tid_t tid); + ThreadWasCreated(NativeThreadLinux &thread); void SigchldHandler(); Index: lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp =================================================================== --- lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp +++ lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp @@ -532,9 +532,6 @@ 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) @@ -763,10 +760,10 @@ 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 (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 ()); @@ -791,7 +788,6 @@ ::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. @@ -857,12 +853,12 @@ it->second = true; // Create the thread, mark it as stopped. - NativeThreadProtocolSP thread_sp (AddThread (static_cast (tid))); + NativeThreadLinuxSP thread_sp (AddThread(static_cast(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 (thread_sp)->SetStoppedBySignal (SIGSTOP); - ThreadWasCreated(tid); + thread_sp->SetStoppedBySignal(SIGSTOP); + ThreadWasCreated(*thread_sp); SetCurrentThreadID (thread_sp->GetID ()); } @@ -1056,7 +1052,7 @@ { Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS)); - NativeThreadLinuxSP new_thread_sp = std::static_pointer_cast(GetThreadByID(tid)); + NativeThreadLinuxSP new_thread_sp = GetThreadByID(tid); if (new_thread_sp) { @@ -1114,9 +1110,9 @@ log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 ": tracking new thread tid %" PRIu32, __FUNCTION__, GetID (), tid); - new_thread_sp = std::static_pointer_cast(AddThread(tid)); + new_thread_sp = AddThread(tid); ResumeThread(new_thread_sp, eStateRunning, LLDB_INVALID_SIGNAL_NUMBER); - ThreadWasCreated(tid); + ThreadWasCreated(*new_thread_sp); } void @@ -1132,7 +1128,7 @@ Mutex::Locker locker (m_threads_mutex); // See if we can find a thread for this signal. - NativeThreadLinuxSP thread_sp = std::static_pointer_cast(GetThreadByID(pid)); + NativeThreadLinuxSP thread_sp = GetThreadByID(pid); if (!thread_sp) { if (log) @@ -1167,7 +1163,7 @@ 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); @@ -1183,13 +1179,12 @@ 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(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 ()); } @@ -1201,7 +1196,7 @@ { m_threads.push_back (main_thread_sp); SetCurrentThreadID (main_thread_sp->GetID ()); - std::static_pointer_cast (main_thread_sp)->SetStoppedByExec (); + main_thread_sp->SetStoppedByExec(); } else { @@ -1211,8 +1206,7 @@ } // 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. @@ -1273,7 +1267,7 @@ __FUNCTION__, pid, error.AsCString()); if (wp_index != LLDB_INVALID_INDEX32) { - MonitorWatchpoint(pid, thread_sp, wp_index); + MonitorWatchpoint(*thread_sp, wp_index); break; } } @@ -1297,7 +1291,7 @@ __FUNCTION__, pid, error.AsCString()); if (wp_index != LLDB_INVALID_INDEX32) { - MonitorWatchpoint(pid, thread_sp, wp_index); + MonitorWatchpoint(*thread_sp, wp_index); break; } } @@ -1327,7 +1321,7 @@ } 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) @@ -1336,7 +1330,7 @@ // This thread is currently stopped. if (thread_sp) - std::static_pointer_cast(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. @@ -1348,7 +1342,7 @@ } 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) @@ -1358,7 +1352,7 @@ // Mark the thread as stopped at breakpoint. if (thread_sp) { - std::static_pointer_cast(thread_sp)->SetStoppedByBreakpoint(); + thread_sp->SetStoppedByBreakpoint(); Error error = FixupBreakpointPCAsNeeded(thread_sp); if (error.Fail()) if (log) @@ -1366,7 +1360,7 @@ __FUNCTION__, pid, error.AsCString()); if (m_threads_stepping_with_breakpoint.find(pid) != m_threads_stepping_with_breakpoint.end()) - std::static_pointer_cast(thread_sp)->SetStoppedByTrace(); + thread_sp->SetStoppedByTrace(); } else if (log) @@ -1380,21 +1374,20 @@ } 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(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 @@ -1421,7 +1414,7 @@ Mutex::Locker locker (m_threads_mutex); // See if we can find a thread for this signal. - NativeThreadLinuxSP thread_sp = std::static_pointer_cast(GetThreadByID(pid)); + NativeThreadLinuxSP thread_sp = GetThreadByID(pid); if (!thread_sp) { if (log) @@ -1453,11 +1446,11 @@ log->Printf ("NativeProcessLinux::%s() pid = %" PRIu64 " tid %" PRIu64 ": new thread notification", __FUNCTION__, GetID (), pid); - thread_sp = std::static_pointer_cast(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; } @@ -1480,10 +1473,7 @@ // 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 linux_thread_sp = std::static_pointer_cast (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. @@ -1496,9 +1486,9 @@ 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(); @@ -1507,11 +1497,11 @@ { // 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()); } } } @@ -1521,7 +1511,7 @@ { // 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) : ""; if (!signal_name) signal_name = ""; @@ -1529,7 +1519,7 @@ 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); @@ -1547,7 +1537,7 @@ // This thread is stopped. if (thread_sp) - std::static_pointer_cast (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); @@ -2820,7 +2810,7 @@ return found; } -NativeThreadProtocolSP +NativeThreadLinuxSP NativeProcessLinux::AddThread (lldb::tid_t thread_id) { Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_THREAD)); @@ -2841,20 +2831,18 @@ if (m_threads.empty ()) SetCurrentThreadID (thread_id); - NativeThreadProtocolSP thread_sp (new NativeThreadLinux (this, thread_id)); + auto thread_sp = std::make_shared(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"); @@ -2862,10 +2850,9 @@ log->Printf ("NativeProcessLinux::%s failed: %s", __FUNCTION__, error.AsCString ()); return error; } - std::shared_ptr linux_thread_sp = std::static_pointer_cast (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"); @@ -2932,13 +2919,13 @@ // 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; } @@ -3009,6 +2996,12 @@ return error; } +NativeThreadLinuxSP +NativeProcessLinux::GetThreadByID(lldb::tid_t tid) +{ + return std::static_pointer_cast(NativeProcessProtocol::GetThreadByID(tid)); +} + Error NativeProcessLinux::ResumeThread(const NativeThreadLinuxSP &thread_sp, lldb::StateType state, int signo) { @@ -3121,21 +3114,18 @@ } 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(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(); } }