LibDebug: Parse DWARF information entries

We can now iterate the tree structure of the DIEs, access attribute
values and parse some very basic DWARF expressions.

Libraries/LibDebug/Dwarf/AbbreviationsMap.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "AbbreviationsMap.h"
+#include "DwarfInfo.h"
+
+namespace Dwarf {
+
+AbbreviationsMap::AbbreviationsMap(const DwarfInfo& dwarf_info, u32 offset)
+    : m_dwarf_info(dwarf_info)
+    , m_offset(offset)
+{
+    populate_map();
+}
+
+void AbbreviationsMap::populate_map()
+{
+    BufferStream abbreviation_stream(const_cast<ByteBuffer&>(m_dwarf_info.abbreviation_data()));
+    abbreviation_stream.advance(m_offset);
+
+    while (!abbreviation_stream.at_end()) {
+        size_t abbreviation_code = 0;
+        abbreviation_stream.read_LEB128_unsigned(abbreviation_code);
+        // An abbrevation code of 0 marks the end of the
+        // abbrevations for a given compilation unit
+        if (abbreviation_code == 0)
+            break;
+
+        size_t tag {};
+        abbreviation_stream.read_LEB128_unsigned(tag);
+
+        u8 has_children = 0;
+        abbreviation_stream >> has_children;
+
+        AbbreviationEntry abbrevation_entry {};
+        abbrevation_entry.tag = static_cast<EntryTag>(tag);
+        abbrevation_entry.has_children = (has_children == 1);
+
+        AttributeSpecification current_attribute_specification {};
+        do {
+            size_t attribute_value = 0;
+            size_t form_value = 0;
+            abbreviation_stream.read_LEB128_unsigned(attribute_value);
+            abbreviation_stream.read_LEB128_unsigned(form_value);
+
+            current_attribute_specification.attribute = static_cast<Attribute>(attribute_value);
+            current_attribute_specification.form = static_cast<AttributeDataForm>(form_value);
+
+            if (current_attribute_specification.attribute != Attribute::None) {
+                abbrevation_entry.attribute_specifications.append(current_attribute_specification);
+            }
+        } while (current_attribute_specification.attribute != Attribute::None || current_attribute_specification.form != AttributeDataForm::None);
+
+        m_entries.set((u32)abbreviation_code, abbrevation_entry);
+    }
+}
+
+Optional<AbbreviationsMap::AbbreviationEntry> AbbreviationsMap::get(u32 code) const
+{
+    return m_entries.get(code);
+}
+
+}

Libraries/LibDebug/Dwarf/AbbreviationsMap.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#include "DwarfTypes.h"
+#include <AK/HashMap.h>
+#include <AK/Optional.h>
+#include <AK/Types.h>
+
+namespace Dwarf {
+class DwarfInfo;
+
+class AbbreviationsMap {
+public:
+    AbbreviationsMap(const DwarfInfo& dwarf_info, u32 offset);
+
+    struct AbbreviationEntry {
+
+        EntryTag tag;
+        bool has_children;
+
+        Vector<AttributeSpecification> attribute_specifications;
+    };
+
+    Optional<AbbreviationEntry> get(u32 code) const;
+
+private:
+    void populate_map();
+
+    const DwarfInfo& m_dwarf_info;
+    u32 m_offset { 0 };
+    HashMap<u32, AbbreviationEntry> m_entries;
+};
+
+}

Libraries/LibDebug/Dwarf/CompilationUnit.cpp

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "CompilationUnit.h"
+#include "DIE.h"
+
+namespace Dwarf {
+
+CompilationUnit::CompilationUnit(const DwarfInfo& dwarf_info, u32 offset, const CompilationUnitHeader& header)
+    : m_dwarf_info(dwarf_info)
+    , m_offset(offset)
+    , m_header(header)
+    , m_abbreviations(dwarf_info, header.abbrev_offset)
+{
+}
+
+DIE CompilationUnit::root_die() const
+{
+    return DIE(*this, m_offset + sizeof(CompilationUnitHeader));
+}
+
+}

