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

LibDebug: Parse DWARF address ranges using Core::Stream

Browse source
This commit is contained in:
Tim Schumacher 2023-01-21 12:50:04 +01:00 • committed by Andreas Kling
parent 908b88db34
commit e235c42e4d
3 changed files with 56 additions and 50 deletions
Download patch file Download diff file Expand all files Collapse all files

68
Userland/Libraries/LibDebug/Dwarf/AddressRanges.cpp
View file

@ -6,34 +6,34 @@
#include "AddressRanges.h" #include "AddressRanges.h"
#include "DwarfTypes.h" #include "DwarfTypes.h"
#include <AK/LEB128.h>
#include <LibCore/Stream.h>
namespace Debug::Dwarf { namespace Debug::Dwarf {
AddressRangesV5::AddressRangesV5(ReadonlyBytes range_lists_data, size_t offset, CompilationUnit const& compilation_unit) AddressRangesV5::AddressRangesV5(NonnullOwnPtr<Core::Stream::Stream> range_lists_stream, CompilationUnit const& compilation_unit)
: m_range_lists_stream(range_lists_data) : m_range_lists_stream(move(range_lists_stream))
, m_compilation_unit(compilation_unit) , m_compilation_unit(compilation_unit)
{ {
m_range_lists_stream.seek(offset);
} }
void AddressRangesV5::for_each_range(Function<void(Range)> callback) ErrorOr<void> AddressRangesV5::for_each_range(Function<void(Range)> callback)
{ {
// Dwarf version 5, section 2.17.3 "Non-Contiguous Address Ranges" // Dwarf version 5, section 2.17.3 "Non-Contiguous Address Ranges"
Core::Stream::WrapInAKInputStream wrapped_range_lists_stream { *m_range_lists_stream };
Optional<FlatPtr> current_base_address; Optional<FlatPtr> current_base_address;
while (!m_range_lists_stream.eof() && !m_range_lists_stream.has_any_error()) { while (!m_range_lists_stream->is_eof()) {
u8 entry_type; auto entry_type = TRY(m_range_lists_stream->read_value<u8>());
m_range_lists_stream >> entry_type;
switch (static_cast<RangeListEntryType>(entry_type)) { switch (static_cast<RangeListEntryType>(entry_type)) {
case RangeListEntryType::BaseAddress: { case RangeListEntryType::BaseAddress: {
FlatPtr base; current_base_address = TRY(m_range_lists_stream->read_value<FlatPtr>());
m_range_lists_stream >> base;
current_base_address = base;
break; break;
} }
case RangeListEntryType::BaseAddressX: { case RangeListEntryType::BaseAddressX: {
FlatPtr index; FlatPtr index;
m_range_lists_stream.read_LEB128_unsigned(index); LEB128::read_unsigned(wrapped_range_lists_stream, index);
current_base_address = m_compilation_unit.get_address(index); current_base_address = m_compilation_unit.get_address(index);
break; break;
} }
@ -43,68 +43,66 @@ void AddressRangesV5::for_each_range(Function<void(Range)> callback)
base_address = m_compilation_unit.base_address(); base_address = m_compilation_unit.base_address();
} }
if (!base_address.has_value()) { if (!base_address.has_value())
dbgln("expected base_address for rangelist"); return Error::from_string_literal("Expected base_address for rangelist");
return;
}
size_t start_offset, end_offset; size_t start_offset, end_offset;
m_range_lists_stream.read_LEB128_unsigned(start_offset); LEB128::read_unsigned(wrapped_range_lists_stream, start_offset);
m_range_lists_stream.read_LEB128_unsigned(end_offset); LEB128::read_unsigned(wrapped_range_lists_stream, end_offset);
callback(Range { start_offset + *base_address, end_offset + *base_address }); callback(Range { start_offset + *base_address, end_offset + *base_address });
break; break;
} }
case RangeListEntryType::StartLength: { case RangeListEntryType::StartLength: {
FlatPtr start; auto start = TRY(m_range_lists_stream->read_value<FlatPtr>());
m_range_lists_stream >> start;
size_t length; size_t length;
m_range_lists_stream.read_LEB128_unsigned(length); LEB128::read_unsigned(wrapped_range_lists_stream, length);
callback(Range { start, start + length }); callback(Range { start, start + length });
break; break;
} }
case RangeListEntryType::StartXEndX: { case RangeListEntryType::StartXEndX: {
size_t start, end; size_t start, end;
m_range_lists_stream.read_LEB128_unsigned(start); LEB128::read_unsigned(wrapped_range_lists_stream, start);
m_range_lists_stream.read_LEB128_unsigned(end); LEB128::read_unsigned(wrapped_range_lists_stream, end);
callback(Range { m_compilation_unit.get_address(start), m_compilation_unit.get_address(end) }); callback(Range { m_compilation_unit.get_address(start), m_compilation_unit.get_address(end) });
break; break;
} }
case RangeListEntryType::StartXLength: { case RangeListEntryType::StartXLength: {
size_t start, length; size_t start, length;
m_range_lists_stream.read_LEB128_unsigned(start); LEB128::read_unsigned(wrapped_range_lists_stream, start);
m_range_lists_stream.read_LEB128_unsigned(length); LEB128::read_unsigned(wrapped_range_lists_stream, length);
auto start_addr = m_compilation_unit.get_address(start); auto start_addr = m_compilation_unit.get_address(start);
callback(Range { start_addr, start_addr + length }); callback(Range { start_addr, start_addr + length });
break; break;
} }
case RangeListEntryType::EndOfList: case RangeListEntryType::EndOfList:
return; return {};
default: default:
dbgln("unsupported range list entry type: 0x{:x}", entry_type); dbgln("unsupported range list entry type: 0x{:x}", entry_type);
return; return Error::from_string_literal("Unsupported range list entry type");
} }
} }
return {};
} }
AddressRangesV4::AddressRangesV4(ReadonlyBytes ranges_data, size_t offset, CompilationUnit const& compilation_unit) AddressRangesV4::AddressRangesV4(NonnullOwnPtr<Core::Stream::Stream> ranges_stream, CompilationUnit const& compilation_unit)
: m_ranges_stream(ranges_data) : m_ranges_stream(move(ranges_stream))
, m_compilation_unit(compilation_unit) , m_compilation_unit(compilation_unit)
{ {
m_ranges_stream.seek(offset);
} }
void AddressRangesV4::for_each_range(Function<void(Range)> callback) ErrorOr<void> AddressRangesV4::for_each_range(Function<void(Range)> callback)
{ {
// Dwarf version 4, section 2.17.3 "Non-Contiguous Address Ranges" // Dwarf version 4, section 2.17.3 "Non-Contiguous Address Ranges"
Optional<FlatPtr> current_base_address; Optional<FlatPtr> current_base_address;
while (!m_ranges_stream.eof() && !m_ranges_stream.has_any_error()) { while (!m_ranges_stream->is_eof()) {
FlatPtr begin, end; auto begin = TRY(m_ranges_stream->read_value<FlatPtr>());
m_ranges_stream >> begin >> end; auto end = TRY(m_ranges_stream->read_value<FlatPtr>());
if (begin == 0 && end == 0) { if (begin == 0 && end == 0) {
// end of list entry // end of list entry
return; return {};
} else if (begin == explode_byte(0xff)) { } else if (begin == explode_byte(0xff)) {
current_base_address = end; current_base_address = end;
} else { } else {
@ -112,6 +110,8 @@ void AddressRangesV4::for_each_range(Function<void(Range)> callback)
callback({ base + begin, base + end }); callback({ base + begin, base + end });
} }
} }
return {};
} }
} }

