archive/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-07-05 06:21:26 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions

MemoryBase::operator+ replaced

Browse source
This commit is contained in:
Nekotekina 2014-09-06 00:26:36 +04:00
parent feec20ac3e
commit db9cbe6cdd
24 changed files with 209 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

6
rpcs3/Emu/Cell/PPUInterpreter.h
View file

@ -2635,7 +2635,8 @@ private:
if (CPU.R_ADDR == addr) 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<volatile u32>(addr), re32((u32)CPU.GPR[rs]), (u32)CPU.R_VALUE) == (u32)CPU.R_VALUE);
CPU.R_ADDR = 0;
} }
else else
{ {
@ -2692,7 +2693,8 @@ private:
if (CPU.R_ADDR == addr) 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<volatile u64>(addr), re64(CPU.GPR[rs]), CPU.R_VALUE) == CPU.R_VALUE);
CPU.R_ADDR = 0;
} }
else else
{ {

6
rpcs3/Emu/Cell/SPUThread.cpp
View file

@ -244,13 +244,13 @@ void SPUThread::ProcessCmd(u32 cmd, u32 tag, u32 lsa, u64 ea, u32 size)
{ {
case MFC_PUT_CMD: case MFC_PUT_CMD:
{ {
memcpy(Memory + ea, Memory + (dmac.ls_offset + lsa), size); memcpy(vm::get_ptr<void>(ea), vm::get_ptr<void>(dmac.ls_offset + lsa), size);
return; return;
} }
case MFC_GET_CMD: case MFC_GET_CMD:
{ {
memcpy(Memory + (dmac.ls_offset + lsa), Memory + ea, size); memcpy(vm::get_ptr<void>(dmac.ls_offset + lsa), vm::get_ptr<void>(ea), size);
return; return;
} }
@ -423,7 +423,7 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs)
{ {
if (buf[i] != R_DATA[i]) 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<volatile u64>(ea)[i], buf[i], R_DATA[i]) != R_DATA[i])
{ {
m_events |= SPU_EVENT_LR; m_events |= SPU_EVENT_LR;
MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE); MFCArgs.AtomicStat.PushUncond(MFC_PUTLLC_FAILURE);

4
rpcs3/Emu/FS/vfsStreamMemory.cpp
View file

@ -31,7 +31,7 @@ u64 vfsStreamMemory::Write(const void* src, u64 size)
size = GetSize() - Tell(); size = GetSize() - Tell();
} }
memcpy(Memory + (m_addr + Tell()), (void*)src, size); memcpy(vm::get_ptr<void>(m_addr + Tell()), src, size);
return vfsStream::Write(src, size); return vfsStream::Write(src, size);
} }
@ -43,7 +43,7 @@ u64 vfsStreamMemory::Read(void* dst, u64 size)
size = GetSize() - Tell(); size = GetSize() - Tell();
} }
memcpy(dst, Memory + (m_addr + Tell()), size); memcpy(dst, vm::get_ptr<void>(m_addr + Tell()), size);
return vfsStream::Read(dst, size); return vfsStream::Read(dst, size);
} }

30
rpcs3/Emu/Memory/Memory.h
View file

@ -95,19 +95,6 @@ public:
void UnregisterPages(u64 addr, u32 size); void UnregisterPages(u64 addr, u32 size);
template<typename T> 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) u32 RealToVirtualAddr(const void* addr)
{ {
const u64 res = (u64)addr - (u64)GetBaseAddr(); const u64 res = (u64)addr - (u64)GetBaseAddr();
@ -332,14 +319,17 @@ public:
bool Unmap(const u64 addr); bool Unmap(const u64 addr);
template<typename T> void* operator + (const T vaddr) template<typename T> u8& operator[] (const T addr)
{ {
return GetMemFromAddr<T>(vaddr); if ((u32)addr == addr)
} {
return *((u8*)GetBaseAddr() + addr);
template<typename T> u8& operator[] (const T vaddr) }
{ else
return *GetMemFromAddr<T>(vaddr); {
InvalidAddress(__FUNCTION__, addr);
return *(u8*)GetBaseAddr();
}
} }
}; };

4
rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
View file

