blob: 5c49053dd972eb1df3e80e27e128ecc737a2c47f [file] [log] [blame]
//===-- 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 "SBReproducerPrivate.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"
using namespace lldb;
using namespace lldb_private;
SBBlock::SBBlock() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBBlock); }
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_RECORD_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &), rhs);
}
const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
LLDB_RECORD_METHOD(const lldb::SBBlock &,
SBBlock, operator=,(const lldb::SBBlock &), rhs);
m_opaque_ptr = rhs.m_opaque_ptr;
return LLDB_RECORD_RESULT(*this);
}
SBBlock::~SBBlock() { m_opaque_ptr = nullptr; }
bool SBBlock::IsValid() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsValid);
return this->operator bool();
}
SBBlock::operator bool() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, operator bool);
return m_opaque_ptr != nullptr;
}
bool SBBlock::IsInlined() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBBlock, IsInlined);
if (m_opaque_ptr)
return m_opaque_ptr->GetInlinedFunctionInfo() != nullptr;
return false;
}
const char *SBBlock::GetInlinedName() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBBlock, GetInlinedName);
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_RECORD_METHOD_CONST_NO_ARGS(lldb::SBFileSpec, SBBlock,
GetInlinedCallSiteFile);
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 LLDB_RECORD_RESULT(sb_file);
}
uint32_t SBBlock::GetInlinedCallSiteLine() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteLine);
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_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBBlock, GetInlinedCallSiteColumn);
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_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetParent);
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetParent();
return LLDB_RECORD_RESULT(sb_block);
}
lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetContainingInlinedBlock);
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetContainingInlinedBlock();
return LLDB_RECORD_RESULT(sb_block);
}
SBBlock SBBlock::GetSibling() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetSibling);
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetSibling();
return LLDB_RECORD_RESULT(sb_block);
}
SBBlock SBBlock::GetFirstChild() {
LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBBlock, GetFirstChild);
SBBlock sb_block;
if (m_opaque_ptr)
sb_block.m_opaque_ptr = m_opaque_ptr->GetFirstChild();
return LLDB_RECORD_RESULT(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_RECORD_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &),
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_RECORD_METHOD_NO_ARGS(uint32_t, SBBlock, GetNumRanges);
if (m_opaque_ptr)
return m_opaque_ptr->GetNumRanges();
return 0;
}
lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress, (uint32_t),
idx);
lldb::SBAddress sb_addr;
if (m_opaque_ptr) {
AddressRange range;
if (m_opaque_ptr->GetRangeAtIndex(idx, range)) {
sb_addr.ref() = range.GetBaseAddress();
}
}
return LLDB_RECORD_RESULT(sb_addr);
}
lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
LLDB_RECORD_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress, (uint32_t),
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 LLDB_RECORD_RESULT(sb_addr);
}
uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
LLDB_RECORD_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
(lldb::SBAddress), 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_RECORD_METHOD(
lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType), 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 LLDB_RECORD_RESULT(value_list);
}
lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,
bool locals, bool statics) {
LLDB_RECORD_METHOD(lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBTarget &, bool, bool, bool), 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 LLDB_RECORD_RESULT(value_list);
}
namespace lldb_private {
namespace repro {
template <>
void RegisterMethods<SBBlock>(Registry &R) {
LLDB_REGISTER_CONSTRUCTOR(SBBlock, ());
LLDB_REGISTER_CONSTRUCTOR(SBBlock, (const lldb::SBBlock &));
LLDB_REGISTER_METHOD(const lldb::SBBlock &,
SBBlock, operator=,(const lldb::SBBlock &));
LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsValid, ());
LLDB_REGISTER_METHOD_CONST(bool, SBBlock, operator bool, ());
LLDB_REGISTER_METHOD_CONST(bool, SBBlock, IsInlined, ());
LLDB_REGISTER_METHOD_CONST(const char *, SBBlock, GetInlinedName, ());
LLDB_REGISTER_METHOD_CONST(lldb::SBFileSpec, SBBlock,
GetInlinedCallSiteFile, ());
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteLine, ());
LLDB_REGISTER_METHOD_CONST(uint32_t, SBBlock, GetInlinedCallSiteColumn, ());
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetParent, ());
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetContainingInlinedBlock, ());
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetSibling, ());
LLDB_REGISTER_METHOD(lldb::SBBlock, SBBlock, GetFirstChild, ());
LLDB_REGISTER_METHOD(bool, SBBlock, GetDescription, (lldb::SBStream &));
LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetNumRanges, ());
LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeStartAddress,
(uint32_t));
LLDB_REGISTER_METHOD(lldb::SBAddress, SBBlock, GetRangeEndAddress,
(uint32_t));
LLDB_REGISTER_METHOD(uint32_t, SBBlock, GetRangeIndexForBlockAddress,
(lldb::SBAddress));
LLDB_REGISTER_METHOD(
lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBFrame &, bool, bool, bool, lldb::DynamicValueType));
LLDB_REGISTER_METHOD(lldb::SBValueList, SBBlock, GetVariables,
(lldb::SBTarget &, bool, bool, bool));
}
}
}