MemoryMap.hpp

#pragma once

#include <exception>
#include <stdexcept>
#include <map>
#include <vector>
#include <string>
#include <cstdint>

class MemoryMap {
    public:
        class ReadMapFailed: public std::exception {};

        struct MemoryRegion {
            MemoryRegion() = default;
            MemoryRegion(uintptr_t begin, uintptr_t end)
                : begin(begin), end(end) {}

            uintptr_t begin; 
            uintptr_t end; 

            bool operator==(const MemoryRegion& oth) const {
                return begin == oth.begin && end == oth.end;
            }

            bool operator<(const MemoryRegion& oth) const {
                if(begin < oth.begin)
                    return true;
                return (begin == oth.begin && end < oth.end);
            }

            bool contains(uintptr_t addr) const {
                return begin <= addr && addr < end;
            }
        };

        struct MapEntry {
            std::string pathname;
            MemoryRegion mem_region;
            uintptr_t offset;

            void dump(std::ostream& os) const;
        };

        typedef std::vector<MapEntry>::const_iterator iter_t;

    public:
        MemoryMap();

        const MapEntry& get_entry(size_t id) const;

        const MapEntry& operator[](size_t id) const;

        size_t id_of_address(uintptr_t addr) const;

        iter_t begin() const;

        iter_t end() const;

        size_t size() const;

    private:
        std::vector<MapEntry> map_entries;

        std::map<MemoryRegion, size_t> rev_addr_map;
};