Libraries/LibDebug/Dwarf/CompilationUnit.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#include "AbbreviationsMap.h"
+#include <AK/Types.h>
+
+namespace Dwarf {
+
+class DwarfInfo;
+class DIE;
+
+class CompilationUnit {
+public:
+    CompilationUnit(const DwarfInfo& dwarf_info, u32 offset, const CompilationUnitHeader&);
+
+    u32 offset() const { return m_offset; }
+    u32 size() const { return m_header.length + sizeof(u32); }
+
+    DIE root_die() const;
+
+    const DwarfInfo& dwarf_info() const { return m_dwarf_info; }
+    const AbbreviationsMap& abbreviations_map() const { return m_abbreviations; }
+
+private:
+    const DwarfInfo& m_dwarf_info;
+    u32 m_offset { 0 };
+    CompilationUnitHeader m_header;
+    AbbreviationsMap m_abbreviations;
+};
+
+}

Libraries/LibDebug/Dwarf/DIE.cpp

@@ -0,0 +1,204 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "DIE.h"
+#include "CompilationUnit.h"
+#include "DwarfInfo.h"
+#include <AK/BufferStream.h>
+#include <AK/ByteBuffer.h>
+
+namespace Dwarf {
+
+DIE::DIE(const CompilationUnit& unit, u32 offset)
+    : m_compilation_unit(unit)
+    , m_offset(offset)
+{
+    BufferStream stream(const_cast<ByteBuffer&>(m_compilation_unit.dwarf_info().debug_info_data()));
+    stream.advance(m_offset);
+    stream.read_LEB128_unsigned(m_abbreviation_code);
+    m_data_offset = stream.offset();
+
+    if (m_abbreviation_code == 0) {
+        // An abbrevation code of 0 ( = null DIE entry) means the end of a chain of sibilings
+        m_tag = EntryTag::None;
+    } else {
+        auto abbreviation_info = m_compilation_unit.abbreviations_map().get(m_abbreviation_code);
+        ASSERT(abbreviation_info.has_value());
+
+        m_tag = abbreviation_info.value().tag;
+        m_has_children = abbreviation_info.value().has_children;
+
+        // We iterate the attributes data only to calculate this DIE's size
+        for (auto attribute_spec : abbreviation_info.value().attribute_specifications) {
+            get_attribute_value(attribute_spec.form, stream);
+        }
+    }
+    m_size = stream.offset() - m_offset;
+}
+
+DIE::AttributeValue DIE::get_attribute_value(AttributeDataForm form,
+    BufferStream& debug_info_stream) const
+{
+    AttributeValue value;
+    switch (form) {
+    case AttributeDataForm::StringPointer: {
+        u32 offset = 0;
+        debug_info_stream >> offset;
+        value.type = AttributeValue::Type::String;
+
+        auto strings_data = m_compilation_unit.dwarf_info().debug_strings_data();
+        value.data.as_string = reinterpret_cast<const char*>(strings_data.data() + offset);
+        break;
+    }
+    case AttributeDataForm::Data1: {
+        u8 data = 0;
+        debug_info_stream >> data;
+        value.type = AttributeValue::Type::UnsignedNumber;
+        value.data.as_u32 = data;
+        break;
+    }
+    case AttributeDataForm::Data2: {
+        u16 data = 0;
+        debug_info_stream >> data;
+        value.type = AttributeValue::Type::UnsignedNumber;
+        value.data.as_u32 = data;
+        break;
+    }
+    case AttributeDataForm::Addr: {
+        u32 address = 0;
+        debug_info_stream >> address;
+        value.type = AttributeValue::Type::UnsignedNumber;
+        value.data.as_u32 = address;
+        break;
+    }
+    case AttributeDataForm::SecOffset: {
+        u32 data = 0;
+        debug_info_stream >> data;
+        value.type = AttributeValue::Type::SecOffset;
+        value.data.as_u32 = data;
+        break;
+    }
+    case AttributeDataForm::Data4: {
+        u32 data = 0;
+        debug_info_stream >> data;
+        value.type = AttributeValue::Type::UnsignedNumber;
+        value.data.as_u32 = data;
+        break;
+    }
+    case AttributeDataForm::Ref4: {
+        u32 data = 0;
+        debug_info_stream >> data;
+        value.type = AttributeValue::Type::DieReference;
+        value.data.as_u32 = data + m_compilation_unit.offset();
+        break;
+    }
+    case AttributeDataForm::FlagPresent: {
+        value.type = AttributeValue::Type::Boolean;
+        value.data.as_bool = true;
+        break;
+    }
+    case AttributeDataForm::ExprLoc: {
+        size_t length = 0;
+        debug_info_stream.read_LEB128_unsigned(length);
+        value.type = AttributeValue::Type::DwarfExpression;
+
+        value.data.as_dwarf_expression.length = length;
+        value.data.as_dwarf_expression.bytes = reinterpret_cast<const u8*>(m_compilation_unit.dwarf_info().debug_info_data().data() + debug_info_stream.offset());
+
+        debug_info_stream.advance(length);
+        break;
+    }
+    case AttributeDataForm::String: {
+        String str;
+        u32 str_offset = debug_info_stream.offset();
+        debug_info_stream >> str;
+        value.type = AttributeValue::Type::String;
+        value.data.as_string = reinterpret_cast<const char*>(str_offset + m_compilation_unit.dwarf_info().debug_info_data().data());
+        break;
+    }
+    default:
+        dbg() << "Unimplemented AttributeDataForm: " << (u32)form;
+        ASSERT_NOT_REACHED();
+    }
+    return value;
+}
+
+Optional<DIE::AttributeValue> DIE::get_attribute(const Attribute& attribute) const
+{
+    BufferStream stream(const_cast<ByteBuffer&>(m_compilation_unit.dwarf_info().debug_info_data()));
+    stream.advance(m_data_offset);
+
+    auto abbreviation_info = m_compilation_unit.abbreviations_map().get(m_abbreviation_code);
+    ASSERT(abbreviation_info.has_value());
+
+    for (const auto& attribute_spec : abbreviation_info.value().attribute_specifications) {
+        auto value = get_attribute_value(attribute_spec.form, stream);
+        if (attribute_spec.attribute == attribute) {
+            return value;
+        }
+    }
+    return {};
+}
+
+void DIE::for_each_child(Function<void(const DIE& child)> callback) const
+{
+    if (!m_has_children)
+        return;
+
+    NonnullOwnPtr<DIE> current_child = make<DIE>(m_compilation_unit, m_offset + m_size);
+    while (true) {
+        callback(*current_child);
+        if (current_child->is_null())
+            break;
+        if (!current_child->has_children()) {
+            current_child = make<DIE>(m_compilation_unit, current_child->offset() + current_child->size());
+            continue;
+        }
+
+        auto sibling = current_child->get_attribute(Attribute::Sibling);
+        u32 sibling_offset = 0;
+        if (sibling.has_value()) {
+            sibling_offset = sibling.value().data.as_u32;
+        }
+
+        if (!sibling.has_value()) {
+            // NOTE: According to the spec, the compiler does'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
+            current_child->for_each_child([&](const DIE& sub_child) {
+                sibling_offset = sub_child.offset() + sub_child.size();
+            });
+        }
+        current_child = make<DIE>(m_compilation_unit, sibling_offset);
+    }
+}
+
+DIE DIE::get_die_at_offset(u32 offset) const
+{
+    ASSERT(offset >= m_compilation_unit.offset() && offset < m_compilation_unit.offset() + m_compilation_unit.size());
+    return DIE(m_compilation_unit, offset);
+}
+
+}

