From cd33be149133b48e7143c135113459ad05ae80c6 Mon Sep 17 00:00:00 2001
From: DHrpcs3 <dh.rpcs3@gmail.com>
Date: Thu, 31 Jul 2014 19:08:02 +0300
Subject: [PATCH 01/36] Implemented vm::var. MemoryAllocator replaced with
 vm::var

---
 rpcs3/Emu/Memory/Memory.h                     |   4 +
 rpcs3/Emu/Memory/vm.h                         |  48 ++
 rpcs3/Emu/Memory/vm_ptr.h                     |   6 +
 rpcs3/Emu/Memory/vm_ref.h                     |   6 +
 rpcs3/Emu/Memory/vm_var.h                     | 513 ++++++++++++++++++
 rpcs3/Emu/SysCalls/Modules/cellFont.cpp       |   5 +-
 rpcs3/Emu/SysCalls/Modules/cellGame.cpp       |  10 +-
 rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp     |  30 +-
 rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp     |  30 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp     |  58 +-
 rpcs3/Emu/SysCalls/Modules/cellResc.cpp       |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp    |  10 +-
 .../SysCalls/Modules/cellSysutil_SaveData.cpp | 160 +++---
 rpcs3/Emu/SysCalls/Modules/sys_fs.cpp         |   8 +-
 rpcs3/emucore.vcxproj                         |   4 +
 rpcs3/emucore.vcxproj.filters                 |  12 +
 16 files changed, 763 insertions(+), 149 deletions(-)
 create mode 100644 rpcs3/Emu/Memory/vm.h
 create mode 100644 rpcs3/Emu/Memory/vm_ptr.h
 create mode 100644 rpcs3/Emu/Memory/vm_ref.h
 create mode 100644 rpcs3/Emu/Memory/vm_var.h

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index 114fdff049..72f48a0e9a 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -1113,6 +1113,7 @@ public:
 	}
 };
 
+/*
 template<typename T>
 class MemoryAllocator
 {
@@ -1222,6 +1223,7 @@ public:
 		return (NT*)(m_ptr + offset);
 	}
 };
+*/
 
 typedef mem_t<u8, u32> mem8_t;
 typedef mem_t<u16, u32> mem16_t;
@@ -1245,3 +1247,5 @@ typedef mem_list_ptr_t<u16, u32> mem16_ptr_t;
 typedef mem_list_ptr_t<u32, u32> mem32_ptr_t;
 typedef mem_list_ptr_t<u64, u32> mem64_ptr_t;
 
+#include "vm.h"
+
diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
new file mode 100644
index 0000000000..b1858c4597
--- /dev/null
+++ b/rpcs3/Emu/Memory/vm.h
@@ -0,0 +1,48 @@
+#pragma once
+
+namespace vm
+{
+	//TODO
+	bool check_addr(u32 addr)
+	{
+		return false;
+	}
+
+	bool map(u32 addr, u32 size, u32 flags)
+	{
+		return false;
+	}
+
+	bool unmap(u32 addr, u32 size = 0, u32 flags = 0)
+	{
+		return false;
+	}
+
+	u32 alloc(u32 size)
+	{
+		return 0;
+	}
+
+	void unalloc(u32 addr)
+	{
+	}
+
+	u32 read32(u32 addr)
+	{
+		return 0;
+	}
+
+	bool read32(u32 addr, u32& value)
+	{
+		return false;
+	}
+
+	bool write32(u32 addr, u32 value)
+	{
+		return false;
+	}
+}
+
+#include "vm_ptr.h"
+#include "vm_ref.h"
+#include "vm_var.h"
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
new file mode 100644
index 0000000000..629a59dc91
--- /dev/null
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace vm
+{
+	//TODO
+}
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
new file mode 100644
index 0000000000..629a59dc91
--- /dev/null
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -0,0 +1,6 @@
+#pragma once
+
+namespace vm
+{
+	//TODO
+}
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
new file mode 100644
index 0000000000..bc4a99422c
--- /dev/null
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -0,0 +1,513 @@
+#pragma once
+
+namespace vm
+{
+	template<typename T>
+	class var
+	{
+		u32 m_addr;
+		u32 m_size;
+		u32 m_align;
+		T* m_ptr;
+
+	public:
+		var(u32 size = sizeof(T), u32 align = sizeof(T))
+			: m_size(size)
+			, m_align(align)
+		{
+			alloc();
+		}
+
+		var(const var& r)
+			: m_size(r.m_size)
+			, m_align(r.m_align)
+		{
+			alloc();
+			*m_ptr = *r.m_ptr;
+		}
+
+		~var()
+		{
+			dealloc();
+		}
+
+		void alloc()
+		{
+			m_addr = Memory.Alloc(size(), m_align);
+			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+		}
+
+		void dealloc()
+		{
+			if (check())
+			{
+				Memory.Free(m_addr);
+				m_addr = 0;
+				m_ptr = nullptr;
+			}
+		}
+
+		void clear()
+		{
+			if (check())
+			{
+				Memory.Free(m_addr);
+				m_addr = 0;
+				m_ptr = nullptr;
+			}
+		}
+		
+		static var make(u32 addr, u32 size = sizeof(T), u32 align = sizeof(T))
+		{
+			var res;
+
+			res.m_addr = addr;
+			res.m_size = size;
+			res.m_align = align;
+			res.m_ptr = Memory.IsGoodAddr(m_addr, sizeof(T)) ? (T*)&Memory[m_addr] : nullptr;
+
+			return res;
+		}
+
+		T* operator -> ()
+		{
+			return m_ptr;
+		}
+
+		const T* operator -> () const
+		{
+			return m_ptr;
+		}
+		
+		T* get_ptr()
+		{
+			return m_ptr;
+		}
+
+		const T* get_ptr() const
+		{
+			return m_ptr;
+		}
+
+		T& value()
+		{
+			return *m_ptr;
+		}
+
+		const T& value() const
+		{
+			return *m_ptr;
+		}
+
+		u32 addr() const
+		{
+			return m_addr;
+		}
+
+		u32 size() const
+		{
+			return m_size;
+		}
+
+		bool check() const
+		{
+			return m_ptr != nullptr;
+		}
+
+		/*
+		operator const ref<T>() const
+		{
+			return addr();
+		}
+		*/
+		
+		operator T&()
+		{
+			return *m_ptr;
+		}
+		
+		operator const T&() const
+		{
+			return *m_ptr;
+		}
+	};
+	
+	template<typename T>
+	class var<T[]>
+	{
+		u32 m_addr;
+		u32 m_count;
+		u32 m_size;
+		u32 m_align;
+		T* m_ptr;
+
+	public:
+		var(u32 count, u32 size = sizeof(T), u32 align = sizeof(T))
+			: m_count(count)
+			, m_size(size)
+			, m_align(align)
+		{
+			alloc();
+		}
+
+		~var()
+		{
+			dealloc();
+		}
+
+		var(const var& r)
+			: m_size(r.m_size)
+			, m_align(r.m_align)
+		{
+			alloc();
+			memcpy(m_ptr, r.m_ptr, size());
+		}
+
+		void alloc()
+		{
+			m_addr = Memory.Alloc(size(), m_align);
+			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+		}
+
+		void dealloc()
+		{
+			if (check())
+			{
+				Memory.Free(m_addr);
+				m_addr = 0;
+				m_ptr = nullptr;
+			}
+		}
+
+		static var make(u32 addr, u32 count, u32 size = sizeof(T), u32 align = sizeof(T))
+		{
+			var res;
+
+			res.m_addr = addr;
+			res.m_count = count;
+			res.m_size = size;
+			res.m_align = align;
+			res.m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+
+			return res;
+		}
+
+		T* begin()
+		{
+			return m_ptr;
+		}
+
+		const T* begin() const
+		{
+			return m_ptr;
+		}
+
+		T* end()
+		{
+			return m_ptr + count();
+		}
+
+		const T* end() const
+		{
+			return m_ptr + count();
+		}
+
+		T* operator -> ()
+		{
+			return m_ptr;
+		}
+
+		T& get()
+		{
+			return m_ptr;
+		}
+
+		const T& get() const
+		{
+			return m_ptr;
+		}
+
+		const T* operator -> () const
+		{
+			return m_ptr;
+		}
+
+		uint addr() const
+		{
+			return m_addr;
+		}
+
+		uint size() const
+		{
+			return m_count * m_size;
+		}
+
+		uint count() const
+		{
+			return m_count;
+		}
+
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr, size());
+		}
+
+		template<typename T1>
+		operator const T1() const
+		{
+			return T1(*m_ptr);
+		}
+
+		template<typename T1>
+		operator T1()
+		{
+			return T1(*m_ptr);
+		}
+
+		operator const T&() const
+		{
+			return *m_ptr;
+		}
+
+		operator T&()
+		{
+			return *m_ptr;
+		}
+
+		operator const T*() const
+		{
+			return m_ptr;
+		}
+
+		operator T*()
+		{
+			return m_ptr;
+		}
+
+		T& operator [](int index)
+		{
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
+		}
+
+		const T& operator [](int index) const
+		{
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
+		}
+
+		T& at(uint index)
+		{
+			if (index >= count())
+				throw std::out_of_range();
+
+			return *(m_ptr + index);
+		}
+
+		const T& at(uint index) const
+		{
+			if (index >= count())
+				throw std::out_of_range();
+
+			return *(m_ptr + index);
+		}
+
+		T* ptr()
+		{
+			return m_ptr;
+		}
+
+		const T* ptr() const
+		{
+			return m_ptr;
+		}
+
+		/*
+		operator const ptr<T>() const
+		{
+			return addr();
+		}
+		*/
+		template<typename NT>
+		NT* To(uint offset = 0)
+		{
+			return (NT*)(m_ptr + offset);
+		}
+	};
+	
+	template<typename T, int _count>
+	class var<T[_count]>
+	{
+		u32 m_addr;
+		u32 m_size;
+		u32 m_align;
+		T* m_ptr;
+
+	public:
+		var(u32 size = sizeof(T), u32 align = sizeof(T))
+			: m_size(size)
+			, m_align(align)
+		{
+			alloc();
+		}
+
+		~var()
+		{
+			dealloc();
+		}
+
+		var(const var& r)
+			: m_size(r.m_size)
+			, m_align(r.m_align)
+		{
+			alloc();
+			memcpy(m_ptr, r.m_ptr, size());
+		}
+
+		void alloc()
+		{
+			m_addr = Memory.Alloc(size(), m_align);
+			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+		}
+
+		void dealloc()
+		{
+			if (check())
+			{
+				Memory.Free(m_addr);
+				m_addr = 0;
+				m_ptr = nullptr;
+			}
+		}
+
+		T* operator -> ()
+		{
+			return m_ptr;
+		}
+		
+		T* begin()
+		{
+			return m_ptr;
+		}
+		
+		const T* begin() const
+		{
+			return m_ptr;
+		}
+		
+		T* end()
+		{
+			return m_ptr + count();
+		}
+		
+		const T* end() const
+		{
+			return m_ptr + count();
+		}
+
+		T& get()
+		{
+			return m_ptr;
+		}
+
+		const T& get() const
+		{
+			return m_ptr;
+		}
+
+		const T* operator -> () const
+		{
+			return m_ptr;
+		}
+
+		uint addr() const
+		{
+			return m_addr;
+		}
+		
+		__forceinline uint count() const
+		{
+			return _count;
+		}
+		
+		uint size() const
+		{
+			return _count * m_size;
+		}
+
+		bool check() const
+		{
+			return m_ptr != nullptr;
+		}
+
+		template<typename T1>
+		operator const T1() const
+		{
+			return T1(*m_ptr);
+		}
+
+		template<typename T1>
+		operator T1()
+		{
+			return T1(*m_ptr);
+		}
+
+		operator const T&() const
+		{
+			return *m_ptr;
+		}
+
+		operator T&()
+		{
+			return *m_ptr;
+		}
+
+		operator const T*() const
+		{
+			return m_ptr;
+		}
+
+		operator T*()
+		{
+			return m_ptr;
+		}
+
+		T& operator [](uint index)
+		{
+			assert(index < count());
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
+		}
+		
+		const T& operator [](uint index) const
+		{
+			assert(index < count());
+			return return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
+		}
+		
+		T& at(uint index)
+		{
+			if (index >= count())
+				throw std::out_of_range();
+
+			return *(m_ptr + index);
+		}
+		
+		const T& at(uint index) const
+		{
+			if (index >= count())
+				throw std::out_of_range();
+
+			return *(m_ptr + index);
+		}
+
+		/*
+		operator const ptr<T>() const
+		{
+			return addr();
+		}
+		*/
+		template<typename NT>
+		NT* To(uint offset = 0)
+		{
+			return (NT*)(m_ptr + offset);
+		}
+	};
+}
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index 177f716bd1..dd1328196d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -269,8 +269,9 @@ int cellFontInit(mem_ptr_t<CellFontConfig> config)
 {
 	cellFont->Log("cellFontInit(config=0x%x)", config.GetAddr());
 
-	MemoryAllocator<u64> revisionFlags = 0;
-	cellFontGetRevisionFlags(revisionFlags.GetAddr());
+	vm::var<u64> revisionFlags;
+	revisionFlags.value() = 0;
+	cellFontGetRevisionFlags(revisionFlags.addr());
 	return cellFontInitializeWithRevision(revisionFlags, config.GetAddr());
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
index 3b1cbf3b04..d43aceb56e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
@@ -241,11 +241,11 @@ int cellGameDataCheckCreate2(u32 version, const mem_list_ptr_t<u8> dirName, u32
 	}
 
 	// TODO: use memory container
-	MemoryAllocator<CellGameDataCBResult> cbResult;
-	MemoryAllocator<CellGameDataStatGet> cbGet;
-	MemoryAllocator<CellGameDataStatSet> cbSet;
+	vm::var<CellGameDataCBResult> cbResult;
+	vm::var<CellGameDataStatGet> cbGet;
+	vm::var<CellGameDataStatSet> cbSet;
 
-	memset(cbGet.GetPtr(), 0, sizeof(CellGameDataStatGet));
+	cbGet.value() = {};
 
 	// TODO: Use the free space of the computer's HDD where RPCS3 is being run.
 	cbGet->hddFreeSizeKB = 40000000; //40 GB
@@ -270,7 +270,7 @@ int cellGameDataCheckCreate2(u32 version, const mem_list_ptr_t<u8> dirName, u32
 	strcpy_trunc(cbGet->getParam.title, psf.GetString("TITLE"));
 	// TODO: write lang titles
 
-	funcStat(cbResult.GetAddr(), cbGet.GetAddr(), cbSet.GetAddr());
+	funcStat(cbResult.addr(), cbGet.addr(), cbSet.addr());
 
 	if (cbSet->setParam.GetAddr())
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
index d515a84bb8..e541b9842b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
@@ -42,14 +42,14 @@ int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, const mem_ptr_t<CellGifDec
 
 	case se32(CELL_GIFDEC_FILE):
 		// Get file descriptor
-		MemoryAllocator<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName, 0, fd.GetAddr(), 0, 0);
+		vm::var<be_t<u32>> fd;
+		int ret = cellFsOpen(src->fileName, 0, fd.addr(), 0, 0);
 		current_subHandle->fd = fd->ToLE();
 		if (ret != CELL_OK) return CELL_GIFDEC_ERROR_OPEN_FILE;
 
 		// Get size of file
-		MemoryAllocator<CellFsStat> sb; // Alloc a CellFsStat struct
-		ret = cellFsFstat(current_subHandle->fd, sb.GetAddr());
+		vm::var<CellFsStat> sb; // Alloc a CellFsStat struct
+		ret = cellFsFstat(current_subHandle->fd, sb.addr());
 		if (ret != CELL_OK) return ret;
 		current_subHandle->fileSize = sb->st_size; // Get CellFsStat.st_size
 		break;
@@ -75,21 +75,21 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellGifDecInfo
 	CellGifDecInfo& current_info = subHandle_data->info;
 	
 	//Write the header to buffer
-	MemoryAllocator<u8> buffer(13); // Alloc buffer for GIF header
-	MemoryAllocator<be_t<u64>> pos, nread;
+	vm::var<u8[13]> buffer; // Alloc buffer for GIF header
+	vm::var<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
 	case se32(CELL_GIFDEC_BUFFER):
-		if (!Memory.Copy(buffer.GetAddr(), subHandle_data->src.streamPtr.ToLE(), buffer.GetSize())) {
+		if (!Memory.Copy(buffer.addr(), subHandle_data->src.streamPtr.ToLE(), buffer.size())) {
 			cellGifDec->Error("cellGifDecReadHeader() failed ()");
 			return CELL_EFAULT;
 		}
 		break;
 
 	case se32(CELL_GIFDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread);
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
+		cellFsRead(fd, buffer.addr(), buffer.size(), nread.addr());
 		break;
 	}
 
@@ -160,21 +160,21 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	const CellGifDecOutParam& current_outParam = subHandle_data->outParam; 
 
 	//Copy the GIF file to a buffer
-	MemoryAllocator<unsigned char> gif(fileSize);
-	MemoryAllocator<u64> pos, nread;
+	vm::var<unsigned char[]> gif(fileSize);
+	vm::var<u64> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
 	case se32(CELL_GIFDEC_BUFFER):
-		if (!Memory.Copy(gif.GetAddr(), subHandle_data->src.streamPtr.ToLE(), gif.GetSize())) {
+		if (!Memory.Copy(gif.addr(), subHandle_data->src.streamPtr.ToLE(), gif.size())) {
 			cellGifDec->Error("cellGifDecDecodeData() failed (I)");
 			return CELL_EFAULT;
 		}
 		break;
 
 	case se32(CELL_GIFDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, gif.GetAddr(), gif.GetSize(), nread);
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
+		cellFsRead(fd, gif.addr(), gif.size(), nread.addr());
 		break;
 	}
 
@@ -182,7 +182,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	int width, height, actual_components;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 		(
-			stbi_load_from_memory(gif.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+			stbi_load_from_memory(gif.ptr(), fileSize, &width, &height, &actual_components, 4),
 			&::free
 		);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
index a10c0c13d3..d627d00763 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
@@ -49,14 +49,14 @@ int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> s
 
 	case se32(CELL_JPGDEC_FILE):
 		// Get file descriptor
-		MemoryAllocator<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName, 0, fd.GetAddr(), 0, 0);
+		vm::var<be_t<u32>> fd;
+		int ret = cellFsOpen(src->fileName, 0, fd.addr(), 0, 0);
 		current_subHandle->fd = fd->ToLE();
 		if (ret != CELL_OK) return CELL_JPGDEC_ERROR_OPEN_FILE;
 
 		// Get size of file
-		MemoryAllocator<CellFsStat> sb; // Alloc a CellFsStat struct
-		ret = cellFsFstat(current_subHandle->fd, sb.GetAddr());
+		vm::var<CellFsStat> sb; // Alloc a CellFsStat struct
+		ret = cellFsFstat(current_subHandle->fd, sb.addr());
 		if (ret != CELL_OK) return ret;
 		current_subHandle->fileSize = sb->st_size;	// Get CellFsStat.st_size
 		break;
@@ -96,21 +96,21 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo
 	CellJpgDecInfo& current_info = subHandle_data->info;
 
 	//Write the header to buffer
-	MemoryAllocator<u8> buffer(fileSize);
-	MemoryAllocator<be_t<u64>> pos, nread;
+	vm::var<u8[]> buffer(fileSize);
+	vm::var<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
 	case se32(CELL_JPGDEC_BUFFER):
-		if (!Memory.Copy(buffer.GetAddr(), subHandle_data->src.streamPtr.ToLE(), buffer.GetSize())) {
+		if (!Memory.Copy(buffer.addr(), subHandle_data->src.streamPtr.ToLE(), buffer.size())) {
 			cellJpgDec->Error("cellJpgDecReadHeader() failed ()");
 			return CELL_EFAULT;
 		}
 		break;
 
 	case se32(CELL_JPGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread);
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
+		cellFsRead(fd, buffer.addr(), buffer.size(), nread.addr());
 		break;
 	}
 
@@ -168,21 +168,21 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	const CellJpgDecOutParam& current_outParam = subHandle_data->outParam; 
 
 	//Copy the JPG file to a buffer
-	MemoryAllocator<unsigned char> jpg(fileSize);
-	MemoryAllocator<u64> pos, nread;
+	vm::var<unsigned char[]> jpg(fileSize);
+	vm::var<u64> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
 	case se32(CELL_JPGDEC_BUFFER):
-		if (!Memory.Copy(jpg.GetAddr(), subHandle_data->src.streamPtr.ToLE(), jpg.GetSize())) {
+		if (!Memory.Copy(jpg.addr(), subHandle_data->src.streamPtr.ToLE(), jpg.size())) {
 			cellJpgDec->Error("cellJpgDecDecodeData() failed (I)");
 			return CELL_EFAULT;
 		}
 		break;
 
 	case se32(CELL_JPGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, jpg.GetAddr(), jpg.GetSize(), nread);
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
+		cellFsRead(fd, jpg.addr(), jpg.size(), nread.addr());
 		break;
 	}
 
@@ -190,7 +190,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	int width, height, actual_components;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 		(
-			stbi_load_from_memory(jpg.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+			stbi_load_from_memory(jpg.ptr(), fileSize, &width, &height, &actual_components, 4),
 			&::free
 		);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index b704303428..5277a1902b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -13,9 +13,10 @@ Module *cellPngDec = nullptr;
 
 static std::map<u32, CellPngDecMainHandle *> cellPngDecMap;
 
-CellPngDecMainHandle *getCellPngDecCtx(u32 mainHandle) {
+CellPngDecMainHandle *getCellPngDecCtx(u32 mainHandle)
+{
 	if (cellPngDecMap.find(mainHandle) == cellPngDecMap.end())
-		return NULL;
+		return nullptr;
 
 	return cellPngDecMap[mainHandle];
 }
@@ -71,14 +72,14 @@ int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> s
 
 	case se32(CELL_PNGDEC_FILE):
 		// Get file descriptor
-		MemoryAllocator<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName_addr, 0, fd.GetAddr(), 0, 0);
+		vm::var<be_t<u32>> fd;
+		int ret = cellFsOpen(src->fileName_addr, 0, fd.addr(), 0, 0);
 		current_subHandle->fd = fd->ToLE();
 		if(ret != CELL_OK) return CELL_PNGDEC_ERROR_OPEN_FILE;
 
 		// Get size of file
-		MemoryAllocator<CellFsStat> sb; // Alloc a CellFsStat struct
-		ret = cellFsFstat(current_subHandle->fd, sb.GetAddr());
+		vm::var<CellFsStat> sb; // Alloc a CellFsStat struct
+		ret = cellFsFstat(current_subHandle->fd, sb.addr());
 		if(ret != CELL_OK) return ret;
 		current_subHandle->fileSize = sb->st_size;	// Get CellFsStat.st_size
 		break;
@@ -97,12 +98,12 @@ int cellPngDecExtOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc
 
 	cellPngDec->Warning("*** cbCtrlStrm->cbCtrlStrmFunc_addr=0x%x", cbCtrlStrm->cbCtrlStrmFunc.GetAddr());
 
-	MemoryAllocator<CellPngDecStrmInfo> streamInfo;
-	MemoryAllocator<CellPngDecStrmParam> streamParam;
+	vm::var<CellPngDecStrmInfo> streamInfo;
+	vm::var<CellPngDecStrmParam> streamParam;
 
 	int res = cellPngDecOpen(mainHandle, subHandle, src, openInfo);
 
-	if (!res) cbCtrlStrm->cbCtrlStrmFunc(streamInfo.GetAddr(), streamParam.GetAddr(), cbCtrlStrm->cbCtrlStrmArg);
+	if (!res) cbCtrlStrm->cbCtrlStrmFunc(streamInfo.addr(), streamParam.addr(), cbCtrlStrm->cbCtrlStrmArg);
 
 	return res;
 }
@@ -139,32 +140,33 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo
 	if(fileSize < 29) return CELL_PNGDEC_ERROR_HEADER;	// Error: The file is smaller than the length of a PNG header
 	
 	//Write the header to buffer
-	MemoryAllocator<be_t<u32>> buffer(34); // Alloc buffer for PNG header
-	MemoryAllocator<be_t<u64>> pos, nread;
+	vm::var<u8[34]> buffer; // Alloc buffer for PNG header
+	auto buffer_32 = buffer.To<be_t<u32>>();
+	vm::var<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
 	case se32(CELL_PNGDEC_BUFFER):
-		if (!Memory.Copy(buffer.GetAddr(), subHandle_data->src.streamPtr.ToLE(), buffer.GetSize()))
+		if (!Memory.Copy(buffer.addr(), subHandle_data->src.streamPtr.ToLE(), buffer.size()))
 		{
 			cellPngDec->Error("cellPngDecReadHeader() failed ()");
 			return CELL_EFAULT;
 		}
 		break;
 	case se32(CELL_PNGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread.GetAddr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
+		cellFsRead(fd, buffer.addr(), buffer.size(), nread.addr());
 		break;
 	}
 
-	if (buffer[0] != 0x89504E47 ||
-		buffer[1] != 0x0D0A1A0A ||  // Error: The first 8 bytes are not a valid PNG signature
-		buffer[3] != 0x49484452)   // Error: The PNG file does not start with an IHDR chunk
+	if (buffer_32[0].ToBE() != se32(0x89504E47) ||
+		buffer_32[1].ToBE() != se32(0x0D0A1A0A) ||  // Error: The first 8 bytes are not a valid PNG signature
+		buffer_32[3].ToBE() != se32(0x49484452))   // Error: The PNG file does not start with an IHDR chunk
 	{
 		return CELL_PNGDEC_ERROR_HEADER; 
 	}
 
-	switch (buffer.To<u8>()[25])
+	switch (buffer[25])
 	{
 	case 0: current_info.colorSpace = CELL_PNGDEC_GRAYSCALE;       current_info.numComponents = 1; break;
 	case 2: current_info.colorSpace = CELL_PNGDEC_RGB;             current_info.numComponents = 3; break;
@@ -174,10 +176,10 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo
 	default: return CELL_PNGDEC_ERROR_HEADER; // Not supported color type
 	}
 
-	current_info.imageWidth       = buffer[4];
-	current_info.imageHeight      = buffer[5];
-	current_info.bitDepth         = buffer.To<u8>()[24];
-	current_info.interlaceMethod  = buffer.To<u8>()[28];
+	current_info.imageWidth       = buffer_32[4];
+	current_info.imageHeight      = buffer_32[5];
+	current_info.bitDepth         = buffer[24];
+	current_info.interlaceMethod  = buffer[28];
 	current_info.chunkInformation = 0; // Unimplemented
 
 	*info = current_info;
@@ -208,21 +210,21 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	const CellPngDecOutParam& current_outParam = subHandle_data->outParam;
 
 	//Copy the PNG file to a buffer
-	MemoryAllocator<unsigned char> png(fileSize);
-	MemoryAllocator<u64> pos, nread;
+	vm::var<unsigned char[]> png(fileSize);
+	vm::var<u64> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
 	case se32(CELL_PNGDEC_BUFFER):
-		if (!Memory.Copy(png.GetAddr(), subHandle_data->src.streamPtr.ToLE(), png.GetSize())) {
+		if (!Memory.Copy(png.addr(), subHandle_data->src.streamPtr.ToLE(), png.size())) {
 			cellPngDec->Error("cellPngDecDecodeData() failed (I)");
 			return CELL_EFAULT;
 		}
 		break;
 
 	case se32(CELL_PNGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, png.GetAddr(), png.GetSize(), nread.GetAddr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
+		cellFsRead(fd, png.addr(), png.size(), nread.addr());
 		break;
 	}
 
@@ -230,7 +232,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	int width, height, actual_components;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 			(
-				stbi_load_from_memory(png.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+				stbi_load_from_memory(png.ptr(), fileSize, &width, &height, &actual_components, 4),
 				&::free
 			);
 	if (!image)	return CELL_PNGDEC_ERROR_STREAM_FORMAT;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
index bf073c0439..548b13de76 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@@ -839,13 +839,13 @@ int cellRescSetDisplayMode(u32 displayMode)
 		else			  m_pCFragmentShader = m_pCFragmentShaderArray[RESC_SHADER_DEFAULT_BILINEAR];
 	}*/
 
-	MemoryAllocator<CellVideoOutConfiguration> videocfg;
+	vm::var<CellVideoOutConfiguration> videocfg;
 	videocfg->resolutionId = RescBufferMode2SysutilResolutionId(s_rescInternalInstance->m_dstMode);
 	videocfg->format       = RescDstFormat2SysutilFormat(s_rescInternalInstance->m_pRescDsts->format );
 	videocfg->aspect       = CELL_VIDEO_OUT_ASPECT_AUTO;
 	videocfg->pitch        = s_rescInternalInstance->m_dstPitch;
 
-	cellVideoOutConfigure(CELL_VIDEO_OUT_PRIMARY, videocfg.GetAddr(), 0, 0);
+	cellVideoOutConfigure(CELL_VIDEO_OUT_PRIMARY, videocfg.addr(), 0, 0);
 
 	if (IsPalInterpolate())
 	{
@@ -1141,8 +1141,8 @@ int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t
 	s_rescInternalInstance->m_vertexArrayEA   = vertexArray.GetAddr();
 	s_rescInternalInstance->m_fragmentUcodeEA = fragmentShader.GetAddr();
 
-	MemoryAllocator<be_t<u32>> dstOffset;
-	cellGcmAddressToOffset(s_rescInternalInstance->m_colorBuffersEA, dstOffset.GetAddr());
+	vm::var<be_t<u32>> dstOffset;
+	cellGcmAddressToOffset(s_rescInternalInstance->m_colorBuffersEA, dstOffset.addr());
 
 	for (int i=0; i<GetNumColorBuffers(); i++)
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
index aae129c92a..36968270bc 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
@@ -702,10 +702,10 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, mem_func_ptr_
 	if (dirName.size() != 9)
 		return CELL_HDDGAME_ERROR_PARAM;
 
-	MemoryAllocator<CellHddGameSystemFileParam> param;
-	MemoryAllocator<CellHddGameCBResult> result;
-	MemoryAllocator<CellHddGameStatGet> get;
-	MemoryAllocator<CellHddGameStatSet> set;
+	vm::var<CellHddGameSystemFileParam> param;
+	vm::var<CellHddGameCBResult> result;
+	vm::var<CellHddGameStatGet> get;
+	vm::var<CellHddGameStatSet> set;
 
 	get->hddFreeSizeKB = 40 * 1024 * 1024; // 40 GB, TODO: Use the free space of the computer's HDD where RPCS3 is being run.
 	get->isNewData = CELL_HDDGAME_ISNEWDATA_EXIST;
@@ -751,7 +751,7 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, mem_func_ptr_
 
 	// TODO ?
 
-	funcStat(result.GetAddr(), get.GetAddr(), set.GetAddr());
+	funcStat(result.addr(), get.addr(), set.addr());
 	if (result->result != CELL_HDDGAME_CBRESULT_OK &&
 		result->result != CELL_HDDGAME_CBRESULT_OK_CANCEL)
 		return CELL_HDDGAME_ERROR_CBRESULT;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index b3c3cb2d27..1c95018fda 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -217,8 +217,8 @@ void getSaveDataStat(SaveDataEntry entry, mem_ptr_t<CellSaveDataStatGet> statGet
 
 s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_ptr_t<CellSaveDataCBResult> result, const std::string& saveDataDir)
 {
-	MemoryAllocator<CellSaveDataFileGet> fileGet;
-	MemoryAllocator<CellSaveDataFileSet> fileSet;
+	vm::var<CellSaveDataFileGet> fileGet;
+	vm::var<CellSaveDataFileSet> fileSet;
 
 	if (!Emu.GetVFS().ExistsDir(saveDataDir))
 		Emu.GetVFS().CreateDir(saveDataDir);
@@ -226,7 +226,7 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
 	fileGet->excSize = 0;
 	while (true)
 	{
-		funcFile(result.GetAddr(), fileGet.GetAddr(), fileSet.GetAddr());
+		funcFile(result.GetAddr(), fileGet.addr(), fileSet.addr());
 		if (result->result < 0)	{
 			LOG_ERROR(HLE, "modifySaveDataFiles: CellSaveDataFileCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 			return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -298,11 +298,11 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	if (!setList.IsGood() || !setBuf.IsGood() || !funcList.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
 		return CELL_SAVEDATA_ERROR_PARAM;
 
-	MemoryAllocator<CellSaveDataCBResult> result;
-	MemoryAllocator<CellSaveDataListGet> listGet;
-	MemoryAllocator<CellSaveDataListSet> listSet;
-	MemoryAllocator<CellSaveDataStatGet> statGet;
-	MemoryAllocator<CellSaveDataStatSet> statSet;
+	vm::var<CellSaveDataCBResult> result;
+	vm::var<CellSaveDataListGet> listGet;
+	vm::var<CellSaveDataListSet> listSet;
+	vm::var<CellSaveDataStatGet> statGet;
+	vm::var<CellSaveDataStatSet> statSet;
 
 	std::string saveBaseDir = "/dev_hdd0/home/00000001/savedata/"; // TODO: Get the path of the current user
 	vfsDir dir(saveBaseDir);
@@ -330,13 +330,15 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
 	listGet->dirList.SetAddr(setBuf->buf_addr);
 	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
-	for (u32 i=0; i<saveEntries.size(); i++) {
+	for (u32 i=0; i<saveEntries.size(); i++)
+	{
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
 
-	funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr());
-	if (result->result < 0)	{
+	funcList(result.addr(), listGet.addr(), listSet.addr());
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataListSave2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -346,7 +348,8 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
 	if (listSet->newData.IsGood())
 		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
-	if (saveEntries.size() == 0) {
+	if (saveEntries.size() == 0)
+	{
 		LOG_WARNING(HLE, "cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
 	}
@@ -354,10 +357,10 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	u32 focusIndex = focusSaveDataEntry(saveEntries, listSet->focusPosition);
 	// TODO: Display the dialog here
 	u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
-	getSaveDataStat(saveEntries[selectedIndex], statGet.GetAddr());
+	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
+	funcStat(result.addr(), statGet.addr(), statSet.addr());
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
 		LOG_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -368,7 +371,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.GetAddr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
@@ -383,11 +386,11 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	if (!setList.IsGood() || !setBuf.IsGood() || !funcList.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
 		return CELL_SAVEDATA_ERROR_PARAM;
 
-	MemoryAllocator<CellSaveDataCBResult> result;
-	MemoryAllocator<CellSaveDataListGet> listGet;
-	MemoryAllocator<CellSaveDataListSet> listSet;
-	MemoryAllocator<CellSaveDataStatGet> statGet;
-	MemoryAllocator<CellSaveDataStatSet> statSet;
+	vm::var<CellSaveDataCBResult> result;
+	vm::var<CellSaveDataListGet> listGet;
+	vm::var<CellSaveDataListSet> listSet;
+	vm::var<CellSaveDataStatGet> statGet;
+	vm::var<CellSaveDataStatSet> statSet;
 
 	std::string saveBaseDir = "/dev_hdd0/home/00000001/savedata/"; // TODO: Get the path of the current user
 	vfsDir dir(saveBaseDir);
@@ -415,13 +418,15 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
 	listGet->dirList.SetAddr(setBuf->buf_addr);
 	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
-	for (u32 i=0; i<saveEntries.size(); i++) {
+	for (u32 i=0; i<saveEntries.size(); i++)
+	{
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
 
-	funcList(result.GetAddr(), listGet.GetAddr(), listSet.GetAddr());
-	if (result->result < 0)	{
+	funcList(result.addr(), listGet.addr(), listSet.addr());
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -431,7 +436,8 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
 	if (listSet->newData.IsGood())
 		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
-	if (saveEntries.size() == 0) {
+	if (saveEntries.size() == 0)
+	{
 		LOG_WARNING(HLE, "cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
 	}
@@ -439,12 +445,13 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	u32 focusIndex = focusSaveDataEntry(saveEntries, listSet->focusPosition);
 	// TODO: Display the dialog here
 	u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
-	getSaveDataStat(saveEntries[selectedIndex], statGet.GetAddr());
+	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
+	funcStat(result.addr(), statGet.addr(), statSet.addr());
 	Memory.Free(statGet->fileList.GetAddr());
-	if (result->result < 0)	{
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -453,7 +460,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.GetAddr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
@@ -468,11 +475,11 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	if (!setList.IsGood() || !setBuf.IsGood() || !funcFixed.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
 		return CELL_SAVEDATA_ERROR_PARAM;
 
-	MemoryAllocator<CellSaveDataCBResult> result;
-	MemoryAllocator<CellSaveDataListGet> listGet;
-	MemoryAllocator<CellSaveDataFixedSet> fixedSet;
-	MemoryAllocator<CellSaveDataStatGet> statGet;
-	MemoryAllocator<CellSaveDataStatSet> statSet;
+	vm::var<CellSaveDataCBResult> result;
+	vm::var<CellSaveDataListGet> listGet;
+	vm::var<CellSaveDataFixedSet> fixedSet;
+	vm::var<CellSaveDataStatGet> statGet;
+	vm::var<CellSaveDataStatSet> statSet;
 
 	std::string saveBaseDir = "/dev_hdd0/home/00000001/savedata/"; // TODO: Get the path of the current user
 	vfsDir dir(saveBaseDir);
@@ -500,23 +507,26 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
 	listGet->dirList.SetAddr(setBuf->buf_addr);
 	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
-	for (u32 i = 0; i<saveEntries.size(); i++) {
+	for (u32 i = 0; i<saveEntries.size(); i++)
+	{
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
-	funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr());
-	if (result->result < 0)	{
+	funcFixed(result.addr(), listGet.addr(), fixedSet.addr());
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	setSaveDataFixed(saveEntries, fixedSet.GetAddr());
-	getSaveDataStat(saveEntries[0], statGet.GetAddr()); // There should be only one element in this list
+	setSaveDataFixed(saveEntries, fixedSet.addr());
+	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
 	// TODO: Display the Yes|No dialog here
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
+	funcStat(result.addr(), statGet.addr(), statSet.addr());
 	Memory.Free(statGet->fileList.GetAddr());
-	if (result->result < 0)	{
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -525,7 +535,7 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.GetAddr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
@@ -540,11 +550,11 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	if (!setList.IsGood() || !setBuf.IsGood() || !funcFixed.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
 		return CELL_SAVEDATA_ERROR_PARAM;
 
-	MemoryAllocator<CellSaveDataCBResult> result;
-	MemoryAllocator<CellSaveDataListGet> listGet;
-	MemoryAllocator<CellSaveDataFixedSet> fixedSet;
-	MemoryAllocator<CellSaveDataStatGet> statGet;
-	MemoryAllocator<CellSaveDataStatSet> statSet;
+	vm::var<CellSaveDataCBResult> result;
+	vm::var<CellSaveDataListGet> listGet;
+	vm::var<CellSaveDataFixedSet> fixedSet;
+	vm::var<CellSaveDataStatGet> statGet;
+	vm::var<CellSaveDataStatSet> statSet;
 
 	std::string saveBaseDir = "/dev_hdd0/home/00000001/savedata/"; // TODO: Get the path of the current user
 	vfsDir dir(saveBaseDir);
@@ -572,23 +582,26 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
 	listGet->dirList.SetAddr(setBuf->buf_addr);
 	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
-	for (u32 i = 0; i<saveEntries.size(); i++) {
+	for (u32 i = 0; i<saveEntries.size(); i++)
+	{
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
-	funcFixed(result.GetAddr(), listGet.GetAddr(), fixedSet.GetAddr());
-	if (result->result < 0)	{
+	funcFixed(result.addr(), listGet.addr(), fixedSet.addr());
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	setSaveDataFixed(saveEntries, fixedSet.GetAddr());
-	getSaveDataStat(saveEntries[0], statGet.GetAddr()); // There should be only one element in this list
+	setSaveDataFixed(saveEntries, fixedSet.addr());
+	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
 	// TODO: Display the Yes|No dialog here
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
+	funcStat(result.addr(), statGet.addr(), statSet.addr());
 	Memory.Free(statGet->fileList.GetAddr());
-	if (result->result < 0)	{
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -597,7 +610,7 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.GetAddr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
@@ -612,9 +625,9 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	if (!setBuf.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
 		return CELL_SAVEDATA_ERROR_PARAM;
 
-	MemoryAllocator<CellSaveDataCBResult> result;
-	MemoryAllocator<CellSaveDataStatGet> statGet;
-	MemoryAllocator<CellSaveDataStatSet> statSet;
+	vm::var<CellSaveDataCBResult> result;
+	vm::var<CellSaveDataStatGet> statGet;
+	vm::var<CellSaveDataStatSet> statSet;
 
 	std::string saveBaseDir = "/dev_hdd0/home/00000001/savedata/"; // TODO: Get the path of the current user
 	vfsDir dir(saveBaseDir);
@@ -625,13 +638,15 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	std::vector<SaveDataEntry> saveEntries;
 	for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
 	{
-		if (entry->flags & DirEntry_TypeDir && entry->name == dirName) {
+		if (entry->flags & DirEntry_TypeDir && entry->name == dirName)
+		{
 			addSaveDataEntry(saveEntries, saveBaseDir+dirName);
 		}
 	}
 
 	// The target entry does not exist
-	if (saveEntries.size() == 0) {
+	if (saveEntries.size() == 0)
+	{
 		SaveDataEntry entry;
 		entry.dirName = dirName;
 		entry.sizeKB = 0;
@@ -639,12 +654,13 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 		saveEntries.push_back(entry);
 	}
 
-	getSaveDataStat(saveEntries[0], statGet.GetAddr()); // There should be only one element in this list
+	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
 	result->userdata_addr = userdata_addr;
-	funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
+	funcStat(result.addr(), statGet.addr(), statSet.addr());
 
 	Memory.Free(statGet->fileList.GetAddr());
-	if (result->result < 0)	{
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -653,7 +669,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.GetAddr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
 
 	return CELL_SAVEDATA_RET_OK;
 }
@@ -668,9 +684,9 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	if (!setBuf.IsGood() || !funcStat.IsGood() || !funcFile.IsGood())
 		return CELL_SAVEDATA_ERROR_PARAM;
 
-	MemoryAllocator<CellSaveDataCBResult> result;
-	MemoryAllocator<CellSaveDataStatGet> statGet;
-	MemoryAllocator<CellSaveDataStatSet> statSet;
+	vm::var<CellSaveDataCBResult> result;
+	vm::var<CellSaveDataStatGet> statGet;
+	vm::var<CellSaveDataStatSet> statSet;
 
 	std::string saveBaseDir = "/dev_hdd0/home/00000001/savedata/"; // TODO: Get the path of the current user
 	vfsDir dir(saveBaseDir);
@@ -681,7 +697,8 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	std::vector<SaveDataEntry> saveEntries;
 	for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
 	{
-		if (entry->flags & DirEntry_TypeDir && entry->name == dirName) {
+		if (entry->flags & DirEntry_TypeDir && entry->name == dirName)
+		{
 			addSaveDataEntry(saveEntries, saveBaseDir+dirName);
 		}
 	}
@@ -692,12 +709,13 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 		return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found?
 	}
 
-	getSaveDataStat(saveEntries[0], statGet.GetAddr()); // There should be only one element in this list
+	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
 	result->userdata_addr = userdata_addr;
-	funcStat(result.GetAddr(), statGet.GetAddr(), statSet.GetAddr());
+	funcStat(result.addr(), statGet.addr(), statSet.addr());
 
 	Memory.Free(statGet->fileList.GetAddr());
-	if (result->result < 0)	{
+	if (result->result < 0)
+	{
 		LOG_ERROR(HLE, "cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
@@ -706,7 +724,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.GetAddr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
 
 	return CELL_SAVEDATA_RET_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
index be6fe5291d..488fa3bee2 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
@@ -246,14 +246,14 @@ int cellFsReadWithOffset(u32 fd, u64 offset, u32 buf_addr, u64 buffer_size, mem6
 		fd, offset, buf_addr, buffer_size, nread.GetAddr());
 
 	int ret;
-	MemoryAllocator<be_t<u64>> oldPos, newPos;
-	ret = cellFsLseek(fd, 0, CELL_SEEK_CUR, oldPos.GetAddr());       // Save the current position
+	vm::var<be_t<u64>> oldPos, newPos;
+	ret = cellFsLseek(fd, 0, CELL_SEEK_CUR, oldPos.addr());       // Save the current position
 	if (ret) return ret;
-	ret = cellFsLseek(fd, offset, CELL_SEEK_SET, newPos.GetAddr());  // Move to the specified offset
+	ret = cellFsLseek(fd, offset, CELL_SEEK_SET, newPos.addr());  // Move to the specified offset
 	if (ret) return ret;
 	ret = cellFsRead(fd, buf_addr, buffer_size, nread.GetAddr());    // Read the file
 	if (ret) return ret;
-	ret = cellFsLseek(fd, Memory.Read64(oldPos.GetAddr()), CELL_SEEK_SET, newPos.GetAddr());  // Return to the old position
+	ret = cellFsLseek(fd, oldPos.value(), CELL_SEEK_SET, newPos.addr());  // Return to the old position
 	if (ret) return ret;
 
 	return CELL_OK;
diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj
index 0465079533..f576cfabe6 100644
--- a/rpcs3/emucore.vcxproj
+++ b/rpcs3/emucore.vcxproj
@@ -313,6 +313,10 @@
     <ClInclude Include="Emu\Memory\DynamicMemoryBlockBase.h" />
     <ClInclude Include="Emu\Memory\Memory.h" />
     <ClInclude Include="Emu\Memory\MemoryBlock.h" />
+    <ClInclude Include="Emu\Memory\vm.h" />
+    <ClInclude Include="Emu\Memory\vm_ptr.h" />
+    <ClInclude Include="Emu\Memory\vm_ref.h" />
+    <ClInclude Include="Emu\Memory\vm_var.h" />
     <ClInclude Include="Emu\SysCalls\Callback.h" />
     <ClInclude Include="Emu\SysCalls\ErrorCodes.h" />
     <ClInclude Include="Emu\SysCalls\LogBase.h" />
diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters
index 11ce9c141d..44c5720d14 100644
--- a/rpcs3/emucore.vcxproj.filters
+++ b/rpcs3/emucore.vcxproj.filters
@@ -1096,5 +1096,17 @@
     <ClInclude Include="Emu\SysCalls\LogBase.h">
       <Filter>Emu\SysCalls</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\Memory\vm.h">
+      <Filter>Emu\Memory</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\Memory\vm_ptr.h">
+      <Filter>Emu\Memory</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\Memory\vm_ref.h">
+      <Filter>Emu\Memory</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\Memory\vm_var.h">
+      <Filter>Emu\Memory</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file

From 7411012db9b6659eed131592d54a7de8bd976d01 Mon Sep 17 00:00:00 2001
From: DHrpcs3 <dh.rpcs3@gmail.com>
Date: Fri, 1 Aug 2014 19:27:48 +0300
Subject: [PATCH 02/36] Fixed compilation errors Implemented vm::ptr & vm::ref

---
 rpcs3/Emu/Memory/vm.cpp       |  44 ++++
 rpcs3/Emu/Memory/vm.h         |  59 ++----
 rpcs3/Emu/Memory/vm_ptr.h     | 382 +++++++++++++++++++++++++++++++++-
 rpcs3/Emu/Memory/vm_ref.h     |  59 +++++-
 rpcs3/Emu/Memory/vm_var.h     |  38 ++--
 rpcs3/emucore.vcxproj         |   3 +-
 rpcs3/emucore.vcxproj.filters |   3 +
 7 files changed, 523 insertions(+), 65 deletions(-)
 create mode 100644 rpcs3/Emu/Memory/vm.cpp

diff --git a/rpcs3/Emu/Memory/vm.cpp b/rpcs3/Emu/Memory/vm.cpp
new file mode 100644
index 0000000000..a475b85eb7
--- /dev/null
+++ b/rpcs3/Emu/Memory/vm.cpp
@@ -0,0 +1,44 @@
+#include "stdafx.h"
+
+namespace vm
+{
+	//TODO
+	bool check_addr(u32 addr)
+	{
+		return false;
+	}
+
+	bool map(u32 addr, u32 size, u32 flags)
+	{
+		return false;
+	}
+
+	bool unmap(u32 addr, u32 size, u32 flags)
+	{
+		return false;
+	}
+
+	u32 alloc(u32 size)
+	{
+		return 0;
+	}
+
+	void unalloc(u32 addr)
+	{
+	}
+
+	u32 read32(u32 addr)
+	{
+		return 0;
+	}
+
+	bool read32(u32 addr, u32& value)
+	{
+		return false;
+	}
+
+	bool write32(u32 addr, u32 value)
+	{
+		return false;
+	}
+}
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
index b1858c4597..97a43cb78a 100644
--- a/rpcs3/Emu/Memory/vm.h
+++ b/rpcs3/Emu/Memory/vm.h
@@ -2,45 +2,28 @@
 
 namespace vm
 {
+	bool check_addr(u32 addr);
+	bool map(u32 addr, u32 size, u32 flags);
+	bool unmap(u32 addr, u32 size = 0, u32 flags = 0);
+	u32 alloc(u32 size);
+	void unalloc(u32 addr);
+	
+	template<typename T>
+	T* get_ptr(u32 addr)
+	{
+		return (T*)&Memory[addr];
+	}
+	
+	template<typename T>
+	T& get_ref(u32 addr)
+	{
+		return (T&)Memory[addr];
+	}
+
 	//TODO
-	bool check_addr(u32 addr)
-	{
-		return false;
-	}
-
-	bool map(u32 addr, u32 size, u32 flags)
-	{
-		return false;
-	}
-
-	bool unmap(u32 addr, u32 size = 0, u32 flags = 0)
-	{
-		return false;
-	}
-
-	u32 alloc(u32 size)
-	{
-		return 0;
-	}
-
-	void unalloc(u32 addr)
-	{
-	}
-
-	u32 read32(u32 addr)
-	{
-		return 0;
-	}
-
-	bool read32(u32 addr, u32& value)
-	{
-		return false;
-	}
-
-	bool write32(u32 addr, u32 value)
-	{
-		return false;
-	}
+	u32 read32(u32 addr);
+	bool read32(u32 addr, u32& value);
+	bool write32(u32 addr, u32 value);
 }
 
 #include "vm_ptr.h"
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 629a59dc91..3003f11e66 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -2,5 +2,385 @@
 
 namespace vm
 {
-	//TODO
+	template<typename T, int lvl = 1, typename AT = u32>
+	class ptr
+	{
+		AT m_addr;
+
+	public:
+		ptr operator++ (int)
+		{
+			AT result = m_addr;
+			m_addr += sizeof(AT);
+			return { result };
+		}
+
+		ptr& operator++ ()
+		{
+			m_addr += sizeof(AT);
+			return *this;
+		}
+
+		ptr operator-- (int)
+		{
+			AT result = m_addr;
+			m_addr -= sizeof(AT);
+			return { result };
+		}
+
+		ptr& operator-- ()
+		{
+			m_addr -= sizeof(AT);
+			return *this;
+		}
+
+		ptr& operator += (int count)
+		{
+			m_addr += count * sizeof(AT);
+			return *this;
+		}
+
+		ptr& operator -= (int count)
+		{
+			m_addr -= count * sizeof(AT);
+			return *this;
+		}
+
+		ptr operator + (int count) const
+		{
+			return { m_addr + count * sizeof(AT) };
+		}
+
+		ptr operator - (int count) const
+		{
+			return { m_addr - count * sizeof(AT) };
+		}
+
+		__forceinline ptr<T, lvl - 1, AT>& operator *()
+		{
+			return get_ref<ptr<T, lvl - 1, AT>>(m_addr);
+		}
+
+		__forceinline const ptr<T, lvl - 1, AT>& operator *() const
+		{
+			return get_ref<const ptr<T, lvl - 1, AT>>(m_addr);
+		}
+
+		__forceinline ptr<T, lvl - 1, AT>& operator [](int index)
+		{
+			return get_ref<ptr<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
+		}
+
+		__forceinline const ptr<T, lvl - 1, AT>& operator [](int index) const
+		{
+			return get_ref<const ptr<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
+		}
+
+		operator bool() const
+		{
+			return m_addr != 0;
+		}
+		
+		AT addr() const
+		{
+			return m_addr;
+		}
+		
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr, sizeof(AT));
+		}
+
+		static ptr make(u32 addr)
+		{
+			return (ptr&)addr;
+		}
+	};
+	
+	template<typename T, typename AT>
+	class ptr<T, 1, AT>
+	{
+		AT m_addr;
+		
+	public:
+		__forceinline T* operator -> ()
+		{
+			return get_ptr<T>(m_addr);
+		}
+
+		__forceinline const T* operator -> () const
+		{
+			return get_ptr<const T>(m_addr);
+		}
+
+		ptr operator++ (int)
+		{
+			AT result = m_addr;
+			m_addr += sizeof(T);
+			return { result };
+		}
+
+		ptr& operator++ ()
+		{
+			m_addr += sizeof(T);
+			return *this;
+		}
+
+		ptr operator-- (int)
+		{
+			AT result = m_addr;
+			m_addr -= sizeof(T);
+			return { result };
+		}
+
+		ptr& operator-- ()
+		{
+			m_addr -= sizeof(T);
+			return *this;
+		}
+
+		ptr& operator += (int count)
+		{
+			m_addr += count * sizeof(T);
+			return *this;
+		}
+
+		ptr& operator -= (int count)
+		{
+			m_addr -= count * sizeof(T);
+			return *this;
+		}
+
+		ptr operator + (int count) const
+		{
+			return { m_addr + count * sizeof(T) };
+		}
+
+		ptr operator - (int count) const
+		{
+			return { m_addr - count * sizeof(T) };
+		}
+
+		__forceinline T& operator *()
+		{
+			return get_ref<T>(m_addr);
+		}
+
+		__forceinline const T& operator *() const
+		{
+			return get_ref<T>(m_addr);
+		}
+
+		__forceinline T& operator [](int index)
+		{
+			return get_ref<T>(m_addr + sizeof(T) * index);
+		}
+
+		__forceinline const T& operator [](int index) const
+		{
+			return get_ref<const T>(m_addr + sizeof(T) * index);
+		}
+		
+		/*
+		operator ref<T>()
+		{
+			return { m_addr };
+		}
+		
+		operator const ref<T>() const
+		{
+			return { m_addr };
+		}
+		*/
+		
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		operator bool() const
+		{
+			return m_addr != 0;
+		}
+
+		T* get_ptr() const
+		{
+			return vm::get_ptr<T>(m_addr);
+		}
+		
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr, sizeof(T));
+		}
+
+		static ptr make(u32 addr)
+		{
+			return (ptr&)addr;
+		}
+	};
+
+	template<typename AT>
+	class ptr<void, 1, AT>
+	{
+		AT m_addr;
+		
+	public:
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		void* get_ptr() const
+		{
+			return vm::get_ptr<void>(m_addr);
+		}
+		
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr);
+		}
+
+		operator bool() const
+		{
+			return m_addr != 0;
+		}
+
+		static ptr make(u32 addr)
+		{
+			return (ptr&)addr;
+		}
+	};
+	
+	template<typename RT, typename AT>
+	class ptr<RT(*)(), 1, AT>
+	{
+		AT m_addr;
+
+		__forceinline RT call_func(bool is_async) const
+		{
+			Callback cb;
+			cb.SetAddr(m_addr);
+			return (RT)cb.Branch(!is_async);
+		}
+
+	public:
+		typedef RT(*type)();
+
+		__forceinline RT operator()() const
+		{
+			return call_func(false);
+		}
+
+		__forceinline void async() const
+		{
+			call_func(true);
+		}
+
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		type get_ptr() const
+		{
+			return *((type*)vm::get_ptr<void*>(m_addr));
+		}
+
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr);
+		}
+
+		operator bool() const
+		{
+			return m_addr != 0;
+		}
+
+		static ptr make(u32 addr)
+		{
+			return (ptr&)addr;
+		}
+	};
+
+	template<typename AT, typename RT, typename ...T>
+	class ptr<RT(*)(T...), 1, AT>
+	{
+		AT m_addr;
+
+		__forceinline RT call_func(bool is_async, T... args) const
+		{
+			template<typename T>
+			struct _func_arg
+			{
+				__forceinline static u64 get_value(const T& arg)
+				{
+					return arg;
+				}
+			};
+
+			template<typename T, typename AT>
+			struct _func_arg<ptr<T, AT>>
+			{
+				__forceinline static u64 get_value(const ptr<T, AT> arg)
+				{
+					return arg.addr();
+				}
+			};
+
+			template<typename T, typename AT>
+			struct _func_arg<ref<T, AT>>
+			{
+				__forceinline static u64 get_value(const ref<T, AT> arg)
+				{
+					return arg.addr();
+				}
+			};
+
+			Callback cb;
+			cb.SetAddr(m_addr);
+			cb.Handle(_func_arg<T>::get_value(args)...);
+			return (RT)cb.Branch(!is_async);
+		}
+
+	public:
+		typedef RT(*type)(T...);
+
+		__forceinline RT operator()(T... args) const
+		{
+			return call_func(false, args...);
+		}
+
+		__forceinline void async(T... args) const
+		{
+			call_func(true, args...);
+		}
+
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		type get_ptr() const
+		{
+			return *((type*)vm::get_ptr<void*>(m_addr));
+		}
+
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr);
+		}
+
+		operator bool() const
+		{
+			return m_addr != 0;
+		}
+
+		static ptr make(u32 addr)
+		{
+			return (ptr&)addr;
+		}
+	};
+
+	template<typename T, int lvl = 1, typename AT = u32>
+	class beptr : public ptr<T, lvl, be_t<AT>> {};
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 629a59dc91..797c6da784 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -2,5 +2,62 @@
 
 namespace vm
 {
-	//TODO
+	template<typename T, typename AT = u32>
+	class _ref_base
+	{
+		AT m_addr;
+
+	public:
+		operator T&()
+		{
+			return get_ref<T>(m_addr);
+		}
+
+		operator const T&() const
+		{
+			return get_ref<const T>(m_addr);
+		}
+
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		bool check() const
+		{
+			return Memory.IsGoodAddr(m_addr, sizeof(T));
+		}
+
+		static ref make(u32 addr)
+		{
+			return (ref&)addr;
+		}
+	};
+
+	//BE reference to LE data
+	template<typename T, typename AT = u32> class brefl : public _ref_base<T, be_t<AT>> {};
+
+	//BE reference to BE data
+	template<typename T, typename AT = u32> class brefb : public _ref_base<be_t<T>, be_t<AT>> {};
+
+	//LE reference to BE data
+	template<typename T, typename AT = u32> class lrefb : public _ref_base<be_t<T>, AT> {};
+
+	//LE reference to LE data
+	template<typename T, typename AT = u32> class lrefl : public _ref_base<T, AT> {};
+
+	namespace ps3
+	{
+		//default reference for HLE functions (LE reference to BE data)
+		template<typename T, typename AT = u32> class ref : public lrefb {};
+
+		//default reference for HLE structures (BE reference to BE data)
+		template<typename T, typename AT = u32> class bref : public brefb {};
+	}
+
+	namespace psv
+	{
+		//default reference for HLE functions & structures (LE reference to LE data)
+		template<typename T, typename AT = u32> class ref : public lrefl {};
+	}
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index bc4a99422c..adb4338c0d 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -34,7 +34,7 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? get_ptr<T>(m_addr) : nullptr;
 		}
 
 		void dealloc()
@@ -46,16 +46,6 @@ namespace vm
 				m_ptr = nullptr;
 			}
 		}
-
-		void clear()
-		{
-			if (check())
-			{
-				Memory.Free(m_addr);
-				m_addr = 0;
-				m_ptr = nullptr;
-			}
-		}
 		
 		static var make(u32 addr, u32 size = sizeof(T), u32 align = sizeof(T))
 		{
@@ -64,7 +54,7 @@ namespace vm
 			res.m_addr = addr;
 			res.m_size = size;
 			res.m_align = align;
-			res.m_ptr = Memory.IsGoodAddr(m_addr, sizeof(T)) ? (T*)&Memory[m_addr] : nullptr;
+			res.m_ptr = Memory.IsGoodAddr(addr, size) ? get_ptr<T>(addr) : nullptr;
 
 			return res;
 		}
@@ -166,7 +156,7 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? get_ptr<T>(m_addr) : nullptr;
 		}
 
 		void dealloc()
@@ -187,7 +177,7 @@ namespace vm
 			res.m_count = count;
 			res.m_size = size;
 			res.m_align = align;
-			res.m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+			res.m_ptr = Memory.IsGoodAddr(addr, size * count) ? get_ptr<T>(addr) : nullptr;
 
 			return res;
 		}
@@ -297,17 +287,17 @@ namespace vm
 		T& at(uint index)
 		{
 			if (index >= count())
-				throw std::out_of_range();
+				throw std::out_of_range(std::to_string(index) + " >= " + count());
 
-			return *(m_ptr + index);
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
 		}
 
 		const T& at(uint index) const
 		{
 			if (index >= count())
-				throw std::out_of_range();
+				throw std::out_of_range(std::to_string(index) + " >= " + count());
 
-			return *(m_ptr + index);
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
 		}
 
 		T* ptr()
@@ -365,7 +355,7 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? (T*)&Memory[m_addr] : nullptr;
+			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? get_ptr<T>(m_addr) : nullptr;
 		}
 
 		void dealloc()
@@ -479,23 +469,23 @@ namespace vm
 		const T& operator [](uint index) const
 		{
 			assert(index < count());
-			return return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
 		}
 		
 		T& at(uint index)
 		{
 			if (index >= count())
-				throw std::out_of_range();
+				throw std::out_of_range(std::to_string(index) + " >= " + count());
 
-			return *(m_ptr + index);
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
 		}
 		
 		const T& at(uint index) const
 		{
 			if (index >= count())
-				throw std::out_of_range();
+				throw std::out_of_range(std::to_string(index) + " >= " + count());
 
-			return *(m_ptr + index);
+			return *(T*)((u8*)m_ptr + (m_size < m_align ? m_align : m_size) * index);
 		}
 
 		/*
diff --git a/rpcs3/emucore.vcxproj b/rpcs3/emucore.vcxproj
index f576cfabe6..8029d613c3 100644
--- a/rpcs3/emucore.vcxproj
+++ b/rpcs3/emucore.vcxproj
@@ -90,6 +90,7 @@
     <ClCompile Include="Emu\Io\Mouse.cpp" />
     <ClCompile Include="Emu\Io\Pad.cpp" />
     <ClCompile Include="Emu\Memory\Memory.cpp" />
+    <ClCompile Include="Emu\Memory\vm.cpp" />
     <ClCompile Include="Emu\SysCalls\Callback.cpp" />
     <ClCompile Include="Emu\SysCalls\FuncList.cpp" />
     <ClCompile Include="Emu\SysCalls\lv2\lv2Fs.cpp" />
@@ -518,7 +519,7 @@
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug - MemLeak|x64'">
     <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
+      <WarningLevel>Level2</WarningLevel>
       <Optimization>Disabled</Optimization>
       <SDLCheck>false</SDLCheck>
       <PrecompiledHeader>Use</PrecompiledHeader>
diff --git a/rpcs3/emucore.vcxproj.filters b/rpcs3/emucore.vcxproj.filters
index 44c5720d14..ac5d371cdb 100644
--- a/rpcs3/emucore.vcxproj.filters
+++ b/rpcs3/emucore.vcxproj.filters
@@ -584,6 +584,9 @@
     <ClCompile Include="Emu\SysCalls\Modules\cellMsgDialog.cpp">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClCompile>
+    <ClCompile Include="Emu\Memory\vm.cpp">
+      <Filter>Emu\Memory</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Crypto\aes.h">

From 8dfe7138dfa12b7cca6f184b2da9635364b793de Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sat, 30 Aug 2014 17:52:12 +0400
Subject: [PATCH 03/36] (nothing, really)

---
 .gitignore                           |  1 +
 rpcs3/Emu/Cell/SPURecompiler.h       |  3 +++
 rpcs3/Emu/Cell/SPURecompilerCore.cpp | 29 ++++++++++++++++++++--------
 3 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/.gitignore b/.gitignore
index d9060700ad..a404287376 100644
--- a/.gitignore
+++ b/.gitignore
@@ -69,3 +69,4 @@ x64/Release/emucore.lib
 rpcs3/x64/*
 
 .DS_Store
+rpcs3/Emu/SysCalls/Modules/prx_*.h
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 2fc927b6f5..927edc1438 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -85,6 +85,9 @@ public:
 		u16 count; // count of instructions compiled from current point (and to be checked)
 		u32 valid; // copy of valid opcode for validation
 		void* pointer; // pointer to executable memory object
+#ifdef _WIN32
+		//_IMAGE_RUNTIME_FUNCTION_ENTRY info;
+#endif
 	};
 
 	SPURecEntry entry[0x10000];
diff --git a/rpcs3/Emu/Cell/SPURecompilerCore.cpp b/rpcs3/Emu/Cell/SPURecompilerCore.cpp
index daa2cf5882..6fb67f73f9 100644
--- a/rpcs3/Emu/Cell/SPURecompilerCore.cpp
+++ b/rpcs3/Emu/Cell/SPURecompilerCore.cpp
@@ -157,8 +157,23 @@ void SPURecompilerCore::Compile(u16 pos)
 	log.Open(fmt::Format("SPUjit_%d.log", GetCurrentSPUThread().GetId()), first ? rFile::write : rFile::write_append);
 	log.Write(fmt::Format("========== START POSITION 0x%x ==========\n\n", start * 4));
 	log.Write(std::string(stringLogger.getString()));
-	log.Write(fmt::Format("========== COMPILED %d (excess %d), time: [start=%lld (decoding=%lld), finalize=%lld]\n\n",
-		entry[start].count, excess, stamp1 - stamp0, time0, get_system_time() - stamp1));
+	if (!entry[start].pointer)
+	{
+		LOG_ERROR(Log::SPU, "SPURecompilerCore::Compile(pos=0x%x) failed", start * sizeof(u32));
+		log.Write("========== FAILED ============\n\n");
+		Emu.Pause();
+	}
+	else
+	{
+		log.Write(fmt::Format("========== COMPILED %d (excess %d), time: [start=%lld (decoding=%lld), finalize=%lld]\n\n",
+			entry[start].count, excess, stamp1 - stamp0, time0, get_system_time() - stamp1));
+#ifdef _WIN32
+		//if (!RtlAddFunctionTable(&info, 1, (u64)entry[start].pointer))
+		//{
+		//	LOG_ERROR(Log::SPU, "RtlAddFunctionTable() failed");
+		//}
+#endif
+	}
 	log.Close();
 	m_enc->compiler = nullptr;
 	first = false;
@@ -195,6 +210,9 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
 					i < (u32)pos + (u32)entry[pos].count)
 				{
 					runtime.release(entry[i].pointer);
+#ifdef _WIN32
+					//RtlDeleteFunctionTable(&entry[i].info);
+#endif
 					entry[i].pointer = nullptr;
 				}
 			}
@@ -215,12 +233,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
 		}
 	}
 
-	if (!entry[pos].pointer)
-	{
-		LOG_ERROR(Log::SPU, "SPURecompilerCore::DecodeMemory(ls_addr=0x%x): compilation failed", pos * sizeof(u32));
-		Emu.Pause();
-		return 0;
-	}
+	if (!entry[pos].pointer) return 0;
 
 	typedef u32(*Func)(const void* _cpu, const void* _ls, const void* _imm, const void* _g_imm);
 

From 3269c88d02a7e6fef584e4dfc326a2a49b12c6c5 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sat, 30 Aug 2014 21:51:00 +0400
Subject: [PATCH 04/36] Some warnings fixed, some code removed

---
 asmjit                               |   2 +-
 rpcs3/Emu/ARMv7/ARMv7Decoder.h       |   4 +-
 rpcs3/Emu/ARMv7/ARMv7DisAsm.h        |   2 +-
 rpcs3/Emu/ARMv7/ARMv7Interpreter.h   |   2 +-
 rpcs3/Emu/ARMv7/ARMv7Thread.cpp      |   2 +-
 rpcs3/Emu/ARMv7/ARMv7Thread.h        |   6 +-
 rpcs3/Emu/CPU/CPUThread.cpp          |   2 +-
 rpcs3/Emu/CPU/CPUThread.h            |   6 +-
 rpcs3/Emu/Cell/PPUInterpreter.h      | 146 +++++++++---------
 rpcs3/Emu/Cell/PPUThread.cpp         |   2 +-
 rpcs3/Emu/Cell/PPUThread.h           |  10 +-
 rpcs3/Emu/Cell/RawSPUThread.cpp      |   8 +-
 rpcs3/Emu/Cell/RawSPUThread.h        |   4 +-
 rpcs3/Emu/Cell/SPUInterpreter.h      |  10 +-
 rpcs3/Emu/Cell/SPURecompiler.h       |  58 +++----
 rpcs3/Emu/Cell/SPURecompilerCore.cpp |   2 +-
 rpcs3/Emu/Cell/SPUThread.h           |  20 +--
 rpcs3/Emu/IdManager.h                |   4 +-
 rpcs3/Emu/Memory/Memory.cpp          | 217 +--------------------------
 rpcs3/Emu/Memory/Memory.h            |   8 +-
 rpcs3/Emu/Memory/MemoryBlock.h       |  51 ++-----
 21 files changed, 166 insertions(+), 400 deletions(-)

diff --git a/asmjit b/asmjit
index 3363e4138b..d7fc62d9e9 160000
--- a/asmjit
+++ b/asmjit
@@ -1 +1 @@
-Subproject commit 3363e4138b003be36dfb63cf8c63cf360f04276f
+Subproject commit d7fc62d9e905859579f5965eee6f7f99b65c2246
diff --git a/rpcs3/Emu/ARMv7/ARMv7Decoder.h b/rpcs3/Emu/ARMv7/ARMv7Decoder.h
index 52e5960e42..5cf82205be 100644
--- a/rpcs3/Emu/ARMv7/ARMv7Decoder.h
+++ b/rpcs3/Emu/ARMv7/ARMv7Decoder.h
@@ -21,8 +21,8 @@ public:
 	virtual u8 DecodeMemory(const u64 address)
 	{
 		using namespace ARMv7_opcodes;
-		const u16 code0 = Memory.PSV.Read16(address);
-		const u16 code1 = Memory.PSV.Read16(address + 2);
+		const u16 code0 = Memory.PSV.Read16((u32)address);
+		const u16 code1 = Memory.PSV.Read16((u32)address + 2);
 
 		switch(code0 >> 12) //15 - 12
 		{
diff --git a/rpcs3/Emu/ARMv7/ARMv7DisAsm.h b/rpcs3/Emu/ARMv7/ARMv7DisAsm.h
index ba59fc0a26..cf84835cd8 100644
--- a/rpcs3/Emu/ARMv7/ARMv7DisAsm.h
+++ b/rpcs3/Emu/ARMv7/ARMv7DisAsm.h
@@ -22,7 +22,7 @@ public:
 protected:
 	virtual u32 DisAsmBranchTarget(const s32 imm)
 	{
-		return dump_pc + imm;
+		return (u32)dump_pc + imm;
 	}
 
 	std::string GetRegsListString(u16 regs_list)
diff --git a/rpcs3/Emu/ARMv7/ARMv7Interpreter.h b/rpcs3/Emu/ARMv7/ARMv7Interpreter.h
index 477f09b18f..90c40af351 100644
--- a/rpcs3/Emu/ARMv7/ARMv7Interpreter.h
+++ b/rpcs3/Emu/ARMv7/ARMv7Interpreter.h
@@ -310,7 +310,7 @@ protected:
 
 	void BL(u32 imm, u8 intstr_size)
 	{
-		CPU.LR = (CPU.PC + intstr_size) | 1;
+		CPU.LR = ((u32)CPU.PC + intstr_size) | 1;
 		CPU.SetBranch(CPU.PC + intstr_size + imm);
 	}
 
diff --git a/rpcs3/Emu/ARMv7/ARMv7Thread.cpp b/rpcs3/Emu/ARMv7/ARMv7Thread.cpp
index 118857dc5e..a49c8ed3e9 100644
--- a/rpcs3/Emu/ARMv7/ARMv7Thread.cpp
+++ b/rpcs3/Emu/ARMv7/ARMv7Thread.cpp
@@ -18,7 +18,7 @@ void ARMv7Thread::InitRegs()
 	memset(GPR, 0, sizeof(GPR[0]) * 15);
 	APSR.APSR = 0;
 	IPSR.IPSR = 0;
-	SP = m_stack_point;
+	SP = (u32)m_stack_point;
 }
 
 void ARMv7Thread::InitStack()
diff --git a/rpcs3/Emu/ARMv7/ARMv7Thread.h b/rpcs3/Emu/ARMv7/ARMv7Thread.h
index f5a21c8cc8..7a4234f00e 100644
--- a/rpcs3/Emu/ARMv7/ARMv7Thread.h
+++ b/rpcs3/Emu/ARMv7/ARMv7Thread.h
@@ -51,7 +51,7 @@ public:
 		u32 IPSR;
 	} IPSR;
 
-	void write_gpr(u8 n, u32 value)
+	void write_gpr(u32 n, u32 value)
 	{
 		assert(n < 16);
 
@@ -65,7 +65,7 @@ public:
 		}
 	}
 
-	u32 read_gpr(u8 n)
+	u32 read_gpr(u32 n)
 	{
 		assert(n < 16);
 
@@ -74,7 +74,7 @@ public:
 			return GPR[n];
 		}
 		
-		return PC;
+		return (u32)PC;
 	}
 
 public:
diff --git a/rpcs3/Emu/CPU/CPUThread.cpp b/rpcs3/Emu/CPU/CPUThread.cpp
index 30a0f94025..ec5278fe67 100644
--- a/rpcs3/Emu/CPU/CPUThread.cpp
+++ b/rpcs3/Emu/CPU/CPUThread.cpp
@@ -287,7 +287,7 @@ void _se_translator(unsigned int u, EXCEPTION_POINTERS* pExp)
 	{
 		// TODO: allow recovering from a page fault
 		throw fmt::Format("Access violation: addr = 0x%x (last_syscall=0x%llx (%s))",
-			(u32)addr, (u64)GetCurrentCPUThread()->m_last_syscall, SysCalls::GetHLEFuncName((u64)GetCurrentCPUThread()->m_last_syscall).c_str());
+			(u32)addr, (u64)GetCurrentCPUThread()->m_last_syscall, SysCalls::GetHLEFuncName((u32)GetCurrentCPUThread()->m_last_syscall).c_str());
 	}
 	else
 	{
diff --git a/rpcs3/Emu/CPU/CPUThread.h b/rpcs3/Emu/CPU/CPUThread.h
index c59fc08b2a..c9d716d553 100644
--- a/rpcs3/Emu/CPU/CPUThread.h
+++ b/rpcs3/Emu/CPU/CPUThread.h
@@ -37,7 +37,7 @@ protected:
 	bool m_is_step;
 
 	u64 m_stack_addr;
-	u64 m_stack_size;
+	u32 m_stack_size;
 	u64 m_stack_point;
 
 	u64 m_exit_status;
@@ -51,11 +51,11 @@ public:
 	virtual void CloseStack();
 
 	u64 GetStackAddr() const { return m_stack_addr; }
-	u64 GetStackSize() const { return m_stack_size; }
+	u32 GetStackSize() const { return m_stack_size; }
 	virtual u64 GetFreeStackSize() const=0;
 
 	void SetStackAddr(u64 stack_addr) { m_stack_addr = stack_addr; }
-	void SetStackSize(u64 stack_size) { m_stack_size = stack_size; }
+	void SetStackSize(u32 stack_size) { m_stack_size = stack_size; }
 
 	virtual void SetArg(const uint pos, const u64 arg) = 0;
 
diff --git a/rpcs3/Emu/Cell/PPUInterpreter.h b/rpcs3/Emu/Cell/PPUInterpreter.h
index e8a94377f8..03cb6e553e 100644
--- a/rpcs3/Emu/Cell/PPUInterpreter.h
+++ b/rpcs3/Emu/Cell/PPUInterpreter.h
@@ -68,12 +68,12 @@ private:
 		const u64 old_sc = CPU.m_last_syscall;
 
 		CPU.m_last_syscall = sc;
-		SysCalls::DoSyscall(sc);
+		SysCalls::DoSyscall((u32)sc);
 
 		if(Ini.HLELogging.GetValue())
 		{
 			LOG_WARNING(PPU, "SysCall[0x%llx ('%s')] done with code [0x%llx]! #pc: 0x%llx",
-				sc, SysCalls::GetHLEFuncName(sc).c_str(), CPU.GPR[3], CPU.PC);
+				sc, SysCalls::GetHLEFuncName((u32)sc).c_str(), CPU.GPR[3], CPU.PC);
 		}
 #ifdef HLE_CALL_DEBUG
 		LOG_NOTICE(PPU, "SysCall[%lld] done with code [0x%llx]! #pc: 0x%llx", sc, CPU.GPR[3], CPU.PC);
@@ -155,7 +155,7 @@ private:
 
 	void TWI(u32 to, u32 ra, s32 simm16)
 	{
-		s32 a = CPU.GPR[ra];
+		s32 a = (s32)CPU.GPR[ra];
 
 		if( (a < simm16  && (to & 0x10)) ||
 			(a > simm16  && (to & 0x8))  ||
@@ -208,7 +208,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 			else
-				CPU.VPR[vd]._s8[b] = result;
+				CPU.VPR[vd]._s8[b] = (s8)result;
 		}
 	}
 	void VADDSHS(u32 vd, u32 va, u32 vb)
@@ -248,7 +248,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 			else
-				CPU.VPR[vd]._s32[w] = result;
+				CPU.VPR[vd]._s32[w] = (s32)result;
 		}
 	}
 	void VADDUBM(u32 vd, u32 va, u32 vb)
@@ -270,7 +270,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 			else
-				CPU.VPR[vd]._u8[b] = result;
+				CPU.VPR[vd]._u8[b] = (u8)result;
 		}
 	}
 	void VADDUHM(u32 vd, u32 va, u32 vb)
@@ -314,7 +314,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 			else
-				CPU.VPR[vd]._u32[w] = result;
+				CPU.VPR[vd]._u32[w] = (u32)result;
 		}
 	}
 	void VAND(u32 vd, u32 va, u32 vb)
@@ -1256,7 +1256,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 				
-			CPU.VPR[vd]._s8[b+8] = result;
+			CPU.VPR[vd]._s8[b+8] = (s8)result;
 
 			result = CPU.VPR[vb]._s16[b];
 
@@ -1271,7 +1271,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 
-			CPU.VPR[vd]._s8[b] = result;
+			CPU.VPR[vd]._s8[b] = (s8)result;
 		}
 	}
 	void VPKSHUS(u32 vd, u32 va, u32 vb)
@@ -1291,7 +1291,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 				
-			CPU.VPR[vd]._u8[b+8] = result;
+			CPU.VPR[vd]._u8[b+8] = (u8)result;
 
 			result = CPU.VPR[vb]._s16[b];
 
@@ -1306,7 +1306,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 				
-			CPU.VPR[vd]._u8[b] = result;
+			CPU.VPR[vd]._u8[b] = (u8)result;
 		}
 	}
 	void VPKSWSS(u32 vd, u32 va, u32 vb)
@@ -1399,7 +1399,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 				
-			CPU.VPR[vd]._u8[b+8] = result;
+			CPU.VPR[vd]._u8[b+8] = (u8)result;
 
 			result = CPU.VPR[vb]._u16[b];
 
@@ -1409,7 +1409,7 @@ private:
 				CPU.VSCR.SAT = 1;
 			}
 				
-			CPU.VPR[vd]._u8[b] = result;
+			CPU.VPR[vd]._u8[b] = (u8)result;
 		}
 	}
 	void VPKUWUM(u32 vd, u32 va, u32 vb)
@@ -1502,7 +1502,7 @@ private:
 	{
 		for (uint w = 0; w < 4; w++)
 		{
-			CPU.VPR[vd]._u32[w] = rotl32(CPU.VPR[va]._u32[w], CPU.VPR[vb]._u8[w*4] & 0x1f);
+			CPU.VPR[vd]._u32[w] = (u32)rotl32(CPU.VPR[va]._u32[w], CPU.VPR[vb]._u8[w*4] & 0x1f);
 		}
 	}
 	void VRSQRTEFP(u32 vd, u32 vb)
@@ -2093,7 +2093,7 @@ private:
 		case 0x1: UNK(fmt::Format("HyperCall %d", CPU.GPR[0])); break;
 		case 0x2: SysCall(); break;
 		case 0x3:
-			Emu.GetSFuncManager().StaticExecute(CPU.GPR[11]);
+			Emu.GetSFuncManager().StaticExecute((u32)CPU.GPR[11]);
 			if (Ini.HLELogging.GetValue())
 			{
 				LOG_NOTICE(PPU, "'%s' done with code[0x%llx]! #pc: 0x%llx",
@@ -2244,11 +2244,11 @@ private:
 	{
 		if (is_r) // rldcr
 		{
-			RLDICR(ra, rs, CPU.GPR[rb], m_eb, rc);
+			RLDICR(ra, rs, (u32)CPU.GPR[rb], m_eb, rc);
 		}
 		else // rldcl
 		{
-			RLDICL(ra, rs, CPU.GPR[rb], m_eb, rc);
+			RLDICL(ra, rs, (u32)CPU.GPR[rb], m_eb, rc);
 		}
 	}
 	void CMP(u32 crfd, u32 l, u32 ra, u32 rb)
@@ -2257,8 +2257,8 @@ private:
 	}
 	void TW(u32 to, u32 ra, u32 rb)
 	{
-		s32 a = CPU.GPR[ra];
-		s32 b = CPU.GPR[rb];
+		s32 a = (s32)CPU.GPR[ra];
+		s32 b = (s32)CPU.GPR[rb];
 
 		if( (a < b  && (to & 0x10)) ||
 			(a > b  && (to & 0x8))  ||
@@ -2328,8 +2328,8 @@ private:
 	}
 	void MULHWU(u32 rd, u32 ra, u32 rb, bool rc)
 	{
-		u32 a = CPU.GPR[ra];
-		u32 b = CPU.GPR[rb];
+		u32 a = (u32)CPU.GPR[ra];
+		u32 b = (u32)CPU.GPR[rb];
 		CPU.GPR[rd] = ((u64)a * (u64)b) >> 32;
 		if(rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]);
 	}
@@ -2380,8 +2380,8 @@ private:
 	void SLW(u32 ra, u32 rs, u32 rb, bool rc)
 	{
 		u32 n = CPU.GPR[rb] & 0x1f;
-		u32 r = rotl32((u32)CPU.GPR[rs], n);
-		u32 m = (CPU.GPR[rb] & 0x20) ? 0 : rotate_mask[32][63 - n];
+		u32 r = (u32)rotl32((u32)CPU.GPR[rs], n);
+		u32 m = ((u32)CPU.GPR[rb] & 0x20) ? 0 : (u32)rotate_mask[32][63 - n];
 
 		CPU.GPR[ra] = r & m;
 
@@ -2509,8 +2509,8 @@ private:
 	}
 	void MULHW(u32 rd, u32 ra, u32 rb, bool rc)
 	{
-		s32 a = CPU.GPR[ra];
-		s32 b = CPU.GPR[rb];
+		s32 a = (s32)CPU.GPR[ra];
+		s32 b = (s32)CPU.GPR[rb];
 		CPU.GPR[rd] = ((s64)a * (s64)b) >> 32;
 		if(rc) CPU.UpdateCR0<s64>(CPU.GPR[rd]);
 	}
@@ -2644,7 +2644,7 @@ private:
 	}
 	void STWX(u32 rs, u32 ra, u32 rb)
 	{
-		Memory.Write32((ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]), CPU.GPR[rs]);
+		Memory.Write32(ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb], (u32)CPU.GPR[rs]);
 	}
 	void STVEHX(u32 vs, u32 ra, u32 rb)
 	{
@@ -2661,7 +2661,7 @@ private:
 	void STWUX(u32 rs, u32 ra, u32 rb)
 	{
 		const u64 addr = CPU.GPR[ra] + CPU.GPR[rb];
-		Memory.Write32(addr, CPU.GPR[rs]);
+		Memory.Write32(addr, (u32)CPU.GPR[rs]);
 		CPU.GPR[ra] = addr;
 	}
 	void STVEWX(u32 vs, u32 ra, u32 rb)
@@ -2701,7 +2701,7 @@ private:
 	}
 	void STBX(u32 rs, u32 ra, u32 rb)
 	{
-		Memory.Write8((ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]), CPU.GPR[rs]);
+		Memory.Write8((ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]), (u8)CPU.GPR[rs]);
 	}
 	void STVX(u32 vs, u32 ra, u32 rb)
 	{
@@ -2744,7 +2744,7 @@ private:
 	void STBUX(u32 rs, u32 ra, u32 rb)
 	{
 		const u64 addr = CPU.GPR[ra] + CPU.GPR[rb];
-		Memory.Write8(addr, CPU.GPR[rs]);
+		Memory.Write8(addr, (u8)CPU.GPR[rs]);
 		CPU.GPR[ra] = addr;
 	}
 	void ADD(u32 rd, u32 ra, u32 rb, u32 oe, bool rc)
@@ -2834,7 +2834,7 @@ private:
 	}
 	void STHX(u32 rs, u32 ra, u32 rb)
 	{
-		Memory.Write16(ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb], CPU.GPR[rs]);
+		Memory.Write16(ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb], (u16)CPU.GPR[rs]);
 	}
 	void ORC(u32 ra, u32 rs, u32 rb, bool rc)
 	{
@@ -2844,12 +2844,12 @@ private:
 	void ECOWX(u32 rs, u32 ra, u32 rb)
 	{
 		//HACK!
-		Memory.Write32((ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]), CPU.GPR[rs]);
+		Memory.Write32((ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]), (u32)CPU.GPR[rs]);
 	}
 	void STHUX(u32 rs, u32 ra, u32 rb)
 	{
 		const u64 addr = CPU.GPR[ra] + CPU.GPR[rb];
-		Memory.Write16(addr, CPU.GPR[rs]);
+		Memory.Write16(addr, (u16)CPU.GPR[rs]);
 		CPU.GPR[ra] = addr;
 	}
 	void OR(u32 ra, u32 rs, u32 rb, bool rc)
@@ -2876,8 +2876,8 @@ private:
 	}
 	void DIVWU(u32 rd, u32 ra, u32 rb, u32 oe, bool rc)
 	{
-		const u32 RA = CPU.GPR[ra];
-		const u32 RB = CPU.GPR[rb];
+		const u32 RA = (u32)CPU.GPR[ra];
+		const u32 RB = (u32)CPU.GPR[rb];
 
 		if(RB == 0)
 		{
@@ -2925,8 +2925,8 @@ private:
 	}
 	void DIVW(u32 rd, u32 ra, u32 rb, u32 oe, bool rc)
 	{
-		const s32 RA = CPU.GPR[ra];
-		const s32 RB = CPU.GPR[rb];
+		const s32 RA = (s32)CPU.GPR[ra];
+		const s32 RB = (s32)CPU.GPR[rb];
 
 		if (RB == 0 || ((u32)RA == (1 << 31) && RB == -1))
 		{
@@ -2967,8 +2967,8 @@ private:
 	void SRW(u32 ra, u32 rs, u32 rb, bool rc)
 	{
 		u32 n = CPU.GPR[rb] & 0x1f;
-		u32 r = rotl32((u32)CPU.GPR[rs], 64 - n);
-		u32 m = (CPU.GPR[rb] & 0x20) ? 0 : rotate_mask[32 + n][63];
+		u32 r = (u32)rotl32((u32)CPU.GPR[rs], 64 - n);
+		u32 m = ((u32)CPU.GPR[rb] & 0x20) ? 0 : (u32)rotate_mask[32 + n][63];
 		CPU.GPR[ra] = r & m;
 		
 		if(rc) CPU.UpdateCR0<s64>(CPU.GPR[ra]);
@@ -2993,7 +2993,7 @@ private:
 	{
 		u64 EA = ra ? CPU.GPR[ra] : 0;
 		u64 N = nb ? nb : 32;
-		u8 reg = CPU.GPR[rd];
+		u8 reg = (u8)CPU.GPR[rd];
 
 		while (N > 0)
 		{
@@ -3051,7 +3051,7 @@ private:
 	}
 	void STWBRX(u32 rs, u32 ra, u32 rb)
 	{
-		(u32&)Memory[ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]] = CPU.GPR[rs];
+		(u32&)Memory[ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]] = (u32)CPU.GPR[rs];
 	}
 	void STFSX(u32 frs, u32 ra, u32 rb)
 	{
@@ -3072,31 +3072,31 @@ private:
 	}
 	void STSWI(u32 rd, u32 ra, u32 nb)
 	{
-			u64 EA = ra ? CPU.GPR[ra] : 0;
-			u64 N = nb ? nb : 32;
-			u8 reg = CPU.GPR[rd];
+		u64 EA = ra ? CPU.GPR[ra] : 0;
+		u64 N = nb ? nb : 32;
+		u8 reg = (u8)CPU.GPR[rd];
 
-			while (N > 0)
+		while (N > 0)
+		{
+			if (N > 3)
 			{
-				if (N > 3)
-				{
-					Memory.Write32(EA, CPU.GPR[reg]);
-					EA += 4;
-					N -= 4;
-				}
-				else
-				{
-					u32 buf = CPU.GPR[reg];
-					while (N > 0)
-					{
-						N = N - 1;
-						Memory.Write8(EA, (0xFF000000 & buf) >> 24);
-						buf <<= 8;
-						EA = EA + 1;
-					}
-				}
-				reg = (reg + 1) % 32;
+				Memory.Write32(EA, (u32)CPU.GPR[reg]);
+				EA += 4;
+				N -= 4;
 			}
+			else
+			{
+				u32 buf = (u32)CPU.GPR[reg];
+				while (N > 0)
+				{
+					N = N - 1;
+					Memory.Write8(EA, (0xFF000000 & buf) >> 24);
+					buf <<= 8;
+					EA = EA + 1;
+				}
+			}
+			reg = (reg + 1) % 32;
+		}
 	}
 	void STFDX(u32 frs, u32 ra, u32 rb)
 	{
@@ -3121,7 +3121,7 @@ private:
 	}
 	void SRAW(u32 ra, u32 rs, u32 rb, bool rc)
 	{
-		s32 RS = CPU.GPR[rs];
+		s32 RS = (s32)CPU.GPR[rs];
 		u8 shift = CPU.GPR[rb] & 63;
 		if (shift > 31)
 		{
@@ -3197,7 +3197,7 @@ private:
 	}
 	void STHBRX(u32 rs, u32 ra, u32 rb)
 	{
-		(u16&)Memory[ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]] = CPU.GPR[rs];
+		(u16&)Memory[ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb]] = (u16)CPU.GPR[rs];
 	}
 	void EXTSH(u32 ra, u32 rs, bool rc)
 	{
@@ -3259,22 +3259,22 @@ private:
 	}
 	void STW(u32 rs, u32 ra, s32 d)
 	{
-		Memory.Write32(ra ? CPU.GPR[ra] + d : d, CPU.GPR[rs]);
+		Memory.Write32(ra ? CPU.GPR[ra] + d : d, (u32)CPU.GPR[rs]);
 	}
 	void STWU(u32 rs, u32 ra, s32 d)
 	{
 		const u64 addr = CPU.GPR[ra] + d;
-		Memory.Write32(addr, CPU.GPR[rs]);
+		Memory.Write32(addr, (u32)CPU.GPR[rs]);
 		CPU.GPR[ra] = addr;
 	}
 	void STB(u32 rs, u32 ra, s32 d)
 	{
-		Memory.Write8(ra ? CPU.GPR[ra] + d : d, CPU.GPR[rs]);
+		Memory.Write8(ra ? CPU.GPR[ra] + d : d, (u8)CPU.GPR[rs]);
 	}
 	void STBU(u32 rs, u32 ra, s32 d)
 	{
 		const u64 addr = CPU.GPR[ra] + d;
-		Memory.Write8(addr, CPU.GPR[rs]);
+		Memory.Write8(addr, (u8)CPU.GPR[rs]);
 		CPU.GPR[ra] = addr;
 	}
 	void LHZ(u32 rd, u32 ra, s32 d)
@@ -3299,12 +3299,12 @@ private:
 	}
 	void STH(u32 rs, u32 ra, s32 d)
 	{
-		Memory.Write16(ra ? CPU.GPR[ra] + d : d, CPU.GPR[rs]);
+		Memory.Write16(ra ? CPU.GPR[ra] + d : d, (u16)CPU.GPR[rs]);
 	}
 	void STHU(u32 rs, u32 ra, s32 d)
 	{
 		const u64 addr = CPU.GPR[ra] + d;
-		Memory.Write16(addr, CPU.GPR[rs]);
+		Memory.Write16(addr, (u16)CPU.GPR[rs]);
 		CPU.GPR[ra] = addr;
 	}
 	void LMW(u32 rd, u32 ra, s32 d)
@@ -3320,7 +3320,7 @@ private:
 		u64 addr = ra ? CPU.GPR[ra] + d : d;
 		for(u32 i=rs; i<32; ++i, addr += 4)
 		{
-			Memory.Write32(addr, CPU.GPR[i]);
+			Memory.Write32(addr, (u32)CPU.GPR[i]);
 		}
 	}
 	void LFS(u32 frd, u32 ra, s32 d)
@@ -3891,7 +3891,7 @@ private:
 				break;
 			}
 			r = (u64)i;
-			double di = i;
+			double di = (double)i;
 			if (di == b)
 			{
 				CPU.SetFPSCR_FI(0);
@@ -3930,7 +3930,7 @@ private:
 		else
 		{
 			s64 i = (s64)b;
-			double di = i;
+			double di = (double)i;
 			if (di == b)
 			{
 				CPU.SetFPSCR_FI(0);
diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp
index 5d4d02fef6..77576e6b88 100644
--- a/rpcs3/Emu/Cell/PPUThread.cpp
+++ b/rpcs3/Emu/Cell/PPUThread.cpp
@@ -108,7 +108,7 @@ void PPUThread::InitRegs()
 		m_stack_point -= 0xc + 4 * argc;
 		u64 argv = m_stack_point;
 
-		mem64_ptr_t argv_list(argv);
+		mem64_ptr_t argv_list((u32)argv);
 		for(int i=0; i<argc; ++i) argv_list += m_argv_addr[i];
 
 		GPR[3] = argc;
diff --git a/rpcs3/Emu/Cell/PPUThread.h b/rpcs3/Emu/Cell/PPUThread.h
index 195994a2be..431bf91b34 100644
--- a/rpcs3/Emu/Cell/PPUThread.h
+++ b/rpcs3/Emu/Cell/PPUThread.h
@@ -389,7 +389,7 @@ struct PPCdouble
 
 	u32 To32() const
 	{
-		float res = _double;
+		float res = (float)_double;
 
 		return (u32&)res;
 	}
@@ -686,7 +686,7 @@ public:
 		}
 		else
 		{
-			UpdateCRn<u32>(n, a, b);
+			UpdateCRn<u32>(n, (u32)a, (u32)b);
 		}
 	}
 
@@ -694,11 +694,11 @@ public:
 	{
 		if(l)
 		{
-			UpdateCRn<s64>(n, a, b);
+			UpdateCRn<s64>(n, (s64)a, (s64)b);
 		}
 		else
 		{
-			UpdateCRn<s32>(n, a, b);
+			UpdateCRn<s32>(n, (s32)a, (s32)b);
 		}
 	}
 
@@ -822,7 +822,7 @@ public:
 			}
 			if (reg == "CR" || reg == "FPSCR")
 			{
-				unsigned long reg_value;
+				unsigned long long reg_value;
 				reg_value = std::stoull(value.substr(24, 31), 0, 16);
 				if (reg == "CR") CR.CR = (u32)reg_value;
 				if (reg == "FPSCR") FPSCR.FPSCR = (u32)reg_value;
diff --git a/rpcs3/Emu/Cell/RawSPUThread.cpp b/rpcs3/Emu/Cell/RawSPUThread.cpp
index 023a946ea7..175dba64ce 100644
--- a/rpcs3/Emu/Cell/RawSPUThread.cpp
+++ b/rpcs3/Emu/Cell/RawSPUThread.cpp
@@ -155,6 +155,12 @@ bool RawSPUThread::Write32(const u64 addr, const u32 value)
 
 	case SPU_NPC_offs:
 	{
+		if (value & 3)
+		{
+			// least significant bit contains some interrupt flag
+			LOG_ERROR(Log::SPU, "RawSPUThread[%d]: Write32(SPU_NPC_offs, 0x%x): lowest bits set", m_index, value);
+			return false;
+		}
 		SPU.NPC.SetValue(value);
 		break;
 	}
@@ -199,5 +205,5 @@ void RawSPUThread::Task()
 
 	SPUThread::Task();
 
-	SPU.NPC.SetValue(PC);
+	SPU.NPC.SetValue((u32)PC);
 }
diff --git a/rpcs3/Emu/Cell/RawSPUThread.h b/rpcs3/Emu/Cell/RawSPUThread.h
index cfea40b0bf..c52dc696a1 100644
--- a/rpcs3/Emu/Cell/RawSPUThread.h
+++ b/rpcs3/Emu/Cell/RawSPUThread.h
@@ -16,9 +16,9 @@ public:
 	RawSPUThread(CPUThreadType type = CPU_THREAD_RAW_SPU);
 	virtual ~RawSPUThread();
 
-	virtual bool Read32(const u64 addr, u32* value) override;
+	bool Read32(const u64 addr, u32* value);
 
-	virtual bool Write32(const u64 addr, const u32 value) override;
+	bool Write32(const u64 addr, const u32 value);
 
 public:
 	virtual void InitRegs();
diff --git a/rpcs3/Emu/Cell/SPUInterpreter.h b/rpcs3/Emu/Cell/SPUInterpreter.h
index be42be1d3e..d789eb3e59 100644
--- a/rpcs3/Emu/Cell/SPUInterpreter.h
+++ b/rpcs3/Emu/Cell/SPUInterpreter.h
@@ -357,7 +357,7 @@ private:
 
 		u64 target = branchTarget(CPU.GPR[ra]._u32[3], 0);
 		CPU.GPR[rt].Reset();
-		CPU.GPR[rt]._u32[3] = CPU.PC + 4;		
+		CPU.GPR[rt]._u32[3] = (u32)CPU.PC + 4;		
 		LOG5_OPCODE("branch (0x%llx)", target);
 		CPU.SetBranch(target);
 	}
@@ -1063,7 +1063,7 @@ private:
 				if (CPU.GPR[rt]._f[i] > 0xffffffff) //if big, result = max
 					CPU.GPR[rt]._u32[i] = 0xffffffff;
 				else
-					CPU.GPR[rt]._u32[i] = floor(CPU.GPR[rt]._f[i]);
+					CPU.GPR[rt]._u32[i] = (u32)floor(CPU.GPR[rt]._f[i]);
 			}
 		}
 	}
@@ -1072,7 +1072,7 @@ private:
 		const u32 scale = 155 - (i8 & 0xff); //unsigned immediate
 		for (int i = 0; i < 4; i++)
 		{
-			CPU.GPR[rt]._f[i] = (s32)CPU.GPR[ra]._i32[i];
+			CPU.GPR[rt]._f[i] = (float)CPU.GPR[ra]._i32[i];
 
 			u32 exp = ((CPU.GPR[rt]._u32[i] >> 23) & 0xff) - scale;
 
@@ -1178,7 +1178,7 @@ private:
 	{
 		u64 target = branchTarget(0, i16);
 		CPU.GPR[rt].Reset();
-		CPU.GPR[rt]._u32[3] = CPU.PC + 4;
+		CPU.GPR[rt]._u32[3] = (u32)CPU.PC + 4;
 		LOG5_OPCODE("branch (0x%llx)", target);
 		CPU.SetBranch(target);
 	}
@@ -1208,7 +1208,7 @@ private:
 	{
 		u64 target = branchTarget(CPU.PC, i16);
 		CPU.GPR[rt].Reset();
-		CPU.GPR[rt]._u32[3] = CPU.PC + 4;
+		CPU.GPR[rt]._u32[3] = (u32)CPU.PC + 4;
 		LOG5_OPCODE("branch (0x%llx)", target);
 		CPU.SetBranch(target);
 	}
diff --git a/rpcs3/Emu/Cell/SPURecompiler.h b/rpcs3/Emu/Cell/SPURecompiler.h
index 927edc1438..13f6903548 100644
--- a/rpcs3/Emu/Cell/SPURecompiler.h
+++ b/rpcs3/Emu/Cell/SPURecompiler.h
@@ -108,14 +108,14 @@ public:
 #define c (*compiler)
 
 #ifdef _WIN32
-#define cpu_xmm(x) oword_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 16) ? offsetof(SPUThread, x) : throw "sizeof("#x") != 16")
-#define cpu_qword(x) qword_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 8) ? offsetof(SPUThread, x) : throw "sizeof("#x") != 8")
-#define cpu_dword(x) dword_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 4) ? offsetof(SPUThread, x) : throw "sizeof("#x") != 4")
-#define cpu_word(x) word_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 2) ? offsetof(SPUThread, x) : throw "sizeof("#x") != 2")
-#define cpu_byte(x) byte_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 1) ? offsetof(SPUThread, x) : throw "sizeof("#x") != 1")
+#define cpu_xmm(x) oword_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 16) ? (s32)offsetof(SPUThread, x) : throw "sizeof("#x") != 16")
+#define cpu_qword(x) qword_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 8) ? (s32)offsetof(SPUThread, x) : throw "sizeof("#x") != 8")
+#define cpu_dword(x) dword_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 4) ? (s32)offsetof(SPUThread, x) : throw "sizeof("#x") != 4")
+#define cpu_word(x) word_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 2) ? (s32)offsetof(SPUThread, x) : throw "sizeof("#x") != 2")
+#define cpu_byte(x) byte_ptr(*cpu_var, (sizeof((*(SPUThread*)nullptr).x) == 1) ? (s32)offsetof(SPUThread, x) : throw "sizeof("#x") != 1")
 
-#define g_imm_xmm(x) oword_ptr(*g_imm_var, offsetof(g_imm_table_struct, x))
-#define g_imm2_xmm(x, y) oword_ptr(*g_imm_var, y, 0, offsetof(g_imm_table_struct, x))
+#define g_imm_xmm(x) oword_ptr(*g_imm_var, (s32)offsetof(g_imm_table_struct, x))
+#define g_imm2_xmm(x, y) oword_ptr(*g_imm_var, y, 0, (s32)offsetof(g_imm_table_struct, x))
 #else
 #define cpu_xmm(x) oword_ptr(*cpu_var, reinterpret_cast<uintptr_t>(&(((SPUThread*)0)->x)) )
 #define cpu_qword(x) qword_ptr(*cpu_var, reinterpret_cast<uintptr_t>(&(((SPUThread*)0)->x)) )
@@ -418,9 +418,9 @@ public:
 				return oword_ptr(*imm_var, i * sizeof(__m128i));
 			}
 		}
-		const int shift = rec.imm_table.size() * sizeof(__m128i);
+		const size_t shift = rec.imm_table.size() * sizeof(__m128i);
 		rec.imm_table.push_back(data);
-		return oword_ptr(*imm_var, shift);
+		return oword_ptr(*imm_var, (s32)shift);
 	}
 
 	Mem XmmConst(const __m128& data)
@@ -1439,7 +1439,7 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(byte_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u8[0])), 0x03);
+		c.mov(byte_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u8[0])), 0x03);
 		LOG_OPCODE();
 	}
 	void CHX(u32 rt, u32 ra, u32 rb)
@@ -1460,7 +1460,7 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(word_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u16[0])), 0x0203);
+		c.mov(word_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u16[0])), 0x0203);
 		LOG_OPCODE();
 	}
 	void CWX(u32 rt, u32 ra, u32 rb)
@@ -1481,7 +1481,7 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(dword_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u32[0])), 0x00010203);
+		c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x00010203);
 		LOG_OPCODE();
 	}
 	void CDX(u32 rt, u32 ra, u32 rb)
@@ -1502,8 +1502,8 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(dword_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u32[0])), 0x04050607);
-		c.mov(dword_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u32[1])), 0x00010203);
+		c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x04050607);
+		c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[1])), 0x00010203);
 		LOG_OPCODE();
 	}
 	void ROTQBI(u32 rt, u32 ra, u32 rb)
@@ -1603,7 +1603,7 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(byte_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u8[0])), 0x03);
+		c.mov(byte_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u8[0])), 0x03);
 		LOG_OPCODE();
 	}
 	void CHD(u32 rt, u32 ra, s32 i7)
@@ -1617,7 +1617,7 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(word_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u16[0])), 0x0203);
+		c.mov(word_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u16[0])), 0x0203);
 		LOG_OPCODE();
 	}
 	void CWD(u32 rt, u32 ra, s32 i7)
@@ -1631,7 +1631,7 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(dword_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u32[0])), 0x00010203);
+		c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x00010203);
 		LOG_OPCODE();
 	}
 	void CDD(u32 rt, u32 ra, s32 i7)
@@ -1645,8 +1645,8 @@ private:
 		c.movdqa(vr.get(), XmmConst(_mm_set_epi32(0x10111213, 0x14151617, 0x18191a1b, 0x1c1d1e1f)));
 		XmmFinalize(vr, rt);
 		XmmInvalidate(rt);
-		c.mov(dword_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u32[0])), 0x04050607);
-		c.mov(dword_ptr(*cpu_var, *addr, 0, offsetof(SPUThread, GPR[rt]._u32[1])), 0x00010203);
+		c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[0])), 0x04050607);
+		c.mov(dword_ptr(*cpu_var, *addr, 0, (s32)offsetof(SPUThread, GPR[rt]._u32[1])), 0x00010203);
 		LOG_OPCODE();
 	}
 	void ROTQBII(u32 rt, u32 ra, s32 i7)
@@ -1961,7 +1961,7 @@ private:
 		for (u32 i = 0; i < 4; i++)
 		{
 			c.bsr(*addr, cpu_dword(GPR[ra]._u32[i]));
-			c.cmovz(*addr, dword_ptr(*g_imm_var, offsetof(g_imm_table_struct, fsmb_table[0xffff]))); // load 0xffffffff
+			c.cmovz(*addr, dword_ptr(*g_imm_var, (s32)offsetof(g_imm_table_struct, fsmb_table[0xffff]))); // load 0xffffffff
 			c.neg(*addr);
 			c.add(*addr, 31);
 			c.mov(cpu_dword(GPR[rt]._u32[i]), *addr);
@@ -1991,7 +1991,7 @@ private:
 		for (u32 i = 0; i < 8; i++)
 		{
 			c.movzx(*addr, cpu_word(GPR[ra]._u16[i]));
-			c.movzx(*addr, word_ptr(*g_imm_var, *addr, 1, offsetof(g_imm_table_struct, cntb_table[0])));
+			c.movzx(*addr, word_ptr(*g_imm_var, *addr, 1, (s32)offsetof(g_imm_table_struct, cntb_table[0])));
 			c.mov(cpu_word(GPR[rt]._u16[i]), addr->r16());
 		}*/
 		const XmmLink& va = XmmGet(ra, rt);
@@ -2677,9 +2677,9 @@ private:
 		const XmmLink& va = XmmGet(ra, rt);
 		if (i8 != 173)
 		{
-			c.mulps(va.get(), XmmConst(_mm_set1_ps(pow(2, 173 - (i8 & 0xff))))); // scale
+			c.mulps(va.get(), XmmConst(_mm_set1_ps((float)pow(2, 173 - (i8 & 0xff))))); // scale
 		}
-		c.maxps(va.get(), XmmConst(_mm_set1_ps(-pow(2, 31)))); // saturate
+		c.maxps(va.get(), XmmConst(_mm_set1_ps((float)-pow(2, 31)))); // saturate
 		c.minps(va.get(), XmmConst(_mm_set1_ps((float)0x7fffffff)));
 		c.cvttps2dq(va.get(), va.get()); // convert to ints with truncation
 		XmmFinalize(va, rt);
@@ -2690,13 +2690,13 @@ private:
 		const XmmLink& va = XmmGet(ra, rt);
 		if (i8 != 173)
 		{
-			c.mulps(va.get(), XmmConst(_mm_set1_ps(pow(2, 173 - (i8 & 0xff))))); // scale
+			c.mulps(va.get(), XmmConst(_mm_set1_ps((float)pow(2, 173 - (i8 & 0xff))))); // scale
 		}
 		c.maxps(va.get(), XmmConst(_mm_set1_ps(0.0f))); // saturate
 		c.minps(va.get(), XmmConst(_mm_set1_ps((float)0xffffffff)));
 		const XmmLink& v1 = XmmCopy(va);
-		c.cmpps(v1.get(), XmmConst(_mm_set1_ps(pow(2, 31))), 5); // generate mask of big values
-		c.andps(v1.get(), XmmConst(_mm_set1_ps(pow(2, 32)))); // generate correction component
+		c.cmpps(v1.get(), XmmConst(_mm_set1_ps((float)pow(2, 31))), 5); // generate mask of big values
+		c.andps(v1.get(), XmmConst(_mm_set1_ps((float)pow(2, 32)))); // generate correction component
 		c.subps(va.get(), v1.get()); // subtract correction component
 		c.cvttps2dq(va.get(), va.get()); // convert to ints with truncation
 		XmmFinalize(va, rt);
@@ -2709,7 +2709,7 @@ private:
 		c.cvtdq2ps(va.get(), va.get()); // convert to floats
 		if (i8 != 155)
 		{
-			c.mulps(va.get(), XmmConst(_mm_set1_ps(pow(2, (i8 & 0xff) - 155)))); // scale
+			c.mulps(va.get(), XmmConst(_mm_set1_ps((float)pow(2, (i8 & 0xff) - 155)))); // scale
 		}
 		XmmFinalize(va, rt);
 		LOG_OPCODE();
@@ -2720,11 +2720,11 @@ private:
 		const XmmLink& v1 = XmmCopy(va);
 		c.cvtdq2ps(va.get(), va.get()); // convert to floats
 		c.psrad(v1.get(), 32); // generate mask from sign bit
-		c.andps(v1.get(), XmmConst(_mm_set1_ps(pow(2, 32)))); // generate correction component
+		c.andps(v1.get(), XmmConst(_mm_set1_ps((float)pow(2, 32)))); // generate correction component
 		c.addps(va.get(), v1.get()); // add correction component
 		if (i8 != 155)
 		{
-			c.mulps(va.get(), XmmConst(_mm_set1_ps(pow(2, (i8 & 0xff) - 155)))); // scale
+			c.mulps(va.get(), XmmConst(_mm_set1_ps((float)pow(2, (i8 & 0xff) - 155)))); // scale
 		}
 		XmmFinalize(va, rt);
 		XmmFinalize(v1);
diff --git a/rpcs3/Emu/Cell/SPURecompilerCore.cpp b/rpcs3/Emu/Cell/SPURecompilerCore.cpp
index 6fb67f73f9..3212096697 100644
--- a/rpcs3/Emu/Cell/SPURecompilerCore.cpp
+++ b/rpcs3/Emu/Cell/SPURecompilerCore.cpp
@@ -183,7 +183,7 @@ u8 SPURecompilerCore::DecodeMemory(const u64 address)
 {
 	assert(CPU.dmac.ls_offset == address - CPU.PC);
 	const u64 m_offset = CPU.dmac.ls_offset;
-	const u16 pos = (CPU.PC >> 2);
+	const u16 pos = (u16)(CPU.PC >> 2);
 
 	//ConLog.Write("DecodeMemory: pos=%d", pos);
 	u32* ls = (u32*)&Memory[m_offset];
diff --git a/rpcs3/Emu/Cell/SPUThread.h b/rpcs3/Emu/Cell/SPUThread.h
index 7736d821b8..64168066bb 100644
--- a/rpcs3/Emu/Cell/SPUThread.h
+++ b/rpcs3/Emu/Cell/SPUThread.h
@@ -522,17 +522,17 @@ public:
 
 	void StopAndSignal(u32 code);
 
-	virtual u8   ReadLS8  (const u32 lsa) const { return Memory.Read8  (lsa + m_offset); }
-	virtual u16  ReadLS16 (const u32 lsa) const { return Memory.Read16 (lsa + m_offset); }
-	virtual u32  ReadLS32 (const u32 lsa) const { return Memory.Read32 (lsa + m_offset); }
-	virtual u64  ReadLS64 (const u32 lsa) const { return Memory.Read64 (lsa + m_offset); }
-	virtual u128 ReadLS128(const u32 lsa) const { return Memory.Read128(lsa + m_offset); }
+	u8   ReadLS8  (const u32 lsa) const { return Memory.Read8  (lsa + m_offset); }
+	u16  ReadLS16 (const u32 lsa) const { return Memory.Read16 (lsa + m_offset); }
+	u32  ReadLS32 (const u32 lsa) const { return Memory.Read32 (lsa + m_offset); }
+	u64  ReadLS64 (const u32 lsa) const { return Memory.Read64 (lsa + m_offset); }
+	u128 ReadLS128(const u32 lsa) const { return Memory.Read128(lsa + m_offset); }
 
-	virtual void WriteLS8  (const u32 lsa, const u8&   data) const { Memory.Write8  (lsa + m_offset, data); }
-	virtual void WriteLS16 (const u32 lsa, const u16&  data) const { Memory.Write16 (lsa + m_offset, data); }
-	virtual void WriteLS32 (const u32 lsa, const u32&  data) const { Memory.Write32 (lsa + m_offset, data); }
-	virtual void WriteLS64 (const u32 lsa, const u64&  data) const { Memory.Write64 (lsa + m_offset, data); }
-	virtual void WriteLS128(const u32 lsa, const u128& data) const { Memory.Write128(lsa + m_offset, data); }
+	void WriteLS8  (const u32 lsa, const u8&   data) const { Memory.Write8  (lsa + m_offset, data); }
+	void WriteLS16 (const u32 lsa, const u16&  data) const { Memory.Write16 (lsa + m_offset, data); }
+	void WriteLS32 (const u32 lsa, const u32&  data) const { Memory.Write32 (lsa + m_offset, data); }
+	void WriteLS64 (const u32 lsa, const u64&  data) const { Memory.Write64 (lsa + m_offset, data); }
+	void WriteLS128(const u32 lsa, const u128& data) const { Memory.Write128(lsa + m_offset, data); }
 
 public:
 	SPUThread(CPUThreadType type = CPU_THREAD_SPU);
diff --git a/rpcs3/Emu/IdManager.h b/rpcs3/Emu/IdManager.h
index b1170cce04..b81c8678cd 100644
--- a/rpcs3/Emu/IdManager.h
+++ b/rpcs3/Emu/IdManager.h
@@ -177,7 +177,7 @@ public:
 		return true;
 	}
 
-	bool HasID(const s64 id)
+	bool HasID(const u32 id)
 	{
 		{
 			std::lock_guard<std::mutex> lock(m_mtx_main);
@@ -211,7 +211,7 @@ public:
 	u32 GetTypeCount(IDType type)
 	{
 		if (type < TYPE_OTHER) {
-			return m_types[type].size();
+			return (u32)m_types[type].size();
 		}
 		return 1;
 	}
diff --git a/rpcs3/Emu/Memory/Memory.cpp b/rpcs3/Emu/Memory/Memory.cpp
index f772145ccf..1dde6e3ba0 100644
--- a/rpcs3/Emu/Memory/Memory.cpp
+++ b/rpcs3/Emu/Memory/Memory.cpp
@@ -2,6 +2,7 @@
 #include "Utilities/Log.h"
 #include "Emu/System.h"
 #include "Memory.h"
+#include "Emu/Cell/RawSPUThread.h"
 
 #ifndef _WIN32
 #include <sys/mman.h>
@@ -191,7 +192,7 @@ void MemoryBase::WriteMMIO32(u32 addr, const u32 data)
 		std::lock_guard<std::recursive_mutex> lock(m_mutex);
 
 		if (RawSPUMem[(addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET] &&
-			RawSPUMem[(addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET]->Write32(addr, data))
+			((RawSPUThread*)RawSPUMem[(addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET])->Write32(addr, data))
 		{
 			return;
 		}
@@ -207,7 +208,7 @@ u32 MemoryBase::ReadMMIO32(u32 addr)
 		std::lock_guard<std::recursive_mutex> lock(m_mutex);
 
 		if (RawSPUMem[(addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET] &&
-			RawSPUMem[(addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET]->Read32(addr, &res))
+			((RawSPUThread*)RawSPUMem[(addr - RAW_SPU_BASE_ADDR) / RAW_SPU_OFFSET])->Read32(addr, &res))
 		{
 			return res;
 		}
@@ -365,218 +366,6 @@ bool MemoryBlock::IsMyAddress(const u64 addr)
 	return mem && addr >= GetStartAddr() && addr < GetEndAddr();
 }
 
-template <typename T>
-__forceinline const T MemoryBlock::FastRead(const u64 addr) const
-{
-	volatile const T data = *(const T *)GetMem(addr);
-	return re(data);
-}
-
-template <>
-__forceinline const u128 MemoryBlock::FastRead<u128>(const u64 addr) const
-{
-	volatile const u128 data = *(const u128 *)GetMem(addr);
-	u128 ret;
-	ret.lo = re(data.hi);
-	ret.hi = re(data.lo);
-	return ret;
-}
-
-bool MemoryBlock::Read8(const u64 addr, u8* value)
-{
-	if(!IsMyAddress(addr))
-	{
-		*value = 0;
-		return false;
-	}
-
-	*value = FastRead<u8>(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlock::Read16(const u64 addr, u16* value)
-{
-	if(!IsMyAddress(addr))
-	{
-		*value = 0;
-		return false;
-	}
-
-	*value = FastRead<u16>(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlock::Read32(const u64 addr, u32* value)
-{
-	if(!IsMyAddress(addr))
-	{
-		*value = 0;
-		return false;
-	}
-
-	*value = FastRead<u32>(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlock::Read64(const u64 addr, u64* value)
-{
-	if(!IsMyAddress(addr))
-	{
-		*value = 0;
-		return false;
-	}
-
-	*value = FastRead<u64>(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlock::Read128(const u64 addr, u128* value)
-{
-	if(!IsMyAddress(addr))
-	{
-		*value = u128::From32(0);
-		return false;
-	}
-
-	*value = FastRead<u128>(FixAddr(addr));
-	return true;
-}
-
-template <typename T>
-__forceinline void MemoryBlock::FastWrite(const u64 addr, const T value)
-{
-	*(T *)GetMem(addr) = re(value);
-}
-
-template <>
-__forceinline void MemoryBlock::FastWrite<u128>(const u64 addr, const u128 value)
-{
-	u128 res;
-	res.lo = re(value.hi);
-	res.hi = re(value.lo);
-	*(u128*)GetMem(addr) = res;
-}
-
-bool MemoryBlock::Write8(const u64 addr, const u8 value)
-{
-	if(!IsMyAddress(addr) || IsLocked(addr)) return false;
-
-	FastWrite<u8>(FixAddr(addr), value);
-	return true;
-}
-
-bool MemoryBlock::Write16(const u64 addr, const u16 value)
-{
-	if(!IsMyAddress(addr) || IsLocked(addr)) return false;
-
-	FastWrite<u16>(FixAddr(addr), value);
-	return true;
-}
-
-bool MemoryBlock::Write32(const u64 addr, const u32 value)
-{
-	if(!IsMyAddress(addr) || IsLocked(addr)) return false;
-
-	FastWrite<u32>(FixAddr(addr), value);
-	return true;
-}
-
-bool MemoryBlock::Write64(const u64 addr, const u64 value)
-{
-	if(!IsMyAddress(addr) || IsLocked(addr)) return false;
-
-	FastWrite<u64>(FixAddr(addr), value);
-	return true;
-}
-
-bool MemoryBlock::Write128(const u64 addr, const u128 value)
-{
-	if(!IsMyAddress(addr) || IsLocked(addr)) return false;
-
-	FastWrite<u128>(FixAddr(addr), value);
-	return true;
-}
-
-bool MemoryBlockLE::Read8(const u64 addr, u8* value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*value = *(u8*)GetMem(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlockLE::Read16(const u64 addr, u16* value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*value = *(u16*)GetMem(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlockLE::Read32(const u64 addr, u32* value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*value = *(u32*)GetMem(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlockLE::Read64(const u64 addr, u64* value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*value = *(u64*)GetMem(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlockLE::Read128(const u64 addr, u128* value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*value = *(u128*)GetMem(FixAddr(addr));
-	return true;
-}
-
-bool MemoryBlockLE::Write8(const u64 addr, const u8 value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*(u8*)GetMem(FixAddr(addr)) = value;
-	return true;
-}
-
-bool MemoryBlockLE::Write16(const u64 addr, const u16 value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*(u16*)GetMem(FixAddr(addr)) = value;
-	return true;
-}
-
-bool MemoryBlockLE::Write32(const u64 addr, const u32 value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*(u32*)GetMem(FixAddr(addr)) = value;
-	return true;
-}
-
-bool MemoryBlockLE::Write64(const u64 addr, const u64 value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*(u64*)GetMem(FixAddr(addr)) = value;
-	return true;
-}
-
-bool MemoryBlockLE::Write128(const u64 addr, const u128 value)
-{
-	if(!IsMyAddress(addr)) return false;
-
-	*(u128*)GetMem(FixAddr(addr)) = value;
-	return true;
-}
-
 VirtualMemoryBlock::VirtualMemoryBlock() : MemoryBlock(), m_reserve_size(0)
 {
 }
diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index 3f5e2c6493..e462ebd096 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -125,9 +125,9 @@ public:
 	{
 		const u64 res = (u64)addr - (u64)GetBaseAddr();
 		
-		if (res < 0x100000000)
+		if ((u32)res == res)
 		{
-			return res;
+			return (u32)res;
 		}
 		else
 		{
@@ -211,7 +211,7 @@ public:
 			}
 			else
 			{
-				WriteMMIO32(addr, data);
+				WriteMMIO32((u32)addr, data);
 			}
 		}
 		else
@@ -285,7 +285,7 @@ public:
 			}
 			else
 			{
-				return ReadMMIO32(addr);
+				return ReadMMIO32((u32)addr);
 			}
 		}
 		else
diff --git a/rpcs3/Emu/Memory/MemoryBlock.h b/rpcs3/Emu/Memory/MemoryBlock.h
index 117d0bb32a..fa80e479d7 100644
--- a/rpcs3/Emu/Memory/MemoryBlock.h
+++ b/rpcs3/Emu/Memory/MemoryBlock.h
@@ -78,7 +78,7 @@ class MemoryBlock
 protected:
 	u8* mem;
 	u64 range_start;
-	u64 range_size;
+	u32 range_size;
 
 public:
 	MemoryBlock();
@@ -102,24 +102,6 @@ public:
 	virtual bool IsMyAddress(const u64 addr);
 	virtual bool IsLocked(const u64 addr) { return false; }
 
-	template <typename T>
-	__forceinline const T FastRead(const u64 addr) const;
-
-	virtual bool Read8(const u64 addr, u8* value);
-	virtual bool Read16(const u64 addr, u16* value);
-	virtual bool Read32(const u64 addr, u32* value);
-	virtual bool Read64(const u64 addr, u64* value);
-	virtual bool Read128(const u64 addr, u128* value);
-
-	template <typename T>
-	__forceinline void FastWrite(const u64 addr, const T value);
-
-	virtual bool Write8(const u64 addr, const u8 value);
-	virtual bool Write16(const u64 addr, const u16 value);
-	virtual bool Write32(const u64 addr, const u32 value);
-	virtual bool Write64(const u64 addr, const u64 value);
-	virtual bool Write128(const u64 addr, const u128 value);
-
 	const u64 GetStartAddr() const { return range_start; }
 	const u64 GetEndAddr() const { return GetStartAddr() + GetSize() - 1; }
 	virtual const u32 GetSize() const { return range_size; }
@@ -137,18 +119,7 @@ public:
 
 class MemoryBlockLE : public MemoryBlock
 {
-public:
-	virtual bool Read8(const u64 addr, u8* value) override;
-	virtual bool Read16(const u64 addr, u16* value) override;
-	virtual bool Read32(const u64 addr, u32* value) override;
-	virtual bool Read64(const u64 addr, u64* value) override;
-	virtual bool Read128(const u64 addr, u128* value) override;
 
-	virtual bool Write8(const u64 addr, const u8 value) override;
-	virtual bool Write16(const u64 addr, const u16 value) override;
-	virtual bool Write32(const u64 addr, const u32 value) override;
-	virtual bool Write64(const u64 addr, const u64 value) override;
-	virtual bool Write128(const u64 addr, const u128 value) override;
 };
 
 class MemoryMirror : public MemoryBlock
@@ -244,17 +215,17 @@ public:
 	// Return the total amount of reserved memory
 	virtual u32 GetReservedAmount();
 
-	virtual bool Read8(const u64 addr, u8* value);
-	virtual bool Read16(const u64 addr, u16* value);
-	virtual bool Read32(const u64 addr, u32* value);
-	virtual bool Read64(const u64 addr, u64* value);
-	virtual bool Read128(const u64 addr, u128* value);
+	bool Read8(const u64 addr, u8* value);
+	bool Read16(const u64 addr, u16* value);
+	bool Read32(const u64 addr, u32* value);
+	bool Read64(const u64 addr, u64* value);
+	bool Read128(const u64 addr, u128* value);
 
-	virtual bool Write8(const u64 addr, const u8 value);
-	virtual bool Write16(const u64 addr, const u16 value);
-	virtual bool Write32(const u64 addr, const u32 value);
-	virtual bool Write64(const u64 addr, const u64 value);
-	virtual bool Write128(const u64 addr, const u128 value);
+	bool Write8(const u64 addr, const u8 value);
+	bool Write16(const u64 addr, const u16 value);
+	bool Write32(const u64 addr, const u32 value);
+	bool Write64(const u64 addr, const u64 value);
+	bool Write128(const u64 addr, const u128 value);
 
 	// try to get the real address given a mapped address
 	// return true for success

From fb1d7d39827f6f94fb53b4ce1b93ffbb6136b476 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sat, 30 Aug 2014 22:35:18 +0400
Subject: [PATCH 05/36] Some warnings fixed

---
 rpcs3/Emu/Audio/AudioDumper.cpp           |  4 ++--
 rpcs3/Emu/Audio/AudioDumper.h             |  2 +-
 rpcs3/Emu/Cell/SPUThread.cpp              | 14 +++++++-------
 rpcs3/Emu/FS/VFS.cpp                      |  4 ++--
 rpcs3/Emu/FS/vfsDevice.cpp                | 18 +++++++++---------
 rpcs3/Emu/Io/MouseHandler.h               |  6 +++---
 rpcs3/Emu/RSX/RSXThread.cpp               | 10 +++++-----
 rpcs3/Emu/SysCalls/Modules/cellAdec.cpp   |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellAudio.cpp  |  8 ++++----
 rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp          |  6 +++---
 rpcs3/Emu/SysCalls/lv2/sys_cond.cpp       |  4 ++--
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp |  6 +++---
 rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp     |  4 ++--
 rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp    |  2 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.cpp     |  4 ++--
 rpcs3/Emu/SysCalls/lv2/sys_memory.h       |  2 +-
 rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp     |  8 ++++----
 rpcs3/Emu/SysCalls/lv2/sys_rwlock.h       |  8 ++++----
 rpcs3/Emu/SysCalls/lv2/sys_spu.cpp        | 12 ++++++------
 rpcs3/Emu/SysCalls/lv2/sys_vm.cpp         |  4 ++--
 rpcs3/Loader/ELF64.h                      |  2 +-
 21 files changed, 65 insertions(+), 65 deletions(-)

diff --git a/rpcs3/Emu/Audio/AudioDumper.cpp b/rpcs3/Emu/Audio/AudioDumper.cpp
index 3187c3b4be..0e51fd4a42 100644
--- a/rpcs3/Emu/Audio/AudioDumper.cpp
+++ b/rpcs3/Emu/Audio/AudioDumper.cpp
@@ -34,8 +34,8 @@ size_t AudioDumper::WriteData(const void* buffer, size_t size)
 	if (!do_save) return size; // ignore empty data
 #endif
 	size_t ret = m_output.Write(buffer, size);
-	m_header.Size += ret;
-	m_header.RIFF.Size += ret;
+	m_header.Size += (u32)ret;
+	m_header.RIFF.Size += (u32)ret;
 	return ret;
 }
 
diff --git a/rpcs3/Emu/Audio/AudioDumper.h b/rpcs3/Emu/Audio/AudioDumper.h
index d3a6080ba4..ebf0f1db25 100644
--- a/rpcs3/Emu/Audio/AudioDumper.h
+++ b/rpcs3/Emu/Audio/AudioDumper.h
@@ -67,5 +67,5 @@ public:
 	void WriteHeader();
 	size_t WriteData(const void* buffer, size_t size);
 	void Finalize();
-	const u8 GetCh() const { return m_header.FMT.NumChannels; }
+	const u8 GetCh() const { return (u8)m_header.FMT.NumChannels; }
 };
diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp
index 71485213af..a44f95fdb0 100644
--- a/rpcs3/Emu/Cell/SPUThread.cpp
+++ b/rpcs3/Emu/Cell/SPUThread.cpp
@@ -155,11 +155,11 @@ void SPUThread::WriteSNR(bool number, u32 value)
 {
 	if (cfg.value & ((u64)1 << (u64)number))
 	{
-		SPU.SNR[number].PushUncond_OR(value); // logical OR
+		SPU.SNR[number ? 1 : 0].PushUncond_OR(value); // logical OR
 	}
 	else
 	{
-		SPU.SNR[number].PushUncond(value); // overwrite
+		SPU.SNR[number ? 1 : 0].PushUncond(value); // overwrite
 	}
 }
 
@@ -282,7 +282,7 @@ void SPUThread::ListCmd(u32 lsa, u64 ea, u16 tag, u16 size, u32 cmd, MFCReg& MFC
 
 	for (u32 i = 0; i < list_size; i++)
 	{
-		mem_ptr_t<list_element> rec(dmac.ls_offset + list_addr + i * 8);
+		mem_ptr_t<list_element> rec((u32)dmac.ls_offset + list_addr + i * 8);
 
 		u32 size = rec->ts;
 		if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8)
@@ -446,7 +446,7 @@ void SPUThread::EnqMfcCmd(MFCReg& MFCArgs)
 						changed, mask, op, cmd, lsa, ea, tag, size);
 
 					SPUDisAsm dis_asm(CPUDisAsm_InterpreterMode);
-					for (s32 i = PC; i < PC + 4 * 7; i += 4)
+					for (s32 i = (s32)PC; i < (s32)PC + 4 * 7; i += 4)
 					{
 						dis_asm.dump_pc = i;
 						dis_asm.offset = Memory.GetMemFromAddr(dmac.ls_offset);
@@ -1013,9 +1013,9 @@ void SPUThread::StopAndSignal(u32 code)
 				eq->events.pop(event);
 				eq->owner.unlock(tid);
 				SPU.In_MBox.PushUncond(CELL_OK);
-				SPU.In_MBox.PushUncond(event.data1);
-				SPU.In_MBox.PushUncond(event.data2);
-				SPU.In_MBox.PushUncond(event.data3);
+				SPU.In_MBox.PushUncond((u32)event.data1);
+				SPU.In_MBox.PushUncond((u32)event.data2);
+				SPU.In_MBox.PushUncond((u32)event.data3);
 				return;
 			}
 			case SMR_FAILED: break;
diff --git a/rpcs3/Emu/FS/VFS.cpp b/rpcs3/Emu/FS/VFS.cpp
index 518ec6b6bd..7007955899 100644
--- a/rpcs3/Emu/FS/VFS.cpp
+++ b/rpcs3/Emu/FS/VFS.cpp
@@ -328,8 +328,8 @@ void VFS::SaveLoadDevices(std::vector<VFSManagerEntry>& res, bool is_load)
 	}
 	else
 	{
-		count = res.size();
-		entries_count.SaveValue(res.size());
+		count = (int)res.size();
+		entries_count.SaveValue(count);
 	}
 
 	for(int i=0; i<count; ++i)
diff --git a/rpcs3/Emu/FS/vfsDevice.cpp b/rpcs3/Emu/FS/vfsDevice.cpp
index 84d7012102..e61fc98d99 100644
--- a/rpcs3/Emu/FS/vfsDevice.cpp
+++ b/rpcs3/Emu/FS/vfsDevice.cpp
@@ -26,7 +26,7 @@ void vfsDevice::SetPath(const std::string& ps3_path, const std::string& local_pa
 
 u32 vfsDevice::CmpPs3Path(const std::string& ps3_path)
 {
-	const u32 lim = std::min(m_ps3_path.length(), ps3_path.length());
+	const u32 lim = (u32)std::min(m_ps3_path.length(), ps3_path.length());
 	u32 ret = 0;
 
 	for(u32 i=0; i<lim; ++i, ++ret)
@@ -58,10 +58,10 @@ u32 vfsDevice::CmpLocalPath(const std::string& local_path)
 	std::vector<std::string> arr0 = fmt::rSplit(path0.GetFullPath(), DL);
 	std::vector<std::string> arr1 = fmt::rSplit(local_path, DL);
 
-	const u32 lim = std::min(arr0.size(), arr1.size());
+	const u32 lim = (u32)std::min(arr0.size(), arr1.size());
 	u32 ret = 0;
 
-	for(u32 i=0; i<lim; ret += arr0[i++].size() + 1)
+	for(u32 i=0; i<lim; ret += (u32)arr0[i++].size() + 1)
 	{
 		if(fmt::CmpNoCase(arr0[i],arr1[i]) != 0)
 		{
@@ -75,7 +75,7 @@ u32 vfsDevice::CmpLocalPath(const std::string& local_path)
 std::string vfsDevice::ErasePath(const std::string& path, u32 start_dir_count, u32 end_dir_count)
 {
 	u32 from = 0;
-	u32 to = path.length() - 1;
+	u32 to = (u32)path.length() - 1;
 
 	for(uint i = 0, dir = 0; i < path.length(); ++i)
 	{
@@ -89,7 +89,7 @@ std::string vfsDevice::ErasePath(const std::string& path, u32 start_dir_count, u
 		}
 	}
 
-	for(int i = path.length() - 1, dir = 0; i >= 0; --i)
+	for(int i = (int)path.length() - 1, dir = 0; i >= 0; --i)
 	{
 		if(path[i] == '\\' || path[i] == '/' || i == 0)
 		{
@@ -109,9 +109,9 @@ std::string vfsDevice::GetRoot(const std::string& path)
 	//return fmt::ToUTF8(wxFileName(fmt::FromUTF8(path), wxPATH_UNIX).GetPath());
 	if(path.empty()) return "";
 
-	u32 first_dir = path.length() - 1;
+	u32 first_dir = (u32)path.length() - 1;
 
-	for(int i = path.length() - 1, dir = 0, li = path.length() - 1; i >= 0 && dir < 2; --i)
+	for(int i = (int)path.length() - 1, dir = 0, li = (int)path.length() - 1; i >= 0 && dir < 2; --i)
 	{
 		if(path[i] == '\\' || path[i] == '/' || i == 0)
 		{
@@ -139,9 +139,9 @@ std::string vfsDevice::GetRootPs3(const std::string& path)
 
 	static const std::string home = "/dev_hdd0/game/";
 	u32 last_dir = 0;
-	u32 first_dir = path.length() - 1;
+	u32 first_dir = (u32)path.length() - 1;
 
-	for(int i = path.length() - 1, dir = 0; i >= 0; --i)
+	for(int i = (int)path.length() - 1, dir = 0; i >= 0; --i)
 	{
 		if(path[i] == '\\' || path[i] == '/' || i == 0)
 		{
diff --git a/rpcs3/Emu/Io/MouseHandler.h b/rpcs3/Emu/Io/MouseHandler.h
index e21e0d0902..a2aeeede32 100644
--- a/rpcs3/Emu/Io/MouseHandler.h
+++ b/rpcs3/Emu/Io/MouseHandler.h
@@ -107,7 +107,7 @@ public:
 
 	void Button(u8 button, bool pressed)
 	{
-		for(u64 p=0; p < m_mice.size(); ++p)
+		for(u32 p=0; p < (u32)m_mice.size(); ++p)
 		{
 			if (m_info.status[p] == CELL_MOUSE_STATUS_CONNECTED)
 			{
@@ -121,7 +121,7 @@ public:
 
 	void Scroll(const s8 rotation)
 	{
-		for(u64 p=0; p < m_mice.size(); ++p)
+		for(u32 p=0; p < (u32)m_mice.size(); ++p)
 		{
 			if (m_info.status[p] == CELL_MOUSE_STATUS_CONNECTED)
 			{
@@ -134,7 +134,7 @@ public:
 
 	void Move(const s16 x_pos_new, const s16 y_pos_new)
 	{
-		for(u64 p=0; p< m_mice.size(); ++p)
+		for(u32 p=0; p < (u32)m_mice.size(); ++p)
 		{
 			if (m_info.status[p] == CELL_MOUSE_STATUS_CONNECTED)
 			{
diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp
index 50d2c050da..762c10740d 100644
--- a/rpcs3/Emu/RSX/RSXThread.cpp
+++ b/rpcs3/Emu/RSX/RSXThread.cpp
@@ -45,8 +45,8 @@ u32 GetAddress(u32 offset, u8 location)
 {
 	switch(location)
 	{
-	case CELL_GCM_LOCATION_LOCAL: return Memory.RSXFBMem.GetStartAddr() + offset;
-	case CELL_GCM_LOCATION_MAIN: return Memory.RSXIOMem.RealAddr(Memory.RSXIOMem.GetStartAddr() + offset); // TODO: Error Check?
+	case CELL_GCM_LOCATION_LOCAL: return (u32)Memory.RSXFBMem.GetStartAddr() + offset;
+	case CELL_GCM_LOCATION_MAIN: return (u32)Memory.RSXIOMem.RealAddr(Memory.RSXIOMem.GetStartAddr() + offset); // TODO: Error Check?
 	}
 
 	LOG_ERROR(RSX, "GetAddress(offset=0x%x, location=0x%x)", location);
@@ -881,7 +881,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
 				{
 					case 0:
 					{
-						int pos = m_indexed_array.m_data.size();
+						int pos = (int)m_indexed_array.m_data.size();
 						m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 4);
 						index = Memory.Read32(m_indexed_array.m_addr + i * 4);
 						*(u32*)&m_indexed_array.m_data[pos] = index;
@@ -891,7 +891,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
 
 					case 1:
 					{
-						int pos = m_indexed_array.m_data.size();
+						int pos = (int)m_indexed_array.m_data.size();
 						m_indexed_array.m_data.resize(m_indexed_array.m_data.size() + 2);
 						index = Memory.Read16(m_indexed_array.m_addr + i * 2);
 						//LOG_WARNING(RSX, "index 2: %d", index);
@@ -1568,7 +1568,7 @@ void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const
 
 	case NV4097_SET_POLYGON_STIPPLE_PATTERN:
 	{
-		for (size_t i = 0; i < 32; i++)
+		for (u32 i = 0; i < 32; i++)
 		{
 			m_polygon_stipple_pattern[i] = ARGS(i);
 		}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
index 7fcf739465..7a5c5831cc 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
@@ -800,7 +800,7 @@ int cellAdecGetPcmItem(u32 handle, mem32_t pcmItem_ptr)
 	pcm->startAddr = 0x00000312; // invalid address (no output)
 	pcm->size = af.size;
 	pcm->status = CELL_OK;
-	pcm->auInfo.pts.lower = af.pts;
+	pcm->auInfo.pts.lower = (u32)af.pts;
 	pcm->auInfo.pts.upper = af.pts >> 32;
 	pcm->auInfo.size = af.auSize;
 	pcm->auInfo.startAddr = af.auAddr;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
index 2b089fca0b..0797bccc30 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
@@ -39,9 +39,9 @@ int cellAudioInit()
 	m_config.counter = 0;
 
 	// alloc memory
-	m_config.m_buffer = 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);
-	m_config.m_indexes = 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);
 
 	thread t("Audio Thread", []()
@@ -527,8 +527,8 @@ int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, mem32_t portNum)
 		{
 			AudioPortConfig& port = m_config.m_ports[i];
 	
-			port.channel = audioParam->nChannel;
-			port.block = audioParam->nBlock;
+			port.channel = (u8)audioParam->nChannel;
+			port.block = (u8)audioParam->nBlock;
 			port.attr = audioParam->attr;
 			if (port.attr & CELL_AUDIO_PORTATTR_INITLEVEL)
 			{
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
index a96b65f061..d529dd3e7b 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
@@ -546,11 +546,11 @@ s32 cellFsStReadInit(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf)
 	fs_config.m_ring_buffer = *ringbuf;
 
 	if(ringbuf->ringbuf_size < 0x40000000) // If the size is less than 1MB
-		fs_config.m_alloc_mem_size = ((ringbuf->ringbuf_size + 64 * 1024 - 1) / (64 * 1024)) * (64 * 1024);
-	fs_config.m_alloc_mem_size = ((ringbuf->ringbuf_size + 1024 * 1024 - 1) / (1024 * 1024)) * (1024 * 1024);
+		fs_config.m_alloc_mem_size = (((u32)ringbuf->ringbuf_size + 64 * 1024 - 1) / (64 * 1024)) * (64 * 1024);
+	fs_config.m_alloc_mem_size = (((u32)ringbuf->ringbuf_size + 1024 * 1024 - 1) / (1024 * 1024)) * (1024 * 1024);
 
 	// alloc memory
-	fs_config.m_buffer = 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);
 
 	fs_config.m_fs_status = CELL_FS_ST_INITIALIZED;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp b/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
index ab7fdbecec..c9e52b5755 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
@@ -182,8 +182,8 @@ s32 sys_cond_wait(u32 cond_id, u64 timeout)
 	mutex->recursive = 0;
 	mutex->m_mutex.unlock(tid, mutex->protocol == SYS_SYNC_PRIORITY ? mutex->m_queue.pop_prio() : mutex->m_queue.pop());
 
-	u32 counter = 0;
-	const u32 max_counter = timeout ? (timeout / 1000) : ~0;
+	u64 counter = 0;
+	const u64 max_counter = timeout ? (timeout / 1000) : ~0ull;
 
 	while (true)
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
index 2e5a0e479f..550420d13a 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
@@ -148,8 +148,8 @@ s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 		}
 	}
 
-	u32 counter = 0;
-	const u32 max_counter = timeout ? (timeout / 1000) : ~0;
+	u64 counter = 0;
+	const u64 max_counter = timeout ? (timeout / 1000) : ~0;
 
 	while (true)
 	{
@@ -337,7 +337,7 @@ s32 sys_event_flag_cancel(u32 eflag_id, mem32_t num)
 		return CELL_OK;
 	}
 
-	if (num.GetAddr()) num = tids.size();
+	if (num.GetAddr()) num = (u32)tids.size();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp b/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
index 4e368f9ed7..79bb73ea62 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
@@ -177,8 +177,8 @@ s32 sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
 			(u32)lwcond->lwcond_queue, (u32)mutex->sleep_queue);
 	}
 
-	u32 counter = 0;
-	const u32 max_counter = timeout ? (timeout / 1000) : ~0;
+	u64 counter = 0;
+	const u64 max_counter = timeout ? (timeout / 1000) : ~0;
 
 	while (true)
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp b/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
index 6324423055..24d7ea6b40 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
@@ -128,7 +128,7 @@ u32 SleepQueue::pop_prio() // SYS_SYNC_PRIORITY
 	{
 		if (list.size())
 		{
-			u32 highest_prio = ~0;
+			u64 highest_prio = ~0ull;
 			u32 sel = 0;
 			for (u32 i = 0; i < list.size(); i++)
 			{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
index 0c78a868cf..e27723d1e6 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
@@ -17,12 +17,12 @@ s32 sys_memory_allocate(u32 size, u32 flags, u32 alloc_addr_addr)
 	{
 	case SYS_MEMORY_PAGE_SIZE_1M:
 		if(size & 0xfffff) return CELL_EALIGN;
-		addr = Memory.Alloc(size, 0x100000);
+		addr = (u32)Memory.Alloc(size, 0x100000);
 	break;
 
 	case SYS_MEMORY_PAGE_SIZE_64K:
 		if(size & 0xffff) return CELL_EALIGN;
-		addr = Memory.Alloc(size, 0x10000);
+		addr = (u32)Memory.Alloc(size, 0x10000);
 	break;
 
 	default: return CELL_EINVAL;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.h b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
index 940882a29a..522c3328fe 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
@@ -32,7 +32,7 @@ struct sys_page_attr_t
 
 struct MemoryContainerInfo
 {
-	u64 addr;
+	u32 addr;
 	u32 size;
 
 	MemoryContainerInfo(u64 addr, u32 size)
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
index 187349b5a2..910777857c 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
@@ -65,8 +65,8 @@ s32 sys_rwlock_rlock(u32 rw_lock_id, u64 timeout)
 
 	if (rw->rlock_trylock(tid)) return CELL_OK;
 
-	u32 counter = 0;
-	const u32 max_counter = timeout ? (timeout / 1000) : 20000;
+	u64 counter = 0;
+	const u64 max_counter = timeout ? (timeout / 1000) : 20000;
 	do
 	{
 		if (Emu.IsStopped())
@@ -128,8 +128,8 @@ s32 sys_rwlock_wlock(u32 rw_lock_id, u64 timeout)
 
 	if (rw->wlock_trylock(tid, true)) return CELL_OK;
 
-	u32 counter = 0;
-	const u32 max_counter = timeout ? (timeout / 1000) : 20000;
+	u64 counter = 0;
+	const u64 max_counter = timeout ? (timeout / 1000) : 20000;
 	do
 	{
 		if (Emu.IsStopped())
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
index 0ca4a41dff..9f9fa0ed35 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
@@ -51,7 +51,7 @@ struct RWLock
 	{
 		std::lock_guard<std::mutex> lock(m_lock);
 
-		for (u32 i = rlock_list.size() - 1; ~i; i--)
+		for (u32 i = (u32)rlock_list.size() - 1; ~i; i--)
 		{
 			if (rlock_list[i] == tid)
 			{
@@ -70,7 +70,7 @@ struct RWLock
 		{
 			return false; // deadlock
 		}
-		for (u32 i = rlock_list.size() - 1; ~i; i--)
+		for (u32 i = (u32)rlock_list.size() - 1; ~i; i--)
 		{
 			if (rlock_list[i] == tid)
 			{
@@ -90,7 +90,7 @@ struct RWLock
 			{
 				return false; // do not enqueue
 			}
-			for (u32 i = wlock_queue.size() - 1; ~i; i--)
+			for (u32 i = (u32)wlock_queue.size() - 1; ~i; i--)
 			{
 				if (wlock_queue[i] == tid)
 				{
@@ -117,7 +117,7 @@ struct RWLock
 					{
 						return false; // do not enqueue
 					}
-					for (u32 i = wlock_queue.size() - 1; ~i; i--)
+					for (u32 i = (u32)wlock_queue.size() - 1; ~i; i--)
 					{
 						if (wlock_queue[i] == tid)
 						{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
index be21717207..146d461b67 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
@@ -16,7 +16,7 @@ u32 LoadSpuImage(vfsStream& stream, u32& spu_ep)
 	ELFLoader l(stream);
 	l.LoadInfo();
 	const u32 alloc_size = 256 * 1024;
-	u32 spu_offset = Memory.MainMem.AllocAlign(alloc_size);
+	u32 spu_offset = (u32)Memory.MainMem.AllocAlign(alloc_size);
 	l.LoadData(spu_offset);
 	spu_ep = l.GetEntry();
 	return spu_offset;
@@ -518,9 +518,9 @@ s32 sys_spu_thread_write_ls(u32 id, u32 address, u64 value, u32 type)
 
 	switch (type)
 	{
-	case 1: (*(SPUThread*)thr).WriteLS8(address, value); return CELL_OK;
-	case 2: (*(SPUThread*)thr).WriteLS16(address, value); return CELL_OK;
-	case 4: (*(SPUThread*)thr).WriteLS32(address, value); return CELL_OK;
+	case 1: (*(SPUThread*)thr).WriteLS8(address, (u8)value); return CELL_OK;
+	case 2: (*(SPUThread*)thr).WriteLS16(address, (u16)value); return CELL_OK;
+	case 4: (*(SPUThread*)thr).WriteLS32(address, (u32)value); return CELL_OK;
 	case 8: (*(SPUThread*)thr).WriteLS64(address, value); return CELL_OK;
 	default: return CELL_EINVAL;
 	}
@@ -631,7 +631,7 @@ s32 sys_spu_thread_write_snr(u32 id, u32 number, u32 value)
 		return CELL_EINVAL;
 	}
 
-	(*(SPUThread*)thr).WriteSNR(number, value);
+	(*(SPUThread*)thr).WriteSNR(number ? true : false, value);
 
 	return CELL_OK;
 }
@@ -1054,6 +1054,6 @@ s32 sys_raw_spu_get_spu_cfg(u32 id, mem32_t value)
 		return CELL_ESRCH;
 	}
 
-	value = t->cfg.value;
+	value = (u32)t->cfg.value;
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_vm.cpp b/rpcs3/Emu/SysCalls/lv2/sys_vm.cpp
index 9fd3e39b2d..ca3b145b77 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_vm.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_vm.cpp
@@ -33,11 +33,11 @@ s32 sys_vm_memory_map(u32 vsize, u32 psize, u32 cid, u64 flag, u64 policy, u32 a
 		switch(flag)
 		{
 		case SYS_MEMORY_PAGE_SIZE_1M:
-			new_addr = Memory.Alloc(psize, 0x100000);
+			new_addr = (u32)Memory.Alloc(psize, 0x100000);
 			break;
 
 		case SYS_MEMORY_PAGE_SIZE_64K:
-			new_addr = Memory.Alloc(psize, 0x10000);
+			new_addr = (u32)Memory.Alloc(psize, 0x10000);
 			break;
 
 		default: return CELL_EINVAL;
diff --git a/rpcs3/Loader/ELF64.h b/rpcs3/Loader/ELF64.h
index 2a98b9bbb8..7843b9f569 100644
--- a/rpcs3/Loader/ELF64.h
+++ b/rpcs3/Loader/ELF64.h
@@ -31,7 +31,7 @@ struct Elf64_Ehdr
 	void Show();
 
 	bool CheckMagic() const { return e_magic == 0x7F454C46; }
-	u32 GetEntry() const { return e_entry; }
+	u64 GetEntry() const { return e_entry; }
 };
 
 struct Elf64_Shdr

From 9e2bb9e9d2734767606c0700b7e5f03679658193 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 00:41:01 +0400
Subject: [PATCH 06/36] Some warnings fixed

---
 Utilities/Log.cpp                             |   2 +-
 rpcs3/Emu/Memory/Memory.h                     |   6 +-
 rpcs3/Emu/SysCalls/Modules.h                  |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellFont.cpp       |  21 +-
 rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp     |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp     |  42 +--
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.h       |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp     |  10 +-
 rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp     |  14 +-
 rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp  |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp     |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellResc.cpp       |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellRtc.cpp        |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp      | 268 +++++++++---------
 rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp    |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellSync.cpp       |  16 +-
 rpcs3/Emu/SysCalls/Modules/cellSync2.cpp      |  68 ++---
 .../SysCalls/Modules/cellSysutil_SaveData.cpp |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellVdec.cpp       |   4 +-
 rpcs3/Emu/SysCalls/Modules/libmixer.cpp       |   2 +-
 rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp    |   2 +-
 rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp  |  18 +-
 rpcs3/Emu/SysCalls/Modules/sys_fs.cpp         |   4 +-
 rpcs3/Emu/SysCalls/Modules/sys_net.cpp        |   2 +-
 rpcs3/Emu/SysCalls/SysCalls.cpp               |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.cpp         |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.h           |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp        |  12 +-
 rpcs3/Emu/SysCalls/lv2/sys_mmapper.h          |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp     |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_prx.cpp            |   4 +-
 rpcs3/Emu/System.cpp                          |  12 +-
 rpcs3/Loader/ELF64.cpp                        |  32 ++-
 rpcs3/Loader/TROPUSR.cpp                      |  16 +-
 rpcs3/Loader/TROPUSR.h                        |   2 +-
 rpcs3/stdafx.h                                |   4 +-
 36 files changed, 308 insertions(+), 313 deletions(-)

diff --git a/Utilities/Log.cpp b/Utilities/Log.cpp
index 46b72ca759..1f736617cf 100644
--- a/Utilities/Log.cpp
+++ b/Utilities/Log.cpp
@@ -14,7 +14,7 @@ LogManager *gLogManager = nullptr;
 u32 LogMessage::size()
 {
 	//1 byte for NULL terminator
-	return sizeof(LogMessage::size_type) + sizeof(LogType) + sizeof(LogSeverity) + sizeof(std::string::value_type)*mText.size() + 1;
+	return (u32)(sizeof(LogMessage::size_type) + sizeof(LogType) + sizeof(LogSeverity) + sizeof(std::string::value_type) * mText.size() + 1);
 }
 
 void LogMessage::serialize(char *output)
diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index e462ebd096..b339a1c500 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -162,7 +162,7 @@ public:
 		}
 		else
 		{
-			for (u32 i = addr / 4096; i <= (addr + size - 1) / 4096; i++)
+			for (u32 i = (u32)addr / 4096; i <= ((u32)addr + size - 1) / 4096; i++)
 			{
 				if (!m_pages[i]) return false; // TODO: define page parameters
 			}
@@ -718,7 +718,7 @@ public:
 	u32 AppendRawBytes(const u8 *bytes, size_t count)
 	{
 		memmove(Memory + this->m_addr, bytes, count);
-		this->m_addr += count;
+		this->m_addr += (u32)count;
 		return this->m_addr;
 	}
 
@@ -835,7 +835,7 @@ class MemoryAllocator
 public:
 	MemoryAllocator(u32 size = sizeof(T), u32 align = 1)
 		: m_size(size)
-		, m_addr(Memory.Alloc(size, align))
+		, m_addr((u32)Memory.Alloc(size, align))
 		, m_ptr((T*)&Memory[m_addr])
 	{
 	}
diff --git a/rpcs3/Emu/SysCalls/Modules.h b/rpcs3/Emu/SysCalls/Modules.h
index 0f22000945..60f0f92938 100644
--- a/rpcs3/Emu/SysCalls/Modules.h
+++ b/rpcs3/Emu/SysCalls/Modules.h
@@ -153,7 +153,7 @@ __forceinline void Module::AddFuncSub(const char group[8], const u64 ops[], cons
 	{
 		SFuncOp op;
 		op.mask = ops[i] >> 32;
-		op.crc = ops[i];
+		op.crc = (u32)ops[i];
 		if (op.mask) op.crc &= op.mask;
 		op.mask = re(op.mask);
 		op.crc = re(op.crc);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index 5987358ef3..7eb1c130cf 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -96,8 +96,8 @@ int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, mem8_ptr_t fontPath
 	if (!f.IsOpened())
 		return CELL_FONT_ERROR_FONT_OPEN_FAILED;
 
-	u32 fileSize = f.GetSize();
-	u32 bufferAddr = Memory.Alloc(fileSize, 1); // Freed in cellFontCloseFont
+	u32 fileSize = (u32)f.GetSize();
+	u32 bufferAddr = (u32)Memory.Alloc(fileSize, 1); // Freed in cellFontCloseFont
 	f.Read(Memory.VirtualToRealAddr(bufferAddr), fileSize);
 	int ret = cellFontOpenFontMemory(library.GetAddr(), bufferAddr, fileSize, subNum, uniqueId, font.GetAddr());
 	font->origin = CELL_FONT_OPEN_FONT_FILE;
@@ -180,7 +180,7 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
 		return CELL_FONT_ERROR_NO_SUPPORT_FONTSET;
 	}
 
-	u32 file_addr = Memory.Alloc(file.length()+1, 1);
+	u32 file_addr = (u32)Memory.Alloc((u32)file.length() + 1, 1);
 	Memory.WriteString(file_addr, file);
 	int ret = cellFontOpenFontFile(library.GetAddr(), file_addr, 0, 0, font.GetAddr()); //TODO: Find the correct values of subNum, uniqueId
 	font->origin = CELL_FONT_OPEN_FONTSET;
@@ -234,7 +234,7 @@ void cellFontRenderSurfaceInit(mem_ptr_t<CellFontRenderSurface> surface, u32 buf
 	surface->height			= h;
 
 	if (!buffer_addr)
-		surface->buffer_addr = Memory.Alloc(bufferWidthByte * h, 1); // TODO: Huge memory leak
+		surface->buffer_addr = (u32)Memory.Alloc(bufferWidthByte * h, 1); // TODO: Huge memory leak
 }
 
 void cellFontRenderSurfaceSetScissor(mem_ptr_t<CellFontRenderSurface> surface, s32 x0, s32 y0, s32 w, s32 h)
@@ -250,8 +250,6 @@ void cellFontRenderSurfaceSetScissor(mem_ptr_t<CellFontRenderSurface> surface, s
 
 int cellFontSetScalePixel(mem_ptr_t<CellFont> font, float w, float h)
 {
-	w = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
-	h = GetCurrentPPUThread().FPR[2]; // TODO: Something is wrong with the float arguments
 	cellFont->Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
 
 	font->scale_x = w;
@@ -305,8 +303,6 @@ int cellFontDestroyRenderer()
 
 int cellFontSetupRenderScalePixel(mem_ptr_t<CellFont> font, float w, float h)
 {
-	w = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
-	h = GetCurrentPPUThread().FPR[2]; // TODO: Something is wrong with the float arguments
 	cellFont->Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
 
 	if (!font->renderer_addr)
@@ -330,8 +326,6 @@ int cellFontGetRenderCharGlyphMetrics(mem_ptr_t<CellFont> font, u32 code, mem_pt
 
 int cellFontRenderCharGlyphImage(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<CellFontRenderSurface> surface, float x, float y, mem_ptr_t<CellFontGlyphMetrics> metrics, mem_ptr_t<CellFontImageTransInfo> transInfo)
 {
-	x = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
-	y = GetCurrentPPUThread().FPR[2]; // TODO: Something is wrong with the float arguments
 	cellFont->Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)",
 		font.GetAddr(), code, surface.GetAddr(), x, y, metrics.GetAddr(), transInfo.GetAddr());
 
@@ -348,7 +342,7 @@ int cellFontRenderCharGlyphImage(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<C
 	int baseLineY;
 	int ascent, descent, lineGap;
 	stbtt_GetFontVMetrics(font->stbfont, &ascent, &descent, &lineGap);
-	baseLineY = ascent * scale;
+	baseLineY = (int)((float)ascent * scale); // ???
 
 	// Move the rendered character to the surface
 	unsigned char* buffer = (unsigned char*)Memory.VirtualToRealAddr(surface->buffer_addr);
@@ -376,7 +370,6 @@ int cellFontEndLibrary()
 
 int cellFontSetEffectSlant(mem_ptr_t<CellFont> font, float slantParam)
 {
-	slantParam = GetCurrentPPUThread().FPR[1]; // TODO: Something is wrong with the float arguments
 	cellFont->Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.GetAddr(), slantParam);
 
 	if (slantParam < -1.0 || slantParam > 1.0)
@@ -386,11 +379,11 @@ int cellFontSetEffectSlant(mem_ptr_t<CellFont> font, float slantParam)
 	return CELL_FONT_OK;
 }
 
-int cellFontGetEffectSlant(mem_ptr_t<CellFont> font, mem32_t slantParam)
+int cellFontGetEffectSlant(mem_ptr_t<CellFont> font, mem_ptr_t<be_t<float>> slantParam)
 {
 	cellFont->Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.GetAddr(), slantParam.GetAddr());
 
-	slantParam = font->slant; //Does this conversion from be_t<float> to *mem32_t work?
+	*slantParam = font->slant;
 	return CELL_FONT_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
index 7b42bf90fd..ce0185c697 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
@@ -21,7 +21,7 @@ int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, mem_ptr_t<CellFon
 	//if (s_fontInternalInstance->m_bInitialized)
 		//return CELL_FONT_ERROR_UNINITIALIZED;
 
-	Memory.Write32(lib_addr_addr, Memory.Alloc(sizeof(CellFontLibrary), 1));
+	Memory.Write32(lib_addr_addr, (u32)Memory.Alloc(sizeof(CellFontLibrary), 1));
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
index 4a19c37968..5ef3020554 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
@@ -29,7 +29,7 @@ const u32 tiled_pitches[] = {
 
 u32 local_size = 0;
 u32 local_addr = 0;
-u32 system_mode = 0;
+u64 system_mode = 0;
 
 CellGcmConfig current_config;
 CellGcmContextData current_context;
@@ -65,8 +65,8 @@ CellGcmOffsetTable offsetTable;
 
 void InitOffsetTable()
 {
-	offsetTable.ioAddress = Memory.Alloc(3072 * sizeof(u16), 1);
-	offsetTable.eaAddress = Memory.Alloc(512 * sizeof(u16), 1);
+	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));
@@ -79,7 +79,7 @@ void InitOffsetTable()
 u32 cellGcmGetLabelAddress(u8 index)
 {
 	cellGcmSys->Log("cellGcmGetLabelAddress(index=%d)", index);
-	return Memory.RSXCMDMem.GetStartAddr() + 0x10 * index;
+	return (u32)Memory.RSXCMDMem.GetStartAddr() + 0x10 * index;
 }
 
 u32 cellGcmGetReportDataAddressLocation(u32 index, u32 location)
@@ -91,7 +91,7 @@ u32 cellGcmGetReportDataAddressLocation(u32 index, u32 location)
 			cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong local index (%d)", index);
 			return 0;
 		}
-		return Memory.RSXFBMem.GetStartAddr() + index * 0x10;
+		return (u32)Memory.RSXFBMem.GetStartAddr() + index * 0x10;
 	}
 
 	if (location == CELL_GCM_LOCATION_MAIN) {
@@ -146,7 +146,7 @@ u32 cellGcmGetNotifyDataAddress(u32 index)
  */
 u32 _cellGcmFunc12()
 {
-	return Memory.RSXFBMem.GetStartAddr(); // TODO
+	return (u32)Memory.RSXFBMem.GetStartAddr(); // TODO
 }
 
 u32 cellGcmGetReport(u32 type, u32 index)
@@ -174,7 +174,7 @@ u32 cellGcmGetReportDataAddress(u32 index)
 		cellGcmSys->Error("cellGcmGetReportDataAddress: Wrong local index (%d)", index);
 		return 0;
 	}
-	return Memory.RSXFBMem.GetStartAddr() + index * 0x10;
+	return (u32)Memory.RSXFBMem.GetStartAddr() + index * 0x10;
 }
 
 u32 cellGcmGetReportDataLocation(u32 index, u32 location)
@@ -332,7 +332,7 @@ s32 _cellGcmInitBody(mem_ptr_t<CellGcmContextData> context, u32 cmdSize, u32 ioS
 	if(!local_size && !local_addr)
 	{
 		local_size = 0xf900000; // TODO: Get sdk_version in _cellGcmFunc15 and pass it to gcmGetLocalMemorySize
-		local_addr = Memory.RSXFBMem.GetStartAddr();
+		local_addr = (u32)Memory.RSXFBMem.GetStartAddr();
 		Memory.RSXFBMem.AllocAlign(local_size);
 	}
 
@@ -374,7 +374,7 @@ s32 _cellGcmInitBody(mem_ptr_t<CellGcmContextData> context, u32 cmdSize, u32 ioS
 	current_context.current = current_context.begin;
 	current_context.callback = Emu.GetRSXCallback() - 4;
 
-	gcm_info.context_addr = Memory.MainMem.AllocAlign(0x1000);
+	gcm_info.context_addr = (u32)Memory.MainMem.AllocAlign(0x1000);
 	gcm_info.control_addr = gcm_info.context_addr + 0x40;
 
 	Memory.WriteData(gcm_info.context_addr, current_context);
@@ -387,9 +387,9 @@ s32 _cellGcmInitBody(mem_ptr_t<CellGcmContextData> context, u32 cmdSize, u32 ioS
 
 	auto& render = Emu.GetGSManager().GetRender();
 	render.m_ctxt_addr = context.GetAddr();
-	render.m_gcm_buffers_addr = Memory.Alloc(sizeof(CellGcmDisplayInfo) * 8, sizeof(CellGcmDisplayInfo));
-	render.m_zculls_addr = Memory.Alloc(sizeof(CellGcmZcullInfo) * 8, sizeof(CellGcmZcullInfo));
-	render.m_tiles_addr = Memory.Alloc(sizeof(CellGcmTileInfo) * 15, sizeof(CellGcmTileInfo));
+	render.m_gcm_buffers_addr = (u32)Memory.Alloc(sizeof(CellGcmDisplayInfo) * 8, sizeof(CellGcmDisplayInfo));
+	render.m_zculls_addr = (u32)Memory.Alloc(sizeof(CellGcmZcullInfo) * 8, sizeof(CellGcmZcullInfo));
+	render.m_tiles_addr = (u32)Memory.Alloc(sizeof(CellGcmTileInfo) * 15, sizeof(CellGcmTileInfo));
 	render.m_gcm_buffers_count = 0;
 	render.m_gcm_current_buffer = 0;
 	render.m_main_mem_addr = 0;
@@ -814,7 +814,7 @@ s32 cellGcmAddressToOffset(u64 address, mem32_t offset)
 
 	// Address in local memory
 	if (Memory.RSXFBMem.IsInMyRange(address)) {
-		result = address - Memory.RSXFBMem.GetStartAddr();
+		result = (u32)(address - Memory.RSXFBMem.GetStartAddr());
 	}
 	// Address in main memory else check 
 	else
@@ -838,7 +838,7 @@ u32 cellGcmGetMaxIoMapSize()
 {
 	cellGcmSys->Log("cellGcmGetMaxIoMapSize()");
 
-	return Memory.RSXIOMem.GetEndAddr() - Memory.RSXIOMem.GetStartAddr() - Memory.RSXIOMem.GetReservedAmount();
+	return (u32)(Memory.RSXIOMem.GetEndAddr() - Memory.RSXIOMem.GetStartAddr() - Memory.RSXIOMem.GetReservedAmount());
 }
 
 void cellGcmGetOffsetTable(mem_ptr_t<CellGcmOffsetTable> table)
@@ -901,7 +901,7 @@ s32 cellGcmMapLocalMemory(u64 address, u64 size)
 	if (!local_size && !local_addr)
 	{
 		local_size = 0xf900000; //TODO
-		local_addr = Memory.RSXFBMem.GetStartAddr();
+		local_addr = (u32)Memory.RSXFBMem.GetStartAddr();
 		Memory.RSXFBMem.AllocAlign(local_size);
 		Memory.Write32(address, local_addr);
 		Memory.Write32(size, local_size);
@@ -915,25 +915,25 @@ s32 cellGcmMapLocalMemory(u64 address, u64 size)
 	return CELL_OK;
 }
 
-s32 cellGcmMapMainMemory(u64 ea, u32 size, mem32_t offset)
+s32 cellGcmMapMainMemory(u32 ea, u32 size, mem32_t offset)
 {
 	cellGcmSys->Warning("cellGcmMapMainMemory(ea=0x%x,size=0x%x,offset_addr=0x%x)", ea, size, offset.GetAddr());
 
-	u64 io;
+	u32 io;
 
 	if ((ea & 0xFFFFF) || (size & 0xFFFFF)) return CELL_GCM_ERROR_FAILURE;
 
 	//check if the mapping was successfull
-	if (io = Memory.RSXIOMem.Map(ea, size, 0))
+	if (io = (u32)Memory.RSXIOMem.Map(ea, size, 0))
 	{
 		// convert to offset
-		io = io - Memory.RSXIOMem.GetStartAddr();
+		io = io - (u32)Memory.RSXIOMem.GetStartAddr();
 
 		//fill the offset table
 		for (u32 i = 0; i<(size >> 20); i++)
 		{
-			Memory.Write16(offsetTable.ioAddress + ((ea >> 20) + i)*sizeof(u16), (io >> 20) + i);
-			Memory.Write16(offsetTable.eaAddress + ((io >> 20) + i)*sizeof(u16), (ea >> 20) + i);
+			Memory.Write16(offsetTable.ioAddress + ((ea >> 20) + i) * sizeof(u16), (u16)(io >> 20) + i);
+			Memory.Write16(offsetTable.eaAddress + ((io >> 20) + i) * sizeof(u16), (u16)(ea >> 20) + i);
 		}
 
 		offset = io;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
index 66b1448a80..1da9d57321 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
@@ -30,7 +30,7 @@ void cellGcmGetOffsetTable(mem_ptr_t<CellGcmOffsetTable> table);
 s32 cellGcmIoOffsetToAddress(u32 ioOffset, u64 address);
 s32 cellGcmMapEaIoAddress(u32 ea, u32 io, u32 size);
 s32 cellGcmMapEaIoAddressWithFlags(u32 ea, u32 io, u32 size, u32 flags);
-s32 cellGcmMapMainMemory(u64 ea, u32 size, mem32_t offset);
+s32 cellGcmMapMainMemory(u32 ea, u32 size, mem32_t offset);
 s32 cellGcmReserveIoMapSize(u32 size);
 s32 cellGcmUnmapEaIoAddress(u64 ea);
 s32 cellGcmUnmapIoAddress(u64 io);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
index b684204a00..b3aa0c793b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
@@ -84,7 +84,7 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellGifDecInfo
 
 	case se32(CELL_GIFDEC_FILE):
 		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread);
+		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread.GetAddr());
 		break;
 	}
 
@@ -155,7 +155,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	const CellGifDecOutParam& current_outParam = subHandle_data->outParam; 
 
 	//Copy the GIF file to a buffer
-	MemoryAllocator<unsigned char> gif(fileSize);
+	MemoryAllocator<unsigned char> gif((u32)fileSize);
 	MemoryAllocator<u64> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
@@ -166,7 +166,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 
 	case se32(CELL_GIFDEC_FILE):
 		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, gif.GetAddr(), gif.GetSize(), nread);
+		cellFsRead(fd, gif.GetAddr(), gif.GetSize(), nread.GetAddr());
 		break;
 	}
 
@@ -174,14 +174,14 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	int width, height, actual_components;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 		(
-			stbi_load_from_memory(gif.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+			stbi_load_from_memory(gif.GetPtr(), (s32)fileSize, &width, &height, &actual_components, 4),
 			&::free
 		);
 
 	if (!image)
 		return CELL_GIFDEC_ERROR_STREAM_FORMAT;
 
-	const int bytesPerLine = dataCtrlParam->outputBytesPerLine;
+	const int bytesPerLine = (u32)dataCtrlParam->outputBytesPerLine;
 	const char nComponents = 4;
 	uint image_size = width * height * nComponents;
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
index 43fd50ca63..71afb2d8e6 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
@@ -93,7 +93,7 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo
 	CellJpgDecInfo& current_info = subHandle_data->info;
 
 	//Write the header to buffer
-	MemoryAllocator<u8> buffer(fileSize);
+	MemoryAllocator<u8> buffer((u32)fileSize);
 	MemoryAllocator<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
@@ -104,7 +104,7 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo
 
 	case se32(CELL_JPGDEC_FILE):
 		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread);
+		cellFsRead(fd, buffer.GetAddr(), buffer.GetSize(), nread.GetAddr());
 		break;
 	}
 
@@ -162,7 +162,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	const CellJpgDecOutParam& current_outParam = subHandle_data->outParam; 
 
 	//Copy the JPG file to a buffer
-	MemoryAllocator<unsigned char> jpg(fileSize);
+	MemoryAllocator<unsigned char> jpg((u32)fileSize);
 	MemoryAllocator<u64> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
@@ -173,7 +173,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 
 	case se32(CELL_JPGDEC_FILE):
 		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.GetAddr());
-		cellFsRead(fd, jpg.GetAddr(), jpg.GetSize(), nread);
+		cellFsRead(fd, jpg.GetAddr(), jpg.GetSize(), nread.GetAddr());
 		break;
 	}
 
@@ -181,7 +181,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	int width, height, actual_components;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 		(
-			stbi_load_from_memory(jpg.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+			stbi_load_from_memory(jpg.GetPtr(), (s32)fileSize, &width, &height, &actual_components, 4),
 			&::free
 		);
 
@@ -189,7 +189,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 		return CELL_JPGDEC_ERROR_STREAM_FORMAT;
 
 	const bool flip = current_outParam.outputMode == CELL_JPGDEC_BOTTOM_TO_TOP;
-	const int bytesPerLine = dataCtrlParam->outputBytesPerLine;
+	const int bytesPerLine = (u32)dataCtrlParam->outputBytesPerLine;
 	size_t image_size = width * height;
 
 	switch((u32)current_outParam.outputColorSpace)
@@ -274,7 +274,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	dataOutInfo->status = CELL_JPGDEC_DEC_STATUS_FINISH;
 
 	if(dataCtrlParam->outputBytesPerLine)
-		dataOutInfo->outputLines = image_size / dataCtrlParam->outputBytesPerLine;
+		dataOutInfo->outputLines = (u32)(image_size / dataCtrlParam->outputBytesPerLine);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
index 17e19899d8..e7267d1359 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
@@ -122,7 +122,7 @@ int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<Ce
 		}
 
 		if (callback && (g_msg_dialog_state != msgDialogAbort))
-			callback.async(status, userData);
+			callback.async((s32)status, userData); // TODO: this callback should be registered
 
 		CallAfter([&]()
 		{
@@ -230,7 +230,7 @@ int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallba
 	}
 
 	if (callback)
-		callback(status, userData);
+		callback((s32)status, userData);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index e94e3369c8..0d444d9803 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -198,7 +198,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	const CellPngDecOutParam& current_outParam = subHandle_data->outParam;
 
 	//Copy the PNG file to a buffer
-	MemoryAllocator<unsigned char> png(fileSize);
+	MemoryAllocator<unsigned char> png((u32)fileSize);
 	MemoryAllocator<u64> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
@@ -217,13 +217,13 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	int width, height, actual_components;
 	auto image = std::unique_ptr<unsigned char,decltype(&::free)>
 			(
-				stbi_load_from_memory(png.GetPtr(), fileSize, &width, &height, &actual_components, 4),
+				stbi_load_from_memory(png.GetPtr(), (s32)fileSize, &width, &height, &actual_components, 4),
 				&::free
 			);
 	if (!image)	return CELL_PNGDEC_ERROR_STREAM_FORMAT;
 
 	const bool flip = current_outParam.outputMode == CELL_PNGDEC_BOTTOM_TO_TOP;
-	const int bytesPerLine = dataCtrlParam->outputBytesPerLine;
+	const int bytesPerLine = (u32)dataCtrlParam->outputBytesPerLine;
 	uint image_size = width * height;
 
 	switch((u32)current_outParam.outputColorSpace)
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
index 2dd1db4040..bbd3797131 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@@ -15,7 +15,7 @@ PICTURE_SIZE = (1.0f),
 UV_DELTA_PS = (1.f / 8.f),
 UV_DELTA_LB = (1.f / 6.f),
 XY_DELTA_LB = (1.f / 8.f),
-PI = 3.1415926535897932384626433832795;
+PI = 3.141592741f;
 
 void BuildupVertexBufferNR()
 {
@@ -124,8 +124,8 @@ void BuildupVertexBufferUN(s32 srcIdx)
 	float U_PS1 = U_CENTER + U_PS;
 	float U2_FS0 = 0.0f;
 	float V2_FS0 = 0.0f;
-	float U2_FS1 = s_rescInternalInstance->m_dstWidth;
-	float V2_FS1 = s_rescInternalInstance->m_dstHeight;
+	float U2_FS1 = (float)s_rescInternalInstance->m_dstWidth;
+	float V2_FS1 = (float)s_rescInternalInstance->m_dstHeight;
 
 	mem_ptr_t<RescVertex_t> vv(s_rescInternalInstance->m_vertexArrayEA);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
index fbb110e40b..cdecda0d8d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
@@ -225,7 +225,7 @@ int cellRtcTickAddMinutes(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick>
 	cellRtc->Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
 	
 	rDateTime date = rDateTime((time_t)pTick1->tick);
-	rTimeSpan minutes = rTimeSpan(0, lAdd, 0, 0);
+	rTimeSpan minutes = rTimeSpan(0, lAdd, 0, 0); // ???
 	date.Add(minutes);
 	pTick0->tick = date.GetTicks();
 
@@ -237,7 +237,7 @@ int cellRtcTickAddHours(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
 	cellRtc->Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
-	rTimeSpan hours = rTimeSpan(iAdd, 0, 0, 0);
+	rTimeSpan hours = rTimeSpan(iAdd, 0, 0, 0); // ???
 	date.Add(hours);
 	pTick0->tick = date.GetTicks();
 
@@ -249,7 +249,7 @@ int cellRtcTickAddDays(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTi
 	cellRtc->Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
-	rDateSpan days = rDateSpan(0, 0, 0, iAdd);
+	rDateSpan days = rDateSpan(0, 0, 0, iAdd); // ???
 	date.Add(days);
 	pTick0->tick = date.GetTicks();
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index d11100efea..ad4a67c6ac 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -14,7 +14,7 @@ extern u32 libsre;
 extern u32 libsre_rtoc;
 #endif
 
-s32 cellSpursInitialize(mem_ptr_t<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
+s64 cellSpursInitialize(mem_ptr_t<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
 {
 	cellSpurs->Warning("cellSpursInitialize(spurs_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs.GetAddr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
 
@@ -28,7 +28,7 @@ s32 cellSpursInitialize(mem_ptr_t<CellSpurs> spurs, s32 nSpus, s32 spuPriority,
 #endif
 }
 
-s32 cellSpursFinalize(mem_ptr_t<CellSpurs> spurs)
+s64 cellSpursFinalize(mem_ptr_t<CellSpurs> spurs)
 {
 	cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.GetAddr());
 
@@ -41,7 +41,7 @@ s32 cellSpursFinalize(mem_ptr_t<CellSpurs> spurs)
 #endif
 }
 
-s32 cellSpursInitializeWithAttribute(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t<CellSpursAttribute> attr)
+s64 cellSpursInitializeWithAttribute(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t<CellSpursAttribute> attr)
 {
 	cellSpurs->Warning("cellSpursInitializeWithAttribute(spurs_addr=0x%x, spurs_addr=0x%x)", spurs.GetAddr(), attr.GetAddr());
 
@@ -54,7 +54,7 @@ s32 cellSpursInitializeWithAttribute(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t
 #endif
 }
 
-s32 cellSpursInitializeWithAttribute2(mem_ptr_t<CellSpurs2> spurs, const mem_ptr_t<CellSpursAttribute> attr)
+s64 cellSpursInitializeWithAttribute2(mem_ptr_t<CellSpurs2> spurs, const mem_ptr_t<CellSpursAttribute> attr)
 {
 	cellSpurs->Warning("cellSpursInitializeWithAttribute2(spurs_addr=0x%x, spurs_addr=0x%x)", spurs.GetAddr(), attr.GetAddr());
 
@@ -67,7 +67,7 @@ s32 cellSpursInitializeWithAttribute2(mem_ptr_t<CellSpurs2> spurs, const mem_ptr
 #endif
 }
 
-s32 _cellSpursAttributeInitialize(mem_ptr_t<CellSpursAttribute> attr, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
+s64 _cellSpursAttributeInitialize(mem_ptr_t<CellSpursAttribute> attr, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
 {
 	cellSpurs->Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
 		attr.GetAddr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
@@ -81,7 +81,7 @@ s32 _cellSpursAttributeInitialize(mem_ptr_t<CellSpursAttribute> attr, s32 nSpus,
 #endif
 }
 
-s32 cellSpursAttributeSetMemoryContainerForSpuThread(mem_ptr_t<CellSpursAttribute> attr, u32 container)
+s64 cellSpursAttributeSetMemoryContainerForSpuThread(mem_ptr_t<CellSpursAttribute> attr, u32 container)
 {
 	cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=0x%x)", attr.GetAddr(), container);
 
@@ -94,7 +94,7 @@ s32 cellSpursAttributeSetMemoryContainerForSpuThread(mem_ptr_t<CellSpursAttribut
 #endif
 }
 
-s32 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, const mem8_t prefix, u32 size)
+s64 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, const mem8_t prefix, u32 size)
 {
 	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.GetAddr(), prefix.GetAddr(), size);
 
@@ -113,7 +113,7 @@ s32 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, const me
 #endif
 }
 
-s32 cellSpursAttributeEnableSpuPrintfIfAvailable(mem_ptr_t<CellSpursAttribute> attr)
+s64 cellSpursAttributeEnableSpuPrintfIfAvailable(mem_ptr_t<CellSpursAttribute> attr)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr_addr=0x%x)", attr.GetAddr());
@@ -124,7 +124,7 @@ s32 cellSpursAttributeEnableSpuPrintfIfAvailable(mem_ptr_t<CellSpursAttribute> a
 #endif
 }
 
-s32 cellSpursAttributeSetSpuThreadGroupType(mem_ptr_t<CellSpursAttribute> attr, s32 type)
+s64 cellSpursAttributeSetSpuThreadGroupType(mem_ptr_t<CellSpursAttribute> attr, s32 type)
 {
 	cellSpurs->Warning("cellSpursAttributeSetSpuThreadGroupType(attr_addr=0x%x, type=%d)", attr.GetAddr(), type);
 
@@ -137,7 +137,7 @@ s32 cellSpursAttributeSetSpuThreadGroupType(mem_ptr_t<CellSpursAttribute> attr,
 #endif
 }
 
-s32 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, mem8_ptr_t priority, u32 maxSpu, mem8_ptr_t isPreemptible)
+s64 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, mem8_ptr_t priority, u32 maxSpu, mem8_ptr_t isPreemptible)
 {
 	cellSpurs->Warning("cellSpursAttributeEnableSystemWorkload(attr_addr=0x%x, priority_addr=0x%x, maxSpu=%d, isPreemptible_addr=0x%x)",
 		attr.GetAddr(), priority.GetAddr(), maxSpu, isPreemptible.GetAddr());
@@ -157,7 +157,7 @@ s32 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, m
 #endif
 }
 
-s32 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, mem32_t group)
+s64 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, mem32_t group)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursGetSpuThreadGroupId(spurs_addr=0x%x, group_addr=0x%x)", spurs.GetAddr(), group.GetAddr());
@@ -168,7 +168,7 @@ s32 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, mem32_t group)
 #endif
 }
 
-s32 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, mem32_t nThreads)
+s64 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, mem32_t nThreads)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursGetNumSpuThread(spurs_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), nThreads.GetAddr());
@@ -179,7 +179,7 @@ s32 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, mem32_t nThreads)
 #endif
 }
 
-s32 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, mem32_t thread, mem32_t nThreads)
+s64 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, mem32_t thread, mem32_t nThreads)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursGetSpuThreadId(spurs_addr=0x%x, thread_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), thread.GetAddr(), nThreads.GetAddr());
@@ -190,7 +190,7 @@ s32 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, mem32_t thread, mem32_t
 #endif
 }
 
-s32 cellSpursSetMaxContention(mem_ptr_t<CellSpurs> spurs, u32 workloadId, u32 maxContention)
+s64 cellSpursSetMaxContention(mem_ptr_t<CellSpurs> spurs, u32 workloadId, u32 maxContention)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursSetMaxContention(spurs_addr=0x%x, workloadId=%d, maxContention=%d)", spurs.GetAddr(), workloadId, maxContention);
@@ -201,7 +201,7 @@ s32 cellSpursSetMaxContention(mem_ptr_t<CellSpurs> spurs, u32 workloadId, u32 ma
 #endif
 }
 
-s32 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, const mem8_ptr_t priorities)
+s64 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, const mem8_ptr_t priorities)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursSetPriorities(spurs_addr=0x%x, workloadId=%d, priorities_addr=0x%x)", spurs.GetAddr(), workloadId, priorities.GetAddr());
@@ -212,7 +212,7 @@ s32 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, const mem
 #endif
 }
 
-s32 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, mem8_ptr_t isPreemptible)
+s64 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, mem8_ptr_t isPreemptible)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursSetPreemptionVictimHints(spurs_addr=0x%x, isPreemptible_addr=0x%x)", spurs.GetAddr(), isPreemptible.GetAddr());
@@ -223,7 +223,7 @@ s32 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, mem8_ptr_t isP
 #endif
 }
 
-s32 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, mem8_t port, s32 isDynamic)
+s64 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, mem8_t port, s32 isDynamic)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursAttachLv2EventQueue(spurs_addr=0x%x, queue=%d, port_addr=0x%x, isDynamic=%d)",
@@ -235,7 +235,7 @@ s32 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, mem8_t p
 #endif
 }
 
-s32 cellSpursDetachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u8 port)
+s64 cellSpursDetachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u8 port)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursDetachLv2EventQueue(spurs_addr=0x%x, port=0x%x)", spurs.GetAddr(), port);
@@ -246,7 +246,7 @@ s32 cellSpursDetachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u8 port)
 #endif
 }
 
-s32 cellSpursEnableExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, bool flag)
+s64 cellSpursEnableExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, bool flag)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEnableExceptionEventHandler(spurs_addr=0x%x, flag=%d)", spurs.GetAddr(), flag);
@@ -257,7 +257,7 @@ s32 cellSpursEnableExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, bool flag)
 #endif
 }
 
-s32 cellSpursSetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, u32 eaHandler_addr, u32 arg_addr)
+s64 cellSpursSetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, u32 eaHandler_addr, u32 arg_addr)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursSetGlobalExceptionEventHandler(spurs_addr=0x%x, eaHandler_addr=0x%x, arg_addr=0x%x)",
@@ -269,7 +269,7 @@ s32 cellSpursSetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, u32 eaHa
 #endif
 }
 
-s32 cellSpursUnsetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs)
+s64 cellSpursUnsetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursUnsetGlobalExceptionEventHandler(spurs_addr=0x%x)", spurs.GetAddr());
@@ -280,7 +280,7 @@ s32 cellSpursUnsetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs)
 #endif
 }
 
-s32 cellSpursGetInfo(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursInfo> info)
+s64 cellSpursGetInfo(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursInfo> info)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursGetInfo(spurs_addr=0x%x, info_addr=0x%x)", spurs.GetAddr(), info.GetAddr());
@@ -291,7 +291,7 @@ s32 cellSpursGetInfo(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursInfo> info)
 #endif
 }
 
-s32 _cellSpursEventFlagInitialize(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, mem_ptr_t<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection)
+s64 _cellSpursEventFlagInitialize(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, mem_ptr_t<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("_cellSpursEventFlagInitialize(spurs_addr=0x%x, taskset_addr=0x%x, eventFlag_addr=0x%x, flagClearMode=%d, flagDirection=%d)",
@@ -303,7 +303,7 @@ s32 _cellSpursEventFlagInitialize(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpur
 #endif
 }
 
-s32 cellSpursEventFlagAttachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFlag)
+s64 cellSpursEventFlagAttachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFlag)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.GetAddr());
@@ -314,7 +314,7 @@ s32 cellSpursEventFlagAttachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFla
 #endif
 }
 
-s32 cellSpursEventFlagDetachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFlag)
+s64 cellSpursEventFlagDetachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFlag)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.GetAddr());
@@ -325,7 +325,7 @@ s32 cellSpursEventFlagDetachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFla
 #endif
 }
 
-s32 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask, u32 mode)
+s64 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask, u32 mode)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=%d)", eventFlag.GetAddr(), mask.GetAddr(), mode);
@@ -336,7 +336,7 @@ s32 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask
 #endif
 }
 
-s32 cellSpursEventFlagClear(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
+s64 cellSpursEventFlagClear(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagClear(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.GetAddr(), bits);
@@ -347,7 +347,7 @@ s32 cellSpursEventFlagClear(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 #endif
 }
 
-s32 cellSpursEventFlagSet(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
+s64 cellSpursEventFlagSet(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagSet(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.GetAddr(), bits);
@@ -358,7 +358,7 @@ s32 cellSpursEventFlagSet(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 #endif
 }
 
-s32 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask, u32 mode)
+s64 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask, u32 mode)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagTryWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=0x%x)", eventFlag.GetAddr(), mask.GetAddr(), mode);
@@ -369,7 +369,7 @@ s32 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t m
 #endif
 }
 
-s32 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, mem32_t direction)
+s64 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, mem32_t direction)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagGetDirection(eventFlag_addr=0x%x, direction_addr=0x%x)", eventFlag.GetAddr(), direction.GetAddr());
@@ -380,7 +380,7 @@ s32 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, mem3
 #endif
 }
 
-s32 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, mem32_t clear_mode)
+s64 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, mem32_t clear_mode)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagGetClearMode(eventFlag_addr=0x%x, clear_mode_addr=0x%x)", eventFlag.GetAddr(), clear_mode.GetAddr());
@@ -391,7 +391,7 @@ s32 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, mem3
 #endif
 }
 
-s32 cellSpursEventFlagGetTasksetAddress(mem_ptr_t<CellSpursEventFlag> eventFlag, mem_ptr_t<CellSpursTaskset> taskset)
+s64 cellSpursEventFlagGetTasksetAddress(mem_ptr_t<CellSpursEventFlag> eventFlag, mem_ptr_t<CellSpursTaskset> taskset)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursEventFlagGetTasksetAddress(eventFlag_addr=0x%x, taskset_addr=0x%x)", eventFlag.GetAddr(), taskset.GetAddr());
@@ -402,7 +402,7 @@ s32 cellSpursEventFlagGetTasksetAddress(mem_ptr_t<CellSpursEventFlag> eventFlag,
 #endif
 }
 
-s32 _cellSpursLFQueueInitialize()
+s64 _cellSpursLFQueueInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -413,7 +413,7 @@ s32 _cellSpursLFQueueInitialize()
 #endif
 }
 
-s32 _cellSpursLFQueuePushBody()
+s64 _cellSpursLFQueuePushBody()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -424,7 +424,7 @@ s32 _cellSpursLFQueuePushBody()
 #endif
 }
 
-s32 cellSpursLFQueueDetachLv2EventQueue()
+s64 cellSpursLFQueueDetachLv2EventQueue()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -435,7 +435,7 @@ s32 cellSpursLFQueueDetachLv2EventQueue()
 #endif
 }
 
-s32 cellSpursLFQueueAttachLv2EventQueue()
+s64 cellSpursLFQueueAttachLv2EventQueue()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -446,7 +446,7 @@ s32 cellSpursLFQueueAttachLv2EventQueue()
 #endif
 }
 
-s32 _cellSpursLFQueuePopBody()
+s64 _cellSpursLFQueuePopBody()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -457,7 +457,7 @@ s32 _cellSpursLFQueuePopBody()
 #endif
 }
 
-s32 cellSpursLFQueueGetTasksetAddress()
+s64 cellSpursLFQueueGetTasksetAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -468,7 +468,7 @@ s32 cellSpursLFQueueGetTasksetAddress()
 #endif
 }
 
-s32 _cellSpursQueueInitialize()
+s64 _cellSpursQueueInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -479,7 +479,7 @@ s32 _cellSpursQueueInitialize()
 #endif
 }
 
-s32 cellSpursQueuePopBody()
+s64 cellSpursQueuePopBody()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -490,7 +490,7 @@ s32 cellSpursQueuePopBody()
 #endif
 }
 
-s32 cellSpursQueuePushBody()
+s64 cellSpursQueuePushBody()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -501,7 +501,7 @@ s32 cellSpursQueuePushBody()
 #endif
 }
 
-s32 cellSpursQueueAttachLv2EventQueue()
+s64 cellSpursQueueAttachLv2EventQueue()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -512,7 +512,7 @@ s32 cellSpursQueueAttachLv2EventQueue()
 #endif
 }
 
-s32 cellSpursQueueDetachLv2EventQueue()
+s64 cellSpursQueueDetachLv2EventQueue()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -523,7 +523,7 @@ s32 cellSpursQueueDetachLv2EventQueue()
 #endif
 }
 
-s32 cellSpursQueueGetTasksetAddress()
+s64 cellSpursQueueGetTasksetAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -534,7 +534,7 @@ s32 cellSpursQueueGetTasksetAddress()
 #endif
 }
 
-s32 cellSpursQueueClear()
+s64 cellSpursQueueClear()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -545,7 +545,7 @@ s32 cellSpursQueueClear()
 #endif
 }
 
-s32 cellSpursQueueDepth()
+s64 cellSpursQueueDepth()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -556,7 +556,7 @@ s32 cellSpursQueueDepth()
 #endif
 }
 
-s32 cellSpursQueueGetEntrySize()
+s64 cellSpursQueueGetEntrySize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -567,7 +567,7 @@ s32 cellSpursQueueGetEntrySize()
 #endif
 }
 
-s32 cellSpursQueueSize()
+s64 cellSpursQueueSize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -578,7 +578,7 @@ s32 cellSpursQueueSize()
 #endif
 }
 
-s32 cellSpursQueueGetDirection()
+s64 cellSpursQueueGetDirection()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -589,7 +589,7 @@ s32 cellSpursQueueGetDirection()
 #endif
 }
 
-s32 cellSpursCreateJobChainWithAttribute()
+s64 cellSpursCreateJobChainWithAttribute()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -600,7 +600,7 @@ s32 cellSpursCreateJobChainWithAttribute()
 #endif
 }
 
-s32 cellSpursCreateJobChain()
+s64 cellSpursCreateJobChain()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -611,7 +611,7 @@ s32 cellSpursCreateJobChain()
 #endif
 }
 
-s32 cellSpursJoinJobChain()
+s64 cellSpursJoinJobChain()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -622,7 +622,7 @@ s32 cellSpursJoinJobChain()
 #endif
 }
 
-s32 cellSpursKickJobChain()
+s64 cellSpursKickJobChain()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -633,7 +633,7 @@ s32 cellSpursKickJobChain()
 #endif
 }
 
-s32 _cellSpursJobChainAttributeInitialize()
+s64 _cellSpursJobChainAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -644,7 +644,7 @@ s32 _cellSpursJobChainAttributeInitialize()
 #endif
 }
 
-s32 cellSpursGetJobChainId()
+s64 cellSpursGetJobChainId()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -655,7 +655,7 @@ s32 cellSpursGetJobChainId()
 #endif
 }
 
-s32 cellSpursJobChainSetExceptionEventHandler()
+s64 cellSpursJobChainSetExceptionEventHandler()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -666,7 +666,7 @@ s32 cellSpursJobChainSetExceptionEventHandler()
 #endif
 }
 
-s32 cellSpursJobChainUnsetExceptionEventHandler()
+s64 cellSpursJobChainUnsetExceptionEventHandler()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -677,7 +677,7 @@ s32 cellSpursJobChainUnsetExceptionEventHandler()
 #endif
 }
 
-s32 cellSpursGetJobChainInfo()
+s64 cellSpursGetJobChainInfo()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -688,7 +688,7 @@ s32 cellSpursGetJobChainInfo()
 #endif
 }
 
-s32 cellSpursJobChainGetSpursAddress()
+s64 cellSpursJobChainGetSpursAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -699,7 +699,7 @@ s32 cellSpursJobChainGetSpursAddress()
 #endif
 }
 
-s32 cellSpursCreateTasksetWithAttribute()
+s64 cellSpursCreateTasksetWithAttribute()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -710,7 +710,7 @@ s32 cellSpursCreateTasksetWithAttribute()
 #endif
 }
 
-s32 cellSpursCreateTaskset(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, u64 args, mem8_t priority, u32 maxContention)
+s64 cellSpursCreateTaskset(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, u64 args, mem8_t priority, u32 maxContention)
 {
 	cellSpurs->Warning("cellSpursCreateTaskset(spurs_addr=0x%x, taskset_addr=0x%x, args=0x%llx, priority_addr=0x%x, maxContention=%d)",
 		spurs.GetAddr(), taskset.GetAddr(), args, priority.GetAddr(), maxContention);
@@ -725,7 +725,7 @@ s32 cellSpursCreateTaskset(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskse
 #endif
 }
 
-s32 cellSpursJoinTaskset(mem_ptr_t<CellSpursTaskset> taskset)
+s64 cellSpursJoinTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursJoinTaskset(taskset_addr=0x%x)", taskset.GetAddr());
@@ -736,7 +736,7 @@ s32 cellSpursJoinTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 #endif
 }
 
-s32 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, mem32_t workloadId)
+s64 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, mem32_t workloadId)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursGetTasksetId(taskset_addr=0x%x, workloadId_addr=0x%x)", taskset.GetAddr(), workloadId.GetAddr());
@@ -747,7 +747,7 @@ s32 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, mem32_t workloadI
 #endif
 }
 
-s32 cellSpursShutdownTaskset(mem_ptr_t<CellSpursTaskset> taskset)
+s64 cellSpursShutdownTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursShutdownTaskset(taskset_addr=0x%x)", taskset.GetAddr());
@@ -758,7 +758,7 @@ s32 cellSpursShutdownTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 #endif
 }
 
-s32 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, mem32_t taskID, u32 elf_addr, u32 context_addr, u32 context_size, mem_ptr_t<CellSpursTaskLsPattern> lsPattern,
+s64 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, mem32_t taskID, u32 elf_addr, u32 context_addr, u32 context_size, mem_ptr_t<CellSpursTaskLsPattern> lsPattern,
 	mem_ptr_t<CellSpursTaskArgument> argument)
 {
 #ifdef PRX_DEBUG
@@ -771,7 +771,7 @@ s32 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, mem32_t taskID, u32
 #endif
 }
 
-s32 _cellSpursSendSignal(mem_ptr_t<CellSpursTaskset> taskset, u32 taskID)
+s64 _cellSpursSendSignal(mem_ptr_t<CellSpursTaskset> taskset, u32 taskID)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("_cellSpursSendSignal(taskset_addr=0x%x, taskID=%d)", taskset.GetAddr(), taskID);
@@ -782,7 +782,7 @@ s32 _cellSpursSendSignal(mem_ptr_t<CellSpursTaskset> taskset, u32 taskID)
 #endif
 }
 
-s32 cellSpursCreateTaskWithAttribute()
+s64 cellSpursCreateTaskWithAttribute()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -793,7 +793,7 @@ s32 cellSpursCreateTaskWithAttribute()
 #endif
 }
 
-s32 cellSpursTasksetAttributeSetName()
+s64 cellSpursTasksetAttributeSetName()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -804,7 +804,7 @@ s32 cellSpursTasksetAttributeSetName()
 #endif
 }
 
-s32 cellSpursTasksetAttributeSetTasksetSize()
+s64 cellSpursTasksetAttributeSetTasksetSize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -815,7 +815,7 @@ s32 cellSpursTasksetAttributeSetTasksetSize()
 #endif
 }
 
-s32 cellSpursTasksetAttributeEnableClearLS()
+s64 cellSpursTasksetAttributeEnableClearLS()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -826,7 +826,7 @@ s32 cellSpursTasksetAttributeEnableClearLS()
 #endif
 }
 
-s32 _cellSpursTasksetAttribute2Initialize(mem_ptr_t<CellSpursTasksetAttribute2> attribute, u32 revision)
+s64 _cellSpursTasksetAttribute2Initialize(mem_ptr_t<CellSpursTasksetAttribute2> attribute, u32 revision)
 {
 	cellSpurs->Warning("_cellSpursTasksetAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.GetAddr(), revision);
 	
@@ -850,7 +850,7 @@ s32 _cellSpursTasksetAttribute2Initialize(mem_ptr_t<CellSpursTasksetAttribute2>
 #endif
 }
 
-s32 cellSpursTaskExitCodeGet()
+s64 cellSpursTaskExitCodeGet()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -861,7 +861,7 @@ s32 cellSpursTaskExitCodeGet()
 #endif
 }
 
-s32 cellSpursTaskExitCodeInitialize()
+s64 cellSpursTaskExitCodeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -872,7 +872,7 @@ s32 cellSpursTaskExitCodeInitialize()
 #endif
 }
 
-s32 cellSpursTaskExitCodeTryGet()
+s64 cellSpursTaskExitCodeTryGet()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -883,7 +883,7 @@ s32 cellSpursTaskExitCodeTryGet()
 #endif
 }
 
-s32 cellSpursTaskGetLoadableSegmentPattern()
+s64 cellSpursTaskGetLoadableSegmentPattern()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -894,7 +894,7 @@ s32 cellSpursTaskGetLoadableSegmentPattern()
 #endif
 }
 
-s32 cellSpursTaskGetReadOnlyAreaPattern()
+s64 cellSpursTaskGetReadOnlyAreaPattern()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -905,7 +905,7 @@ s32 cellSpursTaskGetReadOnlyAreaPattern()
 #endif
 }
 
-s32 cellSpursTaskGenerateLsPattern()
+s64 cellSpursTaskGenerateLsPattern()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -916,7 +916,7 @@ s32 cellSpursTaskGenerateLsPattern()
 #endif
 }
 
-s32 _cellSpursTaskAttributeInitialize()
+s64 _cellSpursTaskAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -927,7 +927,7 @@ s32 _cellSpursTaskAttributeInitialize()
 #endif
 }
 
-s32 cellSpursTaskAttributeSetExitCodeContainer()
+s64 cellSpursTaskAttributeSetExitCodeContainer()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -938,7 +938,7 @@ s32 cellSpursTaskAttributeSetExitCodeContainer()
 #endif
 }
 
-s32 _cellSpursTaskAttribute2Initialize(mem_ptr_t<CellSpursTaskAttribute2> attribute, u32 revision)
+s64 _cellSpursTaskAttribute2Initialize(mem_ptr_t<CellSpursTaskAttribute2> attribute, u32 revision)
 {
 	cellSpurs->Warning("_cellSpursTaskAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.GetAddr(), revision);
 
@@ -965,7 +965,7 @@ s32 _cellSpursTaskAttribute2Initialize(mem_ptr_t<CellSpursTaskAttribute2> attrib
 #endif
 }
 
-s32 cellSpursTaskGetContextSaveAreaSize()
+s64 cellSpursTaskGetContextSaveAreaSize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -976,7 +976,7 @@ s32 cellSpursTaskGetContextSaveAreaSize()
 #endif
 }
 
-s32 cellSpursCreateTaskset2()
+s64 cellSpursCreateTaskset2()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -987,7 +987,7 @@ s32 cellSpursCreateTaskset2()
 #endif
 }
 
-s32 cellSpursCreateTask2()
+s64 cellSpursCreateTask2()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -998,7 +998,7 @@ s32 cellSpursCreateTask2()
 #endif
 }
 
-s32 cellSpursJoinTask2()
+s64 cellSpursJoinTask2()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1009,7 +1009,7 @@ s32 cellSpursJoinTask2()
 #endif
 }
 
-s32 cellSpursTryJoinTask2()
+s64 cellSpursTryJoinTask2()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1020,7 +1020,7 @@ s32 cellSpursTryJoinTask2()
 #endif
 }
 
-s32 cellSpursDestroyTaskset2()
+s64 cellSpursDestroyTaskset2()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1031,7 +1031,7 @@ s32 cellSpursDestroyTaskset2()
 #endif
 }
 
-s32 cellSpursCreateTask2WithBinInfo()
+s64 cellSpursCreateTask2WithBinInfo()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1042,7 +1042,7 @@ s32 cellSpursCreateTask2WithBinInfo()
 #endif
 }
 
-s32 cellSpursTasksetSetExceptionEventHandler()
+s64 cellSpursTasksetSetExceptionEventHandler()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1053,7 +1053,7 @@ s32 cellSpursTasksetSetExceptionEventHandler()
 #endif
 }
 
-s32 cellSpursTasksetUnsetExceptionEventHandler()
+s64 cellSpursTasksetUnsetExceptionEventHandler()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1064,7 +1064,7 @@ s32 cellSpursTasksetUnsetExceptionEventHandler()
 #endif
 }
 
-s32 cellSpursLookUpTasksetAddress()
+s64 cellSpursLookUpTasksetAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1075,7 +1075,7 @@ s32 cellSpursLookUpTasksetAddress()
 #endif
 }
 
-s32 cellSpursTasksetGetSpursAddress()
+s64 cellSpursTasksetGetSpursAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1086,7 +1086,7 @@ s32 cellSpursTasksetGetSpursAddress()
 #endif
 }
 
-s32 cellSpursSetExceptionEventHandler()
+s64 cellSpursSetExceptionEventHandler()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1097,7 +1097,7 @@ s32 cellSpursSetExceptionEventHandler()
 #endif
 }
 
-s32 cellSpursUnsetExceptionEventHandler()
+s64 cellSpursUnsetExceptionEventHandler()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1108,7 +1108,7 @@ s32 cellSpursUnsetExceptionEventHandler()
 #endif
 }
 
-s32 cellSpursGetTasksetInfo()
+s64 cellSpursGetTasksetInfo()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1119,7 +1119,7 @@ s32 cellSpursGetTasksetInfo()
 #endif
 }
 
-s32 _cellSpursTasksetAttributeInitialize()
+s64 _cellSpursTasksetAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1130,7 +1130,7 @@ s32 _cellSpursTasksetAttributeInitialize()
 #endif
 }
 
-s32 cellSpursJobGuardInitialize()
+s64 cellSpursJobGuardInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1141,7 +1141,7 @@ s32 cellSpursJobGuardInitialize()
 #endif
 }
 
-s32 cellSpursJobChainAttributeSetName()
+s64 cellSpursJobChainAttributeSetName()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1152,7 +1152,7 @@ s32 cellSpursJobChainAttributeSetName()
 #endif
 }
 
-s32 cellSpursShutdownJobChain()
+s64 cellSpursShutdownJobChain()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1163,7 +1163,7 @@ s32 cellSpursShutdownJobChain()
 #endif
 }
 
-s32 cellSpursJobChainAttributeSetHaltOnError()
+s64 cellSpursJobChainAttributeSetHaltOnError()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1174,7 +1174,7 @@ s32 cellSpursJobChainAttributeSetHaltOnError()
 #endif
 }
 
-s32 cellSpursJobChainAttributeSetJobTypeMemoryCheck()
+s64 cellSpursJobChainAttributeSetJobTypeMemoryCheck()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1185,7 +1185,7 @@ s32 cellSpursJobChainAttributeSetJobTypeMemoryCheck()
 #endif
 }
 
-s32 cellSpursJobGuardNotify()
+s64 cellSpursJobGuardNotify()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1196,7 +1196,7 @@ s32 cellSpursJobGuardNotify()
 #endif
 }
 
-s32  cellSpursJobGuardReset()
+s64 cellSpursJobGuardReset()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1207,7 +1207,7 @@ s32  cellSpursJobGuardReset()
 #endif
 }
 
-s32 cellSpursRunJobChain()
+s64 cellSpursRunJobChain()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1218,7 +1218,7 @@ s32 cellSpursRunJobChain()
 #endif
 }
 
-s32 cellSpursJobChainGetError()
+s64 cellSpursJobChainGetError()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1229,7 +1229,7 @@ s32 cellSpursJobChainGetError()
 #endif
 }
 
-s32 cellSpursWorkloadAttributeSetName()
+s64 cellSpursWorkloadAttributeSetName()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1240,7 +1240,7 @@ s32 cellSpursWorkloadAttributeSetName()
 #endif
 }
 
-s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook()
+s64 cellSpursWorkloadAttributeSetShutdownCompletionEventHook()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1251,7 +1251,7 @@ s32 cellSpursWorkloadAttributeSetShutdownCompletionEventHook()
 #endif
 }
 
-s32 cellSpursAddWorkloadWithAttribute()
+s64 cellSpursAddWorkloadWithAttribute()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1262,7 +1262,7 @@ s32 cellSpursAddWorkloadWithAttribute()
 #endif
 }
 
-s32 cellSpursRemoveWorkload()
+s64 cellSpursRemoveWorkload()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1273,7 +1273,7 @@ s32 cellSpursRemoveWorkload()
 #endif
 }
 
-s32 cellSpursWaitForWorkloadShutdown()
+s64 cellSpursWaitForWorkloadShutdown()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1284,7 +1284,7 @@ s32 cellSpursWaitForWorkloadShutdown()
 #endif
 }
 
-s32 cellSpursAddWorkload()
+s64 cellSpursAddWorkload()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1295,7 +1295,7 @@ s32 cellSpursAddWorkload()
 #endif
 }
 
-s32 cellSpursWakeUp()
+s64 cellSpursWakeUp()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1306,7 +1306,7 @@ s32 cellSpursWakeUp()
 #endif
 }
 
-s32 cellSpursShutdownWorkload()
+s64 cellSpursShutdownWorkload()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1317,7 +1317,7 @@ s32 cellSpursShutdownWorkload()
 #endif
 }
 
-s32 _cellSpursWorkloadFlagReceiver()
+s64 _cellSpursWorkloadFlagReceiver()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1328,7 +1328,7 @@ s32 _cellSpursWorkloadFlagReceiver()
 #endif
 }
 
-s32 cellSpursGetWorkloadFlag()
+s64 cellSpursGetWorkloadFlag()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1339,7 +1339,7 @@ s32 cellSpursGetWorkloadFlag()
 #endif
 }
 
-s32 cellSpursReadyCountStore()
+s64 cellSpursReadyCountStore()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1350,7 +1350,7 @@ s32 cellSpursReadyCountStore()
 #endif
 }
 
-s32 _cellSpursWorkloadAttributeInitialize()
+s64 _cellSpursWorkloadAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1361,7 +1361,7 @@ s32 _cellSpursWorkloadAttributeInitialize()
 #endif
 }
 
-s32 cellSpursSendWorkloadSignal()
+s64 cellSpursSendWorkloadSignal()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1372,7 +1372,7 @@ s32 cellSpursSendWorkloadSignal()
 #endif
 }
 
-s32 cellSpursGetWorkloadData()
+s64 cellSpursGetWorkloadData()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1383,7 +1383,7 @@ s32 cellSpursGetWorkloadData()
 #endif
 }
 
-s32 cellSpursReadyCountAdd()
+s64 cellSpursReadyCountAdd()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1394,7 +1394,7 @@ s32 cellSpursReadyCountAdd()
 #endif
 }
 
-s32 cellSpursReadyCountCompareAndSwap()
+s64 cellSpursReadyCountCompareAndSwap()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1405,7 +1405,7 @@ s32 cellSpursReadyCountCompareAndSwap()
 #endif
 }
 
-s32 cellSpursReadyCountSwap()
+s64 cellSpursReadyCountSwap()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1416,7 +1416,7 @@ s32 cellSpursReadyCountSwap()
 #endif
 }
 
-s32 cellSpursRequestIdleSpu()
+s64 cellSpursRequestIdleSpu()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1427,7 +1427,7 @@ s32 cellSpursRequestIdleSpu()
 #endif
 }
 
-s32 cellSpursGetWorkloadInfo()
+s64 cellSpursGetWorkloadInfo()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1438,7 +1438,7 @@ s32 cellSpursGetWorkloadInfo()
 #endif
 }
 
-s32 cellSpursGetSpuGuid()
+s64 cellSpursGetSpuGuid()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1449,7 +1449,7 @@ s32 cellSpursGetSpuGuid()
 #endif
 }
 
-s32 _cellSpursWorkloadFlagReceiver2()
+s64 _cellSpursWorkloadFlagReceiver2()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1460,7 +1460,7 @@ s32 _cellSpursWorkloadFlagReceiver2()
 #endif
 }
 
-s32 cellSpursGetJobPipelineInfo()
+s64 cellSpursGetJobPipelineInfo()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1471,7 +1471,7 @@ s32 cellSpursGetJobPipelineInfo()
 #endif
 }
 
-s32 cellSpursJobSetMaxGrab()
+s64 cellSpursJobSetMaxGrab()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1482,7 +1482,7 @@ s32 cellSpursJobSetMaxGrab()
 #endif
 }
 
-s32 cellSpursJobHeaderSetJobbin2Param()
+s64 cellSpursJobHeaderSetJobbin2Param()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1493,7 +1493,7 @@ s32 cellSpursJobHeaderSetJobbin2Param()
 #endif
 }
 
-s32 cellSpursAddUrgentCommand()
+s64 cellSpursAddUrgentCommand()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1504,7 +1504,7 @@ s32 cellSpursAddUrgentCommand()
 #endif
 }
 
-s32 cellSpursAddUrgentCall()
+s64 cellSpursAddUrgentCall()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1515,7 +1515,7 @@ s32 cellSpursAddUrgentCall()
 #endif
 }
 
-s32 cellSpursBarrierInitialize()
+s64 cellSpursBarrierInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1526,7 +1526,7 @@ s32 cellSpursBarrierInitialize()
 #endif
 }
 
-s32 cellSpursBarrierGetTasksetAddress()
+s64 cellSpursBarrierGetTasksetAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1537,7 +1537,7 @@ s32 cellSpursBarrierGetTasksetAddress()
 #endif
 }
 
-s32 _cellSpursSemaphoreInitialize()
+s64 _cellSpursSemaphoreInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
@@ -1548,7 +1548,7 @@ s32 _cellSpursSemaphoreInitialize()
 #endif
 }
 
-s32 cellSpursSemaphoreGetTasksetAddress()
+s64 cellSpursSemaphoreGetTasksetAddress()
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("%s()", __FUNCTION__);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
index 9a74ec0904..95c27a9a9e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
@@ -764,7 +764,7 @@ void cellSpursJq_init()
 #ifdef PRX_DEBUG
 	CallAfter([]()
 	{
-		libspurs_jq = 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));
 		libspurs_jq_rtoc = libspurs_jq + 0x17E80;
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index b4ef823c47..a3c9b9cee5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -1451,7 +1451,7 @@ s32 syncLFQueueCompletePushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer
 				if (exch)
 				{
 					assert(fpSendSignal);
-					return fpSendSignal((u64)queue->m_eaSignal, var6);
+					return fpSendSignal((u32)queue->m_eaSignal, var6);
 				}
 			}
 			else
@@ -1532,7 +1532,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 		else
 		{
 #ifdef PRX_DEBUG
-			res = GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
+			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0);
@@ -1575,7 +1575,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 	else
 	{
 #ifdef PRX_DEBUG
-		res = GetCurrentPPUThread().FastCall(libsre + 0x355C, libsre_rtoc, queue.GetAddr(), position, 0);
+		res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x355C, libsre_rtoc, queue.GetAddr(), position, 0);
 #else
 		res = syncLFQueueCompletePushPointer2(queue, position, nullptr);
 #endif
@@ -1844,7 +1844,7 @@ s32 syncLFQueueCompletePopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer,
 				if (exch)
 				{
 					assert(fpSendSignal);
-					return fpSendSignal((u64)queue->m_eaSignal, var6);
+					return fpSendSignal((u32)queue->m_eaSignal, var6);
 				}
 			}
 			else
@@ -1923,7 +1923,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 		else
 		{
 #ifdef PRX_DEBUG
-			res = GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
+			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0);
@@ -1963,7 +1963,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 	else
 	{
 #ifdef PRX_DEBUG
-		res = GetCurrentPPUThread().FastCall(libsre + 0x3EB8, libsre_rtoc, queue.GetAddr(), position, 0, 0);
+		res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3EB8, libsre_rtoc, queue.GetAddr(), position, 0, 0);
 #else
 		res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0);
 #endif
@@ -2088,7 +2088,7 @@ s32 _cellSyncLFQueueGetSignalAddress(mem_ptr_t<CellSyncLFQueue> queue, mem32_t p
 		return CELL_SYNC_ERROR_ALIGN;
 	}
 
-	ppSignal = queue->m_eaSignal;
+	ppSignal = (u32)queue->m_eaSignal;
 	return CELL_OK;
 }
 
@@ -2206,7 +2206,7 @@ void cellSync_init()
 #ifdef PRX_DEBUG
 	CallAfter([]()
 	{
-		libsre = Memory.PRXMem.AllocAlign(sizeof(libsre_data), 4096);
+		libsre = (u32)Memory.PRXMem.AllocAlign(sizeof(libsre_data), 4096);
 		memcpy(Memory + libsre, libsre_data, sizeof(libsre_data));
 		libsre_rtoc = libsre + 0x399B0;
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
index fdfe773f65..700617edb5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
@@ -15,7 +15,7 @@ u32 libsync2;
 u32 libsync2_rtoc;
 #endif
 
-int _cellSync2MutexAttributeInitialize()
+s64 _cellSync2MutexAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -26,7 +26,7 @@ int _cellSync2MutexAttributeInitialize()
 #endif
 }
 
-int cellSync2MutexEstimateBufferSize()
+s64 cellSync2MutexEstimateBufferSize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -37,7 +37,7 @@ int cellSync2MutexEstimateBufferSize()
 #endif
 }
 
-int cellSync2MutexInitialize()
+s64 cellSync2MutexInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -48,7 +48,7 @@ int cellSync2MutexInitialize()
 #endif
 }
 
-int cellSync2MutexFinalize()
+s64 cellSync2MutexFinalize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -59,7 +59,7 @@ int cellSync2MutexFinalize()
 #endif
 }
 
-int cellSync2MutexLock()
+s64 cellSync2MutexLock()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -70,7 +70,7 @@ int cellSync2MutexLock()
 #endif
 }
 
-int cellSync2MutexTryLock()
+s64 cellSync2MutexTryLock()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -81,7 +81,7 @@ int cellSync2MutexTryLock()
 #endif
 }
 
-int cellSync2MutexUnlock()
+s64 cellSync2MutexUnlock()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -92,7 +92,7 @@ int cellSync2MutexUnlock()
 #endif
 }
 
-int _cellSync2CondAttributeInitialize()
+s64 _cellSync2CondAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -103,7 +103,7 @@ int _cellSync2CondAttributeInitialize()
 #endif
 }
 
-int cellSync2CondEstimateBufferSize()
+s64 cellSync2CondEstimateBufferSize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -114,7 +114,7 @@ int cellSync2CondEstimateBufferSize()
 #endif
 }
 
-int cellSync2CondInitialize()
+s64 cellSync2CondInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -125,7 +125,7 @@ int cellSync2CondInitialize()
 #endif
 }
 
-int cellSync2CondFinalize()
+s64 cellSync2CondFinalize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -136,7 +136,7 @@ int cellSync2CondFinalize()
 #endif
 }
 
-int cellSync2CondWait()
+s64 cellSync2CondWait()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -147,7 +147,7 @@ int cellSync2CondWait()
 #endif
 }
 
-int cellSync2CondSignal()
+s64 cellSync2CondSignal()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -158,7 +158,7 @@ int cellSync2CondSignal()
 #endif
 }
 
-int cellSync2CondSignalAll()
+s64 cellSync2CondSignalAll()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -169,7 +169,7 @@ int cellSync2CondSignalAll()
 #endif
 }
 
-int _cellSync2SemaphoreAttributeInitialize()
+s64 _cellSync2SemaphoreAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -180,7 +180,7 @@ int _cellSync2SemaphoreAttributeInitialize()
 #endif
 }
 
-int cellSync2SemaphoreEstimateBufferSize()
+s64 cellSync2SemaphoreEstimateBufferSize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -191,7 +191,7 @@ int cellSync2SemaphoreEstimateBufferSize()
 #endif
 }
 
-int cellSync2SemaphoreInitialize()
+s64 cellSync2SemaphoreInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -202,7 +202,7 @@ int cellSync2SemaphoreInitialize()
 #endif
 }
 
-int cellSync2SemaphoreFinalize()
+s64 cellSync2SemaphoreFinalize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -213,7 +213,7 @@ int cellSync2SemaphoreFinalize()
 #endif
 }
 
-int cellSync2SemaphoreAcquire()
+s64 cellSync2SemaphoreAcquire()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -224,7 +224,7 @@ int cellSync2SemaphoreAcquire()
 #endif
 }
 
-int cellSync2SemaphoreTryAcquire()
+s64 cellSync2SemaphoreTryAcquire()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -235,7 +235,7 @@ int cellSync2SemaphoreTryAcquire()
 #endif
 }
 
-int cellSync2SemaphoreRelease()
+s64 cellSync2SemaphoreRelease()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -246,7 +246,7 @@ int cellSync2SemaphoreRelease()
 #endif
 }
 
-int cellSync2SemaphoreGetCount()
+s64 cellSync2SemaphoreGetCount()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -257,7 +257,7 @@ int cellSync2SemaphoreGetCount()
 #endif
 }
 
-int _cellSync2QueueAttributeInitialize()
+s64 _cellSync2QueueAttributeInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -268,7 +268,7 @@ int _cellSync2QueueAttributeInitialize()
 #endif
 }
 
-int cellSync2QueueEstimateBufferSize()
+s64 cellSync2QueueEstimateBufferSize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -279,7 +279,7 @@ int cellSync2QueueEstimateBufferSize()
 #endif
 }
 
-int cellSync2QueueInitialize()
+s64 cellSync2QueueInitialize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -290,7 +290,7 @@ int cellSync2QueueInitialize()
 #endif
 }
 
-int cellSync2QueueFinalize()
+s64 cellSync2QueueFinalize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -301,7 +301,7 @@ int cellSync2QueueFinalize()
 #endif
 }
 
-int cellSync2QueuePush()
+s64 cellSync2QueuePush()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -312,7 +312,7 @@ int cellSync2QueuePush()
 #endif
 }
 
-int cellSync2QueueTryPush()
+s64 cellSync2QueueTryPush()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -323,7 +323,7 @@ int cellSync2QueueTryPush()
 #endif
 }
 
-int cellSync2QueuePop()
+s64 cellSync2QueuePop()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -334,7 +334,7 @@ int cellSync2QueuePop()
 #endif
 }
 
-int cellSync2QueueTryPop()
+s64 cellSync2QueueTryPop()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -345,7 +345,7 @@ int cellSync2QueueTryPop()
 #endif
 }
 
-int cellSync2QueueGetSize()
+s64 cellSync2QueueGetSize()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -356,7 +356,7 @@ int cellSync2QueueGetSize()
 #endif
 }
 
-int cellSync2QueueGetDepth()
+s64 cellSync2QueueGetDepth()
 {
 #ifdef PRX_DEBUG
 	cellSync2->Warning("%s()", __FUNCTION__);
@@ -408,7 +408,7 @@ void cellSync2_init()
 #ifdef PRX_DEBUG
 	CallAfter([]()
 	{
-		libsync2 = Memory.PRXMem.AllocAlign(sizeof(libsync2_data), 4096);
+		libsync2 = (u32)Memory.PRXMem.AllocAlign(sizeof(libsync2_data), 4096);
 		memcpy(Memory + libsync2, libsync2_data, sizeof(libsync2_data));
 		libsync2_rtoc = libsync2 + 0xF280;
 
@@ -427,7 +427,7 @@ void cellSync2_init()
 		FIX_IMPORT(sysPrxForUser, sys_lwmutex_create                  , libsync2 + 0x62D0);
 		FIX_IMPORT(sysPrxForUser, sys_ppu_thread_get_id               , libsync2 + 0x62F0);
 		FIX_IMPORT(sysPrxForUser, _sys_memset                         , libsync2 + 0x6310);
-		FIX_IMPORT(sysPrxForUser, _sys_printf                         , libsync2 + 0x6330);
+		FIX_IMPORT(sysPrxForUser, _sys_prs64f                         , libsync2 + 0x6330);
 		fix_import(sysPrxForUser, 0x9FB6228E                          , libsync2 + 0x6350);
 		FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy                 , libsync2 + 0x6370);
 		FIX_IMPORT(sysPrxForUser, _sys_strncpy                        , libsync2 + 0x6390);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index 978c7ce081..3b17cb5fb7 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -74,7 +74,7 @@ void addSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, const std::string
 	saveEntry.title = psf.GetString("TITLE");
 	saveEntry.subtitle = psf.GetString("SUB_TITLE");
 	saveEntry.details = psf.GetString("DETAIL");
-	saveEntry.sizeKB = getSaveDataSize(saveDir)/1024;
+	saveEntry.sizeKB = (u32)(getSaveDataSize(saveDir) / 1024);
 	saveEntry.st_atime_ = 0; // TODO
 	saveEntry.st_mtime_ = 0; // TODO
 	saveEntry.st_ctime_ = 0; // TODO
@@ -209,7 +209,7 @@ void getSaveDataStat(SaveDataEntry entry, mem_ptr_t<CellSaveDataStatGet> statGet
 		}
 	}
 
-	statGet->fileList.SetAddr(be_t<u32>::MakeFromLE(Memory.Alloc(sizeof(CellSaveDataFileStat)* fileEntries.size(), sizeof(CellSaveDataFileStat))));
+	statGet->fileList.SetAddr(be_t<u32>::MakeFromLE((u32)Memory.Alloc(sizeof(CellSaveDataFileStat) * (u32)fileEntries.size(), sizeof(CellSaveDataFileStat))));
 	for (u32 i=0; i<fileEntries.size(); i++)
 		memcpy(&statGet->fileList[i], &fileEntries[i], sizeof(CellSaveDataFileStat));
 }
@@ -256,13 +256,13 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
 		{
 		case CELL_SAVEDATA_FILEOP_READ:
 			file = Emu.GetVFS().OpenFile(filepath, vfsRead);
-			fileGet->excSize = file->Read(buf, std::min(fileSet->fileSize, fileSet->fileBufSize)); // TODO: This may fail for big files because of the dest pointer.
+			fileGet->excSize = (u32)file->Read(buf, (u32)std::min(fileSet->fileSize, fileSet->fileBufSize)); // TODO: This may fail for big files because of the dest pointer.
 			break;
 		
 		case CELL_SAVEDATA_FILEOP_WRITE:
 			Emu.GetVFS().CreateFile(filepath);
 			file = Emu.GetVFS().OpenFile(filepath, vfsWrite);
-			fileGet->excSize = file->Write(buf, std::min(fileSet->fileSize, fileSet->fileBufSize)); // TODO: This may fail for big files because of the dest pointer.
+			fileGet->excSize = (u32)file->Write(buf, (u32)std::min(fileSet->fileSize, fileSet->fileBufSize)); // TODO: This may fail for big files because of the dest pointer.
 			break;
 
 		case CELL_SAVEDATA_FILEOP_DELETE:
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
index 7bfb67aef1..b558b6b20d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
@@ -702,11 +702,11 @@ int cellVdecGetPicItem(u32 handle, mem32_t picItem_ptr)
 	info->startAddr = 0x00000123; // invalid value (no address for picture)
 	info->size = a128(av_image_get_buffer_size(vdec->ctx->pix_fmt, vdec->ctx->width, vdec->ctx->height, 1));
 	info->auNum = 1;
-	info->auPts[0].lower = vf.pts;
+	info->auPts[0].lower = (u32)vf.pts;
 	info->auPts[0].upper = vf.pts >> 32;
 	info->auPts[1].lower = 0xffffffff;
 	info->auPts[1].upper = 0xffffffff;
-	info->auDts[0].lower = vf.dts;
+	info->auDts[0].lower = (u32)vf.dts;
 	info->auDts[0].upper = vf.dts >> 32;
 	info->auDts[1].lower = 0xffffffff;
 	info->auDts[1].upper = 0xffffffff;
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index da49b51552..f9e16dfa0b 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -162,7 +162,7 @@ int cellSSPlayerCreate(mem32_t handle, mem_ptr_t<CellSSPlayerConfig> config)
 	p.m_channels = config->channels;
 	
 	ssp.push_back(p);
-	handle = ssp.size() - 1;
+	handle = (u32)ssp.size() - 1;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
index 9a0c1b5909..71b560cc93 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
@@ -404,7 +404,7 @@ int sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, mem_ptr_t<Sc
 			}
 
 			data->trophyId = trophyId;
-			data->unlocked = ctxt.tropusr->GetTrophyUnlockState(trophyId);
+			data->unlocked = ctxt.tropusr->GetTrophyUnlockState(trophyId) ? true : false; // ???
 			data->timestamp.tick = ctxt.tropusr->GetTrophyTimestamp(trophyId);
 		}		
 	}
diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
index 8a1586aa35..3779de5299 100644
--- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
@@ -32,24 +32,24 @@ int _sys_heap_create_heap(const u32 heap_addr, const u32 align, const u32 size)
 	return heap_id;
 }
 
-int _sys_heap_malloc(const u32 heap_id, const u32 size)
+u32 _sys_heap_malloc(const u32 heap_id, const u32 size)
 {
 	sysPrxForUser->Warning("_sys_heap_malloc(heap_id=%d, size=0x%x)", heap_id, size);
 
 	HeapInfo* heap;
 	if(!sysPrxForUser->CheckId(heap_id, heap)) return CELL_ESRCH;
 
-	return Memory.Alloc(size, 1);
+	return (u32)Memory.Alloc(size, 1);
 }
 
-int _sys_heap_memalign(u32 heap_id, u32 align, u32 size)
+u32 _sys_heap_memalign(u32 heap_id, u32 align, u32 size)
 {
 	sysPrxForUser->Warning("_sys_heap_memalign(heap_id=%d, align=0x%x, size=0x%x)", heap_id, align, size);
 
 	HeapInfo* heap;
 	if(!sysPrxForUser->CheckId(heap_id, heap)) return CELL_ESRCH;
 
-	return Memory.Alloc(size, align);
+	return (u32)Memory.Alloc(size, align);
 }
 
 void sys_initialize_tls()
@@ -172,7 +172,7 @@ s32 _sys_memcmp(u32 addr1, u32 addr2, u32 size)
 	return memcmp(Memory + addr1, Memory + addr2, size);
 }
 
-s32 _sys_strlen(u32 addr)
+s64 _sys_strlen(u32 addr)
 {
 	sysPrxForUser->Log("_sys_strlen(addr=0x%x)", addr);
 
@@ -251,7 +251,7 @@ s32 _sys_spu_printf_finalize()
 	return CELL_OK;
 }
 
-s32 _sys_spu_printf_attach_group(u32 arg)
+s64 _sys_spu_printf_attach_group(u32 arg)
 {
 	sysPrxForUser->Warning("_sys_spu_printf_attach_group(arg=0x%x)", arg);
 
@@ -263,7 +263,7 @@ s32 _sys_spu_printf_attach_group(u32 arg)
 	return GetCurrentPPUThread().FastCall(Memory.Read32(spu_printf_agcb), Memory.Read32(spu_printf_agcb + 4), arg);
 }
 
-s32 _sys_spu_printf_detach_group(u32 arg)
+s64 _sys_spu_printf_detach_group(u32 arg)
 {
 	sysPrxForUser->Warning("_sys_spu_printf_detach_group(arg=0x%x)", arg);
 
@@ -275,7 +275,7 @@ s32 _sys_spu_printf_detach_group(u32 arg)
 	return GetCurrentPPUThread().FastCall(Memory.Read32(spu_printf_dgcb), Memory.Read32(spu_printf_dgcb + 4), arg);
 }
 
-s32 _sys_spu_printf_attach_thread(u32 arg)
+s64 _sys_spu_printf_attach_thread(u32 arg)
 {
 	sysPrxForUser->Warning("_sys_spu_printf_attach_thread(arg=0x%x)", arg);
 
@@ -287,7 +287,7 @@ s32 _sys_spu_printf_attach_thread(u32 arg)
 	return GetCurrentPPUThread().FastCall(Memory.Read32(spu_printf_atcb), Memory.Read32(spu_printf_atcb + 4), arg);
 }
 
-s32 _sys_spu_printf_detach_thread(u32 arg)
+s64 _sys_spu_printf_detach_thread(u32 arg)
 {
 	sysPrxForUser->Warning("_sys_spu_printf_detach_thread(arg=0x%x)", arg);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
index 3f943c843c..c403278ba2 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
@@ -66,7 +66,7 @@ int sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 	u32 blockSize      = re32(*(u32*)&buffer[0x84]);
 	u64 filesizeOutput = re64(*(u64*)&buffer[0x88]);
 	u64 filesizeInput  = packed_stream->GetSize();
-	u32 blockCount     = (filesizeOutput + blockSize-1) / blockSize;
+	u32 blockCount     = (u32)((filesizeOutput + blockSize - 1) / blockSize);
 
 	// SDATA file is compressed
 	if (flags & 0x1)
@@ -99,7 +99,7 @@ int sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 				packed_stream->Seek(packed_stream->Tell() + t1);
 
 			if (!(blockCount-i-1))
-				blockSize = filesizeOutput-i*blockSize;
+				blockSize = (u32)(filesizeOutput - i * blockSize);
 
 			packed_stream->Read(buffer+256, blockSize);
 			unpacked_stream->Write(buffer+256, blockSize);
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
index 9f660fde7b..00a4eeec2a 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
@@ -345,7 +345,7 @@ int socketselect()
 int sys_net_initialize_network_ex(mem_ptr_t<sys_net_initialize_parameter> param)
 {
 	sys_net->Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.GetAddr());
-	g_lastError.SetAddr(Memory.Alloc(4, 1));
+	g_lastError.SetAddr((u32)Memory.Alloc(4, 1));
 #ifdef _WIN32
 	WSADATA wsaData;
 	WORD wVersionRequested = MAKEWORD(1,1);
diff --git a/rpcs3/Emu/SysCalls/SysCalls.cpp b/rpcs3/Emu/SysCalls/SysCalls.cpp
index 999f736df0..4476aa1e3e 100644
--- a/rpcs3/Emu/SysCalls/SysCalls.cpp
+++ b/rpcs3/Emu/SysCalls/SysCalls.cpp
@@ -916,7 +916,7 @@ struct SyscallTableCleaner_t
 void default_syscall()
 {
 	declCPU();
-	u32 code = CPU.GPR[11];
+	u32 code = (u32)CPU.GPR[11];
 	//TODO: remove this
 	switch(code)
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
index e27723d1e6..5091e41b31 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
@@ -52,12 +52,12 @@ s32 sys_memory_allocate_from_container(u32 size, u32 cid, u32 flags, u32 alloc_a
 	{
 	case SYS_MEMORY_PAGE_SIZE_1M:
 		if(size & 0xfffff) return CELL_EALIGN;
-		ct->addr = Memory.Alloc(size, 0x100000);
+		ct->addr = (u32)Memory.Alloc(size, 0x100000);
 	break;
 
 	case SYS_MEMORY_PAGE_SIZE_64K:
 		if(size & 0xffff) return CELL_EALIGN;
-		ct->addr = Memory.Alloc(size, 0x10000);
+		ct->addr = (u32)Memory.Alloc(size, 0x10000);
 	break;
 
 	default: return CELL_EINVAL;
@@ -113,7 +113,7 @@ s32 sys_memory_container_create(mem32_t cid, u32 yield_size)
 	sys_memory.Warning("sys_memory_container_create(cid_addr=0x%x, yield_size=0x%x)", cid.GetAddr(), yield_size);
 
 	yield_size &= ~0xfffff; //round down to 1 MB granularity
-	u64 addr = Memory.Alloc(yield_size, 0x100000); //1 MB alignment
+	u32 addr = (u32)Memory.Alloc(yield_size, 0x100000); //1 MB alignment
 
 	if(!addr)
 		return CELL_ENOMEM;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.h b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
index 522c3328fe..78a4f4b3bd 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
@@ -35,7 +35,7 @@ struct MemoryContainerInfo
 	u32 addr;
 	u32 size;
 
-	MemoryContainerInfo(u64 addr, u32 size)
+	MemoryContainerInfo(u32 addr, u32 size)
 		: addr(addr)
 		, size(size)
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp
index 3c580f1721..66b231e462 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp
@@ -26,13 +26,13 @@ s32 sys_mmapper_allocate_address(u32 size, u64 flags, u32 alignment, u32 alloc_a
 	case SYS_MEMORY_PAGE_SIZE_1M:
 		if(AlignAddr(size, alignment) & 0xfffff)
 			return CELL_EALIGN;
-		addr = Memory.Alloc(size, 0x100000);
+		addr = (u32)Memory.Alloc(size, 0x100000);
 	break;
 
 	case SYS_MEMORY_PAGE_SIZE_64K:
 		if(AlignAddr(size, alignment) & 0xffff)
 			return CELL_EALIGN;
-		addr = Memory.Alloc(size, 0x10000);
+		addr = (u32)Memory.Alloc(size, 0x10000);
 	break;
 	}
 
@@ -64,13 +64,13 @@ s32 sys_mmapper_allocate_memory(u32 size, u64 flags, mem32_t mem_id)
 	case SYS_MEMORY_PAGE_SIZE_1M:
 		if(size & 0xfffff)
 			return CELL_EALIGN;
-		addr = Memory.Alloc(size, 0x100000);
+		addr = (u32)Memory.Alloc(size, 0x100000);
 	break;
 
 	case SYS_MEMORY_PAGE_SIZE_64K:
 		if(size & 0xffff)
 			return CELL_EALIGN;
-		addr = Memory.Alloc(size, 0x10000);
+		addr = (u32)Memory.Alloc(size, 0x10000);
 	break;
 
 	default:
@@ -102,13 +102,13 @@ s32 sys_mmapper_allocate_memory_from_container(u32 size, u32 cid, u64 flags, mem
 	case SYS_MEMORY_PAGE_SIZE_1M:
 		if(size & 0xfffff)
 			return CELL_EALIGN;
-		ct->addr = Memory.Alloc(size, 0x100000);
+		ct->addr = (u32)Memory.Alloc(size, 0x100000);
 	break;
 
 	case SYS_MEMORY_PAGE_SIZE_64K:
 		if(size & 0xffff)
 			return CELL_EALIGN;
-		ct->addr = Memory.Alloc(size, 0x10000);
+		ct->addr = (u32)Memory.Alloc(size, 0x10000);
 	break;
 
 	default:
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h
index 6a7a71d0e0..677ea634d5 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h
@@ -5,11 +5,11 @@
 
 struct mmapper_info
 {
-	u64 addr;
+	u32 addr;
 	u32 size;
-	u32 flags;
+	u64 flags;
 
-	mmapper_info(u64 _addr, u32 _size, u32 _flags)
+	mmapper_info(u32 _addr, u32 _size, u64 _flags)
 		: addr(_addr)
 		, size(_size)
 		, flags(_flags)
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
index d036beea57..875e96acf1 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
@@ -108,7 +108,7 @@ s32 sys_ppu_thread_get_priority(u64 thread_id, u32 prio_addr)
 	CPUThread* thr = Emu.GetCPU().GetThread(thread_id);
 	if(!thr) return CELL_ESRCH;
 
-	Memory.Write32(prio_addr, thr->GetPrio());
+	Memory.Write32(prio_addr, (s32)thr->GetPrio());
 
 	return CELL_OK;
 }
@@ -119,8 +119,8 @@ s32 sys_ppu_thread_get_stack_information(u32 info_addr)
 
 	declCPU();
 
-	Memory.Write32(info_addr,   CPU.GetStackAddr());
-	Memory.Write32(info_addr+4, CPU.GetStackSize());
+	Memory.Write32(info_addr, (u32)CPU.GetStackAddr());
+	Memory.Write32(info_addr + 4, CPU.GetStackSize());
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
index d315f41039..439160dd41 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
@@ -32,8 +32,8 @@ s32 sys_prx_load_module(u32 path_addr, u64 flags, mem_ptr_t<sys_prx_load_module_
 
 	// Create the PRX object and return its id
 	sys_prx_t* prx = new sys_prx_t();
-	prx->size = f.GetSize();
-	prx->address = Memory.Alloc(prx->size, 4);
+	prx->size = (u32)f.GetSize();
+	prx->address = (u32)Memory.Alloc(prx->size, 4);
 	prx->path = path;
 	
 	// Load the PRX into memory
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index 09d02891f1..cac8416bbc 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -344,7 +344,7 @@ void Emulator::Load()
 		thread.AddArgv(m_elf_path);
 		//thread.AddArgv("-emu");
 
-		m_rsx_callback = Memory.MainMem.AllocAlign(4 * 4) + 4;
+		m_rsx_callback = (u32)Memory.MainMem.AllocAlign(4 * 4) + 4;
 		Memory.Write32(m_rsx_callback - 4, m_rsx_callback);
 
 		mem32_ptr_t callback_data(m_rsx_callback);
@@ -352,7 +352,7 @@ void Emulator::Load()
 		callback_data += SC(2);
 		callback_data += BCLR(0x10 | 0x04, 0, 0, 0);
 
-		m_ppu_thr_exit = Memory.MainMem.AllocAlign(4 * 4);
+		m_ppu_thr_exit = (u32)Memory.MainMem.AllocAlign(4 * 4);
 
 		mem32_ptr_t ppu_thr_exit_data(m_ppu_thr_exit);
 		//ppu_thr_exit_data += ADDI(3, 0, 0); // why it kills return value (GPR[3]) ?
@@ -360,7 +360,7 @@ void Emulator::Load()
 		ppu_thr_exit_data += SC(2);
 		ppu_thr_exit_data += BCLR(0x10 | 0x04, 0, 0, 0);
 
-		m_ppu_thr_stop = Memory.MainMem.AllocAlign(2 * 4);
+		m_ppu_thr_stop = (u32)Memory.MainMem.AllocAlign(2 * 4);
 
 		mem32_ptr_t ppu_thr_stop_data(m_ppu_thr_stop);
 		ppu_thr_stop_data += SC(4);
@@ -494,8 +494,8 @@ void Emulator::SavePoints(const std::string& path)
 {
 	std::ofstream f(path, std::ios::binary | std::ios::trunc);
 
-	u32 break_count = m_break_points.size();
-	u32 marked_count = m_marked_points.size();
+	u32 break_count = (u32)m_break_points.size();
+	u32 marked_count = (u32)m_marked_points.size();
 
 	f << bpdb_version << break_count << marked_count;
 	
@@ -519,7 +519,7 @@ void Emulator::LoadPoints(const std::string& path)
 	if (!f.is_open())
 		return;
 	f.seekg(0, std::ios::end);
-	int length = f.tellg();
+	int length = (int)f.tellg();
 	f.seekg(0, std::ios::beg);
 	u32 break_count, marked_count;
 	u16 version;
diff --git a/rpcs3/Loader/ELF64.cpp b/rpcs3/Loader/ELF64.cpp
index 117a0bdbc2..d983d64995 100644
--- a/rpcs3/Loader/ELF64.cpp
+++ b/rpcs3/Loader/ELF64.cpp
@@ -231,7 +231,7 @@ bool ELF64Loader::LoadEhdrInfo(s64 offset)
 		return false;
 	}
 
-	entry = ehdr.GetEntry();
+	entry = (u32)ehdr.GetEntry();
 	if(entry == 0)
 	{
 		LOG_ERROR(LOADER, "elf64 error: entry is null!");
@@ -320,12 +320,12 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
 
 		if (phdr.p_vaddr < min_addr)
 		{
-			min_addr = phdr.p_vaddr;
+			min_addr = (u32)phdr.p_vaddr;
 		}
 
 		if (phdr.p_vaddr + phdr.p_memsz > max_addr)
 		{
-			max_addr = phdr.p_vaddr + phdr.p_memsz;
+			max_addr = (u32)(phdr.p_vaddr + phdr.p_memsz);
 		}
 
 		if (phdr.p_vaddr != phdr.p_paddr)
@@ -334,7 +334,7 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
 				phdr.p_paddr, phdr.p_vaddr);
 		}
 
-		if(!Memory.MainMem.IsInMyRange(offset + phdr.p_vaddr, phdr.p_memsz))
+		if(!Memory.MainMem.IsInMyRange(offset + phdr.p_vaddr, (u32)phdr.p_memsz))
 		{
 #ifdef LOADER_DEBUG
 			LOG_WARNING(LOADER, "Skipping...");
@@ -348,13 +348,15 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
 			case 0x00000001: //LOAD
 				if(phdr.p_memsz)
 				{
-					Memory.MainMem.AllocFixed(offset + phdr.p_vaddr, phdr.p_memsz);
-
-					if(phdr.p_filesz)
+					if (!Memory.MainMem.AllocFixed(offset + phdr.p_vaddr, (u32)phdr.p_memsz))
+					{
+						LOG_ERROR(LOADER, "%s(): AllocFixed(0x%llx, 0x%llx) failed", __FUNCTION__, offset + phdr.p_vaddr, phdr.p_memsz);
+					}
+					else if (phdr.p_filesz)
 					{
 						elf64_f.Seek(phdr.p_offset);
 						elf64_f.Read(&Memory[offset + phdr.p_vaddr], phdr.p_filesz);
-						Emu.GetSFuncManager().StaticAnalyse(&Memory[offset + phdr.p_vaddr], phdr.p_filesz, phdr.p_vaddr);
+						Emu.GetSFuncManager().StaticAnalyse(&Memory[offset + phdr.p_vaddr], (u32)phdr.p_filesz, (u32)phdr.p_vaddr);
 					}
 				}
 			break;
@@ -460,13 +462,13 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
 						LOG_NOTICE(LOADER, "*** nid: 0x%x (0x%x)", nid, stub.s_nid + i*4);
 						LOG_NOTICE(LOADER, "*** text: 0x%x (0x%x)", text, stub.s_text + i*4);
 #endif
-						Memory.Write32(stub.s_text + i*4, tbl + i*8);
+						Memory.Write32(stub.s_text + i*4, (u32)tbl + i*8);
 
-						mem32_ptr_t out_tbl(tbl + i*8);
-						out_tbl += dst + i*section;
+						mem32_ptr_t out_tbl((u32)tbl + i*8);
+						out_tbl += (u32)dst + i*section;
 						out_tbl += Emu.GetModuleManager().GetFuncNumById(nid);
 
-						mem32_ptr_t out_dst(dst + i*section);
+						mem32_ptr_t out_dst((u32)dst + i*section);
 						out_dst += OR(11, 2, 2, 0);
 						out_dst += SC(2);
 						out_dst += BCLR(0x10 | 0x04, 0, 0, 0);
@@ -512,16 +514,16 @@ bool ELF64Loader::LoadShdrData(u64 offset)
 		const u64 addr = shdr.sh_addr;
 		const u64 size = shdr.sh_size;
 
-		if(size == 0 || !Memory.IsGoodAddr(offset + addr, size)) continue;
+		if(size == 0 || !Memory.IsGoodAddr(offset + addr, (u32)size)) continue;
 
 		if(shdr.sh_addr && shdr.sh_addr < min_addr)
 		{
-			min_addr = shdr.sh_addr;
+			min_addr = (u32)shdr.sh_addr;
 		}
 
 		if(shdr.sh_addr + shdr.sh_size > max_addr)
 		{
-			max_addr = shdr.sh_addr + shdr.sh_size;
+			max_addr = (u32)(shdr.sh_addr + shdr.sh_size);
 		}
 
 		if((shdr.sh_type == SHT_RELA) || (shdr.sh_type == SHT_REL))
diff --git a/rpcs3/Loader/TROPUSR.cpp b/rpcs3/Loader/TROPUSR.cpp
index 1464d9189c..e6a15fb59f 100644
--- a/rpcs3/Loader/TROPUSR.cpp
+++ b/rpcs3/Loader/TROPUSR.cpp
@@ -145,10 +145,10 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
 			}
 
 			TROPUSREntry4 entry4 = { be_t<u32>::MakeFromBE(se32(4)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry4) - 0x10)),
-				be_t<u32>::MakeFromLE(m_table4.size()), be_t<u32>::MakeFromBE(se32(0)), be_t<u32>::MakeFromLE(trophy_id),
+				be_t<u32>::MakeFromLE((u32)m_table4.size()), be_t<u32>::MakeFromBE(se32(0)), be_t<u32>::MakeFromLE(trophy_id),
 				be_t<u32>::MakeFromLE(trophy_grade), be_t<u32>::MakeFromBE(se32(0xFFFFFFFF)) };
 			TROPUSREntry6 entry6 = { be_t<u32>::MakeFromBE(se32(6)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry6) - 0x10)),
-				be_t<u32>::MakeFromLE(m_table6.size()), be_t<u32>::MakeFromBE(0), be_t<u32>::MakeFromLE(trophy_id) };
+				be_t<u32>::MakeFromLE((u32)m_table6.size()), be_t<u32>::MakeFromBE(0), be_t<u32>::MakeFromLE(trophy_id) };
 
 			m_table4.push_back(entry4);
 			m_table6.push_back(entry6);
@@ -157,10 +157,10 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
 
 	u64 offset = sizeof(TROPUSRHeader) + 2 * sizeof(TROPUSRTableHeader);
 	TROPUSRTableHeader table4header = { be_t<u32>::MakeFromBE(se32(4)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry4)-0x10)),
-		be_t<u32>::MakeFromBE(se32(1)), be_t<u32>::MakeFromLE(m_table4.size()), be_t<u64>::MakeFromLE(offset) };
+		be_t<u32>::MakeFromBE(se32(1)), be_t<u32>::MakeFromLE((u32)m_table4.size()), be_t<u64>::MakeFromLE(offset) };
 	offset += m_table4.size() * sizeof(TROPUSREntry4);
 	TROPUSRTableHeader table6header = { be_t<u32>::MakeFromBE(se32(6)), be_t<u32>::MakeFromBE(se32(sizeof(TROPUSREntry6)-0x10)),
-		be_t<u32>::MakeFromBE(se32(1)), be_t<u32>::MakeFromLE(m_table6.size()), be_t<u64>::MakeFromLE(offset) };
+		be_t<u32>::MakeFromBE(se32(1)), be_t<u32>::MakeFromLE((u32)m_table6.size()), be_t<u64>::MakeFromLE(offset) };
 	offset += m_table6.size() * sizeof(TROPUSREntry6);
 
 	m_tableHeaders.clear();
@@ -169,7 +169,7 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
 
 	m_header.magic = 0x818F54AD;
 	m_header.unk1 = 0x00010000;
-	m_header.tables_count = m_tableHeaders.size();
+	m_header.tables_count = (u32)m_tableHeaders.size();
 	m_header.unk2 = 0;
 
 	Save(filepath);
@@ -178,7 +178,7 @@ bool TROPUSRLoader::Generate(const std::string& filepath, const std::string& con
 
 u32 TROPUSRLoader::GetTrophiesCount()
 {
-	return m_table6.size();
+	return (u32)m_table6.size();
 }
 
 u32 TROPUSRLoader::GetTrophyUnlockState(u32 id)
@@ -189,9 +189,9 @@ u32 TROPUSRLoader::GetTrophyUnlockState(u32 id)
 	return m_table6[id].trophy_state; // Let's assume the trophies are stored ordered
 }
 
-u32 TROPUSRLoader::GetTrophyTimestamp(u32 id)
+u64 TROPUSRLoader::GetTrophyTimestamp(u32 id)
 {
-	if (id >=  m_table6.size())
+	if (id >= m_table6.size())
 		LOG_WARNING(LOADER, "TROPUSRLoader::GetTrophyTimestamp: Invalid id=%d", id);
 
 	// TODO: What timestamp does sceNpTrophyGetTrophyInfo want, timestamp1 or timestamp2? 
diff --git a/rpcs3/Loader/TROPUSR.h b/rpcs3/Loader/TROPUSR.h
index bfdc0ff182..75c7660192 100644
--- a/rpcs3/Loader/TROPUSR.h
+++ b/rpcs3/Loader/TROPUSR.h
@@ -79,7 +79,7 @@ public:
 	virtual u32 GetTrophiesCount();
 
 	virtual u32 GetTrophyUnlockState(u32 id);
-	virtual u32 GetTrophyTimestamp(u32 id);
+	virtual u64 GetTrophyTimestamp(u32 id);
 
 	virtual bool UnlockTrophy(u32 id, u64 timestamp1, u64 timestamp2);
 };
diff --git a/rpcs3/stdafx.h b/rpcs3/stdafx.h
index 14109af0e2..fdd281b601 100644
--- a/rpcs3/stdafx.h
+++ b/rpcs3/stdafx.h
@@ -42,14 +42,14 @@ typedef uint16_t u16;
 typedef uint32_t u32;
 typedef uint64_t u64;
 
-static const u32 U32_MAX = 0xffffffff;
+static const u32 U32_MAX = 0xffffffffu;
 
 typedef int8_t s8;
 typedef int16_t s16;
 typedef int32_t s32;
 typedef int64_t s64;
 
-static const s32 S32_MIN = -0x80000000;
+static const s32 S32_MIN = (s32)0x80000000u;
 static const s32 S32_MAX = 0x7fffffff;
 
 union u128

From ff3df64a26d203ae51a4ddf8db0f1ee6f6e6fb03 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 03:06:43 +0400
Subject: [PATCH 07/36] Compilation fix

---
 rpcs3/Emu/Memory/vm.cpp                    | 12 ++++--------
 rpcs3/Emu/Memory/vm.h                      |  5 +----
 rpcs3/Emu/Memory/vm_ref.h                  | 10 +++++-----
 rpcs3/Emu/Memory/vm_var.h                  | 10 +++++-----
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp  |  4 ++--
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp   |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSync.cpp    | 14 +++++++-------
 rpcs3/Emu/SysCalls/Modules/cellSync2.cpp   |  2 +-
 9 files changed, 27 insertions(+), 34 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm.cpp b/rpcs3/Emu/Memory/vm.cpp
index a475b85eb7..2f91be639a 100644
--- a/rpcs3/Emu/Memory/vm.cpp
+++ b/rpcs3/Emu/Memory/vm.cpp
@@ -2,12 +2,14 @@
 
 namespace vm
 {
-	//TODO
 	bool check_addr(u32 addr)
 	{
+		// Checking address before using it is unsafe.
+		// The only safe way to check it is to protect both actions (checking and using) with mutex that is used for mapping/allocation.
 		return false;
 	}
 
+	//TODO
 	bool map(u32 addr, u32 size, u32 flags)
 	{
 		return false;
@@ -32,13 +34,7 @@ namespace vm
 		return 0;
 	}
 
-	bool read32(u32 addr, u32& value)
+	void write32(u32 addr, u32 value)
 	{
-		return false;
-	}
-
-	bool write32(u32 addr, u32 value)
-	{
-		return false;
 	}
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
index 97a43cb78a..4cd5b42ec2 100644
--- a/rpcs3/Emu/Memory/vm.h
+++ b/rpcs3/Emu/Memory/vm.h
@@ -2,7 +2,6 @@
 
 namespace vm
 {
-	bool check_addr(u32 addr);
 	bool map(u32 addr, u32 size, u32 flags);
 	bool unmap(u32 addr, u32 size = 0, u32 flags = 0);
 	u32 alloc(u32 size);
@@ -20,10 +19,8 @@ namespace vm
 		return (T&)Memory[addr];
 	}
 
-	//TODO
 	u32 read32(u32 addr);
-	bool read32(u32 addr, u32& value);
-	bool write32(u32 addr, u32 value);
+	void write32(u32 addr, u32 value);
 }
 
 #include "vm_ptr.h"
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 797c6da784..0d15220a08 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -28,9 +28,9 @@ namespace vm
 			return Memory.IsGoodAddr(m_addr, sizeof(T));
 		}
 
-		static ref make(u32 addr)
+		static _ref_base make(u32 addr)
 		{
-			return (ref&)addr;
+			return (_ref_base&)addr;
 		}
 	};
 
@@ -49,15 +49,15 @@ namespace vm
 	namespace ps3
 	{
 		//default reference for HLE functions (LE reference to BE data)
-		template<typename T, typename AT = u32> class ref : public lrefb {};
+		template<typename T, typename AT = u32> class ref : public lrefb<T, AT> {};
 
 		//default reference for HLE structures (BE reference to BE data)
-		template<typename T, typename AT = u32> class bref : public brefb {};
+		template<typename T, typename AT = u32> class bref : public brefb<T, AT> {};
 	}
 
 	namespace psv
 	{
 		//default reference for HLE functions & structures (LE reference to LE data)
-		template<typename T, typename AT = u32> class ref : public lrefl {};
+		template<typename T, typename AT = u32> class ref : public lrefl<T, AT> {};
 	}
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index adb4338c0d..ec2a97057f 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -34,7 +34,7 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? get_ptr<T>(m_addr) : nullptr;
+			m_ptr = (T*)Memory.VirtualToRealAddr(m_addr);
 		}
 
 		void dealloc()
@@ -54,7 +54,7 @@ namespace vm
 			res.m_addr = addr;
 			res.m_size = size;
 			res.m_align = align;
-			res.m_ptr = Memory.IsGoodAddr(addr, size) ? get_ptr<T>(addr) : nullptr;
+			res.m_ptr = (T*)Memory.VirtualToRealAddr(addr);
 
 			return res;
 		}
@@ -156,7 +156,7 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? get_ptr<T>(m_addr) : nullptr;
+			m_ptr = (T*)Memory.VirtualToRealAddr(m_addr);
 		}
 
 		void dealloc()
@@ -177,7 +177,7 @@ namespace vm
 			res.m_count = count;
 			res.m_size = size;
 			res.m_align = align;
-			res.m_ptr = Memory.IsGoodAddr(addr, size * count) ? get_ptr<T>(addr) : nullptr;
+			res.m_ptr = (T*)Memory.VirtualToRealAddr(addr);
 
 			return res;
 		}
@@ -355,7 +355,7 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = Memory.IsGoodAddr(m_addr, size()) ? get_ptr<T>(m_addr) : nullptr;
+			m_ptr = (T*)Memory.VirtualToRealAddr(m_addr);
 		}
 
 		void dealloc()
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
index 5ef3020554..c6ee6ff64a 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
@@ -129,8 +129,8 @@ u32 cellGcmGetNotifyDataAddress(u32 index)
 	cellGcmSys->Warning("cellGcmGetNotifyDataAddress(index=%d)", index);
 
 	// Get address of 'IO table' and 'EA table'
-	MemoryAllocator<CellGcmOffsetTable> table;
-	cellGcmGetOffsetTable(table.GetAddr());
+	vm::var<CellGcmOffsetTable> table;
+	cellGcmGetOffsetTable(table.addr());
 
 	// If entry not in use, return NULL
 	u16 entry = mem_ptr_t<u16>(table->eaAddress)[241];
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index ad4a67c6ac..733fb8feaa 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -9,7 +9,7 @@
 //Module cellSpurs(0x000a, cellSpurs_init);
 Module *cellSpurs = nullptr;
 
-#ifdef PRX_DEBUG
+#ifdef _WIN32
 extern u32 libsre;
 extern u32 libsre_rtoc;
 #endif
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
index 95c27a9a9e..2f768a85a3 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
@@ -8,7 +8,7 @@
 
 Module* cellSpursJq = nullptr;
 
-#ifdef PRX_DEBUG
+#ifdef _WIN32
 #include "prx_libspurs_jq.h"
 u32 libspurs_jq;
 u32 libspurs_jq_rtoc;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index a3c9b9cee5..14eeeea745 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -11,7 +11,7 @@
 //Module cellSync("cellSync", cellSync_init);
 Module *cellSync = nullptr;
 
-#ifdef PRX_DEBUG
+#ifdef _WIN32
 #include "prx_libsre.h"
 u32 libsre;
 u32 libsre_rtoc;	
@@ -1514,7 +1514,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 	//syncLFQueueDump(queue);
 
 #ifdef PRX_DEBUG
-	MemoryAllocator<be_t<s32>> position_v;
+	vm::var<be_t<s32>> position_v;
 #endif
 	while (true)
 	{
@@ -1523,7 +1523,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 		if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
 		{
 #ifdef PRX_DEBUG_XXX
-			res = GetCurrentPPUThread().FastCall(libsre + 0x24B0, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
+			res = GetCurrentPPUThread().FastCall(libsre + 0x24B0, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0);
@@ -1532,7 +1532,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 		else
 		{
 #ifdef PRX_DEBUG
-			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
+			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0);
@@ -1906,7 +1906,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 
 	s32 position;
 #ifdef PRX_DEBUG
-	MemoryAllocator<be_t<s32>> position_v;
+	vm::var<be_t<s32>> position_v;
 #endif
 	while (true)
 	{
@@ -1914,7 +1914,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 		if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
 		{
 #ifdef PRX_DEBUG_XXX
-			res = GetCurrentPPUThread().FastCall(libsre + 0x2A90, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0, 0);
+			res = GetCurrentPPUThread().FastCall(libsre + 0x2A90, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0);
@@ -1923,7 +1923,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 		else
 		{
 #ifdef PRX_DEBUG
-			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.GetAddr(), position_v.GetAddr(), isBlocking, 0);
+			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
index 700617edb5..3ac09b97f1 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
@@ -9,7 +9,7 @@
 //Module cellSync2(0x0055, cellSync2_init);
 Module* cellSync2 = nullptr;
 
-#ifdef PRX_DEBUG
+#ifdef _WIN32
 #include "prx_libsync2.h"
 u32 libsync2;
 u32 libsync2_rtoc;

From 140d40b5bc62b383cb5ee2caccbbd03f8316c354 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 03:19:10 +0400
Subject: [PATCH 08/36] Compilation fix 2

---
 rpcs3/Emu/Memory/vm_ptr.h | 20 ++++++++++----------
 rpcs3/Emu/Memory/vm_var.h | 39 ++++++++++++---------------------------
 2 files changed, 22 insertions(+), 37 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 3003f11e66..23a756fbfa 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -105,12 +105,12 @@ namespace vm
 	public:
 		__forceinline T* operator -> ()
 		{
-			return get_ptr<T>(m_addr);
+			return vm::get_ptr<T>(m_addr);
 		}
 
 		__forceinline const T* operator -> () const
 		{
-			return get_ptr<const T>(m_addr);
+			return vm::get_ptr<const T>(m_addr);
 		}
 
 		ptr operator++ (int)
@@ -309,28 +309,28 @@ namespace vm
 
 		__forceinline RT call_func(bool is_async, T... args) const
 		{
-			template<typename T>
+			template<typename TT>
 			struct _func_arg
 			{
-				__forceinline static u64 get_value(const T& arg)
+				__forceinline static u64 get_value(const TT& arg)
 				{
 					return arg;
 				}
 			};
 
-			template<typename T, typename AT>
-			struct _func_arg<ptr<T, AT>>
+			template<typename TT, typename ATT>
+			struct _func_arg<ptr<TT, ATT>>
 			{
-				__forceinline static u64 get_value(const ptr<T, AT> arg)
+				__forceinline static u64 get_value(const ptr<TT, ATT> arg)
 				{
 					return arg.addr();
 				}
 			};
 
-			template<typename T, typename AT>
-			struct _func_arg<ref<T, AT>>
+			template<typename TT, typename ATT>
+			struct _func_arg<ref<TT, ATT>>
 			{
-				__forceinline static u64 get_value(const ref<T, AT> arg)
+				__forceinline static u64 get_value(const ref<TT, ATT> arg)
 				{
 					return arg.addr();
 				}
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index ec2a97057f..6bd6af59d1 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -34,16 +34,16 @@ namespace vm
 		void alloc()
 		{
 			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = (T*)Memory.VirtualToRealAddr(m_addr);
+			m_ptr = vm::get_ptr<T>(m_addr);
 		}
 
 		void dealloc()
 		{
-			if (check())
+			if (m_addr)
 			{
 				Memory.Free(m_addr);
 				m_addr = 0;
-				m_ptr = nullptr;
+				m_ptr = vm::get_ptr<T>(0);
 			}
 		}
 		
@@ -54,7 +54,7 @@ namespace vm
 			res.m_addr = addr;
 			res.m_size = size;
 			res.m_align = align;
-			res.m_ptr = (T*)Memory.VirtualToRealAddr(addr);
+			res.m_ptr = vm::get_ptr<T>(addr);
 
 			return res;
 		}
@@ -99,11 +99,6 @@ namespace vm
 			return m_size;
 		}
 
-		bool check() const
-		{
-			return m_ptr != nullptr;
-		}
-
 		/*
 		operator const ref<T>() const
 		{
@@ -155,13 +150,13 @@ namespace vm
 
 		void alloc()
 		{
-			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = (T*)Memory.VirtualToRealAddr(m_addr);
+			m_addr = (u32)Memory.Alloc(size(), m_align);
+			m_ptr = vm::get_ptr<T>(m_addr);
 		}
 
 		void dealloc()
 		{
-			if (check())
+			if (m_addr)
 			{
 				Memory.Free(m_addr);
 				m_addr = 0;
@@ -177,7 +172,7 @@ namespace vm
 			res.m_count = count;
 			res.m_size = size;
 			res.m_align = align;
-			res.m_ptr = (T*)Memory.VirtualToRealAddr(addr);
+			res.m_ptr = vm::get_ptr<T>(addr);
 
 			return res;
 		}
@@ -237,11 +232,6 @@ namespace vm
 			return m_count;
 		}
 
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr, size());
-		}
-
 		template<typename T1>
 		operator const T1() const
 		{
@@ -354,17 +344,17 @@ namespace vm
 
 		void alloc()
 		{
-			m_addr = Memory.Alloc(size(), m_align);
-			m_ptr = (T*)Memory.VirtualToRealAddr(m_addr);
+			m_addr = (u32)Memory.Alloc(size(), m_align);
+			m_ptr = vm::get_ptr<T>(m_addr);
 		}
 
 		void dealloc()
 		{
-			if (check())
+			if (m_addr)
 			{
 				Memory.Free(m_addr);
 				m_addr = 0;
-				m_ptr = nullptr;
+				m_ptr = vm::get_ptr<T>(0);
 			}
 		}
 
@@ -423,11 +413,6 @@ namespace vm
 			return _count * m_size;
 		}
 
-		bool check() const
-		{
-			return m_ptr != nullptr;
-		}
-
 		template<typename T1>
 		operator const T1() const
 		{

From 26e03fa794f235367b68b19442eb5e180a2346cc Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 03:38:55 +0400
Subject: [PATCH 09/36] Compilation fix 3

---
 rpcs3/Emu/Memory/vm.h     |  2 +-
 rpcs3/Emu/Memory/vm_ptr.h | 79 +++++++++++++--------------------------
 rpcs3/Emu/Memory/vm_ref.h |  5 ---
 rpcs3/Emu/Memory/vm_var.h |  2 +-
 4 files changed, 29 insertions(+), 59 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
index 4cd5b42ec2..3898847569 100644
--- a/rpcs3/Emu/Memory/vm.h
+++ b/rpcs3/Emu/Memory/vm.h
@@ -23,6 +23,6 @@ namespace vm
 	void write32(u32 addr, u32 value);
 }
 
-#include "vm_ptr.h"
 #include "vm_ref.h"
+#include "vm_ptr.h"
 #include "vm_var.h"
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 23a756fbfa..3ed4231827 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -85,11 +85,6 @@ namespace vm
 		{
 			return m_addr;
 		}
-		
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr, sizeof(AT));
-		}
 
 		static ptr make(u32 addr)
 		{
@@ -208,11 +203,6 @@ namespace vm
 			return vm::get_ptr<T>(m_addr);
 		}
 		
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr, sizeof(T));
-		}
-
 		static ptr make(u32 addr)
 		{
 			return (ptr&)addr;
@@ -234,11 +224,6 @@ namespace vm
 		{
 			return vm::get_ptr<void>(m_addr);
 		}
-		
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr);
-		}
 
 		operator bool() const
 		{
@@ -286,11 +271,6 @@ namespace vm
 			return *((type*)vm::get_ptr<void*>(m_addr));
 		}
 
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr);
-		}
-
 		operator bool() const
 		{
 			return m_addr != 0;
@@ -307,35 +287,35 @@ namespace vm
 	{
 		AT m_addr;
 
+		template<typename TT>
+		struct _func_arg
+		{
+			__forceinline static u64 get_value(const TT& arg)
+			{
+				return arg;
+			}
+		};
+
+		template<typename TT, typename ATT>
+		struct _func_arg<ptr<TT, 1, ATT>>
+		{
+			__forceinline static u64 get_value(const ptr<TT, 1, ATT> arg)
+			{
+				return arg.addr();
+			}
+		};
+
+		template<typename TT, typename ATT>
+		struct _func_arg<_ref_base<TT, ATT>>
+		{
+			__forceinline static u64 get_value(const _ref_base<TT, ATT> arg)
+			{
+				return arg.addr();
+			}
+		};
+
 		__forceinline RT call_func(bool is_async, T... args) const
 		{
-			template<typename TT>
-			struct _func_arg
-			{
-				__forceinline static u64 get_value(const TT& arg)
-				{
-					return arg;
-				}
-			};
-
-			template<typename TT, typename ATT>
-			struct _func_arg<ptr<TT, ATT>>
-			{
-				__forceinline static u64 get_value(const ptr<TT, ATT> arg)
-				{
-					return arg.addr();
-				}
-			};
-
-			template<typename TT, typename ATT>
-			struct _func_arg<ref<TT, ATT>>
-			{
-				__forceinline static u64 get_value(const ref<TT, ATT> arg)
-				{
-					return arg.addr();
-				}
-			};
-
 			Callback cb;
 			cb.SetAddr(m_addr);
 			cb.Handle(_func_arg<T>::get_value(args)...);
@@ -365,11 +345,6 @@ namespace vm
 			return *((type*)vm::get_ptr<void*>(m_addr));
 		}
 
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr);
-		}
-
 		operator bool() const
 		{
 			return m_addr != 0;
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 0d15220a08..e75d67e02a 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -23,11 +23,6 @@ namespace vm
 			return m_addr;
 		}
 
-		bool check() const
-		{
-			return Memory.IsGoodAddr(m_addr, sizeof(T));
-		}
-
 		static _ref_base make(u32 addr)
 		{
 			return (_ref_base&)addr;
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index 6bd6af59d1..39467e3b10 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -33,7 +33,7 @@ namespace vm
 
 		void alloc()
 		{
-			m_addr = Memory.Alloc(size(), m_align);
+			m_addr = (u32)Memory.Alloc(size(), m_align);
 			m_ptr = vm::get_ptr<T>(m_addr);
 		}
 

From 571bd63644383ff58476e353977bdacfab243b02 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 13:54:12 +0400
Subject: [PATCH 10/36] Test

---
 rpcs3/Emu/Memory/Memory.cpp             |  35 ++-
 rpcs3/Emu/Memory/Memory.h               |  13 +-
 rpcs3/Emu/Memory/vm.cpp                 |  25 +-
 rpcs3/Emu/Memory/vm.h                   | 117 ++++++++-
 rpcs3/Emu/Memory/vm_ptr.h               |  12 +-
 rpcs3/Emu/SysCalls/Modules/cellSync.cpp | 320 ++++++++++++------------
 rpcs3/Emu/System.cpp                    |   2 +-
 7 files changed, 313 insertions(+), 211 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.cpp b/rpcs3/Emu/Memory/Memory.cpp
index 1dde6e3ba0..42045a57bd 100644
--- a/rpcs3/Emu/Memory/Memory.cpp
+++ b/rpcs3/Emu/Memory/Memory.cpp
@@ -6,14 +6,14 @@
 
 #ifndef _WIN32
 #include <sys/mman.h>
-#else
-#include <Windows.h>
-#endif
 
 /* OS X uses MAP_ANON instead of MAP_ANONYMOUS */
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
+#else
+#include <Windows.h>
+#endif
 
 MemoryBase Memory;
 
@@ -108,14 +108,11 @@ void MemoryBase::Init(MemoryType type)
 	memset(RawSPUMem, 0, sizeof(RawSPUMem));
 
 #ifdef _WIN32
-	m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE, PAGE_NOACCESS);
 	if (!m_base_addr)
 #else
-	m_base_addr = ::mmap(nullptr, 0x100000000, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
-	if (m_base_addr == (void*)-1)
+	if ((s64)m_base_addr == (s64)-1)
 #endif
 	{
-		m_base_addr = nullptr;
 		LOG_ERROR(MEMORY, "Initializing memory failed");
 		assert(0);
 		return;
@@ -139,7 +136,6 @@ void MemoryBase::Init(MemoryType type)
 	case Memory_PSV:
 		MemoryBlocks.push_back(PSV.RAM.SetRange(0x81000000, 0x10000000));
 		MemoryBlocks.push_back(UserMemory = PSV.Userspace.SetRange(0x91000000, 0x10000000));
-		PSV.Init(GetBaseAddr());
 		break;
 
 	case Memory_PSP:
@@ -148,7 +144,6 @@ void MemoryBase::Init(MemoryType type)
 		MemoryBlocks.push_back(PSP.RAM.SetRange(0x08000000, 0x02000000));
 		MemoryBlocks.push_back(PSP.Kernel.SetRange(0x88000000, 0x00800000));
 		MemoryBlocks.push_back(UserMemory = PSP.Userspace.SetRange(0x08800000, 0x01800000));
-		PSP.Init(GetBaseAddr());
 		break;
 	}
 
@@ -173,17 +168,17 @@ void MemoryBase::Close()
 
 	MemoryBlocks.clear();
 
-#ifdef _WIN32
-	if (!VirtualFree(m_base_addr, 0, MEM_RELEASE))
-	{
-		LOG_ERROR(MEMORY, "VirtualFree(0x%llx) failed", (u64)m_base_addr);
-	}
-#else
-	if (::munmap(m_base_addr, 0x100000000))
-	{
-		LOG_ERROR(MEMORY, "::munmap(0x%llx) failed", (u64)m_base_addr);
-	}
-#endif
+//#ifdef _WIN32
+//	if (!VirtualFree(m_base_addr, 0, MEM_RELEASE))
+//	{
+//		LOG_ERROR(MEMORY, "VirtualFree(0x%llx) failed", (u64)m_base_addr);
+//	}
+//#else
+//	if (::munmap(m_base_addr, 0x100000000))
+//	{
+//		LOG_ERROR(MEMORY, "::munmap(0x%llx) failed", (u64)m_base_addr);
+//	}
+//#endif
 }
 
 void MemoryBase::WriteMMIO32(u32 addr, const u32 data)
diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index 8d7bdc6762..51f4f2ae10 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -8,6 +8,8 @@ using std::nullptr_t;
 #define safe_delete(x) do {delete (x);(x)=nullptr;} while(0)
 #define safe_free(x) do {free(x);(x)=nullptr;} while(0)
 
+extern void* const m_base_addr;
+
 enum MemoryType
 {
 	Memory_PS3,
@@ -25,7 +27,6 @@ enum : u64
 
 class MemoryBase
 {
-	void* m_base_addr;
 	std::vector<MemoryBlock*> MemoryBlocks;
 	u32 m_pages[0x100000000 / 4096]; // information about every page
 	std::recursive_mutex m_mutex;
@@ -44,12 +45,6 @@ public:
 
 	struct Wrapper32LE
 	{
-	private:
-		void* m_base_addr;
-
-	public:
-		Wrapper32LE() : m_base_addr(nullptr) {}
-
 		void Write8(const u32 addr, const u8 data) { *(u8*)((u8*)m_base_addr + addr) = data; }
 		void Write16(const u32 addr, const u16 data) { *(u16*)((u8*)m_base_addr + addr) = data; }
 		void Write32(const u32 addr, const u32 data) { *(u32*)((u8*)m_base_addr + addr) = data; }
@@ -61,8 +56,6 @@ public:
 		u32 Read32(const u32 addr) { return *(u32*)((u8*)m_base_addr + addr); }
 		u64 Read64(const u32 addr) { return *(u64*)((u8*)m_base_addr + addr); }
 		u128 Read128(const u32 addr) { return *(u128*)((u8*)m_base_addr + addr); }
-
-		void Init(void* real_addr) { m_base_addr = real_addr; }
 	};
 
 	struct : Wrapper32LE
@@ -92,7 +85,7 @@ public:
 		Close();
 	}
 
-	void* GetBaseAddr() const
+	static void* const GetBaseAddr()
 	{
 		return m_base_addr;
 	}
diff --git a/rpcs3/Emu/Memory/vm.cpp b/rpcs3/Emu/Memory/vm.cpp
index 2f91be639a..044135c842 100644
--- a/rpcs3/Emu/Memory/vm.cpp
+++ b/rpcs3/Emu/Memory/vm.cpp
@@ -1,4 +1,20 @@
 #include "stdafx.h"
+#include "Memory.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+
+static void* const m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE, PAGE_NOACCESS);
+#else
+#include <sys/mman.h>
+
+/* OS X uses MAP_ANON instead of MAP_ANONYMOUS */
+#ifndef MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif
+
+static void* const m_base_addr = ::mmap(nullptr, 0x100000000, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+#endif
 
 namespace vm
 {
@@ -28,13 +44,4 @@ namespace vm
 	void unalloc(u32 addr)
 	{
 	}
-
-	u32 read32(u32 addr)
-	{
-		return 0;
-	}
-
-	void write32(u32 addr, u32 value)
-	{
-	}
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm.h b/rpcs3/Emu/Memory/vm.h
index 3898847569..0d6d77dee9 100644
--- a/rpcs3/Emu/Memory/vm.h
+++ b/rpcs3/Emu/Memory/vm.h
@@ -8,19 +8,126 @@ namespace vm
 	void unalloc(u32 addr);
 	
 	template<typename T>
-	T* get_ptr(u32 addr)
+	T* const get_ptr(u32 addr)
 	{
-		return (T*)&Memory[addr];
+		return (T*)((u8*)m_base_addr + addr);
 	}
 	
 	template<typename T>
 	T& get_ref(u32 addr)
 	{
-		return (T&)Memory[addr];
+		return *(T*)((u8*)m_base_addr + addr);
 	}
 
-	u32 read32(u32 addr);
-	void write32(u32 addr, u32 value);
+	static u8 read8(u32 addr)
+	{
+		return *((u8*)m_base_addr + addr);
+	}
+
+	static void write8(u32 addr, u8 value)
+	{
+		*((u8*)m_base_addr + addr) = value;
+	}
+
+	namespace ps3
+	{
+		static u16 read16(u32 addr)
+		{
+			return re16(*(u16*)((u8*)m_base_addr + addr));
+		}
+
+		static void write16(u32 addr, u16 value)
+		{
+			*(u16*)((u8*)m_base_addr + addr) = re16(value);
+		}
+
+		static u32 read32(u32 addr)
+		{
+			if (addr < RAW_SPU_BASE_ADDR || (addr % RAW_SPU_OFFSET) < RAW_SPU_PROB_OFFSET)
+			{
+				return re32(*(u32*)((u8*)m_base_addr + addr));
+			}
+			else
+			{
+				return Memory.ReadMMIO32((u32)addr);
+			}
+		}
+
+		static void write32(u32 addr, u32 value)
+		{
+			if (addr < RAW_SPU_BASE_ADDR || (addr % RAW_SPU_OFFSET) < RAW_SPU_PROB_OFFSET)
+			{
+				*(u32*)((u8*)m_base_addr + addr) = re32(value);
+			}
+			else
+			{
+				Memory.WriteMMIO32((u32)addr, value);
+			}
+		}
+
+		static u64 read64(u32 addr)
+		{
+			return re64(*(u64*)((u8*)m_base_addr + addr));
+		}
+
+		static void write64(u32 addr, u64 value)
+		{
+			*(u64*)((u8*)m_base_addr + addr) = re64(value);
+		}
+
+		static u128 read128(u32 addr)
+		{
+			return re128(*(u128*)((u8*)m_base_addr + addr));
+		}
+
+		static void write128(u32 addr, u128 value)
+		{
+			*(u128*)((u8*)m_base_addr + addr) = re128(value);
+		}
+	}
+	
+	namespace psv
+	{
+		static u16 read16(u32 addr)
+		{
+			return *(u16*)((u8*)m_base_addr + addr);
+		}
+
+		static void write16(u32 addr, u16 value)
+		{
+			*(u16*)((u8*)m_base_addr + addr) = value;
+		}
+
+		static u32 read32(u32 addr)
+		{
+			return *(u32*)((u8*)m_base_addr + addr);
+		}
+
+		static void write32(u32 addr, u32 value)
+		{
+			*(u32*)((u8*)m_base_addr + addr) = value;
+		}
+
+		static u64 read64(u32 addr)
+		{
+			return *(u64*)((u8*)m_base_addr + addr);
+		}
+
+		static void write64(u32 addr, u64 value)
+		{
+			*(u64*)((u8*)m_base_addr + addr) = value;
+		}
+
+		static u128 read128(u32 addr)
+		{
+			return *(u128*)((u8*)m_base_addr + addr);
+		}
+
+		static void write128(u32 addr, u128 value)
+		{
+			*(u128*)((u8*)m_base_addr + addr) = value;
+		}
+	}
 }
 
 #include "vm_ref.h"
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 3ed4231827..0b8be18393 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -98,12 +98,12 @@ namespace vm
 		AT m_addr;
 		
 	public:
-		__forceinline T* operator -> ()
+		__forceinline T* const operator -> ()
 		{
 			return vm::get_ptr<T>(m_addr);
 		}
 
-		__forceinline const T* operator -> () const
+		__forceinline const T* const operator -> () const
 		{
 			return vm::get_ptr<const T>(m_addr);
 		}
@@ -198,7 +198,7 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		T* get_ptr() const
+		T* const get_ptr() const
 		{
 			return vm::get_ptr<T>(m_addr);
 		}
@@ -220,7 +220,7 @@ namespace vm
 			return m_addr;
 		}
 
-		void* get_ptr() const
+		void* const get_ptr() const
 		{
 			return vm::get_ptr<void>(m_addr);
 		}
@@ -266,7 +266,7 @@ namespace vm
 			return m_addr;
 		}
 
-		type get_ptr() const
+		type const get_ptr() const
 		{
 			return *((type*)vm::get_ptr<void*>(m_addr));
 		}
@@ -340,7 +340,7 @@ namespace vm
 			return m_addr;
 		}
 
-		type get_ptr() const
+		type const get_ptr() const
 		{
 			return *((type*)vm::get_ptr<void*>(m_addr));
 		}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index 14eeeea745..b9ce671310 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -17,13 +17,13 @@ u32 libsre;
 u32 libsre_rtoc;	
 #endif
 
-s32 syncMutexInitialize(mem_ptr_t<CellSyncMutex> mutex)
+s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex)
 {
 	if (!mutex)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (mutex.GetAddr() % 4)
+	if (mutex.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -34,22 +34,22 @@ s32 syncMutexInitialize(mem_ptr_t<CellSyncMutex> mutex)
 	return CELL_OK;
 }
 
-s32 cellSyncMutexInitialize(mem_ptr_t<CellSyncMutex> mutex)
+s32 cellSyncMutexInitialize(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync->Log("cellSyncMutexInitialize(mutex_addr=0x%x)", mutex.GetAddr());
+	cellSync->Log("cellSyncMutexInitialize(mutex_addr=0x%x)", mutex.addr());
 
 	return syncMutexInitialize(mutex);
 }
 
-s32 cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
+s32 cellSyncMutexLock(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync->Log("cellSyncMutexLock(mutex_addr=0x%x)", mutex.GetAddr());
+	cellSync->Log("cellSyncMutexLock(mutex_addr=0x%x)", mutex.addr());
 
 	if (!mutex)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (mutex.GetAddr() % 4)
+	if (mutex.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -73,7 +73,7 @@ s32 cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
 		std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 		if (Emu.IsStopped())
 		{
-			cellSync->Warning("cellSyncMutexLock(mutex_addr=0x%x) aborted", mutex.GetAddr());
+			cellSync->Warning("cellSyncMutexLock(mutex_addr=0x%x) aborted", mutex.addr());
 			break;
 		}
 	}
@@ -83,15 +83,15 @@ s32 cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
 	return CELL_OK;
 }
 
-s32 cellSyncMutexTryLock(mem_ptr_t<CellSyncMutex> mutex)
+s32 cellSyncMutexTryLock(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync->Log("cellSyncMutexTryLock(mutex_addr=0x%x)", mutex.GetAddr());
+	cellSync->Log("cellSyncMutexTryLock(mutex_addr=0x%x)", mutex.addr());
 
 	if (!mutex)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (mutex.GetAddr() % 4)
+	if (mutex.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -117,15 +117,15 @@ s32 cellSyncMutexTryLock(mem_ptr_t<CellSyncMutex> mutex)
 	return CELL_OK;
 }
 
-s32 cellSyncMutexUnlock(mem_ptr_t<CellSyncMutex> mutex)
+s32 cellSyncMutexUnlock(vm::ptr<CellSyncMutex> mutex)
 {
-	cellSync->Log("cellSyncMutexUnlock(mutex_addr=0x%x)", mutex.GetAddr());
+	cellSync->Log("cellSyncMutexUnlock(mutex_addr=0x%x)", mutex.addr());
 
 	if (!mutex)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (mutex.GetAddr() % 4)
+	if (mutex.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -145,13 +145,13 @@ s32 cellSyncMutexUnlock(mem_ptr_t<CellSyncMutex> mutex)
 	return CELL_OK;
 }
 
-s32 syncBarrierInitialize(mem_ptr_t<CellSyncBarrier> barrier, u16 total_count)
+s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count)
 {
 	if (!barrier)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (barrier.GetAddr() % 4)
+	if (barrier.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -167,22 +167,22 @@ s32 syncBarrierInitialize(mem_ptr_t<CellSyncBarrier> barrier, u16 total_count)
 	return CELL_OK;
 }
 
-s32 cellSyncBarrierInitialize(mem_ptr_t<CellSyncBarrier> barrier, u16 total_count)
+s32 cellSyncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count)
 {
-	cellSync->Log("cellSyncBarrierInitialize(barrier_addr=0x%x, total_count=%d)", barrier.GetAddr(), total_count);
+	cellSync->Log("cellSyncBarrierInitialize(barrier_addr=0x%x, total_count=%d)", barrier.addr(), total_count);
 
 	return syncBarrierInitialize(barrier, total_count);
 }
 
-s32 cellSyncBarrierNotify(mem_ptr_t<CellSyncBarrier> barrier)
+s32 cellSyncBarrierNotify(vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync->Log("cellSyncBarrierNotify(barrier_addr=0x%x)", barrier.GetAddr());
+	cellSync->Log("cellSyncBarrierNotify(barrier_addr=0x%x)", barrier.addr());
 
 	if (!barrier)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (barrier.GetAddr() % 4)
+	if (barrier.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -202,7 +202,7 @@ s32 cellSyncBarrierNotify(mem_ptr_t<CellSyncBarrier> barrier)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncBarrierNotify(barrier_addr=0x%x) aborted", barrier.GetAddr());
+				cellSync->Warning("cellSyncBarrierNotify(barrier_addr=0x%x) aborted", barrier.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -220,15 +220,15 @@ s32 cellSyncBarrierNotify(mem_ptr_t<CellSyncBarrier> barrier)
 	return CELL_OK;
 }
 
-s32 cellSyncBarrierTryNotify(mem_ptr_t<CellSyncBarrier> barrier)
+s32 cellSyncBarrierTryNotify(vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync->Log("cellSyncBarrierTryNotify(barrier_addr=0x%x)", barrier.GetAddr());
+	cellSync->Log("cellSyncBarrierTryNotify(barrier_addr=0x%x)", barrier.addr());
 
 	if (!barrier)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (barrier.GetAddr() % 4)
+	if (barrier.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -261,15 +261,15 @@ s32 cellSyncBarrierTryNotify(mem_ptr_t<CellSyncBarrier> barrier)
 	return CELL_OK;
 }
 
-s32 cellSyncBarrierWait(mem_ptr_t<CellSyncBarrier> barrier)
+s32 cellSyncBarrierWait(vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync->Log("cellSyncBarrierWait(barrier_addr=0x%x)", barrier.GetAddr());
+	cellSync->Log("cellSyncBarrierWait(barrier_addr=0x%x)", barrier.addr());
 
 	if (!barrier)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (barrier.GetAddr() % 4)
+	if (barrier.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -289,7 +289,7 @@ s32 cellSyncBarrierWait(mem_ptr_t<CellSyncBarrier> barrier)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncBarrierWait(barrier_addr=0x%x) aborted", barrier.GetAddr());
+				cellSync->Warning("cellSyncBarrierWait(barrier_addr=0x%x) aborted", barrier.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -307,15 +307,15 @@ s32 cellSyncBarrierWait(mem_ptr_t<CellSyncBarrier> barrier)
 	return CELL_OK;
 }
 
-s32 cellSyncBarrierTryWait(mem_ptr_t<CellSyncBarrier> barrier)
+s32 cellSyncBarrierTryWait(vm::ptr<CellSyncBarrier> barrier)
 {
-	cellSync->Log("cellSyncBarrierTryWait(barrier_addr=0x%x)", barrier.GetAddr());
+	cellSync->Log("cellSyncBarrierTryWait(barrier_addr=0x%x)", barrier.addr());
 
 	if (!barrier)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (barrier.GetAddr() % 4)
+	if (barrier.addr() % 4)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -346,13 +346,13 @@ s32 cellSyncBarrierTryWait(mem_ptr_t<CellSyncBarrier> barrier)
 	return CELL_OK;
 }
 
-s32 syncRwmInitialize(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size)
+s32 syncRwmInitialize(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size)
 {
 	if (!rwm || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (rwm.GetAddr() % 16 || buffer_addr % 128)
+	if (rwm.addr() % 16 || buffer_addr % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -369,22 +369,22 @@ s32 syncRwmInitialize(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_si
 	return CELL_OK;
 }
 
-s32 cellSyncRwmInitialize(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size)
+s32 cellSyncRwmInitialize(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size)
 {
-	cellSync->Log("cellSyncRwmInitialize(rwm_addr=0x%x, buffer_addr=0x%x, buffer_size=0x%x)", rwm.GetAddr(), 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);
 }
 
-s32 cellSyncRwmRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
+s32 cellSyncRwmRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncRwmRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncRwmRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr);
 
 	if (!rwm || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (rwm.GetAddr() % 16)
+	if (rwm.addr() % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -401,7 +401,7 @@ s32 cellSyncRwmRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncRwmRead(rwm_addr=0x%x) aborted", rwm.GetAddr());
+				cellSync->Warning("cellSyncRwmRead(rwm_addr=0x%x) aborted", rwm.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -423,7 +423,7 @@ s32 cellSyncRwmRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 
 		if (!new_rwm.m_readers.ToBE())
 		{
-			cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.GetAddr(), (u16)new_rwm.m_writers);
+			cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.addr(), (u16)new_rwm.m_writers);
 			return CELL_SYNC_ERROR_ABORT;
 		}
 
@@ -433,15 +433,15 @@ s32 cellSyncRwmRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncRwmTryRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
+s32 cellSyncRwmTryRead(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncRwmTryRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncRwmTryRead(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr);
 
 	if (!rwm || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (rwm.GetAddr() % 16)
+	if (rwm.addr() % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -471,7 +471,7 @@ s32 cellSyncRwmTryRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 
 		if (!new_rwm.m_readers.ToBE())
 		{
-			cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.GetAddr(), (u16)new_rwm.m_writers);
+			cellSync->Error("cellSyncRwmRead(rwm_addr=0x%x): m_readers == 0 (m_writers=%d)", rwm.addr(), (u16)new_rwm.m_writers);
 			return CELL_SYNC_ERROR_ABORT;
 		}
 
@@ -481,15 +481,15 @@ s32 cellSyncRwmTryRead(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncRwmWrite(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
+s32 cellSyncRwmWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncRwmWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncRwmWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr);
 
 	if (!rwm || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (rwm.GetAddr() % 16)
+	if (rwm.addr() % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -506,7 +506,7 @@ s32 cellSyncRwmWrite(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (I)", rwm.GetAddr());
+				cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (I)", rwm.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -522,7 +522,7 @@ s32 cellSyncRwmWrite(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 		std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 		if (Emu.IsStopped())
 		{
-			cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (II)", rwm.GetAddr());
+			cellSync->Warning("cellSyncRwmWrite(rwm_addr=0x%x) aborted (II)", rwm.addr());
 			return CELL_OK;
 		}
 	}
@@ -536,15 +536,15 @@ s32 cellSyncRwmWrite(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncRwmTryWrite(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
+s32 cellSyncRwmTryWrite(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncRwmTryWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncRwmTryWrite(rwm_addr=0x%x, buffer_addr=0x%x)", rwm.addr(), buffer_addr);
 
 	if (!rwm || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (rwm.GetAddr() % 16)
+	if (rwm.addr() % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -561,7 +561,7 @@ s32 cellSyncRwmTryWrite(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 syncQueueInitialize(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth)
+s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth)
 {
 	if (!queue)
 	{
@@ -571,7 +571,7 @@ s32 syncQueueInitialize(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr, u32 siz
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32 || buffer_addr % 16)
+	if (queue.addr() % 32 || buffer_addr % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -589,22 +589,22 @@ s32 syncQueueInitialize(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr, u32 siz
 	return CELL_OK;
 }
 
-s32 cellSyncQueueInitialize(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth)
+s32 cellSyncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth)
 {
-	cellSync->Log("cellSyncQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x)", queue.GetAddr(), 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);
 }
 
-s32 cellSyncQueuePush(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
+s32 cellSyncQueuePush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncQueuePush(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncQueuePush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr);
 
 	if (!queue || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -629,7 +629,7 @@ s32 cellSyncQueuePush(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncQueuePush(queue_addr=0x%x) aborted", queue.GetAddr());
+				cellSync->Warning("cellSyncQueuePush(queue_addr=0x%x) aborted", queue.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -660,15 +660,15 @@ s32 cellSyncQueuePush(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncQueueTryPush(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
+s32 cellSyncQueueTryPush(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncQueueTryPush(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncQueueTryPush(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr);
 
 	if (!queue || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -711,15 +711,15 @@ s32 cellSyncQueueTryPush(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncQueuePop(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
+s32 cellSyncQueuePop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncQueuePop(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncQueuePop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr);
 
 	if (!queue || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -744,7 +744,7 @@ s32 cellSyncQueuePop(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncQueuePop(queue_addr=0x%x) aborted", queue.GetAddr());
+				cellSync->Warning("cellSyncQueuePop(queue_addr=0x%x) aborted", queue.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -775,15 +775,15 @@ s32 cellSyncQueuePop(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncQueueTryPop(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
+s32 cellSyncQueueTryPop(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncQueueTryPop(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncQueueTryPop(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr);
 
 	if (!queue || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -826,15 +826,15 @@ s32 cellSyncQueueTryPop(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncQueuePeek(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
+s32 cellSyncQueuePeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncQueuePeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncQueuePeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr);
 
 	if (!queue || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -857,7 +857,7 @@ s32 cellSyncQueuePeek(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncQueuePeek(queue_addr=0x%x) aborted", queue.GetAddr());
+				cellSync->Warning("cellSyncQueuePeek(queue_addr=0x%x) aborted", queue.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -882,15 +882,15 @@ s32 cellSyncQueuePeek(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncQueueTryPeek(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
+s32 cellSyncQueueTryPeek(vm::ptr<CellSyncQueue> queue, u32 buffer_addr)
 {
-	cellSync->Log("cellSyncQueueTryPeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.GetAddr(), buffer_addr);
+	cellSync->Log("cellSyncQueueTryPeek(queue_addr=0x%x, buffer_addr=0x%x)", queue.addr(), buffer_addr);
 
 	if (!queue || !buffer_addr)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -932,15 +932,15 @@ s32 cellSyncQueueTryPeek(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr)
 	return CELL_OK;
 }
 
-s32 cellSyncQueueSize(mem_ptr_t<CellSyncQueue> queue)
+s32 cellSyncQueueSize(vm::ptr<CellSyncQueue> queue)
 {
-	cellSync->Log("cellSyncQueueSize(queue_addr=0x%x)", queue.GetAddr());
+	cellSync->Log("cellSyncQueueSize(queue_addr=0x%x)", queue.addr());
 
 	if (!queue)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -952,15 +952,15 @@ s32 cellSyncQueueSize(mem_ptr_t<CellSyncQueue> queue)
 	return count;
 }
 
-s32 cellSyncQueueClear(mem_ptr_t<CellSyncQueue> queue)
+s32 cellSyncQueueClear(vm::ptr<CellSyncQueue> queue)
 {
-	cellSync->Log("cellSyncQueueClear(queue_addr=0x%x)", queue.GetAddr());
+	cellSync->Log("cellSyncQueueClear(queue_addr=0x%x)", queue.addr());
 
 	if (!queue)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 32)
+	if (queue.addr() % 32)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -982,7 +982,7 @@ s32 cellSyncQueueClear(mem_ptr_t<CellSyncQueue> queue)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (I)", queue.GetAddr());
+				cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (I)", queue.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -1004,7 +1004,7 @@ s32 cellSyncQueueClear(mem_ptr_t<CellSyncQueue> queue)
 			std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 			if (Emu.IsStopped())
 			{
-				cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (II)", queue.GetAddr());
+				cellSync->Warning("cellSyncQueueClear(queue_addr=0x%x) aborted (II)", queue.addr());
 				return CELL_OK;
 			}
 			continue;
@@ -1020,16 +1020,16 @@ s32 cellSyncQueueClear(mem_ptr_t<CellSyncQueue> queue)
 
 // LFQueue functions
 
-void syncLFQueueDump(mem_ptr_t<CellSyncLFQueue> queue)
+void syncLFQueueDump(vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync->Notice("CellSyncLFQueue dump: addr = 0x%x", queue.GetAddr());
+	cellSync->Notice("CellSyncLFQueue dump: addr = 0x%x", queue.addr());
 	for (u32 i = 0; i < sizeof(CellSyncLFQueue) / 16; i++)
 	{
-		cellSync->Notice("*** 0x%.16llx 0x%.16llx", Memory.Read64(queue.GetAddr() + i * 16), Memory.Read64(queue.GetAddr() + i * 16 + 8));
+		cellSync->Notice("*** 0x%.16llx 0x%.16llx", Memory.Read64(queue.addr() + i * 16), Memory.Read64(queue.addr() + i * 16 + 8));
 	}
 }
 
-void syncLFQueueInit(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr)
+void syncLFQueueInit(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr)
 {
 	queue->m_h1 = 0;
 	queue->m_h2 = 0;
@@ -1076,10 +1076,10 @@ void syncLFQueueInit(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 size
 	}
 }
 
-s32 syncLFQueueInitialize(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr)
+s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr)
 {
 #ifdef PRX_DEBUG_XXX
-	return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.GetAddr(), buffer_addr, size, depth, direction, eaSignal_addr);
+	return GetCurrentPPUThread().FastCall(libsre + 0x205C, libsre_rtoc, queue.addr(), buffer_addr, size, depth, direction, eaSignal_addr);
 #else
 
 	if (!queue)
@@ -1101,7 +1101,7 @@ s32 syncLFQueueInitialize(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32
 	{
 		return CELL_SYNC_ERROR_INVAL;
 	}
-	if (queue.GetAddr() % 128 || buffer_addr % 16)
+	if (queue.addr() % 128 || buffer_addr % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -1140,7 +1140,7 @@ s32 syncLFQueueInitialize(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32
 			{
 				for (u32 i = 0; i < sizeof(CellSyncLFQueue) / sizeof(u64); i++)
 				{
-					if ((u64&)Memory[queue.GetAddr() + i * sizeof(u64)])
+					if ((u64&)Memory[queue.addr() + i * sizeof(u64)])
 					{
 						return CELL_SYNC_ERROR_STAT;
 					}
@@ -1183,15 +1183,15 @@ s32 syncLFQueueInitialize(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32
 #endif
 }
 
-s32 cellSyncLFQueueInitialize(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr)
+s32 cellSyncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr)
 {
 	cellSync->Warning("cellSyncLFQueueInitialize(queue_addr=0x%x, buffer_addr=0x%x, size=0x%x, depth=0x%x, direction=%d, eaSignal_addr=0x%x)",
-		queue.GetAddr(), 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);
 }
 
-s32 syncLFQueueGetPushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
+s32 syncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
 {
 	if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_PPU2SPU))
 	{
@@ -1293,10 +1293,10 @@ s32 syncLFQueueGetPushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u3
 	assert(0);
 }
 
-s32 _cellSyncLFQueueGetPushPointer(mem_ptr_t<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
 {
 	cellSync->Todo("_cellSyncLFQueueGetPushPointer(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)",
-		queue.GetAddr(), pointer.GetAddr(), isBlocking, useEventQueue);
+		queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPushPointer(queue, pointer_value, isBlocking, useEventQueue);
@@ -1304,7 +1304,7 @@ s32 _cellSyncLFQueueGetPushPointer(mem_ptr_t<CellSyncLFQueue> queue, mem32_t poi
 	return result;
 }
 
-s32 syncLFQueueGetPushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
+s32 syncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// TODO
 	//pointer = 0;
@@ -1312,11 +1312,11 @@ s32 syncLFQueueGetPushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetPushPointer2(mem_ptr_t<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// arguments copied from _cellSyncLFQueueGetPushPointer
 	cellSync->Todo("_cellSyncLFQueueGetPushPointer2(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)",
-		queue.GetAddr(), pointer.GetAddr(), isBlocking, useEventQueue);
+		queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPushPointer2(queue, pointer_value, isBlocking, useEventQueue);
@@ -1324,7 +1324,7 @@ s32 _cellSyncLFQueueGetPushPointer2(mem_ptr_t<CellSyncLFQueue> queue, mem32_t po
 	return result;
 }
 
-s32 syncLFQueueCompletePushPointer(mem_ptr_t<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)
 {
 	if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_PPU2SPU))
 	{
@@ -1471,15 +1471,15 @@ s32 syncLFQueueCompletePushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer
 	assert(0);
 }
 
-s32 _cellSyncLFQueueCompletePushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal)
+s32 _cellSyncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal)
 {
 	cellSync->Todo("_cellSyncLFQueueCompletePushPointer(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x)",
-		queue.GetAddr(), pointer, fpSendSignal.GetAddr());
+		queue.addr(), pointer, fpSendSignal.GetAddr());
 
 	return syncLFQueueCompletePushPointer(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); });
 }
 
-s32 syncLFQueueCompletePushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal)
+s32 syncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal)
 {
 	// TODO
 	//if (fpSendSignal) return fpSendSignal(0, 0);
@@ -1487,25 +1487,25 @@ s32 syncLFQueueCompletePushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointe
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueCompletePushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal)
+s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal)
 {
 	// arguments copied from _cellSyncLFQueueCompletePushPointer
 	cellSync->Todo("_cellSyncLFQueueCompletePushPointer2(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x)",
-		queue.GetAddr(), pointer, fpSendSignal.GetAddr());
+		queue.addr(), pointer, fpSendSignal.GetAddr());
 
 	return syncLFQueueCompletePushPointer2(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); });
 }
 
-s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 isBlocking)
+s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, 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.GetAddr(), 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)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128 || buffer_addr % 16)
+	if (queue.addr() % 128 || buffer_addr % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -1523,7 +1523,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 		if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
 		{
 #ifdef PRX_DEBUG_XXX
-			res = GetCurrentPPUThread().FastCall(libsre + 0x24B0, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0);
+			res = GetCurrentPPUThread().FastCall(libsre + 0x24B0, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPushPointer(queue, position, isBlocking, 0);
@@ -1532,7 +1532,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 		else
 		{
 #ifdef PRX_DEBUG
-			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0);
+			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3050, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPushPointer2(queue, position, isBlocking, 0);
@@ -1554,7 +1554,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 		std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 		if (Emu.IsStopped())
 		{
-			cellSync->Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.GetAddr());
+			cellSync->Warning("_cellSyncLFQueuePushBody(queue_addr=0x%x) aborted", queue.addr());
 			return CELL_OK;
 		}
 	}
@@ -1567,7 +1567,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 	if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
 	{
 #ifdef PRX_DEBUG_XXX
-		res = GetCurrentPPUThread().FastCall(libsre + 0x26C0, libsre_rtoc, queue.GetAddr(), position, 0);
+		res = GetCurrentPPUThread().FastCall(libsre + 0x26C0, libsre_rtoc, queue.addr(), position, 0);
 #else
 		res = syncLFQueueCompletePushPointer(queue, position, nullptr);
 #endif
@@ -1575,7 +1575,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 	else
 	{
 #ifdef PRX_DEBUG
-		res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x355C, libsre_rtoc, queue.GetAddr(), position, 0);
+		res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x355C, libsre_rtoc, queue.addr(), position, 0);
 #else
 		res = syncLFQueueCompletePushPointer2(queue, position, nullptr);
 #endif
@@ -1585,7 +1585,7 @@ s32 _cellSyncLFQueuePushBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr,
 	return res;
 }
 
-s32 syncLFQueueGetPopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue)
+s32 syncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue)
 {
 	if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_SPU2PPU))
 	{
@@ -1687,10 +1687,10 @@ s32 syncLFQueueGetPopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32
 	assert(0);
 }
 
-s32 _cellSyncLFQueueGetPopPointer(mem_ptr_t<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 arg4, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 arg4, u32 useEventQueue)
 {
 	cellSync->Todo("_cellSyncLFQueueGetPopPointer(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, arg4=%d, useEventQueue=%d)",
-		queue.GetAddr(), pointer.GetAddr(), isBlocking, arg4, useEventQueue);
+		queue.addr(), pointer.GetAddr(), isBlocking, arg4, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPopPointer(queue, pointer_value, isBlocking, arg4, useEventQueue);
@@ -1698,7 +1698,7 @@ s32 _cellSyncLFQueueGetPopPointer(mem_ptr_t<CellSyncLFQueue> queue, mem32_t poin
 	return result;
 }
 
-s32 syncLFQueueGetPopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
+s32 syncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// TODO
 	//pointer = 0;
@@ -1706,11 +1706,11 @@ s32 syncLFQueueGetPopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u3
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetPopPointer2(mem_ptr_t<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// arguments copied from _cellSyncLFQueueGetPopPointer
 	cellSync->Todo("_cellSyncLFQueueGetPopPointer2(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)",
-		queue.GetAddr(), pointer.GetAddr(), isBlocking, useEventQueue);
+		queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPopPointer2(queue, pointer_value, isBlocking, useEventQueue);
@@ -1718,7 +1718,7 @@ s32 _cellSyncLFQueueGetPopPointer2(mem_ptr_t<CellSyncLFQueue> queue, mem32_t poi
 	return result;
 }
 
-s32 syncLFQueueCompletePopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
+s32 syncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_SPU2PPU))
 	{
@@ -1864,16 +1864,16 @@ s32 syncLFQueueCompletePopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer,
 	assert(0);
 }
 
-s32 _cellSyncLFQueueCompletePopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
+s32 _cellSyncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// arguments copied from _cellSyncLFQueueCompletePushPointer + unknown argument (noQueueFull taken from LFQueue2CompletePopPointer)
 	cellSync->Todo("_cellSyncLFQueueCompletePopPointer(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x, noQueueFull=%d)",
-		queue.GetAddr(), pointer, fpSendSignal.GetAddr(), noQueueFull);
+		queue.addr(), pointer, fpSendSignal.GetAddr(), noQueueFull);
 
 	return syncLFQueueCompletePopPointer(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }, noQueueFull);
 }
 
-s32 syncLFQueueCompletePopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
+s32 syncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// TODO
 	//if (fpSendSignal) fpSendSignal(0, 0);
@@ -1881,25 +1881,25 @@ s32 syncLFQueueCompletePopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueCompletePopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
+s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// arguments copied from _cellSyncLFQueueCompletePopPointer
 	cellSync->Todo("_cellSyncLFQueueCompletePopPointer2(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x, noQueueFull=%d)",
-		queue.GetAddr(), pointer, fpSendSignal.GetAddr(), noQueueFull);
+		queue.addr(), pointer, fpSendSignal.GetAddr(), noQueueFull);
 
 	return syncLFQueueCompletePopPointer2(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }, noQueueFull);
 }
 
-s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 isBlocking)
+s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, 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.GetAddr(), 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)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128 || buffer_addr % 16)
+	if (queue.addr() % 128 || buffer_addr % 16)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -1914,7 +1914,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 		if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
 		{
 #ifdef PRX_DEBUG_XXX
-			res = GetCurrentPPUThread().FastCall(libsre + 0x2A90, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0, 0);
+			res = GetCurrentPPUThread().FastCall(libsre + 0x2A90, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPopPointer(queue, position, isBlocking, 0, 0);
@@ -1923,7 +1923,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 		else
 		{
 #ifdef PRX_DEBUG
-			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.GetAddr(), position_v.addr(), isBlocking, 0);
+			res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x39AC, libsre_rtoc, queue.addr(), position_v.addr(), isBlocking, 0);
 			position = position_v->ToLE();
 #else
 			res = syncLFQueueGetPopPointer2(queue, position, isBlocking, 0);
@@ -1942,7 +1942,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 		std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
 		if (Emu.IsStopped())
 		{
-			cellSync->Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.GetAddr());
+			cellSync->Warning("_cellSyncLFQueuePopBody(queue_addr=0x%x) aborted", queue.addr());
 			return CELL_OK;
 		}
 	}
@@ -1955,7 +1955,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 	if (queue->m_direction.ToBE() != se32(CELL_SYNC_QUEUE_ANY2ANY))
 	{
 #ifdef PRX_DEBUG_XXX
-		res = GetCurrentPPUThread().FastCall(libsre + 0x2CA8, libsre_rtoc, queue.GetAddr(), position, 0, 0);
+		res = GetCurrentPPUThread().FastCall(libsre + 0x2CA8, libsre_rtoc, queue.addr(), position, 0, 0);
 #else
 		res = syncLFQueueCompletePopPointer(queue, position, nullptr, 0);
 #endif
@@ -1963,7 +1963,7 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 	else
 	{
 #ifdef PRX_DEBUG
-		res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3EB8, libsre_rtoc, queue.GetAddr(), position, 0, 0);
+		res = (s32)GetCurrentPPUThread().FastCall(libsre + 0x3EB8, libsre_rtoc, queue.addr(), position, 0, 0);
 #else
 		res = syncLFQueueCompletePopPointer2(queue, position, nullptr, 0);
 #endif
@@ -1972,15 +1972,15 @@ s32 _cellSyncLFQueuePopBody(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u
 	return res;
 }
 
-s32 cellSyncLFQueueClear(mem_ptr_t<CellSyncLFQueue> queue)
+s32 cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync->Warning("cellSyncLFQueueClear(queue_addr=0x%x)", queue.GetAddr());
+	cellSync->Warning("cellSyncLFQueueClear(queue_addr=0x%x)", queue.addr());
 
 	if (!queue)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128)
+	if (queue.addr() % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -2020,15 +2020,15 @@ s32 cellSyncLFQueueClear(mem_ptr_t<CellSyncLFQueue> queue)
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueSize(mem_ptr_t<CellSyncLFQueue> queue, mem32_t size)
+s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, mem32_t size)
 {
-	cellSync->Warning("cellSyncLFQueueSize(queue_addr=0x%x, size_addr=0x%x)", queue.GetAddr(), size.GetAddr());
+	cellSync->Warning("cellSyncLFQueueSize(queue_addr=0x%x, size_addr=0x%x)", queue.addr(), size.GetAddr());
 
 	if (!queue || !size.GetAddr())
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128)
+	if (queue.addr() % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -2058,15 +2058,15 @@ s32 cellSyncLFQueueSize(mem_ptr_t<CellSyncLFQueue> queue, mem32_t size)
 	assert(0);
 }
 
-s32 cellSyncLFQueueDepth(mem_ptr_t<CellSyncLFQueue> queue, mem32_t depth)
+s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, mem32_t depth)
 {
-	cellSync->Log("cellSyncLFQueueDepth(queue_addr=0x%x, depth_addr=0x%x)", queue.GetAddr(), depth.GetAddr());
+	cellSync->Log("cellSyncLFQueueDepth(queue_addr=0x%x, depth_addr=0x%x)", queue.addr(), depth.GetAddr());
 
 	if (!queue || !depth.GetAddr())
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128)
+	if (queue.addr() % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -2075,15 +2075,15 @@ s32 cellSyncLFQueueDepth(mem_ptr_t<CellSyncLFQueue> queue, mem32_t depth)
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetSignalAddress(mem_ptr_t<CellSyncLFQueue> queue, mem32_t ppSignal)
+s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, mem32_t ppSignal)
 {
-	cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.GetAddr(), ppSignal.GetAddr());
+	cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.GetAddr());
 
 	if (!queue || !ppSignal.GetAddr())
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128)
+	if (queue.addr() % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -2092,15 +2092,15 @@ s32 _cellSyncLFQueueGetSignalAddress(mem_ptr_t<CellSyncLFQueue> queue, mem32_t p
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueGetDirection(mem_ptr_t<CellSyncLFQueue> queue, mem32_t direction)
+s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, mem32_t direction)
 {
-	cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.GetAddr(), direction.GetAddr());
+	cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.GetAddr());
 
 	if (!queue || !direction.GetAddr())
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128)
+	if (queue.addr() % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -2109,15 +2109,15 @@ s32 cellSyncLFQueueGetDirection(mem_ptr_t<CellSyncLFQueue> queue, mem32_t direct
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueGetEntrySize(mem_ptr_t<CellSyncLFQueue> queue, mem32_t entry_size)
+s32 cellSyncLFQueueGetEntrySize(vm::ptr<CellSyncLFQueue> queue, mem32_t entry_size)
 {
-	cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.GetAddr(), entry_size.GetAddr());
+	cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.addr(), entry_size.GetAddr());
 
 	if (!queue || !entry_size.GetAddr())
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
-	if (queue.GetAddr() % 128)
+	if (queue.addr() % 128)
 	{
 		return CELL_SYNC_ERROR_ALIGN;
 	}
@@ -2126,30 +2126,30 @@ s32 cellSyncLFQueueGetEntrySize(mem_ptr_t<CellSyncLFQueue> queue, mem32_t entry_
 	return CELL_OK;
 }
 
-s32 syncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t<CellSyncLFQueue> queue)
+s32 syncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
 	// TODO
 	assert(0);
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t<CellSyncLFQueue> queue)
+s32 _cellSyncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync->Todo("_cellSyncLFQueueAttachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.GetAddr());
+	cellSync->Todo("_cellSyncLFQueueAttachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.addr());
 
 	return syncLFQueueAttachLv2EventQueue(spus, num, queue);
 }
 
-s32 syncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t<CellSyncLFQueue> queue)
+s32 syncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
 	// TODO
 	assert(0);
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t<CellSyncLFQueue> queue)
+s32 _cellSyncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync->Todo("_cellSyncLFQueueDetachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.GetAddr());
+	cellSync->Todo("_cellSyncLFQueueDetachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.addr());
 
 	return syncLFQueueDetachLv2EventQueue(spus, num, queue);
 }
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index cac8416bbc..a392e1f548 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -341,7 +341,7 @@ void Emulator::Load()
 		thread.SetEntry(l.GetEntry());
 		Memory.StackMem.AllocAlign(0x1000);
 		thread.InitStack();
-		thread.AddArgv(m_elf_path);
+		thread.AddArgv(m_elf_path); // it doesn't work
 		//thread.AddArgv("-emu");
 
 		m_rsx_callback = (u32)Memory.MainMem.AllocAlign(4 * 4) + 4;

From ebc4fa3e81b91d182ea8b6194e02bdfacc0c9eb7 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 15:18:32 +0400
Subject: [PATCH 11/36] Compilation fix

---
 rpcs3/Emu/Memory/vm.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm.cpp b/rpcs3/Emu/Memory/vm.cpp
index 044135c842..a55b9a9259 100644
--- a/rpcs3/Emu/Memory/vm.cpp
+++ b/rpcs3/Emu/Memory/vm.cpp
@@ -4,7 +4,7 @@
 #ifdef _WIN32
 #include <Windows.h>
 
-static void* const m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE, PAGE_NOACCESS);
+void* const m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE, PAGE_NOACCESS);
 #else
 #include <sys/mman.h>
 
@@ -13,7 +13,7 @@ static void* const m_base_addr = VirtualAlloc(nullptr, 0x100000000, MEM_RESERVE,
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
-static void* const m_base_addr = ::mmap(nullptr, 0x100000000, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+void* const m_base_addr = ::mmap(nullptr, 0x100000000, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
 #endif
 
 namespace vm

From a8cfefac07673d49a5653ef193988a8917ffc1fe Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 19:01:48 +0400
Subject: [PATCH 12/36] vm::ptr for u8/char types, mem_list_ptr_t removed

---
 rpcs3/Emu/Cell/PPUThread.cpp                 |   4 +-
 rpcs3/Emu/Cell/SPURSManager.cpp              |   4 +-
 rpcs3/Emu/Cell/SPURSManager.h                |   4 +-
 rpcs3/Emu/Memory/Memory.h                    | 180 -------------------
 rpcs3/Emu/Memory/vm_ptr.h                    |  37 +++-
 rpcs3/Emu/Memory/vm_ref.h                    |   2 +-
 rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp       |   9 +-
 rpcs3/Emu/RSX/RSXThread.cpp                  |  10 +-
 rpcs3/Emu/SysCalls/Modules/cellFont.cpp      |  11 +-
 rpcs3/Emu/SysCalls/Modules/cellGame.cpp      |  36 ++--
 rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp    |  19 +-
 rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp    |  19 +-
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp      |  24 +--
 rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp |  31 ++--
 rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h   |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellPamf.cpp      |   9 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp    |  23 ++-
 rpcs3/Emu/SysCalls/Modules/cellResc.cpp      |   7 +-
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp     |  26 +--
 rpcs3/Emu/SysCalls/Modules/cellSync.cpp      |  12 +-
 rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp   |  18 +-
 rpcs3/Emu/SysCalls/Modules/sys_fs.cpp        |  10 +-
 rpcs3/Emu/SysCalls/Modules/sys_net.cpp       |   7 +-
 rpcs3/Emu/SysCalls/lv2/sys_process.cpp       |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_process.h         |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_spu.cpp           |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_spu.h             |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_tty.cpp           |   4 +-
 rpcs3/Emu/System.cpp                         |  22 +--
 rpcs3/Gui/RSXDebugger.cpp                    |   2 +-
 rpcs3/Loader/ELF64.cpp                       |  14 +-
 31 files changed, 208 insertions(+), 362 deletions(-)

diff --git a/rpcs3/Emu/Cell/PPUThread.cpp b/rpcs3/Emu/Cell/PPUThread.cpp
index 77576e6b88..9cf61e2625 100644
--- a/rpcs3/Emu/Cell/PPUThread.cpp
+++ b/rpcs3/Emu/Cell/PPUThread.cpp
@@ -108,8 +108,8 @@ void PPUThread::InitRegs()
 		m_stack_point -= 0xc + 4 * argc;
 		u64 argv = m_stack_point;
 
-		mem64_ptr_t argv_list((u32)argv);
-		for(int i=0; i<argc; ++i) argv_list += m_argv_addr[i];
+		auto argv_list = vm::ptr<be_t<u64>>::make((u32)argv);
+		for(int i=0; i<argc; ++i) argv_list[i] = m_argv_addr[i];
 
 		GPR[3] = argc;
 		GPR[4] = argv;
diff --git a/rpcs3/Emu/Cell/SPURSManager.cpp b/rpcs3/Emu/Cell/SPURSManager.cpp
index 2e547dce37..365c15847b 100644
--- a/rpcs3/Emu/Cell/SPURSManager.cpp
+++ b/rpcs3/Emu/Cell/SPURSManager.cpp
@@ -40,7 +40,7 @@ SPURSManagerEventFlag::SPURSManagerEventFlag(u32 flagClearMode, u32 flagDirectio
 	this->flagDirection = flagDirection;
 }
 
-SPURSManagerTasksetAttribute::SPURSManagerTasksetAttribute(u64 args, mem8_t priority, u32 maxContention)
+SPURSManagerTasksetAttribute::SPURSManagerTasksetAttribute(u64 args, vm::ptr<const u8> priority, u32 maxContention)
 {
 	this->args = args;
 	this->maxContention = maxContention;
@@ -56,7 +56,7 @@ void SPURSManager::Finalize()
 	delete this->attr;
 }
 
-void SPURSManager::AttachLv2EventQueue(u32 queue, mem8_t port, int isDynamic)
+void SPURSManager::AttachLv2EventQueue(u32 queue, vm::ptr<u8> port, int isDynamic)
 {
 	//TODO:
 }
diff --git a/rpcs3/Emu/Cell/SPURSManager.h b/rpcs3/Emu/Cell/SPURSManager.h
index 210eda74cc..6d17f4e373 100644
--- a/rpcs3/Emu/Cell/SPURSManager.h
+++ b/rpcs3/Emu/Cell/SPURSManager.h
@@ -47,7 +47,7 @@ protected:
 class SPURSManagerTasksetAttribute
 {
 public:
-	SPURSManagerTasksetAttribute(u64 args, mem8_t priority, u32 maxContention);
+	SPURSManagerTasksetAttribute(u64 args, vm::ptr<const u8> priority, u32 maxContention);
 
 protected:
 	be_t<u64> args;
@@ -71,7 +71,7 @@ public:
 	SPURSManager(SPURSManagerAttribute *attr);
 
 	void Finalize();
-	void AttachLv2EventQueue(u32 queue, mem8_t port, int isDynamic);
+	void AttachLv2EventQueue(u32 queue, vm::ptr<u8> port, int isDynamic);
 	void DetachLv2EventQueue(u8 port);
 
 protected:
diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index 51f4f2ae10..d7b2371558 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -689,55 +689,6 @@ public:
 	mem_t& operator >>= (T right) { return *this = (*this) >> right; }
 };
 
-template<typename T, typename AT = u32> class mem_list_ptr_t : public mem_base_t<T, AT>
-{
-public:
-	mem_list_ptr_t(u32 addr) : mem_base_t<T>(addr)
-	{
-	}
-
-	void operator = (T right)
-	{
-		(be_t<T>&)Memory[this->m_addr] = right;
-	}
-
-	u32 operator += (T right)
-	{
-		*this = right;
-		this->m_addr += sizeof(T);
-		return this->m_addr;
-	}
-	
-	u32 AppendRawBytes(const u8 *bytes, size_t count)
-	{
-		memmove(Memory + this->m_addr, bytes, count);
-		this->m_addr += (u32)count;
-		return this->m_addr;
-	}
-
-	u32 Skip(const u32 offset) { return this->m_addr += offset; }
-
-	operator be_t<T>*()			{ return GetPtr(); }
-	operator void*()			{ return GetPtr(); }
-	operator be_t<T>*()	const	{ return GetPtr(); }
-	operator void*()	const	{ return GetPtr(); }
-
-	const char* GetString() const
-	{
-		return (const char*)&Memory[this->m_addr];
-	}
-
-	be_t<T>* GetPtr()
-	{
-		return (be_t<T>*)&Memory[this->m_addr];
-	}
-
-	const be_t<T>* GetPtr() const
-	{
-		return (const be_t<T>*)&Memory[this->m_addr];
-	}
-};
-
 template<typename T>
 struct _func_arg
 {
@@ -758,7 +709,6 @@ struct _func_arg<mem_base_t<T, u32>>
 
 template<typename T, int lvl> struct _func_arg<mem_ptr_t<T, lvl, u32>> : public _func_arg<mem_base_t<T, u32>> {};
 template<int lvl> struct _func_arg<mem_ptr_t<void, lvl, u32>> : public _func_arg<mem_base_t<u8, u32>>{};
-template<typename T> struct _func_arg<mem_list_ptr_t<T, u32>> : public _func_arg<mem_base_t<T, u32>> {};
 template<typename T> struct _func_arg<mem_t<T, u32>> : public _func_arg<mem_base_t<T, u32>> {};
 
 template<typename T>
@@ -818,139 +768,9 @@ public:
 	}
 };
 
-/*
-template<typename T>
-class MemoryAllocator
-{
-	u32 m_addr;
-	u32 m_size;
-	T* m_ptr;
-
-public:
-	MemoryAllocator(u32 size = sizeof(T), u32 align = 1)
-		: m_size(size)
-		, m_addr((u32)Memory.Alloc(size, align))
-		, m_ptr((T*)&Memory[m_addr])
-	{
-	}
-
-	~MemoryAllocator()
-	{
-		Memory.Free(m_addr);
-	}
-
-	T* operator -> ()
-	{
-		return m_ptr;
-	}
-
-	T* GetPtr()
-	{
-		return m_ptr;
-	}
-
-	const T* GetPtr() const
-	{
-		return m_ptr;
-	}
-
-	const T* operator -> () const
-	{
-		return m_ptr;
-	}
-
-	u32 GetAddr() const
-	{
-		return m_addr;
-	}
-
-	u32 GetSize() const
-	{
-		return m_size;
-	}
-
-	bool IsGood() const
-	{
-		return Memory.IsGoodAddr(m_addr, sizeof(T));
-	}
-
-	template<typename T1>
-	operator const T1() const
-	{
-		return T1(*m_ptr);
-	}
-
-	template<typename T1>
-	operator T1()
-	{
-		return T1(*m_ptr);
-	}
-
-	operator const T&() const
-	{
-		return *m_ptr;
-	}
-
-	operator T&()
-	{
-		return *m_ptr;
-	}
-
-	operator const T*() const
-	{
-		return m_ptr;
-	}
-
-	operator T*()
-	{
-		return m_ptr;
-	}
-
-	T operator [](int index)
-	{
-		return *(m_ptr + index);
-	}
-
-	template<typename T1>
-	operator const mem_t<T1>() const
-	{
-		return GetAddr();
-	}
-
-	operator const mem_ptr_t<T>() const
-	{
-		return GetAddr();
-	}
-
-	template<typename NT>
-	NT* To(uint offset = 0)
-	{
-		return (NT*)(m_ptr + offset);
-	}
-};
-*/
-
-typedef mem_t<u8, u32> mem8_t;
 typedef mem_t<u16, u32> mem16_t;
 typedef mem_t<u32, u32> mem32_t;
 typedef mem_t<u64, u32> mem64_t;
 
-/*
-typedef mem_ptr_t<be_t<u8>> mem8_ptr_t;
-typedef mem_ptr_t<be_t<u16>> mem16_ptr_t;
-typedef mem_ptr_t<be_t<u32>> mem32_ptr_t;
-typedef mem_ptr_t<be_t<u64>> mem64_ptr_t;
-
-typedef mem_list_ptr_t<u8> mem8_lptr_t;
-typedef mem_list_ptr_t<u16> mem16_lptr_t;
-typedef mem_list_ptr_t<u32> mem32_lptr_t;
-typedef mem_list_ptr_t<u64> mem64_lptr_t;
-*/
-
-typedef mem_list_ptr_t<u8, u32> mem8_ptr_t;
-typedef mem_list_ptr_t<u16, u32> mem16_ptr_t;
-typedef mem_list_ptr_t<u32, u32> mem32_ptr_t;
-typedef mem_list_ptr_t<u64, u32> mem64_ptr_t;
-
 #include "vm.h"
 
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 0b8be18393..169bfab71b 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -86,7 +86,7 @@ namespace vm
 			return m_addr;
 		}
 
-		static ptr make(u32 addr)
+		static ptr make(AT addr)
 		{
 			return (ptr&)addr;
 		}
@@ -203,7 +203,7 @@ namespace vm
 			return vm::get_ptr<T>(m_addr);
 		}
 		
-		static ptr make(u32 addr)
+		static ptr make(AT addr)
 		{
 			return (ptr&)addr;
 		}
@@ -230,7 +230,34 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(u32 addr)
+		static ptr make(AT addr)
+		{
+			return (ptr&)addr;
+		}
+	};
+
+	template<typename AT>
+	class ptr<const void, 1, AT>
+	{
+		AT m_addr;
+
+	public:
+		AT addr() const
+		{
+			return m_addr;
+		}
+
+		const void* const get_ptr() const
+		{
+			return vm::get_ptr<const void>(m_addr);
+		}
+
+		operator bool() const
+		{
+			return m_addr != 0;
+		}
+
+		static ptr make(AT addr)
 		{
 			return (ptr&)addr;
 		}
@@ -276,7 +303,7 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(u32 addr)
+		static ptr make(AT addr)
 		{
 			return (ptr&)addr;
 		}
@@ -350,7 +377,7 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(u32 addr)
+		static ptr make(AT addr)
 		{
 			return (ptr&)addr;
 		}
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index e75d67e02a..666b059ba7 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -23,7 +23,7 @@ namespace vm
 			return m_addr;
 		}
 
-		static _ref_base make(u32 addr)
+		static _ref_base make(AT addr)
 		{
 			return (_ref_base&)addr;
 		}
diff --git a/rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp b/rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp
index b36279f580..e761b90f65 100644
--- a/rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp
+++ b/rpcs3/Emu/RSX/GL/GLFragmentProgram.cpp
@@ -90,7 +90,7 @@ std::string GLFragmentDecompilerThread::AddConst()
 		return name;
 	}
 
-	mem32_ptr_t data(m_addr + m_size + m_offset);
+	auto data = vm::ptr<be_t<u32>>::make(m_addr + m_size + m_offset);
 
 	m_offset += 4 * 4;
 	u32 x = GetData(data[0]);
@@ -279,7 +279,7 @@ std::string GLFragmentDecompilerThread::BuildCode()
 
 void GLFragmentDecompilerThread::Task()
 {
-	mem32_ptr_t data(m_addr);
+	auto data = vm::ptr<be_t<u32>>::make(m_addr);
 	m_size = 0;
 	m_location = 0;
 	m_loop_count = 0;
@@ -314,7 +314,7 @@ void GLFragmentDecompilerThread::Task()
 		src1.HEX = GetData(data[2]);
 		src2.HEX = GetData(data[3]);
 
-		m_offset = 4 * 4;
+		m_offset = 4 * sizeof(u32);
 
 		const u32 opcode = dst.opcode | (src1.opcode_is_branch << 6);
 
@@ -439,7 +439,8 @@ void GLFragmentDecompilerThread::Task()
 
 		if(dst.end) break;
 
-		data.Skip(m_offset);
+		assert(m_offset % sizeof(u32) == 0);
+		data += m_offset / sizeof(u32);
 	}
 
 	// flush m_code_level
diff --git a/rpcs3/Emu/RSX/RSXThread.cpp b/rpcs3/Emu/RSX/RSXThread.cpp
index 762c10740d..affa9c3449 100644
--- a/rpcs3/Emu/RSX/RSXThread.cpp
+++ b/rpcs3/Emu/RSX/RSXThread.cpp
@@ -6,7 +6,7 @@
 #include "RSXThread.h"
 #include "Emu/SysCalls/lv2/sys_time.h"
 
-#define ARGS(x) (x >= count ? OutOfArgsCount(x, cmd, count, args.GetAddr()) : args[x].ToLE())
+#define ARGS(x) (x >= count ? OutOfArgsCount(x, cmd, count, args.addr()) : args[x].ToLE())
 
 u32 methodRegisters[0xffff];
 
@@ -142,7 +142,7 @@ u32 RSXVertexData::GetTypeSize()
 
 u32 RSXThread::OutOfArgsCount(const uint x, const u32 cmd, const u32 count, const u32 args_addr)
 {
-	mem32_ptr_t args(args_addr);
+	auto args = vm::ptr<be_t<u32>>::make(args_addr);
 	std::string debug = GetMethodName(cmd);
 	debug += "(";
 	for(u32 i=0; i<count; ++i) debug += (i ? ", " : "") + fmt::Format("0x%x", ARGS(i));
@@ -209,7 +209,7 @@ u32 RSXThread::OutOfArgsCount(const uint x, const u32 cmd, const u32 count, cons
 
 void RSXThread::DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const u32 count)
 {
-	mem32_ptr_t args(args_addr);
+	auto args = vm::ptr<be_t<u32>>::make(args_addr);
 
 #if	CMD_DEBUG
 		std::string debug = GetMethodName(cmd);
@@ -2234,14 +2234,14 @@ void RSXThread::Task()
 			continue;
 		}
 
-		mem32_ptr_t args((u32)Memory.RSXIOMem.RealAddr(Memory.RSXIOMem.GetStartAddr() + get + 4));
+		auto args = vm::ptr<be_t<u32>>::make((u32)Memory.RSXIOMem.RealAddr(Memory.RSXIOMem.GetStartAddr() + get + 4));
 
 		for(u32 i=0; i<count; i++)
 		{
 			methodRegisters[(cmd & 0xffff) + (i*4*inc)] = ARGS(i);
 		}
 
-		DoCmd(cmd, cmd & 0x3ffff, args.GetAddr(), count);
+		DoCmd(cmd, cmd & 0x3ffff, args.addr(), count);
 
 		m_ctrl->get = get + (count + 1) * 4;
 		//memset(Memory.GetMemFromAddr(p.m_ioAddress + get), 0, (count + 1) * 4);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index fdd0d4a457..8bde346aaa 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -87,9 +87,9 @@ int cellFontOpenFontMemory(mem_ptr_t<CellFontLibrary> library, u32 fontAddr, u32
 	return CELL_FONT_OK;
 }
 
-int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, mem8_ptr_t fontPath, u32 subNum, s32 uniqueId, mem_ptr_t<CellFont> font)
+int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, vm::ptr<const char> fontPath, u32 subNum, s32 uniqueId, mem_ptr_t<CellFont> font)
 {
-	std::string fp(fontPath.GetString());
+	std::string fp(fontPath.get_ptr());
 	cellFont->Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",
 		library.GetAddr(), fp.c_str(), subNum, uniqueId, font.GetAddr());
 
@@ -181,11 +181,10 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
 		return CELL_FONT_ERROR_NO_SUPPORT_FONTSET;
 	}
 
-	u32 file_addr = (u32)Memory.Alloc((u32)file.length() + 1, 1);
-	Memory.WriteString(file_addr, file);
-	int ret = cellFontOpenFontFile(library.GetAddr(), file_addr, 0, 0, font.GetAddr()); //TODO: Find the correct values of subNum, uniqueId
+	vm::var<const char> f((u32)file.length() + 1, 1);
+	Memory.WriteString(f.addr(), file);
+	int ret = cellFontOpenFontFile(library.GetAddr(), vm::ptr<const char>::make(f.addr()), 0, 0, font.GetAddr()); //TODO: Find the correct values of subNum, uniqueId
 	font->origin = CELL_FONT_OPEN_FONTSET;
-	Memory.Free(file_addr);
 	return ret;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
index b93748ceb5..fd4d9dcf1d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
@@ -16,10 +16,10 @@ Module *cellGame = nullptr;
 std::string contentInfo = "";
 std::string usrdir = "";
 
-int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameContentSize> size, mem_list_ptr_t<u8> dirName)
+int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameContentSize> size, vm::ptr<char> dirName)
 {
 	cellGame->Warning("cellGameBootCheck(type_addr=0x%x, attributes_addr=0x%x, size_addr=0x%x, dirName_addr=0x%x)",
-		type.GetAddr(), attributes.GetAddr(), size.GetAddr(), dirName.GetAddr());
+		type.GetAddr(), attributes.GetAddr(), size.GetAddr(), dirName.addr());
 
 	if (size)
 	{
@@ -50,7 +50,7 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 	{
 		type = CELL_GAME_GAMETYPE_DISC;
 		attributes = 0; // TODO
-		if (dirName.GetAddr()) Memory.WriteString(dirName.GetAddr(), ""); // ???
+		if (dirName) Memory.WriteString(dirName.addr(), ""); // ???
 		contentInfo = "/dev_bdvd/PS3_GAME";
 		usrdir = "/dev_bdvd/PS3_GAME/USRDIR";
 	}
@@ -59,7 +59,7 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 		std::string titleId = psf.GetString("TITLE_ID");
 		type = CELL_GAME_GAMETYPE_HDD;
 		attributes = 0; // TODO
-		if (dirName.GetAddr()) Memory.WriteString(dirName.GetAddr(), titleId);
+		if (dirName) Memory.WriteString(dirName.addr(), titleId);
 		contentInfo = "/dev_hdd0/game/" + titleId;
 		usrdir = "/dev_hdd0/game/" + titleId + "/USRDIR";
 	}
@@ -68,7 +68,7 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 		std::string titleId = psf.GetString("TITLE_ID");
 		type = CELL_GAME_GAMETYPE_DISC;
 		attributes = CELL_GAME_ATTRIBUTE_PATCH; // TODO
-		if (dirName.GetAddr()) Memory.WriteString(dirName.GetAddr(), titleId); // ???
+		if (dirName) Memory.WriteString(dirName.addr(), titleId); // ???
 		contentInfo = "/dev_bdvd/PS3_GAME";
 		usrdir = "/dev_bdvd/PS3_GAME/USRDIR";
 	}
@@ -129,9 +129,9 @@ int cellGamePatchCheck(mem_ptr_t<CellGameContentSize> size, u32 reserved_addr)
 	return CELL_GAME_RET_OK;
 }
 
-int cellGameDataCheck(u32 type, const mem_list_ptr_t<u8> dirName, mem_ptr_t<CellGameContentSize> size)
+int cellGameDataCheck(u32 type, vm::ptr<const char> dirName, mem_ptr_t<CellGameContentSize> size)
 {
-	cellGame->Warning("cellGameDataCheck(type=0x%x, dirName_addr=0x%x, size_addr=0x%x)", type, dirName.GetAddr(), size.GetAddr());
+	cellGame->Warning("cellGameDataCheck(type=0x%x, dirName_addr=0x%x, size_addr=0x%x)", type, dirName.addr(), size.GetAddr());
 
 	if ((type - 1) >= 3)
 	{
@@ -163,7 +163,7 @@ int cellGameDataCheck(u32 type, const mem_list_ptr_t<u8> dirName, mem_ptr_t<Cell
 	}
 	else
 	{
-		std::string dir = "/dev_hdd0/game/" + std::string(dirName.GetString());
+		const std::string dir = std::string("/dev_hdd0/game/") + dirName.get_ptr();
 
 		if (!Emu.GetVFS().ExistsDir(dir))
 		{
@@ -177,10 +177,10 @@ int cellGameDataCheck(u32 type, const mem_list_ptr_t<u8> dirName, mem_ptr_t<Cell
 	return CELL_GAME_RET_OK;
 }
 
-int cellGameContentPermit(mem_list_ptr_t<u8> contentInfoPath, mem_list_ptr_t<u8> usrdirPath)
+int cellGameContentPermit(vm::ptr<char> contentInfoPath, vm::ptr<char> usrdirPath)
 {
 	cellGame->Warning("cellGameContentPermit(contentInfoPath_addr=0x%x, usrdirPath_addr=0x%x)",
-		contentInfoPath.GetAddr(), usrdirPath.GetAddr());
+		contentInfoPath.addr(), usrdirPath.addr());
 	
 	if (contentInfo == "" && usrdir == "")
 	{
@@ -189,8 +189,8 @@ int cellGameContentPermit(mem_list_ptr_t<u8> contentInfoPath, mem_list_ptr_t<u8>
 	}
 
 	// TODO: make it better
-	Memory.WriteString(contentInfoPath.GetAddr(), contentInfo);
-	Memory.WriteString(usrdirPath.GetAddr(), usrdir);
+	Memory.WriteString(contentInfoPath.addr(), contentInfo);
+	Memory.WriteString(usrdirPath.addr(), usrdir);
 
 	contentInfo = "";
 	usrdir = "";
@@ -198,11 +198,11 @@ int cellGameContentPermit(mem_list_ptr_t<u8> contentInfoPath, mem_list_ptr_t<u8>
 	return CELL_GAME_RET_OK;
 }
 
-int cellGameDataCheckCreate2(u32 version, const mem_list_ptr_t<u8> dirName, u32 errDialog,
+int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDialog,
 	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container)
 {
 	cellGame->Warning("cellGameDataCheckCreate2(version=0x%x, dirName_addr=0x%x, errDialog=0x%x, funcStat_addr=0x%x, container=%d)",
-		version, dirName.GetAddr(), errDialog, funcStat.GetAddr(), container);
+		version, dirName.addr(), errDialog, funcStat.GetAddr(), container);
 
 	if (version != CELL_GAMEDATA_VERSION_CURRENT || errDialog > 1)
 	{
@@ -212,7 +212,7 @@ int cellGameDataCheckCreate2(u32 version, const mem_list_ptr_t<u8> dirName, u32
 
 	// TODO: output errors (errDialog)
 
-	const std::string dir = "/dev_hdd0/game/" + std::string(dirName.GetString());
+	const std::string dir = std::string("/dev_hdd0/game/") + dirName.get_ptr();
 
 	if (!Emu.GetVFS().ExistsDir(dir))
 	{
@@ -304,17 +304,17 @@ int cellGameDataCheckCreate2(u32 version, const mem_list_ptr_t<u8> dirName, u32
 	}
 }
 
-int cellGameDataCheckCreate(u32 version, const mem_list_ptr_t<u8> dirName, u32 errDialog, 
+int cellGameDataCheckCreate(u32 version, vm::ptr<const char> dirName, u32 errDialog, 
 	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container)
 {
 	// TODO: almost identical, the only difference is that this function will always calculate the size of game data
 	return cellGameDataCheckCreate2(version, dirName, errDialog, funcStat, container);
 }
 
-int cellGameCreateGameData(mem_ptr_t<CellGameSetInitParams> init, mem_list_ptr_t<u8> tmp_contentInfoPath, mem_list_ptr_t<u8> tmp_usrdirPath)
+int cellGameCreateGameData(mem_ptr_t<CellGameSetInitParams> init, vm::ptr<char> tmp_contentInfoPath, vm::ptr<char> tmp_usrdirPath)
 {
 	cellGame->Todo("cellGameCreateGameData(init_addr=0x%x, tmp_contentInfoPath_addr=0x%x, tmp_usrdirPath_addr=0x%x)",
-		init.GetAddr(), tmp_contentInfoPath.GetAddr(), tmp_usrdirPath.GetAddr());
+		init.GetAddr(), tmp_contentInfoPath.addr(), tmp_usrdirPath.addr());
 
 	// TODO: create temporary game directory, set initial PARAM.SFO parameters
 	// cellGameContentPermit should then move files in non-temporary location and return their non-temporary displacement
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
index dc9bbbafbf..1b7aa846eb 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
@@ -139,10 +139,10 @@ int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellGi
 	return CELL_OK;
 }
 
-int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const mem_ptr_t<CellGifDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellGifDecDataOutInfo> dataOutInfo)
+int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellGifDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellGifDecDataOutInfo> dataOutInfo)
 {
 	cellGifDec->Warning("cellGifDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
-		mainHandle, subHandle, data.GetAddr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
 
 	dataOutInfo->status = CELL_GIFDEC_DEC_STATUS_STOP;
 
@@ -196,12 +196,12 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 			{
 				const int dstOffset = i * bytesPerLine;
 				const int srcOffset = width * nComponents * i;
-				memcpy(Memory + (data.GetAddr() + dstOffset), &image.get()[srcOffset], linesize);
+				memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize);
 			}
 		}
 		else
 		{
-			memcpy(Memory + data.GetAddr(), image.get(), image_size);
+			memcpy(Memory + data.addr(), image.get(), image_size);
 		}
 	}
 	break;
@@ -224,15 +224,15 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 					output[j + 2] = image.get()[srcOffset + j + 1];
 					output[j + 3] = image.get()[srcOffset + j + 2];
 				}
-				memcpy(Memory + (data.GetAddr() + dstOffset), output, linesize);
+				memcpy(Memory + (data.addr() + dstOffset), output, linesize);
 			}
 			free(output);
 		}
 		else
 		{
-			uint* dest = (uint*)new char[image_size];
+			uint* img = (uint*)new char[image_size];
 			uint* source_current = (uint*)&(image.get()[0]);
-			uint* dest_current = dest;
+			uint* dest_current = img;
 			for (uint i = 0; i < image_size / nComponents; i++) 
 			{
 				uint val = *source_current;
@@ -240,9 +240,8 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 				source_current++;
 				dest_current++;
 			}
-			// NOTE: AppendRawBytes has diff side-effect vs Memory.CopyFromReal
-			data.AppendRawBytes((u8*)dest, image_size); 
-			delete[] dest;
+			memcpy(data.get_ptr(), img, image_size); 
+			delete[] img;
 		}
 	}
 	break;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
index 3040029fb3..14210919a2 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
@@ -147,10 +147,10 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo
 	return CELL_OK;
 }
 
-int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const mem_ptr_t<CellJpgDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellJpgDecDataOutInfo> dataOutInfo)
+int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellJpgDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellJpgDecDataOutInfo> dataOutInfo)
 {
 	cellJpgDec->Log("cellJpgDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
-		mainHandle, subHandle, data.GetAddr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
 
 	dataOutInfo->status = CELL_JPGDEC_DEC_STATUS_STOP;
 	CellJpgDecSubHandle* subHandle_data;
@@ -206,12 +206,12 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 			{
 				const int dstOffset = i * bytesPerLine;
 				const int srcOffset = width * nComponents * (flip ? height - i - 1 : i);
-				memcpy(Memory + (data.GetAddr() + dstOffset), &image.get()[srcOffset], linesize);
+				memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize);
 			}
 		}
 		else
 		{
-			memcpy(Memory + data.GetAddr(), image.get(), image_size);
+			memcpy(Memory + data.addr(), image.get(), image_size);
 		}
 	}
 	break;
@@ -236,15 +236,15 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 					output[j + 2] = image.get()[srcOffset + j + 1];
 					output[j + 3] = image.get()[srcOffset + j + 2];
 				}
-				memcpy(Memory + (data.GetAddr() + dstOffset), output, linesize);
+				memcpy(Memory + (data.addr() + dstOffset), output, linesize);
 			}
 			free(output);
 		}
 		else
 		{
-			uint* dest = (uint*)new char[image_size];
+			uint* img = (uint*)new char[image_size];
 			uint* source_current = (uint*)&(image.get()[0]);
-			uint* dest_current = dest;
+			uint* dest_current = img;
 			for (uint i = 0; i < image_size / nComponents; i++) 
 			{
 				uint val = *source_current;
@@ -252,9 +252,8 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 				source_current++;
 				dest_current++;
 			}
-			// NOTE: AppendRawBytes has diff side-effect vs Memory.CopyFromReal
-			data.AppendRawBytes((u8*)dest, image_size); 
-			delete[] dest;
+			memcpy(data.get_ptr(), img, image_size); 
+			delete[] img;
 		}
 	}
 	break;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index 3f4db02ebd..d83ef1ddc7 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -18,12 +18,12 @@
 //Module cellL10n(0x001e, cellL10n_init);
 Module *cellL10n = nullptr;
 
-int UTF16stoUTF8s(mem16_ptr_t utf16, mem64_t utf16_len, mem8_ptr_t utf8, mem64_t utf8_len)
+int UTF16stoUTF8s(vm::ptr<const be_t<u16>> utf16, mem64_t utf16_len, vm::ptr<char> utf8, mem64_t utf8_len)
 {
 	cellL10n->Warning("UTF16stoUTF8s(utf16_addr=0x%x, utf16_len_addr=0x%x, utf8_addr=0x%x, utf8_len_addr=0x%x)",
-		utf16.GetAddr(), utf16_len.GetAddr(), utf8.GetAddr(), utf8_len.GetAddr());
+		utf16.addr(), utf16_len.GetAddr(), utf8.addr(), utf8_len.GetAddr());
 
-	std::u16string wstr =(char16_t*)Memory.VirtualToRealAddr(utf16.GetAddr());
+	std::u16string wstr =(char16_t*)utf16.get_ptr();
 	wstr.resize(utf16_len.GetValue()); // TODO: Is this really the role of utf16_len in this function?
 #ifdef _MSC_VER
 	std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t> convert;
@@ -36,14 +36,14 @@ int UTF16stoUTF8s(mem16_ptr_t utf16, mem64_t utf16_len, mem8_ptr_t utf8, mem64_t
 	}
 
 	utf8_len = str.size();
-	Memory.WriteString(utf8, str.c_str());
+	Memory.WriteString(utf8.addr(), str);
 #endif
 	return ConversionOK;
 }
 
-int jstrchk(mem8_ptr_t jstr)
+int jstrchk(vm::ptr<const char> jstr)
 {
-	cellL10n->Warning("jstrchk(jstr_addr=0x%x) -> utf8", jstr.GetAddr());
+	cellL10n->Warning("jstrchk(jstr_addr=0x%x) -> utf8", jstr.addr());
 
 	return L10N_STR_UTF8;
 }
@@ -247,7 +247,7 @@ int _L10nConvertStr(int src_code, const void *src, size_t * src_len, int dst_cod
 
 	if (target.length() > *dst_len) return DSTExhausted;
 
-	Memory.WriteString(dst, target.c_str());
+	Memory.WriteString(dst.addr(), target);
 
 	return ConversionOK;
 }
@@ -283,11 +283,11 @@ int _L10nConvertStr(int src_code, const void* src, size_t * src_len, int dst_cod
 #endif
 
 //TODO: Check the code in emulation. If support for UTF8/UTF16/UTF32/UCS2/UCS4 should use wider chars.. awful.
-int L10nConvertStr(int src_code, mem8_ptr_t src, mem64_t src_len, int dst_code, mem8_ptr_t dst, mem64_t dst_len)
+int L10nConvertStr(int src_code, vm::ptr<const void> src, mem32_t src_len, int dst_code, vm::ptr<void> dst, mem32_t dst_len)
 {
 	cellL10n->Todo("L10nConvertStr(src_code=%d,src=0x%x,src_len=%ld,dst_code=%d,dst=0x%x,dst_len=%ld)",
-		src_code, src.GetAddr(), src_len.GetValue(), dst_code, dst.GetAddr(), dst_len.GetValue());
-	cellL10n->Todo("L10nConvertStr: 1st char at dst: %x(Hex)", *((char*)Memory.VirtualToRealAddr(src.GetAddr())));
+		src_code, src.addr(), src_len.GetValue(), dst_code, dst.addr(), dst_len.GetValue());
+	cellL10n->Todo("L10nConvertStr: 1st char at dst: %x(Hex)", *((char*)src.get_ptr()));
 #ifdef _MSC_VER
 	unsigned int srcCode = 0, dstCode = 0;	//OEM code pages
 	bool src_page_converted = _L10nCodeParse(src_code, srcCode);	//Check if code is in list.
@@ -298,14 +298,14 @@ int L10nConvertStr(int src_code, mem8_ptr_t src, mem64_t src_len, int dst_code,
 		return ConverterUnknown;
 
 	//if (strnlen_s((char*)src, *src_len) != *src_len) return SRCIllegal;
-	std::string wrapped_source = (char*)Memory.VirtualToRealAddr(src.GetAddr());
+	std::string wrapped_source = (char*)src.get_ptr();
 	//std::string wrapped_source((char*)src);
 	if (wrapped_source.length() != src_len.GetValue()) return SRCIllegal;
 	std::string target = _OemToOem(srcCode, dstCode, wrapped_source);
 
 	if (target.length() > dst_len.GetValue()) return DSTExhausted;
 
-	Memory.WriteString(dst, target.c_str());
+	Memory.WriteString(dst.addr(), target);
 
 	return ConversionOK;
 #else
diff --git a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
index e7267d1359..57196033bc 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
@@ -3,6 +3,7 @@
 #include "Emu/System.h"
 #include "Emu/SysCalls/Modules.h"
 
+#include "Utilities/Log.h"
 #include "Utilities/rMsgBox.h"
 #include "Emu/SysCalls/lv2/sys_time.h"
 #include "cellSysutil.h"
@@ -59,10 +60,10 @@ void MsgDialogClose()
 	g_msg_dialog_wait_until = get_system_time();
 }
 
-int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
+int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
 {
 	cellSysutil->Warning("cellMsgDialogOpen2(type=0x%x, msgString_addr=0x%x, callback_addr=0x%x, userData=0x%x, extParam=0x%x)",
-		type, msgString.GetAddr(), callback.GetAddr(), userData, extParam);
+		type, msgString.addr(), callback.GetAddr(), userData, extParam);
 	
 	//type |= CELL_MSGDIALOG_TYPE_PROGRESSBAR_SINGLE | CELL_MSGDIALOG_TYPE_BG_INVISIBLE;
 	//type |= CELL_MSGDIALOG_TYPE_BUTTON_TYPE_YESNO | CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NO;
@@ -82,12 +83,14 @@ int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<Ce
 	default: g_msg_dialog_progress_bar_count = 0; break; // ???
 	}
 
-	thread t("MsgDialog thread", [=]()
+	std::string msg = msgString.get_ptr();
+
+	thread t("MsgDialog thread", [type, msg, callback, userData, extParam]()
 	{
 		switch (type & CELL_MSGDIALOG_TYPE_SE_TYPE)
 		{
-		case CELL_MSGDIALOG_TYPE_SE_TYPE_NORMAL: cellSysutil->Warning("Message: \n%s", msgString.GetString()); break;
-		case CELL_MSGDIALOG_TYPE_SE_TYPE_ERROR: cellSysutil->Error("Message: \n%s", msgString.GetString()); break;
+		case CELL_MSGDIALOG_TYPE_SE_TYPE_NORMAL: LOG_WARNING(TTY, "%s", msg.c_str()); break;
+		case CELL_MSGDIALOG_TYPE_SE_TYPE_ERROR: LOG_ERROR(TTY, "%s", msg.c_str()); break;
 		}
 
 		switch (type & CELL_MSGDIALOG_TYPE_SE_MUTE) // TODO
@@ -99,9 +102,9 @@ int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<Ce
 		u64 status = CELL_MSGDIALOG_BUTTON_NONE;
 
 		volatile bool m_signal = false;
-		CallAfter([&]()
+		CallAfter([type, msg, &status, &m_signal]()
 		{
-			MsgDialogCreate(type, (char*)msgString.GetPtr(), status);
+			MsgDialogCreate(type, msg.c_str(), status);
 
 			m_signal = true;
 		});
@@ -124,7 +127,7 @@ int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<Ce
 		if (callback && (g_msg_dialog_state != msgDialogAbort))
 			callback.async((s32)status, userData); // TODO: this callback should be registered
 
-		CallAfter([&]()
+		CallAfter([]()
 		{
 			MsgDialogDestroy();
 		});
@@ -136,9 +139,9 @@ int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<Ce
 	return CELL_OK;
 }
 
-int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, mem_ptr_t<void> userData, u32 extParam)
+int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
 {
-	cellSysutil->Warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback_addr=0x%x, userData=%d, extParam=%d)",
+	cellSysutil->Warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback_addr=0x%x, userData=0x%x, extParam=%d)",
 		errorCode, callback.GetAddr(), userData, extParam);
 
 	std::string errorMessage;
@@ -278,10 +281,10 @@ int cellMsgDialogAbort()
 	return CELL_OK;
 }
 
-int cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, mem_list_ptr_t<u8> msgString)
+int cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::ptr<const char> msgString)
 {
-	cellSysutil->Warning("cellMsgDialogProgressBarSetMsg(progressBarIndex=%d, msgString_addr=0x%x): '%s'",
-		progressBarIndex, msgString.GetAddr(), msgString.GetString());
+	cellSysutil->Warning("cellMsgDialogProgressBarSetMsg(progressBarIndex=%d, msgString_addr=0x%x ['%s'])",
+		progressBarIndex, msgString.addr(), msgString.get_ptr());
 
 	if (g_msg_dialog_state != msgDialogOpen)
 	{
@@ -293,7 +296,7 @@ int cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, mem_list_ptr_t<u8> msgS
 		return CELL_MSGDIALOG_ERROR_PARAM;
 	}
 
-	std::string text(msgString.GetString());
+	std::string text = msgString.get_ptr();
 
 	CallAfter([text, progressBarIndex]()
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h
index cc11500829..dbfd1438d4 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h
@@ -81,10 +81,10 @@ enum
 
 typedef void(*CellMsgDialogCallback)(int buttonType, u32 userData);
 
-int cellMsgDialogOpen2(u32 type, mem_list_ptr_t<u8> msgString, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
-int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, mem_ptr_t<void> userData, u32 extParam);
+int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
+int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
 
-int cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, mem_list_ptr_t<u8> msgString);
+int cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::ptr<const char> msgString);
 int cellMsgDialogProgressBarReset(u32 progressBarIndex);
 int cellMsgDialogProgressBarInc(u32 progressBarIndex, u32 delta);
 int cellMsgDialogClose(float delay);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
index 1ea9c785a0..370b475dd9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
@@ -368,12 +368,13 @@ int cellPamfReaderGetStreamIndex(mem_ptr_t<CellPamfReader> pSelf)
 	return pSelf->stream;
 }
 
-int cellPamfReaderGetStreamTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, mem8_t pType, mem8_t pCh)
+int cellPamfReaderGetStreamTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, vm::ptr<u8> pType, vm::ptr<u8> pCh)
 {
-	cellPamf->Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=0x%x (stream=%d), pType_addr=0x%x, pCh_addr=0x%x", pSelf.GetAddr(), pSelf->stream, pType.GetAddr(), pCh.GetAddr());
+	cellPamf->Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=0x%x (stream=%d), pType_addr=0x%x, pCh_addr=0x%x",
+		pSelf.GetAddr(), pSelf->stream, pType.addr(), pCh.addr());
 
-	pType = pamfGetStreamType(pSelf, pSelf->stream);
-	pCh = pamfGetStreamChannel(pSelf, pSelf->stream);
+	*pType = pamfGetStreamType(pSelf, pSelf->stream);
+	*pCh = pamfGetStreamChannel(pSelf, pSelf->stream);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index 9a419e02e4..b68f9c4fa4 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -184,10 +184,10 @@ int cellPngDecExtReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecI
 	return cellPngDecReadHeader(mainHandle, subHandle, info);
 }
 
-int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const mem_ptr_t<CellPngDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellPngDecDataOutInfo> dataOutInfo)
+int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellPngDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellPngDecDataOutInfo> dataOutInfo)
 {
 	cellPngDec->Warning("cellPngDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
-		mainHandle, subHandle, data.GetAddr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
 
 	dataOutInfo->status = CELL_PNGDEC_DEC_STATUS_STOP;
 	CellPngDecSubHandle* subHandle_data;
@@ -241,12 +241,12 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 			{
 				const int dstOffset = i * bytesPerLine;
 				const int srcOffset = width * nComponents * (flip ? height - i - 1 : i);
-				memcpy(Memory + (data.GetAddr() + dstOffset), &image.get()[srcOffset], linesize);
+				memcpy(Memory + (data.addr() + dstOffset), &image.get()[srcOffset], linesize);
 			}
 		}
 		else
 		{
-			memcpy(Memory + data.GetAddr(), image.get(), image_size);
+			memcpy(Memory + data.addr(), image.get(), image_size);
 		}
 	}
 	break;
@@ -271,15 +271,15 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 					output[j + 2] = image.get()[srcOffset + j + 1];
 					output[j + 3] = image.get()[srcOffset + j + 2];
 				}
-				memcpy(Memory + (data.GetAddr() + dstOffset), output, linesize);
+				memcpy(Memory + (data.addr() + dstOffset), output, linesize);
 			}
 			free(output);
 		}
 		else
 		{
-			uint* dest = (uint*)new char[image_size];
+			uint* img = (uint*)new char[image_size];
 			uint* source_current = (uint*)&(image.get()[0]);
-			uint* dest_current = dest;
+			uint* dest_current = img;
 			for (uint i = 0; i < image_size / nComponents; i++) 
 			{
 				uint val = *source_current;
@@ -287,9 +287,8 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 				source_current++;
 				dest_current++;
 			}
-			// NOTE: AppendRawBytes has diff side-effect vs Memory.CopyFromReal
-			data.AppendRawBytes((u8*)dest, image_size); 
-			delete[] dest;
+			memcpy(data.get_ptr(), img, image_size);
+			delete[] img;
 		}
 	}
 	break;
@@ -309,11 +308,11 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const m
 	return CELL_OK;
 }
 
-int cellPngDecExtDecodeData(u32 mainHandle, u32 subHandle, mem8_ptr_t data, const mem_ptr_t<CellPngDecDataCtrlParam> dataCtrlParam,
+int cellPngDecExtDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellPngDecDataCtrlParam> dataCtrlParam,
 	mem_ptr_t<CellPngDecDataOutInfo> dataOutInfo, mem_ptr_t<CellPngDecCbCtrlDisp> cbCtrlDisp, mem_ptr_t<CellPngDecDispParam> dispParam)
 {
 	cellPngDec->Warning("cellPngDecExtDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x, cbCtrlDisp_addr=0x%x, dispParam=0x%x)",
-		mainHandle, subHandle, data.GetAddr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr(), cbCtrlDisp.GetAddr(), dispParam.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr(), cbCtrlDisp.GetAddr(), dispParam.GetAddr());
 
 	if (cbCtrlDisp.GetAddr()) cellPngDec->Warning("*** cbCtrlDisp->cbCtrlDispFunc_addr=0x%x", (u32)cbCtrlDisp->cbCtrlDispFunc_addr);
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
index 4003352d0f..6921eca1a5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@@ -1136,8 +1136,8 @@ int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
 	float bandwidth = 0.5f / (srcH / dstH);
 	float phi_b = 2.f * PI * bandwidth;
 	float window[4];
-	mem16_ptr_t buf16(ea_addr);
-	mem32_ptr_t buf32(ea_addr);
+	auto buf16 = vm::ptr<be_t<u16>>::make(ea_addr);
+	auto buf32 = vm::ptr<be_t<float>>::make(ea_addr);
 
 	blackman(window);
 
@@ -1165,7 +1165,8 @@ int CreateInterlaceTable(u32 ea_addr, float srcH, float dstH, CellRescTableEleme
 			buf16[3] = FloatToHalf(transient[3] / total4);
 			buf16 += 4;
 		}
-		else {
+		else
+		{
 			buf32[0] = transient[0] / total4;
 			buf32[1] = transient[1] / total4;
 			buf32[2] = transient[2] / total4;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index 733fb8feaa..d32c2b7bc6 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -94,9 +94,9 @@ s64 cellSpursAttributeSetMemoryContainerForSpuThread(mem_ptr_t<CellSpursAttribut
 #endif
 }
 
-s64 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, const mem8_t prefix, u32 size)
+s64 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, vm::ptr<const char> prefix, u32 size)
 {
-	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.GetAddr(), prefix.GetAddr(), size);
+	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.GetAddr(), prefix.addr(), size);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x7234, libsre_rtoc);
@@ -107,7 +107,7 @@ s64 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, const me
 		return CELL_SPURS_CORE_ERROR_INVAL;
 	}
 
-	attr->attr->_setNamePrefix(Memory.ReadString(prefix.GetAddr(), size).c_str(), size);
+	attr->attr->_setNamePrefix(prefix.get_ptr(), size);
 
 	return CELL_OK;
 #endif
@@ -137,10 +137,10 @@ s64 cellSpursAttributeSetSpuThreadGroupType(mem_ptr_t<CellSpursAttribute> attr,
 #endif
 }
 
-s64 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, mem8_ptr_t priority, u32 maxSpu, mem8_ptr_t isPreemptible)
+s64 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, vm::ptr<const u8> priority, u32 maxSpu, vm::ptr<const bool> isPreemptible)
 {
 	cellSpurs->Warning("cellSpursAttributeEnableSystemWorkload(attr_addr=0x%x, priority_addr=0x%x, maxSpu=%d, isPreemptible_addr=0x%x)",
-		attr.GetAddr(), priority.GetAddr(), maxSpu, isPreemptible.GetAddr());
+		attr.GetAddr(), priority.addr(), maxSpu, isPreemptible.addr());
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0xF410, libsre_rtoc);
@@ -201,10 +201,10 @@ s64 cellSpursSetMaxContention(mem_ptr_t<CellSpurs> spurs, u32 workloadId, u32 ma
 #endif
 }
 
-s64 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, const mem8_ptr_t priorities)
+s64 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, vm::ptr<const u8> priorities)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursSetPriorities(spurs_addr=0x%x, workloadId=%d, priorities_addr=0x%x)", spurs.GetAddr(), workloadId, priorities.GetAddr());
+	cellSpurs->Warning("cellSpursSetPriorities(spurs_addr=0x%x, workloadId=%d, priorities_addr=0x%x)", spurs.GetAddr(), workloadId, priorities.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8BC0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -212,10 +212,10 @@ s64 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, const mem
 #endif
 }
 
-s64 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, mem8_ptr_t isPreemptible)
+s64 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, vm::ptr<const bool> isPreemptible)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursSetPreemptionVictimHints(spurs_addr=0x%x, isPreemptible_addr=0x%x)", spurs.GetAddr(), isPreemptible.GetAddr());
+	cellSpurs->Warning("cellSpursSetPreemptionVictimHints(spurs_addr=0x%x, isPreemptible_addr=0x%x)", spurs.GetAddr(), isPreemptible.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0xF5A4, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -223,11 +223,11 @@ s64 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, mem8_ptr_t isP
 #endif
 }
 
-s64 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, mem8_t port, s32 isDynamic)
+s64 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursAttachLv2EventQueue(spurs_addr=0x%x, queue=%d, port_addr=0x%x, isDynamic=%d)",
-		spurs.GetAddr(), queue, port.GetAddr(), isDynamic);
+		spurs.GetAddr(), queue, port.addr(), isDynamic);
 	return GetCurrentPPUThread().FastCall2(libsre + 0xAFE0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -710,10 +710,10 @@ s64 cellSpursCreateTasksetWithAttribute()
 #endif
 }
 
-s64 cellSpursCreateTaskset(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, u64 args, mem8_t priority, u32 maxContention)
+s64 cellSpursCreateTaskset(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, u64 args, vm::ptr<const u8> priority, u32 maxContention)
 {
 	cellSpurs->Warning("cellSpursCreateTaskset(spurs_addr=0x%x, taskset_addr=0x%x, args=0x%llx, priority_addr=0x%x, maxContention=%d)",
-		spurs.GetAddr(), taskset.GetAddr(), args, priority.GetAddr(), maxContention);
+		spurs.GetAddr(), taskset.GetAddr(), args, priority.addr(), maxContention);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x14CB8, libsre_rtoc);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index b9ce671310..7c0bc1b0f5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -2126,30 +2126,30 @@ s32 cellSyncLFQueueGetEntrySize(vm::ptr<CellSyncLFQueue> queue, mem32_t entry_si
 	return CELL_OK;
 }
 
-s32 syncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
+s32 syncLFQueueAttachLv2EventQueue(vm::ptr<be_t<u32>> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
 	// TODO
 	assert(0);
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
+s32 _cellSyncLFQueueAttachLv2EventQueue(vm::ptr<be_t<u32>> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync->Todo("_cellSyncLFQueueAttachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.addr());
+	cellSync->Todo("_cellSyncLFQueueAttachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.addr(), num, queue.addr());
 
 	return syncLFQueueAttachLv2EventQueue(spus, num, queue);
 }
 
-s32 syncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
+s32 syncLFQueueDetachLv2EventQueue(vm::ptr<be_t<u32>> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
 	// TODO
 	assert(0);
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
+s32 _cellSyncLFQueueDetachLv2EventQueue(vm::ptr<be_t<u32>> spus, u32 num, vm::ptr<CellSyncLFQueue> queue)
 {
-	cellSync->Todo("_cellSyncLFQueueDetachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.GetAddr(), num, queue.addr());
+	cellSync->Todo("_cellSyncLFQueueDetachLv2EventQueue(spus_addr=0x%x, num=%d, queue_addr=0x%x)", spus.addr(), num, queue.addr());
 
 	return syncLFQueueDetachLv2EventQueue(spus, num, queue);
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
index 2950d4fc66..db188a6970 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
@@ -112,22 +112,22 @@ int cellSysutilGetSystemParamInt(int id, mem32_t value)
 	return CELL_OK;
 }
 
-int cellSysutilGetSystemParamString(s32 id, mem_list_ptr_t<u8> buf, u32 bufsize)
+int cellSysutilGetSystemParamString(s32 id, vm::ptr<char> buf, u32 bufsize)
 {
-	cellSysutil->Log("cellSysutilGetSystemParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf.GetAddr(), bufsize);
+	cellSysutil->Log("cellSysutilGetSystemParamString(id=%d, buf_addr=0x%x, bufsize=%d)", id, buf.addr(), bufsize);
 
-	memset(buf, 0, bufsize);
+	memset(buf.get_ptr(), 0, bufsize);
 
 	switch(id)
 	{
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME:
 		cellSysutil->Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_NICKNAME");
-		memcpy(buf, "Unknown", 8); //for example
+		memcpy(buf.get_ptr(), "Unknown", 8); // for example
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME:
 		cellSysutil->Warning("cellSysutilGetSystemParamString: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USERNAME");
-		memcpy(buf, "Unknown", 8);
+		memcpy(buf.get_ptr(), "Unknown", 8);
 	break;
 
 	default:
@@ -807,9 +807,9 @@ int cellSysutilGetBgmPlaybackStatus2(mem_ptr_t<CellSysutilBgmPlaybackStatus2> st
 	return CELL_OK;
 }
 
-int cellWebBrowserEstimate2(mem8_ptr_t _config, mem32_ptr_t memSize)
+int cellWebBrowserEstimate2(const vm::ptr<const u8> _config, vm::ptr<be_t<u32>> memSize)
 {
-	cellSysutil->Warning("cellWebBrowserEstimate2(config_addr=0x%x, memSize_addr=0x%x)", _config.GetAddr(), memSize.GetAddr());
+	cellSysutil->Warning("cellWebBrowserEstimate2(config_addr=0x%x, memSize_addr=0x%x)", _config.addr(), memSize.addr());
 
 	// TODO: When cellWebBrowser stuff is implemented, change this to some real
 	// needed memory buffer size.
@@ -817,10 +817,10 @@ int cellWebBrowserEstimate2(mem8_ptr_t _config, mem32_ptr_t memSize)
 	return CELL_OK;
 }
 
-extern int cellGameDataCheckCreate2(u32 version, const mem_list_ptr_t<u8> dirName, u32 errDialog,
+extern int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDialog,
 	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container);
 
-extern int cellGameDataCheckCreate(u32 version, const mem_list_ptr_t<u8> dirName, u32 errDialog,
+extern int cellGameDataCheckCreate(u32 version, vm::ptr<const char> dirName, u32 errDialog,
 	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container);
 
 void cellSysutil_init()
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
index e6be52a0c8..cc57857717 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
@@ -236,18 +236,16 @@ int cellFsAioWrite(mem_ptr_t<CellFsAio> aio, mem32_t aio_id, mem_func_ptr_t<void
 	return CELL_OK;
 }
 
-int cellFsAioInit(mem8_ptr_t mount_point)
+int cellFsAioInit(vm::ptr<const char> mount_point)
 {
-	std::string mp = Memory.ReadString(mount_point.GetAddr());
-	sys_fs->Warning("cellFsAioInit(mount_point_addr=0x%x (%s))", mount_point.GetAddr(), mp.c_str());
+	sys_fs->Warning("cellFsAioInit(mount_point_addr=0x%x (%s))", mount_point.addr(), mount_point.get_ptr());
 	aio_init = true;
 	return CELL_OK;
 }
 
-int cellFsAioFinish(mem8_ptr_t mount_point)
+int cellFsAioFinish(vm::ptr<const char> mount_point)
 {
-	std::string mp = Memory.ReadString(mount_point.GetAddr());
-	sys_fs->Warning("cellFsAioFinish(mount_point_addr=0x%x (%s))", mount_point.GetAddr(), mp.c_str());
+	sys_fs->Warning("cellFsAioFinish(mount_point_addr=0x%x (%s))", mount_point.addr(), mount_point.get_ptr());
 	aio_init = false;
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
index 00a4eeec2a..94d91af602 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
@@ -169,11 +169,10 @@ int getsockopt()
 	return CELL_OK;
 }
 
-int sys_net_inet_addr(mem8_ptr_t cp)
+int sys_net_inet_addr(vm::ptr<const char> cp)
 {
-	std::string cp_ = Memory.ReadString(cp.GetAddr());
-	sys_net->Warning("inet_addr(cp=\"%s\")", cp_.c_str());
-	return htonl(inet_addr(cp_.c_str())); // return a big-endian IP address
+	sys_net->Warning("inet_addr(cp_addr=0x%x['%s'])", cp.addr(), cp.get_ptr());
+	return htonl(inet_addr(cp.get_ptr())); // return a big-endian IP address
 }
 
 int inet_aton()
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
index fe1d02b4a8..c2909deb15 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
@@ -168,10 +168,10 @@ s32 sys_process_get_number_of_object(u32 object, mem32_t nump)
 	return CELL_OK;
 }
 
-s32 sys_process_get_id(u32 object, mem32_ptr_t buffer, u32 size, mem32_t set_size)
+s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, mem32_t set_size)
 {
 	sys_process.Todo("sys_process_get_id(object=%d, buffer_addr=0x%x, size=%d, set_size_addr=0x%x)",
-		object, buffer.GetAddr(), size, set_size.GetAddr());
+		object, buffer.addr(), size, set_size.GetAddr());
 
 	switch(object)
 	{
@@ -212,9 +212,9 @@ s32 sys_process_get_id(u32 object, mem32_ptr_t buffer, u32 size, mem32_t set_siz
 	return CELL_OK;
 }
 
-s32 sys_process_get_paramsfo(mem8_ptr_t buffer)
+s32 sys_process_get_paramsfo(vm::ptr<u8> buffer)
 {
-	sys_process.Todo("sys_process_get_paramsfo(buffer_addr=0x%x) -> CELL_ENOENT", buffer.GetAddr());
+	sys_process.Todo("sys_process_get_paramsfo(buffer_addr=0x%x) -> CELL_ENOENT", buffer.addr());
 	return CELL_ENOENT;
 
 	/*//Before uncommenting this code, we should check if it is actually working.
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_process.h b/rpcs3/Emu/SysCalls/lv2/sys_process.h
index 86d1ecfbf0..98d495fc99 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_process.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_process.h
@@ -31,8 +31,8 @@ s32 process_get_sdk_version(u32 pid, s32& ver);
 s32 sys_process_getpid();
 s32 sys_process_getppid();
 s32 sys_process_get_number_of_object(u32 object, mem32_t nump);
-s32 sys_process_get_id(u32 object, mem32_ptr_t buffer, u32 size, mem32_t set_size);
-s32 sys_process_get_paramsfo(mem8_ptr_t buffer);
+s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, mem32_t set_size);
+s32 sys_process_get_paramsfo(vm::ptr<u8> buffer);
 s32 sys_process_get_sdk_version(u32 pid, mem32_t version);
 s32 sys_process_get_status(u64 unk);
 s32 sys_process_exit(s32 errorcode);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
index 146d461b67..a09f70a471 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
@@ -796,10 +796,10 @@ s32 sys_spu_thread_unbind_queue(u32 id, u32 spuq_num)
 	return CELL_OK;
 }
 
-s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, mem8_t spup)
+s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, vm::ptr<u8> spup)
 {
 	sys_spu.Warning("sys_spu_thread_group_connect_event_all_threads(id=%d, eq_id=%d, req=0x%llx, spup_addr=0x%x)",
-		id, eq_id, req, spup.GetAddr());
+		id, eq_id, req, spup.addr());
 
 	EventQueue* eq;
 	if (!Emu.GetIdManager().GetIDData(eq_id, eq))
@@ -854,7 +854,7 @@ s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, m
 					t->SPUPs[i].eq = eq;
 				}
 				sys_spu.Warning("*** spup -> %d", i);
-				spup = (u8)i;
+				*spup = (u8)i;
 			}
 
 			for (auto& t : threads) t->SPUPs[i].m_mutex.unlock();
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.h b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
index df56f7cb8b..2d97c1d54e 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
@@ -124,7 +124,7 @@ s32 sys_spu_thread_create(mem32_t thread_id, mem32_t entry, u64 arg, int prio, u
 s32 sys_spu_thread_group_join(u32 id, mem32_t cause, mem32_t status);
 s32 sys_spu_thread_group_connect_event(u32 id, u32 eq, u32 et);
 s32 sys_spu_thread_group_disconnect_event(u32 id, u32 et);
-s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, mem8_t spup);
+s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, vm::ptr<u8> spup);
 s32 sys_spu_thread_group_disconnect_event_all_threads(u32 id, u8 spup);
 s32 sys_spu_thread_write_ls(u32 id, u32 address, u64 value, u32 type);
 s32 sys_spu_thread_read_ls(u32 id, u32 address, mem64_t value, u32 type);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_tty.cpp b/rpcs3/Emu/SysCalls/lv2/sys_tty.cpp
index 86548b31e4..1bd585f821 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_tty.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_tty.cpp
@@ -26,10 +26,10 @@ s32 sys_tty_write(u32 ch, u64 buf_addr, u32 len, u64 pwritelen_addr)
 	if(ch > 15 || (s32)len <= 0) return CELL_EINVAL;
 	
 	if (ch == SYS_TTYP_PPU_STDOUT || ch == SYS_TTYP_SPU_STDOUT || (ch >= SYS_TTYP_USER1 && ch <= SYS_TTYP_USER13)) {
-		LOG_NOTICE(TTY, Memory.ReadString(buf_addr, len));
+		LOG_NOTICE(TTY, "%s", Memory.ReadString(buf_addr, len).c_str());
 	}
 	if (ch == SYS_TTYP_PPU_STDERR) {
-		LOG_ERROR(TTY, Memory.ReadString(buf_addr, len));
+		LOG_ERROR(TTY, "%s", Memory.ReadString(buf_addr, len).c_str());
 	}
 		
 	Memory.Write32(pwritelen_addr, len);
diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index a392e1f548..59f0103b94 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -347,24 +347,24 @@ void Emulator::Load()
 		m_rsx_callback = (u32)Memory.MainMem.AllocAlign(4 * 4) + 4;
 		Memory.Write32(m_rsx_callback - 4, m_rsx_callback);
 
-		mem32_ptr_t callback_data(m_rsx_callback);
-		callback_data += ADDI(11, 0, 0x3ff);
-		callback_data += SC(2);
-		callback_data += BCLR(0x10 | 0x04, 0, 0, 0);
+		auto callback_data = vm::ptr<be_t<u32>>::make(m_rsx_callback);
+		callback_data[0] = ADDI(11, 0, 0x3ff);
+		callback_data[1] = SC(2);
+		callback_data[2] = BCLR(0x10 | 0x04, 0, 0, 0);
 
 		m_ppu_thr_exit = (u32)Memory.MainMem.AllocAlign(4 * 4);
 
-		mem32_ptr_t ppu_thr_exit_data(m_ppu_thr_exit);
+		auto ppu_thr_exit_data = vm::ptr<be_t<u32>>::make(m_ppu_thr_exit);
 		//ppu_thr_exit_data += ADDI(3, 0, 0); // why it kills return value (GPR[3]) ?
-		ppu_thr_exit_data += ADDI(11, 0, 41);
-		ppu_thr_exit_data += SC(2);
-		ppu_thr_exit_data += BCLR(0x10 | 0x04, 0, 0, 0);
+		ppu_thr_exit_data[0] = ADDI(11, 0, 41);
+		ppu_thr_exit_data[1] = SC(2);
+		ppu_thr_exit_data[2] = BCLR(0x10 | 0x04, 0, 0, 0);
 
 		m_ppu_thr_stop = (u32)Memory.MainMem.AllocAlign(2 * 4);
 
-		mem32_ptr_t ppu_thr_stop_data(m_ppu_thr_stop);
-		ppu_thr_stop_data += SC(4);
-		ppu_thr_exit_data += BCLR(0x10 | 0x04, 0, 0, 0);
+		auto ppu_thr_stop_data = vm::ptr<be_t<u32>>::make(m_ppu_thr_stop);
+		ppu_thr_stop_data[0] = SC(4);
+		ppu_thr_exit_data[1] = BCLR(0x10 | 0x04, 0, 0, 0);
 
 		Memory.Write64(Memory.PRXMem.AllocAlign(0x10000), 0xDEADBEEFABADCAFE);
 	}
diff --git a/rpcs3/Gui/RSXDebugger.cpp b/rpcs3/Gui/RSXDebugger.cpp
index 7b0a958774..1e10d2b6fb 100644
--- a/rpcs3/Gui/RSXDebugger.cpp
+++ b/rpcs3/Gui/RSXDebugger.cpp
@@ -830,7 +830,7 @@ wxString RSXDebugger::DisAsmCommand(u32 cmd, u32 count, u32 currentAddr, u32 ioA
 	}
 	else if(!(cmd & (CELL_GCM_METHOD_FLAG_JUMP | CELL_GCM_METHOD_FLAG_CALL)) && cmd != CELL_GCM_METHOD_FLAG_RETURN)
 	{
-		mem32_ptr_t args(currentAddr + 4);
+		auto args = vm::ptr<be_t<u32>>::make(currentAddr + 4);
 
 		u32 index = 0;
 		switch(cmd & 0x3ffff)
diff --git a/rpcs3/Loader/ELF64.cpp b/rpcs3/Loader/ELF64.cpp
index d983d64995..3d294dbe09 100644
--- a/rpcs3/Loader/ELF64.cpp
+++ b/rpcs3/Loader/ELF64.cpp
@@ -464,14 +464,14 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
 #endif
 						Memory.Write32(stub.s_text + i*4, (u32)tbl + i*8);
 
-						mem32_ptr_t out_tbl((u32)tbl + i*8);
-						out_tbl += (u32)dst + i*section;
-						out_tbl += Emu.GetModuleManager().GetFuncNumById(nid);
+						auto out_tbl = vm::ptr<be_t<u32>>::make((u32)tbl + i * 8);
+						out_tbl[0] = (u32)dst + i*section;
+						out_tbl[1] = Emu.GetModuleManager().GetFuncNumById(nid);
 
-						mem32_ptr_t out_dst((u32)dst + i*section);
-						out_dst += OR(11, 2, 2, 0);
-						out_dst += SC(2);
-						out_dst += BCLR(0x10 | 0x04, 0, 0, 0);
+						auto out_dst = vm::ptr<be_t<u32>>::make((u32)dst + i*section);
+						out_dst[0] = OR(11, 2, 2, 0);
+						out_dst[1] = SC(2);
+						out_dst[2] = BCLR(0x10 | 0x04, 0, 0, 0);
 					}
 				}
 #ifdef LOADER_DEBUG

From 8e5980b307475b5db3cca79d16a3ea953a9fe08a Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 19:31:26 +0400
Subject: [PATCH 13/36] Compilation fix

---
 rpcs3/Emu/SysCalls/Modules/cellSync.h | 30 +++++++++++++--------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.h b/rpcs3/Emu/SysCalls/Modules/cellSync.h
index 70d9c7823d..9e4d73f7b2 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.h
@@ -155,22 +155,22 @@ struct CellSyncLFQueue
 
 static_assert(sizeof(CellSyncLFQueue) == 128, "CellSyncLFQueue: wrong size");
 
-s32 syncMutexInitialize(mem_ptr_t<CellSyncMutex> mutex);
+s32 syncMutexInitialize(vm::ptr<CellSyncMutex> mutex);
 
-s32 syncBarrierInitialize(mem_ptr_t<CellSyncBarrier> barrier, u16 total_count);
+s32 syncBarrierInitialize(vm::ptr<CellSyncBarrier> barrier, u16 total_count);
 
-s32 syncRwmInitialize(mem_ptr_t<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size);
+s32 syncRwmInitialize(vm::ptr<CellSyncRwm> rwm, u32 buffer_addr, u32 buffer_size);
 
-s32 syncQueueInitialize(mem_ptr_t<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth);
+s32 syncQueueInitialize(vm::ptr<CellSyncQueue> queue, u32 buffer_addr, u32 size, u32 depth);
 
-s32 syncLFQueueInitialize(mem_ptr_t<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr);
-s32 syncLFQueueGetPushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue);
-s32 syncLFQueueGetPushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue);
-s32 syncLFQueueCompletePushPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal);
-s32 syncLFQueueCompletePushPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal);
-s32 syncLFQueueGetPopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue);
-s32 syncLFQueueGetPopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue);
-s32 syncLFQueueCompletePopPointer(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull);
-s32 syncLFQueueCompletePopPointer2(mem_ptr_t<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull);
-s32 syncLFQueueAttachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t<CellSyncLFQueue> queue);
-s32 syncLFQueueDetachLv2EventQueue(mem32_ptr_t spus, u32 num, mem_ptr_t<CellSyncLFQueue> queue);
+s32 syncLFQueueInitialize(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 size, u32 depth, CellSyncQueueDirection direction, u32 eaSignal_addr);
+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);
+s32 syncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal);
+s32 syncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32, u32 useEventQueue);
+s32 syncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 isBlocking, u32 useEventQueue);
+s32 syncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull);
+s32 syncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull);
+s32 syncLFQueueAttachLv2EventQueue(vm::ptr<be_t<u32>> spus, u32 num, vm::ptr<CellSyncLFQueue> queue);
+s32 syncLFQueueDetachLv2EventQueue(vm::ptr<be_t<u32>> spus, u32 num, vm::ptr<CellSyncLFQueue> queue);

From f6f58b7615d0bc1b23158fab25a69f68e70c588c Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 19:39:01 +0400
Subject: [PATCH 14/36] Compilation fix 2

---
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index d83ef1ddc7..54f685da94 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -314,8 +314,8 @@ int L10nConvertStr(int src_code, vm::ptr<const void> src, mem32_t src_len, int d
 	if ((_L10nCodeParse(src_code, srcCode)) && (_L10nCodeParse(dst_code, dstCode)))
 	{
 		iconv_t ict = iconv_open(srcCode.c_str(), dstCode.c_str());
-		char *srcBuf = (char*)Memory.VirtualToRealAddr(src.GetAddr());
-		char *dstBuf = (char*)Memory.VirtualToRealAddr(dst.GetAddr());
+		const char *srcBuf = (const char*)src.get_ptr();
+		char *dstBuf = (char*)dst.get_ptr();
 		//char *srcBuf = (char*)src, *dstBuf = (char*)dst;
 		//size_t srcLen = *src_len, dstLen = *dst_len;
 		size_t srcLen = src_len.GetValue(), dstLen = dst_len.GetValue();

From 96d7034c96b9aeae557a639b53ec3a16f56644a3 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 19:48:45 +0400
Subject: [PATCH 15/36] Compilation fix 3

---
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index 54f685da94..24b5f3f0a5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -314,7 +314,7 @@ int L10nConvertStr(int src_code, vm::ptr<const void> src, mem32_t src_len, int d
 	if ((_L10nCodeParse(src_code, srcCode)) && (_L10nCodeParse(dst_code, dstCode)))
 	{
 		iconv_t ict = iconv_open(srcCode.c_str(), dstCode.c_str());
-		const char *srcBuf = (const char*)src.get_ptr();
+		char *srcBuf = (char*)src.get_ptr();
 		char *dstBuf = (char*)dst.get_ptr();
 		//char *srcBuf = (char*)src, *dstBuf = (char*)dst;
 		//size_t srcLen = *src_len, dstLen = *dst_len;

From 06486b6537a72a3d11a6279c73777987cc177f19 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 21:13:21 +0400
Subject: [PATCH 16/36] Bug fixed

---
 rpcs3/Emu/System.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/System.cpp b/rpcs3/Emu/System.cpp
index 59f0103b94..54fbc033ec 100644
--- a/rpcs3/Emu/System.cpp
+++ b/rpcs3/Emu/System.cpp
@@ -364,7 +364,7 @@ void Emulator::Load()
 
 		auto ppu_thr_stop_data = vm::ptr<be_t<u32>>::make(m_ppu_thr_stop);
 		ppu_thr_stop_data[0] = SC(4);
-		ppu_thr_exit_data[1] = BCLR(0x10 | 0x04, 0, 0, 0);
+		ppu_thr_stop_data[1] = BCLR(0x10 | 0x04, 0, 0, 0);
 
 		Memory.Write64(Memory.PRXMem.AllocAlign(0x10000), 0xDEADBEEFABADCAFE);
 	}

From 49b295e332022c806241fabfae5502037cfd0655 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Sun, 31 Aug 2014 23:38:03 +0400
Subject: [PATCH 17/36] Bugs fixed

---
 rpcs3/Emu/Memory/Memory.h    | 2 +-
 rpcs3/Emu/SysCalls/SC_FUNC.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index d7b2371558..bd1f9e66a4 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -358,7 +358,7 @@ public:
 
 	template<typename T> void WriteString(const T addr, const std::string& str)
 	{
-		memcpy(GetMemFromAddr<T>(addr), str.c_str(), str.size());
+		strcpy((char*)GetMemFromAddr<T>(addr), str.c_str());
 	}
 
 	u32 GetUserMemTotalSize()
diff --git a/rpcs3/Emu/SysCalls/SC_FUNC.h b/rpcs3/Emu/SysCalls/SC_FUNC.h
index aa3cc4c5db..f831aa5a64 100644
--- a/rpcs3/Emu/SysCalls/SC_FUNC.h
+++ b/rpcs3/Emu/SysCalls/SC_FUNC.h
@@ -38,7 +38,7 @@ namespace detail
 
 		static __forceinline T func(PPUThread& CPU)
 		{
-			return (T&)CPU.FPR[f_count];
+			return (T)CPU.FPR[f_count];
 		}
 	};
 

From 0d94c78e630af11a3f2024b98568c5c3d8659667 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 01:55:38 +0400
Subject: [PATCH 18/36] mem16_t replaced

I think it's not bad to use pointer type when possible, because it's
often originally pointer, not reference.
---
 rpcs3/Emu/Memory/Memory.h                |  1 -
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp |  8 ++++----
 rpcs3/Emu/SysCalls/Modules/libmixer.cpp  | 10 ++++------
 3 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index bd1f9e66a4..dc390520fe 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -768,7 +768,6 @@ public:
 	}
 };
 
-typedef mem_t<u16, u32> mem16_t;
 typedef mem_t<u32, u32> mem32_t;
 typedef mem_t<u64, u32> mem64_t;
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index d32c2b7bc6..6d0e93bbdb 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -325,10 +325,10 @@ s64 cellSpursEventFlagDetachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFla
 #endif
 }
 
-s64 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask, u32 mode)
+s64 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u16>> mask, u32 mode)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=%d)", eventFlag.GetAddr(), mask.GetAddr(), mode);
+	cellSpurs->Warning("cellSpursEventFlagWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=%d)", eventFlag.GetAddr(), mask.addr(), mode);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15E68, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -358,10 +358,10 @@ s64 cellSpursEventFlagSet(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 #endif
 }
 
-s64 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, mem16_t mask, u32 mode)
+s64 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u16>> mask, u32 mode)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagTryWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=0x%x)", eventFlag.GetAddr(), mask.GetAddr(), mode);
+	cellSpurs->Warning("cellSpursEventFlagTryWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=0x%x)", eventFlag.GetAddr(), mask.addr(), mode);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15E70, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index f9e16dfa0b..3380f00c31 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -361,6 +361,7 @@ int cellSurMixerCreate(const mem_ptr_t<CellSurMixerConfig> config)
 
 					for (auto& p : ssp) if (p.m_active && p.m_created)
 					{
+						auto v = vm::ptr<s16>::make(p.m_addr); // 16-bit LE audio data
 						float left = 0.0f;
 						float right = 0.0f;
 						float speed = fabs(p.m_speed);
@@ -398,15 +399,12 @@ int cellSurMixerCreate(const mem_ptr_t<CellSurMixerConfig> config)
 							p.m_position += (u32)pos_inc;
 							if (p.m_channels == 1) // get mono data
 							{
-								mem16_t v(p.m_addr + pos * sizeof(u16));
-								left = right = (float)(s16)re16(v.GetValue()) / 0x8000 * p.m_level;
+								left = right = (float)v[pos] / 0x8000 * p.m_level;
 							}
 							else if (p.m_channels == 2) // get stereo data
 							{
-								mem16_t v1(p.m_addr + (pos * 2 + 0) * sizeof(u16));
-								mem16_t v2(p.m_addr + (pos * 2 + 1) * sizeof(u16));
-								left = (float)(s16)re16(v1.GetValue()) / 0x8000 * p.m_level;
-								right = (float)(s16)re16(v2.GetValue()) / 0x8000 * p.m_level;
+								left = (float)v[pos * 2 + 0] / 0x8000 * p.m_level;
+								right = (float)v[pos * 2 + 1] / 0x8000 * p.m_level;
 							}
 							if (p.m_connected) // mix
 							{

From 0b5ef1d8f96f2ee626619a023c43d16ea74f05b8 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 02:58:08 +0400
Subject: [PATCH 19/36] mem64_t replaced

Added conversion from vm::var to vm::ptr of the same type.
---
 rpcs3/Emu/Memory/Memory.h                  |  1 -
 rpcs3/Emu/Memory/vm_var.h                  |  5 ++
 rpcs3/Emu/SysCalls/Modules/cellAudio.cpp   | 26 ++++----
 rpcs3/Emu/SysCalls/Modules/cellFont.cpp    | 10 +--
 rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp  | 10 +--
 rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp  | 10 +--
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp    | 14 ++--
 rpcs3/Emu/SysCalls/Modules/cellPamf.cpp    | 20 +++---
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp  | 10 +--
 rpcs3/Emu/SysCalls/Modules/cellRtc.cpp     | 20 +++---
 rpcs3/Emu/SysCalls/Modules/libmixer.cpp    | 12 ++--
 rpcs3/Emu/SysCalls/Modules/sceNp.cpp       |  2 +-
 rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp |  6 +-
 rpcs3/Emu/SysCalls/Modules/sys_fs.cpp      | 12 ++--
 rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp           | 74 +++++++++++-----------
 rpcs3/Emu/SysCalls/lv2/lv2Fs.h             | 22 +++----
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp  | 24 +++----
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.h    |  6 +-
 rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp  | 18 +++---
 rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h    |  6 +-
 rpcs3/Emu/SysCalls/lv2/sys_spu.cpp         | 30 ++++-----
 rpcs3/Emu/SysCalls/lv2/sys_spu.h           |  8 +--
 22 files changed, 177 insertions(+), 169 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index dc390520fe..bbd1d39b47 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -769,7 +769,6 @@ public:
 };
 
 typedef mem_t<u32, u32> mem32_t;
-typedef mem_t<u64, u32> mem64_t;
 
 #include "vm.h"
 
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index 39467e3b10..bb48bf5096 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -105,6 +105,11 @@ namespace vm
 			return addr();
 		}
 		*/
+
+		template<typename AT> operator ptr<T, 1, AT>() const
+		{
+			return ptr<T, 1, AT>::make(m_addr);
+		}
 		
 		operator T&()
 		{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
index 0797bccc30..abbdef18ad 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
@@ -387,17 +387,17 @@ int cellAudioInit()
 				{
 					std::lock_guard<std::mutex> lock(audioMutex);
 					// update indexes:
+					auto indexes = vm::ptr<be_t<u64>>::make(m_config.m_indexes);
 					for (u32 i = 0; i < m_config.AUDIO_PORT_COUNT; i++)
 					{
 						if (!m_config.m_ports[i].m_is_audio_port_started) continue;
 
 						AudioPortConfig& port = m_config.m_ports[i];
-						mem64_t index(m_config.m_indexes + i * sizeof(u64));
 
 						u32 position = port.tag % port.block; // old value
 						port.counter = m_config.counter;
 						port.tag++; // absolute index of block that will be read
-						index = (position + 1) % port.block; // write new value
+						indexes[i] = (position + 1) % port.block; // write new value
 					}
 					// load keys:
 					keys.resize(m_config.m_keys.size());
@@ -659,9 +659,9 @@ int cellAudioPortStop(u32 portNum)
 	return CELL_OK;
 }
 
-int cellAudioGetPortTimestamp(u32 portNum, u64 tag, mem64_t stamp)
+int cellAudioGetPortTimestamp(u32 portNum, u64 tag, vm::ptr<be_t<u64>> stamp)
 {
-	cellAudio->Log("cellAudioGetPortTimestamp(portNum=0x%x, tag=0x%llx, stamp_addr=0x%x)", portNum, tag, stamp.GetAddr());
+	cellAudio->Log("cellAudioGetPortTimestamp(portNum=0x%x, tag=0x%llx, stamp_addr=0x%x)", portNum, tag, stamp.addr());
 
 	if (portNum >= m_config.AUDIO_PORT_COUNT) 
 	{
@@ -682,14 +682,14 @@ int cellAudioGetPortTimestamp(u32 portNum, u64 tag, mem64_t stamp)
 
 	std::lock_guard<std::mutex> lock(audioMutex);
 
-	stamp = m_config.start_time + (port.counter + (tag - port.tag)) * 256000000 / 48000;
+	*stamp = m_config.start_time + (port.counter + (tag - port.tag)) * 256000000 / 48000;
 
 	return CELL_OK;
 }
 
-int cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, mem64_t tag)
+int cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, vm::ptr<be_t<u64>> tag)
 {
-	cellAudio->Log("cellAudioGetPortBlockTag(portNum=0x%x, blockNo=0x%llx, tag_addr=0x%x)", portNum, blockNo, tag.GetAddr());
+	cellAudio->Log("cellAudioGetPortBlockTag(portNum=0x%x, blockNo=0x%llx, tag_addr=0x%x)", portNum, blockNo, tag.addr());
 
 	if (portNum >= m_config.AUDIO_PORT_COUNT) 
 	{
@@ -726,7 +726,7 @@ int cellAudioGetPortBlockTag(u32 portNum, u64 blockNo, mem64_t tag)
 	{
 		tag_base &= ~(port.block-1);
 	}
-	tag = tag_base + blockNo;
+	*tag = tag_base + blockNo;
 
 	return CELL_OK;
 }
@@ -738,9 +738,9 @@ int cellAudioSetPortLevel(u32 portNum, float level)
 }
 
 // Utility Functions  
-int cellAudioCreateNotifyEventQueue(mem32_t id, mem64_t key)
+int cellAudioCreateNotifyEventQueue(mem32_t id, vm::ptr<be_t<u64>> key)
 {
-	cellAudio->Warning("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.GetAddr(), key.GetAddr());
+	cellAudio->Warning("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.GetAddr(), key.addr());
 
 	std::lock_guard<std::mutex> lock(audioMutex);
 
@@ -761,14 +761,14 @@ int cellAudioCreateNotifyEventQueue(mem32_t id, mem64_t key)
 	}
 
 	id = cellAudio->GetNewId(eq);
-	key = event_key;
+	*key = event_key;
 
 	return CELL_OK;
 }
 
-int cellAudioCreateNotifyEventQueueEx(mem32_t id, mem64_t key, u32 iFlags)
+int cellAudioCreateNotifyEventQueueEx(mem32_t id, vm::ptr<be_t<u64>> key, u32 iFlags)
 {
-	cellAudio->Todo("cellAudioCreateNotifyEventQueueEx(id_addr=0x%x, key_addr=0x%x, iFlags=0x%x)", id.GetAddr(), key.GetAddr(), iFlags);
+	cellAudio->Todo("cellAudioCreateNotifyEventQueueEx(id_addr=0x%x, key_addr=0x%x, iFlags=0x%x)", id.GetAddr(), key.addr(), iFlags);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index 8bde346aaa..28e4e66a85 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -34,7 +34,7 @@ int cellFontInitializeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontConfig>
 	return CELL_FONT_OK;
 }
 
-int cellFontGetRevisionFlags(mem64_t revisionFlags)
+int cellFontGetRevisionFlags(vm::ptr<be_t<u64>> revisionFlags)
 {
 	UNIMPLEMENTED_FUNC(cellFont);
 	return CELL_FONT_OK;
@@ -44,10 +44,10 @@ int cellFontInit(mem_ptr_t<CellFontConfig> config)
 {
 	cellFont->Log("cellFontInit(config=0x%x)", config.GetAddr());
 
-	vm::var<u64> revisionFlags;
+	vm::var<be_t<u64>> revisionFlags;
 	revisionFlags.value() = 0;
-	cellFontGetRevisionFlags(revisionFlags.addr());
-	return cellFontInitializeWithRevision(revisionFlags, config.GetAddr());
+	cellFontGetRevisionFlags(revisionFlags);
+	return cellFontInitializeWithRevision(revisionFlags.value(), config.GetAddr());
 }
 
 int cellFontEnd()
@@ -183,7 +183,7 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
 
 	vm::var<const char> f((u32)file.length() + 1, 1);
 	Memory.WriteString(f.addr(), file);
-	int ret = cellFontOpenFontFile(library.GetAddr(), vm::ptr<const char>::make(f.addr()), 0, 0, font.GetAddr()); //TODO: Find the correct values of subNum, uniqueId
+	int ret = cellFontOpenFontFile(library.GetAddr(), f, 0, 0, font.GetAddr()); //TODO: Find the correct values of subNum, uniqueId
 	font->origin = CELL_FONT_OPEN_FONTSET;
 	return ret;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
index 1b7aa846eb..a8acef4722 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
@@ -83,8 +83,8 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellGifDecInfo
 		break;
 
 	case se32(CELL_GIFDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
-		cellFsRead(fd, buffer.addr(), buffer.size(), nread.addr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
+		cellFsRead(fd, buffer.addr(), buffer.size(), nread);
 		break;
 	}
 
@@ -156,7 +156,7 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 
 	//Copy the GIF file to a buffer
 	vm::var<unsigned char[]> gif((u32)fileSize);
-	vm::var<u64> pos, nread;
+	vm::var<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
@@ -165,8 +165,8 @@ int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 		break;
 
 	case se32(CELL_GIFDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
-		cellFsRead(fd, gif.addr(), gif.size(), nread.addr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
+		cellFsRead(fd, gif.addr(), gif.size(), nread);
 		break;
 	}
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
index 14210919a2..0a903f58ed 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
@@ -103,8 +103,8 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo
 		break;
 
 	case se32(CELL_JPGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
-		cellFsRead(fd, buffer.addr(), buffer.size(), nread.addr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
+		cellFsRead(fd, buffer.addr(), buffer.size(), nread);
 		break;
 	}
 
@@ -163,7 +163,7 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 
 	//Copy the JPG file to a buffer
 	vm::var<unsigned char[]> jpg((u32)fileSize);
-	vm::var<u64> pos, nread;
+	vm::var<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
@@ -172,8 +172,8 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 		break;
 
 	case se32(CELL_JPGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
-		cellFsRead(fd, jpg.addr(), jpg.size(), nread.addr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
+		cellFsRead(fd, jpg.addr(), jpg.size(), nread);
 		break;
 	}
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index 24b5f3f0a5..e4ae101ced 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -18,24 +18,24 @@
 //Module cellL10n(0x001e, cellL10n_init);
 Module *cellL10n = nullptr;
 
-int UTF16stoUTF8s(vm::ptr<const be_t<u16>> utf16, mem64_t utf16_len, vm::ptr<char> utf8, mem64_t utf8_len)
+int UTF16stoUTF8s(vm::ptr<const char16_t> utf16, vm::ptr<be_t<u32>> utf16_len, vm::ptr<char> utf8, vm::ptr<be_t<u32>> utf8_len)
 {
 	cellL10n->Warning("UTF16stoUTF8s(utf16_addr=0x%x, utf16_len_addr=0x%x, utf8_addr=0x%x, utf8_len_addr=0x%x)",
-		utf16.addr(), utf16_len.GetAddr(), utf8.addr(), utf8_len.GetAddr());
+		utf16.addr(), utf16_len.addr(), utf8.addr(), utf8_len.addr());
 
-	std::u16string wstr =(char16_t*)utf16.get_ptr();
-	wstr.resize(utf16_len.GetValue()); // TODO: Is this really the role of utf16_len in this function?
+	std::u16string wstr = utf16.get_ptr(); // ???
+	wstr.resize(*utf16_len); // TODO: Is this really the role of utf16_len in this function?
 #ifdef _MSC_VER
 	std::wstring_convert<std::codecvt_utf8_utf16<char16_t>,char16_t> convert;
 	std::string str = convert.to_bytes(wstr);
 
-	if (utf8_len.GetValue() < str.size())
+	if (*utf8_len < str.size())
 	{
-		utf8_len = str.size();
+		*utf8_len = str.size();
 		return DSTExhausted;
 	}
 
-	utf8_len = str.size();
+	*utf8_len = str.size();
 	Memory.WriteString(utf8.addr(), str);
 #endif
 	return ConversionOK;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
index 370b475dd9..d479ea8dde 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
@@ -124,41 +124,41 @@ u8 pamfGetStreamChannel(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
 
 }
 
-int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, mem64_t pSize)
+int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_t<u64>> pSize)
 {
-	cellPamf->Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, pSize.GetAddr());
+	cellPamf->Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, pSize.addr());
 
 	//if ((u32)pAddr->magic != 0x464d4150)
 		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
 	const u64 offset = (u64)pAddr->data_offset << 11;
-	pSize = offset;
+	*pSize = offset;
 	return CELL_OK;
 }
 
-int cellPamfGetHeaderSize2(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attribute, mem64_t pSize)
+int cellPamfGetHeaderSize2(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attribute, vm::ptr<be_t<u64>> pSize)
 {
-	cellPamf->Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, attribute, pSize.GetAddr());
+	cellPamf->Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, attribute, pSize.addr());
 
 	//if ((u32)pAddr->magic != 0x464d4150)
 		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
 	const u64 offset = (u64)pAddr->data_offset << 11;
-	pSize = offset;
+	*pSize = offset;
 	return CELL_OK;
 }
 
-int cellPamfGetStreamOffsetAndSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, mem64_t pOffset, mem64_t pSize)
+int cellPamfGetStreamOffsetAndSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_t<u64>> pOffset, vm::ptr<be_t<u64>> pSize)
 {
-	cellPamf->Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, pOffset.GetAddr(), pSize.GetAddr());
+	cellPamf->Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, pOffset.addr(), pSize.addr());
 
 	//if ((u32)pAddr->magic != 0x464d4150)
 		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
 	const u64 offset = (u64)pAddr->data_offset << 11;
-	pOffset = offset;
+	*pOffset = offset;
 	const u64 size = (u64)pAddr->data_size << 11;
-	pSize = size;
+	*pSize = size;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index b68f9c4fa4..dfd8f4d2f5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -143,8 +143,8 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo
 		memmove(Memory + buffer.addr(), Memory + subHandle_data->src.streamPtr.ToLE(), buffer.size());
 		break;
 	case se32(CELL_PNGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
-		cellFsRead(fd, buffer.addr(), buffer.size(), nread.addr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
+		cellFsRead(fd, buffer.addr(), buffer.size(), nread);
 		break;
 	}
 
@@ -200,7 +200,7 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 
 	//Copy the PNG file to a buffer
 	vm::var<unsigned char[]> png((u32)fileSize);
-	vm::var<u64> pos, nread;
+	vm::var<be_t<u64>> pos, nread;
 
 	switch(subHandle_data->src.srcSelect.ToBE())
 	{
@@ -209,8 +209,8 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 		break;
 
 	case se32(CELL_PNGDEC_FILE):
-		cellFsLseek(fd, 0, CELL_SEEK_SET, pos.addr());
-		cellFsRead(fd, png.addr(), png.size(), nread.addr());
+		cellFsLseek(fd, 0, CELL_SEEK_SET, pos);
+		cellFsRead(fd, png.addr(), png.size(), nread);
 		break;
 	}
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
index cdecda0d8d..dacc5c65ad 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
@@ -9,14 +9,16 @@
 //Module cellRtc(0x0009, cellRtc_init);
 Module *cellRtc = nullptr;
 
-long convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years)
+s64 convertToUNIXTime(u16 seconds, u16 minutes, u16 hours, u16 days, int years)
 {
-	return (seconds + minutes*60 + hours*3600 + days*86400 + (years-70)*31536000 + ((years-69)/4)*86400 - ((years-1)/100)*86400 + ((years+299)/400)*86400);
+	return (s64)seconds + (s64)minutes * 60 + (s64)hours * 3600 + (s64)days * 86400 + 
+		(s64)(years - 70) * 31536000 + (s64)((years - 69) / 4) * 86400 -
+		(s64)((years - 1) / 100) * 86400 + (s64)((years + 299) / 400) * 86400;
 }
 
 u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int years)
 {
-	long unixtime = convertToUNIXTime(seconds, minutes, hours, days, years);
+	s64 unixtime = convertToUNIXTime(seconds, minutes, hours, days, years);
 	u64 win32time = u64(unixtime) * u64(10000000) + u64(116444736000000000);
 	u64 win32filetime = win32time | win32time >> 32;
 	return win32filetime;
@@ -323,25 +325,25 @@ int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem32_t puiDosTime)
 	return CELL_OK;
 }
 
-int cellRtcGetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, mem64_t piTime)
+int cellRtcGetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<s64>> piTime)
 {
-	cellRtc->Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.GetAddr(), piTime.GetAddr());
+	cellRtc->Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.GetAddr(), piTime.addr());
 
 	// Convert to POSIX time_t.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
-	piTime = convertToUNIXTime(date_time.GetSecond(rDateTime::TZ::UTC), date_time.GetMinute(rDateTime::TZ::UTC),
+	*piTime = convertToUNIXTime(date_time.GetSecond(rDateTime::TZ::UTC), date_time.GetMinute(rDateTime::TZ::UTC),
 		date_time.GetHour(rDateTime::TZ::UTC), date_time.GetDay(rDateTime::TZ::UTC), date_time.GetYear(rDateTime::TZ::UTC));
 
 	return CELL_OK;
 }
 
-int cellRtcGetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem64_t pulWin32FileTime)
+int cellRtcGetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<u64>> pulWin32FileTime)
 {
-	cellRtc->Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.GetAddr(), pulWin32FileTime.GetAddr());
+	cellRtc->Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.GetAddr(), pulWin32FileTime.addr());
 
 	// Convert to WIN32 FILETIME.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
-	pulWin32FileTime = convertToWin32FILETIME(date_time.GetSecond(rDateTime::TZ::UTC), date_time.GetMinute(rDateTime::TZ::UTC),
+	*pulWin32FileTime = convertToWin32FILETIME(date_time.GetSecond(rDateTime::TZ::UTC), date_time.GetMinute(rDateTime::TZ::UTC),
 		date_time.GetHour(rDateTime::TZ::UTC), date_time.GetDay(rDateTime::TZ::UTC), date_time.GetYear(rDateTime::TZ::UTC));
 
 	return CELL_OK;
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index 3380f00c31..8e8cc73628 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -574,19 +574,19 @@ int cellSurMixerPause(u32 type)
 	return CELL_OK;
 }
 
-int cellSurMixerGetCurrentBlockTag(mem64_t tag)
+int cellSurMixerGetCurrentBlockTag(vm::ptr<be_t<u64>> tag)
 {
-	libmixer->Log("cellSurMixerGetCurrentBlockTag(tag_addr=0x%x)", tag.GetAddr());
+	libmixer->Log("cellSurMixerGetCurrentBlockTag(tag_addr=0x%x)", tag.addr());
 
-	tag = mixcount;
+	*tag = mixcount;
 	return CELL_OK;
 }
 
-int cellSurMixerGetTimestamp(u64 tag, mem64_t stamp)
+int cellSurMixerGetTimestamp(u64 tag, vm::ptr<be_t<u64>> stamp)
 {
-	libmixer->Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp_addr=0x%x)", tag, stamp.GetAddr());
+	libmixer->Log("cellSurMixerGetTimestamp(tag=0x%llx, stamp_addr=0x%x)", tag, stamp.addr());
 
-	stamp = m_config.start_time + (tag) * 256000000 / 48000; // ???
+	*stamp = m_config.start_time + (tag) * 256000000 / 48000; // ???
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNp.cpp b/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
index baf395453e..55d41b82c6 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
@@ -177,7 +177,7 @@ int sceNpDrmExecuteGamePurchase()
 	return CELL_OK;
 }
 
-int sceNpDrmGetTimelimit(u32 drm_path_addr, mem64_t time_remain_usec)
+int sceNpDrmGetTimelimit(u32 drm_path_addr, vm::ptr<be_t<u64>> time_remain_usec)
 {
 	UNIMPLEMENTED_FUNC(sceNp);
 	return CELL_OK;
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
index 71b560cc93..e5323b3dbf 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
@@ -213,10 +213,10 @@ int sceNpTrophySetSoundLevel()
 	return CELL_OK;
 }
 
-int sceNpTrophyGetRequiredDiskSpace(u32 context, u32 handle, mem64_t reqspace, u64 options)
+int sceNpTrophyGetRequiredDiskSpace(u32 context, u32 handle, vm::ptr<be_t<u64>> reqspace, u64 options)
 {
 	sceNpTrophy->Warning("sceNpTrophyGetRequiredDiskSpace(context=%d, handle=%d, reqspace_addr=0x%x, options=0x%llx)",
-		context, handle, reqspace.GetAddr(), options);
+		context, handle, reqspace.addr(), options);
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -228,7 +228,7 @@ int sceNpTrophyGetRequiredDiskSpace(u32 context, u32 handle, mem64_t reqspace, u
 	if (!ctxt.trp_stream)
 		return SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST;
 
-	reqspace = ctxt.trp_stream->GetSize(); // TODO: This is not accurate. It's just an approximation of the real value
+	*reqspace = ctxt.trp_stream->GetSize(); // TODO: This is not accurate. It's just an approximation of the real value
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
index cc57857717..e1bcc7956e 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
@@ -250,20 +250,20 @@ int cellFsAioFinish(vm::ptr<const char> mount_point)
 	return CELL_OK;
 }
 
-int cellFsReadWithOffset(u32 fd, u64 offset, u32 buf_addr, u64 buffer_size, mem64_t nread)
+int cellFsReadWithOffset(u32 fd, u64 offset, u32 buf_addr, u64 buffer_size, vm::ptr<be_t<u64>> nread)
 {
 	sys_fs->Warning("cellFsReadWithOffset(fd=%d, offset=0x%llx, buf_addr=0x%x, buffer_size=%lld nread=0x%llx)",
-		fd, offset, buf_addr, buffer_size, nread.GetAddr());
+		fd, offset, buf_addr, buffer_size, nread.addr());
 
 	int ret;
 	vm::var<be_t<u64>> oldPos, newPos;
-	ret = cellFsLseek(fd, 0, CELL_SEEK_CUR, oldPos.addr());       // Save the current position
+	ret = cellFsLseek(fd, 0, CELL_SEEK_CUR, oldPos);       // Save the current position
 	if (ret) return ret;
-	ret = cellFsLseek(fd, offset, CELL_SEEK_SET, newPos.addr());  // Move to the specified offset
+	ret = cellFsLseek(fd, offset, CELL_SEEK_SET, newPos);  // Move to the specified offset
 	if (ret) return ret;
-	ret = cellFsRead(fd, buf_addr, buffer_size, nread.GetAddr());    // Read the file
+	ret = cellFsRead(fd, buf_addr, buffer_size, nread);    // Read the file
 	if (ret) return ret;
-	ret = cellFsLseek(fd, oldPos.value(), CELL_SEEK_SET, newPos.addr());  // Return to the old position
+	ret = cellFsLseek(fd, oldPos.value(), CELL_SEEK_SET, newPos);  // Return to the old position
 	if (ret) return ret;
 
 	return CELL_OK;
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
index d529dd3e7b..f5849685bd 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
@@ -115,10 +115,10 @@ s32 cellFsOpen(u32 path_addr, s32 flags, mem32_t fd, mem32_t arg, u64 size)
 	return CELL_OK;
 }
 
-s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nread)
+s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nread)
 {
 	sys_fs->Log("cellFsRead(fd=%d, buf_addr=0x%x, nbytes=0x%llx, nread_addr=0x%x)",
-		fd, buf_addr, nbytes, nread.GetAddr());
+		fd, buf_addr, nbytes, nread.addr());
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
 
@@ -128,15 +128,15 @@ s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nread)
 
 	const u64 res = nbytes ? file->Read(Memory.GetMemFromAddr(buf_addr), nbytes) : 0;
 
-	if (nread.GetAddr()) nread = res; // write value if not NULL
+	if (nread) *nread = res;
 
 	return CELL_OK;
 }
 
-s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nwrite)
+s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nwrite)
 {
 	sys_fs->Log("cellFsWrite(fd=%d, buf_addr=0x%x, nbytes=0x%llx, nwrite_addr=0x%x)",
-		fd, buf_addr, nbytes, nwrite.GetAddr());
+		fd, buf_addr, nbytes, nwrite.addr());
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
 
@@ -146,7 +146,7 @@ s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nwrite)
 
 	const u64 res = nbytes ? file->Write(Memory.GetMemFromAddr(buf_addr), nbytes) : 0;
 
-	if (nwrite.GetAddr()) nwrite = res; // write value if not NULL
+	if (nwrite) *nwrite = res;
 
 	return CELL_OK;
 }
@@ -177,9 +177,9 @@ s32 cellFsOpendir(u32 path_addr, mem32_t fd)
 	return CELL_OK;
 }
 
-s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, mem64_t nread)
+s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, vm::ptr<be_t<u64>> nread)
 {
-	sys_fs->Log("cellFsReaddir(fd=%d, dir_addr=0x%x, nread_addr=0x%x)", fd, dir.GetAddr(), nread.GetAddr());
+	sys_fs->Log("cellFsReaddir(fd=%d, dir_addr=0x%x, nread_addr=0x%x)", fd, dir.GetAddr(), nread.addr());
 
 	vfsDirBase* directory;
 	if(!sys_fs->CheckId(fd, directory))
@@ -188,14 +188,14 @@ s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, mem64_t nread)
 	const DirEntryInfo* info = directory->Read();
 	if(info)
 	{
-		nread = 1;
+		*nread = 1;
 		Memory.WriteString(dir.GetAddr()+2, info->name);
 		dir->d_namlen = info->name.length();
 		dir->d_type = (info->flags & DirEntry_TypeFile) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
 	}
 	else
 	{
-		nread = 0;
+		*nread = 0;
 	}
 
 	return CELL_OK;
@@ -378,10 +378,10 @@ s32 cellFsUnlink(u32 path_addr)
 	return CELL_OK;
 }
 
-s32 cellFsLseek(u32 fd, s64 offset, u32 whence, mem64_t pos)
+s32 cellFsLseek(u32 fd, s64 offset, u32 whence, vm::ptr<be_t<u64>> pos)
 {
 	vfsSeekMode seek_mode;
-	sys_fs->Log("cellFsLseek(fd=%d, offset=0x%llx, whence=0x%x, pos_addr=0x%x)", fd, offset, whence, pos.GetAddr());
+	sys_fs->Log("cellFsLseek(fd=%d, offset=0x%llx, whence=0x%x, pos_addr=0x%x)", fd, offset, whence, pos.addr());
 	switch(whence)
 	{
 	case CELL_SEEK_SET: seek_mode = vfsSeekSet; break;
@@ -397,7 +397,7 @@ s32 cellFsLseek(u32 fd, s64 offset, u32 whence, mem64_t pos)
 	if (!sys_fs->CheckId(fd, file, type) || type != TYPE_FS_FILE) {
 		return CELL_ESRCH;
 	}
-	pos = file->Seek(offset, seek_mode);
+	*pos = file->Seek(offset, seek_mode);
 	return CELL_OK;
 }
 
@@ -461,41 +461,43 @@ s32 cellFsTruncate(u32 path_addr, u64 size)
 	return CELL_OK;
 }
 
-s32 cellFsFGetBlockSize(u32 fd, mem64_t sector_size, mem64_t block_size)
+s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size)
 {
-	sys_fs->Log("cellFsFGetBlockSize(fd=%d, sector_size_addr: 0x%x, block_size_addr: 0x%x)", fd, sector_size.GetAddr(), block_size.GetAddr());
+	sys_fs->Log("cellFsFGetBlockSize(fd=%d, sector_size_addr: 0x%x, block_size_addr: 0x%x)",
+		fd, sector_size.addr(), block_size.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
 
-	sector_size = 4096; // ?
-	block_size = 4096; // ?
+	*sector_size = 4096; // ?
+	*block_size = 4096; // ?
 
 	return CELL_OK;
 }
 
-s32 cellFsGetBlockSize(u32 path_addr, mem64_t sector_size, mem64_t block_size)
+s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size)
 {
-	sys_fs->Log("cellFsGetBlockSize(file: %s, sector_size_addr: 0x%x, block_size_addr: 0x%x)", Memory.ReadString(path_addr).c_str(), sector_size.GetAddr(), block_size.GetAddr());
+	sys_fs->Log("cellFsGetBlockSize(file: %s, sector_size_addr: 0x%x, block_size_addr: 0x%x)",
+		Memory.ReadString(path_addr).c_str(), sector_size.addr(), block_size.addr());
 
-	sector_size = 4096; // ?
-	block_size = 4096; // ?
+	*sector_size = 4096; // ?
+	*block_size = 4096; // ?
 
 	return CELL_OK;
 }
 
-s32 cellFsGetFreeSize(u32 path_addr, mem32_t block_size, mem64_t block_count)
+s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count)
 {
 	const std::string& ps3_path = Memory.ReadString(path_addr);
 	sys_fs->Warning("cellFsGetFreeSize(path=\"%s\", block_size_addr=0x%x, block_count_addr=0x%x)",
-		ps3_path.c_str(), block_size.GetAddr(), block_count.GetAddr());
+		ps3_path.c_str(), block_size.addr(), block_count.addr());
 
 	if (ps3_path.empty())
 		return CELL_EINVAL;
 
 	// TODO: Get real values. Currently, it always returns 40 GB of free space divided in 4 KB blocks
-	block_size = 4096; // ?
-	block_count = 10485760; // ?
+	*block_size = 4096; // ?
+	*block_count = 10485760; // ?
 
 	return CELL_OK;
 }
@@ -585,26 +587,26 @@ s32 cellFsStReadGetRingBuf(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf)
 	return CELL_OK;
 }
 
-s32 cellFsStReadGetStatus(u32 fd, mem64_t status)
+s32 cellFsStReadGetStatus(u32 fd, vm::ptr<be_t<u64>> status)
 {
-	sys_fs->Warning("cellFsStReadGetRingBuf(fd=%d, status_addr=0x%x)", fd, status.GetAddr());
+	sys_fs->Warning("cellFsStReadGetRingBuf(fd=%d, status_addr=0x%x)", fd, status.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
 
-	status = fs_config.m_fs_status;
+	*status = fs_config.m_fs_status;
 
 	return CELL_OK;
 }
 
-s32 cellFsStReadGetRegid(u32 fd, mem64_t regid)
+s32 cellFsStReadGetRegid(u32 fd, vm::ptr<be_t<u64>> regid)
 {
-	sys_fs->Warning("cellFsStReadGetRingBuf(fd=%d, regid_addr=0x%x)", fd, regid.GetAddr());
+	sys_fs->Warning("cellFsStReadGetRingBuf(fd=%d, regid_addr=0x%x)", fd, regid.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
 
-	regid = fs_config.m_regid;
+	*regid = fs_config.m_regid;
 
 	return CELL_OK;
 }
@@ -634,22 +636,22 @@ s32 cellFsStReadStop(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, mem64_t rsize)
+s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, vm::ptr<be_t<u64>> rsize)
 {
-	sys_fs->Todo("cellFsStRead(fd=%d, buf_addr=0x%x, size=0x%llx, rsize_addr = 0x%x)", fd, buf_addr, size, rsize.GetAddr());
+	sys_fs->Todo("cellFsStRead(fd=%d, buf_addr=0x%x, size=0x%llx, rsize_addr = 0x%x)", fd, buf_addr, size, rsize.addr());
 	
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
 
 	fs_config.m_regid += size;
-	rsize = fs_config.m_regid;
+	*rsize = fs_config.m_regid;
 
 	return CELL_OK;
 }
 
-s32 cellFsStReadGetCurrentAddr(u32 fd, mem32_t addr_addr, mem64_t size)
+s32 cellFsStReadGetCurrentAddr(u32 fd, mem32_t addr_addr, vm::ptr<be_t<u64>> size)
 {
-	sys_fs->Todo("cellFsStReadGetCurrentAddr(fd=%d, addr_addr=0x%x, size_addr = 0x%x)", fd, addr_addr.GetAddr(), size.GetAddr());
+	sys_fs->Todo("cellFsStReadGetCurrentAddr(fd=%d, addr_addr=0x%x, size_addr = 0x%x)", fd, addr_addr.GetAddr(), size.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
index d1f299e1b3..0034f1387b 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
@@ -125,11 +125,11 @@ struct CellFsRingBuffer
 
 // SysCalls
 s32 cellFsOpen(u32 path_addr, s32 flags, mem32_t fd, mem32_t arg, u64 size);
-s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nread);
-s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, mem64_t nwrite);
+s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nread);
+s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nwrite);
 s32 cellFsClose(u32 fd);
 s32 cellFsOpendir(u32 path_addr, mem32_t fd);
-s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, mem64_t nread);
+s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, vm::ptr<be_t<u64>> nread);
 s32 cellFsClosedir(u32 fd);
 s32 cellFsStat(u32 path_addr, mem_ptr_t<CellFsStat> sb);
 s32 cellFsFstat(u32 fd, mem_ptr_t<CellFsStat> sb);
@@ -139,22 +139,22 @@ s32 cellFsChmod(u32 path_addr, u32 mode);
 s32 cellFsFsync(u32 fd);
 s32 cellFsRmdir(u32 path_addr);
 s32 cellFsUnlink(u32 path_addr);
-s32 cellFsLseek(u32 fd, s64 offset, u32 whence, mem64_t pos);
+s32 cellFsLseek(u32 fd, s64 offset, u32 whence, vm::ptr<be_t<u64>> pos);
 s32 cellFsFtruncate(u32 fd, u64 size);
 s32 cellFsTruncate(u32 path_addr, u64 size);
-s32 cellFsFGetBlockSize(u32 fd, mem64_t sector_size, mem64_t block_size);
-s32 cellFsGetBlockSize(u32 path_addr, mem64_t sector_size, mem64_t block_size);
-s32 cellFsGetFreeSize(u32 path_addr, mem32_t block_size, mem64_t block_count);
+s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
+s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
+s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count);
 s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, mem32_t data_count);
 s32 cellFsStReadInit(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf);
 s32 cellFsStReadFinish(u32 fd);
 s32 cellFsStReadGetRingBuf(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf);
-s32 cellFsStReadGetStatus(u32 fd, mem64_t status);
-s32 cellFsStReadGetRegid(u32 fd, mem64_t regid);
+s32 cellFsStReadGetStatus(u32 fd, vm::ptr<be_t<u64>> status);
+s32 cellFsStReadGetRegid(u32 fd, vm::ptr<be_t<u64>> regid);
 s32 cellFsStReadStart(u32 fd, u64 offset, u64 size);
 s32 cellFsStReadStop(u32 fd);
-s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, mem64_t rsize);
-s32 cellFsStReadGetCurrentAddr(u32 fd, mem32_t addr_addr, mem64_t size);
+s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, vm::ptr<be_t<u64>> rsize);
+s32 cellFsStReadGetCurrentAddr(u32 fd, mem32_t addr_addr, vm::ptr<be_t<u64>> size);
 s32 cellFsStReadPutCurrentAddr(u32 fd, u32 addr_addr, u64 size);
 s32 cellFsStReadWait(u32 fd, u64 size);
 s32 cellFsStReadWaitCallback(u32 fd, u64 size, mem_func_ptr_t<void (*)(int xfd, u64 xsize)> func);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
index 550420d13a..d0e94c08a0 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
@@ -88,12 +88,12 @@ s32 sys_event_flag_destroy(u32 eflag_id)
 	return CELL_OK;
 }
 
-s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64 timeout)
+s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result, u64 timeout)
 {
 	sys_event_flag.Log("sys_event_flag_wait(eflag_id=%d, bitptn=0x%llx, mode=0x%x, result_addr=0x%x, timeout=%lld)",
-		eflag_id, bitptn, mode, result.GetAddr(), timeout);
+		eflag_id, bitptn, mode, result.addr(), timeout);
 
-	if (result.GetAddr()) result = 0;
+	if (result) *result = 0;
 
 	switch (mode & 0xf)
 	{
@@ -142,7 +142,7 @@ s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 				ef->flags = 0;
 			}
 
-			if (result.GetAddr()) result = flags;
+			if (result) *result = flags;
 
 			return CELL_OK;
 		}
@@ -185,7 +185,7 @@ s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 						ef->signal.unlock(tid);
 					}
 
-					if (result.GetAddr()) result = flags;
+					if (result) *result = flags;
 
 					return CELL_OK;
 				}
@@ -220,12 +220,12 @@ s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64
 	}
 }
 
-s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result)
+s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result)
 {
 	sys_event_flag.Log("sys_event_flag_trywait(eflag_id=%d, bitptn=0x%llx, mode=0x%x, result_addr=0x%x)",
-		eflag_id, bitptn, mode, result.GetAddr());
+		eflag_id, bitptn, mode, result.addr());
 
-	if (result.GetAddr()) result = 0;
+	if (result) *result = 0;
 
 	switch (mode & 0xf)
 	{
@@ -261,7 +261,7 @@ s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result)
 			ef->flags = 0;
 		}
 
-		if (result.GetAddr()) result = flags;
+		if (result) *result = flags;
 
 		return CELL_OK;
 	}
@@ -342,15 +342,15 @@ s32 sys_event_flag_cancel(u32 eflag_id, mem32_t num)
 	return CELL_OK;
 }
 
-s32 sys_event_flag_get(u32 eflag_id, mem64_t flags)
+s32 sys_event_flag_get(u32 eflag_id, vm::ptr<be_t<u64>> flags)
 {
-	sys_event_flag.Log("sys_event_flag_get(eflag_id=%d, flags_addr=0x%x)", eflag_id, flags.GetAddr());
+	sys_event_flag.Log("sys_event_flag_get(eflag_id=%d, flags_addr=0x%x)", eflag_id, flags.addr());
 
 	EventFlag* ef;
 	if (!sys_event_flag.CheckId(eflag_id, ef)) return CELL_ESRCH;
 
 	SMutexLocker lock(ef->m_mutex);
-	flags = ef->flags;
+	*flags = ef->flags;
 
 	return CELL_OK;
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
index f31b04a57f..e7d60605c7 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
@@ -52,9 +52,9 @@ struct EventFlag
 
 s32 sys_event_flag_create(mem32_t eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init);
 s32 sys_event_flag_destroy(u32 eflag_id);
-s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result, u64 timeout);
-s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, mem64_t result);
+s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result, u64 timeout);
+s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result);
 s32 sys_event_flag_set(u32 eflag_id, u64 bitptn);
 s32 sys_event_flag_clear(u32 eflag_id, u64 bitptn);
 s32 sys_event_flag_cancel(u32 eflag_id, mem32_t num);
-s32 sys_event_flag_get(u32 eflag_id, mem64_t flags);
\ No newline at end of file
+s32 sys_event_flag_get(u32 eflag_id, vm::ptr<be_t<u64>> flags);
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
index 875e96acf1..bc9250180e 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
@@ -48,9 +48,9 @@ s32 sys_ppu_thread_yield()
 	return CELL_OK;
 }
 
-s32 sys_ppu_thread_join(u64 thread_id, mem64_t vptr)
+s32 sys_ppu_thread_join(u64 thread_id, vm::ptr<be_t<u64>> vptr)
 {
-	sys_ppu_thread.Warning("sys_ppu_thread_join(thread_id=%lld, vptr_addr=0x%x)", thread_id, vptr.GetAddr());
+	sys_ppu_thread.Warning("sys_ppu_thread_join(thread_id=%lld, vptr_addr=0x%x)", thread_id, vptr.addr());
 
 	CPUThread* thr = Emu.GetCPU().GetThread(thread_id);
 	if(!thr) return CELL_ESRCH;
@@ -65,7 +65,7 @@ s32 sys_ppu_thread_join(u64 thread_id, mem64_t vptr)
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 	}
 
-	vptr = thr->GetExitStatus();
+	*vptr = thr->GetExitStatus();
 	return CELL_OK;
 }
 
@@ -150,13 +150,13 @@ s32 sys_ppu_thread_restart(u64 thread_id)
 	return CELL_OK;
 }
 
-s32 sys_ppu_thread_create(mem64_t thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr)
+s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr)
 {
 	std::string threadname = "";
 	if (threadname_addr) threadname = Memory.ReadString(threadname_addr);
 	
 	sys_ppu_thread.Log("sys_ppu_thread_create(thread_id_addr=0x%x, entry=0x%x, arg=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname_addr=0x%x('%s'))",
-		thread_id.GetAddr(), entry, arg, prio, stacksize, flags, threadname_addr, threadname.c_str());
+		thread_id.addr(), entry, arg, prio, stacksize, flags, threadname_addr, threadname.c_str());
 
 	bool is_joinable = false;
 	bool is_interrupt = false;
@@ -179,7 +179,7 @@ s32 sys_ppu_thread_create(mem64_t thread_id, u32 entry, u64 arg, s32 prio, u32 s
 
 	CPUThread& new_thread = Emu.GetCPU().AddThread(CPU_THREAD_PPU);
 
-	thread_id = new_thread.GetId();
+	*thread_id = new_thread.GetId();
 	new_thread.SetEntry(entry);
 	new_thread.SetArg(0, arg);
 	new_thread.SetPrio(prio);
@@ -211,11 +211,11 @@ void sys_ppu_thread_once(mem_ptr_t<std::atomic<be_t<u32>>> once_ctrl, u32 entry)
 	}
 }
 
-s32 sys_ppu_thread_get_id(mem64_t thread_id)
+s32 sys_ppu_thread_get_id(vm::ptr<be_t<u64>> thread_id)
 {
-	sys_ppu_thread.Log("sys_ppu_thread_get_id(thread_id_addr=0x%x)", thread_id.GetAddr());
+	sys_ppu_thread.Log("sys_ppu_thread_get_id(thread_id_addr=0x%x)", thread_id.addr());
 
-	thread_id = GetCurrentPPUThread().GetId();
+	*thread_id = GetCurrentPPUThread().GetId();
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
index ef1be8cc49..162f627f41 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
@@ -16,7 +16,7 @@ enum ppu_thread_flags : u64
 void sys_ppu_thread_exit(u64 errorcode);
 void sys_internal_ppu_thread_exit(u64 errorcode);
 s32 sys_ppu_thread_yield();
-s32 sys_ppu_thread_join(u64 thread_id, mem64_t vptr);
+s32 sys_ppu_thread_join(u64 thread_id, vm::ptr<be_t<u64>> vptr);
 s32 sys_ppu_thread_detach(u64 thread_id);
 void sys_ppu_thread_get_join_state(u32 isjoinable_addr);
 s32 sys_ppu_thread_set_priority(u64 thread_id, s32 prio);
@@ -24,7 +24,7 @@ s32 sys_ppu_thread_get_priority(u64 thread_id, u32 prio_addr);
 s32 sys_ppu_thread_get_stack_information(u32 info_addr);
 s32 sys_ppu_thread_stop(u64 thread_id);
 s32 sys_ppu_thread_restart(u64 thread_id);
-s32 sys_ppu_thread_create(mem64_t thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr);
+s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr);
 void sys_ppu_thread_once(mem_ptr_t<std::atomic<be_t<u32>>> once_ctrl, u32 entry);
-s32 sys_ppu_thread_get_id(mem64_t thread_id);
+s32 sys_ppu_thread_get_id(vm::ptr<be_t<u64>> thread_id);
 s32 sys_ppu_thread_rename(u64 thread_id, u32 name_addr);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
index a09f70a471..50624a8d5e 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
@@ -527,10 +527,10 @@ s32 sys_spu_thread_write_ls(u32 id, u32 address, u64 value, u32 type)
 }
 
 //182
-s32 sys_spu_thread_read_ls(u32 id, u32 address, mem64_t value, u32 type)
+s32 sys_spu_thread_read_ls(u32 id, u32 address, vm::ptr<be_t<u64>> value, u32 type)
 {
 	sys_spu.Log("sys_spu_thread_read_ls(id=%d, address=0x%x, value_addr=0x%x, type=0x%x)",
-		id, address, value.GetAddr(), type);
+		id, address, value.addr(), type);
 
 	CPUThread* thr = Emu.GetCPU().GetThread(id);
 
@@ -551,10 +551,10 @@ s32 sys_spu_thread_read_ls(u32 id, u32 address, mem64_t value, u32 type)
 
 	switch (type)
 	{
-	case 1: value = (*(SPUThread*)thr).ReadLS8(address); return CELL_OK;
-	case 2: value = (*(SPUThread*)thr).ReadLS16(address); return CELL_OK;
-	case 4: value = (*(SPUThread*)thr).ReadLS32(address); return CELL_OK;
-	case 8: value = (*(SPUThread*)thr).ReadLS64(address); return CELL_OK;
+	case 1: *value = (*(SPUThread*)thr).ReadLS8(address); return CELL_OK;
+	case 2: *value = (*(SPUThread*)thr).ReadLS16(address); return CELL_OK;
+	case 4: *value = (*(SPUThread*)thr).ReadLS32(address); return CELL_OK;
+	case 8: *value = (*(SPUThread*)thr).ReadLS64(address); return CELL_OK;
 	default: return CELL_EINVAL;
 	}
 }
@@ -599,9 +599,9 @@ s32 sys_spu_thread_set_spu_cfg(u32 id, u64 value)
 }
 
 //188
-s32 sys_spu_thread_get_spu_cfg(u32 id, mem64_t value)
+s32 sys_spu_thread_get_spu_cfg(u32 id, vm::ptr<be_t<u64>> value)
 {
-	sys_spu.Warning("sys_spu_thread_get_spu_cfg(id=%d, value_addr=0x%x)", id, value.GetAddr());
+	sys_spu.Warning("sys_spu_thread_get_spu_cfg(id=%d, value_addr=0x%x)", id, value.addr());
 
 	CPUThread* thr = Emu.GetCPU().GetThread(id);
 
@@ -610,7 +610,7 @@ s32 sys_spu_thread_get_spu_cfg(u32 id, mem64_t value)
 		return CELL_ESRCH;
 	}
 
-	value = (*(SPUThread*)thr).cfg.value;
+	*value = (*(SPUThread*)thr).cfg.value;
 
 	return CELL_OK;
 }
@@ -957,9 +957,9 @@ s32 sys_raw_spu_set_int_mask(u32 id, u32 class_id, u64 mask)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_get_int_mask(u32 id, u32 class_id, mem64_t mask)
+s32 sys_raw_spu_get_int_mask(u32 id, u32 class_id, vm::ptr<be_t<u64>> mask)
 {
-	sys_spu.Log("sys_raw_spu_get_int_mask(id=%d, class_id=%d, mask_addr=0x%x)", id, class_id, mask.GetAddr());
+	sys_spu.Log("sys_raw_spu_get_int_mask(id=%d, class_id=%d, mask_addr=0x%x)", id, class_id, mask.addr());
 
 	RawSPUThread* t = Emu.GetCPU().GetRawSPUThread(id);
 	if (!t)
@@ -972,7 +972,7 @@ s32 sys_raw_spu_get_int_mask(u32 id, u32 class_id, mem64_t mask)
 		return CELL_EINVAL;
 	}
 
-	mask = t->m_intrtag[class_id].mask;
+	*mask = t->m_intrtag[class_id].mask;
 	return CELL_OK;
 }
 
@@ -995,9 +995,9 @@ s32 sys_raw_spu_set_int_stat(u32 id, u32 class_id, u64 stat)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, mem64_t stat)
+s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, vm::ptr<be_t<u64>> stat)
 {
-	sys_spu.Log("sys_raw_spu_get_int_stat(id=%d, class_id=%d, stat_addr=0xx)", id, class_id, stat.GetAddr());
+	sys_spu.Log("sys_raw_spu_get_int_stat(id=%d, class_id=%d, stat_addr=0xx)", id, class_id, stat.addr());
 
 	RawSPUThread* t = Emu.GetCPU().GetRawSPUThread(id);
 	if (!t)
@@ -1010,7 +1010,7 @@ s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, mem64_t stat)
 		return CELL_EINVAL;
 	}
 
-	stat = t->m_intrtag[class_id].stat;
+	*stat = t->m_intrtag[class_id].stat;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.h b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
index 2d97c1d54e..7736a51b23 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
@@ -127,10 +127,10 @@ s32 sys_spu_thread_group_disconnect_event(u32 id, u32 et);
 s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, vm::ptr<u8> spup);
 s32 sys_spu_thread_group_disconnect_event_all_threads(u32 id, u8 spup);
 s32 sys_spu_thread_write_ls(u32 id, u32 address, u64 value, u32 type);
-s32 sys_spu_thread_read_ls(u32 id, u32 address, mem64_t value, u32 type);
+s32 sys_spu_thread_read_ls(u32 id, u32 address, vm::ptr<be_t<u64>> value, u32 type);
 s32 sys_spu_thread_write_spu_mb(u32 id, u32 value);
 s32 sys_spu_thread_set_spu_cfg(u32 id, u64 value);
-s32 sys_spu_thread_get_spu_cfg(u32 id, mem64_t value);
+s32 sys_spu_thread_get_spu_cfg(u32 id, vm::ptr<be_t<u64>> value);
 s32 sys_spu_thread_write_snr(u32 id, u32 number, u32 value);
 s32 sys_spu_thread_connect_event(u32 id, u32 eq, u32 et, u8 spup);
 s32 sys_spu_thread_disconnect_event(u32 id, u32 event_type, u8 spup);
@@ -142,9 +142,9 @@ s32 sys_raw_spu_create(mem32_t id, u32 attr_addr);
 s32 sys_raw_spu_destroy(u32 id);
 s32 sys_raw_spu_create_interrupt_tag(u32 id, u32 class_id, u32 hwthread, mem32_t intrtag);
 s32 sys_raw_spu_set_int_mask(u32 id, u32 class_id, u64 mask);
-s32 sys_raw_spu_get_int_mask(u32 id, u32 class_id, mem64_t mask);
+s32 sys_raw_spu_get_int_mask(u32 id, u32 class_id, vm::ptr<be_t<u64>> mask);
 s32 sys_raw_spu_set_int_stat(u32 id, u32 class_id, u64 stat);
-s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, mem64_t stat);
+s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, vm::ptr<be_t<u64>> stat);
 s32 sys_raw_spu_read_puint_mb(u32 id, mem32_t value);
 s32 sys_raw_spu_set_spu_cfg(u32 id, u32 value);
 s32 sys_raw_spu_get_spu_cfg(u32 id, mem32_t value);

From 9501869aa140a6bda33e5a2e763e213de896cc79 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 04:51:48 +0400
Subject: [PATCH 20/36] mem32_t replaced

---
 rpcs3/Emu/Memory/Memory.h                     |   2 -
 rpcs3/Emu/SysCalls/Modules/SC_Pad.cpp         |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellAdec.cpp       |  18 ++--
 rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp      | 100 +++++++++---------
 rpcs3/Emu/SysCalls/Modules/cellAudio.cpp      |  28 ++---
 rpcs3/Emu/SysCalls/Modules/cellDmux.cpp       |  56 +++++-----
 rpcs3/Emu/SysCalls/Modules/cellFont.cpp       |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellGame.cpp       |  26 ++---
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp     |  12 +--
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.h       |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp     |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp     |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp       |  12 +--
 rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp     |  10 +-
 rpcs3/Emu/SysCalls/Modules/cellNetCtl.h       |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp     |  12 +--
 rpcs3/Emu/SysCalls/Modules/cellResc.cpp       |  43 ++++----
 rpcs3/Emu/SysCalls/Modules/cellResc.h         |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellRtc.cpp        |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp      |  28 ++---
 rpcs3/Emu/SysCalls/Modules/cellSync.cpp       |  66 ++++++------
 rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp    |  34 +++---
 .../SysCalls/Modules/cellSysutil_SaveData.cpp |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp   |  16 +--
 rpcs3/Emu/SysCalls/Modules/cellVdec.cpp       |  18 ++--
 rpcs3/Emu/SysCalls/Modules/cellVpost.cpp      |  12 +--
 rpcs3/Emu/SysCalls/Modules/libmixer.cpp       |  18 ++--
 rpcs3/Emu/SysCalls/Modules/sceNp.cpp          |   6 +-
 rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp    |  24 ++---
 rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp  |  12 +--
 rpcs3/Emu/SysCalls/Modules/sys_fs.cpp         |  19 ++--
 rpcs3/Emu/SysCalls/Modules/sys_io.cpp         |   2 +-
 rpcs3/Emu/SysCalls/Modules/sys_net.cpp        |  50 ++++-----
 rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp              |  28 ++---
 rpcs3/Emu/SysCalls/lv2/lv2Fs.h                |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_cond.cpp           |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_cond.h             |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_event.cpp          |  25 ++---
 rpcs3/Emu/SysCalls/lv2/sys_event.h            |  11 +-
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp     |  16 +--
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.h       |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_interrupt.cpp      |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_interrupt.h        |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.cpp         |   9 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.h           |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp        |  12 +--
 rpcs3/Emu/SysCalls/lv2/sys_mmapper.h          |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp          |   9 +-
 rpcs3/Emu/SysCalls/lv2/sys_mutex.h            |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_process.cpp        |  56 +++++-----
 rpcs3/Emu/SysCalls/lv2/sys_process.h          |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_prx.cpp            |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_prx.h              |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp            |  12 +--
 rpcs3/Emu/SysCalls/lv2/sys_rsx.h              |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp         |   9 +-
 rpcs3/Emu/SysCalls/lv2/sys_rwlock.h           |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp      |  15 +--
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.h        |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_spu.cpp            |  61 +++++------
 rpcs3/Emu/SysCalls/lv2/sys_spu.h              |  18 ++--
 rpcs3/Emu/SysCalls/lv2/sys_time.cpp           |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_time.h             |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_timer.cpp          |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_timer.h            |   2 +-
 65 files changed, 521 insertions(+), 514 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index bbd1d39b47..9959922730 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -768,7 +768,5 @@ public:
 	}
 };
 
-typedef mem_t<u32, u32> mem32_t;
-
 #include "vm.h"
 
diff --git a/rpcs3/Emu/SysCalls/Modules/SC_Pad.cpp b/rpcs3/Emu/SysCalls/Modules/SC_Pad.cpp
index c04cd67a01..c215b2d8ba 100644
--- a/rpcs3/Emu/SysCalls/Modules/SC_Pad.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/SC_Pad.cpp
@@ -359,9 +359,9 @@ int cellPadGetInfo2(u32 info_addr)
 	return CELL_OK;
 }
 
-int cellPadGetCapabilityInfo(u32 port_no, mem32_t info_addr)
+int cellPadGetCapabilityInfo(u32 port_no, vm::ptr<be_t<u32>> info_addr)
 {
-	sys_io->Log("cellPadGetCapabilityInfo[port_no: %d, data_addr: 0x%x]", port_no, info_addr.GetAddr());
+	sys_io->Log("cellPadGetCapabilityInfo[port_no: %d, data_addr: 0x%x]", port_no, info_addr.addr());
 	if (!Emu.GetPadManager().IsInited()) return CELL_PAD_ERROR_UNINITIALIZED;
 	const PadInfo& rinfo = Emu.GetPadManager().GetInfo();
 	if (port_no >= rinfo.max_connect) return CELL_PAD_ERROR_INVALID_PARAMETER;
@@ -374,7 +374,7 @@ int cellPadGetCapabilityInfo(u32 port_no, mem32_t info_addr)
 	//Should return the same as device capability mask, psl1ght has it backwards in pad.h
 	data.info[0] = pads[port_no].m_device_capability;
 
-	Memory.WriteData(info_addr.GetAddr(), data);
+	Memory.WriteData(info_addr.addr(), data);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
index 7a5c5831cc..7bc8d42a23 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
@@ -614,26 +614,26 @@ int cellAdecQueryAttr(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecAttr> attr
 	return CELL_OK;
 }
 
-int cellAdecOpen(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResource> res, mem_ptr_t<CellAdecCb> cb, mem32_t handle)
+int cellAdecOpen(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResource> res, mem_ptr_t<CellAdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellAdec->Warning("cellAdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)", 
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr());
+		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
 
 	if (!adecCheckType(type->audioCodecType)) return CELL_ADEC_ERROR_ARG;
 
-	handle = adecOpen(new AudioDecoder(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg));
+	*handle = adecOpen(new AudioDecoder(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg));
 
 	return CELL_OK;
 }
 
-int cellAdecOpenEx(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResourceEx> res, mem_ptr_t<CellAdecCb> cb, mem32_t handle)
+int cellAdecOpenEx(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResourceEx> res, mem_ptr_t<CellAdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellAdec->Warning("cellAdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)", 
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr());
+		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
 
 	if (!adecCheckType(type->audioCodecType)) return CELL_ADEC_ERROR_ARG;
 
-	handle = adecOpen(new AudioDecoder(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg));
+	*handle = adecOpen(new AudioDecoder(type->audioCodecType, res->startAddr, res->totalMemSize, cb->cbFunc, cb->cbArg));
 
 	return CELL_OK;
 }
@@ -767,9 +767,9 @@ int cellAdecGetPcm(u32 handle, u32 outBuffer_addr)
 	return CELL_OK;
 }
 
-int cellAdecGetPcmItem(u32 handle, mem32_t pcmItem_ptr)
+int cellAdecGetPcmItem(u32 handle, vm::ptr<be_t<u32>> pcmItem_ptr)
 {
-	cellAdec->Log("cellAdecGetPcmItem(handle=%d, pcmItem_ptr_addr=0x%x)", handle, pcmItem_ptr.GetAddr());
+	cellAdec->Log("cellAdecGetPcmItem(handle=%d, pcmItem_ptr_addr=0x%x)", handle, pcmItem_ptr.addr());
 
 	AudioDecoder* adec;
 	if (!Emu.GetIdManager().GetIDData(handle, adec))
@@ -811,7 +811,7 @@ int cellAdecGetPcmItem(u32 handle, mem32_t pcmItem_ptr)
 	atx->nbytes = frame->nb_samples * frame->channels * sizeof(float); // ???
 	atx->channelConfigIndex = CELL_ADEC_CH_STEREO; // ???
 
-	pcmItem_ptr = pcm.GetAddr();
+	*pcmItem_ptr = pcm.GetAddr();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
index 7967075062..5346e740f1 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
@@ -6,12 +6,12 @@ Module *cellAtrac = nullptr;
 
 #include "cellAtrac.h"
 
-int cellAtracSetDataAndGetMemSize(mem_ptr_t<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, mem32_t puiWorkMemByte)
+int cellAtracSetDataAndGetMemSize(mem_ptr_t<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<be_t<u32>> puiWorkMemByte)
 {
 	cellAtrac->Todo("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
-		pHandle.GetAddr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.GetAddr());
+		pHandle.GetAddr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
 
-	puiWorkMemByte = 0x1000; // unproved
+	*puiWorkMemByte = 0x1000; // unproved
 	return CELL_OK;
 }
 
@@ -39,25 +39,25 @@ int cellAtracDeleteDecoder(mem_ptr_t<CellAtracHandle> pHandle)
 	return CELL_OK;
 }
 
-int cellAtracDecode(mem_ptr_t<CellAtracHandle> pHandle, u32 pfOutAddr, mem32_t puiSamples, mem32_t puiFinishflag, mem32_t piRemainFrame)
+int cellAtracDecode(mem_ptr_t<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<be_t<u32>> puiSamples, vm::ptr<be_t<u32>> puiFinishflag, vm::ptr<be_t<u32>> piRemainFrame)
 {
 	cellAtrac->Todo("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
-		pHandle.GetAddr(), pfOutAddr, puiSamples.GetAddr(), puiFinishflag.GetAddr(), piRemainFrame.GetAddr());
+		pHandle.GetAddr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
 
-	puiSamples = 0;
-	puiFinishflag = 1;
-	piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
+	*puiSamples = 0;
+	*puiFinishflag = 1;
+	*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
 	return CELL_OK;
 }
 
-int cellAtracGetStreamDataInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t ppucWritePointer, mem32_t puiWritableByte, mem32_t puiReadPosition)
+int cellAtracGetStreamDataInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> ppucWritePointer, vm::ptr<be_t<u32>> puiWritableByte, vm::ptr<be_t<u32>> puiReadPosition)
 {
 	cellAtrac->Todo("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
-		pHandle.GetAddr(), ppucWritePointer.GetAddr(), puiWritableByte.GetAddr(), puiReadPosition.GetAddr());
+		pHandle.GetAddr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
 
-	ppucWritePointer = pHandle->data.pucWorkMem_addr;
-	puiWritableByte = 0x1000;
-	puiReadPosition = 0;
+	*ppucWritePointer = pHandle->data.pucWorkMem_addr;
+	*puiWritableByte = 0x1000;
+	*puiReadPosition = 0;
 	return CELL_OK;
 }
 
@@ -67,19 +67,19 @@ int cellAtracAddStreamData(mem_ptr_t<CellAtracHandle> pHandle, u32 uiAddByte)
 	return CELL_OK;
 }
 
-int cellAtracGetRemainFrame(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piRemainFrame)
+int cellAtracGetRemainFrame(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piRemainFrame)
 {
-	cellAtrac->Todo("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.GetAddr(), piRemainFrame.GetAddr());
+	cellAtrac->Todo("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.GetAddr(), piRemainFrame.addr());
 
-	piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
+	*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
 	return CELL_OK;
 }
 
-int cellAtracGetVacantSize(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiVacantSize)
+int cellAtracGetVacantSize(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiVacantSize)
 {
-	cellAtrac->Todo("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.GetAddr(), puiVacantSize.GetAddr());
+	cellAtrac->Todo("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.GetAddr(), puiVacantSize.addr());
 
-	puiVacantSize = 0x1000;
+	*puiVacantSize = 0x1000;
 	return CELL_OK;
 }
 
@@ -89,13 +89,13 @@ int cellAtracIsSecondBufferNeeded(mem_ptr_t<CellAtracHandle> pHandle)
 	return CELL_OK;
 }
 
-int cellAtracGetSecondBufferInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiReadPosition, mem32_t puiDataByte)
+int cellAtracGetSecondBufferInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiReadPosition, vm::ptr<be_t<u32>> puiDataByte)
 {
 	cellAtrac->Todo("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
-		pHandle.GetAddr(), puiReadPosition.GetAddr(), puiDataByte.GetAddr());
+		pHandle.GetAddr(), puiReadPosition.addr(), puiDataByte.addr());
 
-	puiReadPosition = 0;
-	puiDataByte = 0; // write to null block will occur
+	*puiReadPosition = 0;
+	*puiDataByte = 0; // write to null block will occur
 	return CELL_OK;
 }
 
@@ -106,66 +106,66 @@ int cellAtracSetSecondBuffer(mem_ptr_t<CellAtracHandle> pHandle, u32 pucSecondBu
 	return CELL_OK;
 }
 
-int cellAtracGetChannel(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiChannel)
+int cellAtracGetChannel(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiChannel)
 {
-	cellAtrac->Todo("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.GetAddr(), puiChannel.GetAddr());
+	cellAtrac->Todo("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.GetAddr(), puiChannel.addr());
 
-	puiChannel = 2;
+	*puiChannel = 2;
 	return CELL_OK;
 }
 
-int cellAtracGetMaxSample(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiMaxSample)
+int cellAtracGetMaxSample(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiMaxSample)
 {
-	cellAtrac->Todo("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.GetAddr(), puiMaxSample.GetAddr());
+	cellAtrac->Todo("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.GetAddr(), puiMaxSample.addr());
 
-	puiMaxSample = 512;
+	*puiMaxSample = 512;
 	return CELL_OK;
 }
 
-int cellAtracGetNextSample(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiNextSample)
+int cellAtracGetNextSample(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiNextSample)
 {
-	cellAtrac->Todo("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.GetAddr(), puiNextSample.GetAddr());
+	cellAtrac->Todo("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.GetAddr(), puiNextSample.addr());
 
-	puiNextSample = 0;
+	*puiNextSample = 0;
 	return CELL_OK;
 }
 
-int cellAtracGetSoundInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piEndSample, mem32_t piLoopStartSample, mem32_t piLoopEndSample)
+int cellAtracGetSoundInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piEndSample, vm::ptr<be_t<u32>> piLoopStartSample, vm::ptr<be_t<u32>> piLoopEndSample)
 {
 	cellAtrac->Todo("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
-		pHandle.GetAddr(), piEndSample.GetAddr(), piLoopStartSample.GetAddr(), piLoopEndSample.GetAddr());
+		pHandle.GetAddr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
 
-	piEndSample = 0;
-	piLoopStartSample = 0;
-	piLoopEndSample = 0;
+	*piEndSample = 0;
+	*piLoopStartSample = 0;
+	*piLoopEndSample = 0;
 	return CELL_OK;
 }
 
-int cellAtracGetNextDecodePosition(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiSamplePosition)
+int cellAtracGetNextDecodePosition(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiSamplePosition)
 {
 	cellAtrac->Todo("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
-		pHandle.GetAddr(), puiSamplePosition.GetAddr());
+		pHandle.GetAddr(), puiSamplePosition.addr());
 
-	puiSamplePosition = 0;
+	*puiSamplePosition = 0;
 	return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED;
 }
 
-int cellAtracGetBitrate(mem_ptr_t<CellAtracHandle> pHandle, mem32_t puiBitrate)
+int cellAtracGetBitrate(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiBitrate)
 {
 	cellAtrac->Todo("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
-		pHandle.GetAddr(), puiBitrate.GetAddr());
+		pHandle.GetAddr(), puiBitrate.addr());
 
-	puiBitrate = 128;
+	*puiBitrate = 128;
 	return CELL_OK;
 }
 
-int cellAtracGetLoopInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piLoopNum, mem32_t puiLoopStatus)
+int cellAtracGetLoopInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piLoopNum, vm::ptr<be_t<u32>> puiLoopStatus)
 {
 	cellAtrac->Todo("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
-		pHandle.GetAddr(), piLoopNum.GetAddr(), puiLoopStatus.GetAddr());
+		pHandle.GetAddr(), piLoopNum.addr(), puiLoopStatus.addr());
 
-	piLoopNum = 0;
-	puiLoopStatus = 0;
+	*piLoopNum = 0;
+	*puiLoopStatus = 0;
 	return CELL_OK;
 }
 
@@ -194,12 +194,12 @@ int cellAtracResetPlayPosition(mem_ptr_t<CellAtracHandle> pHandle, u32 uiSample,
 	return CELL_OK;
 }
 
-int cellAtracGetInternalErrorInfo(mem_ptr_t<CellAtracHandle> pHandle, mem32_t piResult)
+int cellAtracGetInternalErrorInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piResult)
 {
 	cellAtrac->Todo("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
-		pHandle.GetAddr(), piResult.GetAddr());
+		pHandle.GetAddr(), piResult.addr());
 
-	piResult = 0;
+	*piResult = 0;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
index abbdef18ad..5bc9dd349f 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
@@ -507,9 +507,9 @@ int cellAudioQuit()
 	return CELL_OK;
 }
 
-int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, mem32_t portNum)
+int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, vm::ptr<be_t<u32>> portNum)
 {
-	cellAudio->Warning("cellAudioPortOpen(audioParam_addr=0x%x, portNum_addr=0x%x)", audioParam.GetAddr(), portNum.GetAddr());
+	cellAudio->Warning("cellAudioPortOpen(audioParam_addr=0x%x, portNum_addr=0x%x)", audioParam.GetAddr(), portNum.addr());
 
 	if (audioParam->nChannel > 8 || audioParam->nBlock > 16)
 	{
@@ -539,7 +539,7 @@ int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, mem32_t portNum)
 				port.level = 1.0f;
 			}
 
-			portNum = i;
+			*portNum = i;
 			cellAudio->Warning("*** audio port opened(nChannel=%d, nBlock=%d, attr=0x%llx, level=%f): port = %d",
 				port.channel, port.block, port.attr, port.level, i);
 			
@@ -738,9 +738,9 @@ int cellAudioSetPortLevel(u32 portNum, float level)
 }
 
 // Utility Functions  
-int cellAudioCreateNotifyEventQueue(mem32_t id, vm::ptr<be_t<u64>> key)
+int cellAudioCreateNotifyEventQueue(vm::ptr<be_t<u32>> id, vm::ptr<be_t<u64>> key)
 {
-	cellAudio->Warning("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.GetAddr(), key.addr());
+	cellAudio->Warning("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.addr(), key.addr());
 
 	std::lock_guard<std::mutex> lock(audioMutex);
 
@@ -760,15 +760,15 @@ int cellAudioCreateNotifyEventQueue(mem32_t id, vm::ptr<be_t<u64>> key)
 		return CELL_AUDIO_ERROR_EVENT_QUEUE;
 	}
 
-	id = cellAudio->GetNewId(eq);
+	*id = cellAudio->GetNewId(eq);
 	*key = event_key;
 
 	return CELL_OK;
 }
 
-int cellAudioCreateNotifyEventQueueEx(mem32_t id, vm::ptr<be_t<u64>> key, u32 iFlags)
+int cellAudioCreateNotifyEventQueueEx(vm::ptr<be_t<u32>> id, vm::ptr<be_t<u64>> key, u32 iFlags)
 {
-	cellAudio->Todo("cellAudioCreateNotifyEventQueueEx(id_addr=0x%x, key_addr=0x%x, iFlags=0x%x)", id.GetAddr(), key.addr(), iFlags);
+	cellAudio->Todo("cellAudioCreateNotifyEventQueueEx(id_addr=0x%x, key_addr=0x%x, iFlags=0x%x)", id.addr(), key.addr(), iFlags);
 	return CELL_OK;
 }
 
@@ -844,21 +844,21 @@ int cellAudioRemoveNotifyEventQueueEx(u64 key, u32 iFlags)
 	return CELL_OK;
 }
 
-int cellAudioAddData(u32 portNum, mem32_t src, u32 samples, float volume)
+int cellAudioAddData(u32 portNum, vm::ptr<be_t<float>> src, u32 samples, float volume)
 {
-	cellAudio->Todo("cellAudioAddData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.GetAddr(), samples, volume);
+	cellAudio->Todo("cellAudioAddData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.addr(), samples, volume);
 	return CELL_OK;
 }
 
-int cellAudioAdd2chData(u32 portNum, mem32_t src, u32 samples, float volume) 
+int cellAudioAdd2chData(u32 portNum, vm::ptr<be_t<float>> src, u32 samples, float volume)
 {
-	cellAudio->Todo("cellAudioAdd2chData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.GetAddr(), samples, volume);
+	cellAudio->Todo("cellAudioAdd2chData(portNum=0x%x, src_addr=0x%x, samples=%d, volume=%f)", portNum, src.addr(), samples, volume);
 	return CELL_OK;
 }
 
-int cellAudioAdd6chData(u32 portNum, mem32_t src, float volume)
+int cellAudioAdd6chData(u32 portNum, vm::ptr<be_t<float>> src, float volume)
 {
-	cellAudio->Todo("cellAudioAdd6chData(portNum=0x%x, src_addr=0x%x, volume=%f)", portNum, src.GetAddr(), volume);
+	cellAudio->Todo("cellAudioAdd6chData(portNum=0x%x, src_addr=0x%x, volume=%f)", portNum, src.addr(), volume);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
index 0569017e2a..1e8c5a5f78 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
@@ -776,10 +776,10 @@ int cellDmuxQueryAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, mem_ptr_t<Ce
 }
 
 int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResource> demuxerResource, 
-				 const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
+	const mem_ptr_t<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
 {
 	cellDmux->Warning("cellDmuxOpen(demuxerType_addr=0x%x, demuxerResource_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
-		demuxerType.GetAddr(), demuxerResource.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.GetAddr());
+		demuxerType.GetAddr(), demuxerResource.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.addr());
 
 	if (demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -788,16 +788,16 @@ int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Cell
 
 	// TODO: check demuxerResource and demuxerCb arguments
 
-	demuxerHandle = dmuxOpen(new Demuxer(demuxerResource->memAddr, demuxerResource->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
+	*demuxerHandle = dmuxOpen(new Demuxer(demuxerResource->memAddr, demuxerResource->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
 
 	return CELL_OK;
 }
 
 int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResourceEx> demuxerResourceEx, 
-				   const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
+	const mem_ptr_t<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
 {
 	cellDmux->Warning("cellDmuxOpenEx(demuxerType_addr=0x%x, demuxerResourceEx_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
-		demuxerType.GetAddr(), demuxerResourceEx.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.GetAddr());
+		demuxerType.GetAddr(), demuxerResourceEx.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.addr());
 
 	if (demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -806,16 +806,16 @@ int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Ce
 
 	// TODO: check demuxerResourceEx and demuxerCb arguments
 
-	demuxerHandle = dmuxOpen(new Demuxer(demuxerResourceEx->memAddr, demuxerResourceEx->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
+	*demuxerHandle = dmuxOpen(new Demuxer(demuxerResourceEx->memAddr, demuxerResourceEx->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
 
 	return CELL_OK;
 }
 
 int cellDmuxOpen2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<CellDmuxResource2> demuxerResource2, 
-				  const mem_ptr_t<CellDmuxCb> demuxerCb, mem32_t demuxerHandle)
+	const mem_ptr_t<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
 {
 	cellDmux->Warning("cellDmuxOpen2(demuxerType2_addr=0x%x, demuxerResource2_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
-		demuxerType2.GetAddr(), demuxerResource2.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.GetAddr());
+		demuxerType2.GetAddr(), demuxerResource2.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.addr());
 
 	if (demuxerType2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -824,7 +824,7 @@ int cellDmuxOpen2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<C
 
 	// TODO: check demuxerType2, demuxerResource2 and demuxerCb arguments
 
-	demuxerHandle = dmuxOpen(new Demuxer(demuxerResource2->memAddr, demuxerResource2->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
+	*demuxerHandle = dmuxOpen(new Demuxer(demuxerResource2->memAddr, demuxerResource2->memSize, demuxerCb->cbMsgFunc, demuxerCb->cbArg_addr));
 
 	return CELL_OK;
 }
@@ -979,11 +979,11 @@ int cellDmuxQueryEsAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_
 
 int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esFilterId, 
 					 const mem_ptr_t<CellDmuxEsResource> esResourceInfo, const mem_ptr_t<CellDmuxEsCb> esCb,
-					 const u32 esSpecificInfo_addr, mem32_t esHandle)
+					 const u32 esSpecificInfo_addr, vm::ptr<be_t<u32>> esHandle)
 {
 	cellDmux->Warning("cellDmuxEnableEs(demuxerHandle=%d, esFilterId_addr=0x%x, esResourceInfo_addr=0x%x, esCb_addr=0x%x, "
 		"esSpecificInfo_addr=0x%x, esHandle_addr=0x%x)", demuxerHandle, esFilterId.GetAddr(), esResourceInfo.GetAddr(),
-		esCb.GetAddr(), esSpecificInfo_addr, esHandle.GetAddr());
+		esCb.GetAddr(), esSpecificInfo_addr, esHandle.addr());
 
 	Demuxer* dmux;
 	if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
@@ -999,7 +999,7 @@ int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esF
 
 	u32 id = cellDmux->GetNewId(es);
 	es->id = id;
-	esHandle = id;
+	*esHandle = id;
 
 	cellDmux->Warning("*** New ES(dmux=%d, addr=0x%x, size=0x%x, filter(0x%x, 0x%x, 0x%x, 0x%x), cb=0x%x(arg=0x%x), spec=0x%x): id = %d",
 		demuxerHandle, es->memAddr, es->memSize, es->fidMajor, es->fidMinor, es->sup1, es->sup2, (u32)esCb->cbEsMsgFunc, es->cbArg, es->spec, id);
@@ -1048,10 +1048,10 @@ int cellDmuxResetEs(u32 esHandle)
 	return CELL_OK;
 }
 
-int cellDmuxGetAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
+int cellDmuxGetAu(u32 esHandle, vm::ptr<be_t<u32>> auInfo_ptr, vm::ptr<be_t<u32>> auSpecificInfo_ptr)
 {
 	cellDmux->Log("cellDmuxGetAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfo_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+		esHandle, auInfo_ptr.addr(), auSpecificInfo_ptr.addr());
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -1066,15 +1066,15 @@ int cellDmuxGetAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
 		return CELL_DMUX_ERROR_EMPTY;
 	}
 
-	auInfo_ptr = info;
-	auSpecificInfo_ptr = spec;
+	*auInfo_ptr = info;
+	*auSpecificInfo_ptr = spec;
 	return CELL_OK;
 }
 
-int cellDmuxPeekAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
+int cellDmuxPeekAu(u32 esHandle, vm::ptr<be_t<u32>> auInfo_ptr, vm::ptr<be_t<u32>> auSpecificInfo_ptr)
 {
 	cellDmux->Log("cellDmuxPeekAu(esHandle=0x%x, auInfo_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfo_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+		esHandle, auInfo_ptr.addr(), auSpecificInfo_ptr.addr());
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -1089,15 +1089,15 @@ int cellDmuxPeekAu(u32 esHandle, mem32_t auInfo_ptr, mem32_t auSpecificInfo_ptr)
 		return CELL_DMUX_ERROR_EMPTY;
 	}
 
-	auInfo_ptr = info;
-	auSpecificInfo_ptr = spec;
+	*auInfo_ptr = info;
+	*auSpecificInfo_ptr = spec;
 	return CELL_OK;
 }
 
-int cellDmuxGetAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_ptr)
+int cellDmuxGetAuEx(u32 esHandle, vm::ptr<be_t<u32>> auInfoEx_ptr, vm::ptr<be_t<u32>> auSpecificInfo_ptr)
 {
 	cellDmux->Log("cellDmuxGetAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfoEx_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+		esHandle, auInfoEx_ptr.addr(), auSpecificInfo_ptr.addr());
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -1112,15 +1112,15 @@ int cellDmuxGetAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_p
 		return CELL_DMUX_ERROR_EMPTY;
 	}
 
-	auInfoEx_ptr = info;
-	auSpecificInfo_ptr = spec;
+	*auInfoEx_ptr = info;
+	*auSpecificInfo_ptr = spec;
 	return CELL_OK;
 }
 
-int cellDmuxPeekAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_ptr)
+int cellDmuxPeekAuEx(u32 esHandle, vm::ptr<be_t<u32>> auInfoEx_ptr, vm::ptr<be_t<u32>> auSpecificInfo_ptr)
 {
 	cellDmux->Log("cellDmuxPeekAuEx(esHandle=0x%x, auInfoEx_ptr_addr=0x%x, auSpecificInfo_ptr_addr=0x%x)",
-		esHandle, auInfoEx_ptr.GetAddr(), auSpecificInfo_ptr.GetAddr());
+		esHandle, auInfoEx_ptr.addr(), auSpecificInfo_ptr.addr());
 
 	ElementaryStream* es;
 	if (!Emu.GetIdManager().GetIDData(esHandle, es))
@@ -1135,8 +1135,8 @@ int cellDmuxPeekAuEx(u32 esHandle, mem32_t auInfoEx_ptr, mem32_t auSpecificInfo_
 		return CELL_DMUX_ERROR_EMPTY;
 	}
 
-	auInfoEx_ptr = info;
-	auSpecificInfo_ptr = spec;
+	*auInfoEx_ptr = info;
+	*auSpecificInfo_ptr = spec;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index 28e4e66a85..b4b6510801 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -387,10 +387,10 @@ int cellFontGetEffectSlant(mem_ptr_t<CellFont> font, mem_ptr_t<be_t<float>> slan
 	return CELL_FONT_OK;
 }
 
-int cellFontGetFontIdCode(mem_ptr_t<CellFont> font, u32 code, mem32_t fontId, mem32_t fontCode)
+int cellFontGetFontIdCode(mem_ptr_t<CellFont> font, u32 code, vm::ptr<be_t<u32>> fontId, vm::ptr<be_t<u32>> fontCode)
 {
 	cellFont->Todo("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x",
-		font.GetAddr(), code, fontId.GetAddr(), fontCode.GetAddr());
+		font.GetAddr(), code, fontId.addr(), fontCode.addr());
 
 	// TODO: ?
 	return CELL_FONT_OK;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
index fd4d9dcf1d..d0b6548da3 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
@@ -16,10 +16,10 @@ Module *cellGame = nullptr;
 std::string contentInfo = "";
 std::string usrdir = "";
 
-int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameContentSize> size, vm::ptr<char> dirName)
+int cellGameBootCheck(vm::ptr<be_t<u32>> type, vm::ptr<be_t<u32>> attributes, mem_ptr_t<CellGameContentSize> size, vm::ptr<char> dirName)
 {
 	cellGame->Warning("cellGameBootCheck(type_addr=0x%x, attributes_addr=0x%x, size_addr=0x%x, dirName_addr=0x%x)",
-		type.GetAddr(), attributes.GetAddr(), size.GetAddr(), dirName.addr());
+		type.addr(), attributes.addr(), size.GetAddr(), dirName.addr());
 
 	if (size)
 	{
@@ -48,8 +48,8 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 	std::string category = psf.GetString("CATEGORY");
 	if (category.substr(0, 2) == "DG")
 	{
-		type = CELL_GAME_GAMETYPE_DISC;
-		attributes = 0; // TODO
+		*type = CELL_GAME_GAMETYPE_DISC;
+		*attributes = 0; // TODO
 		if (dirName) Memory.WriteString(dirName.addr(), ""); // ???
 		contentInfo = "/dev_bdvd/PS3_GAME";
 		usrdir = "/dev_bdvd/PS3_GAME/USRDIR";
@@ -57,8 +57,8 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 	else if (category.substr(0, 2) == "HG")
 	{
 		std::string titleId = psf.GetString("TITLE_ID");
-		type = CELL_GAME_GAMETYPE_HDD;
-		attributes = 0; // TODO
+		*type = CELL_GAME_GAMETYPE_HDD;
+		*attributes = 0; // TODO
 		if (dirName) Memory.WriteString(dirName.addr(), titleId);
 		contentInfo = "/dev_hdd0/game/" + titleId;
 		usrdir = "/dev_hdd0/game/" + titleId + "/USRDIR";
@@ -66,8 +66,8 @@ int cellGameBootCheck(mem32_t type, mem32_t attributes, mem_ptr_t<CellGameConten
 	else if (category.substr(0, 2) == "GD")
 	{
 		std::string titleId = psf.GetString("TITLE_ID");
-		type = CELL_GAME_GAMETYPE_DISC;
-		attributes = CELL_GAME_ATTRIBUTE_PATCH; // TODO
+		*type = CELL_GAME_GAMETYPE_DISC;
+		*attributes = CELL_GAME_ATTRIBUTE_PATCH; // TODO
 		if (dirName) Memory.WriteString(dirName.addr(), titleId); // ???
 		contentInfo = "/dev_bdvd/PS3_GAME";
 		usrdir = "/dev_bdvd/PS3_GAME/USRDIR";
@@ -327,9 +327,9 @@ int cellGameDeleteGameData()
 	return CELL_OK;
 }
 
-int cellGameGetParamInt(u32 id, mem32_t value)
+int cellGameGetParamInt(u32 id, vm::ptr<be_t<u32>> value)
 {
-	cellGame->Warning("cellGameGetParamInt(id=%d, value_addr=0x%x)", id, value.GetAddr());
+	cellGame->Warning("cellGameGetParamInt(id=%d, value_addr=0x%x)", id, value.addr());
 
 	// TODO: Access through cellGame***Check functions
 	vfsFile f("/app_home/PARAM.SFO");
@@ -339,9 +339,9 @@ int cellGameGetParamInt(u32 id, mem32_t value)
 
 	switch(id)
 	{
-	case CELL_GAME_PARAMID_PARENTAL_LEVEL:  value = psf.GetInteger("PARENTAL_LEVEL"); break;
-	case CELL_GAME_PARAMID_RESOLUTION:      value = psf.GetInteger("RESOLUTION");     break;
-	case CELL_GAME_PARAMID_SOUND_FORMAT:    value = psf.GetInteger("SOUND_FORMAT");   break;
+	case CELL_GAME_PARAMID_PARENTAL_LEVEL:  *value = psf.GetInteger("PARENTAL_LEVEL"); break;
+	case CELL_GAME_PARAMID_RESOLUTION:      *value = psf.GetInteger("RESOLUTION");     break;
+	case CELL_GAME_PARAMID_SOUND_FORMAT:    *value = psf.GetInteger("SOUND_FORMAT");   break;
 
 	default:
 		return CELL_GAME_ERROR_INVALID_ID;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
index c6ee6ff64a..d335acea33 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
@@ -801,9 +801,9 @@ int cellGcmSortRemapEaIoAddress()
 //----------------------------------------------------------------------------
 // Memory Mapping
 //----------------------------------------------------------------------------
-s32 cellGcmAddressToOffset(u64 address, mem32_t offset)
+s32 cellGcmAddressToOffset(u64 address, vm::ptr<be_t<u32>> offset)
 {
-	cellGcmSys->Log("cellGcmAddressToOffset(address=0x%x,offset_addr=0x%x)", address, offset.GetAddr());
+	cellGcmSys->Log("cellGcmAddressToOffset(address=0x%x,offset_addr=0x%x)", address, offset.addr());
 
 	// Address not on main memory or local memory
 	if (address >= 0xD0000000) {
@@ -830,7 +830,7 @@ s32 cellGcmAddressToOffset(u64 address, mem32_t offset)
 		}
 	}
 
-	offset = result;
+	*offset = result;
 	return CELL_OK;
 }
 
@@ -915,9 +915,9 @@ s32 cellGcmMapLocalMemory(u64 address, u64 size)
 	return CELL_OK;
 }
 
-s32 cellGcmMapMainMemory(u32 ea, u32 size, mem32_t offset)
+s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<be_t<u32>> offset)
 {
-	cellGcmSys->Warning("cellGcmMapMainMemory(ea=0x%x,size=0x%x,offset_addr=0x%x)", ea, size, offset.GetAddr());
+	cellGcmSys->Warning("cellGcmMapMainMemory(ea=0x%x,size=0x%x,offset_addr=0x%x)", ea, size, offset.addr());
 
 	u32 io;
 
@@ -936,7 +936,7 @@ s32 cellGcmMapMainMemory(u32 ea, u32 size, mem32_t offset)
 			Memory.Write16(offsetTable.eaAddress + ((io >> 20) + i) * sizeof(u16), (u16)(ea >> 20) + i);
 		}
 
-		offset = io;
+		*offset = io;
 	}
 	else
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
index 1da9d57321..f2c25a726b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
@@ -24,13 +24,13 @@ u32 gcmGetLocalMemorySize();
 // SysCalls
 s32 cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id);
 
-s32 cellGcmAddressToOffset(u64 address, mem32_t offset);
+s32 cellGcmAddressToOffset(u64 address, vm::ptr<be_t<u32>> offset);
 u32 cellGcmGetMaxIoMapSize();
 void cellGcmGetOffsetTable(mem_ptr_t<CellGcmOffsetTable> table);
 s32 cellGcmIoOffsetToAddress(u32 ioOffset, u64 address);
 s32 cellGcmMapEaIoAddress(u32 ea, u32 io, u32 size);
 s32 cellGcmMapEaIoAddressWithFlags(u32 ea, u32 io, u32 size, u32 flags);
-s32 cellGcmMapMainMemory(u32 ea, u32 size, mem32_t offset);
+s32 cellGcmMapMainMemory(u32 ea, u32 size, vm::ptr<be_t<u32>> offset);
 s32 cellGcmReserveIoMapSize(u32 size);
 s32 cellGcmUnmapEaIoAddress(u64 ea);
 s32 cellGcmUnmapIoAddress(u64 io);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
index a8acef4722..5b5b028b79 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
@@ -23,10 +23,10 @@ int cellGifDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u
 	return CELL_OK;
 }
 
-int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, const mem_ptr_t<CellGifDecSrc> src, mem_ptr_t<CellGifDecOpnInfo> openInfo)
+int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const mem_ptr_t<CellGifDecSrc> src, mem_ptr_t<CellGifDecOpnInfo> openInfo)
 {
 	cellGifDec->Warning("cellGifDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)",
-		mainHandle, subHandle.GetAddr(), src.GetAddr(), openInfo.GetAddr());
+		mainHandle, subHandle.addr(), src.GetAddr(), openInfo.GetAddr());
 
 	CellGifDecSubHandle *current_subHandle = new CellGifDecSubHandle;
 	current_subHandle->fd = 0;
@@ -41,7 +41,7 @@ int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, const mem_ptr_t<CellGifDec
 	case se32(CELL_GIFDEC_FILE):
 		// Get file descriptor
 		vm::var<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName, 0, fd.addr(), 0, 0);
+		int ret = cellFsOpen(src->fileName, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
 		current_subHandle->fd = fd->ToLE();
 		if (ret != CELL_OK) return CELL_GIFDEC_ERROR_OPEN_FILE;
 
@@ -54,7 +54,7 @@ int cellGifDecOpen(u32 mainHandle, mem32_t subHandle, const mem_ptr_t<CellGifDec
 	}
 
 	// From now, every u32 subHandle argument is a pointer to a CellGifDecSubHandle struct.
-	subHandle = cellGifDec->GetNewId(current_subHandle);
+	*subHandle = cellGifDec->GetNewId(current_subHandle);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
index 0a903f58ed..80495f7802 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
@@ -28,10 +28,10 @@ int cellJpgDecDestroy(u32 mainHandle)
 	return CELL_OK;
 }
 
-int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> src, mem_ptr_t<CellJpgDecOpnInfo> openInfo)
+int cellJpgDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellJpgDecSrc> src, mem_ptr_t<CellJpgDecOpnInfo> openInfo)
 {
 	cellJpgDec->Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)",
-		mainHandle, subHandle.GetAddr(), src.GetAddr(), openInfo.GetAddr());
+		mainHandle, subHandle.addr(), src.GetAddr(), openInfo.GetAddr());
 
 	CellJpgDecSubHandle *current_subHandle = new CellJpgDecSubHandle;
 
@@ -47,7 +47,7 @@ int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> s
 	case se32(CELL_JPGDEC_FILE):
 		// Get file descriptor
 		vm::var<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName, 0, fd.addr(), 0, 0);
+		int ret = cellFsOpen(src->fileName, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
 		current_subHandle->fd = fd->ToLE();
 		if (ret != CELL_OK) return CELL_JPGDEC_ERROR_OPEN_FILE;
 
@@ -60,7 +60,7 @@ int cellJpgDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellJpgDecSrc> s
 	}
 
 	// From now, every u32 subHandle argument is a pointer to a CellJpgDecSubHandle struct.
-	subHandle = cellJpgDec->GetNewId(current_subHandle);
+	*subHandle = cellJpgDec->GetNewId(current_subHandle);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index e4ae101ced..536122f30c 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -283,10 +283,10 @@ int _L10nConvertStr(int src_code, const void* src, size_t * src_len, int dst_cod
 #endif
 
 //TODO: Check the code in emulation. If support for UTF8/UTF16/UTF32/UCS2/UCS4 should use wider chars.. awful.
-int L10nConvertStr(int src_code, vm::ptr<const void> src, mem32_t src_len, int dst_code, vm::ptr<void> dst, mem32_t dst_len)
+int L10nConvertStr(int src_code, vm::ptr<const void> src, vm::ptr<be_t<u32>> src_len, int dst_code, vm::ptr<void> dst, vm::ptr<be_t<u32>> dst_len)
 {
 	cellL10n->Todo("L10nConvertStr(src_code=%d,src=0x%x,src_len=%ld,dst_code=%d,dst=0x%x,dst_len=%ld)",
-		src_code, src.addr(), src_len.GetValue(), dst_code, dst.addr(), dst_len.GetValue());
+		src_code, src.addr(), src_len.addr(), dst_code, dst.addr(), dst_len.addr());
 	cellL10n->Todo("L10nConvertStr: 1st char at dst: %x(Hex)", *((char*)src.get_ptr()));
 #ifdef _MSC_VER
 	unsigned int srcCode = 0, dstCode = 0;	//OEM code pages
@@ -300,10 +300,10 @@ int L10nConvertStr(int src_code, vm::ptr<const void> src, mem32_t src_len, int d
 	//if (strnlen_s((char*)src, *src_len) != *src_len) return SRCIllegal;
 	std::string wrapped_source = (char*)src.get_ptr();
 	//std::string wrapped_source((char*)src);
-	if (wrapped_source.length() != src_len.GetValue()) return SRCIllegal;
+	if (wrapped_source.length() != *src_len) return SRCIllegal;
 	std::string target = _OemToOem(srcCode, dstCode, wrapped_source);
 
-	if (target.length() > dst_len.GetValue()) return DSTExhausted;
+	if (target.length() > *dst_len) return DSTExhausted;
 
 	Memory.WriteString(dst.addr(), target);
 
@@ -318,9 +318,9 @@ int L10nConvertStr(int src_code, vm::ptr<const void> src, mem32_t src_len, int d
 		char *dstBuf = (char*)dst.get_ptr();
 		//char *srcBuf = (char*)src, *dstBuf = (char*)dst;
 		//size_t srcLen = *src_len, dstLen = *dst_len;
-		size_t srcLen = src_len.GetValue(), dstLen = dst_len.GetValue();
+		size_t srcLen = *src_len, dstLen = *dst_len;
 		size_t ictd = iconv(ict, &srcBuf, &srcLen, &dstBuf, &dstLen);
-		if (ictd != src_len.GetValue())//if (ictd != *src_len)
+		if (ictd != *src_len)//if (ictd != *src_len)
 		{
 			if (errno == EILSEQ)
 				retValue = SRCIllegal;  //Invalid multi-byte sequence
diff --git a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
index 790d991a1c..dd03de2960 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
@@ -20,18 +20,18 @@ int cellNetCtlTerm()
 	return CELL_OK;
 }
 
-int cellNetCtlGetState(mem32_t state)
+int cellNetCtlGetState(vm::ptr<be_t<u32>> state)
 {
-	cellNetCtl->Log("cellNetCtlGetState(state_addr=0x%x)", state.GetAddr());
+	cellNetCtl->Log("cellNetCtlGetState(state_addr=0x%x)", state.addr());
 
-	state = CELL_NET_CTL_STATE_Disconnected; // TODO: Allow other states
+	*state = CELL_NET_CTL_STATE_Disconnected; // TODO: Allow other states
 
 	return CELL_OK;
 }
 
-int cellNetCtlAddHandler(mem_func_ptr_t<cellNetCtlHandler> handler, mem32_t arg, s32 hid)
+int cellNetCtlAddHandler(mem_func_ptr_t<cellNetCtlHandler> handler, vm::ptr<be_t<u32>> arg, s32 hid)
 {
-	cellNetCtl->Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid=%x)", handler.GetAddr(), arg.GetAddr(), hid);
+	cellNetCtl->Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid=%x)", handler.GetAddr(), arg.addr(), hid);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.h b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.h
index b4f43d0c5a..6f6b18d653 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.h
@@ -257,4 +257,4 @@ struct CellNetCtlNatInfo
 	be_t<u32> mapped_addr;
 };
 
-typedef void(*cellNetCtlHandler)(s32 prev_state, s32 new_state, s32 event, s32 error_code, mem32_t arg);
\ No newline at end of file
+typedef void(*cellNetCtlHandler)(s32 prev_state, s32 new_state, s32 event, s32 error_code, vm::ptr<be_t<u32>> arg);
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index dfd8f4d2f5..aedf3de8c9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -51,10 +51,10 @@ int cellPngDecDestroy(u32 mainHandle)
 	return CELL_OK;
 }
 
-int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo)
+int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo)
 {
 	cellPngDec->Warning("cellPngDecOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x)",
-		mainHandle, subHandle.GetAddr(), src.GetAddr(), openInfo);
+		mainHandle, subHandle.addr(), src.GetAddr(), openInfo);
 
 	CellPngDecSubHandle *current_subHandle = new CellPngDecSubHandle;
 	current_subHandle->fd = 0;
@@ -69,7 +69,7 @@ int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> s
 	case se32(CELL_PNGDEC_FILE):
 		// Get file descriptor
 		vm::var<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName_addr, 0, fd.addr(), 0, 0);
+		int ret = cellFsOpen(src->fileName_addr, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
 		current_subHandle->fd = fd->ToLE();
 		if(ret != CELL_OK) return CELL_PNGDEC_ERROR_OPEN_FILE;
 
@@ -82,15 +82,15 @@ int cellPngDecOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> s
 	}
 
 	// From now, every u32 subHandle argument is a pointer to a CellPngDecSubHandle struct.
-	subHandle = cellPngDec->GetNewId(current_subHandle);
+	*subHandle = cellPngDec->GetNewId(current_subHandle);
 
 	return CELL_OK;
 }
 
-int cellPngDecExtOpen(u32 mainHandle, mem32_t subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo, mem_ptr_t<CellPngDecCbCtrlStrm> cbCtrlStrm, mem_ptr_t<CellPngDecOpnParam> opnParam)
+int cellPngDecExtOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo, mem_ptr_t<CellPngDecCbCtrlStrm> cbCtrlStrm, mem_ptr_t<CellPngDecOpnParam> opnParam)
 {
 	cellPngDec->Warning("cellPngDecExtOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x, cbCtrlStrm_addr=0x%x, opnParam=0x%x)",
-		mainHandle, subHandle.GetAddr(), src.GetAddr(), openInfo, cbCtrlStrm.GetAddr(), opnParam.GetAddr());
+		mainHandle, subHandle.addr(), src.GetAddr(), openInfo, cbCtrlStrm.GetAddr(), opnParam.GetAddr());
 
 	cellPngDec->Warning("*** cbCtrlStrm->cbCtrlStrmFunc_addr=0x%x", cbCtrlStrm->cbCtrlStrmFunc.GetAddr());
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
index 6921eca1a5..c780234cb8 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@@ -582,23 +582,23 @@ void cellRescExit()
 	s_rescInternalInstance->m_bInitialized = false;
 }
 
-int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, mem32_t bufferMode)
+int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<be_t<u32>> bufferMode)
 {
-	cellResc->Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.GetAddr());
+	cellResc->Log("cellRescVideoOutResolutionId2RescBufferMode(resolutionId=%d, bufferMode_addr=0x%x)", resolutionId, bufferMode.addr());
 
 	switch (resolutionId)
 	{
 	case CELL_VIDEO_OUT_RESOLUTION_1080: 
-		bufferMode = CELL_RESC_1920x1080; 
+		*bufferMode = CELL_RESC_1920x1080; 
 		break;
 	case CELL_VIDEO_OUT_RESOLUTION_720:  
-		bufferMode = CELL_RESC_1280x720;  
+		*bufferMode = CELL_RESC_1280x720;  
 		break;
 	case CELL_VIDEO_OUT_RESOLUTION_480:  
-		bufferMode = CELL_RESC_720x480;   
+		*bufferMode = CELL_RESC_720x480;   
 		break;
 	case CELL_VIDEO_OUT_RESOLUTION_576:  
-		bufferMode = CELL_RESC_720x576;   
+		*bufferMode = CELL_RESC_720x576;   
 		break;
 	default: 
 		cellResc->Error("cellRescVideoOutResolutionId2RescBufferMod : CELL_RESC_ERROR_BAD_ARGUMENT");
@@ -820,9 +820,10 @@ int cellRescSetPalInterpolateDropFlexRatio(float ratio)
 	return CELL_OK;
 }
 
-int cellRescGetBufferSize(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fragmentShader)
+int cellRescGetBufferSize(vm::ptr<be_t<u32>> colorBuffers, vm::ptr<be_t<u32>> vertexArray, vm::ptr<be_t<u32>> fragmentShader)
 {
-	cellResc->Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
+	cellResc->Warning("cellRescGetBufferSize(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)",
+		colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
@@ -845,19 +846,19 @@ int cellRescGetBufferSize(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fra
 		fragmentUcodeSize = 0x300;
 	}
 
-	if (colorBuffers.GetAddr())
+	if (colorBuffers)
 	{
-		colorBuffers = colorBuffersSize;
+		*colorBuffers = colorBuffersSize;
 	}
 
-	if (vertexArray.GetAddr())
+	if (vertexArray)
 	{
-		vertexArray = vertexArraySize;
+		*vertexArray = vertexArraySize;
 	}
 
-	if (fragmentShader.GetAddr())
+	if (fragmentShader)
 	{
-		fragmentShader = fragmentUcodeSize;
+		*fragmentShader = fragmentUcodeSize;
 	}
 
 	return CELL_OK;
@@ -996,9 +997,9 @@ int cellRescSetWaitFlip()
 	return CELL_OK;
 }
 
-int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t fragmentShader)
+int cellRescSetBufferAddress(vm::ptr<be_t<u32>> colorBuffers, vm::ptr<be_t<u32>> vertexArray, vm::ptr<be_t<u32>> fragmentShader)
 {
-	cellResc->Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.GetAddr(), vertexArray.GetAddr(), fragmentShader.GetAddr());
+	cellResc->Warning("cellRescSetBufferAddress(colorBuffers_addr=0x%x, vertexArray_addr=0x%x, fragmentShader_addr=0x%x)", colorBuffers.addr(), vertexArray.addr(), fragmentShader.addr());
 
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
@@ -1006,18 +1007,18 @@ int cellRescSetBufferAddress(mem32_t colorBuffers, mem32_t vertexArray, mem32_t
 		return CELL_RESC_ERROR_NOT_INITIALIZED;
 	}
 
-	if(colorBuffers.GetAddr() % COLOR_BUFFER_ALIGNMENT || vertexArray.GetAddr() % VERTEX_BUFFER_ALIGNMENT || fragmentShader.GetAddr() % FRAGMENT_SHADER_ALIGNMENT)
+	if(colorBuffers.addr() % COLOR_BUFFER_ALIGNMENT || vertexArray.addr() % VERTEX_BUFFER_ALIGNMENT || fragmentShader.addr() % FRAGMENT_SHADER_ALIGNMENT)
 	{
 		cellResc->Error("cellRescSetBufferAddress : CELL_RESC_ERROR_BAD_ALIGNMENT");
 		return CELL_RESC_ERROR_BAD_ALIGNMENT;
 	}
 
-	s_rescInternalInstance->m_colorBuffersEA  = colorBuffers.GetAddr();
-	s_rescInternalInstance->m_vertexArrayEA   = vertexArray.GetAddr();
-	s_rescInternalInstance->m_fragmentUcodeEA = fragmentShader.GetAddr();
+	s_rescInternalInstance->m_colorBuffersEA  = colorBuffers.addr();
+	s_rescInternalInstance->m_vertexArrayEA   = vertexArray.addr();
+	s_rescInternalInstance->m_fragmentUcodeEA = fragmentShader.addr();
 
 	vm::var<be_t<u32>> dstOffset;
-	cellGcmAddressToOffset(s_rescInternalInstance->m_colorBuffersEA, dstOffset.addr());
+	cellGcmAddressToOffset(s_rescInternalInstance->m_colorBuffersEA, dstOffset);
 
 	for (int i=0; i<GetNumColorBuffers(); i++)
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.h b/rpcs3/Emu/SysCalls/Modules/cellResc.h
index e45d54a7e0..5ad753e197 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.h
@@ -153,7 +153,7 @@ CCellRescInternal* s_rescInternalInstance = nullptr;
 extern int cellGcmSetFlipMode(u32 mode);
 extern void cellGcmSetFlipHandler(u32 handler_addr);
 extern void cellGcmSetVBlankHandler(u32 handler_addr);
-extern int cellGcmAddressToOffset(u64 address, mem32_t offset);
+extern int cellGcmAddressToOffset(u64 address, vm::ptr<be_t<u32>> offset);
 extern int cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height);
 extern int cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctx, u32 id);
 extern int cellGcmSetSecondVFrequency(u32 freq);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
index dacc5c65ad..6449393eba 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
@@ -314,13 +314,13 @@ int cellRtcConvertLocalTimeToUtc(mem_ptr_t<CellRtcTick> pLocalTime, mem_ptr_t<Ce
 	return CELL_OK;
 }
 
-int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, mem32_t puiDosTime)
+int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<u32>> puiDosTime)
 {
-	cellRtc->Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.GetAddr(), puiDosTime.GetAddr());
+	cellRtc->Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.GetAddr(), puiDosTime.addr());
 
 	// Convert to DOS time.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
-	puiDosTime = date_time.GetAsDOS();
+	*puiDosTime = date_time.GetAsDOS();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index 6d0e93bbdb..506152dfe0 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -157,10 +157,10 @@ s64 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, v
 #endif
 }
 
-s64 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, mem32_t group)
+s64 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> group)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetSpuThreadGroupId(spurs_addr=0x%x, group_addr=0x%x)", spurs.GetAddr(), group.GetAddr());
+	cellSpurs->Warning("cellSpursGetSpuThreadGroupId(spurs_addr=0x%x, group_addr=0x%x)", spurs.GetAddr(), group.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8B30, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -168,10 +168,10 @@ s64 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, mem32_t group)
 #endif
 }
 
-s64 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, mem32_t nThreads)
+s64 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> nThreads)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetNumSpuThread(spurs_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), nThreads.GetAddr());
+	cellSpurs->Warning("cellSpursGetNumSpuThread(spurs_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), nThreads.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8B78, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -179,10 +179,10 @@ s64 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, mem32_t nThreads)
 #endif
 }
 
-s64 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, mem32_t thread, mem32_t nThreads)
+s64 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> thread, vm::ptr<be_t<u32>> nThreads)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetSpuThreadId(spurs_addr=0x%x, thread_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), thread.GetAddr(), nThreads.GetAddr());
+	cellSpurs->Warning("cellSpursGetSpuThreadId(spurs_addr=0x%x, thread_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), thread.addr(), nThreads.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8A98, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -369,10 +369,10 @@ s64 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<b
 #endif
 }
 
-s64 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, mem32_t direction)
+s64 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u32>> direction)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagGetDirection(eventFlag_addr=0x%x, direction_addr=0x%x)", eventFlag.GetAddr(), direction.GetAddr());
+	cellSpurs->Warning("cellSpursEventFlagGetDirection(eventFlag_addr=0x%x, direction_addr=0x%x)", eventFlag.GetAddr(), direction.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x162C4, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -380,10 +380,10 @@ s64 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, mem3
 #endif
 }
 
-s64 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, mem32_t clear_mode)
+s64 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u32>> clear_mode)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagGetClearMode(eventFlag_addr=0x%x, clear_mode_addr=0x%x)", eventFlag.GetAddr(), clear_mode.GetAddr());
+	cellSpurs->Warning("cellSpursEventFlagGetClearMode(eventFlag_addr=0x%x, clear_mode_addr=0x%x)", eventFlag.GetAddr(), clear_mode.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x16310, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -736,10 +736,10 @@ s64 cellSpursJoinTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 #endif
 }
 
-s64 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, mem32_t workloadId)
+s64 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, vm::ptr<be_t<u32>> workloadId)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetTasksetId(taskset_addr=0x%x, workloadId_addr=0x%x)", taskset.GetAddr(), workloadId.GetAddr());
+	cellSpurs->Warning("cellSpursGetTasksetId(taskset_addr=0x%x, workloadId_addr=0x%x)", taskset.GetAddr(), workloadId.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x14EA0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -758,12 +758,12 @@ s64 cellSpursShutdownTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 #endif
 }
 
-s64 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, mem32_t taskID, u32 elf_addr, u32 context_addr, u32 context_size, mem_ptr_t<CellSpursTaskLsPattern> lsPattern,
+s64 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, vm::ptr<be_t<u32>> taskID, u32 elf_addr, u32 context_addr, u32 context_size, mem_ptr_t<CellSpursTaskLsPattern> lsPattern,
 	mem_ptr_t<CellSpursTaskArgument> argument)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursCreateTask(taskset_addr=0x%x, taskID_addr=0x%x, elf_addr_addr=0x%x, context_addr_addr=0x%x, context_size=%d, lsPattern_addr=0x%x, argument_addr=0x%x)",
-		taskset.GetAddr(), taskID.GetAddr(), elf_addr, context_addr, context_size, lsPattern.GetAddr(), argument.GetAddr());
+		taskset.GetAddr(), taskID.addr(), elf_addr, context_addr, context_size, lsPattern.GetAddr(), argument.GetAddr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x12414, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index 7c0bc1b0f5..1daae5a56b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -1293,14 +1293,14 @@ s32 syncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32
 	assert(0);
 }
 
-s32 _cellSyncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPushPointer(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> pointer, u32 isBlocking, u32 useEventQueue)
 {
 	cellSync->Todo("_cellSyncLFQueueGetPushPointer(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)",
-		queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue);
+		queue.addr(), pointer.addr(), isBlocking, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPushPointer(queue, pointer_value, isBlocking, useEventQueue);
-	pointer = pointer_value;
+	*pointer = pointer_value;
 	return result;
 }
 
@@ -1312,15 +1312,15 @@ s32 syncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPushPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// arguments copied from _cellSyncLFQueueGetPushPointer
 	cellSync->Todo("_cellSyncLFQueueGetPushPointer2(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)",
-		queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue);
+		queue.addr(), pointer.addr(), isBlocking, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPushPointer2(queue, pointer_value, isBlocking, useEventQueue);
-	pointer = pointer_value;
+	*pointer = pointer_value;
 	return result;
 }
 
@@ -1687,14 +1687,14 @@ s32 syncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32 i
 	assert(0);
 }
 
-s32 _cellSyncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 arg4, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPopPointer(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> pointer, u32 isBlocking, u32 arg4, u32 useEventQueue)
 {
 	cellSync->Todo("_cellSyncLFQueueGetPopPointer(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, arg4=%d, useEventQueue=%d)",
-		queue.addr(), pointer.GetAddr(), isBlocking, arg4, useEventQueue);
+		queue.addr(), pointer.addr(), isBlocking, arg4, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPopPointer(queue, pointer_value, isBlocking, arg4, useEventQueue);
-	pointer = pointer_value;
+	*pointer = pointer_value;
 	return result;
 }
 
@@ -1706,15 +1706,15 @@ s32 syncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, s32& pointer, u32
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, mem32_t pointer, u32 isBlocking, u32 useEventQueue)
+s32 _cellSyncLFQueueGetPopPointer2(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> pointer, u32 isBlocking, u32 useEventQueue)
 {
 	// arguments copied from _cellSyncLFQueueGetPopPointer
 	cellSync->Todo("_cellSyncLFQueueGetPopPointer2(queue_addr=0x%x, pointer_addr=0x%x, isBlocking=%d, useEventQueue=%d)",
-		queue.addr(), pointer.GetAddr(), isBlocking, useEventQueue);
+		queue.addr(), pointer.addr(), isBlocking, useEventQueue);
 
 	s32 pointer_value;
 	s32 result = syncLFQueueGetPopPointer2(queue, pointer_value, isBlocking, useEventQueue);
-	pointer = pointer_value;
+	*pointer = pointer_value;
 	return result;
 }
 
@@ -2020,11 +2020,11 @@ s32 cellSyncLFQueueClear(vm::ptr<CellSyncLFQueue> queue)
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, mem32_t size)
+s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> size)
 {
-	cellSync->Warning("cellSyncLFQueueSize(queue_addr=0x%x, size_addr=0x%x)", queue.addr(), size.GetAddr());
+	cellSync->Warning("cellSyncLFQueueSize(queue_addr=0x%x, size_addr=0x%x)", queue.addr(), size.addr());
 
-	if (!queue || !size.GetAddr())
+	if (!queue || !size)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
@@ -2045,11 +2045,11 @@ s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, mem32_t size)
 		{
 			if (var1 <= var2)
 			{
-				size = var2 - var1;
+				*size = var2 - var1;
 			}
 			else
 			{
-				size = var2 - var1 + (u32)queue->m_depth * 2;
+				*size = var2 - var1 + (u32)queue->m_depth * 2;
 			}
 			return CELL_OK;
 		}
@@ -2058,11 +2058,11 @@ s32 cellSyncLFQueueSize(vm::ptr<CellSyncLFQueue> queue, mem32_t size)
 	assert(0);
 }
 
-s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, mem32_t depth)
+s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> depth)
 {
-	cellSync->Log("cellSyncLFQueueDepth(queue_addr=0x%x, depth_addr=0x%x)", queue.addr(), depth.GetAddr());
+	cellSync->Log("cellSyncLFQueueDepth(queue_addr=0x%x, depth_addr=0x%x)", queue.addr(), depth.addr());
 
-	if (!queue || !depth.GetAddr())
+	if (!queue || !depth)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
@@ -2071,15 +2071,15 @@ s32 cellSyncLFQueueDepth(vm::ptr<CellSyncLFQueue> queue, mem32_t depth)
 		return CELL_SYNC_ERROR_ALIGN;
 	}
 
-	depth = queue->m_depth;
+	*depth = queue->m_depth;
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, mem32_t ppSignal)
+s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<u32>> ppSignal)
 {
-	cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.GetAddr());
+	cellSync->Log("_cellSyncLFQueueGetSignalAddress(queue_addr=0x%x, ppSignal_addr=0x%x)", queue.addr(), ppSignal.addr());
 
-	if (!queue || !ppSignal.GetAddr())
+	if (!queue || !ppSignal)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
@@ -2088,15 +2088,15 @@ s32 _cellSyncLFQueueGetSignalAddress(vm::ptr<CellSyncLFQueue> queue, mem32_t ppS
 		return CELL_SYNC_ERROR_ALIGN;
 	}
 
-	ppSignal = (u32)queue->m_eaSignal;
+	*ppSignal = (u32)queue->m_eaSignal;
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, mem32_t direction)
+s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, vm::ptr<be_t<CellSyncQueueDirection>> direction)
 {
-	cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.GetAddr());
+	cellSync->Log("cellSyncLFQueueGetDirection(queue_addr=0x%x, direction_addr=0x%x)", queue.addr(), direction.addr());
 
-	if (!queue || !direction.GetAddr())
+	if (!queue || !direction)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
@@ -2105,15 +2105,15 @@ s32 cellSyncLFQueueGetDirection(vm::ptr<CellSyncLFQueue> queue, mem32_t directio
 		return CELL_SYNC_ERROR_ALIGN;
 	}
 
-	direction = queue->m_direction;
+	*direction = queue->m_direction;
 	return CELL_OK;
 }
 
-s32 cellSyncLFQueueGetEntrySize(vm::ptr<CellSyncLFQueue> queue, mem32_t entry_size)
+s32 cellSyncLFQueueGetEntrySize(vm::ptr<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.GetAddr());
+	cellSync->Log("cellSyncLFQueueGetEntrySize(queue_addr=0x%x, entry_size_addr=0x%x)", queue.addr(), entry_size.addr());
 
-	if (!queue || !entry_size.GetAddr())
+	if (!queue || !entry_size)
 	{
 		return CELL_SYNC_ERROR_NULL_POINTER;
 	}
@@ -2122,7 +2122,7 @@ s32 cellSyncLFQueueGetEntrySize(vm::ptr<CellSyncLFQueue> queue, mem32_t entry_si
 		return CELL_SYNC_ERROR_ALIGN;
 	}
 
-	entry_size = queue->m_size;
+	*entry_size = queue->m_size;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
index db188a6970..8ad66a0c32 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
@@ -24,85 +24,85 @@ typedef void (*CellHddGameStatCallback)(mem_ptr_t<CellHddGameCBResult> cbResult,
 //Module cellSysutil(0x0015, cellSysutil_init);
 Module *cellSysutil = nullptr;
 
-int cellSysutilGetSystemParamInt(int id, mem32_t value)
+int cellSysutilGetSystemParamInt(int id, vm::ptr<be_t<u32>> value)
 {
-	cellSysutil->Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.GetAddr());
+	cellSysutil->Log("cellSysutilGetSystemParamInt(id=0x%x, value_addr=0x%x)", id, value.addr());
 
 	switch(id)
 	{
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_LANG:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_LANG");
-		value = Ini.SysLanguage.GetValue();
+		*value = Ini.SysLanguage.GetValue();
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_ENTER_BUTTON_ASSIGN");
-		value = CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS;
+		*value = CELL_SYSUTIL_ENTER_BUTTON_ASSIGN_CROSS;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_DATE_FORMAT");
-		value = CELL_SYSUTIL_DATE_FMT_DDMMYYYY;
+		*value = CELL_SYSUTIL_DATE_FMT_DDMMYYYY;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIME_FORMAT");
-		value = CELL_SYSUTIL_TIME_FMT_CLOCK24;
+		*value = CELL_SYSUTIL_TIME_FMT_CLOCK24;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE");
-		value = 3;
+		*value = 3;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_SUMMERTIME");
-		value = 1;
+		*value = 1;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL");
-		value = CELL_SYSUTIL_GAME_PARENTAL_OFF;
+		*value = CELL_SYSUTIL_GAME_PARENTAL_OFF;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_GAME_PARENTAL_LEVEL0_RESTRICT");
-		value = CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF;
+		*value = CELL_SYSUTIL_GAME_PARENTAL_LEVEL0_RESTRICT_OFF;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CURRENT_USER_HAS_NP_ACCOUNT");
-		value = 0;
+		*value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CAMERA_PLFREQ");
-		value = CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED;
+		*value = CELL_SYSUTIL_CAMERA_PLFREQ_DISABLED;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_RUMBLE");
-		value = CELL_SYSUTIL_PAD_RUMBLE_OFF;
+		*value = CELL_SYSUTIL_PAD_RUMBLE_OFF;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_KEYBOARD_TYPE");
-		value = 0;
+		*value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_JAPANESE_KEYBOARD_ENTRY_METHOD");
-		value = 0;
+		*value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_CHINESE_KEYBOARD_ENTRY_METHOD");
-		value = 0;
+		*value = 0;
 	break;
 
 	case CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF:
 		cellSysutil->Warning("cellSysutilGetSystemParamInt: CELL_SYSUTIL_SYSTEMPARAM_ID_PAD_AUTOOFF");
-		value = 0;
+		*value = 0;
 	break;
 
 	default:
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index da5dce0882..8066857f18 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -966,7 +966,7 @@ int cellSaveDataFixedExport() //const char *dirName, u32 maxSizeKB, CellSaveData
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataGetListItem() //const char *dirName, CellSaveDataDirStat *dir, CellSaveDataSystemFileParam *sysFileParam, mem32_t bind, mem32_t sizeKB
+int cellSaveDataGetListItem() //const char *dirName, CellSaveDataDirStat *dir, CellSaveDataSystemFileParam *sysFileParam, vm::ptr<be_t<u32>> bind, vm::ptr<be_t<u32>> sizeKB
 {
 	UNIMPLEMENTED_FUNC(cellSysutil);
 	return CELL_SAVEDATA_RET_OK;
@@ -1002,7 +1002,7 @@ int cellSaveDataUserFixedExport() //CellSysutilUserId userId, const char *dirNam
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataUserGetListItem() //CellSysutilUserId userId, const char *dirName, CellSaveDataDirStat *dir, CellSaveDataSystemFileParam *sysFileParam, mem32_t bind, mem32_t sizeKB
+int cellSaveDataUserGetListItem() //CellSysutilUserId userId, const char *dirName, CellSaveDataDirStat *dir, CellSaveDataSystemFileParam *sysFileParam, vm::ptr<be_t<u32>> bind, vm::ptr<be_t<u32>> sizeKB
 {
 	UNIMPLEMENTED_FUNC(cellSysutil);
 	return CELL_SAVEDATA_RET_OK;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
index 490642db67..3bf5a379af 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
@@ -57,21 +57,21 @@ int cellUserInfoEnableOverlay()
 	return CELL_OK;
 }
 
-int cellUserInfoGetList(mem32_t listNum, mem_ptr_t<CellUserInfoUserList> listBuf, mem32_t currentUserId)
+int cellUserInfoGetList(vm::ptr<be_t<u32>> listNum, mem_ptr_t<CellUserInfoUserList> listBuf, vm::ptr<be_t<u32>> currentUserId)
 {
 	cellUserInfo->Warning("cellUserInfoGetList(listNum_addr=0x%x, listBuf_addr=0x%x, currentUserId_addr=0x%x)",
-		listNum.GetAddr(), listBuf.GetAddr(), currentUserId.GetAddr());
+		listNum.addr(), listBuf.GetAddr(), currentUserId.addr());
 
 	// If only listNum is NULL, an error will be returned
-	if (listBuf.GetAddr() && !listNum.GetAddr())
+	if (listBuf && !listNum)
 		return CELL_USERINFO_ERROR_PARAM;
-	if (listNum.GetAddr())
-		listNum = 1;
-	if (listBuf.GetAddr())
+	if (listNum)
+		*listNum = 1;
+	if (listBuf)
 		listBuf->userId[0] = 1;
 
-	if (currentUserId.GetAddr())
-		currentUserId = 1;
+	if (currentUserId)
+		*currentUserId = 1;
 	
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
index b558b6b20d..7319219289 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
@@ -496,22 +496,22 @@ int cellVdecQueryAttrEx(const mem_ptr_t<CellVdecTypeEx> type, mem_ptr_t<CellVdec
 	return vdecQueryAttr(type->codecType, type->profileLevel, type->codecSpecificInfo_addr, attr);
 }
 
-int cellVdecOpen(const mem_ptr_t<CellVdecType> type, const mem_ptr_t<CellVdecResource> res, const mem_ptr_t<CellVdecCb> cb, mem32_t handle)
+int cellVdecOpen(const mem_ptr_t<CellVdecType> type, const mem_ptr_t<CellVdecResource> res, const mem_ptr_t<CellVdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellVdec->Warning("cellVdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr());
+		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
 
-	handle = vdecOpen(new VideoDecoder(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
+	*handle = vdecOpen(new VideoDecoder(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
 
 	return CELL_OK;
 }
 
-int cellVdecOpenEx(const mem_ptr_t<CellVdecTypeEx> type, const mem_ptr_t<CellVdecResourceEx> res, const mem_ptr_t<CellVdecCb> cb, mem32_t handle)
+int cellVdecOpenEx(const mem_ptr_t<CellVdecTypeEx> type, const mem_ptr_t<CellVdecResourceEx> res, const mem_ptr_t<CellVdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellVdec->Warning("cellVdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.GetAddr());
+		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
 
-	handle = vdecOpen(new VideoDecoder(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
+	*handle = vdecOpen(new VideoDecoder(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
 
 	return CELL_OK;
 }
@@ -670,9 +670,9 @@ int cellVdecGetPicture(u32 handle, const mem_ptr_t<CellVdecPicFormat> format, u3
 	return CELL_OK;
 }
 
-int cellVdecGetPicItem(u32 handle, mem32_t picItem_ptr)
+int cellVdecGetPicItem(u32 handle, vm::ptr<be_t<u32>> picItem_ptr)
 {
-	cellVdec->Log("cellVdecGetPicItem(handle=%d, picItem_ptr_addr=0x%x)", handle, picItem_ptr.GetAddr());
+	cellVdec->Log("cellVdecGetPicItem(handle=%d, picItem_ptr_addr=0x%x)", handle, picItem_ptr.addr());
 
 	VideoDecoder* vdec;
 	if (!Emu.GetIdManager().GetIDData(handle, vdec))
@@ -775,7 +775,7 @@ int cellVdecGetPicItem(u32 handle, mem32_t picItem_ptr)
 	avc->reserved[0] = 0;
 	avc->reserved[1] = 0;
 	
-	picItem_ptr = info.GetAddr();
+	*picItem_ptr = info.GetAddr();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
index 038fb4b891..d35ead7ac9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
@@ -37,23 +37,23 @@ u32 vpostOpen(VpostInstance* data)
 	return id;
 }
 
-int cellVpostOpen(const mem_ptr_t<CellVpostCfgParam> cfgParam, const mem_ptr_t<CellVpostResource> resource, mem32_t handle)
+int cellVpostOpen(const mem_ptr_t<CellVpostCfgParam> cfgParam, const mem_ptr_t<CellVpostResource> resource, vm::ptr<be_t<u32>> handle)
 {
 	cellVpost->Warning("cellVpostOpen(cfgParam_addr=0x%x, resource_addr=0x%x, handle_addr=0x%x)",
-		cfgParam.GetAddr(), resource.GetAddr(), handle.GetAddr());
+		cfgParam.GetAddr(), resource.GetAddr(), handle.addr());
 
 	// TODO: check values
-	handle = vpostOpen(new VpostInstance(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV));
+	*handle = vpostOpen(new VpostInstance(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV));
 	return CELL_OK;
 }
 
-int cellVpostOpenEx(const mem_ptr_t<CellVpostCfgParam> cfgParam, const mem_ptr_t<CellVpostResourceEx> resource, mem32_t handle)
+int cellVpostOpenEx(const mem_ptr_t<CellVpostCfgParam> cfgParam, const mem_ptr_t<CellVpostResourceEx> resource, vm::ptr<be_t<u32>> handle)
 {
 	cellVpost->Warning("cellVpostOpenEx(cfgParam_addr=0x%x, resource_addr=0x%x, handle_addr=0x%x)",
-		cfgParam.GetAddr(), resource.GetAddr(), handle.GetAddr());
+		cfgParam.GetAddr(), resource.GetAddr(), handle.addr());
 
 	// TODO: check values
-	handle = vpostOpen(new VpostInstance(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV));
+	*handle = vpostOpen(new VpostInstance(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV));
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index 8e8cc73628..48044586e9 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -141,10 +141,10 @@ int cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePort
 	return CELL_OK;
 }
  
-int cellSSPlayerCreate(mem32_t handle, mem_ptr_t<CellSSPlayerConfig> config)
+int cellSSPlayerCreate(vm::ptr<be_t<u32>> handle, mem_ptr_t<CellSSPlayerConfig> config)
 {
 	libmixer->Warning("cellSSPlayerCreate(handle_addr=0x%x, config_addr=0x%x)",
-		handle.GetAddr(), config.GetAddr());
+		handle.addr(), config.GetAddr());
 
 	if (config->outputMode != 0 || config->channels - 1 >= 2)
 	{
@@ -162,7 +162,7 @@ int cellSSPlayerCreate(mem32_t handle, mem_ptr_t<CellSSPlayerConfig> config)
 	p.m_channels = config->channels;
 	
 	ssp.push_back(p);
-	handle = (u32)ssp.size() - 1;
+	*handle = (u32)ssp.size() - 1;
 	return CELL_OK;
 }
 
@@ -463,17 +463,17 @@ int cellSurMixerCreate(const mem_ptr_t<CellSurMixerConfig> config)
 	return CELL_OK;
 }
 
-int cellSurMixerGetAANHandle(mem32_t handle)
+int cellSurMixerGetAANHandle(vm::ptr<be_t<u32>> handle)
 {
-	libmixer->Warning("cellSurMixerGetAANHandle(handle_addr=0x%x) -> %d", handle.GetAddr(), 0x11111111);
-	handle = 0x11111111;
+	libmixer->Warning("cellSurMixerGetAANHandle(handle_addr=0x%x) -> %d", handle.addr(), 0x11111111);
+	*handle = 0x11111111;
 	return CELL_OK;
 }
 
-int cellSurMixerChStripGetAANPortNo(mem32_t port, u32 type, u32 index)
+int cellSurMixerChStripGetAANPortNo(vm::ptr<be_t<u32>> port, u32 type, u32 index)
 {
-	libmixer->Warning("cellSurMixerChStripGetAANPortNo(port_addr=0x%x, type=0x%x, index=0x%x) -> 0x%x", port.GetAddr(), type, index, (type << 16) | index);
-	port = (type << 16) | index;
+	libmixer->Warning("cellSurMixerChStripGetAANPortNo(port_addr=0x%x, type=0x%x, index=0x%x) -> 0x%x", port.addr(), type, index, (type << 16) | index);
+	*port = (type << 16) | index;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNp.cpp b/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
index 55d41b82c6..c89c1a76e1 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNp.cpp
@@ -183,14 +183,14 @@ int sceNpDrmGetTimelimit(u32 drm_path_addr, vm::ptr<be_t<u64>> time_remain_usec)
 	return CELL_OK;
 }
 
-int sceNpManagerGetStatus(mem32_t status)
+int sceNpManagerGetStatus(vm::ptr<be_t<u32>> status)
 {
-	sceNp->Log("sceNpManagerGetStatus(status_addr=0x%x)", status.GetAddr());
+	sceNp->Log("sceNpManagerGetStatus(status_addr=0x%x)", status.addr());
 
 	// TODO: Check if sceNpInit() was called, if not return SCE_NP_ERROR_NOT_INITIALIZED
 
 	// TODO: Support different statuses
-	status = SCE_NP_MANAGER_STATUS_OFFLINE;
+	*status = SCE_NP_MANAGER_STATUS_OFFLINE;
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
index e5323b3dbf..9b7b6b1bb0 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
@@ -85,10 +85,10 @@ int sceNpTrophyInit(u32 pool_addr, u32 poolSize, u32 containerId, u64 options)
 	return CELL_OK;
 }
 
-int sceNpTrophyCreateContext(mem32_t context, mem_ptr_t<SceNpCommunicationId> commID, mem_ptr_t<SceNpCommunicationSignature> commSign, u64 options)
+int sceNpTrophyCreateContext(vm::ptr<be_t<u32>> context, mem_ptr_t<SceNpCommunicationId> commID, mem_ptr_t<SceNpCommunicationSignature> commSign, u64 options)
 {
 	sceNpTrophy->Warning("sceNpTrophyCreateContext(context_addr=0x%x, commID_addr=0x%x, commSign_addr=0x%x, options=0x%llx)",
-		context.GetAddr(), commID.GetAddr(), commSign.GetAddr(), options);
+		context.addr(), commID.GetAddr(), commSign.GetAddr(), options);
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -123,9 +123,9 @@ int sceNpTrophyCreateContext(mem32_t context, mem_ptr_t<SceNpCommunicationId> co
 	return SCE_NP_TROPHY_ERROR_CONF_DOES_NOT_EXIST;
 }
 
-int sceNpTrophyCreateHandle(mem32_t handle)
+int sceNpTrophyCreateHandle(vm::ptr<be_t<u32>> handle)
 {
-	sceNpTrophy->Warning("sceNpTrophyCreateHandle(handle_addr=0x%x)", handle.GetAddr());
+	sceNpTrophy->Warning("sceNpTrophyCreateHandle(handle_addr=0x%x)", handle.addr());
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -302,10 +302,10 @@ int sceNpTrophyDestroyHandle()
 	return CELL_OK;
 }
 
-int sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, mem32_t platinumId)
+int sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, vm::ptr<be_t<u32>> platinumId)
 {
 	sceNpTrophy->Warning("sceNpTrophyUnlockTrophy(context=%d, handle=%d, trophyId=%d, platinumId_addr=0x%x)",
-		context, handle, trophyId, platinumId.GetAddr());
+		context, handle, trophyId, platinumId.addr());
 	
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -323,7 +323,7 @@ int sceNpTrophyUnlockTrophy(u32 context, u32 handle, s32 trophyId, mem32_t plati
 	std::string trophyPath = "/dev_hdd0/home/00000001/trophy/" + ctxt.trp_name + "/TROPUSR.DAT";
 	ctxt.tropusr->Save(trophyPath);
 
-	platinumId = SCE_NP_TROPHY_INVALID_TROPHY_ID; // TODO
+	*platinumId = SCE_NP_TROPHY_INVALID_TROPHY_ID; // TODO
 	return CELL_OK;
 }
 
@@ -333,22 +333,22 @@ int sceNpTrophyTerm()
 	return CELL_OK;
 }
 
-int sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, mem_ptr_t<SceNpTrophyFlagArray> flags, mem32_t count)
+int sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, mem_ptr_t<SceNpTrophyFlagArray> flags, vm::ptr<be_t<u32>> count)
 {
 	sceNpTrophy->Warning("sceNpTrophyGetTrophyUnlockState(context=%d, handle=%d, flags_addr=0x%x, count_addr=0x%x)",
-		context, handle, flags.GetAddr(), count.GetAddr());
+		context, handle, flags.GetAddr(), count.addr());
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
 	// TODO: There are other possible errors
 
 	sceNpTrophyInternalContext& ctxt = s_npTrophyInstance.contexts[context];
-	count = ctxt.tropusr->GetTrophiesCount();
-	if (count.GetValue() > 128)
+	*count = ctxt.tropusr->GetTrophiesCount();
+	if (*count > 128)
 		sceNpTrophy->Warning("sceNpTrophyGetTrophyUnlockState: More than 128 trophies detected!");
 
 	// Pack up to 128 bools in u32 flag_bits[4]
-	for (u32 id=0; id<count.GetValue(); id++)
+	for (u32 id=0; id<*count; id++)
 	{
 		if (ctxt.tropusr->GetTrophyUnlockState(id))
 			flags->flag_bits[id/32] |= 1<<(id%32);
diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
index 3779de5299..377cd87522 100644
--- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
@@ -83,15 +83,15 @@ s64 sys_prx_exitspawn_with_level()
 	return CELL_OK;
 }
 
-int sys_spu_elf_get_information(u32 elf_img, mem32_t entry, mem32_t nseg)
+int sys_spu_elf_get_information(u32 elf_img, vm::ptr<be_t<u32>> entry, vm::ptr<be_t<u32>> nseg)
 {
-	sysPrxForUser->Warning("sys_spu_elf_get_information(elf_img=0x%x, entry_addr=0x%x, nseg_addr=0x%x", elf_img, entry.GetAddr(), nseg.GetAddr());
+	sysPrxForUser->Todo("sys_spu_elf_get_information(elf_img=0x%x, entry_addr=0x%x, nseg_addr=0x%x", elf_img, entry.addr(), nseg.addr());
 	return CELL_OK;
 }
 
 int sys_spu_elf_get_segments(u32 elf_img, mem_ptr_t<sys_spu_segment> segments, int nseg)
 {
-	sysPrxForUser->Warning("sys_spu_elf_get_segments(elf_img=0x%x, segments_addr=0x%x, nseg=0x%x)", elf_img, segments.GetAddr(), nseg);
+	sysPrxForUser->Todo("sys_spu_elf_get_segments(elf_img=0x%x, segments_addr=0x%x, nseg=0x%x)", elf_img, segments.GetAddr(), nseg);
 	return CELL_OK;
 }
 
@@ -117,11 +117,11 @@ int sys_spu_image_close(mem_ptr_t<sys_spu_image> img)
 	return CELL_OK;
 }
 
-int sys_raw_spu_load(int id, u32 path_addr, mem32_t entry)
+int sys_raw_spu_load(int id, u32 path_addr, vm::ptr<be_t<u32>> entry)
 {
 	const std::string path = Memory.ReadString(path_addr);
 	sysPrxForUser->Warning("sys_raw_spu_load(id=0x%x, path=0x%x [%s], entry_addr=0x%x)", 
-		id, path_addr, path.c_str(), entry.GetAddr());
+		id, path_addr, path.c_str(), entry.addr());
 
 	vfsFile f(path);
 	if(!f.IsOpened())
@@ -134,7 +134,7 @@ int sys_raw_spu_load(int id, u32 path_addr, mem32_t entry)
 	l.LoadInfo();
 	l.LoadData(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id);
 
-	entry = l.GetEntry();
+	*entry = l.GetEntry();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
index e1bcc7956e..fb0fd704b5 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
@@ -110,11 +110,11 @@ int sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 }
 	
 
-int cellFsSdataOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
+int cellFsSdataOpen(u32 path_addr, int flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
 {
 	const std::string& path = Memory.ReadString(path_addr);
 	sys_fs->Warning("cellFsSdataOpen(path=\"%s\", flags=0x%x, fd_addr=0x%x, arg_addr=0x%x, size=0x%llx) -> cellFsOpen()",
-		path.c_str(), flags, fd.GetAddr(), arg.GetAddr(), size);
+		path.c_str(), flags, fd.addr(), arg.addr(), size);
 
 	/*if (flags != CELL_O_RDONLY)
 		return CELL_EINVAL;
@@ -136,9 +136,10 @@ int cellFsSdataOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 	return cellFsOpen(path_addr, flags, fd, arg, size);
 }
 
-int cellFsSdataOpenByFd(int mself_fd, int flags, mem32_t sdata_fd, u64 offset, mem32_t arg, u64 size)
+int cellFsSdataOpenByFd(int mself_fd, int flags, vm::ptr<be_t<u32>> sdata_fd, u64 offset, vm::ptr<be_t<u32>> arg, u64 size)
 {
-	sys_fs->Todo("cellFsSdataOpenByFd(mself_fd=0x%x, flags=0x%x, sdata_fd_addr=0x%x, offset=0x%llx, arg_addr=0x%x, size=0x%llx) -> cellFsOpen()", mself_fd, flags, sdata_fd.GetAddr(), offset, arg.GetAddr(), size);
+	sys_fs->Todo("cellFsSdataOpenByFd(mself_fd=0x%x, flags=0x%x, sdata_fd_addr=0x%x, offset=0x%llx, arg_addr=0x%x, size=0x%llx) -> cellFsOpen()",
+		mself_fd, flags, sdata_fd.addr(), offset, arg.addr(), size);
 
 	// TODO:
 
@@ -198,9 +199,9 @@ void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*
 	g_FsAioReadCur++;
 }
 
-int cellFsAioRead(mem_ptr_t<CellFsAio> aio, mem32_t aio_id, mem_func_ptr_t<void (*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
+int cellFsAioRead(mem_ptr_t<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, mem_func_ptr_t<void(*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
 {
-	sys_fs->Warning("cellFsAioRead(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.GetAddr(), func.GetAddr());
+	sys_fs->Warning("cellFsAioRead(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.addr(), func.GetAddr());
 
 	if (!aio_init)
 	{
@@ -217,7 +218,7 @@ int cellFsAioRead(mem_ptr_t<CellFsAio> aio, mem32_t aio_id, mem_func_ptr_t<void
 
 	//get a unique id for the callback (may be used by cellFsAioCancel)
 	const u32 xid = g_FsAioReadID++;
-	aio_id = xid;
+	*aio_id = xid;
 
 	{
 		thread t("fsAioRead", std::bind(fsAioRead, fd, aio, xid, func));
@@ -227,9 +228,9 @@ int cellFsAioRead(mem_ptr_t<CellFsAio> aio, mem32_t aio_id, mem_func_ptr_t<void
 	return CELL_OK;
 }
 
-int cellFsAioWrite(mem_ptr_t<CellFsAio> aio, mem32_t aio_id, mem_func_ptr_t<void(*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
+int cellFsAioWrite(mem_ptr_t<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, mem_func_ptr_t<void(*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
 {
-	sys_fs->Todo("cellFsAioWrite(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.GetAddr(), func.GetAddr());
+	sys_fs->Todo("cellFsAioWrite(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.addr(), func.GetAddr());
 
 	// TODO:
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_io.cpp b/rpcs3/Emu/SysCalls/Modules/sys_io.cpp
index 02821baeba..527cf543b6 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_io.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_io.cpp
@@ -23,7 +23,7 @@ extern int cellPadInfoPressMode(u32 port_no);
 extern int cellPadInfoSensorMode(u32 port_no);
 extern int cellPadSetPressMode(u32 port_no, u32 mode);
 extern int cellPadSetSensorMode(u32 port_no, u32 mode);
-extern int cellPadGetCapabilityInfo(u32 port_no, mem32_t info_addr);
+extern int cellPadGetCapabilityInfo(u32 port_no, vm::ptr<be_t<u32>> info_addr);
 
 void sys_io_init()
 {
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
index 94d91af602..fa20136f5c 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
@@ -21,7 +21,7 @@ extern "C"
 //Module sys_net((u16)0x0000, sys_net_init);
 Module *sys_net = nullptr;
 
-mem32_t g_lastError(0);
+vm::ptr<be_t<s32>> g_lastError = vm::ptr<be_t<s32>>::make(0);
 
 
 // Auxiliary Functions
@@ -94,21 +94,21 @@ using pck_len_t = u32;
 #endif
 
 // Functions
-int sys_net_accept(s32 s, mem_ptr_t<sys_net_sockaddr> addr, mem32_t paddrlen)
+int sys_net_accept(s32 s, mem_ptr_t<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> paddrlen)
 {
-	sys_net->Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.GetAddr(), paddrlen.GetAddr());
+	sys_net->Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.GetAddr(), paddrlen.addr());
 	if (addr.GetAddr() == 0) {
 		int ret = accept(s, NULL, NULL);
-		g_lastError = getLastError();
+		*g_lastError = getLastError();
 		return ret;
 	}
 	else {
 		sockaddr _addr;
 		memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
 		_addr.sa_family = addr->sa_family;
-		pck_len_t *_paddrlen = (pck_len_t *)Memory.VirtualToRealAddr(paddrlen.GetAddr());
+		pck_len_t *_paddrlen = (pck_len_t *)Memory.VirtualToRealAddr(paddrlen.addr());
 		int ret = accept(s, &_addr, _paddrlen);
-		g_lastError = getLastError();
+		*g_lastError = getLastError();
 		return ret;
 	}
 }
@@ -122,7 +122,7 @@ int sys_net_bind(s32 s, mem_ptr_t<sys_net_sockaddr_in> addr, u32 addrlen)
 	const char *ipaddr = inet_ntoa(saddr.sin_addr);
 	sys_net->Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
 	int ret = bind(s, (const sockaddr *)&saddr, addrlen);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -135,7 +135,7 @@ int sys_net_connect(s32 s, mem_ptr_t<sys_net_sockaddr_in> addr, u32 addrlen)
 	const char *ipaddr = inet_ntoa(saddr.sin_addr);
 	sys_net->Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
 	int ret = connect(s, (const sockaddr *) &saddr, addrlen);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -229,7 +229,7 @@ int sys_net_listen(s32 s, s32 backlog)
 {
 	sys_net->Warning("listen(s=%d, backlog=%d)", s, backlog);
 	int ret = listen(s, backlog);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -238,22 +238,22 @@ int sys_net_recv(s32 s, u32 buf_addr, u32 len, s32 flags)
 	sys_net->Warning("recv(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf_addr, len, flags);
 	char *buf = (char *)Memory.VirtualToRealAddr(buf_addr);
 	int ret = recv(s, buf, len, flags);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
-int sys_net_recvfrom(s32 s, u32 buf_addr, u32 len, s32 flags, mem_ptr_t<sys_net_sockaddr> addr, mem32_t paddrlen)
+int sys_net_recvfrom(s32 s, u32 buf_addr, u32 len, s32 flags, mem_ptr_t<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> paddrlen)
 {
 	sys_net->Warning("recvfrom(s=%d, buf_addr=0x%x, len=%u, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
-		s, buf_addr, len, flags, addr.GetAddr(), paddrlen.GetAddr());
+		s, buf_addr, len, flags, addr.GetAddr(), paddrlen.addr());
 
 	char *_buf_addr = (char *)Memory.VirtualToRealAddr(buf_addr);
 	sockaddr _addr;
 	memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
 	_addr.sa_family = addr->sa_family;
-	pck_len_t *_paddrlen = (pck_len_t *) Memory.VirtualToRealAddr(paddrlen.GetAddr());
+	pck_len_t *_paddrlen = (pck_len_t *) Memory.VirtualToRealAddr(paddrlen.addr());
 	int ret = recvfrom(s, _buf_addr, len, flags, &_addr, _paddrlen);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -268,7 +268,7 @@ int sys_net_send(s32 s, u32 buf_addr, u32 len, s32 flags)
 	sys_net->Warning("send(s=%d, buf_addr=0x%x, len=%d, flags=0x%x)", s, buf_addr, len, flags);
 	char *buf = (char *)Memory.VirtualToRealAddr(buf_addr);
 	int ret = send(s, buf, len, flags);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -288,7 +288,7 @@ int sys_net_sendto(s32 s, u32 buf_addr, u32 len, s32 flags, mem_ptr_t<sys_net_so
 	memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
 	_addr.sa_family = addr->sa_family;
 	int ret = sendto(s, _buf_addr, len, flags, &_addr, addrlen);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -297,7 +297,7 @@ int sys_net_setsockopt(s32 s, s32 level, s32 optname, u32 optval_addr, u32 optle
 	sys_net->Warning("socket(s=%d, level=%d, optname=%d, optval_addr=0x%x, optlen=%u)", s, level, optname, optval_addr, optlen);
 	char *_optval_addr = (char *)Memory.VirtualToRealAddr(optval_addr);
 	int ret = setsockopt(s, level, optname, _optval_addr, optlen);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -305,7 +305,7 @@ int sys_net_shutdown(s32 s, s32 how)
 {
 	sys_net->Warning("shutdown(s=%d, how=%d)", s, how);
 	int ret = shutdown(s, how);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -313,7 +313,7 @@ int sys_net_socket(s32 family, s32 type, s32 protocol)
 {
 	sys_net->Warning("socket(family=%d, type=%d, protocol=%d)", family, type, protocol);
 	int ret = socket(family, type, protocol);
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -325,7 +325,7 @@ int sys_net_socketclose(s32 s)
 #else
 	int ret = close(s);
 #endif
-	g_lastError = getLastError();
+	*g_lastError = getLastError();
 	return ret;
 }
 
@@ -344,7 +344,7 @@ int socketselect()
 int sys_net_initialize_network_ex(mem_ptr_t<sys_net_initialize_parameter> param)
 {
 	sys_net->Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.GetAddr());
-	g_lastError.SetAddr((u32)Memory.Alloc(4, 1));
+	g_lastError = vm::ptr<be_t<s32>>::make((u32)Memory.Alloc(4, 1));
 #ifdef _WIN32
 	WSADATA wsaData;
 	WORD wVersionRequested = MAKEWORD(1,1);
@@ -407,10 +407,10 @@ int sys_net_show_nameserver()
 	return CELL_OK;
 }
 
-s32 _sys_net_errno_loc()
+u32 _sys_net_errno_loc()
 {
 	sys_net->Warning("_sys_net_errno_loc()");
-	return g_lastError.GetAddr();
+	return g_lastError.addr();
 }
 
 int sys_net_set_resolver_configurations()
@@ -476,8 +476,8 @@ int sys_net_show_ifconfig()
 int sys_net_finalize_network()
 {
 	sys_net->Warning("sys_net_initialize_network_ex()");
-	Memory.Free(g_lastError.GetAddr());
-	g_lastError.SetAddr(0);
+	Memory.Free(g_lastError.addr());
+	g_lastError = vm::ptr<be_t<s32>>::make(0);
 #ifdef _WIN32
 	WSACleanup();
 #endif
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
index f5849685bd..0f58bfe074 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
@@ -30,11 +30,11 @@ struct FsRingBufferConfig
 } fs_config;
 
 
-s32 cellFsOpen(u32 path_addr, s32 flags, mem32_t fd, mem32_t arg, u64 size)
+s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
 {
 	const std::string& path = Memory.ReadString(path_addr);
 	sys_fs->Log("cellFsOpen(path=\"%s\", flags=0x%x, fd_addr=0x%x, arg_addr=0x%x, size=0x%llx)",
-		path.c_str(), flags, fd.GetAddr(), arg.GetAddr(), size);
+		path.c_str(), flags, fd.addr(), arg.addr(), size);
 
 	const std::string& ppath = path;
 	//ConLog.Warning("path: %s [%s]", ppath.c_str(), path.c_str());
@@ -109,8 +109,9 @@ s32 cellFsOpen(u32 path_addr, s32 flags, mem32_t fd, mem32_t arg, u64 size)
 		return CELL_ENOENT;
 	}
 
-	fd = sys_fs->GetNewId(stream, TYPE_FS_FILE);
-	sys_fs->Notice("\"%s\" opened: fd = %d", path.c_str(), fd.GetValue());
+	u32 id = sys_fs->GetNewId(stream, TYPE_FS_FILE);
+	*fd = id;
+	sys_fs->Notice("\"%s\" opened: fd = %d", path.c_str(), id);
 
 	return CELL_OK;
 }
@@ -161,10 +162,10 @@ s32 cellFsClose(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsOpendir(u32 path_addr, mem32_t fd)
+s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd)
 {
 	const std::string& path = Memory.ReadString(path_addr);
-	sys_fs->Warning("cellFsOpendir(path=\"%s\", fd_addr=0x%x)", path.c_str(), fd.GetAddr());
+	sys_fs->Warning("cellFsOpendir(path=\"%s\", fd_addr=0x%x)", path.c_str(), fd.addr());
 	
 	vfsDirBase* dir = Emu.GetVFS().OpenDir(path);
 	if(!dir || !dir->IsOpened())
@@ -173,7 +174,7 @@ s32 cellFsOpendir(u32 path_addr, mem32_t fd)
 		return CELL_ENOENT;
 	}
 
-	fd = sys_fs->GetNewId(dir, TYPE_FS_DIR);
+	*fd = sys_fs->GetNewId(dir, TYPE_FS_DIR);
 	return CELL_OK;
 }
 
@@ -502,9 +503,10 @@ s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t
 	return CELL_OK;
 }
 
-s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, mem32_t data_count)
+s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count)
 {
-	sys_fs->Log("cellFsGetDirectoryEntries(fd=%d, entries_addr=0x%x, entries_size = 0x%x, data_count_addr=0x%x)", fd, entries.GetAddr(), entries_size, data_count.GetAddr());
+	sys_fs->Log("cellFsGetDirectoryEntries(fd=%d, entries_addr=0x%x, entries_size = 0x%x, data_count_addr=0x%x)",
+		fd, entries.GetAddr(), entries_size, data_count.addr());
 
 	vfsDirBase* directory;
 	if(!sys_fs->CheckId(fd, directory))
@@ -513,7 +515,7 @@ s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u
 	const DirEntryInfo* info = directory->Read();
 	if(info)
 	{
-		data_count = 1;
+		*data_count = 1;
 		Memory.WriteString(entries.GetAddr()+2, info->name);
 		entries->entry_name.d_namlen = info->name.length();
 		entries->entry_name.d_type = (info->flags & DirEntry_TypeFile) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
@@ -532,7 +534,7 @@ s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u
 	}
 	else
 	{
-		data_count = 0;
+		*data_count = 0;
 	}
 
 	return CELL_OK;
@@ -649,9 +651,9 @@ s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, vm::ptr<be_t<u64>> rsize)
 	return CELL_OK;
 }
 
-s32 cellFsStReadGetCurrentAddr(u32 fd, mem32_t addr_addr, vm::ptr<be_t<u64>> size)
+s32 cellFsStReadGetCurrentAddr(u32 fd, vm::ptr<be_t<u32>> addr, vm::ptr<be_t<u64>> size)
 {
-	sys_fs->Todo("cellFsStReadGetCurrentAddr(fd=%d, addr_addr=0x%x, size_addr = 0x%x)", fd, addr_addr.GetAddr(), size.addr());
+	sys_fs->Todo("cellFsStReadGetCurrentAddr(fd=%d, addr_addr=0x%x, size_addr = 0x%x)", fd, addr.addr(), size.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
index 0034f1387b..132a501fc4 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
@@ -124,11 +124,11 @@ struct CellFsRingBuffer
 };
 
 // SysCalls
-s32 cellFsOpen(u32 path_addr, s32 flags, mem32_t fd, mem32_t arg, u64 size);
+s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size);
 s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nread);
 s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nwrite);
 s32 cellFsClose(u32 fd);
-s32 cellFsOpendir(u32 path_addr, mem32_t fd);
+s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd);
 s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, vm::ptr<be_t<u64>> nread);
 s32 cellFsClosedir(u32 fd);
 s32 cellFsStat(u32 path_addr, mem_ptr_t<CellFsStat> sb);
@@ -145,7 +145,7 @@ s32 cellFsTruncate(u32 path_addr, u64 size);
 s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
 s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
 s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count);
-s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, mem32_t data_count);
+s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count);
 s32 cellFsStReadInit(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf);
 s32 cellFsStReadFinish(u32 fd);
 s32 cellFsStReadGetRingBuf(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf);
@@ -154,7 +154,7 @@ s32 cellFsStReadGetRegid(u32 fd, vm::ptr<be_t<u64>> regid);
 s32 cellFsStReadStart(u32 fd, u64 offset, u64 size);
 s32 cellFsStReadStop(u32 fd);
 s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, vm::ptr<be_t<u64>> rsize);
-s32 cellFsStReadGetCurrentAddr(u32 fd, mem32_t addr_addr, vm::ptr<be_t<u64>> size);
+s32 cellFsStReadGetCurrentAddr(u32 fd, vm::ptr<be_t<u32>> addr_addr, vm::ptr<be_t<u64>> size);
 s32 cellFsStReadPutCurrentAddr(u32 fd, u32 addr_addr, u64 size);
 s32 cellFsStReadWait(u32 fd, u64 size);
 s32 cellFsStReadWaitCallback(u32 fd, u64 size, mem_func_ptr_t<void (*)(int xfd, u64 xsize)> func);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp b/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
index c9e52b5755..7207268f88 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
@@ -9,10 +9,10 @@
 
 SysCallBase sys_cond("sys_cond");
 
-s32 sys_cond_create(mem32_t cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr)
+s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr)
 {
 	sys_cond.Log("sys_cond_create(cond_id_addr=0x%x, mutex_id=%d, attr_addr=0x%x)",
-		cond_id.GetAddr(), mutex_id, attr.GetAddr());
+		cond_id.addr(), mutex_id, attr.GetAddr());
 
 	if (attr->pshared.ToBE() != se32(0x200))
 	{
@@ -33,9 +33,9 @@ s32 sys_cond_create(mem32_t cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute>
 
 	Cond* cond = new Cond(mutex, attr->name_u64);
 	u32 id = sys_cond.GetNewId(cond, TYPE_COND);
-	cond_id = id;
+	*cond_id = id;
 	mutex->cond_count++;
-	sys_cond.Warning("*** condition created [%s] (mutex_id=%d): id = %d", std::string(attr->name, 8).c_str(), mutex_id, cond_id.GetValue());
+	sys_cond.Warning("*** condition created [%s] (mutex_id=%d): id = %d", std::string(attr->name, 8).c_str(), mutex_id, id);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_cond.h b/rpcs3/Emu/SysCalls/lv2/sys_cond.h
index c934f4fd9f..0ed9846980 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_cond.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_cond.h
@@ -31,7 +31,7 @@ struct Cond
 };
 
 // SysCalls
-s32 sys_cond_create(mem32_t cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr);
+s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr);
 s32 sys_cond_destroy(u32 cond_id);
 s32 sys_cond_wait(u32 cond_id, u64 timeout);
 s32 sys_cond_signal(u32 cond_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event.cpp
index 953538decd..7feff56bf5 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event.cpp
@@ -10,10 +10,10 @@
 
 SysCallBase sys_event("sys_event");
 
-s32 sys_event_queue_create(mem32_t equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size)
+s32 sys_event_queue_create(vm::ptr<be_t<u32>> equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size)
 {
 	sys_event.Warning("sys_event_queue_create(equeue_id_addr=0x%x, attr_addr=0x%x, event_queue_key=0x%llx, size=%d)",
-		equeue_id.GetAddr(), attr.GetAddr(), event_queue_key, size);
+		equeue_id.addr(), attr.GetAddr(), event_queue_key, size);
 
 	if(size <= 0 || size > 127)
 	{
@@ -49,9 +49,10 @@ s32 sys_event_queue_create(mem32_t equeue_id, mem_ptr_t<sys_event_queue_attr> at
 		return CELL_EAGAIN;
 	}
 
-	equeue_id = sys_event.GetNewId(eq, TYPE_EVENT_QUEUE);
+	u32 id = sys_event.GetNewId(eq, TYPE_EVENT_QUEUE);
+	*equeue_id = id;
 	sys_event.Warning("*** event_queue created [%s] (protocol=0x%x, type=0x%x): id = %d",
-		std::string(attr->name, 8).c_str(), (u32)attr->protocol, (int)attr->type, equeue_id.GetValue());
+		std::string(attr->name, 8).c_str(), (u32)attr->protocol, (int)attr->type, id);
 
 	return CELL_OK;
 }
@@ -101,10 +102,10 @@ s32 sys_event_queue_destroy(u32 equeue_id, int mode)
 	return CELL_OK;
 }
 
-s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_array, int size, mem32_t number)
+s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_array, int size, vm::ptr<be_t<u32>> number)
 {
 	sys_event.Todo("sys_event_queue_tryreceive(equeue_id=%d, event_array_addr=0x%x, size=%d, number_addr=0x%x)",
-		equeue_id, event_array.GetAddr(), size, number.GetAddr());
+		equeue_id, event_array.GetAddr(), size, number.addr());
 
 	EventQueue* eq;
 	if (!Emu.GetIdManager().GetIDData(equeue_id, eq))
@@ -119,7 +120,7 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_ar
 
 	if (size == 0)
 	{
-		number = 0;
+		*number = 0;
 		return CELL_OK;
 	}
 
@@ -129,12 +130,12 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_ar
 	eq->owner.lock(tid);
 	if (eq->sq.list.size())
 	{
-		number = 0;
+		*number = 0;
 		eq->owner.unlock(tid);
 		eq->sq.m_mutex.unlock();
 		return CELL_OK;
 	}
-	number = eq->events.pop_all((sys_event_data*)(Memory + event_array.GetAddr()), size);
+	*number = eq->events.pop_all((sys_event_data*)(Memory + event_array.GetAddr()), size);
 	eq->owner.unlock(tid);
 	eq->sq.m_mutex.unlock();
 	return CELL_OK;
@@ -224,10 +225,10 @@ s32 sys_event_queue_drain(u32 equeue_id)
 	return CELL_OK;
 }
 
-s32 sys_event_port_create(mem32_t eport_id, int port_type, u64 name)
+s32 sys_event_port_create(vm::ptr<be_t<u32>> eport_id, int port_type, u64 name)
 {
 	sys_event.Warning("sys_event_port_create(eport_id_addr=0x%x, port_type=0x%x, name=0x%llx)",
-		eport_id.GetAddr(), port_type, name);
+		eport_id.addr(), port_type, name);
 
 	if (port_type != SYS_EVENT_PORT_LOCAL)
 	{
@@ -238,7 +239,7 @@ s32 sys_event_port_create(mem32_t eport_id, int port_type, u64 name)
 	EventPort* eport = new EventPort();
 	u32 id = sys_event.GetNewId(eport, TYPE_EVENT_PORT);
 	eport->name = name ? name : ((u64)process_getpid() << 32) | (u64)id;
-	eport_id = id;
+	*eport_id = id;
 	sys_event.Warning("*** sys_event_port created: id = %d", id);
 
 	return CELL_OK;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event.h b/rpcs3/Emu/SysCalls/lv2/sys_event.h
index 984e3bd762..8926ed1591 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event.h
@@ -162,8 +162,9 @@ public:
 		std::lock_guard<std::mutex> lock(m_mutex);
 		for (u32 i = 0; i < data.size(); i++)
 		{
-			std::lock_guard<std::mutex> lock2(data[i]->m_mutex);
-			data[i]->eq = nullptr; // force all ports to disconnect
+			// TODO: force all ports to disconnect
+			//std::lock_guard<std::mutex> lock2(data[i]->m_mutex);
+			//data[i]->eq = nullptr;
 		}
 		data.clear();
 	}
@@ -215,13 +216,13 @@ struct EventQueue
 };
 
 // SysCalls
-s32 sys_event_queue_create(mem32_t equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size);
+s32 sys_event_queue_create(vm::ptr<be_t<u32>> equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size);
 s32 sys_event_queue_destroy(u32 equeue_id, int mode);
 s32 sys_event_queue_receive(u32 equeue_id, mem_ptr_t<sys_event_data> event, u64 timeout);
-s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_array, int size, mem32_t number);
+s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_array, int size, vm::ptr<be_t<u32>> number);
 s32 sys_event_queue_drain(u32 event_queue_id);
 
-s32 sys_event_port_create(mem32_t eport_id, int port_type, u64 name);
+s32 sys_event_port_create(vm::ptr<be_t<u32>> eport_id, int port_type, u64 name);
 s32 sys_event_port_destroy(u32 eport_id);
 s32 sys_event_port_connect_local(u32 event_port_id, u32 event_queue_id);
 s32 sys_event_port_disconnect(u32 eport_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
index d0e94c08a0..274924d9de 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
@@ -37,10 +37,10 @@ u32 EventFlag::check()
 	return target;
 }
 
-s32 sys_event_flag_create(mem32_t eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init)
+s32 sys_event_flag_create(vm::ptr<be_t<u32>> eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init)
 {
 	sys_event_flag.Warning("sys_event_flag_create(eflag_id_addr=0x%x, attr_addr=0x%x, init=0x%llx)",
-		eflag_id.GetAddr(), attr.GetAddr(), init);
+		eflag_id.addr(), attr.GetAddr(), init);
 
 	switch (attr->protocol.ToBE())
 	{
@@ -63,10 +63,10 @@ s32 sys_event_flag_create(mem32_t eflag_id, mem_ptr_t<sys_event_flag_attr> attr,
 	default: return CELL_EINVAL;
 	}
 
-	eflag_id = sys_event_flag.GetNewId(new EventFlag(init, (u32)attr->protocol, (int)attr->type), TYPE_EVENT_FLAG);
-
+	u32 id = sys_event_flag.GetNewId(new EventFlag(init, (u32)attr->protocol, (int)attr->type), TYPE_EVENT_FLAG);
+	*eflag_id = id;
 	sys_event_flag.Warning("*** event_flag created [%s] (protocol=0x%x, type=0x%x): id = %d",
-		std::string(attr->name, 8).c_str(), (u32)attr->protocol, (int)attr->type, eflag_id.GetValue());
+		std::string(attr->name, 8).c_str(), (u32)attr->protocol, (int)attr->type, id);
 
 	return CELL_OK;
 }
@@ -307,9 +307,9 @@ s32 sys_event_flag_clear(u32 eflag_id, u64 bitptn)
 	return CELL_OK;
 }
 
-s32 sys_event_flag_cancel(u32 eflag_id, mem32_t num)
+s32 sys_event_flag_cancel(u32 eflag_id, vm::ptr<be_t<u32>> num)
 {
-	sys_event_flag.Log("sys_event_flag_cancel(eflag_id=%d, num_addr=0x%x)", eflag_id, num.GetAddr());
+	sys_event_flag.Log("sys_event_flag_cancel(eflag_id=%d, num_addr=0x%x)", eflag_id, num.addr());
 
 	EventFlag* ef;
 	if (!sys_event_flag.CheckId(eflag_id, ef)) return CELL_ESRCH;
@@ -337,7 +337,7 @@ s32 sys_event_flag_cancel(u32 eflag_id, mem32_t num)
 		return CELL_OK;
 	}
 
-	if (num.GetAddr()) num = (u32)tids.size();
+	if (num) *num = (u32)tids.size();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
index e7d60605c7..d6dd8ac4e5 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
@@ -50,11 +50,11 @@ struct EventFlag
 	u32 check();
 };
 
-s32 sys_event_flag_create(mem32_t eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init);
+s32 sys_event_flag_create(vm::ptr<be_t<u32>> eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init);
 s32 sys_event_flag_destroy(u32 eflag_id);
 s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result, u64 timeout);
 s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result);
 s32 sys_event_flag_set(u32 eflag_id, u64 bitptn);
 s32 sys_event_flag_clear(u32 eflag_id, u64 bitptn);
-s32 sys_event_flag_cancel(u32 eflag_id, mem32_t num);
+s32 sys_event_flag_cancel(u32 eflag_id, vm::ptr<be_t<u32>> num);
 s32 sys_event_flag_get(u32 eflag_id, vm::ptr<be_t<u64>> flags);
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_interrupt.cpp b/rpcs3/Emu/SysCalls/lv2/sys_interrupt.cpp
index 4a4b9d67f1..94e8cd2eaa 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_interrupt.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_interrupt.cpp
@@ -37,9 +37,9 @@ s32 sys_interrupt_tag_destroy(u32 intrtag)
 	return CELL_OK;
 }
 
-s32 sys_interrupt_thread_establish(mem32_t ih, u32 intrtag, u64 intrthread, u64 arg)
+s32 sys_interrupt_thread_establish(vm::ptr<be_t<u32>> ih, u32 intrtag, u64 intrthread, u64 arg)
 {
-	sys_interrupt.Warning("sys_interrupt_thread_establish(ih_addr=0x%x, intrtag=%d, intrthread=%lld, arg=0x%llx)", ih.GetAddr(), intrtag, intrthread, arg);
+	sys_interrupt.Warning("sys_interrupt_thread_establish(ih_addr=0x%x, intrtag=%d, intrthread=%lld, arg=0x%llx)", ih.addr(), intrtag, intrthread, arg);
 
 	u32 id = intrtag & 0xff;
 	u32 class_id = intrtag >> 8;
@@ -71,7 +71,7 @@ s32 sys_interrupt_thread_establish(mem32_t ih, u32 intrtag, u64 intrthread, u64
 		return CELL_EAGAIN;
 	}
 
-	ih = (t->m_intrtag[class_id].thread = intrthread);
+	*ih = (t->m_intrtag[class_id].thread = intrthread);
 	it->m_interrupt_arg = arg;
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_interrupt.h b/rpcs3/Emu/SysCalls/lv2/sys_interrupt.h
index 2254b7e607..9ada3e84d7 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_interrupt.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_interrupt.h
@@ -2,6 +2,6 @@
 
 // SysCalls
 s32 sys_interrupt_tag_destroy(u32 intrtag);
-s32 sys_interrupt_thread_establish(mem32_t ih, u32 intrtag, u64 intrthread, u64 arg);
+s32 sys_interrupt_thread_establish(vm::ptr<be_t<u32>> ih, u32 intrtag, u64 intrthread, u64 arg);
 s32 sys_interrupt_thread_disestablish(u32 ih);
 void sys_interrupt_thread_eoi();
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
index 5091e41b31..d49e23ddc4 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
@@ -108,9 +108,9 @@ s32 sys_memory_get_user_memory_size(mem_ptr_t<sys_memory_info_t> mem_info)
 	return CELL_OK;
 }
 
-s32 sys_memory_container_create(mem32_t cid, u32 yield_size)
+s32 sys_memory_container_create(vm::ptr<be_t<u32>> cid, u32 yield_size)
 {
-	sys_memory.Warning("sys_memory_container_create(cid_addr=0x%x, yield_size=0x%x)", cid.GetAddr(), yield_size);
+	sys_memory.Warning("sys_memory_container_create(cid_addr=0x%x, yield_size=0x%x)", cid.addr(), yield_size);
 
 	yield_size &= ~0xfffff; //round down to 1 MB granularity
 	u32 addr = (u32)Memory.Alloc(yield_size, 0x100000); //1 MB alignment
@@ -120,9 +120,10 @@ s32 sys_memory_container_create(mem32_t cid, u32 yield_size)
 
 	// Wrap the allocated memory in a memory container.
 	MemoryContainerInfo *ct = new MemoryContainerInfo(addr, yield_size);
-	cid = sys_memory.GetNewId(ct, TYPE_MEM);
+	u32 id = sys_memory.GetNewId(ct, TYPE_MEM);
+	*cid = id;
 
-	sys_memory.Warning("*** memory_container created(addr=0x%llx): id = %d", addr, cid.GetValue());
+	sys_memory.Warning("*** memory_container created(addr=0x%llx): id = %d", addr, id);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.h b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
index 78a4f4b3bd..9eb3e12077 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
@@ -48,6 +48,6 @@ s32 sys_memory_allocate_from_container(u32 size, u32 cid, u32 flags, u32 alloc_a
 s32 sys_memory_free(u32 start_addr);
 s32 sys_memory_get_page_attribute(u32 addr, mem_ptr_t<sys_page_attr_t> attr);
 s32 sys_memory_get_user_memory_size(mem_ptr_t<sys_memory_info_t> mem_info);
-s32 sys_memory_container_create(mem32_t cid, u32 yield_size);
+s32 sys_memory_container_create(vm::ptr<be_t<u32>> cid, u32 yield_size);
 s32 sys_memory_container_destroy(u32 cid);
 s32 sys_memory_container_get_size(mem_ptr_t<sys_memory_info_t> mem_info, u32 cid);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp
index 66b231e462..8367267e03 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.cpp
@@ -53,9 +53,9 @@ s32 sys_mmapper_allocate_fixed_address()
 	return CELL_OK;
 }
 
-s32 sys_mmapper_allocate_memory(u32 size, u64 flags, mem32_t mem_id)
+s32 sys_mmapper_allocate_memory(u32 size, u64 flags, vm::ptr<be_t<u32>> mem_id)
 {
-	sys_mmapper.Warning("sys_mmapper_allocate_memory(size=0x%x, flags=0x%llx, mem_id_addr=0x%x)", size, flags, mem_id.GetAddr());
+	sys_mmapper.Warning("sys_mmapper_allocate_memory(size=0x%x, flags=0x%llx, mem_id_addr=0x%x)", size, flags, mem_id.addr());
 
 	// Check page granularity.
 	u32 addr;
@@ -81,15 +81,15 @@ s32 sys_mmapper_allocate_memory(u32 size, u64 flags, mem32_t mem_id)
 		return CELL_ENOMEM;
 
 	// Generate a new mem ID.
-	mem_id = sys_mmapper.GetNewId(new mmapper_info(addr, size, flags));
+	*mem_id = sys_mmapper.GetNewId(new mmapper_info(addr, size, flags));
 
 	return CELL_OK;
 }
 
-s32 sys_mmapper_allocate_memory_from_container(u32 size, u32 cid, u64 flags, mem32_t mem_id)
+s32 sys_mmapper_allocate_memory_from_container(u32 size, u32 cid, u64 flags, vm::ptr<be_t<u32>> mem_id)
 {
 	sys_mmapper.Warning("sys_mmapper_allocate_memory_from_container(size=0x%x, cid=%d, flags=0x%llx, mem_id_addr=0x%x)", 
-		size, cid, flags, mem_id.GetAddr());
+		size, cid, flags, mem_id.addr());
 
 	// Check if this container ID is valid.
 	MemoryContainerInfo* ct;
@@ -120,7 +120,7 @@ s32 sys_mmapper_allocate_memory_from_container(u32 size, u32 cid, u64 flags, mem
 	ct->size = size;
 
 	// Generate a new mem ID.
-	mem_id = sys_mmapper.GetNewId(new mmapper_info(ct->addr, ct->size, flags), TYPE_MEM);
+	*mem_id = sys_mmapper.GetNewId(new mmapper_info(ct->addr, ct->size, flags), TYPE_MEM);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h
index 677ea634d5..64e132a2ec 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mmapper.h
@@ -24,8 +24,8 @@ struct mmapper_info
 // SysCalls
 s32 sys_mmapper_allocate_address(u32 size, u64 flags, u32 alignment, u32 alloc_addr);
 s32 sys_mmapper_allocate_fixed_address();
-s32 sys_mmapper_allocate_memory(u32 size, u64 flags, mem32_t mem_id);
-s32 sys_mmapper_allocate_memory_from_container(u32 size, u32 cid, u64 flags, mem32_t mem_id);
+s32 sys_mmapper_allocate_memory(u32 size, u64 flags, vm::ptr<be_t<u32>> mem_id);
+s32 sys_mmapper_allocate_memory_from_container(u32 size, u32 cid, u64 flags, vm::ptr<be_t<u32>> mem_id);
 s32 sys_mmapper_change_address_access_right(u32 start_addr, u64 flags);
 s32 sys_mmapper_free_address(u32 start_addr);
 s32 sys_mmapper_free_memory(u32 mem_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp b/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
index eca0b8f297..f1c7b1bb74 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
@@ -26,9 +26,9 @@ Mutex::~Mutex()
 	m_queue.m_mutex.unlock();
 }
 
-s32 sys_mutex_create(mem32_t mutex_id, mem_ptr_t<sys_mutex_attribute> attr)
+s32 sys_mutex_create(vm::ptr<be_t<u32>> mutex_id, mem_ptr_t<sys_mutex_attribute> attr)
 {
-	sys_mutex.Log("sys_mutex_create(mutex_id_addr=0x%x, attr_addr=0x%x)", mutex_id.GetAddr(), attr.GetAddr());
+	sys_mutex.Log("sys_mutex_create(mutex_id_addr=0x%x, attr_addr=0x%x)", mutex_id.addr(), attr.GetAddr());
 
 	switch (attr->protocol.ToBE())
 	{
@@ -58,11 +58,10 @@ s32 sys_mutex_create(mem32_t mutex_id, mem_ptr_t<sys_mutex_attribute> attr)
 	u32 id = sys_mutex.GetNewId(mutex, TYPE_MUTEX);
 	mutex->m_mutex.lock(tid);
 	mutex->id = id;
-	mutex_id = id;
+	*mutex_id = id;
 	mutex->m_mutex.unlock(tid);
 	sys_mutex.Warning("*** mutex created [%s] (protocol=0x%x, recursive=%s): id = %d",
-		std::string(attr->name, 8).c_str(), (u32) attr->protocol,
-		(is_recursive ? "true" : "false"), mutex_id.GetValue());
+		std::string(attr->name, 8).c_str(), (u32) attr->protocol, (is_recursive ? "true" : "false"), id);
 
 	// TODO: unlock mutex when owner thread does exit
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mutex.h b/rpcs3/Emu/SysCalls/lv2/sys_mutex.h
index b2813e41d2..4ef1dea1b5 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mutex.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mutex.h
@@ -40,7 +40,7 @@ struct Mutex
 };
 
 // SysCalls
-s32 sys_mutex_create(mem32_t mutex_id, mem_ptr_t<sys_mutex_attribute> attr);
+s32 sys_mutex_create(vm::ptr<be_t<u32>> mutex_id, mem_ptr_t<sys_mutex_attribute> attr);
 s32 sys_mutex_destroy(u32 mutex_id);
 s32 sys_mutex_lock(u32 mutex_id, u64 timeout);
 s32 sys_mutex_trylock(u32 mutex_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
index c2909deb15..38ef93b6fd 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
@@ -133,32 +133,32 @@ void sys_game_process_exitspawn2(
 	return;
 }
 
-s32 sys_process_get_number_of_object(u32 object, mem32_t nump)
+s32 sys_process_get_number_of_object(u32 object, vm::ptr<be_t<u32>> nump)
 {
 	sys_process.Warning("sys_process_get_number_of_object(object=%d, nump_addr=0x%x)",
-		object, nump.GetAddr());
+		object, nump.addr());
 
 	switch(object)
 	{
-	case SYS_MEM_OBJECT:                  nump = Emu.GetIdManager().GetTypeCount(TYPE_MEM);                 break;
-	case SYS_MUTEX_OBJECT:                nump = Emu.GetIdManager().GetTypeCount(TYPE_MUTEX);               break;
-	case SYS_COND_OBJECT:                 nump = Emu.GetIdManager().GetTypeCount(TYPE_COND);                break;
-	case SYS_RWLOCK_OBJECT:               nump = Emu.GetIdManager().GetTypeCount(TYPE_RWLOCK);              break;
-	case SYS_INTR_TAG_OBJECT:             nump = Emu.GetIdManager().GetTypeCount(TYPE_INTR_TAG);            break;
-	case SYS_INTR_SERVICE_HANDLE_OBJECT:  nump = Emu.GetIdManager().GetTypeCount(TYPE_INTR_SERVICE_HANDLE); break;
-	case SYS_EVENT_QUEUE_OBJECT:          nump = Emu.GetIdManager().GetTypeCount(TYPE_EVENT_QUEUE);         break;
-	case SYS_EVENT_PORT_OBJECT:           nump = Emu.GetIdManager().GetTypeCount(TYPE_EVENT_PORT);          break;
-	case SYS_TRACE_OBJECT:                nump = Emu.GetIdManager().GetTypeCount(TYPE_TRACE);               break;
-	case SYS_SPUIMAGE_OBJECT:             nump = Emu.GetIdManager().GetTypeCount(TYPE_SPUIMAGE);            break;
-	case SYS_PRX_OBJECT:                  nump = Emu.GetIdManager().GetTypeCount(TYPE_PRX);                 break;
-	case SYS_SPUPORT_OBJECT:              nump = Emu.GetIdManager().GetTypeCount(TYPE_SPUPORT);             break;
-	case SYS_LWMUTEX_OBJECT:              nump = Emu.GetIdManager().GetTypeCount(TYPE_LWMUTEX);             break;
-	case SYS_TIMER_OBJECT:                nump = Emu.GetIdManager().GetTypeCount(TYPE_TIMER);               break;
-	case SYS_SEMAPHORE_OBJECT:            nump = Emu.GetIdManager().GetTypeCount(TYPE_SEMAPHORE);           break;
-	case SYS_LWCOND_OBJECT:               nump = Emu.GetIdManager().GetTypeCount(TYPE_LWCOND);              break;
-	case SYS_EVENT_FLAG_OBJECT:           nump = Emu.GetIdManager().GetTypeCount(TYPE_EVENT_FLAG);          break;
+	case SYS_MEM_OBJECT:                  *nump = Emu.GetIdManager().GetTypeCount(TYPE_MEM);                 break;
+	case SYS_MUTEX_OBJECT:                *nump = Emu.GetIdManager().GetTypeCount(TYPE_MUTEX);               break;
+	case SYS_COND_OBJECT:                 *nump = Emu.GetIdManager().GetTypeCount(TYPE_COND);                break;
+	case SYS_RWLOCK_OBJECT:               *nump = Emu.GetIdManager().GetTypeCount(TYPE_RWLOCK);              break;
+	case SYS_INTR_TAG_OBJECT:             *nump = Emu.GetIdManager().GetTypeCount(TYPE_INTR_TAG);            break;
+	case SYS_INTR_SERVICE_HANDLE_OBJECT:  *nump = Emu.GetIdManager().GetTypeCount(TYPE_INTR_SERVICE_HANDLE); break;
+	case SYS_EVENT_QUEUE_OBJECT:          *nump = Emu.GetIdManager().GetTypeCount(TYPE_EVENT_QUEUE);         break;
+	case SYS_EVENT_PORT_OBJECT:           *nump = Emu.GetIdManager().GetTypeCount(TYPE_EVENT_PORT);          break;
+	case SYS_TRACE_OBJECT:                *nump = Emu.GetIdManager().GetTypeCount(TYPE_TRACE);               break;
+	case SYS_SPUIMAGE_OBJECT:             *nump = Emu.GetIdManager().GetTypeCount(TYPE_SPUIMAGE);            break;
+	case SYS_PRX_OBJECT:                  *nump = Emu.GetIdManager().GetTypeCount(TYPE_PRX);                 break;
+	case SYS_SPUPORT_OBJECT:              *nump = Emu.GetIdManager().GetTypeCount(TYPE_SPUPORT);             break;
+	case SYS_LWMUTEX_OBJECT:              *nump = Emu.GetIdManager().GetTypeCount(TYPE_LWMUTEX);             break;
+	case SYS_TIMER_OBJECT:                *nump = Emu.GetIdManager().GetTypeCount(TYPE_TIMER);               break;
+	case SYS_SEMAPHORE_OBJECT:            *nump = Emu.GetIdManager().GetTypeCount(TYPE_SEMAPHORE);           break;
+	case SYS_LWCOND_OBJECT:               *nump = Emu.GetIdManager().GetTypeCount(TYPE_LWCOND);              break;
+	case SYS_EVENT_FLAG_OBJECT:           *nump = Emu.GetIdManager().GetTypeCount(TYPE_EVENT_FLAG);          break;
 	case SYS_FS_FD_OBJECT:
-		nump = Emu.GetIdManager().GetTypeCount(TYPE_FS_FILE) + Emu.GetIdManager().GetTypeCount(TYPE_FS_DIR);
+		*nump = Emu.GetIdManager().GetTypeCount(TYPE_FS_FILE) + Emu.GetIdManager().GetTypeCount(TYPE_FS_DIR);
 		break;
 
 	default:      
@@ -168,10 +168,10 @@ s32 sys_process_get_number_of_object(u32 object, mem32_t nump)
 	return CELL_OK;
 }
 
-s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, mem32_t set_size)
+s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, vm::ptr<be_t<u32>> set_size)
 {
 	sys_process.Todo("sys_process_get_id(object=%d, buffer_addr=0x%x, size=%d, set_size_addr=0x%x)",
-		object, buffer.addr(), size, set_size.GetAddr());
+		object, buffer.addr(), size, set_size.addr());
 
 	switch(object)
 	{
@@ -181,7 +181,7 @@ s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, mem32_t
 	const auto& objects = Emu.GetIdManager().GetTypeIDs(type); \
 	for(auto id=objects.begin(); i<size && id!=objects.end(); id++, i++) \
 		buffer[i] = *id; \
-	set_size = i; \
+	*set_size = i; \
 	}
 
 	case SYS_MEM_OBJECT:                  ADD_OBJECTS(TYPE_MEM);                 break;
@@ -239,9 +239,9 @@ s32 process_get_sdk_version(u32 pid, s32& ver)
 	return CELL_OK;
 }
 
-s32 sys_process_get_sdk_version(u32 pid, mem32_t version)
+s32 sys_process_get_sdk_version(u32 pid, vm::ptr<be_t<s32>> version)
 {
-	sys_process.Warning("sys_process_get_sdk_version(pid=%d, version_addr=0x%x)", pid, version.GetAddr());
+	sys_process.Warning("sys_process_get_sdk_version(pid=%d, version_addr=0x%x)", pid, version.addr());
 
 	s32 sdk_ver;
 	s32 ret = process_get_sdk_version(pid, sdk_ver);
@@ -251,7 +251,7 @@ s32 sys_process_get_sdk_version(u32 pid, mem32_t version)
 	}
 	else
 	{
-		version = sdk_ver;
+		*version = sdk_ver;
 		return CELL_OK;
 	}
 }
@@ -262,10 +262,10 @@ s32 sys_process_kill(u32 pid)
 	return CELL_OK;
 }
 
-s32 sys_process_wait_for_child(u32 pid, mem32_t status, u64 unk)
+s32 sys_process_wait_for_child(u32 pid, vm::ptr<be_t<u32>> status, u64 unk)
 {
 	sys_process.Todo("sys_process_wait_for_child(pid=%d, status_addr=0x%x, unk=0x%llx",
-		pid, status.GetAddr(), unk);
+		pid, status.addr(), unk);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_process.h b/rpcs3/Emu/SysCalls/lv2/sys_process.h
index 98d495fc99..38c2d14d53 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_process.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_process.h
@@ -30,14 +30,14 @@ s32 process_get_sdk_version(u32 pid, s32& ver);
 // SysCalls
 s32 sys_process_getpid();
 s32 sys_process_getppid();
-s32 sys_process_get_number_of_object(u32 object, mem32_t nump);
-s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, mem32_t set_size);
+s32 sys_process_get_number_of_object(u32 object, vm::ptr<be_t<u32>> nump);
+s32 sys_process_get_id(u32 object, vm::ptr<be_t<u32>> buffer, u32 size, vm::ptr<be_t<u32>> set_size);
 s32 sys_process_get_paramsfo(vm::ptr<u8> buffer);
-s32 sys_process_get_sdk_version(u32 pid, mem32_t version);
+s32 sys_process_get_sdk_version(u32 pid, vm::ptr<be_t<s32>> version);
 s32 sys_process_get_status(u64 unk);
 s32 sys_process_exit(s32 errorcode);
 s32 sys_process_kill(u32 pid);
-s32 sys_process_wait_for_child(u32 pid, mem32_t status, u64 unk);
+s32 sys_process_wait_for_child(u32 pid, vm::ptr<be_t<u32>> status, u64 unk);
 s32 sys_process_wait_for_child2(u64 unk1, u64 unk2, u64 unk3, u64 unk4, u64 unk5, u64 unk6);
 s32 sys_process_detach_child(u64 unk);
 void sys_game_process_exitspawn(u32 path_addr, u32 argv_addr, u32 envp_addr,
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
index 439160dd41..45bc944813 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
@@ -61,10 +61,10 @@ s32 sys_prx_load_module_on_memcontainer_by_fd()
 	return CELL_OK;
 }
 
-s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, mem32_t modres, u64 flags, mem_ptr_t<sys_prx_start_module_option_t> pOpt)
+s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_start_module_option_t> pOpt)
 {
 	sys_prx.Todo("sys_prx_start_module(id=%d, args=%d, argp_addr=0x%x, modres_addr=0x%x, flags=0x%llx, pOpt=0x%x)",
-		id, args, argp_addr, modres.GetAddr(), flags, pOpt.GetAddr());
+		id, args, argp_addr, modres.addr(), flags, pOpt.GetAddr());
 
 	sys_prx_t* prx;
 	if (!Emu.GetIdManager().GetIDData(id, prx))
@@ -76,10 +76,10 @@ s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, mem32_t modres, u64 fl
 	return CELL_OK;
 }
 
-s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, mem32_t modres, u64 flags, mem_ptr_t<sys_prx_stop_module_option_t> pOpt)
+s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_stop_module_option_t> pOpt)
 {
 	sys_prx.Todo("sys_prx_stop_module(id=%d, args=%d, argp_addr=0x%x, modres_addr=0x%x, flags=0x%llx, pOpt=0x%x)",
-		id, args, argp_addr, modres.GetAddr(), flags, pOpt.GetAddr());
+		id, args, argp_addr, modres.addr(), flags, pOpt.GetAddr());
 
 	sys_prx_t* prx;
 	if (!Emu.GetIdManager().GetIDData(id, prx))
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.h b/rpcs3/Emu/SysCalls/lv2/sys_prx.h
index 5c09a7c475..bb93b72617 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.h
@@ -69,8 +69,8 @@ s32 sys_prx_load_module(u32 path_addr, u64 flags, mem_ptr_t<sys_prx_load_module_
 s32 sys_prx_load_module_on_memcontainer();
 s32 sys_prx_load_module_by_fd();
 s32 sys_prx_load_module_on_memcontainer_by_fd();
-s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, mem32_t modres, u64 flags, mem_ptr_t<sys_prx_start_module_option_t> pOpt);
-s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, mem32_t modres, u64 flags, mem_ptr_t<sys_prx_stop_module_option_t> pOpt);
+s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_start_module_option_t> pOpt);
+s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_stop_module_option_t> pOpt);
 s32 sys_prx_unload_module(s32 id, u64 flags, mem_ptr_t<sys_prx_unload_module_option_t> pOpt);
 s32 sys_prx_get_module_list();
 s32 sys_prx_get_my_module_id();
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp b/rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp
index a8bdcf76e5..c6e6ec7d53 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rsx.cpp
@@ -29,10 +29,10 @@ s32 sys_rsx_device_close()
  * @param a6 (IN): E.g. Immediate value passed in cellGcmSys is 16. 
  * @param a7 (IN): E.g. Immediate value passed in cellGcmSys is 8.
  */
-s32 sys_rsx_memory_allocate(mem32_t mem_handle, mem32_t mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7)
+s32 sys_rsx_memory_allocate(vm::ptr<be_t<u32>> mem_handle, vm::ptr<be_t<u32>> mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7)
 {
 	sys_rsx.Todo("sys_rsx_memory_allocate(mem_handle_addr=0x%x, local_mem_addr=0x%x, size=0x%x, flags=0x%x, a5=%d, a6=%d, a7=%d)",
-		mem_handle.GetAddr(), mem_addr.GetAddr(), size, flags, a5, a6, a7);
+		mem_handle.addr(), mem_addr.addr(), size, flags, a5, a6, a7);
 	return CELL_OK;
 }
 
@@ -55,10 +55,10 @@ s32 sys_rsx_memory_free(u32 mem_handle)
  * @param mem_ctx (IN): mem_ctx given by sys_rsx_memory_allocate
  * @param system_mode (IN):
  */
-s32 sys_rsx_context_allocate(mem32_t context_id, mem32_t lpar_dma_control, mem32_t lpar_driver_info, mem32_t lpar_reports, u64 mem_ctx, u64 system_mode)
+s32 sys_rsx_context_allocate(vm::ptr<be_t<u32>> context_id, vm::ptr<be_t<u32>> lpar_dma_control, vm::ptr<be_t<u32>> lpar_driver_info, vm::ptr<be_t<u32>> lpar_reports, u64 mem_ctx, u64 system_mode)
 {
 	sys_rsx.Todo("sys_rsx_context_allocate(context_id_addr=0x%x, lpar_dma_control_addr=0x%x, lpar_driver_info_addr=0x%x, lpar_reports_addr=0x%x, mem_ctx=0x%x, system_mode=0x%x)",
-		context_id.GetAddr(), lpar_dma_control.GetAddr(), lpar_driver_info.GetAddr(), lpar_reports.GetAddr(), mem_ctx, system_mode);
+		context_id.addr(), lpar_dma_control.addr(), lpar_driver_info.addr(), lpar_reports.addr(), mem_ctx, system_mode);
 
 	return CELL_OK;
 }
@@ -170,9 +170,9 @@ s32 sys_rsx_context_attribute(s32 context_id, u32 package_id, u64 a3, u64 a4, u6
  * @param a2 (OUT): Unused?
  * @param dev_id (IN): An immediate value and always 8. (cellGcmInitPerfMon uses 11, 10, 9, 7, 12 successively).
  */
-s32 sys_rsx_device_map(mem32_t a1, mem32_t a2, u32 dev_id)
+s32 sys_rsx_device_map(vm::ptr<be_t<u32>> a1, vm::ptr<be_t<u32>> a2, u32 dev_id)
 {
-	sys_rsx.Todo("sys_rsx_device_map(a1_addr=0x%x, a2_addr=0x%x, a3=%d)", a1.GetAddr(), a2.GetAddr(), dev_id);
+	sys_rsx.Todo("sys_rsx_device_map(a1_addr=0x%x, a2_addr=0x%x, a3=%d)", a1.addr(), a2.addr(), dev_id);
 
 	if (dev_id > 15) {
 		// TODO: Throw RSX error
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rsx.h b/rpcs3/Emu/SysCalls/lv2/sys_rsx.h
index cba4e38c0c..244588c8c7 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rsx.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rsx.h
@@ -3,13 +3,13 @@
 // SysCalls
 s32 sys_rsx_device_open();
 s32 sys_rsx_device_close();
-s32 sys_rsx_memory_allocate(mem32_t mem_handle, mem32_t mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7);
+s32 sys_rsx_memory_allocate(vm::ptr<be_t<u32>> mem_handle, vm::ptr<be_t<u32>> mem_addr, u32 size, u64 flags, u64 a5, u64 a6, u64 a7);
 s32 sys_rsx_memory_free(u32 mem_handle);
-s32 sys_rsx_context_allocate(mem32_t context_id, mem32_t lpar_dma_control, mem32_t lpar_driver_info, mem32_t lpar_reports, u64 mem_ctx, u64 system_mode);
+s32 sys_rsx_context_allocate(vm::ptr<be_t<u32>> context_id, vm::ptr<be_t<u32>> lpar_dma_control, vm::ptr<be_t<u32>> lpar_driver_info, vm::ptr<be_t<u32>> lpar_reports, u64 mem_ctx, u64 system_mode);
 s32 sys_rsx_context_free(u32 context_id);
 s32 sys_rsx_context_iomap(u32 context_id, u32 io, u32 ea, u32 size, u64 flags);
 s32 sys_rsx_context_iounmap(u32 context_id, u32 a2, u32 io_addr, u32 size);
 s32 sys_rsx_context_attribute(s32 context_id, u32 package_id, u64 a3, u64 a4, u64 a5, u64 a6);
-s32 sys_rsx_device_map(mem32_t a1, mem32_t a2, u32 dev_id);
+s32 sys_rsx_device_map(vm::ptr<be_t<u32>> a1, vm::ptr<be_t<u32>> a2, u32 dev_id);
 s32 sys_rsx_device_unmap(u32 dev_id);
 s32 sys_rsx_attribute();
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
index 910777857c..09d979d671 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
@@ -9,9 +9,9 @@
 
 SysCallBase sys_rwlock("sys_rwlock");
 
-s32 sys_rwlock_create(mem32_t rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr)
+s32 sys_rwlock_create(vm::ptr<be_t<u32>> rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr)
 {
-	sys_rwlock.Warning("sys_rwlock_create(rw_lock_id_addr=0x%x, attr_addr=0x%x)", rw_lock_id.GetAddr(), attr.GetAddr());
+	sys_rwlock.Warning("sys_rwlock_create(rw_lock_id_addr=0x%x, attr_addr=0x%x)", rw_lock_id.addr(), attr.GetAddr());
 
 	if (!attr)
 		return CELL_EFAULT;
@@ -31,10 +31,11 @@ s32 sys_rwlock_create(mem32_t rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr
 		return CELL_EINVAL;
 	}
 
-	rw_lock_id = sys_rwlock.GetNewId(new RWLock((u32)attr->attr_protocol, attr->name_u64), TYPE_RWLOCK);
+	u32 id = sys_rwlock.GetNewId(new RWLock((u32)attr->attr_protocol, attr->name_u64), TYPE_RWLOCK);
+	*rw_lock_id = id;
 
 	sys_rwlock.Warning("*** rwlock created [%s] (protocol=0x%x): id = %d",
-		std::string(attr->name, 8).c_str(), (u32)attr->attr_protocol, rw_lock_id.GetValue());
+		std::string(attr->name, 8).c_str(), (u32)attr->attr_protocol, id);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
index 9f9fa0ed35..8e18b468de 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
@@ -150,7 +150,7 @@ struct RWLock
 };
 
 // SysCalls
-s32 sys_rwlock_create(mem32_t rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr);
+s32 sys_rwlock_create(vm::ptr<be_t<u32>> rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr);
 s32 sys_rwlock_destroy(u32 rw_lock_id);
 s32 sys_rwlock_rlock(u32 rw_lock_id, u64 timeout);
 s32 sys_rwlock_tryrlock(u32 rw_lock_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
index c539e7fc55..52ff26cbbc 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
@@ -11,10 +11,10 @@
 
 SysCallBase sys_semaphore("sys_semaphore");
 
-s32 sys_semaphore_create(mem32_t sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
+s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
 {
 	sys_semaphore.Warning("sys_semaphore_create(sem_addr=0x%x, attr_addr=0x%x, initial_count=%d, max_count=%d)",
-		sem.GetAddr(), attr.GetAddr(), initial_count, max_count);
+		sem.addr(), attr.GetAddr(), initial_count, max_count);
 
 	if (max_count <= 0 || initial_count > max_count || initial_count < 0)
 	{
@@ -37,9 +37,10 @@ s32 sys_semaphore_create(mem32_t sem, mem_ptr_t<sys_semaphore_attribute> attr, i
 	default: sys_semaphore.Error("Unknown protocol attribute(0x%x)", (u32)attr->protocol); return CELL_EINVAL;
 	}
 
-	sem = sys_semaphore.GetNewId(new Semaphore(initial_count, max_count, attr->protocol, attr->name_u64), TYPE_SEMAPHORE);
+	u32 id = sys_semaphore.GetNewId(new Semaphore(initial_count, max_count, attr->protocol, attr->name_u64), TYPE_SEMAPHORE);
+	*sem = id;
 	sys_semaphore.Notice("*** semaphore created [%s] (protocol=0x%x): id = %d",
-		std::string(attr->name, 8).c_str(), (u32)attr->protocol, sem.GetValue());
+		std::string(attr->name, 8).c_str(), (u32)attr->protocol, id);
 
 	return CELL_OK;
 }
@@ -192,9 +193,9 @@ s32 sys_semaphore_post(u32 sem_id, int count)
 	return CELL_OK;
 }
 
-s32 sys_semaphore_get_value(u32 sem_id, mem32_t count)
+s32 sys_semaphore_get_value(u32 sem_id, vm::ptr<be_t<s32>> count)
 {
-	sys_semaphore.Log("sys_semaphore_get_value(sem_id=%d, count_addr=0x%x)", sem_id, count.GetAddr());
+	sys_semaphore.Log("sys_semaphore_get_value(sem_id=%d, count_addr=0x%x)", sem_id, count.addr());
 
 	Semaphore* sem;
 	if (!Emu.GetIdManager().GetIDData(sem_id, sem))
@@ -204,7 +205,7 @@ s32 sys_semaphore_get_value(u32 sem_id, mem32_t count)
 
 	std::lock_guard<std::mutex> lock(sem->m_mutex);
 	
-	count = sem->m_value;
+	*count = sem->m_value;
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
index e78165d989..a27691405a 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
@@ -38,9 +38,9 @@ struct Semaphore
 };
 
 // SysCalls
-s32 sys_semaphore_create(mem32_t sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
+s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
 s32 sys_semaphore_destroy(u32 sem_id);
 s32 sys_semaphore_wait(u32 sem_id, u64 timeout);
 s32 sys_semaphore_trywait(u32 sem_id);
 s32 sys_semaphore_post(u32 sem_id, int count);
-s32 sys_semaphore_get_value(u32 sem_id, mem32_t count);
+s32 sys_semaphore_get_value(u32 sem_id, vm::ptr<be_t<s32>> count);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
index 50624a8d5e..529931a74e 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
@@ -47,10 +47,10 @@ s32 sys_spu_image_open(mem_ptr_t<sys_spu_image> img, u32 path_addr)
 }
 
 //172
-s32 sys_spu_thread_initialize(mem32_t thread, u32 group, u32 spu_num, mem_ptr_t<sys_spu_image> img, mem_ptr_t<sys_spu_thread_attribute> attr, mem_ptr_t<sys_spu_thread_argument> arg)
+s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, mem_ptr_t<sys_spu_image> img, mem_ptr_t<sys_spu_thread_attribute> attr, mem_ptr_t<sys_spu_thread_argument> arg)
 {
 	sys_spu.Warning("sys_spu_thread_initialize(thread_addr=0x%x, group=0x%x, spu_num=%d, img_addr=0x%x, attr_addr=0x%x, arg_addr=0x%x)",
-		thread.GetAddr(), group, spu_num, img.GetAddr(), attr.GetAddr(), arg.GetAddr());
+		thread.addr(), group, spu_num, img.GetAddr(), attr.GetAddr(), arg.GetAddr());
 
 	SpuGroupInfo* group_info;
 	if(!Emu.GetIdManager().GetIDData(group, group_info))
@@ -96,11 +96,12 @@ s32 sys_spu_thread_initialize(mem32_t thread, u32 group, u32 spu_num, mem_ptr_t<
 	new_thread.SetArg(3, a4);
 	new_thread.Run();
 
-	thread = group_info->list[spu_num] = new_thread.GetId();
+	u32 id = new_thread.GetId();
+	*thread = group_info->list[spu_num] = id;
 	(*(SPUThread*)&new_thread).group = group_info;
 
 	sys_spu.Warning("*** New SPU Thread [%s] (img_offset=0x%x, ls_offset=0x%x, ep=0x%x, a1=0x%llx, a2=0x%llx, a3=0x%llx, a4=0x%llx): id=%d",
-		(attr->name_addr ? name.c_str() : ""), (u32) img->segs_addr, ((SPUThread&) new_thread).dmac.ls_offset, spu_ep, a1, a2, a3, a4, thread.GetValue());
+		(attr->name_addr ? name.c_str() : ""), (u32) img->segs_addr, ((SPUThread&) new_thread).dmac.ls_offset, spu_ep, a1, a2, a3, a4, id);
 
 	return CELL_OK;
 }
@@ -125,9 +126,9 @@ s32 sys_spu_thread_set_argument(u32 id, mem_ptr_t<sys_spu_thread_argument> arg)
 }
 
 //165
-s32 sys_spu_thread_get_exit_status(u32 id, mem32_t status)
+s32 sys_spu_thread_get_exit_status(u32 id, vm::ptr<be_t<u32>> status)
 {
-	sys_spu.Warning("sys_spu_thread_get_exit_status(id=%d, status_addr=0x%x)", id, status.GetAddr());
+	sys_spu.Warning("sys_spu_thread_get_exit_status(id=%d, status_addr=0x%x)", id, status.addr());
 
 	CPUThread* thr = Emu.GetCPU().GetThread(id);
 
@@ -142,7 +143,7 @@ s32 sys_spu_thread_get_exit_status(u32 id, mem32_t status)
 		return CELL_ESTAT;
 	}
 
-	status = res;
+	*status = res;
 	return CELL_OK;
 }
 
@@ -400,10 +401,10 @@ s32 sys_spu_thread_group_terminate(u32 id, int value)
 }
 
 //170
-s32 sys_spu_thread_group_create(mem32_t id, u32 num, int prio, mem_ptr_t<sys_spu_thread_group_attribute> attr)
+s32 sys_spu_thread_group_create(vm::ptr<be_t<u32>> id, u32 num, int prio, mem_ptr_t<sys_spu_thread_group_attribute> attr)
 {
 	sys_spu.Warning("sys_spu_thread_group_create(id_addr=0x%x, num=%d, prio=%d, attr_addr=0x%x)",
-		id.GetAddr(), num, prio, attr.GetAddr());
+		id.addr(), num, prio, attr.GetAddr());
 
 	if (num > 256) return CELL_EINVAL;
 
@@ -411,18 +412,18 @@ s32 sys_spu_thread_group_create(mem32_t id, u32 num, int prio, mem_ptr_t<sys_spu
 
 	const std::string name = Memory.ReadString(attr->name_addr, attr->name_len);
 
-	id = sys_spu.GetNewId(new SpuGroupInfo(name, num, prio, attr->type, attr->ct));
+	*id = sys_spu.GetNewId(new SpuGroupInfo(name, num, prio, attr->type, attr->ct));
 
 	sys_spu.Warning("*** SPU Thread Group created [%s] (type=0x%x, option.ct=0x%x): id=%d", 
-		name.c_str(), (int)attr->type, (u32)attr->ct, id.GetValue());
+		name.c_str(), (int)attr->type, (u32)attr->ct, (u32)*id);
 
 	return CELL_OK;
 }
 
 //178
-s32 sys_spu_thread_group_join(u32 id, mem32_t cause, mem32_t status)
+s32 sys_spu_thread_group_join(u32 id, vm::ptr<be_t<u32>> cause, vm::ptr<be_t<u32>> status)
 {
-	sys_spu.Warning("sys_spu_thread_group_join(id=%d, cause_addr=0x%x, status_addr=0x%x)", id, cause.GetAddr(), status.GetAddr());
+	sys_spu.Warning("sys_spu_thread_group_join(id=%d, cause_addr=0x%x, status_addr=0x%x)", id, cause.addr(), status.addr());
 
 	SpuGroupInfo* group_info;
 	if(!Emu.GetIdManager().GetIDData(id, group_info))
@@ -457,26 +458,26 @@ s32 sys_spu_thread_group_join(u32 id, mem32_t cause, mem32_t status)
 		}
 	}
 
-	if (cause.GetAddr())
+	if (cause)
 	{
-		cause = group_info->m_group_exit
+		*cause = group_info->m_group_exit
 			? SYS_SPU_THREAD_GROUP_JOIN_GROUP_EXIT
 			: (all_threads_exit
 				? SYS_SPU_THREAD_GROUP_JOIN_ALL_THREADS_EXIT
 				: SYS_SPU_THREAD_GROUP_JOIN_TERMINATED);
 	}
 
-	if (status.GetAddr()) status = group_info->m_exit_status;
+	if (status) *status = group_info->m_exit_status;
 
 	group_info->m_state = SPU_THREAD_GROUP_STATUS_INITIALIZED;
 	group_info->lock = 0; // release lock	TODO: this LOCK may be replaced.
 	return CELL_OK;
 }
 
-s32 sys_spu_thread_create(mem32_t thread_id, mem32_t entry, u64 arg, int prio, u32 stacksize, u64 flags, u32 threadname_addr)
+s32 sys_spu_thread_create(vm::ptr<be_t<u32>> thread_id, vm::ptr<be_t<u32>> entry, u64 arg, int prio, u32 stacksize, u64 flags, u32 threadname_addr)
 {
 	sys_spu.Todo("sys_spu_thread_create(thread_id_addr=0x%x, entry_addr=0x%x, arg=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname_addr=0x%x",
-		thread_id.GetAddr(), entry.GetAddr(), arg, prio, stacksize, flags, threadname_addr);
+		thread_id.addr(), entry.addr(), arg, prio, stacksize, flags, threadname_addr);
 	return CELL_OK;
 }
 
@@ -878,9 +879,9 @@ s32 sys_spu_thread_group_disconnect_event_all_threads(u32 id, u8 spup)
 }
 
 //160
-s32 sys_raw_spu_create(mem32_t id, u32 attr_addr)
+s32 sys_raw_spu_create(vm::ptr<be_t<u32>> id, u32 attr_addr)
 {
-	sys_spu.Warning("sys_raw_spu_create(id_addr=0x%x, attr_addr=0x%x)", id.GetAddr(), attr_addr);
+	sys_spu.Warning("sys_raw_spu_create(id_addr=0x%x, attr_addr=0x%x)", id.addr(), attr_addr);
 
 	CPUThread& new_thread = Emu.GetCPU().AddThread(CPU_THREAD_RAW_SPU);
 	if (((RawSPUThread&)new_thread).GetIndex() >= 5)
@@ -889,7 +890,7 @@ s32 sys_raw_spu_create(mem32_t id, u32 attr_addr)
 		return CELL_EAGAIN;
 	}
 
-	id = ((RawSPUThread&)new_thread).GetIndex();
+	*id = ((RawSPUThread&)new_thread).GetIndex();
 	new_thread.Run();
 	return CELL_OK;
 }
@@ -911,9 +912,9 @@ s32 sys_raw_spu_destroy(u32 id)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_create_interrupt_tag(u32 id, u32 class_id, u32 hwthread, mem32_t intrtag)
+s32 sys_raw_spu_create_interrupt_tag(u32 id, u32 class_id, u32 hwthread, vm::ptr<be_t<u32>> intrtag)
 {
-	sys_spu.Warning("sys_raw_spu_create_interrupt_tag(id=%d, class_id=%d, hwthread=0x%x, intrtag_addr=0x%x)", id, class_id, hwthread, intrtag.GetAddr());
+	sys_spu.Warning("sys_raw_spu_create_interrupt_tag(id=%d, class_id=%d, hwthread=0x%x, intrtag_addr=0x%x)", id, class_id, hwthread, intrtag.addr());
 
 	RawSPUThread* t = Emu.GetCPU().GetRawSPUThread(id);
 
@@ -933,7 +934,7 @@ s32 sys_raw_spu_create_interrupt_tag(u32 id, u32 class_id, u32 hwthread, mem32_t
 	}
 
 	t->m_intrtag[class_id].enabled = 1;
-	intrtag = (id & 0xff) | (class_id << 8);
+	*intrtag = (id & 0xff) | (class_id << 8);
 
 	return CELL_OK;
 }
@@ -1014,9 +1015,9 @@ s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, vm::ptr<be_t<u64>> stat)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_read_puint_mb(u32 id, mem32_t value)
+s32 sys_raw_spu_read_puint_mb(u32 id, vm::ptr<be_t<u32>> value)
 {
-	sys_spu.Log("sys_raw_spu_read_puint_mb(id=%d, value_addr=0x%x)", id, value.GetAddr());
+	sys_spu.Log("sys_raw_spu_read_puint_mb(id=%d, value_addr=0x%x)", id, value.addr());
 
 	RawSPUThread* t = Emu.GetCPU().GetRawSPUThread(id);
 	if (!t)
@@ -1026,7 +1027,7 @@ s32 sys_raw_spu_read_puint_mb(u32 id, mem32_t value)
 
 	u32 v;
 	t->SPU.Out_IntrMBox.PopUncond(v);
-	value = v;
+	*value = v;
 	return CELL_OK;
 }
 
@@ -1044,9 +1045,9 @@ s32 sys_raw_spu_set_spu_cfg(u32 id, u32 value)
 	return CELL_OK;
 }
 
-s32 sys_raw_spu_get_spu_cfg(u32 id, mem32_t value)
+s32 sys_raw_spu_get_spu_cfg(u32 id, vm::ptr<be_t<u32>> value)
 {
-	sys_spu.Log("sys_raw_spu_get_spu_afg(id=%d, value_addr=0x%x)", id, value.GetAddr());
+	sys_spu.Log("sys_raw_spu_get_spu_afg(id=%d, value_addr=0x%x)", id, value.addr());
 
 	RawSPUThread* t = Emu.GetCPU().GetRawSPUThread(id);
 	if (!t)
@@ -1054,6 +1055,6 @@ s32 sys_raw_spu_get_spu_cfg(u32 id, mem32_t value)
 		return CELL_ESRCH;
 	}
 
-	value = (u32)t->cfg.value;
+	*value = (u32)t->cfg.value;
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.h b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
index 7736a51b23..4547186697 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
@@ -111,7 +111,7 @@ struct SpuGroupInfo
 // SysCalls
 s32 sys_spu_initialize(u32 max_usable_spu, u32 max_raw_spu);
 s32 sys_spu_image_open(mem_ptr_t<sys_spu_image> img, u32 path_addr);
-s32 sys_spu_thread_initialize(mem32_t thread, u32 group, u32 spu_num, mem_ptr_t<sys_spu_image> img, mem_ptr_t<sys_spu_thread_attribute> attr, mem_ptr_t<sys_spu_thread_argument> arg);
+s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, mem_ptr_t<sys_spu_image> img, mem_ptr_t<sys_spu_thread_attribute> attr, mem_ptr_t<sys_spu_thread_argument> arg);
 s32 sys_spu_thread_set_argument(u32 id, mem_ptr_t<sys_spu_thread_argument> arg);
 s32 sys_spu_thread_group_destroy(u32 id);
 s32 sys_spu_thread_group_start(u32 id);
@@ -119,9 +119,9 @@ s32 sys_spu_thread_group_suspend(u32 id);
 s32 sys_spu_thread_group_resume(u32 id);
 s32 sys_spu_thread_group_yield(u32 id);	
 s32 sys_spu_thread_group_terminate(u32 id, int value);
-s32 sys_spu_thread_group_create(mem32_t id, u32 num, int prio, mem_ptr_t<sys_spu_thread_group_attribute> attr);
-s32 sys_spu_thread_create(mem32_t thread_id, mem32_t entry, u64 arg, int prio, u32 stacksize, u64 flags, u32 threadname_addr);
-s32 sys_spu_thread_group_join(u32 id, mem32_t cause, mem32_t status);
+s32 sys_spu_thread_group_create(vm::ptr<be_t<u32>> id, u32 num, int prio, mem_ptr_t<sys_spu_thread_group_attribute> attr);
+s32 sys_spu_thread_create(vm::ptr<be_t<u32>> thread_id, vm::ptr<be_t<u32>> entry, u64 arg, int prio, u32 stacksize, u64 flags, u32 threadname_addr);
+s32 sys_spu_thread_group_join(u32 id, vm::ptr<be_t<u32>> cause, vm::ptr<be_t<u32>> status);
 s32 sys_spu_thread_group_connect_event(u32 id, u32 eq, u32 et);
 s32 sys_spu_thread_group_disconnect_event(u32 id, u32 et);
 s32 sys_spu_thread_group_connect_event_all_threads(u32 id, u32 eq_id, u64 req, vm::ptr<u8> spup);
@@ -136,15 +136,15 @@ s32 sys_spu_thread_connect_event(u32 id, u32 eq, u32 et, u8 spup);
 s32 sys_spu_thread_disconnect_event(u32 id, u32 event_type, u8 spup);
 s32 sys_spu_thread_bind_queue(u32 id, u32 spuq, u32 spuq_num);
 s32 sys_spu_thread_unbind_queue(u32 id, u32 spuq_num);
-s32 sys_spu_thread_get_exit_status(u32 id, mem32_t status);
+s32 sys_spu_thread_get_exit_status(u32 id, vm::ptr<be_t<u32>> status);
 
-s32 sys_raw_spu_create(mem32_t id, u32 attr_addr);
+s32 sys_raw_spu_create(vm::ptr<be_t<u32>> id, u32 attr_addr);
 s32 sys_raw_spu_destroy(u32 id);
-s32 sys_raw_spu_create_interrupt_tag(u32 id, u32 class_id, u32 hwthread, mem32_t intrtag);
+s32 sys_raw_spu_create_interrupt_tag(u32 id, u32 class_id, u32 hwthread, vm::ptr<be_t<u32>> intrtag);
 s32 sys_raw_spu_set_int_mask(u32 id, u32 class_id, u64 mask);
 s32 sys_raw_spu_get_int_mask(u32 id, u32 class_id, vm::ptr<be_t<u64>> mask);
 s32 sys_raw_spu_set_int_stat(u32 id, u32 class_id, u64 stat);
 s32 sys_raw_spu_get_int_stat(u32 id, u32 class_id, vm::ptr<be_t<u64>> stat);
-s32 sys_raw_spu_read_puint_mb(u32 id, mem32_t value);
+s32 sys_raw_spu_read_puint_mb(u32 id, vm::ptr<be_t<u32>> value);
 s32 sys_raw_spu_set_spu_cfg(u32 id, u32 value);
-s32 sys_raw_spu_get_spu_cfg(u32 id, mem32_t value);
+s32 sys_raw_spu_get_spu_cfg(u32 id, vm::ptr<be_t<u32>> value);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_time.cpp b/rpcs3/Emu/SysCalls/lv2/sys_time.cpp
index f0f13ff8f8..8591c10f66 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_time.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_time.cpp
@@ -18,7 +18,7 @@
 SysCallBase sys_time("sys_time");
 
 static const u64 timebase_frequency = /*79800000*/ 80000000; // 80 Mhz
-extern int cellSysutilGetSystemParamInt(int id, mem32_t value);
+extern int cellSysutilGetSystemParamInt(int id, vm::ptr<be_t<u32>> value);
 
 // Auxiliary functions
 u64 get_time()
@@ -59,9 +59,9 @@ u64 get_system_time()
 
 
 // Functions
-s32 sys_time_get_timezone(mem32_t timezone, mem32_t summertime)
+s32 sys_time_get_timezone(vm::ptr<be_t<u32>> timezone, vm::ptr<be_t<u32>> summertime)
 {
-	sys_time.Warning("sys_time_get_timezone(timezone_addr=0x%x, summertime_addr=0x%x)", timezone.GetAddr(), summertime.GetAddr());
+	sys_time.Warning("sys_time_get_timezone(timezone_addr=0x%x, summertime_addr=0x%x)", timezone.addr(), summertime.addr());
 
 	int ret;
 	ret = cellSysutilGetSystemParamInt(0x0116, timezone);   //0x0116 = CELL_SYSUTIL_SYSTEMPARAM_ID_TIMEZONE
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_time.h b/rpcs3/Emu/SysCalls/lv2/sys_time.h
index bb65b7c7f2..28863999e5 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_time.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_time.h
@@ -7,7 +7,7 @@ u64 get_time();
 u64 get_system_time();
 
 // SysCalls
-s32 sys_time_get_timezone(mem32_t timezone, mem32_t summertime);
+s32 sys_time_get_timezone(vm::ptr<be_t<u32>> timezone, vm::ptr<be_t<u32>> summertime);
 s32 sys_time_get_current_time(u32 sec_addr, u32 nsec_addr);
 s64 sys_time_get_system_time();
 u64 sys_time_get_timebase_frequency();
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp b/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
index 7250394698..fefcb9522e 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
@@ -8,11 +8,11 @@
 
 SysCallBase sys_timer("sys_timer");
 
-s32 sys_timer_create(mem32_t timer_id)
+s32 sys_timer_create(vm::ptr<be_t<u32>> timer_id)
 {
-	sys_timer.Warning("sys_timer_create(timer_id_addr=0x%x)", timer_id.GetAddr());
+	sys_timer.Warning("sys_timer_create(timer_id_addr=0x%x)", timer_id.addr());
 
-	timer_id = sys_timer.GetNewId(new timer, TYPE_TIMER);
+	*timer_id = sys_timer.GetNewId(new timer, TYPE_TIMER);
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_timer.h b/rpcs3/Emu/SysCalls/lv2/sys_timer.h
index 4332f75667..9e294f3b62 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_timer.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_timer.h
@@ -19,7 +19,7 @@ struct timer
 	sys_timer_information_t timer_information_t;
 };
 
-s32 sys_timer_create(mem32_t timer_id);
+s32 sys_timer_create(vm::ptr<be_t<u32>> timer_id);
 s32 sys_timer_destroy(u32 timer_id);
 s32 sys_timer_get_information(u32 timer_id, mem_ptr_t<sys_timer_information_t> info);
 s32 sys_timer_start(u32 timer_id, s64 basetime, u64 period);

From f31ed4e9f25a6f146cb523d16471647fc5624a04 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 16:47:26 +0400
Subject: [PATCH 21/36] mem_func_ptr_t replaced

---
 rpcs3/Emu/Memory/Memory.h                     | 79 ---------------
 rpcs3/Emu/Memory/vm_ptr.h                     | 33 +++++--
 rpcs3/Emu/SysCalls/Modules/cellAdec.h         |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellDmux.h         |  4 +-
 rpcs3/Emu/SysCalls/Modules/cellGame.cpp       |  8 +-
 rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp  |  8 +-
 rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h    |  4 +-
 rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp     |  4 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp     |  4 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.h       |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSail.h         | 28 +++---
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp      |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp    |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSync.cpp       | 26 ++---
 rpcs3/Emu/SysCalls/Modules/cellSync2.cpp      |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp    | 12 +--
 .../SysCalls/Modules/cellSysutil_SaveData.cpp | 96 ++++++++++---------
 .../SysCalls/Modules/cellSysutil_SaveData.h   | 30 +++---
 rpcs3/Emu/SysCalls/Modules/cellVdec.h         |  2 +-
 rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp    |  4 +-
 rpcs3/Emu/SysCalls/Modules/sys_fs.cpp         | 10 +-
 rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp              |  4 +-
 rpcs3/Emu/SysCalls/lv2/lv2Fs.h                |  2 +-
 23 files changed, 152 insertions(+), 216 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index 9959922730..127428d0d8 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -689,84 +689,5 @@ public:
 	mem_t& operator >>= (T right) { return *this = (*this) >> right; }
 };
 
-template<typename T>
-struct _func_arg
-{
-	__forceinline static u64 get_value(const T& arg)
-	{
-		return arg;
-	}
-};
-
-template<typename T>
-struct _func_arg<mem_base_t<T, u32>>
-{
-	__forceinline static u64 get_value(const mem_base_t<T, u32> arg)
-	{
-		return arg.GetAddr();
-	}
-};
-
-template<typename T, int lvl> struct _func_arg<mem_ptr_t<T, lvl, u32>> : public _func_arg<mem_base_t<T, u32>> {};
-template<int lvl> struct _func_arg<mem_ptr_t<void, lvl, u32>> : public _func_arg<mem_base_t<u8, u32>>{};
-template<typename T> struct _func_arg<mem_t<T, u32>> : public _func_arg<mem_base_t<T, u32>> {};
-
-template<typename T>
-struct _func_arg<be_t<T>>
-{
-	__forceinline static u64 get_value(const be_t<T>& arg)
-	{
-		return arg.ToLE();
-	}
-};
-
-template<typename T, typename AT = u32> class mem_func_ptr_t;
-template<typename T, typename AT = u32> class mem_func_beptr_t : public mem_func_ptr_t<T, be_t<AT>> {};
-
-template<typename RT, typename AT>
-class mem_func_ptr_t<RT (*)(), AT> : public mem_base_t<u64, AT>
-{
-	__forceinline RT call_func(bool is_async) const
-	{
-		Callback cb;
-		cb.SetAddr(this->m_addr);
-		return (RT)cb.Branch(!is_async);
-	}
-
-public:
-	__forceinline RT operator()() const
-	{
-		return call_func(false);
-	}
-
-	__forceinline void async() const
-	{
-		call_func(true);
-	}
-};
-
-template<typename AT, typename RT, typename ...T>
-class mem_func_ptr_t<RT(*)(T...), AT> : public mem_base_t<u64, AT>
-{
-	__forceinline RT call_func(bool is_async, T... args) const
-	{
-		Callback cb;
-		cb.SetAddr(this->m_addr);
-		cb.Handle(_func_arg<T>::get_value(args)...);
-		return (RT)cb.Branch(!is_async);
-	}
-
-public:
-	__forceinline RT operator()(T... args) const
-	{
-		return call_func(false, args...);
-	}
-
-	__forceinline void async(T... args) const
-	{
-		call_func(true, args...);
-	}
-};
-
 #include "vm.h"
 
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 169bfab71b..88cab76b3c 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -293,11 +293,6 @@ namespace vm
 			return m_addr;
 		}
 
-		type const get_ptr() const
-		{
-			return *((type*)vm::get_ptr<void*>(m_addr));
-		}
-
 		operator bool() const
 		{
 			return m_addr != 0;
@@ -307,6 +302,12 @@ namespace vm
 		{
 			return (ptr&)addr;
 		}
+
+		operator std::function<RT()>() const
+		{
+			const AT addr = m_addr;
+			return [addr]() -> RT { return make(addr)(); };
+		}
 	};
 
 	template<typename AT, typename RT, typename ...T>
@@ -341,6 +342,17 @@ namespace vm
 			}
 		};
 
+		template<typename TT, int i, typename ATT>
+		struct _func_arg<mem_ptr_t<TT, i, ATT>>
+		{
+			static_assert(!i, "Invalid callback argument type (mem_ptr_t), use vm::ptr");
+			
+			__forceinline static u64 get_value(const mem_ptr_t<TT, i, ATT> arg)
+			{
+				return 0;
+			}
+		};
+
 		__forceinline RT call_func(bool is_async, T... args) const
 		{
 			Callback cb;
@@ -367,11 +379,6 @@ namespace vm
 			return m_addr;
 		}
 
-		type const get_ptr() const
-		{
-			return *((type*)vm::get_ptr<void*>(m_addr));
-		}
-
 		operator bool() const
 		{
 			return m_addr != 0;
@@ -381,6 +388,12 @@ namespace vm
 		{
 			return (ptr&)addr;
 		}
+
+		operator std::function<RT(T...)>() const
+		{
+			const AT addr = m_addr;
+			return [addr](T... args) -> RT { return make(addr)(args...); };
+		}
 	};
 
 	template<typename T, int lvl = 1, typename AT = u32>
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.h b/rpcs3/Emu/SysCalls/Modules/cellAdec.h
index a72c126094..a77840187e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAdec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.h
@@ -360,7 +360,7 @@ enum CellAdecMsgType
 	CELL_ADEC_MSG_TYPE_SEQDONE,
 };
 
-typedef mem_func_ptr_t<int (*)(u32 handle, CellAdecMsgType msgType, int msgData, u32 cbArg)> CellAdecCbMsg;
+typedef s32(*CellAdecCbMsg)(u32 handle, CellAdecMsgType msgType, int msgData, u32 cbArg);
 
 struct CellAdecCb
 {
diff --git a/rpcs3/Emu/SysCalls/Modules/cellDmux.h b/rpcs3/Emu/SysCalls/Modules/cellDmux.h
index cd0e5c6af7..c44418ea5d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellDmux.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellDmux.h
@@ -222,7 +222,7 @@ struct CellDmuxResource2
 	be_t<u32> shit[4];
 };
 
-typedef mem_func_ptr_t<void (*)(u32 demuxerHandle, mem_ptr_t<CellDmuxMsg> demuxerMsg, u32 cbArg_addr)> CellDmuxCbMsg;
+typedef u32(*CellDmuxCbMsg)(u32 demuxerHandle, vm::ptr<CellDmuxMsg> demuxerMsg, u32 cbArg_addr);
 
 struct CellDmuxCb
 {
@@ -231,7 +231,7 @@ struct CellDmuxCb
 	be_t<u32> cbArg_addr;
 };
 
-typedef mem_func_ptr_t<void (*)(u32 demuxerHandle, u32 esHandle, mem_ptr_t<CellDmuxEsMsg> esMsg, u32 cbArg_addr)> CellDmuxCbEsMsg;
+typedef u32(*CellDmuxCbEsMsg)(u32 demuxerHandle, u32 esHandle, vm::ptr<CellDmuxEsMsg> esMsg, u32 cbArg_addr);
 
 struct CellDmuxEsCb
 {
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
index d0b6548da3..ba2aadd2a5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
@@ -199,10 +199,10 @@ int cellGameContentPermit(vm::ptr<char> contentInfoPath, vm::ptr<char> usrdirPat
 }
 
 int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDialog,
-	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container)
+	vm::ptr<void(*)(vm::ptr<CellGameDataCBResult> cbResult, vm::ptr<CellGameDataStatGet> get, vm::ptr<CellGameDataStatSet> set)> funcStat, u32 container)
 {
 	cellGame->Warning("cellGameDataCheckCreate2(version=0x%x, dirName_addr=0x%x, errDialog=0x%x, funcStat_addr=0x%x, container=%d)",
-		version, dirName.addr(), errDialog, funcStat.GetAddr(), container);
+		version, dirName.addr(), errDialog, funcStat.addr(), container);
 
 	if (version != CELL_GAMEDATA_VERSION_CURRENT || errDialog > 1)
 	{
@@ -265,7 +265,7 @@ int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDi
 	strcpy_trunc(cbGet->getParam.title, psf.GetString("TITLE"));
 	// TODO: write lang titles
 
-	funcStat(cbResult.addr(), cbGet.addr(), cbSet.addr());
+	funcStat(cbResult, cbGet, cbSet);
 
 	if (cbSet->setParam.GetAddr())
 	{
@@ -305,7 +305,7 @@ int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDi
 }
 
 int cellGameDataCheckCreate(u32 version, vm::ptr<const char> dirName, u32 errDialog, 
-	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container)
+	vm::ptr<void(*)(vm::ptr<CellGameDataCBResult> cbResult, vm::ptr<CellGameDataStatGet> get, vm::ptr<CellGameDataStatSet> set)> funcStat, u32 container)
 {
 	// TODO: almost identical, the only difference is that this function will always calculate the size of game data
 	return cellGameDataCheckCreate2(version, dirName, errDialog, funcStat, container);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
index 57196033bc..714f45c1bf 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
@@ -60,10 +60,10 @@ void MsgDialogClose()
 	g_msg_dialog_wait_until = get_system_time();
 }
 
-int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
+int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, vm::ptr<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
 {
 	cellSysutil->Warning("cellMsgDialogOpen2(type=0x%x, msgString_addr=0x%x, callback_addr=0x%x, userData=0x%x, extParam=0x%x)",
-		type, msgString.addr(), callback.GetAddr(), userData, extParam);
+		type, msgString.addr(), callback.addr(), userData, extParam);
 	
 	//type |= CELL_MSGDIALOG_TYPE_PROGRESSBAR_SINGLE | CELL_MSGDIALOG_TYPE_BG_INVISIBLE;
 	//type |= CELL_MSGDIALOG_TYPE_BUTTON_TYPE_YESNO | CELL_MSGDIALOG_TYPE_DEFAULT_CURSOR_NO;
@@ -139,10 +139,10 @@ int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, mem_func_ptr_t<C
 	return CELL_OK;
 }
 
-int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
+int cellMsgDialogOpenErrorCode(u32 errorCode, vm::ptr<CellMsgDialogCallback> callback, u32 userData, u32 extParam)
 {
 	cellSysutil->Warning("cellMsgDialogOpenErrorCode(errorCode=0x%x, callback_addr=0x%x, userData=0x%x, extParam=%d)",
-		errorCode, callback.GetAddr(), userData, extParam);
+		errorCode, callback.addr(), userData, extParam);
 
 	std::string errorMessage;
 	switch (errorCode)
diff --git a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h
index dbfd1438d4..820d2a7792 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.h
@@ -81,8 +81,8 @@ enum
 
 typedef void(*CellMsgDialogCallback)(int buttonType, u32 userData);
 
-int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
-int cellMsgDialogOpenErrorCode(u32 errorCode, mem_func_ptr_t<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
+int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, vm::ptr<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
+int cellMsgDialogOpenErrorCode(u32 errorCode, vm::ptr<CellMsgDialogCallback> callback, u32 userData, u32 extParam);
 
 int cellMsgDialogProgressBarSetMsg(u32 progressBarIndex, vm::ptr<const char> msgString);
 int cellMsgDialogProgressBarReset(u32 progressBarIndex);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
index dd03de2960..e3b992bd0c 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
@@ -29,9 +29,9 @@ int cellNetCtlGetState(vm::ptr<be_t<u32>> state)
 	return CELL_OK;
 }
 
-int cellNetCtlAddHandler(mem_func_ptr_t<cellNetCtlHandler> handler, vm::ptr<be_t<u32>> arg, s32 hid)
+int cellNetCtlAddHandler(vm::ptr<cellNetCtlHandler> handler, vm::ptr<be_t<u32>> arg, s32 hid)
 {
-	cellNetCtl->Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid=%x)", handler.GetAddr(), arg.addr(), hid);
+	cellNetCtl->Todo("cellNetCtlAddHandler(handler_addr=0x%x, arg_addr=0x%x, hid=%x)", handler.addr(), arg.addr(), hid);
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index aedf3de8c9..daf21dded9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -92,14 +92,14 @@ int cellPngDecExtOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<Ce
 	cellPngDec->Warning("cellPngDecExtOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x, cbCtrlStrm_addr=0x%x, opnParam=0x%x)",
 		mainHandle, subHandle.addr(), src.GetAddr(), openInfo, cbCtrlStrm.GetAddr(), opnParam.GetAddr());
 
-	cellPngDec->Warning("*** cbCtrlStrm->cbCtrlStrmFunc_addr=0x%x", cbCtrlStrm->cbCtrlStrmFunc.GetAddr());
+	cellPngDec->Warning("*** cbCtrlStrm->cbCtrlStrmFunc_addr=0x%x", cbCtrlStrm->cbCtrlStrmFunc.addr());
 
 	vm::var<CellPngDecStrmInfo> streamInfo;
 	vm::var<CellPngDecStrmParam> streamParam;
 
 	int res = cellPngDecOpen(mainHandle, subHandle, src, openInfo);
 
-	if (!res) cbCtrlStrm->cbCtrlStrmFunc(streamInfo.addr(), streamParam.addr(), cbCtrlStrm->cbCtrlStrmArg);
+	if (!res) cbCtrlStrm->cbCtrlStrmFunc(streamInfo, streamParam, cbCtrlStrm->cbCtrlStrmArg);
 
 	return res;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
index 271e1e837f..57372d5f3b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
@@ -122,7 +122,7 @@ struct CellPngDecStrmParam
 
 struct CellPngDecCbCtrlStrm
 {
-	mem_func_beptr_t<void(*)(mem_ptr_t<CellPngDecStrmInfo> strmInfo, mem_ptr_t<CellPngDecStrmParam> strmParam, u32 cbCtrlStrmArg)> cbCtrlStrmFunc;
+	vm::beptr<void(*)(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, u32 cbCtrlStrmArg)> cbCtrlStrmFunc;
 	be_t<u32> cbCtrlStrmArg;
 };
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSail.h b/rpcs3/Emu/SysCalls/Modules/cellSail.h
index 9361081976..55dc556dc3 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSail.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSail.h
@@ -110,28 +110,28 @@ typedef void(*CellSailMemAllocatorFuncFree)(u32 pArg, u32 boundary, u32 pMemory)
 
 typedef int(*CellSailSoundAdapterFuncMakeup)(u32 pArg);
 typedef int(*CellSailSoundAdapterFuncCleanup)(u32 pArg);
-typedef void(*CellSailSoundAdapterFuncFormatChanged)(u32 pArg, mem_ptr_t<CellSailAudioFormat> pFormat, u32 sessionId);
+typedef void(*CellSailSoundAdapterFuncFormatChanged)(u32 pArg, vm::ptr<CellSailAudioFormat> pFormat, u32 sessionId);
 
 typedef int(*CellSailGraphicsAdapterFuncMakeup)(u32 pArg);
 typedef int(*CellSailGraphicsAdapterFuncCleanup)(u32 pArg);
-typedef void(*CellSailGraphicsAdapterFuncFormatChanged)(u32 pArg, mem_ptr_t<CellSailVideoFormat> pFormat, u32 sessionId);
+typedef void(*CellSailGraphicsAdapterFuncFormatChanged)(u32 pArg, vm::ptr<CellSailVideoFormat> pFormat, u32 sessionId);
 typedef int(*CellSailGraphicsAdapterFuncAllocFrame)(u32 pArg, u32 size, s32 num, u8 ppFrame);
 typedef int(*CellSailGraphicsAdapterFuncFreeFrame)(u32 pArg, s32 num, u8 ppFrame);
 
 typedef int(*CellSailSourceFuncMakeup)(u32 pArg, s8 pProtocolNames);
 typedef int(*CellSailSourceFuncCleanup)(u32 pArg);
-typedef void(*CellSailSourceFuncOpen)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, mem_ptr_t<CellSailSourceStreamingProfile> pProfile);
+typedef void(*CellSailSourceFuncOpen)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, vm::ptr<CellSailSourceStreamingProfile> pProfile);
 typedef void(*CellSailSourceFuncClose)(u32 pArg);
-typedef void(*CellSailSourceFuncStart)(u32 pArg, mem_ptr_t<CellSailSourceStartCommand> pCommand, u32 sessionId);
+typedef void(*CellSailSourceFuncStart)(u32 pArg, vm::ptr<CellSailSourceStartCommand> pCommand, u32 sessionId);
 typedef void(*CellSailSourceFuncStop)(u32 pArg);
 typedef void(*CellSailSourceFuncCancel)(u32 pArg);
-typedef int(*CellSailSourceFuncCheckout)(u32 pArg, mem_ptr_t<CellSailSourceBufferItem> ppItem);
-typedef int(*CellSailSourceFuncCheckin)(u32 pArg, mem_ptr_t<CellSailSourceBufferItem> pItem);
+typedef int(*CellSailSourceFuncCheckout)(u32 pArg, vm::ptr<CellSailSourceBufferItem> ppItem);
+typedef int(*CellSailSourceFuncCheckin)(u32 pArg, vm::ptr<CellSailSourceBufferItem> pItem);
 typedef int(*CellSailSourceFuncClear)(u32 pArg);
 typedef int(*CellSailSourceFuncRead)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, u64 offset, u8 pBuf, u32 size, u64 pTotalSize);
 typedef int(*CellSailSourceFuncReadSync)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, u64 offset, u8 pBuf, u32 size, u64 pTotalSize);
 typedef int(*CellSailSourceFuncGetCapabilities)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, u64 pCapabilities);
-typedef int(*CellSailSourceFuncInquireCapability)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, mem_ptr_t<CellSailSourceStartCommand> pCommand);
+typedef int(*CellSailSourceFuncInquireCapability)(u32 pArg, s32 streamType, u32 pMediaInfo, s8 pUri, vm::ptr<CellSailSourceStartCommand> pCommand);
 typedef void(*CellSailSourceCheckFuncError)(u32 pArg, s8 pMsg, s32 line);
 
 typedef int(*CellSailFsFuncOpen)(s8 pPath, s32 flag, s32 pFd, u32 pArg, u64 size);
@@ -144,25 +144,25 @@ typedef int(*CellSailFsFuncCancel)(s32 fd);
 
 typedef int(*CellSailRendererAudioFuncMakeup)(u32 pArg);
 typedef int(*CellSailRendererAudioFuncCleanup)(u32 pArg);
-typedef void(*CellSailRendererAudioFuncOpen)(u32 pArg, mem_ptr_t<CellSailAudioFormat> pInfo, u32 frameNum);
+typedef void(*CellSailRendererAudioFuncOpen)(u32 pArg, vm::ptr<CellSailAudioFormat> pInfo, u32 frameNum);
 typedef void(*CellSailRendererAudioFuncClose)(u32 pArg);
 typedef void(*CellSailRendererAudioFuncStart)(u32 pArg, bool buffering);
 typedef void(*CellSailRendererAudioFuncStop)(u32 pArg, bool flush);
 typedef void(*CellSailRendererAudioFuncCancel)(u32 pArg);
-typedef int(*CellSailRendererAudioFuncCheckout)(u32 pArg, mem_ptr_t<CellSailAudioFrameInfo> ppInfo);
-typedef int(*CellSailRendererAudioFuncCheckin)(u32 pArg, mem_ptr_t<CellSailAudioFrameInfo> pInfo);
+typedef int(*CellSailRendererAudioFuncCheckout)(u32 pArg, vm::ptr<CellSailAudioFrameInfo> ppInfo);
+typedef int(*CellSailRendererAudioFuncCheckin)(u32 pArg, vm::ptr<CellSailAudioFrameInfo> pInfo);
 
 typedef int(*CellSailRendererVideoFuncMakeup)(u32 pArg);
 typedef int(*CellSailRendererVideoFuncCleanup)(u32 pArg);
-typedef void(*CellSailRendererVideoFuncOpen)(u32 pArg, mem_ptr_t<CellSailVideoFormat> pInfo, u32 frameNum, u32 minFrameNum);
+typedef void(*CellSailRendererVideoFuncOpen)(u32 pArg, vm::ptr<CellSailVideoFormat> pInfo, u32 frameNum, u32 minFrameNum);
 typedef void(*CellSailRendererVideoFuncClose)(u32 pArg);
 typedef void(*CellSailRendererVideoFuncStart)(u32 pArg, bool buffering);
 typedef void(*CellSailRendererVideoFuncStop)(u32 pArg, bool flush, bool keepRendering);
 typedef void(*CellSailRendererVideoFuncCancel)(u32 pArg);
-typedef int(*CellSailRendererVideoFuncCheckout)(u32 pArg, mem_ptr_t<CellSailVideoFrameInfo> ppInfo);
-typedef int(*CellSailRendererVideoFuncCheckin)(u32 pArg, mem_ptr_t<CellSailVideoFrameInfo> pInfo);
+typedef int(*CellSailRendererVideoFuncCheckout)(u32 pArg, vm::ptr<CellSailVideoFrameInfo> ppInfo);
+typedef int(*CellSailRendererVideoFuncCheckin)(u32 pArg, vm::ptr<CellSailVideoFrameInfo> pInfo);
 
-typedef void(*CellSailPlayerFuncNotified)(u32 pArg, mem_ptr_t<CellSailEvent> event, u64 arg0, u64 arg1);
+typedef void(*CellSailPlayerFuncNotified)(u32 pArg, vm::ptr<CellSailEvent> event, u64 arg0, u64 arg1);
 
 struct CellSailMemAllocatorFuncs
 {
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index 506152dfe0..8a606fadc0 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -9,7 +9,7 @@
 //Module cellSpurs(0x000a, cellSpurs_init);
 Module *cellSpurs = nullptr;
 
-#ifdef _WIN32
+#ifdef PRX_DEBUG
 extern u32 libsre;
 extern u32 libsre_rtoc;
 #endif
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
index 2f768a85a3..95c27a9a9e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpursJq.cpp
@@ -8,7 +8,7 @@
 
 Module* cellSpursJq = nullptr;
 
-#ifdef _WIN32
+#ifdef PRX_DEBUG
 #include "prx_libspurs_jq.h"
 u32 libspurs_jq;
 u32 libspurs_jq_rtoc;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
index 1daae5a56b..0ce8261e7e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync.cpp
@@ -11,7 +11,7 @@
 //Module cellSync("cellSync", cellSync_init);
 Module *cellSync = nullptr;
 
-#ifdef _WIN32
+#ifdef PRX_DEBUG
 #include "prx_libsre.h"
 u32 libsre;
 u32 libsre_rtoc;	
@@ -1471,12 +1471,12 @@ s32 syncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer,
 	assert(0);
 }
 
-s32 _cellSyncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal)
+s32 _cellSyncLFQueueCompletePushPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(*)(u32 addr, u32 arg)> fpSendSignal)
 {
 	cellSync->Todo("_cellSyncLFQueueCompletePushPointer(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x)",
-		queue.addr(), pointer, fpSendSignal.GetAddr());
+		queue.addr(), pointer, fpSendSignal.addr());
 
-	return syncLFQueueCompletePushPointer(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); });
+	return syncLFQueueCompletePushPointer(queue, pointer, fpSendSignal);
 }
 
 s32 syncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal)
@@ -1487,13 +1487,13 @@ s32 syncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer,
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal)
+s32 _cellSyncLFQueueCompletePushPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(*)(u32 addr, u32 arg)> fpSendSignal)
 {
 	// arguments copied from _cellSyncLFQueueCompletePushPointer
 	cellSync->Todo("_cellSyncLFQueueCompletePushPointer2(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x)",
-		queue.addr(), pointer, fpSendSignal.GetAddr());
+		queue.addr(), pointer, fpSendSignal.addr());
 
-	return syncLFQueueCompletePushPointer2(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); });
+	return syncLFQueueCompletePushPointer2(queue, pointer, fpSendSignal);
 }
 
 s32 _cellSyncLFQueuePushBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 isBlocking)
@@ -1864,13 +1864,13 @@ s32 syncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, c
 	assert(0);
 }
 
-s32 _cellSyncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
+s32 _cellSyncLFQueueCompletePopPointer(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// arguments copied from _cellSyncLFQueueCompletePushPointer + unknown argument (noQueueFull taken from LFQueue2CompletePopPointer)
 	cellSync->Todo("_cellSyncLFQueueCompletePopPointer(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x, noQueueFull=%d)",
-		queue.addr(), pointer, fpSendSignal.GetAddr(), noQueueFull);
+		queue.addr(), pointer, fpSendSignal.addr(), noQueueFull);
 
-	return syncLFQueueCompletePopPointer(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }, noQueueFull);
+	return syncLFQueueCompletePopPointer(queue, pointer, fpSendSignal, noQueueFull);
 }
 
 s32 syncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, const std::function<s32(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
@@ -1881,13 +1881,13 @@ s32 syncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer,
 	return CELL_OK;
 }
 
-s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, mem_func_ptr_t<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
+s32 _cellSyncLFQueueCompletePopPointer2(vm::ptr<CellSyncLFQueue> queue, s32 pointer, vm::ptr<s32(*)(u32 addr, u32 arg)> fpSendSignal, u32 noQueueFull)
 {
 	// arguments copied from _cellSyncLFQueueCompletePopPointer
 	cellSync->Todo("_cellSyncLFQueueCompletePopPointer2(queue_addr=0x%x, pointer=%d, fpSendSignal_addr=0x%x, noQueueFull=%d)",
-		queue.addr(), pointer, fpSendSignal.GetAddr(), noQueueFull);
+		queue.addr(), pointer, fpSendSignal.addr(), noQueueFull);
 
-	return syncLFQueueCompletePopPointer2(queue, pointer, [fpSendSignal](u32 addr, u32 arg){ return fpSendSignal(addr, arg); }, noQueueFull);
+	return syncLFQueueCompletePopPointer2(queue, pointer, fpSendSignal, noQueueFull);
 }
 
 s32 _cellSyncLFQueuePopBody(vm::ptr<CellSyncLFQueue> queue, u32 buffer_addr, u32 isBlocking)
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
index 3ac09b97f1..700617edb5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
@@ -9,7 +9,7 @@
 //Module cellSync2(0x0055, cellSync2_init);
 Module* cellSync2 = nullptr;
 
-#ifdef _WIN32
+#ifdef PRX_DEBUG
 #include "prx_libsync2.h"
 u32 libsync2;
 u32 libsync2_rtoc;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
index 8ad66a0c32..aa13463ecb 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
@@ -17,7 +17,7 @@
 #include "cellSysutil.h"
 #include "cellSysutil_SaveData.h"
 
-typedef void (*CellHddGameStatCallback)(mem_ptr_t<CellHddGameCBResult> cbResult, mem_ptr_t<CellHddGameStatGet> get, mem_ptr_t<CellHddGameStatSet> set);
+typedef void (*CellHddGameStatCallback)(vm::ptr<CellHddGameCBResult> cbResult, vm::ptr<CellHddGameStatGet> get, vm::ptr<CellHddGameStatSet> set);
 
 
 //void cellSysutil_init();
@@ -672,10 +672,10 @@ int cellSysCacheMount(mem_ptr_t<CellSysCacheParam> param)
 	return CELL_SYSCACHE_RET_OK_RELAYED;
 }
 
-int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, mem_func_ptr_t<CellHddGameStatCallback> funcStat, u32 container)
+int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
 {
 	cellSysutil->Warning("cellHddGameCheck(version=%d, dirName_addr=0x%xx, errDialog=%d, funcStat_addr=0x%x, container=%d)",
-		version, dirName_addr, errDialog, funcStat, container);
+		version, dirName_addr, errDialog, funcStat.addr(), container);
 
 	std::string dirName = Memory.ReadString(dirName_addr);
 	if (dirName.size() != 9)
@@ -730,7 +730,7 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, mem_func_ptr_
 
 	// TODO ?
 
-	funcStat(result.addr(), get.addr(), set.addr());
+	funcStat(result, get, set);
 	if (result->result != CELL_HDDGAME_CBRESULT_OK &&
 		result->result != CELL_HDDGAME_CBRESULT_OK_CANCEL)
 		return CELL_HDDGAME_ERROR_CBRESULT;
@@ -818,10 +818,10 @@ int cellWebBrowserEstimate2(const vm::ptr<const u8> _config, vm::ptr<be_t<u32>>
 }
 
 extern int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDialog,
-	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container);
+	vm::ptr<void(*)(vm::ptr<CellGameDataCBResult> cbResult, vm::ptr<CellGameDataStatGet> get, vm::ptr<CellGameDataStatSet> set)> funcStat, u32 container);
 
 extern int cellGameDataCheckCreate(u32 version, vm::ptr<const char> dirName, u32 errDialog,
-	mem_func_ptr_t<void(*)(mem_ptr_t<CellGameDataCBResult> cbResult, mem_ptr_t<CellGameDataStatGet> get, mem_ptr_t<CellGameDataStatSet> set)> funcStat, u32 container);
+	vm::ptr<void(*)(vm::ptr<CellGameDataCBResult> cbResult, vm::ptr<CellGameDataStatGet> get, vm::ptr<CellGameDataStatSet> set)> funcStat, u32 container);
 
 void cellSysutil_init()
 {
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index 8066857f18..6361e3d7b4 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -214,7 +214,7 @@ void getSaveDataStat(SaveDataEntry entry, mem_ptr_t<CellSaveDataStatGet> statGet
 		memcpy(&statGet->fileList[i], &fileEntries[i], sizeof(CellSaveDataFileStat));
 }
 
-s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_ptr_t<CellSaveDataCBResult> result, const std::string& saveDataDir)
+s32 modifySaveDataFiles(vm::ptr<CellSaveDataFileCallback> funcFile, vm::ptr<CellSaveDataCBResult> result, const std::string& saveDataDir)
 {
 	vm::var<CellSaveDataFileGet> fileGet;
 	vm::var<CellSaveDataFileSet> fileSet;
@@ -225,7 +225,7 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
 	fileGet->excSize = 0;
 	while (true)
 	{
-		funcFile(result.GetAddr(), fileGet.addr(), fileSet.addr());
+		funcFile(result, fileGet, fileSet);
 		if (result->result < 0)	{
 			cellSysutil->Error("modifySaveDataFiles: CellSaveDataFileCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 			return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -288,11 +288,11 @@ s32 modifySaveDataFiles(mem_func_ptr_t<CellSaveDataFileCallback>& funcFile, mem_
 
 // Functions
 int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						  mem_func_ptr_t<CellSaveDataListCallback> funcList, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						  vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcList.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, setList.GetAddr(), setBuf.GetAddr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -333,7 +333,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
 
-	funcList(result.addr(), listGet.addr(), listSet.addr());
+	funcList(result, listGet, listSet);
 
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListSave2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -354,7 +354,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -366,17 +366,17 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
 
 int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						  mem_func_ptr_t<CellSaveDataListCallback> funcList, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						  vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListLoad2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcList.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, setList.GetAddr(), setBuf.GetAddr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -418,7 +418,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
 
-	funcList(result.addr(), listGet.addr(), listSet.addr());
+	funcList(result, listGet, listSet);
 
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListLoad2: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -439,7 +439,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -451,17 +451,17 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
 
 int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						   mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						   vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						   u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataFixedSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcFixed_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -499,7 +499,7 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
-	funcFixed(result.addr(), listGet.addr(), fixedSet.addr());
+	funcFixed(result, listGet, fixedSet);
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -509,7 +509,7 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	// TODO: Display the Yes|No dialog here
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -520,17 +520,17 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
 
 int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						   mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						   vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						   u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataFixedLoad2(version=%d, setList_addr=0x%x, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -568,7 +568,7 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
-	funcFixed(result.addr(), listGet.addr(), fixedSet.addr());
+	funcFixed(result, listGet, fixedSet);
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -578,7 +578,7 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	// TODO: Display the Yes|No dialog here
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
@@ -589,17 +589,17 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return ret;
 }
 
 int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						  mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataAutoSave2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataStatGet> statGet;
@@ -630,7 +630,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 
 	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
 	result->userdata_addr = userdata_addr;
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
@@ -642,17 +642,17 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return CELL_SAVEDATA_RET_OK;
 }
 
 int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						  mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataAutoLoad2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataStatGet> statGet;
@@ -680,7 +680,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 
 	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
 	result->userdata_addr = userdata_addr;
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
@@ -692,20 +692,20 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed,
-							 mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
+int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListAutoSave(version=%d, errDialog=%d, setBuf=0x%x, funcFixed=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, errDialog, setList.GetAddr(), setBuf.GetAddr(), funcFixed.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+		version, errDialog, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
-	vm::var<CellSaveDataListSet> listSet;
+	vm::var<CellSaveDataFixedSet> fixedSet;
 	vm::var<CellSaveDataStatGet> statGet;
 	vm::var<CellSaveDataStatSet> statSet;
 
@@ -743,14 +743,15 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
 
-	funcFixed(result.addr(), listGet.addr(), listSet.addr());
+	throw fmt::Format("%s(): implementation broken", __FUNCTION__);
+	funcFixed(result, listGet, fixedSet);
 
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListAutoSave: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
+	/*setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
 	if (listSet->newData.GetAddr())
 		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
 	if (saveEntries.size() == 0) {
@@ -764,32 +765,32 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
 	result->userdata_addr = userdata_addr;
 
-	funcStat(result.addr(), statGet.addr(), statSet.addr());
+	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.GetAddr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListAutoSave: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
-	}
+	}*/
 
 	/*if (statSet->setParam.GetAddr())
 	addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); // TODO: This *is* wrong
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed,
-							 mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
+int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListAutoLoad(version=%d, errDialog=%d, setBuf=0x%x, funcFixed=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-					  version, errDialog, setList.GetAddr(), setBuf.GetAddr(), funcFixed.GetAddr(), funcStat.GetAddr(), funcFile.GetAddr(), container, userdata_addr);
+					  version, errDialog, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
-	vm::var<CellSaveDataListSet> listSet;
+	vm::var<CellSaveDataFixedSet> fixedSet;
 	vm::var<CellSaveDataStatGet> statGet;
 	vm::var<CellSaveDataStatSet> statSet;
 
@@ -827,14 +828,15 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 	}
 
-	funcFixed(result.addr(), listGet.addr(), listSet.addr());
+	throw fmt::Format("%s(): implementation broken", __FUNCTION__);
+	funcFixed(result, listGet, fixedSet);
 
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListAutoLoad: CellSaveDataListCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
+	/*setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
 	if (listSet->newData.GetAddr())
 		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
 	if (saveEntries.size() == 0) {
@@ -854,14 +856,14 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListAutoLoad: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
-	}
+	}*/
 
 	/*if (statSet->setParam.GetAddr())
 	// TODO: Write PARAM.SFO file
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
-	s32 ret = modifySaveDataFiles(funcFile, result.addr(), saveBaseDir + (char*)statGet->dir.dirName);
+	s32 ret = modifySaveDataFiles(funcFile, result, saveBaseDir + (char*)statGet->dir.dirName);
 
 	return CELL_SAVEDATA_RET_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
index 6dc680cf92..6ec2ea1605 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
@@ -247,11 +247,11 @@ struct CellSaveDataDoneGet
 
 
 // Callback Functions
-typedef void (*CellSaveDataFixedCallback)(mem_ptr_t<CellSaveDataCBResult> cbResult, mem_ptr_t<CellSaveDataListGet> get, mem_ptr_t<CellSaveDataFixedSet> set);
-typedef void (*CellSaveDataListCallback) (mem_ptr_t<CellSaveDataCBResult> cbResult, mem_ptr_t<CellSaveDataListGet> get, mem_ptr_t<CellSaveDataListSet> set);
-typedef void (*CellSaveDataStatCallback) (mem_ptr_t<CellSaveDataCBResult> cbResult, mem_ptr_t<CellSaveDataStatGet> get, mem_ptr_t<CellSaveDataStatSet> set);
-typedef void (*CellSaveDataFileCallback) (mem_ptr_t<CellSaveDataCBResult> cbResult, mem_ptr_t<CellSaveDataFileGet> get, mem_ptr_t<CellSaveDataFileSet> set);
-typedef void (*CellSaveDataDoneCallback) (mem_ptr_t<CellSaveDataCBResult> cbResult, mem_ptr_t<CellSaveDataDoneGet> get);
+typedef void(*CellSaveDataFixedCallback)(vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataListGet> get, vm::ptr<CellSaveDataFixedSet> set);
+typedef void(*CellSaveDataListCallback) (vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataListGet> get, vm::ptr<CellSaveDataListSet> set);
+typedef void(*CellSaveDataStatCallback) (vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataStatGet> get, vm::ptr<CellSaveDataStatSet> set);
+typedef void(*CellSaveDataFileCallback) (vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataFileGet> get, vm::ptr<CellSaveDataFileSet> set);
+typedef void(*CellSaveDataDoneCallback) (vm::ptr<CellSaveDataCBResult> cbResult, vm::ptr<CellSaveDataDoneGet> get);
 
 
 // Auxiliary Structs
@@ -274,31 +274,31 @@ struct SaveDataEntry
 
 // Function declarations
 int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-                          mem_func_ptr_t<CellSaveDataListCallback> funcList, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+                          vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
 int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-                          mem_func_ptr_t<CellSaveDataListCallback> funcList, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+                          vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
 int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-                          mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+                          vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
 int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-                          mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed, mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+                          vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
 int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						  mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr);
 
 int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
-						  mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile,
+						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr);
 
-int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed,
-							 mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
+int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
 
-int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, mem_func_ptr_t<CellSaveDataFixedCallback> funcFixed,
-							 mem_func_ptr_t<CellSaveDataStatCallback> funcStat, mem_func_ptr_t<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
\ No newline at end of file
+int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.h b/rpcs3/Emu/SysCalls/Modules/cellVdec.h
index 10fb65a16e..e36b792526 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVdec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.h
@@ -167,7 +167,7 @@ struct CellVdecPicFormat
 	u8 alpha;
 };
 
-typedef mem_func_ptr_t<void (*)(u32 handle_addr, CellVdecMsgType msgType, int msgData, u32 cbArg_addr)> CellVdecCbMsg;
+typedef void(*CellVdecCbMsg)(u32 handle_addr, CellVdecMsgType msgType, int msgData, u32 cbArg_addr);
 
 // Callback Function Information
 struct CellVdecCb
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
index 9b7b6b1bb0..3969646ff9 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
@@ -136,10 +136,10 @@ int sceNpTrophyCreateHandle(vm::ptr<be_t<u32>> handle)
 	return CELL_OK;
 }
 
-int sceNpTrophyRegisterContext(u32 context, u32 handle, mem_func_ptr_t<SceNpTrophyStatusCallback> statusCb, u32 arg_addr, u64 options)
+int sceNpTrophyRegisterContext(u32 context, u32 handle, vm::ptr<SceNpTrophyStatusCallback> statusCb, u32 arg_addr, u64 options)
 {
 	sceNpTrophy->Warning("sceNpTrophyRegisterContext(context=%d, handle=%d, statusCb_addr=0x%x, arg_addr=0x%x, options=0x%llx)",
-		context, handle, statusCb.GetAddr(), arg_addr, options);
+		context, handle, statusCb.addr(), arg_addr, options);
 
 	if (!(s_npTrophyInstance.m_bInitialized))
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
index fb0fd704b5..298538f481 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_fs.cpp
@@ -150,7 +150,7 @@ std::atomic<u32> g_FsAioReadID( 0 );
 std::atomic<u32> g_FsAioReadCur( 0 );
 bool aio_init = false;
 
-void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
+void fsAioRead(u32 fd, vm::ptr<CellFsAio> aio, int xid, vm::ptr<void (*)(vm::ptr<CellFsAio> xaio, int error, int xid, u64 size)> func)
 {
 	while (g_FsAioReadCur != xid)
 	{
@@ -199,9 +199,9 @@ void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*
 	g_FsAioReadCur++;
 }
 
-int cellFsAioRead(mem_ptr_t<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, mem_func_ptr_t<void(*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
+int cellFsAioRead(vm::ptr<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, vm::ptr<void(*)(vm::ptr<CellFsAio> xaio, int error, int xid, u64 size)> func)
 {
-	sys_fs->Warning("cellFsAioRead(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.addr(), func.GetAddr());
+	sys_fs->Warning("cellFsAioRead(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.addr(), aio_id.addr(), func.addr());
 
 	if (!aio_init)
 	{
@@ -228,9 +228,9 @@ int cellFsAioRead(mem_ptr_t<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, mem_func_
 	return CELL_OK;
 }
 
-int cellFsAioWrite(mem_ptr_t<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, mem_func_ptr_t<void(*)(mem_ptr_t<CellFsAio> xaio, int error, int xid, u64 size)> func)
+int cellFsAioWrite(vm::ptr<CellFsAio> aio, vm::ptr<be_t<u32>> aio_id, vm::ptr<void(*)(vm::ptr<CellFsAio> xaio, int error, int xid, u64 size)> func)
 {
-	sys_fs->Todo("cellFsAioWrite(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.addr(), func.GetAddr());
+	sys_fs->Todo("cellFsAioWrite(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.addr(), aio_id.addr(), func.addr());
 
 	// TODO:
 
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
index 0f58bfe074..77470ce7f4 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
@@ -681,9 +681,9 @@ s32 cellFsStReadWait(u32 fd, u64 size)
 	return CELL_OK;
 }
 
-s32 cellFsStReadWaitCallback(u32 fd, u64 size, mem_func_ptr_t<void (*)(int xfd, u64 xsize)> func)
+s32 cellFsStReadWaitCallback(u32 fd, u64 size, vm::ptr<void (*)(int xfd, u64 xsize)> func)
 {
-	sys_fs->Todo("cellFsStReadWaitCallback(fd=%d, size = 0x%llx, func_addr = 0x%x)", fd, size, func.GetAddr());
+	sys_fs->Todo("cellFsStReadWaitCallback(fd=%d, size = 0x%llx, func_addr = 0x%x)", fd, size, func.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
index 132a501fc4..df017a78d3 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
@@ -157,4 +157,4 @@ s32 cellFsStRead(u32 fd, u32 buf_addr, u64 size, vm::ptr<be_t<u64>> rsize);
 s32 cellFsStReadGetCurrentAddr(u32 fd, vm::ptr<be_t<u32>> addr_addr, vm::ptr<be_t<u64>> size);
 s32 cellFsStReadPutCurrentAddr(u32 fd, u32 addr_addr, u64 size);
 s32 cellFsStReadWait(u32 fd, u64 size);
-s32 cellFsStReadWaitCallback(u32 fd, u64 size, mem_func_ptr_t<void (*)(int xfd, u64 xsize)> func);
+s32 cellFsStReadWaitCallback(u32 fd, u64 size, vm::ptr<void (*)(int xfd, u64 xsize)> func);

From 774b5be7d7df2288ae407ecbbff0206395a85c88 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 20:16:44 +0400
Subject: [PATCH 22/36] Patch from DH applied

---
 Utilities/BEType.h                      |  75 +++++++++++-
 rpcs3/Emu/Memory/vm_ptr.h               | 145 ++++++++++++++----------
 rpcs3/Emu/Memory/vm_ref.h               |  48 ++++++--
 rpcs3/Emu/Memory/vm_var.h               |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.h |   2 +-
 rpcs3/Emu/SysCalls/Modules/libmixer.cpp |   2 +-
 7 files changed, 203 insertions(+), 75 deletions(-)

diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index 0915a0b739..fe7988823e 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -47,10 +47,10 @@ template<typename T, s64 _value> struct const_se_t<T, _value, 8>
 		((_value << 56) & 0xff00000000000000);
 };
 
-template<typename T, int size=sizeof(T)>
+template<typename T, typename T2 = T>
 class be_t
 {
-	static_assert(size == 1 || size == 2 || size == 4 || size == 8, "Bad be_t type");
+	static_assert(sizeof(T2) == 1 || sizeof(T2) == 2 || sizeof(T2) == 4 || sizeof(T2) == 8, "Bad be_t type");
 	T m_data;
 
 public:
@@ -65,7 +65,7 @@ public:
 	{
 		T res;
 
-		se_t<T>::func(res, m_data);
+		se_t<T, sizeof(T2)>::func(res, m_data);
 
 		return res;
 	}
@@ -77,7 +77,7 @@ public:
 
 	void FromLE(const T& value)
 	{
-		se_t<T>::func(m_data, value);
+		se_t<T, sizeof(T2)>::func(m_data, value);
 	}
 
 	static be_t MakeFromLE(const T value)
@@ -125,7 +125,7 @@ public:
 		return *this;
 	}
 
-	be_t<T,size>& operator = (const be_t<T,size>& right) = default;
+	be_t& operator = (const be_t& right) = default;
 
 	template<typename T1> be_t& operator += (T1 right) { return *this = T(*this) + right; }
 	template<typename T1> be_t& operator -= (T1 right) { return *this = T(*this) - right; }
@@ -171,6 +171,71 @@ public:
 	be_t& operator-- () { *this -= 1; return *this; }
 };
 
+template<typename T, typename T2 = T>
+struct is_be_t : public std::integral_constant<bool, false> {};
+
+template<typename T, typename T2>
+struct is_be_t<be_t<T, T2>, T2> : public std::integral_constant<bool, true>
+{
+};
+
+template<typename T>
+struct remove_be_t
+{
+	typedef T type;
+};
+
+template<typename T, typename T2>
+struct remove_be_t<be_t<T, T2>>
+{
+	typedef T type;
+};
+
+template<typename T, typename T2 = T>
+class to_be_t
+{
+	template<typename T, typename T2, bool is_need_swap>
+	struct _be_type_selector
+	{
+		typedef typename T type;
+	};
+
+	template<typename T, typename T2>
+	struct _be_type_selector<T, T2, true>
+	{
+		typedef typename be_t<T, T2> type;
+	};
+
+public:
+	//true if need swap endianes for be
+	static const bool value = (sizeof(T2) > 1) && std::is_arithmetic<T>::value;
+
+	//be_t<T, size> if need swap endianes, T otherwise
+	typedef typename _be_type_selector< T, T2, value >::type type;
+};
+
+template<typename T>
+class to_be_t<T, void>
+{
+public:
+	//true if need swap endianes for be
+	static const bool value = false;
+
+	//be_t<T, size> if need swap endianes, T otherwise
+	typedef void type;
+};
+
+template<typename T>
+class to_be_t<T, const void>
+{
+public:
+	//true if need swap endianes for be
+	static const bool value = false;
+
+	//be_t<T, size> if need swap endianes, T otherwise
+	typedef void type;
+};
+
 template<typename T, typename T1, T1 value> struct _se : public const_se_t<T, value> {};
 template<typename T, typename T1, T1 value> struct _se<be_t<T>, T1, value> : public const_se_t<T, value> {};
 
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 88cab76b3c..50a2cc9780 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -3,77 +3,79 @@
 namespace vm
 {
 	template<typename T, int lvl = 1, typename AT = u32>
-	class ptr
+	class _ptr_base
 	{
 		AT m_addr;
 
 	public:
-		ptr operator++ (int)
+		typedef T type;
+
+		_ptr_base operator++ (int)
 		{
 			AT result = m_addr;
 			m_addr += sizeof(AT);
-			return { result };
+			return make(result);
 		}
 
-		ptr& operator++ ()
+		_ptr_base& operator++ ()
 		{
 			m_addr += sizeof(AT);
 			return *this;
 		}
 
-		ptr operator-- (int)
+		_ptr_base operator-- (int)
 		{
 			AT result = m_addr;
 			m_addr -= sizeof(AT);
-			return { result };
+			return make(result);
 		}
 
-		ptr& operator-- ()
+		_ptr_base& operator-- ()
 		{
 			m_addr -= sizeof(AT);
 			return *this;
 		}
 
-		ptr& operator += (int count)
+		_ptr_base& operator += (int count)
 		{
 			m_addr += count * sizeof(AT);
 			return *this;
 		}
 
-		ptr& operator -= (int count)
+		_ptr_base& operator -= (int count)
 		{
 			m_addr -= count * sizeof(AT);
 			return *this;
 		}
 
-		ptr operator + (int count) const
+		_ptr_base operator + (int count) const
 		{
-			return { m_addr + count * sizeof(AT) };
+			return make(m_addr + count * sizeof(AT));
 		}
 
-		ptr operator - (int count) const
+		_ptr_base operator - (int count) const
 		{
-			return { m_addr - count * sizeof(AT) };
+			return make(m_addr - count * sizeof(AT));
 		}
 
-		__forceinline ptr<T, lvl - 1, AT>& operator *()
+		__forceinline _ptr_base<T, lvl - 1, AT>& operator *()
 		{
-			return get_ref<ptr<T, lvl - 1, AT>>(m_addr);
+			return vm::get_ref<_ptr_base<T, lvl - 1, AT>>(m_addr);
 		}
 
-		__forceinline const ptr<T, lvl - 1, AT>& operator *() const
+		__forceinline const _ptr_base<T, lvl - 1, AT>& operator *() const
 		{
-			return get_ref<const ptr<T, lvl - 1, AT>>(m_addr);
+			return vm::get_ref<const _ptr_base<T, lvl - 1, AT>>(m_addr);
 		}
 
-		__forceinline ptr<T, lvl - 1, AT>& operator [](int index)
+		__forceinline _ptr_base<T, lvl - 1, AT>& operator [](int index)
 		{
-			return get_ref<ptr<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
+			return vm::get_ref<_ptr_base<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
 		}
 
-		__forceinline const ptr<T, lvl - 1, AT>& operator [](int index) const
+		__forceinline const _ptr_base<T, lvl - 1, AT>& operator [](int index) const
 		{
-			return get_ref<const ptr<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
+			return vm::get_ref<const _ptr_base<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
 		}
 
 		operator bool() const
@@ -86,14 +88,14 @@ namespace vm
 			return m_addr;
 		}
 
-		static ptr make(AT addr)
+		static _ptr_base make(AT addr)
 		{
-			return (ptr&)addr;
+			return (_ptr_base&)addr;
 		}
 	};
 	
 	template<typename T, typename AT>
-	class ptr<T, 1, AT>
+	class _ptr_base<T, 1, AT>
 	{
 		AT m_addr;
 		
@@ -108,52 +110,52 @@ namespace vm
 			return vm::get_ptr<const T>(m_addr);
 		}
 
-		ptr operator++ (int)
+		_ptr_base operator++ (int)
 		{
 			AT result = m_addr;
 			m_addr += sizeof(T);
-			return { result };
+			return make(result);
 		}
 
-		ptr& operator++ ()
+		_ptr_base& operator++ ()
 		{
 			m_addr += sizeof(T);
 			return *this;
 		}
 
-		ptr operator-- (int)
+		_ptr_base operator-- (int)
 		{
 			AT result = m_addr;
 			m_addr -= sizeof(T);
-			return { result };
+			return make(result);
 		}
 
-		ptr& operator-- ()
+		_ptr_base& operator-- ()
 		{
 			m_addr -= sizeof(T);
 			return *this;
 		}
 
-		ptr& operator += (int count)
+		_ptr_base& operator += (int count)
 		{
 			m_addr += count * sizeof(T);
 			return *this;
 		}
 
-		ptr& operator -= (int count)
+		_ptr_base& operator -= (int count)
 		{
 			m_addr -= count * sizeof(T);
 			return *this;
 		}
 
-		ptr operator + (int count) const
+		_ptr_base operator + (int count) const
 		{
-			return { m_addr + count * sizeof(T) };
+			return make(m_addr + count * sizeof(T));
 		}
 
-		ptr operator - (int count) const
+		_ptr_base operator - (int count) const
 		{
-			return { m_addr - count * sizeof(T) };
+			return make(m_addr - count * sizeof(T));
 		}
 
 		__forceinline T& operator *()
@@ -177,14 +179,14 @@ namespace vm
 		}
 		
 		/*
-		operator ref<T>()
+		operator _ref_base<T, AT>()
 		{
-			return { m_addr };
+			return _ref_base<T, AT>::make(m_addr);
 		}
 		
-		operator const ref<T>() const
+		operator const _ref_base<T, AT>() const
 		{
-			return { m_addr };
+			return _ref_base<T, AT>::make(m_addr);
 		}
 		*/
 		
@@ -203,14 +205,14 @@ namespace vm
 			return vm::get_ptr<T>(m_addr);
 		}
 		
-		static ptr make(AT addr)
+		static _ptr_base make(AT addr)
 		{
-			return (ptr&)addr;
+			return (_ptr_base&)addr;
 		}
 	};
 
 	template<typename AT>
-	class ptr<void, 1, AT>
+	class _ptr_base<void, 1, AT>
 	{
 		AT m_addr;
 		
@@ -230,14 +232,14 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(AT addr)
+		static _ptr_base make(AT addr)
 		{
-			return (ptr&)addr;
+			return (_ptr_base&)addr;
 		}
 	};
 
 	template<typename AT>
-	class ptr<const void, 1, AT>
+	class _ptr_base<const void, 1, AT>
 	{
 		AT m_addr;
 
@@ -257,14 +259,14 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(AT addr)
+		static _ptr_base make(AT addr)
 		{
-			return (ptr&)addr;
+			return (_ptr_base&)addr;
 		}
 	};
 	
 	template<typename RT, typename AT>
-	class ptr<RT(*)(), 1, AT>
+	class _ptr_base<RT(*)(), 1, AT>
 	{
 		AT m_addr;
 
@@ -298,9 +300,9 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(AT addr)
+		static _ptr_base make(AT addr)
 		{
-			return (ptr&)addr;
+			return (_ptr_base&)addr;
 		}
 
 		operator std::function<RT()>() const
@@ -311,7 +313,7 @@ namespace vm
 	};
 
 	template<typename AT, typename RT, typename ...T>
-	class ptr<RT(*)(T...), 1, AT>
+	class _ptr_base<RT(*)(T...), 1, AT>
 	{
 		AT m_addr;
 
@@ -325,9 +327,9 @@ namespace vm
 		};
 
 		template<typename TT, typename ATT>
-		struct _func_arg<ptr<TT, 1, ATT>>
+		struct _func_arg<_ptr_base<TT, 1, ATT>>
 		{
-			__forceinline static u64 get_value(const ptr<TT, 1, ATT> arg)
+			__forceinline static u64 get_value(const _ptr_base<TT, 1, ATT> arg)
 			{
 				return arg.addr();
 			}
@@ -384,9 +386,9 @@ namespace vm
 			return m_addr != 0;
 		}
 
-		static ptr make(AT addr)
+		static _ptr_base make(AT addr)
 		{
-			return (ptr&)addr;
+			return (_ptr_base&)addr;
 		}
 
 		operator std::function<RT(T...)>() const
@@ -396,6 +398,33 @@ namespace vm
 		}
 	};
 
-	template<typename T, int lvl = 1, typename AT = u32>
-	class beptr : public ptr<T, lvl, be_t<AT>> {};
+	//BE pointer to LE data
+	template<typename T, int lvl = 1, typename AT = u32> class bptrl : public _ptr_base<T, lvl, typename to_be_t<AT>::type> {};
+	//BE pointer to BE data
+	template<typename T, int lvl = 1, typename AT = u32> class bptrb : public _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type> {};
+	//LE pointer to BE data
+	template<typename T, int lvl = 1, typename AT = u32> class lptrb : public _ptr_base<typename to_be_t<T>::type, lvl, AT> {};
+	//LE pointer to LE data
+	template<typename T, int lvl = 1, typename AT = u32> class lptrl : public _ptr_base<T, lvl, AT> {};
+	namespace ps3
+	{
+		//default pointer for HLE functions (LE ptrerence to BE data)
+		template<typename T, int lvl = 1, typename AT = u32> class ptr : public lptrb<T, lvl, AT>
+		{
+		public:
+			static ptr make(AT addr)
+			{
+				return (ptr&)addr;
+			}
+		};
+		//default pointer for HLE structures (BE ptrerence to BE data)
+		template<typename T, int lvl = 1, typename AT = u32> class bptr : public bptrb<T, lvl, AT> {};
+	}
+	namespace psv
+	{
+		//default pointer for HLE functions & structures (LE ptrerence to LE data)
+		template<typename T, int lvl = 1, typename AT = u32> class ptr : public lptrl<T, lvl, AT> {};
+	}
+	//PS3 emulation is main now, so lets it be as default
+	using namespace ps3;
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 666b059ba7..2e47d29c16 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -5,9 +5,12 @@ namespace vm
 	template<typename T, typename AT = u32>
 	class _ref_base
 	{
+	protected:
 		AT m_addr;
 
 	public:
+		typedef T type;
+
 		operator T&()
 		{
 			return get_ref<T>(m_addr);
@@ -30,29 +33,60 @@ namespace vm
 	};
 
 	//BE reference to LE data
-	template<typename T, typename AT = u32> class brefl : public _ref_base<T, be_t<AT>> {};
+	template<typename T, typename AT = u32> struct brefl : public _ref_base<T, typename to_be_t<AT>::type>
+	{
+		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+	};
 
 	//BE reference to BE data
-	template<typename T, typename AT = u32> class brefb : public _ref_base<be_t<T>, be_t<AT>> {};
+	template<typename T, typename AT = u32> struct brefb : public _ref_base<typename to_be_t<T>::type, typename to_be_t<AT>::type>
+	{
+		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+	};
 
 	//LE reference to BE data
-	template<typename T, typename AT = u32> class lrefb : public _ref_base<be_t<T>, AT> {};
+	template<typename T, typename AT = u32> struct lrefb : public _ref_base<typename to_be_t<T>::type, AT>
+	{
+		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+	};
 
 	//LE reference to LE data
-	template<typename T, typename AT = u32> class lrefl : public _ref_base<T, AT> {};
+	template<typename T, typename AT = u32> struct lrefl : public _ref_base<T, AT>
+	{
+		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+	};
 
 	namespace ps3
 	{
 		//default reference for HLE functions (LE reference to BE data)
-		template<typename T, typename AT = u32> class ref : public lrefb<T, AT> {};
+		template<typename T, typename AT = u32> struct ref : public lrefb<T, AT>
+		{
+			_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+			const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		};
 
 		//default reference for HLE structures (BE reference to BE data)
-		template<typename T, typename AT = u32> class bref : public brefb<T, AT> {};
+		template<typename T, typename AT = u32> struct bref : public brefb<T, AT>
+		{
+			_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+			const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		};
 	}
 
 	namespace psv
 	{
 		//default reference for HLE functions & structures (LE reference to LE data)
-		template<typename T, typename AT = u32> class ref : public lrefl<T, AT> {};
+		template<typename T, typename AT = u32> struct ref : public lrefl<T, AT>
+		{
+			_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
+			const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		};
 	}
+
+	//PS3 emulation is main now, so lets it be as default
+	using namespace ps3;
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/Memory/vm_var.h b/rpcs3/Emu/Memory/vm_var.h
index bb48bf5096..f878de752b 100644
--- a/rpcs3/Emu/Memory/vm_var.h
+++ b/rpcs3/Emu/Memory/vm_var.h
@@ -106,9 +106,9 @@ namespace vm
 		}
 		*/
 
-		template<typename AT> operator ptr<T, 1, AT>() const
+		template<typename AT> operator ps3::ptr<T, 1, AT>() const
 		{
-			return ptr<T, 1, AT>::make(m_addr);
+			return ps3::ptr<T, 1, AT>::make(m_addr);
 		}
 		
 		operator T&()
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index 536122f30c..db75833d76 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -18,7 +18,7 @@
 //Module cellL10n(0x001e, cellL10n_init);
 Module *cellL10n = nullptr;
 
-int UTF16stoUTF8s(vm::ptr<const char16_t> utf16, vm::ptr<be_t<u32>> utf16_len, vm::ptr<char> utf8, vm::ptr<be_t<u32>> utf8_len)
+int UTF16stoUTF8s(vm::lptrl<const char16_t> utf16, vm::ptr<be_t<u32>> utf16_len, vm::ptr<char> utf8, vm::ptr<be_t<u32>> utf8_len)
 {
 	cellL10n->Warning("UTF16stoUTF8s(utf16_addr=0x%x, utf16_len_addr=0x%x, utf8_addr=0x%x, utf8_len_addr=0x%x)",
 		utf16.addr(), utf16_len.addr(), utf8.addr(), utf8_len.addr());
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
index 57372d5f3b..cdbaeb97ca 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.h
@@ -122,7 +122,7 @@ struct CellPngDecStrmParam
 
 struct CellPngDecCbCtrlStrm
 {
-	vm::beptr<void(*)(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, u32 cbCtrlStrmArg)> cbCtrlStrmFunc;
+	vm::bptr<void(*)(vm::ptr<CellPngDecStrmInfo> strmInfo, vm::ptr<CellPngDecStrmParam> strmParam, u32 cbCtrlStrmArg)> cbCtrlStrmFunc;
 	be_t<u32> cbCtrlStrmArg;
 };
 
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index 48044586e9..7fd2644af7 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -361,7 +361,7 @@ int cellSurMixerCreate(const mem_ptr_t<CellSurMixerConfig> config)
 
 					for (auto& p : ssp) if (p.m_active && p.m_created)
 					{
-						auto v = vm::ptr<s16>::make(p.m_addr); // 16-bit LE audio data
+						auto v = vm::lptrl<s16>::make(p.m_addr); // 16-bit LE audio data
 						float left = 0.0f;
 						float right = 0.0f;
 						float speed = fabs(p.m_speed);

From 3b764d45f2e3cc3058ab65329f11b215174d4e05 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 20:45:22 +0400
Subject: [PATCH 23/36] Compilation fix

---
 Utilities/BEType.h | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index fe7988823e..f8375351b8 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -194,16 +194,16 @@ struct remove_be_t<be_t<T, T2>>
 template<typename T, typename T2 = T>
 class to_be_t
 {
-	template<typename T, typename T2, bool is_need_swap>
+	template<typename TT, typename TT2, bool is_need_swap>
 	struct _be_type_selector
 	{
-		typedef typename T type;
+		typedef typename TT type;
 	};
 
-	template<typename T, typename T2>
-	struct _be_type_selector<T, T2, true>
+	template<typename TT, typename TT2>
+	struct _be_type_selector<TT, TT2, true>
 	{
-		typedef typename be_t<T, T2> type;
+		typedef typename be_t<TT, TT2> type;
 	};
 
 public:

From 09022b1000dd8b399cdd6d8de33417fd505ddd62 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 21:38:55 +0400
Subject: [PATCH 24/36] Compilation fix 2 + callback fix

---
 Utilities/BEType.h        |  4 ++--
 rpcs3/Emu/Memory/vm_ptr.h | 20 +++++++++++++++++---
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index f8375351b8..d2dc61b663 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -197,13 +197,13 @@ class to_be_t
 	template<typename TT, typename TT2, bool is_need_swap>
 	struct _be_type_selector
 	{
-		typedef typename TT type;
+		typedef TT type;
 	};
 
 	template<typename TT, typename TT2>
 	struct _be_type_selector<TT, TT2, true>
 	{
-		typedef typename be_t<TT, TT2> type;
+		typedef be_t<TT, TT2> type;
 	};
 
 public:
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 50a2cc9780..c7dd6d2c0e 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -312,6 +312,11 @@ namespace vm
 		}
 	};
 
+	namespace ps3
+	{
+		template<typename T, int lvl, typename AT> class ptr;
+	}
+
 	template<typename AT, typename RT, typename ...T>
 	class _ptr_base<RT(*)(T...), 1, AT>
 	{
@@ -329,7 +334,16 @@ namespace vm
 		template<typename TT, typename ATT>
 		struct _func_arg<_ptr_base<TT, 1, ATT>>
 		{
-			__forceinline static u64 get_value(const _ptr_base<TT, 1, ATT> arg)
+			__forceinline static u64 get_value(const _ptr_base<TT, 1, ATT>& arg)
+			{
+				return arg.addr();
+			}
+		};
+
+		template<typename TT, typename ATT>
+		struct _func_arg<ps3::ptr<TT, 1, ATT>>
+		{
+			__forceinline static u64 get_value(const ps3::ptr<TT, 1, ATT>& arg)
 			{
 				return arg.addr();
 			}
@@ -338,7 +352,7 @@ namespace vm
 		template<typename TT, typename ATT>
 		struct _func_arg<_ref_base<TT, ATT>>
 		{
-			__forceinline static u64 get_value(const _ref_base<TT, ATT> arg)
+			__forceinline static u64 get_value(const _ref_base<TT, ATT>& arg)
 			{
 				return arg.addr();
 			}
@@ -349,7 +363,7 @@ namespace vm
 		{
 			static_assert(!i, "Invalid callback argument type (mem_ptr_t), use vm::ptr");
 			
-			__forceinline static u64 get_value(const mem_ptr_t<TT, i, ATT> arg)
+			__forceinline static u64 get_value(const mem_ptr_t<TT, i, ATT>& arg)
 			{
 				return 0;
 			}

From 4f6a4073931992a4c8cf3b032fe86afce71f470a Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Mon, 1 Sep 2014 22:29:51 +0400
Subject: [PATCH 25/36] Compilation fix 3

---
 rpcs3/Emu/Memory/vm_ref.h | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 2e47d29c16..539c7c0115 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -35,29 +35,29 @@ namespace vm
 	//BE reference to LE data
 	template<typename T, typename AT = u32> struct brefl : public _ref_base<T, typename to_be_t<AT>::type>
 	{
-		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		brefl& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+		const brefl& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 	};
 
 	//BE reference to BE data
 	template<typename T, typename AT = u32> struct brefb : public _ref_base<typename to_be_t<T>::type, typename to_be_t<AT>::type>
 	{
-		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		brefb& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+		const brefb& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 	};
 
 	//LE reference to BE data
 	template<typename T, typename AT = u32> struct lrefb : public _ref_base<typename to_be_t<T>::type, AT>
 	{
-		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		lrefb& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+		const lrefb& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 	};
 
 	//LE reference to LE data
 	template<typename T, typename AT = u32> struct lrefl : public _ref_base<T, AT>
 	{
-		_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-		const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+		lrefl& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+		const lrefl& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 	};
 
 	namespace ps3
@@ -65,15 +65,15 @@ namespace vm
 		//default reference for HLE functions (LE reference to BE data)
 		template<typename T, typename AT = u32> struct ref : public lrefb<T, AT>
 		{
-			_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-			const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+			ref& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+			const ref& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 		};
 
 		//default reference for HLE structures (BE reference to BE data)
 		template<typename T, typename AT = u32> struct bref : public brefb<T, AT>
 		{
-			_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-			const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+			bref& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+			const bref& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 		};
 	}
 
@@ -82,8 +82,8 @@ namespace vm
 		//default reference for HLE functions & structures (LE reference to LE data)
 		template<typename T, typename AT = u32> struct ref : public lrefl<T, AT>
 		{
-			_ref_base& operator = (typename T right) { get_ref<T>(m_addr) = right; return *this; }
-			const _ref_base& operator = (typename T right) const { get_ref<T>(m_addr) = right; return *this; }
+			ref& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
+			const ref& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
 		};
 	}
 

From 73555c1df178e2d4ec1e49e46e712e4528efd5ac Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 01:22:07 +0400
Subject: [PATCH 26/36] Compilation fix 4

---
 Utilities/BEType.h        |  6 ++---
 rpcs3/Emu/Memory/vm_ref.h | 47 +++++++++++++++++++++++++++------------
 2 files changed, 35 insertions(+), 18 deletions(-)

diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index d2dc61b663..e8a072851d 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -175,11 +175,9 @@ template<typename T, typename T2 = T>
 struct is_be_t : public std::integral_constant<bool, false> {};
 
 template<typename T, typename T2>
-struct is_be_t<be_t<T, T2>, T2> : public std::integral_constant<bool, true>
-{
-};
+struct is_be_t<be_t<T, T2>, T2> : public std::integral_constant<bool, true> {};
 
-template<typename T>
+template<typename T, typename T2 = T>
 struct remove_be_t
 {
 	typedef T type;
diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 539c7c0115..ad238223e7 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -10,6 +10,8 @@ namespace vm
 
 	public:
 		typedef T type;
+		typedef typename remove_be_t<T>::type le_type;
+		typedef typename to_be_t<T>::type be_type;
 
 		operator T&()
 		{
@@ -30,34 +32,54 @@ namespace vm
 		{
 			return (_ref_base&)addr;
 		}
+
+		_ref_base& operator = (le_type right)
+		{
+			get_ref<T>(m_addr) = right;
+			return *this;
+		}
+
+		const _ref_base& operator = (le_type right) const
+		{
+			get_ref<T>(m_addr) = right;
+			return *this;
+		}
+
+		_ref_base& operator = (be_type right)
+		{
+			get_ref<T>(m_addr) = right;
+			return *this;
+		}
+
+		const _ref_base& operator = (be_type right) const
+		{
+			get_ref<T>(m_addr) = right;
+			return *this;
+		}
 	};
 
 	//BE reference to LE data
 	template<typename T, typename AT = u32> struct brefl : public _ref_base<T, typename to_be_t<AT>::type>
 	{
-		brefl& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-		const brefl& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+		using _ref_base::operator=;
 	};
 
 	//BE reference to BE data
 	template<typename T, typename AT = u32> struct brefb : public _ref_base<typename to_be_t<T>::type, typename to_be_t<AT>::type>
 	{
-		brefb& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-		const brefb& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+		using _ref_base::operator=;
 	};
 
 	//LE reference to BE data
 	template<typename T, typename AT = u32> struct lrefb : public _ref_base<typename to_be_t<T>::type, AT>
 	{
-		lrefb& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-		const lrefb& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+		using _ref_base::operator=;
 	};
 
 	//LE reference to LE data
 	template<typename T, typename AT = u32> struct lrefl : public _ref_base<T, AT>
 	{
-		lrefl& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-		const lrefl& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+		using _ref_base::operator=;
 	};
 
 	namespace ps3
@@ -65,15 +87,13 @@ namespace vm
 		//default reference for HLE functions (LE reference to BE data)
 		template<typename T, typename AT = u32> struct ref : public lrefb<T, AT>
 		{
-			ref& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-			const ref& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+			using _ref_base::operator=;
 		};
 
 		//default reference for HLE structures (BE reference to BE data)
 		template<typename T, typename AT = u32> struct bref : public brefb<T, AT>
 		{
-			bref& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-			const bref& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+			using _ref_base::operator=;
 		};
 	}
 
@@ -82,8 +102,7 @@ namespace vm
 		//default reference for HLE functions & structures (LE reference to LE data)
 		template<typename T, typename AT = u32> struct ref : public lrefl<T, AT>
 		{
-			ref& operator = (T right) { get_ref<T>(m_addr) = right; return *this; }
-			const ref& operator = (T right) const { get_ref<T>(m_addr) = right; return *this; }
+			using _ref_base::operator=;
 		};
 	}
 

From 51ea1e3bed76eb6da47f99451e28b3ebff5fc221 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 01:41:36 +0400
Subject: [PATCH 27/36] Compilation fix 5

---
 rpcs3/Emu/Memory/vm_ref.h                | 12 ++++++------
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp |  4 ++--
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.h   |  2 +-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index ad238223e7..65047cabf1 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -61,25 +61,25 @@ namespace vm
 	//BE reference to LE data
 	template<typename T, typename AT = u32> struct brefl : public _ref_base<T, typename to_be_t<AT>::type>
 	{
-		using _ref_base::operator=;
+		using _ref_base<T, typename to_be_t<AT>::type>::operator=;
 	};
 
 	//BE reference to BE data
 	template<typename T, typename AT = u32> struct brefb : public _ref_base<typename to_be_t<T>::type, typename to_be_t<AT>::type>
 	{
-		using _ref_base::operator=;
+		using _ref_base<typename to_be_t<T>::type, typename to_be_t<AT>::type>::operator=;
 	};
 
 	//LE reference to BE data
 	template<typename T, typename AT = u32> struct lrefb : public _ref_base<typename to_be_t<T>::type, AT>
 	{
-		using _ref_base::operator=;
+		using _ref_base<typename to_be_t<T>::type, AT>::operator=;
 	};
 
 	//LE reference to LE data
 	template<typename T, typename AT = u32> struct lrefl : public _ref_base<T, AT>
 	{
-		using _ref_base::operator=;
+		using _ref_base<T, AT>::operator=;
 	};
 
 	namespace ps3
@@ -87,13 +87,13 @@ namespace vm
 		//default reference for HLE functions (LE reference to BE data)
 		template<typename T, typename AT = u32> struct ref : public lrefb<T, AT>
 		{
-			using _ref_base::operator=;
+			using lrefb<T, AT>::operator=;
 		};
 
 		//default reference for HLE structures (BE reference to BE data)
 		template<typename T, typename AT = u32> struct bref : public brefb<T, AT>
 		{
-			using _ref_base::operator=;
+			using brefb<T, AT>::operator=;
 		};
 	}
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
index 52ff26cbbc..858bd25940 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
@@ -11,7 +11,7 @@
 
 SysCallBase sys_semaphore("sys_semaphore");
 
-s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
+s32 sys_semaphore_create(vm::ref<u32> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
 {
 	sys_semaphore.Warning("sys_semaphore_create(sem_addr=0x%x, attr_addr=0x%x, initial_count=%d, max_count=%d)",
 		sem.addr(), attr.GetAddr(), initial_count, max_count);
@@ -38,7 +38,7 @@ s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribu
 	}
 
 	u32 id = sys_semaphore.GetNewId(new Semaphore(initial_count, max_count, attr->protocol, attr->name_u64), TYPE_SEMAPHORE);
-	*sem = id;
+	sem = id;
 	sys_semaphore.Notice("*** semaphore created [%s] (protocol=0x%x): id = %d",
 		std::string(attr->name, 8).c_str(), (u32)attr->protocol, id);
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
index a27691405a..079c9c4130 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
@@ -38,7 +38,7 @@ struct Semaphore
 };
 
 // SysCalls
-s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
+s32 sys_semaphore_create(vm::ref<u32> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
 s32 sys_semaphore_destroy(u32 sem_id);
 s32 sys_semaphore_wait(u32 sem_id, u64 timeout);
 s32 sys_semaphore_trywait(u32 sem_id);

From 37da5589e4275e0c04f91e8da573a707b1a0aa8d Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 01:46:02 +0400
Subject: [PATCH 28/36] Compilation fix 6

---
 rpcs3/Emu/Memory/vm_ref.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/Memory/vm_ref.h b/rpcs3/Emu/Memory/vm_ref.h
index 65047cabf1..4d682e1ab1 100644
--- a/rpcs3/Emu/Memory/vm_ref.h
+++ b/rpcs3/Emu/Memory/vm_ref.h
@@ -102,7 +102,7 @@ namespace vm
 		//default reference for HLE functions & structures (LE reference to LE data)
 		template<typename T, typename AT = u32> struct ref : public lrefl<T, AT>
 		{
-			using _ref_base::operator=;
+			using lrefl<T, AT>::operator=;
 		};
 	}
 

From 9c94a6943d5948febbcff541e4360b6cc6c1849c Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 02:22:13 +0400
Subject: [PATCH 29/36] mem_bptr_t replaced

---
 rpcs3/Emu/Memory/Memory.h                     |  3 -
 rpcs3/Emu/Memory/vm_ptr.h                     | 74 ++++++++++++++++---
 rpcs3/Emu/SysCalls/Modules/cellGame.cpp       |  4 +-
 rpcs3/Emu/SysCalls/Modules/cellGame.h         |  2 +-
 rpcs3/Emu/SysCalls/Modules/cellSysutil.h      |  2 +-
 .../SysCalls/Modules/cellSysutil_SaveData.cpp | 54 +++++++-------
 .../SysCalls/Modules/cellSysutil_SaveData.h   | 16 ++--
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp      |  4 +-
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.h        |  2 +-
 9 files changed, 107 insertions(+), 54 deletions(-)

diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index 127428d0d8..fc1a989a87 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -650,9 +650,6 @@ public:
 	template<typename NT> operator const mem_ptr_t<NT, 1, AT>&() const { return (const mem_ptr_t<NT, 1, AT>&)*this; }
 };
 
-template<typename T, int lvl = 1, typename AT = u32>
-class mem_beptr_t : public mem_ptr_t<T, lvl, be_t<AT>> {};
-
 template<typename T, typename AT = u32> class mem_t : public mem_base_t<T, AT>
 {
 public:
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index c7dd6d2c0e..693bc5d183 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -314,7 +314,7 @@ namespace vm
 
 	namespace ps3
 	{
-		template<typename T, int lvl, typename AT> class ptr;
+		template<typename T, int lvl, typename AT> struct ptr;
 	}
 
 	template<typename AT, typename RT, typename ...T>
@@ -413,32 +413,88 @@ namespace vm
 	};
 
 	//BE pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> class bptrl : public _ptr_base<T, lvl, typename to_be_t<AT>::type> {};
+	template<typename T, int lvl = 1, typename AT = u32> struct bptrl : public _ptr_base<T, lvl, typename to_be_t<AT>::type>
+	{
+		static bptrl make(AT addr)
+		{
+			return (bptrl&)addr;
+		}
+
+		using _ptr_base<T, lvl, typename to_be_t<AT>::type>::operator=;
+	};
+
 	//BE pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> class bptrb : public _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type> {};
+	template<typename T, int lvl = 1, typename AT = u32> struct bptrb : public _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>
+	{
+		static bptrb make(AT addr)
+		{
+			return (bptrb&)addr;
+		}
+
+		using _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::operator=;
+	};
+
 	//LE pointer to BE data
-	template<typename T, int lvl = 1, typename AT = u32> class lptrb : public _ptr_base<typename to_be_t<T>::type, lvl, AT> {};
+	template<typename T, int lvl = 1, typename AT = u32> struct lptrb : public _ptr_base<typename to_be_t<T>::type, lvl, AT>
+	{
+		static lptrb make(AT addr)
+		{
+			return (lptrb&)addr;
+		}
+
+		using _ptr_base<typename to_be_t<T>::type, lvl, AT>::operator=;
+	};
+
 	//LE pointer to LE data
-	template<typename T, int lvl = 1, typename AT = u32> class lptrl : public _ptr_base<T, lvl, AT> {};
+	template<typename T, int lvl = 1, typename AT = u32> struct lptrl : public _ptr_base<T, lvl, AT>
+	{
+		static lptrl make(AT addr)
+		{
+			return (lptrl&)addr;
+		}
+
+		using _ptr_base<T, lvl, AT>::operator=;
+	};
+
 	namespace ps3
 	{
 		//default pointer for HLE functions (LE ptrerence to BE data)
-		template<typename T, int lvl = 1, typename AT = u32> class ptr : public lptrb<T, lvl, AT>
+		template<typename T, int lvl = 1, typename AT = u32> struct ptr : public lptrb<T, lvl, AT>
 		{
-		public:
 			static ptr make(AT addr)
 			{
 				return (ptr&)addr;
 			}
+
+			using lptrb<T, lvl, AT>::operator=;
 		};
+
 		//default pointer for HLE structures (BE ptrerence to BE data)
-		template<typename T, int lvl = 1, typename AT = u32> class bptr : public bptrb<T, lvl, AT> {};
+		template<typename T, int lvl = 1, typename AT = u32> struct bptr : public bptrb<T, lvl, AT>
+		{
+			static bptr make(AT addr)
+			{
+				return (bptr&)addr;
+			}
+
+			using bptrb<T, lvl, AT>::operator=;
+		};
 	}
+
 	namespace psv
 	{
 		//default pointer for HLE functions & structures (LE ptrerence to LE data)
-		template<typename T, int lvl = 1, typename AT = u32> class ptr : public lptrl<T, lvl, AT> {};
+		template<typename T, int lvl = 1, typename AT = u32> struct ptr : public lptrl<T, lvl, AT>
+		{
+			static ptr make(AT addr)
+			{
+				return (ptr&)addr;
+			}
+
+			using lptrl<T, lvl, AT>::operator=;
+		};
 	}
+
 	//PS3 emulation is main now, so lets it be as default
 	using namespace ps3;
 }
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
index ba2aadd2a5..20ac617af6 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
@@ -267,10 +267,10 @@ int cellGameDataCheckCreate2(u32 version, vm::ptr<const char> dirName, u32 errDi
 
 	funcStat(cbResult, cbGet, cbSet);
 
-	if (cbSet->setParam.GetAddr())
+	if (cbSet->setParam)
 	{
 		// TODO: write PARAM.SFO from cbSet
-		cellGame->Todo("cellGameDataCheckCreate2(): writing PARAM.SFO parameters (addr=0x%x)", cbSet->setParam.GetAddr());
+		cellGame->Todo("cellGameDataCheckCreate2(): writing PARAM.SFO parameters (addr=0x%x)", cbSet->setParam.addr());
 	}
 
 	switch ((s32)cbResult->result)
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.h b/rpcs3/Emu/SysCalls/Modules/cellGame.h
index 12a0165eba..0e7f6e3e95 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.h
@@ -197,6 +197,6 @@ struct CellGameDataStatGet
 
 struct CellGameDataStatSet
 {
-	mem_beptr_t<CellGameDataSystemFileParam> setParam;
+	vm::bptr<CellGameDataSystemFileParam> setParam;
 	be_t<u32> reserved;
 };
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.h b/rpcs3/Emu/SysCalls/Modules/cellSysutil.h
index 5a82805bd8..de53898d1c 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.h
@@ -202,7 +202,7 @@ struct CellHddGameStatGet
 
 struct CellHddGameStatSet
 {
-	mem_beptr_t<CellHddGameSystemFileParam> setParam;
+	vm::bptr<CellHddGameSystemFileParam> setParam;
 	be_t<u32> reserved_addr;  // void*
 };
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index 6361e3d7b4..8b2d444f4b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -145,7 +145,7 @@ void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, mem_ptr_t<CellSav
 		saveEntries.push_back(entry);
 	}
 
-	if (fixedSet->newIcon.GetAddr())
+	if (fixedSet->newIcon)
 	{
 		saveEntries[0].iconBuf = Memory.VirtualToRealAddr(fixedSet->newIcon->iconBuf_addr);
 		saveEntries[0].iconBufSize = fixedSet->newIcon->iconBufSize;
@@ -177,7 +177,7 @@ void getSaveDataStat(SaveDataEntry entry, mem_ptr_t<CellSaveDataStatGet> statGet
 	memcpy(statGet->getParam.listParam, entry.listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
 
 	statGet->fileNum = 0;
-	statGet->fileList.SetAddr(be_t<u32>::MakeFromBE(0));
+	statGet->fileList = vm::bptr<CellSaveDataFileStat>::make(0);
 	statGet->fileListNum = 0;
 	std::string saveDir = "/dev_hdd0/home/00000001/savedata/" + entry.dirName; // TODO: Get the path of the current user
 	vfsDir dir(saveDir);
@@ -209,7 +209,7 @@ void getSaveDataStat(SaveDataEntry entry, mem_ptr_t<CellSaveDataStatGet> statGet
 		}
 	}
 
-	statGet->fileList.SetAddr(be_t<u32>::MakeFromLE((u32)Memory.Alloc(sizeof(CellSaveDataFileStat) * (u32)fileEntries.size(), sizeof(CellSaveDataFileStat))));
+	statGet->fileList = vm::bptr<CellSaveDataFileStat>::make(be_t<u32>::MakeFromLE((u32)Memory.Alloc(sizeof(CellSaveDataFileStat) * (u32)fileEntries.size(), sizeof(CellSaveDataFileStat))));
 	for (u32 i=0; i<fileEntries.size(); i++)
 		memcpy(&statGet->fileList[i], &fileEntries[i], sizeof(CellSaveDataFileStat));
 }
@@ -325,8 +325,8 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList.SetAddr(setBuf->buf_addr);
-	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
+	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
 
 	for (u32 i=0; i<saveEntries.size(); i++) {
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
@@ -340,9 +340,9 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
-	if (listSet->newData.GetAddr())
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
+	setSaveDataList(saveEntries, (u32)listSet->fixedList.addr(), listSet->fixedListNum);
+	if (listSet->newData)
+		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr());
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -355,7 +355,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -410,8 +410,8 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList.SetAddr(setBuf->buf_addr);
-	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
+	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
 
 	for (u32 i=0; i<saveEntries.size(); i++) {
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
@@ -425,9 +425,9 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
-	if (listSet->newData.GetAddr())
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
+	setSaveDataList(saveEntries, (u32)listSet->fixedList.addr(), listSet->fixedListNum);
+	if (listSet->newData)
+		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr());
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -440,7 +440,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -493,8 +493,8 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList.SetAddr(setBuf->buf_addr);
-	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
+	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
 	for (u32 i = 0; i<saveEntries.size(); i++) {
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
@@ -510,7 +510,7 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -562,8 +562,8 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList.SetAddr(setBuf->buf_addr);
-	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
+	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
 	for (u32 i = 0; i<saveEntries.size(); i++) {
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
 		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
@@ -579,7 +579,7 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -632,7 +632,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	result->userdata_addr = userdata_addr;
 	funcStat(result, statGet, statSet);
 
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -682,7 +682,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	result->userdata_addr = userdata_addr;
 	funcStat(result, statGet, statSet);
 
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
@@ -735,8 +735,8 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList.SetAddr(setBuf->buf_addr);
-	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
+	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
 
 	for (u32 i = 0; i<saveEntries.size(); i++) {
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
@@ -820,8 +820,8 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList.SetAddr(setBuf->buf_addr);
-	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.GetAddr());
+	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	CellSaveDataDirList* dirList = (CellSaveDataDirList*)Memory.VirtualToRealAddr(listGet->dirList.addr());
 
 	for (u32 i = 0; i<saveEntries.size(); i++) {
 		memcpy(dirList[i].dirName, saveEntries[i].dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
index 6ec2ea1605..1f0c92015e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
@@ -116,7 +116,7 @@ struct CellSaveDataListNewData
 { 
 	be_t<u32> iconPosition;
 	be_t<u32> dirName_addr; // char*
-	mem_beptr_t<CellSaveDataNewDataIcon> icon;
+	vm::bptr<CellSaveDataNewDataIcon> icon;
 };
 
 struct CellSaveDataDirList
@@ -129,7 +129,7 @@ struct CellSaveDataListGet
 { 
 	be_t<u32> dirNum;
 	be_t<u32> dirListNum;
-	mem_beptr_t<CellSaveDataDirList> dirList;
+	vm::bptr<CellSaveDataDirList> dirList;
 };
 
 struct CellSaveDataListSet
@@ -137,15 +137,15 @@ struct CellSaveDataListSet
 	be_t<u32> focusPosition;
 	be_t<u32> focusDirName_addr; // char*
 	be_t<u32> fixedListNum;
-	mem_beptr_t<CellSaveDataDirList> fixedList;
-	mem_beptr_t<CellSaveDataListNewData> newData;
+	vm::bptr<CellSaveDataDirList> fixedList;
+	vm::bptr<CellSaveDataListNewData> newData;
 	be_t<u32> reserved_addr;  // void*
 };
 
 struct CellSaveDataFixedSet
 { 
 	be_t<u32> dirName_addr; // char*
-	mem_beptr_t<CellSaveDataNewDataIcon> newIcon;
+	vm::bptr<CellSaveDataNewDataIcon> newIcon;
 	be_t<u32> option;
 };
 
@@ -191,7 +191,7 @@ struct CellSaveDataStatGet
 	be_t<s32> sysSizeKB;
 	be_t<u32> fileNum;
 	be_t<u32> fileListNum;
-	mem_beptr_t<CellSaveDataFileStat> fileList;
+	vm::bptr<CellSaveDataFileStat> fileList;
 };
 
 struct CellSaveDataAutoIndicator
@@ -205,9 +205,9 @@ struct CellSaveDataAutoIndicator
 
 struct CellSaveDataStatSet 
 { 
-	mem_beptr_t<CellSaveDataSystemFileParam> setParam;
+	vm::bptr<CellSaveDataSystemFileParam> setParam;
 	be_t<u32> reCreateMode;
-	mem_beptr_t<CellSaveDataAutoIndicator> indicator;
+	vm::bptr<CellSaveDataAutoIndicator> indicator;
 };
 
 struct CellSaveDataFileGet
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
index 858bd25940..52ff26cbbc 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
@@ -11,7 +11,7 @@
 
 SysCallBase sys_semaphore("sys_semaphore");
 
-s32 sys_semaphore_create(vm::ref<u32> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
+s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
 {
 	sys_semaphore.Warning("sys_semaphore_create(sem_addr=0x%x, attr_addr=0x%x, initial_count=%d, max_count=%d)",
 		sem.addr(), attr.GetAddr(), initial_count, max_count);
@@ -38,7 +38,7 @@ s32 sys_semaphore_create(vm::ref<u32> sem, mem_ptr_t<sys_semaphore_attribute> at
 	}
 
 	u32 id = sys_semaphore.GetNewId(new Semaphore(initial_count, max_count, attr->protocol, attr->name_u64), TYPE_SEMAPHORE);
-	sem = id;
+	*sem = id;
 	sys_semaphore.Notice("*** semaphore created [%s] (protocol=0x%x): id = %d",
 		std::string(attr->name, 8).c_str(), (u32)attr->protocol, id);
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
index 079c9c4130..a27691405a 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
@@ -38,7 +38,7 @@ struct Semaphore
 };
 
 // SysCalls
-s32 sys_semaphore_create(vm::ref<u32> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
+s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
 s32 sys_semaphore_destroy(u32 sem_id);
 s32 sys_semaphore_wait(u32 sem_id, u64 timeout);
 s32 sys_semaphore_trywait(u32 sem_id);

From 6e02477fc623ffb9ea25a91106d3bceed674423b Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 02:35:10 +0400
Subject: [PATCH 30/36] Some warnings fixed

---
 Utilities/Thread.h           | 7 -------
 rpcs3/Emu/SysCalls/SC_FUNC.h | 1 +
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/Utilities/Thread.h b/Utilities/Thread.h
index 987a9ea3d2..1daeeb5f59 100644
--- a/Utilities/Thread.h
+++ b/Utilities/Thread.h
@@ -2,13 +2,6 @@
 
 static std::thread::id main_thread;
 
-struct rThread
-{
-	static bool IsMain() { std::this_thread::get_id() == main_thread; }
-};
-
-class ThreadExec;
-
 class NamedThreadBase
 {
 	std::string m_name;
diff --git a/rpcs3/Emu/SysCalls/SC_FUNC.h b/rpcs3/Emu/SysCalls/SC_FUNC.h
index f831aa5a64..5b6b596234 100644
--- a/rpcs3/Emu/SysCalls/SC_FUNC.h
+++ b/rpcs3/Emu/SysCalls/SC_FUNC.h
@@ -5,6 +5,7 @@ class func_caller
 {
 public:
 	virtual void operator()() = 0;
+	virtual ~func_caller(){};
 };
 
 namespace detail

From bd9775e0ebc5536261603999cf25a57d3e5acd22 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 02:59:46 +0400
Subject: [PATCH 31/36] Callbacks fix + TODO

---
 rpcs3/Emu/Memory/vm_ptr.h    | 59 +++++++++---------------------------
 rpcs3/Emu/SysCalls/SC_FUNC.h |  2 +-
 2 files changed, 16 insertions(+), 45 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index 693bc5d183..b62d78f61d 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -270,6 +270,10 @@ namespace vm
 	{
 		AT m_addr;
 
+		static_assert(!std::is_floating_point<RT>::value, "TODO: Unsupported callback result type (floating point)");
+
+		static_assert(!std::is_pointer<RT>::value, "Invalid callback result type (pointer)");
+
 		__forceinline RT call_func(bool is_async) const
 		{
 			Callback cb;
@@ -312,60 +316,27 @@ namespace vm
 		}
 	};
 
-	namespace ps3
-	{
-		template<typename T, int lvl, typename AT> struct ptr;
-	}
-
 	template<typename AT, typename RT, typename ...T>
 	class _ptr_base<RT(*)(T...), 1, AT>
 	{
 		AT m_addr;
 
+		static_assert(!std::is_floating_point<RT>::value, "TODO: Unsupported callback result type (floating point)");
+
+		static_assert(!std::is_pointer<RT>::value, "Invalid callback result type (pointer)");
+
 		template<typename TT>
 		struct _func_arg
 		{
+			static_assert(!std::is_floating_point<TT>::value, "TODO: Unsupported callback argument type (floating point)");
+
+			static_assert(!std::is_pointer<TT>::value, "Invalid callback argument type (pointer)");
+
 			__forceinline static u64 get_value(const TT& arg)
 			{
-				return arg;
-			}
-		};
-
-		template<typename TT, typename ATT>
-		struct _func_arg<_ptr_base<TT, 1, ATT>>
-		{
-			__forceinline static u64 get_value(const _ptr_base<TT, 1, ATT>& arg)
-			{
-				return arg.addr();
-			}
-		};
-
-		template<typename TT, typename ATT>
-		struct _func_arg<ps3::ptr<TT, 1, ATT>>
-		{
-			__forceinline static u64 get_value(const ps3::ptr<TT, 1, ATT>& arg)
-			{
-				return arg.addr();
-			}
-		};
-
-		template<typename TT, typename ATT>
-		struct _func_arg<_ref_base<TT, ATT>>
-		{
-			__forceinline static u64 get_value(const _ref_base<TT, ATT>& arg)
-			{
-				return arg.addr();
-			}
-		};
-
-		template<typename TT, int i, typename ATT>
-		struct _func_arg<mem_ptr_t<TT, i, ATT>>
-		{
-			static_assert(!i, "Invalid callback argument type (mem_ptr_t), use vm::ptr");
-			
-			__forceinline static u64 get_value(const mem_ptr_t<TT, i, ATT>& arg)
-			{
-				return 0;
+				u64 res = 0;
+				(TT&)res = arg;
+				return res;
 			}
 		};
 
diff --git a/rpcs3/Emu/SysCalls/SC_FUNC.h b/rpcs3/Emu/SysCalls/SC_FUNC.h
index 5b6b596234..72fd52e847 100644
--- a/rpcs3/Emu/SysCalls/SC_FUNC.h
+++ b/rpcs3/Emu/SysCalls/SC_FUNC.h
@@ -74,7 +74,7 @@ namespace detail
 			static_assert(!std::is_pointer<T>::value, "Invalid function result type: pointer");
 			if (std::is_floating_point<T>::value)
 			{
-				(T&)CPU.FPR[1] = value;
+				CPU.FPR[1] = (double)value;
 			}
 			else
 			{

From b952017a3aa81b632035ff5380850f059441db00 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 05:05:13 +0400
Subject: [PATCH 32/36] mem_ptr_t replaced

---
 rpcs3/Emu/Cell/SPUThread.cpp                  |   2 +-
 rpcs3/Emu/Memory/Memory.h                     | 278 ------------------
 rpcs3/Emu/Memory/vm_ptr.h                     |   5 +
 rpcs3/Emu/SysCalls/Modules/SC_Keyboard.cpp    |  12 +-
 rpcs3/Emu/SysCalls/Modules/SC_Keyboard.h      |   6 +-
 rpcs3/Emu/SysCalls/Modules/SC_Mouse.cpp       |  16 +-
 rpcs3/Emu/SysCalls/Modules/SC_Mouse.h         |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellAdec.cpp       |  26 +-
 rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp      |  92 +++---
 rpcs3/Emu/SysCalls/Modules/cellAudio.cpp      |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellDmux.cpp       | 138 ++++-----
 rpcs3/Emu/SysCalls/Modules/cellFiber.cpp      |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellFont.cpp       |  92 +++---
 rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp     |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellGame.cpp       |  16 +-
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp     |  70 ++---
 rpcs3/Emu/SysCalls/Modules/cellGcmSys.h       |   4 +-
 rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp     |  18 +-
 rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp     |  18 +-
 rpcs3/Emu/SysCalls/Modules/cellL10n.cpp       |   6 +-
 rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp     |  16 +-
 rpcs3/Emu/SysCalls/Modules/cellPamf.cpp       | 144 ++++-----
 rpcs3/Emu/SysCalls/Modules/cellPamf.h         |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp     |  40 +--
 rpcs3/Emu/SysCalls/Modules/cellResc.cpp       |  36 +--
 rpcs3/Emu/SysCalls/Modules/cellResc.h         |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellRtc.cpp        | 118 ++++----
 rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp      | 164 +++++------
 rpcs3/Emu/SysCalls/Modules/cellSpurs.h        |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp    |  38 +--
 .../SysCalls/Modules/cellSysutil_SaveData.cpp | 100 +++----
 .../SysCalls/Modules/cellSysutil_SaveData.h   |  16 +-
 rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp   |   8 +-
 rpcs3/Emu/SysCalls/Modules/cellUserInfo.h     |   2 +-
 rpcs3/Emu/SysCalls/Modules/cellVdec.cpp       |  34 +--
 rpcs3/Emu/SysCalls/Modules/cellVpost.cpp      |  18 +-
 rpcs3/Emu/SysCalls/Modules/libmixer.cpp       |  26 +-
 rpcs3/Emu/SysCalls/Modules/libsynth2.cpp      |   8 +-
 rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp    |  16 +-
 rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp  |  16 +-
 rpcs3/Emu/SysCalls/Modules/sys_net.cpp        |  36 +--
 rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp              |  28 +-
 rpcs3/Emu/SysCalls/lv2/lv2Fs.h                |  12 +-
 rpcs3/Emu/SysCalls/lv2/sys_cond.cpp           |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_cond.h             |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_event.cpp          |  14 +-
 rpcs3/Emu/SysCalls/lv2/sys_event.h            |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp     |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_event_flag.h       |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp         |  34 +--
 rpcs3/Emu/SysCalls/lv2/sys_lwcond.h           |  12 +-
 rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp        |  24 +-
 rpcs3/Emu/SysCalls/lv2/sys_lwmutex.h          |  10 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.cpp         |  12 +-
 rpcs3/Emu/SysCalls/lv2/sys_memory.h           |   6 +-
 rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp          |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_mutex.h            |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp     |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h       |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_process.cpp        |  26 +-
 rpcs3/Emu/SysCalls/lv2/sys_prx.cpp            |  16 +-
 rpcs3/Emu/SysCalls/lv2/sys_prx.h              |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp         |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_rwlock.h           |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp      |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_semaphore.h        |   2 +-
 rpcs3/Emu/SysCalls/lv2/sys_spinlock.cpp       |  18 +-
 rpcs3/Emu/SysCalls/lv2/sys_spinlock.h         |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_spu.cpp            |  16 +-
 rpcs3/Emu/SysCalls/lv2/sys_spu.h              |   8 +-
 rpcs3/Emu/SysCalls/lv2/sys_timer.cpp          |   4 +-
 rpcs3/Emu/SysCalls/lv2/sys_timer.h            |   2 +-
 rpcs3/Gui/RSXDebugger.cpp                     |   4 +-
 73 files changed, 833 insertions(+), 1142 deletions(-)

diff --git a/rpcs3/Emu/Cell/SPUThread.cpp b/rpcs3/Emu/Cell/SPUThread.cpp
index a44f95fdb0..4017366e98 100644
--- a/rpcs3/Emu/Cell/SPUThread.cpp
+++ b/rpcs3/Emu/Cell/SPUThread.cpp
@@ -282,7 +282,7 @@ void SPUThread::ListCmd(u32 lsa, u64 ea, u16 tag, u16 size, u32 cmd, MFCReg& MFC
 
 	for (u32 i = 0; i < list_size; i++)
 	{
-		mem_ptr_t<list_element> rec((u32)dmac.ls_offset + list_addr + i * 8);
+		auto rec = vm::ptr<list_element>::make((u32)dmac.ls_offset + list_addr + i * 8);
 
 		u32 size = rec->ts;
 		if (size < 16 && size != 1 && size != 2 && size != 4 && size != 8)
diff --git a/rpcs3/Emu/Memory/Memory.h b/rpcs3/Emu/Memory/Memory.h
index fc1a989a87..b2af476441 100644
--- a/rpcs3/Emu/Memory/Memory.h
+++ b/rpcs3/Emu/Memory/Memory.h
@@ -408,283 +408,5 @@ public:
 
 extern MemoryBase Memory;
 
-template<typename T, typename AT = u32>
-class mem_base_t
-{
-protected:
-	AT m_addr;
-
-public:
-	mem_base_t(AT addr) : m_addr(addr)
-	{
-	}
-
-	__forceinline AT GetAddr() const { return m_addr; }
-
-	__forceinline void SetAddr(AT addr) { m_addr = addr; }
-
-	__forceinline bool IsGood() const
-	{
-		return Memory.IsGoodAddr(m_addr, sizeof(T));
-	}
-
-	__forceinline operator bool() const
-	{
-		return m_addr != 0;
-	}
-
-	__forceinline bool operator != (nullptr_t) const
-	{
-		return m_addr != 0;
-	}
-
-	__forceinline bool operator == (nullptr_t) const
-	{
-		return m_addr == 0;
-	}
-	
-	bool operator == (const mem_base_t& right) const { return m_addr == right.m_addr; }
-	bool operator != (const mem_base_t& right) const { return m_addr != right.m_addr; }
-	bool operator > (const mem_base_t& right) const { return m_addr > right.m_addr; }
-	bool operator < (const mem_base_t& right) const { return m_addr < right.m_addr; }
-	bool operator >= (const mem_base_t& right) const { return m_addr >= right.m_addr; }
-	bool operator <= (const mem_base_t& right) const { return m_addr <= right.m_addr; }
-
-	bool operator == (T* right) const { return (T*)&Memory[m_addr] == right; }
-	bool operator != (T* right) const { return (T*)&Memory[m_addr] != right; }
-	bool operator > (T* right) const { return (T*)&Memory[m_addr] > right; }
-	bool operator < (T* right) const { return (T*)&Memory[m_addr] < right; }
-	bool operator >= (T* right) const { return (T*)&Memory[m_addr] >= right; }
-	bool operator <= (T* right) const { return (T*)&Memory[m_addr] <= right; }
-};
-
-template<typename T, int lvl = 1, typename AT = u32>
-class mem_ptr_t : public mem_base_t<AT, AT>
-{
-public:
-	mem_ptr_t(AT addr) : mem_base_t<AT, AT>(addr)
-	{
-	}
-
-	template<typename NT> operator mem_ptr_t<NT, lvl, AT>&() { return (mem_ptr_t<NT, lvl, AT>&)*this; }
-	template<typename NT> operator const mem_ptr_t<NT, lvl, AT>&() const { return (const mem_ptr_t<NT, lvl, AT>&)*this; }
-
-	mem_ptr_t operator++ (int)
-	{
-		mem_ptr_t ret(this->m_addr);
-		this->m_addr += sizeof(AT);
-		return ret;
-	}
-
-	mem_ptr_t& operator++ ()
-	{
-		this->m_addr += sizeof(AT);
-		return *this;
-	}
-
-	mem_ptr_t operator-- (int)
-	{
-		mem_ptr_t ret(this->m_addr);
-		this->m_addr -= sizeof(AT);
-		return ret;
-	}
-
-	mem_ptr_t& operator-- ()
-	{
-		this->m_addr -= sizeof(AT);
-		return *this;
-	}
-
-	mem_ptr_t& operator += (uint count)
-	{
-		this->m_addr += count * sizeof(AT);
-		return *this;
-	}
-
-	mem_ptr_t& operator -= (uint count)
-	{
-		this->m_addr -= count * sizeof(AT);
-		return *this;
-	}
-
-	mem_ptr_t operator + (uint count) const
-	{
-		return this->m_addr + count * sizeof(AT);
-	}
-
-	mem_ptr_t operator - (uint count) const
-	{
-		return this->m_addr - count * sizeof(AT);
-	}
-
-	__forceinline mem_ptr_t<T, lvl - 1, AT>& operator *()
-	{
-		return (mem_ptr_t<T, lvl - 1, AT>&)Memory[this->m_addr];
-	}
-
-	__forceinline const mem_ptr_t<T, lvl - 1, AT>& operator *() const
-	{
-		return (const mem_ptr_t<T, lvl - 1, AT>&)Memory[this->m_addr];
-	}
-
-	__forceinline mem_ptr_t<T, lvl - 1, AT>& operator [](uint index)
-	{
-		return (mem_ptr_t<T, lvl - 1, AT>&)Memory[this->m_addr + sizeof(AT) * index];
-	}
-
-	__forceinline const mem_ptr_t<T, lvl - 1, AT>& operator [](uint index) const
-	{
-		return (const mem_ptr_t<T, lvl - 1, AT>&)Memory[this->m_addr + sizeof(AT) * index];
-	}
-
-	bool IsGood() const
-	{
-		return (*this)->IsGood() && mem_base_t<T, AT>::IsGood();
-	}
-
-	__forceinline bool IsGoodAddr() const
-	{
-		return mem_base_t<T, AT>::IsGood();
-	}
-};
-
-template<typename T, typename AT>
-class mem_ptr_t<T, 1, AT> : public mem_base_t<T, AT>
-{
-public:
-	mem_ptr_t(AT addr) : mem_base_t<T, AT>(addr)
-	{
-	}
-
-	template<typename NT> operator mem_ptr_t<NT, 1, AT>&() { return (mem_ptr_t<NT, 1, AT>&)*this; }
-	template<typename NT> operator const mem_ptr_t<NT, 1, AT>&() const { return (const mem_ptr_t<NT, 1, AT>&)*this; }
-
-	__forceinline T* operator -> ()
-	{
-		return (T*)&Memory[this->m_addr];
-	}
-
-	__forceinline const T* operator -> () const
-	{
-		return (const T*)&Memory[this->m_addr];
-	}
-
-	mem_ptr_t operator++ (int)
-	{
-		mem_ptr_t ret(this->m_addr);
-		this->m_addr += sizeof(T);
-		return ret;
-	}
-
-	mem_ptr_t& operator++ ()
-	{
-		this->m_addr += sizeof(T);
-		return *this;
-	}
-
-	mem_ptr_t operator-- (int)
-	{
-		mem_ptr_t ret(this->m_addr);
-		this->m_addr -= sizeof(T);
-		return ret;
-	}
-
-	mem_ptr_t& operator-- ()
-	{
-		this->m_addr -= sizeof(T);
-		return *this;
-	}
-
-	mem_ptr_t& operator += (uint count)
-	{
-		this->m_addr += count * sizeof(T);
-		return *this;
-	}
-
-	mem_ptr_t& operator -= (uint count)
-	{
-		this->m_addr -= count * sizeof(T);
-		return *this;
-	}
-
-	mem_ptr_t operator + (uint count) const
-	{
-		return this->m_addr + count * sizeof(T);
-	}
-
-	mem_ptr_t operator - (uint count) const
-	{
-		return this->m_addr - count * sizeof(T);
-	}
-
-	__forceinline T& operator *()
-	{
-		return (T&)Memory[this->m_addr];
-	}
-
-	__forceinline const T& operator *() const
-	{
-		return (T&)Memory[this->m_addr];
-	}
-
-	__forceinline T& operator [](uint index)
-	{
-		return (T&)Memory[this->m_addr + sizeof(T) * index];
-	}
-
-	__forceinline const T& operator [](uint index) const
-	{
-		return (const T&)Memory[this->m_addr + sizeof(T) * index];
-	}
-};
-
-template<typename AT>
-class mem_ptr_t<void, 1, AT> : public mem_base_t<u8, AT>
-{
-public:
-	mem_ptr_t(AT addr) : mem_base_t<u8, AT>(addr)
-	{
-	}
-
-	template<typename NT> operator mem_ptr_t<NT, 1, AT>&() { return (mem_ptr_t<NT, 1, AT>&)*this; }
-	template<typename NT> operator const mem_ptr_t<NT, 1, AT>&() const { return (const mem_ptr_t<NT, 1, AT>&)*this; }
-};
-
-template<typename T, typename AT = u32> class mem_t : public mem_base_t<T, AT>
-{
-public:
-	mem_t(AT addr) : mem_base_t<T, AT>(addr)
-	{
-	}
-
-	mem_t& operator = (T right)
-	{
-		(be_t<T>&)Memory[this->m_addr] = right;
-
-		return *this;
-	}
-
-	__forceinline T GetValue()
-	{
-		return (be_t<T>&)Memory[this->m_addr];
-	}
-
-	operator const T() const
-	{
-		return (be_t<T>&)Memory[this->m_addr];
-	}
-
-	mem_t& operator += (T right) { return *this = (*this) + right; }
-	mem_t& operator -= (T right) { return *this = (*this) - right; }
-	mem_t& operator *= (T right) { return *this = (*this) * right; }
-	mem_t& operator /= (T right) { return *this = (*this) / right; }
-	mem_t& operator %= (T right) { return *this = (*this) % right; }
-	mem_t& operator &= (T right) { return *this = (*this) & right; }
-	mem_t& operator |= (T right) { return *this = (*this) | right; }
-	mem_t& operator ^= (T right) { return *this = (*this) ^ right; }
-	mem_t& operator <<= (T right) { return *this = (*this) << right; }
-	mem_t& operator >>= (T right) { return *this = (*this) >> right; }
-};
-
 #include "vm.h"
 
diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index b62d78f61d..b13675b55f 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -448,6 +448,11 @@ namespace vm
 				return (bptr&)addr;
 			}
 
+			operator ptr<T, lvl, AT>() const
+			{
+				return ptr<T, lvl, AT>::make(addr());
+			}
+
 			using bptrb<T, lvl, AT>::operator=;
 		};
 	}
diff --git a/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.cpp b/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.cpp
index d93739c596..e605b8cda0 100644
--- a/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.cpp
@@ -85,9 +85,9 @@ u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode)
 	return 0x0000;
 }
 
-int cellKbGetInfo(mem_ptr_t<CellKbInfo> info)
+int cellKbGetInfo(vm::ptr<CellKbInfo> info)
 {
-	sys_io->Log("cellKbGetInfo(info_addr=0x%x)", info.GetAddr());
+	sys_io->Log("cellKbGetInfo(info_addr=0x%x)", info.addr());
 	if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED;
 
 	const KbInfo& current_info = Emu.GetKeyboardManager().GetInfo();
@@ -102,9 +102,9 @@ int cellKbGetInfo(mem_ptr_t<CellKbInfo> info)
 	return CELL_OK;
 }
 
-int cellKbRead(u32 port_no, mem_ptr_t<CellKbData> data)
+int cellKbRead(u32 port_no, vm::ptr<CellKbData> data)
 {
-	sys_io->Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.GetAddr());
+	sys_io->Log("cellKbRead(port_no=%d,info_addr=0x%x)", port_no, data.addr());
 
 	const std::vector<Keyboard>& keyboards = Emu.GetKeyboardManager().GetKeyboards();
 	if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED;
@@ -151,9 +151,9 @@ int cellKbSetReadMode(u32 port_no, u32 rmode)
 	return CELL_OK;
 }
 
-int cellKbGetConfiguration(u32 port_no, mem_ptr_t<CellKbConfig> config)
+int cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config)
 {
-	sys_io->Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.GetAddr());
+	sys_io->Log("cellKbGetConfiguration(port_no=%d,config_addr=0x%x)", port_no, config.addr());
 	if(!Emu.GetKeyboardManager().IsInited()) return CELL_KB_ERROR_UNINITIALIZED;
 
 	const KbConfig& current_config = Emu.GetKeyboardManager().GetConfig(port_no);
diff --git a/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.h b/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.h
index ca77078e17..af23ce6226 100644
--- a/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.h
+++ b/rpcs3/Emu/SysCalls/Modules/SC_Keyboard.h
@@ -43,9 +43,9 @@ int cellKbInit(u32 max_connect);
 int cellKbEnd();
 int cellKbClearBuf(u32 port_no);
 u16 cellKbCnvRawCode(u32 arrange, u32 mkey, u32 led, u16 rawcode);
-int cellKbGetInfo(mem_ptr_t<CellKbInfo> info);
-int cellKbRead(u32 port_no, mem_ptr_t<CellKbData> data);
+int cellKbGetInfo(vm::ptr<CellKbInfo> info);
+int cellKbRead(u32 port_no, vm::ptr<CellKbData> data);
 int cellKbSetCodeType(u32 port_no, u32 type);
 int cellKbSetLEDStatus(u32 port_no, u8 led);
 int cellKbSetReadMode(u32 port_no, u32 rmode);
-int cellKbGetConfiguration(u32 port_no, mem_ptr_t<CellKbConfig> config);
\ No newline at end of file
+int cellKbGetConfiguration(u32 port_no, vm::ptr<CellKbConfig> config);
diff --git a/rpcs3/Emu/SysCalls/Modules/SC_Mouse.cpp b/rpcs3/Emu/SysCalls/Modules/SC_Mouse.cpp
index 210bcbbb94..b2ddbf63a6 100644
--- a/rpcs3/Emu/SysCalls/Modules/SC_Mouse.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/SC_Mouse.cpp
@@ -38,9 +38,9 @@ int cellMouseEnd()
 	return CELL_OK;
 }
 
-int cellMouseGetInfo(mem_ptr_t<CellMouseInfo> info)
+int cellMouseGetInfo(vm::ptr<CellMouseInfo> info)
 {
-	sys_io->Log("cellMouseGetInfo(info_addr=0x%x)", info.GetAddr());
+	sys_io->Log("cellMouseGetInfo(info_addr=0x%x)", info.addr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 
 	const MouseInfo& current_info = Emu.GetMouseManager().GetInfo();
@@ -54,9 +54,9 @@ int cellMouseGetInfo(mem_ptr_t<CellMouseInfo> info)
 	return CELL_OK;
 }
 
-int cellMouseInfoTabletMode(u32 port_no, mem_ptr_t<CellMouseInfoTablet> info)
+int cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info)
 {
-	sys_io->Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.GetAddr());
+	sys_io->Log("cellMouseInfoTabletMode(port_no=%d,info_addr=0x%x)", port_no, info.addr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_INVALID_PARAMETER;
 
@@ -66,9 +66,9 @@ int cellMouseInfoTabletMode(u32 port_no, mem_ptr_t<CellMouseInfoTablet> info)
 	return CELL_OK;
 }
 
-int cellMouseGetData(u32 port_no, mem_ptr_t<CellMouseData> data)
+int cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data)
 {
-	sys_io->Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.GetAddr());
+	sys_io->Log("cellMouseGetData(port_no=%d,data_addr=0x%x)", port_no, data.addr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_NO_DEVICE;
 	
@@ -88,7 +88,7 @@ int cellMouseGetData(u32 port_no, mem_ptr_t<CellMouseData> data)
 	return CELL_OK;
 }
 
-int cellMouseGetDataList(u32 port_no, mem_ptr_t<CellMouseDataList> data)
+int cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data)
 {
 	UNIMPLEMENTED_FUNC(sys_io);
 	
@@ -113,7 +113,7 @@ int cellMouseGetRawData(u32 port_no, u32 data_addr)
 {
 	UNIMPLEMENTED_FUNC(sys_io);
 
-	/*sys_io->Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no, data.GetAddr());
+	/*sys_io->Log("cellMouseGetRawData(port_no=%d,data_addr=0x%x)", port_no, data.addr());
 	if(!Emu.GetMouseManager().IsInited()) return CELL_MOUSE_ERROR_UNINITIALIZED;
 	if(port_no >= Emu.GetMouseManager().GetMice().size()) return CELL_MOUSE_ERROR_NO_DEVICE;
 
diff --git a/rpcs3/Emu/SysCalls/Modules/SC_Mouse.h b/rpcs3/Emu/SysCalls/Modules/SC_Mouse.h
index 02915c7ab3..123de6076e 100644
--- a/rpcs3/Emu/SysCalls/Modules/SC_Mouse.h
+++ b/rpcs3/Emu/SysCalls/Modules/SC_Mouse.h
@@ -53,10 +53,10 @@ static const u32 CELL_MOUSE_MAX_CODES = 64;
 int cellMouseInit(u32 max_connect);
 int cellMouseClearBuf(u32 port_no);
 int cellMouseEnd();
-int cellMouseGetInfo(mem_ptr_t<CellMouseInfo> info);
-int cellMouseInfoTabletMode(u32 port_no, mem_ptr_t<CellMouseInfoTablet> info);
-int cellMouseGetData(u32 port_no, mem_ptr_t<CellMouseData> data);
-int cellMouseGetDataList(u32 port_no, mem_ptr_t<CellMouseDataList> data);
+int cellMouseGetInfo(vm::ptr<CellMouseInfo> info);
+int cellMouseInfoTabletMode(u32 port_no, vm::ptr<CellMouseInfoTablet> info);
+int cellMouseGetData(u32 port_no, vm::ptr<CellMouseData> data);
+int cellMouseGetDataList(u32 port_no, vm::ptr<CellMouseDataList> data);
 int cellMouseSetTabletMode(u32 port_no, u32 mode);
 int cellMouseGetTabletDataList(u32 port_no, u32 data_addr);
 int cellMouseGetRawData(u32 port_no, u32 data_addr);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
index 7bc8d42a23..0c288d07ae 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAdec.cpp
@@ -600,9 +600,9 @@ bool adecCheckType(AudioCodecType type)
 	return true;
 }
 
-int cellAdecQueryAttr(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecAttr> attr)
+int cellAdecQueryAttr(vm::ptr<CellAdecType> type, vm::ptr<CellAdecAttr> attr)
 {
-	cellAdec->Warning("cellAdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.GetAddr(), attr.GetAddr());
+	cellAdec->Warning("cellAdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.addr(), attr.addr());
 
 	if (!adecCheckType(type->audioCodecType)) return CELL_ADEC_ERROR_ARG;
 
@@ -614,10 +614,10 @@ int cellAdecQueryAttr(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecAttr> attr
 	return CELL_OK;
 }
 
-int cellAdecOpen(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResource> res, mem_ptr_t<CellAdecCb> cb, vm::ptr<be_t<u32>> handle)
+int cellAdecOpen(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResource> res, vm::ptr<CellAdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellAdec->Warning("cellAdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)", 
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
+		type.addr(), res.addr(), cb.addr(), handle.addr());
 
 	if (!adecCheckType(type->audioCodecType)) return CELL_ADEC_ERROR_ARG;
 
@@ -626,10 +626,10 @@ int cellAdecOpen(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResource> res,
 	return CELL_OK;
 }
 
-int cellAdecOpenEx(mem_ptr_t<CellAdecType> type, mem_ptr_t<CellAdecResourceEx> res, mem_ptr_t<CellAdecCb> cb, vm::ptr<be_t<u32>> handle)
+int cellAdecOpenEx(vm::ptr<CellAdecType> type, vm::ptr<CellAdecResourceEx> res, vm::ptr<CellAdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellAdec->Warning("cellAdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)", 
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
+		type.addr(), res.addr(), cb.addr(), handle.addr());
 
 	if (!adecCheckType(type->audioCodecType)) return CELL_ADEC_ERROR_ARG;
 
@@ -703,9 +703,9 @@ int cellAdecEndSeq(u32 handle)
 	return CELL_OK;
 }
 
-int cellAdecDecodeAu(u32 handle, mem_ptr_t<CellAdecAuInfo> auInfo)
+int cellAdecDecodeAu(u32 handle, vm::ptr<CellAdecAuInfo> auInfo)
 {
-	cellAdec->Log("cellAdecDecodeAu(handle=%d, auInfo_addr=0x%x)", handle, auInfo.GetAddr());
+	cellAdec->Log("cellAdecDecodeAu(handle=%d, auInfo_addr=0x%x)", handle, auInfo.addr());
 
 	AudioDecoder* adec;
 	if (!Emu.GetIdManager().GetIDData(handle, adec))
@@ -714,7 +714,7 @@ int cellAdecDecodeAu(u32 handle, mem_ptr_t<CellAdecAuInfo> auInfo)
 	}
 
 	AdecTask task(adecDecodeAu);
-	task.au.auInfo_addr = auInfo.GetAddr();
+	task.au.auInfo_addr = auInfo.addr();
 	task.au.addr = auInfo->startAddr;
 	task.au.size = auInfo->size;
 	task.au.pts = ((u64)auInfo->pts.upper << 32) | (u64)auInfo->pts.lower;
@@ -787,7 +787,7 @@ int cellAdecGetPcmItem(u32 handle, vm::ptr<be_t<u32>> pcmItem_ptr)
 
 	AVFrame* frame = af.data;
 
-	mem_ptr_t<CellAdecPcmItem> pcm(adec->memAddr + adec->memBias);
+	auto pcm = vm::ptr<CellAdecPcmItem>::make(adec->memAddr + adec->memBias);
 
 	adec->memBias += 512;
 	if (adec->memBias + 512 > adec->memSize)
@@ -796,7 +796,7 @@ int cellAdecGetPcmItem(u32 handle, vm::ptr<be_t<u32>> pcmItem_ptr)
 	}
 
 	pcm->pcmHandle = 0; // ???
-	pcm->pcmAttr.bsiInfo_addr = pcm.GetAddr() + sizeof(CellAdecPcmItem);
+	pcm->pcmAttr.bsiInfo_addr = pcm.addr() + sizeof(CellAdecPcmItem);
 	pcm->startAddr = 0x00000312; // invalid address (no output)
 	pcm->size = af.size;
 	pcm->status = CELL_OK;
@@ -806,12 +806,12 @@ int cellAdecGetPcmItem(u32 handle, vm::ptr<be_t<u32>> pcmItem_ptr)
 	pcm->auInfo.startAddr = af.auAddr;
 	pcm->auInfo.userData = af.userdata;
 
-	mem_ptr_t<CellAdecAtracXInfo> atx(pcm.GetAddr() + sizeof(CellAdecPcmItem));
+	auto atx = vm::ptr<CellAdecAtracXInfo>::make(pcm.addr() + sizeof(CellAdecPcmItem));
 	atx->samplingFreq = frame->sample_rate; // ???
 	atx->nbytes = frame->nb_samples * frame->channels * sizeof(float); // ???
 	atx->channelConfigIndex = CELL_ADEC_CH_STEREO; // ???
 
-	*pcmItem_ptr = pcm.GetAddr();
+	*pcmItem_ptr = pcm.addr();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
index 5346e740f1..14227915a2 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAtrac.cpp
@@ -6,43 +6,43 @@ Module *cellAtrac = nullptr;
 
 #include "cellAtrac.h"
 
-int cellAtracSetDataAndGetMemSize(mem_ptr_t<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<be_t<u32>> puiWorkMemByte)
+int cellAtracSetDataAndGetMemSize(vm::ptr<CellAtracHandle> pHandle, u32 pucBufferAddr, u32 uiReadByte, u32 uiBufferByte, vm::ptr<be_t<u32>> puiWorkMemByte)
 {
 	cellAtrac->Todo("cellAtracSetDataAndGetMemSize(pHandle=0x%x, pucBufferAddr=0x%x, uiReadByte=0x%x, uiBufferByte=0x%x, puiWorkMemByte_addr=0x%x)",
-		pHandle.GetAddr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
+		pHandle.addr(), pucBufferAddr, uiReadByte, uiBufferByte, puiWorkMemByte.addr());
 
 	*puiWorkMemByte = 0x1000; // unproved
 	return CELL_OK;
 }
 
-int cellAtracCreateDecoder(mem_ptr_t<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
+int cellAtracCreateDecoder(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, u32 uiSpuThreadPriority)
 {
 	cellAtrac->Todo("cellAtracCreateDecoder(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, uiSpuThreadPriority=%d)",
-		pHandle.GetAddr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
+		pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, uiSpuThreadPriority);
 
 	pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
 	return CELL_OK;
 }
 
-int cellAtracCreateDecoderExt(mem_ptr_t<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, mem_ptr_t<CellAtracExtRes> pExtRes)
+int cellAtracCreateDecoderExt(vm::ptr<CellAtracHandle> pHandle, u32 pucWorkMem_addr, u32 uiPpuThreadPriority, vm::ptr<CellAtracExtRes> pExtRes)
 {
 	cellAtrac->Todo("cellAtracCreateDecoderExt(pHandle=0x%x, pucWorkMem_addr=0x%x, uiPpuThreadPriority=%d, pExtRes_addr=0x%x)",
-		pHandle.GetAddr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.GetAddr());
+		pHandle.addr(), pucWorkMem_addr, uiPpuThreadPriority, pExtRes.addr());
 
 	pHandle->data.pucWorkMem_addr = pucWorkMem_addr;
 	return CELL_OK;
 }
 
-int cellAtracDeleteDecoder(mem_ptr_t<CellAtracHandle> pHandle)
+int cellAtracDeleteDecoder(vm::ptr<CellAtracHandle> pHandle)
 {
-	cellAtrac->Todo("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.GetAddr());
+	cellAtrac->Todo("cellAtracDeleteDecoder(pHandle=0x%x)", pHandle.addr());
 	return CELL_OK;
 }
 
-int cellAtracDecode(mem_ptr_t<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<be_t<u32>> puiSamples, vm::ptr<be_t<u32>> puiFinishflag, vm::ptr<be_t<u32>> piRemainFrame)
+int cellAtracDecode(vm::ptr<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<be_t<u32>> puiSamples, vm::ptr<be_t<u32>> puiFinishflag, vm::ptr<be_t<u32>> piRemainFrame)
 {
 	cellAtrac->Todo("cellAtracDecode(pHandle=0x%x, pfOutAddr=0x%x, puiSamples_addr=0x%x, puiFinishFlag_addr=0x%x, piRemainFrame_addr=0x%x)",
-		pHandle.GetAddr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
+		pHandle.addr(), pfOutAddr, puiSamples.addr(), puiFinishflag.addr(), piRemainFrame.addr());
 
 	*puiSamples = 0;
 	*puiFinishflag = 1;
@@ -50,10 +50,10 @@ int cellAtracDecode(mem_ptr_t<CellAtracHandle> pHandle, u32 pfOutAddr, vm::ptr<b
 	return CELL_OK;
 }
 
-int cellAtracGetStreamDataInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> ppucWritePointer, vm::ptr<be_t<u32>> puiWritableByte, vm::ptr<be_t<u32>> puiReadPosition)
+int cellAtracGetStreamDataInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> ppucWritePointer, vm::ptr<be_t<u32>> puiWritableByte, vm::ptr<be_t<u32>> puiReadPosition)
 {
 	cellAtrac->Todo("cellAtracGetStreamDataInfo(pHandle=0x%x, ppucWritePointer_addr=0x%x, puiWritableByte_addr=0x%x, puiReadPosition_addr=0x%x)",
-		pHandle.GetAddr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
+		pHandle.addr(), ppucWritePointer.addr(), puiWritableByte.addr(), puiReadPosition.addr());
 
 	*ppucWritePointer = pHandle->data.pucWorkMem_addr;
 	*puiWritableByte = 0x1000;
@@ -61,79 +61,79 @@ int cellAtracGetStreamDataInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<
 	return CELL_OK;
 }
 
-int cellAtracAddStreamData(mem_ptr_t<CellAtracHandle> pHandle, u32 uiAddByte)
+int cellAtracAddStreamData(vm::ptr<CellAtracHandle> pHandle, u32 uiAddByte)
 {
-	cellAtrac->Todo("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.GetAddr(), uiAddByte);
+	cellAtrac->Todo("cellAtracAddStreamData(pHandle=0x%x, uiAddByte=0x%x)", pHandle.addr(), uiAddByte);
 	return CELL_OK;
 }
 
-int cellAtracGetRemainFrame(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piRemainFrame)
+int cellAtracGetRemainFrame(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piRemainFrame)
 {
-	cellAtrac->Todo("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.GetAddr(), piRemainFrame.addr());
+	cellAtrac->Todo("cellAtracGetRemainFrame(pHandle=0x%x, piRemainFrame_addr=0x%x)", pHandle.addr(), piRemainFrame.addr());
 
 	*piRemainFrame = CELL_ATRAC_ALLDATA_IS_ON_MEMORY;
 	return CELL_OK;
 }
 
-int cellAtracGetVacantSize(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiVacantSize)
+int cellAtracGetVacantSize(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiVacantSize)
 {
-	cellAtrac->Todo("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.GetAddr(), puiVacantSize.addr());
+	cellAtrac->Todo("cellAtracGetVacantSize(pHandle=0x%x, puiVacantSize_addr=0x%x)", pHandle.addr(), puiVacantSize.addr());
 
 	*puiVacantSize = 0x1000;
 	return CELL_OK;
 }
 
-int cellAtracIsSecondBufferNeeded(mem_ptr_t<CellAtracHandle> pHandle)
+int cellAtracIsSecondBufferNeeded(vm::ptr<CellAtracHandle> pHandle)
 {
-	cellAtrac->Todo("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.GetAddr());
+	cellAtrac->Todo("cellAtracIsSecondBufferNeeded(pHandle=0x%x)", pHandle.addr());
 	return CELL_OK;
 }
 
-int cellAtracGetSecondBufferInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiReadPosition, vm::ptr<be_t<u32>> puiDataByte)
+int cellAtracGetSecondBufferInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiReadPosition, vm::ptr<be_t<u32>> puiDataByte)
 {
 	cellAtrac->Todo("cellAtracGetSecondBufferInfo(pHandle=0x%x, puiReadPosition_addr=0x%x, puiDataByte_addr=0x%x)",
-		pHandle.GetAddr(), puiReadPosition.addr(), puiDataByte.addr());
+		pHandle.addr(), puiReadPosition.addr(), puiDataByte.addr());
 
 	*puiReadPosition = 0;
 	*puiDataByte = 0; // write to null block will occur
 	return CELL_OK;
 }
 
-int cellAtracSetSecondBuffer(mem_ptr_t<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte)
+int cellAtracSetSecondBuffer(vm::ptr<CellAtracHandle> pHandle, u32 pucSecondBufferAddr, u32 uiSecondBufferByte)
 {
 	cellAtrac->Todo("cellAtracSetSecondBuffer(pHandle=0x%x, pucSecondBufferAddr=0x%x, uiSecondBufferByte=0x%x)",
-		pHandle.GetAddr(), pucSecondBufferAddr, uiSecondBufferByte);
+		pHandle.addr(), pucSecondBufferAddr, uiSecondBufferByte);
 	return CELL_OK;
 }
 
-int cellAtracGetChannel(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiChannel)
+int cellAtracGetChannel(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiChannel)
 {
-	cellAtrac->Todo("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.GetAddr(), puiChannel.addr());
+	cellAtrac->Todo("cellAtracGetChannel(pHandle=0x%x, puiChannel_addr=0x%x)", pHandle.addr(), puiChannel.addr());
 
 	*puiChannel = 2;
 	return CELL_OK;
 }
 
-int cellAtracGetMaxSample(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiMaxSample)
+int cellAtracGetMaxSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiMaxSample)
 {
-	cellAtrac->Todo("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.GetAddr(), puiMaxSample.addr());
+	cellAtrac->Todo("cellAtracGetMaxSample(pHandle=0x%x, puiMaxSample_addr=0x%x)", pHandle.addr(), puiMaxSample.addr());
 
 	*puiMaxSample = 512;
 	return CELL_OK;
 }
 
-int cellAtracGetNextSample(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiNextSample)
+int cellAtracGetNextSample(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiNextSample)
 {
-	cellAtrac->Todo("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.GetAddr(), puiNextSample.addr());
+	cellAtrac->Todo("cellAtracGetNextSample(pHandle=0x%x, puiNextSample_addr=0x%x)", pHandle.addr(), puiNextSample.addr());
 
 	*puiNextSample = 0;
 	return CELL_OK;
 }
 
-int cellAtracGetSoundInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piEndSample, vm::ptr<be_t<u32>> piLoopStartSample, vm::ptr<be_t<u32>> piLoopEndSample)
+int cellAtracGetSoundInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piEndSample, vm::ptr<be_t<u32>> piLoopStartSample, vm::ptr<be_t<u32>> piLoopEndSample)
 {
 	cellAtrac->Todo("cellAtracGetSoundInfo(pHandle=0x%x, piEndSample_addr=0x%x, piLoopStartSample_addr=0x%x, piLoopEndSample_addr=0x%x)",
-		pHandle.GetAddr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
+		pHandle.addr(), piEndSample.addr(), piLoopStartSample.addr(), piLoopEndSample.addr());
 
 	*piEndSample = 0;
 	*piLoopStartSample = 0;
@@ -141,44 +141,44 @@ int cellAtracGetSoundInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>>
 	return CELL_OK;
 }
 
-int cellAtracGetNextDecodePosition(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiSamplePosition)
+int cellAtracGetNextDecodePosition(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiSamplePosition)
 {
 	cellAtrac->Todo("cellAtracGetNextDecodePosition(pHandle=0x%x, puiSamplePosition_addr=0x%x)",
-		pHandle.GetAddr(), puiSamplePosition.addr());
+		pHandle.addr(), puiSamplePosition.addr());
 
 	*puiSamplePosition = 0;
 	return CELL_ATRAC_ERROR_ALLDATA_WAS_DECODED;
 }
 
-int cellAtracGetBitrate(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiBitrate)
+int cellAtracGetBitrate(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> puiBitrate)
 {
 	cellAtrac->Todo("cellAtracGetBitrate(pHandle=0x%x, puiBitrate_addr=0x%x)",
-		pHandle.GetAddr(), puiBitrate.addr());
+		pHandle.addr(), puiBitrate.addr());
 
 	*puiBitrate = 128;
 	return CELL_OK;
 }
 
-int cellAtracGetLoopInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piLoopNum, vm::ptr<be_t<u32>> puiLoopStatus)
+int cellAtracGetLoopInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piLoopNum, vm::ptr<be_t<u32>> puiLoopStatus)
 {
 	cellAtrac->Todo("cellAtracGetLoopInfo(pHandle=0x%x, piLoopNum_addr=0x%x, puiLoopStatus_addr=0x%x)",
-		pHandle.GetAddr(), piLoopNum.addr(), puiLoopStatus.addr());
+		pHandle.addr(), piLoopNum.addr(), puiLoopStatus.addr());
 
 	*piLoopNum = 0;
 	*puiLoopStatus = 0;
 	return CELL_OK;
 }
 
-int cellAtracSetLoopNum(mem_ptr_t<CellAtracHandle> pHandle, int iLoopNum)
+int cellAtracSetLoopNum(vm::ptr<CellAtracHandle> pHandle, int iLoopNum)
 {
-	cellAtrac->Todo("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.GetAddr(), iLoopNum);
+	cellAtrac->Todo("cellAtracSetLoopNum(pHandle=0x%x, iLoopNum=0x%x)", pHandle.addr(), iLoopNum);
 	return CELL_OK;
 }
 
-int cellAtracGetBufferInfoForResetting(mem_ptr_t<CellAtracHandle> pHandle, u32 uiSample, mem_ptr_t<CellAtracBufferInfo> pBufferInfo)
+int cellAtracGetBufferInfoForResetting(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, vm::ptr<CellAtracBufferInfo> pBufferInfo)
 {
 	cellAtrac->Todo("cellAtracGetBufferInfoForResetting(pHandle=0x%x, uiSample=0x%x, pBufferInfo_addr=0x%x)",
-		pHandle.GetAddr(), uiSample, pBufferInfo.GetAddr());
+		pHandle.addr(), uiSample, pBufferInfo.addr());
 
 	pBufferInfo->pucWriteAddr = pHandle->data.pucWorkMem_addr;
 	pBufferInfo->uiWritableByte = 0x1000;
@@ -187,17 +187,17 @@ int cellAtracGetBufferInfoForResetting(mem_ptr_t<CellAtracHandle> pHandle, u32 u
 	return CELL_OK;
 }
 
-int cellAtracResetPlayPosition(mem_ptr_t<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
+int cellAtracResetPlayPosition(vm::ptr<CellAtracHandle> pHandle, u32 uiSample, u32 uiWriteByte)
 {
 	cellAtrac->Todo("cellAtracResetPlayPosition(pHandle=0x%x, uiSample=0x%x, uiWriteByte=0x%x)",
-		pHandle.GetAddr(), uiSample, uiWriteByte);
+		pHandle.addr(), uiSample, uiWriteByte);
 	return CELL_OK;
 }
 
-int cellAtracGetInternalErrorInfo(mem_ptr_t<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piResult)
+int cellAtracGetInternalErrorInfo(vm::ptr<CellAtracHandle> pHandle, vm::ptr<be_t<u32>> piResult)
 {
 	cellAtrac->Todo("cellAtracGetInternalErrorInfo(pHandle=0x%x, piResult_addr=0x%x)",
-		pHandle.GetAddr(), piResult.addr());
+		pHandle.addr(), piResult.addr());
 
 	*piResult = 0;
 	return CELL_OK;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
index 5bc9dd349f..2f873ea426 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellAudio.cpp
@@ -507,9 +507,9 @@ int cellAudioQuit()
 	return CELL_OK;
 }
 
-int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, vm::ptr<be_t<u32>> portNum)
+int cellAudioPortOpen(vm::ptr<CellAudioPortParam> audioParam, vm::ptr<be_t<u32>> portNum)
 {
-	cellAudio->Warning("cellAudioPortOpen(audioParam_addr=0x%x, portNum_addr=0x%x)", audioParam.GetAddr(), portNum.addr());
+	cellAudio->Warning("cellAudioPortOpen(audioParam_addr=0x%x, portNum_addr=0x%x)", audioParam.addr(), portNum.addr());
 
 	if (audioParam->nChannel > 8 || audioParam->nBlock > 16)
 	{
@@ -555,9 +555,9 @@ int cellAudioPortOpen(mem_ptr_t<CellAudioPortParam> audioParam, vm::ptr<be_t<u32
 	return CELL_AUDIO_ERROR_PORT_FULL;
 }
 
-int cellAudioGetPortConfig(u32 portNum, mem_ptr_t<CellAudioPortConfig> portConfig)
+int cellAudioGetPortConfig(u32 portNum, vm::ptr<CellAudioPortConfig> portConfig)
 {
-	cellAudio->Warning("cellAudioGetPortConfig(portNum=0x%x, portConfig_addr=0x%x)", portNum, portConfig.GetAddr());
+	cellAudio->Warning("cellAudioGetPortConfig(portNum=0x%x, portConfig_addr=0x%x)", portNum, portConfig.addr());
 
 	if (portNum >= m_config.AUDIO_PORT_COUNT) 
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
index 1e8c5a5f78..46761b0dc5 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellDmux.cpp
@@ -114,7 +114,7 @@ bool ElementaryStream::isfull()
 	return is_full();
 }
 
-void ElementaryStream::finish(DemuxerStream& stream) // not multithread-safe
+void ElementaryStream::finish(DemuxerStream& stream) // not multithread-safe (or safe?)
 {
 	u32 addr;
 	{
@@ -122,16 +122,8 @@ void ElementaryStream::finish(DemuxerStream& stream) // not multithread-safe
 		//if (fidMajor != 0xbd) LOG_NOTICE(HLE, ">>> es::finish(): peek=0x%x, first=0x%x, put=0x%x, size=0x%x", peek, first, put, size);
 
 		addr = put;
-		/*if (!first)
-		{
-		first = put;
-		}
-		if (!peek)
-		{
-		peek = put;
-		}*/
 
-		mem_ptr_t<CellDmuxAuInfo> info(put);
+		auto info = vm::ptr<CellDmuxAuInfo>::make(put);
 		//if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::finish(): (%s) size = 0x%x, info_addr=0x%x, pts = 0x%x",
 		//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(),
 		//(u32)info->auSize, put, (u32)info->ptsLower);
@@ -167,7 +159,7 @@ void ElementaryStream::push(DemuxerStream& stream, u32 sz, PesHeader& pes)
 	memcpy(Memory + data_addr, Memory + stream.addr, sz);
 	stream.skip(sz);
 
-	mem_ptr_t<CellDmuxAuInfoEx> info(put);
+	auto info = vm::ptr<CellDmuxAuInfoEx>::make(put);
 	info->auAddr = put + 128;
 	info->auSize = size;
 	if (pes.new_au)
@@ -181,10 +173,10 @@ void ElementaryStream::push(DemuxerStream& stream, u32 sz, PesHeader& pes)
 		info->userData = stream.userdata;
 	}
 
-	mem_ptr_t<CellDmuxPamfAuSpecificInfoAvc> tail(put + sizeof(CellDmuxAuInfoEx));
+	auto tail = vm::ptr<CellDmuxPamfAuSpecificInfoAvc>::make(put + sizeof(CellDmuxAuInfoEx));
 	tail->reserved1 = 0;
 
-	mem_ptr_t<CellDmuxAuInfo> inf(put + 64);
+	auto inf = vm::ptr<CellDmuxAuInfo>::make(put + 64);
 	inf->auAddr = put + 128;
 	inf->auSize = size;
 	if (pes.new_au)
@@ -210,7 +202,7 @@ bool ElementaryStream::release()
 
 	u32 addr = entries.Peek();
 
-	mem_ptr_t<CellDmuxAuInfo> info(addr);
+	auto info = vm::ptr<CellDmuxAuInfo>::make(addr);
 	//if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::release(): (%s) size = 0x%x, info = 0x%x, pts = 0x%x",
 	//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, first, (u32)info->ptsLower);
 
@@ -220,21 +212,6 @@ bool ElementaryStream::release()
 		return false;
 	}
 
-	/*u32 new_addr = a128(info.GetAddr() + 128 + info->auSize);
-
-	if (new_addr == put)
-	{
-	first = 0;
-	}
-	else if ((new_addr + GetMaxAU()) > (memAddr + memSize))
-	{
-	first = memAddr;
-	}
-	else
-	{
-	first = new_addr;
-	}*/
-
 	released++;
 	if (!entries.Pop(addr))
 	{
@@ -260,7 +237,7 @@ bool ElementaryStream::peek(u32& out_data, bool no_ex, u32& out_spec, bool updat
 	}
 
 	u32 addr = entries.Peek(peek_count - released);
-	mem_ptr_t<CellDmuxAuInfo> info(addr);
+	auto info = vm::ptr<CellDmuxAuInfo>::make(addr);
 	//if (fidMajor != 0xbd) LOG_WARNING(HLE, "es::peek(%sAu(Ex)): (%s) size = 0x%x, info = 0x%x, pts = 0x%x",
 	//wxString(update_index ? "Get" : "Peek").wx_str(),
 	//wxString(fidMajor == 0xbd ? "ATRAC3P Audio" : "Video AVC").wx_str(), (u32)info->auSize, peek, (u32)info->ptsLower);
@@ -271,19 +248,6 @@ bool ElementaryStream::peek(u32& out_data, bool no_ex, u32& out_spec, bool updat
 
 	if (update_index)
 	{
-		/*u32 new_addr = a128(peek + 128 + info->auSize);
-		if (new_addr == put)
-		{
-		peek = 0;
-		}
-		else if ((new_addr + GetMaxAU()) > (memAddr + memSize))
-		{
-		peek = memAddr;
-		}
-		else
-		{
-		peek = new_addr;
-		}*/
 		peek_count++;
 	}
 
@@ -305,15 +269,15 @@ void ElementaryStream::reset()
 	peek_count = 0;
 }
 
-void dmuxQueryAttr(u32 info_addr /* may be 0 */, mem_ptr_t<CellDmuxAttr> attr)
+void dmuxQueryAttr(u32 info_addr /* may be 0 */, vm::ptr<CellDmuxAttr> attr)
 {
 	attr->demuxerVerLower = 0x280000; // TODO: check values
 	attr->demuxerVerUpper = 0x260000;
 	attr->memSize = 0x10000; // 0x3e8e6 from ps3
 }
 
-void dmuxQueryEsAttr(u32 info_addr /* may be 0 */, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
-					 const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> attr)
+void dmuxQueryEsAttr(u32 info_addr /* may be 0 */, const vm::ptr<CellCodecEsFilterId> esFilterId,
+					 const u32 esSpecificInfo_addr, vm::ptr<CellDmuxEsAttr> attr)
 {
 	if (esFilterId->filterIdMajor >= 0xe0)
 		attr->memSize = 0x500000; // 0x45fa49 from ps3
@@ -373,14 +337,14 @@ u32 dmuxOpen(Demuxer* data)
 				{
 					dmux.is_running = false;
 					// demuxing finished
-					mem_ptr_t<CellDmuxMsg> dmuxMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+					auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
 					dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
 					dmuxMsg->supplementalInfo = stream.userdata;
 					/*Callback cb;
 					cb.SetAddr(dmux.cbFunc);
-					cb.Handle(dmux.id, dmuxMsg.GetAddr(), dmux.cbArg);
+					cb.Handle(dmux.id, dmuxMsg.addr(), dmux.cbArg);
 					cb.Branch(task.type == dmuxResetStreamAndWaitDone);*/
-					dmux.dmuxCb->ExecAsCallback(dmux.cbFunc, true, dmux.id, dmuxMsg.GetAddr(), dmux.cbArg);
+					dmux.dmuxCb->ExecAsCallback(dmux.cbFunc, true, dmux.id, dmuxMsg.addr(), dmux.cbArg);
 					updates_signaled++;
 				}
 				else switch (code.ToLE())
@@ -457,14 +421,14 @@ u32 dmuxOpen(Demuxer* data)
 							es.finish(stream);
 							//LOG_NOTICE(HLE, "*** AT3+ AU sent (len=0x%x, pts=0x%llx)", len - pes.size - 3, pes.pts);
 							
-							mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+							auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
 							esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
 							esMsg->supplementalInfo = stream.userdata;
 							/*Callback cb;
 							cb.SetAddr(es.cbFunc);
-							cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+							cb.Handle(dmux.id, es.id, esMsg.addr(), es.cbArg);
 							cb.Branch(false);*/
-							dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+							dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.addr(), es.cbArg);
 						}
 						else
 						{
@@ -510,14 +474,14 @@ u32 dmuxOpen(Demuxer* data)
 								}*/
 								es.finish(stream);
 								// callback
-								mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+								auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
 								esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
 								esMsg->supplementalInfo = stream.userdata;
 								/*Callback cb;
 								cb.SetAddr(es.cbFunc);
-								cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+								cb.Handle(dmux.id, es.id, esMsg.addr(), es.cbArg);
 								cb.Branch(false);*/
-								dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+								dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.addr(), es.cbArg);
 							}
 
 							if (pes.new_au)
@@ -622,15 +586,15 @@ u32 dmuxOpen(Demuxer* data)
 			case dmuxResetStream:
 			case dmuxResetStreamAndWaitDone:
 				{
-					mem_ptr_t<CellDmuxMsg> dmuxMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+					auto dmuxMsg = vm::ptr<CellDmuxMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
 					dmuxMsg->msgType = CELL_DMUX_MSG_TYPE_DEMUX_DONE;
 					dmuxMsg->supplementalInfo = stream.userdata;
 					/*Callback cb;
 					cb.SetAddr(dmux.cbFunc);
-					cb.Handle(dmux.id, dmuxMsg.GetAddr(), dmux.cbArg);
+					cb.Handle(dmux.id, dmuxMsg.addr(), dmux.cbArg);
 					cb.Branch(task.type == dmuxResetStreamAndWaitDone);*/
 					dmux.dmuxCb->ExecAsCallback(dmux.cbFunc, task.type == dmuxResetStreamAndWaitDone,
-						dmux.id, dmuxMsg.GetAddr(), dmux.cbArg);
+						dmux.id, dmuxMsg.addr(), dmux.cbArg);
 
 					updates_signaled++;
 					dmux.is_running = false;
@@ -708,25 +672,25 @@ u32 dmuxOpen(Demuxer* data)
 					{
 						es.finish(stream);
 						// callback
-						mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+						auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
 						esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_AU_FOUND;
 						esMsg->supplementalInfo = stream.userdata;
 						/*Callback cb;
 						cb.SetAddr(es.cbFunc);
-						cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+						cb.Handle(dmux.id, es.id, esMsg.addr(), es.cbArg);
 						cb.Branch(false);*/
-						dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+						dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.addr(), es.cbArg);
 					}
 
 					// callback
-					mem_ptr_t<CellDmuxEsMsg> esMsg(a128(dmux.memAddr) + (cb_add ^= 16));
+					auto esMsg = vm::ptr<CellDmuxEsMsg>::make(a128(dmux.memAddr) + (cb_add ^= 16));
 					esMsg->msgType = CELL_DMUX_ES_MSG_TYPE_FLUSH_DONE;
 					esMsg->supplementalInfo = stream.userdata;
 					/*Callback cb;
 					cb.SetAddr(es.cbFunc);
-					cb.Handle(dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+					cb.Handle(dmux.id, es.id, esMsg.addr(), es.cbArg);
 					cb.Branch(false);*/
-					dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.GetAddr(), es.cbArg);
+					dmux.dmuxCb->ExecAsCallback(es.cbFunc, false, dmux.id, es.id, esMsg.addr(), es.cbArg);
 				}
 				break;
 
@@ -749,9 +713,9 @@ u32 dmuxOpen(Demuxer* data)
 	return dmux_id;
 }
 
-int cellDmuxQueryAttr(const mem_ptr_t<CellDmuxType> demuxerType, mem_ptr_t<CellDmuxAttr> demuxerAttr)
+int cellDmuxQueryAttr(const vm::ptr<CellDmuxType> demuxerType, vm::ptr<CellDmuxAttr> demuxerAttr)
 {
-	cellDmux->Warning("cellDmuxQueryAttr(demuxerType_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType.GetAddr(), demuxerAttr.GetAddr());
+	cellDmux->Warning("cellDmuxQueryAttr(demuxerType_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType.addr(), demuxerAttr.addr());
 
 	if (demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -762,9 +726,9 @@ int cellDmuxQueryAttr(const mem_ptr_t<CellDmuxType> demuxerType, mem_ptr_t<CellD
 	return CELL_OK;
 }
 
-int cellDmuxQueryAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, mem_ptr_t<CellDmuxAttr> demuxerAttr)
+int cellDmuxQueryAttr2(const vm::ptr<CellDmuxType2> demuxerType2, vm::ptr<CellDmuxAttr> demuxerAttr)
 {
-	cellDmux->Warning("cellDmuxQueryAttr2(demuxerType2_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType2.GetAddr(), demuxerAttr.GetAddr());
+	cellDmux->Warning("cellDmuxQueryAttr2(demuxerType2_addr=0x%x, demuxerAttr_addr=0x%x)", demuxerType2.addr(), demuxerAttr.addr());
 
 	if (demuxerType2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -775,11 +739,11 @@ int cellDmuxQueryAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, mem_ptr_t<Ce
 	return CELL_OK;
 }
 
-int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResource> demuxerResource, 
-	const mem_ptr_t<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
+int cellDmuxOpen(const vm::ptr<CellDmuxType> demuxerType, const vm::ptr<CellDmuxResource> demuxerResource, 
+	const vm::ptr<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
 {
 	cellDmux->Warning("cellDmuxOpen(demuxerType_addr=0x%x, demuxerResource_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
-		demuxerType.GetAddr(), demuxerResource.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.addr());
+		demuxerType.addr(), demuxerResource.addr(), demuxerCb.addr(), demuxerHandle.addr());
 
 	if (demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -793,11 +757,11 @@ int cellDmuxOpen(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Cell
 	return CELL_OK;
 }
 
-int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellDmuxResourceEx> demuxerResourceEx, 
-	const mem_ptr_t<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
+int cellDmuxOpenEx(const vm::ptr<CellDmuxType> demuxerType, const vm::ptr<CellDmuxResourceEx> demuxerResourceEx, 
+	const vm::ptr<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
 {
 	cellDmux->Warning("cellDmuxOpenEx(demuxerType_addr=0x%x, demuxerResourceEx_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
-		demuxerType.GetAddr(), demuxerResourceEx.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.addr());
+		demuxerType.addr(), demuxerResourceEx.addr(), demuxerCb.addr(), demuxerHandle.addr());
 
 	if (demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -811,11 +775,11 @@ int cellDmuxOpenEx(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<Ce
 	return CELL_OK;
 }
 
-int cellDmuxOpen2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<CellDmuxResource2> demuxerResource2, 
-	const mem_ptr_t<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
+int cellDmuxOpen2(const vm::ptr<CellDmuxType2> demuxerType2, const vm::ptr<CellDmuxResource2> demuxerResource2, 
+	const vm::ptr<CellDmuxCb> demuxerCb, vm::ptr<be_t<u32>> demuxerHandle)
 {
 	cellDmux->Warning("cellDmuxOpen2(demuxerType2_addr=0x%x, demuxerResource2_addr=0x%x, demuxerCb_addr=0x%x, demuxerHandle_addr=0x%x)",
-		demuxerType2.GetAddr(), demuxerResource2.GetAddr(), demuxerCb.GetAddr(), demuxerHandle.addr());
+		demuxerType2.addr(), demuxerResource2.addr(), demuxerCb.addr(), demuxerHandle.addr());
 
 	if (demuxerType2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -943,11 +907,11 @@ int cellDmuxResetStreamAndWaitDone(u32 demuxerHandle)
 	return CELL_OK;
 }
 
-int cellDmuxQueryEsAttr(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
-						const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> esAttr)
+int cellDmuxQueryEsAttr(const vm::ptr<CellDmuxType> demuxerType, const vm::ptr<CellCodecEsFilterId> esFilterId,
+						const u32 esSpecificInfo_addr, vm::ptr<CellDmuxEsAttr> esAttr)
 {
 	cellDmux->Warning("cellDmuxQueryEsAttr(demuxerType_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
-		demuxerType.GetAddr(), esFilterId.GetAddr(), esSpecificInfo_addr, esAttr.GetAddr());
+		demuxerType.addr(), esFilterId.addr(), esSpecificInfo_addr, esAttr.addr());
 
 	if (demuxerType->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -960,11 +924,11 @@ int cellDmuxQueryEsAttr(const mem_ptr_t<CellDmuxType> demuxerType, const mem_ptr
 	return CELL_OK;
 }
 
-int cellDmuxQueryEsAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_ptr_t<CellCodecEsFilterId> esFilterId,
-						 const u32 esSpecificInfo_addr, mem_ptr_t<CellDmuxEsAttr> esAttr)
+int cellDmuxQueryEsAttr2(const vm::ptr<CellDmuxType2> demuxerType2, const vm::ptr<CellCodecEsFilterId> esFilterId,
+						 const u32 esSpecificInfo_addr, vm::ptr<CellDmuxEsAttr> esAttr)
 {
 	cellDmux->Warning("cellDmuxQueryEsAttr2(demuxerType2_addr=0x%x, esFilterId_addr=0x%x, esSpecificInfo_addr=0x%x, esAttr_addr=0x%x)",
-		demuxerType2.GetAddr(), esFilterId.GetAddr(), esSpecificInfo_addr, esAttr.GetAddr());
+		demuxerType2.addr(), esFilterId.addr(), esSpecificInfo_addr, esAttr.addr());
 
 	if (demuxerType2->streamType != CELL_DMUX_STREAM_TYPE_PAMF)
 	{
@@ -977,13 +941,13 @@ int cellDmuxQueryEsAttr2(const mem_ptr_t<CellDmuxType2> demuxerType2, const mem_
 	return CELL_OK;
 }
 
-int cellDmuxEnableEs(u32 demuxerHandle, const mem_ptr_t<CellCodecEsFilterId> esFilterId, 
-					 const mem_ptr_t<CellDmuxEsResource> esResourceInfo, const mem_ptr_t<CellDmuxEsCb> esCb,
+int cellDmuxEnableEs(u32 demuxerHandle, const vm::ptr<CellCodecEsFilterId> esFilterId, 
+					 const vm::ptr<CellDmuxEsResource> esResourceInfo, const vm::ptr<CellDmuxEsCb> esCb,
 					 const u32 esSpecificInfo_addr, vm::ptr<be_t<u32>> esHandle)
 {
 	cellDmux->Warning("cellDmuxEnableEs(demuxerHandle=%d, esFilterId_addr=0x%x, esResourceInfo_addr=0x%x, esCb_addr=0x%x, "
-		"esSpecificInfo_addr=0x%x, esHandle_addr=0x%x)", demuxerHandle, esFilterId.GetAddr(), esResourceInfo.GetAddr(),
-		esCb.GetAddr(), esSpecificInfo_addr, esHandle.addr());
+		"esSpecificInfo_addr=0x%x, esHandle_addr=0x%x)", demuxerHandle, esFilterId.addr(), esResourceInfo.addr(),
+		esCb.addr(), esSpecificInfo_addr, esHandle.addr());
 
 	Demuxer* dmux;
 	if (!Emu.GetIdManager().GetIDData(demuxerHandle, dmux))
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFiber.cpp b/rpcs3/Emu/SysCalls/Modules/cellFiber.cpp
index 7a5dec9d14..c52891d005 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFiber.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFiber.cpp
@@ -81,12 +81,12 @@ int cellFiberPpuJoinFiber()
 	return CELL_OK;
 }
 
-u32 cellFiberPpuSelf()
+vm::ptr<void> cellFiberPpuSelf()
 {
 	cellFiber->Log("cellFiberPpuSelf() -> nullptr"); // TODO
 
 	// returns fiber structure (zero for simple PPU thread)
-	return 0;
+	return vm::ptr<void>::make(0);
 }
 
 int cellFiberPpuSendSignal()
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
index b4b6510801..5d4d9aac44 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFont.cpp
@@ -15,9 +15,9 @@ Module *cellFont = nullptr;
 CCellFontInternal* s_fontInternalInstance = nullptr;
 
 // Functions
-int cellFontInitializeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontConfig> config)
+int cellFontInitializeWithRevision(u64 revisionFlags, vm::ptr<CellFontConfig> config)
 {
-	cellFont->Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.GetAddr());
+	cellFont->Warning("cellFontInitializeWithRevision(revisionFlags=0x%llx, config=0x%x)", revisionFlags, config.addr());
 	
 	if (s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_ALREADY_INITIALIZED;
@@ -40,14 +40,14 @@ int cellFontGetRevisionFlags(vm::ptr<be_t<u64>> revisionFlags)
 	return CELL_FONT_OK;
 }
 
-int cellFontInit(mem_ptr_t<CellFontConfig> config)
+int cellFontInit(vm::ptr<CellFontConfig> config)
 {
-	cellFont->Log("cellFontInit(config=0x%x)", config.GetAddr());
+	cellFont->Log("cellFontInit(config=0x%x)", config.addr());
 
 	vm::var<be_t<u64>> revisionFlags;
 	revisionFlags.value() = 0;
 	cellFontGetRevisionFlags(revisionFlags);
-	return cellFontInitializeWithRevision(revisionFlags.value(), config.GetAddr());
+	return cellFontInitializeWithRevision(revisionFlags.value(), config);
 }
 
 int cellFontEnd()
@@ -68,10 +68,10 @@ s32 cellFontSetFontsetOpenMode(u32 openMode)
 	return CELL_FONT_OK;
 }
 
-int cellFontOpenFontMemory(mem_ptr_t<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, mem_ptr_t<CellFont> font)
+int cellFontOpenFontMemory(vm::ptr<CellFontLibrary> library, u32 fontAddr, u32 fontSize, u32 subNum, u32 uniqueId, vm::ptr<CellFont> font)
 {
 	cellFont->Warning("cellFontOpenFontMemory(library_addr=0x%x, fontAddr=0x%x, fontSize=%d, subNum=%d, uniqueId=%d, font_addr=0x%x)",
-		library.GetAddr(), fontAddr, fontSize, subNum, uniqueId, font.GetAddr());
+		library.addr(), fontAddr, fontSize, subNum, uniqueId, font.addr());
 
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
@@ -87,11 +87,11 @@ int cellFontOpenFontMemory(mem_ptr_t<CellFontLibrary> library, u32 fontAddr, u32
 	return CELL_FONT_OK;
 }
 
-int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, vm::ptr<const char> fontPath, u32 subNum, s32 uniqueId, mem_ptr_t<CellFont> font)
+int cellFontOpenFontFile(vm::ptr<CellFontLibrary> library, vm::ptr<const char> fontPath, u32 subNum, s32 uniqueId, vm::ptr<CellFont> font)
 {
 	std::string fp(fontPath.get_ptr());
 	cellFont->Warning("cellFontOpenFontFile(library_addr=0x%x, fontPath=\"%s\", subNum=%d, uniqueId=%d, font_addr=0x%x)",
-		library.GetAddr(), fp.c_str(), subNum, uniqueId, font.GetAddr());
+		library.addr(), fp.c_str(), subNum, uniqueId, font.addr());
 
 	vfsFile f(fp);
 	if (!f.IsOpened())
@@ -100,15 +100,15 @@ int cellFontOpenFontFile(mem_ptr_t<CellFontLibrary> library, vm::ptr<const char>
 	u32 fileSize = (u32)f.GetSize();
 	u32 bufferAddr = (u32)Memory.Alloc(fileSize, 1); // Freed in cellFontCloseFont
 	f.Read(Memory.VirtualToRealAddr(bufferAddr), fileSize);
-	int ret = cellFontOpenFontMemory(library.GetAddr(), bufferAddr, fileSize, subNum, uniqueId, font.GetAddr());
+	int ret = cellFontOpenFontMemory(library, bufferAddr, fileSize, subNum, uniqueId, font);
 	font->origin = CELL_FONT_OPEN_FONT_FILE;
 	return ret;
 }
 
-int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontType> fontType, mem_ptr_t<CellFont> font)
+int cellFontOpenFontset(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontType> fontType, vm::ptr<CellFont> font)
 {
 	cellFont->Log("cellFontOpenFontset(library_addr=0x%x, fontType_addr=0x%x, font_addr=0x%x)",
-		library.GetAddr(), fontType.GetAddr(), font.GetAddr());
+		library.addr(), fontType.addr(), font.addr());
 
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
@@ -183,14 +183,14 @@ int cellFontOpenFontset(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontTy
 
 	vm::var<const char> f((u32)file.length() + 1, 1);
 	Memory.WriteString(f.addr(), file);
-	int ret = cellFontOpenFontFile(library.GetAddr(), f, 0, 0, font.GetAddr()); //TODO: Find the correct values of subNum, uniqueId
+	int ret = cellFontOpenFontFile(library, f, 0, 0, font); //TODO: Find the correct values of subNum, uniqueId
 	font->origin = CELL_FONT_OPEN_FONTSET;
 	return ret;
 }
 
-int cellFontOpenFontInstance(mem_ptr_t<CellFont> openedFont, mem_ptr_t<CellFont> font)
+int cellFontOpenFontInstance(vm::ptr<CellFont> openedFont, vm::ptr<CellFont> font)
 {
-	cellFont->Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.GetAddr(), font.GetAddr());
+	cellFont->Warning("cellFontOpenFontInstance(openedFont=0x%x, font=0x%x)", openedFont.addr(), font.addr());
 
 	font->renderer_addr = openedFont->renderer_addr;
 	font->scale_x = openedFont->scale_x;
@@ -209,10 +209,10 @@ s32 cellFontSetFontOpenMode(u32 openMode)
 	return CELL_FONT_OK;
 }
 
-int cellFontCreateRenderer(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFontRendererConfig> config, mem_ptr_t<CellFontRenderer> Renderer)
+int cellFontCreateRenderer(vm::ptr<CellFontLibrary> library, vm::ptr<CellFontRendererConfig> config, vm::ptr<CellFontRenderer> Renderer)
 {
 	cellFont->Warning("cellFontCreateRenderer(library_addr=0x%x, config_addr=0x%x, Renderer_addr=0x%x)",
-		library.GetAddr(), config.GetAddr(), Renderer.GetAddr());
+		library.addr(), config.addr(), Renderer.addr());
 
 	if (!s_fontInternalInstance->m_bInitialized)
 		return CELL_FONT_ERROR_UNINITIALIZED;
@@ -222,10 +222,10 @@ int cellFontCreateRenderer(mem_ptr_t<CellFontLibrary> library, mem_ptr_t<CellFon
 	return CELL_FONT_OK;
 }
 
-void cellFontRenderSurfaceInit(mem_ptr_t<CellFontRenderSurface> surface, u32 buffer_addr, s32 bufferWidthByte, s32 pixelSizeByte, s32 w, s32 h)
+void cellFontRenderSurfaceInit(vm::ptr<CellFontRenderSurface> surface, u32 buffer_addr, s32 bufferWidthByte, s32 pixelSizeByte, s32 w, s32 h)
 {
 	cellFont->Warning("cellFontRenderSurfaceInit(surface_addr=0x%x, buffer_addr=0x%x, bufferWidthByte=%d, pixelSizeByte=%d, w=%d, h=%d)",
-		surface.GetAddr(), buffer_addr, bufferWidthByte, pixelSizeByte, w, h);
+		surface.addr(), buffer_addr, bufferWidthByte, pixelSizeByte, w, h);
 
 	surface->buffer_addr	= buffer_addr;
 	surface->widthByte		= bufferWidthByte;
@@ -237,10 +237,10 @@ void cellFontRenderSurfaceInit(mem_ptr_t<CellFontRenderSurface> surface, u32 buf
 		surface->buffer_addr = (u32)Memory.Alloc(bufferWidthByte * h, 1); // TODO: Huge memory leak
 }
 
-void cellFontRenderSurfaceSetScissor(mem_ptr_t<CellFontRenderSurface> surface, s32 x0, s32 y0, s32 w, s32 h)
+void cellFontRenderSurfaceSetScissor(vm::ptr<CellFontRenderSurface> surface, s32 x0, s32 y0, s32 w, s32 h)
 {
 	cellFont->Warning("cellFontRenderSurfaceSetScissor(surface_addr=0x%x, x0=%d, y0=%d, w=%d, h=%d)",
-		surface.GetAddr(), x0, y0, w, h);
+		surface.addr(), x0, y0, w, h);
 
 	surface->Scissor.x0 = x0;
 	surface->Scissor.y0 = y0;
@@ -248,19 +248,19 @@ void cellFontRenderSurfaceSetScissor(mem_ptr_t<CellFontRenderSurface> surface, s
 	surface->Scissor.y1 = h;
 }
 
-int cellFontSetScalePixel(mem_ptr_t<CellFont> font, float w, float h)
+int cellFontSetScalePixel(vm::ptr<CellFont> font, float w, float h)
 {
-	cellFont->Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
+	cellFont->Log("cellFontSetScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h);
 
 	font->scale_x = w;
 	font->scale_y = h;
 	return CELL_FONT_OK;
 }
 
-int cellFontGetHorizontalLayout(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontHorizontalLayout> layout)
+int cellFontGetHorizontalLayout(vm::ptr<CellFont> font, vm::ptr<CellFontHorizontalLayout> layout)
 {
 	cellFont->Log("cellFontGetHorizontalLayout(font_addr=0x%x, layout_addr=0x%x)",
-		font.GetAddr(), layout.GetAddr());
+		font.addr(), layout.addr());
 
 	int ascent, descent, lineGap;
 	float scale = stbtt_ScaleForPixelHeight(font->stbfont, font->scale_y);
@@ -272,21 +272,21 @@ int cellFontGetHorizontalLayout(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontHori
 	return CELL_FONT_OK;
 }
 
-int cellFontBindRenderer(mem_ptr_t<CellFont> font, mem_ptr_t<CellFontRenderer> renderer)
+int cellFontBindRenderer(vm::ptr<CellFont> font, vm::ptr<CellFontRenderer> renderer)
 {
 	cellFont->Warning("cellFontBindRenderer(font_addr=0x%x, renderer_addr=0x%x)",
-		font.GetAddr(), renderer.GetAddr());
+		font.addr(), renderer.addr());
 
 	if (font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_ALREADY_BIND;
 
-	font->renderer_addr = renderer.GetAddr();
+	font->renderer_addr = renderer.addr();
 	return CELL_FONT_OK;
 }
 
-int cellFontUnbindRenderer(mem_ptr_t<CellFont> font)
+int cellFontUnbindRenderer(vm::ptr<CellFont> font)
 {
-	cellFont->Warning("cellFontBindRenderer(font_addr=0x%x)", font.GetAddr());
+	cellFont->Warning("cellFontBindRenderer(font_addr=0x%x)", font.addr());
 	
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
@@ -301,9 +301,9 @@ int cellFontDestroyRenderer()
 	return CELL_FONT_OK;
 }
 
-int cellFontSetupRenderScalePixel(mem_ptr_t<CellFont> font, float w, float h)
+int cellFontSetupRenderScalePixel(vm::ptr<CellFont> font, float w, float h)
 {
-	cellFont->Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.GetAddr(), w, h);
+	cellFont->Log("cellFontSetupRenderScalePixel(font_addr=0x%x, w=%f, h=%f)", font.addr(), w, h);
 
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
@@ -312,10 +312,10 @@ int cellFontSetupRenderScalePixel(mem_ptr_t<CellFont> font, float w, float h)
 	return CELL_FONT_OK;
 }
 
-int cellFontGetRenderCharGlyphMetrics(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<CellFontGlyphMetrics> metrics)
+int cellFontGetRenderCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
 {
 	cellFont->Log("cellFontGetRenderCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x)",
-		font.GetAddr(), code, metrics.GetAddr());
+		font.addr(), code, metrics.addr());
 
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
@@ -324,10 +324,10 @@ int cellFontGetRenderCharGlyphMetrics(mem_ptr_t<CellFont> font, u32 code, mem_pt
 	return CELL_FONT_OK;
 }
 
-int cellFontRenderCharGlyphImage(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<CellFontRenderSurface> surface, float x, float y, mem_ptr_t<CellFontGlyphMetrics> metrics, mem_ptr_t<CellFontImageTransInfo> transInfo)
+int cellFontRenderCharGlyphImage(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontRenderSurface> surface, float x, float y, vm::ptr<CellFontGlyphMetrics> metrics, vm::ptr<CellFontImageTransInfo> transInfo)
 {
 	cellFont->Log("cellFontRenderCharGlyphImage(font_addr=0x%x, code=0x%x, surface_addr=0x%x, x=%f, y=%f, metrics_addr=0x%x, trans_addr=0x%x)",
-		font.GetAddr(), code, surface.GetAddr(), x, y, metrics.GetAddr(), transInfo.GetAddr());
+		font.addr(), code, surface.addr(), x, y, metrics.addr(), transInfo.addr());
 
 	if (!font->renderer_addr)
 		return CELL_FONT_ERROR_RENDERER_UNBIND;
@@ -368,9 +368,9 @@ int cellFontEndLibrary()
 	return CELL_FONT_OK;
 }
 
-int cellFontSetEffectSlant(mem_ptr_t<CellFont> font, float slantParam)
+int cellFontSetEffectSlant(vm::ptr<CellFont> font, float slantParam)
 {
-	cellFont->Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.GetAddr(), slantParam);
+	cellFont->Log("cellFontSetEffectSlant(font_addr=0x%x, slantParam=%f)", font.addr(), slantParam);
 
 	if (slantParam < -1.0 || slantParam > 1.0)
 		return CELL_FONT_ERROR_INVALID_PARAMETER;
@@ -379,26 +379,26 @@ int cellFontSetEffectSlant(mem_ptr_t<CellFont> font, float slantParam)
 	return CELL_FONT_OK;
 }
 
-int cellFontGetEffectSlant(mem_ptr_t<CellFont> font, mem_ptr_t<be_t<float>> slantParam)
+int cellFontGetEffectSlant(vm::ptr<CellFont> font, vm::ptr<be_t<float>> slantParam)
 {
-	cellFont->Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.GetAddr(), slantParam.GetAddr());
+	cellFont->Warning("cellFontSetEffectSlant(font_addr=0x%x, slantParam_addr=0x%x)", font.addr(), slantParam.addr());
 
 	*slantParam = font->slant;
 	return CELL_FONT_OK;
 }
 
-int cellFontGetFontIdCode(mem_ptr_t<CellFont> font, u32 code, vm::ptr<be_t<u32>> fontId, vm::ptr<be_t<u32>> fontCode)
+int cellFontGetFontIdCode(vm::ptr<CellFont> font, u32 code, vm::ptr<be_t<u32>> fontId, vm::ptr<be_t<u32>> fontCode)
 {
 	cellFont->Todo("cellFontGetFontIdCode(font_addr=0x%x, code=0x%x, fontId_addr=0x%x, fontCode_addr=0x%x",
-		font.GetAddr(), code, fontId.addr(), fontCode.addr());
+		font.addr(), code, fontId.addr(), fontCode.addr());
 
 	// TODO: ?
 	return CELL_FONT_OK;
 }
 
-int cellFontCloseFont(mem_ptr_t<CellFont> font)
+int cellFontCloseFont(vm::ptr<CellFont> font)
 {
-	cellFont->Warning("cellFontCloseFont(font_addr=0x%x)", font.GetAddr());
+	cellFont->Warning("cellFontCloseFont(font_addr=0x%x)", font.addr());
 
 	if (font->origin == CELL_FONT_OPEN_FONTSET ||
 		font->origin == CELL_FONT_OPEN_FONT_FILE ||
@@ -408,10 +408,10 @@ int cellFontCloseFont(mem_ptr_t<CellFont> font)
 	return CELL_FONT_OK;
 }
 
-int cellFontGetCharGlyphMetrics(mem_ptr_t<CellFont> font, u32 code, mem_ptr_t<CellFontGlyphMetrics> metrics)
+int cellFontGetCharGlyphMetrics(vm::ptr<CellFont> font, u32 code, vm::ptr<CellFontGlyphMetrics> metrics)
 {
 	cellFont->Log("cellFontGetCharGlyphMetrics(font_addr=0x%x, code=0x%x, metrics_addr=0x%x",
-		font.GetAddr(), code, metrics.GetAddr());
+		font.addr(), code, metrics.addr());
 
 	int x0, y0, x1, y1;
 	int advanceWidth, leftSideBearing;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
index ce0185c697..4d141542e0 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellFontFT.cpp
@@ -13,10 +13,10 @@ Module *cellFontFT = nullptr;
 
 CCellFontFTInternal* s_fontFtInternalInstance = nullptr;
 
-int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, mem_ptr_t<CellFontLibraryConfigFT> config, u32 lib_addr_addr)
+int cellFontInitLibraryFreeTypeWithRevision(u64 revisionFlags, vm::ptr<CellFontLibraryConfigFT> config, u32 lib_addr_addr)
 {
 	cellFontFT->Warning("cellFontInitLibraryFreeTypeWithRevision(revisionFlags=0x%llx, config_addr=0x%x, lib_addr_addr=0x%x",
-		revisionFlags, config.GetAddr(), lib_addr_addr);
+		revisionFlags, config.addr(), lib_addr_addr);
 
 	//if (s_fontInternalInstance->m_bInitialized)
 		//return CELL_FONT_ERROR_UNINITIALIZED;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
index 20ac617af6..de8aa0eb35 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGame.cpp
@@ -16,10 +16,10 @@ Module *cellGame = nullptr;
 std::string contentInfo = "";
 std::string usrdir = "";
 
-int cellGameBootCheck(vm::ptr<be_t<u32>> type, vm::ptr<be_t<u32>> attributes, mem_ptr_t<CellGameContentSize> size, vm::ptr<char> dirName)
+int cellGameBootCheck(vm::ptr<be_t<u32>> type, vm::ptr<be_t<u32>> attributes, vm::ptr<CellGameContentSize> size, vm::ptr<char> dirName)
 {
 	cellGame->Warning("cellGameBootCheck(type_addr=0x%x, attributes_addr=0x%x, size_addr=0x%x, dirName_addr=0x%x)",
-		type.addr(), attributes.addr(), size.GetAddr(), dirName.addr());
+		type.addr(), attributes.addr(), size.addr(), dirName.addr());
 
 	if (size)
 	{
@@ -81,9 +81,9 @@ int cellGameBootCheck(vm::ptr<be_t<u32>> type, vm::ptr<be_t<u32>> attributes, me
 	return CELL_GAME_RET_OK;
 }
 
-int cellGamePatchCheck(mem_ptr_t<CellGameContentSize> size, u32 reserved_addr)
+int cellGamePatchCheck(vm::ptr<CellGameContentSize> size, u32 reserved_addr)
 {
-	cellGame->Warning("cellGamePatchCheck(size_addr=0x%x, reserved_addr=0x%x)", size.GetAddr(), reserved_addr);
+	cellGame->Warning("cellGamePatchCheck(size_addr=0x%x, reserved_addr=0x%x)", size.addr(), reserved_addr);
 
 	if (reserved_addr != 0)
 	{
@@ -129,9 +129,9 @@ int cellGamePatchCheck(mem_ptr_t<CellGameContentSize> size, u32 reserved_addr)
 	return CELL_GAME_RET_OK;
 }
 
-int cellGameDataCheck(u32 type, vm::ptr<const char> dirName, mem_ptr_t<CellGameContentSize> size)
+int cellGameDataCheck(u32 type, vm::ptr<const char> dirName, vm::ptr<CellGameContentSize> size)
 {
-	cellGame->Warning("cellGameDataCheck(type=0x%x, dirName_addr=0x%x, size_addr=0x%x)", type, dirName.addr(), size.GetAddr());
+	cellGame->Warning("cellGameDataCheck(type=0x%x, dirName_addr=0x%x, size_addr=0x%x)", type, dirName.addr(), size.addr());
 
 	if ((type - 1) >= 3)
 	{
@@ -311,10 +311,10 @@ int cellGameDataCheckCreate(u32 version, vm::ptr<const char> dirName, u32 errDia
 	return cellGameDataCheckCreate2(version, dirName, errDialog, funcStat, container);
 }
 
-int cellGameCreateGameData(mem_ptr_t<CellGameSetInitParams> init, vm::ptr<char> tmp_contentInfoPath, vm::ptr<char> tmp_usrdirPath)
+int cellGameCreateGameData(vm::ptr<CellGameSetInitParams> init, vm::ptr<char> tmp_contentInfoPath, vm::ptr<char> tmp_usrdirPath)
 {
 	cellGame->Todo("cellGameCreateGameData(init_addr=0x%x, tmp_contentInfoPath_addr=0x%x, tmp_usrdirPath_addr=0x%x)",
-		init.GetAddr(), tmp_contentInfoPath.addr(), tmp_usrdirPath.addr());
+		init.addr(), tmp_contentInfoPath.addr(), tmp_usrdirPath.addr());
 
 	// TODO: create temporary game directory, set initial PARAM.SFO parameters
 	// cellGameContentPermit should then move files in non-temporary location and return their non-temporary displacement
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
index d335acea33..58e44afef0 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.cpp
@@ -82,29 +82,29 @@ u32 cellGcmGetLabelAddress(u8 index)
 	return (u32)Memory.RSXCMDMem.GetStartAddr() + 0x10 * index;
 }
 
-u32 cellGcmGetReportDataAddressLocation(u32 index, u32 location)
+vm::ptr<CellGcmReportData> cellGcmGetReportDataAddressLocation(u32 index, u32 location)
 {
 	cellGcmSys->Warning("cellGcmGetReportDataAddressLocation(index=%d, location=%d)", index, location);
 
 	if (location == CELL_GCM_LOCATION_LOCAL) {
 		if (index >= 2048) {
 			cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong local index (%d)", index);
-			return 0;
+			return vm::ptr<CellGcmReportData>::make(0);
 		}
-		return (u32)Memory.RSXFBMem.GetStartAddr() + index * 0x10;
+		return vm::ptr<CellGcmReportData>::make((u32)Memory.RSXFBMem.GetStartAddr() + index * 0x10);
 	}
 
 	if (location == CELL_GCM_LOCATION_MAIN) {
 		if (index >= 1024*1024) {
 			cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong main index (%d)", index);
-			return 0;
+			return vm::ptr<CellGcmReportData>::make(0);
 		}
 		// TODO: It seems m_report_main_addr is not initialized
-		return Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10;
+		return vm::ptr<CellGcmReportData>::make(Emu.GetGSManager().GetRender().m_report_main_addr + index * 0x10);
 	}
 
 	cellGcmSys->Error("cellGcmGetReportDataAddressLocation: Wrong location (%d)", location);
-	return 0;
+	return vm::ptr<CellGcmReportData>::make(0);
 }
 
 u64 cellGcmGetTimeStamp(u32 index)
@@ -130,10 +130,10 @@ u32 cellGcmGetNotifyDataAddress(u32 index)
 
 	// Get address of 'IO table' and 'EA table'
 	vm::var<CellGcmOffsetTable> table;
-	cellGcmGetOffsetTable(table.addr());
+	cellGcmGetOffsetTable(table);
 
 	// If entry not in use, return NULL
-	u16 entry = mem_ptr_t<u16>(table->eaAddress)[241];
+	u16 entry = Memory.Read16(table->eaAddress + 241 * sizeof(u16));
 	if (entry == 0xFFFF) {
 		return 0;
 	}
@@ -144,9 +144,9 @@ u32 cellGcmGetNotifyDataAddress(u32 index)
 /*
  *  Get base address of local report data area
  */
-u32 _cellGcmFunc12()
+vm::ptr<CellGcmReportData> _cellGcmFunc12()
 {
-	return (u32)Memory.RSXFBMem.GetStartAddr(); // TODO
+	return vm::ptr<CellGcmReportData>::make(Memory.RSXFBMem.GetStartAddr()); // TODO
 }
 
 u32 cellGcmGetReport(u32 type, u32 index)
@@ -162,7 +162,7 @@ u32 cellGcmGetReport(u32 type, u32 index)
 		return -1;
 	}
 
-	mem_ptr_t<CellGcmReportData> local_reports = _cellGcmFunc12();
+	vm::ptr<CellGcmReportData> local_reports = _cellGcmFunc12();
 	return local_reports[index].value;
 }
 
@@ -181,7 +181,7 @@ u32 cellGcmGetReportDataLocation(u32 index, u32 location)
 {
 	cellGcmSys->Warning("cellGcmGetReportDataLocation(index=%d, location=%d)", index, location);
 
-	mem_ptr_t<CellGcmReportData> report = cellGcmGetReportDataAddressLocation(index, location);
+	vm::ptr<CellGcmReportData> report = cellGcmGetReportDataAddressLocation(index, location);
 	return report->value;
 }
 
@@ -281,9 +281,9 @@ int cellGcmBindZcull(u8 index)
 	return CELL_OK;
 }
 
-int cellGcmGetConfiguration(mem_ptr_t<CellGcmConfig> config)
+int cellGcmGetConfiguration(vm::ptr<CellGcmConfig> config)
 {
-	cellGcmSys->Log("cellGcmGetConfiguration(config_addr=0x%x)", config.GetAddr());
+	cellGcmSys->Log("cellGcmGetConfiguration(config_addr=0x%x)", config.addr());
 
 	*config = current_config;
 
@@ -315,16 +315,16 @@ void _cellGcmFunc1()
 	return;
 }
 
-void _cellGcmFunc15(mem_ptr_t<CellGcmContextData> context)
+void _cellGcmFunc15(vm::ptr<CellGcmContextData> context)
 {
-	cellGcmSys->Todo("_cellGcmFunc15(context_addr=0x%x)", context.GetAddr());
+	cellGcmSys->Todo("_cellGcmFunc15(context_addr=0x%x)", context.addr());
 	return;
 }
 
 // Called by cellGcmInit
-s32 _cellGcmInitBody(mem_ptr_t<CellGcmContextData> context, u32 cmdSize, u32 ioSize, u32 ioAddress)
+s32 _cellGcmInitBody(vm::ptr<CellGcmContextData> context, u32 cmdSize, u32 ioSize, u32 ioAddress)
 {
-	cellGcmSys->Warning("_cellGcmInitBody(context_addr=0x%x, cmdSize=0x%x, ioSize=0x%x, ioAddress=0x%x)", context.GetAddr(), cmdSize, ioSize, ioAddress);
+	cellGcmSys->Warning("_cellGcmInitBody(context_addr=0x%x, cmdSize=0x%x, ioSize=0x%x, ioAddress=0x%x)", context.addr(), cmdSize, ioSize, ioAddress);
 
 	if(!cellGcmSys->IsLoaded())
 		cellGcmSys->Load();
@@ -378,7 +378,7 @@ s32 _cellGcmInitBody(mem_ptr_t<CellGcmContextData> context, u32 cmdSize, u32 ioS
 	gcm_info.control_addr = gcm_info.context_addr + 0x40;
 
 	Memory.WriteData(gcm_info.context_addr, current_context);
-	Memory.Write32(context.GetAddr(), gcm_info.context_addr);
+	Memory.Write32(context.addr(), gcm_info.context_addr);
 
 	CellGcmControl& ctrl = (CellGcmControl&)Memory[gcm_info.control_addr];
 	ctrl.put = 0;
@@ -386,7 +386,7 @@ s32 _cellGcmInitBody(mem_ptr_t<CellGcmContextData> context, u32 cmdSize, u32 ioS
 	ctrl.ref = -1;
 
 	auto& render = Emu.GetGSManager().GetRender();
-	render.m_ctxt_addr = context.GetAddr();
+	render.m_ctxt_addr = context.addr();
 	render.m_gcm_buffers_addr = (u32)Memory.Alloc(sizeof(CellGcmDisplayInfo) * 8, sizeof(CellGcmDisplayInfo));
 	render.m_zculls_addr = (u32)Memory.Alloc(sizeof(CellGcmZcullInfo) * 8, sizeof(CellGcmZcullInfo));
 	render.m_tiles_addr = (u32)Memory.Alloc(sizeof(CellGcmTileInfo) * 15, sizeof(CellGcmTileInfo));
@@ -448,9 +448,9 @@ int cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height
 	return CELL_OK;
 }
 
-int cellGcmSetFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
+int cellGcmSetFlip(vm::ptr<CellGcmContextData> ctxt, u32 id)
 {
-	cellGcmSys->Log("cellGcmSetFlip(ctx=0x%x, id=0x%x)", ctxt.GetAddr(), id);
+	cellGcmSys->Log("cellGcmSetFlip(ctx=0x%x, id=0x%x)", ctxt.addr(), id);
 
 	int res = cellGcmSetPrepareFlip(ctxt, id);
 	return res < 0 ? CELL_GCM_ERROR_FAILURE : CELL_OK;
@@ -489,9 +489,9 @@ void cellGcmSetFlipStatus()
 	Emu.GetGSManager().GetRender().m_flip_status = 0;
 }
 
-s32 cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
+s32 cellGcmSetPrepareFlip(vm::ptr<CellGcmContextData> ctxt, u32 id)
 {
-	cellGcmSys->Log("cellGcmSetPrepareFlip(ctx=0x%x, id=0x%x)", ctxt.GetAddr(), id);
+	cellGcmSys->Log("cellGcmSetPrepareFlip(ctx=0x%x, id=0x%x)", ctxt.addr(), id);
 
 	if(id > 7)
 	{
@@ -507,7 +507,7 @@ s32 cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
 	if(current + 8 >= end)
 	{
 		cellGcmSys->Error("bad flip!");
-		//cellGcmCallback(ctxt.GetAddr(), current + 8 - end);
+		//cellGcmCallback(ctxt.addr(), current + 8 - end);
 		//copied:
  
 		CellGcmControl& ctrl = (CellGcmControl&)Memory[gcm_info.control_addr];
@@ -528,7 +528,7 @@ s32 cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id)
 	Memory.Write32(current + 4, id);
 	ctxt->current += 8;
 
-	if(ctxt.GetAddr() == gcm_info.context_addr)
+	if(ctxt.addr() == gcm_info.context_addr)
 	{
 		CellGcmControl& ctrl = (CellGcmControl&)Memory[gcm_info.control_addr];
 		ctrl.put += 8;
@@ -610,9 +610,9 @@ void cellGcmSetVBlankHandler(u32 handler_addr)
 	Emu.GetGSManager().GetRender().m_vblank_handler.SetAddr(handler_addr);
 }
 
-int cellGcmSetWaitFlip(mem_ptr_t<CellGcmContextData> ctxt)
+int cellGcmSetWaitFlip(vm::ptr<CellGcmContextData> ctxt)
 {
-	cellGcmSys->Log("cellGcmSetWaitFlip(ctx=0x%x)", ctxt.GetAddr());
+	cellGcmSys->Log("cellGcmSetWaitFlip(ctx=0x%x)", ctxt.addr());
 
 	GSLockCurrent lock(GS_LOCK_WAIT_FLIP);
 	return CELL_OK;
@@ -841,9 +841,9 @@ u32 cellGcmGetMaxIoMapSize()
 	return (u32)(Memory.RSXIOMem.GetEndAddr() - Memory.RSXIOMem.GetStartAddr() - Memory.RSXIOMem.GetReservedAmount());
 }
 
-void cellGcmGetOffsetTable(mem_ptr_t<CellGcmOffsetTable> table)
+void cellGcmGetOffsetTable(vm::ptr<CellGcmOffsetTable> table)
 {
-	cellGcmSys->Log("cellGcmGetOffsetTable(table_addr=0x%x)", table.GetAddr());
+	cellGcmSys->Log("cellGcmGetOffsetTable(table_addr=0x%x)", table.addr());
 
 	table->ioAddress = offsetTable.ioAddress;
 	table->eaAddress = offsetTable.eaAddress;
@@ -1095,17 +1095,17 @@ void cellGcmSetDefaultCommandBuffer()
 // Other
 //------------------------------------------------------------------------
 
-int cellGcmSetFlipCommand(u32 ctx, u32 id)
+int cellGcmSetFlipCommand(vm::ptr<CellGcmContextData> ctx, u32 id)
 {
-	cellGcmSys->Log("cellGcmSetFlipCommand(ctx=0x%x, id=0x%x)", ctx, id);
+	cellGcmSys->Log("cellGcmSetFlipCommand(ctx_addr=0x%x, id=0x%x)", ctx.addr(), id);
 
 	return cellGcmSetPrepareFlip(ctx, id);
 }
 
-int cellGcmSetFlipCommandWithWaitLabel(u32 ctx, u32 id, u32 label_index, u32 label_value)
+int cellGcmSetFlipCommandWithWaitLabel(vm::ptr<CellGcmContextData> ctx, u32 id, u32 label_index, u32 label_value)
 {
-	cellGcmSys->Log("cellGcmSetFlipCommandWithWaitLabel(ctx=0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)",
-		ctx, id, label_index, label_value);
+	cellGcmSys->Log("cellGcmSetFlipCommandWithWaitLabel(ctx_addr=0x%x, id=0x%x, label_index=0x%x, label_value=0x%x)",
+		ctx.addr(), id, label_index, label_value);
 
 	int res = cellGcmSetPrepareFlip(ctx, id);
 	Memory.Write32(Memory.RSXCMDMem.GetStartAddr() + 0x10 * label_index, label_value);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
index f2c25a726b..5c80727595 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellGcmSys.h
@@ -22,11 +22,11 @@ u32 gcmGetLocalMemorySize();
 
 
 // SysCalls
-s32 cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctxt, u32 id);
+s32 cellGcmSetPrepareFlip(vm::ptr<CellGcmContextData> ctxt, u32 id);
 
 s32 cellGcmAddressToOffset(u64 address, vm::ptr<be_t<u32>> offset);
 u32 cellGcmGetMaxIoMapSize();
-void cellGcmGetOffsetTable(mem_ptr_t<CellGcmOffsetTable> table);
+void cellGcmGetOffsetTable(vm::ptr<CellGcmOffsetTable> table);
 s32 cellGcmIoOffsetToAddress(u32 ioOffset, u64 address);
 s32 cellGcmMapEaIoAddress(u32 ea, u32 io, u32 size);
 s32 cellGcmMapEaIoAddressWithFlags(u32 ea, u32 io, u32 size, u32 flags);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
index 5b5b028b79..9282d9d01a 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp
@@ -23,10 +23,10 @@ int cellGifDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u
 	return CELL_OK;
 }
 
-int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const mem_ptr_t<CellGifDecSrc> src, mem_ptr_t<CellGifDecOpnInfo> openInfo)
+int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const vm::ptr<CellGifDecSrc> src, vm::ptr<CellGifDecOpnInfo> openInfo)
 {
 	cellGifDec->Warning("cellGifDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)",
-		mainHandle, subHandle.addr(), src.GetAddr(), openInfo.GetAddr());
+		mainHandle, subHandle.addr(), src.addr(), openInfo.addr());
 
 	CellGifDecSubHandle *current_subHandle = new CellGifDecSubHandle;
 	current_subHandle->fd = 0;
@@ -47,7 +47,7 @@ int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const mem_ptr_t
 
 		// Get size of file
 		vm::var<CellFsStat> sb; // Alloc a CellFsStat struct
-		ret = cellFsFstat(current_subHandle->fd, sb.addr());
+		ret = cellFsFstat(current_subHandle->fd, sb);
 		if (ret != CELL_OK) return ret;
 		current_subHandle->fileSize = sb->st_size; // Get CellFsStat.st_size
 		break;
@@ -59,10 +59,10 @@ int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const mem_ptr_t
 	return CELL_OK;
 }
 
-int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellGifDecInfo> info)
+int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellGifDecInfo> info)
 {
 	cellGifDec->Warning("cellGifDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)",
-		mainHandle, subHandle, info.GetAddr());
+		mainHandle, subHandle, info.addr());
 
 	CellGifDecSubHandle* subHandle_data;
 	if(!cellGifDec->CheckId(subHandle, subHandle_data))
@@ -109,10 +109,10 @@ int cellGifDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellGifDecInfo
 	return CELL_OK;
 }
 
-int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellGifDecInParam> inParam, mem_ptr_t<CellGifDecOutParam> outParam)
+int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, const vm::ptr<CellGifDecInParam> inParam, vm::ptr<CellGifDecOutParam> outParam)
 {
 	cellGifDec->Warning("cellGifDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x)",
-		mainHandle, subHandle, inParam.GetAddr(), outParam.GetAddr());
+		mainHandle, subHandle, inParam.addr(), outParam.addr());
 
 	CellGifDecSubHandle* subHandle_data;
 	if(!cellGifDec->CheckId(subHandle, subHandle_data))
@@ -139,10 +139,10 @@ int cellGifDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellGi
 	return CELL_OK;
 }
 
-int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellGifDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellGifDecDataOutInfo> dataOutInfo)
+int cellGifDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const vm::ptr<CellGifDecDataCtrlParam> dataCtrlParam, vm::ptr<CellGifDecDataOutInfo> dataOutInfo)
 {
 	cellGifDec->Warning("cellGifDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
-		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.addr(), dataOutInfo.addr());
 
 	dataOutInfo->status = CELL_GIFDEC_DEC_STATUS_STOP;
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
index 80495f7802..87d96da750 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp
@@ -28,10 +28,10 @@ int cellJpgDecDestroy(u32 mainHandle)
 	return CELL_OK;
 }
 
-int cellJpgDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellJpgDecSrc> src, mem_ptr_t<CellJpgDecOpnInfo> openInfo)
+int cellJpgDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellJpgDecSrc> src, vm::ptr<CellJpgDecOpnInfo> openInfo)
 {
 	cellJpgDec->Warning("cellJpgDecOpen(mainHandle=0x%x, subHandle_addr=0x%x, src_addr=0x%x, openInfo_addr=0x%x)",
-		mainHandle, subHandle.addr(), src.GetAddr(), openInfo.GetAddr());
+		mainHandle, subHandle.addr(), src.addr(), openInfo.addr());
 
 	CellJpgDecSubHandle *current_subHandle = new CellJpgDecSubHandle;
 
@@ -53,7 +53,7 @@ int cellJpgDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellJ
 
 		// Get size of file
 		vm::var<CellFsStat> sb; // Alloc a CellFsStat struct
-		ret = cellFsFstat(current_subHandle->fd, sb.addr());
+		ret = cellFsFstat(current_subHandle->fd, sb);
 		if (ret != CELL_OK) return ret;
 		current_subHandle->fileSize = sb->st_size;	// Get CellFsStat.st_size
 		break;
@@ -80,9 +80,9 @@ int cellJpgDecClose(u32 mainHandle, u32 subHandle)
 	return CELL_OK;
 }
 
-int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo> info)
+int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellJpgDecInfo> info)
 {
-	cellJpgDec->Log("cellJpgDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)", mainHandle, subHandle, info.GetAddr());
+	cellJpgDec->Log("cellJpgDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)", mainHandle, subHandle, info.addr());
 
 	CellJpgDecSubHandle* subHandle_data;
 	if(!cellJpgDec->CheckId(subHandle, subHandle_data))
@@ -147,10 +147,10 @@ int cellJpgDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellJpgDecInfo
 	return CELL_OK;
 }
 
-int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellJpgDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellJpgDecDataOutInfo> dataOutInfo)
+int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const vm::ptr<CellJpgDecDataCtrlParam> dataCtrlParam, vm::ptr<CellJpgDecDataOutInfo> dataOutInfo)
 {
 	cellJpgDec->Log("cellJpgDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
-		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.addr(), dataOutInfo.addr());
 
 	dataOutInfo->status = CELL_JPGDEC_DEC_STATUS_STOP;
 	CellJpgDecSubHandle* subHandle_data;
@@ -278,10 +278,10 @@ int cellJpgDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 	return CELL_OK;
 }
 
-int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellJpgDecInParam> inParam, mem_ptr_t<CellJpgDecOutParam> outParam)
+int cellJpgDecSetParameter(u32 mainHandle, u32 subHandle, const vm::ptr<CellJpgDecInParam> inParam, vm::ptr<CellJpgDecOutParam> outParam)
 {
 	cellJpgDec->Log("cellJpgDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x)",
-		mainHandle, subHandle, inParam.GetAddr(), outParam.GetAddr());
+		mainHandle, subHandle, inParam.addr(), outParam.addr());
 
 	CellJpgDecSubHandle* subHandle_data;
 	if(!cellJpgDec->CheckId(subHandle, subHandle_data))
diff --git a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
index db75833d76..f0d754e2e7 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellL10n.cpp
@@ -240,7 +240,7 @@ int _L10nConvertStr(int src_code, const void *src, size_t * src_len, int dst_cod
 		return ConverterUnknown;
 
 	if (strnlen_s((char*)src, *src_len) != *src_len) return SRCIllegal;
-	//std::string wrapped_source = (char*)Memory.VirtualToRealAddr(src.GetAddr());
+	//std::string wrapped_source = (char*)Memory.VirtualToRealAddr(src.addr());
 	std::string wrapped_source((char*)src);
 	//if (wrapped_source.length != src_len.GetValue()) return SRCIllegal;
 	std::string target = _OemToOem(srcCode, dstCode, wrapped_source);
@@ -260,8 +260,8 @@ int _L10nConvertStr(int src_code, const void* src, size_t * src_len, int dst_cod
 	if ((_L10nCodeParse(src_code, srcCode)) && (_L10nCodeParse(dst_code, dstCode)))
 	{
 		iconv_t ict = iconv_open(srcCode.c_str(), dstCode.c_str());
-		//char *srcBuf = (char*)Memory.VirtualToRealAddr(src.GetAddr());
-		//char *dstBuf = (char*)Memory.VirtualToRealAddr(dst.GetAddr());
+		//char *srcBuf = (char*)Memory.VirtualToRealAddr(src.addr());
+		//char *dstBuf = (char*)Memory.VirtualToRealAddr(dst.addr());
 		char *srcBuf = (char*)src, *dstBuf = (char*)dst;
 		size_t srcLen = *src_len, dstLen = *dst_len;
 		size_t ictd = iconv(ict, &srcBuf, &srcLen, &dstBuf, &dstLen);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
index e3b992bd0c..61e3da0a88 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellNetCtl.cpp
@@ -43,16 +43,16 @@ int cellNetCtlDelHandler(s32 hid)
 	return CELL_OK;
 }
 
-int cellNetCtlGetInfo(s32 code, mem_ptr_t<CellNetCtlInfo> info)
+int cellNetCtlGetInfo(s32 code, vm::ptr<CellNetCtlInfo> info)
 {
-	cellNetCtl->Todo("cellNetCtlGetInfo(code=%x, info_addr=0x%x)", code, info.GetAddr());
+	cellNetCtl->Todo("cellNetCtlGetInfo(code=%x, info_addr=0x%x)", code, info.addr());
 
 	return CELL_OK;
 }
 
-int cellNetCtlNetStartDialogLoadAsync(mem_ptr_t<CellNetCtlNetStartDialogParam> param)
+int cellNetCtlNetStartDialogLoadAsync(vm::ptr<CellNetCtlNetStartDialogParam> param)
 {
-	cellNetCtl->Todo("cellNetCtlNetStartDialogLoadAsync(param_addr=0x%x)", param.GetAddr());
+	cellNetCtl->Todo("cellNetCtlNetStartDialogLoadAsync(param_addr=0x%x)", param.addr());
 
 	return CELL_OK;
 }
@@ -64,16 +64,16 @@ int cellNetCtlNetStartDialogAbortAsync()
 	return CELL_OK;
 }
 
-int cellNetCtlNetStartDialogUnloadAsync(mem_ptr_t<CellNetCtlNetStartDialogResult> result)
+int cellNetCtlNetStartDialogUnloadAsync(vm::ptr<CellNetCtlNetStartDialogResult> result)
 {
-	cellNetCtl->Todo("cellNetCtlNetStartDialogUnloadAsync(result_addr=0x%x)", result.GetAddr());
+	cellNetCtl->Todo("cellNetCtlNetStartDialogUnloadAsync(result_addr=0x%x)", result.addr());
 
 	return CELL_OK;
 }
 
-int cellNetCtlGetNatInfo(mem_ptr_t<CellNetCtlNatInfo> natInfo)
+int cellNetCtlGetNatInfo(vm::ptr<CellNetCtlNatInfo> natInfo)
 {
-	cellNetCtl->Todo("cellNetCtlGetNatInfo(natInfo_addr=0x%x)", natInfo.GetAddr());
+	cellNetCtl->Todo("cellNetCtlGetNatInfo(natInfo_addr=0x%x)", natInfo.addr());
 
 	if (natInfo->size == 0)
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
index d479ea8dde..361768451b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPamf.cpp
@@ -6,7 +6,7 @@
 
 Module *cellPamf = nullptr;
 
-int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pEsFilterId)
+int pamfStreamTypeToEsFilterId(u8 type, u8 ch, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
 	//TODO: convert type and ch to EsFilterId
 	pEsFilterId->filterIdMajor = 0;
@@ -74,10 +74,10 @@ int pamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pE
 	return CELL_OK;
 }
 
-u8 pamfGetStreamType(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
+u8 pamfGetStreamType(vm::ptr<CellPamfReader> pSelf, u8 stream)
 {
 	//TODO: get stream type correctly
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	switch (pAddr->stream_headers[stream].type)
 	{
@@ -91,10 +91,10 @@ u8 pamfGetStreamType(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
 	}
 }
 
-u8 pamfGetStreamChannel(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
+u8 pamfGetStreamChannel(vm::ptr<CellPamfReader> pSelf, u8 stream)
 {
 	//TODO: get stream channel correctly
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	switch (pAddr->stream_headers[stream].type)
 	{
@@ -124,9 +124,9 @@ u8 pamfGetStreamChannel(mem_ptr_t<CellPamfReader> pSelf, u8 stream)
 
 }
 
-int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_t<u64>> pSize)
+int cellPamfGetHeaderSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_t<u64>> pSize)
 {
-	cellPamf->Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, pSize.addr());
+	cellPamf->Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)", pAddr.addr(), fileSize, pSize.addr());
 
 	//if ((u32)pAddr->magic != 0x464d4150)
 		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
@@ -136,9 +136,9 @@ int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_
 	return CELL_OK;
 }
 
-int cellPamfGetHeaderSize2(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attribute, vm::ptr<be_t<u64>> pSize)
+int cellPamfGetHeaderSize2(vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribute, vm::ptr<be_t<u64>> pSize)
 {
-	cellPamf->Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, attribute, pSize.addr());
+	cellPamf->Warning("cellPamfGetHeaderSize2(pAddr=0x%x, fileSize=%d, attribute=0x%x, pSize_addr=0x%x)", pAddr.addr(), fileSize, attribute, pSize.addr());
 
 	//if ((u32)pAddr->magic != 0x464d4150)
 		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
@@ -148,9 +148,9 @@ int cellPamfGetHeaderSize2(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attrib
 	return CELL_OK;
 }
 
-int cellPamfGetStreamOffsetAndSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_t<u64>> pOffset, vm::ptr<be_t<u64>> pSize)
+int cellPamfGetStreamOffsetAndSize(vm::ptr<PamfHeader> pAddr, u64 fileSize, vm::ptr<be_t<u64>> pOffset, vm::ptr<be_t<u64>> pSize)
 {
-	cellPamf->Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)", pAddr.GetAddr(), fileSize, pOffset.addr(), pSize.addr());
+	cellPamf->Warning("cellPamfGetStreamOffsetAndSize(pAddr=0x%x, fileSize=%d, pOffset_addr=0x%x, pSize_addr=0x%x)", pAddr.addr(), fileSize, pOffset.addr(), pSize.addr());
 
 	//if ((u32)pAddr->magic != 0x464d4150)
 		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
@@ -162,16 +162,16 @@ int cellPamfGetStreamOffsetAndSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, vm
 	return CELL_OK;
 }
 
-int cellPamfVerify(mem_ptr_t<PamfHeader> pAddr, u64 fileSize)
+int cellPamfVerify(vm::ptr<PamfHeader> pAddr, u64 fileSize)
 {
-	cellPamf->Warning("cellPamfVerify(pAddr=0x%x, fileSize=%d)", pAddr.GetAddr(), fileSize);
+	cellPamf->Warning("cellPamfVerify(pAddr=0x%x, fileSize=%d)", pAddr.addr(), fileSize);
 
 	return CELL_OK;
 }
 
-int cellPamfReaderInitialize(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<PamfHeader> pAddr, u64 fileSize, u32 attribute)
+int cellPamfReaderInitialize(vm::ptr<CellPamfReader> pSelf, vm::ptr<PamfHeader> pAddr, u64 fileSize, u32 attribute)
 {
-	cellPamf->Warning("cellPamfReaderInitialize(pSelf=0x%x, pAddr=0x%x, fileSize=%d, attribute=0x%x)", pSelf.GetAddr(), pAddr.GetAddr(), fileSize, attribute);
+	cellPamf->Warning("cellPamfReaderInitialize(pSelf=0x%x, pAddr=0x%x, fileSize=%d, attribute=0x%x)", pSelf.addr(), pAddr.addr(), fileSize, attribute);
 	
 	if (fileSize)
 	{
@@ -181,7 +181,7 @@ int cellPamfReaderInitialize(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<PamfHead
 	{
 		pSelf->fileSize = ((u64)pAddr->data_offset << 11) + ((u64)pAddr->data_size << 11);
 	}
-	pSelf->pAddr = pAddr.GetAddr();
+	pSelf->pAddr = vm::ptr<PamfHeader>::make(pAddr.addr());
 
 	if (attribute & CELL_PAMF_ATTRIBUTE_VERIFY_ON)
 	{
@@ -192,49 +192,49 @@ int cellPamfReaderInitialize(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<PamfHead
 	return CELL_OK;
 }
 
-int cellPamfReaderGetPresentationStartTime(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecTimeStamp> pTimeStamp)
+int cellPamfReaderGetPresentationStartTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp)
 {
-	cellPamf->Warning("cellPamfReaderGetPresentationStartTime(pSelf=0x%x, pTimeStamp_addr=0x%x)", pSelf.GetAddr(), pTimeStamp.GetAddr());
+	cellPamf->Warning("cellPamfReaderGetPresentationStartTime(pSelf=0x%x, pTimeStamp_addr=0x%x)", pSelf.addr(), pTimeStamp.addr());
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 	const u32 upper = (u16)pAddr->start_pts_high;
 	pTimeStamp->upper = upper;
 	pTimeStamp->lower = pAddr->start_pts_low;
 	return CELL_OK;
 }
 
-int cellPamfReaderGetPresentationEndTime(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecTimeStamp> pTimeStamp)
+int cellPamfReaderGetPresentationEndTime(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp)
 {
-	cellPamf->Warning("cellPamfReaderGetPresentationEndTime(pSelf=0x%x, pTimeStamp_addr=0x%x)", pSelf.GetAddr(), pTimeStamp.GetAddr());
+	cellPamf->Warning("cellPamfReaderGetPresentationEndTime(pSelf=0x%x, pTimeStamp_addr=0x%x)", pSelf.addr(), pTimeStamp.addr());
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 	const u32 upper = (u16)pAddr->end_pts_high;
 	pTimeStamp->upper = upper;
 	pTimeStamp->lower = pAddr->end_pts_low;
 	return CELL_OK;
 }
 
-int cellPamfReaderGetMuxRateBound(mem_ptr_t<CellPamfReader> pSelf)
+int cellPamfReaderGetMuxRateBound(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf->Warning("cellPamfReaderGetMuxRateBound(pSelf=0x%x)", pSelf.GetAddr());
+	cellPamf->Warning("cellPamfReaderGetMuxRateBound(pSelf=0x%x)", pSelf.addr());
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 	return pAddr->mux_rate_max;
 }
 
-int cellPamfReaderGetNumberOfStreams(mem_ptr_t<CellPamfReader> pSelf)
+int cellPamfReaderGetNumberOfStreams(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf->Warning("cellPamfReaderGetNumberOfStreams(pSelf=0x%x)", pSelf.GetAddr());
+	cellPamf->Warning("cellPamfReaderGetNumberOfStreams(pSelf=0x%x)", pSelf.addr());
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 	return pAddr->stream_count;
 }
 
-int cellPamfReaderGetNumberOfSpecificStreams(mem_ptr_t<CellPamfReader> pSelf, u8 streamType)
+int cellPamfReaderGetNumberOfSpecificStreams(vm::ptr<CellPamfReader> pSelf, u8 streamType)
 {
-	cellPamf->Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=0x%x, streamType=%d)", pSelf.GetAddr(), streamType);
+	cellPamf->Warning("cellPamfReaderGetNumberOfSpecificStreams(pSelf=0x%x, streamType=%d)", pSelf.addr(), streamType);
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	int counts[6] = {0, 0, 0, 0, 0, 0};
 
@@ -261,11 +261,11 @@ int cellPamfReaderGetNumberOfSpecificStreams(mem_ptr_t<CellPamfReader> pSelf, u8
 	}
 }
 
-int cellPamfReaderSetStreamWithIndex(mem_ptr_t<CellPamfReader> pSelf, u8 streamIndex)
+int cellPamfReaderSetStreamWithIndex(vm::ptr<CellPamfReader> pSelf, u8 streamIndex)
 {
-	cellPamf->Warning("cellPamfReaderSetStreamWithIndex(pSelf=0x%x, streamIndex=%d)", pSelf.GetAddr(), streamIndex);
+	cellPamf->Warning("cellPamfReaderSetStreamWithIndex(pSelf=0x%x, streamIndex=%d)", pSelf.addr(), streamIndex);
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	if (streamIndex < pAddr->stream_count)
 	{
@@ -279,11 +279,11 @@ int cellPamfReaderSetStreamWithIndex(mem_ptr_t<CellPamfReader> pSelf, u8 streamI
 	}	
 }
 
-int cellPamfReaderSetStreamWithTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, u8 streamType, u8 ch)
+int cellPamfReaderSetStreamWithTypeAndChannel(vm::ptr<CellPamfReader> pSelf, u8 streamType, u8 ch)
 {
-	cellPamf->Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=0x%x, streamType=%d, ch=%d)", pSelf.GetAddr(), streamType, ch);
+	cellPamf->Warning("cellPamfReaderSetStreamWithTypeAndChannel(pSelf=0x%x, streamType=%d, ch=%d)", pSelf.addr(), streamType, ch);
 	
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	if (streamType > 5)
 	{
@@ -307,11 +307,11 @@ int cellPamfReaderSetStreamWithTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, u
 	return CELL_PAMF_ERROR_STREAM_NOT_FOUND;
 }
 
-int cellPamfReaderSetStreamWithTypeAndIndex(mem_ptr_t<CellPamfReader> pSelf, u8 streamType, u8 streamIndex)
+int cellPamfReaderSetStreamWithTypeAndIndex(vm::ptr<CellPamfReader> pSelf, u8 streamType, u8 streamIndex)
 {
-	cellPamf->Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=0x%x, streamType=%d, streamIndex=%d)", pSelf.GetAddr(), streamType, streamIndex);
+	cellPamf->Warning("cellPamfReaderSetStreamWithTypeAndIndex(pSelf=0x%x, streamType=%d, streamIndex=%d)", pSelf.addr(), streamType, streamIndex);
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	u32 found = 0;
 
@@ -354,43 +354,43 @@ int cellPamfReaderSetStreamWithTypeAndIndex(mem_ptr_t<CellPamfReader> pSelf, u8
 	return CELL_PAMF_ERROR_STREAM_NOT_FOUND;
 }
 
-int cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, mem_ptr_t<CellCodecEsFilterId> pEsFilterId)
+int cellPamfStreamTypeToEsFilterId(u8 type, u8 ch, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
-	cellPamf->Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId_addr=0x%x)", type, ch, pEsFilterId.GetAddr());
+	cellPamf->Warning("cellPamfStreamTypeToEsFilterId(type=%d, ch=%d, pEsFilterId_addr=0x%x)", type, ch, pEsFilterId.addr());
 	
 	return pamfStreamTypeToEsFilterId(type, ch, pEsFilterId);
 }
 
-int cellPamfReaderGetStreamIndex(mem_ptr_t<CellPamfReader> pSelf)
+int cellPamfReaderGetStreamIndex(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf->Log("cellPamfReaderGetStreamIndex(pSelf=0x%x)", pSelf.GetAddr());
+	cellPamf->Log("cellPamfReaderGetStreamIndex(pSelf=0x%x)", pSelf.addr());
 
 	return pSelf->stream;
 }
 
-int cellPamfReaderGetStreamTypeAndChannel(mem_ptr_t<CellPamfReader> pSelf, vm::ptr<u8> pType, vm::ptr<u8> pCh)
+int cellPamfReaderGetStreamTypeAndChannel(vm::ptr<CellPamfReader> pSelf, vm::ptr<u8> pType, vm::ptr<u8> pCh)
 {
 	cellPamf->Warning("cellPamfReaderGetStreamTypeAndChannel(pSelf=0x%x (stream=%d), pType_addr=0x%x, pCh_addr=0x%x",
-		pSelf.GetAddr(), pSelf->stream, pType.addr(), pCh.addr());
+		pSelf.addr(), pSelf->stream, pType.addr(), pCh.addr());
 
 	*pType = pamfGetStreamType(pSelf, pSelf->stream);
 	*pCh = pamfGetStreamChannel(pSelf, pSelf->stream);
 	return CELL_OK;
 }
 
-int cellPamfReaderGetEsFilterId(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecEsFilterId> pEsFilterId)
+int cellPamfReaderGetEsFilterId(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecEsFilterId> pEsFilterId)
 {
-	cellPamf->Warning("cellPamfReaderGetEsFilterId(pSelf=0x%x (stream=%d), pEsFilterId_addr=0x%x)", pSelf.GetAddr(), pSelf->stream, pEsFilterId.GetAddr());
+	cellPamf->Warning("cellPamfReaderGetEsFilterId(pSelf=0x%x (stream=%d), pEsFilterId_addr=0x%x)", pSelf.addr(), pSelf->stream, pEsFilterId.addr());
 
 	return pamfStreamTypeToEsFilterId(pamfGetStreamType(pSelf, pSelf->stream), 
 		pamfGetStreamChannel(pSelf, pSelf->stream), pEsFilterId);
 }
 
-int cellPamfReaderGetStreamInfo(mem_ptr_t<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.GetAddr(), 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);
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	memset(Memory + pInfo_addr, 0, size);
 
@@ -398,8 +398,8 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
 	{
 	case CELL_PAMF_STREAM_TYPE_AVC:
 		{
-			mem_ptr_t<CellPamfAvcInfo> pInfo(pInfo_addr);
-			mem_ptr_t<PamfStreamHeader_AVC> pAVC(pSelf->pAddr + 0x98 + pSelf->stream * 0x30);
+			auto pInfo = vm::ptr<CellPamfAvcInfo>::make(pInfo_addr);
+			auto pAVC = vm::ptr<PamfStreamHeader_AVC>::make(pSelf->pAddr.addr() + 0x98 + pSelf->stream * 0x30);
 
 			if (size != sizeof(CellPamfAvcInfo))
 			{
@@ -434,8 +434,8 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
 		break;
 	case CELL_PAMF_STREAM_TYPE_ATRAC3PLUS: 
 		{
-			mem_ptr_t<CellPamfAtrac3plusInfo> pInfo(pInfo_addr);
-			mem_ptr_t<PamfStreamHeader_Audio> pAudio(pSelf->pAddr + 0x98 + pSelf->stream * 0x30);
+			auto pInfo = vm::ptr<CellPamfAtrac3plusInfo>::make(pInfo_addr);
+			auto pAudio = vm::ptr<PamfStreamHeader_Audio>::make(pSelf->pAddr.addr() + 0x98 + pSelf->stream * 0x30);
 
 			if (size != sizeof(CellPamfAtrac3plusInfo))
 			{
@@ -449,8 +449,8 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
 		break;
 	case CELL_PAMF_STREAM_TYPE_AC3:
 		{
-			mem_ptr_t<CellPamfAc3Info> pInfo(pInfo_addr);
-			mem_ptr_t<PamfStreamHeader_Audio> pAudio(pSelf->pAddr + 0x98 + pSelf->stream * 0x30);
+			auto pInfo = vm::ptr<CellPamfAc3Info>::make(pInfo_addr);
+			auto pAudio = vm::ptr<PamfStreamHeader_Audio>::make(pSelf->pAddr + 0x98 + pSelf->stream * 0x30);
 
 			if (size != sizeof(CellPamfAc3Info))
 			{
@@ -464,8 +464,8 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
 		break;
 	case CELL_PAMF_STREAM_TYPE_PAMF_LPCM:
 		{
-			mem_ptr_t<CellPamfLpcmInfo> pInfo(pInfo_addr);
-			mem_ptr_t<PamfStreamHeader_Audio> pAudio(pSelf->pAddr + 0x98 + pSelf->stream * 0x30);
+			auto pInfo = vm::ptr<CellPamfLpcmInfo>::make(pInfo_addr);
+			auto pAudio = vm::ptr<PamfStreamHeader_Audio>::make(pSelf->pAddr + 0x98 + pSelf->stream * 0x30);
 
 			if (size != sizeof(CellPamfLpcmInfo))
 			{
@@ -493,46 +493,46 @@ int cellPamfReaderGetStreamInfo(mem_ptr_t<CellPamfReader> pSelf, u32 pInfo_addr,
 	return CELL_OK;
 }
 
-int cellPamfReaderGetNumberOfEp(mem_ptr_t<CellPamfReader> pSelf)
+int cellPamfReaderGetNumberOfEp(vm::ptr<CellPamfReader> pSelf)
 {
-	cellPamf->Warning("cellPamfReaderGetNumberOfEp(pSelf=0x%x, stream=%d)", pSelf.GetAddr(), pSelf->stream);
+	cellPamf->Warning("cellPamfReaderGetNumberOfEp(pSelf=0x%x, stream=%d)", pSelf.addr(), pSelf->stream);
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);	
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);	
 	return pAddr->stream_headers[pSelf->stream].ep_num;
 }
 
-int cellPamfReaderGetEpIteratorWithIndex(mem_ptr_t<CellPamfReader> pSelf, u32 epIndex, mem_ptr_t<CellPamfEpIterator> pIt)
+int cellPamfReaderGetEpIteratorWithIndex(vm::ptr<CellPamfReader> pSelf, u32 epIndex, vm::ptr<CellPamfEpIterator> pIt)
 {
-	cellPamf->Todo("cellPamfReaderGetEpIteratorWithIndex(pSelf=0x%x, stream=%d, epIndex=%d, pIt_addr=0x%x)", pSelf.GetAddr(), pSelf->stream, epIndex, pIt.GetAddr());
+	cellPamf->Todo("cellPamfReaderGetEpIteratorWithIndex(pSelf=0x%x, stream=%d, epIndex=%d, pIt_addr=0x%x)", pSelf.addr(), pSelf->stream, epIndex, pIt.addr());
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 	//TODO:
 	return CELL_OK;
 }
 
-int cellPamfReaderGetEpIteratorWithTimeStamp(mem_ptr_t<CellPamfReader> pSelf, mem_ptr_t<CellCodecTimeStamp> pTimeStamp, mem_ptr_t<CellPamfEpIterator> pIt)
+int cellPamfReaderGetEpIteratorWithTimeStamp(vm::ptr<CellPamfReader> pSelf, vm::ptr<CellCodecTimeStamp> pTimeStamp, vm::ptr<CellPamfEpIterator> pIt)
 {
-	cellPamf->Todo("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=0x%x, pTimeStamp_addr=0x%x, pIt_addr=0x%x)", pSelf.GetAddr(), pTimeStamp.GetAddr(), pIt.GetAddr());
+	cellPamf->Todo("cellPamfReaderGetEpIteratorWithTimeStamp(pSelf=0x%x, pTimeStamp_addr=0x%x, pIt_addr=0x%x)", pSelf.addr(), pTimeStamp.addr(), pIt.addr());
 
-	const mem_ptr_t<PamfHeader> pAddr(pSelf->pAddr);
+	const vm::ptr<PamfHeader> pAddr(pSelf->pAddr);
 
 	//TODO:
 
 	return CELL_OK;
 }
 
-int cellPamfEpIteratorGetEp(mem_ptr_t<CellPamfEpIterator> pIt, mem_ptr_t<CellPamfEp> pEp)
+int cellPamfEpIteratorGetEp(vm::ptr<CellPamfEpIterator> pIt, vm::ptr<CellPamfEp> pEp)
 {
-	cellPamf->Todo("cellPamfEpIteratorGetEp(pIt_addr=0x%x, pEp_addr=0x%x)", pIt.GetAddr(), pEp.GetAddr());
+	cellPamf->Todo("cellPamfEpIteratorGetEp(pIt_addr=0x%x, pEp_addr=0x%x)", pIt.addr(), pEp.addr());
 
 	//TODO:
 
 	return CELL_OK;
 }
 
-int cellPamfEpIteratorMove(mem_ptr_t<CellPamfEpIterator> pIt, s32 steps, mem_ptr_t<CellPamfEp> pEp)
+int cellPamfEpIteratorMove(vm::ptr<CellPamfEpIterator> pIt, s32 steps, vm::ptr<CellPamfEp> pEp)
 {
-	cellPamf->Todo("cellPamfEpIteratorMove(pIt_addr=0x%x, steps=%d, pEp_addr=0x%x)", pIt.GetAddr(), steps, pEp.GetAddr());
+	cellPamf->Todo("cellPamfEpIteratorMove(pIt_addr=0x%x, steps=%d, pEp_addr=0x%x)", pIt.addr(), steps, pEp.addr());
 
 	//TODO:
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPamf.h b/rpcs3/Emu/SysCalls/Modules/cellPamf.h
index fd1b9a6a7e..468d735ed9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPamf.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellPamf.h
@@ -330,7 +330,7 @@ struct CellPamfReader
 {
 	//this struct can be used in any way, if it is not accessed directly by virtual CPU
 	//be_t<u64> internalData[16];
-	u32 pAddr;
+	vm::ptr<PamfHeader> pAddr;
 	int stream;
 	u64 fileSize;
 	u32 internalData[28];
diff --git a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
index daf21dded9..1342119fe2 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp
@@ -51,10 +51,10 @@ int cellPngDecDestroy(u32 mainHandle)
 	return CELL_OK;
 }
 
-int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo)
+int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellPngDecSrc> src, u32 openInfo)
 {
 	cellPngDec->Warning("cellPngDecOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x)",
-		mainHandle, subHandle.addr(), src.GetAddr(), openInfo);
+		mainHandle, subHandle.addr(), src.addr(), openInfo);
 
 	CellPngDecSubHandle *current_subHandle = new CellPngDecSubHandle;
 	current_subHandle->fd = 0;
@@ -75,7 +75,7 @@ int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellP
 
 		// Get size of file
 		vm::var<CellFsStat> sb; // Alloc a CellFsStat struct
-		ret = cellFsFstat(current_subHandle->fd, sb.addr());
+		ret = cellFsFstat(current_subHandle->fd, sb);
 		if(ret != CELL_OK) return ret;
 		current_subHandle->fileSize = sb->st_size;	// Get CellFsStat.st_size
 		break;
@@ -87,10 +87,10 @@ int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellP
 	return CELL_OK;
 }
 
-int cellPngDecExtOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, mem_ptr_t<CellPngDecSrc> src, u32 openInfo, mem_ptr_t<CellPngDecCbCtrlStrm> cbCtrlStrm, mem_ptr_t<CellPngDecOpnParam> opnParam)
+int cellPngDecExtOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellPngDecSrc> src, u32 openInfo, vm::ptr<CellPngDecCbCtrlStrm> cbCtrlStrm, vm::ptr<CellPngDecOpnParam> opnParam)
 {
 	cellPngDec->Warning("cellPngDecExtOpen(mainHandle=0x%x, subHandle=0x%x, src_addr=0x%x, openInfo=0x%x, cbCtrlStrm_addr=0x%x, opnParam=0x%x)",
-		mainHandle, subHandle.addr(), src.GetAddr(), openInfo, cbCtrlStrm.GetAddr(), opnParam.GetAddr());
+		mainHandle, subHandle.addr(), src.addr(), openInfo, cbCtrlStrm.addr(), opnParam.addr());
 
 	cellPngDec->Warning("*** cbCtrlStrm->cbCtrlStrmFunc_addr=0x%x", cbCtrlStrm->cbCtrlStrmFunc.addr());
 
@@ -118,9 +118,9 @@ int cellPngDecClose(u32 mainHandle, u32 subHandle)
 	return CELL_OK;
 }
 
-int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo> info)
+int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellPngDecInfo> info)
 {
-	cellPngDec->Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)", mainHandle, subHandle, info.GetAddr());
+	cellPngDec->Warning("cellPngDecReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x)", mainHandle, subHandle, info.addr());
 	CellPngDecSubHandle* subHandle_data;
 	if(!cellPngDec->CheckId(subHandle, subHandle_data))
 		return CELL_PNGDEC_ERROR_FATAL;
@@ -176,18 +176,18 @@ int cellPngDecReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo
 	return CELL_OK;
 }
 
-int cellPngDecExtReadHeader(u32 mainHandle, u32 subHandle, mem_ptr_t<CellPngDecInfo> info, mem_ptr_t<CellPngDecExtInfo> extInfo)
+int cellPngDecExtReadHeader(u32 mainHandle, u32 subHandle, vm::ptr<CellPngDecInfo> info, vm::ptr<CellPngDecExtInfo> extInfo)
 {
 	cellPngDec->Warning("cellPngDecExtReadHeader(mainHandle=0x%x, subHandle=0x%x, info_addr=0x%x, extInfo_addr=0x%x)",
-		mainHandle, subHandle, info.GetAddr(), extInfo.GetAddr());
+		mainHandle, subHandle, info.addr(), extInfo.addr());
 
 	return cellPngDecReadHeader(mainHandle, subHandle, info);
 }
 
-int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellPngDecDataCtrlParam> dataCtrlParam, mem_ptr_t<CellPngDecDataOutInfo> dataOutInfo)
+int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const vm::ptr<CellPngDecDataCtrlParam> dataCtrlParam, vm::ptr<CellPngDecDataOutInfo> dataOutInfo)
 {
 	cellPngDec->Warning("cellPngDecDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x)",
-		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.addr(), dataOutInfo.addr());
 
 	dataOutInfo->status = CELL_PNGDEC_DEC_STATUS_STOP;
 	CellPngDecSubHandle* subHandle_data;
@@ -308,21 +308,21 @@ int cellPngDecDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const
 	return CELL_OK;
 }
 
-int cellPngDecExtDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const mem_ptr_t<CellPngDecDataCtrlParam> dataCtrlParam,
-	mem_ptr_t<CellPngDecDataOutInfo> dataOutInfo, mem_ptr_t<CellPngDecCbCtrlDisp> cbCtrlDisp, mem_ptr_t<CellPngDecDispParam> dispParam)
+int cellPngDecExtDecodeData(u32 mainHandle, u32 subHandle, vm::ptr<u8> data, const vm::ptr<CellPngDecDataCtrlParam> dataCtrlParam,
+	vm::ptr<CellPngDecDataOutInfo> dataOutInfo, vm::ptr<CellPngDecCbCtrlDisp> cbCtrlDisp, vm::ptr<CellPngDecDispParam> dispParam)
 {
 	cellPngDec->Warning("cellPngDecExtDecodeData(mainHandle=0x%x, subHandle=0x%x, data_addr=0x%x, dataCtrlParam_addr=0x%x, dataOutInfo_addr=0x%x, cbCtrlDisp_addr=0x%x, dispParam=0x%x)",
-		mainHandle, subHandle, data.addr(), dataCtrlParam.GetAddr(), dataOutInfo.GetAddr(), cbCtrlDisp.GetAddr(), dispParam.GetAddr());
+		mainHandle, subHandle, data.addr(), dataCtrlParam.addr(), dataOutInfo.addr(), cbCtrlDisp.addr(), dispParam.addr());
 
-	if (cbCtrlDisp.GetAddr()) cellPngDec->Warning("*** cbCtrlDisp->cbCtrlDispFunc_addr=0x%x", (u32)cbCtrlDisp->cbCtrlDispFunc_addr);
+	if (cbCtrlDisp) cellPngDec->Warning("*** cbCtrlDisp->cbCtrlDispFunc_addr=0x%x", (u32)cbCtrlDisp->cbCtrlDispFunc_addr);
 
 	return cellPngDecDecodeData(mainHandle, subHandle, data, dataCtrlParam, dataOutInfo);
 }
 
-int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellPngDecInParam> inParam, mem_ptr_t<CellPngDecOutParam> outParam)
+int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, const vm::ptr<CellPngDecInParam> inParam, vm::ptr<CellPngDecOutParam> outParam)
 {
 	cellPngDec->Warning("cellPngDecSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x)",
-		mainHandle, subHandle, inParam.GetAddr(), outParam.GetAddr());
+		mainHandle, subHandle, inParam.addr(), outParam.addr());
 
 	CellPngDecSubHandle* subHandle_data;
 	if(!cellPngDec->CheckId(subHandle, subHandle_data))
@@ -360,11 +360,11 @@ int cellPngDecSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellPn
 	return CELL_OK;
 }
 
-int cellPngDecExtSetParameter(u32 mainHandle, u32 subHandle, const mem_ptr_t<CellPngDecInParam> inParam, mem_ptr_t<CellPngDecOutParam> outParam,
-	mem_ptr_t<CellPngDecExtInParam> extInParam, mem_ptr_t<CellPngDecExtOutParam> extOutParam)
+int cellPngDecExtSetParameter(u32 mainHandle, u32 subHandle, const vm::ptr<CellPngDecInParam> inParam, vm::ptr<CellPngDecOutParam> outParam,
+	vm::ptr<CellPngDecExtInParam> extInParam, vm::ptr<CellPngDecExtOutParam> extOutParam)
 {
 	cellPngDec->Warning("cellPngDecExtSetParameter(mainHandle=0x%x, subHandle=0x%x, inParam_addr=0x%x, outParam_addr=0x%x, extInParam=0x%x, extOutParam=0x%x",
-		mainHandle, subHandle, inParam.GetAddr(), outParam.GetAddr(), extInParam.GetAddr(), extOutParam.GetAddr());
+		mainHandle, subHandle, inParam.addr(), outParam.addr(), extInParam.addr(), extOutParam.addr());
 
 	return cellPngDecSetParameter(mainHandle, subHandle, inParam, outParam);
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
index c780234cb8..4759d3eeba 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.cpp
@@ -37,7 +37,7 @@ void BuildupVertexBufferNR()
 	float U_PS0 = UV_CENTER - U_PS;
 	float U_PS1 = UV_CENTER + U_PS;
 
-	mem_ptr_t<RescVertex_t> vv(s_rescInternalInstance->m_vertexArrayEA);
+	auto vv = vm::ptr<RescVertex_t>::make(s_rescInternalInstance->m_vertexArrayEA);
 
 	if (s_rescInternalInstance->m_dstMode == CELL_RESC_720x480 || s_rescInternalInstance->m_dstMode == CELL_RESC_720x576)
 	{
@@ -127,7 +127,7 @@ void BuildupVertexBufferUN(s32 srcIdx)
 	float U2_FS1 = (float)s_rescInternalInstance->m_dstWidth;
 	float V2_FS1 = (float)s_rescInternalInstance->m_dstHeight;
 
-	mem_ptr_t<RescVertex_t> vv(s_rescInternalInstance->m_vertexArrayEA);
+	auto vv = vm::ptr<RescVertex_t>::make(s_rescInternalInstance->m_vertexArrayEA);
 
 	if (s_rescInternalInstance->m_dstMode == CELL_RESC_720x480 || s_rescInternalInstance->m_dstMode == CELL_RESC_720x576)
 	{
@@ -171,7 +171,7 @@ UN_PANSCAN:
 	return;
 }
 
-inline int InternalVersion(mem_ptr_t<CellRescInitConfig> conf)
+inline int InternalVersion(vm::ptr<CellRescInitConfig> conf)
 {
 	switch ((u32)conf->size)
 	{
@@ -323,7 +323,7 @@ int CalculateMaxColorBuffersSize()
 	return maxBufSize;
 }
 
-bool CheckInitConfig(mem_ptr_t<CellRescInitConfig> initConfig)
+bool CheckInitConfig(vm::ptr<CellRescInitConfig> initConfig)
 {
 	if ((initConfig->resourcePolicy & ~((u32)0x3)) || (initConfig->supportModes & 0xF) == 0 || (initConfig->ratioMode > 2) || (initConfig->palTemporalMode > 5))
 	{
@@ -426,7 +426,7 @@ void InitMembers()
 	}
 }
 
-void SetupRsxRenderingStates(mem_ptr_t<CellGcmContextData>& cntxt)
+void SetupRsxRenderingStates(vm::ptr<CellGcmContextData>& cntxt)
 {
 	//TODO: use cntxt
 	GSLockCurrent lock(GS_LOCK_WAIT_FLUSH);
@@ -473,7 +473,7 @@ void SetupRsxRenderingStates(mem_ptr_t<CellGcmContextData>& cntxt)
 	}
 }
 
-void SetupVertexArrays(mem_ptr_t<CellGcmContextData>& cntxt)
+void SetupVertexArrays(vm::ptr<CellGcmContextData>& cntxt)
 {
 	GSLockCurrent lock(GS_LOCK_WAIT_FLUSH);
 	GSRender& r = Emu.GetGSManager().GetRender();
@@ -481,7 +481,7 @@ void SetupVertexArrays(mem_ptr_t<CellGcmContextData>& cntxt)
 	//TODO
 }
 
-void SetupSurfaces(mem_ptr_t<CellGcmContextData>& cntxt)
+void SetupSurfaces(vm::ptr<CellGcmContextData>& cntxt)
 {
 	bool isMrt;
 	u32 dstOffset0, dstOffset1;
@@ -529,9 +529,9 @@ void SetupSurfaces(mem_ptr_t<CellGcmContextData>& cntxt)
 }
 
 // Module Functions
-int cellRescInit(mem_ptr_t<CellRescInitConfig> initConfig)
+int cellRescInit(vm::ptr<CellRescInitConfig> initConfig)
 {
-	cellResc->Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.GetAddr());
+	cellResc->Warning("cellRescInit(initConfig_addr=0x%x)", initConfig.addr());
 
 	if (s_rescInternalInstance->m_bInitialized)
 	{
@@ -539,7 +539,7 @@ int cellRescInit(mem_ptr_t<CellRescInitConfig> initConfig)
 		return CELL_RESC_ERROR_REINITIALIZED;
 	}
 
-	if (InternalVersion(initConfig.GetAddr()) == -1 || !CheckInitConfig(initConfig))
+	if (InternalVersion(initConfig) == -1 || !CheckInitConfig(initConfig))
 	{
 		cellResc->Error("cellRescInit : CELL_RESC_ERROR_BAD_ARGUMENT");
 		return CELL_RESC_ERROR_BAD_ARGUMENT;
@@ -608,9 +608,9 @@ int cellRescVideoOutResolutionId2RescBufferMode(u32 resolutionId, vm::ptr<be_t<u
 	return CELL_OK;
 }
 
-int cellRescSetDsts(u32 dstsMode, mem_ptr_t<CellRescDsts> dsts)
+int cellRescSetDsts(u32 dstsMode, vm::ptr<CellRescDsts> dsts)
 {
-	cellResc->Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.GetAddr());
+	cellResc->Log("cellRescSetDsts(dstsMode=%d, CellRescDsts_addr=0x%x)", dstsMode, dsts.addr());
 
 	if (!s_rescInternalInstance->m_bInitialized)
 	{
@@ -885,9 +885,9 @@ int cellRescGetNumColorBuffers(u32 dstMode, u32 palTemporalMode, u32 reserved)
 		: 2;
 }
 
-int cellRescGcmSurface2RescSrc(mem_ptr_t<CellGcmSurface> gcmSurface, mem_ptr_t<CellRescSrc> rescSrc)
+int cellRescGcmSurface2RescSrc(vm::ptr<CellGcmSurface> gcmSurface, vm::ptr<CellRescSrc> rescSrc)
 {
-	cellResc->Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.GetAddr(), rescSrc.GetAddr());
+	cellResc->Log("cellRescGcmSurface2RescSrc(gcmSurface_addr=0x%x, rescSrc_addr=0x%x)", gcmSurface.addr(), rescSrc.addr());
 
 	u8 textureFormat = GcmSurfaceFormat2GcmTextureFormat(gcmSurface->colorFormat, gcmSurface->type);
 	s32 xW = 1, xH = 1;
@@ -916,9 +916,9 @@ int cellRescGcmSurface2RescSrc(mem_ptr_t<CellGcmSurface> gcmSurface, mem_ptr_t<C
 	return CELL_OK;
 }
 
-int cellRescSetSrc(s32 idx, mem_ptr_t<CellRescSrc> src)
+int cellRescSetSrc(s32 idx, vm::ptr<CellRescSrc> src)
 {
-	cellResc->Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.GetAddr());
+	cellResc->Log("cellRescSetSrc(idx=0x%x, src_addr=0x%x)", idx, src.addr());
 
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
@@ -951,9 +951,9 @@ int cellRescSetSrc(s32 idx, mem_ptr_t<CellRescSrc> src)
 	return 0;
 }
 
-int cellRescSetConvertAndFlip(mem_ptr_t<CellGcmContextData> cntxt, s32 idx)
+int cellRescSetConvertAndFlip(vm::ptr<CellGcmContextData> cntxt, s32 idx)
 {
-	cellResc->Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.GetAddr(), idx);
+	cellResc->Log("cellRescSetConvertAndFlip(cntxt_addr=0x%x, indx=0x%x)", cntxt.addr(), idx);
 
 	if(!s_rescInternalInstance->m_bInitialized)
 	{
diff --git a/rpcs3/Emu/SysCalls/Modules/cellResc.h b/rpcs3/Emu/SysCalls/Modules/cellResc.h
index 5ad753e197..9e3d2fa16e 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellResc.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellResc.h
@@ -155,7 +155,7 @@ extern void cellGcmSetFlipHandler(u32 handler_addr);
 extern void cellGcmSetVBlankHandler(u32 handler_addr);
 extern int cellGcmAddressToOffset(u64 address, vm::ptr<be_t<u32>> offset);
 extern int cellGcmSetDisplayBuffer(u32 id, u32 offset, u32 pitch, u32 width, u32 height);
-extern int cellGcmSetPrepareFlip(mem_ptr_t<CellGcmContextData> ctx, u32 id);
+extern int cellGcmSetPrepareFlip(vm::ptr<CellGcmContextData> ctx, u32 id);
 extern int cellGcmSetSecondVFrequency(u32 freq);
 extern u32 cellGcmGetLabelAddress(u8 index);
 extern u32 cellGcmGetTiledPitchSize(u32 size);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
index 6449393eba..d6dd962c2b 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellRtc.cpp
@@ -24,18 +24,18 @@ u64 convertToWin32FILETIME(u16 seconds, u16 minutes, u16 hours, u16 days, int ye
 	return win32filetime;
 }
 
-int cellRtcGetCurrentTick(mem_ptr_t<CellRtcTick> pTick)
+int cellRtcGetCurrentTick(vm::ptr<CellRtcTick> pTick)
 {
-	cellRtc->Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.GetAddr());
+	cellRtc->Log("cellRtcGetCurrentTick(pTick=0x%x)", pTick.addr());
 
 	rDateTime unow = rDateTime::UNow();
 	pTick->tick = unow.GetTicks();
 	return CELL_OK;
 }
 
-int cellRtcGetCurrentClock(mem_ptr_t<CellRtcDateTime> pClock, s32 iTimeZone)
+int cellRtcGetCurrentClock(vm::ptr<CellRtcDateTime> pClock, s32 iTimeZone)
 {
-	cellRtc->Log("cellRtcGetCurrentClock(pClock=0x%x, time_zone=%d)", pClock.GetAddr(), iTimeZone);
+	cellRtc->Log("cellRtcGetCurrentClock(pClock=0x%x, time_zone=%d)", pClock.addr(), iTimeZone);
 
 	rDateTime unow = rDateTime::UNow();
 
@@ -54,9 +54,9 @@ int cellRtcGetCurrentClock(mem_ptr_t<CellRtcDateTime> pClock, s32 iTimeZone)
 	return CELL_OK;
 }
 
-int cellRtcGetCurrentClockLocalTime(mem_ptr_t<CellRtcDateTime> pClock)
+int cellRtcGetCurrentClockLocalTime(vm::ptr<CellRtcDateTime> pClock)
 {
-	cellRtc->Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.GetAddr());
+	cellRtc->Log("cellRtcGetCurrentClockLocalTime(pClock=0x%x)", pClock.addr());
 
 	rDateTime unow = rDateTime::UNow();
 
@@ -71,9 +71,9 @@ int cellRtcGetCurrentClockLocalTime(mem_ptr_t<CellRtcDateTime> pClock)
 	return CELL_OK;
 }
 
-int cellRtcFormatRfc2822(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32 iTimeZone)
+int cellRtcFormatRfc2822(u32 pszDateTime_addr, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
 {
-	cellRtc->Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
+	cellRtc->Log("cellRtcFormatRfc2822(pszDateTime_addr=0x%x, pUtc=0x%x, time_zone=%d)", pszDateTime_addr, pUtc.addr(), iTimeZone);
 
 	// Add time_zone as offset in minutes.
 	rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
@@ -89,9 +89,9 @@ int cellRtcFormatRfc2822(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32
 	return CELL_OK;
 }
 
-int cellRtcFormatRfc2822LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc)
+int cellRtcFormatRfc2822LocalTime(u32 pszDateTime_addr, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc->Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
+	cellRtc->Log("cellRtcFormatRfc2822LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.addr());
 
 	// Get date from ticks.
 	rDateTime date = rDateTime((time_t)pUtc->tick);
@@ -103,9 +103,9 @@ int cellRtcFormatRfc2822LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> p
 	return CELL_OK;
 }
 
-int cellRtcFormatRfc3339(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32 iTimeZone)
+int cellRtcFormatRfc3339(u32 pszDateTime_addr, vm::ptr<CellRtcTick> pUtc, s32 iTimeZone)
 {
-	cellRtc->Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime_addr, pUtc.GetAddr(), iTimeZone);
+	cellRtc->Log("cellRtcFormatRfc3339(pszDateTime_addr=0x%x, pUtc=0x%x, iTimeZone=%d)", pszDateTime_addr, pUtc.addr(), iTimeZone);
 	
 	// Add time_zone as offset in minutes.
 	rTimeSpan tz = rTimeSpan(0, (long) iTimeZone, 0, 0);
@@ -121,9 +121,9 @@ int cellRtcFormatRfc3339(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc, s32
 	return CELL_OK;
 }
 
-int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> pUtc)
+int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc->Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.GetAddr());
+	cellRtc->Log("cellRtcFormatRfc3339LocalTime(pszDateTime_addr=0x%x, pUtc=0x%x)", pszDateTime_addr, pUtc.addr());
 	
 	// Get date from ticks.
 	rDateTime date = rDateTime((time_t) pUtc->tick);
@@ -135,9 +135,9 @@ int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, mem_ptr_t<CellRtcTick> p
 	return CELL_OK;
 }
 
-int cellRtcParseDateTime(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
+int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, u32 pszDateTime_addr)
 {
-	cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
+	cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime_addr);
 
 	// Get date from formatted string.
 	rDateTime date;
@@ -149,9 +149,9 @@ int cellRtcParseDateTime(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
 	return CELL_OK;
 }
 
-int cellRtcParseRfc3339(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
+int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, u32 pszDateTime_addr)
 {
-	cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.GetAddr(), pszDateTime_addr);
+	cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime_addr);
 
 	// Get date from RFC3339 formatted string.
 	rDateTime date;
@@ -163,9 +163,9 @@ int cellRtcParseRfc3339(mem_ptr_t<CellRtcTick> pUtc, u32 pszDateTime_addr)
 	return CELL_OK;
 }
 
-int cellRtcGetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTick)
+int cellRtcGetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
 {
-	cellRtc->Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
+	cellRtc->Log("cellRtcGetTick(pTime=0x%x, pTick=0x%x)", pTime.addr(), pTick.addr());
 
 	rDateTime datetime = rDateTime(pTime->day, (rDateTime::Month)pTime->month.ToLE(), pTime->year, pTime->hour, pTime->minute, pTime->second, (pTime->microsecond / 1000));
 	pTick->tick = datetime.GetTicks();
@@ -173,9 +173,9 @@ int cellRtcGetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTic
 	return CELL_OK;
 }
 
-int cellRtcSetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTick)
+int cellRtcSetTick(vm::ptr<CellRtcDateTime> pTime, vm::ptr<CellRtcTick> pTick)
 {
-	cellRtc->Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.GetAddr(), pTick.GetAddr());
+	cellRtc->Log("cellRtcSetTick(pTime=0x%x, pTick=0x%x)", pTime.addr(), pTick.addr());
 	
 	rDateTime date = rDateTime((time_t)pTick->tick);
 
@@ -190,17 +190,17 @@ int cellRtcSetTick(mem_ptr_t<CellRtcDateTime> pTime, mem_ptr_t<CellRtcTick> pTic
 	return CELL_OK;
 }
 
-int cellRtcTickAddTicks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
+int cellRtcTickAddTicks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc->Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
+	cellRtc->Log("cellRtcTickAddTicks(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
 
 	pTick0->tick = pTick1->tick + lAdd;
 	return CELL_OK;
 }
 
-int cellRtcTickAddMicroseconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
+int cellRtcTickAddMicroseconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc->Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
+	cellRtc->Log("cellRtcTickAddMicroseconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
 	
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan microseconds = rTimeSpan(0, 0, 0, lAdd / 1000);
@@ -210,9 +210,9 @@ int cellRtcTickAddMicroseconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcT
 	return CELL_OK;
 }
 
-int cellRtcTickAddSeconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
+int cellRtcTickAddSeconds(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc->Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
+	cellRtc->Log("cellRtcTickAddSeconds(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan seconds = rTimeSpan(0, 0, lAdd, 0);
@@ -222,9 +222,9 @@ int cellRtcTickAddSeconds(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick>
 	return CELL_OK;
 }
 
-int cellRtcTickAddMinutes(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s64 lAdd)
+int cellRtcTickAddMinutes(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s64 lAdd)
 {
-	cellRtc->Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.GetAddr(), pTick1.GetAddr(), lAdd);
+	cellRtc->Log("cellRtcTickAddMinutes(pTick0=0x%x, pTick1=0x%x, lAdd=%lld)", pTick0.addr(), pTick1.addr(), lAdd);
 	
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan minutes = rTimeSpan(0, lAdd, 0, 0); // ???
@@ -234,9 +234,9 @@ int cellRtcTickAddMinutes(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick>
 	return CELL_OK;
 }
 
-int cellRtcTickAddHours(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
+int cellRtcTickAddHours(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc->Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
+	cellRtc->Log("cellRtcTickAddHours(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rTimeSpan hours = rTimeSpan(iAdd, 0, 0, 0); // ???
@@ -246,9 +246,9 @@ int cellRtcTickAddHours(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
 	return CELL_OK;
 }
 
-int cellRtcTickAddDays(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
+int cellRtcTickAddDays(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc->Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
+	cellRtc->Log("cellRtcTickAddDays(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan days = rDateSpan(0, 0, 0, iAdd); // ???
@@ -258,9 +258,9 @@ int cellRtcTickAddDays(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTi
 	return CELL_OK;
 }
 
-int cellRtcTickAddWeeks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
+int cellRtcTickAddWeeks(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc->Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
+	cellRtc->Log("cellRtcTickAddWeeks(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan weeks = rDateSpan(0, 0, iAdd, 0);
@@ -270,9 +270,9 @@ int cellRtcTickAddWeeks(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
 	return CELL_OK;
 }
 
-int cellRtcTickAddMonths(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
+int cellRtcTickAddMonths(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc->Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
+	cellRtc->Log("cellRtcTickAddMonths(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan months = rDateSpan(0, iAdd, 0, 0);
@@ -282,9 +282,9 @@ int cellRtcTickAddMonths(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> p
 	return CELL_OK;
 }
 
-int cellRtcTickAddYears(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1, s32 iAdd)
+int cellRtcTickAddYears(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1, s32 iAdd)
 {
-	cellRtc->Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.GetAddr(), pTick1.GetAddr(), iAdd);
+	cellRtc->Log("cellRtcTickAddYears(pTick0=0x%x, pTick1=0x%x, iAdd=%d)", pTick0.addr(), pTick1.addr(), iAdd);
 
 	rDateTime date = rDateTime((time_t)pTick1->tick);
 	rDateSpan years = rDateSpan(iAdd, 0, 0, 0);
@@ -294,9 +294,9 @@ int cellRtcTickAddYears(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pT
 	return CELL_OK;
 }
 
-int cellRtcConvertUtcToLocalTime(mem_ptr_t<CellRtcTick> pUtc, mem_ptr_t<CellRtcTick> pLocalTime)
+int cellRtcConvertUtcToLocalTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<CellRtcTick> pLocalTime)
 {
-	cellRtc->Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.GetAddr(), pLocalTime.GetAddr());
+	cellRtc->Log("cellRtcConvertUtcToLocalTime(pUtc=0x%x, pLocalTime=0x%x)", pUtc.addr(), pLocalTime.addr());
 
 	rDateTime time = rDateTime((time_t)pUtc->tick);
 	rDateTime local_time = time.FromUTC(false);
@@ -304,9 +304,9 @@ int cellRtcConvertUtcToLocalTime(mem_ptr_t<CellRtcTick> pUtc, mem_ptr_t<CellRtcT
 	return CELL_OK;
 }
 
-int cellRtcConvertLocalTimeToUtc(mem_ptr_t<CellRtcTick> pLocalTime, mem_ptr_t<CellRtcTick> pUtc)
+int cellRtcConvertLocalTimeToUtc(vm::ptr<CellRtcTick> pLocalTime, vm::ptr<CellRtcTick> pUtc)
 {
-	cellRtc->Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.GetAddr(), pUtc.GetAddr());
+	cellRtc->Log("cellRtcConvertLocalTimeToUtc(pLocalTime=0x%x, pUtc=0x%x)", pLocalTime.addr(), pUtc.addr());
 
 	rDateTime time = rDateTime((time_t)pLocalTime->tick);
 	rDateTime utc_time = time.ToUTC(false);
@@ -314,9 +314,9 @@ int cellRtcConvertLocalTimeToUtc(mem_ptr_t<CellRtcTick> pLocalTime, mem_ptr_t<Ce
 	return CELL_OK;
 }
 
-int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<u32>> puiDosTime)
+int cellRtcGetDosTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<be_t<u32>> puiDosTime)
 {
-	cellRtc->Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.GetAddr(), puiDosTime.addr());
+	cellRtc->Log("cellRtcGetDosTime(pDateTime=0x%x, puiDosTime=0x%x)", pDateTime.addr(), puiDosTime.addr());
 
 	// Convert to DOS time.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
@@ -325,9 +325,9 @@ int cellRtcGetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<u32>> p
 	return CELL_OK;
 }
 
-int cellRtcGetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<s64>> piTime)
+int cellRtcGetTime_t(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<be_t<s64>> piTime)
 {
-	cellRtc->Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.GetAddr(), piTime.addr());
+	cellRtc->Log("cellRtcGetTime_t(pDateTime=0x%x, piTime=0x%x)", pDateTime.addr(), piTime.addr());
 
 	// Convert to POSIX time_t.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
@@ -337,9 +337,9 @@ int cellRtcGetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<s64>> pi
 	return CELL_OK;
 }
 
-int cellRtcGetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<u64>> pulWin32FileTime)
+int cellRtcGetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, vm::ptr<be_t<u64>> pulWin32FileTime)
 {
-	cellRtc->Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.GetAddr(), pulWin32FileTime.addr());
+	cellRtc->Log("cellRtcGetWin32FileTime(pDateTime=0x%x, pulWin32FileTime=0x%x)", pDateTime.addr(), pulWin32FileTime.addr());
 
 	// Convert to WIN32 FILETIME.
 	rDateTime date_time = rDateTime(pDateTime->day, (rDateTime::Month)pDateTime->month.ToLE(), pDateTime->year, pDateTime->hour, pDateTime->minute, pDateTime->second, (pDateTime->microsecond / 1000));
@@ -349,9 +349,9 @@ int cellRtcGetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, vm::ptr<be_t<u
 	return CELL_OK;
 }
 
-int cellRtcSetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, u32 uiDosTime)
+int cellRtcSetDosTime(vm::ptr<CellRtcDateTime> pDateTime, u32 uiDosTime)
 {
-	cellRtc->Log("cellRtcSetDosTime(pDateTime=0x%x, uiDosTime=0x%x)", pDateTime.GetAddr(), uiDosTime);
+	cellRtc->Log("cellRtcSetDosTime(pDateTime=0x%x, uiDosTime=0x%x)", pDateTime.addr(), uiDosTime);
 
 	rDateTime date_time;
 	rDateTime dos_time = date_time.SetFromDOS(uiDosTime);
@@ -367,9 +367,9 @@ int cellRtcSetDosTime(mem_ptr_t<CellRtcDateTime> pDateTime, u32 uiDosTime)
 	return CELL_OK;
 }
 
-int cellRtcSetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, u64 iTime)
+int cellRtcSetTime_t(vm::ptr<CellRtcDateTime> pDateTime, u64 iTime)
 {
-	cellRtc->Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.GetAddr(), iTime);
+	cellRtc->Log("cellRtcSetTime_t(pDateTime=0x%x, iTime=0x%llx)", pDateTime.addr(), iTime);
 
 	rDateTime date_time = rDateTime((time_t)iTime);
 	
@@ -384,7 +384,7 @@ int cellRtcSetTime_t(mem_ptr_t<CellRtcDateTime> pDateTime, u64 iTime)
 	return CELL_OK;
 }
 
-int cellRtcSetWin32FileTime(mem_ptr_t<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
+int cellRtcSetWin32FileTime(vm::ptr<CellRtcDateTime> pDateTime, u64 ulWin32FileTime)
 {
 	cellRtc->Log("cellRtcSetWin32FileTime(pDateTime=0x%x, ulWin32FileTime=0x%llx)", pDateTime, ulWin32FileTime);
 
@@ -426,9 +426,9 @@ int cellRtcGetDayOfWeek(s32 year, s32 month, s32 day)
 	return datetime.GetWeekDay();
 }
 
-int cellRtcCheckValid(mem_ptr_t<CellRtcDateTime> pTime)
+int cellRtcCheckValid(vm::ptr<CellRtcDateTime> pTime)
 {
-	cellRtc->Log("cellRtcCheckValid(pTime=0x%x)", pTime.GetAddr());
+	cellRtc->Log("cellRtcCheckValid(pTime=0x%x)", pTime.addr());
 
 	if ((pTime->year < 1) || (pTime->year > 9999)) return CELL_RTC_ERROR_INVALID_YEAR;
 	else if ((pTime->month < 1) || (pTime->month > 12)) return CELL_RTC_ERROR_INVALID_MONTH;
@@ -440,9 +440,9 @@ int cellRtcCheckValid(mem_ptr_t<CellRtcDateTime> pTime)
 	else return CELL_OK;
 }
 
-int cellRtcCompareTick(mem_ptr_t<CellRtcTick> pTick0, mem_ptr_t<CellRtcTick> pTick1)
+int cellRtcCompareTick(vm::ptr<CellRtcTick> pTick0, vm::ptr<CellRtcTick> pTick1)
 {
-	cellRtc->Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.GetAddr(), pTick1.GetAddr());
+	cellRtc->Log("cellRtcCompareTick(pTick0=0x%x, pTick1=0x%x)", pTick0.addr(), pTick1.addr());
 
 	if (pTick0->tick < pTick1->tick) return -1;
 	else if (pTick0->tick > pTick1->tick) return 1;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
index 8a606fadc0..c73b008f6c 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.cpp
@@ -14,9 +14,9 @@ extern u32 libsre;
 extern u32 libsre_rtoc;
 #endif
 
-s64 cellSpursInitialize(mem_ptr_t<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
+s64 cellSpursInitialize(vm::ptr<CellSpurs> spurs, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
 {
-	cellSpurs->Warning("cellSpursInitialize(spurs_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs.GetAddr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
+	cellSpurs->Warning("cellSpursInitialize(spurs_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)", spurs.addr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8480, libsre_rtoc);
@@ -28,9 +28,9 @@ s64 cellSpursInitialize(mem_ptr_t<CellSpurs> spurs, s32 nSpus, s32 spuPriority,
 #endif
 }
 
-s64 cellSpursFinalize(mem_ptr_t<CellSpurs> spurs)
+s64 cellSpursFinalize(vm::ptr<CellSpurs> spurs)
 {
-	cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.GetAddr());
+	cellSpurs->Warning("cellSpursFinalize(spurs_addr=0x%x)", spurs.addr());
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8568, libsre_rtoc);
@@ -41,9 +41,9 @@ s64 cellSpursFinalize(mem_ptr_t<CellSpurs> spurs)
 #endif
 }
 
-s64 cellSpursInitializeWithAttribute(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t<CellSpursAttribute> attr)
+s64 cellSpursInitializeWithAttribute(vm::ptr<CellSpurs> spurs, const vm::ptr<CellSpursAttribute> attr)
 {
-	cellSpurs->Warning("cellSpursInitializeWithAttribute(spurs_addr=0x%x, spurs_addr=0x%x)", spurs.GetAddr(), attr.GetAddr());
+	cellSpurs->Warning("cellSpursInitializeWithAttribute(spurs_addr=0x%x, spurs_addr=0x%x)", spurs.addr(), attr.addr());
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x839C, libsre_rtoc);
@@ -54,9 +54,9 @@ s64 cellSpursInitializeWithAttribute(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t
 #endif
 }
 
-s64 cellSpursInitializeWithAttribute2(mem_ptr_t<CellSpurs2> spurs, const mem_ptr_t<CellSpursAttribute> attr)
+s64 cellSpursInitializeWithAttribute2(vm::ptr<CellSpurs2> spurs, const vm::ptr<CellSpursAttribute> attr)
 {
-	cellSpurs->Warning("cellSpursInitializeWithAttribute2(spurs_addr=0x%x, spurs_addr=0x%x)", spurs.GetAddr(), attr.GetAddr());
+	cellSpurs->Warning("cellSpursInitializeWithAttribute2(spurs_addr=0x%x, spurs_addr=0x%x)", spurs.addr(), attr.addr());
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x82B4, libsre_rtoc);
@@ -67,10 +67,10 @@ s64 cellSpursInitializeWithAttribute2(mem_ptr_t<CellSpurs2> spurs, const mem_ptr
 #endif
 }
 
-s64 _cellSpursAttributeInitialize(mem_ptr_t<CellSpursAttribute> attr, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
+s64 _cellSpursAttributeInitialize(vm::ptr<CellSpursAttribute> attr, s32 nSpus, s32 spuPriority, s32 ppuPriority, bool exitIfNoWork)
 {
 	cellSpurs->Warning("_cellSpursAttributeInitialize(attr_addr=0x%x, nSpus=%d, spuPriority=%d, ppuPriority=%d, exitIfNoWork=%d)",
-		attr.GetAddr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
+		attr.addr(), nSpus, spuPriority, ppuPriority, exitIfNoWork);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x72CC, libsre_rtoc);
@@ -81,9 +81,9 @@ s64 _cellSpursAttributeInitialize(mem_ptr_t<CellSpursAttribute> attr, s32 nSpus,
 #endif
 }
 
-s64 cellSpursAttributeSetMemoryContainerForSpuThread(mem_ptr_t<CellSpursAttribute> attr, u32 container)
+s64 cellSpursAttributeSetMemoryContainerForSpuThread(vm::ptr<CellSpursAttribute> attr, u32 container)
 {
-	cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=0x%x)", attr.GetAddr(), container);
+	cellSpurs->Warning("cellSpursAttributeSetMemoryContainerForSpuThread(attr_addr=0x%x, container=0x%x)", attr.addr(), container);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x6FF8, libsre_rtoc);
@@ -94,9 +94,9 @@ s64 cellSpursAttributeSetMemoryContainerForSpuThread(mem_ptr_t<CellSpursAttribut
 #endif
 }
 
-s64 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, vm::ptr<const char> prefix, u32 size)
+s64 cellSpursAttributeSetNamePrefix(vm::ptr<CellSpursAttribute> attr, vm::ptr<const char> prefix, u32 size)
 {
-	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.GetAddr(), prefix.addr(), size);
+	cellSpurs->Warning("cellSpursAttributeSetNamePrefix(attr_addr=0x%x, prefix_addr=0x%x, size=0x%x)", attr.addr(), prefix.addr(), size);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x7234, libsre_rtoc);
@@ -113,10 +113,10 @@ s64 cellSpursAttributeSetNamePrefix(mem_ptr_t<CellSpursAttribute> attr, vm::ptr<
 #endif
 }
 
-s64 cellSpursAttributeEnableSpuPrintfIfAvailable(mem_ptr_t<CellSpursAttribute> attr)
+s64 cellSpursAttributeEnableSpuPrintfIfAvailable(vm::ptr<CellSpursAttribute> attr)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr_addr=0x%x)", attr.GetAddr());
+	cellSpurs->Warning("cellSpursAttributeEnableSpuPrintfIfAvailable(attr_addr=0x%x)", attr.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x7150, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -124,9 +124,9 @@ s64 cellSpursAttributeEnableSpuPrintfIfAvailable(mem_ptr_t<CellSpursAttribute> a
 #endif
 }
 
-s64 cellSpursAttributeSetSpuThreadGroupType(mem_ptr_t<CellSpursAttribute> attr, s32 type)
+s64 cellSpursAttributeSetSpuThreadGroupType(vm::ptr<CellSpursAttribute> attr, s32 type)
 {
-	cellSpurs->Warning("cellSpursAttributeSetSpuThreadGroupType(attr_addr=0x%x, type=%d)", attr.GetAddr(), type);
+	cellSpurs->Warning("cellSpursAttributeSetSpuThreadGroupType(attr_addr=0x%x, type=%d)", attr.addr(), type);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x70C8, libsre_rtoc);
@@ -137,10 +137,10 @@ s64 cellSpursAttributeSetSpuThreadGroupType(mem_ptr_t<CellSpursAttribute> attr,
 #endif
 }
 
-s64 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, vm::ptr<const u8> priority, u32 maxSpu, vm::ptr<const bool> isPreemptible)
+s64 cellSpursAttributeEnableSystemWorkload(vm::ptr<CellSpursAttribute> attr, vm::ptr<const u8> priority, u32 maxSpu, vm::ptr<const bool> isPreemptible)
 {
 	cellSpurs->Warning("cellSpursAttributeEnableSystemWorkload(attr_addr=0x%x, priority_addr=0x%x, maxSpu=%d, isPreemptible_addr=0x%x)",
-		attr.GetAddr(), priority.addr(), maxSpu, isPreemptible.addr());
+		attr.addr(), priority.addr(), maxSpu, isPreemptible.addr());
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0xF410, libsre_rtoc);
@@ -157,10 +157,10 @@ s64 cellSpursAttributeEnableSystemWorkload(mem_ptr_t<CellSpursAttribute> attr, v
 #endif
 }
 
-s64 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> group)
+s64 cellSpursGetSpuThreadGroupId(vm::ptr<CellSpurs> spurs, vm::ptr<be_t<u32>> group)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetSpuThreadGroupId(spurs_addr=0x%x, group_addr=0x%x)", spurs.GetAddr(), group.addr());
+	cellSpurs->Warning("cellSpursGetSpuThreadGroupId(spurs_addr=0x%x, group_addr=0x%x)", spurs.addr(), group.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8B30, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -168,10 +168,10 @@ s64 cellSpursGetSpuThreadGroupId(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>>
 #endif
 }
 
-s64 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> nThreads)
+s64 cellSpursGetNumSpuThread(vm::ptr<CellSpurs> spurs, vm::ptr<be_t<u32>> nThreads)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetNumSpuThread(spurs_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), nThreads.addr());
+	cellSpurs->Warning("cellSpursGetNumSpuThread(spurs_addr=0x%x, nThreads_addr=0x%x)", spurs.addr(), nThreads.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8B78, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -179,10 +179,10 @@ s64 cellSpursGetNumSpuThread(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> nThr
 #endif
 }
 
-s64 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> thread, vm::ptr<be_t<u32>> nThreads)
+s64 cellSpursGetSpuThreadId(vm::ptr<CellSpurs> spurs, vm::ptr<be_t<u32>> thread, vm::ptr<be_t<u32>> nThreads)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetSpuThreadId(spurs_addr=0x%x, thread_addr=0x%x, nThreads_addr=0x%x)", spurs.GetAddr(), thread.addr(), nThreads.addr());
+	cellSpurs->Warning("cellSpursGetSpuThreadId(spurs_addr=0x%x, thread_addr=0x%x, nThreads_addr=0x%x)", spurs.addr(), thread.addr(), nThreads.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8A98, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -190,10 +190,10 @@ s64 cellSpursGetSpuThreadId(mem_ptr_t<CellSpurs> spurs, vm::ptr<be_t<u32>> threa
 #endif
 }
 
-s64 cellSpursSetMaxContention(mem_ptr_t<CellSpurs> spurs, u32 workloadId, u32 maxContention)
+s64 cellSpursSetMaxContention(vm::ptr<CellSpurs> spurs, u32 workloadId, u32 maxContention)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursSetMaxContention(spurs_addr=0x%x, workloadId=%d, maxContention=%d)", spurs.GetAddr(), workloadId, maxContention);
+	cellSpurs->Warning("cellSpursSetMaxContention(spurs_addr=0x%x, workloadId=%d, maxContention=%d)", spurs.addr(), workloadId, maxContention);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8E90, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -201,10 +201,10 @@ s64 cellSpursSetMaxContention(mem_ptr_t<CellSpurs> spurs, u32 workloadId, u32 ma
 #endif
 }
 
-s64 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, vm::ptr<const u8> priorities)
+s64 cellSpursSetPriorities(vm::ptr<CellSpurs> spurs, u32 workloadId, vm::ptr<const u8> priorities)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursSetPriorities(spurs_addr=0x%x, workloadId=%d, priorities_addr=0x%x)", spurs.GetAddr(), workloadId, priorities.addr());
+	cellSpurs->Warning("cellSpursSetPriorities(spurs_addr=0x%x, workloadId=%d, priorities_addr=0x%x)", spurs.addr(), workloadId, priorities.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x8BC0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -212,10 +212,10 @@ s64 cellSpursSetPriorities(mem_ptr_t<CellSpurs> spurs, u32 workloadId, vm::ptr<c
 #endif
 }
 
-s64 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, vm::ptr<const bool> isPreemptible)
+s64 cellSpursSetPreemptionVictimHints(vm::ptr<CellSpurs> spurs, vm::ptr<const bool> isPreemptible)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursSetPreemptionVictimHints(spurs_addr=0x%x, isPreemptible_addr=0x%x)", spurs.GetAddr(), isPreemptible.addr());
+	cellSpurs->Warning("cellSpursSetPreemptionVictimHints(spurs_addr=0x%x, isPreemptible_addr=0x%x)", spurs.addr(), isPreemptible.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0xF5A4, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -223,11 +223,11 @@ s64 cellSpursSetPreemptionVictimHints(mem_ptr_t<CellSpurs> spurs, vm::ptr<const
 #endif
 }
 
-s64 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic)
+s64 cellSpursAttachLv2EventQueue(vm::ptr<CellSpurs> spurs, u32 queue, vm::ptr<u8> port, s32 isDynamic)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursAttachLv2EventQueue(spurs_addr=0x%x, queue=%d, port_addr=0x%x, isDynamic=%d)",
-		spurs.GetAddr(), queue, port.addr(), isDynamic);
+		spurs.addr(), queue, port.addr(), isDynamic);
 	return GetCurrentPPUThread().FastCall2(libsre + 0xAFE0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -235,10 +235,10 @@ s64 cellSpursAttachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u32 queue, vm::ptr<
 #endif
 }
 
-s64 cellSpursDetachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u8 port)
+s64 cellSpursDetachLv2EventQueue(vm::ptr<CellSpurs> spurs, u8 port)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursDetachLv2EventQueue(spurs_addr=0x%x, port=0x%x)", spurs.GetAddr(), port);
+	cellSpurs->Warning("cellSpursDetachLv2EventQueue(spurs_addr=0x%x, port=0x%x)", spurs.addr(), port);
 	return GetCurrentPPUThread().FastCall2(libsre + 0xB144, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -246,10 +246,10 @@ s64 cellSpursDetachLv2EventQueue(mem_ptr_t<CellSpurs> spurs, u8 port)
 #endif
 }
 
-s64 cellSpursEnableExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, bool flag)
+s64 cellSpursEnableExceptionEventHandler(vm::ptr<CellSpurs> spurs, bool flag)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEnableExceptionEventHandler(spurs_addr=0x%x, flag=%d)", spurs.GetAddr(), flag);
+	cellSpurs->Warning("cellSpursEnableExceptionEventHandler(spurs_addr=0x%x, flag=%d)", spurs.addr(), flag);
 	return GetCurrentPPUThread().FastCall2(libsre + 0xDCC0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -257,11 +257,11 @@ s64 cellSpursEnableExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, bool flag)
 #endif
 }
 
-s64 cellSpursSetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, u32 eaHandler_addr, u32 arg_addr)
+s64 cellSpursSetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs, u32 eaHandler_addr, u32 arg_addr)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursSetGlobalExceptionEventHandler(spurs_addr=0x%x, eaHandler_addr=0x%x, arg_addr=0x%x)",
-		spurs.GetAddr(), eaHandler_addr, arg_addr);
+		spurs.addr(), eaHandler_addr, arg_addr);
 	return GetCurrentPPUThread().FastCall2(libsre + 0xD6D0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -269,10 +269,10 @@ s64 cellSpursSetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs, u32 eaHa
 #endif
 }
 
-s64 cellSpursUnsetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs)
+s64 cellSpursUnsetGlobalExceptionEventHandler(vm::ptr<CellSpurs> spurs)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursUnsetGlobalExceptionEventHandler(spurs_addr=0x%x)", spurs.GetAddr());
+	cellSpurs->Warning("cellSpursUnsetGlobalExceptionEventHandler(spurs_addr=0x%x)", spurs.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0xD674, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -280,10 +280,10 @@ s64 cellSpursUnsetGlobalExceptionEventHandler(mem_ptr_t<CellSpurs> spurs)
 #endif
 }
 
-s64 cellSpursGetInfo(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursInfo> info)
+s64 cellSpursGetInfo(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursInfo> info)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetInfo(spurs_addr=0x%x, info_addr=0x%x)", spurs.GetAddr(), info.GetAddr());
+	cellSpurs->Warning("cellSpursGetInfo(spurs_addr=0x%x, info_addr=0x%x)", spurs.addr(), info.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0xE540, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -291,11 +291,11 @@ s64 cellSpursGetInfo(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursInfo> info)
 #endif
 }
 
-s64 _cellSpursEventFlagInitialize(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, mem_ptr_t<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection)
+s64 _cellSpursEventFlagInitialize(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, vm::ptr<CellSpursEventFlag> eventFlag, u32 flagClearMode, u32 flagDirection)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("_cellSpursEventFlagInitialize(spurs_addr=0x%x, taskset_addr=0x%x, eventFlag_addr=0x%x, flagClearMode=%d, flagDirection=%d)",
-		spurs.GetAddr(), taskset.GetAddr(), eventFlag.GetAddr(), flagClearMode, flagDirection);
+		spurs.addr(), taskset.addr(), eventFlag.addr(), flagClearMode, flagDirection);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x1564C, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -303,10 +303,10 @@ s64 _cellSpursEventFlagInitialize(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpur
 #endif
 }
 
-s64 cellSpursEventFlagAttachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFlag)
+s64 cellSpursEventFlagAttachLv2EventQueue(vm::ptr<CellSpursEventFlag> eventFlag)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.GetAddr());
+	cellSpurs->Warning("cellSpursEventFlagAttachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x157B8, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -314,10 +314,10 @@ s64 cellSpursEventFlagAttachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFla
 #endif
 }
 
-s64 cellSpursEventFlagDetachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFlag)
+s64 cellSpursEventFlagDetachLv2EventQueue(vm::ptr<CellSpursEventFlag> eventFlag)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.GetAddr());
+	cellSpurs->Warning("cellSpursEventFlagDetachLv2EventQueue(eventFlag_addr=0x%x)", eventFlag.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15998, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -325,10 +325,10 @@ s64 cellSpursEventFlagDetachLv2EventQueue(mem_ptr_t<CellSpursEventFlag> eventFla
 #endif
 }
 
-s64 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u16>> mask, u32 mode)
+s64 cellSpursEventFlagWait(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u16>> mask, u32 mode)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=%d)", eventFlag.GetAddr(), mask.addr(), mode);
+	cellSpurs->Warning("cellSpursEventFlagWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=%d)", eventFlag.addr(), mask.addr(), mode);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15E68, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -336,10 +336,10 @@ s64 cellSpursEventFlagWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t
 #endif
 }
 
-s64 cellSpursEventFlagClear(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
+s64 cellSpursEventFlagClear(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagClear(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.GetAddr(), bits);
+	cellSpurs->Warning("cellSpursEventFlagClear(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.addr(), bits);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15E9C, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -347,10 +347,10 @@ s64 cellSpursEventFlagClear(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 #endif
 }
 
-s64 cellSpursEventFlagSet(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
+s64 cellSpursEventFlagSet(vm::ptr<CellSpursEventFlag> eventFlag, u16 bits)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagSet(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.GetAddr(), bits);
+	cellSpurs->Warning("cellSpursEventFlagSet(eventFlag_addr=0x%x, bits=0x%x)", eventFlag.addr(), bits);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15F04, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -358,10 +358,10 @@ s64 cellSpursEventFlagSet(mem_ptr_t<CellSpursEventFlag> eventFlag, u16 bits)
 #endif
 }
 
-s64 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u16>> mask, u32 mode)
+s64 cellSpursEventFlagTryWait(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u16>> mask, u32 mode)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagTryWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=0x%x)", eventFlag.GetAddr(), mask.addr(), mode);
+	cellSpurs->Warning("cellSpursEventFlagTryWait(eventFlag_addr=0x%x, mask_addr=0x%x, mode=0x%x)", eventFlag.addr(), mask.addr(), mode);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x15E70, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -369,10 +369,10 @@ s64 cellSpursEventFlagTryWait(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<b
 #endif
 }
 
-s64 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u32>> direction)
+s64 cellSpursEventFlagGetDirection(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u32>> direction)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagGetDirection(eventFlag_addr=0x%x, direction_addr=0x%x)", eventFlag.GetAddr(), direction.addr());
+	cellSpurs->Warning("cellSpursEventFlagGetDirection(eventFlag_addr=0x%x, direction_addr=0x%x)", eventFlag.addr(), direction.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x162C4, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -380,10 +380,10 @@ s64 cellSpursEventFlagGetDirection(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::
 #endif
 }
 
-s64 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u32>> clear_mode)
+s64 cellSpursEventFlagGetClearMode(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<be_t<u32>> clear_mode)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagGetClearMode(eventFlag_addr=0x%x, clear_mode_addr=0x%x)", eventFlag.GetAddr(), clear_mode.addr());
+	cellSpurs->Warning("cellSpursEventFlagGetClearMode(eventFlag_addr=0x%x, clear_mode_addr=0x%x)", eventFlag.addr(), clear_mode.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x16310, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -391,10 +391,10 @@ s64 cellSpursEventFlagGetClearMode(mem_ptr_t<CellSpursEventFlag> eventFlag, vm::
 #endif
 }
 
-s64 cellSpursEventFlagGetTasksetAddress(mem_ptr_t<CellSpursEventFlag> eventFlag, mem_ptr_t<CellSpursTaskset> taskset)
+s64 cellSpursEventFlagGetTasksetAddress(vm::ptr<CellSpursEventFlag> eventFlag, vm::ptr<CellSpursTaskset> taskset)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursEventFlagGetTasksetAddress(eventFlag_addr=0x%x, taskset_addr=0x%x)", eventFlag.GetAddr(), taskset.GetAddr());
+	cellSpurs->Warning("cellSpursEventFlagGetTasksetAddress(eventFlag_addr=0x%x, taskset_addr=0x%x)", eventFlag.addr(), taskset.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x1635C, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -710,25 +710,25 @@ s64 cellSpursCreateTasksetWithAttribute()
 #endif
 }
 
-s64 cellSpursCreateTaskset(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, u64 args, vm::ptr<const u8> priority, u32 maxContention)
+s64 cellSpursCreateTaskset(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, u64 args, vm::ptr<const u8> priority, u32 maxContention)
 {
 	cellSpurs->Warning("cellSpursCreateTaskset(spurs_addr=0x%x, taskset_addr=0x%x, args=0x%llx, priority_addr=0x%x, maxContention=%d)",
-		spurs.GetAddr(), taskset.GetAddr(), args, priority.addr(), maxContention);
+		spurs.addr(), taskset.addr(), args, priority.addr(), maxContention);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x14CB8, libsre_rtoc);
 #else
 	SPURSManagerTasksetAttribute *tattr = new SPURSManagerTasksetAttribute(args, priority, maxContention);
-	taskset->taskset = new SPURSManagerTaskset(taskset.GetAddr(), tattr);
+	taskset->taskset = new SPURSManagerTaskset(taskset.addr(), tattr);
 
 	return CELL_OK;
 #endif
 }
 
-s64 cellSpursJoinTaskset(mem_ptr_t<CellSpursTaskset> taskset)
+s64 cellSpursJoinTaskset(vm::ptr<CellSpursTaskset> taskset)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursJoinTaskset(taskset_addr=0x%x)", taskset.GetAddr());
+	cellSpurs->Warning("cellSpursJoinTaskset(taskset_addr=0x%x)", taskset.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x152F8, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -736,10 +736,10 @@ s64 cellSpursJoinTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 #endif
 }
 
-s64 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, vm::ptr<be_t<u32>> workloadId)
+s64 cellSpursGetTasksetId(vm::ptr<CellSpursTaskset> taskset, vm::ptr<be_t<u32>> workloadId)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursGetTasksetId(taskset_addr=0x%x, workloadId_addr=0x%x)", taskset.GetAddr(), workloadId.addr());
+	cellSpurs->Warning("cellSpursGetTasksetId(taskset_addr=0x%x, workloadId_addr=0x%x)", taskset.addr(), workloadId.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x14EA0, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -747,10 +747,10 @@ s64 cellSpursGetTasksetId(mem_ptr_t<CellSpursTaskset> taskset, vm::ptr<be_t<u32>
 #endif
 }
 
-s64 cellSpursShutdownTaskset(mem_ptr_t<CellSpursTaskset> taskset)
+s64 cellSpursShutdownTaskset(vm::ptr<CellSpursTaskset> taskset)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("cellSpursShutdownTaskset(taskset_addr=0x%x)", taskset.GetAddr());
+	cellSpurs->Warning("cellSpursShutdownTaskset(taskset_addr=0x%x)", taskset.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x14868, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -758,12 +758,12 @@ s64 cellSpursShutdownTaskset(mem_ptr_t<CellSpursTaskset> taskset)
 #endif
 }
 
-s64 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, vm::ptr<be_t<u32>> taskID, u32 elf_addr, u32 context_addr, u32 context_size, mem_ptr_t<CellSpursTaskLsPattern> lsPattern,
-	mem_ptr_t<CellSpursTaskArgument> argument)
+s64 cellSpursCreateTask(vm::ptr<CellSpursTaskset> taskset, vm::ptr<be_t<u32>> taskID, u32 elf_addr, u32 context_addr, u32 context_size, vm::ptr<CellSpursTaskLsPattern> lsPattern,
+	vm::ptr<CellSpursTaskArgument> argument)
 {
 #ifdef PRX_DEBUG
 	cellSpurs->Warning("cellSpursCreateTask(taskset_addr=0x%x, taskID_addr=0x%x, elf_addr_addr=0x%x, context_addr_addr=0x%x, context_size=%d, lsPattern_addr=0x%x, argument_addr=0x%x)",
-		taskset.GetAddr(), taskID.addr(), elf_addr, context_addr, context_size, lsPattern.GetAddr(), argument.GetAddr());
+		taskset.addr(), taskID.addr(), elf_addr, context_addr, context_size, lsPattern.addr(), argument.addr());
 	return GetCurrentPPUThread().FastCall2(libsre + 0x12414, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -771,10 +771,10 @@ s64 cellSpursCreateTask(mem_ptr_t<CellSpursTaskset> taskset, vm::ptr<be_t<u32>>
 #endif
 }
 
-s64 _cellSpursSendSignal(mem_ptr_t<CellSpursTaskset> taskset, u32 taskID)
+s64 _cellSpursSendSignal(vm::ptr<CellSpursTaskset> taskset, u32 taskID)
 {
 #ifdef PRX_DEBUG
-	cellSpurs->Warning("_cellSpursSendSignal(taskset_addr=0x%x, taskID=%d)", taskset.GetAddr(), taskID);
+	cellSpurs->Warning("_cellSpursSendSignal(taskset_addr=0x%x, taskID=%d)", taskset.addr(), taskID);
 	return GetCurrentPPUThread().FastCall2(libsre + 0x124CC, libsre_rtoc);
 #else
 	UNIMPLEMENTED_FUNC(cellSpurs);
@@ -826,9 +826,9 @@ s64 cellSpursTasksetAttributeEnableClearLS()
 #endif
 }
 
-s64 _cellSpursTasksetAttribute2Initialize(mem_ptr_t<CellSpursTasksetAttribute2> attribute, u32 revision)
+s64 _cellSpursTasksetAttribute2Initialize(vm::ptr<CellSpursTasksetAttribute2> attribute, u32 revision)
 {
-	cellSpurs->Warning("_cellSpursTasksetAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.GetAddr(), revision);
+	cellSpurs->Warning("_cellSpursTasksetAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.addr(), revision);
 	
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x1474C, libsre_rtoc);
@@ -938,9 +938,9 @@ s64 cellSpursTaskAttributeSetExitCodeContainer()
 #endif
 }
 
-s64 _cellSpursTaskAttribute2Initialize(mem_ptr_t<CellSpursTaskAttribute2> attribute, u32 revision)
+s64 _cellSpursTaskAttribute2Initialize(vm::ptr<CellSpursTaskAttribute2> attribute, u32 revision)
 {
-	cellSpurs->Warning("_cellSpursTaskAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.GetAddr(), revision);
+	cellSpurs->Warning("_cellSpursTaskAttribute2Initialize(attribute_addr=0x%x, revision=%d)", attribute.addr(), revision);
 
 #ifdef PRX_DEBUG
 	return GetCurrentPPUThread().FastCall2(libsre + 0x10B00, libsre_rtoc);
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
index b23fea8496..d17a93eac0 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSpurs.h
@@ -194,11 +194,11 @@ struct CellSpursTracePacket
 };
 
 // Exception handlers.
-//typedef void (*CellSpursGlobalExceptionEventHandler)(mem_ptr_t<CellSpurs> spurs, const mem_ptr_t<CellSpursExceptionInfo> info, 
-//													 u32 id, mem_ptr_t<void> arg);
+//typedef void (*CellSpursGlobalExceptionEventHandler)(vm::ptr<CellSpurs> spurs, const vm::ptr<CellSpursExceptionInfo> info, 
+//													 u32 id, vm::ptr<void> arg);
 //
-//typedef void (*CellSpursTasksetExceptionEventHandler)(mem_ptr_t<CellSpurs> spurs, mem_ptr_t<CellSpursTaskset> taskset, 
-//													 u32 idTask, const mem_ptr_t<CellSpursExceptionInfo> info, mem_ptr_t<void> arg);
+//typedef void (*CellSpursTasksetExceptionEventHandler)(vm::ptr<CellSpurs> spurs, vm::ptr<CellSpursTaskset> taskset, 
+//													 u32 idTask, const vm::ptr<CellSpursExceptionInfo> info, vm::ptr<void> arg);
 
 struct CellSpursTasksetInfo
 {
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
index aa13463ecb..879d2d41ab 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp
@@ -174,10 +174,10 @@ int cellVideoOutGetState(u32 videoOut, u32 deviceIndex, u32 state_addr)
 	return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT;
 }
 
-int cellVideoOutGetResolution(u32 resolutionId, mem_ptr_t<CellVideoOutResolution> resolution)
+int cellVideoOutGetResolution(u32 resolutionId, vm::ptr<CellVideoOutResolution> resolution)
 {
 	cellSysutil->Log("cellVideoOutGetResolution(resolutionId=%d, resolution_addr=0x%x)",
-		resolutionId, resolution.GetAddr());
+		resolutionId, resolution.addr());
 
 	u32 num = ResolutionIdToNum(resolutionId);
 	if(!num)
@@ -253,10 +253,10 @@ int cellVideoOutGetConfiguration(u32 videoOut, u32 config_addr, u32 option_addr)
 	return CELL_VIDEO_OUT_ERROR_UNSUPPORTED_VIDEO_OUT;
 }
 
-int cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, mem_ptr_t<CellVideoOutDeviceInfo> info)
+int cellVideoOutGetDeviceInfo(u32 videoOut, u32 deviceIndex, vm::ptr<CellVideoOutDeviceInfo> info)
 {
 	cellSysutil->Warning("cellVideoOutGetDeviceInfo(videoOut=%u, deviceIndex=%u, info_addr=0x%x)",
-		videoOut, deviceIndex, info.GetAddr());
+		videoOut, deviceIndex, info.addr());
 
 	if(deviceIndex) return CELL_VIDEO_OUT_ERROR_DEVICE_NOT_FOUND;
 
@@ -482,10 +482,10 @@ int cellAudioOutGetState(u32 audioOut, u32 deviceIndex, u32 state_addr)
 	return CELL_AUDIO_OUT_ERROR_UNSUPPORTED_AUDIO_OUT;
 }
 
-int cellAudioOutConfigure(u32 audioOut, mem_ptr_t<CellAudioOutConfiguration> config, mem_ptr_t<CellAudioOutOption> option, u32 waitForEvent)
+int cellAudioOutConfigure(u32 audioOut, vm::ptr<CellAudioOutConfiguration> config, vm::ptr<CellAudioOutOption> option, u32 waitForEvent)
 {
 	cellSysutil->Warning("cellAudioOutConfigure(audioOut=%d, config_addr=0x%x, option_addr=0x%x, (!)waitForEvent=%d)",
-		audioOut, config.GetAddr(), option.GetAddr(), waitForEvent);
+		audioOut, config.addr(), option.addr(), waitForEvent);
 
 	switch(audioOut)
 	{
@@ -551,10 +551,10 @@ int cellAudioOutGetNumberOfDevice(u32 audioOut)
 	return CELL_AUDIO_OUT_ERROR_UNSUPPORTED_AUDIO_OUT;
 }
 
-int cellAudioOutGetDeviceInfo(u32 audioOut, u32 deviceIndex, mem_ptr_t<CellAudioOutDeviceInfo> info)
+int cellAudioOutGetDeviceInfo(u32 audioOut, u32 deviceIndex, vm::ptr<CellAudioOutDeviceInfo> info)
 {
 	cellSysutil->Todo("cellAudioOutGetDeviceInfo(audioOut=%u, deviceIndex=%u, info_addr=0x%x)",
-		audioOut, deviceIndex, info.GetAddr());
+		audioOut, deviceIndex, info.addr());
 
 	if(deviceIndex) return CELL_AUDIO_OUT_ERROR_DEVICE_NOT_FOUND;
 
@@ -602,7 +602,7 @@ int cellAudioOutSetCopyControl(u32 audioOut, u32 control)
 typedef struct{
 	char cacheId[CELL_SYSCACHE_ID_SIZE];
 	char getCachePath[CELL_SYSCACHE_PATH_MAX];
-	mem_ptr_t<void> reserved;
+	vm::ptr<void> reserved;
 } CellSysCacheParam;
 
 
@@ -658,9 +658,9 @@ int cellSysCacheClear(void)
 	return CELL_SYSCACHE_RET_OK_CLEARED;
 }
 
-int cellSysCacheMount(mem_ptr_t<CellSysCacheParam> param)
+int cellSysCacheMount(vm::ptr<CellSysCacheParam> param)
 {
-	cellSysutil->Warning("cellSysCacheMount(param_addr=0x%x)", param.GetAddr());
+	cellSysutil->Warning("cellSysCacheMount(param_addr=0x%x)", param.addr());
 
 	//TODO: implement
 	char id[CELL_SYSCACHE_ID_SIZE];
@@ -752,9 +752,9 @@ int cellSysutilEnableBgmPlayback()
 	return CELL_OK;
 }
 
-int cellSysutilEnableBgmPlaybackEx(mem_ptr_t<CellSysutilBgmPlaybackExtraParam> param)
+int cellSysutilEnableBgmPlaybackEx(vm::ptr<CellSysutilBgmPlaybackExtraParam> param)
 {
-	cellSysutil->Warning("cellSysutilEnableBgmPlaybackEx(param_addr=0x%x)", param.GetAddr());
+	cellSysutil->Warning("cellSysutilEnableBgmPlaybackEx(param_addr=0x%x)", param.addr());
 
 	// TODO
 	bgm_playback_enabled = true; 
@@ -772,9 +772,9 @@ int cellSysutilDisableBgmPlayback()
 	return CELL_OK;
 }
 
-int cellSysutilDisableBgmPlaybackEx(mem_ptr_t<CellSysutilBgmPlaybackExtraParam> param)
+int cellSysutilDisableBgmPlaybackEx(vm::ptr<CellSysutilBgmPlaybackExtraParam> param)
 {
-	cellSysutil->Warning("cellSysutilDisableBgmPlaybackEx(param_addr=0x%x)", param.GetAddr());
+	cellSysutil->Warning("cellSysutilDisableBgmPlaybackEx(param_addr=0x%x)", param.addr());
 
 	// TODO
 	bgm_playback_enabled = false;
@@ -782,9 +782,9 @@ int cellSysutilDisableBgmPlaybackEx(mem_ptr_t<CellSysutilBgmPlaybackExtraParam>
 	return CELL_OK;
 }
 
-int cellSysutilGetBgmPlaybackStatus(mem_ptr_t<CellSysutilBgmPlaybackStatus> status)
+int cellSysutilGetBgmPlaybackStatus(vm::ptr<CellSysutilBgmPlaybackStatus> status)
 {
-	cellSysutil->Log("cellSysutilGetBgmPlaybackStatus(status_addr=0x%x)", status.GetAddr());
+	cellSysutil->Log("cellSysutilGetBgmPlaybackStatus(status_addr=0x%x)", status.addr());
 
 	// TODO
 	status->playerState = CELL_SYSUTIL_BGMPLAYBACK_STATUS_STOP;
@@ -796,9 +796,9 @@ int cellSysutilGetBgmPlaybackStatus(mem_ptr_t<CellSysutilBgmPlaybackStatus> stat
 	return CELL_OK;
 }
 
-int cellSysutilGetBgmPlaybackStatus2(mem_ptr_t<CellSysutilBgmPlaybackStatus2> status2)
+int cellSysutilGetBgmPlaybackStatus2(vm::ptr<CellSysutilBgmPlaybackStatus2> status2)
 {
-	cellSysutil->Log("cellSysutilGetBgmPlaybackStatus2(status2_addr=0x%x)", status2.GetAddr());
+	cellSysutil->Log("cellSysutilGetBgmPlaybackStatus2(status2_addr=0x%x)", status2.addr());
 
 	// TODO
 	status2->playerState = CELL_SYSUTIL_BGMPLAYBACK_STATUS_STOP;
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index 8b2d444f4b..eff78cff85 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -85,7 +85,7 @@ void addSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, const std::string
 	saveEntries.push_back(saveEntry);
 }
 
-void addNewSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, mem_ptr_t<CellSaveDataListNewData> newData)
+void addNewSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveDataListNewData> newData)
 {
 	SaveDataEntry saveEntry;
 	saveEntry.dirName = (char*)Memory.VirtualToRealAddr(newData->dirName_addr);
@@ -105,7 +105,7 @@ u32 focusSaveDataEntry(const std::vector<SaveDataEntry>& saveEntries, u32 focusP
 	return 0;
 }
 
-void setSaveDataList(std::vector<SaveDataEntry>& saveEntries, mem_ptr_t<CellSaveDataDirList> fixedList, u32 fixedListNum)
+void setSaveDataList(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveDataDirList> fixedList, u32 fixedListNum)
 {
 	std::vector<SaveDataEntry>::iterator entry = saveEntries.begin();
 	while (entry != saveEntries.end())
@@ -126,7 +126,7 @@ void setSaveDataList(std::vector<SaveDataEntry>& saveEntries, mem_ptr_t<CellSave
 	}
 }
 
-void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, mem_ptr_t<CellSaveDataFixedSet> fixedSet)
+void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveDataFixedSet> fixedSet)
 {
 	std::vector<SaveDataEntry>::iterator entry = saveEntries.begin();
 	while (entry != saveEntries.end())
@@ -154,7 +154,7 @@ void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, mem_ptr_t<CellSav
 	}
 }
 
-void getSaveDataStat(SaveDataEntry entry, mem_ptr_t<CellSaveDataStatGet> statGet)
+void getSaveDataStat(SaveDataEntry entry, vm::ptr<CellSaveDataStatGet> statGet)
 {
 	if (entry.isNew)
 		statGet->isNewData = CELL_SAVEDATA_ISNEWDATA_YES;
@@ -287,12 +287,12 @@ s32 modifySaveDataFiles(vm::ptr<CellSaveDataFileCallback> funcFile, vm::ptr<Cell
 
 
 // Functions
-int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, setList.addr(), setBuf.addr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -340,9 +340,9 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, (u32)listSet->fixedList.addr(), listSet->fixedListNum);
+	setSaveDataList(saveEntries, listSet->fixedList, listSet->fixedListNum);
 	if (listSet->newData)
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr());
+		addNewSaveDataEntry(saveEntries, listSet->newData);
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -351,7 +351,7 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	u32 focusIndex = focusSaveDataEntry(saveEntries, listSet->focusPosition);
 	// TODO: Display the dialog here
 	u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
-	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
+	getSaveDataStat(saveEntries[selectedIndex], statGet);
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
@@ -361,8 +361,8 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	/*if (statSet->setParam.GetAddr())
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); // TODO: This *is* wrong
+	/*if (statSet->setParam)
+		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr()); // TODO: This *is* wrong
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
@@ -371,12 +371,12 @@ int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	return ret;
 }
 
-int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListLoad2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcList_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, setList.addr(), setBuf.addr(), funcList.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -425,9 +425,9 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, (u32)listSet->fixedList.addr(), listSet->fixedListNum);
+	setSaveDataList(saveEntries, listSet->fixedList, listSet->fixedListNum);
 	if (listSet->newData)
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr());
+		addNewSaveDataEntry(saveEntries, listSet->newData);
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -436,7 +436,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	u32 focusIndex = focusSaveDataEntry(saveEntries, listSet->focusPosition);
 	// TODO: Display the dialog here
 	u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
-	getSaveDataStat(saveEntries[selectedIndex], statGet.addr());
+	getSaveDataStat(saveEntries[selectedIndex], statGet);
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
@@ -446,7 +446,7 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	/*if (statSet->setParam.GetAddr())
+	/*if (statSet->setParam)
 		// TODO: Write PARAM.SFO file
 	*/
 
@@ -456,12 +456,12 @@ int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, m
 	return ret;
 }
 
-int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataFixedSave2(u32 version,  vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
 						   vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						   u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataFixedSave2(version=%d, setList_addr=0x%x, setBuf_addr=0x%x, funcFixed_addr=0x%x, funcStat_addr=0x%x, funcFile_addr=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -504,8 +504,8 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 		cellSysutil->Error("cellSaveDataFixedSave2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	setSaveDataFixed(saveEntries, fixedSet.addr());
-	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
+	setSaveDataFixed(saveEntries, fixedSet);
+	getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
 	// TODO: Display the Yes|No dialog here
 	result->userdata_addr = userdata_addr;
 
@@ -515,7 +515,7 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 		cellSysutil->Error("cellSaveDataFixedSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	/*if (statSet->setParam.GetAddr())
+	/*if (statSet->setParam)
 		// TODO: Write PARAM.SFO file
 	*/
 
@@ -525,12 +525,12 @@ int cellSaveDataFixedSave2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	return ret;
 }
 
-int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataFixedLoad2(u32 version,  vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
 						   vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						   u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataFixedLoad2(version=%d, setList_addr=0x%x, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -573,8 +573,8 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 		cellSysutil->Error("cellSaveDataFixedLoad2: CellSaveDataFixedCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	setSaveDataFixed(saveEntries, fixedSet.addr());
-	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
+	setSaveDataFixed(saveEntries, fixedSet);
+	getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
 	// TODO: Display the Yes|No dialog here
 	result->userdata_addr = userdata_addr;
 
@@ -584,7 +584,7 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 		cellSysutil->Error("cellSaveDataFixedLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	/*if (statSet->setParam.GetAddr())
+	/*if (statSet->setParam)
 		// TODO: Write PARAM.SFO file
 	*/
 
@@ -594,12 +594,12 @@ int cellSaveDataFixedLoad2(u32 version,  mem_ptr_t<CellSaveDataSetList> setList,
 	return ret;
 }
 
-int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataAutoSave2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, dirName_addr, errDialog, setBuf.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataStatGet> statGet;
@@ -628,7 +628,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 		saveEntries.push_back(entry);
 	}
 
-	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
+	getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
 	result->userdata_addr = userdata_addr;
 	funcStat(result, statGet, statSet);
 
@@ -637,7 +637,7 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 		cellSysutil->Error("cellSaveDataAutoSave2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	/*if (statSet->setParam.GetAddr())
+	/*if (statSet->setParam)
 		// TODO: Write PARAM.SFO file
 	*/
 
@@ -647,12 +647,12 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataAutoLoad2(version=%d, dirName_addr=0x%x, errDialog=%d, setBuf=0x%x, funcList=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, dirName_addr, errDialog, setBuf.GetAddr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, dirName_addr, errDialog, setBuf.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataStatGet> statGet;
@@ -678,7 +678,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 		return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found?
 	}
 
-	getSaveDataStat(saveEntries[0], statGet.addr()); // There should be only one element in this list
+	getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
 	result->userdata_addr = userdata_addr;
 	funcStat(result, statGet, statSet);
 
@@ -687,7 +687,7 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 		cellSysutil->Error("cellSaveDataAutoLoad2: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
-	/*if (statSet->setParam.GetAddr())
+	/*if (statSet->setParam)
 		// TODO: Write PARAM.SFO file
 	*/
 
@@ -697,11 +697,11 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
 							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListAutoSave(version=%d, errDialog=%d, setBuf=0x%x, funcFixed=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-		version, errDialog, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+		version, errDialog, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -751,9 +751,9 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	/*setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
-	if (listSet->newData.GetAddr())
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
+	/*setSaveDataList(saveEntries, (u32)listSet->fixedList.addr(), listSet->fixedListNum);
+	if (listSet->newData)
+		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr());
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListAutoSave: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -766,14 +766,14 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result, statGet, statSet);
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListAutoSave: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}*/
 
-	/*if (statSet->setParam.GetAddr())
-	addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr()); // TODO: This *is* wrong
+	/*if (statSet->setParam)
+	addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr()); // TODO: This *is* wrong
 	*/
 
 	// Enter the loop where the save files are read/created/deleted.
@@ -782,11 +782,11 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
 							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr)
 {
 	cellSysutil->Warning("cellSaveDataListAutoLoad(version=%d, errDialog=%d, setBuf=0x%x, funcFixed=0x%x, funcStat=0x%x, funcFile=0x%x, container=0x%x, userdata_addr=0x%x)",
-					  version, errDialog, setList.GetAddr(), setBuf.GetAddr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
+					  version, errDialog, setList.addr(), setBuf.addr(), funcFixed.addr(), funcStat.addr(), funcFile.addr(), container, userdata_addr);
 
 	vm::var<CellSaveDataCBResult> result;
 	vm::var<CellSaveDataListGet> listGet;
@@ -836,9 +836,9 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	/*setSaveDataList(saveEntries, (u32)listSet->fixedList.GetAddr(), listSet->fixedListNum);
-	if (listSet->newData.GetAddr())
-		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.GetAddr());
+	/*setSaveDataList(saveEntries, (u32)listSet->fixedList.addr(), listSet->fixedListNum);
+	if (listSet->newData)
+		addNewSaveDataEntry(saveEntries, (u32)listSet->newData.addr());
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListAutoLoad: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -851,14 +851,14 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataS
 	result->userdata_addr = userdata_addr;
 
 	funcStat(result.addr(), statGet.addr(), statSet.addr());
-	Memory.Free(statGet->fileList.GetAddr());
+	Memory.Free(statGet->fileList.addr());
 
 	if (result->result < 0)	{
 		cellSysutil->Error("cellSaveDataListAutoLoad: CellSaveDataStatCallback failed."); // TODO: Once we verify that the entire SysCall is working, delete this debug error message.
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}*/
 
-	/*if (statSet->setParam.GetAddr())
+	/*if (statSet->setParam)
 	// TODO: Write PARAM.SFO file
 	*/
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
index 1f0c92015e..b2ef5dbed7 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.h
@@ -273,32 +273,32 @@ struct SaveDataEntry
 
 
 // Function declarations
-int cellSaveDataListSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
                           vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
-int cellSaveDataListLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
                           vm::ptr<CellSaveDataListCallback> funcList, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
-int cellSaveDataFixedSave2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataFixedSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
                           vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
-int cellSaveDataFixedLoad2(u32 version, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataFixedLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf,
                           vm::ptr<CellSaveDataFixedCallback> funcFixed, vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
                           u32 container, u32 userdata_addr);
 
-int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr);
 
-int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, mem_ptr_t<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
 						  u32 container, u32 userdata_addr);
 
-int cellSaveDataListAutoSave(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
 							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
 
-int cellSaveDataListAutoLoad(u32 version, u32 errDialog, mem_ptr_t<CellSaveDataSetList> setList, mem_ptr_t<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
+int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSetList> setList, vm::ptr<CellSaveDataSetBuf> setBuf, vm::ptr<CellSaveDataFixedCallback> funcFixed,
 							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, u32 userdata_addr);
\ No newline at end of file
diff --git a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
index 3bf5a379af..162a32bc61 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.cpp
@@ -11,9 +11,9 @@
 //Module cellUserInfo(0x0032, cellUserInfo_init);
 Module *cellUserInfo = nullptr;
 
-int cellUserInfoGetStat(u32 id, mem_ptr_t<CellUserInfoUserStat> stat)
+int cellUserInfoGetStat(u32 id, vm::ptr<CellUserInfoUserStat> stat)
 {
-	cellUserInfo->Warning("cellUserInfoGetStat(id=%d, stat_addr=0x%x)", id, stat.GetAddr());
+	cellUserInfo->Warning("cellUserInfoGetStat(id=%d, stat_addr=0x%x)", id, stat.addr());
 
 	if (id > CELL_USERINFO_USER_MAX)
 		return CELL_USERINFO_ERROR_NOUSER;
@@ -57,10 +57,10 @@ int cellUserInfoEnableOverlay()
 	return CELL_OK;
 }
 
-int cellUserInfoGetList(vm::ptr<be_t<u32>> listNum, mem_ptr_t<CellUserInfoUserList> listBuf, vm::ptr<be_t<u32>> currentUserId)
+int cellUserInfoGetList(vm::ptr<be_t<u32>> listNum, vm::ptr<CellUserInfoUserList> listBuf, vm::ptr<be_t<u32>> currentUserId)
 {
 	cellUserInfo->Warning("cellUserInfoGetList(listNum_addr=0x%x, listBuf_addr=0x%x, currentUserId_addr=0x%x)",
-		listNum.addr(), listBuf.GetAddr(), currentUserId.addr());
+		listNum.addr(), listBuf.addr(), currentUserId.addr());
 
 	// If only listNum is NULL, an error will be returned
 	if (listBuf && !listNum)
diff --git a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.h b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.h
index c48a2f9a2b..5edd525cb6 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellUserInfo.h
+++ b/rpcs3/Emu/SysCalls/Modules/cellUserInfo.h
@@ -42,7 +42,7 @@ struct CellUserInfoListSet
 	be_t<u32> title_addr; // (char*)
 	be_t<u32> focus;
 	be_t<u32> fixedListNum;
-	mem_ptr_t<CellUserInfoUserList> fixedList;
+	vm::ptr<CellUserInfoUserList> fixedList;
 	be_t<u32> reserved_addr; // (void*)
 };
 
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
index 7319219289..ebecbca4b8 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVdec.cpp
@@ -161,7 +161,7 @@ next:
 	}
 }
 
-u32 vdecQueryAttr(CellVdecCodecType type, u32 profile, u32 spec_addr /* may be 0 */, mem_ptr_t<CellVdecAttr> attr)
+u32 vdecQueryAttr(CellVdecCodecType type, u32 profile, u32 spec_addr /* may be 0 */, vm::ptr<CellVdecAttr> attr)
 {
 	switch (type) // TODO: check profile levels
 	{
@@ -482,34 +482,34 @@ u32 vdecOpen(VideoDecoder* data)
 	return vdec_id;
 }
 
-int cellVdecQueryAttr(const mem_ptr_t<CellVdecType> type, mem_ptr_t<CellVdecAttr> attr)
+int cellVdecQueryAttr(const vm::ptr<CellVdecType> type, vm::ptr<CellVdecAttr> attr)
 {
-	cellVdec->Warning("cellVdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.GetAddr(), attr.GetAddr());
+	cellVdec->Warning("cellVdecQueryAttr(type_addr=0x%x, attr_addr=0x%x)", type.addr(), attr.addr());
 
 	return vdecQueryAttr(type->codecType, type->profileLevel, 0, attr);
 }
 
-int cellVdecQueryAttrEx(const mem_ptr_t<CellVdecTypeEx> type, mem_ptr_t<CellVdecAttr> attr)
+int cellVdecQueryAttrEx(const vm::ptr<CellVdecTypeEx> type, vm::ptr<CellVdecAttr> attr)
 {
-	cellVdec->Warning("cellVdecQueryAttrEx(type_addr=0x%x, attr_addr=0x%x)", type.GetAddr(), attr.GetAddr());
+	cellVdec->Warning("cellVdecQueryAttrEx(type_addr=0x%x, attr_addr=0x%x)", type.addr(), attr.addr());
 
 	return vdecQueryAttr(type->codecType, type->profileLevel, type->codecSpecificInfo_addr, attr);
 }
 
-int cellVdecOpen(const mem_ptr_t<CellVdecType> type, const mem_ptr_t<CellVdecResource> res, const mem_ptr_t<CellVdecCb> cb, vm::ptr<be_t<u32>> handle)
+int cellVdecOpen(const vm::ptr<CellVdecType> type, const vm::ptr<CellVdecResource> res, const vm::ptr<CellVdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellVdec->Warning("cellVdecOpen(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
+		type.addr(), res.addr(), cb.addr(), handle.addr());
 
 	*handle = vdecOpen(new VideoDecoder(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
 
 	return CELL_OK;
 }
 
-int cellVdecOpenEx(const mem_ptr_t<CellVdecTypeEx> type, const mem_ptr_t<CellVdecResourceEx> res, const mem_ptr_t<CellVdecCb> cb, vm::ptr<be_t<u32>> handle)
+int cellVdecOpenEx(const vm::ptr<CellVdecTypeEx> type, const vm::ptr<CellVdecResourceEx> res, const vm::ptr<CellVdecCb> cb, vm::ptr<be_t<u32>> handle)
 {
 	cellVdec->Warning("cellVdecOpenEx(type_addr=0x%x, res_addr=0x%x, cb_addr=0x%x, handle_addr=0x%x)",
-		type.GetAddr(), res.GetAddr(), cb.GetAddr(), handle.addr());
+		type.addr(), res.addr(), cb.addr(), handle.addr());
 
 	*handle = vdecOpen(new VideoDecoder(type->codecType, type->profileLevel, res->memAddr, res->memSize, cb->cbFunc, cb->cbArg));
 
@@ -593,9 +593,9 @@ int cellVdecEndSeq(u32 handle)
 	return CELL_OK;
 }
 
-int cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, const mem_ptr_t<CellVdecAuInfo> auInfo)
+int cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, const vm::ptr<CellVdecAuInfo> auInfo)
 {
-	cellVdec->Log("cellVdecDecodeAu(handle=%d, mode=0x%x, auInfo_addr=0x%x)", handle, mode, auInfo.GetAddr());
+	cellVdec->Log("cellVdecDecodeAu(handle=%d, mode=0x%x, auInfo_addr=0x%x)", handle, mode, auInfo.addr());
 
 	VideoDecoder* vdec;
 	if (!Emu.GetIdManager().GetIDData(handle, vdec))
@@ -617,9 +617,9 @@ int cellVdecDecodeAu(u32 handle, CellVdecDecodeMode mode, const mem_ptr_t<CellVd
 	return CELL_OK;
 }
 
-int cellVdecGetPicture(u32 handle, const mem_ptr_t<CellVdecPicFormat> format, u32 out_addr)
+int cellVdecGetPicture(u32 handle, const vm::ptr<CellVdecPicFormat> format, u32 out_addr)
 {
-	cellVdec->Log("cellVdecGetPicture(handle=%d, format_addr=0x%x, out_addr=0x%x)", handle, format.GetAddr(), out_addr);
+	cellVdec->Log("cellVdecGetPicture(handle=%d, format_addr=0x%x, out_addr=0x%x)", handle, format.addr(), out_addr);
 
 	VideoDecoder* vdec;
 	if (!Emu.GetIdManager().GetIDData(handle, vdec))
@@ -690,7 +690,7 @@ int cellVdecGetPicItem(u32 handle, vm::ptr<be_t<u32>> picItem_ptr)
 
 	AVFrame& frame = *vf.data;
 
-	mem_ptr_t<CellVdecPicItem> info(vdec->memAddr + vdec->memBias);
+	auto info = vm::ptr<CellVdecPicItem>::make(vdec->memAddr + vdec->memBias);
 
 	vdec->memBias += 512;
 	if (vdec->memBias + 512 > vdec->memSize)
@@ -714,9 +714,9 @@ int cellVdecGetPicItem(u32 handle, vm::ptr<be_t<u32>> picItem_ptr)
 	info->auUserData[1] = 0;
 	info->status = CELL_OK;
 	info->attr = CELL_VDEC_PICITEM_ATTR_NORMAL;
-	info->picInfo_addr = info.GetAddr() + sizeof(CellVdecPicItem);
+	info->picInfo_addr = info.addr() + sizeof(CellVdecPicItem);
 
-	mem_ptr_t<CellVdecAvcInfo> avc(info.GetAddr() + sizeof(CellVdecPicItem));
+	auto avc = vm::ptr<CellVdecAvcInfo>::make(info.addr() + sizeof(CellVdecPicItem));
 
 	avc->horizontalSize = frame.width;
 	avc->verticalSize = frame.height;
@@ -775,7 +775,7 @@ int cellVdecGetPicItem(u32 handle, vm::ptr<be_t<u32>> picItem_ptr)
 	avc->reserved[0] = 0;
 	avc->reserved[1] = 0;
 	
-	*picItem_ptr = info.GetAddr();
+	*picItem_ptr = info.addr();
 
 	return CELL_OK;
 }
diff --git a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
index d35ead7ac9..8f0f800198 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellVpost.cpp
@@ -14,9 +14,9 @@ extern "C"
 //Module cellVpost(0x0008, cellVpost_init);
 Module *cellVpost = nullptr;
 
-int cellVpostQueryAttr(const mem_ptr_t<CellVpostCfgParam> cfgParam, mem_ptr_t<CellVpostAttr> attr)
+int cellVpostQueryAttr(const vm::ptr<CellVpostCfgParam> cfgParam, vm::ptr<CellVpostAttr> attr)
 {
-	cellVpost->Warning("cellVpostQueryAttr(cfgParam_addr=0x%x, attr_addr=0x%x)", cfgParam.GetAddr(), attr.GetAddr());
+	cellVpost->Warning("cellVpostQueryAttr(cfgParam_addr=0x%x, attr_addr=0x%x)", cfgParam.addr(), attr.addr());
 
 	// TODO: check cfgParam and output values
 
@@ -37,20 +37,20 @@ u32 vpostOpen(VpostInstance* data)
 	return id;
 }
 
-int cellVpostOpen(const mem_ptr_t<CellVpostCfgParam> cfgParam, const mem_ptr_t<CellVpostResource> resource, vm::ptr<be_t<u32>> handle)
+int cellVpostOpen(const vm::ptr<CellVpostCfgParam> cfgParam, const vm::ptr<CellVpostResource> resource, vm::ptr<be_t<u32>> handle)
 {
 	cellVpost->Warning("cellVpostOpen(cfgParam_addr=0x%x, resource_addr=0x%x, handle_addr=0x%x)",
-		cfgParam.GetAddr(), resource.GetAddr(), handle.addr());
+		cfgParam.addr(), resource.addr(), handle.addr());
 
 	// TODO: check values
 	*handle = vpostOpen(new VpostInstance(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV));
 	return CELL_OK;
 }
 
-int cellVpostOpenEx(const mem_ptr_t<CellVpostCfgParam> cfgParam, const mem_ptr_t<CellVpostResourceEx> resource, vm::ptr<be_t<u32>> handle)
+int cellVpostOpenEx(const vm::ptr<CellVpostCfgParam> cfgParam, const vm::ptr<CellVpostResourceEx> resource, vm::ptr<be_t<u32>> handle)
 {
 	cellVpost->Warning("cellVpostOpenEx(cfgParam_addr=0x%x, resource_addr=0x%x, handle_addr=0x%x)",
-		cfgParam.GetAddr(), resource.GetAddr(), handle.addr());
+		cfgParam.addr(), resource.addr(), handle.addr());
 
 	// TODO: check values
 	*handle = vpostOpen(new VpostInstance(cfgParam->outPicFmt == CELL_VPOST_PIC_FMT_OUT_RGBA_ILV));
@@ -71,11 +71,11 @@ int cellVpostClose(u32 handle)
 	return CELL_OK;
 }
 
-int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const mem_ptr_t<CellVpostCtrlParam> ctrlParam,
-				  u32 outPicBuff_addr, mem_ptr_t<CellVpostPictureInfo> picInfo)
+int cellVpostExec(u32 handle, const u32 inPicBuff_addr, const vm::ptr<CellVpostCtrlParam> ctrlParam,
+				  u32 outPicBuff_addr, vm::ptr<CellVpostPictureInfo> picInfo)
 {
 	cellVpost->Log("cellVpostExec(handle=0x%x, inPicBuff_addr=0x%x, ctrlParam_addr=0x%x, outPicBuff_addr=0x%x, picInfo_addr=0x%x)",
-		handle, inPicBuff_addr, ctrlParam.GetAddr(), outPicBuff_addr, picInfo.GetAddr());
+		handle, inPicBuff_addr, ctrlParam.addr(), outPicBuff_addr, picInfo.addr());
 
 	VpostInstance* vpost;
 	if (!Emu.GetIdManager().GetIDData(handle, vpost))
diff --git a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
index 7fd2644af7..c41e29b132 100644
--- a/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libmixer.cpp
@@ -141,10 +141,10 @@ int cellAANDisconnect(u32 receive, u32 receivePortNo, u32 source, u32 sourcePort
 	return CELL_OK;
 }
  
-int cellSSPlayerCreate(vm::ptr<be_t<u32>> handle, mem_ptr_t<CellSSPlayerConfig> config)
+int cellSSPlayerCreate(vm::ptr<be_t<u32>> handle, vm::ptr<CellSSPlayerConfig> config)
 {
 	libmixer->Warning("cellSSPlayerCreate(handle_addr=0x%x, config_addr=0x%x)",
-		handle.addr(), config.GetAddr());
+		handle.addr(), config.addr());
 
 	if (config->outputMode != 0 || config->channels - 1 >= 2)
 	{
@@ -185,10 +185,10 @@ int cellSSPlayerRemove(u32 handle)
 	return CELL_OK;
 }
 
-int cellSSPlayerSetWave(u32 handle, mem_ptr_t<CellSSPlayerWaveParam> waveInfo, mem_ptr_t<CellSSPlayerCommonParam> commonInfo)
+int cellSSPlayerSetWave(u32 handle, vm::ptr<CellSSPlayerWaveParam> waveInfo, vm::ptr<CellSSPlayerCommonParam> commonInfo)
 {
 	libmixer->Warning("cellSSPlayerSetWave(handle=%d, waveInfo_addr=0x%x, commonInfo_addr=0x%x)",
-		handle, waveInfo.GetAddr(), commonInfo.GetAddr());
+		handle, waveInfo.addr(), commonInfo.addr());
 
 	std::lock_guard<std::mutex> lock(mixer_mutex);
 
@@ -203,15 +203,15 @@ int cellSSPlayerSetWave(u32 handle, mem_ptr_t<CellSSPlayerWaveParam> waveInfo, m
 	ssp[handle].m_addr = waveInfo->addr;
 	ssp[handle].m_samples = waveInfo->samples;
 	ssp[handle].m_loop_start = waveInfo->loopStartOffset - 1;
-	ssp[handle].m_loop_mode = commonInfo.GetAddr() ? (u32)commonInfo->loopMode : CELL_SSPLAYER_ONESHOT;
+	ssp[handle].m_loop_mode = commonInfo ? (u32)commonInfo->loopMode : CELL_SSPLAYER_ONESHOT;
 	ssp[handle].m_position = waveInfo->startOffset - 1;
 
 	return CELL_OK;
 }
 
-int cellSSPlayerPlay(u32 handle, mem_ptr_t<CellSSPlayerRuntimeInfo> info)
+int cellSSPlayerPlay(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 {
-	libmixer->Warning("cellSSPlayerPlay(handle=%d, info_addr=0x%x)", handle, info.GetAddr());
+	libmixer->Warning("cellSSPlayerPlay(handle=%d, info_addr=0x%x)", handle, info.addr());
 
 	std::lock_guard<std::mutex> lock(mixer_mutex);
 
@@ -252,9 +252,9 @@ int cellSSPlayerStop(u32 handle, u32 mode)
 	return CELL_OK;
 }
 
-int cellSSPlayerSetParam(u32 handle, mem_ptr_t<CellSSPlayerRuntimeInfo> info)
+int cellSSPlayerSetParam(u32 handle, vm::ptr<CellSSPlayerRuntimeInfo> info)
 {
-	libmixer->Warning("cellSSPlayerSetParam(handle=%d, info_addr=0x%x)", handle, info.GetAddr());
+	libmixer->Warning("cellSSPlayerSetParam(handle=%d, info_addr=0x%x)", handle, info.addr());
 
 	std::lock_guard<std::mutex> lock(mixer_mutex);
 
@@ -295,9 +295,9 @@ int cellSSPlayerGetState(u32 handle)
 	return CELL_SSPLAYER_STATE_OFF;
 }
 
-int cellSurMixerCreate(const mem_ptr_t<CellSurMixerConfig> config)
+int cellSurMixerCreate(const vm::ptr<CellSurMixerConfig> config)
 {
-	libmixer->Warning("cellSurMixerCreate(config_addr=0x%x)", config.GetAddr());
+	libmixer->Warning("cellSurMixerCreate(config_addr=0x%x)", config.addr());
 
 	surMixer = *config;
 
@@ -554,9 +554,9 @@ int cellSurMixerSurBusAddData(u32 busNo, u32 offset, u32 addr, u32 samples)
 	return CELL_OK;
 }
 
-int cellSurMixerChStripSetParameter(u32 type, u32 index, mem_ptr_t<CellSurMixerChStripParam> param)
+int cellSurMixerChStripSetParameter(u32 type, u32 index, vm::ptr<CellSurMixerChStripParam> param)
 {
-	libmixer->Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param_addr=0x%x)", type, index, param.GetAddr());
+	libmixer->Todo("cellSurMixerChStripSetParameter(type=%d, index=%d, param_addr=0x%x)", type, index, param.addr());
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/libsynth2.cpp b/rpcs3/Emu/SysCalls/Modules/libsynth2.cpp
index 5f335b1e58..9cc4119865 100644
--- a/rpcs3/Emu/SysCalls/Modules/libsynth2.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/libsynth2.cpp
@@ -58,15 +58,15 @@ u32 cellSoundSynth2GetAddr(u16 reg)
 	return 0;
 }
 
-int cellSoundSynth2SetEffectAttr(s16 bus, mem_ptr_t<CellSoundSynth2EffectAttr> attr)
+int cellSoundSynth2SetEffectAttr(s16 bus, vm::ptr<CellSoundSynth2EffectAttr> attr)
 {
-	libsynth2.Todo("cellSoundSynth2SetEffectAttr(bus=%d, attr_addr=0x%x)", bus, attr.GetAddr());
+	libsynth2.Todo("cellSoundSynth2SetEffectAttr(bus=%d, attr_addr=0x%x)", bus, attr.addr());
 	return CELL_OK;
 }
 
-int cellSoundSynth2SetEffectMode(s16 bus, mem_ptr_t<CellSoundSynth2EffectAttr> attr)
+int cellSoundSynth2SetEffectMode(s16 bus, vm::ptr<CellSoundSynth2EffectAttr> attr)
 {
-	libsynth2.Todo("cellSoundSynth2SetEffectMode(bus=%d, attr_addr=0x%x)", bus, attr.GetAddr());
+	libsynth2.Todo("cellSoundSynth2SetEffectMode(bus=%d, attr_addr=0x%x)", bus, attr.addr());
 	return CELL_OK;
 }
 
diff --git a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
index 3969646ff9..76676966d0 100644
--- a/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sceNpTrophy.cpp
@@ -85,10 +85,10 @@ int sceNpTrophyInit(u32 pool_addr, u32 poolSize, u32 containerId, u64 options)
 	return CELL_OK;
 }
 
-int sceNpTrophyCreateContext(vm::ptr<be_t<u32>> context, mem_ptr_t<SceNpCommunicationId> commID, mem_ptr_t<SceNpCommunicationSignature> commSign, u64 options)
+int sceNpTrophyCreateContext(vm::ptr<be_t<u32>> context, vm::ptr<SceNpCommunicationId> commID, vm::ptr<SceNpCommunicationSignature> commSign, u64 options)
 {
 	sceNpTrophy->Warning("sceNpTrophyCreateContext(context_addr=0x%x, commID_addr=0x%x, commSign_addr=0x%x, options=0x%llx)",
-		context.addr(), commID.GetAddr(), commSign.GetAddr(), options);
+		context.addr(), commID.addr(), commSign.addr(), options);
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -244,10 +244,10 @@ int sceNpTrophyAbortHandle()
 	return CELL_OK;
 }
 
-int sceNpTrophyGetGameInfo(u32 context, u32 handle, mem_ptr_t<SceNpTrophyGameDetails> details, mem_ptr_t<SceNpTrophyGameData> data)
+int sceNpTrophyGetGameInfo(u32 context, u32 handle, vm::ptr<SceNpTrophyGameDetails> details, vm::ptr<SceNpTrophyGameData> data)
 {
 	sceNpTrophy->Warning("sceNpTrophyGetGameInfo(context=%d, handle=%d, details_addr=0x%x, data_addr=0x%x)",
-		context, handle, details.GetAddr(), data.GetAddr());
+		context, handle, details.addr(), data.addr());
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -333,10 +333,10 @@ int sceNpTrophyTerm()
 	return CELL_OK;
 }
 
-int sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, mem_ptr_t<SceNpTrophyFlagArray> flags, vm::ptr<be_t<u32>> count)
+int sceNpTrophyGetTrophyUnlockState(u32 context, u32 handle, vm::ptr<SceNpTrophyFlagArray> flags, vm::ptr<be_t<u32>> count)
 {
 	sceNpTrophy->Warning("sceNpTrophyGetTrophyUnlockState(context=%d, handle=%d, flags_addr=0x%x, count_addr=0x%x)",
-		context, handle, flags.GetAddr(), count.addr());
+		context, handle, flags.addr(), count.addr());
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
@@ -365,10 +365,10 @@ int sceNpTrophyGetTrophyIcon()
 	return CELL_OK;
 }
 
-int sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, mem_ptr_t<SceNpTrophyDetails> details, mem_ptr_t<SceNpTrophyData> data)
+int sceNpTrophyGetTrophyInfo(u32 context, u32 handle, s32 trophyId, vm::ptr<SceNpTrophyDetails> details, vm::ptr<SceNpTrophyData> data)
 {
 	sceNpTrophy->Warning("sceNpTrophyGetTrophyInfo(context=%u, handle=%u, trophyId=%d, details_addr=0x%x, data_addr=0x%x)",
-		context, handle, trophyId, details.GetAddr(), data.GetAddr());
+		context, handle, trophyId, details.addr(), data.addr());
 
 	if (!s_npTrophyInstance.m_bInitialized)
 		return SCE_NP_TROPHY_ERROR_NOT_INITIALIZED;
diff --git a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
index 377cd87522..9187629fd3 100644
--- a/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp
@@ -89,15 +89,15 @@ int sys_spu_elf_get_information(u32 elf_img, vm::ptr<be_t<u32>> entry, vm::ptr<b
 	return CELL_OK;
 }
 
-int sys_spu_elf_get_segments(u32 elf_img, mem_ptr_t<sys_spu_segment> segments, int nseg)
+int sys_spu_elf_get_segments(u32 elf_img, vm::ptr<sys_spu_segment> segments, int nseg)
 {
-	sysPrxForUser->Todo("sys_spu_elf_get_segments(elf_img=0x%x, segments_addr=0x%x, nseg=0x%x)", elf_img, segments.GetAddr(), nseg);
+	sysPrxForUser->Todo("sys_spu_elf_get_segments(elf_img=0x%x, segments_addr=0x%x, nseg=0x%x)", elf_img, segments.addr(), nseg);
 	return CELL_OK;
 }
 
-int sys_spu_image_import(mem_ptr_t<sys_spu_image> img, u32 src, u32 type)
+int sys_spu_image_import(vm::ptr<sys_spu_image> img, u32 src, u32 type)
 {
-	sysPrxForUser->Warning("sys_spu_image_import(img=0x%x, src=0x%x, type=0x%x)", img.GetAddr(), src, type);
+	sysPrxForUser->Warning("sys_spu_image_import(img=0x%x, src=0x%x, type=0x%x)", img.addr(), src, type);
 
 	vfsStreamMemory f(src);
 	u32 entry;
@@ -111,9 +111,9 @@ int sys_spu_image_import(mem_ptr_t<sys_spu_image> img, u32 src, u32 type)
 	return CELL_OK;
 }
 
-int sys_spu_image_close(mem_ptr_t<sys_spu_image> img)
+int sys_spu_image_close(vm::ptr<sys_spu_image> img)
 {
-	sysPrxForUser->Warning("sys_spu_image_close(img=0x%x)", img.GetAddr());
+	sysPrxForUser->Warning("sys_spu_image_close(img=0x%x)", img.addr());
 	return CELL_OK;
 }
 
@@ -139,9 +139,9 @@ int sys_raw_spu_load(int id, u32 path_addr, vm::ptr<be_t<u32>> entry)
 	return CELL_OK;
 }
 
-int sys_raw_spu_image_load(int id, mem_ptr_t<sys_spu_image> img)
+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.GetAddr());
+	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);
 	Memory.Write32(RAW_SPU_BASE_ADDR + RAW_SPU_OFFSET * id + RAW_SPU_PROB_OFFSET + SPU_NPC_offs, (u32)img->entry_point);
diff --git a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
index fa20136f5c..770c7ffdf4 100644
--- a/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/sys_net.cpp
@@ -94,17 +94,17 @@ using pck_len_t = u32;
 #endif
 
 // Functions
-int sys_net_accept(s32 s, mem_ptr_t<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> paddrlen)
+int sys_net_accept(s32 s, vm::ptr<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> paddrlen)
 {
-	sys_net->Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.GetAddr(), paddrlen.addr());
-	if (addr.GetAddr() == 0) {
+	sys_net->Warning("accept(s=%d, family_addr=0x%x, paddrlen=0x%x)", s, addr.addr(), paddrlen.addr());
+	if (!addr) {
 		int ret = accept(s, NULL, NULL);
 		*g_lastError = getLastError();
 		return ret;
 	}
 	else {
 		sockaddr _addr;
-		memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
+		memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
 		_addr.sa_family = addr->sa_family;
 		pck_len_t *_paddrlen = (pck_len_t *)Memory.VirtualToRealAddr(paddrlen.addr());
 		int ret = accept(s, &_addr, _paddrlen);
@@ -113,11 +113,11 @@ int sys_net_accept(s32 s, mem_ptr_t<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> p
 	}
 }
 
-int sys_net_bind(s32 s, mem_ptr_t<sys_net_sockaddr_in> addr, u32 addrlen)
+int sys_net_bind(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
 {
-	sys_net->Warning("bind(s=%d, family_addr=0x%x, addrlen=%u)", s, addr.GetAddr(), addrlen);
+	sys_net->Warning("bind(s=%d, family_addr=0x%x, addrlen=%u)", s, addr.addr(), addrlen);
 	sockaddr_in saddr;
-	memcpy(&saddr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr_in));
+	memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
 	saddr.sin_family = addr->sin_family;
 	const char *ipaddr = inet_ntoa(saddr.sin_addr);
 	sys_net->Warning("binding on %s to port %d", ipaddr, ntohs(saddr.sin_port));
@@ -126,11 +126,11 @@ int sys_net_bind(s32 s, mem_ptr_t<sys_net_sockaddr_in> addr, u32 addrlen)
 	return ret;
 }
 
-int sys_net_connect(s32 s, mem_ptr_t<sys_net_sockaddr_in> addr, u32 addrlen)
+int sys_net_connect(s32 s, vm::ptr<sys_net_sockaddr_in> addr, u32 addrlen)
 {
-	sys_net->Warning("connect(s=%d, family_addr=0x%x, addrlen=%u)", s, addr.GetAddr(), addrlen);
+	sys_net->Warning("connect(s=%d, family_addr=0x%x, addrlen=%u)", s, addr.addr(), addrlen);
 	sockaddr_in saddr;
-	memcpy(&saddr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr_in));
+	memcpy(&saddr, addr.get_ptr(), sizeof(sockaddr_in));
 	saddr.sin_family = addr->sin_family;
 	const char *ipaddr = inet_ntoa(saddr.sin_addr);
 	sys_net->Warning("connecting on %s to port %d", ipaddr, ntohs(saddr.sin_port));
@@ -242,14 +242,14 @@ int sys_net_recv(s32 s, u32 buf_addr, u32 len, s32 flags)
 	return ret;
 }
 
-int sys_net_recvfrom(s32 s, u32 buf_addr, u32 len, s32 flags, mem_ptr_t<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> paddrlen)
+int sys_net_recvfrom(s32 s, u32 buf_addr, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, vm::ptr<be_t<u32>> paddrlen)
 {
 	sys_net->Warning("recvfrom(s=%d, buf_addr=0x%x, len=%u, flags=0x%x, addr_addr=0x%x, paddrlen=0x%x)",
-		s, buf_addr, len, flags, addr.GetAddr(), paddrlen.addr());
+		s, buf_addr, len, flags, addr.addr(), paddrlen.addr());
 
 	char *_buf_addr = (char *)Memory.VirtualToRealAddr(buf_addr);
 	sockaddr _addr;
-	memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
+	memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
 	_addr.sa_family = addr->sa_family;
 	pck_len_t *_paddrlen = (pck_len_t *) Memory.VirtualToRealAddr(paddrlen.addr());
 	int ret = recvfrom(s, _buf_addr, len, flags, &_addr, _paddrlen);
@@ -278,14 +278,14 @@ int sendmsg()
 	return CELL_OK;
 }
 
-int sys_net_sendto(s32 s, u32 buf_addr, u32 len, s32 flags, mem_ptr_t<sys_net_sockaddr> addr, u32 addrlen)
+int sys_net_sendto(s32 s, u32 buf_addr, u32 len, s32 flags, vm::ptr<sys_net_sockaddr> addr, u32 addrlen)
 {
 	sys_net->Warning("sendto(s=%d, buf_addr=0x%x, len=%u, flags=0x%x, addr=0x%x, addrlen=%u)",
-		s, buf_addr, len, flags, addr.GetAddr(), addrlen);
+		s, buf_addr, len, flags, addr.addr(), addrlen);
 
 	char *_buf_addr = (char *)Memory.VirtualToRealAddr(buf_addr);
 	sockaddr _addr;
-	memcpy(&_addr, Memory.VirtualToRealAddr(addr.GetAddr()), sizeof(sockaddr));
+	memcpy(&_addr, addr.get_ptr(), sizeof(sockaddr));
 	_addr.sa_family = addr->sa_family;
 	int ret = sendto(s, _buf_addr, len, flags, &_addr, addrlen);
 	*g_lastError = getLastError();
@@ -341,9 +341,9 @@ int socketselect()
 	return CELL_OK;
 }
 
-int sys_net_initialize_network_ex(mem_ptr_t<sys_net_initialize_parameter> param)
+int sys_net_initialize_network_ex(vm::ptr<sys_net_initialize_parameter> param)
 {
-	sys_net->Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.GetAddr());
+	sys_net->Warning("sys_net_initialize_network_ex(param_addr=0x%x)", param.addr());
 	g_lastError = vm::ptr<be_t<s32>>::make((u32)Memory.Alloc(4, 1));
 #ifdef _WIN32
 	WSADATA wsaData;
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
index 77470ce7f4..87bd66a694 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp
@@ -178,9 +178,9 @@ s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd)
 	return CELL_OK;
 }
 
-s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, vm::ptr<be_t<u64>> nread)
+s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<be_t<u64>> nread)
 {
-	sys_fs->Log("cellFsReaddir(fd=%d, dir_addr=0x%x, nread_addr=0x%x)", fd, dir.GetAddr(), nread.addr());
+	sys_fs->Log("cellFsReaddir(fd=%d, dir_addr=0x%x, nread_addr=0x%x)", fd, dir.addr(), nread.addr());
 
 	vfsDirBase* directory;
 	if(!sys_fs->CheckId(fd, directory))
@@ -190,7 +190,7 @@ s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, vm::ptr<be_t<u64>> nread)
 	if(info)
 	{
 		*nread = 1;
-		Memory.WriteString(dir.GetAddr()+2, info->name);
+		Memory.WriteString(dir.addr() + 2, info->name);
 		dir->d_namlen = info->name.length();
 		dir->d_type = (info->flags & DirEntry_TypeFile) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
 	}
@@ -212,10 +212,10 @@ s32 cellFsClosedir(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsStat(const u32 path_addr, mem_ptr_t<CellFsStat> sb)
+s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
 {
 	const std::string& path = Memory.ReadString(path_addr);
-	sys_fs->Warning("cellFsStat(path=\"%s\", sb_addr: 0x%x)", path.c_str(), sb.GetAddr());
+	sys_fs->Warning("cellFsStat(path=\"%s\", sb_addr: 0x%x)", path.c_str(), sb.addr());
 
 	sb->st_mode = 
 		CELL_FS_S_IRUSR | CELL_FS_S_IWUSR | CELL_FS_S_IXUSR |
@@ -252,9 +252,9 @@ s32 cellFsStat(const u32 path_addr, mem_ptr_t<CellFsStat> sb)
 	return CELL_ENOENT;
 }
 
-s32 cellFsFstat(u32 fd, mem_ptr_t<CellFsStat> sb)
+s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
 {
-	sys_fs->Log("cellFsFstat(fd=%d, sb_addr: 0x%x)", fd, sb.GetAddr());
+	sys_fs->Log("cellFsFstat(fd=%d, sb_addr: 0x%x)", fd, sb.addr());
 
 	IDType type;
 	vfsStream* file;
@@ -503,10 +503,10 @@ s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t
 	return CELL_OK;
 }
 
-s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count)
+s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count)
 {
 	sys_fs->Log("cellFsGetDirectoryEntries(fd=%d, entries_addr=0x%x, entries_size = 0x%x, data_count_addr=0x%x)",
-		fd, entries.GetAddr(), entries_size, data_count.addr());
+		fd, entries.addr(), entries_size, data_count.addr());
 
 	vfsDirBase* directory;
 	if(!sys_fs->CheckId(fd, directory))
@@ -516,7 +516,7 @@ s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u
 	if(info)
 	{
 		*data_count = 1;
-		Memory.WriteString(entries.GetAddr()+2, info->name);
+		Memory.WriteString(entries.addr()+2, info->name);
 		entries->entry_name.d_namlen = info->name.length();
 		entries->entry_name.d_type = (info->flags & DirEntry_TypeFile) ? CELL_FS_TYPE_REGULAR : CELL_FS_TYPE_DIRECTORY;
 
@@ -540,9 +540,9 @@ s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u
 	return CELL_OK;
 }
 
-s32 cellFsStReadInit(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf)
+s32 cellFsStReadInit(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
 {
-	sys_fs->Warning("cellFsStReadInit(fd=%d, ringbuf_addr=0x%x)", fd, ringbuf.GetAddr());
+	sys_fs->Warning("cellFsStReadInit(fd=%d, ringbuf_addr=0x%x)", fd, ringbuf.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
@@ -575,9 +575,9 @@ s32 cellFsStReadFinish(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsStReadGetRingBuf(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf)
+s32 cellFsStReadGetRingBuf(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf)
 {
-	sys_fs->Warning("cellFsStReadGetRingBuf(fd=%d, ringbuf_addr=0x%x)", fd, ringbuf.GetAddr());
+	sys_fs->Warning("cellFsStReadGetRingBuf(fd=%d, ringbuf_addr=0x%x)", fd, ringbuf.addr());
 
 	vfsStream* file;
 	if(!sys_fs->CheckId(fd, file)) return CELL_ESRCH;
diff --git a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
index df017a78d3..0c891ff452 100644
--- a/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
+++ b/rpcs3/Emu/SysCalls/lv2/lv2Fs.h
@@ -129,10 +129,10 @@ s32 cellFsRead(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nread);
 s32 cellFsWrite(u32 fd, u32 buf_addr, u64 nbytes, vm::ptr<be_t<u64>> nwrite);
 s32 cellFsClose(u32 fd);
 s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd);
-s32 cellFsReaddir(u32 fd, mem_ptr_t<CellFsDirent> dir, vm::ptr<be_t<u64>> nread);
+s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<be_t<u64>> nread);
 s32 cellFsClosedir(u32 fd);
-s32 cellFsStat(u32 path_addr, mem_ptr_t<CellFsStat> sb);
-s32 cellFsFstat(u32 fd, mem_ptr_t<CellFsStat> sb);
+s32 cellFsStat(u32 path_addr, vm::ptr<CellFsStat> sb);
+s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb);
 s32 cellFsMkdir(u32 path_addr, u32 mode);
 s32 cellFsRename(u32 from_addr, u32 to_addr);
 s32 cellFsChmod(u32 path_addr, u32 mode);
@@ -145,10 +145,10 @@ s32 cellFsTruncate(u32 path_addr, u64 size);
 s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
 s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size);
 s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count);
-s32 cellFsGetDirectoryEntries(u32 fd, mem_ptr_t<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count);
-s32 cellFsStReadInit(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf);
+s32 cellFsGetDirectoryEntries(u32 fd, vm::ptr<CellFsDirectoryEntry> entries, u32 entries_size, vm::ptr<be_t<u32>> data_count);
+s32 cellFsStReadInit(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf);
 s32 cellFsStReadFinish(u32 fd);
-s32 cellFsStReadGetRingBuf(u32 fd, mem_ptr_t<CellFsRingBuffer> ringbuf);
+s32 cellFsStReadGetRingBuf(u32 fd, vm::ptr<CellFsRingBuffer> ringbuf);
 s32 cellFsStReadGetStatus(u32 fd, vm::ptr<be_t<u64>> status);
 s32 cellFsStReadGetRegid(u32 fd, vm::ptr<be_t<u64>> regid);
 s32 cellFsStReadStart(u32 fd, u64 offset, u64 size);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp b/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
index 7207268f88..8fdc6b6766 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_cond.cpp
@@ -9,10 +9,10 @@
 
 SysCallBase sys_cond("sys_cond");
 
-s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr)
+s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute> attr)
 {
 	sys_cond.Log("sys_cond_create(cond_id_addr=0x%x, mutex_id=%d, attr_addr=0x%x)",
-		cond_id.addr(), mutex_id, attr.GetAddr());
+		cond_id.addr(), mutex_id, attr.addr());
 
 	if (attr->pshared.ToBE() != se32(0x200))
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_cond.h b/rpcs3/Emu/SysCalls/lv2/sys_cond.h
index 0ed9846980..3ed2c93eca 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_cond.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_cond.h
@@ -31,7 +31,7 @@ struct Cond
 };
 
 // SysCalls
-s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr);
+s32 sys_cond_create(vm::ptr<be_t<u32>> cond_id, u32 mutex_id, vm::ptr<sys_cond_attribute> attr);
 s32 sys_cond_destroy(u32 cond_id);
 s32 sys_cond_wait(u32 cond_id, u64 timeout);
 s32 sys_cond_signal(u32 cond_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event.cpp
index 7feff56bf5..bb6f0e5f89 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event.cpp
@@ -10,10 +10,10 @@
 
 SysCallBase sys_event("sys_event");
 
-s32 sys_event_queue_create(vm::ptr<be_t<u32>> equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size)
+s32 sys_event_queue_create(vm::ptr<be_t<u32>> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, int size)
 {
 	sys_event.Warning("sys_event_queue_create(equeue_id_addr=0x%x, attr_addr=0x%x, event_queue_key=0x%llx, size=%d)",
-		equeue_id.addr(), attr.GetAddr(), event_queue_key, size);
+		equeue_id.addr(), attr.addr(), event_queue_key, size);
 
 	if(size <= 0 || size > 127)
 	{
@@ -102,10 +102,10 @@ s32 sys_event_queue_destroy(u32 equeue_id, int mode)
 	return CELL_OK;
 }
 
-s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_array, int size, vm::ptr<be_t<u32>> number)
+s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_data> event_array, int size, vm::ptr<be_t<u32>> number)
 {
 	sys_event.Todo("sys_event_queue_tryreceive(equeue_id=%d, event_array_addr=0x%x, size=%d, number_addr=0x%x)",
-		equeue_id, event_array.GetAddr(), size, number.addr());
+		equeue_id, event_array.addr(), size, number.addr());
 
 	EventQueue* eq;
 	if (!Emu.GetIdManager().GetIDData(equeue_id, eq))
@@ -135,16 +135,16 @@ s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_ar
 		eq->sq.m_mutex.unlock();
 		return CELL_OK;
 	}
-	*number = eq->events.pop_all((sys_event_data*)(Memory + event_array.GetAddr()), size);
+	*number = eq->events.pop_all((sys_event_data*)(Memory + event_array.addr()), size);
 	eq->owner.unlock(tid);
 	eq->sq.m_mutex.unlock();
 	return CELL_OK;
 }
 
-s32 sys_event_queue_receive(u32 equeue_id, mem_ptr_t<sys_event_data> event, u64 timeout)
+s32 sys_event_queue_receive(u32 equeue_id, vm::ptr<sys_event_data> event, u64 timeout)
 {
 	sys_event.Log("sys_event_queue_receive(equeue_id=%d, event_addr=0x%x, timeout=%lld)",
-		equeue_id, event.GetAddr(), timeout);
+		equeue_id, event.addr(), timeout);
 
 	EventQueue* eq;
 	if (!Emu.GetIdManager().GetIDData(equeue_id, eq))
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event.h b/rpcs3/Emu/SysCalls/lv2/sys_event.h
index 8926ed1591..c379370d45 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event.h
@@ -216,10 +216,10 @@ struct EventQueue
 };
 
 // SysCalls
-s32 sys_event_queue_create(vm::ptr<be_t<u32>> equeue_id, mem_ptr_t<sys_event_queue_attr> attr, u64 event_queue_key, int size);
+s32 sys_event_queue_create(vm::ptr<be_t<u32>> equeue_id, vm::ptr<sys_event_queue_attr> attr, u64 event_queue_key, int size);
 s32 sys_event_queue_destroy(u32 equeue_id, int mode);
-s32 sys_event_queue_receive(u32 equeue_id, mem_ptr_t<sys_event_data> event, u64 timeout);
-s32 sys_event_queue_tryreceive(u32 equeue_id, mem_ptr_t<sys_event_data> event_array, int size, vm::ptr<be_t<u32>> number);
+s32 sys_event_queue_receive(u32 equeue_id, vm::ptr<sys_event_data> event, u64 timeout);
+s32 sys_event_queue_tryreceive(u32 equeue_id, vm::ptr<sys_event_data> event_array, int size, vm::ptr<be_t<u32>> number);
 s32 sys_event_queue_drain(u32 event_queue_id);
 
 s32 sys_event_port_create(vm::ptr<be_t<u32>> eport_id, int port_type, u64 name);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
index 274924d9de..98a29d0643 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.cpp
@@ -37,10 +37,10 @@ u32 EventFlag::check()
 	return target;
 }
 
-s32 sys_event_flag_create(vm::ptr<be_t<u32>> eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init)
+s32 sys_event_flag_create(vm::ptr<be_t<u32>> eflag_id, vm::ptr<sys_event_flag_attr> attr, u64 init)
 {
 	sys_event_flag.Warning("sys_event_flag_create(eflag_id_addr=0x%x, attr_addr=0x%x, init=0x%llx)",
-		eflag_id.addr(), attr.GetAddr(), init);
+		eflag_id.addr(), attr.addr(), init);
 
 	switch (attr->protocol.ToBE())
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
index d6dd8ac4e5..90a4fc7a54 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_event_flag.h
@@ -50,7 +50,7 @@ struct EventFlag
 	u32 check();
 };
 
-s32 sys_event_flag_create(vm::ptr<be_t<u32>> eflag_id, mem_ptr_t<sys_event_flag_attr> attr, u64 init);
+s32 sys_event_flag_create(vm::ptr<be_t<u32>> eflag_id, vm::ptr<sys_event_flag_attr> attr, u64 init);
 s32 sys_event_flag_destroy(u32 eflag_id);
 s32 sys_event_flag_wait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result, u64 timeout);
 s32 sys_event_flag_trywait(u32 eflag_id, u64 bitptn, u32 mode, vm::ptr<be_t<u64>> result);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp b/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
index 79bb73ea62..56d1dbd4c9 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_lwcond.cpp
@@ -9,24 +9,24 @@
 
 SysCallBase sys_lwcond("sys_lwcond");
 
-s32 sys_lwcond_create(mem_ptr_t<sys_lwcond_t> lwcond, mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwcond_attribute_t> attr)
+s32 sys_lwcond_create(vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwcond_attribute_t> attr)
 {
 	sys_lwcond.Log("sys_lwcond_create(lwcond_addr=0x%x, lwmutex_addr=0x%x, attr_addr=0x%x)",
-		lwcond.GetAddr(), lwmutex.GetAddr(), attr.GetAddr());
+		lwcond.addr(), lwmutex.addr(), attr.addr());
 
 	u32 id = sys_lwcond.GetNewId(new Lwcond(attr->name_u64), TYPE_LWCOND);
-	lwcond->lwmutex = lwmutex.GetAddr();
+	lwcond->lwmutex = lwmutex.addr();
 	lwcond->lwcond_queue = id;
 
 	sys_lwcond.Warning("*** lwcond created [%s] (lwmutex_addr=0x%x): id = %d", 
-		std::string(attr->name, 8).c_str(), lwmutex.GetAddr(), (u32) lwcond->lwcond_queue);
+		std::string(attr->name, 8).c_str(), lwmutex.addr(), (u32) lwcond->lwcond_queue);
 
 	return CELL_OK;
 }
 
-s32 sys_lwcond_destroy(mem_ptr_t<sys_lwcond_t> lwcond)
+s32 sys_lwcond_destroy(vm::ptr<sys_lwcond_t> lwcond)
 {
-	sys_lwcond.Warning("sys_lwcond_destroy(lwcond_addr=0x%x)", lwcond.GetAddr());
+	sys_lwcond.Warning("sys_lwcond_destroy(lwcond_addr=0x%x)", lwcond.addr());
 
 	u32 id = lwcond->lwcond_queue;
 
@@ -45,9 +45,9 @@ s32 sys_lwcond_destroy(mem_ptr_t<sys_lwcond_t> lwcond)
 	return CELL_OK;
 }
 
-s32 sys_lwcond_signal(mem_ptr_t<sys_lwcond_t> lwcond)
+s32 sys_lwcond_signal(vm::ptr<sys_lwcond_t> lwcond)
 {
-	sys_lwcond.Log("sys_lwcond_signal(lwcond_addr=0x%x)", lwcond.GetAddr());
+	sys_lwcond.Log("sys_lwcond_signal(lwcond_addr=0x%x)", lwcond.addr());
 
 	Lwcond* lw;
 	if (!Emu.GetIdManager().GetIDData((u32)lwcond->lwcond_queue, lw))
@@ -55,7 +55,7 @@ s32 sys_lwcond_signal(mem_ptr_t<sys_lwcond_t> lwcond)
 		return CELL_ESRCH;
 	}
 
-	mem_ptr_t<sys_lwmutex_t> mutex(lwcond->lwmutex);
+	auto mutex = vm::ptr<sys_lwmutex_t>::make(lwcond->lwmutex);
 
 	if (u32 target = (mutex->attribute.ToBE() == se32(SYS_SYNC_PRIORITY) ? lw->m_queue.pop_prio() : lw->m_queue.pop()))
 	{
@@ -71,9 +71,9 @@ s32 sys_lwcond_signal(mem_ptr_t<sys_lwcond_t> lwcond)
 	return CELL_OK;
 }
 
-s32 sys_lwcond_signal_all(mem_ptr_t<sys_lwcond_t> lwcond)
+s32 sys_lwcond_signal_all(vm::ptr<sys_lwcond_t> lwcond)
 {
-	sys_lwcond.Log("sys_lwcond_signal_all(lwcond_addr=0x%x)", lwcond.GetAddr());
+	sys_lwcond.Log("sys_lwcond_signal_all(lwcond_addr=0x%x)", lwcond.addr());
 
 	Lwcond* lw;
 	if (!Emu.GetIdManager().GetIDData((u32)lwcond->lwcond_queue, lw))
@@ -81,7 +81,7 @@ s32 sys_lwcond_signal_all(mem_ptr_t<sys_lwcond_t> lwcond)
 		return CELL_ESRCH;
 	}
 
-	mem_ptr_t<sys_lwmutex_t> mutex(lwcond->lwmutex);
+	auto mutex = vm::ptr<sys_lwmutex_t>::make(lwcond->lwmutex);
 
 	while (u32 target = (mutex->attribute.ToBE() == se32(SYS_SYNC_PRIORITY) ? lw->m_queue.pop_prio() : lw->m_queue.pop()))
 	{
@@ -97,9 +97,9 @@ s32 sys_lwcond_signal_all(mem_ptr_t<sys_lwcond_t> lwcond)
 	return CELL_OK;
 }
 
-s32 sys_lwcond_signal_to(mem_ptr_t<sys_lwcond_t> lwcond, u32 ppu_thread_id)
+s32 sys_lwcond_signal_to(vm::ptr<sys_lwcond_t> lwcond, u32 ppu_thread_id)
 {
-	sys_lwcond.Log("sys_lwcond_signal_to(lwcond_addr=0x%x, ppu_thread_id=%d)", lwcond.GetAddr(), ppu_thread_id);
+	sys_lwcond.Log("sys_lwcond_signal_to(lwcond_addr=0x%x, ppu_thread_id=%d)", lwcond.addr(), ppu_thread_id);
 
 	Lwcond* lw;
 	if (!Emu.GetIdManager().GetIDData((u32)lwcond->lwcond_queue, lw))
@@ -131,9 +131,9 @@ s32 sys_lwcond_signal_to(mem_ptr_t<sys_lwcond_t> lwcond, u32 ppu_thread_id)
 	return CELL_OK;
 }
 
-s32 sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
+s32 sys_lwcond_wait(vm::ptr<sys_lwcond_t> lwcond, u64 timeout)
 {
-	sys_lwcond.Log("sys_lwcond_wait(lwcond_addr=0x%x, timeout=%lld)", lwcond.GetAddr(), timeout);
+	sys_lwcond.Log("sys_lwcond_wait(lwcond_addr=0x%x, timeout=%lld)", lwcond.addr(), timeout);
 
 	Lwcond* lw;
 	if (!Emu.GetIdManager().GetIDData((u32)lwcond->lwcond_queue, lw))
@@ -141,7 +141,7 @@ s32 sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
 		return CELL_ESRCH;
 	}
 
-	mem_ptr_t<sys_lwmutex_t> mutex(lwcond->lwmutex);
+	auto mutex = vm::ptr<sys_lwmutex_t>::make(lwcond->lwmutex);
 	u32 tid_le = GetCurrentPPUThread().GetId();
 	be_t<u32> tid = be_t<u32>::MakeFromLE(tid_le);
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_lwcond.h b/rpcs3/Emu/SysCalls/lv2/sys_lwcond.h
index 5d5584395a..8331fc00db 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_lwcond.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_lwcond.h
@@ -27,9 +27,9 @@ struct Lwcond
 };
 
 // SysCalls
-s32 sys_lwcond_create(mem_ptr_t<sys_lwcond_t> lwcond, mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwcond_attribute_t> attr);
-s32 sys_lwcond_destroy(mem_ptr_t<sys_lwcond_t> lwcond);
-s32 sys_lwcond_signal(mem_ptr_t<sys_lwcond_t> lwcond);
-s32 sys_lwcond_signal_all(mem_ptr_t<sys_lwcond_t> lwcond);
-s32 sys_lwcond_signal_to(mem_ptr_t<sys_lwcond_t> lwcond, u32 ppu_thread_id);
-s32 sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout);
+s32 sys_lwcond_create(vm::ptr<sys_lwcond_t> lwcond, vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwcond_attribute_t> attr);
+s32 sys_lwcond_destroy(vm::ptr<sys_lwcond_t> lwcond);
+s32 sys_lwcond_signal(vm::ptr<sys_lwcond_t> lwcond);
+s32 sys_lwcond_signal_all(vm::ptr<sys_lwcond_t> lwcond);
+s32 sys_lwcond_signal_to(vm::ptr<sys_lwcond_t> lwcond, u32 ppu_thread_id);
+s32 sys_lwcond_wait(vm::ptr<sys_lwcond_t> lwcond, u64 timeout);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp b/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
index 24d7ea6b40..330a56ee0d 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.cpp
@@ -11,10 +11,10 @@ SysCallBase sys_lwmutex("sys_lwmutex");
 
 // TODO: move SleepQueue somewhere
 
-s32 sys_lwmutex_create(mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwmutex_attribute_t> attr)
+s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attribute_t> attr)
 {
 	sys_lwmutex.Log("sys_lwmutex_create(lwmutex_addr=0x%x, lwmutex_attr_addr=0x%x)",
-		lwmutex.GetAddr(), attr.GetAddr());
+		lwmutex.addr(), attr.addr());
 
 	switch (attr->attr_recursive.ToBE())
 	{
@@ -48,9 +48,9 @@ s32 sys_lwmutex_create(mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwmutex_a
 	return CELL_OK;
 }
 
-s32 sys_lwmutex_destroy(mem_ptr_t<sys_lwmutex_t> lwmutex)
+s32 sys_lwmutex_destroy(vm::ptr<sys_lwmutex_t> lwmutex)
 {
-	sys_lwmutex.Warning("sys_lwmutex_destroy(lwmutex_addr=0x%x)", lwmutex.GetAddr());
+	sys_lwmutex.Warning("sys_lwmutex_destroy(lwmutex_addr=0x%x)", lwmutex.addr());
 
 	u32 sq_id = lwmutex->sleep_queue;
 	if (!Emu.GetIdManager().CheckID(sq_id)) return CELL_ESRCH;
@@ -67,29 +67,29 @@ s32 sys_lwmutex_destroy(mem_ptr_t<sys_lwmutex_t> lwmutex)
 	}
 }
 
-s32 sys_lwmutex_lock(mem_ptr_t<sys_lwmutex_t> lwmutex, u64 timeout)
+s32 sys_lwmutex_lock(vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout)
 {
-	sys_lwmutex.Log("sys_lwmutex_lock(lwmutex_addr=0x%x, timeout=%lld)", lwmutex.GetAddr(), timeout);
+	sys_lwmutex.Log("sys_lwmutex_lock(lwmutex_addr=0x%x, timeout=%lld)", lwmutex.addr(), timeout);
 
 	//ConLog.Write("*** lock mutex (addr=0x%x, attr=0x%x, Nrec=%d, owner=%d, waiter=%d)",
-		//lwmutex.GetAddr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter);
+		//lwmutex.addr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter);
 
 	return lwmutex->lock(be_t<u32>::MakeFromLE(GetCurrentPPUThread().GetId()), timeout ? ((timeout < 1000) ? 1 : (timeout / 1000)) : 0);
 }
 
-s32 sys_lwmutex_trylock(mem_ptr_t<sys_lwmutex_t> lwmutex)
+s32 sys_lwmutex_trylock(vm::ptr<sys_lwmutex_t> lwmutex)
 {
-	sys_lwmutex.Log("sys_lwmutex_trylock(lwmutex_addr=0x%x)", lwmutex.GetAddr());
+	sys_lwmutex.Log("sys_lwmutex_trylock(lwmutex_addr=0x%x)", lwmutex.addr());
 
 	return lwmutex->trylock(be_t<u32>::MakeFromLE(GetCurrentPPUThread().GetId()));
 }
 
-s32 sys_lwmutex_unlock(mem_ptr_t<sys_lwmutex_t> lwmutex)
+s32 sys_lwmutex_unlock(vm::ptr<sys_lwmutex_t> lwmutex)
 {
-	sys_lwmutex.Log("sys_lwmutex_unlock(lwmutex_addr=0x%x)", lwmutex.GetAddr());
+	sys_lwmutex.Log("sys_lwmutex_unlock(lwmutex_addr=0x%x)", lwmutex.addr());
 
 	//ConLog.Write("*** unlocking mutex (addr=0x%x, attr=0x%x, Nrec=%d, owner=%d, waiter=%d)",
-		//lwmutex.GetAddr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, (u32)lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter);
+		//lwmutex.addr(), (u32)lwmutex->attribute, (u32)lwmutex->recursive_count, (u32)lwmutex->vars.parts.owner.GetOwner(), (u32)lwmutex->waiter);
 
 	return lwmutex->unlock(be_t<u32>::MakeFromLE(GetCurrentPPUThread().GetId()));
 }
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.h b/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.h
index ab02592b9f..067a317e1b 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_lwmutex.h
@@ -80,8 +80,8 @@ struct sys_lwmutex_t
 };
 
 // SysCalls
-s32 sys_lwmutex_create(mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwmutex_attribute_t> attr);
-s32 sys_lwmutex_destroy(mem_ptr_t<sys_lwmutex_t> lwmutex);
-s32 sys_lwmutex_lock(mem_ptr_t<sys_lwmutex_t> lwmutex, u64 timeout);
-s32 sys_lwmutex_trylock(mem_ptr_t<sys_lwmutex_t> lwmutex);
-s32 sys_lwmutex_unlock(mem_ptr_t<sys_lwmutex_t> lwmutex);
+s32 sys_lwmutex_create(vm::ptr<sys_lwmutex_t> lwmutex, vm::ptr<sys_lwmutex_attribute_t> attr);
+s32 sys_lwmutex_destroy(vm::ptr<sys_lwmutex_t> lwmutex);
+s32 sys_lwmutex_lock(vm::ptr<sys_lwmutex_t> lwmutex, u64 timeout);
+s32 sys_lwmutex_trylock(vm::ptr<sys_lwmutex_t> lwmutex);
+s32 sys_lwmutex_unlock(vm::ptr<sys_lwmutex_t> lwmutex);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
index d49e23ddc4..79958ed504 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.cpp
@@ -86,9 +86,9 @@ s32 sys_memory_free(u32 start_addr)
 	return CELL_OK;
 }
 
-s32 sys_memory_get_page_attribute(u32 addr, mem_ptr_t<sys_page_attr_t> attr)
+s32 sys_memory_get_page_attribute(u32 addr, vm::ptr<sys_page_attr_t> attr)
 {
-	sys_memory.Warning("sys_memory_get_page_attribute(addr=0x%x, attr_addr=0x%x)", addr, attr.GetAddr());
+	sys_memory.Warning("sys_memory_get_page_attribute(addr=0x%x, attr_addr=0x%x)", addr, attr.addr());
 
 	// TODO: Implement per thread page attribute setting.
 	attr->attribute = 0x40000ull; // SYS_MEMORY_PROT_READ_WRITE
@@ -98,9 +98,9 @@ s32 sys_memory_get_page_attribute(u32 addr, mem_ptr_t<sys_page_attr_t> attr)
 	return CELL_OK;
 }
 
-s32 sys_memory_get_user_memory_size(mem_ptr_t<sys_memory_info_t> mem_info)
+s32 sys_memory_get_user_memory_size(vm::ptr<sys_memory_info_t> mem_info)
 {
-	sys_memory.Warning("sys_memory_get_user_memory_size(mem_info_addr=0x%x)", mem_info.GetAddr());
+	sys_memory.Warning("sys_memory_get_user_memory_size(mem_info_addr=0x%x)", mem_info.addr());
 	
 	// Fetch the user memory available.
 	mem_info->total_user_memory = Memory.GetUserMemTotalSize();
@@ -144,9 +144,9 @@ s32 sys_memory_container_destroy(u32 cid)
 	return CELL_OK;
 }
 
-s32 sys_memory_container_get_size(mem_ptr_t<sys_memory_info_t> mem_info, u32 cid)
+s32 sys_memory_container_get_size(vm::ptr<sys_memory_info_t> mem_info, u32 cid)
 {
-	sys_memory.Warning("sys_memory_container_get_size(mem_info_addr=0x%x, cid=%d)", mem_info.GetAddr(), cid);
+	sys_memory.Warning("sys_memory_container_get_size(mem_info_addr=0x%x, cid=%d)", mem_info.addr(), cid);
 
 	// Check if this container ID is valid.
 	MemoryContainerInfo* ct;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_memory.h b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
index 9eb3e12077..3941590e02 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_memory.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_memory.h
@@ -46,8 +46,8 @@ struct MemoryContainerInfo
 s32 sys_memory_allocate(u32 size, u32 flags, u32 alloc_addr_addr);
 s32 sys_memory_allocate_from_container(u32 size, u32 cid, u32 flags, u32 alloc_addr_addr);
 s32 sys_memory_free(u32 start_addr);
-s32 sys_memory_get_page_attribute(u32 addr, mem_ptr_t<sys_page_attr_t> attr);
-s32 sys_memory_get_user_memory_size(mem_ptr_t<sys_memory_info_t> mem_info);
+s32 sys_memory_get_page_attribute(u32 addr, vm::ptr<sys_page_attr_t> attr);
+s32 sys_memory_get_user_memory_size(vm::ptr<sys_memory_info_t> mem_info);
 s32 sys_memory_container_create(vm::ptr<be_t<u32>> cid, u32 yield_size);
 s32 sys_memory_container_destroy(u32 cid);
-s32 sys_memory_container_get_size(mem_ptr_t<sys_memory_info_t> mem_info, u32 cid);
+s32 sys_memory_container_get_size(vm::ptr<sys_memory_info_t> mem_info, u32 cid);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp b/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
index f1c7b1bb74..534496bbd4 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mutex.cpp
@@ -26,9 +26,9 @@ Mutex::~Mutex()
 	m_queue.m_mutex.unlock();
 }
 
-s32 sys_mutex_create(vm::ptr<be_t<u32>> mutex_id, mem_ptr_t<sys_mutex_attribute> attr)
+s32 sys_mutex_create(vm::ptr<be_t<u32>> mutex_id, vm::ptr<sys_mutex_attribute> attr)
 {
-	sys_mutex.Log("sys_mutex_create(mutex_id_addr=0x%x, attr_addr=0x%x)", mutex_id.addr(), attr.GetAddr());
+	sys_mutex.Log("sys_mutex_create(mutex_id_addr=0x%x, attr_addr=0x%x)", mutex_id.addr(), attr.addr());
 
 	switch (attr->protocol.ToBE())
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_mutex.h b/rpcs3/Emu/SysCalls/lv2/sys_mutex.h
index 4ef1dea1b5..a94ce37eaf 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_mutex.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_mutex.h
@@ -40,7 +40,7 @@ struct Mutex
 };
 
 // SysCalls
-s32 sys_mutex_create(vm::ptr<be_t<u32>> mutex_id, mem_ptr_t<sys_mutex_attribute> attr);
+s32 sys_mutex_create(vm::ptr<be_t<u32>> mutex_id, vm::ptr<sys_mutex_attribute> attr);
 s32 sys_mutex_destroy(u32 mutex_id);
 s32 sys_mutex_lock(u32 mutex_id, u64 timeout);
 s32 sys_mutex_trylock(u32 mutex_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
index bc9250180e..700d0f93a3 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp
@@ -200,9 +200,9 @@ s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32
 	return CELL_OK;
 }
 
-void sys_ppu_thread_once(mem_ptr_t<std::atomic<be_t<u32>>> once_ctrl, u32 entry)
+void sys_ppu_thread_once(vm::ptr<std::atomic<be_t<u32>>> once_ctrl, u32 entry)
 {
-	sys_ppu_thread.Warning("sys_ppu_thread_once(once_ctrl_addr=0x%x, entry=0x%x)", once_ctrl.GetAddr(), entry);
+	sys_ppu_thread.Warning("sys_ppu_thread_once(once_ctrl_addr=0x%x, entry=0x%x)", once_ctrl.addr(), entry);
 
 	be_t<u32> old = be_t<u32>::MakeFromBE(se32(SYS_PPU_THREAD_ONCE_INIT));
 	if (once_ctrl->compare_exchange_weak(old, be_t<u32>::MakeFromBE(se32(SYS_PPU_THREAD_DONE_INIT))))
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
index 162f627f41..4805dcff8a 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h
@@ -25,6 +25,6 @@ s32 sys_ppu_thread_get_stack_information(u32 info_addr);
 s32 sys_ppu_thread_stop(u64 thread_id);
 s32 sys_ppu_thread_restart(u64 thread_id);
 s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, u32 threadname_addr);
-void sys_ppu_thread_once(mem_ptr_t<std::atomic<be_t<u32>>> once_ctrl, u32 entry);
+void sys_ppu_thread_once(vm::ptr<std::atomic<be_t<u32>>> once_ctrl, u32 entry);
 s32 sys_ppu_thread_get_id(vm::ptr<be_t<u64>> thread_id);
 s32 sys_ppu_thread_rename(u64 thread_id, u32 name_addr);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
index 38ef93b6fd..eaa84908f3 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_process.cpp
@@ -59,16 +59,16 @@ void sys_game_process_exitspawn(
 	std::vector<std::string> argv;
 	std::vector<std::string> env;
 
-	mem_ptr_t<u32> argvp(argv_addr);
-	while (argvp.GetAddr() && *argvp)
+	auto argvp = vm::ptr<u32>::make(argv_addr);
+	while (argvp && *argvp)
 	{
-		argv.push_back(Memory.ReadString(Memory.Read32(argvp.GetAddr())));
+		argv.push_back(Memory.ReadString(Memory.Read32(argvp.addr())));
 		argvp++;
 	}
-	mem_ptr_t<u32> envp(envp_addr);
-	while (envp.GetAddr() && *envp)
+	auto envp = vm::ptr<u32>::make(envp_addr);
+	while (envp && *envp)
 	{
-		env.push_back(Memory.ReadString(Memory.Read32(envp.GetAddr())));
+		env.push_back(Memory.ReadString(Memory.Read32(envp.addr())));
 		envp++;
 	}
 
@@ -107,16 +107,16 @@ void sys_game_process_exitspawn2(
 	std::vector<std::string> argv;
 	std::vector<std::string> env;
 
-	mem_ptr_t<u32> argvp(argv_addr);
-	while (argvp.GetAddr() && *argvp)
+	auto argvp = vm::ptr<u32>::make(argv_addr);
+	while (argvp && *argvp)
 	{
-		argv.push_back(Memory.ReadString(Memory.Read32(argvp.GetAddr())));
+		argv.push_back(Memory.ReadString(Memory.Read32(argvp.addr())));
 		argvp++;
 	}
-	mem_ptr_t<u32> envp(envp_addr);
-	while (envp.GetAddr() && *envp)
+	auto envp = vm::ptr<u32>::make(envp_addr);
+	while (envp && *envp)
 	{
-		env.push_back(Memory.ReadString(Memory.Read32(envp.GetAddr())));
+		env.push_back(Memory.ReadString(Memory.Read32(envp.addr())));
 		envp++;
 	}
 
@@ -225,7 +225,7 @@ s32 sys_process_get_paramsfo(vm::ptr<u8> buffer)
 
 	MemoryAllocator<be_t<u64>> pos, nread;
 	cellFsLseek(fd, 0, CELL_SEEK_SET, pos); //TODO: Move to the appropriate offset (probably 0x3F7)
-	cellFsRead(fd, buffer.GetAddr(), 40, nread); //WARNING: If offset==0x3F7: The file will end before the buffer (40 bytes) is filled!
+	cellFsRead(fd, buffer.addr(), 40, nread); //WARNING: If offset==0x3F7: The file will end before the buffer (40 bytes) is filled!
 	cellFsClose(fd);
 
 	return CELL_OK;*/
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
index 45bc944813..1027648447 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.cpp
@@ -10,10 +10,10 @@
 
 SysCallBase sys_prx("sys_prx");
 
-s32 sys_prx_load_module(u32 path_addr, u64 flags, mem_ptr_t<sys_prx_load_module_option_t> pOpt)
+s32 sys_prx_load_module(u32 path_addr, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
 {
 	std::string path = Memory.ReadString(path_addr);
-	sys_prx.Todo("sys_prx_load_module(path=\"%s\", flags=0x%llx, pOpt=0x%x)", path.c_str(), flags, pOpt.GetAddr());
+	sys_prx.Todo("sys_prx_load_module(path=\"%s\", flags=0x%llx, pOpt=0x%x)", path.c_str(), flags, pOpt.addr());
 
 	// Check if the file is SPRX
 	std::string local_path;
@@ -61,10 +61,10 @@ s32 sys_prx_load_module_on_memcontainer_by_fd()
 	return CELL_OK;
 }
 
-s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_start_module_option_t> pOpt)
+s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, vm::ptr<sys_prx_start_module_option_t> pOpt)
 {
 	sys_prx.Todo("sys_prx_start_module(id=%d, args=%d, argp_addr=0x%x, modres_addr=0x%x, flags=0x%llx, pOpt=0x%x)",
-		id, args, argp_addr, modres.addr(), flags, pOpt.GetAddr());
+		id, args, argp_addr, modres.addr(), flags, pOpt.addr());
 
 	sys_prx_t* prx;
 	if (!Emu.GetIdManager().GetIDData(id, prx))
@@ -76,10 +76,10 @@ s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> mod
 	return CELL_OK;
 }
 
-s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_stop_module_option_t> pOpt)
+s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, vm::ptr<sys_prx_stop_module_option_t> pOpt)
 {
 	sys_prx.Todo("sys_prx_stop_module(id=%d, args=%d, argp_addr=0x%x, modres_addr=0x%x, flags=0x%llx, pOpt=0x%x)",
-		id, args, argp_addr, modres.addr(), flags, pOpt.GetAddr());
+		id, args, argp_addr, modres.addr(), flags, pOpt.addr());
 
 	sys_prx_t* prx;
 	if (!Emu.GetIdManager().GetIDData(id, prx))
@@ -91,9 +91,9 @@ s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modr
 	return CELL_OK;
 }
 
-s32 sys_prx_unload_module(s32 id, u64 flags, mem_ptr_t<sys_prx_unload_module_option_t> pOpt)
+s32 sys_prx_unload_module(s32 id, u64 flags, vm::ptr<sys_prx_unload_module_option_t> pOpt)
 {
-	sys_prx.Todo("sys_prx_unload_module(id=%d, flags=0x%llx, pOpt=0x%x)", id, flags, pOpt.GetAddr());
+	sys_prx.Todo("sys_prx_unload_module(id=%d, flags=0x%llx, pOpt=0x%x)", id, flags, pOpt.addr());
 
 	// Get the PRX, free the used memory and delete the object and its ID
 	sys_prx_t* prx;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_prx.h b/rpcs3/Emu/SysCalls/lv2/sys_prx.h
index bb93b72617..be554db7bb 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_prx.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_prx.h
@@ -65,13 +65,13 @@ struct sys_prx_t
 };
 
 // SysCalls
-s32 sys_prx_load_module(u32 path_addr, u64 flags, mem_ptr_t<sys_prx_load_module_option_t> pOpt);
+s32 sys_prx_load_module(u32 path_addr, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
 s32 sys_prx_load_module_on_memcontainer();
 s32 sys_prx_load_module_by_fd();
 s32 sys_prx_load_module_on_memcontainer_by_fd();
-s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_start_module_option_t> pOpt);
-s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, mem_ptr_t<sys_prx_stop_module_option_t> pOpt);
-s32 sys_prx_unload_module(s32 id, u64 flags, mem_ptr_t<sys_prx_unload_module_option_t> pOpt);
+s32 sys_prx_start_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, vm::ptr<sys_prx_start_module_option_t> pOpt);
+s32 sys_prx_stop_module(s32 id, u32 args, u32 argp_addr, vm::ptr<be_t<u32>> modres, u64 flags, vm::ptr<sys_prx_stop_module_option_t> pOpt);
+s32 sys_prx_unload_module(s32 id, u64 flags, vm::ptr<sys_prx_unload_module_option_t> pOpt);
 s32 sys_prx_get_module_list();
 s32 sys_prx_get_my_module_id();
 s32 sys_prx_get_module_id_by_address();
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
index 09d979d671..8e4d323d18 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.cpp
@@ -9,9 +9,9 @@
 
 SysCallBase sys_rwlock("sys_rwlock");
 
-s32 sys_rwlock_create(vm::ptr<be_t<u32>> rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr)
+s32 sys_rwlock_create(vm::ptr<be_t<u32>> rw_lock_id, vm::ptr<sys_rwlock_attribute_t> attr)
 {
-	sys_rwlock.Warning("sys_rwlock_create(rw_lock_id_addr=0x%x, attr_addr=0x%x)", rw_lock_id.addr(), attr.GetAddr());
+	sys_rwlock.Warning("sys_rwlock_create(rw_lock_id_addr=0x%x, attr_addr=0x%x)", rw_lock_id.addr(), attr.addr());
 
 	if (!attr)
 		return CELL_EFAULT;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
index 8e18b468de..9b3dcff1a3 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_rwlock.h
@@ -150,7 +150,7 @@ struct RWLock
 };
 
 // SysCalls
-s32 sys_rwlock_create(vm::ptr<be_t<u32>> rw_lock_id, mem_ptr_t<sys_rwlock_attribute_t> attr);
+s32 sys_rwlock_create(vm::ptr<be_t<u32>> rw_lock_id, vm::ptr<sys_rwlock_attribute_t> attr);
 s32 sys_rwlock_destroy(u32 rw_lock_id);
 s32 sys_rwlock_rlock(u32 rw_lock_id, u64 timeout);
 s32 sys_rwlock_tryrlock(u32 rw_lock_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
index 52ff26cbbc..e3e7574821 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.cpp
@@ -11,10 +11,10 @@
 
 SysCallBase sys_semaphore("sys_semaphore");
 
-s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count)
+s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, vm::ptr<sys_semaphore_attribute> attr, int initial_count, int max_count)
 {
 	sys_semaphore.Warning("sys_semaphore_create(sem_addr=0x%x, attr_addr=0x%x, initial_count=%d, max_count=%d)",
-		sem.addr(), attr.GetAddr(), initial_count, max_count);
+		sem.addr(), attr.addr(), initial_count, max_count);
 
 	if (max_count <= 0 || initial_count > max_count || initial_count < 0)
 	{
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
index a27691405a..6ce29cf398 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_semaphore.h
@@ -38,7 +38,7 @@ struct Semaphore
 };
 
 // SysCalls
-s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, mem_ptr_t<sys_semaphore_attribute> attr, int initial_count, int max_count);
+s32 sys_semaphore_create(vm::ptr<be_t<u32>> sem, vm::ptr<sys_semaphore_attribute> attr, int initial_count, int max_count);
 s32 sys_semaphore_destroy(u32 sem_id);
 s32 sys_semaphore_wait(u32 sem_id, u64 timeout);
 s32 sys_semaphore_trywait(u32 sem_id);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spinlock.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spinlock.cpp
index 454b23572b..5c6c3d9f27 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spinlock.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spinlock.cpp
@@ -7,17 +7,17 @@
 
 SysCallBase sys_spinlock("sys_spinlock");
 
-void sys_spinlock_initialize(mem_ptr_t<std::atomic<be_t<u32>>> lock)
+void sys_spinlock_initialize(vm::ptr<std::atomic<be_t<u32>>> lock)
 {
-	sys_spinlock.Log("sys_spinlock_initialize(lock_addr=0x%x)", lock.GetAddr());
+	sys_spinlock.Log("sys_spinlock_initialize(lock_addr=0x%x)", lock.addr());
 
 	// prx: set 0 and sync
 	*lock = be_t<u32>::MakeFromBE(0);
 }
 
-void sys_spinlock_lock(mem_ptr_t<std::atomic<be_t<u32>>> lock)
+void sys_spinlock_lock(vm::ptr<std::atomic<be_t<u32>>> lock)
 {
-	sys_spinlock.Log("sys_spinlock_lock(lock_addr=0x%x)", lock.GetAddr());
+	sys_spinlock.Log("sys_spinlock_lock(lock_addr=0x%x)", lock.addr());
 
 	// prx: exchange with 0xabadcafe, repeat until exchanged with 0
 	while (lock->exchange(be_t<u32>::MakeFromBE(se32(0xabadcafe))).ToBE())
@@ -33,15 +33,15 @@ void sys_spinlock_lock(mem_ptr_t<std::atomic<be_t<u32>>> lock)
 
 		if (Emu.IsStopped())
 		{
-			sys_spinlock.Warning("sys_spinlock_lock(0x%x) aborted", lock.GetAddr());
+			sys_spinlock.Warning("sys_spinlock_lock(0x%x) aborted", lock.addr());
 			break;
 		}
 	}
 }
 
-s32 sys_spinlock_trylock(mem_ptr_t<std::atomic<be_t<u32>>> lock)
+s32 sys_spinlock_trylock(vm::ptr<std::atomic<be_t<u32>>> lock)
 {
-	sys_spinlock.Log("sys_spinlock_trylock(lock_addr=0x%x)", lock.GetAddr());
+	sys_spinlock.Log("sys_spinlock_trylock(lock_addr=0x%x)", lock.addr());
 
 	// prx: exchange with 0xabadcafe, translate exchanged value
 	if (lock->exchange(be_t<u32>::MakeFromBE(se32(0xabadcafe))).ToBE())
@@ -52,9 +52,9 @@ s32 sys_spinlock_trylock(mem_ptr_t<std::atomic<be_t<u32>>> lock)
 	return CELL_OK;
 }
 
-void sys_spinlock_unlock(mem_ptr_t<std::atomic<be_t<u32>>> lock)
+void sys_spinlock_unlock(vm::ptr<std::atomic<be_t<u32>>> lock)
 {
-	sys_spinlock.Log("sys_spinlock_unlock(lock_addr=0x%x)", lock.GetAddr());
+	sys_spinlock.Log("sys_spinlock_unlock(lock_addr=0x%x)", lock.addr());
 
 	// prx: sync and set 0
 	*lock = be_t<u32>::MakeFromBE(0);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spinlock.h b/rpcs3/Emu/SysCalls/lv2/sys_spinlock.h
index 0dfaa371fc..9bab9011a1 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spinlock.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spinlock.h
@@ -1,7 +1,7 @@
 #pragma once
 
 // SysCalls
-void sys_spinlock_initialize(mem_ptr_t<std::atomic<be_t<u32>>> lock);
-void sys_spinlock_lock(mem_ptr_t<std::atomic<be_t<u32>>> lock);
-s32 sys_spinlock_trylock(mem_ptr_t<std::atomic<be_t<u32>>> lock);
-void sys_spinlock_unlock(mem_ptr_t<std::atomic<be_t<u32>>> lock);
+void sys_spinlock_initialize(vm::ptr<std::atomic<be_t<u32>>> lock);
+void sys_spinlock_lock(vm::ptr<std::atomic<be_t<u32>>> lock);
+s32 sys_spinlock_trylock(vm::ptr<std::atomic<be_t<u32>>> lock);
+void sys_spinlock_unlock(vm::ptr<std::atomic<be_t<u32>>> lock);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
index 529931a74e..3b503066c8 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.cpp
@@ -23,10 +23,10 @@ u32 LoadSpuImage(vfsStream& stream, u32& spu_ep)
 }
 
 //156
-s32 sys_spu_image_open(mem_ptr_t<sys_spu_image> img, u32 path_addr)
+s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, u32 path_addr)
 {
 	const std::string path = Memory.ReadString(path_addr);
-	sys_spu.Warning("sys_spu_image_open(img_addr=0x%x, path_addr=0x%x [%s])", img.GetAddr(), path_addr, path.c_str());
+	sys_spu.Warning("sys_spu_image_open(img_addr=0x%x, path_addr=0x%x [%s])", img.addr(), path_addr, path.c_str());
 
 	vfsFile f(path);
 	if(!f.IsOpened())
@@ -47,10 +47,10 @@ s32 sys_spu_image_open(mem_ptr_t<sys_spu_image> img, u32 path_addr)
 }
 
 //172
-s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, mem_ptr_t<sys_spu_image> img, mem_ptr_t<sys_spu_thread_attribute> attr, mem_ptr_t<sys_spu_thread_argument> arg)
+s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, vm::ptr<sys_spu_image> img, vm::ptr<sys_spu_thread_attribute> attr, vm::ptr<sys_spu_thread_argument> arg)
 {
 	sys_spu.Warning("sys_spu_thread_initialize(thread_addr=0x%x, group=0x%x, spu_num=%d, img_addr=0x%x, attr_addr=0x%x, arg_addr=0x%x)",
-		thread.addr(), group, spu_num, img.GetAddr(), attr.GetAddr(), arg.GetAddr());
+		thread.addr(), group, spu_num, img.addr(), attr.addr(), arg.addr());
 
 	SpuGroupInfo* group_info;
 	if(!Emu.GetIdManager().GetIDData(group, group_info))
@@ -107,9 +107,9 @@ s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num,
 }
 
 //166
-s32 sys_spu_thread_set_argument(u32 id, mem_ptr_t<sys_spu_thread_argument> arg)
+s32 sys_spu_thread_set_argument(u32 id, vm::ptr<sys_spu_thread_argument> arg)
 {
-	sys_spu.Warning("sys_spu_thread_set_argument(id=%d, arg_addr=0x%x)", id, arg.GetAddr());
+	sys_spu.Warning("sys_spu_thread_set_argument(id=%d, arg_addr=0x%x)", id, arg.addr());
 	CPUThread* thr = Emu.GetCPU().GetThread(id);
 
 	if(!thr || thr->GetType() != CPU_THREAD_SPU)
@@ -401,10 +401,10 @@ s32 sys_spu_thread_group_terminate(u32 id, int value)
 }
 
 //170
-s32 sys_spu_thread_group_create(vm::ptr<be_t<u32>> id, u32 num, int prio, mem_ptr_t<sys_spu_thread_group_attribute> attr)
+s32 sys_spu_thread_group_create(vm::ptr<be_t<u32>> id, u32 num, int prio, vm::ptr<sys_spu_thread_group_attribute> attr)
 {
 	sys_spu.Warning("sys_spu_thread_group_create(id_addr=0x%x, num=%d, prio=%d, attr_addr=0x%x)",
-		id.addr(), num, prio, attr.GetAddr());
+		id.addr(), num, prio, attr.addr());
 
 	if (num > 256) return CELL_EINVAL;
 
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_spu.h b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
index 4547186697..3354c3e118 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_spu.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_spu.h
@@ -110,16 +110,16 @@ struct SpuGroupInfo
 
 // SysCalls
 s32 sys_spu_initialize(u32 max_usable_spu, u32 max_raw_spu);
-s32 sys_spu_image_open(mem_ptr_t<sys_spu_image> img, u32 path_addr);
-s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, mem_ptr_t<sys_spu_image> img, mem_ptr_t<sys_spu_thread_attribute> attr, mem_ptr_t<sys_spu_thread_argument> arg);
-s32 sys_spu_thread_set_argument(u32 id, mem_ptr_t<sys_spu_thread_argument> arg);
+s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, u32 path_addr);
+s32 sys_spu_thread_initialize(vm::ptr<be_t<u32>> thread, u32 group, u32 spu_num, vm::ptr<sys_spu_image> img, vm::ptr<sys_spu_thread_attribute> attr, vm::ptr<sys_spu_thread_argument> arg);
+s32 sys_spu_thread_set_argument(u32 id, vm::ptr<sys_spu_thread_argument> arg);
 s32 sys_spu_thread_group_destroy(u32 id);
 s32 sys_spu_thread_group_start(u32 id);
 s32 sys_spu_thread_group_suspend(u32 id);
 s32 sys_spu_thread_group_resume(u32 id);
 s32 sys_spu_thread_group_yield(u32 id);	
 s32 sys_spu_thread_group_terminate(u32 id, int value);
-s32 sys_spu_thread_group_create(vm::ptr<be_t<u32>> id, u32 num, int prio, mem_ptr_t<sys_spu_thread_group_attribute> attr);
+s32 sys_spu_thread_group_create(vm::ptr<be_t<u32>> id, u32 num, int prio, vm::ptr<sys_spu_thread_group_attribute> attr);
 s32 sys_spu_thread_create(vm::ptr<be_t<u32>> thread_id, vm::ptr<be_t<u32>> entry, u64 arg, int prio, u32 stacksize, u64 flags, u32 threadname_addr);
 s32 sys_spu_thread_group_join(u32 id, vm::ptr<be_t<u32>> cause, vm::ptr<be_t<u32>> status);
 s32 sys_spu_thread_group_connect_event(u32 id, u32 eq, u32 et);
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp b/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
index fefcb9522e..31cd0699ae 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
+++ b/rpcs3/Emu/SysCalls/lv2/sys_timer.cpp
@@ -26,9 +26,9 @@ s32 sys_timer_destroy(u32 timer_id)
 	return CELL_OK;
 }
 
-s32 sys_timer_get_information(u32 timer_id, mem_ptr_t<sys_timer_information_t> info)
+s32 sys_timer_get_information(u32 timer_id, vm::ptr<sys_timer_information_t> info)
 {
-	sys_timer.Warning("sys_timer_get_information(timer_id=%d, info_addr=0x%x)", timer_id, info.GetAddr());
+	sys_timer.Warning("sys_timer_get_information(timer_id=%d, info_addr=0x%x)", timer_id, info.addr());
 	
 	timer* timer_data = nullptr;
 	if(!sys_timer.CheckId(timer_id, timer_data)) return CELL_ESRCH;
diff --git a/rpcs3/Emu/SysCalls/lv2/sys_timer.h b/rpcs3/Emu/SysCalls/lv2/sys_timer.h
index 9e294f3b62..1d65520047 100644
--- a/rpcs3/Emu/SysCalls/lv2/sys_timer.h
+++ b/rpcs3/Emu/SysCalls/lv2/sys_timer.h
@@ -21,7 +21,7 @@ struct timer
 
 s32 sys_timer_create(vm::ptr<be_t<u32>> timer_id);
 s32 sys_timer_destroy(u32 timer_id);
-s32 sys_timer_get_information(u32 timer_id, mem_ptr_t<sys_timer_information_t> info);
+s32 sys_timer_get_information(u32 timer_id, vm::ptr<sys_timer_information_t> info);
 s32 sys_timer_start(u32 timer_id, s64 basetime, u64 period);
 s32 sys_timer_stop(u32 timer_id);
 s32 sys_timer_connect_event_queue(u32 timer_id, u32 queue_id, u64 name, u64 data1, u64 data2);
diff --git a/rpcs3/Gui/RSXDebugger.cpp b/rpcs3/Gui/RSXDebugger.cpp
index 1e10d2b6fb..8688c189b9 100644
--- a/rpcs3/Gui/RSXDebugger.cpp
+++ b/rpcs3/Gui/RSXDebugger.cpp
@@ -295,9 +295,9 @@ void RSXDebugger::OnClickBuffer(wxMouseEvent& event)
 {
 	if (!RSXReady()) return;
 	const GSRender& render = Emu.GetGSManager().GetRender();
-	const mem_ptr_t<CellGcmDisplayInfo> buffers = render.m_gcm_buffers_addr;
+	const auto buffers = vm::ptr<CellGcmDisplayInfo>::make(render.m_gcm_buffers_addr);
 
-	if(!buffers.IsGood())
+	if(!buffers)
 		return;
 
 	// TODO: Is there any better way to choose the color buffers

From 1626df7e4602bb9388ac06cf478c66886b48273a Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 05:14:24 +0400
Subject: [PATCH 33/36] Compilation fix

---
 rpcs3/Emu/Memory/vm_ptr.h                           | 5 -----
 rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp | 8 ++++----
 2 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/rpcs3/Emu/Memory/vm_ptr.h b/rpcs3/Emu/Memory/vm_ptr.h
index b13675b55f..b62d78f61d 100644
--- a/rpcs3/Emu/Memory/vm_ptr.h
+++ b/rpcs3/Emu/Memory/vm_ptr.h
@@ -448,11 +448,6 @@ namespace vm
 				return (bptr&)addr;
 			}
 
-			operator ptr<T, lvl, AT>() const
-			{
-				return ptr<T, lvl, AT>::make(addr());
-			}
-
 			using bptrb<T, lvl, AT>::operator=;
 		};
 	}
diff --git a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
index eff78cff85..e698e65be9 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSysutil_SaveData.cpp
@@ -340,9 +340,9 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, listSet->fixedList, listSet->fixedListNum);
+	setSaveDataList(saveEntries, vm::ptr<CellSaveDataDirList>::make(listSet->fixedList.addr()), listSet->fixedListNum);
 	if (listSet->newData)
-		addNewSaveDataEntry(saveEntries, listSet->newData);
+		addNewSaveDataEntry(saveEntries, vm::ptr<CellSaveDataListNewData>::make(listSet->newData.addr()));
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListSave2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;
@@ -425,9 +425,9 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 		return CELL_SAVEDATA_ERROR_CBRESULT;
 	}
 
-	setSaveDataList(saveEntries, listSet->fixedList, listSet->fixedListNum);
+	setSaveDataList(saveEntries, vm::ptr<CellSaveDataDirList>::make(listSet->fixedList.addr()), listSet->fixedListNum);
 	if (listSet->newData)
-		addNewSaveDataEntry(saveEntries, listSet->newData);
+		addNewSaveDataEntry(saveEntries, vm::ptr<CellSaveDataListNewData>::make(listSet->newData.addr()));
 	if (saveEntries.size() == 0) {
 		cellSysutil->Warning("cellSaveDataListLoad2: No save entries found!"); // TODO: Find a better way to handle this error
 		return CELL_SAVEDATA_RET_OK;

From 30d7fcd28872637030dbeae96eb99051c3e2bdb1 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 16:18:50 +0400
Subject: [PATCH 34/36] Small mistake

---
 Utilities/BEType.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Utilities/BEType.h b/Utilities/BEType.h
index e8a072851d..5274fe5f56 100644
--- a/Utilities/BEType.h
+++ b/Utilities/BEType.h
@@ -231,7 +231,7 @@ public:
 	static const bool value = false;
 
 	//be_t<T, size> if need swap endianes, T otherwise
-	typedef void type;
+	typedef const void type;
 };
 
 template<typename T, typename T1, T1 value> struct _se : public const_se_t<T, value> {};

From 47ee010b64861489ef08f0500fe05a5db41bdc49 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 16:45:53 +0400
Subject: [PATCH 35/36] Another little bug

---
 rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
index 714f45c1bf..bccbb5fd8d 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellMsgDialog.cpp
@@ -127,11 +127,18 @@ int cellMsgDialogOpen2(u32 type, vm::ptr<const char> msgString, vm::ptr<CellMsgD
 		if (callback && (g_msg_dialog_state != msgDialogAbort))
 			callback.async((s32)status, userData); // TODO: this callback should be registered
 
-		CallAfter([]()
+		CallAfter([&m_signal]()
 		{
 			MsgDialogDestroy();
+
+			m_signal = false;
 		});
 
+		while (m_signal)
+		{
+			std::this_thread::sleep_for(std::chrono::milliseconds(1));
+		}
+
 		g_msg_dialog_state = msgDialogNone;
 	});
 	t.detach();

From fa43e80206ba44473f8f94a919388613c5c4fd89 Mon Sep 17 00:00:00 2001
From: Nekotekina <fbx@3mf.ru>
Date: Tue, 2 Sep 2014 16:50:19 +0400
Subject: [PATCH 36/36] Small mistake

---
 rpcs3/Emu/SysCalls/Modules/cellSync2.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
index 700617edb5..b5045f0cad 100644
--- a/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
+++ b/rpcs3/Emu/SysCalls/Modules/cellSync2.cpp
@@ -427,7 +427,7 @@ void cellSync2_init()
 		FIX_IMPORT(sysPrxForUser, sys_lwmutex_create                  , libsync2 + 0x62D0);
 		FIX_IMPORT(sysPrxForUser, sys_ppu_thread_get_id               , libsync2 + 0x62F0);
 		FIX_IMPORT(sysPrxForUser, _sys_memset                         , libsync2 + 0x6310);
-		FIX_IMPORT(sysPrxForUser, _sys_prs64f                         , libsync2 + 0x6330);
+		FIX_IMPORT(sysPrxForUser, _sys_printf                         , libsync2 + 0x6330);
 		fix_import(sysPrxForUser, 0x9FB6228E                          , libsync2 + 0x6350);
 		FIX_IMPORT(sysPrxForUser, sys_lwmutex_destroy                 , libsync2 + 0x6370);
 		FIX_IMPORT(sysPrxForUser, _sys_strncpy                        , libsync2 + 0x6390);