15ffd83dbSDimitry Andric //===-- ThreadList.cpp ----------------------------------------------------===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric
9fe6060f1SDimitry Andric #include <cstdlib>
100b57cec5SDimitry Andric
110b57cec5SDimitry Andric #include <algorithm>
120b57cec5SDimitry Andric
130b57cec5SDimitry Andric #include "lldb/Target/Process.h"
140b57cec5SDimitry Andric #include "lldb/Target/RegisterContext.h"
150b57cec5SDimitry Andric #include "lldb/Target/Thread.h"
160b57cec5SDimitry Andric #include "lldb/Target/ThreadList.h"
170b57cec5SDimitry Andric #include "lldb/Target/ThreadPlan.h"
180b57cec5SDimitry Andric #include "lldb/Utility/LLDBAssert.h"
1981ad6265SDimitry Andric #include "lldb/Utility/LLDBLog.h"
200b57cec5SDimitry Andric #include "lldb/Utility/Log.h"
210b57cec5SDimitry Andric #include "lldb/Utility/State.h"
220b57cec5SDimitry Andric
230b57cec5SDimitry Andric using namespace lldb;
240b57cec5SDimitry Andric using namespace lldb_private;
250b57cec5SDimitry Andric
ThreadList(Process * process)260b57cec5SDimitry Andric ThreadList::ThreadList(Process *process)
270b57cec5SDimitry Andric : ThreadCollection(), m_process(process), m_stop_id(0),
280b57cec5SDimitry Andric m_selected_tid(LLDB_INVALID_THREAD_ID) {}
290b57cec5SDimitry Andric
ThreadList(const ThreadList & rhs)300b57cec5SDimitry Andric ThreadList::ThreadList(const ThreadList &rhs)
310b57cec5SDimitry Andric : ThreadCollection(), m_process(rhs.m_process), m_stop_id(rhs.m_stop_id),
320b57cec5SDimitry Andric m_selected_tid() {
330b57cec5SDimitry Andric // Use the assignment operator since it uses the mutex
340b57cec5SDimitry Andric *this = rhs;
350b57cec5SDimitry Andric }
360b57cec5SDimitry Andric
operator =(const ThreadList & rhs)370b57cec5SDimitry Andric const ThreadList &ThreadList::operator=(const ThreadList &rhs) {
380b57cec5SDimitry Andric if (this != &rhs) {
390b57cec5SDimitry Andric // Lock both mutexes to make sure neither side changes anyone on us while
400b57cec5SDimitry Andric // the assignment occurs
410b57cec5SDimitry Andric std::lock(GetMutex(), rhs.GetMutex());
420b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex(), std::adopt_lock);
430b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> rhs_guard(rhs.GetMutex(),
440b57cec5SDimitry Andric std::adopt_lock);
450b57cec5SDimitry Andric
460b57cec5SDimitry Andric m_process = rhs.m_process;
470b57cec5SDimitry Andric m_stop_id = rhs.m_stop_id;
480b57cec5SDimitry Andric m_threads = rhs.m_threads;
490b57cec5SDimitry Andric m_selected_tid = rhs.m_selected_tid;
500b57cec5SDimitry Andric }
510b57cec5SDimitry Andric return *this;
520b57cec5SDimitry Andric }
530b57cec5SDimitry Andric
~ThreadList()540b57cec5SDimitry Andric ThreadList::~ThreadList() {
550b57cec5SDimitry Andric // Clear the thread list. Clear will take the mutex lock which will ensure
560b57cec5SDimitry Andric // that if anyone is using the list they won't get it removed while using it.
570b57cec5SDimitry Andric Clear();
580b57cec5SDimitry Andric }
590b57cec5SDimitry Andric
GetExpressionExecutionThread()600b57cec5SDimitry Andric lldb::ThreadSP ThreadList::GetExpressionExecutionThread() {
610b57cec5SDimitry Andric if (m_expression_tid_stack.empty())
620b57cec5SDimitry Andric return GetSelectedThread();
630b57cec5SDimitry Andric ThreadSP expr_thread_sp = FindThreadByID(m_expression_tid_stack.back());
640b57cec5SDimitry Andric if (expr_thread_sp)
650b57cec5SDimitry Andric return expr_thread_sp;
660b57cec5SDimitry Andric else
670b57cec5SDimitry Andric return GetSelectedThread();
680b57cec5SDimitry Andric }
690b57cec5SDimitry Andric
PushExpressionExecutionThread(lldb::tid_t tid)700b57cec5SDimitry Andric void ThreadList::PushExpressionExecutionThread(lldb::tid_t tid) {
710b57cec5SDimitry Andric m_expression_tid_stack.push_back(tid);
720b57cec5SDimitry Andric }
730b57cec5SDimitry Andric
PopExpressionExecutionThread(lldb::tid_t tid)740b57cec5SDimitry Andric void ThreadList::PopExpressionExecutionThread(lldb::tid_t tid) {
750b57cec5SDimitry Andric assert(m_expression_tid_stack.back() == tid);
760b57cec5SDimitry Andric m_expression_tid_stack.pop_back();
770b57cec5SDimitry Andric }
780b57cec5SDimitry Andric
GetStopID() const790b57cec5SDimitry Andric uint32_t ThreadList::GetStopID() const { return m_stop_id; }
800b57cec5SDimitry Andric
SetStopID(uint32_t stop_id)810b57cec5SDimitry Andric void ThreadList::SetStopID(uint32_t stop_id) { m_stop_id = stop_id; }
820b57cec5SDimitry Andric
GetSize(bool can_update)830b57cec5SDimitry Andric uint32_t ThreadList::GetSize(bool can_update) {
840b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
850b57cec5SDimitry Andric
860b57cec5SDimitry Andric if (can_update)
870b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
880b57cec5SDimitry Andric return m_threads.size();
890b57cec5SDimitry Andric }
900b57cec5SDimitry Andric
GetThreadAtIndex(uint32_t idx,bool can_update)910b57cec5SDimitry Andric ThreadSP ThreadList::GetThreadAtIndex(uint32_t idx, bool can_update) {
920b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
930b57cec5SDimitry Andric
940b57cec5SDimitry Andric if (can_update)
950b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
960b57cec5SDimitry Andric
970b57cec5SDimitry Andric ThreadSP thread_sp;
980b57cec5SDimitry Andric if (idx < m_threads.size())
990b57cec5SDimitry Andric thread_sp = m_threads[idx];
1000b57cec5SDimitry Andric return thread_sp;
1010b57cec5SDimitry Andric }
1020b57cec5SDimitry Andric
FindThreadByID(lldb::tid_t tid,bool can_update)1030b57cec5SDimitry Andric ThreadSP ThreadList::FindThreadByID(lldb::tid_t tid, bool can_update) {
1040b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
1050b57cec5SDimitry Andric
1060b57cec5SDimitry Andric if (can_update)
1070b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
1080b57cec5SDimitry Andric
1090b57cec5SDimitry Andric ThreadSP thread_sp;
1100b57cec5SDimitry Andric uint32_t idx = 0;
1110b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
1120b57cec5SDimitry Andric for (idx = 0; idx < num_threads; ++idx) {
1130b57cec5SDimitry Andric if (m_threads[idx]->GetID() == tid) {
1140b57cec5SDimitry Andric thread_sp = m_threads[idx];
1150b57cec5SDimitry Andric break;
1160b57cec5SDimitry Andric }
1170b57cec5SDimitry Andric }
1180b57cec5SDimitry Andric return thread_sp;
1190b57cec5SDimitry Andric }
1200b57cec5SDimitry Andric
FindThreadByProtocolID(lldb::tid_t tid,bool can_update)1210b57cec5SDimitry Andric ThreadSP ThreadList::FindThreadByProtocolID(lldb::tid_t tid, bool can_update) {
1220b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
1230b57cec5SDimitry Andric
1240b57cec5SDimitry Andric if (can_update)
1250b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
1260b57cec5SDimitry Andric
1270b57cec5SDimitry Andric ThreadSP thread_sp;
1280b57cec5SDimitry Andric uint32_t idx = 0;
1290b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
1300b57cec5SDimitry Andric for (idx = 0; idx < num_threads; ++idx) {
1310b57cec5SDimitry Andric if (m_threads[idx]->GetProtocolID() == tid) {
1320b57cec5SDimitry Andric thread_sp = m_threads[idx];
1330b57cec5SDimitry Andric break;
1340b57cec5SDimitry Andric }
1350b57cec5SDimitry Andric }
1360b57cec5SDimitry Andric return thread_sp;
1370b57cec5SDimitry Andric }
1380b57cec5SDimitry Andric
RemoveThreadByID(lldb::tid_t tid,bool can_update)1390b57cec5SDimitry Andric ThreadSP ThreadList::RemoveThreadByID(lldb::tid_t tid, bool can_update) {
1400b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
1410b57cec5SDimitry Andric
1420b57cec5SDimitry Andric if (can_update)
1430b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
1440b57cec5SDimitry Andric
1450b57cec5SDimitry Andric ThreadSP thread_sp;
1460b57cec5SDimitry Andric uint32_t idx = 0;
1470b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
1480b57cec5SDimitry Andric for (idx = 0; idx < num_threads; ++idx) {
1490b57cec5SDimitry Andric if (m_threads[idx]->GetID() == tid) {
1500b57cec5SDimitry Andric thread_sp = m_threads[idx];
1510b57cec5SDimitry Andric m_threads.erase(m_threads.begin() + idx);
1520b57cec5SDimitry Andric break;
1530b57cec5SDimitry Andric }
1540b57cec5SDimitry Andric }
1550b57cec5SDimitry Andric return thread_sp;
1560b57cec5SDimitry Andric }
1570b57cec5SDimitry Andric
RemoveThreadByProtocolID(lldb::tid_t tid,bool can_update)1580b57cec5SDimitry Andric ThreadSP ThreadList::RemoveThreadByProtocolID(lldb::tid_t tid,
1590b57cec5SDimitry Andric bool can_update) {
1600b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
1610b57cec5SDimitry Andric
1620b57cec5SDimitry Andric if (can_update)
1630b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
1640b57cec5SDimitry Andric
1650b57cec5SDimitry Andric ThreadSP thread_sp;
1660b57cec5SDimitry Andric uint32_t idx = 0;
1670b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
1680b57cec5SDimitry Andric for (idx = 0; idx < num_threads; ++idx) {
1690b57cec5SDimitry Andric if (m_threads[idx]->GetProtocolID() == tid) {
1700b57cec5SDimitry Andric thread_sp = m_threads[idx];
1710b57cec5SDimitry Andric m_threads.erase(m_threads.begin() + idx);
1720b57cec5SDimitry Andric break;
1730b57cec5SDimitry Andric }
1740b57cec5SDimitry Andric }
1750b57cec5SDimitry Andric return thread_sp;
1760b57cec5SDimitry Andric }
1770b57cec5SDimitry Andric
GetThreadSPForThreadPtr(Thread * thread_ptr)1780b57cec5SDimitry Andric ThreadSP ThreadList::GetThreadSPForThreadPtr(Thread *thread_ptr) {
1790b57cec5SDimitry Andric ThreadSP thread_sp;
1800b57cec5SDimitry Andric if (thread_ptr) {
1810b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
1820b57cec5SDimitry Andric
1830b57cec5SDimitry Andric uint32_t idx = 0;
1840b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
1850b57cec5SDimitry Andric for (idx = 0; idx < num_threads; ++idx) {
1860b57cec5SDimitry Andric if (m_threads[idx].get() == thread_ptr) {
1870b57cec5SDimitry Andric thread_sp = m_threads[idx];
1880b57cec5SDimitry Andric break;
1890b57cec5SDimitry Andric }
1900b57cec5SDimitry Andric }
1910b57cec5SDimitry Andric }
1920b57cec5SDimitry Andric return thread_sp;
1930b57cec5SDimitry Andric }
1940b57cec5SDimitry Andric
GetBackingThread(const ThreadSP & real_thread)1950b57cec5SDimitry Andric ThreadSP ThreadList::GetBackingThread(const ThreadSP &real_thread) {
1960b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
1970b57cec5SDimitry Andric
1980b57cec5SDimitry Andric ThreadSP thread_sp;
1990b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
2000b57cec5SDimitry Andric for (uint32_t idx = 0; idx < num_threads; ++idx) {
2010b57cec5SDimitry Andric if (m_threads[idx]->GetBackingThread() == real_thread) {
2020b57cec5SDimitry Andric thread_sp = m_threads[idx];
2030b57cec5SDimitry Andric break;
2040b57cec5SDimitry Andric }
2050b57cec5SDimitry Andric }
2060b57cec5SDimitry Andric return thread_sp;
2070b57cec5SDimitry Andric }
2080b57cec5SDimitry Andric
FindThreadByIndexID(uint32_t index_id,bool can_update)2090b57cec5SDimitry Andric ThreadSP ThreadList::FindThreadByIndexID(uint32_t index_id, bool can_update) {
2100b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
2110b57cec5SDimitry Andric
2120b57cec5SDimitry Andric if (can_update)
2130b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
2140b57cec5SDimitry Andric
2150b57cec5SDimitry Andric ThreadSP thread_sp;
2160b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
2170b57cec5SDimitry Andric for (uint32_t idx = 0; idx < num_threads; ++idx) {
2180b57cec5SDimitry Andric if (m_threads[idx]->GetIndexID() == index_id) {
2190b57cec5SDimitry Andric thread_sp = m_threads[idx];
2200b57cec5SDimitry Andric break;
2210b57cec5SDimitry Andric }
2220b57cec5SDimitry Andric }
2230b57cec5SDimitry Andric return thread_sp;
2240b57cec5SDimitry Andric }
2250b57cec5SDimitry Andric
ShouldStop(Event * event_ptr)2260b57cec5SDimitry Andric bool ThreadList::ShouldStop(Event *event_ptr) {
2270b57cec5SDimitry Andric // Running events should never stop, obviously...
2280b57cec5SDimitry Andric
22981ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Step);
2300b57cec5SDimitry Andric
2310b57cec5SDimitry Andric // The ShouldStop method of the threads can do a whole lot of work, figuring
2320b57cec5SDimitry Andric // out whether the thread plan conditions are met. So we don't want to keep
2330b57cec5SDimitry Andric // the ThreadList locked the whole time we are doing this.
2340b57cec5SDimitry Andric // FIXME: It is possible that running code could cause new threads
2350b57cec5SDimitry Andric // to be created. If that happens, we will miss asking them whether they
2360b57cec5SDimitry Andric // should stop. This is not a big deal since we haven't had a chance to hang
2370b57cec5SDimitry Andric // any interesting operations on those threads yet.
2380b57cec5SDimitry Andric
2390b57cec5SDimitry Andric collection threads_copy;
2400b57cec5SDimitry Andric {
2410b57cec5SDimitry Andric // Scope for locker
2420b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
2430b57cec5SDimitry Andric
2440b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
2450b57cec5SDimitry Andric for (lldb::ThreadSP thread_sp : m_threads) {
2460b57cec5SDimitry Andric // This is an optimization... If we didn't let a thread run in between
2470b57cec5SDimitry Andric // the previous stop and this one, we shouldn't have to consult it for
248bdd1243dSDimitry Andric // ShouldStop. So just leave it off the list we are going to inspect.
249bdd1243dSDimitry Andric // If the thread didn't run but had work to do before declaring a public
250bdd1243dSDimitry Andric // stop, then also include it.
251bdd1243dSDimitry Andric // On Linux, if a thread-specific conditional breakpoint was hit, it won't
2520b57cec5SDimitry Andric // necessarily be the thread that hit the breakpoint itself that
2530b57cec5SDimitry Andric // evaluates the conditional expression, so the thread that hit the
2540b57cec5SDimitry Andric // breakpoint could still be asked to stop, even though it hasn't been
2550b57cec5SDimitry Andric // allowed to run since the previous stop.
2560b57cec5SDimitry Andric if (thread_sp->GetTemporaryResumeState() != eStateSuspended ||
257bdd1243dSDimitry Andric thread_sp->IsStillAtLastBreakpointHit()
258bdd1243dSDimitry Andric || thread_sp->ShouldRunBeforePublicStop())
2590b57cec5SDimitry Andric threads_copy.push_back(thread_sp);
2600b57cec5SDimitry Andric }
2610b57cec5SDimitry Andric
2620b57cec5SDimitry Andric // It is possible the threads we were allowing to run all exited and then
2630b57cec5SDimitry Andric // maybe the user interrupted or something, then fall back on looking at
2640b57cec5SDimitry Andric // all threads:
2650b57cec5SDimitry Andric
2660b57cec5SDimitry Andric if (threads_copy.size() == 0)
2670b57cec5SDimitry Andric threads_copy = m_threads;
2680b57cec5SDimitry Andric }
2690b57cec5SDimitry Andric
2700b57cec5SDimitry Andric collection::iterator pos, end = threads_copy.end();
2710b57cec5SDimitry Andric
2720b57cec5SDimitry Andric if (log) {
2730b57cec5SDimitry Andric log->PutCString("");
2749dba64beSDimitry Andric LLDB_LOGF(log,
2759dba64beSDimitry Andric "ThreadList::%s: %" PRIu64 " threads, %" PRIu64
2760b57cec5SDimitry Andric " unsuspended threads",
2770b57cec5SDimitry Andric __FUNCTION__, (uint64_t)m_threads.size(),
2780b57cec5SDimitry Andric (uint64_t)threads_copy.size());
2790b57cec5SDimitry Andric }
2800b57cec5SDimitry Andric
2810b57cec5SDimitry Andric bool did_anybody_stop_for_a_reason = false;
2820b57cec5SDimitry Andric
2830b57cec5SDimitry Andric // If the event is an Interrupt event, then we're going to stop no matter
2840b57cec5SDimitry Andric // what. Otherwise, presume we won't stop.
2850b57cec5SDimitry Andric bool should_stop = false;
2860b57cec5SDimitry Andric if (Process::ProcessEventData::GetInterruptedFromEvent(event_ptr)) {
2879dba64beSDimitry Andric LLDB_LOGF(
2889dba64beSDimitry Andric log, "ThreadList::%s handling interrupt event, should stop set to true",
2890b57cec5SDimitry Andric __FUNCTION__);
2900b57cec5SDimitry Andric
2910b57cec5SDimitry Andric should_stop = true;
2920b57cec5SDimitry Andric }
2930b57cec5SDimitry Andric
2940b57cec5SDimitry Andric // Now we run through all the threads and get their stop info's. We want to
2950b57cec5SDimitry Andric // make sure to do this first before we start running the ShouldStop, because
2960b57cec5SDimitry Andric // one thread's ShouldStop could destroy information (like deleting a thread
2970b57cec5SDimitry Andric // specific breakpoint another thread had stopped at) which could lead us to
2980b57cec5SDimitry Andric // compute the StopInfo incorrectly. We don't need to use it here, we just
2990b57cec5SDimitry Andric // want to make sure it gets computed.
3000b57cec5SDimitry Andric
3010b57cec5SDimitry Andric for (pos = threads_copy.begin(); pos != end; ++pos) {
3020b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
3030b57cec5SDimitry Andric thread_sp->GetStopInfo();
3040b57cec5SDimitry Andric }
3050b57cec5SDimitry Andric
306bdd1243dSDimitry Andric // If a thread needs to finish some job that can be done just on this thread
307bdd1243dSDimitry Andric // before broadcastion the stop, it will signal that by returning true for
308bdd1243dSDimitry Andric // ShouldRunBeforePublicStop. This variable gathers the results from that.
309bdd1243dSDimitry Andric bool a_thread_needs_to_run = false;
3100b57cec5SDimitry Andric for (pos = threads_copy.begin(); pos != end; ++pos) {
3110b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
3120b57cec5SDimitry Andric
3130b57cec5SDimitry Andric // We should never get a stop for which no thread had a stop reason, but
3140b57cec5SDimitry Andric // sometimes we do see this - for instance when we first connect to a
3150b57cec5SDimitry Andric // remote stub. In that case we should stop, since we can't figure out the
3160b57cec5SDimitry Andric // right thing to do and stopping gives the user control over what to do in
3170b57cec5SDimitry Andric // this instance.
3180b57cec5SDimitry Andric //
3190b57cec5SDimitry Andric // Note, this causes a problem when you have a thread specific breakpoint,
3200b57cec5SDimitry Andric // and a bunch of threads hit the breakpoint, but not the thread which we
3210b57cec5SDimitry Andric // are waiting for. All the threads that are not "supposed" to hit the
3220b57cec5SDimitry Andric // breakpoint are marked as having no stop reason, which is right, they
3230b57cec5SDimitry Andric // should not show a stop reason. But that triggers this code and causes
3240b57cec5SDimitry Andric // us to stop seemingly for no reason.
3250b57cec5SDimitry Andric //
3260b57cec5SDimitry Andric // Since the only way we ever saw this error was on first attach, I'm only
3270b57cec5SDimitry Andric // going to trigger set did_anybody_stop_for_a_reason to true unless this
3280b57cec5SDimitry Andric // is the first stop.
3290b57cec5SDimitry Andric //
3300b57cec5SDimitry Andric // If this becomes a problem, we'll have to have another StopReason like
3310b57cec5SDimitry Andric // "StopInfoHidden" which will look invalid everywhere but at this check.
3320b57cec5SDimitry Andric
3330b57cec5SDimitry Andric if (thread_sp->GetProcess()->GetStopID() > 1)
3340b57cec5SDimitry Andric did_anybody_stop_for_a_reason = true;
3350b57cec5SDimitry Andric else
3360b57cec5SDimitry Andric did_anybody_stop_for_a_reason |= thread_sp->ThreadStoppedForAReason();
3370b57cec5SDimitry Andric
3380b57cec5SDimitry Andric const bool thread_should_stop = thread_sp->ShouldStop(event_ptr);
339bdd1243dSDimitry Andric
3400b57cec5SDimitry Andric if (thread_should_stop)
3410b57cec5SDimitry Andric should_stop |= true;
342bdd1243dSDimitry Andric else {
343bdd1243dSDimitry Andric bool this_thread_forces_run = thread_sp->ShouldRunBeforePublicStop();
344bdd1243dSDimitry Andric a_thread_needs_to_run |= this_thread_forces_run;
345bdd1243dSDimitry Andric if (this_thread_forces_run)
346bdd1243dSDimitry Andric LLDB_LOG(log,
347bdd1243dSDimitry Andric "ThreadList::{0} thread: {1:x}, "
348bdd1243dSDimitry Andric "says it needs to run before public stop.",
349bdd1243dSDimitry Andric __FUNCTION__, thread_sp->GetID());
350bdd1243dSDimitry Andric }
3510b57cec5SDimitry Andric }
3520b57cec5SDimitry Andric
353bdd1243dSDimitry Andric if (a_thread_needs_to_run) {
354bdd1243dSDimitry Andric should_stop = false;
355bdd1243dSDimitry Andric } else if (!should_stop && !did_anybody_stop_for_a_reason) {
3560b57cec5SDimitry Andric should_stop = true;
3579dba64beSDimitry Andric LLDB_LOGF(log,
3589dba64beSDimitry Andric "ThreadList::%s we stopped but no threads had a stop reason, "
3590b57cec5SDimitry Andric "overriding should_stop and stopping.",
3600b57cec5SDimitry Andric __FUNCTION__);
3610b57cec5SDimitry Andric }
3620b57cec5SDimitry Andric
3639dba64beSDimitry Andric LLDB_LOGF(log, "ThreadList::%s overall should_stop = %i", __FUNCTION__,
3640b57cec5SDimitry Andric should_stop);
3650b57cec5SDimitry Andric
3660b57cec5SDimitry Andric if (should_stop) {
3670b57cec5SDimitry Andric for (pos = threads_copy.begin(); pos != end; ++pos) {
3680b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
3690b57cec5SDimitry Andric thread_sp->WillStop();
3700b57cec5SDimitry Andric }
3710b57cec5SDimitry Andric }
3720b57cec5SDimitry Andric
3730b57cec5SDimitry Andric return should_stop;
3740b57cec5SDimitry Andric }
3750b57cec5SDimitry Andric
ShouldReportStop(Event * event_ptr)3760b57cec5SDimitry Andric Vote ThreadList::ShouldReportStop(Event *event_ptr) {
3770b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
3780b57cec5SDimitry Andric
3790b57cec5SDimitry Andric Vote result = eVoteNoOpinion;
3800b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
3810b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
3820b57cec5SDimitry Andric
38381ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Step);
3840b57cec5SDimitry Andric
3859dba64beSDimitry Andric LLDB_LOGF(log, "ThreadList::%s %" PRIu64 " threads", __FUNCTION__,
3860b57cec5SDimitry Andric (uint64_t)m_threads.size());
3870b57cec5SDimitry Andric
3880b57cec5SDimitry Andric // Run through the threads and ask whether we should report this event. For
3890b57cec5SDimitry Andric // stopping, a YES vote wins over everything. A NO vote wins over NO
390bdd1243dSDimitry Andric // opinion. The exception is if a thread has work it needs to force before
391bdd1243dSDimitry Andric // a public stop, which overrides everyone else's opinion:
3920b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
3930b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
394bdd1243dSDimitry Andric if (thread_sp->ShouldRunBeforePublicStop()) {
395bdd1243dSDimitry Andric LLDB_LOG(log, "Thread {0:x} has private business to complete, overrode "
396bdd1243dSDimitry Andric "the should report stop.", thread_sp->GetID());
397bdd1243dSDimitry Andric result = eVoteNo;
398bdd1243dSDimitry Andric break;
399bdd1243dSDimitry Andric }
400bdd1243dSDimitry Andric
4010b57cec5SDimitry Andric const Vote vote = thread_sp->ShouldReportStop(event_ptr);
4020b57cec5SDimitry Andric switch (vote) {
4030b57cec5SDimitry Andric case eVoteNoOpinion:
4040b57cec5SDimitry Andric continue;
4050b57cec5SDimitry Andric
4060b57cec5SDimitry Andric case eVoteYes:
4070b57cec5SDimitry Andric result = eVoteYes;
4080b57cec5SDimitry Andric break;
4090b57cec5SDimitry Andric
4100b57cec5SDimitry Andric case eVoteNo:
4110b57cec5SDimitry Andric if (result == eVoteNoOpinion) {
4120b57cec5SDimitry Andric result = eVoteNo;
4130b57cec5SDimitry Andric } else {
4140b57cec5SDimitry Andric LLDB_LOG(log,
4150b57cec5SDimitry Andric "Thread {0:x} voted {1}, but lost out because result was {2}",
4160b57cec5SDimitry Andric thread_sp->GetID(), vote, result);
4170b57cec5SDimitry Andric }
4180b57cec5SDimitry Andric break;
4190b57cec5SDimitry Andric }
4200b57cec5SDimitry Andric }
4210b57cec5SDimitry Andric LLDB_LOG(log, "Returning {0}", result);
4220b57cec5SDimitry Andric return result;
4230b57cec5SDimitry Andric }
4240b57cec5SDimitry Andric
SetShouldReportStop(Vote vote)4250b57cec5SDimitry Andric void ThreadList::SetShouldReportStop(Vote vote) {
4260b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
4270b57cec5SDimitry Andric
4280b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
4290b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
4300b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
4310b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
4320b57cec5SDimitry Andric thread_sp->SetShouldReportStop(vote);
4330b57cec5SDimitry Andric }
4340b57cec5SDimitry Andric }
4350b57cec5SDimitry Andric
ShouldReportRun(Event * event_ptr)4360b57cec5SDimitry Andric Vote ThreadList::ShouldReportRun(Event *event_ptr) {
4370b57cec5SDimitry Andric
4380b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
4390b57cec5SDimitry Andric
4400b57cec5SDimitry Andric Vote result = eVoteNoOpinion;
4410b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
4420b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
4430b57cec5SDimitry Andric
4440b57cec5SDimitry Andric // Run through the threads and ask whether we should report this event. The
4450b57cec5SDimitry Andric // rule is NO vote wins over everything, a YES vote wins over no opinion.
4460b57cec5SDimitry Andric
44781ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Step);
4480b57cec5SDimitry Andric
4490b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
4500b57cec5SDimitry Andric if ((*pos)->GetResumeState() != eStateSuspended) {
4510b57cec5SDimitry Andric switch ((*pos)->ShouldReportRun(event_ptr)) {
4520b57cec5SDimitry Andric case eVoteNoOpinion:
4530b57cec5SDimitry Andric continue;
4540b57cec5SDimitry Andric case eVoteYes:
4550b57cec5SDimitry Andric if (result == eVoteNoOpinion)
4560b57cec5SDimitry Andric result = eVoteYes;
4570b57cec5SDimitry Andric break;
4580b57cec5SDimitry Andric case eVoteNo:
4599dba64beSDimitry Andric LLDB_LOGF(log,
4609dba64beSDimitry Andric "ThreadList::ShouldReportRun() thread %d (0x%4.4" PRIx64
4610b57cec5SDimitry Andric ") says don't report.",
4620b57cec5SDimitry Andric (*pos)->GetIndexID(), (*pos)->GetID());
4630b57cec5SDimitry Andric result = eVoteNo;
4640b57cec5SDimitry Andric break;
4650b57cec5SDimitry Andric }
4660b57cec5SDimitry Andric }
4670b57cec5SDimitry Andric }
4680b57cec5SDimitry Andric return result;
4690b57cec5SDimitry Andric }
4700b57cec5SDimitry Andric
Clear()4710b57cec5SDimitry Andric void ThreadList::Clear() {
4720b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
4730b57cec5SDimitry Andric m_stop_id = 0;
4740b57cec5SDimitry Andric m_threads.clear();
4750b57cec5SDimitry Andric m_selected_tid = LLDB_INVALID_THREAD_ID;
4760b57cec5SDimitry Andric }
4770b57cec5SDimitry Andric
Destroy()4780b57cec5SDimitry Andric void ThreadList::Destroy() {
4790b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
4800b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
4810b57cec5SDimitry Andric for (uint32_t idx = 0; idx < num_threads; ++idx) {
4820b57cec5SDimitry Andric m_threads[idx]->DestroyThread();
4830b57cec5SDimitry Andric }
4840b57cec5SDimitry Andric }
4850b57cec5SDimitry Andric
RefreshStateAfterStop()4860b57cec5SDimitry Andric void ThreadList::RefreshStateAfterStop() {
4870b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
4880b57cec5SDimitry Andric
4890b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
4900b57cec5SDimitry Andric
49181ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Step);
4920b57cec5SDimitry Andric if (log && log->GetVerbose())
4939dba64beSDimitry Andric LLDB_LOGF(log,
4949dba64beSDimitry Andric "Turning off notification of new threads while single stepping "
4950b57cec5SDimitry Andric "a thread.");
4960b57cec5SDimitry Andric
4970b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
4980b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos)
4990b57cec5SDimitry Andric (*pos)->RefreshStateAfterStop();
5000b57cec5SDimitry Andric }
5010b57cec5SDimitry Andric
DiscardThreadPlans()5020b57cec5SDimitry Andric void ThreadList::DiscardThreadPlans() {
5030b57cec5SDimitry Andric // You don't need to update the thread list here, because only threads that
5040b57cec5SDimitry Andric // you currently know about have any thread plans.
5050b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
5060b57cec5SDimitry Andric
5070b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
5080b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos)
5090b57cec5SDimitry Andric (*pos)->DiscardThreadPlans(true);
5100b57cec5SDimitry Andric }
5110b57cec5SDimitry Andric
WillResume()5120b57cec5SDimitry Andric bool ThreadList::WillResume() {
5130b57cec5SDimitry Andric // Run through the threads and perform their momentary actions. But we only
5140b57cec5SDimitry Andric // do this for threads that are running, user suspended threads stay where
5150b57cec5SDimitry Andric // they are.
5160b57cec5SDimitry Andric
5170b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
5180b57cec5SDimitry Andric m_process->UpdateThreadListIfNeeded();
5190b57cec5SDimitry Andric
5200b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
5210b57cec5SDimitry Andric
5220b57cec5SDimitry Andric // See if any thread wants to run stopping others. If it does, then we won't
5230b57cec5SDimitry Andric // setup the other threads for resume, since they aren't going to get a
5240b57cec5SDimitry Andric // chance to run. This is necessary because the SetupForResume might add
5250b57cec5SDimitry Andric // "StopOthers" plans which would then get to be part of the who-gets-to-run
5260b57cec5SDimitry Andric // negotiation, but they're coming in after the fact, and the threads that
5270b57cec5SDimitry Andric // are already set up should take priority.
5280b57cec5SDimitry Andric
5290b57cec5SDimitry Andric bool wants_solo_run = false;
5300b57cec5SDimitry Andric
5310b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
5320b57cec5SDimitry Andric lldbassert((*pos)->GetCurrentPlan() &&
5330b57cec5SDimitry Andric "thread should not have null thread plan");
5340b57cec5SDimitry Andric if ((*pos)->GetResumeState() != eStateSuspended &&
5350b57cec5SDimitry Andric (*pos)->GetCurrentPlan()->StopOthers()) {
5360b57cec5SDimitry Andric if ((*pos)->IsOperatingSystemPluginThread() &&
5370b57cec5SDimitry Andric !(*pos)->GetBackingThread())
5380b57cec5SDimitry Andric continue;
5390b57cec5SDimitry Andric wants_solo_run = true;
5400b57cec5SDimitry Andric break;
5410b57cec5SDimitry Andric }
5420b57cec5SDimitry Andric }
5430b57cec5SDimitry Andric
5440b57cec5SDimitry Andric if (wants_solo_run) {
54581ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Step);
5460b57cec5SDimitry Andric if (log && log->GetVerbose())
5479dba64beSDimitry Andric LLDB_LOGF(log, "Turning on notification of new threads while single "
5480b57cec5SDimitry Andric "stepping a thread.");
5490b57cec5SDimitry Andric m_process->StartNoticingNewThreads();
5500b57cec5SDimitry Andric } else {
55181ad6265SDimitry Andric Log *log = GetLog(LLDBLog::Step);
5520b57cec5SDimitry Andric if (log && log->GetVerbose())
5539dba64beSDimitry Andric LLDB_LOGF(log, "Turning off notification of new threads while single "
5540b57cec5SDimitry Andric "stepping a thread.");
5550b57cec5SDimitry Andric m_process->StopNoticingNewThreads();
5560b57cec5SDimitry Andric }
5570b57cec5SDimitry Andric
5580b57cec5SDimitry Andric // Give all the threads that are likely to run a last chance to set up their
5590b57cec5SDimitry Andric // state before we negotiate who is actually going to get a chance to run...
5600b57cec5SDimitry Andric // Don't set to resume suspended threads, and if any thread wanted to stop
5610b57cec5SDimitry Andric // others, only call setup on the threads that request StopOthers...
5620b57cec5SDimitry Andric
5630b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
5640b57cec5SDimitry Andric if ((*pos)->GetResumeState() != eStateSuspended &&
5650b57cec5SDimitry Andric (!wants_solo_run || (*pos)->GetCurrentPlan()->StopOthers())) {
5660b57cec5SDimitry Andric if ((*pos)->IsOperatingSystemPluginThread() &&
5670b57cec5SDimitry Andric !(*pos)->GetBackingThread())
5680b57cec5SDimitry Andric continue;
5690b57cec5SDimitry Andric (*pos)->SetupForResume();
5700b57cec5SDimitry Andric }
5710b57cec5SDimitry Andric }
5720b57cec5SDimitry Andric
5730b57cec5SDimitry Andric // Now go through the threads and see if any thread wants to run just itself.
5740b57cec5SDimitry Andric // if so then pick one and run it.
5750b57cec5SDimitry Andric
5760b57cec5SDimitry Andric ThreadList run_me_only_list(m_process);
5770b57cec5SDimitry Andric
5780b57cec5SDimitry Andric run_me_only_list.SetStopID(m_process->GetStopID());
5790b57cec5SDimitry Andric
580bdd1243dSDimitry Andric // One or more threads might want to "Stop Others". We want to handle all
581bdd1243dSDimitry Andric // those requests first. And if there is a thread that wanted to "resume
582bdd1243dSDimitry Andric // before a public stop", let it get the first crack:
583bdd1243dSDimitry Andric // There are two special kinds of thread that have priority for "StopOthers":
584bdd1243dSDimitry Andric // a "ShouldRunBeforePublicStop thread, or the currently selected thread. If
585bdd1243dSDimitry Andric // we find one satisfying that critereon, put it here.
586bdd1243dSDimitry Andric ThreadSP stop_others_thread_sp;
5870b57cec5SDimitry Andric
5880b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
5890b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
5900b57cec5SDimitry Andric if (thread_sp->GetResumeState() != eStateSuspended &&
5910b57cec5SDimitry Andric thread_sp->GetCurrentPlan()->StopOthers()) {
5920b57cec5SDimitry Andric if ((*pos)->IsOperatingSystemPluginThread() &&
5930b57cec5SDimitry Andric !(*pos)->GetBackingThread())
5940b57cec5SDimitry Andric continue;
5950b57cec5SDimitry Andric
5960b57cec5SDimitry Andric // You can't say "stop others" and also want yourself to be suspended.
5970b57cec5SDimitry Andric assert(thread_sp->GetCurrentPlan()->RunState() != eStateSuspended);
5980b57cec5SDimitry Andric run_me_only_list.AddThread(thread_sp);
599bdd1243dSDimitry Andric
600bdd1243dSDimitry Andric if (thread_sp == GetSelectedThread())
601bdd1243dSDimitry Andric stop_others_thread_sp = thread_sp;
602bdd1243dSDimitry Andric
603bdd1243dSDimitry Andric if (thread_sp->ShouldRunBeforePublicStop()) {
604bdd1243dSDimitry Andric // This takes precedence, so if we find one of these, service it:
605bdd1243dSDimitry Andric stop_others_thread_sp = thread_sp;
6060b57cec5SDimitry Andric break;
6070b57cec5SDimitry Andric }
6080b57cec5SDimitry Andric }
6090b57cec5SDimitry Andric }
6100b57cec5SDimitry Andric
6110b57cec5SDimitry Andric bool need_to_resume = true;
6120b57cec5SDimitry Andric
6130b57cec5SDimitry Andric if (run_me_only_list.GetSize(false) == 0) {
6140b57cec5SDimitry Andric // Everybody runs as they wish:
6150b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
6160b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
6170b57cec5SDimitry Andric StateType run_state;
6180b57cec5SDimitry Andric if (thread_sp->GetResumeState() != eStateSuspended)
6190b57cec5SDimitry Andric run_state = thread_sp->GetCurrentPlan()->RunState();
6200b57cec5SDimitry Andric else
6210b57cec5SDimitry Andric run_state = eStateSuspended;
6220b57cec5SDimitry Andric if (!thread_sp->ShouldResume(run_state))
6230b57cec5SDimitry Andric need_to_resume = false;
6240b57cec5SDimitry Andric }
6250b57cec5SDimitry Andric } else {
6260b57cec5SDimitry Andric ThreadSP thread_to_run;
6270b57cec5SDimitry Andric
628bdd1243dSDimitry Andric if (stop_others_thread_sp) {
629bdd1243dSDimitry Andric thread_to_run = stop_others_thread_sp;
6300b57cec5SDimitry Andric } else if (run_me_only_list.GetSize(false) == 1) {
6310b57cec5SDimitry Andric thread_to_run = run_me_only_list.GetThreadAtIndex(0);
6320b57cec5SDimitry Andric } else {
6330b57cec5SDimitry Andric int random_thread =
6340b57cec5SDimitry Andric (int)((run_me_only_list.GetSize(false) * (double)rand()) /
6350b57cec5SDimitry Andric (RAND_MAX + 1.0));
6360b57cec5SDimitry Andric thread_to_run = run_me_only_list.GetThreadAtIndex(random_thread);
6370b57cec5SDimitry Andric }
6380b57cec5SDimitry Andric
6390b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
6400b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
6410b57cec5SDimitry Andric if (thread_sp == thread_to_run) {
642bdd1243dSDimitry Andric // Note, a thread might be able to fulfil it's plan w/o actually
643bdd1243dSDimitry Andric // resuming. An example of this is a step that changes the current
644bdd1243dSDimitry Andric // inlined function depth w/o moving the PC. Check that here:
6450b57cec5SDimitry Andric if (!thread_sp->ShouldResume(thread_sp->GetCurrentPlan()->RunState()))
6460b57cec5SDimitry Andric need_to_resume = false;
6470b57cec5SDimitry Andric } else
6480b57cec5SDimitry Andric thread_sp->ShouldResume(eStateSuspended);
6490b57cec5SDimitry Andric }
6500b57cec5SDimitry Andric }
6510b57cec5SDimitry Andric
6520b57cec5SDimitry Andric return need_to_resume;
6530b57cec5SDimitry Andric }
6540b57cec5SDimitry Andric
DidResume()6550b57cec5SDimitry Andric void ThreadList::DidResume() {
6560b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
6570b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
6580b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
6590b57cec5SDimitry Andric // Don't clear out threads that aren't going to get a chance to run, rather
6600b57cec5SDimitry Andric // leave their state for the next time around.
6610b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
662bdd1243dSDimitry Andric if (thread_sp->GetTemporaryResumeState() != eStateSuspended)
6630b57cec5SDimitry Andric thread_sp->DidResume();
6640b57cec5SDimitry Andric }
6650b57cec5SDimitry Andric }
6660b57cec5SDimitry Andric
DidStop()6670b57cec5SDimitry Andric void ThreadList::DidStop() {
6680b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
6690b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
6700b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos) {
6710b57cec5SDimitry Andric // Notify threads that the process just stopped. Note, this currently
6720b57cec5SDimitry Andric // assumes that all threads in the list stop when the process stops. In
6730b57cec5SDimitry Andric // the future we will want to support a debugging model where some threads
6740b57cec5SDimitry Andric // continue to run while others are stopped. We either need to handle that
6750b57cec5SDimitry Andric // somehow here or create a special thread list containing only threads
6760b57cec5SDimitry Andric // which will stop in the code that calls this method (currently
6770b57cec5SDimitry Andric // Process::SetPrivateState).
6780b57cec5SDimitry Andric ThreadSP thread_sp(*pos);
6790b57cec5SDimitry Andric if (StateIsRunningState(thread_sp->GetState()))
6800b57cec5SDimitry Andric thread_sp->DidStop();
6810b57cec5SDimitry Andric }
6820b57cec5SDimitry Andric }
6830b57cec5SDimitry Andric
GetSelectedThread()6840b57cec5SDimitry Andric ThreadSP ThreadList::GetSelectedThread() {
6850b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
6860b57cec5SDimitry Andric ThreadSP thread_sp = FindThreadByID(m_selected_tid);
6870b57cec5SDimitry Andric if (!thread_sp.get()) {
6880b57cec5SDimitry Andric if (m_threads.size() == 0)
6890b57cec5SDimitry Andric return thread_sp;
6900b57cec5SDimitry Andric m_selected_tid = m_threads[0]->GetID();
6910b57cec5SDimitry Andric thread_sp = m_threads[0];
6920b57cec5SDimitry Andric }
6930b57cec5SDimitry Andric return thread_sp;
6940b57cec5SDimitry Andric }
6950b57cec5SDimitry Andric
SetSelectedThreadByID(lldb::tid_t tid,bool notify)6960b57cec5SDimitry Andric bool ThreadList::SetSelectedThreadByID(lldb::tid_t tid, bool notify) {
6970b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
6980b57cec5SDimitry Andric ThreadSP selected_thread_sp(FindThreadByID(tid));
6990b57cec5SDimitry Andric if (selected_thread_sp) {
7000b57cec5SDimitry Andric m_selected_tid = tid;
7010b57cec5SDimitry Andric selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
7020b57cec5SDimitry Andric } else
7030b57cec5SDimitry Andric m_selected_tid = LLDB_INVALID_THREAD_ID;
7040b57cec5SDimitry Andric
7050b57cec5SDimitry Andric if (notify)
7060b57cec5SDimitry Andric NotifySelectedThreadChanged(m_selected_tid);
7070b57cec5SDimitry Andric
7080b57cec5SDimitry Andric return m_selected_tid != LLDB_INVALID_THREAD_ID;
7090b57cec5SDimitry Andric }
7100b57cec5SDimitry Andric
SetSelectedThreadByIndexID(uint32_t index_id,bool notify)7110b57cec5SDimitry Andric bool ThreadList::SetSelectedThreadByIndexID(uint32_t index_id, bool notify) {
7120b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
7130b57cec5SDimitry Andric ThreadSP selected_thread_sp(FindThreadByIndexID(index_id));
7140b57cec5SDimitry Andric if (selected_thread_sp.get()) {
7150b57cec5SDimitry Andric m_selected_tid = selected_thread_sp->GetID();
7160b57cec5SDimitry Andric selected_thread_sp->SetDefaultFileAndLineToSelectedFrame();
7170b57cec5SDimitry Andric } else
7180b57cec5SDimitry Andric m_selected_tid = LLDB_INVALID_THREAD_ID;
7190b57cec5SDimitry Andric
7200b57cec5SDimitry Andric if (notify)
7210b57cec5SDimitry Andric NotifySelectedThreadChanged(m_selected_tid);
7220b57cec5SDimitry Andric
7230b57cec5SDimitry Andric return m_selected_tid != LLDB_INVALID_THREAD_ID;
7240b57cec5SDimitry Andric }
7250b57cec5SDimitry Andric
NotifySelectedThreadChanged(lldb::tid_t tid)7260b57cec5SDimitry Andric void ThreadList::NotifySelectedThreadChanged(lldb::tid_t tid) {
7270b57cec5SDimitry Andric ThreadSP selected_thread_sp(FindThreadByID(tid));
7280b57cec5SDimitry Andric if (selected_thread_sp->EventTypeHasListeners(
7297a6dacacSDimitry Andric Thread::eBroadcastBitThreadSelected)) {
7307a6dacacSDimitry Andric auto data_sp =
7317a6dacacSDimitry Andric std::make_shared<Thread::ThreadEventData>(selected_thread_sp);
7327a6dacacSDimitry Andric selected_thread_sp->BroadcastEvent(Thread::eBroadcastBitThreadSelected,
7337a6dacacSDimitry Andric data_sp);
7347a6dacacSDimitry Andric }
7350b57cec5SDimitry Andric }
7360b57cec5SDimitry Andric
Update(ThreadList & rhs)7370b57cec5SDimitry Andric void ThreadList::Update(ThreadList &rhs) {
7380b57cec5SDimitry Andric if (this != &rhs) {
7390b57cec5SDimitry Andric // Lock both mutexes to make sure neither side changes anyone on us while
7400b57cec5SDimitry Andric // the assignment occurs
7415f757f3fSDimitry Andric std::scoped_lock<std::recursive_mutex, std::recursive_mutex> guard(GetMutex(), rhs.GetMutex());
7420b57cec5SDimitry Andric
7430b57cec5SDimitry Andric m_process = rhs.m_process;
7440b57cec5SDimitry Andric m_stop_id = rhs.m_stop_id;
7450b57cec5SDimitry Andric m_threads.swap(rhs.m_threads);
7460b57cec5SDimitry Andric m_selected_tid = rhs.m_selected_tid;
7470b57cec5SDimitry Andric
7480b57cec5SDimitry Andric // Now we look for threads that we are done with and make sure to clear
7490b57cec5SDimitry Andric // them up as much as possible so anyone with a shared pointer will still
7500b57cec5SDimitry Andric // have a reference, but the thread won't be of much use. Using
7510b57cec5SDimitry Andric // std::weak_ptr for all backward references (such as a thread to a
7520b57cec5SDimitry Andric // process) will eventually solve this issue for us, but for now, we need
7530b57cec5SDimitry Andric // to work around the issue
7540b57cec5SDimitry Andric collection::iterator rhs_pos, rhs_end = rhs.m_threads.end();
7550b57cec5SDimitry Andric for (rhs_pos = rhs.m_threads.begin(); rhs_pos != rhs_end; ++rhs_pos) {
7565ffd83dbSDimitry Andric // If this thread has already been destroyed, we don't need to look for
7575ffd83dbSDimitry Andric // it to destroy it again.
7585ffd83dbSDimitry Andric if (!(*rhs_pos)->IsValid())
7595ffd83dbSDimitry Andric continue;
7605ffd83dbSDimitry Andric
7610b57cec5SDimitry Andric const lldb::tid_t tid = (*rhs_pos)->GetID();
7620b57cec5SDimitry Andric bool thread_is_alive = false;
7630b57cec5SDimitry Andric const uint32_t num_threads = m_threads.size();
7640b57cec5SDimitry Andric for (uint32_t idx = 0; idx < num_threads; ++idx) {
7650b57cec5SDimitry Andric ThreadSP backing_thread = m_threads[idx]->GetBackingThread();
7660b57cec5SDimitry Andric if (m_threads[idx]->GetID() == tid ||
7670b57cec5SDimitry Andric (backing_thread && backing_thread->GetID() == tid)) {
7680b57cec5SDimitry Andric thread_is_alive = true;
7690b57cec5SDimitry Andric break;
7700b57cec5SDimitry Andric }
7710b57cec5SDimitry Andric }
7725ffd83dbSDimitry Andric if (!thread_is_alive) {
7730b57cec5SDimitry Andric (*rhs_pos)->DestroyThread();
7740b57cec5SDimitry Andric }
7750b57cec5SDimitry Andric }
7760b57cec5SDimitry Andric }
7775ffd83dbSDimitry Andric }
7780b57cec5SDimitry Andric
Flush()7790b57cec5SDimitry Andric void ThreadList::Flush() {
7800b57cec5SDimitry Andric std::lock_guard<std::recursive_mutex> guard(GetMutex());
7810b57cec5SDimitry Andric collection::iterator pos, end = m_threads.end();
7820b57cec5SDimitry Andric for (pos = m_threads.begin(); pos != end; ++pos)
7830b57cec5SDimitry Andric (*pos)->Flush();
7840b57cec5SDimitry Andric }
7850b57cec5SDimitry Andric
GetMutex() const7860b57cec5SDimitry Andric std::recursive_mutex &ThreadList::GetMutex() const {
7870b57cec5SDimitry Andric return m_process->m_thread_mutex;
7880b57cec5SDimitry Andric }
7890b57cec5SDimitry Andric
ExpressionExecutionThreadPusher(lldb::ThreadSP thread_sp)7900b57cec5SDimitry Andric ThreadList::ExpressionExecutionThreadPusher::ExpressionExecutionThreadPusher(
7910b57cec5SDimitry Andric lldb::ThreadSP thread_sp)
7920b57cec5SDimitry Andric : m_thread_list(nullptr), m_tid(LLDB_INVALID_THREAD_ID) {
7930b57cec5SDimitry Andric if (thread_sp) {
7940b57cec5SDimitry Andric m_tid = thread_sp->GetID();
7950b57cec5SDimitry Andric m_thread_list = &thread_sp->GetProcess()->GetThreadList();
7960b57cec5SDimitry Andric m_thread_list->PushExpressionExecutionThread(m_tid);
7970b57cec5SDimitry Andric }
7980b57cec5SDimitry Andric }
799