Some functions removed

Utilities/rTime.cpp

@@ -139,9 +139,9 @@ std::string rDateTime::Format(const std::string &format, const rTimeZone &tz) co
 	return fmt::ToUTF8(static_cast<wxDateTime*>(handle)->Format(fmt::FromUTF8(format),convertTZ(tz)));
 }
 
-void rDateTime::ParseDateTime(const std::string & format)
+void rDateTime::ParseDateTime(const char* format)
 {
-	static_cast<wxDateTime*>(handle)->ParseDateTime(fmt::FromUTF8(format));
+	static_cast<wxDateTime*>(handle)->ParseDateTime(format);
 }
 
 u32 rDateTime::GetAsDOS()

Utilities/rTime.h

@@ -79,7 +79,7 @@ struct rDateTime
 	void Close();
 	std::string Format(const std::string &format = rDefaultDateTimeFormat, const rTimeZone &tz = Local) const;
 
-	void ParseDateTime(const std::string & format);
+	void ParseDateTime(const char* format);
 
 	u32 GetAsDOS();
 	rDateTime &SetFromDOS(u32 fromdos);

rpcs3/Emu/Cell/PPUInterpreter.h

@@ -2945,7 +2945,8 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.ReadLeft(CPU.VPR[vd]._u8 + eb, addr, 16 - eb);
+		CPU.VPR[vd].Clear();
+		for (u32 i = 0; i < 16 - eb; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i);
 	}
 	void LDBRX(u32 rd, u32 ra, u32 rb)
 	{
@@ -2987,7 +2988,8 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.ReadRight(CPU.VPR[vd]._u8, addr & ~0xf, eb);
+		CPU.VPR[vd].Clear();
+		for (u32 i = 16 - eb; i < 16; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i - 16);
 	}
 	void LSWI(u32 rd, u32 ra, u32 nb)
 	{
@@ -3043,7 +3045,7 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.WriteLeft(addr, 16 - eb, CPU.VPR[vs]._u8 + eb);
+		for (u32 i = 0; i < 16 - eb; ++i) Memory.Write8(addr + i, CPU.VPR[vs]._u8[15 - i]);
 	}
 	void STSWX(u32 rs, u32 ra, u32 rb)
 	{
@@ -3062,7 +3064,7 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.WriteRight(addr - eb, eb, CPU.VPR[vs]._u8);
+		for (u32 i = 16 - eb; i < 16; ++i) Memory.Write8(addr + i - 16, CPU.VPR[vs]._u8[15 - i]);
 	}
 	void STFSUX(u32 frs, u32 ra, u32 rb)
 	{
@@ -3113,7 +3115,8 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.ReadLeft(CPU.VPR[vd]._u8 + eb, addr, 16 - eb);
+		CPU.VPR[vd].Clear();
+		for (u32 i = 0; i < 16 - eb; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i);
 	}
 	void LHBRX(u32 rd, u32 ra, u32 rb)
 	{
@@ -3158,7 +3161,8 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.ReadRight(CPU.VPR[vd]._u8, addr & ~0xf, eb);
+		CPU.VPR[vd].Clear();
+		for (u32 i = 16 - eb; i < 16; ++i) CPU.VPR[vd]._u8[15 - i] = Memory.Read8(addr + i - 16);
 	}
 	void DSS(u32 strm, u32 a)
 	{
@@ -3193,7 +3197,7 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.WriteLeft(addr, 16 - eb, CPU.VPR[vs]._u8 + eb);
+		for (u32 i = 0; i < 16 - eb; ++i) Memory.Write8(addr + i, CPU.VPR[vs]._u8[15 - i]);
 	}
 	void STHBRX(u32 rs, u32 ra, u32 rb)
 	{
@@ -3209,7 +3213,7 @@ private:
 		const u64 addr = ra ? CPU.GPR[ra] + CPU.GPR[rb] : CPU.GPR[rb];
 		const u8 eb = addr & 0xf;
 
-		Memory.WriteRight(addr - eb, eb, CPU.VPR[vs]._u8);
+		for (u32 i = 16 - eb; i < 16; ++i) Memory.Write8(addr + i - 16, CPU.VPR[vs]._u8[15 - i]);
 	}
 	void EXTSB(u32 ra, u32 rs, bool rc)
 	{

rpcs3/Emu/Cell/PPUThread.h

@@ -516,7 +516,7 @@ union VPR_reg
 		_u64[1] |= (value & 0x1) << bit;
 	}
 
-	void Clear() { memset(this, 0, sizeof(*this)); }
+	void Clear() { _u64[1] = _u64[0] = 0; }
 };
 
 static const s32 MAX_INT_VALUE = 0x7fffffff;

rpcs3/Emu/Memory/Memory.h

@@ -313,41 +313,6 @@ public:
 		}
 	}
 
-	void ReadLeft(u8* dst, const u64 addr, const u32 size)
-	{
-		for (u32 i = 0; i < size; ++i) dst[size - 1 - i] = Read8(addr + i);
-	}
-
-	void WriteLeft(const u64 addr, const u32 size, const u8* src)
-	{
-		for (u32 i = 0; i < size; ++i) Write8(addr + i, src[size - 1 - i]);
-	}
-
-	void ReadRight(u8* dst, const u64 addr, const u32 size)
-	{
-		for (u32 i = 0; i < size; ++i) dst[i] = Read8(addr + (size - 1 - i));
-	}
-
-	void WriteRight(const u64 addr, const u32 size, const u8* src)
-	{
-		for (u32 i = 0; i < size; ++i) Write8(addr + (size - 1 - i), src[i]);
-	}
-
-	//template<typename T, typename Td> void WriteData(const T addr, const Td* data)
-	//{
-	//	memcpy(GetMemFromAddr<T>(addr), data, sizeof(Td));
-	//}
-
-	//template<typename T, typename Td> void WriteData(const T addr, const Td data)
-	//{
-	//	*(Td*)GetMemFromAddr<T>(addr) = data;
-	//}
-
-	template<typename T> std::string ReadString(const T addr)
-	{
-		return std::string((const char*)GetMemFromAddr<T>(addr));
-	}
-
 	template<typename T> void WriteString(const T addr, const std::string& str)
 	{
 		memcpy((char*)GetMemFromAddr<T>(addr), str.c_str(), str.size() + 1);

rpcs3/Emu/Memory/vm_ptr.h

@@ -58,31 +58,30 @@ namespace vm
 			return make(m_addr - count * sizeof(AT));
 		}
 
-		__forceinline _ptr_base<T, lvl - 1, AT>& operator *()
+		__forceinline _ptr_base<T, lvl - 1, AT>& operator *() const
 		{
 			return vm::get_ref<_ptr_base<T, lvl - 1, AT>>(m_addr);
 		}
 
-		__forceinline const _ptr_base<T, lvl - 1, AT>& operator *() const
+		__forceinline _ptr_base<T, lvl - 1, AT>& operator [](int index) const
-		{
-			return vm::get_ref<const _ptr_base<T, lvl - 1, AT>>(m_addr);
-		}
-
-		__forceinline _ptr_base<T, lvl - 1, AT>& operator [](int index)
 		{
 			return vm::get_ref<_ptr_base<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
 		}
 
-		__forceinline const _ptr_base<T, lvl - 1, AT>& operator [](int index) const
-		{
-			return vm::get_ref<const _ptr_base<T, lvl - 1, AT>>(m_addr + sizeof(AT) * index);
-		}
-
 		operator bool() const
 		{
 			return m_addr != 0;
 		}
 
+		//typedef typename invert_be_t<AT>::type AT2;
+
+		template<typename AT2>
+		operator const _ptr_base<T, lvl, AT2>() const
+		{
+			std::remove_const<AT2>::type addr; addr = m_addr;
+			return (_ptr_base<T, lvl, AT2>&)addr;
+		}
+		
 		AT addr() const
 		{
 			return m_addr;
@@ -92,6 +91,8 @@ namespace vm
 		{
 			return (_ptr_base&)addr;
 		}
+
+		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 	
 	template<typename T, typename AT>
@@ -100,16 +101,11 @@ namespace vm
 		AT m_addr;
 		
 	public:
-		__forceinline T* const operator -> ()
+		__forceinline T* const operator -> () const
 		{
 			return vm::get_ptr<T>(m_addr);
 		}
 
-		__forceinline const T* const operator -> () const
-		{
-			return vm::get_ptr<const T>(m_addr);
-		}
-
 		_ptr_base operator++ (int)
 		{
 			AT result = m_addr;
@@ -158,26 +154,16 @@ namespace vm
 			return make(m_addr - count * sizeof(T));
 		}
 
-		__forceinline T& operator *()
+		__forceinline T& operator *() const
 		{
 			return get_ref<T>(m_addr);
 		}
 
-		__forceinline const T& operator *() const
+		__forceinline T& operator [](int index) 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_base<T, AT>()
 		{
@@ -200,6 +186,15 @@ namespace vm
 			return m_addr != 0;
 		}
 
+		//typedef typename invert_be_t<AT>::type AT2;
+
+		template<typename AT2>
+		operator const _ptr_base<T, 1, AT2>() const
+		{
+			std::remove_const<AT2>::type addr; addr = m_addr;
+			return (_ptr_base<T, 1, AT2>&)addr;
+		}
+
 		T* const get_ptr() const
 		{
 			return vm::get_ptr<T>(m_addr);
@@ -209,6 +204,8 @@ namespace vm
 		{
 			return (_ptr_base&)addr;
 		}
+
+		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 
 	template<typename AT>
@@ -232,10 +229,21 @@ namespace vm
 			return m_addr != 0;
 		}
 
+		//typedef typename invert_be_t<AT>::type AT2;
+
+		template<typename AT2>
+		operator const _ptr_base<void, 1, AT2>() const
+		{
+			std::remove_const<AT2>::type addr; addr = m_addr;
+			return (_ptr_base<void, 1, AT2>&)addr;
+		}
+
 		static _ptr_base make(AT addr)
 		{
 			return (_ptr_base&)addr;
 		}
+
+		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 
 	template<typename AT>
@@ -259,10 +267,21 @@ namespace vm
 			return m_addr != 0;
 		}
 
+		//typedef typename invert_be_t<AT>::type AT2;
+
+		template<typename AT2>
+		operator const _ptr_base<const void, 1, AT2>() const
+		{
+			std::remove_const<AT2>::type addr; addr = m_addr;
+			return (_ptr_base<const void, 1, AT2>&)addr;
+		}
+
 		static _ptr_base make(AT addr)
 		{
 			return (_ptr_base&)addr;
 		}
