DwarfInterpret.hpp

#pragma once

#include <string>
#include <memory>
#include <cstdint>

#include <dwarfpp/lib.hpp>
#include <dwarfpp/regs.hpp>
#include <dwarfpp/frame.hpp>
#include <dwarfpp/attr.hpp>
#include <dwarfpp/frame.hpp>
#include <dwarfpp/root.hpp>

#include "MemoryMap.hpp"

#define OF_WHAT_EXCEPTION(cl_name) \
    cl_name: public WhatException { \
        public:\
            cl_name(const std::string& what): WhatException(what) {} \
            cl_name() = default; \
    }

class DwarfInterpret {
    public:  // Types, sub-classes, …
        class WhatException: public std::exception {
            std::string what_str;

            public:
                explicit WhatException(const std::string& what)
                    : what_str(what) {}

                WhatException(): what_str("") {}

                const char* what() const noexcept {
                    return what_str.c_str();
                }
        };


        class OF_WHAT_EXCEPTION(InvalidElf);

        class OF_WHAT_EXCEPTION(NoDebugData);

        class OF_WHAT_EXCEPTION(NoElfForPC);

        class OF_WHAT_EXCEPTION(ExoticRegister);

        class OF_WHAT_EXCEPTION(ValuelessRegister);

        class OF_WHAT_EXCEPTION(NotImplemented);

        class OF_WHAT_EXCEPTION(FailedGetContext);

        class OF_WHAT_EXCEPTION(NotFound);

        class FirstUnwindFrame: public std::exception {};

        typedef dwarf::core::FrameSection::register_def DwarfRegister;

        typedef std::set<std::pair<int, DwarfRegister> > DwarfRow;

        typedef uintptr_t reg_content_t;


        struct UnwindContext {
            // Let's pretend this is enough
            uintptr_t rip;
            uintptr_t rsp;
            uintptr_t rbp;
        };

    public:  // methods
        DwarfInterpret(DwarfInterpret const&) = delete;
        void operator=(DwarfInterpret const&) = delete;

        static DwarfInterpret& acquire();

        static DwarfInterpret& acquire(uintptr_t pc);

        DwarfRow dwarf_row_at(uintptr_t pc) const;

        reg_content_t interpret_dw_register(
                const DwarfRow& row,
                const DwarfRegister& reg,
                const UnwindContext& ctx
                ) const;

        reg_content_t interpret_dw_register(
                const DwarfRow& row,
                int reg_id,
                const UnwindContext& ctx
                ) const;

        static UnwindContext get_current_unwind_context();

        UnwindContext unwind_context(const UnwindContext& ctx);

    private:
        DwarfInterpret(const MemoryMap::MapEntry& memory_object);

        DwarfRegister get_column(const DwarfRow& row, int column) const;

        const dwarf::core::FrameSection::fde_iterator fde_at(
                uintptr_t pc) const;
        const dwarf::core::FrameSection::cie_iterator cie_at(
                uintptr_t pc) const;

        DwarfInterpret* get_responsible_instance(uintptr_t pc) const;


    private: // members
        static MemoryMap memory_map;

        // This map maps a `memory_map` memory region index to some instance of
        // a DwarfInterpret. The special index -1 is mapped to the anonymous
        // instance.
        static std::map<int, std::unique_ptr<DwarfInterpret> > instances;

        MemoryMap::MapEntry map_entry;

        std::unique_ptr<dwarf::core::root_die> root_die;

        uintptr_t pc_offset;

        friend class std::unique_ptr<DwarfInterpret>;
};