@ -116,7 +116,7 @@ next:
break; break;
case adecDecodeAu: case adecDecodeAu:
{ {
memcpy(buf, Memory + adec.reader.addr, adec.reader.size); memcpy(buf, vm::get_ptr<void>(adec.reader.addr), adec.reader.size);
buf += adec.reader.size; buf += adec.reader.size;
buf_size -= adec.reader.size; buf_size -= adec.reader.size;
@ -149,7 +149,7 @@ next:
} }
else else
{ {
memcpy(buf, Memory + adec.reader.addr, buf_size); memcpy(buf, vm::get_ptr<void>(adec.reader.addr), buf_size);
adec.reader.addr += buf_size; adec.reader.addr += buf_size;
adec.reader.size -= buf_size; adec.reader.size -= buf_size;

4
rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
View file

@ -40,9 +40,9 @@ int cellAudioInit()
// alloc memory // alloc memory
m_config.m_buffer = (u32)Memory.Alloc(128 * 1024 * m_config.AUDIO_PORT_COUNT, 1024); 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<void>(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); 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<void>(m_config.m_indexes), 0, sizeof(u64) * m_config.AUDIO_PORT_COUNT);
thread t("Audio Thread", []() thread t("Audio Thread", []()
{ {

2
rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
View file

@ -156,7 +156,7 @@ void ElementaryStream::push(DemuxerStream& stream, u32 sz, PesHeader& pes)
u32 data_addr = put + 128 + size; u32 data_addr = put + 128 + size;
size += sz; size += sz;
memcpy(Memory + data_addr, Memory + stream.addr, sz); memcpy(vm::get_ptr<void>(data_addr), vm::get_ptr<void>(stream.addr), sz);
stream.skip(sz); stream.skip(sz);
auto info = vm::ptr<CellDmuxAuInfoEx>::make(put); auto info = vm::ptr<CellDmuxAuInfoEx>::make(put);

8
rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
View file

@ -68,8 +68,8 @@ void InitOffsetTable()
offsetTable.ioAddress = (u32)Memory.Alloc(3072 * sizeof(u16), 1); offsetTable.ioAddress = (u32)Memory.Alloc(3072 * sizeof(u16), 1);
offsetTable.eaAddress = (u32)Memory.Alloc(512 * sizeof(u16), 1); offsetTable.eaAddress = (u32)Memory.Alloc(512 * sizeof(u16), 1);
_sys_memset(offsetTable.ioAddress, 0xFF, 3072 * sizeof(u16)); memset(vm::get_ptr<void>(offsetTable.ioAddress), 0xFF, 3072 * sizeof(u16));
_sys_memset(offsetTable.eaAddress, 0xFF, 512 * sizeof(u16)); memset(vm::get_ptr<void>(offsetTable.eaAddress), 0xFF, 512 * sizeof(u16));
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -514,7 +514,7 @@ s32 cellGcmSetPrepareFlip(vm::ptr<CellGcmContextData> ctxt, u32 id)
const s32 res = ctxt->current - ctxt->begin - ctrl.put; const s32 res = ctxt->current - ctxt->begin - ctrl.put;
memmove(Memory + ctxt->begin, Memory + (ctxt->current - res), res); memmove(vm::get_ptr<void>(ctxt->begin), vm::get_ptr<void>(ctxt->current - res), res);
ctxt->current = ctxt->begin + 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; const s32 res = ctx.current - ctx.begin - ctrl.put;
memmove(Memory + ctx.begin, Memory + (ctx.current - res), res); memmove(vm::get_ptr<void>(ctx.begin), vm::get_ptr<void>(ctx.current - res), res);
ctx.current = ctx.begin + res; ctx.current = ctx.begin + res;

10
rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
View file

@ -79,7 +79,7 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellGifDecInfo>
switch(subHandle_data->src.srcSelect.ToBE()) switch(subHandle_data->src.srcSelect.ToBE())
{ {
case se32(CELL_GIFDEC_BUFFER): case se32(CELL_GIFDEC_BUFFER):
memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size()); memmove(buffer.begin(), vm::get_ptr<void>(subHandle_data->src.streamPtr), buffer.size());
break; break;
case se32(CELL_GIFDEC_FILE): case se32(CELL_GIFDEC_FILE):
@ -161,7 +161,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
switch(subHandle_data->src.srcSelect.ToBE()) switch(subHandle_data->src.srcSelect.ToBE())
{ {
case se32(CELL_GIFDEC_BUFFER): case se32(CELL_GIFDEC_BUFFER):
memmove(Memory + gif.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), gif.size()); memmove(gif.begin(), vm::get_ptr<void>(subHandle_data->src.streamPtr), gif.size());
break; break;
case se32(CELL_GIFDEC_FILE): case se32(CELL_GIFDEC_FILE):
@ -196,12 +196,12 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
{ {
const int dstOffset = i * bytesPerLine; const int dstOffset = i * bytesPerLine;
const int srcOffset = width * nComponents * i; const int srcOffset = width * nComponents * i;
memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize); memcpy(&data[dstOffset], &image.get()[srcOffset], linesize);
} }
} }
else else
{ {
memcpy(Memory + data.addr(), image.get(), image_size); memcpy(data.get_ptr(), image.get(), image_size);
} }
} }
break; break;
@ -224,7 +224,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
output[j + 2] = image.get()[srcOffset + j + 1]; output[j + 2] = image.get()[srcOffset + j + 1];
output[j + 3] = image.get()[srcOffset + j + 2]; output[j + 3] = image.get()[srcOffset + j + 2];
} }
memcpy(Memory + (data.addr() + dstOffset), output, linesize); memcpy(&data[dstOffset], output, linesize);
} }
free(output); free(output);
} }

10
rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
View file

