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

RealToVirtualAddr became vm::get_addr()

Browse Source
This commit is contained in:
Nekotekina 2015-01-19 22:41:31 +03:00
parent c4558d2ca7
commit 5195b2b1b4
9 changed files with 61 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp
View File

@ -95,20 +95,18 @@ s32 sceKernelCreateThread(
s32 cpuAffinityMask,
vm::psv::ptr<const SceKernelThreadOptParam> pOptParam)
{
sceLibKernel.Error("sceKernelCreateThread(pName=0x%x ('%s'), entry=0x%x, initPriority=%d, stackSize=0x%x, attr=0x%x, cpuAffinityMask=0x%x, pOptParam=0x%x)",
pName, pName.get_ptr(), entry, initPriority, stackSize, attr, cpuAffinityMask, pOptParam);
sceLibKernel.Error("sceKernelCreateThread(pName=0x%x, entry=0x%x, initPriority=%d, stackSize=0x%x, attr=0x%x, cpuAffinityMask=0x%x, pOptParam=0x%x)",
pName, entry, initPriority, stackSize, attr, cpuAffinityMask, pOptParam);
std::string name = pName.get_ptr();
ARMv7Thread& new_thread = *(ARMv7Thread*)&Emu.GetCPU().AddThread(CPU_THREAD_ARMv7);
ARMv7Thread& new_thread = static_cast<ARMv7Thread&>(Emu.GetCPU().AddThread(CPU_THREAD_ARMv7));
u32 id = new_thread.GetId();
new_thread.SetEntry(entry.addr() ^ 1);
new_thread.SetPrio(initPriority);
new_thread.SetStackSize(stackSize);
new_thread.SetName(name);
new_thread.SetName(pName.get_ptr());
sceLibKernel.Error("*** New ARMv7 Thread [%s] (entry_addr=0x%x): id = %d", name.c_str(), entry.addr(), id);
sceLibKernel.Error("*** New ARMv7 Thread [%s] (entry_addr=0x%x)^1: id = %d", pName.get_ptr(), entry, id);
new_thread.Run();
@ -128,15 +126,17 @@ s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::psv::ptr<const void> pAr
RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
}
ARMv7Thread& thread = static_cast<ARMv7Thread&>(*t);
// push arg block onto the stack
u32 pos = (static_cast<ARMv7Thread*>(t.get())->SP -= argSize);
const u32 pos = (thread.SP -= argSize);
memcpy(vm::get_ptr<void>(pos), pArgBlock.get_ptr(), argSize);
// set SceKernelThreadEntry function arguments
static_cast<ARMv7Thread*>(t.get())->write_gpr(0, argSize);
static_cast<ARMv7Thread*>(t.get())->write_gpr(1, pos);
thread.write_gpr(0, argSize);
thread.write_gpr(1, pos);
t->Exec();
thread.Exec();
return SCE_OK;
}

15
rpcs3/Emu/Memory/Memory.h
View File

@ -83,21 +83,6 @@ public:
void UnregisterPages(u64 addr, u32 size);
u32 RealToVirtualAddr(const void* addr)
{
const u64 res = (u64)addr - (u64)GetBaseAddr();
if ((u32)res == res)
{
return (u32)res;
}
else
{
assert(!addr);
return 0;
}
}
u32 InitRawSPU(MemoryBlock* raw_spu);
void CloseRawSPU(MemoryBlock* raw_spu, const u32 num);

14
rpcs3/Emu/Memory/vm.cpp
View File