+
+		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 	
 	template<typename RT, typename AT>
@@ -304,6 +323,15 @@ namespace vm
 			return m_addr != 0;
 		}
 
+		//typedef typename invert_be_t<AT>::type AT2;
+
+		template<typename AT2>
+		operator const _ptr_base<RT(*)(), 1, AT2>() const
+		{
+			std::remove_const<AT2>::type addr; addr = m_addr;
+			return (_ptr_base<RT(*)(), 1, AT2>&)addr;
+		}
+
 		static _ptr_base make(AT addr)
 		{
 			return (_ptr_base&)addr;
@@ -314,6 +342,8 @@ namespace vm
 			const AT addr = m_addr;
 			return [addr]() -> RT { return make(addr)(); };
 		}
+
+		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 
 	template<typename AT, typename RT, typename ...T>
@@ -371,16 +401,27 @@ namespace vm
 			return m_addr != 0;
 		}
 
+		//typedef typename invert_be_t<AT>::type AT2;
+
+		template<typename AT2>
+		operator const _ptr_base<RT(*)(T...), 1, AT2>() const
+		{
+			std::remove_const<AT2>::type addr; addr = m_addr;
+			return (_ptr_base<RT(*)(T...), 1, AT2>&)addr;
+		}
+
 		static _ptr_base make(AT addr)
 		{
 			return (_ptr_base&)addr;
 		}
 
-		operator std::function<RT(T...)>() const
+		operator const std::function<RT(T...)>() const
 		{
-			const AT addr = m_addr;
+			std::remove_const<AT>::type AT addr; addr = m_addr;
 			return [addr](T... args) -> RT { return make(addr)(args...); };
 		}
+
+		_ptr_base& operator = (const _ptr_base& right) = default;
 	};
 
 	//BE pointer to LE data
@@ -392,6 +433,7 @@ namespace vm
 		}
 
 		using _ptr_base<T, lvl, typename to_be_t<AT>::type>::operator=;
+		//using _ptr_base<T, lvl, typename to_be_t<AT>::type>::operator const _ptr_base<T, lvl, AT>;
 	};
 
 	//BE pointer to BE data
@@ -403,6 +445,7 @@ namespace vm
 		}
 
 		using _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::operator=;
+		//using _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>::operator const _ptr_base<typename to_be_t<T>::type, lvl, AT>;
 	};
 
 	//LE pointer to BE data
@@ -414,6 +457,7 @@ namespace vm
 		}
 
 		using _ptr_base<typename to_be_t<T>::type, lvl, AT>::operator=;
+		//using _ptr_base<typename to_be_t<T>::type, lvl, AT>::operator const _ptr_base<typename to_be_t<T>::type, lvl, typename to_be_t<AT>::type>;
 	};
 
 	//LE pointer to LE data
@@ -425,6 +469,7 @@ namespace vm
 		}
 
 		using _ptr_base<T, lvl, AT>::operator=;
+		//using _ptr_base<T, lvl, AT>::operator const _ptr_base<T, lvl, typename to_be_t<AT>::type>;
 	};
 
 	namespace ps3
@@ -438,6 +483,7 @@ namespace vm
 			}
 
 			using lptrb<T, lvl, AT>::operator=;
+			//using lptrb<T, lvl, AT>::operator const _ptr_base<typename to_be_t<T>::type, lvl, AT>;
 		};
 
 		//default pointer for HLE structures (BE ptrerence to BE data)
@@ -449,6 +495,7 @@ namespace vm
 			}
 
 			using bptrb<T, lvl, AT>::operator=;
+			//using bptrb<T, lvl, AT>::operator const _ptr_base<typename to_be_t<T>::type, lvl, AT>;
 		};
 	}
 

rpcs3/Emu/SysCalls/Modules/cellGifDec.cpp

@@ -23,7 +23,7 @@ int cellGifDecExtCreate(u32 mainHandle, u32 threadInParam, u32 threadOutParam, u
 	return CELL_OK;
 }
 
-int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const vm::ptr<CellGifDecSrc> src, vm::ptr<CellGifDecOpnInfo> openInfo)
+int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, 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.addr(), openInfo.addr());
@@ -41,7 +41,7 @@ int cellGifDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, const vm::ptr<C
 	case se32(CELL_GIFDEC_FILE):
 		// Get file descriptor
 		vm::var<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