@ -99,7 +99,7 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellJpgDecInfo>
switch(subHandle_data->src.srcSelect.ToBE()) switch(subHandle_data->src.srcSelect.ToBE())
{ {
case se32(CELL_JPGDEC_BUFFER): case se32(CELL_JPGDEC_BUFFER):
memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size()); memmove(buffer.begin(), vm::get_ptr<void>(subHandle_data->src.streamPtr), buffer.size());
break; break;
case se32(CELL_JPGDEC_FILE): case se32(CELL_JPGDEC_FILE):
@ -168,7 +168,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
switch(subHandle_data->src.srcSelect.ToBE()) switch(subHandle_data->src.srcSelect.ToBE())
{ {
case se32(CELL_JPGDEC_BUFFER): case se32(CELL_JPGDEC_BUFFER):
memmove(Memory + jpg.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), jpg.size()); memmove(jpg.begin(), vm::get_ptr<void>(subHandle_data->src.streamPtr), jpg.size());
break; break;
case se32(CELL_JPGDEC_FILE): case se32(CELL_JPGDEC_FILE):
@ -206,12 +206,12 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
{ {
const int dstOffset = i * bytesPerLine; const int dstOffset = i * bytesPerLine;
const int srcOffset = width * nComponents * (flip ? height - i - 1 : i); 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 else
{ {
memcpy(Memory + data.addr(), image.get(), image_size); memcpy(data.get_ptr(), image.get(), image_size);
} }
} }
break; break;
@ -236,7 +236,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
output[j + 2] = image.get()[srcOffset + j + 1]; output[j + 2] = image.get()[srcOffset + j + 1];
output[j + 3] = image.get()[srcOffset + j + 2]; output[j + 3] = image.get()[srcOffset + j + 2];
} }
memcpy(Memory + (data.addr() + dstOffset), output, linesize); memcpy(&data[dstOffset], output, linesize);
} }
free(output); free(output);
} }

4
rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
View file

@ -388,11 +388,11 @@ int cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodec
int cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> pSelf, u32 pInfo_addr, u32 size) int cellPamfReaderGetStreamInfo(vm::ptr<CellPamfReader> 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<const PamfHeader> pAddr(pSelf->pAddr); vm::ptr<const PamfHeader> pAddr(pSelf->pAddr);
memset(Memory + pInfo_addr, 0, size); memset(vm::get_ptr<void>(pInfo_addr), 0, size);
switch (pamfGetStreamType(pSelf, pSelf->stream)) switch (pamfGetStreamType(pSelf, pSelf->stream))
{ {

10
rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
View file

@ -140,7 +140,7 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellPngDecInfo>
switch(subHandle_data->src.srcSelect.ToBE()) switch(subHandle_data->src.srcSelect.ToBE())
{ {
case se32(CELL_PNGDEC_BUFFER): case se32(CELL_PNGDEC_BUFFER):
memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size()); memmove(buffer.begin(), vm::get_ptr<void>(subHandle_data->src.streamPtr), buffer.size());
break; break;
case se32(CELL_PNGDEC_FILE): case se32(CELL_PNGDEC_FILE):
cellFsLseek(fd, 0, CELL_SEEK_SET, pos); cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
@ -205,7 +205,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
switch(subHandle_data->src.srcSelect.ToBE()) switch(subHandle_data->src.srcSelect.ToBE())
{ {
case se32(CELL_PNGDEC_BUFFER): case se32(CELL_PNGDEC_BUFFER):
memmove(Memory + png.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), png.size()); memmove(png.begin(), vm::get_ptr<void>(subHandle_data->src.streamPtr), png.size());
break; break;
case se32(CELL_PNGDEC_FILE): case se32(CELL_PNGDEC_FILE):
@ -241,12 +241,12 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
{ {
const int dstOffset = i * bytesPerLine; const int dstOffset = i * bytesPerLine;
const int srcOffset = width * nComponents * (flip ? height - i - 1 : i); 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 else
{ {
memcpy(Memory + data.addr(), image.get(), image_size); memcpy(data.get_ptr(), image.get(), image_size);
} }
} }
break; break;
@ -271,7 +271,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, vm::pt
output[j + 2] = image.get()[srcOffset + j + 1]; output[j + 2] = image.get()[srcOffset + j + 1];
output[j + 3] = image.get()[srcOffset + j + 2]; output[j + 3] = image.get()[srcOffset + j + 2];
} }
memcpy(Memory + (data.addr() + dstOffset), output, linesize); memcpy(&data[dstOffset], output, linesize);
} }
free(output); free(output);
} }

6
rpcs3/Emu/SysCalls/Modules/cellSpurs.h
View file

