#pragma once

#include "MappedFileRegion.h"

#include "Utility.h"

class UnmappedRegionException : public std::exception

{

uint64_t m_address;

public:

explicit UnmappedRegionException(uint64_t address) : m_address(address) {}

virtual const char* what() const throw()

{

thread_local std::string message;

message = fmt::format("Tried to access unmapped region using address {0:x}", m_address);

return message.c_str();

}

};

// A region within the virtual memory

struct VirtualMemoryRegion

{

uint64_t fileOffset;

std::shared_ptr<MappedFileRegion> file;

VirtualMemoryRegion(uint64_t offset, std::shared_ptr<MappedFileRegion> f)

: fileOffset(offset), file(std::move(f)) {}

};

// Contains information to handle mapping of multiple mapped files into a single memory space.

// This models how the loader of DYLD shared caches would operate, so that we can effectively query memory regions

// and map them into Binary Ninja.

class VirtualMemory

{

AddressRangeMap<VirtualMemoryRegion> m_regions;

uint64_t m_addressSize = 8;

public:

explicit VirtualMemory(uint64_t addressSize = 8) : m_addressSize(addressSize) {}

uint64_t GetAddressSize() const { return m_addressSize; }

void MapRegion(std::shared_ptr<MappedFileRegion> file, AddressRange mappedRange, uint64_t fileOffset);

const VirtualMemoryRegion* FindRegionAtAddress(uint64_t address, uint64_t& addressOffset) const;

const VirtualMemoryRegion* FindRegionAtAddress(uint64_t address) const;

bool IsAddressMapped(uint64_t address) const;

uint64_t ReadPointer(uint64_t address) const;

std::string ReadCString(uint64_t address) const;

uint8_t ReadUInt8(uint64_t address) const;

int8_t ReadInt8(uint64_t address) const;

uint16_t ReadUInt16(uint64_t address) const;

int16_t ReadInt16(uint64_t address) const;

uint32_t ReadUInt32(uint64_t address) const;

int32_t ReadInt32(uint64_t address) const;

uint64_t ReadUInt64(uint64_t address) const;

int64_t ReadInt64(uint64_t address) const;

BinaryNinja::DataBuffer ReadBuffer(uint64_t address, size_t length) const;

std::span<const uint8_t> ReadSpan(uint64_t address, size_t length) const;

void Read(void* dest, uint64_t address, size_t length) const;

};

class VirtualMemoryReader

{

std::shared_ptr<VirtualMemory> m_memory;

uint64_t m_cursor;

BNEndianness m_endianness = LittleEndian;

public:

explicit VirtualMemoryReader(std::shared_ptr<VirtualMemory> memory);

void SetEndianness(BNEndianness endianness) { m_endianness = endianness; }

BNEndianness GetEndianness() const { return m_endianness; }

void Seek(const uint64_t address) { m_cursor = address; };

void SeekRelative(const size_t offset) { m_cursor += offset; };

size_t GetOffset() const { return m_cursor; }

std::string ReadCString(uint64_t address, size_t maxLength = -1);

uint64_t ReadPointer();

uint64_t ReadPointer(uint64_t address);

uint8_t ReadUInt8();

uint8_t ReadUInt8(uint64_t address);

int8_t ReadInt8();

int8_t ReadInt8(uint64_t address);

uint16_t ReadUInt16();

uint16_t ReadUInt16(uint64_t address);

int16_t ReadInt16();

int16_t ReadInt16(uint64_t address);

uint32_t ReadUInt32();

uint32_t ReadUInt32(uint64_t address);

int32_t ReadInt32();

int32_t ReadInt32(uint64_t address);

uint64_t ReadUInt64();

uint64_t ReadUInt64(uint64_t address);

int64_t ReadInt64();

int64_t ReadInt64(uint64_t address);

BinaryNinja::DataBuffer ReadBuffer(size_t length);

BinaryNinja::DataBuffer ReadBuffer(uint64_t address, size_t length);

void Read(void* dest, size_t length);

void Read(void* dest, uint64_t address, size_t length);

};