blob: 6af04f8ffc37676b5069e10ea4f07f004e046404 [file] [log] [blame]
//===-- ThreadList.h --------------------------------------------*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include <mutex>
#include <vector>
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadCollection.h"
#include "lldb/Utility/Iterable.h"
#include "lldb/Utility/UserID.h"
#include "lldb/lldb-private.h"
namespace lldb_private {
// This is a thread list with lots of functionality for use only by the process
// for which this is the thread list. A generic container class with iterator
// functionality is ThreadCollection.
class ThreadList : public ThreadCollection {
friend class Process;
ThreadList(Process *process);
ThreadList(const ThreadList &rhs);
~ThreadList() override;
const ThreadList &operator=(const ThreadList &rhs);
uint32_t GetSize(bool can_update = true);
// Return the selected thread if there is one. Otherwise, return the thread
// selected at index 0.
lldb::ThreadSP GetSelectedThread();
// Manage the thread to use for running expressions. This is usually the
// Selected thread, but sometimes (e.g. when evaluating breakpoint conditions
// & stop hooks) it isn't.
class ExpressionExecutionThreadPusher {
ExpressionExecutionThreadPusher(ThreadList &thread_list, lldb::tid_t tid)
: m_thread_list(&thread_list), m_tid(tid) {
ExpressionExecutionThreadPusher(lldb::ThreadSP thread_sp);
~ExpressionExecutionThreadPusher() {
if (m_thread_list && m_tid != LLDB_INVALID_THREAD_ID)
ThreadList *m_thread_list;
lldb::tid_t m_tid;
lldb::ThreadSP GetExpressionExecutionThread();
void PushExpressionExecutionThread(lldb::tid_t tid);
void PopExpressionExecutionThread(lldb::tid_t tid);
bool SetSelectedThreadByID(lldb::tid_t tid, bool notify = false);
bool SetSelectedThreadByIndexID(uint32_t index_id, bool notify = false);
void Clear();
void Flush();
void Destroy();
// Note that "idx" is not the same as the "thread_index". It is a zero based
// index to accessing the current threads, whereas "thread_index" is a unique
// index assigned
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update = true);
lldb::ThreadSP FindThreadByID(lldb::tid_t tid, bool can_update = true);
lldb::ThreadSP FindThreadByProtocolID(lldb::tid_t tid,
bool can_update = true);
lldb::ThreadSP RemoveThreadByID(lldb::tid_t tid, bool can_update = true);
lldb::ThreadSP RemoveThreadByProtocolID(lldb::tid_t tid,
bool can_update = true);
lldb::ThreadSP FindThreadByIndexID(uint32_t index_id, bool can_update = true);
lldb::ThreadSP GetThreadSPForThreadPtr(Thread *thread_ptr);
lldb::ThreadSP GetBackingThread(const lldb::ThreadSP &real_thread);
bool ShouldStop(Event *event_ptr);
Vote ShouldReportStop(Event *event_ptr);
Vote ShouldReportRun(Event *event_ptr);
void RefreshStateAfterStop();
/// The thread list asks tells all the threads it is about to resume.
/// If a thread can "resume" without having to resume the target, it
/// will return false for WillResume, and then the process will not be
/// restarted.
/// \return
/// \b true instructs the process to resume normally,
/// \b false means start & stopped events will be generated, but
/// the process will not actually run. The thread must then return
/// the correct StopInfo when asked.
bool WillResume();
void DidResume();
void DidStop();
void DiscardThreadPlans();
uint32_t GetStopID() const;
void SetStopID(uint32_t stop_id);
std::recursive_mutex &GetMutex() const override;
void Update(ThreadList &rhs);
void SetShouldReportStop(Vote vote);
void NotifySelectedThreadChanged(lldb::tid_t tid);
// Classes that inherit from Process can see and modify these
Process *m_process; ///< The process that manages this thread list.
m_stop_id; ///< The process stop ID that this thread list is valid for.
m_selected_tid; ///< For targets that need the notion of a current thread.
std::vector<lldb::tid_t> m_expression_tid_stack;
ThreadList() = delete;
} // namespace lldb_private