+		int ret = cellFsOpen(vm::ptr<const char>::make(src->fileName.addr()), 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;
 

rpcs3/Emu/SysCalls/Modules/cellGifDec.h

@@ -53,7 +53,7 @@ struct CellGifDecInfo
 struct CellGifDecSrc
 {
 	be_t<u32> srcSelect;
-	be_t<u32> fileName;
+	vm::bptr<const char> fileName;
 	be_t<s64> fileOffset;
 	be_t<u64> fileSize;
 	be_t<u32> streamPtr;

rpcs3/Emu/SysCalls/Modules/cellJpgDec.cpp

@@ -47,7 +47,7 @@ int cellJpgDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellJpg
 	case se32(CELL_JPGDEC_FILE):
 		// Get file descriptor
 		vm::var<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
+		int ret = cellFsOpen(vm::ptr<const char>::make(src->fileName.addr()), 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;
 

rpcs3/Emu/SysCalls/Modules/cellJpgDec.h

@@ -56,7 +56,7 @@ struct CellJpgDecInfo
 struct CellJpgDecSrc
 {
 	be_t<u32> srcSelect;       // CellJpgDecStreamSrcSel
-	be_t<u32> fileName;        // const char*
+	vm::bptr<const char> fileName;
 	be_t<u64> fileOffset;      // int64_t
 	be_t<u32> fileSize;
 	be_t<u32> streamPtr;

rpcs3/Emu/SysCalls/Modules/cellPngDec.cpp

@@ -69,7 +69,7 @@ int cellPngDecOpen(u32 mainHandle, vm::ptr<be_t<u32>> subHandle, vm::ptr<CellPng
 	case se32(CELL_PNGDEC_FILE):
 		// Get file descriptor
 		vm::var<be_t<u32>> fd;
-		int ret = cellFsOpen(src->fileName_addr, 0, fd, vm::ptr<be_t<u32>>::make(0), 0);
+		int ret = cellFsOpen(vm::ptr<const char>::make(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;
 

rpcs3/Emu/SysCalls/Modules/cellPngDec.h

@@ -78,7 +78,7 @@ struct CellPngDecInfo
 struct CellPngDecSrc
 {
 	be_t<u32> srcSelect;          // CellPngDecStreamSrcSel
-	be_t<u32> fileName_addr;      // const char*
+	vm::bptr<const char> fileName;
 	be_t<s64> fileOffset;
 	be_t<u32> fileSize;
 	be_t<u32> streamPtr;

rpcs3/Emu/SysCalls/Modules/cellRtc.cpp

@@ -135,28 +135,26 @@ int cellRtcFormatRfc3339LocalTime(u32 pszDateTime_addr, vm::ptr<CellRtcTick> pUt
 	return CELL_OK;
 }
 
-int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, u32 pszDateTime_addr)
+int cellRtcParseDateTime(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateTime)
 {
-	cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime_addr);
+	cellRtc->Log("cellRtcParseDateTime(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
 
 	// Get date from formatted string.
 	rDateTime date;
-	const std::string& format = Memory.ReadString(pszDateTime_addr);
+	date.ParseDateTime(pszDateTime.get_ptr());
-	date.ParseDateTime(format);
 
 	pUtc->tick = date.GetTicks();
 
 	return CELL_OK;
 }
 
-int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, u32 pszDateTime_addr)
+int cellRtcParseRfc3339(vm::ptr<CellRtcTick> pUtc, vm::ptr<const char> pszDateTime)
 {
-	cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime_addr);
+	cellRtc->Log("cellRtcParseRfc3339(pUtc=0x%x, pszDateTime_addr=0x%x)", pUtc.addr(), pszDateTime.addr());
 
 	// Get date from RFC3339 formatted string.
 	rDateTime date;
-	const std::string& format = Memory.ReadString(pszDateTime_addr);
+	date.ParseDateTime(pszDateTime.get_ptr());
-	date.ParseDateTime(format);
 
 	pUtc->tick = date.GetTicks();
 

rpcs3/Emu/SysCalls/Modules/cellSaveData.cpp

@@ -7,7 +7,7 @@
 #include "Emu/FS/vfsFile.h"
 #include "Emu/FS/vfsDir.h"
 #include "Loader/PSF.h"
-#include "cellSysutil_SaveData.h"
+#include "cellSaveData.h"
 
 extern Module *cellSysutil;
 
@@ -88,10 +88,10 @@ void addSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, const std::string
 void addNewSaveDataEntry(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveDataListNewData> newData)
 {
 	SaveDataEntry saveEntry;
-	saveEntry.dirName = (char*)Memory.VirtualToRealAddr(newData->dirName_addr);
+	saveEntry.dirName = newData->dirName.get_ptr();
-	saveEntry.title = (char*)Memory.VirtualToRealAddr(newData->icon->title_addr);
+	saveEntry.title = newData->icon->title.get_ptr();
-	saveEntry.subtitle = (char*)Memory.VirtualToRealAddr(newData->icon->title_addr);
+	saveEntry.subtitle = newData->icon->title.get_ptr();
-	saveEntry.iconBuf = Memory.VirtualToRealAddr(newData->icon->iconBuf_addr);
+	saveEntry.iconBuf = newData->icon->iconBuf.get_ptr();
 	saveEntry.iconBufSize = newData->icon->iconBufSize;
 	saveEntry.isNew = true;
 	// TODO: Add information stored in newData->iconPosition. (It's not very relevant)
@@ -131,7 +131,7 @@ void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveD
 	std::vector<SaveDataEntry>::iterator entry = saveEntries.begin();
 	while (entry != saveEntries.end())
 	{
-		if (entry->dirName == (char*)Memory.VirtualToRealAddr(fixedSet->dirName_addr))
+		if (entry->dirName == fixedSet->dirName.get_ptr())
 			entry = saveEntries.erase(entry);
 		else
 			entry++;
@@ -140,17 +140,17 @@ void setSaveDataFixed(std::vector<SaveDataEntry>& saveEntries, vm::ptr<CellSaveD
 	if (saveEntries.size() == 0)
 	{
 		SaveDataEntry entry;
-		entry.dirName = (char*)Memory.VirtualToRealAddr(fixedSet->dirName_addr);
+		entry.dirName = fixedSet->dirName.get_ptr();
 		entry.isNew = true;
 		saveEntries.push_back(entry);
 	}
 
 	if (fixedSet->newIcon)
 	{
-		saveEntries[0].iconBuf = Memory.VirtualToRealAddr(fixedSet->newIcon->iconBuf_addr);
+		saveEntries[0].iconBuf = fixedSet->newIcon->iconBuf.get_ptr();
 		saveEntries[0].iconBufSize = fixedSet->newIcon->iconBufSize;
-		saveEntries[0].title = (char*)Memory.VirtualToRealAddr(fixedSet->newIcon->title_addr);
+		saveEntries[0].title = fixedSet->newIcon->title.get_ptr();
-		saveEntries[0].subtitle = (char*)Memory.VirtualToRealAddr(fixedSet->newIcon->title_addr);
+		saveEntries[0].subtitle = fixedSet->newIcon->title.get_ptr();
 	}
 }
 
@@ -168,13 +168,13 @@ void getSaveDataStat(SaveDataEntry entry, vm::ptr<CellSaveDataStatGet> statGet)
 	statGet->dir.st_atime_ = 0; // TODO ?
 	statGet->dir.st_mtime_ = 0; // TODO ?
 	statGet->dir.st_ctime_ = 0; // TODO ?
-	memcpy(statGet->dir.dirName, entry.dirName.c_str(), CELL_SAVEDATA_DIRNAME_SIZE);
+	strcpy_trunc(statGet->dir.dirName, entry.dirName);
 
 	statGet->getParam.attribute = 0; // TODO ?
-	memcpy(statGet->getParam.title, entry.title.c_str(), CELL_SAVEDATA_SYSP_TITLE_SIZE);
+	strcpy_trunc(statGet->getParam.title, entry.title);
-	memcpy(statGet->getParam.subTitle, entry.subtitle.c_str(), CELL_SAVEDATA_SYSP_SUBTITLE_SIZE);
+	strcpy_trunc(statGet->getParam.subTitle, entry.subtitle);
-	memcpy(statGet->getParam.detail, entry.details.c_str(), CELL_SAVEDATA_SYSP_DETAIL_SIZE);
+	strcpy_trunc(statGet->getParam.detail, entry.details);
-	memcpy(statGet->getParam.listParam, entry.listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+	strcpy_trunc(statGet->getParam.listParam, entry.listParam);
 
 	statGet->fileNum = 0;
 	statGet->fileList = vm::bptr<CellSaveDataFileStat>::make(0);
@@ -203,7 +203,7 @@ void getSaveDataStat(SaveDataEntry entry, vm::ptr<CellSaveDataStatGet> statGet)
 			fileEntry.st_atime_ = 0; // TODO ?
 			fileEntry.st_mtime_ = 0; // TODO ?
 			fileEntry.st_ctime_ = 0; // TODO ?
-			memcpy(fileEntry.fileName, dirEntry->name.c_str(), CELL_SAVEDATA_FILENAME_SIZE);
+			strcpy_trunc(fileEntry.fileName, dirEntry->name);
 
 			fileEntries.push_back(fileEntry);
 		}
@@ -236,12 +236,12 @@ s32 modifySaveDataFiles(vm::ptr<CellSaveDataFileCallback> funcFile, vm::ptr<Cell
 
 		std::string filepath = saveDataDir + '/';
 		vfsStream* file = NULL;
-		void* buf = Memory.VirtualToRealAddr(fileSet->fileBuf_addr);
+		void* buf = fileSet->fileBuf.get_ptr();
 
 		switch ((u32)fileSet->fileType)
 		{
-		case CELL_SAVEDATA_FILETYPE_SECUREFILE:     filepath += (char*)Memory.VirtualToRealAddr(fileSet->fileName_addr); break;
+		case CELL_SAVEDATA_FILETYPE_SECUREFILE:     filepath += fileSet->fileName.get_ptr(); break;
-		case CELL_SAVEDATA_FILETYPE_NORMALFILE:     filepath += (char*)Memory.VirtualToRealAddr(fileSet->fileName_addr); break;
+		case CELL_SAVEDATA_FILETYPE_NORMALFILE:     filepath += fileSet->fileName.get_ptr(); break;
 		case CELL_SAVEDATA_FILETYPE_CONTENT_ICON0:  filepath += "ICON0.PNG"; break;
 		case CELL_SAVEDATA_FILETYPE_CONTENT_ICON1:  filepath += "ICON1.PAM"; break;
 		case CELL_SAVEDATA_FILETYPE_CONTENT_PIC1:   filepath += "PIC1.PNG";  break;
@@ -289,10 +289,10 @@ s32 modifySaveDataFiles(vm::ptr<CellSaveDataFileCallback> funcFile, vm::ptr<Cell
 // Functions
 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)
+						  u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), setBuf.addr(), 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;
@@ -305,7 +305,7 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 	if(!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
+	std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
 	std::vector<SaveDataEntry> saveEntries;
 
 	for(const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@@ -325,12 +325,13 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	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);
+		strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
-		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+		strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
+		*dirList[i].reserved = {};
 	}
 
 	funcList(result, listGet, listSet);
@@ -352,7 +353,7 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 	// TODO: Display the dialog here
 	u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
 	getSaveDataStat(saveEntries[selectedIndex], statGet);
-	result->userdata_addr = userdata_addr;
+	result->userdata = userdata;
 
 	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.addr());
@@ -373,10 +374,10 @@ int cellSaveDataListSave2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 
 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)
+						  u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), setBuf.addr(), 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;
@@ -390,7 +391,7 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 	if(!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
+	std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
 	std::vector<SaveDataEntry> saveEntries;
 
 	for(const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@@ -410,12 +411,13 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	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);
+		strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
-		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+		strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
+		*dirList[i].reserved = {};
 	}
 
 	funcList(result, listGet, listSet);
@@ -437,7 +439,7 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 	// TODO: Display the dialog here
 	u32 selectedIndex = focusIndex; // TODO: Until the dialog is implemented, select always the focused entry
 	getSaveDataStat(saveEntries[selectedIndex], statGet);
-	result->userdata_addr = userdata_addr;
+	result->userdata = userdata;
 
 	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.addr());
@@ -458,10 +460,10 @@ int cellSaveDataListLoad2(u32 version, vm::ptr<CellSaveDataSetList> setList, vm:
 
 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)
+						   u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), setBuf.addr(), 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;
@@ -474,7 +476,7 @@ int cellSaveDataFixedSave2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 	if (!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
+	std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
 	std::vector<SaveDataEntry> saveEntries;
 	for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
 	{
@@ -493,11 +495,12 @@ int cellSaveDataFixedSave2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	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);
+		strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
-		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+		strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
+		*dirList[i].reserved = {};
 	}
 	funcFixed(result, listGet, fixedSet);
 	if (result->result < 0)	{
@@ -507,7 +510,7 @@ int cellSaveDataFixedSave2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 	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;
+	result->userdata = userdata;
 
 	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.addr());
@@ -527,10 +530,10 @@ int cellSaveDataFixedSave2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 
 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)
+						   u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), setBuf.addr(), 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;
@@ -543,7 +546,7 @@ int cellSaveDataFixedLoad2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 	if (!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
+	std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
 	std::vector<SaveDataEntry> saveEntries;
 	for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
 	{
@@ -562,11 +565,12 @@ int cellSaveDataFixedLoad2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	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);
+		strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
-		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+		strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
+		*dirList[i].reserved = {};
 	}
 	funcFixed(result, listGet, fixedSet);
 	if (result->result < 0)	{
@@ -576,7 +580,7 @@ int cellSaveDataFixedLoad2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 	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;
+	result->userdata = userdata;
 
 	funcStat(result, statGet, statSet);
 	Memory.Free(statGet->fileList.addr());
@@ -594,12 +598,12 @@ int cellSaveDataFixedLoad2(u32 version,  vm::ptr<CellSaveDataSetList> setList, v
 	return ret;
 }
 
-int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoSave2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
-						  u32 container, u32 userdata_addr)
+						  u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), 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;
@@ -610,26 +614,26 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
 	if (!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirName = Memory.ReadString(dirName_addr);
+	std::string dirN = dirName.get_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 == dirN) {
-			addSaveDataEntry(saveEntries, saveBaseDir+dirName);
+			addSaveDataEntry(saveEntries, saveBaseDir + dirN);
 		}
 	}
 
 	// The target entry does not exist
 	if (saveEntries.size() == 0) {
 		SaveDataEntry entry;
-		entry.dirName = dirName;
+		entry.dirName = dirN;
 		entry.sizeKB = 0;
 		entry.isNew = true;
 		saveEntries.push_back(entry);
 	}
 
 	getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
-	result->userdata_addr = userdata_addr;
+	result->userdata = userdata;
 	funcStat(result, statGet, statSet);
 
 	Memory.Free(statGet->fileList.addr());
@@ -647,12 +651,12 @@ int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
 	return CELL_SAVEDATA_RET_OK;
 }
 
-int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoLoad2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
-						  u32 container, u32 userdata_addr)
+						  u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), 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;
@@ -663,23 +667,23 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
 	if (!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirName = Memory.ReadString(dirName_addr);
+	std::string dirN = dirName.get_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 == dirN) {
-			addSaveDataEntry(saveEntries, saveBaseDir+dirName);
+			addSaveDataEntry(saveEntries, saveBaseDir + dirN);
 		}
 	}
 
 	// The target entry does not exist
 	if (saveEntries.size() == 0) {
-		cellSysutil->Warning("cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirName.c_str());
+		cellSysutil->Warning("cellSaveDataAutoLoad2: Couldn't find save entry (%s)", dirN.c_str());
 		return CELL_OK; // TODO: Can anyone check the actual behaviour of a PS3 when saves are not found?
 	}
 
 	getSaveDataStat(saveEntries[0], statGet); // There should be only one element in this list
-	result->userdata_addr = userdata_addr;
+	result->userdata = userdata;
 	funcStat(result, statGet, statSet);
 
 	Memory.Free(statGet->fileList.addr());
@@ -698,10 +702,10 @@ int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<
 }
 
 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)
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), setBuf.addr(), 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;
@@ -715,7 +719,7 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
 	if (!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
+	std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
 	std::vector<SaveDataEntry> saveEntries;
 
 	for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@@ -735,12 +739,13 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	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);
