mirror of
https://github.com/RPCSX/rpcsx.git
synced 2026-04-05 06:26:49 +00:00
vm::var improved, cleanup
Mostly vm::var initialization introduced. Added vm::make_var function.
This commit is contained in:
Nekotekina
parent
cc02a147d3
commit
a974ee009e
116 changed files with 2763 additions and 3019 deletions
|
|
@ -25,60 +25,71 @@
|
|||
|
||||
namespace vm
|
||||
{
|
||||
void* initialize()
|
||||
template<std::size_t Size> struct mapped_ptr_deleter
|
||||
{
|
||||
void operator ()(void* ptr)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
::UnmapViewOfFile(ptr);
|
||||
#else
|
||||
::munmap(ptr, Size);
|
||||
#endif
|
||||
}
|
||||
};
|
||||
|
||||
using mapped_ptr_t = std::unique_ptr<u8[], mapped_ptr_deleter<0x100000000>>;
|
||||
|
||||
std::array<mapped_ptr_t, 2> initialize()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
HANDLE memory_handle = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE | SEC_RESERVE, 0x1, 0x0, NULL);
|
||||
const HANDLE memory_handle = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE | SEC_RESERVE, 0x1, 0x0, NULL);
|
||||
|
||||
void* base_addr = MapViewOfFile(memory_handle, FILE_MAP_WRITE, 0, 0, 0x100000000);
|
||||
g_priv_addr = MapViewOfFile(memory_handle, FILE_MAP_WRITE, 0, 0, 0x100000000);
|
||||
if (memory_handle == NULL)
|
||||
{
|
||||
std::printf("CreateFileMapping() failed\n");
|
||||
return{};
|
||||
}
|
||||
|
||||
CloseHandle(memory_handle);
|
||||
mapped_ptr_t base_addr(static_cast<u8*>(::MapViewOfFile(memory_handle, FILE_MAP_WRITE, 0, 0, 0x100000000)));
|
||||
mapped_ptr_t priv_addr(static_cast<u8*>(::MapViewOfFile(memory_handle, FILE_MAP_WRITE, 0, 0, 0x100000000)));
|
||||
|
||||
return base_addr;
|
||||
::CloseHandle(memory_handle);
|
||||
#else
|
||||
int memory_handle = shm_open("/rpcs3_vm", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
|
||||
const int memory_handle = ::shm_open("/rpcs3_vm", O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR);
|
||||
|
||||
if (memory_handle == -1)
|
||||
{
|
||||
std::printf("shm_open('/rpcs3_vm') failed\n");
|
||||
return (void*)-1;
|
||||
return{};
|
||||
}
|
||||
|
||||
if (ftruncate(memory_handle, 0x100000000) == -1)
|
||||
if (::ftruncate(memory_handle, 0x100000000) == -1)
|
||||
{
|
||||
std::printf("ftruncate(memory_handle) failed\n");
|
||||
shm_unlink("/rpcs3_vm");
|
||||
return (void*)-1;
|
||||
::shm_unlink("/rpcs3_vm");
|
||||
return{};
|
||||
}
|
||||
|
||||
void* base_addr = mmap(nullptr, 0x100000000, PROT_NONE, MAP_SHARED, memory_handle, 0);
|
||||
g_priv_addr = mmap(nullptr, 0x100000000, PROT_NONE, MAP_SHARED, memory_handle, 0);
|
||||
mapped_ptr_t base_addr(static_cast<u8*>(::mmap(nullptr, 0x100000000, PROT_NONE, MAP_SHARED, memory_handle, 0)));
|
||||
mapped_ptr_t priv_addr(static_cast<u8*>(::mmap(nullptr, 0x100000000, PROT_NONE, MAP_SHARED, memory_handle, 0)));
|
||||
|
||||
shm_unlink("/rpcs3_vm");
|
||||
|
||||
std::printf("/rpcs3_vm: g_base_addr = %p, g_priv_addr = %p\n", base_addr, g_priv_addr);
|
||||
|
||||
return base_addr;
|
||||
::shm_unlink("/rpcs3_vm");
|
||||
#endif
|
||||
|
||||
std::printf("vm: base_addr = %p, priv_addr = %p\n", base_addr.get(), priv_addr.get());
|
||||
|
||||
return{ std::move(base_addr), std::move(priv_addr) };
|
||||
}
|
||||
|
||||
void finalize()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
UnmapViewOfFile(g_base_addr);
|
||||
UnmapViewOfFile(g_priv_addr);
|
||||
#else
|
||||
munmap(g_base_addr, 0x100000000);
|
||||
munmap(g_priv_addr, 0x100000000);
|
||||
#endif
|
||||
}
|
||||
const auto g_addr_set = vm::initialize();
|
||||
|
||||
void* const g_base_addr = (atexit(finalize), initialize());
|
||||
void* g_priv_addr;
|
||||
u8* const g_base_addr = g_addr_set[0].get();
|
||||
u8* const g_priv_addr = g_addr_set[1].get();
|
||||
|
||||
std::array<atomic_t<u8>, 0x100000000ull / 4096> g_pages{}; // information about every page
|
||||
|
||||
std::vector<std::shared_ptr<block_t>> g_locations; // memory locations
|
||||
|
||||
const thread_ctrl_t* const INVALID_THREAD = reinterpret_cast<const thread_ctrl_t*>(~0ull);
|
||||
|
||||
//using reservation_mutex_t = std::mutex;
|
||||
|
|
@ -361,9 +372,9 @@ namespace vm
|
|||
{
|
||||
#ifdef _WIN32
|
||||
DWORD old;
|
||||
if (!VirtualProtect(get_ptr(addr & ~0xfff), 4096, no_access ? PAGE_NOACCESS : PAGE_READONLY, &old))
|
||||
if (!::VirtualProtect(vm::base(addr & ~0xfff), 4096, no_access ? PAGE_NOACCESS : PAGE_READONLY, &old))
|
||||
#else
|
||||
if (mprotect(get_ptr(addr & ~0xfff), 4096, no_access ? PROT_NONE : PROT_READ))
|
||||
if (::mprotect(vm::base(addr & ~0xfff), 4096, no_access ? PROT_NONE : PROT_READ))
|
||||
#endif
|
||||
{
|
||||
throw EXCEPTION("System failure (addr=0x%x)", addr);
|
||||
|
|
@ -376,9 +387,9 @@ namespace vm
|
|||
{
|
||||
#ifdef _WIN32
|
||||
DWORD old;
|
||||
if (!VirtualProtect(get_ptr(addr & ~0xfff), 4096, PAGE_READWRITE, &old))
|
||||
if (!::VirtualProtect(vm::base(addr & ~0xfff), 4096, PAGE_READWRITE, &old))
|
||||
#else
|
||||
if (mprotect(get_ptr(addr & ~0xfff), 4096, PROT_READ | PROT_WRITE))
|
||||
if (::mprotect(vm::base(addr & ~0xfff), 4096, PROT_READ | PROT_WRITE))
|
||||
#endif
|
||||
{
|
||||
throw EXCEPTION("System failure (addr=0x%x)", addr);
|
||||
|
|
@ -443,7 +454,7 @@ namespace vm
|
|||
g_reservation_owner = get_current_thread_ctrl();
|
||||
|
||||
// copy data
|
||||
std::memcpy(data, get_ptr(addr), size);
|
||||
std::memcpy(data, vm::base(addr), size);
|
||||
}
|
||||
|
||||
bool reservation_update(u32 addr, const void* data, u32 size)
|
||||
|
|
@ -467,7 +478,7 @@ namespace vm
|
|||
_reservation_set(addr, true);
|
||||
|
||||
// update memory using privileged access
|
||||
std::memcpy(priv_ptr(addr), data, size);
|
||||
std::memcpy(vm::base_priv(addr), data, size);
|
||||
|
||||
// free the reservation and restore memory protection
|
||||
_reservation_break(addr);
|
||||
|
|
@ -578,7 +589,10 @@ namespace vm
|
|||
|
||||
void _page_map(u32 addr, u32 size, u8 flags)
|
||||
{
|
||||
assert(size && (size | addr) % 4096 == 0 && flags < page_allocated);
|
||||
if (!size || (size | addr) % 4096 || flags & page_allocated)
|
||||
{
|
||||
throw EXCEPTION("Invalid arguments (addr=0x%x, size=0x%x)", addr, size);
|
||||
}
|
||||
|
||||
for (u32 i = addr / 4096; i < addr / 4096 + size / 4096; i++)
|
||||
{
|
||||
|
|
@ -588,15 +602,15 @@ namespace vm
|
|||
}
|
||||
}
|
||||
|
||||
void* real_addr = get_ptr(addr);
|
||||
void* priv_addr = priv_ptr(addr);
|
||||
void* real_addr = vm::base(addr);
|
||||
void* priv_addr = vm::base_priv(addr);
|
||||
|
||||
#ifdef _WIN32
|
||||
auto protection = flags & page_writable ? PAGE_READWRITE : (flags & page_readable ? PAGE_READONLY : PAGE_NOACCESS);
|
||||
if (!VirtualAlloc(priv_addr, size, MEM_COMMIT, PAGE_READWRITE) || !VirtualAlloc(real_addr, size, MEM_COMMIT, protection))
|
||||
if (!::VirtualAlloc(priv_addr, size, MEM_COMMIT, PAGE_READWRITE) || !::VirtualAlloc(real_addr, size, MEM_COMMIT, protection))
|
||||
#else
|
||||
auto protection = flags & page_writable ? PROT_WRITE | PROT_READ : (flags & page_readable ? PROT_READ : PROT_NONE);
|
||||
if (mprotect(priv_addr, size, PROT_READ | PROT_WRITE) || mprotect(real_addr, size, protection))
|
||||
if (::mprotect(priv_addr, size, PROT_READ | PROT_WRITE) || ::mprotect(real_addr, size, protection))
|
||||
#endif
|
||||
{
|
||||
throw EXCEPTION("System failure (addr=0x%x, size=0x%x, flags=0x%x)", addr, size, flags);
|
||||
|
|
@ -610,16 +624,19 @@ namespace vm
|
|||
}
|
||||
}
|
||||
|
||||
memset(priv_addr, 0, size); // ???
|
||||
std::memset(priv_addr, 0, size); // ???
|
||||
}
|
||||
|
||||
bool page_protect(u32 addr, u32 size, u8 flags_test, u8 flags_set, u8 flags_clear)
|
||||
{
|
||||
std::lock_guard<reservation_mutex_t> lock(g_reservation_mutex);
|
||||
|
||||
u8 flags_inv = flags_set & flags_clear;
|
||||
if (!size || (size | addr) % 4096)
|
||||
{
|
||||
throw EXCEPTION("Invalid arguments (addr=0x%x, size=0x%x)", addr, size);
|
||||
}
|
||||
|
||||
assert(size && (size | addr) % 4096 == 0);
|
||||
const u8 flags_inv = flags_set & flags_clear;
|
||||
|
||||
flags_test |= page_allocated;
|
||||
|
||||
|
|
@ -646,16 +663,16 @@ namespace vm
|
|||
|
||||
if (f1 != f2)
|
||||
{
|
||||
void* real_addr = get_ptr(i * 4096);
|
||||
void* real_addr = vm::base(i * 4096);
|
||||
|
||||
#ifdef _WIN32
|
||||
DWORD old;
|
||||
|
||||
auto protection = f2 & page_writable ? PAGE_READWRITE : (f2 & page_readable ? PAGE_READONLY : PAGE_NOACCESS);
|
||||
if (!VirtualProtect(real_addr, 4096, protection, &old))
|
||||
if (!::VirtualProtect(real_addr, 4096, protection, &old))
|
||||
#else
|
||||
auto protection = f2 & page_writable ? PROT_WRITE | PROT_READ : (f2 & page_readable ? PROT_READ : PROT_NONE);
|
||||
if (mprotect(real_addr, 4096, protection))
|
||||
if (::mprotect(real_addr, 4096, protection))
|
||||
#endif
|
||||
{
|
||||
throw EXCEPTION("System failure (addr=0x%x, size=0x%x, flags_test=0x%x, flags_set=0x%x, flags_clear=0x%x)", addr, size, flags_test, flags_set, flags_clear);
|
||||
|
|
@ -668,7 +685,10 @@ namespace vm
|
|||
|
||||
void _page_unmap(u32 addr, u32 size)
|
||||
{
|
||||
assert(size && (size | addr) % 4096 == 0);
|
||||
if (!size || (size | addr) % 4096)
|
||||
{
|
||||
throw EXCEPTION("Invalid arguments (addr=0x%x, size=0x%x)", addr, size);
|
||||
}
|
||||
|
||||
for (u32 i = addr / 4096; i < addr / 4096 + size / 4096; i++)
|
||||
{
|
||||
|
|
@ -688,15 +708,15 @@ namespace vm
|
|||
}
|
||||
}
|
||||
|
||||
void* real_addr = get_ptr(addr);
|
||||
void* priv_addr = priv_ptr(addr);
|
||||
void* real_addr = vm::base(addr);
|
||||
void* priv_addr = vm::base_priv(addr);
|
||||
|
||||
#ifdef _WIN32
|
||||
DWORD old;
|
||||
|
||||
if (!VirtualProtect(real_addr, size, PAGE_NOACCESS, &old) || !VirtualProtect(priv_addr, size, PAGE_NOACCESS, &old))
|
||||
if (!::VirtualProtect(real_addr, size, PAGE_NOACCESS, &old) || !::VirtualProtect(priv_addr, size, PAGE_NOACCESS, &old))
|
||||
#else
|
||||
if (mprotect(real_addr, size, PROT_NONE) || mprotect(priv_addr, size, PROT_NONE))
|
||||
if (::mprotect(real_addr, size, PROT_NONE) || ::mprotect(priv_addr, size, PROT_NONE))
|
||||
#endif
|
||||
{
|
||||
throw EXCEPTION("System failure (addr=0x%x, size=0x%x)", addr, size);
|
||||
|
|
@ -705,8 +725,6 @@ namespace vm
|
|||
|
||||
bool check_addr(u32 addr, u32 size)
|
||||
{
|
||||
assert(size);
|
||||
|
||||
if (addr + (size - 1) < addr)
|
||||
{
|
||||
return false;
|
||||
|
|
@ -723,8 +741,6 @@ namespace vm
|
|||
return true;
|
||||
}
|
||||
|
||||
std::vector<std::shared_ptr<block_t>> g_locations;
|
||||
|
||||
u32 alloc(u32 size, memory_location_t location, u32 align)
|
||||
{
|
||||
const auto block = get(location);
|
||||
|
|
@ -1003,8 +1019,7 @@ namespace vm
|
|||
std::make_shared<block_t>(0x20000000, 0x10000000), // user
|
||||
std::make_shared<block_t>(0xC0000000, 0x10000000), // video
|
||||
std::make_shared<block_t>(0xD0000000, 0x10000000), // stack
|
||||
|
||||
std::make_shared<block_t>(0xE0000000, 0x20000000), // SPU
|
||||
std::make_shared<block_t>(0xE0000000, 0x20000000), // SPU reserved
|
||||
};
|
||||
|
||||
vm::start();
|
||||
|
|
@ -1019,8 +1034,8 @@ namespace vm
|
|||
{
|
||||
std::make_shared<block_t>(0x81000000, 0x10000000), // RAM
|
||||
std::make_shared<block_t>(0x91000000, 0x2F000000), // user
|
||||
nullptr, // video
|
||||
nullptr, // stack
|
||||
std::make_shared<block_t>(0xC0000000, 0x10000000), // video (arbitrarily)
|
||||
std::make_shared<block_t>(0xD0000000, 0x10000000), // stack (arbitrarily)
|
||||
};
|
||||
|
||||
vm::start();
|
||||
|
|
@ -1051,16 +1066,16 @@ namespace vm
|
|||
g_locations.clear();
|
||||
}
|
||||
|
||||
u32 stack_push(CPUThread& cpu, u32 size, u32 align_v, u32& old_pos)
|
||||
u32 stack_push(u32 size, u32 align_v)
|
||||
{
|
||||
switch (cpu.get_type())
|
||||
if (auto cpu = get_current_cpu_thread()) switch (cpu->get_type())
|
||||
{
|
||||
case CPU_THREAD_PPU:
|
||||
{
|
||||
PPUThread& context = static_cast<PPUThread&>(cpu);
|
||||
PPUThread& context = static_cast<PPUThread&>(*cpu);
|
||||
|
||||
old_pos = VM_CAST(context.GPR[1]);
|
||||
context.GPR[1] -= align(size, 8); // room minimal possible size
|
||||
const u32 old_pos = VM_CAST(context.GPR[1]);
|
||||
context.GPR[1] -= align(size + 4, 8); // room minimal possible size
|
||||
context.GPR[1] &= ~(align_v - 1); // fix stack alignment
|
||||
|
||||
if (context.GPR[1] < context.stack_addr)
|
||||
|
|
@ -1069,17 +1084,19 @@ namespace vm
|
|||
}
|
||||
else
|
||||
{
|
||||
return static_cast<u32>(context.GPR[1]);
|
||||
const u32 addr = static_cast<u32>(context.GPR[1]);
|
||||
vm::ps3::_ref<nse_t<u32>>(addr + size) = old_pos;
|
||||
return addr;
|
||||
}
|
||||
}
|
||||
|
||||
case CPU_THREAD_SPU:
|
||||
case CPU_THREAD_RAW_SPU:
|
||||
{
|
||||
SPUThread& context = static_cast<SPUThread&>(cpu);
|
||||
SPUThread& context = static_cast<SPUThread&>(*cpu);
|
||||
|
||||
old_pos = context.gpr[1]._u32[3];
|
||||
context.gpr[1]._u32[3] -= align(size, 16);
|
||||
const u32 old_pos = context.gpr[1]._u32[3];
|
||||
context.gpr[1]._u32[3] -= align(size + 4, 16);
|
||||
context.gpr[1]._u32[3] &= ~(align_v - 1);
|
||||
|
||||
if (context.gpr[1]._u32[3] >= 0x40000) // extremely rough
|
||||
|
|
@ -1088,16 +1105,18 @@ namespace vm
|
|||
}
|
||||
else
|
||||
{
|
||||
return context.gpr[1]._u32[3] + context.offset;
|
||||
const u32 addr = context.gpr[1]._u32[3] + context.offset;
|
||||
vm::ps3::_ref<nse_t<u32>>(addr + size) = old_pos;
|
||||
return addr;
|
||||
}
|
||||
}
|
||||
|
||||
case CPU_THREAD_ARMv7:
|
||||
{
|
||||
ARMv7Context& context = static_cast<ARMv7Thread&>(cpu);
|
||||
ARMv7Context& context = static_cast<ARMv7Thread&>(*cpu);
|
||||
|
||||
old_pos = context.SP;
|
||||
context.SP -= align(size, 4); // room minimal possible size
|
||||
const u32 old_pos = context.SP;
|
||||
context.SP -= align(size + 4, 4); // room minimal possible size
|
||||
context.SP &= ~(align_v - 1); // fix stack alignment
|
||||
|
||||
if (context.SP < context.stack_addr)
|
||||
|
|
@ -1106,65 +1125,70 @@ namespace vm
|
|||
}
|
||||
else
|
||||
{
|
||||
vm::psv::_ref<nse_t<u32>>(context.SP + size) = old_pos;
|
||||
return context.SP;
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
throw EXCEPTION("Invalid thread type (%d)", cpu.get_id());
|
||||
throw EXCEPTION("Invalid thread type (%d)", cpu->get_type());
|
||||
}
|
||||
}
|
||||
|
||||
throw EXCEPTION("Invalid thread");
|
||||
}
|
||||
|
||||
void stack_pop(CPUThread& cpu, u32 addr, u32 old_pos)
|
||||
void stack_pop(u32 addr, u32 size)
|
||||
{
|
||||
switch (cpu.get_type())
|
||||
if (auto cpu = get_current_cpu_thread()) switch (cpu->get_type())
|
||||
{
|
||||
case CPU_THREAD_PPU:
|
||||
{
|
||||
PPUThread& context = static_cast<PPUThread&>(cpu);
|
||||
PPUThread& context = static_cast<PPUThread&>(*cpu);
|
||||
|
||||
if (context.GPR[1] != addr)
|
||||
{
|
||||
throw EXCEPTION("Stack inconsistency (addr=0x%x, SP=0x%llx, old_pos=0x%x)", addr, context.GPR[1], old_pos);
|
||||
throw EXCEPTION("Stack inconsistency (addr=0x%x, SP=0x%llx, size=0x%x)", addr, context.GPR[1], size);
|
||||
}
|
||||
|
||||
context.GPR[1] = old_pos;
|
||||
context.GPR[1] = vm::ps3::_ref<nse_t<u32>>(context.GPR[1] + size);
|
||||
return;
|
||||
}
|
||||
|
||||
case CPU_THREAD_SPU:
|
||||
case CPU_THREAD_RAW_SPU:
|
||||
{
|
||||
SPUThread& context = static_cast<SPUThread&>(cpu);
|
||||
SPUThread& context = static_cast<SPUThread&>(*cpu);
|
||||
|
||||
if (context.gpr[1]._u32[3] + context.offset != addr)
|
||||
{
|
||||
throw EXCEPTION("Stack inconsistency (addr=0x%x, SP=LS:0x%05x, old_pos=LS:0x%05x)", addr, context.gpr[1]._u32[3], old_pos);
|
||||
throw EXCEPTION("Stack inconsistency (addr=0x%x, SP=LS:0x%05x, size=0x%x)", addr, context.gpr[1]._u32[3], size);
|
||||
}
|
||||
|
||||
context.gpr[1]._u32[3] = old_pos;
|
||||
context.gpr[1]._u32[3] = vm::ps3::_ref<nse_t<u32>>(context.gpr[1]._u32[3] + context.offset + size);
|
||||
return;
|
||||
}
|
||||
|
||||
case CPU_THREAD_ARMv7:
|
||||
{
|
||||
ARMv7Context& context = static_cast<ARMv7Thread&>(cpu);
|
||||
ARMv7Context& context = static_cast<ARMv7Thread&>(*cpu);
|
||||
|
||||
if (context.SP != addr)
|
||||
{
|
||||
throw EXCEPTION("Stack inconsistency (addr=0x%x, SP=0x%x, old_pos=0x%x)", addr, context.SP, old_pos);
|
||||
throw EXCEPTION("Stack inconsistency (addr=0x%x, SP=0x%x, size=0x%x)", addr, context.SP, size);
|
||||
}
|
||||
|
||||
context.SP = old_pos;
|
||||
context.SP = vm::psv::_ref<nse_t<u32>>(context.SP + size);
|
||||
return;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
throw EXCEPTION("Invalid thread type (%d)", cpu.get_type());
|
||||
throw EXCEPTION("Invalid thread type (%d)", cpu->get_type());
|
||||
}
|
||||
}
|
||||
|
||||
throw EXCEPTION("Invalid thread");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,8 +8,8 @@ class named_thread_t;
|
|||
|
||||
namespace vm
|
||||
{
|
||||
extern void* const g_base_addr; // base address of ps3/psv virtual memory for common access
|
||||
extern void* g_priv_addr; // base address of ps3/psv virtual memory for privileged access
|
||||
extern u8* const g_base_addr;
|
||||
extern u8* const g_priv_addr;
|
||||
|
||||
enum memory_location_t : uint
|
||||
{
|
||||
|
|
@ -39,7 +39,7 @@ namespace vm
|
|||
u32 addr = 0;
|
||||
u32 mask = ~0;
|
||||
named_thread_t* thread = nullptr;
|
||||
|
||||
|
||||
std::function<bool()> pred;
|
||||
|
||||
waiter_t() = default;
|
||||
|
|
@ -68,8 +68,6 @@ namespace vm
|
|||
std::unique_lock<std::mutex> m_lock;
|
||||
|
||||
public:
|
||||
waiter_lock_t() = delete;
|
||||
|
||||
waiter_lock_t(named_thread_t& thread, u32 addr, u32 size);
|
||||
|
||||
waiter_t* operator ->() const
|
||||
|
|
@ -82,7 +80,7 @@ namespace vm
|
|||
~waiter_lock_t();
|
||||
};
|
||||
|
||||
// wait until pred() returns true, addr must be aligned to size which must be a power of 2, pred() may be called by any thread
|
||||
// Wait until pred() returns true, addr must be aligned to size which must be a power of 2, pred() may be called by any thread
|
||||
template<typename F, typename... Args> auto wait_op(named_thread_t& thread, u32 addr, u32 size, F pred, Args&&... args) -> decltype(static_cast<void>(pred(args...)))
|
||||
{
|
||||
// return immediately if condition passed (optimistic case)
|
||||
|
|
@ -98,10 +96,10 @@ namespace vm
|
|||
lock.wait();
|
||||
}
|
||||
|
||||
// notify waiters on specific addr, addr must be aligned to size which must be a power of 2
|
||||
// Notify waiters on specific addr, addr must be aligned to size which must be a power of 2
|
||||
void notify_at(u32 addr, u32 size);
|
||||
|
||||
// try to poll each waiter's condition (false if try_lock failed)
|
||||
// Try to poll each waiter's condition (false if try_lock failed)
|
||||
bool notify_all();
|
||||
|
||||
// This flag is changed by various reservation functions and may have different meaning.
|
||||
|
|
@ -152,7 +150,7 @@ namespace vm
|
|||
// dealloc() with no return value and no exceptions
|
||||
void dealloc_verbose_nothrow(u32 addr, memory_location_t location = any) noexcept;
|
||||
|
||||
// Object that handles memory allocations inside specific constant bounds ("location"), currently non-virtual
|
||||
// Object that handles memory allocations inside specific constant bounds ("location")
|
||||
class block_t final
|
||||
{
|
||||
std::map<u32, u32> m_map; // addr -> size mapping of mapped locations
|
||||
|
|
@ -161,12 +159,11 @@ namespace vm
|
|||
bool try_alloc(u32 addr, u32 size);
|
||||
|
||||
public:
|
||||
block_t() = delete;
|
||||
|
||||
block_t(u32 addr, u32 size, u64 flags = 0)
|
||||
: addr(addr)
|
||||
, size(size)
|
||||
, flags(flags)
|
||||
, used(0)
|
||||
{
|
||||
}
|
||||
|
||||
|
|
@ -177,7 +174,7 @@ namespace vm
|
|||
const u32 size; // total size
|
||||
const u64 flags; // currently unused
|
||||
|
||||
atomic_t<u32> used{}; // amount of memory used, may be increased manually to prevent some memory from allocating
|
||||
atomic_t<u32> used; // amount of memory used, may be increased manually to prevent some memory from allocating
|
||||
|
||||
// Search and map memory (don't pass alignment smaller than 4096)
|
||||
u32 alloc(u32 size, u32 align = 4096);
|
||||
|
|
@ -197,30 +194,16 @@ namespace vm
|
|||
|
||||
// get memory block associated with optionally specified memory location or optionally specified address
|
||||
std::shared_ptr<block_t> get(memory_location_t location, u32 addr = 0);
|
||||
|
||||
template<typename T = void> T* get_ptr(u32 addr)
|
||||
{
|
||||
return reinterpret_cast<T*>(static_cast<u8*>(g_base_addr) + addr);
|
||||
}
|
||||
|
||||
template<typename T> T& get_ref(u32 addr)
|
||||
// Get PS3/PSV virtual memory address from the provided pointer (nullptr always converted to 0)
|
||||
inline u32 get_addr(const void* real_ptr)
|
||||
{
|
||||
return *get_ptr<T>(addr);
|
||||
}
|
||||
if (!real_ptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
template<typename T = void> T* priv_ptr(u32 addr)
|
||||
{
|
||||
return reinterpret_cast<T*>(static_cast<u8*>(g_priv_addr) + addr);
|
||||
}
|
||||
|
||||
template<typename T> T& priv_ref(u32 addr)
|
||||
{
|
||||
return *priv_ptr<T>(addr);
|
||||
}
|
||||
|
||||
inline u32 get_addr(const void* real_pointer)
|
||||
{
|
||||
const std::uintptr_t diff = reinterpret_cast<std::uintptr_t>(real_pointer) - reinterpret_cast<std::uintptr_t>(g_base_addr);
|
||||
const std::ptrdiff_t diff = static_cast<const u8*>(real_ptr) - g_base_addr;
|
||||
const u32 res = static_cast<u32>(diff);
|
||||
|
||||
if (res == diff)
|
||||
|
|
@ -228,27 +211,23 @@ namespace vm
|
|||
return res;
|
||||
}
|
||||
|
||||
if (real_pointer)
|
||||
{
|
||||
throw EXCEPTION("Not a virtual memory pointer (%p)", real_pointer);
|
||||
}
|
||||
throw EXCEPTION("Not a virtual memory pointer (%p)", real_ptr);
|
||||
}
|
||||
|
||||
return 0;
|
||||
// Convert pointer-to-member to a vm address compatible offset
|
||||
template<typename MT, typename T> inline u32 get_offset(MT T::*const member_ptr)
|
||||
{
|
||||
return static_cast<u32>(reinterpret_cast<std::uintptr_t>(&(reinterpret_cast<T*>(0ull)->*member_ptr)));
|
||||
}
|
||||
|
||||
template<typename T> struct cast_ptr
|
||||
{
|
||||
static_assert(std::is_same<T, u32>::value, "Unsupported VM_CAST() type");
|
||||
|
||||
force_inline static u32 cast(const T& addr, const char* file, int line, const char* func)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
template<> struct cast_ptr<u32>
|
||||
{
|
||||
force_inline static u32 cast(const u32 addr, const char* file, int line, const char* func)
|
||||
static u32 cast(const u32 addr, const char* file, int line, const char* func)
|
||||
{
|
||||
return addr;
|
||||
}
|
||||
|
|
@ -256,131 +235,157 @@ namespace vm
|
|||
|
||||
template<> struct cast_ptr<u64>
|
||||
{
|
||||
force_inline static u32 cast(const u64 addr, const char* file, int line, const char* func)
|
||||
static u32 cast(const u64 addr, const char* file, int line, const char* func)
|
||||
{
|
||||
const u32 res = static_cast<u32>(addr);
|
||||
|
||||
if (res != addr)
|
||||
{
|
||||
throw fmt::exception(file, line, func, "VM_CAST failed (addr=0x%llx)", addr);
|
||||
}
|
||||
|
||||
return res;
|
||||
return static_cast<u32>(addr) == addr ? static_cast<u32>(addr) : throw fmt::exception(file, line, func, "VM_CAST failed (addr=0x%llx)", addr);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T, bool Se> struct cast_ptr<se_t<T, Se>>
|
||||
{
|
||||
force_inline static u32 cast(const se_t<T, Se>& addr, const char* file, int line, const char* func)
|
||||
static u32 cast(const se_t<T, Se>& addr, const char* file, int line, const char* func)
|
||||
{
|
||||
return cast_ptr<T>::cast(addr, file, line, func);
|
||||
}
|
||||
};
|
||||
|
||||
// function for VM_CAST
|
||||
template<typename T> force_inline static u32 impl_cast(const T& addr, const char* file, int line, const char* func)
|
||||
template<typename T> u32 impl_cast(const T& addr, const char* file, int line, const char* func)
|
||||
{
|
||||
return cast_ptr<T>::cast(addr, file, line, func);
|
||||
}
|
||||
|
||||
static const u8& read8(u32 addr)
|
||||
// Convert specified PS3/PSV virtual memory address to a pointer for common access
|
||||
inline void* base(u32 addr)
|
||||
{
|
||||
return get_ref<const u8>(addr);
|
||||
return g_base_addr + addr;
|
||||
}
|
||||
|
||||
static void write8(u32 addr, u8 value)
|
||||
// Convert specified PS3/PSV virtual memory address to a pointer for privileged access (always readable/writable if allocated)
|
||||
inline void* base_priv(u32 addr)
|
||||
{
|
||||
get_ref<u8>(addr) = value;
|
||||
return g_priv_addr + addr;
|
||||
}
|
||||
|
||||
inline const u8& read8(u32 addr)
|
||||
{
|
||||
return g_base_addr[addr];
|
||||
}
|
||||
|
||||
inline void write8(u32 addr, u8 value)
|
||||
{
|
||||
g_base_addr[addr] = value;
|
||||
}
|
||||
|
||||
namespace ps3
|
||||
{
|
||||
void init();
|
||||
// Convert specified PS3 address to a pointer of specified (possibly converted to BE) type
|
||||
template<typename T> inline to_be_t<T>* _ptr(u32 addr)
|
||||
{
|
||||
return static_cast<to_be_t<T>*>(base(addr));
|
||||
}
|
||||
|
||||
template<typename T> inline to_be_t<T>* _ptr_priv(u32 addr)
|
||||
{
|
||||
return static_cast<to_be_t<T>*>(base_priv(addr));
|
||||
}
|
||||
|
||||
// Convert specified PS3 address to a reference of specified (possibly converted to BE) type
|
||||
template<typename T> inline to_be_t<T>& _ref(u32 addr)
|
||||
{
|
||||
return *_ptr<T>(addr);
|
||||
}
|
||||
|
||||
template<typename T> inline to_be_t<T>& _ref_priv(u32 addr)
|
||||
{
|
||||
return *_ptr_priv<T>(addr);
|
||||
}
|
||||
|
||||
inline const be_t<u16>& read16(u32 addr)
|
||||
{
|
||||
return get_ref<const be_t<u16>>(addr);
|
||||
return _ref<u16>(addr);
|
||||
}
|
||||
|
||||
inline void write16(u32 addr, be_t<u16> value)
|
||||
{
|
||||
get_ref<be_t<u16>>(addr) = value;
|
||||
_ref<u16>(addr) = value;
|
||||
}
|
||||
|
||||
inline const be_t<u32>& read32(u32 addr)
|
||||
{
|
||||
return get_ref<const be_t<u32>>(addr);
|
||||
return _ref<u32>(addr);
|
||||
}
|
||||
|
||||
inline void write32(u32 addr, be_t<u32> value)
|
||||
{
|
||||
get_ref<be_t<u32>>(addr) = value;
|
||||
_ref<u32>(addr) = value;
|
||||
}
|
||||
|
||||
inline const be_t<u64>& read64(u32 addr)
|
||||
{
|
||||
return get_ref<const be_t<u64>>(addr);
|
||||
return _ref<u64>(addr);
|
||||
}
|
||||
|
||||
inline void write64(u32 addr, be_t<u64> value)
|
||||
{
|
||||
get_ref<be_t<u64>>(addr) = value;
|
||||
_ref<u64>(addr) = value;
|
||||
}
|
||||
|
||||
inline const be_t<v128>& read128(u32 addr)
|
||||
{
|
||||
return get_ref<const be_t<v128>>(addr);
|
||||
}
|
||||
|
||||
inline void write128(u32 addr, be_t<v128> value)
|
||||
{
|
||||
get_ref<be_t<v128>>(addr) = value;
|
||||
}
|
||||
void init();
|
||||
}
|
||||
|
||||
namespace psv
|
||||
{
|
||||
void init();
|
||||
template<typename T> inline to_le_t<T>* _ptr(u32 addr)
|
||||
{
|
||||
return static_cast<to_le_t<T>*>(base(addr));
|
||||
}
|
||||
|
||||
template<typename T> inline to_le_t<T>* _ptr_priv(u32 addr)
|
||||
{
|
||||
return static_cast<to_le_t<T>*>(base_priv(addr));
|
||||
}
|
||||
|
||||
template<typename T> inline to_le_t<T>& _ref(u32 addr)
|
||||
{
|
||||
return *_ptr<T>(addr);
|
||||
}
|
||||
|
||||
template<typename T> inline to_le_t<T>& _ref_priv(u32 addr)
|
||||
{
|
||||
return *_ptr_priv<T>(addr);
|
||||
}
|
||||
|
||||
inline const le_t<u16>& read16(u32 addr)
|
||||
{
|
||||
return get_ref<const le_t<u16>>(addr);
|
||||
return _ref<u16>(addr);
|
||||
}
|
||||
|
||||
inline void write16(u32 addr, le_t<u16> value)
|
||||
{
|
||||
get_ref<le_t<u16>>(addr) = value;
|
||||
_ref<u16>(addr) = value;
|
||||
}
|
||||
|
||||
inline const le_t<u32>& read32(u32 addr)
|
||||
{
|
||||
return get_ref<const le_t<u32>>(addr);
|
||||
return _ref<u32>(addr);
|
||||
}
|
||||
|
||||
inline void write32(u32 addr, le_t<u32> value)
|
||||
{
|
||||
get_ref<le_t<u32>>(addr) = value;
|
||||
_ref<u32>(addr) = value;
|
||||
}
|
||||
|
||||
inline const le_t<u64>& read64(u32 addr)
|
||||
{
|
||||
return get_ref<const le_t<u64>>(addr);
|
||||
return _ref<u64>(addr);
|
||||
}
|
||||
|
||||
inline void write64(u32 addr, le_t<u64> value)
|
||||
{
|
||||
get_ref<le_t<u64>>(addr) = value;
|
||||
_ref<u64>(addr) = value;
|
||||
}
|
||||
|
||||
inline const le_t<v128>& read128(u32 addr)
|
||||
{
|
||||
return get_ref<const le_t<v128>>(addr);
|
||||
}
|
||||
|
||||
inline void write128(u32 addr, le_t<v128> value)
|
||||
{
|
||||
get_ref<le_t<v128>>(addr) = value;
|
||||
}
|
||||
void init();
|
||||
}
|
||||
|
||||
namespace psp
|
||||
|
|
@ -393,11 +398,8 @@ namespace vm
|
|||
void close();
|
||||
}
|
||||
|
||||
#include "vm_ref.h"
|
||||
#include "vm_ptr.h"
|
||||
|
||||
class CPUThread;
|
||||
|
||||
namespace vm
|
||||
{
|
||||
class stack
|
||||
|
|
@ -433,8 +435,8 @@ namespace vm
|
|||
}
|
||||
};
|
||||
|
||||
u32 stack_push(CPUThread& cpu, u32 size, u32 align_v, u32& old_pos);
|
||||
void stack_pop(CPUThread& cpu, u32 addr, u32 old_pos);
|
||||
u32 stack_push(u32 size, u32 align_v);
|
||||
void stack_pop(u32 addr, u32 size);
|
||||
}
|
||||
|
||||
#include "vm_var.h"
|
||||
|
|
|
|||
|
|
@ -1,12 +1,12 @@
|
|||
#pragma once
|
||||
|
||||
#include "vm_ref.h"
|
||||
|
||||
class PPUThread;
|
||||
class ARMv7Thread;
|
||||
|
||||
namespace vm
|
||||
{
|
||||
template<typename T, typename AT> struct _ref_base;
|
||||
|
||||
// helper SFINAE type for vm::_ptr_base comparison operators (enables comparison between equal types and between any type and void*)
|
||||
template<typename T1, typename T2, typename RT = void> using if_comparable_t = std::enable_if_t<
|
||||
std::is_void<T1>::value ||
|
||||
|
|
@ -14,84 +14,83 @@ namespace vm
|
|||
std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
|
||||
RT>;
|
||||
|
||||
// helper SFINAE type for vm::_ptr_base pointer arithmetic operators and indirection (disabled for void and function pointers)
|
||||
template<typename T, typename RT = void> using if_arithmetical_ptr_t = std::enable_if_t<
|
||||
!std::is_void<T>::value &&
|
||||
!std::is_function<T>::value,
|
||||
RT>;
|
||||
|
||||
template<typename T, typename AT = u32>
|
||||
struct _ptr_base
|
||||
template<typename T, typename AT = u32> class _ptr_base
|
||||
{
|
||||
AT m_addr; // don't access directly
|
||||
|
||||
using type = T;
|
||||
AT m_addr;
|
||||
|
||||
static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
|
||||
static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
|
||||
|
||||
AT addr() const
|
||||
public:
|
||||
using type = T;
|
||||
using addr_type = std::remove_cv_t<AT>;
|
||||
|
||||
_ptr_base() = default;
|
||||
|
||||
constexpr _ptr_base(addr_type addr, const addr_tag_t&)
|
||||
: m_addr(addr)
|
||||
{
|
||||
}
|
||||
|
||||
constexpr addr_type addr() const
|
||||
{
|
||||
return m_addr;
|
||||
}
|
||||
|
||||
// get vm pointer to a struct member
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<MT> ptr(MT T2::*const member) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<MT> ptr(MT T2::*const mptr) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr), vm::addr };
|
||||
}
|
||||
|
||||
// get vm pointer to a struct member with array subscription
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<std::remove_extent_t<MT>> ptr(MT T2::*const member, u32 index) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ptr_base<std::remove_extent_t<MT>> ptr(MT T2::*const mptr, u32 index) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset + sizeof32(T) * index) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr) + sizeof32(T) * index, vm::addr };
|
||||
}
|
||||
|
||||
// get vm reference to a struct member
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<MT> ref(MT T2::*const member) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<MT> ref(MT T2::*const mptr) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr), vm::addr };
|
||||
}
|
||||
|
||||
// get vm reference to a struct member with array subscription
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<std::remove_extent_t<MT>> ref(MT T2::*const member, u32 index) const
|
||||
template<typename MT, typename T2, typename = if_comparable_t<T, T2>> _ref_base<std::remove_extent_t<MT>> ref(MT T2::*const mptr, u32 index) const
|
||||
{
|
||||
const u32 offset = static_cast<u32>(reinterpret_cast<std::ptrdiff_t>(&(reinterpret_cast<T*>(0ull)->*member)));
|
||||
return{ VM_CAST(m_addr + offset + sizeof32(T) * index) };
|
||||
return{ VM_CAST(m_addr) + get_offset(mptr) + sizeof32(T) * index, vm::addr };
|
||||
}
|
||||
|
||||
// get vm reference
|
||||
_ref_base<T, u32> ref() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
|
||||
/*[[deprecated("Use constructor instead")]]*/ void set(addr_type value)
|
||||
{
|
||||
m_addr = value;
|
||||
}
|
||||
|
||||
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ptr_base> make(const AT2& addr)
|
||||
/*[[deprecated("Use constructor instead")]]*/ static _ptr_base make(addr_type addr)
|
||||
{
|
||||
const AT value = addr;
|
||||
return{ value };
|
||||
return{ addr, vm::addr };
|
||||
}
|
||||
|
||||
T* get_ptr() const
|
||||
{
|
||||
return vm::get_ptr<T>(VM_CAST(m_addr));
|
||||
return static_cast<T*>(vm::base(VM_CAST(m_addr)));
|
||||
}
|
||||
|
||||
T* priv_ptr() const
|
||||
T* get_ptr_priv() const
|
||||
{
|
||||
return vm::priv_ptr<T>(VM_CAST(m_addr));
|
||||
return static_cast<T*>(vm::base_priv(VM_CAST(m_addr)));
|
||||
}
|
||||
|
||||
T* operator ->() const
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-> is not available for void pointers");
|
||||
|
||||
return get_ptr();
|
||||
}
|
||||
|
||||
|
|
@ -99,59 +98,127 @@ namespace vm
|
|||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator[] is not available for void pointers");
|
||||
|
||||
return vm::get_ref<T>(VM_CAST(m_addr + sizeof32(T) * index));
|
||||
return *static_cast<T*>(vm::base(VM_CAST(m_addr) + sizeof32(T) * index));
|
||||
}
|
||||
|
||||
// enable only the conversions which are originally possible between pointer types
|
||||
template<typename T2, typename AT2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> operator _ptr_base<T2, AT2>() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
template<typename T2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> explicit operator T2*() const
|
||||
{
|
||||
return get_ptr();
|
||||
}
|
||||
//template<typename T2, typename = std::enable_if_t<std::is_convertible<T*, T2*>::value>> explicit operator T2*() const
|
||||
//{
|
||||
// return get_ptr();
|
||||
//}
|
||||
|
||||
explicit operator bool() const
|
||||
{
|
||||
return m_addr != 0;
|
||||
}
|
||||
|
||||
// test address alignment using alignof(T)
|
||||
// Test address for arbitrary alignment: (addr & (align - 1)) != 0
|
||||
bool aligned(u32 align) const
|
||||
{
|
||||
return (m_addr & (align - 1)) == 0;
|
||||
}
|
||||
|
||||
// Test address for type's alignment using alignof(T)
|
||||
bool aligned() const
|
||||
{
|
||||
return m_addr % alignof32(T) == 0;
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: aligned() is not available for void pointers");
|
||||
|
||||
return aligned(alignof32(T));
|
||||
}
|
||||
|
||||
// test address for arbitrary alignment or something
|
||||
force_inline explicit_bool_t operator %(to_ne_t<AT> right) const
|
||||
// Call aligned(value)
|
||||
explicit_bool_t operator %(u32 align) const
|
||||
{
|
||||
return m_addr % right != 0;
|
||||
return aligned(align);
|
||||
}
|
||||
|
||||
_ptr_base& operator =(const _ptr_base&) = default;
|
||||
// pointer increment (postfix)
|
||||
_ptr_base operator ++(int)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator++ is not available for void pointers");
|
||||
|
||||
const addr_type result = m_addr;
|
||||
m_addr = VM_CAST(m_addr) + sizeof32(T);
|
||||
return{ result, vm::addr };
|
||||
}
|
||||
|
||||
// pointer increment (prefix)
|
||||
_ptr_base& operator ++()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator++ is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) + sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
|
||||
// pointer decrement (postfix)
|
||||
_ptr_base operator --(int)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-- is not available for void pointers");
|
||||
|
||||
const addr_type result = m_addr;
|
||||
m_addr = VM_CAST(m_addr) - sizeof32(T);
|
||||
return{ result, vm::addr };
|
||||
}
|
||||
|
||||
// pointer decrement (prefix)
|
||||
_ptr_base& operator --()
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-- is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) - sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
|
||||
_ptr_base& operator +=(s32 count)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator+= is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) + count * sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
|
||||
_ptr_base& operator -=(s32 count)
|
||||
{
|
||||
static_assert(!std::is_void<T>::value, "vm::_ptr_base<> error: operator-= is not available for void pointers");
|
||||
|
||||
m_addr = VM_CAST(m_addr) - count * sizeof32(T);
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename AT, typename RT, typename... T>
|
||||
struct _ptr_base<RT(T...), AT>
|
||||
template<typename AT, typename RT, typename... T> class _ptr_base<RT(T...), AT>
|
||||
{
|
||||
AT m_addr;
|
||||
|
||||
AT addr() const
|
||||
public:
|
||||
using addr_type = std::remove_cv_t<AT>;
|
||||
|
||||
_ptr_base() = default;
|
||||
|
||||
constexpr _ptr_base(addr_type addr, const addr_tag_t&)
|
||||
: m_addr(addr)
|
||||
{
|
||||
}
|
||||
|
||||
constexpr addr_type addr() const
|
||||
{
|
||||
return m_addr;
|
||||
}
|
||||
|
||||
template<typename CT> std::enable_if_t<std::is_assignable<AT&, CT>::value> set(const CT& value)
|
||||
/*[[deprecated("Use constructor instead")]]*/ void set(addr_type value)
|
||||
{
|
||||
m_addr = value;
|
||||
}
|
||||
|
||||
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ptr_base> make(const AT2& addr)
|
||||
/*[[deprecated("Use constructor instead")]]*/ static _ptr_base make(addr_type addr)
|
||||
{
|
||||
const AT value = addr;
|
||||
return{ value };
|
||||
return{ addr, vm::addr };
|
||||
}
|
||||
|
||||
// defined in CB_FUNC.h, passing context is mandatory
|
||||
|
|
@ -163,19 +230,16 @@ namespace vm
|
|||
// conversion to another function pointer
|
||||
template<typename AT2> operator _ptr_base<RT(T...), AT2>() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
explicit operator bool() const
|
||||
{
|
||||
return m_addr != 0;
|
||||
}
|
||||
|
||||
_ptr_base& operator =(const _ptr_base&) = default;
|
||||
};
|
||||
|
||||
template<typename AT, typename RT, typename... T>
|
||||
struct _ptr_base<RT(*)(T...), AT>
|
||||
template<typename AT, typename RT, typename... T> class _ptr_base<RT(*)(T...), AT>
|
||||
{
|
||||
AT m_addr;
|
||||
|
||||
|
|
@ -222,6 +286,18 @@ namespace vm
|
|||
|
||||
template<typename T, typename AT = u32> using cpptr = pptr<const T, AT>;
|
||||
template<typename T, typename AT = u32> using bcpptr = bpptr<const T, AT>;
|
||||
|
||||
// perform static_cast (for example, vm::ptr<void> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(static_cast<to_be_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_be_t<CT>> static_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
|
||||
// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(const_cast<to_be_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_be_t<CT>> const_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
}
|
||||
|
||||
namespace psv
|
||||
|
|
@ -246,268 +322,203 @@ namespace vm
|
|||
|
||||
template<typename T> using cpptr = pptr<const T>;
|
||||
template<typename T> using lcpptr = lpptr<const T>;
|
||||
|
||||
// perform static_cast (for example, vm::ptr<void> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(static_cast<to_le_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_le_t<CT>> static_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
|
||||
// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(const_cast<to_le_t<CT>*>(std::declval<T*>()))> inline _ptr_base<to_le_t<CT>> const_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ VM_CAST(other.addr()), vm::addr };
|
||||
}
|
||||
}
|
||||
|
||||
struct null_t
|
||||
{
|
||||
template<typename T, typename AT> operator _ptr_base<T, AT>() const
|
||||
{
|
||||
return{};
|
||||
return{ 0, vm::addr };
|
||||
}
|
||||
};
|
||||
|
||||
// vm::null is convertible to any vm::ptr type as null pointer in virtual memory
|
||||
static null_t null;
|
||||
|
||||
// perform static_cast (for example, vm::ptr<void> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(static_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> static_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
// Call wait_op() for specified vm pointer
|
||||
template<typename T, typename AT, typename F, typename... Args> inline auto wait_op(named_thread_t& thread, const _ptr_base<T, AT>& ptr, F pred, Args&&... args) -> decltype(static_cast<void>(pred(args...)))
|
||||
{
|
||||
return{ other.m_addr };
|
||||
return wait_op(thread, ptr.addr(), sizeof32(T), std::move(pred), std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
// perform const_cast (for example, vm::cptr<char> to vm::ptr<char>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(const_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> const_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
// Call notify_at() for specified vm pointer
|
||||
template<typename T, typename AT> inline void notify_at(const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return{ other.m_addr };
|
||||
}
|
||||
|
||||
// perform reinterpret_cast (for example, vm::ptr<char> to vm::ptr<u32>)
|
||||
template<typename CT, typename T, typename AT, typename = decltype(reinterpret_cast<CT*>(std::declval<T*>()))> inline _ptr_base<CT, AT> reinterpret_ptr_cast(const _ptr_base<T, AT>& other)
|
||||
{
|
||||
return{ other.m_addr };
|
||||
return notify_at(ptr.addr(), sizeof32(T));
|
||||
}
|
||||
}
|
||||
|
||||
// unary plus operator for vm::_ptr_base (always available)
|
||||
template<typename T, typename AT> inline vm::_ptr_base<T, AT> operator +(const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline vm::_ptr_base<T> operator +(const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// indirection operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, T&> operator *(const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, T&> operator *(const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return vm::get_ref<T>(VM_CAST(ptr.m_addr));
|
||||
}
|
||||
|
||||
// postfix increment operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator ++(vm::_ptr_base<T, AT>& ptr, int)
|
||||
{
|
||||
const AT result = ptr.m_addr;
|
||||
ptr.m_addr += sizeof32(T);
|
||||
return{ result };
|
||||
}
|
||||
|
||||
// prefix increment operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator ++(vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
ptr.m_addr += sizeof32(T);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// postfix decrement operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator --(vm::_ptr_base<T, AT>& ptr, int)
|
||||
{
|
||||
const AT result = ptr.m_addr;
|
||||
ptr.m_addr -= sizeof32(T);
|
||||
return{ result };
|
||||
}
|
||||
|
||||
// prefix decrement operator for vm::_ptr_base
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator --(vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
ptr.m_addr -= sizeof32(T);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// addition assignment operator for vm::_ptr_base (pointer += integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator +=(vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
{
|
||||
ptr.m_addr += count * sizeof32(T);
|
||||
return ptr;
|
||||
}
|
||||
|
||||
// subtraction assignment operator for vm::_ptr_base (pointer -= integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>&> operator -=(vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
{
|
||||
ptr.m_addr -= count * sizeof32(T);
|
||||
return ptr;
|
||||
return *ptr.get_ptr();
|
||||
}
|
||||
|
||||
// addition operator for vm::_ptr_base (pointer + integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator +(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, vm::_ptr_base<T>> operator +(const vm::_ptr_base<T, AT>& ptr, u32 count)
|
||||
{
|
||||
return{ ptr.m_addr + count * sizeof32(T) };
|
||||
return{ VM_CAST(ptr.addr()) + count * sizeof32(T), vm::addr };
|
||||
}
|
||||
|
||||
// addition operator for vm::_ptr_base (integer + pointer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator +(to_ne_t<AT> count, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, vm::_ptr_base<T>> operator +(u32 count, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return{ ptr.m_addr + count * sizeof32(T) };
|
||||
return{ VM_CAST(ptr.addr()) + count * sizeof32(T), vm::addr };
|
||||
}
|
||||
|
||||
// subtraction operator for vm::_ptr_base (pointer - integer)
|
||||
template<typename T, typename AT> inline vm::if_arithmetical_ptr_t<T, vm::_ptr_base<T, AT>> operator -(const vm::_ptr_base<T, AT>& ptr, to_ne_t<AT> count)
|
||||
template<typename T, typename AT> inline std::enable_if_t<std::is_object<T>::value, vm::_ptr_base<T>> operator -(const vm::_ptr_base<T, AT>& ptr, u32 count)
|
||||
{
|
||||
return{ ptr.m_addr - count * sizeof32(T) };
|
||||
return{ VM_CAST(ptr.addr()) - count * sizeof32(T), vm::addr };
|
||||
}
|
||||
|
||||
// pointer difference operator for vm::_ptr_base
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline std::enable_if_t<
|
||||
!std::is_void<T1>::value &&
|
||||
!std::is_void<T2>::value &&
|
||||
!std::is_function<T1>::value &&
|
||||
!std::is_function<T2>::value &&
|
||||
std::is_object<T1>::value &&
|
||||
std::is_object<T2>::value &&
|
||||
std::is_same<std::remove_cv_t<T1>, std::remove_cv_t<T2>>::value,
|
||||
s32> operator -(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return static_cast<s32>(left.m_addr - right.m_addr) / sizeof32(T1);
|
||||
return static_cast<s32>(VM_CAST(left.addr()) - VM_CAST(right.addr())) / sizeof32(T1);
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 == pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator ==(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator ==(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr == right.m_addr;
|
||||
return left.addr() == right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator ==(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator ==(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator ==(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator ==(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 != pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator !=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator !=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr != right.m_addr;
|
||||
return left.addr() != right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator !=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator !=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator !=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator !=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 < pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator <(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator <(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr < right.m_addr;
|
||||
return left.addr() < right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator <(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator <(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 <= pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator <=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator <=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr <= right.m_addr;
|
||||
return left.addr() <= right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <=(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
template<typename T, typename AT> inline bool operator <=(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator <=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator <=(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 > pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator >(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator >(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr > right.m_addr;
|
||||
return left.addr() > right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
template<typename T, typename AT> inline bool operator >(const vm::null_t&, const vm::_ptr_base<T, AT>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator >(const vm::_ptr_base<T, AT>& ptr, const vm::null_t&)
|
||||
{
|
||||
return ptr.m_addr != 0;
|
||||
return ptr.operator bool();
|
||||
}
|
||||
|
||||
// comparison operator for vm::_ptr_base (pointer1 >= pointer2)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> vm::if_comparable_t<T1, T2, bool> operator >=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
template<typename T1, typename AT1, typename T2, typename AT2> inline vm::if_comparable_t<T1, T2, bool> operator >=(const vm::_ptr_base<T1, AT1>& left, const vm::_ptr_base<T2, AT2>& right)
|
||||
{
|
||||
return left.m_addr >= right.m_addr;
|
||||
return left.addr() >= right.addr();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
template<typename T, typename AT> inline bool operator >=(const vm::null_t&, const vm::_ptr_base<T, AT>& ptr)
|
||||
{
|
||||
return ptr.m_addr == 0;
|
||||
return !ptr.operator bool();
|
||||
}
|
||||
|
||||
template<typename T, typename AT> bool operator >=(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
template<typename T, typename AT> inline bool operator >=(const vm::_ptr_base<T, AT>&, const vm::null_t&)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// external specialization for is_be_t<> (true if AT is be_t<>)
|
||||
// external specialization for to_se<> (change AT endianness to BE/LE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct is_be_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
|
||||
template<typename T, typename AT, bool Se> struct to_se<vm::_ptr_base<T, AT>, Se>
|
||||
{
|
||||
using type = vm::_ptr_base<T, typename to_se<AT, Se>::type>;
|
||||
};
|
||||
|
||||
// external specialization for is_le_t<> (true if AT is le_t<>)
|
||||
// external specialization for to_ne<> (change AT endianness to native)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct is_le_t<vm::_ptr_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
|
||||
template<typename T, typename AT> struct to_ne<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
};
|
||||
|
||||
// external specialization for to_ne_t<> (change AT endianness to native)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_ne<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ptr_base<T, to_ne_t<AT>>;
|
||||
};
|
||||
|
||||
// external specialization for to_be_t<> (change AT endianness to BE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_be<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ptr_base<T, to_be_t<AT>>;
|
||||
};
|
||||
|
||||
// external specialization for to_le_t<> (change AT endianness to LE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_le<vm::_ptr_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ptr_base<T, to_le_t<AT>>;
|
||||
using type = vm::_ptr_base<T, typename to_ne<AT>::type>;
|
||||
};
|
||||
|
||||
namespace fmt
|
||||
{
|
||||
// external specialization for fmt::format function
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct unveil<vm::_ptr_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct unveil<vm::_ptr_base<T, AT>, false>
|
||||
{
|
||||
using result_type = typename unveil<AT>::result_type;
|
||||
|
||||
force_inline static result_type get_value(const vm::_ptr_base<T, AT>& arg)
|
||||
static inline result_type get_value(const vm::_ptr_base<T, AT>& arg)
|
||||
{
|
||||
return unveil<AT>::get_value(arg.addr());
|
||||
}
|
||||
|
|
@ -516,38 +527,34 @@ namespace fmt
|
|||
|
||||
// external specializations for PPU GPR (SC_FUNC.h, CB_FUNC.h)
|
||||
|
||||
template<typename T, bool is_enum>
|
||||
struct cast_ppu_gpr;
|
||||
template<typename T, bool is_enum> struct cast_ppu_gpr;
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct cast_ppu_gpr<vm::_ptr_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct cast_ppu_gpr<vm::_ptr_base<T, AT>, false>
|
||||
{
|
||||
force_inline static u64 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
static inline u64 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
{
|
||||
return cast_ppu_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
|
||||
}
|
||||
|
||||
force_inline static vm::_ptr_base<T, AT> from_gpr(const u64 reg)
|
||||
static inline vm::_ptr_base<T, AT> from_gpr(const u64 reg)
|
||||
{
|
||||
return vm::_ptr_base<T, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
||||
return{ cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg), vm::addr };
|
||||
}
|
||||
};
|
||||
|
||||
// external specializations for ARMv7 GPR
|
||||
|
||||
template<typename T, bool is_enum>
|
||||
struct cast_armv7_gpr;
|
||||
template<typename T, bool is_enum> struct cast_armv7_gpr;
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct cast_armv7_gpr<vm::_ptr_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct cast_armv7_gpr<vm::_ptr_base<T, AT>, false>
|
||||
{
|
||||
force_inline static u32 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
static inline u32 to_gpr(const vm::_ptr_base<T, AT>& value)
|
||||
{
|
||||
return cast_armv7_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
|
||||
}
|
||||
|
||||
force_inline static vm::_ptr_base<T, AT> from_gpr(const u32 reg)
|
||||
static inline vm::_ptr_base<T, AT> from_gpr(const u32 reg)
|
||||
{
|
||||
return vm::_ptr_base<T, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
||||
return{ cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg), vm::addr };
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -2,78 +2,138 @@
|
|||
|
||||
namespace vm
|
||||
{
|
||||
template<typename T, typename AT> struct _ptr_base;
|
||||
// Tag which allows to construct vm objects from the address value
|
||||
static struct addr_tag_t {} constexpr addr{};
|
||||
|
||||
template<typename T, typename AT = u32>
|
||||
struct _ref_base
|
||||
template<typename T, typename AT> class _ptr_base;
|
||||
|
||||
template<typename T, typename AT = u32> class _ref_base
|
||||
{
|
||||
AT m_addr; // don't access directly
|
||||
AT m_addr;
|
||||
|
||||
static_assert(!std::is_pointer<T>::value, "vm::_ref_base<> error: invalid type (pointer)");
|
||||
static_assert(!std::is_reference<T>::value, "vm::_ref_base<> error: invalid type (reference)");
|
||||
static_assert(!std::is_function<T>::value, "vm::_ref_base<> error: invalid type (function)");
|
||||
static_assert(!std::is_void<T>::value, "vm::_ref_base<> error: invalid type (void)");
|
||||
|
||||
AT addr() const
|
||||
public:
|
||||
using type = T;
|
||||
using addr_type = std::remove_cv_t<AT>;
|
||||
|
||||
_ref_base() = default;
|
||||
|
||||
_ref_base(const _ref_base&) = default;
|
||||
|
||||
constexpr _ref_base(addr_type addr, const addr_tag_t&)
|
||||
: m_addr(addr)
|
||||
{
|
||||
}
|
||||
|
||||
constexpr addr_type addr() const
|
||||
{
|
||||
return m_addr;
|
||||
}
|
||||
|
||||
template<typename AT2 = AT> static std::enable_if_t<std::is_constructible<AT, AT2>::value, _ref_base> make(const AT2& addr)
|
||||
{
|
||||
return{ addr };
|
||||
}
|
||||
|
||||
T& get_ref() const
|
||||
{
|
||||
return vm::get_ref<T>(VM_CAST(m_addr));
|
||||
return *static_cast<T*>(vm::base(VM_CAST(m_addr)));
|
||||
}
|
||||
|
||||
T& priv_ref() const
|
||||
// convert to vm pointer
|
||||
vm::_ptr_base<T, u32> ptr() const
|
||||
{
|
||||
return vm::priv_ref<T>(VM_CAST(m_addr));
|
||||
return{ VM_CAST(m_addr), vm::addr };
|
||||
}
|
||||
|
||||
// TODO: conversion operator (seems hard to define it correctly)
|
||||
//template<typename CT, typename = std::enable_if_t<std::is_convertible<T, CT>::value || std::is_convertible<to_ne_t<T>, CT>::value>> operator CT() const
|
||||
//{
|
||||
// return get_ref();
|
||||
//}
|
||||
|
||||
operator to_ne_t<T>() const
|
||||
{
|
||||
return get_ref();
|
||||
}
|
||||
|
||||
explicit operator T&() const
|
||||
operator T&() const
|
||||
{
|
||||
return get_ref();
|
||||
}
|
||||
|
||||
// convert to vm pointer
|
||||
vm::_ptr_base<T, u32> operator &() const
|
||||
{
|
||||
return{ VM_CAST(m_addr) };
|
||||
}
|
||||
|
||||
// copy assignment operator:
|
||||
// returns T& by default, this may be wrong if called assignment operator has different return type
|
||||
T& operator =(const _ref_base& right)
|
||||
{
|
||||
static_assert(!std::is_const<T>::value, "vm::_ref_base<> error: operator= is not available for const reference");
|
||||
|
||||
return get_ref() = right.get_ref();
|
||||
}
|
||||
|
||||
template<typename CT, typename AT2> auto operator =(const _ref_base<CT, AT2>& right) const -> decltype(std::declval<T&>() = std::declval<CT>())
|
||||
{
|
||||
return get_ref() = right.get_ref();
|
||||
}
|
||||
|
||||
template<typename CT> auto operator =(const CT& right) const -> decltype(std::declval<T&>() = std::declval<CT>())
|
||||
T& operator =(const T& right) const
|
||||
{
|
||||
return get_ref() = right;
|
||||
}
|
||||
|
||||
decltype(auto) operator ++(int)
|
||||
{
|
||||
return get_ref()++;
|
||||
}
|
||||
|
||||
decltype(auto) operator ++()
|
||||
{
|
||||
return ++get_ref();
|
||||
}
|
||||
|
||||
decltype(auto) operator --(int)
|
||||
{
|
||||
return get_ref()--;
|
||||
}
|
||||
|
||||
decltype(auto) operator --()
|
||||
{
|
||||
return --get_ref();
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator +=(const T2& right)
|
||||
{
|
||||
return get_ref() += right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator -=(const T2& right)
|
||||
{
|
||||
return get_ref() -= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator *=(const T2& right)
|
||||
{
|
||||
return get_ref() *= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator /=(const T2& right)
|
||||
{
|
||||
return get_ref() /= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator %=(const T2& right)
|
||||
{
|
||||
return get_ref() %= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator &=(const T2& right)
|
||||
{
|
||||
return get_ref() &= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator |=(const T2& right)
|
||||
{
|
||||
return get_ref() |= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator ^=(const T2& right)
|
||||
{
|
||||
return get_ref() ^= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator <<=(const T2& right)
|
||||
{
|
||||
return get_ref() <<= right;
|
||||
}
|
||||
|
||||
template<typename T2> decltype(auto) operator >>=(const T2& right)
|
||||
{
|
||||
return get_ref() >>= right;
|
||||
}
|
||||
};
|
||||
|
||||
// Native endianness reference to LE data
|
||||
|
|
@ -113,138 +173,29 @@ namespace vm
|
|||
}
|
||||
}
|
||||
|
||||
// postfix increment operator for vm::_ref_base
|
||||
template<typename T, typename AT> inline auto operator ++(const vm::_ref_base<T, AT>& ref, int) -> decltype(std::declval<T&>()++)
|
||||
{
|
||||
return ref.get_ref()++;
|
||||
}
|
||||
// external specialization for to_se<> (change AT's endianness to BE/LE)
|
||||
|
||||
// prefix increment operator for vm::_ref_base
|
||||
template<typename T, typename AT> inline auto operator ++(const vm::_ref_base<T, AT>& ref) -> decltype(++std::declval<T&>())
|
||||
{
|
||||
return ++ref.get_ref();
|
||||
}
|
||||
|
||||
// postfix decrement operator for vm::_ref_base
|
||||
template<typename T, typename AT> inline auto operator --(const vm::_ref_base<T, AT>& ref, int) -> decltype(std::declval<T&>()--)
|
||||
{
|
||||
return ref.get_ref()--;
|
||||
}
|
||||
|
||||
// prefix decrement operator for vm::_ref_base
|
||||
template<typename T, typename AT> inline auto operator --(const vm::_ref_base<T, AT>& ref) -> decltype(--std::declval<T&>())
|
||||
{
|
||||
return --ref.get_ref();
|
||||
}
|
||||
|
||||
// addition assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator +=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() += std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() += right;
|
||||
}
|
||||
|
||||
// subtraction assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator -=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() -= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() -= right;
|
||||
}
|
||||
|
||||
// multiplication assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator *=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() *= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() *= right;
|
||||
}
|
||||
|
||||
// division assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator /=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() /= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() /= right;
|
||||
}
|
||||
|
||||
// modulo assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator %=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() %= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() %= right;
|
||||
}
|
||||
|
||||
// bitwise AND assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator &=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() &= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() &= right;
|
||||
}
|
||||
|
||||
// bitwise OR assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator |=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() |= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() |= right;
|
||||
}
|
||||
|
||||
// bitwise XOR assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator ^=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() ^= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() ^= right;
|
||||
}
|
||||
|
||||
// bitwise left shift assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator <<=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() <<= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() <<= right;
|
||||
}
|
||||
|
||||
// bitwise right shift assignment operator for vm::_ref_base
|
||||
template<typename T, typename AT, typename T2> inline auto operator >>=(const vm::_ref_base<T, AT>& ref, const T2& right) -> decltype(std::declval<T&>() >>= std::declval<T2>())
|
||||
{
|
||||
return ref.get_ref() >>= right;
|
||||
}
|
||||
|
||||
// external specialization for is_be_t<> (true if AT's endianness is BE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct is_be_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_be_t<AT>::value>
|
||||
template<typename T, typename AT, bool Se> struct to_se<vm::_ref_base<T, AT>, Se>
|
||||
{
|
||||
using type = vm::_ref_base<T, typename to_se<AT, Se>::type>;
|
||||
};
|
||||
|
||||
// external specialization for is_le_t<> (true if AT's endianness is LE)
|
||||
// external specialization for to_ne<> (change AT's endianness to native)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct is_le_t<vm::_ref_base<T, AT>> : public std::integral_constant<bool, is_le_t<AT>::value>
|
||||
template<typename T, typename AT> struct to_ne<vm::_ref_base<T, AT>>
|
||||
{
|
||||
};
|
||||
|
||||
// external specialization for to_ne_t<> (change AT's endianness to native)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_ne<vm::_ref_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ref_base<T, to_ne_t<AT>>;
|
||||
};
|
||||
|
||||
// external specialization for to_be_t<> (change AT's endianness to BE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_be<vm::_ref_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ref_base<T, to_be_t<AT>>;
|
||||
};
|
||||
|
||||
// external specialization for to_le_t<> (change AT's endianness to LE)
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct to_le<vm::_ref_base<T, AT>>
|
||||
{
|
||||
using type = vm::_ref_base<T, to_le_t<AT>>;
|
||||
using type = vm::_ref_base<T, typename to_ne<AT>::type>;
|
||||
};
|
||||
|
||||
namespace fmt
|
||||
{
|
||||
// external specialization for fmt::format function
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct unveil<vm::_ref_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct unveil<vm::_ref_base<T, AT>, false>
|
||||
{
|
||||
using result_type = typename unveil<AT>::result_type;
|
||||
|
||||
force_inline static result_type get_value(const vm::_ref_base<T, AT>& arg)
|
||||
static inline result_type get_value(const vm::_ref_base<T, AT>& arg)
|
||||
{
|
||||
return unveil<AT>::get_value(arg.addr());
|
||||
}
|
||||
|
|
@ -253,38 +204,34 @@ namespace fmt
|
|||
|
||||
// external specializations for PPU GPR (SC_FUNC.h, CB_FUNC.h)
|
||||
|
||||
template<typename T, bool is_enum>
|
||||
struct cast_ppu_gpr;
|
||||
template<typename T, bool is_enum> struct cast_ppu_gpr;
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct cast_ppu_gpr<vm::_ref_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct cast_ppu_gpr<vm::_ref_base<T, AT>, false>
|
||||
{
|
||||
force_inline static u64 to_gpr(const vm::_ref_base<T, AT>& value)
|
||||
static inline u64 to_gpr(const vm::_ref_base<T, AT>& value)
|
||||
{
|
||||
return cast_ppu_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
|
||||
}
|
||||
|
||||
force_inline static vm::_ref_base<T, AT> from_gpr(const u64 reg)
|
||||
static inline vm::_ref_base<T, AT> from_gpr(const u64 reg)
|
||||
{
|
||||
return vm::_ref_base<T, AT>::make(cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
||||
return{ cast_ppu_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg), vm::addr };
|
||||
}
|
||||
};
|
||||
|
||||
// external specializations for ARMv7 GPR
|
||||
|
||||
template<typename T, bool is_enum>
|
||||
struct cast_armv7_gpr;
|
||||
template<typename T, bool is_enum> struct cast_armv7_gpr;
|
||||
|
||||
template<typename T, typename AT>
|
||||
struct cast_armv7_gpr<vm::_ref_base<T, AT>, false>
|
||||
template<typename T, typename AT> struct cast_armv7_gpr<vm::_ref_base<T, AT>, false>
|
||||
{
|
||||
force_inline static u32 to_gpr(const vm::_ref_base<T, AT>& value)
|
||||
static inline u32 to_gpr(const vm::_ref_base<T, AT>& value)
|
||||
{
|
||||
return cast_armv7_gpr<AT, std::is_enum<AT>::value>::to_gpr(value.addr());
|
||||
}
|
||||
|
||||
force_inline static vm::_ref_base<T, AT> from_gpr(const u32 reg)
|
||||
static inline vm::_ref_base<T, AT> from_gpr(const u32 reg)
|
||||
{
|
||||
return vm::_ref_base<T, AT>::make(cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg));
|
||||
return{ cast_armv7_gpr<AT, std::is_enum<AT>::value>::from_gpr(reg), vm::addr };
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,34 +1,32 @@
|
|||
#pragma once
|
||||
|
||||
class CPUThread;
|
||||
|
||||
namespace vm
|
||||
{
|
||||
template<typename T> class page_alloc_t
|
||||
template<memory_location_t Location = vm::main> class page_alloc_t
|
||||
{
|
||||
u32 m_addr;
|
||||
|
||||
void dealloc()
|
||||
public:
|
||||
static inline u32 alloc(u32 size, u32 align)
|
||||
{
|
||||
if (m_addr)
|
||||
{
|
||||
vm::dealloc_verbose_nothrow(m_addr);
|
||||
}
|
||||
return vm::alloc(size, Location, std::max<u32>(align, 4096));
|
||||
}
|
||||
|
||||
static inline void dealloc(u32 addr, u32 size) noexcept
|
||||
{
|
||||
return vm::dealloc_verbose_nothrow(addr, Location);
|
||||
}
|
||||
|
||||
public:
|
||||
page_alloc_t()
|
||||
: m_addr(0)
|
||||
{
|
||||
}
|
||||
|
||||
page_alloc_t(vm::memory_location_t location, u32 count = 1)
|
||||
: m_addr(vm::alloc(sizeof32(T) * count, location, std::max<u32>(alignof32(T), 4096)))
|
||||
page_alloc_t(u32 size, u32 align)
|
||||
: m_addr(alloc(size, align))
|
||||
{
|
||||
}
|
||||
|
||||
page_alloc_t(const page_alloc_t&) = delete;
|
||||
|
||||
page_alloc_t(page_alloc_t&& other)
|
||||
: m_addr(other.m_addr)
|
||||
{
|
||||
|
|
@ -37,11 +35,12 @@ namespace vm
|
|||
|
||||
~page_alloc_t()
|
||||
{
|
||||
this->dealloc();
|
||||
if (m_addr)
|
||||
{
|
||||
dealloc(m_addr, 0);
|
||||
}
|
||||
}
|
||||
|
||||
page_alloc_t& operator =(const page_alloc_t&) = delete;
|
||||
|
||||
page_alloc_t& operator =(page_alloc_t&& other)
|
||||
{
|
||||
std::swap(m_addr, other.m_addr);
|
||||
|
|
@ -55,37 +54,37 @@ namespace vm
|
|||
}
|
||||
};
|
||||
|
||||
template<typename T> class stack_alloc_t
|
||||
class stack_alloc_t
|
||||
{
|
||||
u32 m_addr;
|
||||
u32 m_old_pos; // TODO: use the stack to save it?
|
||||
|
||||
CPUThread& m_thread;
|
||||
u32 m_size;
|
||||
|
||||
public:
|
||||
stack_alloc_t() = delete;
|
||||
|
||||
stack_alloc_t(CPUThread& thread, u32 count = 1)
|
||||
: m_addr(vm::stack_push(thread, sizeof32(T) * count, alignof32(T), m_old_pos))
|
||||
, m_thread(thread)
|
||||
static inline u32 alloc(u32 size, u32 align)
|
||||
{
|
||||
return vm::stack_push(size, align);
|
||||
}
|
||||
|
||||
~stack_alloc_t() noexcept(false) // allow exceptions
|
||||
static inline void dealloc(u32 addr, u32 size)
|
||||
{
|
||||
if (!std::uncaught_exception()) // don't call during stack unwinding (it's pointless anyway)
|
||||
if (!std::uncaught_exception()) // Don't call during stack unwinding
|
||||
{
|
||||
vm::stack_pop(m_thread, m_addr, m_old_pos);
|
||||
vm::stack_pop(addr, size);
|
||||
}
|
||||
}
|
||||
|
||||
stack_alloc_t(const stack_alloc_t&) = delete;
|
||||
stack_alloc_t(u32 size, u32 align)
|
||||
: m_addr(alloc(size, align))
|
||||
, m_size(size)
|
||||
{
|
||||
}
|
||||
|
||||
~stack_alloc_t() noexcept(false) // Allow exceptions
|
||||
{
|
||||
dealloc(m_addr, m_size);
|
||||
}
|
||||
|
||||
stack_alloc_t(stack_alloc_t&&) = delete;
|
||||
|
||||
stack_alloc_t& operator =(const stack_alloc_t&) = delete;
|
||||
|
||||
stack_alloc_t& operator =(stack_alloc_t&&) = delete;
|
||||
stack_alloc_t(const stack_alloc_t&) = delete; // Delete copy/move constructors and copy/move operators
|
||||
|
||||
u32 get_addr() const
|
||||
{
|
||||
|
|
@ -93,31 +92,167 @@ namespace vm
|
|||
}
|
||||
};
|
||||
|
||||
template<typename T, template<typename> class A> class _var_base final : public _ptr_base<T>, private A<T>
|
||||
{
|
||||
using _ptr_base<T>::m_addr;
|
||||
// _var_base prototype (T - data type, A - allocation traits)
|
||||
template<typename T, typename A> class _var_base;
|
||||
|
||||
using allocation = A<T>;
|
||||
// _var_base general specialization (single object of type T)
|
||||
template<typename T, typename A> class _var_base final : public _ptr_base<T, const u32>
|
||||
{
|
||||
using pointer = _ptr_base<T, const u32>;
|
||||
|
||||
public:
|
||||
template<typename... Args, typename = std::enable_if_t<std::is_constructible<A<T>, Args...>::value>> _var_base(Args&&... args)
|
||||
: allocation(std::forward<Args>(args)...)
|
||||
template<typename... Args, typename = std::enable_if_t<std::is_constructible<T, Args...>::value>> _var_base(Args&&... args)
|
||||
: pointer(A::alloc(sizeof32(T), alignof32(T)), vm::addr)
|
||||
{
|
||||
m_addr = allocation::get_addr();
|
||||
// Call the constructor with specified arguments
|
||||
new(pointer::get_ptr()) T(std::forward<Args>(args)...);
|
||||
}
|
||||
|
||||
_var_base(const _var_base&) = delete; // Delete copy/move constructors and copy/move operators
|
||||
|
||||
~_var_base() noexcept(noexcept(std::declval<T&>().~T()) && noexcept(A::dealloc(0, 0)))
|
||||
{
|
||||
// Call the destructor
|
||||
pointer::get_ptr()->~T();
|
||||
|
||||
// Deallocate memory
|
||||
A::dealloc(pointer::addr(), sizeof32(T));
|
||||
}
|
||||
|
||||
// Remove operator []
|
||||
std::add_lvalue_reference_t<T> operator [](u32 index) const = delete;
|
||||
};
|
||||
|
||||
template<typename T, template<typename> class A = vm::stack_alloc_t> using varl = _var_base<to_le_t<T>, A>;
|
||||
// _var_base unknown length array specialization
|
||||
template<typename T, typename A> class _var_base<T[], A> final : public _ptr_base<T, const u32>
|
||||
{
|
||||
using pointer = _ptr_base<T, const u32>;
|
||||
|
||||
template<typename T, template<typename> class A = vm::stack_alloc_t> using varb = _var_base<to_be_t<T>, A>;
|
||||
u32 m_count;
|
||||
|
||||
public:
|
||||
_var_base(u32 count)
|
||||
: pointer(A::alloc(sizeof32(T) * count, alignof32(T)), vm::addr)
|
||||
, m_count(count)
|
||||
{
|
||||
// Call the default constructor for each element
|
||||
new(pointer::get_ptr()) T[count]();
|
||||
}
|
||||
|
||||
template<typename T2> _var_base(u32 count, T2 it)
|
||||
: pointer(A::alloc(sizeof32(T) * count, alignof32(T)), vm::addr)
|
||||
, m_count(count)
|
||||
{
|
||||
// Initialize each element using iterator
|
||||
std::uninitialized_copy_n<T2>(it, count, const_cast<std::remove_cv_t<T>*>(pointer::get_ptr()));
|
||||
}
|
||||
|
||||
_var_base(const _var_base&) = delete; // Delete copy/move constructors and copy/move operators
|
||||
|
||||
~_var_base() noexcept(noexcept(std::declval<T&>().~T()) && noexcept(A::dealloc(0, 0)))
|
||||
{
|
||||
// Call the destructor for each element
|
||||
for (u32 i = m_count - 1; ~i; i--) pointer::operator [](i).~T();
|
||||
|
||||
// Deallocate memory
|
||||
A::dealloc(pointer::addr(), sizeof32(T) * m_count);
|
||||
}
|
||||
|
||||
u32 get_count() const
|
||||
{
|
||||
return m_count;
|
||||
}
|
||||
|
||||
std::add_lvalue_reference_t<T> at(u32 index) const
|
||||
{
|
||||
if (index >= m_count) throw EXCEPTION("Out of range (0x%x >= 0x%x)", index, m_count);
|
||||
|
||||
return pointer::operator [](index);
|
||||
}
|
||||
|
||||
// Remove operator ->
|
||||
T* operator ->() const = delete;
|
||||
};
|
||||
|
||||
// _var_base fixed length array specialization
|
||||
template<typename T, typename A, u32 N> class _var_base<T[N], A> final : public _ptr_base<T, const u32>
|
||||
{
|
||||
using pointer = _ptr_base<T, const u32>;
|
||||
|
||||
public:
|
||||
_var_base()
|
||||
: pointer(A::alloc(sizeof32(T) * N, alignof32(T)), vm::addr)
|
||||
{
|
||||
// Call the default constructor for each element
|
||||
new(pointer::get_ptr()) T[N]();
|
||||
}
|
||||
|
||||
template<typename T2> _var_base(const T2(&array)[N])
|
||||
: pointer(A::alloc(sizeof32(T) * N, alignof32(T)), vm::addr)
|
||||
{
|
||||
// Copy the array
|
||||
std::uninitialized_copy_n(array + 0, N, const_cast<std::remove_cv_t<T>*>(pointer::get_ptr()));
|
||||
}
|
||||
|
||||
_var_base(const _var_base&) = delete; // Delete copy/move constructors and copy/move operators
|
||||
|
||||
~_var_base() noexcept(noexcept(std::declval<T&>().~T()) && noexcept(A::dealloc(0, 0)))
|
||||
{
|
||||
// Call the destructor for each element
|
||||
for (u32 i = N - 1; ~i; i--) pointer::operator [](i).~T();
|
||||
|
||||
// Deallocate memory
|
||||
A::dealloc(pointer::addr(), sizeof32(T) * N);
|
||||
}
|
||||
|
||||
constexpr u32 get_count() const
|
||||
{
|
||||
return N;
|
||||
}
|
||||
|
||||
std::add_lvalue_reference_t<T> at(u32 index) const
|
||||
{
|
||||
if (index >= N) throw EXCEPTION("Out of range (0x%x > 0x%x)", index, N);
|
||||
|
||||
return pointer::operator [](index);
|
||||
}
|
||||
|
||||
// Remove operator ->
|
||||
T* operator ->() const = delete;
|
||||
};
|
||||
|
||||
// LE variable
|
||||
template<typename T, typename A = vm::stack_alloc_t> using varl = _var_base<to_le_t<T>, A>;
|
||||
|
||||
// BE variable
|
||||
template<typename T, typename A = vm::stack_alloc_t> using varb = _var_base<to_be_t<T>, A>;
|
||||
|
||||
namespace ps3
|
||||
{
|
||||
template<typename T, template<typename> class A = vm::stack_alloc_t> using var = varb<T, A>;
|
||||
// BE variable
|
||||
template<typename T, typename A = vm::stack_alloc_t> using var = varb<T, A>;
|
||||
|
||||
// BE variable initialized from value
|
||||
template<typename T> inline varb<T, vm::stack_alloc_t> make_var(const T& value)
|
||||
{
|
||||
return{ value };
|
||||
}
|
||||
}
|
||||
|
||||
namespace psv
|
||||
{
|
||||
template<typename T, template<typename> class A = vm::stack_alloc_t> using var = varl<T, A>;
|
||||
// LE variable
|
||||
template<typename T, typename A = vm::stack_alloc_t> using var = varl<T, A>;
|
||||
|
||||
// LE variable initialized from value
|
||||
template<typename T> inline varl<T, vm::stack_alloc_t> make_var(const T& value)
|
||||
{
|
||||
return{ value };
|
||||
}
|
||||
}
|
||||
|
||||
static _var_base<char[], vm::stack_alloc_t> make_str(const std::string& str)
|
||||
{
|
||||
return{ size32(str) + 1, str.data() };
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue