mapped_ptr.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <string_view>
#include <type_traits>
 
#include <rex/platform.h>
#include <rex/types.h>
 
namespace rex::memory {

template <typename T>
class MappedPtr {
  T* host_ptr_ = nullptr;
  u32 guest_addr_ = 0;
 
 public:
  MappedPtr() = default;
 
  MappedPtr(T* host_ptr, u32 guest_addr) : host_ptr_(host_ptr), guest_addr_(guest_addr) {}

  MappedPtr(std::nullptr_t) {}

  static MappedPtr FromHost(T* host_ptr) { return MappedPtr(host_ptr, 0); }
 
  u32 GetGuestAddress() const { return guest_addr_; }
 
  T* GetHostPtr() const { return host_ptr_; }
 
  operator T*() const { return host_ptr_; }
 
  T* operator->() const { return host_ptr_; }
 
  T& operator*() const { return *host_ptr_; }

  auto GetValue() const {
    if constexpr (is_be_type_v<T>) {
      return static_cast<T::value_type>(*host_ptr_);
    } else {
      return *host_ptr_;
    }
  }
 
  explicit operator bool() const { return host_ptr_ != nullptr; }
 
  explicit operator u32() const { return GetGuestAddress(); }

  MappedPtr operator+(std::ptrdiff_t offset) const {
    return MappedPtr(host_ptr_ + offset, guest_addr_ + static_cast<u32>(offset * sizeof(T)));
  }

  MappedPtr operator-(std::ptrdiff_t offset) const {
    return MappedPtr(host_ptr_ - offset, guest_addr_ - static_cast<u32>(offset * sizeof(T)));
  }
 
  template <typename U>
  U As() const {
    return reinterpret_cast<U>(host_ptr_);
  }

  template <typename U>
  rex::BE<U>* AsArray() const {
    return reinterpret_cast<rex::BE<U>*>(host_ptr_);
  }

  void Zero() const {
    if (host_ptr_) {
      std::memset(host_ptr_, 0, sizeof(T));
    }
  }

  void Zero(size_t size) const {
    if (host_ptr_) {
      std::memset(host_ptr_, 0, size);
    }
  }
};

template <>
class MappedPtr<void> {
  void* host_ptr_ = nullptr;
  u32 guest_addr_ = 0;
 
 public:
  MappedPtr() = default;
 
  MappedPtr(void* host_ptr, u32 guest_addr) : host_ptr_(host_ptr), guest_addr_(guest_addr) {}

  MappedPtr(std::nullptr_t) {}

  static MappedPtr FromHost(void* host_ptr) { return MappedPtr(host_ptr, 0); }
 
  u32 GetGuestAddress() const { return guest_addr_; }
 
  u32 GetValue() const { return guest_addr_; }
 
  void* GetHostPtr() const { return host_ptr_; }
 
  operator void*() const { return host_ptr_; }

  operator u8*() const { return static_cast<u8*>(host_ptr_); }
 
  explicit operator bool() const { return host_ptr_ != nullptr; }
 
  explicit operator u32() const { return guest_addr_; }

  template <std::integral IntType>
  MappedPtr operator+(IntType offset) const {
    return MappedPtr(static_cast<u8*>(host_ptr_) + static_cast<std::ptrdiff_t>(offset),
                     guest_addr_ + static_cast<u32>(offset));
  }

  template <std::integral IntType>
  MappedPtr operator-(IntType offset) const {
    return MappedPtr(static_cast<u8*>(host_ptr_) - static_cast<std::ptrdiff_t>(offset),
                     guest_addr_ - static_cast<u32>(offset));
  }
 
  template <typename U>
  U As() const {
    return reinterpret_cast<U>(host_ptr_);
  }

  template <typename U>
  rex::BE<U>* AsArray() const {
    return reinterpret_cast<rex::BE<U>*>(host_ptr_);
  }

  void Zero(size_t size) const {
    if (host_ptr_) {
      std::memset(host_ptr_, 0, size);
    }
  }
};

template <>
class MappedPtr<char> {
  char* host_ptr_ = nullptr;
  u32 guest_addr_ = 0;
 
 public:
  MappedPtr() = default;
 
  MappedPtr(char* host_ptr, u32 guest_addr) : host_ptr_(host_ptr), guest_addr_(guest_addr) {}

  MappedPtr(std::nullptr_t) {}
 
  u32 GetGuestAddress() const { return guest_addr_; }
 
  char* GetHostPtr() const { return host_ptr_; }
 
  operator char*() const { return host_ptr_; }
 
  explicit operator bool() const { return host_ptr_ != nullptr; }

  std::string_view GetValue() const {
    return host_ptr_ ? std::string_view(host_ptr_) : std::string_view();
  }
 
  char* operator->() const { return host_ptr_; }
 
  char& operator*() const { return *host_ptr_; }

  MappedPtr operator+(std::ptrdiff_t offset) const {
    return MappedPtr(host_ptr_ + offset, guest_addr_ + static_cast<u32>(offset));
  }

  MappedPtr operator-(std::ptrdiff_t offset) const {
    return MappedPtr(host_ptr_ - offset, guest_addr_ - static_cast<u32>(offset));
  }
 
