SBThread.cpp | Explore in Territory

//===-- SBThread.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 "lldb/API/SBThread.h"
#include "Utils.h"
#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBFormat.h"
#include "lldb/API/SBFrame.h"
#include "lldb/API/SBProcess.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBThreadCollection.h"
#include "lldb/API/SBThreadPlan.h"
#include "lldb/API/SBValue.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Core/ValueObject.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Queue.h"
#include "lldb/Target/StopInfo.h"
#include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Target/ThreadPlanStepInRange.h"
#include "lldb/Target/ThreadPlanStepInstruction.h"
#include "lldb/Target/ThreadPlanStepOut.h"
#include "lldb/Target/ThreadPlanStepRange.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/State.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StructuredData.h"
#include "lldb/lldb-enumerations.h"

#include <memory>

usingnamespacelldb;
usingnamespacelldb_private;

const char *SBThread::GetBroadcasterClassName() { … }

// Constructors
SBThread::SBThread() : … { … }

SBThread::SBThread(const ThreadSP &lldb_object_sp)
    : … { … }

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

// Assignment operator

const lldb::SBThread &SBThread::operator=(const SBThread &rhs) { … }

// Destructor
SBThread::~SBThread() = default;

lldb::SBQueue SBThread::GetQueue() const { … }

bool SBThread::IsValid() const { … }
operator bool()

void SBThread::Clear() { … }

StopReason SBThread::GetStopReason() { … }

size_t SBThread::GetStopReasonDataCount() { … }

uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) { … }

bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) { … }

SBThreadCollection
SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) { … }

size_t SBThread::GetStopDescription(char *dst, size_t dst_len) { … }

SBValue SBThread::GetStopReturnValue() { … }

void SBThread::SetThread(const ThreadSP &lldb_object_sp) { … }

lldb::tid_t SBThread::GetThreadID() const { … }

uint32_t SBThread::GetIndexID() const { … }

const char *SBThread::GetName() const { … }

const char *SBThread::GetQueueName() const { … }

lldb::queue_id_t SBThread::GetQueueID() const { … }

bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) { … }

SBError SBThread::ResumeNewPlan(ExecutionContext &exe_ctx,
                                ThreadPlan *new_plan) { … }

void SBThread::StepOver(lldb::RunMode stop_other_threads) { … }

void SBThread::StepOver(lldb::RunMode stop_other_threads, SBError &error) { … }

void SBThread::StepInto(lldb::RunMode stop_other_threads) { … }

void SBThread::StepInto(const char *target_name,
                        lldb::RunMode stop_other_threads) { … }

void SBThread::StepInto(const char *target_name, uint32_t end_line,
                        SBError &error, lldb::RunMode stop_other_threads) { … }

void SBThread::StepOut() { … }

void SBThread::StepOut(SBError &error) { … }

void SBThread::StepOutOfFrame(SBFrame &sb_frame) { … }

void SBThread::StepOutOfFrame(SBFrame &sb_frame, SBError &error) { … }

void SBThread::StepInstruction(bool step_over) { … }

void SBThread::StepInstruction(bool step_over, SBError &error) { … }

void SBThread::RunToAddress(lldb::addr_t addr) { … }

void SBThread::RunToAddress(lldb::addr_t addr, SBError &error) { … }

SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
                                lldb::SBFileSpec &sb_file_spec, uint32_t line) { … }

SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) { … }

SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
                                            bool resume_immediately) { … }

SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
                                              SBStructuredData &args_data,
                                              bool resume_immediately) { … }

SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) { … }

SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) { … }

SBError SBThread::UnwindInnermostExpression() { … }

bool SBThread::Suspend() { … }

bool SBThread::Suspend(SBError &error) { … }

bool SBThread::Resume() { … }

bool SBThread::Resume(SBError &error) { … }

bool SBThread::IsSuspended() { … }

bool SBThread::IsStopped() { … }

SBProcess SBThread::GetProcess() { … }

uint32_t SBThread::GetNumFrames() { … }

SBFrame SBThread::GetFrameAtIndex(uint32_t idx) { … }

lldb::SBFrame SBThread::GetSelectedFrame() { … }

lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) { … }

bool SBThread::EventIsThreadEvent(const SBEvent &event) { … }

SBFrame SBThread::GetStackFrameFromEvent(const SBEvent &event) { … }

SBThread SBThread::GetThreadFromEvent(const SBEvent &event) { … }

bool SBThread::operator==(const SBThread &rhs) const { … }

bool SBThread::operator!=(const SBThread &rhs) const { … }

bool SBThread::GetStatus(SBStream &status) const { … }

bool SBThread::GetDescription(SBStream &description) const { … }

bool SBThread::GetDescription(SBStream &description, bool stop_format) const { … }

SBError SBThread::GetDescriptionWithFormat(const SBFormat &format,
                                           SBStream &output) { … }

SBThread SBThread::GetExtendedBacktraceThread(const char *type) { … }

uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() { … }

SBValue SBThread::GetCurrentException() { … }

SBThread SBThread::GetCurrentExceptionBacktrace() { … }

bool SBThread::SafeToCallFunctions() { … }

lldb::ThreadSP SBThread::GetSP() const { … }

lldb_private::Thread *SBThread::operator->() { … }

lldb_private::Thread *SBThread::get() { … }

SBValue SBThread::GetSiginfo() { … }
llvm/lldb/source/API/SBThread.cpp