13
Userland/Libraries/LibDebug/Dwarf/AddressRanges.h
View file

@ -11,6 +11,7 @@
#include <AK/Function.h> #include <AK/Function.h>
#include <AK/MemoryStream.h> #include <AK/MemoryStream.h>
#include <AK/Noncopyable.h> #include <AK/Noncopyable.h>
#include <LibCore/Stream.h>
namespace Debug::Dwarf { namespace Debug::Dwarf {
@ -24,12 +25,12 @@ class AddressRangesV5 {
AK_MAKE_NONMOVABLE(AddressRangesV5); AK_MAKE_NONMOVABLE(AddressRangesV5);
public: public:
AddressRangesV5(ReadonlyBytes range_lists_data, size_t offset, CompilationUnit const& compilation_unit); AddressRangesV5(NonnullOwnPtr<Core::Stream::Stream> range_lists_stream, CompilationUnit const& compilation_unit);
void for_each_range(Function<void(Range)>); ErrorOr<void> for_each_range(Function<void(Range)>);
private: private:
InputMemoryStream m_range_lists_stream; NonnullOwnPtr<Core::Stream::Stream> m_range_lists_stream;
CompilationUnit const& m_compilation_unit; CompilationUnit const& m_compilation_unit;
}; };
@ -38,12 +39,12 @@ class AddressRangesV4 {
AK_MAKE_NONMOVABLE(AddressRangesV4); AK_MAKE_NONMOVABLE(AddressRangesV4);
public: public:
AddressRangesV4(ReadonlyBytes ranges_data, size_t offset, CompilationUnit const&); AddressRangesV4(NonnullOwnPtr<Core::Stream::Stream> ranges_stream, CompilationUnit const&);
void for_each_range(Function<void(Range)>); ErrorOr<void> for_each_range(Function<void(Range)>);
private: private:
InputMemoryStream m_ranges_stream; NonnullOwnPtr<Core::Stream::Stream> m_ranges_stream;
CompilationUnit const& m_compilation_unit; CompilationUnit const& m_compilation_unit;
}; };

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

