RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 14:07:45 +00:00
Code Issues Activity Actions

LibDebug: Don't expose AttributeValue internals, use getters instead

Browse source 
This will be needed when we add `DW_FORM_strx*` and `DW_FORM_addrx*`
support, which requires us to fetch `DW_AT_str_offsets_base` and
`DW_AT_addr_base` attributes from the parent compilation unit. This
can't be done as we read the values, because it would create infinite
recursion (as we might try to parse the compilation unit's
`DW_FORM_strx*` encoded name before we get to the attribute). Having
getters ensures that we will perform lookups if they are needed.
This commit is contained in:
Daniel Bertalan 2021-10-09 16:58:48 +02:00 • committed by Linus Groh
parent 1b63c8f3b0
commit 8e5b70a0ba
6 changed files with 101 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

51
Userland/Libraries/LibDebug/DebugInfo.cpp
View file

@ -54,15 +54,18 @@ void DebugInfo::parse_scopes_impl(Dwarf::DIE const& die)
VariablesScope scope {}; VariablesScope scope {};
scope.is_function = (child.tag() == Dwarf::EntryTag::SubProgram); scope.is_function = (child.tag() == Dwarf::EntryTag::SubProgram);
if (name.has_value()) if (name.has_value())
scope.name = name.value().data.as_string; scope.name = name.value().as_string();
if (!child.get_attribute(Dwarf::Attribute::LowPc).has_value()) { if (!child.get_attribute(Dwarf::Attribute::LowPc).has_value()) {
dbgln_if(SPAM_DEBUG, "DWARF: Couldn't find attribute LowPc for scope"); dbgln_if(SPAM_DEBUG, "DWARF: Couldn't find attribute LowPc for scope");
return; return;
} }
scope.address_low = child.get_attribute(Dwarf::Attribute::LowPc).value().data.as_addr; scope.address_low = child.get_attribute(Dwarf::Attribute::LowPc).value().as_addr();
// The attribute name HighPc is confusing. In this context, it seems to actually be a positive offset from LowPc auto high_pc = child.get_attribute(Dwarf::Attribute::HighPc);
scope.address_high = scope.address_low + child.get_attribute(Dwarf::Attribute::HighPc).value().data.as_addr; if (high_pc->type() == Dwarf::AttributeValue::Type::Address)
scope.address_high = high_pc->as_addr();
else
scope.address_high = scope.address_low + high_pc->as_unsigned();
child.for_each_child([&](Dwarf::DIE const& variable_entry) { child.for_each_child([&](Dwarf::DIE const& variable_entry) {
if (!(variable_entry.tag() == Dwarf::EntryTag::Variable if (!(variable_entry.tag() == Dwarf::EntryTag::Variable
@ -187,12 +190,12 @@ static Optional<Dwarf::DIE> parse_variable_type_die(Dwarf::DIE const& variable_d
if (!type_die_offset.has_value()) if (!type_die_offset.has_value())
return {}; return {};
VERIFY(type_die_offset.value().type == Dwarf::AttributeValue::Type::DieReference); VERIFY(type_die_offset.value().type() == Dwarf::AttributeValue::Type::DieReference);
auto type_die = variable_die.compilation_unit().get_die_at_offset(type_die_offset.value().data.as_unsigned); auto type_die = variable_die.compilation_unit().get_die_at_offset(type_die_offset.value().as_unsigned());
auto type_name = type_die.get_attribute(Dwarf::Attribute::Name); auto type_name = type_die.get_attribute(Dwarf::Attribute::Name);
if (type_name.has_value()) { if (type_name.has_value()) {
variable_info.type_name = type_name.value().data.as_string; variable_info.type_name = type_name.value().as_string();
} else { } else {
dbgln("Unnamed DWARF type at offset: {}", type_die.offset()); dbgln("Unnamed DWARF type at offset: {}", type_die.offset());
variable_info.type_name = "[Unnamed Type]"; variable_info.type_name = "[Unnamed Type]";
@ -211,13 +214,13 @@ static void parse_variable_location(Dwarf::DIE const& variable_die, DebugInfo::V
if (!location_info.has_value()) if (!location_info.has_value())
return; return;
switch (location_info.value().type) { switch (location_info.value().type()) {
case Dwarf::AttributeValue::Type::UnsignedNumber: case Dwarf::AttributeValue::Type::UnsignedNumber:
variable_info.location_type = DebugInfo::VariableInfo::LocationType::Address; variable_info.location_type = DebugInfo::VariableInfo::LocationType::Address;
variable_info.location_data.address = location_info.value().data.as_addr; variable_info.location_data.address = location_info.value().as_unsigned();
break; break;
case Dwarf::AttributeValue::Type::DwarfExpression: { case Dwarf::AttributeValue::Type::DwarfExpression: {
auto expression_bytes = ReadonlyBytes { location_info.value().data.as_raw_bytes.bytes, location_info.value().data.as_raw_bytes.length }; auto expression_bytes = location_info.value().as_raw_bytes();
auto value = Dwarf::Expression::evaluate(expression_bytes, regs); auto value = Dwarf::Expression::evaluate(expression_bytes, regs);
if (value.type != Dwarf::Expression::Type::None) { if (value.type != Dwarf::Expression::Type::None) {
@ -228,7 +231,7 @@ static void parse_variable_location(Dwarf::DIE const& variable_die, DebugInfo::V
break; break;
} }
default: default:
dbgln("Warning: unhandled Dwarf location type: {}", (int)location_info.value().type); dbgln("Warning: unhandled Dwarf location type: {}", (int)location_info.value().type());
} }
} }
@ -245,22 +248,22 @@ OwnPtr<DebugInfo::VariableInfo> DebugInfo::create_variable_info(Dwarf::DIE const
NonnullOwnPtr<VariableInfo> variable_info = make<VariableInfo>(); NonnullOwnPtr<VariableInfo> variable_info = make<VariableInfo>();
auto name_attribute = variable_die.get_attribute(Dwarf::Attribute::Name); auto name_attribute = variable_die.get_attribute(Dwarf::Attribute::Name);
if (name_attribute.has_value()) if (name_attribute.has_value())
variable_info->name = name_attribute.value().data.as_string; variable_info->name = name_attribute.value().as_string();
auto type_die = parse_variable_type_die(variable_die, *variable_info); auto type_die = parse_variable_type_die(variable_die, *variable_info);
if (variable_die.tag() == Dwarf::EntryTag::Enumerator) { if (variable_die.tag() == Dwarf::EntryTag::Enumerator) {
auto constant = variable_die.get_attribute(Dwarf::Attribute::ConstValue); auto constant = variable_die.get_attribute(Dwarf::Attribute::ConstValue);
VERIFY(constant.has_value()); VERIFY(constant.has_value());
switch (constant.value().type) { switch (constant.value().type()) {
case Dwarf::AttributeValue::Type::UnsignedNumber: case Dwarf::AttributeValue::Type::UnsignedNumber:
variable_info->constant_data.as_u32 = constant.value().data.as_unsigned; variable_info->constant_data.as_u32 = constant.value().as_unsigned();
break; break;
case Dwarf::AttributeValue::Type::SignedNumber: case Dwarf::AttributeValue::Type::SignedNumber:
variable_info->constant_data.as_i32 = constant.value().data.as_signed; variable_info->constant_data.as_i32 = constant.value().as_signed();
break; break;
case Dwarf::AttributeValue::Type::String: case Dwarf::AttributeValue::Type::String:
variable_info->constant_data.as_string = constant.value().data.as_string; variable_info->constant_data.as_string = constant.value().as_string();
break; break;
default: default:
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
@ -294,7 +297,7 @@ void DebugInfo::add_type_info_to_variable(Dwarf::DIE const& type_die, PtraceRegi
if (is_array_type && member.tag() == Dwarf::EntryTag::SubRangeType) { if (is_array_type && member.tag() == Dwarf::EntryTag::SubRangeType) {
auto upper_bound = member.get_attribute(Dwarf::Attribute::UpperBound); auto upper_bound = member.get_attribute(Dwarf::Attribute::UpperBound);
VERIFY(upper_bound.has_value()); VERIFY(upper_bound.has_value());
auto size = upper_bound.value().data.as_unsigned + 1; auto size = upper_bound.value().as_unsigned() + 1;
type_info->dimension_sizes.append(size); type_info->dimension_sizes.append(size);
return; return;
} }
@ -428,12 +431,12 @@ Optional<Dwarf::LineProgram::DirectoryAndFile> DebugInfo::get_source_path_of_inl
if (caller_file.has_value()) { if (caller_file.has_value()) {
u32 file_index = 0; u32 file_index = 0;
if (caller_file->type == Dwarf::AttributeValue::Type::UnsignedNumber) { if (caller_file->type() == Dwarf::AttributeValue::Type::UnsignedNumber) {
file_index = caller_file->data.as_unsigned; file_index = caller_file->as_unsigned();
} else if (caller_file->type == Dwarf::AttributeValue::Type::SignedNumber) { } else if (caller_file->type() == Dwarf::AttributeValue::Type::SignedNumber) {
// For some reason, the file_index is sometimes stored as a signed number. // For some reason, the file_index is sometimes stored as a signed number.
VERIFY(caller_file->data.as_signed >= 0); VERIFY(caller_file->as_signed() >= 0);
file_index = (u32)caller_file->data.as_signed; file_index = (u32)caller_file->as_signed();
} else { } else {
return {}; return {};
} }
@ -449,9 +452,9 @@ Optional<uint32_t> DebugInfo::get_line_of_inline(Dwarf::DIE const& die) const
if (!caller_line.has_value()) if (!caller_line.has_value())
return {}; return {};
if (caller_line->type != Dwarf::AttributeValue::Type::UnsignedNumber) if (caller_line->type() != Dwarf::AttributeValue::Type::UnsignedNumber)
return {}; return {};
return caller_line.value().data.as_unsigned; return caller_line.value().as_unsigned();
} }
} }

34
Userland/Libraries/LibDebug/Dwarf/AttributeValue.h
View file

@ -6,12 +6,18 @@
#pragma once #pragma once
#include <AK/Span.h>
#include <AK/Types.h> #include <AK/Types.h>
#include <LibDebug/Dwarf/DwarfTypes.h> #include <LibDebug/Dwarf/DwarfTypes.h>
namespace Debug::Dwarf { namespace Debug::Dwarf {
struct AttributeValue { class CompilationUnit;
class AttributeValue {
friend class DwarfInfo;
public:
enum class Type : u8 { enum class Type : u8 {
UnsignedNumber, UnsignedNumber,
SignedNumber, SignedNumber,
@ -21,21 +27,33 @@ struct AttributeValue {
DwarfExpression, DwarfExpression,
SecOffset, SecOffset,
RawBytes, RawBytes,
} type; Address
};
Type type() const { return m_type; }
AttributeDataForm form() const { return m_form; }
FlatPtr as_addr() const { return m_data.as_addr; }
u64 as_unsigned() const { return m_data.as_unsigned; }
i64 as_signed() const { return m_data.as_signed; }
const char* as_string() const { return m_data.as_string; }
bool as_bool() const { return m_data.as_bool; }
ReadonlyBytes as_raw_bytes() const { return m_data.as_raw_bytes; }
private:
Type m_type;
union { union {
FlatPtr as_addr; FlatPtr as_addr;
u64 as_unsigned; u64 as_unsigned;
i64 as_signed; i64 as_signed;
const char* as_string; // points to bytes in the memory mapped elf image const char* as_string; // points to bytes in the memory mapped elf image
bool as_bool; bool as_bool;
struct { ReadonlyBytes as_raw_bytes;
u32 length; } m_data {};
const u8* bytes; // points to bytes in the memory mapped elf image
} as_raw_bytes;
} data {};
AttributeDataForm form {}; AttributeDataForm m_form {};
CompilationUnit const* m_compilation_unit { nullptr };
}; };
} }

2
Userland/Libraries/LibDebug/Dwarf/CompilationUnit.cpp
View file

@ -38,7 +38,7 @@ Optional<FlatPtr> CompilationUnit::base_address() const
auto die = root_die(); auto die = root_die();
auto res = die.get_attribute(Attribute::LowPc); auto res = die.get_attribute(Attribute::LowPc);
if (res.has_value()) { if (res.has_value()) {
m_cached_base_address = res->data.as_addr; m_cached_base_address = res->as_addr();
} }
m_has_cached_base_address = true; m_has_cached_base_address = true;
return m_cached_base_address; return m_cached_base_address;

2
Userland/Libraries/LibDebug/Dwarf/DIE.cpp
View file

@ -81,7 +81,7 @@ void DIE::for_each_child(Function<void(DIE const& child)> callback) const
auto sibling = current_child.get_attribute(Attribute::Sibling); auto sibling = current_child.get_attribute(Attribute::Sibling);
u32 sibling_offset = 0; u32 sibling_offset = 0;
if (sibling.has_value()) { if (sibling.has_value()) {
sibling_offset = sibling.value().data.as_unsigned; sibling_offset = sibling.value().as_unsigned();
} else { } else {
// NOTE: According to the spec, the compiler doesn't have to supply the sibling information. // NOTE: According to the spec, the compiler doesn't have to supply the sibling information.
// When it doesn't, we have to recursively iterate the current child's children to find where they end // When it doesn't, we have to recursively iterate the current child's children to find where they end

88
Userland/Libraries/LibDebug/Dwarf/DwarfInfo.cpp
View file

@ -66,14 +66,14 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
InputMemoryStream& debug_info_stream, const CompilationUnit* unit) const InputMemoryStream& debug_info_stream, const CompilationUnit* unit) const
{ {
AttributeValue value; AttributeValue value;
value.form = form; value.m_form = form;
value.m_compilation_unit = unit;
auto assign_raw_bytes_value = [&](size_t length) { auto assign_raw_bytes_value = [&](size_t length) {
value.data.as_raw_bytes.length = length; value.m_data.as_raw_bytes = { reinterpret_cast<const u8*>(debug_info_data().data() + debug_info_stream.offset()), length };
value.data.as_raw_bytes.bytes = reinterpret_cast<const u8*>(debug_info_data().data()
+ debug_info_stream.offset());
debug_info_stream.discard_or_error(length); debug_info_stream.discard_or_error(length);
VERIFY(!debug_info_stream.has_any_error());
}; };
switch (form) { switch (form) {
@ -81,95 +81,95 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
u32 offset; u32 offset;
debug_info_stream >> offset; debug_info_stream >> offset;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::String; value.m_type = AttributeValue::Type::String;
auto strings_data = debug_strings_data(); auto strings_data = debug_strings_data();
value.data.as_string = reinterpret_cast<const char*>(strings_data.data() + offset); value.m_data.as_string = reinterpret_cast<const char*>(strings_data.data() + offset);
break; break;
} }
case AttributeDataForm::Data1: { case AttributeDataForm::Data1: {
u8 data; u8 data;
debug_info_stream >> data; debug_info_stream >> data;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::UnsignedNumber; value.m_type = AttributeValue::Type::UnsignedNumber;
value.data.as_unsigned = data; value.m_data.as_unsigned = data;
break; break;
} }
case AttributeDataForm::Data2: { case AttributeDataForm::Data2: {
u16 data; u16 data;
debug_info_stream >> data; debug_info_stream >> data;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::UnsignedNumber; value.m_type = AttributeValue::Type::UnsignedNumber;
value.data.as_signed = data; value.m_data.as_signed = data;
break; break;
} }
case AttributeDataForm::Addr: { case AttributeDataForm::Addr: {
FlatPtr address; FlatPtr address;
debug_info_stream >> address; debug_info_stream >> address;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::UnsignedNumber; value.m_type = AttributeValue::Type::Address;
value.data.as_addr = address; value.m_data.as_addr = address;
break; break;
} }
case AttributeDataForm::SData: { case AttributeDataForm::SData: {
i64 data; i64 data;
debug_info_stream.read_LEB128_signed(data); debug_info_stream.read_LEB128_signed(data);
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::SignedNumber; value.m_type = AttributeValue::Type::SignedNumber;
value.data.as_signed = data; value.m_data.as_signed = data;
break; break;
} }
case AttributeDataForm::UData: { case AttributeDataForm::UData: {
u64 data; u64 data;
debug_info_stream.read_LEB128_unsigned(data); debug_info_stream.read_LEB128_unsigned(data);
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::UnsignedNumber; value.m_type = AttributeValue::Type::UnsignedNumber;
value.data.as_unsigned = data; value.m_data.as_unsigned = data;
break; break;
} }
case AttributeDataForm::SecOffset: { case AttributeDataForm::SecOffset: {
u32 data; u32 data;
debug_info_stream >> data; debug_info_stream >> data;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::SecOffset; value.m_type = AttributeValue::Type::SecOffset;
value.data.as_unsigned = data; value.m_data.as_unsigned = data;
break; break;
} }
case AttributeDataForm::Data4: { case AttributeDataForm::Data4: {
u32 data; u32 data;
debug_info_stream >> data; debug_info_stream >> data;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::UnsignedNumber; value.m_type = AttributeValue::Type::UnsignedNumber;
value.data.as_unsigned = data; value.m_data.as_unsigned = data;
break; break;
} }
case AttributeDataForm::Data8: { case AttributeDataForm::Data8: {
u64 data; u64 data;
debug_info_stream >> data; debug_info_stream >> data;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::UnsignedNumber; value.m_type = AttributeValue::Type::UnsignedNumber;
value.data.as_unsigned = data; value.m_data.as_unsigned = data;
break; break;
} }
case AttributeDataForm::Ref4: { case AttributeDataForm::Ref4: {
u32 data; u32 data;
debug_info_stream >> data; debug_info_stream >> data;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::DieReference; value.m_type = AttributeValue::Type::DieReference;
VERIFY(unit); VERIFY(unit);
value.data.as_unsigned = data + unit->offset(); value.m_data.as_unsigned = data + unit->offset();
break; break;
} }
case AttributeDataForm::FlagPresent: { case AttributeDataForm::FlagPresent: {
value.type = AttributeValue::Type::Boolean; value.m_type = AttributeValue::Type::Boolean;
value.data.as_bool = true; value.m_data.as_bool = true;
break; break;
} }
case AttributeDataForm::ExprLoc: { case AttributeDataForm::ExprLoc: {
size_t length; size_t length;
debug_info_stream.read_LEB128_unsigned(length); debug_info_stream.read_LEB128_unsigned(length);
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::DwarfExpression; value.m_type = AttributeValue::Type::DwarfExpression;
assign_raw_bytes_value(length); assign_raw_bytes_value(length);
break; break;
} }
@ -178,12 +178,12 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
u32 str_offset = debug_info_stream.offset(); u32 str_offset = debug_info_stream.offset();
debug_info_stream >> str; debug_info_stream >> str;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::String; value.m_type = AttributeValue::Type::String;
value.data.as_string = reinterpret_cast<const char*>(str_offset + debug_info_data().data()); value.m_data.as_string = reinterpret_cast<const char*>(str_offset + debug_info_data().data());
break; break;
} }
case AttributeDataForm::Block1: { case AttributeDataForm::Block1: {
value.type = AttributeValue::Type::RawBytes; value.m_type = AttributeValue::Type::RawBytes;
u8 length; u8 length;
debug_info_stream >> length; debug_info_stream >> length;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
@ -191,7 +191,7 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
break; break;
} }
case AttributeDataForm::Block2: { case AttributeDataForm::Block2: {
value.type = AttributeValue::Type::RawBytes; value.m_type = AttributeValue::Type::RawBytes;
u16 length; u16 length;
debug_info_stream >> length; debug_info_stream >> length;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
@ -199,7 +199,7 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
break; break;
} }
case AttributeDataForm::Block4: { case AttributeDataForm::Block4: {
value.type = AttributeValue::Type::RawBytes; value.m_type = AttributeValue::Type::RawBytes;
u32 length; u32 length;
debug_info_stream >> length; debug_info_stream >> length;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
@ -207,7 +207,7 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
break; break;
} }
case AttributeDataForm::Block: { case AttributeDataForm::Block: {
value.type = AttributeValue::Type::RawBytes; value.m_type = AttributeValue::Type::RawBytes;
size_t length; size_t length;
debug_info_stream.read_LEB128_unsigned(length); debug_info_stream.read_LEB128_unsigned(length);
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
@ -218,16 +218,16 @@ AttributeValue DwarfInfo::get_attribute_value(AttributeDataForm form, ssize_t im
u32 offset; u32 offset;
debug_info_stream >> offset; debug_info_stream >> offset;
VERIFY(!debug_info_stream.has_any_error()); VERIFY(!debug_info_stream.has_any_error());
value.type = AttributeValue::Type::String; value.m_type = AttributeValue::Type::String;
auto strings_data = debug_line_strings_data(); auto strings_data = debug_line_strings_data();
value.data.as_string = reinterpret_cast<const char*>(strings_data.data() + offset); value.m_data.as_string = reinterpret_cast<const char*>(strings_data.data() + offset);
break; break;
} }
case AttributeDataForm::ImplicitConst: { case AttributeDataForm::ImplicitConst: {
/* Value is part of the abbreviation record. */ /* Value is part of the abbreviation record. */
value.type = AttributeValue::Type::SignedNumber; value.m_type = AttributeValue::Type::SignedNumber;
value.data.as_signed = implicit_const_value; value.m_data.as_signed = implicit_const_value;
break; break;
} }
default: default:
@ -247,9 +247,9 @@ void DwarfInfo::build_cached_dies() const
auto ranges = die.get_attribute(Attribute::Ranges); auto ranges = die.get_attribute(Attribute::Ranges);
if (ranges.has_value()) { if (ranges.has_value()) {
// TODO Support DW_FORM_rnglistx // TODO Support DW_FORM_rnglistx
if (ranges->form != AttributeDataForm::SecOffset) if (ranges->form() != AttributeDataForm::SecOffset)
return {}; return {};
auto offset = ranges->data.as_addr; auto offset = ranges->as_unsigned();
AddressRanges address_ranges(debug_range_lists_data(), offset, die.compilation_unit()); AddressRanges address_ranges(debug_range_lists_data(), offset, die.compilation_unit());
Vector<DIERange> entries; Vector<DIERange> entries;
address_ranges.for_each_range([&entries](auto range) { address_ranges.for_each_range([&entries](auto range) {
@ -264,18 +264,18 @@ void DwarfInfo::build_cached_dies() const
if (!start.has_value() || !end.has_value()) if (!start.has_value() || !end.has_value())
return {}; return {};
VERIFY(start->form == Dwarf::AttributeDataForm::Addr); VERIFY(start->type() == Dwarf::AttributeValue::Type::Address);
// DW_AT_high_pc attribute can have different meanings depending on the attribute form. // DW_AT_high_pc attribute can have different meanings depending on the attribute form.
// (Dwarf version 5, section 2.17.2). // (Dwarf version 5, section 2.17.2).
uint32_t range_end = 0; uint32_t range_end = 0;
if (end->form == Dwarf::AttributeDataForm::Addr) if (end->form() == Dwarf::AttributeDataForm::Addr)
range_end = end->data.as_addr; range_end = end->as_addr();
else else
range_end = start->data.as_unsigned + end->data.as_unsigned; range_end = start->as_addr() + end->as_unsigned();
return { DIERange { (FlatPtr)start.value().data.as_addr, range_end } }; return { DIERange { start.value().as_addr(), range_end } };
}; };
// If we simply use a lambda, type deduction fails because it's used recursively. // If we simply use a lambda, type deduction fails because it's used recursively.

4
Userland/Libraries/LibDebug/Dwarf/LineProgram.cpp
View file

@ -60,10 +60,10 @@ void LineProgram::parse_path_entries(Function<void(PathEntry& entry)> callback,
auto value = m_dwarf_info.get_attribute_value(format_description.form, 0, m_stream); auto value = m_dwarf_info.get_attribute_value(format_description.form, 0, m_stream);
switch (format_description.type) { switch (format_description.type) {
case ContentType::Path: case ContentType::Path:
entry.path = value.data.as_string; entry.path = value.as_string();
break; break;
case ContentType::DirectoryIndex: case ContentType::DirectoryIndex:
entry.directory_index = value.data.as_unsigned; entry.directory_index = value.as_unsigned();
break; break;
default: default:
dbgln_if(DWARF_DEBUG, "Unhandled path list attribute: {}", (int)format_description.type); dbgln_if(DWARF_DEBUG, "Unhandled path list attribute: {}", (int)format_description.type);