@ -52,6 +52,20 @@ namespace vm
return g_locations[location].deallocator(addr);
}
u32 get_addr(const void* real_pointer)
{
const u64 diff = (u64)real_pointer - (u64)g_base_addr;
const u32 res = (u32)diff;
if (res == diff)
{
return res;
}
assert(!real_pointer);
return 0;
}
namespace ps3
{
u32 main_alloc(u32 size)

46
rpcs3/Emu/Memory/vm.h
View File

@ -31,7 +31,7 @@ namespace vm
template<typename T = void>
T* const get_ptr(u32 addr)
{
return (T*)((u8*)g_base_addr + addr);
return reinterpret_cast<T*>(static_cast<u8*>(g_base_addr) + addr);
}
template<typename T>
@ -40,6 +40,8 @@ namespace vm
return *get_ptr<T>(addr);
}
u32 get_addr(const void* real_pointer);
template<typename T>
struct cast_ptr
{
@ -65,7 +67,7 @@ namespace vm
{
__forceinline static u32 cast(const u64 addr, const char* func)
{
const u32 res = (u32)addr;
const u32 res = static_cast<u32>(addr);
if (res != addr)
{
throw fmt::Format("%s(): invalid address 0x%llx", func, addr);
@ -96,42 +98,42 @@ namespace vm
static u8 read8(u32 addr)
{
return *((u8*)g_base_addr + addr);
return get_ref<u8>(addr);
}
static void write8(u32 addr, u8 value)
{
*((u8*)g_base_addr + addr) = value;
get_ref<u8>(addr) = value;
}
static u16 read16(u32 addr)
{
return re16(*(u16*)((u8*)g_base_addr + addr));
return get_ref<be_t<u16>>(addr);
}
static void write16(u32 addr, be_t<u16> value)
{
*(be_t<u16>*)((u8*)g_base_addr + addr) = value;
get_ref<be_t<u16>>(addr) = value;
}
static u32 read32(u32 addr)
{
return re32(*(u32*)((u8*)g_base_addr + addr));;
return get_ref<be_t<u32>>(addr);
}
static void write32(u32 addr, be_t<u32> value)
{
*(be_t<u32>*)((u8*)g_base_addr + addr) = value;
get_ref<be_t<u32>>(addr) = value;
}
static u64 read64(u32 addr)
{
return re64(*(u64*)((u8*)g_base_addr + addr));
return get_ref<be_t<u64>>(addr);
}
static void write64(u32 addr, be_t<u64> value)
{
*(be_t<u64>*)((u8*)g_base_addr + addr) = value;
get_ref<be_t<u64>>(addr) = value;
}
static void write16(u32 addr, u16 value)
@ -151,12 +153,12 @@ namespace vm
static u128 read128(u32 addr)
{
return re128(*(u128*)((u8*)g_base_addr + addr));
return get_ref<be_t<u128>>(addr);
}
static void write128(u32 addr, u128 value)
{
*(u128*)((u8*)g_base_addr + addr) = re128(value);
get_ref<be_t<u128>>(addr) = value;
}
}
@ -166,52 +168,52 @@ namespace vm
static u8 read8(u32 addr)
{
return *((u8*)g_base_addr + addr);
return get_ref<u8>(addr);
}
static void write8(u32 addr, u8 value)
{
*((u8*)g_base_addr + addr) = value;
get_ref<u8>(addr) = value;
}
static u16 read16(u32 addr)
{
return *(u16*)((u8*)g_base_addr + addr);
return get_ref<u16>(addr);
}
static void write16(u32 addr, u16 value)
{
*(u16*)((u8*)g_base_addr + addr) = value;
get_ref<u16>(addr) = value;
}
static u32 read32(u32 addr)
{
return *(u32*)((u8*)g_base_addr + addr);
return get_ref<u32>(addr);
}
static void write32(u32 addr, u32 value)
{
*(u32*)((u8*)g_base_addr + addr) = value;
get_ref<u32>(addr) = value;
}
static u64 read64(u32 addr)
{
return *(u64*)((u8*)g_base_addr + addr);
return get_ref<u64>(addr);
}
static void write64(u32 addr, u64 value)
{
*(u64*)((u8*)g_base_addr + addr) = value;
get_ref<u64>(addr) = value;
}
static u128 read128(u32 addr)
{
return *(u128*)((u8*)g_base_addr + addr);
return get_ref<u128>(addr);
}
static void write128(u32 addr, u128 value)
{
*(u128*)((u8*)g_base_addr + addr) = value;
get_ref<u128>(addr) = value;
}
}

8
rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
View File

@ -66,7 +66,7 @@ s64 spursInit(
{
#ifdef PRX_DEBUG_XXX
return cb_call<s32, vm::ptr<CellSpurs>, u32, u32, s32, s32, s32, u32, u32, u32, u32, u32, u32, u32>(GetCurrentPPUThread(), libsre + 0x74E4, libsre_rtoc,
spurs, revision, sdkVersion, nSpus, spuPriority, ppuPriority, flags, Memory.RealToVirtualAddr(prefix), prefixSize, container, Memory.RealToVirtualAddr(swlPriority), swlMaxSpu, swlIsPreem);
spurs, revision, sdkVersion, nSpus, spuPriority, ppuPriority, flags, vm::get_addr(prefix), prefixSize, container, vm::get_addr(swlPriority), swlMaxSpu, swlIsPreem);
#endif
// SPURS initialization (asserts should actually rollback and return the error instead)
@ -700,7 +700,7 @@ s64 spursInit(
s32 res = CELL_OK;
#ifdef PRX_DEBUG
res = cb_call<s32, vm::ptr<CellSpurs>, u32, u32, u32>(GetCurrentPPUThread(), libsre + 0x10428, libsre_rtoc,
spurs, Memory.RealToVirtualAddr(swlPriority), swlMaxSpu, swlIsPreem);
spurs, vm::get_addr(swlPriority), swlMaxSpu, swlIsPreem);
#endif
assert(res == CELL_OK);
}
@ -1327,7 +1327,7 @@ s32 spursAddWorkload(
{
#ifdef PRX_DEBUG_XXX
return cb_call<s32, vm::ptr<CellSpurs>, vm::ptr<u32>, vm::ptr<const void>, u32, u64, u32, u32, u32, u32, u32, u32, u32>(GetCurrentPPUThread(), libsre + 0x96EC, libsre_rtoc,
spurs, wid, pm, size, data, Memory.RealToVirtualAddr(priorityTable), minContention, maxContention,
spurs, wid, pm, size, data, vm::get_addr(priorityTable), minContention, maxContention,
nameClass.addr(), nameInstance.addr(), hook.addr(), hookArg.addr());
#endif
@ -1752,7 +1752,7 @@ s64 cellSpursGetWorkloadFlag(vm::ptr<CellSpurs> spurs, vm::ptr<vm::bptr<CellSpur
return CELL_SPURS_POLICY_MODULE_ERROR_ALIGN;
}
flag->set(Memory.RealToVirtualAddr(&spurs->m.wklFlag));
flag->set(vm::get_addr(&spurs->m.wklFlag));
return CELL_OK;
}

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

@ -367,12 +367,12 @@ struct CellSpurs
__forceinline vm::ptr<sys_lwmutex_t> get_lwmutex()
{
return vm::ptr<sys_lwmutex_t>::make(Memory.RealToVirtualAddr(&m.mutex));
return vm::ptr<sys_lwmutex_t>::make(vm::get_addr(&m.mutex));
}
__forceinline vm::ptr<sys_lwcond_t> get_lwcond()
{
return vm::ptr<sys_lwcond_t>::make(Memory.RealToVirtualAddr(&m.cond));
return vm::ptr<sys_lwcond_t>::make(vm::get_addr(&m.cond));
}
};

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

@ -321,7 +321,6 @@ s32 syncRwmReadEndOp(CellSyncRwm::data_t& rwm)
{
if (!rwm.m_readers.data())
{
cellSync->Error("syncRwmReadEndOp(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", Memory.RealToVirtualAddr(&rwm), (u16)rwm.m_writers);
return CELL_SYNC_ERROR_ABORT;
}
@ -354,6 +353,7 @@ s32 cellSyncRwmRead(vm::ptr<CellSyncRwm> rwm, vm::ptr<void> buffer)
// prx: decrease m_readers (return 0x8041010C if already zero)
if (s32 res = rwm->data.atomic_op(CELL_OK, syncRwmReadEndOp))
{
cellSync->Error("syncRwmReadEndOp(rwm=0x%x) failed: m_readers == 0", rwm);
return res;
}

6
rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
View File

@ -14,10 +14,12 @@ SysCallBase sys_lwcond("sys_lwcond");
s32 lwcond_create(sys_lwcond_t& lwcond, sys_lwmutex_t& lwmutex, u64 name_u64)
{
std::shared_ptr<Lwcond> lw(new Lwcond(name_u64, Memory.RealToVirtualAddr(&lwcond)));
const u32 addr = vm::get_addr(&lwmutex);
std::shared_ptr<Lwcond> lw(new Lwcond(name_u64, addr));
const u32 id = sys_lwcond.GetNewId(lw, TYPE_LWCOND);
const u32 addr = Memory.RealToVirtualAddr(&lwmutex);
lw->queue.set_full_name(fmt::Format("Lwcond(%d, addr=0x%x)", id, lw->addr));
lwcond.lwmutex.set(addr);
lwcond.lwcond_queue = id;

2
rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
View File

@ -22,7 +22,7 @@ s32 lwmutex_create(sys_lwmutex_t& lwmutex, u32 protocol, u32 recursive, u64 name
lwmutex.recursive_count.write_relaxed(be_t<u32>::make(0));
u32 sq_id = sys_lwmutex.GetNewId(sq, TYPE_LWMUTEX);
lwmutex.sleep_queue = sq_id;
sq->set_full_name(fmt::Format("Lwmutex(%d, addr=0x%x)", sq_id, Memory.RealToVirtualAddr(&lwmutex)));
sq->set_full_name(fmt::Format("Lwmutex(%d, addr=0x%x)", sq_id, vm::get_addr(&lwmutex)));
// passing be_t<u32> (test)
sys_lwmutex.Notice("*** lwmutex created [%s] (attribute=0x%x): sq_id = %d", std::string((const char*)&name_u64, 8).c_str(), lwmutex.attribute, sq_id);