llvm/lldb/source/Target/ThreadList.cpp

//===-- ThreadList.cpp ----------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include <cstdlib>

#include <algorithm>

#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadList.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/State.h"

usingnamespacelldb;
usingnamespacelldb_private;

ThreadList::ThreadList(Process &process)
    : … { … }

ThreadList::ThreadList(const ThreadList &rhs)
    : … { … }

const ThreadList &ThreadList::operator=(const ThreadList &rhs) { … }

ThreadList::~ThreadList() { … }

lldb::ThreadSP ThreadList::GetExpressionExecutionThread() { … }

void ThreadList::PushExpressionExecutionThread(lldb::tid_t tid) { … }

void ThreadList::PopExpressionExecutionThread(lldb::tid_t tid) { … }

uint32_t ThreadList::GetStopID() const { … }

void ThreadList::SetStopID(uint32_t stop_id) { … }

uint32_t ThreadList::GetSize(bool can_update) { … }

ThreadSP ThreadList::GetThreadAtIndex(uint32_t idx, bool can_update) { … }

ThreadSP ThreadList::FindThreadByID(lldb::tid_t tid, bool can_update) { … }

ThreadSP ThreadList::FindThreadByProtocolID(lldb::tid_t tid, bool can_update) { … }

ThreadSP ThreadList::RemoveThreadByID(lldb::tid_t tid, bool can_update) { … }

ThreadSP ThreadList::RemoveThreadByProtocolID(lldb::tid_t tid,
                                              bool can_update) { … }

ThreadSP ThreadList::GetThreadSPForThreadPtr(Thread *thread_ptr) { … }

ThreadSP ThreadList::GetBackingThread(const ThreadSP &real_thread) { … }

ThreadSP ThreadList::FindThreadByIndexID(uint32_t index_id, bool can_update) { … }

bool ThreadList::ShouldStop(Event *event_ptr) { … }

Vote ThreadList::ShouldReportStop(Event *event_ptr) { … }

void ThreadList::SetShouldReportStop(Vote vote) { … }

Vote ThreadList::ShouldReportRun(Event *event_ptr) { … }

void ThreadList::Clear() { … }

void ThreadList::Destroy() { … }

void ThreadList::RefreshStateAfterStop() { … }

void ThreadList::DiscardThreadPlans() { … }

bool ThreadList::WillResume() { … }

void ThreadList::DidResume() { … }

void ThreadList::DidStop() { … }

ThreadSP ThreadList::GetSelectedThread() { … }

bool ThreadList::SetSelectedThreadByID(lldb::tid_t tid, bool notify) { … }

bool ThreadList::SetSelectedThreadByIndexID(uint32_t index_id, bool notify) { … }

void ThreadList::NotifySelectedThreadChanged(lldb::tid_t tid) { … }

void ThreadList::Update(ThreadList &rhs) { … }

void ThreadList::Flush() { … }

std::recursive_mutex &ThreadList::GetMutex() const { … }

ThreadList::ExpressionExecutionThreadPusher::ExpressionExecutionThreadPusher(
    lldb::ThreadSP thread_sp)
    : … { … }