Small refactoring

rpcs3/Emu/Memory/Memory.cpp

@@ -299,7 +299,7 @@ void MemoryBlock::Init()
 	range_start = 0;
 	range_size = 0;
 
-	mem = vm::get_ptr<u8>(0);
+	mem = vm::get_ptr<u8>(0u);
 }
 
 void MemoryBlock::InitMemory()

rpcs3/Emu/Memory/Memory.h

@@ -16,12 +16,12 @@ enum MemoryType
 	Memory_PSP,
 };
 
-enum : u64
+enum : u32
 {
-	RAW_SPU_OFFSET = 0x0000000000100000,
-	RAW_SPU_BASE_ADDR = 0x00000000E0000000,
-	RAW_SPU_LS_OFFSET = 0x0000000000000000,
-	RAW_SPU_PROB_OFFSET = 0x0000000000040000,
+	RAW_SPU_OFFSET = 0x00100000,
+	RAW_SPU_BASE_ADDR = 0xE0000000,
+	RAW_SPU_LS_OFFSET = 0x00000000,
+	RAW_SPU_PROB_OFFSET = 0x00040000,
 };
 
 class MemoryBase

rpcs3/Emu/Memory/vm.h

@@ -12,35 +12,67 @@ namespace vm
 	{
 		return (T*)((u8*)m_base_addr + addr);
 	}
+
+	template<typename T>
+	T* const get_ptr(u64 addr)
+	{
+		return get_ptr<T>((u32)addr);
+	}
 	
 	template<typename T>
 	T& get_ref(u32 addr)
 	{
-		return *(T*)((u8*)m_base_addr + addr);
+		return *get_ptr<T>(addr);
 	}
 
-	static u8 read8(u32 addr)
+	template<typename T>
+	T& get_ref(u64 addr)
 	{
-		return *((u8*)m_base_addr + addr);
-	}
-
-	static void write8(u32 addr, u8 value)
-	{
-		*((u8*)m_base_addr + addr) = value;
+		return get_ref<T>((u32)addr);
 	}
 
 	namespace ps3
 	{
+		static u8 read8(u32 addr)
+		{
+			return *((u8*)m_base_addr + addr);
+		}
+
+		static u8 read8(u64 addr)
+		{
+			return read8((u32)addr);
+		}
+
+		static void write8(u32 addr, u8 value)
+		{
+			*((u8*)m_base_addr + addr) = value;
+		}
+
+		static void write8(u64 addr, u8 value)
+		{
+			write8((u32)addr, value);
+		}
+
 		static u16 read16(u32 addr)
 		{
 			return re16(*(u16*)((u8*)m_base_addr + addr));
 		}
 
+		static u16 read16(u64 addr)
+		{
+			return read16((u32)addr);
+		}
+
 		static void write16(u32 addr, u16 value)
 		{
 			*(u16*)((u8*)m_base_addr + addr) = re16(value);
 		}
 
+		static void write16(u64 addr, u16 value)
+		{
+			write16((u32)addr, value);
+		}
+
 		static u32 read32(u32 addr)
 		{
 			if (addr < RAW_SPU_BASE_ADDR || (addr % RAW_SPU_OFFSET) < RAW_SPU_PROB_OFFSET)
@@ -53,6 +85,11 @@ namespace vm
 			}
 		}
 
+		static u32 read32(u64 addr)
+		{
+			return read32((u32)addr);
+		}
+
 		static void write32(u32 addr, u32 value)
 		{
 			if (addr < RAW_SPU_BASE_ADDR || (addr % RAW_SPU_OFFSET) < RAW_SPU_PROB_OFFSET)
@@ -65,29 +102,64 @@ namespace vm
 			}
 		}
 
+		static void write32(u64 addr, u32 value)
+		{
+			write32((u32)addr, value);
+		}
+
 		static u64 read64(u32 addr)
 		{
 			return re64(*(u64*)((u8*)m_base_addr + addr));
 		}
 
+		static u64 read64(u64 addr)
+		{
+			return read64((u32)addr);
+		}
+
 		static void write64(u32 addr, u64 value)
 		{
 			*(u64*)((u8*)m_base_addr + addr) = re64(value);
 		}
 
+		static void write64(u64 addr, u64 value)
+		{
+			write64((u32)addr, value);
+		}
+
 		static u128 read128(u32 addr)
 		{
 			return re128(*(u128*)((u8*)m_base_addr + addr));
 		}
 
+		static u128 read128(u64 addr)
+		{
+			return read128((u32)addr);
+		}
+
 		static void write128(u32 addr, u128 value)
 		{
 			*(u128*)((u8*)m_base_addr + addr) = re128(value);
 		}
+
+		static void write128(u64 addr, u128 value)
+		{
+			write128((u32)addr, value);
+		}
 	}
 	
 	namespace psv
 	{
+		static u8 read8(u32 addr)
+		{
+			return *((u8*)m_base_addr + addr);
+		}
+
+		static void write8(u32 addr, u8 value)
+		{
+			*((u8*)m_base_addr + addr) = value;
+		}
+
 		static u16 read16(u32 addr)
 		{
 			return *(u16*)((u8*)m_base_addr + addr);

rpcs3/Emu/Memory/vm_var.h

@@ -43,7 +43,7 @@ namespace vm
 			{
 				Memory.Free(m_addr);
 				m_addr = 0;
-				m_ptr = vm::get_ptr<T>(0);
+				m_ptr = vm::get_ptr<T>(0u);
 			}
 		}
 		
@@ -364,7 +364,7 @@ namespace vm
 			{
 				Memory.Free(m_addr);
 				m_addr = 0;
-				m_ptr = vm::get_ptr<T>(0);
+				m_ptr = vm::get_ptr<T>(0u);
 			}
 		}