Libraries/LibDebug/Dwarf/DIE.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#include "CompilationUnit.h"
+#include "DwarfTypes.h"
+#include <AK/BufferStream.h>
+#include <AK/Function.h>
+#include <AK/NonnullOwnPtr.h>
+#include <AK/Optional.h>
+#include <AK/Types.h>
+
+namespace Dwarf {
+
+class CompilationUnit;
+
+// DIE = Dwarf Information Entry
+class DIE {
+public:
+    DIE(const CompilationUnit&, u32 offset);
+
+    struct AttributeValue {
+        enum class Type {
+            UnsignedNumber,
+            SignedNumber,
+            String,
+            DieReference, // Reference to another DIE in the same compilation unit
+            Boolean,
+            DwarfExpression,
+            SecOffset,
+        } type;
+
+        union {
+            u32 as_u32;
+            i32 as_i32;
+            const char* as_string; // points to bytes in the memory mapped elf image
+            bool as_bool;
+            struct {
+                u32 length;
+                const u8* bytes; // points to bytes in the memory mapped elf image
+            } as_dwarf_expression;
+        } data {};
+    };
+
+    u32 offset() const { return m_offset; }
+    u32 size() const { return m_size; }
+    bool has_children() const { return m_has_children; }
+    EntryTag tag() const { return m_tag; }
+
+    Optional<AttributeValue> get_attribute(const Attribute&) const;
+
+    void for_each_child(Function<void(const DIE& child)> callback) const;
+
+    bool is_null() const { return m_tag == EntryTag::None; }
+
+    DIE get_die_at_offset(u32 offset) const;
+
+private:
+    AttributeValue get_attribute_value(AttributeDataForm form,
+        BufferStream& debug_info_stream) const;
+
+    const CompilationUnit& m_compilation_unit;
+    u32 m_offset { 0 };
+    u32 m_data_offset { 0 };
+    size_t m_abbreviation_code { 0 };
+    EntryTag m_tag { EntryTag::None };
+    bool m_has_children { false };
+    u32 m_size { 0 };
+};
+
+}

