diff --git a/rpcs3/Emu/Cell/PPUInterpreter.h b/rpcs3/Emu/Cell/PPUInterpreter.h index a05970e885..1d74b153ed 100644 --- a/rpcs3/Emu/Cell/PPUInterpreter.h +++ b/rpcs3/Emu/Cell/PPUInterpreter.h @@ -2635,7 +2635,8 @@ private: if (CPU.R_ADDR == addr) { - CPU.SetCR_EQ(0, InterlockedCompareExchange((volatile u32*)(Memory + addr), re32((u32)CPU.GPR[rs]), (u32)CPU.R_VALUE) == (u32)CPU.R_VALUE); + CPU.SetCR_EQ(0, InterlockedCompareExchange(vm::get_ptr(addr), re32((u32)CPU.GPR[rs]), (u32)CPU.R_VALUE) == (u32)CPU.R_VALUE); + CPU.R_ADDR = 0; } else { @@ -2692,7 +2693,8 @@ private: if (CPU.R_ADDR == addr) { - CPU.SetCR_EQ(0, InterlockedCompareExchange((volatile u64*)(Memory + addr), re64(CPU.GPR[rs]), CPU.R_VALUE) == CPU.R_VALUE); + CPU.SetCR_EQ(0, InterlockedCompareExchange(vm::get_ptr(addr), re64(CPU.GPR[rs]), CPU.R_VALUE) == CPU.R_VALUE); + CPU.R_ADDR = 0; } else { diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp index 6584aba784..df9d9ee04b 100644 --- a/rpcs3/Emu/Cell/SPUThread.cpp +++ b/rpcs3/Emu/Cell/SPUThread.cpp @@ -244,13 +244,13 @@ void SPUThread::ProcessCmd(u32 cmd, u32 tag, u32 lsa, u64 ea, u32 size) { case MFC_PUT_CMD: { - memcpy(Memory + ea, Memory + (dmac.ls_offset + lsa), size); + memcpy(vm::get_ptr(ea), vm::get_ptr(dmac.ls_offset + lsa), size); return; } case MFC_GET_CMD: { - memcpy(Memory + (dmac.ls_offset + lsa), Memory + ea, size); + memcpy(vm::get_ptr(dmac.ls_offset + lsa), vm::get_ptr(ea), size); return; } @@ -423,7 +423,7 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs) { if (buf[i] != R_DATA[i]) { - if (InterlockedCompareExchange((volatile u64*)(Memory + (ea + i * 8)), buf[i], R_DATA[i]) != R_DATA[i]) + if (InterlockedCompareExchange(&vm::get_ptr(ea)[i], buf[i], R_DATA[i]) != R_DATA[i]) { m_events |= SPU_EVENT_LR; MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE); diff --git a/rpcs3/Emu/FS/vfsStreamMemory.cpp b/rpcs3/Emu/FS/vfsStreamMemory.cpp index 102f4b3f8c..f385a4ecb3 100644 --- a/rpcs3/Emu/FS/vfsStreamMemory.cpp +++ b/rpcs3/Emu/FS/vfsStreamMemory.cpp @@ -31,7 +31,7 @@ u64 vfsStreamMemory::Write(const void* src, u64 size) size = GetSize() - Tell(); } - memcpy(Memory + (m_addr + Tell()), (void*)src, size); + memcpy(vm::get_ptr(m_addr + Tell()), src, size); return vfsStream::Write(src, size); } @@ -43,7 +43,7 @@ u64 vfsStreamMemory::Read(void* dst, u64 size) size = GetSize() - Tell(); } - memcpy(dst, Memory + (m_addr + Tell()), size); + memcpy(dst, vm::get_ptr(m_addr + Tell()), size); return vfsStream::Read(dst, size); } diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h index 23cc389e64..0244e149cd 100644 --- a/rpcs3/Emu/Memory/Memory.h +++ b/rpcs3/Emu/Memory/Memory.h @@ -95,19 +95,6 @@ public: void UnregisterPages(u64 addr, u32 size); - template u8* GetMemFromAddr(const T addr) - { - if ((u32)addr == addr) - { - return (u8*)GetBaseAddr() + addr; - } - else - { - InvalidAddress(__FUNCTION__, addr); - return (u8*)GetBaseAddr(); - } - } - u32 RealToVirtualAddr(const void* addr) { const u64 res = (u64)addr - (u64)GetBaseAddr(); @@ -332,14 +319,17 @@ public: bool Unmap(const u64 addr); - template void* operator + (const T vaddr) + template u8& operator[] (const T addr) { - return GetMemFromAddr(vaddr); - } - - template u8& operator[] (const T vaddr) - { - return *GetMemFromAddr(vaddr); + if ((u32)addr == addr) + { + return *((u8*)GetBaseAddr() + addr); + } + else + { + InvalidAddress(__FUNCTION__, addr); + return *(u8*)GetBaseAddr(); + } } }; diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp index 1cad5040c6..e6999655cf 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp @@ -116,7 +116,7 @@ next: break; case adecDecodeAu: { - memcpy(buf, Memory + adec.reader.addr, adec.reader.size); + memcpy(buf, vm::get_ptr(adec.reader.addr), adec.reader.size); buf += adec.reader.size; buf_size -= adec.reader.size; @@ -149,7 +149,7 @@ next: } else { - memcpy(buf, Memory + adec.reader.addr, buf_size); + memcpy(buf, vm::get_ptr(adec.reader.addr), buf_size); adec.reader.addr += buf_size; adec.reader.size -= buf_size; diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp index 2f873ea426..40692a92d1 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp @@ -40,9 +40,9 @@ int cellAudioInit() // alloc memory m_config.m_buffer = (u32)Memory.Alloc(128 * 1024 * m_config.AUDIO_PORT_COUNT, 1024); - memset(Memory + m_config.m_buffer, 0, 128 * 1024 * m_config.AUDIO_PORT_COUNT); + memset(vm::get_ptr(m_config.m_buffer), 0, 128 * 1024 * m_config.AUDIO_PORT_COUNT); m_config.m_indexes = (u32)Memory.Alloc(sizeof(u64) * m_config.AUDIO_PORT_COUNT, 16); - memset(Memory + m_config.m_indexes, 0, sizeof(u64) * m_config.AUDIO_PORT_COUNT); + memset(vm::get_ptr(m_config.m_indexes), 0, sizeof(u64) * m_config.AUDIO_PORT_COUNT); thread t("Audio Thread", []() { diff --git a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp index b44a01a5f1..2640aa7360 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp @@ -156,7 +156,7 @@ void ElementaryStream::push(DemuxerStream& stream, u32 sz, PesHeader& pes) u32 data_addr = put + 128 + size; size += sz; - memcpy(Memory + data_addr, Memory + stream.addr, sz); + memcpy(vm::get_ptr(data_addr), vm::get_ptr(stream.addr), sz); stream.skip(sz); auto info = vm::ptr::make(put); diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp index 8cc4bda3b9..7983e0734a 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp @@ -68,8 +68,8 @@ void InitOffsetTable() offsetTable.ioAddress = (u32)Memory.Alloc(3072 * sizeof(u16), 1); offsetTable.eaAddress = (u32)Memory.Alloc(512 * sizeof(u16), 1); - _sys_memset(offsetTable.ioAddress, 0xFF, 3072 * sizeof(u16)); - _sys_memset(offsetTable.eaAddress, 0xFF, 512 * sizeof(u16)); + memset(vm::get_ptr(offsetTable.ioAddress), 0xFF, 3072 * sizeof(u16)); + memset(vm::get_ptr(offsetTable.eaAddress), 0xFF, 512 * sizeof(u16)); } //---------------------------------------------------------------------------- @@ -514,7 +514,7 @@ s32 cellGcmSetPrepareFlip(vm::ptr ctxt, u32 id) const s32 res = ctxt->current - ctxt->begin - ctrl.put; - memmove(Memory + ctxt->begin, Memory + (ctxt->current - res), res); + memmove(vm::get_ptr(ctxt->begin), vm::get_ptr(ctxt->current - res), res); ctxt->current = ctxt->begin + res; @@ -1169,7 +1169,7 @@ int cellGcmCallback(u32 context_addr, u32 count) const s32 res = ctx.current - ctx.begin - ctrl.put; - memmove(Memory + ctx.begin, Memory + (ctx.current - res), res); + memmove(vm::get_ptr(ctx.begin), vm::get_ptr(ctx.current - res), res); ctx.current = ctx.begin + res; diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp index 5a27fe8b47..75675106a8 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp @@ -79,7 +79,7 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr switch(subHandle_data->src.srcSelect.ToBE()) { case se32(CELL_GIFDEC_BUFFER): - memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size()); + memmove(buffer.begin(), vm::get_ptr(subHandle_data->src.streamPtr), buffer.size()); break; case se32(CELL_GIFDEC_FILE): @@ -161,7 +161,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt switch(subHandle_data->src.srcSelect.ToBE()) { case se32(CELL_GIFDEC_BUFFER): - memmove(Memory + gif.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), gif.size()); + memmove(gif.begin(), vm::get_ptr(subHandle_data->src.streamPtr), gif.size()); break; case se32(CELL_GIFDEC_FILE): @@ -196,12 +196,12 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt { const int dstOffset = i * bytesPerLine; const int srcOffset = width * nComponents * i; - memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize); + memcpy(&data[dstOffset], &image.get()[srcOffset], linesize); } } else { - memcpy(Memory + data.addr(), image.get(), image_size); + memcpy(data.get_ptr(), image.get(), image_size); } } break; @@ -224,7 +224,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt output[j + 2] = image.get()[srcOffset + j + 1]; output[j + 3] = image.get()[srcOffset + j + 2]; } - memcpy(Memory + (data.addr() + dstOffset), output, linesize); + memcpy(&data[dstOffset], output, linesize); } free(output); } diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp index 367007c33d..b34c42dc3e 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp @@ -99,7 +99,7 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr switch(subHandle_data->src.srcSelect.ToBE()) { case se32(CELL_JPGDEC_BUFFER): - memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size()); + memmove(buffer.begin(), vm::get_ptr(subHandle_data->src.streamPtr), buffer.size()); break; case se32(CELL_JPGDEC_FILE): @@ -168,7 +168,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt switch(subHandle_data->src.srcSelect.ToBE()) { case se32(CELL_JPGDEC_BUFFER): - memmove(Memory + jpg.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), jpg.size()); + memmove(jpg.begin(), vm::get_ptr(subHandle_data->src.streamPtr), jpg.size()); break; case se32(CELL_JPGDEC_FILE): @@ -206,12 +206,12 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt { const int dstOffset = i * bytesPerLine; const int srcOffset = width * nComponents * (flip ? height - i - 1 : i); - memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize); + memcpy(&data[dstOffset], &image.get()[srcOffset], linesize); } } else { - memcpy(Memory + data.addr(), image.get(), image_size); + memcpy(data.get_ptr(), image.get(), image_size); } } break; @@ -236,7 +236,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt output[j + 2] = image.get()[srcOffset + j + 1]; output[j + 3] = image.get()[srcOffset + j + 2]; } - memcpy(Memory + (data.addr() + dstOffset), output, linesize); + memcpy(&data[dstOffset], output, linesize); } free(output); } diff --git a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp index ca395e5875..584157e797 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp @@ -388,11 +388,11 @@ int cellPamfReaderGetEsFilterId(vm::ptr pSelf, vm::ptr pSelf, u32 pInfo_addr, u32 size) { - cellPamf->Warning("cellPamfReaderGetStreamInfo(pSelf=0x%x, stream=%d, pInfo_addr=0x%x, size=%d)", pSelf.addr(), pSelf->stream, pInfo_addr, size); + cellPamf->Warning("cellPamfReaderGetStreamInfo(pSelf=0x%x, stream=%d, pInfo_addr=0x%x, size=%d)", pSelf.addr(), pSelf->stream, pInfo_addr, size); vm::ptr pAddr(pSelf->pAddr); - memset(Memory + pInfo_addr, 0, size); + memset(vm::get_ptr(pInfo_addr), 0, size); switch (pamfGetStreamType(pSelf, pSelf->stream)) { diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp index d166a36b45..af26cb2a59 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp @@ -140,7 +140,7 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr switch(subHandle_data->src.srcSelect.ToBE()) { case se32(CELL_PNGDEC_BUFFER): - memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size()); + memmove(buffer.begin(), vm::get_ptr(subHandle_data->src.streamPtr), buffer.size()); break; case se32(CELL_PNGDEC_FILE): cellFsLseek(fd, 0, CELL_SEEK_SET, pos); @@ -205,7 +205,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt switch(subHandle_data->src.srcSelect.ToBE()) { case se32(CELL_PNGDEC_BUFFER): - memmove(Memory + png.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), png.size()); + memmove(png.begin(), vm::get_ptr(subHandle_data->src.streamPtr), png.size()); break; case se32(CELL_PNGDEC_FILE): @@ -241,12 +241,12 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt { const int dstOffset = i * bytesPerLine; const int srcOffset = width * nComponents * (flip ? height - i - 1 : i); - memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize); + memcpy(&data[dstOffset], &image.get()[srcOffset], linesize); } } else { - memcpy(Memory + data.addr(), image.get(), image_size); + memcpy(data.get_ptr(), image.get(), image_size); } } break; @@ -271,7 +271,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr data, vm::pt output[j + 2] = image.get()[srcOffset + j + 1]; output[j + 3] = image.get()[srcOffset + j + 2]; } - memcpy(Memory + (data.addr() + dstOffset), output, linesize); + memcpy(&data[dstOffset], output, linesize); } free(output); } diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h index d17a93eac0..51a92a298f 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h +++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h @@ -194,11 +194,11 @@ struct CellSpursTracePacket }; // Exception handlers. -//typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr spurs, const vm::ptr info, -// u32 id, vm::ptr arg); +//typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr spurs, vm::ptr info, +// u32 id, vm::ptr arg); // //typedef void (*CellSpursTasksetExceptionEventHandler)(vm::ptr spurs, vm::ptr taskset, -// u32 idTask, const vm::ptr info, vm::ptr arg); +// u32 idTask, vm::ptr info, vm::ptr arg); struct CellSpursTasksetInfo { diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp index 95c27a9a9e..572113678d 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp @@ -765,7 +765,7 @@ void cellSpursJq_init() CallAfter([]() { libspurs_jq = (u32)Memory.PRXMem.AllocAlign(sizeof(libspurs_jq_data), 4096); - memcpy(Memory + libspurs_jq, libspurs_jq_data, sizeof(libspurs_jq_data)); + memcpy(vm::get_ptr(libspurs_jq), libspurs_jq_data, sizeof(libspurs_jq_data)); libspurs_jq_rtoc = libspurs_jq + 0x17E80; extern Module* sysPrxForUser; diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp index 0ce8261e7e..720244a422 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp @@ -346,13 +346,13 @@ s32 cellSyncBarrierTryWait(vm::ptr barrier) return CELL_OK; } -s32 syncRwmInitialize(vm::ptr rwm, u32 buffer_addr, u32 buffer_size) +s32 syncRwmInitialize(vm::ptr rwm, vm::ptr buffer, u32 buffer_size) { - if (!rwm || !buffer_addr) + if (!rwm || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (rwm.addr() % 16 || buffer_addr % 128) + if (rwm.addr() % 16 || buffer.addr() % 128) { return CELL_SYNC_ERROR_ALIGN; } @@ -364,23 +364,23 @@ s32 syncRwmInitialize(vm::ptr rwm, u32 buffer_addr, u32 buffer_size // prx: zeroize first u16 and second u16, write buffer_size in second u32, write buffer_addr in second u64 and sync rwm->m_data() = 0; rwm->m_size = buffer_size; - rwm->m_addr = (u64)buffer_addr; + rwm->m_buffer = buffer; InterlockedCompareExchange(&rwm->m_data(), 0, 0); return CELL_OK; } -s32 cellSyncRwmInitialize(vm::ptr rwm, u32 buffer_addr, u32 buffer_size) +s32 cellSyncRwmInitialize(vm::ptr rwm, vm::ptr buffer, u32 buffer_size) { - cellSync->Log("cellSyncRwmInitialize(rwm_addr=0x%x, buffer_addr=0x%x, buffer_size=0x%x)", rwm.addr(), 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); + return syncRwmInitialize(rwm, buffer, buffer_size); } -s32 cellSyncRwmRead(vm::ptr rwm, u32 buffer_addr) +s32 cellSyncRwmRead(vm::ptr rwm, vm::ptr buffer) { - cellSync->Log("cellSyncRwmRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); + cellSync->Log("cellSyncRwmRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer.addr()); - if (!rwm || !buffer_addr) + if (!rwm || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -412,7 +412,7 @@ s32 cellSyncRwmRead(vm::ptr rwm, u32 buffer_addr) } // copy data to buffer_addr - memcpy(Memory + buffer_addr, Memory + (u64)rwm->m_addr, (u32)rwm->m_size); + memcpy(buffer.get_ptr(), rwm->m_buffer.get_ptr(), (u32)rwm->m_size); // prx: load first u32, return 0x8041010C if first u16 == 0, atomically decrease it while (true) @@ -433,11 +433,11 @@ s32 cellSyncRwmRead(vm::ptr rwm, u32 buffer_addr) return CELL_OK; } -s32 cellSyncRwmTryRead(vm::ptr rwm, u32 buffer_addr) +s32 cellSyncRwmTryRead(vm::ptr rwm, vm::ptr buffer) { - cellSync->Log("cellSyncRwmTryRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); + cellSync->Log("cellSyncRwmTryRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer.addr()); - if (!rwm || !buffer_addr) + if (!rwm || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -461,7 +461,7 @@ s32 cellSyncRwmTryRead(vm::ptr rwm, u32 buffer_addr) if (InterlockedCompareExchange(&rwm->m_data(), new_rwm.m_data(), old_data) == old_data) break; } - memcpy(Memory + buffer_addr, Memory + (u64)rwm->m_addr, (u32)rwm->m_size); + memcpy(buffer.get_ptr(), rwm->m_buffer.get_ptr(), (u32)rwm->m_size); while (true) { @@ -481,11 +481,11 @@ s32 cellSyncRwmTryRead(vm::ptr rwm, u32 buffer_addr) return CELL_OK; } -s32 cellSyncRwmWrite(vm::ptr rwm, u32 buffer_addr) +s32 cellSyncRwmWrite(vm::ptr rwm, vm::ptr buffer) { - cellSync->Log("cellSyncRwmWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); + cellSync->Log("cellSyncRwmWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer.addr()); - if (!rwm || !buffer_addr) + if (!rwm || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -528,7 +528,7 @@ s32 cellSyncRwmWrite(vm::ptr rwm, u32 buffer_addr) } // prx: copy data from buffer_addr - memcpy(Memory + (u64)rwm->m_addr, Memory + buffer_addr, (u32)rwm->m_size); + memcpy(rwm->m_buffer.get_ptr(), buffer.get_ptr(), (u32)rwm->m_size); // prx: sync and zeroize m_readers and m_writers InterlockedCompareExchange(&rwm->m_data(), 0, 0); @@ -536,11 +536,11 @@ s32 cellSyncRwmWrite(vm::ptr rwm, u32 buffer_addr) return CELL_OK; } -s32 cellSyncRwmTryWrite(vm::ptr rwm, u32 buffer_addr) +s32 cellSyncRwmTryWrite(vm::ptr rwm, vm::ptr buffer) { - cellSync->Log("cellSyncRwmTryWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr); + cellSync->Log("cellSyncRwmTryWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer.addr()); - if (!rwm || !buffer_addr) + if (!rwm || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -553,7 +553,7 @@ s32 cellSyncRwmTryWrite(vm::ptr rwm, u32 buffer_addr) if (InterlockedCompareExchange(&rwm->m_data(), se32(1), 0) != 0) return CELL_SYNC_ERROR_BUSY; // prx: copy data from buffer_addr - memcpy(Memory + (u64)rwm->m_addr, Memory + buffer_addr, (u32)rwm->m_size); + memcpy(rwm->m_buffer.get_ptr(), buffer.get_ptr(), (u32)rwm->m_size); // prx: sync and zeroize m_readers and m_writers InterlockedCompareExchange(&rwm->m_data(), 0, 0); @@ -561,17 +561,17 @@ s32 cellSyncRwmTryWrite(vm::ptr rwm, u32 buffer_addr) return CELL_OK; } -s32 syncQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth) +s32 syncQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth) { if (!queue) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (size && !buffer_addr) + if (size && !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.addr() % 32 || buffer_addr % 16) + if (queue.addr() % 32 || buffer.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -584,23 +584,23 @@ s32 syncQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, queue->m_data() = 0; queue->m_size = size; queue->m_depth = depth; - queue->m_addr = (u64)buffer_addr; + queue->m_buffer = buffer; InterlockedCompareExchange(&queue->m_data(), 0, 0); return CELL_OK; } -s32 cellSyncQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth) +s32 cellSyncQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth) { - cellSync->Log("cellSyncQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x)", queue.addr(), 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); + return syncQueueInitialize(queue, buffer, size, depth); } -s32 cellSyncQueuePush(vm::ptr queue, u32 buffer_addr) +s32 cellSyncQueuePush(vm::ptr queue, vm::ptr buffer) { - cellSync->Log("cellSyncQueuePush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); + cellSync->Log("cellSyncQueuePush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer.addr()); - if (!queue || !buffer_addr) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -645,7 +645,7 @@ s32 cellSyncQueuePush(vm::ptr queue, u32 buffer_addr) } // prx: memcpy(position * m_size + m_addr, buffer_addr, m_size), sync - memcpy(Memory + ((u64)queue->m_addr + position * size), Memory + buffer_addr, size); + memcpy(&queue->m_buffer[position * size], buffer.get_ptr(), size); // prx: atomically insert 0 in 5th u8 while (true) @@ -660,11 +660,11 @@ s32 cellSyncQueuePush(vm::ptr queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueTryPush(vm::ptr queue, u32 buffer_addr) +s32 cellSyncQueueTryPush(vm::ptr queue, vm::ptr buffer) { - cellSync->Log("cellSyncQueueTryPush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); + cellSync->Log("cellSyncQueueTryPush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer.addr()); - if (!queue || !buffer_addr) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -697,7 +697,7 @@ s32 cellSyncQueueTryPush(vm::ptr queue, u32 buffer_addr) if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; } - memcpy(Memory + ((u64)queue->m_addr + position * size), Memory + buffer_addr, size); + memcpy(&queue->m_buffer[position * size], buffer.get_ptr(), size); while (true) { @@ -711,11 +711,11 @@ s32 cellSyncQueueTryPush(vm::ptr queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueuePop(vm::ptr queue, u32 buffer_addr) +s32 cellSyncQueuePop(vm::ptr queue, vm::ptr buffer) { - cellSync->Log("cellSyncQueuePop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); + cellSync->Log("cellSyncQueuePop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer.addr()); - if (!queue || !buffer_addr) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -760,7 +760,7 @@ s32 cellSyncQueuePop(vm::ptr queue, u32 buffer_addr) } // prx: (sync), memcpy(buffer_addr, position * m_size + m_addr, m_size) - memcpy(Memory + buffer_addr, Memory + ((u64)queue->m_addr + position * size), size); + memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size); // prx: atomically insert 0 in first u8 while (true) @@ -775,11 +775,11 @@ s32 cellSyncQueuePop(vm::ptr queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueTryPop(vm::ptr queue, u32 buffer_addr) +s32 cellSyncQueueTryPop(vm::ptr queue, vm::ptr buffer) { - cellSync->Log("cellSyncQueueTryPop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); + cellSync->Log("cellSyncQueueTryPop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer.addr()); - if (!queue || !buffer_addr) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -812,7 +812,7 @@ s32 cellSyncQueueTryPop(vm::ptr queue, u32 buffer_addr) if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; } - memcpy(Memory + buffer_addr, Memory + ((u64)queue->m_addr + position * size), size); + memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size); while (true) { @@ -826,11 +826,11 @@ s32 cellSyncQueueTryPop(vm::ptr queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueuePeek(vm::ptr queue, u32 buffer_addr) +s32 cellSyncQueuePeek(vm::ptr queue, vm::ptr buffer) { - cellSync->Log("cellSyncQueuePeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); + cellSync->Log("cellSyncQueuePeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer.addr()); - if (!queue || !buffer_addr) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -868,7 +868,7 @@ s32 cellSyncQueuePeek(vm::ptr queue, u32 buffer_addr) if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; } - memcpy(Memory + buffer_addr, Memory + ((u64)queue->m_addr + position * size), size); + memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size); while (true) { @@ -882,11 +882,11 @@ s32 cellSyncQueuePeek(vm::ptr queue, u32 buffer_addr) return CELL_OK; } -s32 cellSyncQueueTryPeek(vm::ptr queue, u32 buffer_addr) +s32 cellSyncQueueTryPeek(vm::ptr queue, vm::ptr buffer) { - cellSync->Log("cellSyncQueueTryPeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr); + cellSync->Log("cellSyncQueueTryPeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer.addr()); - if (!queue || !buffer_addr) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -918,7 +918,7 @@ s32 cellSyncQueueTryPeek(vm::ptr queue, u32 buffer_addr) if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; } - memcpy(Memory + buffer_addr, Memory + ((u64)queue->m_addr + position * size), size); + memcpy(buffer.get_ptr(), &queue->m_buffer[position * size], size); while (true) { @@ -1029,7 +1029,7 @@ void syncLFQueueDump(vm::ptr queue) } } -void syncLFQueueInit(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) +void syncLFQueueInit(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal) { queue->m_h1 = 0; queue->m_h2 = 0; @@ -1039,19 +1039,20 @@ void syncLFQueueInit(vm::ptr queue, u32 buffer_addr, u32 size, queue->m_h8 = 0; queue->m_size = size; queue->m_depth = depth; - queue->m_buffer = (u64)buffer_addr; + queue->m_buffer = buffer; queue->m_direction = direction; for (u32 i = 0; i < sizeof(queue->m_hs) / sizeof(queue->m_hs[0]); i++) { queue->m_hs[i] = 0; } - queue->m_eaSignal = (u64)eaSignal_addr; + queue->m_eaSignal = eaSignal; if (direction == CELL_SYNC_QUEUE_ANY2ANY) { queue->m_h3 = 0; queue->m_h7 = 0; - queue->m_buffer = (u64)buffer_addr | 1; + queue->m_buffer = buffer + 1; + assert(queue->m_buffer.addr() % 2); queue->m_bs[0] = -1; queue->m_bs[1] = -1; //m_bs[2] @@ -1076,7 +1077,7 @@ void syncLFQueueInit(vm::ptr queue, u32 buffer_addr, u32 size, } } -s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) +s32 syncLFQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal) { #ifdef PRX_DEBUG_XXX return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.addr(), buffer_addr, size, depth, direction, eaSignal_addr); @@ -1088,7 +1089,7 @@ s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 s } if (size) { - if (!buffer_addr) + if (!buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } @@ -1101,7 +1102,7 @@ s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 s { return CELL_SYNC_ERROR_INVAL; } - if (queue.addr() % 128 || buffer_addr % 16) + if (queue.addr() % 128 || buffer.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -1155,13 +1156,13 @@ s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 s if (old_value == se32(2)) { - if ((u32)queue->m_size != size || (u32)queue->m_depth != depth || (u64)queue->m_buffer != (u64)buffer_addr) + if ((u32)queue->m_size != size || (u32)queue->m_depth != depth || queue->m_buffer.addr() != buffer.addr()) { return CELL_SYNC_ERROR_INVAL; } if (sdk_ver > 0x17ffff) { - if ((u64)queue->m_eaSignal != (u64)eaSignal_addr || (u32)queue->m_direction != direction) + if (queue->m_eaSignal.addr() != eaSignal.addr() || (u32)queue->m_direction != direction) { return CELL_SYNC_ERROR_INVAL; } @@ -1170,7 +1171,7 @@ s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 s else { // prx: call internal function with same arguments - syncLFQueueInit(queue, buffer_addr, size, depth, direction, eaSignal_addr); + syncLFQueueInit(queue, buffer, size, depth, direction, eaSignal); // prx: sync, zeroize u32 at 0x2c offset InterlockedCompareExchange(&queue->m_data(), 0, 0); @@ -1183,12 +1184,12 @@ s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 s #endif } -s32 cellSyncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) +s32 cellSyncLFQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal) { cellSync->Warning("cellSyncLFQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x, direction=%d, eaSignal_addr=0x%x)", - queue.addr(), 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); + return syncLFQueueInitialize(queue, buffer, size, depth, direction, eaSignal); } s32 syncLFQueueGetPushPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue) @@ -1451,7 +1452,7 @@ s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, if (exch) { assert(fpSendSignal); - return fpSendSignal((u32)queue->m_eaSignal, var6); + return fpSendSignal((u32)queue->m_eaSignal.addr(), var6); } } else @@ -1496,16 +1497,16 @@ s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr queue, s32 poi return syncLFQueueCompletePushPointer2(queue, pointer, fpSendSignal); } -s32 _cellSyncLFQueuePushBody(vm::ptr queue, u32 buffer_addr, u32 isBlocking) +s32 _cellSyncLFQueuePushBody(vm::ptr queue, vm::ptr buffer, 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.addr(), 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) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.addr() % 128 || buffer_addr % 16) + if (queue.addr() % 128 || buffer.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -1561,7 +1562,7 @@ s32 _cellSyncLFQueuePushBody(vm::ptr queue, u32 buffer_addr, u3 s32 depth = (u32)queue->m_depth; s32 size = (u32)queue->m_size; - memcpy(Memory + (((u64)queue->m_buffer & ~1ull) + size * (position >= depth ? position - depth : position)), Memory + buffer_addr, size); + memcpy(vm::get_ptr((queue->m_buffer.addr() & ~1ull) + size * (position >= depth ? position - depth : position)), buffer.get_ptr(), size); s32 res; if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) @@ -1844,7 +1845,7 @@ s32 syncLFQueueCompletePopPointer(vm::ptr queue, s32 pointer, c if (exch) { assert(fpSendSignal); - return fpSendSignal((u32)queue->m_eaSignal, var6); + return fpSendSignal((u32)queue->m_eaSignal.addr(), var6); } } else @@ -1890,16 +1891,16 @@ s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr queue, s32 poin return syncLFQueueCompletePopPointer2(queue, pointer, fpSendSignal, noQueueFull); } -s32 _cellSyncLFQueuePopBody(vm::ptr queue, u32 buffer_addr, u32 isBlocking) +s32 _cellSyncLFQueuePopBody(vm::ptr queue, vm::ptr buffer, 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.addr(), 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) + if (!queue || !buffer) { return CELL_SYNC_ERROR_NULL_POINTER; } - if (queue.addr() % 128 || buffer_addr % 16) + if (queue.addr() % 128 || buffer.addr() % 16) { return CELL_SYNC_ERROR_ALIGN; } @@ -1949,7 +1950,7 @@ s32 _cellSyncLFQueuePopBody(vm::ptr queue, u32 buffer_addr, u32 s32 depth = (u32)queue->m_depth; s32 size = (u32)queue->m_size; - memcpy(Memory + buffer_addr, Memory + (((u64)queue->m_buffer & ~1ull) + size * (position >= depth ? position - depth : position)), size); + memcpy(buffer.get_ptr(), vm::get_ptr((queue->m_buffer.addr() & ~1ull) + size * (position >= depth ? position - depth : position)), size); s32 res; if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) @@ -2075,7 +2076,7 @@ s32 cellSyncLFQueueDepth(vm::ptr queue, vm::ptr> dept return CELL_OK; } -s32 _cellSyncLFQueueGetSignalAddress(vm::ptr queue, vm::ptr> ppSignal) +s32 _cellSyncLFQueueGetSignalAddress(vm::ptr queue, vm::ptr> ppSignal) { cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.addr()); @@ -2088,11 +2089,11 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::ptr queue, vm::ptrm_eaSignal; + *ppSignal = (u32)queue->m_eaSignal.addr(); return CELL_OK; } -s32 cellSyncLFQueueGetDirection(vm::ptr queue, vm::ptr> direction) +s32 cellSyncLFQueueGetDirection(vm::ptr queue, vm::ptr> direction) { cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.addr()); @@ -2109,7 +2110,7 @@ s32 cellSyncLFQueueGetDirection(vm::ptr queue, vm::ptr queue, vm::ptr> entry_size) +s32 cellSyncLFQueueGetEntrySize(vm::ptr queue, vm::ptr> entry_size) { cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.addr(), entry_size.addr()); @@ -2207,7 +2208,7 @@ void cellSync_init() CallAfter([]() { libsre = (u32)Memory.PRXMem.AllocAlign(sizeof(libsre_data), 4096); - memcpy(Memory + libsre, libsre_data, sizeof(libsre_data)); + memcpy(vm::get_ptr(libsre), libsre_data, sizeof(libsre_data)); libsre_rtoc = libsre + 0x399B0; extern Module* sysPrxForUser; diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.h b/rpcs3/Emu/SysCalls/Modules/cellSync.h index 9e4d73f7b2..5e282cec50 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync.h +++ b/rpcs3/Emu/SysCalls/Modules/cellSync.h @@ -60,7 +60,7 @@ struct CellSyncRwm be_t m_readers; be_t m_writers; be_t m_size; - be_t m_addr; + vm::bptr m_buffer; volatile u32& m_data() { @@ -76,7 +76,7 @@ struct CellSyncQueue be_t m_v2; be_t m_size; be_t m_depth; - be_t m_addr; + vm::bptr m_buffer; be_t reserved; volatile u64& m_data() @@ -107,13 +107,13 @@ struct CellSyncLFQueue be_t m_h8; // 0xE be_t m_size; // 0x10 be_t m_depth; // 0x14 - be_t m_buffer; // 0x18 + vm::bptr m_buffer; // 0x18 u8 m_bs[4]; // 0x20 be_t m_direction; // 0x24 be_t m_v1; // 0x28 be_t m_sync; // 0x2C be_t m_hs[32]; // 0x30 - be_t m_eaSignal;// 0x70 + vm::bptr m_eaSignal; // 0x70 be_t m_v2; // 0x78 be_t m_v3; // 0x7C @@ -159,11 +159,11 @@ s32 syncMutexInitialize(vm::ptr mutex); s32 syncBarrierInitialize(vm::ptr barrier, u16 total_count); -s32 syncRwmInitialize(vm::ptr rwm, u32 buffer_addr, u32 buffer_size); +s32 syncRwmInitialize(vm::ptr rwm, vm::ptr buffer, u32 buffer_size); -s32 syncQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth); +s32 syncQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth); -s32 syncLFQueueInitialize(vm::ptr queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr); +s32 syncLFQueueInitialize(vm::ptr queue, vm::ptr buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr eaSignal); s32 syncLFQueueGetPushPointer(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); s32 syncLFQueueGetPushPointer2(vm::ptr queue, s32& pointer, u32 isBlocking, u32 useEventQueue); s32 syncLFQueueCompletePushPointer(vm::ptr queue, s32 pointer, const std::function fpSendSignal); diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp index b5045f0cad..5c482fc77b 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp @@ -409,7 +409,7 @@ void cellSync2_init() CallAfter([]() { libsync2 = (u32)Memory.PRXMem.AllocAlign(sizeof(libsync2_data), 4096); - memcpy(Memory + libsync2, libsync2_data, sizeof(libsync2_data)); + memcpy(vm::get_ptr(libsync2), libsync2_data, sizeof(libsync2_data)); libsync2_rtoc = libsync2 + 0xF280; extern Module* sysPrxForUser; diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.h b/rpcs3/Emu/SysCalls/Modules/cellSysutil.h index 2abf887bfa..cba1204446 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.h +++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.h @@ -279,7 +279,7 @@ struct CellWebBrowserConfig2 vm::bptr status_error_cb; vm::bptr notify_cb; vm::bptr request_cb; - vm::bptr rect; + CellWebBrowserRect rect; be_t resolution_factor; be_t magic_number_; }; diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp index 786e2a03f1..adcc418cdc 100644 --- a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp +++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp @@ -116,7 +116,7 @@ next: break; case vdecDecodeAu: { - memcpy(buf, Memory + vdec.reader.addr, vdec.reader.size); + memcpy(buf, vm::get_ptr(vdec.reader.addr), vdec.reader.size); buf += vdec.reader.size; buf_size -= vdec.reader.size; @@ -153,7 +153,7 @@ next: } else { - memcpy(buf, Memory + vdec.reader.addr, buf_size); + memcpy(buf, vm::get_ptr(vdec.reader.addr), buf_size); vdec.reader.addr += buf_size; vdec.reader.size -= buf_size; diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp index 7d73fba06f..5285525690 100644 --- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp +++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp @@ -142,83 +142,84 @@ int sys_raw_spu_image_load(int id, vm::ptr img) { sysPrxForUser->Warning("sys_raw_spu_image_load(id=0x%x, img_addr=0x%x)", id, img.addr()); - memcpy(Memory + (RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id), Memory + (u32)img->segs_addr, 256 * 1024); + // TODO: use segment info + memcpy(vm::get_ptr(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id), vm::get_ptr(img->segs_addr), 256 * 1024); Memory.Write32(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id + RAW_SPU_PROB_OFFSET + SPU_NPC_offs, (u32)img->entry_point); return CELL_OK; } -u32 _sys_memset(u32 addr, s32 value, u32 size) +vm::ptr _sys_memset(vm::ptr dst, s32 value, u32 size) { - sysPrxForUser->Log("_sys_memset(addr=0x%x, value=%d, size=%d)", addr, value, size); + sysPrxForUser->Log("_sys_memset(dst_addr=0x%x, value=%d, size=%d)", dst.addr(), value, size); - memset(Memory + addr, value, size); - return addr; + memset(dst.get_ptr(), value, size); + return dst; } -u32 _sys_memcpy(u32 dest, u32 source, u32 size) +vm::ptr _sys_memcpy(vm::ptr dst, vm::ptr src, u32 size) { - sysPrxForUser->Log("_sys_memcpy(dest=0x%x, source=0x%x, size=%d)", dest, source, size); + sysPrxForUser->Log("_sys_memcpy(dst_addr=0x%x, src_addr=0x%x, size=%d)", dst.addr(), src.addr(), size); - memcpy(Memory + dest, Memory + source, size); + memcpy(dst.get_ptr(), src.get_ptr(), size); + return dst; +} + +s32 _sys_memcmp(vm::ptr buf1, vm::ptr buf2, u32 size) +{ + sysPrxForUser->Log("_sys_memcmp(buf1_addr=0x%x, buf2_addr=0x%x, size=%d)", buf1.addr(), buf2.addr(), size); + + return memcmp(buf1.get_ptr(), buf2.get_ptr(), size); +} + +s64 _sys_strlen(vm::ptr str) +{ + sysPrxForUser->Log("_sys_strlen(str_addr=0x%x)", str.addr()); + + return strlen(str.get_ptr()); +} + +s32 _sys_strncmp(vm::ptr str1, vm::ptr str2, s32 max) +{ + sysPrxForUser->Log("_sys_strncmp(str1_addr=0x%x, str2_addr=0x%x, max=%d)", str1.addr(), str2.addr(), max); + + return strncmp(str1.get_ptr(), str2.get_ptr(), max); +} + +vm::ptr _sys_strcat(vm::ptr dest, vm::ptr source) +{ + sysPrxForUser->Log("_sys_strcat(dest_addr=0x%x, source_addr=0x%x)", dest.addr(), source.addr()); + + assert(strcat(dest.get_ptr(), source.get_ptr()) == dest.get_ptr()); return dest; } -s32 _sys_memcmp(u32 addr1, u32 addr2, u32 size) +vm::ptr _sys_strncat(vm::ptr dest, vm::ptr source, u32 len) { - sysPrxForUser->Log("_sys_memcmp(addr1=0x%x, addr2=0x%x, size=%d)", addr1, addr2, size); + sysPrxForUser->Log("_sys_strncat(dest_addr=0x%x, source_addr=0x%x, len=%d)", dest.addr(), source.addr(), len); - return memcmp(Memory + addr1, Memory + addr2, size); -} - -s64 _sys_strlen(u32 addr) -{ - sysPrxForUser->Log("_sys_strlen(addr=0x%x)", addr); - - return strlen((char*)(Memory + addr)); -} - -s32 _sys_strncmp(u32 str1, u32 str2, s32 max) -{ - sysPrxForUser->Log("_sys_strncmp(str1=0x%x, str2=0x%x, max=%d)", str1, str2, max); - - return strncmp((char*)(Memory + str1), (char*)(Memory + str2), max); -} - -u32 _sys_strcat(u32 dest, u32 source) -{ - sysPrxForUser->Log("_sys_strcat(dest=0x%x, source=0x%x)", dest, source); - - assert(Memory.RealToVirtualAddr(strcat((char*)(Memory + dest), (char*)(Memory + source))) == dest); + assert(strncat(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr()); return dest; } -u32 _sys_strncat(u32 dest, u32 source, u32 len) +vm::ptr _sys_strcpy(vm::ptr dest, vm::ptr source) { - sysPrxForUser->Log("_sys_strncat(dest=0x%x, source=0x%x, len=%d)", dest, source, len); + sysPrxForUser->Log("_sys_strcpy(dest_addr=0x%x, source_addr=0x%x)", dest.addr(), source.addr()); - assert(Memory.RealToVirtualAddr(strncat((char*)(Memory + dest), (char*)(Memory + source), len)) == dest); + assert(strcpy(dest.get_ptr(), source.get_ptr()) == dest.get_ptr()); return dest; } -u32 _sys_strcpy(u32 dest, u32 source) +vm::ptr _sys_strncpy(vm::ptr dest, vm::ptr source, u32 len) { - sysPrxForUser->Log("_sys_strcpy(dest=0x%x, source=0x%x)", dest, source); - - assert(Memory.RealToVirtualAddr(strcpy((char*)(Memory + dest), (char*)(Memory + source))) == dest); - return dest; -} - -u32 _sys_strncpy(u32 dest, u32 source, u32 len) -{ - sysPrxForUser->Log("_sys_strncpy(dest=0x%x, source=0x%x, len=%d)", dest, source, len); + sysPrxForUser->Log("_sys_strncpy(dest_addr=0x%x, source_addr=0x%x, len=%d)", dest.addr(), source.addr(), len); if (!dest || !source) { - return 0; + return vm::ptr::make(0); } - assert(Memory.RealToVirtualAddr(strncpy((char*)(Memory + dest), (char*)(Memory + source), len)) == dest); + assert(strncpy(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr()); return dest; } @@ -298,12 +299,12 @@ s64 _sys_spu_printf_detach_thread(u32 arg) return GetCurrentPPUThread().FastCall(Memory.Read32(spu_printf_dtcb), Memory.Read32(spu_printf_dtcb + 4), arg); } -s32 _sys_printf(u32 arg1) +s32 _sys_printf(vm::ptr fmt) { - sysPrxForUser->Todo("_sys_printf(arg1=0x%x)", arg1); + sysPrxForUser->Todo("_sys_printf(fmt_addr=0x%x, ...)", fmt.addr()); // probably, assertion failed - sysPrxForUser->Warning("_sys_printf: \n%s", (char*)(Memory + arg1)); + sysPrxForUser->Warning("_sys_printf: \n%s", fmt.get_ptr()); return CELL_OK; } diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h index 527549f990..6fa65c5d69 100644 --- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h +++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h @@ -15,4 +15,4 @@ struct HeapInfo }; // SysCalls -u32 _sys_memset(u32 addr, s32 value, u32 size); +vm::ptr _sys_memset(vm::ptr dst, s32 value, u32 size); diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp index 94e784b60e..b2d6da9860 100644 --- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp +++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp @@ -595,7 +595,7 @@ s32 cellFsStReadInit(u32 fd, vm::ptr ringbuf) // alloc memory fs_config.m_buffer = (u32)Memory.Alloc(fs_config.m_alloc_mem_size, 1024); - memset(Memory + fs_config.m_buffer, 0, fs_config.m_alloc_mem_size); + memset(vm::get_ptr(fs_config.m_buffer), 0, fs_config.m_alloc_mem_size); fs_config.m_fs_status = CELL_FS_ST_INITIALIZED; diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event.cpp index bb6f0e5f89..76a73b0f26 100644 --- a/rpcs3/Emu/SysCalls/lv2/sys_event.cpp +++ b/rpcs3/Emu/SysCalls/lv2/sys_event.cpp @@ -135,7 +135,7 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr event_arra eq->sq.m_mutex.unlock(); return CELL_OK; } - *number = eq->events.pop_all((sys_event_data*)(Memory + event_array.addr()), size); + *number = eq->events.pop_all(event_array.get_ptr(), size); eq->owner.unlock(tid); eq->sq.m_mutex.unlock(); return CELL_OK; diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp index d0560297f6..f18236a937 100644 --- a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp +++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp @@ -80,9 +80,10 @@ s32 sys_spu_thread_initialize(vm::ptr> thread, u32 group, u32 spu_num, u64 a3 = arg->arg3; u64 a4 = arg->arg4; - //copy SPU image: - auto spu_offset = Memory.MainMem.AllocAlign(256 * 1024); - memcpy(Memory + spu_offset, Memory + (u32)img->segs_addr, 256 * 1024); + // Copy SPU image: + // TODO: use correct segment info + auto spu_offset = Memory.Alloc(256 * 1024, 4096); + memcpy(vm::get_ptr(spu_offset), vm::get_ptr(img->segs_addr), 256 * 1024); CPUThread& new_thread = Emu.GetCPU().AddThread(CPU_THREAD_SPU); //initialize from new place: @@ -174,8 +175,12 @@ s32 sys_spu_thread_group_destroy(u32 id) for (u32 i = 0; i < group_info->list.size(); i++) { // TODO: disconnect all event ports - - Emu.GetCPU().RemoveThread(group_info->list[i]); + CPUThread* t = Emu.GetCPU().GetThread(group_info->list[i]); + if (t) + { + Memory.Free(((SPUThread*)t)->GetOffset()); + Emu.GetCPU().RemoveThread(group_info->list[i]); + } } group_info->m_state = SPU_THREAD_GROUP_STATUS_UNKNOWN;