SBFrame.cpp | Explore in Territory

//===-- SBFrame.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 <algorithm>
#include <set>
#include <string>

#include "lldb/API/SBFrame.h"

#include "lldb/lldb-types.h"

#include "Utils.h"
#include "lldb/Core/Address.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/ValueObjectRegister.h"
#include "lldb/Core/ValueObjectVariable.h"
#include "lldb/Core/ValueObjectConstResult.h"
#include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Expression/UserExpression.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/StackFrameRecognizer.h"
#include "lldb/Target/StackID.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Instrumentation.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Stream.h"

#include "lldb/API/SBAddress.h"
#include "lldb/API/SBDebugger.h"
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBFormat.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBValue.h"
#include "lldb/API/SBVariablesOptions.h"

#include "llvm/Support/PrettyStackTrace.h"

usingnamespacelldb;
usingnamespacelldb_private;

SBFrame::SBFrame() : … { … }

SBFrame::SBFrame(const StackFrameSP &lldb_object_sp)
    : … { … }

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

SBFrame::~SBFrame() = default;

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

StackFrameSP SBFrame::GetFrameSP() const { … }

void SBFrame::SetFrameSP(const StackFrameSP &lldb_object_sp) { … }

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

SBSymbolContext SBFrame::GetSymbolContext(uint32_t resolve_scope) const { … }

SBModule SBFrame::GetModule() const { … }

SBCompileUnit SBFrame::GetCompileUnit() const { … }

SBFunction SBFrame::GetFunction() const { … }

SBSymbol SBFrame::GetSymbol() const { … }

SBBlock SBFrame::GetBlock() const { … }

SBBlock SBFrame::GetFrameBlock() const { … }

SBLineEntry SBFrame::GetLineEntry() const { … }

uint32_t SBFrame::GetFrameID() const { … }

lldb::addr_t SBFrame::GetCFA() const { … }

addr_t SBFrame::GetPC() const { … }

bool SBFrame::SetPC(addr_t new_pc) { … }

addr_t SBFrame::GetSP() const { … }

addr_t SBFrame::GetFP() const { … }

SBAddress SBFrame::GetPCAddress() const { … }

void SBFrame::Clear() { … }

lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) { … }

lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
                                               DynamicValueType use_dynamic) { … }

SBValue SBFrame::FindVariable(const char *name) { … }

SBValue SBFrame::FindVariable(const char *name,
                              lldb::DynamicValueType use_dynamic) { … }

SBValue SBFrame::FindValue(const char *name, ValueType value_type) { … }

SBValue SBFrame::FindValue(const char *name, ValueType value_type,
                           lldb::DynamicValueType use_dynamic) { … }

bool SBFrame::IsEqual(const SBFrame &that) const { … }

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

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

SBThread SBFrame::GetThread() const { … }

const char *SBFrame::Disassemble() const { … }

SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
                                  bool in_scope_only) { … }

lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
                                        bool statics, bool in_scope_only,
                                        lldb::DynamicValueType use_dynamic) { … }

SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) { … }

SBValueList SBFrame::GetRegisters() { … }

SBValue SBFrame::FindRegister(const char *name) { … }

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

bool SBFrame::GetDescription(SBStream &description) { … }

SBValue SBFrame::EvaluateExpression(const char *expr) { … }

SBValue
SBFrame::EvaluateExpression(const char *expr,
                            lldb::DynamicValueType fetch_dynamic_value) { … }

SBValue SBFrame::EvaluateExpression(const char *expr,
                                    lldb::DynamicValueType fetch_dynamic_value,
                                    bool unwind_on_error) { … }

lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
                                          const SBExpressionOptions &options) { … }

bool SBFrame::IsInlined() { … }

bool SBFrame::IsInlined() const { … }

bool SBFrame::IsArtificial() { … }

bool SBFrame::IsArtificial() const { … }

bool SBFrame::IsHidden() const { … }

const char *SBFrame::GetFunctionName() { … }

lldb::LanguageType SBFrame::GuessLanguage() const { … }

const char *SBFrame::GetFunctionName() const { … }

const char *SBFrame::GetDisplayFunctionName() { … }
llvm/lldb/source/API/SBFrame.cpp