+		strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName.c_str());
-		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+		strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam.c_str());
+		*dirList[i].reserved = {};
 	}
 
 	throw fmt::Format("%s(): implementation broken", __FUNCTION__);
@@ -783,10 +788,10 @@ int cellSaveDataListAutoSave(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
 }
 
 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)
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata)
 {
 	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.addr(), setBuf.addr(), 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;
@@ -800,7 +805,7 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
 	if (!dir.IsOpened())
 		return CELL_SAVEDATA_ERROR_INTERNAL;
 
-	std::string dirNamePrefix = Memory.ReadString(setList->dirNamePrefix_addr);
+	std::string dirNamePrefix = setList->dirNamePrefix.get_ptr();
 	std::vector<SaveDataEntry> saveEntries;
 
 	for (const DirEntryInfo* entry = dir.Read(); entry; entry = dir.Read())
@@ -820,12 +825,13 @@ int cellSaveDataListAutoLoad(u32 version, u32 errDialog, vm::ptr<CellSaveDataSet
 
 	// Sort the entries and fill the listGet->dirList array
 	std::sort(saveEntries.begin(), saveEntries.end(), sortSaveDataEntry(setList->sortType, setList->sortOrder));
-	listGet->dirList = vm::bptr<CellSaveDataDirList>::make(setBuf->buf_addr);
+	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);
+		strcpy_trunc(dirList[i].dirName, saveEntries[i].dirName);
-		memcpy(dirList[i].listParam, saveEntries[i].listParam.c_str(), CELL_SAVEDATA_SYSP_LPARAM_SIZE);
+		strcpy_trunc(dirList[i].listParam, saveEntries[i].listParam);
+		*dirList[i].reserved = {};
 	}
 
 	throw fmt::Format("%s(): implementation broken", __FUNCTION__);

rpcs3/Emu/SysCalls/Modules/cellSaveData.h

@@ -93,7 +93,8 @@ struct CellSaveDataSetList
 { 
 	be_t<u32> sortType;
 	be_t<u32> sortOrder;
-	be_t<u32> dirNamePrefix_addr; // char*
+	vm::bptr<char> dirNamePrefix;
+	vm::bptr<void> reserved;
 };
 
 struct CellSaveDataSetBuf
@@ -102,27 +103,30 @@ struct CellSaveDataSetBuf
 	be_t<u32> fileListMax;
 	be_t<u32> reserved[6];
 	be_t<u32> bufSize;
-	be_t<u32> buf_addr; // void*
+	vm::bptr<void> buf;
 };
 
 struct CellSaveDataNewDataIcon 
 { 
-	be_t<u32> title_addr; // char*
+	vm::bptr<char> title;
 	be_t<u32> iconBufSize;
-	be_t<u32> iconBuf_addr; // void*
+	vm::bptr<void> iconBuf;
+	vm::bptr<void> reserved;
 };
 
 struct CellSaveDataListNewData 
 { 
 	be_t<u32> iconPosition;
-	be_t<u32> dirName_addr; // char*
+	vm::bptr<char> dirName;
 	vm::bptr<CellSaveDataNewDataIcon> icon;
+	vm::bptr<void> reserved;
 };
 
 struct CellSaveDataDirList
 { 
-	s8 dirName[CELL_SAVEDATA_DIRNAME_SIZE]; 
+	char dirName[CELL_SAVEDATA_DIRNAME_SIZE]; 
-	s8 listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE]; 
+	char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE];
+	char reserved[8];
 };
 
 struct CellSaveDataListGet
@@ -130,34 +134,35 @@ struct CellSaveDataListGet
 	be_t<u32> dirNum;
 	be_t<u32> dirListNum;
 	vm::bptr<CellSaveDataDirList> dirList;
+	char reserved[64];
 };
 
 struct CellSaveDataListSet
 { 
 	be_t<u32> focusPosition;
-	be_t<u32> focusDirName_addr; // char*
+	vm::bptr<char> focusDirName;
 	be_t<u32> fixedListNum;
 	vm::bptr<CellSaveDataDirList> fixedList;
 	vm::bptr<CellSaveDataListNewData> newData;
-	be_t<u32> reserved_addr;  // void*
+	vm::bptr<void> reserved;
 };
 
 struct CellSaveDataFixedSet
 { 
-	be_t<u32> dirName_addr; // char*
+	vm::bptr<char> dirName;
 	vm::bptr<CellSaveDataNewDataIcon> newIcon;
 	be_t<u32> option;
 };
 
 struct CellSaveDataSystemFileParam 
 { 
-	s8 title[CELL_SAVEDATA_SYSP_TITLE_SIZE]; 
+	char title[CELL_SAVEDATA_SYSP_TITLE_SIZE]; 
-	s8 subTitle[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE]; 
+	char subTitle[CELL_SAVEDATA_SYSP_SUBTITLE_SIZE]; 
-	s8 detail[CELL_SAVEDATA_SYSP_DETAIL_SIZE]; 
+	char detail[CELL_SAVEDATA_SYSP_DETAIL_SIZE]; 
 	be_t<u32> attribute; 
-	s8 reserved2[4]; 
+	char reserved2[4]; 
-	s8 listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE]; 
+	char listParam[CELL_SAVEDATA_SYSP_LPARAM_SIZE]; 
-	s8 reserved[256]; 
+	char reserved[256]; 
 };
 
 struct CellSaveDataDirStat
@@ -165,7 +170,7 @@ struct CellSaveDataDirStat
 	be_t<s64> st_atime_;
 	be_t<s64> st_mtime_;
 	be_t<s64> st_ctime_;
-	s8 dirName[CELL_SAVEDATA_DIRNAME_SIZE]; 
+	char dirName[CELL_SAVEDATA_DIRNAME_SIZE]; 
 };
 
 struct CellSaveDataFileStat
@@ -176,7 +181,7 @@ struct CellSaveDataFileStat
 	be_t<s64> st_atime_;
 	be_t<s64> st_mtime_;
 	be_t<s64> st_ctime_;
-	u8 fileName[CELL_SAVEDATA_FILENAME_SIZE]; 
+	char fileName[CELL_SAVEDATA_FILENAME_SIZE]; 
 	u8 reserved2[3];
 };
 
@@ -192,15 +197,17 @@ struct CellSaveDataStatGet
 	be_t<u32> fileNum;
 	be_t<u32> fileListNum;
 	vm::bptr<CellSaveDataFileStat> fileList;
+	char reserved[64];
 };
 
 struct CellSaveDataAutoIndicator
 { 
 	be_t<u32> dispPosition;
 	be_t<u32> dispMode;
-	be_t<u32> dispMsg_addr; // char*
+	vm::bptr<char> dispMsg;
 	be_t<u32> picBufSize;
-	be_t<u32> picBuf_addr; // void*
+	vm::bptr<void> picBuf;
+	vm::bptr<void> reserved;
 };
 
 struct CellSaveDataStatSet 
@@ -213,19 +220,20 @@ struct CellSaveDataStatSet
 struct CellSaveDataFileGet
 { 
 	be_t<u32> excSize;
+	char reserved[64];
 }; 
 
 struct CellSaveDataFileSet 
 { 
 	be_t<u32> fileOperation;
-	be_t<u32> reserved_addr; // void*
+	vm::bptr<void> reserved;
 	be_t<u32> fileType;
 	u8 secureFileId[CELL_SAVEDATA_SECUREFILEID_SIZE]; 
-	be_t<u32> fileName_addr; // char*
+	vm::bptr<char> fileName;
 	be_t<u32> fileOffset;
 	be_t<u32> fileSize;
 	be_t<u32> fileBufSize;
-	be_t<u32> fileBuf_addr; // void*
+	vm::bptr<void> fileBuf;
 };
 
 struct CellSaveDataCBResult 
@@ -233,16 +241,17 @@ struct CellSaveDataCBResult
 	be_t<s32> result;
 	be_t<u32> progressBarInc;
 	be_t<s32> errNeedSizeKB;
-	be_t<u32> invalidMsg_addr; // char*
+	vm::bptr<char> invalidMsg;
-	be_t<u32> userdata_addr;   // void*
+	vm::bptr<void> userdata;
 };
 
 struct CellSaveDataDoneGet
 { 
 	be_t<s32> excResult;
-	s8 dirName[CELL_SAVEDATA_DIRNAME_SIZE]; 
+	char dirName[CELL_SAVEDATA_DIRNAME_SIZE]; 
 	be_t<s32> sizeKB;
 	be_t<s32> hddFreeSizeKB;
+	char reserved[64];
 };
 
 
@@ -275,30 +284,30 @@ struct SaveDataEntry
 // Function declarations
 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);
+                          u32 container, vm::ptr<void> userdata);
 
 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);
+						  u32 container, vm::ptr<void> userdata);
 
 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);
+						  u32 container, vm::ptr<void> userdata);
 
 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);
+						  u32 container, vm::ptr<void> userdata);
 
-int cellSaveDataAutoSave2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoSave2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
-						  u32 container, u32 userdata_addr);
+						  u32 container, vm::ptr<void> userdata);
 
-int cellSaveDataAutoLoad2(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
+int cellSaveDataAutoLoad2(u32 version, vm::ptr<const char> dirName, u32 errDialog, vm::ptr<CellSaveDataSetBuf> setBuf,
 						  vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile,
-						  u32 container, u32 userdata_addr);
+						  u32 container, vm::ptr<void> userdata);
 
 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);
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata);
 
 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);
+							 vm::ptr<CellSaveDataStatCallback> funcStat, vm::ptr<CellSaveDataFileCallback> funcFile, u32 container, vm::ptr<void> userdata);

rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp

@@ -15,7 +15,7 @@
 #include "cellMsgDialog.h"
 #include "cellGame.h"
 #include "cellSysutil.h"
-#include "cellSysutil_SaveData.h"
+#include "cellSaveData.h"
 
 typedef void (*CellHddGameStatCallback)(vm::ptr<CellHddGameCBResult> cbResult, vm::ptr<CellHddGameStatGet> get, vm::ptr<CellHddGameStatSet> set);
 
@@ -652,13 +652,13 @@ int cellSysCacheMount(vm::ptr<CellSysCacheParam> param)
 	return CELL_SYSCACHE_RET_OK_RELAYED;
 }
 