@ -194,11 +194,11 @@ struct CellSpursTracePacket
}; };
// Exception handlers. // Exception handlers.
//typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr<CellSpurs> spurs, const vm::ptr<CellSpursExceptionInfo> info, //typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr<CellSpurs> spurs, vm::ptr<const CellSpursExceptionInfo> info,
// u32 id, vm::ptr<void> arg); // u32 id, vm::ptr<void> arg);
// //
//typedef void (*CellSpursTasksetExceptionEventHandler)(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, //typedef void (*CellSpursTasksetExceptionEventHandler)(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset,
// u32 idTask, const vm::ptr<CellSpursExceptionInfo> info, vm::ptr<void> arg); // u32 idTask, vm::ptr<const CellSpursExceptionInfo> info, vm::ptr<void> arg);
struct CellSpursTasksetInfo struct CellSpursTasksetInfo
{ {

2
rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
View file

@ -765,7 +765,7 @@ void cellSpursJq_init()
CallAfter([]() CallAfter([]()
{ {
libspurs_jq = (u32)Memory.PRXMem.AllocAlign(sizeof(libspurs_jq_data), 4096); 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<void>(libspurs_jq), libspurs_jq_data, sizeof(libspurs_jq_data));
libspurs_jq_rtoc = libspurs_jq + 0x17E80; libspurs_jq_rtoc = libspurs_jq + 0x17E80;
extern Module* sysPrxForUser; extern Module* sysPrxForUser;

169
rpcs3/Emu/SysCalls/Modules/cellSync.cpp
View file

@ -346,13 +346,13 @@ s32 cellSyncBarrierTryWait(vm::ptr<CellSyncBarrier> barrier)
return CELL_OK; return CELL_OK;
} }
s32 syncRwmInitialize(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size) s32 syncRwmInitialize(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer, u32 buffer_size)
{ {
if (!rwm || !buffer_addr) if (!rwm || !buffer)
{ {
return CELL_SYNC_ERROR_NULL_POINTER; 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; return CELL_SYNC_ERROR_ALIGN;
} }
@ -364,23 +364,23 @@ s32 syncRwmInitialize(vm::ptr<CellSyncRwm> 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 // 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_data() = 0;
rwm->m_size = buffer_size; rwm->m_size = buffer_size;
rwm->m_addr = (u64)buffer_addr; rwm->m_buffer = buffer;
InterlockedCompareExchange(&rwm->m_data(), 0, 0); InterlockedCompareExchange(&rwm->m_data(), 0, 0);
return CELL_OK; return CELL_OK;
} }
s32 cellSyncRwmInitialize(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size) s32 cellSyncRwmInitialize(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> 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<CellSyncRwm> rwm, u32 buffer_addr) s32 cellSyncRwmRead(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -412,7 +412,7 @@ s32 cellSyncRwmRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
} }
// copy data to 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 // prx: load first u32, return 0x8041010C if first u16 == 0, atomically decrease it
while (true) while (true)
@ -433,11 +433,11 @@ s32 cellSyncRwmRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr) s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -461,7 +461,7 @@ s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
if (InterlockedCompareExchange(&rwm->m_data(), new_rwm.m_data(), old_data) == old_data) break; 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) while (true)
{ {
@ -481,11 +481,11 @@ s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr) s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, vm::ptr<const void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -528,7 +528,7 @@ s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
} }
// prx: copy data from 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 // prx: sync and zeroize m_readers and m_writers
InterlockedCompareExchange(&rwm->m_data(), 0, 0); InterlockedCompareExchange(&rwm->m_data(), 0, 0);
@ -536,11 +536,11 @@ s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr) s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, vm::ptr<const void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -553,7 +553,7 @@ s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
if (InterlockedCompareExchange(&rwm->m_data(), se32(1), 0) != 0) return CELL_SYNC_ERROR_BUSY; if (InterlockedCompareExchange(&rwm->m_data(), se32(1), 0) != 0) return CELL_SYNC_ERROR_BUSY;
// prx: copy data from 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 // prx: sync and zeroize m_readers and m_writers
InterlockedCompareExchange(&rwm->m_data(), 0, 0); InterlockedCompareExchange(&rwm->m_data(), 0, 0);
@ -561,17 +561,17 @@ s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth) s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth)
{ {
if (!queue) if (!queue)
{ {
return CELL_SYNC_ERROR_NULL_POINTER; return CELL_SYNC_ERROR_NULL_POINTER;
} }
if (size && !buffer_addr) if (size && !buffer)
{ {
return CELL_SYNC_ERROR_NULL_POINTER; 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; return CELL_SYNC_ERROR_ALIGN;
} }
@ -584,23 +584,23 @@ s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size,
queue->m_data() = 0; queue->m_data() = 0;
queue->m_size = size; queue->m_size = size;
queue->m_depth = depth; queue->m_depth = depth;
queue->m_addr = (u64)buffer_addr; queue->m_buffer = buffer;
InterlockedCompareExchange(&queue->m_data(), 0, 0); InterlockedCompareExchange(&queue->m_data(), 0, 0);
return CELL_OK; return CELL_OK;
} }
s32 cellSyncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth) s32 cellSyncQueueInitialize(vm::ptr<CellSyncQueue> queue, vm::ptr<u8> 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<CellSyncQueue> queue, u32 buffer_addr) s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, vm::ptr<const void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -645,7 +645,7 @@ s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
} }
// prx: memcpy(position * m_size + m_addr, buffer_addr, m_size), sync // 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 // prx: atomically insert 0 in 5th u8
while (true) while (true)
@ -660,11 +660,11 @@ s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr) s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, vm::ptr<const void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -697,7 +697,7 @@ s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; 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) while (true)
{ {
@ -711,11 +711,11 @@ s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncQueuePop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr) s32 cellSyncQueuePop(vm::ptr<CellSyncQueue> queue, vm::ptr<void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -760,7 +760,7 @@ s32 cellSyncQueuePop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
} }
// prx: (sync), memcpy(buffer_addr, position * m_size + m_addr, m_size) // 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 // prx: atomically insert 0 in first u8
while (true) while (true)
@ -775,11 +775,11 @@ s32 cellSyncQueuePop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr) s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, vm::ptr<void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -812,7 +812,7 @@ s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; 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) while (true)
{ {
@ -826,11 +826,11 @@ s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncQueuePeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr) s32 cellSyncQueuePeek(vm::ptr<CellSyncQueue> queue, vm::ptr<void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -868,7 +868,7 @@ s32 cellSyncQueuePeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; 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) while (true)
{ {
@ -882,11 +882,11 @@ s32 cellSyncQueuePeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
return CELL_OK; return CELL_OK;
} }
s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr) s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, vm::ptr<void> 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; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -918,7 +918,7 @@ s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
if (InterlockedCompareExchange(&queue->m_data(), new_queue.m_data(), old_data) == old_data) break; 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) while (true)
{ {
@ -1029,7 +1029,7 @@ void syncLFQueueDump(vm::ptr<CellSyncLFQueue> queue)
} }
} }
void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr<void> eaSignal)
{ {
queue->m_h1 = 0; queue->m_h1 = 0;
queue->m_h2 = 0; queue->m_h2 = 0;
@ -1039,19 +1039,20 @@ void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size,
queue->m_h8 = 0; queue->m_h8 = 0;
queue->m_size = size; queue->m_size = size;
queue->m_depth = depth; queue->m_depth = depth;
queue->m_buffer = (u64)buffer_addr; queue->m_buffer = buffer;
queue->m_direction = direction; queue->m_direction = direction;
for (u32 i = 0; i < sizeof(queue->m_hs) / sizeof(queue->m_hs[0]); i++) for (u32 i = 0; i < sizeof(queue->m_hs) / sizeof(queue->m_hs[0]); i++)
{ {
queue->m_hs[i] = 0; queue->m_hs[i] = 0;
} }
queue->m_eaSignal = (u64)eaSignal_addr; queue->m_eaSignal = eaSignal;
if (direction == CELL_SYNC_QUEUE_ANY2ANY) if (direction == CELL_SYNC_QUEUE_ANY2ANY)
{ {
queue->m_h3 = 0; queue->m_h3 = 0;
queue->m_h7 = 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[0] = -1;
queue->m_bs[1] = -1; queue->m_bs[1] = -1;
//m_bs[2] //m_bs[2]
@ -1076,7 +1077,7 @@ void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size,
} }
} }
s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr<void> eaSignal)
{ {
#ifdef PRX_DEBUG_XXX #ifdef PRX_DEBUG_XXX
return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.addr(), buffer_addr, size, depth, direction, eaSignal_addr); return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.addr(), buffer_addr, size, depth, direction, eaSignal_addr);
@ -1088,7 +1089,7 @@ s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 s
} }
if (size) if (size)
{ {
if (!buffer_addr) if (!buffer)
{ {
return CELL_SYNC_ERROR_NULL_POINTER; return CELL_SYNC_ERROR_NULL_POINTER;
} }
@ -1101,7 +1102,7 @@ s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 s
{ {
return CELL_SYNC_ERROR_INVAL; return CELL_SYNC_ERROR_INVAL;
} }
if (queue.addr() % 128 || buffer_addr % 16) if (queue.addr() % 128 || buffer.addr() % 16)
{ {
return CELL_SYNC_ERROR_ALIGN; return CELL_SYNC_ERROR_ALIGN;
} }
@ -1155,13 +1156,13 @@ s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 s
if (old_value == se32(2)) 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; return CELL_SYNC_ERROR_INVAL;
} }
if (sdk_ver > 0x17ffff) 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; return CELL_SYNC_ERROR_INVAL;
} }
@ -1170,7 +1171,7 @@ s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 s
else else
{ {
// prx: call internal function with same arguments // 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 // prx: sync, zeroize u32 at 0x2c offset
InterlockedCompareExchange(&queue->m_data(), 0, 0); InterlockedCompareExchange(&queue->m_data(), 0, 0);
@ -1183,12 +1184,12 @@ s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 s
#endif #endif
} }
s32 cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr) s32 cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr<void> eaSignal)
{ {
cellSync->Warning("cellSyncLFQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x, direction=%d, eaSignal_addr=0x%x)", 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<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue) s32 syncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
@ -1451,7 +1452,7 @@ s32 syncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer,
if (exch) if (exch)
{ {
assert(fpSendSignal); assert(fpSendSignal);
return fpSendSignal((u32)queue->m_eaSignal, var6); return fpSendSignal((u32)queue->m_eaSignal.addr(), var6);
} }
} }
else else
@ -1496,16 +1497,16 @@ s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 poi
return syncLFQueueCompletePushPointer2(queue, pointer, fpSendSignal); return syncLFQueueCompletePushPointer2(queue, pointer, fpSendSignal);
} }
s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 isBlocking) s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<const void> buffer, u32 isBlocking)
{ {
// cellSyncLFQueuePush has 1 in isBlocking param, cellSyncLFQueueTryPush has 0 // 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; 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; return CELL_SYNC_ERROR_ALIGN;
} }
@ -1561,7 +1562,7 @@ s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u3
s32 depth = (u32)queue->m_depth; s32 depth = (u32)queue->m_depth;
s32 size = (u32)queue->m_size; 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<void>((queue->m_buffer.addr() & ~1ull) + size * (position >= depth ? position - depth : position)), buffer.get_ptr(), size);
s32 res; s32 res;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
@ -1844,7 +1845,7 @@ s32 syncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, c
if (exch) if (exch)
{ {
assert(fpSendSignal); assert(fpSendSignal);
return fpSendSignal((u32)queue->m_eaSignal, var6); return fpSendSignal((u32)queue->m_eaSignal.addr(), var6);
} }
} }
else else
@ -1890,16 +1891,16 @@ s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 poin
return syncLFQueueCompletePopPointer2(queue, pointer, fpSendSignal, noQueueFull); return syncLFQueueCompletePopPointer2(queue, pointer, fpSendSignal, noQueueFull);
} }
s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 isBlocking) s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, vm::ptr<void> buffer, u32 isBlocking)
{ {
// cellSyncLFQueuePop has 1 in isBlocking param, cellSyncLFQueueTryPop has 0 // 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; 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; return CELL_SYNC_ERROR_ALIGN;
} }
@ -1949,7 +1950,7 @@ s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32
s32 depth = (u32)queue->m_depth; s32 depth = (u32)queue->m_depth;
s32 size = (u32)queue->m_size; 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<void>((queue->m_buffer.addr() & ~1ull) + size * (position >= depth ? position - depth : position)), size);
s32 res; s32 res;
if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY)) if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
@ -2075,7 +2076,7 @@ s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> dept
return CELL_OK; return CELL_OK;
} }
s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> ppSignal) s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<be_t<u32>> ppSignal)
{ {
cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.addr()); cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.addr());
@ -2088,11 +2089,11 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_
return CELL_SYNC_ERROR_ALIGN; return CELL_SYNC_ERROR_ALIGN;
} }
*ppSignal = (u32)queue->m_eaSignal; *ppSignal = (u32)queue->m_eaSignal.addr();
return CELL_OK; return CELL_OK;
} }
s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<CellSyncQueueDirection>> direction) s32 cellSyncLFQueueGetDirection(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<be_t<CellSyncQueueDirection>> direction)
{ {
cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.addr()); cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.addr());
@ -2109,7 +2110,7 @@ s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<Cel
return CELL_OK; return CELL_OK;
} }
s32 cellSyncLFQueueGetEntrySize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> entry_size) s32 cellSyncLFQueueGetEntrySize(vm::ptr<const CellSyncLFQueue> queue, vm::ptr<be_t<u32>> entry_size)
{ {
cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.addr(), entry_size.addr()); 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([]() CallAfter([]()
{ {
libsre = (u32)Memory.PRXMem.AllocAlign(sizeof(libsre_data), 4096); libsre = (u32)Memory.PRXMem.AllocAlign(sizeof(libsre_data), 4096);
memcpy(Memory + libsre, libsre_data, sizeof(libsre_data)); memcpy(vm::get_ptr<void>(libsre), libsre_data, sizeof(libsre_data));
libsre_rtoc = libsre + 0x399B0; libsre_rtoc = libsre + 0x399B0;
extern Module* sysPrxForUser; extern Module* sysPrxForUser;

14
rpcs3/Emu/SysCalls/Modules/cellSync.h
View file

@ -60,7 +60,7 @@ struct CellSyncRwm
be_t<u16> m_readers; be_t<u16> m_readers;
be_t<u16> m_writers; be_t<u16> m_writers;
be_t<u32> m_size; be_t<u32> m_size;
be_t<u64> m_addr; vm::bptr<void, 1, u64> m_buffer;
volatile u32& m_data() volatile u32& m_data()
{ {
@ -76,7 +76,7 @@ struct CellSyncQueue
be_t<u32> m_v2; be_t<u32> m_v2;
be_t<u32> m_size; be_t<u32> m_size;
be_t<u32> m_depth; be_t<u32> m_depth;
be_t<u64> m_addr; vm::bptr<u8, 1, u64> m_buffer;
be_t<u64> reserved; be_t<u64> reserved;
volatile u64& m_data() volatile u64& m_data()
@ -107,13 +107,13 @@ struct CellSyncLFQueue
be_t<u16> m_h8; // 0xE be_t<u16> m_h8; // 0xE
be_t<u32> m_size; // 0x10 be_t<u32> m_size; // 0x10
be_t<u32> m_depth; // 0x14 be_t<u32> m_depth; // 0x14
be_t<u64> m_buffer; // 0x18 vm::bptr<u8, 1, u64> m_buffer; // 0x18
u8 m_bs[4]; // 0x20 u8 m_bs[4]; // 0x20
be_t<CellSyncQueueDirection> m_direction; // 0x24 be_t<CellSyncQueueDirection> m_direction; // 0x24
be_t<u32> m_v1; // 0x28 be_t<u32> m_v1; // 0x28
be_t<u32> m_sync; // 0x2C be_t<u32> m_sync; // 0x2C
be_t<u16> m_hs[32]; // 0x30 be_t<u16> m_hs[32]; // 0x30
be_t<u64> m_eaSignal;// 0x70 vm::bptr<void, 1, u64> m_eaSignal; // 0x70
be_t<u32> m_v2; // 0x78 be_t<u32> m_v2; // 0x78
be_t<u32> m_v3; // 0x7C be_t<u32> m_v3; // 0x7C
@ -159,11 +159,11 @@ s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex);
s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count); s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count);
s32 syncRwmInitialize(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size); s32 syncRwmInitialize(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer, u32 buffer_size);
s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth); s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth);
s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr); s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<u8> buffer, u32 size, u32 depth, CellSyncQueueDirection direction, vm::ptr<void> eaSignal);
s32 syncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue); s32 syncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue);
s32 syncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue); s32 syncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue);
s32 syncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal); s32 syncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal);

