llvm/lldb/source/Target/ThreadPlanStack.cpp

//===-- ThreadPlanStack.cpp -------------------------------------*- C++ -*-===//
//
// 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/Target/ThreadPlanStack.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Target/ThreadPlan.h"
#include "lldb/Utility/Log.h"

usingnamespacelldb;
usingnamespacelldb_private;

static void PrintPlanElement(Stream &s, const ThreadPlanSP &plan,
                             lldb::DescriptionLevel desc_level,
                             int32_t elem_idx) { … }

ThreadPlanStack::ThreadPlanStack(const Thread &thread, bool make_null) { … }

void ThreadPlanStack::DumpThreadPlans(Stream &s,
                                      lldb::DescriptionLevel desc_level,
                                      bool include_internal) const { … }

void ThreadPlanStack::PrintOneStack(Stream &s, llvm::StringRef stack_name,
                                    const PlanStack &stack,
                                    lldb::DescriptionLevel desc_level,
                                    bool include_internal) const { … }

size_t ThreadPlanStack::CheckpointCompletedPlans() { … }

void ThreadPlanStack::RestoreCompletedPlanCheckpoint(size_t checkpoint) { … }

void ThreadPlanStack::DiscardCompletedPlanCheckpoint(size_t checkpoint) { … }

void ThreadPlanStack::ThreadDestroyed(Thread *thread) { … }

void ThreadPlanStack::PushPlan(lldb::ThreadPlanSP new_plan_sp) { … }

lldb::ThreadPlanSP ThreadPlanStack::PopPlan() { … }

lldb::ThreadPlanSP ThreadPlanStack::DiscardPlan() { … }

// If the input plan is nullptr, discard all plans.  Otherwise make sure this
// plan is in the stack, and if so discard up to and including it.
void ThreadPlanStack::DiscardPlansUpToPlan(ThreadPlan *up_to_plan_ptr) { … }

void ThreadPlanStack::DiscardAllPlans() { … }

void ThreadPlanStack::DiscardConsultingControllingPlans() { … }

lldb::ThreadPlanSP ThreadPlanStack::GetCurrentPlan() const { … }

lldb::ThreadPlanSP ThreadPlanStack::GetCompletedPlan(bool skip_private) const { … }

lldb::ThreadPlanSP ThreadPlanStack::GetPlanByIndex(uint32_t plan_idx,
                                                   bool skip_private) const { … }

lldb::ValueObjectSP ThreadPlanStack::GetReturnValueObject() const { … }

lldb::ExpressionVariableSP ThreadPlanStack::GetExpressionVariable() const { … }
bool ThreadPlanStack::AnyPlans() const { … }

bool ThreadPlanStack::AnyCompletedPlans() const { … }

bool ThreadPlanStack::AnyDiscardedPlans() const { … }

bool ThreadPlanStack::IsPlanDone(ThreadPlan *in_plan) const { … }

bool ThreadPlanStack::WasPlanDiscarded(ThreadPlan *in_plan) const { … }

ThreadPlan *ThreadPlanStack::GetPreviousPlan(ThreadPlan *current_plan) const { … }

ThreadPlan *ThreadPlanStack::GetInnermostExpression() const { … }

void ThreadPlanStack::ClearThreadCache() { … }

void ThreadPlanStack::WillResume() { … }

void ThreadPlanStackMap::Update(ThreadList &current_threads,
                                bool delete_missing,
                                bool check_for_new) { … }

void ThreadPlanStackMap::DumpPlans(Stream &strm,
                                   lldb::DescriptionLevel desc_level,
                                   bool internal, bool condense_if_trivial,
                                   bool skip_unreported) { … }

bool ThreadPlanStackMap::DumpPlansForTID(Stream &strm, lldb::tid_t tid,
                                         lldb::DescriptionLevel desc_level,
                                         bool internal,
                                         bool condense_if_trivial,
                                         bool skip_unreported) { … }

bool ThreadPlanStackMap::PrunePlansForTID(lldb::tid_t tid) { … }