-int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellHddGameStatCallback> funcStat, u32 container)
+int cellHddGameCheck(u32 version, vm::ptr<const char> dirName, 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)",
+	cellSysutil->Warning("cellHddGameCheck(version=%d, dirName_addr=0x%x, errDialog=%d, funcStat_addr=0x%x, container=%d)",
-		version, dirName_addr, errDialog, funcStat.addr(), container);
+		version, dirName.addr(), errDialog, funcStat.addr(), container);
 
-	std::string dirName = Memory.ReadString(dirName_addr);
+	std::string dir = dirName.get_ptr();
-	if (dirName.size() != 9)
+	if (dir.size() != 9)
 		return CELL_HDDGAME_ERROR_PARAM;
 
 	vm::var<CellHddGameSystemFileParam> param;
@@ -673,10 +673,10 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellH
 	get->st_ctime__  = 0; // TODO
 	get->st_mtime__  = 0; // TODO
 	get->sizeKB = CELL_HDDGAME_SIZEKB_NOTCALC;
-	memcpy(get->contentInfoPath, ("/dev_hdd0/game/"+dirName).c_str(), CELL_HDDGAME_PATH_MAX);
+	memcpy(get->contentInfoPath, ("/dev_hdd0/game/" + dir).c_str(), CELL_HDDGAME_PATH_MAX);
-	memcpy(get->hddGamePath, ("/dev_hdd0/game/"+dirName+"/USRDIR").c_str(), CELL_HDDGAME_PATH_MAX);
+	memcpy(get->hddGamePath, ("/dev_hdd0/game/" + dir + "/USRDIR").c_str(), CELL_HDDGAME_PATH_MAX);
 
-	if (!Emu.GetVFS().ExistsDir(("/dev_hdd0/game/"+dirName).c_str()))
+	if (!Emu.GetVFS().ExistsDir(("/dev_hdd0/game/" + dir).c_str()))
 	{
 		get->isNewData = CELL_HDDGAME_ISNEWDATA_NODIR;
 	}
@@ -684,7 +684,7 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellH
 	{
 		// TODO: Is cellHddGameCheck really responsible for writing the information in get->getParam ? (If not, delete this else)
 
-		vfsFile f(("/dev_hdd0/game/"+dirName+"/PARAM.SFO").c_str());
+		vfsFile f(("/dev_hdd0/game/" + dir + "/PARAM.SFO").c_str());
 		PSFLoader psf(f);
 		if (!psf.Load(false)) {
 			return CELL_HDDGAME_ERROR_BROKEN;
@@ -695,16 +695,16 @@ int cellHddGameCheck(u32 version, u32 dirName_addr, u32 errDialog, vm::ptr<CellH
 		get->getParam.resolution = psf.GetInteger("RESOLUTION");
 		get->getParam.soundFormat = psf.GetInteger("SOUND_FORMAT");
 		std::string title = psf.GetString("TITLE");
-		memcpy(get->getParam.title, title.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_TITLE_SIZE,title.length()+1));
+		strcpy_trunc(get->getParam.title, title);
 		std::string app_ver = psf.GetString("APP_VER");
-		memcpy(get->getParam.dataVersion, app_ver.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_VERSION_SIZE,app_ver.length()+1));
+		strcpy_trunc(get->getParam.dataVersion, app_ver);
-		memcpy(get->getParam.titleId, dirName.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_TITLEID_SIZE,dirName.length()+1));
+		strcpy_trunc(get->getParam.titleId, dir);
 
 		for (u32 i=0; i<CELL_HDDGAME_SYSP_LANGUAGE_NUM; i++) {
 			char key [16];
 			sprintf(key, "TITLE_%02d", i);
 			title = psf.GetString(key);
-			memcpy(get->getParam.titleLang[i], title.c_str(), std::min<size_t>(CELL_HDDGAME_SYSP_TITLE_SIZE, title.length() + 1));
+			strcpy_trunc(get->getParam.titleLang[i], title);
 		}
 	}
 

rpcs3/Emu/SysCalls/Modules/cellSysutil.h

@@ -171,11 +171,11 @@ enum
 
 struct CellHddGameSystemFileParam
 {
-	u8 title[CELL_HDDGAME_SYSP_TITLE_SIZE];
+	char title[CELL_HDDGAME_SYSP_TITLE_SIZE];
-	u8 titleLang[CELL_HDDGAME_SYSP_LANGUAGE_NUM][CELL_HDDGAME_SYSP_TITLE_SIZE];
+	char titleLang[CELL_HDDGAME_SYSP_LANGUAGE_NUM][CELL_HDDGAME_SYSP_TITLE_SIZE];
-	u8 titleId[CELL_HDDGAME_SYSP_TITLEID_SIZE];
+	char titleId[CELL_HDDGAME_SYSP_TITLEID_SIZE];
 	u8 reserved0[2];
-	u8 dataVersion[CELL_HDDGAME_SYSP_VERSION_SIZE];
+	char dataVersion[CELL_HDDGAME_SYSP_VERSION_SIZE];
 	u8 reserved1[2];
 	be_t<u32> attribute;
 	be_t<u32> parentalLevel;

rpcs3/Emu/SysCalls/Modules/sceNp.cpp

@@ -25,14 +25,11 @@ int sceNpTerm()
 	return CELL_OK;
 }
 
-int sceNpDrmIsAvailable(u32 k_licensee_addr, u32 drm_path_addr)
+int npDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
 {
-	sceNp->Warning("sceNpDrmIsAvailable(k_licensee_addr=0x%x, drm_path_addr=0x%x)", k_licensee_addr, drm_path_addr);
+	if (!Emu.GetVFS().ExistsFile(drm_path.get_ptr()))
-
-	std::string drm_path = Memory.ReadString(drm_path_addr);
-	if (!Emu.GetVFS().ExistsFile(drm_path))
 	{
-		sceNp->Warning("sceNpDrmIsAvailable(): '%s' not found", drm_path.c_str());
+		sceNp->Warning("npDrmIsAvailable(): '%s' not found", drm_path.get_ptr());
 		return CELL_ENOENT;
 	}
 
@@ -48,24 +45,24 @@ int sceNpDrmIsAvailable(u32 k_licensee_addr, u32 drm_path_addr)
 		}
 	}
 
-	sceNp->Warning("sceNpDrmIsAvailable: Found DRM license file at %s", drm_path.c_str());
+	sceNp->Warning("npDrmIsAvailable: Found DRM license file at %s", drm_path.get_ptr());
-	sceNp->Warning("sceNpDrmIsAvailable: Using k_licensee 0x%s", k_licensee_str.c_str());
+	sceNp->Warning("npDrmIsAvailable: Using k_licensee 0x%s", k_licensee_str.c_str());
 
 	// Set the necessary file paths.
-	std::string drm_file_name = fmt::AfterLast(drm_path,'/');
+	std::string drm_file_name = fmt::AfterLast(drm_path.get_ptr(), '/');
 
 	// TODO: Make more explicit what this actually does (currently it copies "XXXXXXXX" from drm_path (== "/dev_hdd0/game/XXXXXXXXX/*" assumed)
-	std::string titleID = drm_path.substr(15, 9);
+	std::string titleID(&drm_path[15], 9);
 
 	// TODO: These shouldn't use current dir
-	std::string enc_drm_path = drm_path;
+	std::string enc_drm_path = drm_path.get_ptr();
 	std::string dec_drm_path = "/dev_hdd1/" + titleID + "/" + drm_file_name;
 	std::string rap_path = "/dev_usb000/";
 
 	// Search dev_usb000 for a compatible RAP file. 
 	vfsDir *raps_dir = new vfsDir(rap_path);
 	if (!raps_dir->IsOpened())
-		sceNp->Warning("sceNpDrmIsAvailable: Can't find RAP file for DRM!");
+		sceNp->Warning("npDrmIsAvailable: Can't find RAP file for DRM!");
 	else
 	{
 		const std::vector<DirEntryInfo> &entries = raps_dir->GetEntries();
@@ -95,74 +92,18 @@ int sceNpDrmIsAvailable(u32 k_licensee_addr, u32 drm_path_addr)
 	return CELL_OK;
 }
 
-int sceNpDrmIsAvailable2(u32 k_licensee_addr, u32 drm_path_addr)
+int sceNpDrmIsAvailable(u32 k_licensee_addr, vm::ptr<const char> drm_path)
 {
-	sceNp->Warning("sceNpDrmIsAvailable2(k_licensee_addr=0x%x, drm_path_addr=0x%x)", k_licensee_addr, drm_path_addr);
+	sceNp->Warning("sceNpDrmIsAvailable(k_licensee_addr=0x%x, drm_path_addr=0x%x('%s'))", k_licensee_addr, drm_path.addr(), drm_path.get_ptr());
 
-	std::string drm_path = Memory.ReadString(drm_path_addr);
+	return npDrmIsAvailable(k_licensee_addr, drm_path);
-	if (!Emu.GetVFS().ExistsFile(drm_path))
-	{
-		sceNp->Warning("sceNpDrmIsAvailable2(): '%s' not found", drm_path.c_str());
-		return CELL_ENOENT;
 }
 
-	std::string k_licensee_str = "0";
+int sceNpDrmIsAvailable2(u32 k_licensee_addr, vm::ptr<const char> drm_path)
-	u8 k_licensee[0x10];
-
-	if (k_licensee_addr)
 {
-		for (int i = 0; i < 0x10; i++)
+	sceNp->Warning("sceNpDrmIsAvailable2(k_licensee_addr=0x%x, drm_path_addr=0x%x('%s'))", k_licensee_addr, drm_path.addr(), drm_path.get_ptr());
-		{
-			k_licensee[i] = Memory.Read8(k_licensee_addr + i);
-			k_licensee_str += fmt::Format("%02x", k_licensee[i]);
-		}
-	}
 
-	sceNp->Warning("sceNpDrmIsAvailable2: Found DRM license file at %s", drm_path.c_str());
+	return npDrmIsAvailable(k_licensee_addr, drm_path);
-	sceNp->Warning("sceNpDrmIsAvailable2: Using k_licensee 0x%s", k_licensee_str.c_str());
-
-	// Set the necessary file paths.
-	std::string drm_file_name = fmt::AfterLast(drm_path, '/');
-
-	// TODO: Make more explicit what this actually does (currently it copies "XXXXXXXX" from drm_path (== "/dev_hdd0/game/XXXXXXXXX/*" assumed)
-	std::string titleID = drm_path.substr(15, 9);
-
-	// TODO: These shouldn't use current dir
-	std::string enc_drm_path = drm_path;
-	std::string dec_drm_path = "/dev_hdd1/" + titleID + "/" + drm_file_name;
-	std::string rap_path = "/dev_usb000/";
-
-	// Search dev_usb000 for a compatible RAP file. 
-	vfsDir *raps_dir = new vfsDir(rap_path);
-	if (!raps_dir->IsOpened())
-		sceNp->Warning("sceNpDrmIsAvailable2: Can't find RAP file for DRM!");
-	else
-	{
-		const std::vector<DirEntryInfo> &entries = raps_dir->GetEntries();
-		for (auto &entry : entries)
-		{
-			if (entry.name.find(titleID) != std::string::npos)
-			{
-				rap_path += entry.name;
-				break;
-			}
-		}
-	}
-
-	// Create a new directory under dev_hdd1/titleID to hold the decrypted data.
-	// TODO: These shouldn't use current dir
-	std::string tmp_dir = "./dev_hdd1/" + titleID;
-	if (!rExists(tmp_dir))
-		rMkdir("./dev_hdd1/" + titleID);
-
-	// Decrypt this EDAT using the supplied k_licensee and matching RAP file.
-	std::string enc_drm_path_local, dec_drm_path_local, rap_path_local;
-	Emu.GetVFS().GetDevice(enc_drm_path, enc_drm_path_local);
-	Emu.GetVFS().GetDevice(dec_drm_path, dec_drm_path_local);
-	Emu.GetVFS().GetDevice(rap_path, rap_path_local);
-
-	DecryptEDAT(enc_drm_path_local, dec_drm_path_local, 8, rap_path_local, k_licensee, false);
-	return CELL_OK;
 }
 
 int sceNpDrmVerifyUpgradeLicense(u32 content_id_addr)

rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp

@@ -117,16 +117,15 @@ int sys_spu_image_close(vm::ptr<sys_spu_image> img)
 	return CELL_OK;
 }
 
-int sys_raw_spu_load(int id, u32 path_addr, vm::ptr<be_t<u32>> entry)
+int sys_raw_spu_load(s32 id, vm::ptr<const char> path, vm::ptr<be_t<u32>> entry)
 {
-	const std::string path = Memory.ReadString(path_addr);
+	sysPrxForUser->Warning("sys_raw_spu_load(id=0x%x, path_addr=0x%x('%s'), entry_addr=0x%x)", 
-	sysPrxForUser->Warning("sys_raw_spu_load(id=0x%x, path=0x%x [%s], entry_addr=0x%x)", 
+		id, path.addr(), path.get_ptr(), entry.addr());
-		id, path_addr, path.c_str(), entry.addr());
 
-	vfsFile f(path);
+	vfsFile f(path.get_ptr());
 	if(!f.IsOpened())
 	{
-		sysPrxForUser->Error("sys_raw_spu_load error: '%s' not found!", path.c_str());
+		sysPrxForUser->Error("sys_raw_spu_load error: '%s' not found!", path.get_ptr());
 		return CELL_ENOENT;
 	}
 

rpcs3/Emu/SysCalls/Modules/sys_fs.cpp

@@ -110,11 +110,10 @@ int sdata_unpack(const std::string& packed_file, const std::string& unpacked_fil
 }
 	
 
-int cellFsSdataOpen(u32 path_addr, int flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
+int cellFsSdataOpen(vm::ptr<const char> path, 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.addr(), arg.addr(), size);
+		path.get_ptr(), flags, fd.addr(), arg.addr(), size);
 
 	/*if (flags != CELL_O_RDONLY)
 		return CELL_EINVAL;
@@ -133,7 +132,7 @@ int cellFsSdataOpen(u32 path_addr, int flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_
 
 	return CELL_OK;*/
 
-	return cellFsOpen(path_addr, flags, fd, arg, size);
+	return cellFsOpen(path, flags, fd, arg, 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)

rpcs3/Emu/SysCalls/lv2/lv2Fs.cpp

@@ -30,20 +30,18 @@ struct FsRingBufferConfig
 } fs_config;
 
 
-s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size)
+s32 cellFsOpen(vm::ptr<const char> path, 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.addr(), arg.addr(), size);
+		path.get_ptr(), flags, fd.addr(), arg.addr(), size);
 
-	const std::string& ppath = path;
+	const std::string _path = path.get_ptr();
-	//ConLog.Warning("path: %s [%s]", ppath.c_str(), path.c_str());
 
 	s32 _oflags = flags;
 	if(flags & CELL_O_CREAT)
 	{
 		_oflags &= ~CELL_O_CREAT;
-		Emu.GetVFS().CreateFile(ppath);
+		Emu.GetVFS().CreateFile(_path);
 	}
 
 	vfsOpenMode o_mode;
@@ -81,7 +79,7 @@ s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32
 		{
 			_oflags &= ~CELL_O_TRUNC;
 			//truncate file before opening it as read/write
-			auto filePtr = Emu.GetVFS().OpenFile(ppath, vfsWrite);
+			auto filePtr = Emu.GetVFS().OpenFile(_path, vfsWrite);
 			delete filePtr;
 		}
 		o_mode = vfsReadWrite;
@@ -90,28 +88,28 @@ s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32
 
 	if(_oflags != 0)
 	{
-		sys_fs->Error("\"%s\" has unknown flags! flags: 0x%08x", ppath.c_str(), flags);
+		sys_fs->Error("\"%s\" has unknown flags! flags: 0x%08x", path.get_ptr(), flags);
 		return CELL_EINVAL;
 	}
 
-	if (!Emu.GetVFS().ExistsFile(ppath))
+	if (!Emu.GetVFS().ExistsFile(_path))
 	{
-		sys_fs->Error("\"%s\" not found! flags: 0x%08x", ppath.c_str(), flags);
+		sys_fs->Error("\"%s\" not found! flags: 0x%08x", path.get_ptr(), flags);
 		return CELL_ENOENT;
 	}
 
-	vfsFileBase* stream = Emu.GetVFS().OpenFile(ppath, o_mode);
+	vfsFileBase* stream = Emu.GetVFS().OpenFile(_path, o_mode);
 
 	if(!stream || !stream->IsOpened())
 	{
 		delete stream;
-		sys_fs->Error("\"%s\" not found! flags: 0x%08x", ppath.c_str(), flags);
+		sys_fs->Error("\"%s\" not found! flags: 0x%08x", path.get_ptr(), flags);
 		return CELL_ENOENT;
 	}
 
 	u32 id = sys_fs->GetNewId(stream, TYPE_FS_FILE);
 	*fd = id;
-	sys_fs->Notice("\"%s\" opened: fd = %d", path.c_str(), id);
+	sys_fs->Notice("\"%s\" opened: fd = %d", path.get_ptr(), id);
 
 	return CELL_OK;
 }