2
rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
View file

@ -409,7 +409,7 @@ void cellSync2_init()
CallAfter([]() CallAfter([]()
{ {
libsync2 = (u32)Memory.PRXMem.AllocAlign(sizeof(libsync2_data), 4096); libsync2 = (u32)Memory.PRXMem.AllocAlign(sizeof(libsync2_data), 4096);
memcpy(Memory + libsync2, libsync2_data, sizeof(libsync2_data)); memcpy(vm::get_ptr<void>(libsync2), libsync2_data, sizeof(libsync2_data));
libsync2_rtoc = libsync2 + 0xF280; libsync2_rtoc = libsync2 + 0xF280;
extern Module* sysPrxForUser; extern Module* sysPrxForUser;

2
rpcs3/Emu/SysCalls/Modules/cellSysutil.h
View file

@ -279,7 +279,7 @@ struct CellWebBrowserConfig2
vm::bptr<CellWebBrowserStatusCallback> status_error_cb; vm::bptr<CellWebBrowserStatusCallback> status_error_cb;
vm::bptr<CellWebBrowserNotify> notify_cb; vm::bptr<CellWebBrowserNotify> notify_cb;
vm::bptr<CellWebBrowserCallback> request_cb; vm::bptr<CellWebBrowserCallback> request_cb;
vm::bptr<CellWebBrowserRect> rect; CellWebBrowserRect rect;
be_t<float> resolution_factor; be_t<float> resolution_factor;
be_t<s32> magic_number_; be_t<s32> magic_number_;
}; };

4
rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
View file

@ -116,7 +116,7 @@ next:
break; break;
case vdecDecodeAu: case vdecDecodeAu:
{ {
memcpy(buf, Memory + vdec.reader.addr, vdec.reader.size); memcpy(buf, vm::get_ptr<void>(vdec.reader.addr), vdec.reader.size);
buf += vdec.reader.size; buf += vdec.reader.size;
buf_size -= vdec.reader.size; buf_size -= vdec.reader.size;
@ -153,7 +153,7 @@ next:
} }
else else
{ {
memcpy(buf, Memory + vdec.reader.addr, buf_size); memcpy(buf, vm::get_ptr<void>(vdec.reader.addr), buf_size);
vdec.reader.addr += buf_size; vdec.reader.addr += buf_size;
vdec.reader.size -= buf_size; vdec.reader.size -= buf_size;

101
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
View file

@ -142,83 +142,84 @@ int sys_raw_spu_image_load(int id, vm::ptr<sys_spu_image> img)
{ {
sysPrxForUser->Warning("sys_raw_spu_image_load(id=0x%x, img_addr=0x%x)", id, img.addr()); 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<void>(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id), vm::get_ptr<void>(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); Memory.Write32(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id + RAW_SPU_PROB_OFFSET + SPU_NPC_offs, (u32)img->entry_point);
return CELL_OK; return CELL_OK;
} }
u32 _sys_memset(u32 addr, s32 value, u32 size) vm::ptr<void> _sys_memset(vm::ptr<void> 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); memset(dst.get_ptr(), value, size);
return addr; return dst;
} }
u32 _sys_memcpy(u32 dest, u32 source, u32 size) vm::ptr<void> _sys_memcpy(vm::ptr<void> dst, vm::ptr<const void> 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<const void> buf1, vm::ptr<const void> 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<const char> str)
{
sysPrxForUser->Log("_sys_strlen(str_addr=0x%x)", str.addr());
return strlen(str.get_ptr());
}
s32 _sys_strncmp(vm::ptr<const char> str1, vm::ptr<const char> 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<char> _sys_strcat(vm::ptr<char> dest, vm::ptr<const char> 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; return dest;
} }
s32 _sys_memcmp(u32 addr1, u32 addr2, u32 size) vm::ptr<char> _sys_strncat(vm::ptr<char> dest, vm::ptr<const char> 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); assert(strncat(dest.get_ptr(), source.get_ptr(), len) == dest.get_ptr());
}
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);
return dest; return dest;
} }
u32 _sys_strncat(u32 dest, u32 source, u32 len) vm::ptr<char> _sys_strcpy(vm::ptr<char> dest, vm::ptr<const char> 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; return dest;
} }
u32 _sys_strcpy(u32 dest, u32 source) vm::ptr<char> _sys_strncpy(vm::ptr<char> dest, vm::ptr<const char> source, u32 len)
{ {
sysPrxForUser->Log("_sys_strcpy(dest=0x%x, source=0x%x)", dest, source); sysPrxForUser->Log("_sys_strncpy(dest_addr=0x%x, source_addr=0x%x, len=%d)", dest.addr(), source.addr(), len);
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);
if (!dest || !source) if (!dest || !source)
{ {
return 0; return vm::ptr<char>::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; 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); 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<const char> fmt)
{ {
sysPrxForUser->Todo("_sys_printf(arg1=0x%x)", arg1); sysPrxForUser->Todo("_sys_printf(fmt_addr=0x%x, ...)", fmt.addr());
// probably, assertion failed // probably, assertion failed
sysPrxForUser->Warning("_sys_printf: \n%s", (char*)(Memory + arg1)); sysPrxForUser->Warning("_sys_printf: \n%s", fmt.get_ptr());
return CELL_OK; return CELL_OK;
} }

2
rpcs3/Emu/SysCalls/Modules/sysPrxForUser.h
View file

@ -15,4 +15,4 @@ struct HeapInfo
}; };
// SysCalls // SysCalls
u32 _sys_memset(u32 addr, s32 value, u32 size); vm::ptr<void> _sys_memset(vm::ptr<void> dst, s32 value, u32 size);

