mirror/rpcs3
1
0
Fork 0
mirror of https://github.com/RPCS3/rpcs3.git synced 2025-03-15 22:21:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

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
Show Stats 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)
{
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
{
@ -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<volatile u64>(addr), re64(CPU.GPR[rs]), CPU.R_VALUE) == CPU.R_VALUE);
CPU.R_ADDR = 0;
}
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:
{
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;
}
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;
}
@ -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<volatile u64>(ea)[i], buf[i], R_DATA[i]) != R_DATA[i])
{
m_events |= SPU_EVENT_LR;
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();
}
memcpy(Memory + (m_addr + Tell()), (void*)src, size);
memcpy(vm::get_ptr<void>(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<void>(m_addr + Tell()), 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);
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)
{
const u64 res = (u64)addr - (u64)GetBaseAddr();
@ -332,14 +319,17 @@ public:
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);
}
template<typename T> u8& operator[] (const T vaddr)
{
return *GetMemFromAddr<T>(vaddr);
if ((u32)addr == addr)
{
return *((u8*)GetBaseAddr() + addr);
}
else
{
InvalidAddress(__FUNCTION__, addr);
return *(u8*)GetBaseAddr();
}
}
};

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

@ -116,7 +116,7 @@ next:
break;
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_size -= adec.reader.size;
@ -149,7 +149,7 @@ next:
}
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.size -= buf_size;

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

@ -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<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);
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", []()
{

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;
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);
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.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<void>(offsetTable.ioAddress), 0xFF, 3072 * 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;
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;
@ -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<void>(ctx.begin), vm::get_ptr<void>(ctx.current - res), 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())
{
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;
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())
{
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;
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 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<u8> 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);
}

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())
{
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;
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())
{
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;
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 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<u8> 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);
}

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)
{
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);
memset(Memory + pInfo_addr, 0, size);
memset(vm::get_ptr<void>(pInfo_addr), 0, size);
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())
{
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;
case se32(CELL_PNGDEC_FILE):
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())
{
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;
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 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<u8> 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);
}

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

@ -194,11 +194,11 @@ struct CellSpursTracePacket
};
// Exception handlers.
//typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr<CellSpurs> spurs, const vm::ptr<CellSpursExceptionInfo> info,
// u32 id, vm::ptr<void> arg);
//typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr<CellSpurs> spurs, vm::ptr<const CellSpursExceptionInfo> info,
// u32 id, vm::ptr<void> arg);
//
//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
{

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

@ -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<void>(libspurs_jq), libspurs_jq_data, sizeof(libspurs_jq_data));
libspurs_jq_rtoc = libspurs_jq + 0x17E80;
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;
}
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;
}
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<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
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<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;
}
@ -412,7 +412,7 @@ s32 cellSyncRwmRead(vm::ptr<CellSyncRwm> 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<CellSyncRwm> rwm, u32 buffer_addr)
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;
}
@ -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;
}
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<CellSyncRwm> rwm, u32 buffer_addr)
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;
}
@ -528,7 +528,7 @@ s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> 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<CellSyncRwm> rwm, u32 buffer_addr)
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;
}
@ -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;
// 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<CellSyncRwm> rwm, u32 buffer_addr)
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)
{
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<CellSyncQueue> 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<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;
}
@ -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
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<CellSyncQueue> queue, u32 buffer_addr)
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;
}
@ -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;
}
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<CellSyncQueue> queue, u32 buffer_addr)
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;
}
@ -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)
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<CellSyncQueue> queue, u32 buffer_addr)
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;
}
@ -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;
}
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<CellSyncQueue> queue, u32 buffer_addr)
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;
}
@ -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;
}
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<CellSyncQueue> queue, u32 buffer_addr)
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;
}
@ -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;
}
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<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_h2 = 0;
@ -1039,19 +1039,20 @@ void syncLFQueueInit(vm::ptr<CellSyncLFQueue> 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<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
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 (!buffer_addr)
if (!buffer)
{
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;
}
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<CellSyncLFQueue> 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<CellSyncLFQueue> 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<CellSyncLFQueue> queue, u32 buffer_addr, u32 s
#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)",
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)
@ -1451,7 +1452,7 @@ s32 syncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> 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<CellSyncLFQueue> queue, s32 poi
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
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<CellSyncLFQueue> 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<void>((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<CellSyncLFQueue> 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<CellSyncLFQueue> queue, s32 poin
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
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<CellSyncLFQueue> 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<void>((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<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> dept
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());
@ -2088,11 +2089,11 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_
return CELL_SYNC_ERROR_ALIGN;
}
*ppSignal = (u32)queue->m_eaSignal;
*ppSignal = (u32)queue->m_eaSignal.addr();
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());
@ -2109,7 +2110,7 @@ s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<Cel
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());
@ -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<void>(libsre), libsre_data, sizeof(libsre_data));
libsre_rtoc = libsre + 0x399B0;
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_writers;
be_t<u32> m_size;
be_t<u64> m_addr;
vm::bptr<void, 1, u64> m_buffer;
volatile u32& m_data()
{
@ -76,7 +76,7 @@ struct CellSyncQueue
be_t<u32> m_v2;
be_t<u32> m_size;
be_t<u32> m_depth;
be_t<u64> m_addr;
vm::bptr<u8, 1, u64> m_buffer;
be_t<u64> reserved;
volatile u64& m_data()
@ -107,13 +107,13 @@ struct CellSyncLFQueue
be_t<u16> m_h8; // 0xE
be_t<u32> m_size; // 0x10
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
be_t<CellSyncQueueDirection> m_direction; // 0x24
be_t<u32> m_v1; // 0x28
be_t<u32> m_sync; // 0x2C
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_v3; // 0x7C
@ -159,11 +159,11 @@ s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex);
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 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);

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

@ -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<void>(libsync2), libsync2_data, sizeof(libsync2_data));
libsync2_rtoc = libsync2 + 0xF280;
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<CellWebBrowserNotify> notify_cb;
vm::bptr<CellWebBrowserCallback> request_cb;
vm::bptr<CellWebBrowserRect> rect;
CellWebBrowserRect rect;
be_t<float> resolution_factor;
be_t<s32> magic_number_;
};

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

@ -116,7 +116,7 @@ next:
break;
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_size -= vdec.reader.size;
@ -153,7 +153,7 @@ next:
}
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.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());
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);
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);
return addr;
memset(dst.get_ptr(), value, size);
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;
}
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);
}
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<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;
}
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);
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<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;
}
@ -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<const char> 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;
}

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

@ -15,4 +15,4 @@ struct HeapInfo
};
// 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
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;

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();
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;

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 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<void>(spu_offset), vm::get_ptr<void>(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;