  char& operator[](size_t idx) const { return host_ptr_[idx]; }
 
  template <typename U>
  U As() const {
    return reinterpret_cast<U>(host_ptr_);
  }
};

template <>
class MappedPtr<char16_t> {
  char16_t* host_ptr_ = nullptr;
  u32 guest_addr_ = 0;
 
 public:
  MappedPtr() = default;
 
  MappedPtr(char16_t* host_ptr, u32 guest_addr) : host_ptr_(host_ptr), guest_addr_(guest_addr) {}

  MappedPtr(std::nullptr_t) {}
 
  u32 GetGuestAddress() const { return guest_addr_; }
 
  char16_t* GetHostPtr() const { return host_ptr_; }
 
  operator char16_t*() const { return host_ptr_; }
 
  explicit operator bool() const { return host_ptr_ != nullptr; }

  std::u16string_view GetValue() const {
    return host_ptr_ ? std::u16string_view(host_ptr_) : std::u16string_view();
  }
 
  char16_t* operator->() const { return host_ptr_; }
 
  char16_t& operator*() const { return *host_ptr_; }

  MappedPtr operator+(std::ptrdiff_t offset) const {
    return MappedPtr(host_ptr_ + offset, guest_addr_ + static_cast<u32>(offset * sizeof(char16_t)));
  }

  MappedPtr operator-(std::ptrdiff_t offset) const {
    return MappedPtr(host_ptr_ - offset, guest_addr_ - static_cast<u32>(offset * sizeof(char16_t)));
  }
 
  char16_t& operator[](size_t idx) const { return host_ptr_[idx]; }
 
  template <typename U>
  U As() const {
    return reinterpret_cast<U>(host_ptr_);
  }
};
 
template <typename T>
struct IsMappedPtr : std::false_type {};
 
template <typename T>
struct IsMappedPtr<MappedPtr<T>> : std::true_type {};
 
template <typename T>
inline constexpr bool is_mapped_ptr_v = IsMappedPtr<T>::value;
 
template <typename T>
struct MappedPtrInnerType;

template <typename T>
struct MappedPtrInnerType<MappedPtr<T>> {
  using type = T;
};
 
}  // namespace rex::memory
 
using MappedVoid = rex::memory::MappedPtr<void>;
using MappedU8 = rex::memory::MappedPtr<rex::u8>;
using MappedU16 = rex::memory::MappedPtr<rex::be_u16>;
using MappedU32 = rex::memory::MappedPtr<rex::be_u32>;
using MappedU64 = rex::memory::MappedPtr<rex::be_u64>;
using MappedF32 = rex::memory::MappedPtr<rex::be_f32>;
using MappedF64 = rex::memory::MappedPtr<rex::be_f64>;
using MappedString = rex::memory::MappedPtr<char>;
using MappedWString = rex::memory::MappedPtr<char16_t>;
 
template <typename T>
using GuestPtrT = rex::memory::MappedPtr<T>;
 
namespace rex::memory::detail {

#ifndef REX_PHYSICAL_OFFSET_IN_CODE
#error "REX_PHYSICAL_OFFSET_IN_CODE is set by the CMake option of the same name"
#endif
inline constexpr bool kPhysicalOffsetInCode = static_cast<bool>(REX_PHYSICAL_OFFSET_IN_CODE);

constexpr u32 PhysicalHostOffset(u32 guest_addr) noexcept {
  return (kPhysicalOffsetInCode && guest_addr >= 0xE0000000u) ? 0x1000u : 0u;
}

constexpr u32 RemovePhysicalHostOffset(std::size_t host_offset) noexcept {
  constexpr std::size_t kOffset = PhysicalHostOffset(0xE0000000u);
  const bool shifted =
      host_offset >= 0xE0000000u + kOffset && host_offset < 0x100000000ull + kOffset;
  return static_cast<u32>(shifted ? host_offset - kOffset : host_offset);
}
 
}  // namespace rex::memory::detail
 
namespace rex::memory {

template <typename T = u8*>
inline T GuestPtr(u8* base, u32 guest_address) noexcept {
  return reinterpret_cast<T>(base + guest_address + detail::PhysicalHostOffset(guest_address));
}

inline u32 HostPtrToGuest(const u8* base, const void* host_address) noexcept {
  if (host_address == nullptr) {
    return 0;
  }
  return detail::RemovePhysicalHostOffset(reinterpret_cast<std::size_t>(host_address) -
                                          reinterpret_cast<std::size_t>(base));
}

class GuestMembase {
 public:
  constexpr GuestMembase() noexcept = default;
 
  explicit constexpr GuestMembase(u8* base) noexcept : base_(base) {}

  [[nodiscard]] constexpr u8* GetBase() const noexcept { return base_; }

  template <typename T = u8*>
  [[nodiscard]] T TranslateVirtual(u32 guest_address) const noexcept {
    return GuestPtr<T>(base_, guest_address);
  }

  [[nodiscard]] u32 HostToGuestVirtual(const void* host_address) const noexcept {
    return HostPtrToGuest(base_, host_address);
  }
 
 private:
  u8* base_ = nullptr;
};
 
}  // namespace rex::memory