2
rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
View file

@ -595,7 +595,7 @@ s32 cellFsStReadInit(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
// alloc memory // alloc memory
fs_config.m_buffer = (u32)Memory.Alloc(fs_config.m_alloc_mem_size, 1024); 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<void>(fs_config.m_buffer), 0, fs_config.m_alloc_mem_size);
fs_config.m_fs_status = CELL_FS_ST_INITIALIZED; fs_config.m_fs_status = CELL_FS_ST_INITIALIZED;

2
rpcs3/Emu/SysCalls/lv2/sys_event.cpp
View file

@ -135,7 +135,7 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_data> event_arra
eq->sq.m_mutex.unlock(); eq->sq.m_mutex.unlock();
return CELL_OK; 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->owner.unlock(tid);
eq->sq.m_mutex.unlock(); eq->sq.m_mutex.unlock();
return CELL_OK; return CELL_OK;

15
rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
View file

@ -80,9 +80,10 @@ s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num,
u64 a3 = arg->arg3; u64 a3 = arg->arg3;
u64 a4 = arg->arg4; u64 a4 = arg->arg4;
//copy SPU image: // Copy SPU image:
auto spu_offset = Memory.MainMem.AllocAlign(256 * 1024); // TODO: use correct segment info
memcpy(Memory + spu_offset, Memory + (u32)img->segs_addr, 256 * 1024); auto spu_offset = Memory.Alloc(256 * 1024, 4096);
memcpy(vm::get_ptr<void>(spu_offset), vm::get_ptr<void>(img->segs_addr), 256 * 1024);
CPUThread& new_thread = Emu.GetCPU().AddThread(CPU_THREAD_SPU); CPUThread& new_thread = Emu.GetCPU().AddThread(CPU_THREAD_SPU);
//initialize from new place: //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++) for (u32 i = 0; i < group_info->list.size(); i++)
{ {
// TODO: disconnect all event ports // TODO: disconnect all event ports
CPUThread* t = Emu.GetCPU().GetThread(group_info->list[i]);
Emu.GetCPU().RemoveThread(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; group_info->m_state = SPU_THREAD_GROUP_STATUS_UNKNOWN;