Libraries/LibDebug/Dwarf/DwarfInfo.cpp

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "DwarfInfo.h"
+
+namespace Dwarf {
+
+DwarfInfo::DwarfInfo(NonnullRefPtr<const ELF::Loader> elf)
+    : m_elf(elf)
+{
+    m_debug_info_data = section_data(".debug_info");
+    m_abbreviation_data = section_data(".debug_abbrev");
+    m_debug_strings_data = section_data(".debug_str");
+
+    populate_compilation_units();
+}
+
+ByteBuffer DwarfInfo::section_data(const String& section_name)
+{
+    auto section = m_elf->image().lookup_section(section_name);
+    ASSERT(!section.is_undefined());
+    return ByteBuffer::wrap(reinterpret_cast<const u8*>(section.raw_data()), section.size());
+}
+
+void DwarfInfo::populate_compilation_units()
+{
+    // We have to const_cast here because there isn't a version of
+    // BufferStream that accepts a const ByteStream
+    // We take care not to use BufferStream operations that modify the underlying buffer
+    // TOOD: Add a variant of BufferStream that operates on a const ByteBuffer to AK
+    BufferStream stream(const_cast<ByteBuffer&>(m_debug_info_data));
+    while (!stream.at_end()) {
+        auto unit_offset = stream.offset();
+        CompilationUnitHeader compilation_unit_header {};
+
+        stream.read_raw(reinterpret_cast<u8*>(&compilation_unit_header), sizeof(CompilationUnitHeader));
+        ASSERT(compilation_unit_header.address_size == sizeof(u32));
+        ASSERT(compilation_unit_header.version == 4);
+
+        u32 length_after_header = compilation_unit_header.length - (sizeof(CompilationUnitHeader) - offsetof(CompilationUnitHeader, version));
+        m_compilation_units.empend(*this, unit_offset, compilation_unit_header);
+        stream.advance(length_after_header);
+    }
+}
+
+}

Libraries/LibDebug/Dwarf/DwarfInfo.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#include "CompilationUnit.h"
+#include "DwarfTypes.h"
+#include <AK/BufferStream.h>
+#include <AK/ByteBuffer.h>
+#include <AK/NonnullRefPtr.h>
+#include <AK/RefCounted.h>
+#include <AK/String.h>
+#include <Libraries/LibELF/Loader.h>
+
+namespace Dwarf {
+
+class DwarfInfo : public RefCounted<DwarfInfo> {
+public:
+    static NonnullRefPtr<DwarfInfo> create(NonnullRefPtr<const ELF::Loader> elf) { return adopt(*new DwarfInfo(elf)); }
+
+    const ByteBuffer& debug_info_data() const { return m_debug_info_data; }
+    const ByteBuffer& abbreviation_data() const { return m_abbreviation_data; }
+    const ByteBuffer& debug_strings_data() const { return m_debug_strings_data; }
+
+    template<typename Callback>
+    void for_each_compilation_unit(Callback) const;
+
+private:
+    explicit DwarfInfo(NonnullRefPtr<const ELF::Loader> elf);
+    void populate_compilation_units();
+
+    ByteBuffer section_data(const String& section_name);
+
+    NonnullRefPtr<const ELF::Loader> m_elf;
+    ByteBuffer m_debug_info_data;
+    ByteBuffer m_abbreviation_data;
+    ByteBuffer m_debug_strings_data;
+
+    Vector<Dwarf::CompilationUnit> m_compilation_units;
+};
+
+template<typename Callback>
+void DwarfInfo::for_each_compilation_unit(Callback callback) const
+{
+    for (const auto& unit : m_compilation_units) {
+        callback(unit);
+    }
+}
+
+}