@@ -162,12 +160,11 @@ s32 cellFsClose(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsOpendir(u32 path_addr, vm::ptr<be_t<u32>> fd)
+s32 cellFsOpendir(vm::ptr<const char> path, 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.get_ptr(), fd.addr());
-	sys_fs->Warning("cellFsOpendir(path=\"%s\", fd_addr=0x%x)", path.c_str(), fd.addr());
 	
-	vfsDirBase* dir = Emu.GetVFS().OpenDir(path);
+	vfsDirBase* dir = Emu.GetVFS().OpenDir(path.get_ptr());
 	if(!dir || !dir->IsOpened())
 	{
 		delete dir;
@@ -212,10 +209,11 @@ s32 cellFsClosedir(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
+s32 cellFsStat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb)
 {
-	const std::string& path = Memory.ReadString(path_addr);
+	sys_fs->Warning("cellFsStat(path=\"%s\", sb_addr: 0x%x)", path.get_ptr(), sb.addr());
-	sys_fs->Warning("cellFsStat(path=\"%s\", sb_addr: 0x%x)", path.c_str(), sb.addr());
+
+	const std::string _path = path.get_ptr();
 
 	sb->st_mode = 
 		CELL_FS_S_IRUSR | CELL_FS_S_IWUSR | CELL_FS_S_IXUSR |
@@ -230,7 +228,7 @@ s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
 	sb->st_blksize = 4096;
 
 	{
-		vfsDir dir(path);
+		vfsDir dir(_path);
 		if(dir.IsOpened())
 		{
 			sb->st_mode |= CELL_FS_S_IFDIR;
@@ -239,7 +237,7 @@ s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
 	}
 
 	{
-		vfsFile f(path);
+		vfsFile f(_path);
 		if(f.IsOpened())
 		{
 			sb->st_mode |= CELL_FS_S_IFREG;
@@ -248,7 +246,7 @@ s32 cellFsStat(const u32 path_addr, vm::ptr<CellFsStat> sb)
 		}
 	}
 
-	sys_fs->Warning("cellFsStat: \"%s\" not found.", path.c_str());
+	sys_fs->Warning("cellFsStat: \"%s\" not found.", path.get_ptr());
 	return CELL_ENOENT;
 }
 
@@ -279,36 +277,32 @@ s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb)
 	return CELL_OK;
 }
 
-s32 cellFsMkdir(u32 path_addr, u32 mode)
+s32 cellFsMkdir(vm::ptr<const char> path, u32 mode)
 {
-	const std::string& ps3_path = Memory.ReadString(path_addr);
+	sys_fs->Log("cellFsMkdir(path=\"%s\", mode=0x%x)", path.get_ptr(), mode);
-	sys_fs->Log("cellFsMkdir(path=\"%s\", mode=0x%x)", ps3_path.c_str(), mode);
 
-	/*vfsDir dir;
+	const std::string _path = path.get_ptr();
-	if(dir.IsExists(ps3_path))
-		return CELL_EEXIST;
-	if(!dir.Create(ps3_path))
-		return CELL_EBUSY;*/
 
-	if(Emu.GetVFS().ExistsDir(ps3_path))
+	if(Emu.GetVFS().ExistsDir(_path))
 		return CELL_EEXIST;
-	if(!Emu.GetVFS().CreateDir(ps3_path))
+	if(!Emu.GetVFS().CreateDir(_path))
 		return CELL_EBUSY;
 
 	return CELL_OK;
 }
 
-s32 cellFsRename(u32 from_addr, u32 to_addr)
+s32 cellFsRename(vm::ptr<const char> from, vm::ptr<const char> to)
 {
-	const std::string& ps3_from = Memory.ReadString(from_addr);
+	sys_fs->Log("cellFsRename(from='%s' (from_addr=0x%x), to='%s' (to_addr=0x%x))", from.get_ptr(), from.addr(), to.get_ptr(), to.addr());
-	const std::string& ps3_to = Memory.ReadString(to_addr);
+
-	sys_fs->Log("cellFsRename(from='%s' (from_addr=0x%x), to='%s' (to_addr=0x%x))", ps3_from.c_str(), from_addr, ps3_to.c_str(), to_addr);
+	std::string _from = from.get_ptr();
+	std::string _to = to.get_ptr();
 
 	{
 		vfsDir dir;
-		if(dir.IsExists(ps3_from))
+		if(dir.IsExists(_from))
 		{
-			if(!dir.Rename(ps3_from, ps3_to))
+			if(!dir.Rename(_from, _to))
 				return CELL_EBUSY;
 
 			return CELL_OK;
@@ -317,9 +311,10 @@ s32 cellFsRename(u32 from_addr, u32 to_addr)
 
 	{
 		vfsFile f;
-		if(f.Exists(ps3_from))
+
+		if(f.Exists(_from))
 		{
-			if(!f.Rename(ps3_from, ps3_to))
+			if(!f.Rename(_from, _to))
 				return CELL_EBUSY;
 
 			return CELL_OK;
@@ -328,10 +323,9 @@ s32 cellFsRename(u32 from_addr, u32 to_addr)
 
 	return CELL_ENOENT;
 }
-s32 cellFsChmod(u32 path_addr, u32 mode)
+s32 cellFsChmod(vm::ptr<const char> path, u32 mode)
 {
-	const std::string& ps3_path = Memory.ReadString(path_addr);
+	sys_fs->Todo("cellFsChmod(path=\"%s\", mode=0x%x)", path.get_ptr(), mode);
-	sys_fs->Todo("cellFsChmod(path=\"%s\", mode=0x%x)", ps3_path.c_str(), mode);
 
 	// TODO:
 
@@ -347,33 +341,35 @@ s32 cellFsFsync(u32 fd)
 	return CELL_OK;
 }
 
-s32 cellFsRmdir(u32 path_addr)
+s32 cellFsRmdir(vm::ptr<const char> path)
 {
-	const std::string& ps3_path = Memory.ReadString(path_addr);
+	sys_fs->Log("cellFsRmdir(path=\"%s\")", path.get_ptr());
-	sys_fs->Log("cellFsRmdir(path=\"%s\")", ps3_path.c_str());
+
+	std::string _path = path.get_ptr();
 
 	vfsDir d;
-	if(!d.IsExists(ps3_path))
+	if(!d.IsExists(_path))
 		return CELL_ENOENT;
 
-	if(!d.Remove(ps3_path))
+	if(!d.Remove(_path))
 		return CELL_EBUSY;
 
 	return CELL_OK;
 }
 
-s32 cellFsUnlink(u32 path_addr)
+s32 cellFsUnlink(vm::ptr<const char> path)
 {
-	const std::string& ps3_path = Memory.ReadString(path_addr);
+	sys_fs->Warning("cellFsUnlink(path=\"%s\")", path.get_ptr());
-	sys_fs->Warning("cellFsUnlink(path=\"%s\")", ps3_path.c_str());
 
-	if (Emu.GetVFS().ExistsDir(ps3_path))
+	std::string _path = path.get_ptr();
+
+	if (Emu.GetVFS().ExistsDir(_path))
 		return CELL_EISDIR;
 
-	if (!Emu.GetVFS().ExistsFile(ps3_path))
+	if (!Emu.GetVFS().ExistsFile(_path))
 		return CELL_ENOENT;
 
-	if (!Emu.GetVFS().RemoveFile(ps3_path))
+	if (!Emu.GetVFS().RemoveFile(_path))
 		return CELL_EACCES;
 	
 	return CELL_OK;
@@ -431,15 +427,14 @@ s32 cellFsFtruncate(u32 fd, u64 size)
 	return CELL_OK;
 }
 
-s32 cellFsTruncate(u32 path_addr, u64 size)
+s32 cellFsTruncate(vm::ptr<const char> path, u64 size)
 {
-	const std::string& path = Memory.ReadString(path_addr);
+	sys_fs->Log("cellFsTruncate(path=\"%s\", size=%lld)", path.get_ptr(), size);
-	sys_fs->Log("cellFsTruncate(path=\"%s\", size=%lld)", path.c_str(), size);
 
-	vfsFile f(path, vfsReadWrite);
+	vfsFile f(path.get_ptr(), vfsReadWrite);
 	if(!f.IsOpened())
 	{
-		sys_fs->Warning("cellFsTruncate: \"%s\" not found.", path.c_str());
+		sys_fs->Warning("cellFsTruncate: \"%s\" not found.", path.get_ptr());
 		return CELL_ENOENT;
 	}
 	u64 initialSize = f.GetSize();
@@ -464,7 +459,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)
 {
-	sys_fs->Log("cellFsFGetBlockSize(fd=%d, sector_size_addr: 0x%x, block_size_addr: 0x%x)",
+	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;
@@ -476,10 +471,10 @@ s32 cellFsFGetBlockSize(u32 fd, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64
 	return CELL_OK;
 }
 
-s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be_t<u64>> block_size)
+s32 cellFsGetBlockSize(vm::ptr<const char> path, 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)",
+	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());
+		path.get_ptr(), sector_size.addr(), block_size.addr());
 
 	*sector_size = 4096; // ?
 	*block_size = 4096; // ?
@@ -487,14 +482,10 @@ s32 cellFsGetBlockSize(u32 path_addr, vm::ptr<be_t<u64>> sector_size, vm::ptr<be
 	return CELL_OK;
 }
 
-s32 cellFsGetFreeSize(u32 path_addr, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count)
+s32 cellFsGetFreeSize(vm::ptr<const char> path, 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.addr(), block_count.addr());
+		path.get_ptr(), 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; // ?

rpcs3/Emu/SysCalls/lv2/lv2Fs.h

@@ -124,27 +124,27 @@ struct CellFsRingBuffer
 };
 
 // SysCalls
-s32 cellFsOpen(u32 path_addr, s32 flags, vm::ptr<be_t<u32>> fd, vm::ptr<be_t<u32>> arg, u64 size);
+s32 cellFsOpen(vm::ptr<const char> path, 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, vm::ptr<be_t<u32>> fd);
+s32 cellFsOpendir(vm::ptr<const char> path, vm::ptr<be_t<u32>> fd);
 s32 cellFsReaddir(u32 fd, vm::ptr<CellFsDirent> dir, vm::ptr<be_t<u64>> nread);
 s32 cellFsClosedir(u32 fd);
-s32 cellFsStat(u32 path_addr, vm::ptr<CellFsStat> sb);
+s32 cellFsStat(vm::ptr<const char> path, vm::ptr<CellFsStat> sb);
 s32 cellFsFstat(u32 fd, vm::ptr<CellFsStat> sb);
-s32 cellFsMkdir(u32 path_addr, u32 mode);
+s32 cellFsMkdir(vm::ptr<const char> path, u32 mode);
-s32 cellFsRename(u32 from_addr, u32 to_addr);
+s32 cellFsRename(vm::ptr<const char> from, vm::ptr<const char> to);
-s32 cellFsChmod(u32 path_addr, u32 mode);
+s32 cellFsChmod(vm::ptr<const char> path, u32 mode);
 s32 cellFsFsync(u32 fd);
-s32 cellFsRmdir(u32 path_addr);
+s32 cellFsRmdir(vm::ptr<const char> path);
-s32 cellFsUnlink(u32 path_addr);
+s32 cellFsUnlink(vm::ptr<const char> path);
 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 cellFsTruncate(vm::ptr<const char> path, 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 cellFsGetBlockSize(vm::ptr<const char> path, 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 cellFsGetFreeSize(vm::ptr<const char> path, vm::ptr<be_t<u32>> block_size, vm::ptr<be_t<u64>> block_count);
 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);

rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.cpp

@@ -150,13 +150,10 @@ s32 sys_ppu_thread_restart(u64 thread_id)
 	return CELL_OK;
 }
 
-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)
+s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32 prio, u32 stacksize, u64 flags, vm::ptr<const char> threadname)
 {
-	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.addr(), entry, arg, prio, stacksize, flags, threadname_addr, threadname.c_str());
+		thread_id.addr(), entry, arg, prio, stacksize, flags, threadname.addr(), threadname.get_ptr());
 
 	bool is_joinable = false;
 	bool is_interrupt = false;
@@ -187,7 +184,7 @@ s32 sys_ppu_thread_create(vm::ptr<be_t<u64>> thread_id, u32 entry, u64 arg, s32
 	//new_thread.flags = flags;
 	new_thread.m_has_interrupt = false;
 	new_thread.m_is_interrupt = is_interrupt;
-	new_thread.SetName(threadname);
+	new_thread.SetName(threadname.get_ptr());
 
 	sys_ppu_thread.Notice("*** New PPU Thread [%s] (flags=0x%llx, entry=0x%x): id = %d", new_thread.GetName().c_str(), flags, entry, new_thread.GetId());
 
@@ -219,15 +216,15 @@ s32 sys_ppu_thread_get_id(vm::ptr<be_t<u64>> thread_id)
 	return CELL_OK;
 }
 
-s32 sys_ppu_thread_rename(u64 thread_id, u32 name_addr)
+s32 sys_ppu_thread_rename(u64 thread_id, vm::ptr<const char> name)
 {
-	sys_ppu_thread.Log("sys_ppu_thread_rename(thread_id=%d, name_addr=0x%x)", thread_id, name_addr);
+	sys_ppu_thread.Log("sys_ppu_thread_rename(thread_id=%d, name_addr=0x%x('%s'))", thread_id, name.addr(), name.get_ptr());
 
 	CPUThread* thr = Emu.GetCPU().GetThread(thread_id);
 	if (!thr) {
 		return CELL_ESRCH;
 	}
 
-	thr->SetThreadName(Memory.ReadString(name_addr));
+	thr->SetThreadName(name.get_ptr());
 	return CELL_OK;
 }

rpcs3/Emu/SysCalls/lv2/sys_ppu_thread.h

@@ -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(vm::ptr<be_t<u64>> 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, vm::ptr<const char> threadname);
 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);
