diff --git a/rpcs3/Emu/Memory/Memory.cpp b/rpcs3/Emu/Memory/Memory.cpp index 1dde6e3ba0..42045a57bd 100644 --- a/rpcs3/Emu/Memory/Memory.cpp +++ b/rpcs3/Emu/Memory/Memory.cpp @@ -6,14 +6,14 @@ #ifndef _WIN32 #include -#else -#include -#endif /* OS X uses MAP_ANON instead of MAP_ANONYMOUS */ #ifndef MAP_ANONYMOUS #define MAP_ANONYMOUS MAP_ANON #endif +#else +#include +#endif MemoryBase Memory; @@ -108,14 +108,11 @@ void MemoryBase::Init(MemoryType type) memset(RawSPUMem, 0, sizeof(RawSPUMem)); #ifdef _WIN32 - m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE, PAGE_NOACCESS); if (!m_base_addr) #else - m_base_addr = ::mmap(nullptr, 0x100000000, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); - if (m_base_addr == (void*)-1) + if ((s64)m_base_addr == (s64)-1) #endif { - m_base_addr = nullptr; LOG_ERROR(MEMORY, "Initializing memory failed"); assert(0); return; @@ -139,7 +136,6 @@ void MemoryBase::Init(MemoryType type) case Memory_PSV: MemoryBlocks.push_back(PSV.RAM.SetRange(0x81000000, 0x10000000)); MemoryBlocks.push_back(UserMemory = PSV.Userspace.SetRange(0x91000000, 0x10000000)); - PSV.Init(GetBaseAddr()); break; case Memory_PSP: @@ -148,7 +144,6 @@ void MemoryBase::Init(MemoryType type) MemoryBlocks.push_back(PSP.RAM.SetRange(0x08000000, 0x02000000)); MemoryBlocks.push_back(PSP.Kernel.SetRange(0x88000000, 0x00800000)); MemoryBlocks.push_back(UserMemory = PSP.Userspace.SetRange(0x08800000, 0x01800000)); - PSP.Init(GetBaseAddr()); break; } @@ -173,17 +168,17 @@ void MemoryBase::Close() MemoryBlocks.clear(); -#ifdef _WIN32 - if (!VirtualFree(m_base_addr, 0, MEM_RELEASE)) - { - LOG_ERROR(MEMORY, "VirtualFree(0x%llx) failed", (u64)m_base_addr); - } -#else - if (::munmap(m_base_addr, 0x100000000)) - { - LOG_ERROR(MEMORY, "::munmap(0x%llx) failed", (u64)m_base_addr); - } -#endif +//#ifdef _WIN32 +// if (!VirtualFree(m_base_addr, 0, MEM_RELEASE)) +// { +// LOG_ERROR(MEMORY, "VirtualFree(0x%llx) failed", (u64)m_base_addr); +// } +//#else +// if (::munmap(m_base_addr, 0x100000000)) +// { +// LOG_ERROR(MEMORY, "::munmap(0x%llx) failed", (u64)m_base_addr); +// } +//#endif } void MemoryBase::WriteMMIO32(u32 addr, const u32 data) diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h index 8d7bdc6762..51f4f2ae10 100644 --- a/rpcs3/Emu/Memory/Memory.h +++ b/rpcs3/Emu/Memory/Memory.h @@ -8,6 +8,8 @@ using std::nullptr_t; #define safe_delete(x) do {delete (x);(x)=nullptr;} while(0) #define safe_free(x) do {free(x);(x)=nullptr;} while(0) +extern void* const m_base_addr; + enum MemoryType { Memory_PS3, @@ -25,7 +27,6 @@ enum : u64 class MemoryBase { - void* m_base_addr; std::vector MemoryBlocks; u32 m_pages[0x100000000 / 4096]; // information about every page std::recursive_mutex m_mutex; @@ -44,12 +45,6 @@ public: struct Wrapper32LE { - private: - void* m_base_addr; - - public: - Wrapper32LE() : m_base_addr(nullptr) {} - void Write8(const u32 addr, const u8 data) { *(u8*)((u8*)m_base_addr + addr) = data; } void Write16(const u32 addr, const u16 data) { *(u16*)((u8*)m_base_addr + addr) = data; } void Write32(const u32 addr, const u32 data) { *(u32*)((u8*)m_base_addr + addr) = data; } @@ -61,8 +56,6 @@ public: u32 Read32(const u32 addr) { return *(u32*)((u8*)m_base_addr + addr); } u64 Read64(const u32 addr) { return *(u64*)((u8*)m_base_addr + addr); } u128 Read128(const u32 addr) { return *(u128*)((u8*)m_base_addr + addr); } - - void Init(void* real_addr) { m_base_addr = real_addr; } }; struct : Wrapper32LE @@ -92,7 +85,7 @@ public: Close(); } - void* GetBaseAddr() const + static void* const GetBaseAddr() { return m_base_addr; } diff --git a/rpcs3/Emu/Memory/vm.cpp b/rpcs3/Emu/Memory/vm.cpp index 2f91be639a..044135c842 100644 --- a/rpcs3/Emu/Memory/vm.cpp +++ b/rpcs3/Emu/Memory/vm.cpp @@ -1,4 +1,20 @@ #include "stdafx.h" +#include "Memory.h" + +#ifdef _WIN32 +#include + +static void* const m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE, PAGE_NOACCESS); +#else +#include + +/* OS X uses MAP_ANON instead of MAP_ANONYMOUS */ +#ifndef MAP_ANONYMOUS +#define MAP_ANONYMOUS MAP_ANON +#endif + +static void* const m_base_addr = ::mmap(nullptr, 0x100000000, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0); +#endif namespace vm { @@ -28,13 +44,4 @@ namespace vm void unalloc(u32 addr) { } - - u32 read32(u32 addr) - { - return 0; - } - - void write32(u32 addr, u32 value) - { - } } \ No newline at end of file diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h index 3898847569..0d6d77dee9 100644 --- a/rpcs3/Emu/Memory/vm.h +++ b/rpcs3/Emu/Memory/vm.h @@ -8,19 +8,126 @@ namespace vm void unalloc(u32 addr); template - T* get_ptr(u32 addr) + T* const get_ptr(u32 addr) { - return (T*)&Memory[addr]; + return (T*)((u8*)m_base_addr + addr); } template T& get_ref(u32 addr) { - return (T&)Memory[addr]; + return *(T*)((u8*)m_base_addr + addr); } - u32 read32(u32 addr); - void write32(u32 addr, u32 value); + static u8 read8(u32 addr) + { + return *((u8*)m_base_addr + addr); + } + + static void write8(u32 addr, u8 value) + { + *((u8*)m_base_addr + addr) = value; + } + + namespace ps3 + { + static u16 read16(u32 addr) + { + return re16(*(u16*)((u8*)m_base_addr + addr)); + } + + static void write16(u32 addr, u16 value) + { + *(u16*)((u8*)m_base_addr + addr) = re16(value); + } + + static u32 read32(u32 addr) + { + if (addr < RAW_SPU_BASE_ADDR || (addr % RAW_SPU_OFFSET) < RAW_SPU_PROB_OFFSET) + { + return re32(*(u32*)((u8*)m_base_addr + addr)); + } + else + { + return Memory.ReadMMIO32((u32)addr); + } + } + + static void write32(u32 addr, u32 value) + { + if (addr < RAW_SPU_BASE_ADDR || (addr % RAW_SPU_OFFSET) < RAW_SPU_PROB_OFFSET) + { + *(u32*)((u8*)m_base_addr + addr) = re32(value); + } + else + { + Memory.WriteMMIO32((u32)addr, value); + } + } + + static u64 read64(u32 addr) + { + return re64(*(u64*)((u8*)m_base_addr + addr)); + } + + static void write64(u32 addr, u64 value) + { + *(u64*)((u8*)m_base_addr + addr) = re64(value); + } + + static u128 read128(u32 addr) + { + return re128(*(u128*)((u8*)m_base_addr + addr)); + } + + static void write128(u32 addr, u128 value) + { + *(u128*)((u8*)m_base_addr + addr) = re128(value); + } + } + + namespace psv + { + static u16 read16(u32 addr) + { + return *(u16*)((u8*)m_base_addr + addr); + } + + static void write16(u32 addr, u16 value) + { + *(u16*)((u8*)m_base_addr + addr) = value; + } + + static u32 read32(u32 addr) + { + return *(u32*)((u8*)m_base_addr + addr); + } + + static void write32(u32 addr, u32 value) + { + *(u32*)((u8*)m_base_addr + addr) = value; + } + + static u64 read64(u32 addr) + { + return *(u64*)((u8*)m_base_addr + addr); + } + + static void write64(u32 addr, u64 value) + { + *(u64*)((u8*)m_base_addr + addr) = value; + } + + static u128 read128(u32 addr) + { + return *(u128*)((u8*)m_base_addr + addr); + } + + static void write128(u32 addr, u128 value) + { + *(u128*)((u8*)m_base_addr + addr) = value; + } + } } #include "vm_ref.h" diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h index 3ed4231827..0b8be18393 100644 --- a/rpcs3/Emu/Memory/vm_ptr.h +++ b/rpcs3/Emu/Memory/vm_ptr.h @@ -98,12 +98,12 @@ namespace vm AT m_addr; public: - __forceinline T* operator -> () + __forceinline T* const operator -> () { return vm::get_ptr(m_addr); } - __forceinline const T* operator -> () const + __forceinline const T* const operator -> () const { return vm::get_ptr(m_addr); } @@ -198,7 +198,7 @@ namespace vm return m_addr != 0; } - T* get_ptr() const + T* const get_ptr() const { return vm::get_ptr(m_addr); } @@ -220,7 +220,7 @@ namespace vm return m_addr; } - void* get_ptr() const + void* const get_ptr() const { return vm::get_ptr(m_addr); } @@ -266,7 +266,7 @@ namespace vm return m_addr; } - type get_ptr() const + type const get_ptr() const { return *((type*)vm::get_ptr(m_addr)); } @@ -340,7 +340,7 @@ namespace vm return m_addr; } - type get_ptr() const + type const get_ptr() const { return *((type*)vm::get_ptr(m_addr)); } diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp index 14eeeea745..b9ce671310 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp @@ -17,13 +17,13 @@ u32 libsre; u32 libsre_rtoc; #endif -s32 syncMutexInitialize(mem_ptr_t mutex) +s32 syncMutexInitialize(vm::ptr mutex) { if (!mutex) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex.GetAddr() % 4) + if (mutex.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -34,22 +34,22 @@ s32 syncMutexInitialize(mem_ptr_t mutex) return CELL_OK; } -s32 cellSyncMutexInitialize(mem_ptr_t mutex) +s32 cellSyncMutexInitialize(vm::ptr mutex) { - cellSync->Log("cellSyncMutexInitialize(mutex_addr=0x%x)", mutex.GetAddr()); + cellSync->Log("cellSyncMutexInitialize(mutex_addr=0x%x)", mutex.addr()); return syncMutexInitialize(mutex); } -s32 cellSyncMutexLock(mem_ptr_t mutex) +s32 cellSyncMutexLock(vm::ptr mutex) { - cellSync->Log("cellSyncMutexLock(mutex_addr=0x%x)", mutex.GetAddr()); + cellSync->Log("cellSyncMutexLock(mutex_addr=0x%x)", mutex.addr()); if (!mutex) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex.GetAddr() % 4) + if (mutex.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -73,7 +73,7 @@ s32 cellSyncMutexLock(mem_ptr_t mutex) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncMutexLock(mutex_addr=0x%x) aborted", mutex.GetAddr()); + cellSync->Warning("cellSyncMutexLock(mutex_addr=0x%x) aborted", mutex.addr()); break; } } @@ -83,15 +83,15 @@ s32 cellSyncMutexLock(mem_ptr_t mutex) return CELL_OK; } -s32 cellSyncMutexTryLock(mem_ptr_t mutex) +s32 cellSyncMutexTryLock(vm::ptr mutex) { - cellSync->Log("cellSyncMutexTryLock(mutex_addr=0x%x)", mutex.GetAddr()); + cellSync->Log("cellSyncMutexTryLock(mutex_addr=0x%x)", mutex.addr()); if (!mutex) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex.GetAddr() % 4) + if (mutex.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -117,15 +117,15 @@ s32 cellSyncMutexTryLock(mem_ptr_t mutex) return CELL_OK; } -s32 cellSyncMutexUnlock(mem_ptr_t mutex) +s32 cellSyncMutexUnlock(vm::ptr mutex) { - cellSync->Log("cellSyncMutexUnlock(mutex_addr=0x%x)", mutex.GetAddr()); + cellSync->Log("cellSyncMutexUnlock(mutex_addr=0x%x)", mutex.addr()); if (!mutex) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (mutex.GetAddr() % 4) + if (mutex.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -145,13 +145,13 @@ s32 cellSyncMutexUnlock(mem_ptr_t mutex) return CELL_OK; } -s32 syncBarrierInitialize(mem_ptr_t barrier, u16 total_count) +s32 syncBarrierInitialize(vm::ptr barrier, u16 total_count) { if (!barrier) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (barrier.GetAddr() % 4) + if (barrier.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -167,22 +167,22 @@ s32 syncBarrierInitialize(mem_ptr_t barrier, u16 total_count) return CELL_OK; } -s32 cellSyncBarrierInitialize(mem_ptr_t barrier, u16 total_count) +s32 cellSyncBarrierInitialize(vm::ptr barrier, u16 total_count) { - cellSync->Log("cellSyncBarrierInitialize(barrier_addr=0x%x, total_count=%d)", barrier.GetAddr(), total_count); + cellSync->Log("cellSyncBarrierInitialize(barrier_addr=0x%x, total_count=%d)", barrier.addr(), total_count); return syncBarrierInitialize(barrier, total_count); } -s32 cellSyncBarrierNotify(mem_ptr_t barrier) +s32 cellSyncBarrierNotify(vm::ptr barrier) { - cellSync->Log("cellSyncBarrierNotify(barrier_addr=0x%x)", barrier.GetAddr()); + cellSync->Log("cellSyncBarrierNotify(barrier_addr=0x%x)", barrier.addr()); if (!barrier) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (barrier.GetAddr() % 4) + if (barrier.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -202,7 +202,7 @@ s32 cellSyncBarrierNotify(mem_ptr_t barrier) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncBarrierNotify(barrier_addr=0x%x) aborted", barrier.GetAddr()); + cellSync->Warning("cellSyncBarrierNotify(barrier_addr=0x%x) aborted", barrier.addr()); return CELL_OK; } continue; @@ -220,15 +220,15 @@ s32 cellSyncBarrierNotify(mem_ptr_t barrier) return CELL_OK; } -s32 cellSyncBarrierTryNotify(mem_ptr_t barrier) +s32 cellSyncBarrierTryNotify(vm::ptr barrier) { - cellSync->Log("cellSyncBarrierTryNotify(barrier_addr=0x%x)", barrier.GetAddr()); + cellSync->Log("cellSyncBarrierTryNotify(barrier_addr=0x%x)", barrier.addr()); if (!barrier) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (barrier.GetAddr() % 4) + if (barrier.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -261,15 +261,15 @@ s32 cellSyncBarrierTryNotify(mem_ptr_t barrier) return CELL_OK; } -s32 cellSyncBarrierWait(mem_ptr_t barrier) +s32 cellSyncBarrierWait(vm::ptr barrier) { - cellSync->Log("cellSyncBarrierWait(barrier_addr=0x%x)", barrier.GetAddr()); + cellSync->Log("cellSyncBarrierWait(barrier_addr=0x%x)", barrier.addr()); if (!barrier) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (barrier.GetAddr() % 4) + if (barrier.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -289,7 +289,7 @@ s32 cellSyncBarrierWait(mem_ptr_t barrier) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncBarrierWait(barrier_addr=0x%x) aborted", barrier.GetAddr()); + cellSync->Warning("cellSyncBarrierWait(barrier_addr=0x%x) aborted", barrier.addr()); return CELL_OK; } continue; @@ -307,15 +307,15 @@ s32 cellSyncBarrierWait(mem_ptr_t barrier) return CELL_OK; } -s32 cellSyncBarrierTryWait(mem_ptr_t barrier) +s32 cellSyncBarrierTryWait(vm::ptr barrier) { - cellSync->Log("cellSyncBarrierTryWait(barrier_addr=0x%x)", barrier.GetAddr()); + cellSync->Log("cellSyncBarrierTryWait(barrier_addr=0x%x)", barrier.addr()); if (!barrier) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (barrier.GetAddr() % 4) + if (barrier.addr() % 4) { return CELL_SYNC_ERROR_ALIGN; } @@ -346,13 +346,13 @@ s32 cellSyncBarrierTryWait(mem_ptr_t barrier) return CELL_OK; } -s32 syncRwmInitialize(mem_ptr_t rwm, u32 buffer_addr, u32 buffer_size) +s32 syncRwmInitialize(vm::ptr rwm, u32 buffer_addr, u32 buffer_size) { if (!rwm || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (rwm.GetAddr() % 16 || buffer_addr % 128) + if (rwm.addr() % 16 || buffer_addr % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -369,22 +369,22 @@ s32 syncRwmInitialize(mem_ptr_t rwm, u32 buffer_addr, u32 buffer_si return CELL_OK; } -s32 cellSyncRwmInitialize(mem_ptr_t rwm, u32 buffer_addr, u32 buffer_size) +s32 cellSyncRwmInitialize(vm::ptr rwm, u32 buffer_addr, u32 buffer_size) { - cellSync->Log("cellSyncRwmInitialize(rwm_addr=0x%x, buffer_addr=0x%x, buffer_size=0x%x)", rwm.GetAddr(), buffer_addr, buffer_size); + cellSync->Log("cellSyncRwmInitialize(rwm_addr=0x%x, buffer_addr=0x%x, buffer_size=0x%x)", rwm.addr(), buffer_addr, buffer_size); return syncRwmInitialize(rwm, buffer_addr, buffer_size); } -s32 cellSyncRwmRead(mem_ptr_t rwm, u32 buffer_addr) +s32 cellSyncRwmRead(vm::ptr rwm, u32 buffer_addr) { - cellSync->Log("cellSyncRwmRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr); + cellSync->Log("cellSyncRwmRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); if (!rwm || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (rwm.GetAddr() % 16) + if (rwm.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -401,7 +401,7 @@ s32 cellSyncRwmRead(mem_ptr_t rwm, u32 buffer_addr) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncRwmRead(rwm_addr=0x%x) aborted", rwm.GetAddr()); + cellSync->Warning("cellSyncRwmRead(rwm_addr=0x%x) aborted", rwm.addr()); return CELL_OK; } continue; @@ -423,7 +423,7 @@ s32 cellSyncRwmRead(mem_ptr_t rwm, u32 buffer_addr) if (!new_rwm.m_readers.ToBE()) { - cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.GetAddr(), (u16)new_rwm.m_writers); + cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.addr(), (u16)new_rwm.m_writers); return CELL_SYNC_ERROR_ABORT; } @@ -433,15 +433,15 @@ s32 cellSyncRwmRead(mem_ptr_t rwm, u32 buffer_addr) return CELL_OK; } -s32 cellSyncRwmTryRead(mem_ptr_t rwm, u32 buffer_addr) +s32 cellSyncRwmTryRead(vm::ptr rwm, u32 buffer_addr) { - cellSync->Log("cellSyncRwmTryRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr); + cellSync->Log("cellSyncRwmTryRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); if (!rwm || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (rwm.GetAddr() % 16) + if (rwm.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -471,7 +471,7 @@ s32 cellSyncRwmTryRead(mem_ptr_t rwm, u32 buffer_addr) if (!new_rwm.m_readers.ToBE()) { - cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.GetAddr(), (u16)new_rwm.m_writers); + cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.addr(), (u16)new_rwm.m_writers); return CELL_SYNC_ERROR_ABORT; } @@ -481,15 +481,15 @@ s32 cellSyncRwmTryRead(mem_ptr_t rwm, u32 buffer_addr) return CELL_OK; } -s32 cellSyncRwmWrite(mem_ptr_t rwm, u32 buffer_addr) +s32 cellSyncRwmWrite(vm::ptr rwm, u32 buffer_addr) { - cellSync->Log("cellSyncRwmWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr); + cellSync->Log("cellSyncRwmWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); if (!rwm || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (rwm.GetAddr() % 16) + if (rwm.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -506,7 +506,7 @@ s32 cellSyncRwmWrite(mem_ptr_t rwm, u32 buffer_addr) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (I)", rwm.GetAddr()); + cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (I)", rwm.addr()); return CELL_OK; } continue; @@ -522,7 +522,7 @@ s32 cellSyncRwmWrite(mem_ptr_t rwm, u32 buffer_addr) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (II)", rwm.GetAddr()); + cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (II)", rwm.addr()); return CELL_OK; } } @@ -536,15 +536,15 @@ s32 cellSyncRwmWrite(mem_ptr_t rwm, u32 buffer_addr) return CELL_OK; } -s32 cellSyncRwmTryWrite(mem_ptr_t rwm, u32 buffer_addr) +s32 cellSyncRwmTryWrite(vm::ptr rwm, u32 buffer_addr) { - cellSync->Log("cellSyncRwmTryWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr); + cellSync->Log("cellSyncRwmTryWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); if (!rwm || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (rwm.GetAddr() % 16) + if (rwm.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -561,7 +561,7 @@ s32 cellSyncRwmTryWrite(mem_ptr_t rwm, u32 buffer_addr) return CELL_OK; } -s32 syncQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 size, u32 depth) +s32 syncQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth) { if (!queue) { @@ -571,7 +571,7 @@ s32 syncQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 siz { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32 || buffer_addr % 16) + if (queue.addr() % 32 || buffer_addr % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -589,22 +589,22 @@ s32 syncQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 siz return CELL_OK; } -s32 cellSyncQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 size, u32 depth) +s32 cellSyncQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth) { - cellSync->Log("cellSyncQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x)", queue.GetAddr(), buffer_addr, size, depth); + cellSync->Log("cellSyncQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x)", queue.addr(), buffer_addr, size, depth); return syncQueueInitialize(queue, buffer_addr, size, depth); } -s32 cellSyncQueuePush(mem_ptr_t queue, u32 buffer_addr) +s32 cellSyncQueuePush(vm::ptr queue, u32 buffer_addr) { - cellSync->Log("cellSyncQueuePush(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr); + cellSync->Log("cellSyncQueuePush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -629,7 +629,7 @@ s32 cellSyncQueuePush(mem_ptr_t queue, u32 buffer_addr) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncQueuePush(queue_addr=0x%x) aborted", queue.GetAddr()); + cellSync->Warning("cellSyncQueuePush(queue_addr=0x%x) aborted", queue.addr()); return CELL_OK; } continue; @@ -660,15 +660,15 @@ s32 cellSyncQueuePush(mem_ptr_t queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueTryPush(mem_ptr_t queue, u32 buffer_addr) +s32 cellSyncQueueTryPush(vm::ptr queue, u32 buffer_addr) { - cellSync->Log("cellSyncQueueTryPush(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr); + cellSync->Log("cellSyncQueueTryPush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -711,15 +711,15 @@ s32 cellSyncQueueTryPush(mem_ptr_t queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueuePop(mem_ptr_t queue, u32 buffer_addr) +s32 cellSyncQueuePop(vm::ptr queue, u32 buffer_addr) { - cellSync->Log("cellSyncQueuePop(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr); + cellSync->Log("cellSyncQueuePop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -744,7 +744,7 @@ s32 cellSyncQueuePop(mem_ptr_t queue, u32 buffer_addr) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncQueuePop(queue_addr=0x%x) aborted", queue.GetAddr()); + cellSync->Warning("cellSyncQueuePop(queue_addr=0x%x) aborted", queue.addr()); return CELL_OK; } continue; @@ -775,15 +775,15 @@ s32 cellSyncQueuePop(mem_ptr_t queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueTryPop(mem_ptr_t queue, u32 buffer_addr) +s32 cellSyncQueueTryPop(vm::ptr queue, u32 buffer_addr) { - cellSync->Log("cellSyncQueueTryPop(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr); + cellSync->Log("cellSyncQueueTryPop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -826,15 +826,15 @@ s32 cellSyncQueueTryPop(mem_ptr_t queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueuePeek(mem_ptr_t queue, u32 buffer_addr) +s32 cellSyncQueuePeek(vm::ptr queue, u32 buffer_addr) { - cellSync->Log("cellSyncQueuePeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr); + cellSync->Log("cellSyncQueuePeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -857,7 +857,7 @@ s32 cellSyncQueuePeek(mem_ptr_t queue, u32 buffer_addr) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncQueuePeek(queue_addr=0x%x) aborted", queue.GetAddr()); + cellSync->Warning("cellSyncQueuePeek(queue_addr=0x%x) aborted", queue.addr()); return CELL_OK; } continue; @@ -882,15 +882,15 @@ s32 cellSyncQueuePeek(mem_ptr_t queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueTryPeek(mem_ptr_t queue, u32 buffer_addr) +s32 cellSyncQueueTryPeek(vm::ptr queue, u32 buffer_addr) { - cellSync->Log("cellSyncQueueTryPeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr); + cellSync->Log("cellSyncQueueTryPeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -932,15 +932,15 @@ s32 cellSyncQueueTryPeek(mem_ptr_t queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueSize(mem_ptr_t queue) +s32 cellSyncQueueSize(vm::ptr queue) { - cellSync->Log("cellSyncQueueSize(queue_addr=0x%x)", queue.GetAddr()); + cellSync->Log("cellSyncQueueSize(queue_addr=0x%x)", queue.addr()); if (!queue) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -952,15 +952,15 @@ s32 cellSyncQueueSize(mem_ptr_t queue) return count; } -s32 cellSyncQueueClear(mem_ptr_t queue) +s32 cellSyncQueueClear(vm::ptr queue) { - cellSync->Log("cellSyncQueueClear(queue_addr=0x%x)", queue.GetAddr()); + cellSync->Log("cellSyncQueueClear(queue_addr=0x%x)", queue.addr()); if (!queue) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 32) + if (queue.addr() % 32) { return CELL_SYNC_ERROR_ALIGN; } @@ -982,7 +982,7 @@ s32 cellSyncQueueClear(mem_ptr_t queue) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (I)", queue.GetAddr()); + cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (I)", queue.addr()); return CELL_OK; } continue; @@ -1004,7 +1004,7 @@ s32 cellSyncQueueClear(mem_ptr_t queue) std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (II)", queue.GetAddr()); + cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (II)", queue.addr()); return CELL_OK; } continue; @@ -1020,16 +1020,16 @@ s32 cellSyncQueueClear(mem_ptr_t queue) // LFQueue functions -void syncLFQueueDump(mem_ptr_t queue) +void syncLFQueueDump(vm::ptr queue) { - cellSync->Notice("CellSyncLFQueue dump: addr = 0x%x", queue.GetAddr()); + cellSync->Notice("CellSyncLFQueue dump: addr = 0x%x", queue.addr()); for (u32 i = 0; i < sizeof(CellSyncLFQueue) / 16; i++) { - cellSync->Notice("*** 0x%.16llx 0x%.16llx", Memory.Read64(queue.GetAddr() + i * 16), Memory.Read64(queue.GetAddr() + i * 16 + 8)); + cellSync->Notice("*** 0x%.16llx 0x%.16llx", Memory.Read64(queue.addr() + i * 16), Memory.Read64(queue.addr() + i * 16 + 8)); } } -void syncLFQueueInit(mem_ptr_t queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) +void syncLFQueueInit(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) { queue->m_h1 = 0; queue->m_h2 = 0; @@ -1076,10 +1076,10 @@ void syncLFQueueInit(mem_ptr_t queue, u32 buffer_addr, u32 size } } -s32 syncLFQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) +s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) { #ifdef PRX_DEBUG_XXX - return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.GetAddr(), buffer_addr, size, depth, direction, eaSignal_addr); + return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.addr(), buffer_addr, size, depth, direction, eaSignal_addr); #else if (!queue) @@ -1101,7 +1101,7 @@ s32 syncLFQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 { return CELL_SYNC_ERROR_INVAL; } - if (queue.GetAddr() % 128 || buffer_addr % 16) + if (queue.addr() % 128 || buffer_addr % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -1140,7 +1140,7 @@ s32 syncLFQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 { for (u32 i = 0; i < sizeof(CellSyncLFQueue) / sizeof(u64); i++) { - if ((u64&)Memory[queue.GetAddr() + i * sizeof(u64)]) + if ((u64&)Memory[queue.addr() + i * sizeof(u64)]) { return CELL_SYNC_ERROR_STAT; } @@ -1183,15 +1183,15 @@ s32 syncLFQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 #endif } -s32 cellSyncLFQueueInitialize(mem_ptr_t queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) +s32 cellSyncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) { cellSync->Warning("cellSyncLFQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x, direction=%d, eaSignal_addr=0x%x)", - queue.GetAddr(), buffer_addr, size, depth, direction, eaSignal_addr); + queue.addr(), buffer_addr, size, depth, direction, eaSignal_addr); return syncLFQueueInitialize(queue, buffer_addr, size, depth, direction, eaSignal_addr); } -s32 syncLFQueueGetPushPointer(mem_ptr_t queue, s32& pointer, u32 isBlocking, u32 useEventQueue) +s32 syncLFQueueGetPushPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_PPU2SPU)) { @@ -1293,10 +1293,10 @@ s32 syncLFQueueGetPushPointer(mem_ptr_t queue, s32& pointer, u3 assert(0); } -s32 _cellSyncLFQueueGetPushPointer(mem_ptr_t queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue) +s32 _cellSyncLFQueueGetPushPointer(vm::ptr queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue) { cellSync->Todo("_cellSyncLFQueueGetPushPointer(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)", - queue.GetAddr(), pointer.GetAddr(), isBlocking, useEventQueue); + queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue); s32 pointer_value; s32 result = syncLFQueueGetPushPointer(queue, pointer_value, isBlocking, useEventQueue); @@ -1304,7 +1304,7 @@ s32 _cellSyncLFQueueGetPushPointer(mem_ptr_t queue, mem32_t poi return result; } -s32 syncLFQueueGetPushPointer2(mem_ptr_t queue, s32& pointer, u32 isBlocking, u32 useEventQueue) +s32 syncLFQueueGetPushPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { // TODO //pointer = 0; @@ -1312,11 +1312,11 @@ s32 syncLFQueueGetPushPointer2(mem_ptr_t queue, s32& pointer, u return CELL_OK; } -s32 _cellSyncLFQueueGetPushPointer2(mem_ptr_t queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue) +s32 _cellSyncLFQueueGetPushPointer2(vm::ptr queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue) { // arguments copied from _cellSyncLFQueueGetPushPointer cellSync->Todo("_cellSyncLFQueueGetPushPointer2(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)", - queue.GetAddr(), pointer.GetAddr(), isBlocking, useEventQueue); + queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue); s32 pointer_value; s32 result = syncLFQueueGetPushPointer2(queue, pointer_value, isBlocking, useEventQueue); @@ -1324,7 +1324,7 @@ s32 _cellSyncLFQueueGetPushPointer2(mem_ptr_t queue, mem32_t po return result; } -s32 syncLFQueueCompletePushPointer(mem_ptr_t queue, s32 pointer, const std::function fpSendSignal) +s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, const std::function fpSendSignal) { if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_PPU2SPU)) { @@ -1471,15 +1471,15 @@ s32 syncLFQueueCompletePushPointer(mem_ptr_t queue, s32 pointer assert(0); } -s32 _cellSyncLFQueueCompletePushPointer(mem_ptr_t queue, s32 pointer, mem_func_ptr_t fpSendSignal) +s32 _cellSyncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, mem_func_ptr_t fpSendSignal) { cellSync->Todo("_cellSyncLFQueueCompletePushPointer(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x)", - queue.GetAddr(), pointer, fpSendSignal.GetAddr()); + queue.addr(), pointer, fpSendSignal.GetAddr()); return syncLFQueueCompletePushPointer(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }); } -s32 syncLFQueueCompletePushPointer2(mem_ptr_t queue, s32 pointer, const std::function fpSendSignal) +s32 syncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, const std::function fpSendSignal) { // TODO //if (fpSendSignal) return fpSendSignal(0, 0); @@ -1487,25 +1487,25 @@ s32 syncLFQueueCompletePushPointer2(mem_ptr_t queue, s32 pointe return CELL_OK; } -s32 _cellSyncLFQueueCompletePushPointer2(mem_ptr_t queue, s32 pointer, mem_func_ptr_t fpSendSignal) +s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr queue, s32 pointer, mem_func_ptr_t fpSendSignal) { // arguments copied from _cellSyncLFQueueCompletePushPointer cellSync->Todo("_cellSyncLFQueueCompletePushPointer2(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x)", - queue.GetAddr(), pointer, fpSendSignal.GetAddr()); + queue.addr(), pointer, fpSendSignal.GetAddr()); return syncLFQueueCompletePushPointer2(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }); } -s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, u32 isBlocking) +s32 _cellSyncLFQueuePushBody(vm::ptr queue, u32 buffer_addr, u32 isBlocking) { // cellSyncLFQueuePush has 1 in isBlocking param, cellSyncLFQueueTryPush has 0 - cellSync->Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x, buffer_addr=0x%x, isBlocking=%d)", queue.GetAddr(), buffer_addr, isBlocking); + cellSync->Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x, buffer_addr=0x%x, isBlocking=%d)", queue.addr(), buffer_addr, isBlocking); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128 || buffer_addr % 16) + if (queue.addr() % 128 || buffer_addr % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -1523,7 +1523,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) { #ifdef PRX_DEBUG_XXX - res = GetCurrentPPUThread().FastCall(libsre + 0x24B0, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0); + res = GetCurrentPPUThread().FastCall(libsre + 0x24B0, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0); position = position_v->ToLE(); #else res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0); @@ -1532,7 +1532,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, else { #ifdef PRX_DEBUG - res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0); + res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0); position = position_v->ToLE(); #else res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0); @@ -1554,7 +1554,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.GetAddr()); + cellSync->Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.addr()); return CELL_OK; } } @@ -1567,7 +1567,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) { #ifdef PRX_DEBUG_XXX - res = GetCurrentPPUThread().FastCall(libsre + 0x26C0, libsre_rtoc, queue.GetAddr(), position, 0); + res = GetCurrentPPUThread().FastCall(libsre + 0x26C0, libsre_rtoc, queue.addr(), position, 0); #else res = syncLFQueueCompletePushPointer(queue, position, nullptr); #endif @@ -1575,7 +1575,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, else { #ifdef PRX_DEBUG - res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x355C, libsre_rtoc, queue.GetAddr(), position, 0); + res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x355C, libsre_rtoc, queue.addr(), position, 0); #else res = syncLFQueueCompletePushPointer2(queue, position, nullptr); #endif @@ -1585,7 +1585,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t queue, u32 buffer_addr, return res; } -s32 syncLFQueueGetPopPointer(mem_ptr_t queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue) +s32 syncLFQueueGetPopPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue) { if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_SPU2PPU)) { @@ -1687,10 +1687,10 @@ s32 syncLFQueueGetPopPointer(mem_ptr_t queue, s32& pointer, u32 assert(0); } -s32 _cellSyncLFQueueGetPopPointer(mem_ptr_t queue, mem32_t pointer, u32 isBlocking, u32 arg4, u32 useEventQueue) +s32 _cellSyncLFQueueGetPopPointer(vm::ptr queue, mem32_t pointer, u32 isBlocking, u32 arg4, u32 useEventQueue) { cellSync->Todo("_cellSyncLFQueueGetPopPointer(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, arg4=%d, useEventQueue=%d)", - queue.GetAddr(), pointer.GetAddr(), isBlocking, arg4, useEventQueue); + queue.addr(), pointer.GetAddr(), isBlocking, arg4, useEventQueue); s32 pointer_value; s32 result = syncLFQueueGetPopPointer(queue, pointer_value, isBlocking, arg4, useEventQueue); @@ -1698,7 +1698,7 @@ s32 _cellSyncLFQueueGetPopPointer(mem_ptr_t queue, mem32_t poin return result; } -s32 syncLFQueueGetPopPointer2(mem_ptr_t queue, s32& pointer, u32 isBlocking, u32 useEventQueue) +s32 syncLFQueueGetPopPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) { // TODO //pointer = 0; @@ -1706,11 +1706,11 @@ s32 syncLFQueueGetPopPointer2(mem_ptr_t queue, s32& pointer, u3 return CELL_OK; } -s32 _cellSyncLFQueueGetPopPointer2(mem_ptr_t queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue) +s32 _cellSyncLFQueueGetPopPointer2(vm::ptr queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue) { // arguments copied from _cellSyncLFQueueGetPopPointer cellSync->Todo("_cellSyncLFQueueGetPopPointer2(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)", - queue.GetAddr(), pointer.GetAddr(), isBlocking, useEventQueue); + queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue); s32 pointer_value; s32 result = syncLFQueueGetPopPointer2(queue, pointer_value, isBlocking, useEventQueue); @@ -1718,7 +1718,7 @@ s32 _cellSyncLFQueueGetPopPointer2(mem_ptr_t queue, mem32_t poi return result; } -s32 syncLFQueueCompletePopPointer(mem_ptr_t queue, s32 pointer, const std::function fpSendSignal, u32 noQueueFull) +s32 syncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, const std::function fpSendSignal, u32 noQueueFull) { if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_SPU2PPU)) { @@ -1864,16 +1864,16 @@ s32 syncLFQueueCompletePopPointer(mem_ptr_t queue, s32 pointer, assert(0); } -s32 _cellSyncLFQueueCompletePopPointer(mem_ptr_t queue, s32 pointer, mem_func_ptr_t fpSendSignal, u32 noQueueFull) +s32 _cellSyncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, mem_func_ptr_t fpSendSignal, u32 noQueueFull) { // arguments copied from _cellSyncLFQueueCompletePushPointer + unknown argument (noQueueFull taken from LFQueue2CompletePopPointer) cellSync->Todo("_cellSyncLFQueueCompletePopPointer(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x, noQueueFull=%d)", - queue.GetAddr(), pointer, fpSendSignal.GetAddr(), noQueueFull); + queue.addr(), pointer, fpSendSignal.GetAddr(), noQueueFull); return syncLFQueueCompletePopPointer(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }, noQueueFull); } -s32 syncLFQueueCompletePopPointer2(mem_ptr_t queue, s32 pointer, const std::function fpSendSignal, u32 noQueueFull) +s32 syncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, const std::function fpSendSignal, u32 noQueueFull) { // TODO //if (fpSendSignal) fpSendSignal(0, 0); @@ -1881,25 +1881,25 @@ s32 syncLFQueueCompletePopPointer2(mem_ptr_t queue, s32 pointer return CELL_OK; } -s32 _cellSyncLFQueueCompletePopPointer2(mem_ptr_t queue, s32 pointer, mem_func_ptr_t fpSendSignal, u32 noQueueFull) +s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr queue, s32 pointer, mem_func_ptr_t fpSendSignal, u32 noQueueFull) { // arguments copied from _cellSyncLFQueueCompletePopPointer cellSync->Todo("_cellSyncLFQueueCompletePopPointer2(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x, noQueueFull=%d)", - queue.GetAddr(), pointer, fpSendSignal.GetAddr(), noQueueFull); + queue.addr(), pointer, fpSendSignal.GetAddr(), noQueueFull); return syncLFQueueCompletePopPointer2(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }, noQueueFull); } -s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u32 isBlocking) +s32 _cellSyncLFQueuePopBody(vm::ptr queue, u32 buffer_addr, u32 isBlocking) { // cellSyncLFQueuePop has 1 in isBlocking param, cellSyncLFQueueTryPop has 0 - cellSync->Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x, buffer_addr=0x%x, isBlocking=%d)", queue.GetAddr(), buffer_addr, isBlocking); + cellSync->Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x, buffer_addr=0x%x, isBlocking=%d)", queue.addr(), buffer_addr, isBlocking); if (!queue || !buffer_addr) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128 || buffer_addr % 16) + if (queue.addr() % 128 || buffer_addr % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -1914,7 +1914,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) { #ifdef PRX_DEBUG_XXX - res = GetCurrentPPUThread().FastCall(libsre + 0x2A90, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0, 0); + res = GetCurrentPPUThread().FastCall(libsre + 0x2A90, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0, 0); position = position_v->ToLE(); #else res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0); @@ -1923,7 +1923,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u else { #ifdef PRX_DEBUG - res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0); + res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0); position = position_v->ToLE(); #else res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0); @@ -1942,7 +1942,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack if (Emu.IsStopped()) { - cellSync->Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.GetAddr()); + cellSync->Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.addr()); return CELL_OK; } } @@ -1955,7 +1955,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) { #ifdef PRX_DEBUG_XXX - res = GetCurrentPPUThread().FastCall(libsre + 0x2CA8, libsre_rtoc, queue.GetAddr(), position, 0, 0); + res = GetCurrentPPUThread().FastCall(libsre + 0x2CA8, libsre_rtoc, queue.addr(), position, 0, 0); #else res = syncLFQueueCompletePopPointer(queue, position, nullptr, 0); #endif @@ -1963,7 +1963,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u else { #ifdef PRX_DEBUG - res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3EB8, libsre_rtoc, queue.GetAddr(), position, 0, 0); + res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3EB8, libsre_rtoc, queue.addr(), position, 0, 0); #else res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0); #endif @@ -1972,15 +1972,15 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t queue, u32 buffer_addr, u return res; } -s32 cellSyncLFQueueClear(mem_ptr_t queue) +s32 cellSyncLFQueueClear(vm::ptr queue) { - cellSync->Warning("cellSyncLFQueueClear(queue_addr=0x%x)", queue.GetAddr()); + cellSync->Warning("cellSyncLFQueueClear(queue_addr=0x%x)", queue.addr()); if (!queue) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128) + if (queue.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -2020,15 +2020,15 @@ s32 cellSyncLFQueueClear(mem_ptr_t queue) return CELL_OK; } -s32 cellSyncLFQueueSize(mem_ptr_t queue, mem32_t size) +s32 cellSyncLFQueueSize(vm::ptr queue, mem32_t size) { - cellSync->Warning("cellSyncLFQueueSize(queue_addr=0x%x, size_addr=0x%x)", queue.GetAddr(), size.GetAddr()); + cellSync->Warning("cellSyncLFQueueSize(queue_addr=0x%x, size_addr=0x%x)", queue.addr(), size.GetAddr()); if (!queue || !size.GetAddr()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128) + if (queue.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -2058,15 +2058,15 @@ s32 cellSyncLFQueueSize(mem_ptr_t queue, mem32_t size) assert(0); } -s32 cellSyncLFQueueDepth(mem_ptr_t queue, mem32_t depth) +s32 cellSyncLFQueueDepth(vm::ptr queue, mem32_t depth) { - cellSync->Log("cellSyncLFQueueDepth(queue_addr=0x%x, depth_addr=0x%x)", queue.GetAddr(), depth.GetAddr()); + cellSync->Log("cellSyncLFQueueDepth(queue_addr=0x%x, depth_addr=0x%x)", queue.addr(), depth.GetAddr()); if (!queue || !depth.GetAddr()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128) + if (queue.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -2075,15 +2075,15 @@ s32 cellSyncLFQueueDepth(mem_ptr_t queue, mem32_t depth) return CELL_OK; } -s32 _cellSyncLFQueueGetSignalAddress(mem_ptr_t queue, mem32_t ppSignal) +s32 _cellSyncLFQueueGetSignalAddress(vm::ptr queue, mem32_t ppSignal) { - cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.GetAddr(), ppSignal.GetAddr()); + cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.GetAddr()); if (!queue || !ppSignal.GetAddr()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128) + if (queue.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -2092,15 +2092,15 @@ s32 _cellSyncLFQueueGetSignalAddress(mem_ptr_t queue, mem32_t p return CELL_OK; } -s32 cellSyncLFQueueGetDirection(mem_ptr_t queue, mem32_t direction) +s32 cellSyncLFQueueGetDirection(vm::ptr queue, mem32_t direction) { - cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.GetAddr(), direction.GetAddr()); + cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.GetAddr()); if (!queue || !direction.GetAddr()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128) + if (queue.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -2109,15 +2109,15 @@ s32 cellSyncLFQueueGetDirection(mem_ptr_t queue, mem32_t direct return CELL_OK; } -s32 cellSyncLFQueueGetEntrySize(mem_ptr_t queue, mem32_t entry_size) +s32 cellSyncLFQueueGetEntrySize(vm::ptr queue, mem32_t entry_size) { - cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.GetAddr(), entry_size.GetAddr()); + cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.addr(), entry_size.GetAddr()); if (!queue || !entry_size.GetAddr()) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.GetAddr() % 128) + if (queue.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -2126,30 +2126,30 @@ s32 cellSyncLFQueueGetEntrySize(mem_ptr_t queue, mem32_t entry_ return CELL_OK; } -s32 syncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t queue) +s32 syncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr queue) { // TODO assert(0); return CELL_OK; } -s32 _cellSyncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t queue) +s32 _cellSyncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr queue) { - cellSync->Todo("_cellSyncLFQueueAttachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.GetAddr()); + cellSync->Todo("_cellSyncLFQueueAttachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.addr()); return syncLFQueueAttachLv2EventQueue(spus, num, queue); } -s32 syncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t queue) +s32 syncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr queue) { // TODO assert(0); return CELL_OK; } -s32 _cellSyncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t queue) +s32 _cellSyncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr queue) { - cellSync->Todo("_cellSyncLFQueueDetachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.GetAddr()); + cellSync->Todo("_cellSyncLFQueueDetachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.addr()); return syncLFQueueDetachLv2EventQueue(spus, num, queue); } diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp index cac8416bbc..a392e1f548 100644 --- a/rpcs3/Emu/System.cpp +++ b/rpcs3/Emu/System.cpp @@ -341,7 +341,7 @@ void Emulator::Load() thread.SetEntry(l.GetEntry()); Memory.StackMem.AllocAlign(0x1000); thread.InitStack(); - thread.AddArgv(m_elf_path); + thread.AddArgv(m_elf_path); // it doesn't work //thread.AddArgv("-emu"); m_rsx_callback = (u32)Memory.MainMem.AllocAlign(4 * 4) + 4;