Libraries/LibDebug/Dwarf/DwarfTypes.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#pragma once
+#include <AK/Types.h>
+
+namespace Dwarf {
+
+struct [[gnu::packed]] CompilationUnitHeader
+{
+    u32 length;
+    u16 version;
+    u32 abbrev_offset;
+    u8 address_size;
+};
+
+enum class EntryTag : u32 {
+    None = 0,
+    LexicalBlock = 0xb,
+    Member = 0xd,
+    SubProgram = 0x2e,
+    Variable = 0x34,
+};
+
+enum class Attribute : u32 {
+    None = 0,
+    Sibling = 0x1,
+    Location = 0x2,
+    Name = 0x3,
+    LowPc = 0x11,
+    HighPc = 0x12,
+    Inline = 0x20,
+    MemberLocation = 0x38,
+    Type = 0x49,
+    Ranges = 0x55,
+};
+
+enum class AttributeDataForm : u32 {
+    None = 0,
+    Addr = 0x1,
+    Data2 = 0x5,
+    Data4 = 0x6,
+    String = 0x8,
+    Data1 = 0xb,
+    StringPointer = 0xe,
+    Ref4 = 0x13,
+    SecOffset = 0x17,
+    ExprLoc = 0x18,
+    FlagPresent = 0x19,
+};
+
+struct AttributeSpecification {
+    Attribute attribute;
+    AttributeDataForm form;
+};
+
+}

Libraries/LibDebug/Dwarf/Expression.cpp

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include "Expression.h"
+#include <AK/BufferStream.h>
+#include <sys/arch/i386/regs.h>
+
+namespace Dwarf {
+namespace Expression {
+
+Value evaluate(const ByteBuffer& bytes, const PtraceRegisters& regs)
+{
+    // TODO: we need a BufferStream variant that takes a const ByteBuffer
+    BufferStream stream(const_cast<ByteBuffer&>(bytes));
+
+    while (!stream.at_end()) {
+        u8 opcode = 0;
+        stream >> opcode;
+
+        switch (static_cast<Operations>(opcode)) {
+        case Operations::RegEbp: {
+            int offset = 0;
+            stream.read_LEB128_signed(offset);
+            return Value { Type::UnsignedIntetger, regs.ebp + offset };
+        }
+
+        case Operations::FbReg: {
+            int offset = 0;
+            stream.read_LEB128_signed(offset);
+            return Value { Type::UnsignedIntetger, regs.ebp + 2 * sizeof(size_t) + offset };
+        }
+
+        default:
+            dbg() << "DWARF expr addr: " << (const void*)bytes.data();
+            dbg() << "unsupported opcode: " << (u8)opcode;
+            ASSERT_NOT_REACHED();
+        }
+    }
+    ASSERT_NOT_REACHED();
+}
+
+};
+};

Libraries/LibDebug/Dwarf/Expression.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2020, Itamar S. <itamar8910@gmail.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+#include "AK/ByteBuffer.h"
+#include "AK/Types.h"
+
+class PtraceRegisters;
+
+namespace Dwarf {
+namespace Expression {
+enum class Type {
+    None,
+    UnsignedIntetger,
+    Register,
+};
+
+struct Value {
+    Type type;
+    union {
+        u32 as_u32;
+    } data { 0 };
+};
+
+enum class Operations : u8 {
+    RegEbp = 0x75,
+    FbReg = 0x91,
+};
+
+Value evaluate(const ByteBuffer&, const PtraceRegisters&);
+
+};
+};