+s32 sys_ppu_thread_rename(u64 thread_id, vm::ptr<const char> name);

rpcs3/Emu/SysCalls/lv2/sys_process.cpp

@@ -38,7 +38,7 @@ s32 sys_process_exit(s32 errorcode)
 }
 
 void sys_game_process_exitspawn(
-			u32 path_addr,
+			vm::ptr<const char> path,
 			u32 argv_addr,
 			u32 envp_addr,
 			u32 data_addr,
@@ -47,7 +47,7 @@ void sys_game_process_exitspawn(
 			u64 flags )
 {
 	sys_process.Todo("sys_game_process_exitspawn()");
-	sys_process.Warning("path: %s", Memory.ReadString(path_addr).c_str());
+	sys_process.Warning("path: %s", path.get_ptr());
 	sys_process.Warning("argv: 0x%x", argv_addr);
 	sys_process.Warning("envp: 0x%x", envp_addr);
 	sys_process.Warning("data: 0x%x", data_addr);
@@ -55,20 +55,20 @@ void sys_game_process_exitspawn(
 	sys_process.Warning("prio: %d", prio);
 	sys_process.Warning("flags: %d", flags);
 
-	std::string path = Memory.ReadString(path_addr);
+	std::string _path = path.get_ptr();
 	std::vector<std::string> argv;
 	std::vector<std::string> env;
 
-	auto argvp = vm::ptr<u32>::make(argv_addr);
+	auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
 	while (argvp && *argvp)
 	{
-		argv.push_back(Memory.ReadString(Memory.Read32(argvp.addr())));
+		argv.push_back(argvp[0].get_ptr());
 		argvp++;
 	}
-	auto envp = vm::ptr<u32>::make(envp_addr);
+	auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
 	while (envp && *envp)
 	{
-		env.push_back(Memory.ReadString(Memory.Read32(envp.addr())));
+		env.push_back(envp[0].get_ptr());
 		envp++;
 	}
 
@@ -86,7 +86,7 @@ void sys_game_process_exitspawn(
 }
 
 void sys_game_process_exitspawn2(
-			u32 path_addr,
+			vm::ptr<const char> path,
 			u32 argv_addr,
 			u32 envp_addr,
 			u32 data_addr,
@@ -95,7 +95,7 @@ void sys_game_process_exitspawn2(
 			u64 flags)
 {
 	sys_process.Todo("sys_game_process_exitspawn2");
-	sys_process.Warning("path: %s", Memory.ReadString(path_addr).c_str());
+	sys_process.Warning("path: %s", path.get_ptr());
 	sys_process.Warning("argv: 0x%x", argv_addr);
 	sys_process.Warning("envp: 0x%x", envp_addr);
 	sys_process.Warning("data: 0x%x", data_addr);
@@ -103,20 +103,20 @@ void sys_game_process_exitspawn2(
 	sys_process.Warning("prio: %d", prio);
 	sys_process.Warning("flags: %d", flags);
 
-	std::string path = Memory.ReadString(path_addr);
+	std::string _path = path.get_ptr();
 	std::vector<std::string> argv;
 	std::vector<std::string> env;
 
-	auto argvp = vm::ptr<u32>::make(argv_addr);
+	auto argvp = vm::ptr<vm::bptr<const char>>::make(argv_addr);
 	while (argvp && *argvp)
 	{
-		argv.push_back(Memory.ReadString(Memory.Read32(argvp.addr())));
+		argv.push_back(argvp[0].get_ptr());
 		argvp++;
 	}
-	auto envp = vm::ptr<u32>::make(envp_addr);
+	auto envp = vm::ptr<vm::bptr<const char>>::make(envp_addr);
 	while (envp && *envp)
 	{
-		env.push_back(Memory.ReadString(Memory.Read32(envp.addr())));
+		env.push_back(envp[0].get_ptr());
 		envp++;
 	}
 

rpcs3/Emu/SysCalls/lv2/sys_process.h

@@ -40,7 +40,7 @@ s32 sys_process_kill(u32 pid);
 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,
+void sys_game_process_exitspawn(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr,
 								u32 data_addr, u32 data_size, u32 prio, u64 flags);
-void sys_game_process_exitspawn2(u32 path_addr, u32 argv_addr, u32 envp_addr,
+void sys_game_process_exitspawn2(vm::ptr<const char> path, u32 argv_addr, u32 envp_addr,
 								u32 data_addr, u32 data_size, u32 prio, u64 flags);

rpcs3/Emu/SysCalls/lv2/sys_prx.cpp

@@ -10,22 +10,22 @@
 
 SysCallBase sys_prx("sys_prx");
 
-s32 sys_prx_load_module(u32 path_addr, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt)
+s32 sys_prx_load_module(vm::ptr<const char> path, 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.get_ptr(), flags, pOpt.addr());
-	sys_prx.Todo("sys_prx_load_module(path=\"%s\", flags=0x%llx, pOpt=0x%x)", path.c_str(), flags, pOpt.addr());
 
+	std::string _path = path.get_ptr();
 	// Check if the file is SPRX
 	std::string local_path;
-	Emu.GetVFS().GetDevice(path, local_path);
+	Emu.GetVFS().GetDevice(_path, local_path);
 	if (IsSelf(local_path)) {
 		if (!DecryptSelf(local_path+".prx", local_path)) {
 			return CELL_PRX_ERROR_ILLEGAL_LIBRARY;
 		}
-		path += ".prx";
+		_path += ".prx";
 	}
 
-	vfsFile f(path);
+	vfsFile f(_path);
 	if (!f.IsOpened()) {
 		return CELL_PRX_ERROR_UNKNOWN_MODULE;
 	}

rpcs3/Emu/SysCalls/lv2/sys_prx.h

@@ -65,7 +65,7 @@ struct sys_prx_t
 };
 
 // SysCalls
-s32 sys_prx_load_module(u32 path_addr, u64 flags, vm::ptr<sys_prx_load_module_option_t> pOpt);
+s32 sys_prx_load_module(vm::ptr<const char> path, 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();

rpcs3/Emu/SysCalls/lv2/sys_spu.cpp

@@ -23,15 +23,14 @@ u32 LoadSpuImage(vfsStream& stream, u32& spu_ep)
 }
 
 //156
-s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, u32 path_addr)
+s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::ptr<const char> path)
 {
-	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.addr(), path.addr(), path.get_ptr());
-	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);
+	vfsFile f(path.get_ptr());
 	if(!f.IsOpened())
 	{
-		sys_spu.Error("sys_spu_image_open error: '%s' not found!", path.c_str());
+		sys_spu.Error("sys_spu_image_open error: '%s' not found!", path.get_ptr());
 		return CELL_ENOENT;
 	}
 

rpcs3/Emu/SysCalls/lv2/sys_spu.h

@@ -109,7 +109,7 @@ struct SpuGroupInfo
 
 // SysCalls
 s32 sys_spu_initialize(u32 max_usable_spu, u32 max_raw_spu);
-s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, u32 path_addr);
+s32 sys_spu_image_open(vm::ptr<sys_spu_image> img, vm::ptr<const char> path);
 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);

rpcs3/Loader/ELF64.cpp

@@ -420,7 +420,7 @@ bool ELF64Loader::LoadPhdrData(u64 offset)
 				{
 					Elf64_StubHeader stub = *(Elf64_StubHeader*)Memory.GetMemFromAddr(offset + s);
 
-					const std::string& module_name = Memory.ReadString(stub.s_modulename);
+					const std::string module_name = vm::get_ptr<const char>(stub.s_modulename);
 					Module* module = Emu.GetModuleManager().GetModuleByName(module_name);
 					if (module) {
 						//module->SetLoaded();

rpcs3/emucore.vcxproj

@@ -177,7 +177,7 @@
     <ClCompile Include="Emu\SysCalls\Modules\cellSysmodule.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellSysutil.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellSysutilAp.cpp" />
-    <ClCompile Include="Emu\SysCalls\Modules\cellSysutil_SaveData.cpp" />
+    <ClCompile Include="Emu\SysCalls\Modules\cellSaveData.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellUsbd.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellUsbpspcm.cpp" />
     <ClCompile Include="Emu\SysCalls\Modules\cellUserInfo.cpp" />
@@ -385,7 +385,7 @@
     <ClInclude Include="Emu\SysCalls\Modules\cellSync.h" />
     <ClInclude Include="Emu\SysCalls\Modules\cellSync2.h" />
     <ClInclude Include="Emu\SysCalls\Modules\cellSysutil.h" />
-    <ClInclude Include="Emu\SysCalls\Modules\cellSysutil_SaveData.h" />
+    <ClInclude Include="Emu\SysCalls\Modules\cellSaveData.h" />
     <ClInclude Include="Emu\SysCalls\Modules\cellUserInfo.h" />
     <ClInclude Include="Emu\SysCalls\Modules\cellVdec.h" />
     <ClInclude Include="Emu\SysCalls\Modules\cellVpost.h" />

rpcs3/emucore.vcxproj.filters

@@ -188,9 +188,6 @@
     <ClCompile Include="Emu\SysCalls\Modules\cellSysutilAp.cpp">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClCompile>
-    <ClCompile Include="Emu\SysCalls\Modules\cellSysutil_SaveData.cpp">
-      <Filter>Emu\SysCalls\Modules</Filter>
-    </ClCompile>
     <ClCompile Include="Emu\SysCalls\Modules\cellUserInfo.cpp">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClCompile>
@@ -623,6 +620,9 @@
     <ClCompile Include="Emu\SysCalls\Modules\cellPad.cpp">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClCompile>
+    <ClCompile Include="Emu\SysCalls\Modules\cellSaveData.cpp">
+      <Filter>Emu\SysCalls\Modules</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Crypto\aes.h">
@@ -715,9 +715,6 @@
     <ClInclude Include="Emu\SysCalls\Modules\cellSysutil.h">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClInclude>
-    <ClInclude Include="Emu\SysCalls\Modules\cellSysutil_SaveData.h">
-      <Filter>Emu\SysCalls\Modules</Filter>
-    </ClInclude>
     <ClInclude Include="Emu\SysCalls\Modules\cellUserInfo.h">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClInclude>
@@ -1204,5 +1201,8 @@
     <ClInclude Include="Emu\SysCalls\Modules\cellMouse.h">
       <Filter>Emu\SysCalls\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\SysCalls\Modules\cellSaveData.h">
+      <Filter>Emu\SysCalls\Modules</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>