@ -11,6 +11,7 @@
#include <AK/ByteReader.h> #include <AK/ByteReader.h>
#include <AK/MemoryStream.h> #include <AK/MemoryStream.h>
#include <LibCore/MemoryStream.h>
#include <LibDebug/DebugInfo.h> #include <LibDebug/DebugInfo.h>
namespace Debug::Dwarf { namespace Debug::Dwarf {
@ -337,7 +338,7 @@ void DwarfInfo::build_cached_dies() const
m_cached_dies_by_range.insert(range.start_address, DIEAndRange { die, range }); m_cached_dies_by_range.insert(range.start_address, DIEAndRange { die, range });
m_cached_dies_by_offset.insert(die.offset(), die); m_cached_dies_by_offset.insert(die.offset(), die);
}; };
auto get_ranges_of_die = [this](DIE const& die) -> Vector<DIERange> { auto get_ranges_of_die = [this](DIE const& die) -> ErrorOr<Vector<DIERange>> {
auto ranges = die.get_attribute(Attribute::Ranges); auto ranges = die.get_attribute(Attribute::Ranges);
if (ranges.has_value()) { if (ranges.has_value()) {
size_t offset; size_t offset;
@ -353,15 +354,19 @@ void DwarfInfo::build_cached_dies() const
Vector<DIERange> entries; Vector<DIERange> entries;
if (die.compilation_unit().dwarf_version() == 5) { if (die.compilation_unit().dwarf_version() == 5) {
AddressRangesV5 address_ranges(debug_range_lists_data(), offset, die.compilation_unit()); auto range_lists_stream = TRY(Core::Stream::FixedMemoryStream::construct(debug_range_lists_data()));
address_ranges.for_each_range([&entries](auto range) { TRY(range_lists_stream->seek(offset));
AddressRangesV5 address_ranges(move(range_lists_stream), die.compilation_unit());
TRY(address_ranges.for_each_range([&entries](auto range) {
entries.empend(range.start, range.end); entries.empend(range.start, range.end);
}); }));
} else { } else {
AddressRangesV4 address_ranges(debug_ranges_data(), offset, die.compilation_unit()); auto ranges_stream = TRY(Core::Stream::FixedMemoryStream::construct(debug_ranges_data()));
address_ranges.for_each_range([&entries](auto range) { TRY(ranges_stream->seek(offset));
AddressRangesV4 address_ranges(move(ranges_stream), die.compilation_unit());
TRY(address_ranges.for_each_range([&entries](auto range) {
entries.empend(range.start, range.end); entries.empend(range.start, range.end);
}); }));
} }
return entries; return entries;
} }
@ -370,7 +375,7 @@ void DwarfInfo::build_cached_dies() const
auto end = die.get_attribute(Attribute::HighPc); auto end = die.get_attribute(Attribute::HighPc);
if (!start.has_value() || !end.has_value()) if (!start.has_value() || !end.has_value())
return {}; return Vector<DIERange> {};
VERIFY(start->type() == Dwarf::AttributeValue::Type::Address); VERIFY(start->type() == Dwarf::AttributeValue::Type::Address);
@ -383,14 +388,14 @@ void DwarfInfo::build_cached_dies() const
else else
range_end = start->as_addr() + end->as_unsigned(); range_end = start->as_addr() + end->as_unsigned();
return { DIERange { start.value().as_addr(), range_end } }; return Vector<DIERange> { 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.
Function<void(DIE const& die)> insert_to_cache_recursively; Function<void(DIE const& die)> insert_to_cache_recursively;
insert_to_cache_recursively = [&](DIE const& die) { insert_to_cache_recursively = [&](DIE const& die) {
if (die.offset() == 0 || die.parent_offset().has_value()) { if (die.offset() == 0 || die.parent_offset().has_value()) {
auto ranges = get_ranges_of_die(die); auto ranges = get_ranges_of_die(die).release_value_but_fixme_should_propagate_errors();
for (auto& range : ranges) { for (auto& range : ranges) {
insert_to_cache(die, range); insert_to_cache(die, range);
} }