diff options
11 files changed, 217 insertions, 293 deletions
diff --git a/lldb/include/lldb/Host/common/NativeProcessProtocol.h b/lldb/include/lldb/Host/common/NativeProcessProtocol.h index 9671d710fc0..554f53dd0d7 100644 --- a/lldb/include/lldb/Host/common/NativeProcessProtocol.h +++ b/lldb/include/lldb/Host/common/NativeProcessProtocol.h @@ -10,6 +10,9 @@ #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" @@ -23,9 +26,6 @@ #include "llvm/Support/MemoryBuffer.h" #include <vector> -#include "NativeBreakpointList.h" -#include "NativeWatchpointList.h" - namespace lldb_private { class MemoryRegionInfo; class ResumeActionList; @@ -166,15 +166,15 @@ public: //---------------------------------------------------------------------- // 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); } @@ -401,7 +401,7 @@ public: 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; @@ -461,7 +461,7 @@ protected: // ----------------------------------------------------------- void NotifyDidExec(); - NativeThreadProtocolSP GetThreadByIDUnlocked(lldb::tid_t tid); + NativeThreadProtocol *GetThreadByIDUnlocked(lldb::tid_t tid); // ----------------------------------------------------------- // Static helper methods for derived classes. diff --git a/lldb/include/lldb/Host/common/NativeThreadProtocol.h b/lldb/include/lldb/Host/common/NativeThreadProtocol.h index d96f7131118..1c57eb3fe27 100644 --- a/lldb/include/lldb/Host/common/NativeThreadProtocol.h +++ b/lldb/include/lldb/Host/common/NativeThreadProtocol.h @@ -20,8 +20,7 @@ namespace lldb_private { //------------------------------------------------------------------ // NativeThreadProtocol //------------------------------------------------------------------ -class NativeThreadProtocol - : public std::enable_shared_from_this<NativeThreadProtocol> { +class NativeThreadProtocol { public: NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid); diff --git a/lldb/include/lldb/lldb-private-forward.h b/lldb/include/lldb/lldb-private-forward.h index 296facb1a0b..520777bfd4a 100644 --- a/lldb/include/lldb/lldb-private-forward.h +++ b/lldb/include/lldb/lldb-private-forward.h @@ -32,8 +32,6 @@ class UnixSignals; 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) diff --git a/lldb/source/Host/common/NativeProcessProtocol.cpp b/lldb/source/Host/common/NativeProcessProtocol.cpp index b5b6e9d8b92..b2cf7f4bbd1 100644 --- a/lldb/source/Host/common/NativeProcessProtocol.cpp +++ b/lldb/source/Host/common/NativeProcessProtocol.cpp @@ -90,23 +90,23 @@ bool NativeProcessProtocol::SetExitStatus(WaitStatus status, 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); } @@ -134,22 +134,18 @@ 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; } @@ -175,7 +171,7 @@ Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size, // 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, @@ -184,40 +180,33 @@ Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size, // 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( - "hardware watchpoint requested but software watchpoint set"); - } + 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; @@ -233,12 +222,10 @@ Status NativeProcessProtocol::RemoveWatchpoint(lldb::addr_t addr) { 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 @@ -277,20 +264,18 @@ Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr, // 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 @@ -298,12 +283,10 @@ Status NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr, 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; @@ -324,12 +307,9 @@ Status NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) { 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. diff --git a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp index a5dac2a98cf..150de3c0f7a 100644 --- a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp +++ b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp @@ -305,10 +305,9 @@ NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd, 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. @@ -478,11 +477,11 @@ void NativeProcessLinux::MonitorCallback(lldb::pid_t pid, bool exited, 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; } @@ -549,12 +548,9 @@ void NativeProcessLinux::MonitorCallback(lldb::pid_t pid, bool exited, 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; } @@ -587,10 +583,10 @@ void NativeProcessLinux::WaitForNewThread(::pid_t tid) { } 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, @@ -630,7 +626,6 @@ void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info, } 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. @@ -640,44 +635,26 @@ void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info, // 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; } @@ -1115,44 +1092,44 @@ Status NativeProcessLinux::Resume(const ResumeActionList &resume_actions) { 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; } @@ -1165,7 +1142,7 @@ Status NativeProcessLinux::Resume(const ResumeActionList &resume_actions) { return Status("NativeProcessLinux::%s (): unexpected state %s specified " "for pid %" PRIu64 ", tid %" PRIu64, __FUNCTION__, StateAsCString(action->state), GetID(), - thread_sp->GetID()); + thread->GetID()); } } @@ -1191,8 +1168,8 @@ Status NativeProcessLinux::Detach() { 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. @@ -1222,29 +1199,25 @@ Status NativeProcessLinux::Interrupt() { // 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); @@ -1252,14 +1225,14 @@ Status NativeProcessLinux::Interrupt() { 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(); } @@ -1975,9 +1948,9 @@ Status NativeProcessLinux::Detach(lldb::tid_t 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; } @@ -2006,7 +1979,7 @@ bool NativeProcessLinux::StopTrackingThread(lldb::tid_t thread_id) { 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); @@ -2017,8 +1990,7 @@ NativeThreadLinuxSP NativeProcessLinux::AddThread(lldb::tid_t 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); + m_threads.push_back(llvm::make_unique<NativeThreadLinux>(*this, thread_id)); if (m_pt_proces_trace_id != LLDB_INVALID_UID) { auto traceMonitor = ProcessorTraceMonitor::Create( @@ -2034,7 +2006,7 @@ NativeThreadLinuxSP NativeProcessLinux::AddThread(lldb::tid_t thread_id) { } } - return thread_sp; + return static_cast<NativeThreadLinux &>(*m_threads.back()); } Status @@ -2156,8 +2128,8 @@ Status NativeProcessLinux::GetFileLoadAddress(const llvm::StringRef &file_name, 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)); } @@ -2212,9 +2184,9 @@ void NativeProcessLinux::StopRunningThreads(const lldb::tid_t 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(); diff --git a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h index c9ec002760f..3d861202568 100644 --- a/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h +++ b/lldb/source/Plugins/Process/Linux/NativeProcessLinux.h @@ -102,7 +102,7 @@ public: 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 { @@ -203,7 +203,7 @@ private: 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); diff --git a/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h b/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h index 6ae87feffcd..01b54d9ec47 100644 --- a/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h +++ b/lldb/source/Plugins/Process/Linux/NativeThreadLinux.h @@ -110,8 +110,6 @@ private: 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 diff --git a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp index 388989a21f7..4f9a69688fe 100644 --- a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp +++ b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp @@ -109,10 +109,8 @@ NativeProcessNetBSD::Factory::Launch(ProcessLaunchInfo &launch_info, 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); @@ -198,9 +196,9 @@ void NativeProcessNetBSD::MonitorSIGSTOP(lldb::pid_t pid) { // 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); } } @@ -221,18 +219,15 @@ void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) { 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: { @@ -245,37 +240,34 @@ void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) { // 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()) @@ -284,10 +276,8 @@ void NativeProcessNetBSD::MonitorSIGTRAP(lldb::pid_t pid) { "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; } @@ -300,8 +290,8 @@ void NativeProcessNetBSD::MonitorSignal(lldb::pid_t pid, int signal) { 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); @@ -433,13 +423,13 @@ 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(); } @@ -452,9 +442,8 @@ Status NativeProcessNetBSD::Resume(const ResumeActionList &resume_actions) { 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; } @@ -464,9 +453,8 @@ Status NativeProcessNetBSD::Resume(const ResumeActionList &resume_actions) { 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; @@ -478,7 +466,7 @@ Status NativeProcessNetBSD::Resume(const ResumeActionList &resume_actions) { 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(); @@ -764,9 +752,9 @@ void NativeProcessNetBSD::SigchldHandler() { } 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; } @@ -776,7 +764,7 @@ bool NativeProcessNetBSD::HasThreadNoLock(lldb::tid_t thread_id) { 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); @@ -788,9 +776,8 @@ NativeThreadNetBSDSP NativeProcessNetBSD::AddThread(lldb::tid_t thread_id) { 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() { @@ -811,10 +798,8 @@ Status NativeProcessNetBSD::Attach() { 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); @@ -928,7 +913,7 @@ Status NativeProcessNetBSD::ReinitializeThreads() { } // 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; diff --git a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h index 2cbd5e30ab2..5ecf4623572 100644 --- a/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h +++ b/lldb/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h @@ -121,7 +121,7 @@ private: 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); diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp index 9294359dbef..d5b031bc928 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp @@ -523,16 +523,16 @@ static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process, // 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; @@ -548,7 +548,7 @@ static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process, 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); } @@ -556,7 +556,7 @@ static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process, 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)); @@ -604,14 +604,14 @@ GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 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. @@ -638,7 +638,7 @@ GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 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(); @@ -665,15 +665,13 @@ GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 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(';'); @@ -701,10 +699,10 @@ GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( 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; @@ -739,7 +737,7 @@ GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread( // // 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. @@ -1316,12 +1314,12 @@ GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) { 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()); } @@ -1692,12 +1690,12 @@ GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo( 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); @@ -1908,18 +1906,17 @@ GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo( 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"); @@ -1951,22 +1948,19 @@ GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) { } // 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); } @@ -2063,8 +2057,8 @@ GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) { 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)", @@ -2073,13 +2067,13 @@ GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) { } // 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); } @@ -2177,8 +2171,8 @@ GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) { // 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", @@ -2739,8 +2733,8 @@ GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) { // 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. @@ -2865,8 +2859,8 @@ GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( 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"); @@ -2876,12 +2870,12 @@ GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState( } // 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); } @@ -2930,8 +2924,8 @@ GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( } // 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"); @@ -2941,12 +2935,12 @@ GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState( } // 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); } @@ -3219,14 +3213,12 @@ void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() { } } -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. @@ -3234,7 +3226,7 @@ NativeThreadProtocolSP GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( 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); @@ -3251,11 +3243,11 @@ NativeThreadProtocolSP GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( "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) { @@ -3264,14 +3256,14 @@ NativeThreadProtocolSP GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix( "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 { diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h index 71199473bb8..7deee4b953c 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h @@ -234,7 +234,7 @@ private: void HandleInferiorState_Stopped(NativeProcessProtocol *process); - NativeThreadProtocolSP GetThreadFromSuffix(StringExtractorGDBRemote &packet); + NativeThreadProtocol *GetThreadFromSuffix(StringExtractorGDBRemote &packet); uint32_t GetNextSavedRegistersID(); |
