335 lines
9.0 KiB
C++
335 lines
9.0 KiB
C++
//===-- SBBlock.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/SBBlock.h"
|
|
#include "lldb/API/SBAddress.h"
|
|
#include "lldb/API/SBFileSpec.h"
|
|
#include "lldb/API/SBFrame.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBValue.h"
|
|
#include "lldb/Core/AddressRange.h"
|
|
#include "lldb/Core/ValueObjectVariable.h"
|
|
#include "lldb/Symbol/Block.h"
|
|
#include "lldb/Symbol/Function.h"
|
|
#include "lldb/Symbol/SymbolContext.h"
|
|
#include "lldb/Symbol/VariableList.h"
|
|
#include "lldb/Target/StackFrame.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Utility/Instrumentation.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
SBBlock::SBBlock() { LLDB_INSTRUMENT_VA(this); }
|
|
|
|
SBBlock::SBBlock(lldb_private::Block *lldb_object_ptr)
|
|
: m_opaque_ptr(lldb_object_ptr) {}
|
|
|
|
SBBlock::SBBlock(const SBBlock &rhs) : m_opaque_ptr(rhs.m_opaque_ptr) {
|
|
LLDB_INSTRUMENT_VA(this, rhs);
|
|
}
|
|
|
|
const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
|
|
LLDB_INSTRUMENT_VA(this, rhs);
|
|
|
|
m_opaque_ptr = rhs.m_opaque_ptr;
|
|
return *this;
|
|
}
|
|
|
|
SBBlock::~SBBlock() { m_opaque_ptr = nullptr; }
|
|
|
|
bool SBBlock::IsValid() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
return this->operator bool();
|
|
}
|
|
SBBlock::operator bool() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
return m_opaque_ptr != nullptr;
|
|
}
|
|
|
|
bool SBBlock::IsInlined() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
if (m_opaque_ptr)
|
|
return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr;
|
|
return false;
|
|
}
|
|
|
|
const char *SBBlock::GetInlinedName() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
if (m_opaque_ptr) {
|
|
const InlineFunctionInfo *inlined_info =
|
|
m_opaque_ptr->GetInlinedFunctionInfo();
|
|
if (inlined_info) {
|
|
return inlined_info->GetName().AsCString(nullptr);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
SBFileSpec SBBlock::GetInlinedCallSiteFile() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
SBFileSpec sb_file;
|
|
if (m_opaque_ptr) {
|
|
const InlineFunctionInfo *inlined_info =
|
|
m_opaque_ptr->GetInlinedFunctionInfo();
|
|
if (inlined_info)
|
|
sb_file.SetFileSpec(inlined_info->GetCallSite().GetFile());
|
|
}
|
|
return sb_file;
|
|
}
|
|
|
|
uint32_t SBBlock::GetInlinedCallSiteLine() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
if (m_opaque_ptr) {
|
|
const InlineFunctionInfo *inlined_info =
|
|
m_opaque_ptr->GetInlinedFunctionInfo();
|
|
if (inlined_info)
|
|
return inlined_info->GetCallSite().GetLine();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint32_t SBBlock::GetInlinedCallSiteColumn() const {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
if (m_opaque_ptr) {
|
|
const InlineFunctionInfo *inlined_info =
|
|
m_opaque_ptr->GetInlinedFunctionInfo();
|
|
if (inlined_info)
|
|
return inlined_info->GetCallSite().GetColumn();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void SBBlock::AppendVariables(bool can_create, bool get_parent_variables,
|
|
lldb_private::VariableList *var_list) {
|
|
if (IsValid()) {
|
|
bool show_inline = true;
|
|
m_opaque_ptr->AppendVariables(can_create, get_parent_variables, show_inline,
|
|
[](Variable *) { return true; }, var_list);
|
|
}
|
|
}
|
|
|
|
SBBlock SBBlock::GetParent() {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
SBBlock sb_block;
|
|
if (m_opaque_ptr)
|
|
sb_block.m_opaque_ptr = m_opaque_ptr->GetParent();
|
|
return sb_block;
|
|
}
|
|
|
|
lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
SBBlock sb_block;
|
|
if (m_opaque_ptr)
|
|
sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock();
|
|
return sb_block;
|
|
}
|
|
|
|
SBBlock SBBlock::GetSibling() {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
SBBlock sb_block;
|
|
if (m_opaque_ptr)
|
|
sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling();
|
|
return sb_block;
|
|
}
|
|
|
|
SBBlock SBBlock::GetFirstChild() {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
SBBlock sb_block;
|
|
if (m_opaque_ptr)
|
|
sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild();
|
|
return sb_block;
|
|
}
|
|
|
|
lldb_private::Block *SBBlock::GetPtr() { return m_opaque_ptr; }
|
|
|
|
void SBBlock::SetPtr(lldb_private::Block *block) { m_opaque_ptr = block; }
|
|
|
|
bool SBBlock::GetDescription(SBStream &description) {
|
|
LLDB_INSTRUMENT_VA(this, description);
|
|
|
|
Stream &strm = description.ref();
|
|
|
|
if (m_opaque_ptr) {
|
|
lldb::user_id_t id = m_opaque_ptr->GetID();
|
|
strm.Printf("Block: {id: %" PRIu64 "} ", id);
|
|
if (IsInlined()) {
|
|
strm.Printf(" (inlined, '%s') ", GetInlinedName());
|
|
}
|
|
lldb_private::SymbolContext sc;
|
|
m_opaque_ptr->CalculateSymbolContext(&sc);
|
|
if (sc.function) {
|
|
m_opaque_ptr->DumpAddressRanges(
|
|
&strm,
|
|
sc.function->GetAddressRange().GetBaseAddress().GetFileAddress());
|
|
}
|
|
} else
|
|
strm.PutCString("No value");
|
|
|
|
return true;
|
|
}
|
|
|
|
uint32_t SBBlock::GetNumRanges() {
|
|
LLDB_INSTRUMENT_VA(this);
|
|
|
|
if (m_opaque_ptr)
|
|
return m_opaque_ptr->GetNumRanges();
|
|
return 0;
|
|
}
|
|
|
|
lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
|
|
LLDB_INSTRUMENT_VA(this, idx);
|
|
|
|
lldb::SBAddress sb_addr;
|
|
if (m_opaque_ptr) {
|
|
AddressRange range;
|
|
if (m_opaque_ptr->GetRangeAtIndex(idx, range)) {
|
|
sb_addr.ref() = range.GetBaseAddress();
|
|
}
|
|
}
|
|
return sb_addr;
|
|
}
|
|
|
|
lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
|
|
LLDB_INSTRUMENT_VA(this, idx);
|
|
|
|
lldb::SBAddress sb_addr;
|
|
if (m_opaque_ptr) {
|
|
AddressRange range;
|
|
if (m_opaque_ptr->GetRangeAtIndex(idx, range)) {
|
|
sb_addr.ref() = range.GetBaseAddress();
|
|
sb_addr.ref().Slide(range.GetByteSize());
|
|
}
|
|
}
|
|
return sb_addr;
|
|
}
|
|
|
|
uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
|
|
LLDB_INSTRUMENT_VA(this, block_addr);
|
|
|
|
if (m_opaque_ptr && block_addr.IsValid()) {
|
|
return m_opaque_ptr->GetRangeIndexContainingAddress(block_addr.ref());
|
|
}
|
|
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
|
|
bool locals, bool statics,
|
|
lldb::DynamicValueType use_dynamic) {
|
|
LLDB_INSTRUMENT_VA(this, frame, arguments, locals, statics, use_dynamic);
|
|
|
|
Block *block = GetPtr();
|
|
SBValueList value_list;
|
|
if (block) {
|
|
StackFrameSP frame_sp(frame.GetFrameSP());
|
|
VariableListSP variable_list_sp(block->GetBlockVariableList(true));
|
|
|
|
if (variable_list_sp) {
|
|
const size_t num_variables = variable_list_sp->GetSize();
|
|
if (num_variables) {
|
|
for (size_t i = 0; i < num_variables; ++i) {
|
|
VariableSP variable_sp(variable_list_sp->GetVariableAtIndex(i));
|
|
if (variable_sp) {
|
|
bool add_variable = false;
|
|
switch (variable_sp->GetScope()) {
|
|
case eValueTypeVariableGlobal:
|
|
case eValueTypeVariableStatic:
|
|
case eValueTypeVariableThreadLocal:
|
|
add_variable = statics;
|
|
break;
|
|
|
|
case eValueTypeVariableArgument:
|
|
add_variable = arguments;
|
|
break;
|
|
|
|
case eValueTypeVariableLocal:
|
|
add_variable = locals;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (add_variable) {
|
|
if (frame_sp) {
|
|
lldb::ValueObjectSP valobj_sp(
|
|
frame_sp->GetValueObjectForFrameVariable(variable_sp,
|
|
eNoDynamicValues));
|
|
SBValue value_sb;
|
|
value_sb.SetSP(valobj_sp, use_dynamic);
|
|
value_list.Append(value_sb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return value_list;
|
|
}
|
|
|
|
lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
|
|
bool locals, bool statics) {
|
|
LLDB_INSTRUMENT_VA(this, target, arguments, locals, statics);
|
|
|
|
Block *block = GetPtr();
|
|
|
|
SBValueList value_list;
|
|
if (block) {
|
|
TargetSP target_sp(target.GetSP());
|
|
|
|
VariableListSP variable_list_sp(block->GetBlockVariableList(true));
|
|
|
|
if (variable_list_sp) {
|
|
const size_t num_variables = variable_list_sp->GetSize();
|
|
if (num_variables) {
|
|
for (size_t i = 0; i < num_variables; ++i) {
|
|
VariableSP variable_sp(variable_list_sp->GetVariableAtIndex(i));
|
|
if (variable_sp) {
|
|
bool add_variable = false;
|
|
switch (variable_sp->GetScope()) {
|
|
case eValueTypeVariableGlobal:
|
|
case eValueTypeVariableStatic:
|
|
case eValueTypeVariableThreadLocal:
|
|
add_variable = statics;
|
|
break;
|
|
|
|
case eValueTypeVariableArgument:
|
|
add_variable = arguments;
|
|
break;
|
|
|
|
case eValueTypeVariableLocal:
|
|
add_variable = locals;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (add_variable) {
|
|
if (target_sp)
|
|
value_list.Append(
|
|
ValueObjectVariable::Create(target_sp.get(), variable_sp));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return value_list;
|
|
}
|