RealToVirtualAddr became vm::get_addr()

rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp

@@ -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)",
+	sceLibKernel.Error("sceKernelCreateThread(pName=0x%x, 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);
+		pName, entry, initPriority, stackSize, attr, cpuAffinityMask, pOptParam);
 
-	std::string name = pName.get_ptr();
+	ARMv7Thread& new_thread = static_cast<ARMv7Thread&>(Emu.GetCPU().AddThread(CPU_THREAD_ARMv7));
-
-	ARMv7Thread& new_thread = *(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);
+	thread.write_gpr(0, argSize);
-	static_cast<ARMv7Thread*>(t.get())->write_gpr(1, pos);
+	thread.write_gpr(1, pos);
 
-	t->Exec();
+	thread.Exec();
 	return SCE_OK;
 }
 

rpcs3/Emu/Memory/Memory.h

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

rpcs3/Emu/Memory/vm.cpp

@@ -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)

rpcs3/Emu/Memory/vm.h

@@ -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;
 		}
 	}
 

rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp

@@ -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;
 }
 

rpcs3/Emu/SysCalls/Modules/cellSpurs.h

@@ -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));
 	}
 };
 

rpcs3/Emu/SysCalls/Modules/cellSync.cpp

@@ -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;
 	}
 

rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp

@@ -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;

rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp

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