PSV modules refactoring

Utilities/StrFmt.h

@@ -257,12 +257,8 @@ namespace fmt
 	be_t<> forced to .value() (fmt::unveil reverts byte order automatically)
 
 	External specializations for fmt::unveil (can be found in another headers):
-	vm::ps3::ptr (fmt::unveil) (vm_ptr.h) (with appropriate address type, using .addr() can be avoided)
+	vm::ptr, vm::bptr, ... (fmt::unveil) (vm_ptr.h) (with appropriate address type, using .addr() can be avoided)
-	vm::ps3::bptr (fmt::unveil) (vm_ptr.h)
+	vm::ref, vm::bref, ... (fmt::unveil) (vm_ref.h)
-	vm::psv::ptr (fmt::unveil) (vm_ptr.h)
-	vm::ps3::ref (fmt::unveil) (vm_ref.h)
-	vm::ps3::bref (fmt::unveil) (vm_ref.h)
-	vm::psv::ref (fmt::unveil) (vm_ref.h)
 	
 	*/
 	template<typename... Args> force_inline safe_buffers std::string format(const char* fmt, Args... args)

Utilities/Thread.cpp

@@ -1373,7 +1373,7 @@ void thread_t::set_name(const std::string& name)
 
 thread_t::~thread_t()
 {
-	if (m_state.exchange(TS_NON_EXISTENT) == TS_JOINABLE)
+	if (m_state == TS_JOINABLE)
 	{
 		if (m_autojoin)
 		{

rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp

@@ -1,5 +1,4 @@
 #include "stdafx.h"
-#include <map>
 #include "Utilities/Log.h"
 #include "Emu/System.h"
 #include "Emu/Memory/Memory.h"
@@ -1969,7 +1968,7 @@ void ARMv7_instrs::LDM(ARMv7Context& context, const ARMv7Code code, const ARMv7_
 
 	if (ConditionPassed(context, cond))
 	{
-		auto memory = vm::psv::ptr<u32>::make(context.read_gpr(n));
+		auto memory = vm::ptr<u32>::make(context.read_gpr(n));
 
 		for (u32 i = 0; i < 16; i++)
 		{
@@ -2088,7 +2087,7 @@ void ARMv7_instrs::LDR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
 	{
 		const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		context.write_gpr(t, vm::psv::read32(addr));
+		context.write_gpr(t, vm::read32(addr));
 
 		if (wback)
 		{
@@ -2137,7 +2136,7 @@ void ARMv7_instrs::LDR_LIT(ARMv7Context& context, const ARMv7Code code, const AR
 
 	if (ConditionPassed(context, cond))
 	{
-		const u32 data = vm::psv::read32(addr);
+		const u32 data = vm::read32(addr);
 		context.write_gpr(t, data);
 	}
 }
@@ -2194,7 +2193,7 @@ void ARMv7_instrs::LDR_REG(ARMv7Context& context, const ARMv7Code code, const AR
 		const u32 offset = Shift(context.read_gpr(m), shift_t, shift_n, context.APSR.C);
 		const u32 offset_addr = add ? context.read_gpr(n) + offset : context.read_gpr(n) - offset;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		context.write_gpr(t, vm::psv::read32(addr));
+		context.write_gpr(t, vm::read32(addr));
 
 		if (wback)
 		{
@@ -2386,7 +2385,7 @@ void ARMv7_instrs::LDRD_IMM(ARMv7Context& context, const ARMv7Code code, const A
 	{
 		const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		const u64 value = vm::psv::read64(addr);
+		const u64 value = vm::read64(addr);
 		context.write_gpr(t, (u32)(value));
 		context.write_gpr(t2, (u32)(value >> 32));
 
@@ -2431,7 +2430,7 @@ void ARMv7_instrs::LDRD_LIT(ARMv7Context& context, const ARMv7Code code, const A
 
 	if (ConditionPassed(context, cond))
 	{
-		const u64 value = vm::psv::read64(addr);
+		const u64 value = vm::read64(addr);
 		context.write_gpr(t, (u32)(value));
 		context.write_gpr(t2, (u32)(value >> 32));
 	}
@@ -2511,7 +2510,7 @@ void ARMv7_instrs::LDRH_IMM(ARMv7Context& context, const ARMv7Code code, const A
 	{
 		const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		context.write_gpr(t, vm::psv::read16(addr));
+		context.write_gpr(t, vm::read16(addr));
 
 		if (wback)
 		{
@@ -3475,7 +3474,7 @@ void ARMv7_instrs::POP(ARMv7Context& context, const ARMv7Code code, const ARMv7_
 
 	if (ConditionPassed(context, cond))
 	{
-		auto stack = vm::psv::ptr<u32>::make(context.SP);
+		auto stack = vm::ptr<u32>::make(context.SP);
 
 		for (u32 i = 0; i < 16; i++)
 		{
@@ -3546,7 +3545,7 @@ void ARMv7_instrs::PUSH(ARMv7Context& context, const ARMv7Code code, const ARMv7
 
 	if (ConditionPassed(context, cond))
 	{
-		auto memory = vm::psv::ptr<u32>::make(context.SP);
+		auto memory = vm::ptr<u32>::make(context.SP);
 
 		for (u32 i = 15; ~i; i--)
 		{
@@ -4296,7 +4295,7 @@ void ARMv7_instrs::STM(ARMv7Context& context, const ARMv7Code code, const ARMv7_
 
 	if (ConditionPassed(context, cond))
 	{
-		auto memory = vm::psv::ptr<u32>::make(context.read_gpr(n));
+		auto memory = vm::ptr<u32>::make(context.read_gpr(n));
 
 		for (u32 i = 0; i < 16; i++)
 		{
@@ -4414,7 +4413,7 @@ void ARMv7_instrs::STR_IMM(ARMv7Context& context, const ARMv7Code code, const AR
 	{
 		const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		vm::psv::write32(addr, context.read_gpr(t));
+		vm::write32(addr, context.read_gpr(t));
 
 		if (wback)
 		{
@@ -4474,7 +4473,7 @@ void ARMv7_instrs::STR_REG(ARMv7Context& context, const ARMv7Code code, const AR
 		const u32 offset = Shift(context.read_gpr(m), shift_t, shift_n, context.APSR.C);
 		const u32 offset_addr = add ? context.read_gpr(n) + offset : context.read_gpr(n) - offset;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		vm::psv::write32(addr, context.read_gpr(t));
+		vm::write32(addr, context.read_gpr(t));
 
 		if (wback)
 		{
@@ -4653,7 +4652,7 @@ void ARMv7_instrs::STRD_IMM(ARMv7Context& context, const ARMv7Code code, const A
 		const u32 n_value = context.read_gpr(n);
 		const u32 offset = add ? n_value + imm32 : n_value - imm32;
 		const u32 addr = index ? offset : n_value;
-		vm::psv::write64(addr, (u64)context.read_gpr(t2) << 32 | (u64)context.read_gpr(t));
+		vm::write64(addr, (u64)context.read_gpr(t2) << 32 | (u64)context.read_gpr(t));
 
 		if (wback)
 		{
@@ -4733,7 +4732,7 @@ void ARMv7_instrs::STRH_IMM(ARMv7Context& context, const ARMv7Code code, const A
 	{
 		const u32 offset_addr = add ? context.read_gpr(n) + imm32 : context.read_gpr(n) - imm32;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		vm::psv::write16(addr, (u16)context.read_gpr(t));
+		vm::write16(addr, (u16)context.read_gpr(t));
 
 		if (wback)
 		{
@@ -4793,7 +4792,7 @@ void ARMv7_instrs::STRH_REG(ARMv7Context& context, const ARMv7Code code, const A
 		const u32 offset = Shift(context.read_gpr(m), shift_t, shift_n, context.APSR.C);
 		const u32 offset_addr = add ? context.read_gpr(n) + offset : context.read_gpr(n) - offset;
 		const u32 addr = index ? offset_addr : context.read_gpr(n);
-		vm::psv::write16(addr, (u16)context.read_gpr(t));
+		vm::write16(addr, (u16)context.read_gpr(t));
 
 		if (wback)
 		{

rpcs3/Emu/ARMv7/Modules/sceAppMgr.cpp

@@ -2,21 +2,14 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAppMgr;
+#include "sceAppMgr.h"
 
-struct SceAppMgrEvent
+s32 sceAppMgrReceiveEventNum(vm::ptr<s32> eventNum)
-{
-	s32 event;
-	s32 appId;
-	char param[56];
-};
-
-s32 sceAppMgrReceiveEventNum(vm::psv::ptr<s32> eventNum)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppMgrReceiveEvent(vm::psv::ptr<SceAppMgrEvent> appEvent)
+s32 sceAppMgrReceiveEvent(vm::ptr<SceAppMgrEvent> appEvent)
 {
 	throw __FUNCTION__;
 }
@@ -39,6 +32,7 @@ psv_log_base sceAppMgr("SceAppMgr", []()
 	sceAppMgr.on_load = nullptr;
 	sceAppMgr.on_unload = nullptr;
 	sceAppMgr.on_stop = nullptr;
+	sceAppMgr.on_error = nullptr;
 
 	REG_FUNC(0x47E5DD7D, sceAppMgrReceiveEventNum);
 	REG_FUNC(0xCFAD5A3A, sceAppMgrReceiveEvent);

rpcs3/Emu/ARMv7/Modules/sceAppMgr.h

@@ -0,0 +1,10 @@
+#pragma once
+
+struct SceAppMgrEvent
+{
+	le_t<s32> event;
+	le_t<s32> appId;
+	char param[56];
+};
+
+extern psv_log_base sceAppMgr;

rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp

@@ -4,7 +4,7 @@
 
 #include "sceAppUtil.h"
 
-s32 sceAppUtilInit(vm::psv::ptr<const SceAppUtilInitParam> initParam, vm::psv::ptr<SceAppUtilBootParam> bootParam)
+s32 sceAppUtilInit(vm::ptr<const SceAppUtilInitParam> initParam, vm::ptr<SceAppUtilBootParam> bootParam)
 {
 	throw __FUNCTION__;
 }
@@ -14,27 +14,27 @@ s32 sceAppUtilShutdown()
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::ptr<const SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::ptr<const SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::psv::ptr<SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::ptr<SceAppUtilSaveDataSlotParam> param, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveDataFileSave(vm::psv::ptr<const SceAppUtilSaveDataFileSlot> slot, vm::psv::ptr<const SceAppUtilSaveDataFile> files, u32 fileNum, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint, vm::psv::ptr<u32> requiredSizeKB)
+s32 sceAppUtilSaveDataFileSave(vm::ptr<const SceAppUtilSaveDataFileSlot> slot, vm::ptr<const SceAppUtilSaveDataFile> files, u32 fileNum, vm::ptr<const SceAppUtilSaveDataMountPoint> mountPoint, vm::ptr<u32> requiredSizeKB)
 {
 	throw __FUNCTION__;
 }
@@ -49,22 +49,22 @@ s32 sceAppUtilPhotoUmount()
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::psv::ptr<s32> value)
+s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::ptr<s32> value)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSystemParamGetString(u32 paramId, vm::psv::ptr<char> buf, u32 bufSize)
+s32 sceAppUtilSystemParamGetString(u32 paramId, vm::ptr<char> buf, u32 bufSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilSaveSafeMemory(vm::psv::ptr<const void> buf, u32 bufSize, s64 offset)
+s32 sceAppUtilSaveSafeMemory(vm::ptr<const void> buf, u32 bufSize, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAppUtilLoadSafeMemory(vm::psv::ptr<void> buf, u32 bufSize, s64 offset)
+s32 sceAppUtilLoadSafeMemory(vm::ptr<void> buf, u32 bufSize, s64 offset)
 {
 	throw __FUNCTION__;
 }
@@ -77,6 +77,7 @@ psv_log_base sceAppUtil("SceAppUtil", []()
 	sceAppUtil.on_load = nullptr;
 	sceAppUtil.on_unload = nullptr;
 	sceAppUtil.on_stop = nullptr;
+	sceAppUtil.on_error = nullptr;
 
 	REG_FUNC(0xDAFFE671, sceAppUtilInit);
 	REG_FUNC(0xB220B00B, sceAppUtilShutdown);

rpcs3/Emu/ARMv7/Modules/sceAppUtil.h

@@ -2,14 +2,14 @@
 
 struct SceAppUtilInitParam
 {
-	u32 workBufSize;
+	le_t<u32> workBufSize;
 	char reserved[60];
 };
 
 struct SceAppUtilBootParam
 {
-	u32 attr;
+	le_t<u32> attr;
-	u32 appVersion;
+	le_t<u32> appVersion;
 	char reserved[32];
 };
 
@@ -20,49 +20,49 @@ struct SceAppUtilSaveDataMountPoint
 
 struct SceAppUtilSaveDataSlotParam
 {
-	u32 status;
+	le_t<u32> status;
 	char title[64];
 	char subTitle[128];
 	char detail[512];
 	char iconPath[64];
-	s32 userParam;
+	le_t<s32> userParam;
-	u32 sizeKB;
+	le_t<u32> sizeKB;
 	SceDateTime modifiedTime;
 	char reserved[48];
 };
 
 struct SceAppUtilSaveDataSlotEmptyParam
 {
-	vm::psv::ptr<char> title;
+	vm::lptr<char> title;
-	vm::psv::ptr<char> iconPath;
+	vm::lptr<char> iconPath;
-	vm::psv::ptr<void> iconBuf;
+	vm::lptr<void> iconBuf;
-	u32 iconBufSize;
+	le_t<u32> iconBufSize;
 	char reserved[32];
 };
 
 struct SceAppUtilSaveDataSlot
 {
-	u32 id;
+	le_t<u32> id;
-	u32 status;
+	le_t<u32> status;
-	s32 userParam;
+	le_t<s32> userParam;
-	vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
+	vm::lptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
 };
 
 struct SceAppUtilSaveDataFile
 {
-	vm::psv::ptr<const char> filePath;
+	vm::lptr<const char> filePath;
-	vm::psv::ptr<void> buf;
+	vm::lptr<void> buf;
-	u32 bufSize;
+	le_t<u32> bufSize;
-	s64 offset;
+	le_t<s64> offset;
-	u32 mode;
+	le_t<u32> mode;
-	u32 progDelta;
+	le_t<u32> progDelta;
 	char reserved[32];
 };
 
 struct SceAppUtilSaveDataFileSlot
 {
-	u32 id;
+	le_t<u32> id;
-	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
+	vm::lptr<SceAppUtilSaveDataSlotParam> slotParam;
 	char reserved[32];
 };
 

rpcs3/Emu/ARMv7/Modules/sceAudio.cpp

@@ -2,7 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAudio;
+#include "sceAudio.h"
 
 s32 sceAudioOutOpenPort(s32 portType, s32 len, s32 freq, s32 param)
 {
@@ -14,12 +14,12 @@ s32 sceAudioOutReleasePort(s32 port)
 	throw __FUNCTION__;
 }
 
-s32 sceAudioOutOutput(s32 port, vm::psv::ptr<void> ptr)
+s32 sceAudioOutOutput(s32 port, vm::ptr<void> ptr)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::psv::ptr<s32> vol)
+s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::ptr<s32> vol)
 {
 	throw __FUNCTION__;
 }
@@ -52,6 +52,7 @@ psv_log_base sceAudio("SceAudio", []()
 	sceAudio.on_load = nullptr;
 	sceAudio.on_unload = nullptr;
 	sceAudio.on_stop = nullptr;
+	sceAudio.on_error = nullptr;
 
 	REG_FUNC(0x5BC341E4, sceAudioOutOpenPort);
 	REG_FUNC(0x69E2E6B5, sceAudioOutReleasePort);

rpcs3/Emu/ARMv7/Modules/sceAudio.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceAudio;

rpcs3/Emu/ARMv7/Modules/sceAudioIn.cpp

@@ -2,7 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAudioIn;
+#include "sceAudioIn.h"
 
 s32 sceAudioInOpenPort(s32 portType, s32 grain, s32 freq, s32 param)
 {
@@ -14,7 +14,7 @@ s32 sceAudioInReleasePort(s32 port)
 	throw __FUNCTION__;
 }
 
-s32 sceAudioInInput(s32 port, vm::psv::ptr<void> destPtr)
+s32 sceAudioInInput(s32 port, vm::ptr<void> destPtr)
 {
 	throw __FUNCTION__;
 }
@@ -27,6 +27,7 @@ psv_log_base sceAudioIn("SceAudioIn", []()
 	sceAudioIn.on_load = nullptr;
 	sceAudioIn.on_unload = nullptr;
 	sceAudioIn.on_stop = nullptr;
+	sceAudioIn.on_error = nullptr;
 
 	REG_FUNC(0x638ADD2D, sceAudioInInput);
 	REG_FUNC(0x39B50DC1, sceAudioInOpenPort);

rpcs3/Emu/ARMv7/Modules/sceAudioIn.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceAudioIn;

rpcs3/Emu/ARMv7/Modules/sceAudiodec.cpp

@@ -2,89 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAudiodec;
+#include "sceAudiodec.h"
 
-struct SceAudiodecInitStreamParam
+s32 sceAudiodecInitLibrary(u32 codecType, vm::ptr<SceAudiodecInitParam> pInitParam)
-{
-	u32 size;
-	u32 totalStreams;
-};
-
-struct SceAudiodecInitChParam
-{
-	u32 size;
-	u32 totalCh;
-};
-
-union SceAudiodecInitParam
-{
-	u32 size;
-	SceAudiodecInitChParam     at9;
-	SceAudiodecInitStreamParam mp3;
-	SceAudiodecInitStreamParam aac;
-	SceAudiodecInitStreamParam celp;
-};
-
-struct SceAudiodecInfoAt9
-{
-	u32 size;
-	u8 configData[4];
-	u32 ch;
-	u32 bitRate;
-	u32 samplingRate;
-	u32 superFrameSize;
-	u32 framesInSuperFrame;
-};
-
-struct SceAudiodecInfoMp3
-{
-	u32 size;
-	u32 ch;
-	u32 version;
-};
-
-struct SceAudiodecInfoAac
-{
-	u32 size;
-	u32 isAdts;
-	u32 ch;
-	u32 samplingRate;
-	u32 isSbr;
-};
-
-struct SceAudiodecInfoCelp
-{
-	u32 size;
-	u32 excitationMode;
-	u32 samplingRate;
-	u32 bitRate;
-	u32 lostCount;
-};
-
-union SceAudiodecInfo
-{
-	u32 size;
-	SceAudiodecInfoAt9  at9;
-	SceAudiodecInfoMp3  mp3;
-	SceAudiodecInfoAac  aac;
-	SceAudiodecInfoCelp celp;
-};
-
-struct SceAudiodecCtrl
-{
-	u32 size;
-	s32 handle;
-	vm::psv::ptr<u8> pEs;
-	u32 inputEsSize;
-	u32 maxEsSize;
-	vm::psv::ptr<void> pPcm;
-	u32 outputPcmSize;
-	u32 maxPcmSize;
-	u32 wordLength;
-	vm::psv::ptr<SceAudiodecInfo> pInfo;
-};
-
-s32 sceAudiodecInitLibrary(u32 codecType, vm::psv::ptr<SceAudiodecInitParam> pInitParam)
 {
 	throw __FUNCTION__;
 }
@@ -94,27 +14,27 @@ s32 sceAudiodecTermLibrary(u32 codecType)
 	throw __FUNCTION__;
 }
 
-s32 sceAudiodecCreateDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
+s32 sceAudiodecCreateDecoder(vm::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudiodecDeleteDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
+s32 sceAudiodecDeleteDecoder(vm::ptr<SceAudiodecCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudiodecDecode(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
+s32 sceAudiodecDecode(vm::ptr<SceAudiodecCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudiodecClearContext(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
+s32 sceAudiodecClearContext(vm::ptr<SceAudiodecCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudiodecGetInternalError(vm::psv::ptr<SceAudiodecCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
+s32 sceAudiodecGetInternalError(vm::ptr<SceAudiodecCtrl> pCtrl, vm::ptr<s32> pInternalError)
 {
 	throw __FUNCTION__;
 }
@@ -127,6 +47,7 @@ psv_log_base sceAudiodec("SceAudiodec", []()
 	sceAudiodec.on_load = nullptr;
 	sceAudiodec.on_unload = nullptr;
 	sceAudiodec.on_stop = nullptr;
+	sceAudiodec.on_error = nullptr;
 
 	REG_FUNC(0x445C2CEF, sceAudiodecInitLibrary);
 	REG_FUNC(0x45719B9D, sceAudiodecTermLibrary);

rpcs3/Emu/ARMv7/Modules/sceAudiodec.h

@@ -0,0 +1,83 @@
+#pragma once
+
+struct SceAudiodecInitStreamParam
+{
+	le_t<u32> size;
+	le_t<u32> totalStreams;
+};
+
+struct SceAudiodecInitChParam
+{
+	le_t<u32> size;
+	le_t<u32> totalCh;
+};
+
+union SceAudiodecInitParam
+{
+	le_t<u32> size;
+	SceAudiodecInitChParam     at9;
+	SceAudiodecInitStreamParam mp3;
+	SceAudiodecInitStreamParam aac;
+	SceAudiodecInitStreamParam celp;
+};
+
+struct SceAudiodecInfoAt9
+{
+	le_t<u32> size;
+	u8 configData[4];
+	le_t<u32> ch;
+	le_t<u32> bitRate;
+	le_t<u32> samplingRate;
+	le_t<u32> superFrameSize;
+	le_t<u32> framesInSuperFrame;
+};
+
+struct SceAudiodecInfoMp3
+{
+	le_t<u32> size;
+	le_t<u32> ch;
+	le_t<u32> version;
+};
+
+struct SceAudiodecInfoAac
+{
+	le_t<u32> size;
+	le_t<u32> isAdts;
+	le_t<u32> ch;
+	le_t<u32> samplingRate;
+	le_t<u32> isSbr;
+};
+
+struct SceAudiodecInfoCelp
+{
+	le_t<u32> size;
+	le_t<u32> excitationMode;
+	le_t<u32> samplingRate;
+	le_t<u32> bitRate;
+	le_t<u32> lostCount;
+};
+
+union SceAudiodecInfo
+{
+	le_t<u32> size;
+	SceAudiodecInfoAt9  at9;
+	SceAudiodecInfoMp3  mp3;
+	SceAudiodecInfoAac  aac;
+	SceAudiodecInfoCelp celp;
+};
+
+struct SceAudiodecCtrl
+{
+	le_t<u32> size;
+	le_t<s32> handle;
+	vm::lptr<u8> pEs;
+	le_t<u32> inputEsSize;
+	le_t<u32> maxEsSize;
+	vm::lptr<void> pPcm;
+	le_t<u32> outputPcmSize;
+	le_t<u32> maxPcmSize;
+	le_t<u32> wordLength;
+	vm::lptr<SceAudiodecInfo> pInfo;
+};
+
+extern psv_log_base sceAudiodec;

rpcs3/Emu/ARMv7/Modules/sceAudioenc.cpp

@@ -2,66 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceAudioenc;
+#include "sceAudioenc.h"
 
-struct SceAudioencInitStreamParam
+s32 sceAudioencInitLibrary(u32 codecType, vm::ptr<SceAudioencInitParam> pInitParam)
-{
-	u32 size;
-	u32 totalStreams;
-};
-
-struct SceAudioencInfoCelp
-{
-	u32 size;
-	u32 excitationMode;
-	u32 samplingRate;
-	u32 bitRate;
-};
-
-struct SceAudioencOptInfoCelp
-{
-	u32 size;
-	u8 header[32];
-	u32 headerSize;
-	u32 encoderVersion;
-};
-
-
-union SceAudioencInitParam
-{
-	u32 size;
-	SceAudioencInitStreamParam celp;
-};
-
-union SceAudioencInfo
-{
-	u32 size;
-	SceAudioencInfoCelp celp;
-};
-
-union SceAudioencOptInfo
-{
-	u32 size;
-	SceAudioencOptInfoCelp celp;
-};
-
-struct SceAudioencCtrl
-{
-	u32 size;
-	s32 handle;
-	vm::psv::ptr<u8> pInputPcm;
-	u32 inputPcmSize;
-	u32 maxPcmSize;
-	vm::psv::ptr<void> pOutputEs;
-	u32 outputEsSize;
-	u32 maxEsSize;
-	u32 wordLength;
-	vm::psv::ptr<SceAudioencInfo> pInfo;
-	vm::psv::ptr<SceAudioencOptInfo> pOptInfo;
-};
-
-
-s32 sceAudioencInitLibrary(u32 codecType, vm::psv::ptr<SceAudioencInitParam> pInitParam)
 {
 	throw __FUNCTION__;
 }
@@ -71,32 +14,32 @@ s32 sceAudioencTermLibrary(u32 codecType)
 	throw __FUNCTION__;
 }
 
-s32 sceAudioencCreateEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
+s32 sceAudioencCreateEncoder(vm::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudioencDeleteEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+s32 sceAudioencDeleteEncoder(vm::ptr<SceAudioencCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudioencEncode(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+s32 sceAudioencEncode(vm::ptr<SceAudioencCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudioencClearContext(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+s32 sceAudioencClearContext(vm::ptr<SceAudioencCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudioencGetOptInfo(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+s32 sceAudioencGetOptInfo(vm::ptr<SceAudioencCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceAudioencGetInternalError(vm::psv::ptr<SceAudioencCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
+s32 sceAudioencGetInternalError(vm::ptr<SceAudioencCtrl> pCtrl, vm::ptr<s32> pInternalError)
 {
 	throw __FUNCTION__;
 }
@@ -109,6 +52,7 @@ psv_log_base sceAudioenc("SceAudioenc", []()
 	sceAudioenc.on_load = nullptr;
 	sceAudioenc.on_unload = nullptr;
 	sceAudioenc.on_stop = nullptr;
+	sceAudioenc.on_error = nullptr;
 
 	REG_FUNC(0x76EE4DC6, sceAudioencInitLibrary);
 	REG_FUNC(0xAB32D022, sceAudioencTermLibrary);

rpcs3/Emu/ARMv7/Modules/sceAudioenc.h

@@ -0,0 +1,59 @@
+#pragma once
+
+struct SceAudioencInitStreamParam
+{
+	le_t<u32> size;
+	le_t<u32> totalStreams;
+};
+
+struct SceAudioencInfoCelp
+{
+	le_t<u32> size;
+	le_t<u32> excitationMode;
+	le_t<u32> samplingRate;
+	le_t<u32> bitRate;
+};
+
+struct SceAudioencOptInfoCelp
+{
+	le_t<u32> size;
+	u8 header[32];
+	le_t<u32> headerSize;
+	le_t<u32> encoderVersion;
+};
+
+
+union SceAudioencInitParam
+{
+	le_t<u32> size;
+	SceAudioencInitStreamParam celp;
+};
+
+union SceAudioencInfo
+{
+	le_t<u32> size;
+	SceAudioencInfoCelp celp;
+};
+
+union SceAudioencOptInfo
+{
+	le_t<u32> size;
+	SceAudioencOptInfoCelp celp;
+};
+
+struct SceAudioencCtrl
+{
+	le_t<u32> size;
+	le_t<s32> handle;
+	vm::lptr<u8> pInputPcm;
+	le_t<u32> inputPcmSize;
+	le_t<u32> maxPcmSize;
+	vm::lptr<void> pOutputEs;
+	le_t<u32> outputEsSize;
+	le_t<u32> maxEsSize;
+	le_t<u32> wordLength;
+	vm::lptr<SceAudioencInfo> pInfo;
+	vm::lptr<SceAudioencOptInfo> pOptInfo;
+};
+
+extern psv_log_base sceAudioenc;

rpcs3/Emu/ARMv7/Modules/sceCamera.cpp

@@ -2,46 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceCamera;
+#include "sceCamera.h"
 
-struct SceCameraInfo
+s32 sceCameraOpen(s32 devnum, vm::ptr<SceCameraInfo> pInfo)
-{
-	u32 sizeThis;
-	u32 wPriority;
-	u32 wFormat;
-	u32 wResolution;
-	u32 wFramerate;
-	u32 wWidth;
-	u32 wHeight;
-	u32 wRange;
-	u32 _padding_0;
-	u32 sizeIBase;
-	u32 sizeUBase;
-	u32 sizeVBase;
-	vm::psv::ptr<void> pvIBase;
-	vm::psv::ptr<void> pvUBase;
-	vm::psv::ptr<void> pvVBase;
-	u32 wPitch;
-	u32 wBuffer;
-};
-
-struct SceCameraRead
-{
-	u32 sizeThis;
-	s32 dwMode;
-	s32 _padding_0;
-	s32 dwStatus;
-	u32 qwFrame;
-	u32 qwTimestamp;
-	u32 sizeIBase;
-	u32 sizeUBase;
-	u32 sizeVBase;
-	vm::psv::ptr<void> pvIBase;
-	vm::psv::ptr<void> pvUBase;
-	vm::psv::ptr<void> pvVBase;
-};
-
-s32 sceCameraOpen(s32 devnum, vm::psv::ptr<SceCameraInfo> pInfo)
 {
 	throw __FUNCTION__;
 }
@@ -61,7 +24,7 @@ s32 sceCameraStop(s32 devnum)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraRead(s32 devnum, vm::psv::ptr<SceCameraRead> pRead)
+s32 sceCameraRead(s32 devnum, vm::ptr<SceCameraRead> pRead)
 {
 	throw __FUNCTION__;
 }
@@ -71,7 +34,7 @@ s32 sceCameraIsActive(s32 devnum)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetSaturation(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetSaturation(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -81,7 +44,7 @@ s32 sceCameraSetSaturation(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetBrightness(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetBrightness(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -91,7 +54,7 @@ s32 sceCameraSetBrightness(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetContrast(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetContrast(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -101,7 +64,7 @@ s32 sceCameraSetContrast(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetSharpness(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetSharpness(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -111,7 +74,7 @@ s32 sceCameraSetSharpness(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetReverse(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetReverse(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -121,7 +84,7 @@ s32 sceCameraSetReverse(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetEffect(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetEffect(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -131,7 +94,7 @@ s32 sceCameraSetEffect(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetEV(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetEV(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -141,7 +104,7 @@ s32 sceCameraSetEV(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetZoom(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetZoom(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -151,7 +114,7 @@ s32 sceCameraSetZoom(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetAntiFlicker(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetAntiFlicker(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -161,7 +124,7 @@ s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetISO(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetISO(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -171,7 +134,7 @@ s32 sceCameraSetISO(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetGain(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetGain(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -181,7 +144,7 @@ s32 sceCameraSetGain(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetWhiteBalance(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetWhiteBalance(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -191,7 +154,7 @@ s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetBacklight(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetBacklight(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -201,7 +164,7 @@ s32 sceCameraSetBacklight(s32 devnum, s32 mode)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetNightmode(s32 devnum, vm::psv::ptr<s32> pMode)
+s32 sceCameraGetNightmode(s32 devnum, vm::ptr<s32> pMode)
 {
 	throw __FUNCTION__;
 }
@@ -221,7 +184,7 @@ s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -231,7 +194,7 @@ s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
 	throw __FUNCTION__;
 }
 
-s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::ptr<s32> pLevel)
 {
 	throw __FUNCTION__;
 }
@@ -254,6 +217,7 @@ psv_log_base sceCamera("SceCamera", []()
 	sceCamera.on_load = nullptr;
 	sceCamera.on_unload = nullptr;
 	sceCamera.on_stop = nullptr;
+	sceCamera.on_error = nullptr;
 
 	REG_FUNC(0xA462F801, sceCameraOpen);
 	REG_FUNC(0xCD6E1CFC, sceCameraClose);

rpcs3/Emu/ARMv7/Modules/sceCamera.h

@@ -0,0 +1,40 @@
+#pragma once
+
+struct SceCameraInfo
+{
+	le_t<u32> sizeThis;
+	le_t<u32> wPriority;
+	le_t<u32> wFormat;
+	le_t<u32> wResolution;
+	le_t<u32> wFramerate;
+	le_t<u32> wWidth;
+	le_t<u32> wHeight;
+	le_t<u32> wRange;
+	le_t<u32> _padding_0;
+	le_t<u32> sizeIBase;
+	le_t<u32> sizeUBase;
+	le_t<u32> sizeVBase;
+	vm::lptr<void> pvIBase;
+	vm::lptr<void> pvUBase;
+	vm::lptr<void> pvVBase;
+	le_t<u32> wPitch;
+	le_t<u32> wBuffer;
+};
+
+struct SceCameraRead
+{
+	le_t<u32> sizeThis;
+	le_t<s32> dwMode;
+	le_t<s32> _padding_0;
+	le_t<s32> dwStatus;
+	le_t<u32> qwFrame;
+	le_t<u32> qwTimestamp;
+	le_t<u32> sizeIBase;
+	le_t<u32> sizeUBase;
+	le_t<u32> sizeVBase;
+	vm::lptr<void> pvIBase;
+	vm::lptr<void> pvUBase;
+	vm::lptr<void> pvVBase;
+};
+
+extern psv_log_base sceCamera;

rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp

@@ -2,13 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceCodecEngine;
+#include "sceCodecEngine.h"
-
-struct SceCodecEnginePmonProcessorLoad
-{
-	u32 size;
-	u32 average;
-};
 
 s32 sceCodecEnginePmonStart()
 {
@@ -20,7 +14,7 @@ s32 sceCodecEnginePmonStop()
 	throw __FUNCTION__;
 }
 
-s32 sceCodecEnginePmonGetProcessorLoad(vm::psv::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
+s32 sceCodecEnginePmonGetProcessorLoad(vm::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
 {
 	throw __FUNCTION__;
 }
@@ -38,6 +32,7 @@ psv_log_base sceCodecEngine("SceCodecEngine", []()
 	sceCodecEngine.on_load = nullptr;
 	sceCodecEngine.on_unload = nullptr;
 	sceCodecEngine.on_stop = nullptr;
+	sceCodecEngine.on_error = nullptr;
 
 	REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
 	REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);

rpcs3/Emu/ARMv7/Modules/sceCodecEngine.h

@@ -0,0 +1,9 @@
+#pragma once
+
+struct SceCodecEnginePmonProcessorLoad
+{
+	le_t<u32> size;
+	le_t<u32> average;
+};
+
+extern psv_log_base sceCodecEngine;

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp

@@ -2,314 +2,14 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceGxm.h"
+#include "sceCommonDialog.h"
-#include "sceAppUtil.h"
-#include "sceIme.h"
 
-extern psv_log_base sceCommonDialog;
+s32 sceCommonDialogUpdate(vm::ptr<const SceCommonDialogUpdateParam> updateParam)
-
-enum SceCommonDialogStatus : s32
-{
-	SCE_COMMON_DIALOG_STATUS_NONE = 0,
-	SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
-	SCE_COMMON_DIALOG_STATUS_FINISHED = 2
-};
-
-enum SceCommonDialogResult : s32
-{
-	SCE_COMMON_DIALOG_RESULT_OK,
-	SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
-	SCE_COMMON_DIALOG_RESULT_ABORTED
-};
-
-struct SceCommonDialogRenderTargetInfo
-{
-	vm::psv::ptr<void> depthSurfaceData;
-	vm::psv::ptr<void> colorSurfaceData;
-	SceGxmColorSurfaceType surfaceType;
-	SceGxmColorFormat colorFormat;
-	u32 width;
-	u32 height;
-	u32 strideInPixels;
-	u8 reserved[32];
-};
-
-struct SceCommonDialogUpdateParam
-{
-	SceCommonDialogRenderTargetInfo renderTarget;
-	vm::psv::ptr<SceGxmSyncObject> displaySyncObject;
-	u8 reserved[32];
-};
-
-struct SceMsgDialogUserMessageParam
-{
-	s32 buttonType;
-	vm::psv::ptr<const char> msg;
-	char reserved[32];
-};
-
-struct SceMsgDialogSystemMessageParam
-{
-	s32 sysMsgType;
-	s32 value;
-	char reserved[32];
-};
-
-struct SceMsgDialogErrorCodeParam
-{
-	s32 errorCode;
-	char reserved[32];
-};
-
-struct SceMsgDialogProgressBarParam
-{
-	s32 barType;
-	SceMsgDialogSystemMessageParam sysMsgParam;
-	vm::psv::ptr<const char> msg;
-	char reserved[32];
-};
-
-struct SceMsgDialogParam
-{
-	u32 sdkVersion;
-	s32 mode;
-	vm::psv::ptr<SceMsgDialogUserMessageParam> userMsgParam;
-	vm::psv::ptr<SceMsgDialogSystemMessageParam> sysMsgParam;
-	vm::psv::ptr<SceMsgDialogErrorCodeParam> errorCodeParam;
-	vm::psv::ptr<SceMsgDialogProgressBarParam> progBarParam;
-	u32 flag;
-	char reserved[32];
-};
-
-struct SceMsgDialogResult
-{
-	s32 mode;
-	s32 result;
-	s32 buttonId;
-	u8 reserved[32];
-};
-
-
-struct SceNetCheckDialogParam
-{
-	u32 sdkVersion;
-	s32 mode;
-	u8 reserved[128];
-};
-
-struct SceNetCheckDialogResult
-{
-	s32 result;
-	u8 reserved[128];
-};
-
-struct SceSaveDataDialogFixedParam
-{
-	u32 targetSlot;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogListParam
-{
-	vm::psv::ptr<const u32> slotList;
-	u32 slotListSize;
-	s32 focusPos;
-	u32 focusId;
-	vm::psv::ptr<const char> listTitle;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogUserMessageParam
-{
-	s32 buttonType;
-	vm::psv::ptr<const char> msg;
-	u32 targetSlot;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogSystemMessageParam
-{
-	s32 sysMsgType;
-	s32 value;
-	u32 targetSlot;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogErrorCodeParam
-{
-	s32 errorCode;
-	u32 targetSlot;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogProgressBarParam
-{
-	s32 barType;
-	SceSaveDataDialogSystemMessageParam sysMsgParam;
-	vm::psv::ptr<const char> msg;
-	u32 targetSlot;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogSlotConfigParam
-{
-	vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint;
-	vm::psv::ptr<const char> appSubDir;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogParam
-{
-	u32 sdkVersion;
-	s32 mode;
-	s32 dispType;
-	vm::psv::ptr<SceSaveDataDialogFixedParam> fixedParam;
-	vm::psv::ptr<SceSaveDataDialogListParam> listParam;
-	vm::psv::ptr<SceSaveDataDialogUserMessageParam> userMsgParam;
-	vm::psv::ptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
-	vm::psv::ptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
-	vm::psv::ptr<SceSaveDataDialogProgressBarParam> progBarParam;
-	vm::psv::ptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
-	u32 flag;
-	vm::psv::ptr<void> userdata;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogFinishParam
-{
-	u32 flag;
-	char reserved[32];
-};
-
-struct SceSaveDataDialogSlotInfo
-{
-	u32 isExist;
-	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
-	u8 reserved[32];
-};
-
-struct SceSaveDataDialogResult
-{
-	s32 mode;
-	s32 result;
-	s32 buttonId;
-	u32 slotId;
-	vm::psv::ptr<SceSaveDataDialogSlotInfo> slotInfo;
-	vm::psv::ptr<void> userdata;
-	char reserved[32];
-};
-
-
-struct SceImeDialogParam
-{
-	u32 sdkVersion;
-	u32 inputMethod;
-	u64 supportedLanguages;
-	s32 languagesForced;
-	u32 type;
-	u32 option;
-	vm::psv::ptr<SceImeCharFilter> filter;
-	u32 dialogMode;
-	u32 textBoxMode;
-	vm::psv::ptr<const u16> title;
-	u32 maxTextLength;
-	vm::psv::ptr<u16> initialText;
-	vm::psv::ptr<u16> inputTextBuffer;
-	char reserved[32];
-};
-
-struct SceImeDialogResult
-{
-	s32 result;
-	char reserved[32];
-};
-
-enum ScePhotoImportDialogFormatType : s32
-{
-	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
-	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
-	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
-	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
-	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
-	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
-};
-
-enum ScePhotoImportDialogOrientation : s32
-{
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
-	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM
-};
-
-struct ScePhotoImportDialogFileDataSub
-{
-	u32 width;
-	u32 height;
-	ScePhotoImportDialogFormatType format;
-	ScePhotoImportDialogOrientation orientation;
-	char reserved[32];
-};
-
-struct ScePhotoImportDialogFileData
-{
-	char fileName[1024];
-	char photoTitle[256];
-	char reserved[32];
-};
-
-struct ScePhotoImportDialogItemData
-{
-	ScePhotoImportDialogFileData fileData;
-	ScePhotoImportDialogFileDataSub dataSub;
-	char reserved[32];
-};
-
-struct ScePhotoImportDialogResult
-{
-	s32 result;
-	u32 importedItemNum;
-	char reserved[32];
-};
-
-struct ScePhotoImportDialogParam
-{
-	u32 sdkVersion;
-	s32 mode;
-	u32 visibleCategory;
-	u32 itemCount;
-	vm::psv::ptr<ScePhotoImportDialogItemData> itemData;
-	char reserved[32];
-};
-
-struct ScePhotoReviewDialogParam
-{
-	u32 sdkVersion;
-	s32 mode;
-	char fileName[1024];
-	vm::psv::ptr<void> workMemory;
-	u32 workMemorySize;
-	char reserved[32];
-};
-
-struct ScePhotoReviewDialogResult
-{
-	s32 result;
-	char reserved[32];
-};
-
-
-s32 sceCommonDialogUpdate(vm::psv::ptr<const SceCommonDialogUpdateParam> updateParam)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMsgDialogInit(vm::psv::ptr<const SceMsgDialogParam> param)
+s32 sceMsgDialogInit(vm::ptr<const SceMsgDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -324,7 +24,7 @@ s32 sceMsgDialogAbort()
 	throw __FUNCTION__;
 }
 
-s32 sceMsgDialogGetResult(vm::psv::ptr<SceMsgDialogResult> result)
+s32 sceMsgDialogGetResult(vm::ptr<SceMsgDialogResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -349,7 +49,7 @@ s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
 	throw __FUNCTION__;
 }
 
-s32 sceNetCheckDialogInit(vm::psv::ptr<SceNetCheckDialogParam> param)
+s32 sceNetCheckDialogInit(vm::ptr<SceNetCheckDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -364,7 +64,7 @@ s32 sceNetCheckDialogAbort()
 	throw __FUNCTION__;
 }
 
-s32 sceNetCheckDialogGetResult(vm::psv::ptr<SceNetCheckDialogResult> result)
+s32 sceNetCheckDialogGetResult(vm::ptr<SceNetCheckDialogResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -374,7 +74,7 @@ s32 sceNetCheckDialogTerm()
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogInit(vm::psv::ptr<const SceSaveDataDialogParam> param)
+s32 sceSaveDataDialogInit(vm::ptr<const SceSaveDataDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -389,7 +89,7 @@ s32 sceSaveDataDialogAbort()
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogGetResult(vm::psv::ptr<SceSaveDataDialogResult> result)
+s32 sceSaveDataDialogGetResult(vm::ptr<SceSaveDataDialogResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -409,12 +109,12 @@ s32 sceSaveDataDialogSubClose()
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogContinue(vm::psv::ptr<const SceSaveDataDialogParam> param)
+s32 sceSaveDataDialogContinue(vm::ptr<const SceSaveDataDialogParam> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSaveDataDialogFinish(vm::psv::ptr<const SceSaveDataDialogFinishParam> param)
+s32 sceSaveDataDialogFinish(vm::ptr<const SceSaveDataDialogFinishParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -429,7 +129,7 @@ s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
 	throw __FUNCTION__;
 }
 
-s32 sceImeDialogInit(vm::psv::ptr<const SceImeDialogParam> param)
+s32 sceImeDialogInit(vm::ptr<const SceImeDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -444,7 +144,7 @@ s32 sceImeDialogAbort()
 	throw __FUNCTION__;
 }
 
-s32 sceImeDialogGetResult(vm::psv::ptr<SceImeDialogResult> result)
+s32 sceImeDialogGetResult(vm::ptr<SceImeDialogResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -454,7 +154,7 @@ s32 sceImeDialogTerm()
 	throw __FUNCTION__;
 }
 
-s32 scePhotoImportDialogInit(vm::psv::ptr<const ScePhotoImportDialogParam> param)
+s32 scePhotoImportDialogInit(vm::ptr<const ScePhotoImportDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -464,7 +164,7 @@ SceCommonDialogStatus scePhotoImportDialogGetStatus()
 	throw __FUNCTION__;
 }
 
-s32 scePhotoImportDialogGetResult(vm::psv::ptr<ScePhotoImportDialogResult> result)
+s32 scePhotoImportDialogGetResult(vm::ptr<ScePhotoImportDialogResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -479,7 +179,7 @@ s32 scePhotoImportDialogAbort()
 	throw __FUNCTION__;
 }
 
-s32 scePhotoReviewDialogInit(vm::psv::ptr<const ScePhotoReviewDialogParam> param)
+s32 scePhotoReviewDialogInit(vm::ptr<const ScePhotoReviewDialogParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -489,7 +189,7 @@ SceCommonDialogStatus scePhotoReviewDialogGetStatus()
 	throw __FUNCTION__;
 }
 
-s32 scePhotoReviewDialogGetResult(vm::psv::ptr<ScePhotoReviewDialogResult> result)
+s32 scePhotoReviewDialogGetResult(vm::ptr<ScePhotoReviewDialogResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -512,6 +212,7 @@ psv_log_base sceCommonDialog("SceCommonDialog", []()
 	sceCommonDialog.on_load = nullptr;
 	sceCommonDialog.on_unload = nullptr;
 	sceCommonDialog.on_stop = nullptr;
+	sceCommonDialog.on_error = nullptr;
 
 	REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
 	REG_FUNC(0x755FF270, sceMsgDialogInit);

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.h

@@ -0,0 +1,302 @@
+#pragma once
+
+#include "sceGxm.h"
+#include "sceAppUtil.h"
+#include "sceIme.h"
+
+enum SceCommonDialogStatus : s32
+{
+	SCE_COMMON_DIALOG_STATUS_NONE = 0,
+	SCE_COMMON_DIALOG_STATUS_RUNNING = 1,
+	SCE_COMMON_DIALOG_STATUS_FINISHED = 2,
+};
+
+enum SceCommonDialogResult : s32
+{
+	SCE_COMMON_DIALOG_RESULT_OK,
+	SCE_COMMON_DIALOG_RESULT_USER_CANCELED,
+	SCE_COMMON_DIALOG_RESULT_ABORTED,
+};
+
+struct SceCommonDialogRenderTargetInfo
+{
+	vm::lptr<void> depthSurfaceData;
+	vm::lptr<void> colorSurfaceData;
+	le_t<u32> surfaceType; // SceGxmColorSurfaceType
+	le_t<u32> colorFormat; // SceGxmColorFormat
+	le_t<u32> width;
+	le_t<u32> height;
+	le_t<u32> strideInPixels;
+	u8 reserved[32];
+};
+
+struct SceCommonDialogUpdateParam
+{
+	SceCommonDialogRenderTargetInfo renderTarget;
+	vm::lptr<SceGxmSyncObject> displaySyncObject;
+	u8 reserved[32];
+};
+
+struct SceMsgDialogUserMessageParam
+{
+	le_t<s32> buttonType;
+	vm::lptr<const char> msg;
+	char reserved[32];
+};
+
+struct SceMsgDialogSystemMessageParam
+{
+	le_t<s32> sysMsgType;
+	le_t<s32> value;
+	char reserved[32];
+};
+
+struct SceMsgDialogErrorCodeParam
+{
+	le_t<s32> errorCode;
+	char reserved[32];
+};
+
+struct SceMsgDialogProgressBarParam
+{
+	le_t<s32> barType;
+	SceMsgDialogSystemMessageParam sysMsgParam;
+	vm::lptr<const char> msg;
+	char reserved[32];
+};
+
+struct SceMsgDialogParam
+{
+	le_t<u32> sdkVersion;
+	le_t<s32> mode;
+	vm::lptr<SceMsgDialogUserMessageParam> userMsgParam;
+	vm::lptr<SceMsgDialogSystemMessageParam> sysMsgParam;
+	vm::lptr<SceMsgDialogErrorCodeParam> errorCodeParam;
+	vm::lptr<SceMsgDialogProgressBarParam> progBarParam;
+	le_t<u32> flag;
+	char reserved[32];
+};
+
+struct SceMsgDialogResult
+{
+	le_t<s32> mode;
+	le_t<s32> result;
+	le_t<s32> buttonId;
+	u8 reserved[32];
+};
+
+
+struct SceNetCheckDialogParam
+{
+	le_t<u32> sdkVersion;
+	le_t<s32> mode;
+	u8 reserved[128];
+};
+
+struct SceNetCheckDialogResult
+{
+	le_t<s32> result;
+	u8 reserved[128];
+};
+
+struct SceSaveDataDialogFixedParam
+{
+	le_t<u32> targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogListParam
+{
+	vm::lptr<const u32> slotList;
+	le_t<u32> slotListSize;
+	le_t<s32> focusPos;
+	le_t<u32> focusId;
+	vm::lptr<const char> listTitle;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogUserMessageParam
+{
+	le_t<s32> buttonType;
+	vm::lptr<const char> msg;
+	le_t<u32> targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSystemMessageParam
+{
+	le_t<s32> sysMsgType;
+	le_t<s32> value;
+	le_t<u32> targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogErrorCodeParam
+{
+	le_t<s32> errorCode;
+	le_t<u32> targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogProgressBarParam
+{
+	le_t<s32> barType;
+	SceSaveDataDialogSystemMessageParam sysMsgParam;
+	vm::lptr<const char> msg;
+	le_t<u32> targetSlot;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSlotConfigParam
+{
+	vm::lptr<const SceAppUtilSaveDataMountPoint> mountPoint;
+	vm::lptr<const char> appSubDir;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogParam
+{
+	le_t<u32> sdkVersion;
+	le_t<s32> mode;
+	le_t<s32> dispType;
+	vm::lptr<SceSaveDataDialogFixedParam> fixedParam;
+	vm::lptr<SceSaveDataDialogListParam> listParam;
+	vm::lptr<SceSaveDataDialogUserMessageParam> userMsgParam;
+	vm::lptr<SceSaveDataDialogSystemMessageParam> sysMsgParam;
+	vm::lptr<SceSaveDataDialogErrorCodeParam> errorCodeParam;
+	vm::lptr<SceSaveDataDialogProgressBarParam> progBarParam;
+	vm::lptr<SceSaveDataDialogSlotConfigParam> slotConfParam;
+	le_t<u32> flag;
+	vm::lptr<void> userdata;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogFinishParam
+{
+	le_t<u32> flag;
+	char reserved[32];
+};
+
+struct SceSaveDataDialogSlotInfo
+{
+	le_t<u32> isExist;
+	vm::lptr<SceAppUtilSaveDataSlotParam> slotParam;
+	u8 reserved[32];
+};
+
+struct SceSaveDataDialogResult
+{
+	le_t<s32> mode;
+	le_t<s32> result;
+	le_t<s32> buttonId;
+	le_t<u32> slotId;
+	vm::lptr<SceSaveDataDialogSlotInfo> slotInfo;
+	vm::lptr<void> userdata;
+	char reserved[32];
+};
+
+
+struct SceImeDialogParam
+{
+	le_t<u32> sdkVersion;
+	le_t<u32> inputMethod;
+	le_t<u64> supportedLanguages;
+	le_t<s32> languagesForced;
+	le_t<u32> type;
+	le_t<u32> option;
+	vm::lptr<SceImeCharFilter> filter;
+	le_t<u32> dialogMode;
+	le_t<u32> textBoxMode;
+	vm::lptr<const u16> title;
+	le_t<u32> maxTextLength;
+	vm::lptr<u16> initialText;
+	vm::lptr<u16> inputTextBuffer;
+	char reserved[32];
+};
+
+struct SceImeDialogResult
+{
+	le_t<s32> result;
+	char reserved[32];
+};
+
+enum ScePhotoImportDialogFormatType : s32
+{
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_UNKNOWN = 0,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_JPEG,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_PNG,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_GIF,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_BMP,
+	SCE_PHOTOIMPORT_DIALOG_FORMAT_TYPE_TIFF
+};
+
+enum ScePhotoImportDialogOrientation : s32
+{
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_UNKNOWN = 0,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_LEFT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_TOP_RIGHT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_RIGHT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_BOTTOM_LEFT,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_TOP,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_TOP,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_RIGHT_BOTTOM,
+	SCE_PHOTOIMPORT_DIALOG_ORIENTATION_LEFT_BOTTOM,
+};
+
+struct ScePhotoImportDialogFileDataSub
+{
+	le_t<u32> width;
+	le_t<u32> height;
+	ScePhotoImportDialogFormatType format;
+	ScePhotoImportDialogOrientation orientation;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogFileData
+{
+	char fileName[1024];
+	char photoTitle[256];
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogItemData
+{
+	ScePhotoImportDialogFileData fileData;
+	ScePhotoImportDialogFileDataSub dataSub;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogResult
+{
+	le_t<s32> result;
+	le_t<u32> importedItemNum;
+	char reserved[32];
+};
+
+struct ScePhotoImportDialogParam
+{
+	le_t<u32> sdkVersion;
+	le_t<s32> mode;
+	le_t<u32> visibleCategory;
+	le_t<u32> itemCount;
+	vm::lptr<ScePhotoImportDialogItemData> itemData;
+	char reserved[32];
+};
+
+struct ScePhotoReviewDialogParam
+{
+	le_t<u32> sdkVersion;
+	le_t<s32> mode;
+	char fileName[1024];
+	vm::lptr<void> workMemory;
+	le_t<u32> workMemorySize;
+	char reserved[32];
+};
+
+struct ScePhotoReviewDialogResult
+{
+	le_t<s32> result;
+	char reserved[32];
+};
+
+extern psv_log_base sceCommonDialog;

rpcs3/Emu/ARMv7/Modules/sceCtrl.cpp

@@ -2,60 +2,39 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceCtrl;
+#include "sceCtrl.h"
-
-struct SceCtrlData
-{
-	u64 timeStamp;
-	u32 buttons;
-	u8 lx;
-	u8 ly;
-	u8 rx;
-	u8 ry;
-	u8 rsrv[16];
-};
-
-struct SceCtrlRapidFireRule
-{
-	u32 uiMask;
-	u32 uiTrigger;
-	u32 uiTarget;
-	u32 uiDelay;
-	u32 uiMake;
-	u32 uiBreak;
-};
 
 s32 sceCtrlSetSamplingMode(u32 uiMode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlGetSamplingMode(vm::psv::ptr<u32> puiMode)
+s32 sceCtrlGetSamplingMode(vm::ptr<u32> puiMode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlPeekBufferPositive(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
+s32 sceCtrlPeekBufferPositive(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlPeekBufferNegative(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
+s32 sceCtrlPeekBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlReadBufferPositive(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
+s32 sceCtrlReadBufferPositive(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlReadBufferNegative(s32 port, vm::psv::ptr<SceCtrlData> pData, s32 nBufs)
+s32 sceCtrlReadBufferNegative(s32 port, vm::ptr<SceCtrlData> pData, s32 nBufs)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::psv::ptr<const SceCtrlRapidFireRule> pRule)
+s32 sceCtrlSetRapidFire(s32 port, s32 idx, vm::ptr<const SceCtrlRapidFireRule> pRule)
 {
 	throw __FUNCTION__;
 }
@@ -73,6 +52,7 @@ psv_log_base sceCtrl("SceCtrl", []()
 	sceCtrl.on_load = nullptr;
 	sceCtrl.on_unload = nullptr;
 	sceCtrl.on_stop = nullptr;
+	sceCtrl.on_error = nullptr;
 
 	REG_FUNC(0xA497B150, sceCtrlSetSamplingMode);
 	REG_FUNC(0xEC752AAF, sceCtrlGetSamplingMode);

rpcs3/Emu/ARMv7/Modules/sceCtrl.h

@@ -0,0 +1,24 @@
+#pragma once
+
+struct SceCtrlData
+{
+	le_t<u64> timeStamp;
+	le_t<u32> buttons;
+	u8 lx;
+	u8 ly;
+	u8 rx;
+	u8 ry;
+	u8 reserved[16];
+};
+
+struct SceCtrlRapidFireRule
+{
+	le_t<u32> uiMask;
+	le_t<u32> uiTrigger;
+	le_t<u32> uiTarget;
+	le_t<u32> uiDelay;
+	le_t<u32> uiMake;
+	le_t<u32> uiBreak;
+};
+
+extern psv_log_base sceCtrl;

rpcs3/Emu/ARMv7/Modules/sceDbg.cpp

@@ -2,13 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceDbg;
+#include "sceDbg.h"
-
-enum SceDbgBreakOnErrorState : s32
-{
-	SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
-	SCE_DBG_ENABLE_BREAK_ON_ERROR
-};
 
 s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
 {
@@ -20,12 +14,12 @@ s32 sceDbgSetBreakOnErrorState(SceDbgBreakOnErrorState state)
 	throw __FUNCTION__;
 }
 
-s32 sceDbgAssertionHandler(vm::psv::ptr<const char> pFile, s32 line, bool stop, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
+s32 sceDbgAssertionHandler(vm::ptr<const char> pFile, s32 line, bool stop, vm::ptr<const char> pComponent, vm::ptr<const char> pMessage) // va_args...
 {
 	throw __FUNCTION__;
 }
 
-s32 sceDbgLoggingHandler(vm::psv::ptr<const char> pFile, s32 line, s32 severity, vm::psv::ptr<const char> pComponent, vm::psv::ptr<const char> pMessage) // va_args...
+s32 sceDbgLoggingHandler(vm::ptr<const char> pFile, s32 line, s32 severity, vm::ptr<const char> pComponent, vm::ptr<const char> pMessage) // va_args...
 {
 	throw __FUNCTION__;
 }
@@ -38,6 +32,7 @@ psv_log_base sceDbg("SceDbg", []()
 	sceDbg.on_load = nullptr;
 	sceDbg.on_unload = nullptr;
 	sceDbg.on_stop = nullptr;
+	sceDbg.on_error = nullptr;
 
 	REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
 	REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);

rpcs3/Emu/ARMv7/Modules/sceDbg.h

@@ -0,0 +1,9 @@
+#pragma once
+
+enum SceDbgBreakOnErrorState : s32
+{
+	SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
+	SCE_DBG_ENABLE_BREAK_ON_ERROR
+};
+
+extern psv_log_base sceDbg;

rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp

@@ -2,11 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceDeci4p;
+#include "sceDeci4p.h"
 
-typedef vm::psv::ptr<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon)> SceKernelDeci4pCallback;
+s32 sceKernelDeci4pOpen(vm::ptr<const char> protoname, u32 protonum, u32 bufsize)
-
-s32 sceKernelDeci4pOpen(vm::psv::ptr<const char> protoname, u32 protonum, u32 bufsize)
 {
 	throw __FUNCTION__;
 }
@@ -16,12 +14,12 @@ s32 sceKernelDeci4pClose(s32 socketid)
 	throw __FUNCTION__;
 }
 
-s32 sceKernelDeci4pRead(s32 socketid, vm::psv::ptr<void> buffer, u32 size, u32 reserved)
+s32 sceKernelDeci4pRead(s32 socketid, vm::ptr<void> buffer, u32 size, u32 reserved)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceKernelDeci4pWrite(s32 socketid, vm::psv::ptr<const void> buffer, u32 size, u32 reserved)
+s32 sceKernelDeci4pWrite(s32 socketid, vm::ptr<const void> buffer, u32 size, u32 reserved)
 {
 	throw __FUNCTION__;
 }
@@ -39,6 +37,7 @@ psv_log_base sceDeci4p("SceDeci4pUserp", []()
 	sceDeci4p.on_load = nullptr;
 	sceDeci4p.on_unload = nullptr;
 	sceDeci4p.on_stop = nullptr;
+	sceDeci4p.on_error = nullptr;
 
 	REG_FUNC(0x28578FE8, sceKernelDeci4pOpen);
 	REG_FUNC(0x63B0C50F, sceKernelDeci4pClose);

rpcs3/Emu/ARMv7/Modules/sceDeci4p.h

@@ -0,0 +1,5 @@
+#pragma once
+
+using SceKernelDeci4pCallback = func_def<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::ptr<void> pCommon)>;
+
+extern psv_log_base sceDeci4p;

rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp

@@ -2,69 +2,69 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceDeflt;
+#include "sceDeflt.h"
 
-s32 sceGzipIsValid(vm::psv::ptr<const void> pSrcGzip)
+s32 sceGzipIsValid(vm::ptr<const void> pSrcGzip)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGzipGetInfo(vm::psv::ptr<const void> pSrcGzip, vm::psv::pptr<const void> ppvExtra, vm::psv::pptr<const char> ppszName, vm::psv::pptr<const char> ppszComment, vm::psv::ptr<u16> pusCrc, vm::psv::pptr<const void> ppvData)
+s32 sceGzipGetInfo(vm::ptr<const void> pSrcGzip, vm::pptr<const void> ppvExtra, vm::pptr<const char> ppszName, vm::pptr<const char> ppszComment, vm::ptr<u16> pusCrc, vm::pptr<const void> ppvData)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const char> sceGzipGetName(vm::psv::ptr<const void> pSrcGzip)
+vm::ptr<const char> sceGzipGetName(vm::ptr<const void> pSrcGzip)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const char> sceGzipGetComment(vm::psv::ptr<const void> pSrcGzip)
+vm::ptr<const char> sceGzipGetComment(vm::ptr<const void> pSrcGzip)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const void> sceGzipGetCompressedData(vm::psv::ptr<const void> pSrcGzip)
+vm::ptr<const void> sceGzipGetCompressedData(vm::ptr<const void> pSrcGzip)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceGzipDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<u32> puiCrc32)
+s32 sceGzipDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::ptr<const void> pSrcGzip, vm::ptr<u32> puiCrc32)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceZlibIsValid(vm::psv::ptr<const void> pSrcZlib)
+s32 sceZlibIsValid(vm::ptr<const void> pSrcZlib)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceZlibGetInfo(vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u8> pbCmf, vm::psv::ptr<u8> pbFlg, vm::psv::ptr<u32> puiDictId, vm::psv::pptr<const void> ppvData)
+s32 sceZlibGetInfo(vm::ptr<const void> pSrcZlib, vm::ptr<u8> pbCmf, vm::ptr<u8> pbFlg, vm::ptr<u32> puiDictId, vm::pptr<const void> ppvData)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const void> sceZlibGetCompressedData(vm::psv::ptr<const void> pSrcZlib)
+vm::ptr<const void> sceZlibGetCompressedData(vm::ptr<const void> pSrcZlib)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceZlibDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcZlib, vm::psv::ptr<u32> puiAdler32)
+s32 sceZlibDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::ptr<const void> pSrcZlib, vm::ptr<u32> puiAdler32)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceZlibAdler32(u32 uiAdler, vm::psv::ptr<const u8> pSrc, u32 uiSize)
+u32 sceZlibAdler32(u32 uiAdler, vm::ptr<const u8> pSrc, u32 uiSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceDeflateDecompress(vm::psv::ptr<void> pDst, u32 uiBufSize, vm::psv::ptr<const void> pSrcDeflate, vm::psv::pptr<const void> ppNext)
+s32 sceDeflateDecompress(vm::ptr<void> pDst, u32 uiBufSize, vm::ptr<const void> pSrcDeflate, vm::pptr<const void> ppNext)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceZipGetInfo(vm::psv::ptr<const void> pSrc, vm::psv::pptr<const void> ppvExtra, vm::psv::ptr<u32> puiCrc, vm::psv::pptr<const void> ppvData)
+s32 sceZipGetInfo(vm::ptr<const void> pSrc, vm::pptr<const void> ppvExtra, vm::ptr<u32> puiCrc, vm::pptr<const void> ppvData)
 {
 	throw __FUNCTION__;
 }
@@ -77,6 +77,7 @@ psv_log_base sceDeflt("SceDeflt", []()
 	sceDeflt.on_load = nullptr;
 	sceDeflt.on_unload = nullptr;
 	sceDeflt.on_stop = nullptr;
+	sceDeflt.on_error = nullptr;
 
 	REG_FUNC(0xCD83A464, sceZlibAdler32);
 	REG_FUNC(0x110D5050, sceDeflateDecompress);

rpcs3/Emu/ARMv7/Modules/sceDeflt.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceDeflt;

rpcs3/Emu/ARMv7/Modules/sceDisplay.cpp

@@ -2,29 +2,19 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceDisplay;
+#include "sceDisplay.h"
 
-struct SceDisplayFrameBuf
+s32 sceDisplayGetRefreshRate(vm::ptr<float> pFps)
-{
-	u32 size;
-	vm::psv::ptr<void> base;
-	u32 pitch;
-	u32 pixelformat;
-	u32 width;
-	u32 height;
-};
-
-s32 sceDisplayGetRefreshRate(vm::psv::ptr<float> pFps)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceDisplaySetFrameBuf(vm::psv::ptr<const SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
+s32 sceDisplaySetFrameBuf(vm::ptr<const SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceDisplayGetFrameBuf(vm::psv::ptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
+s32 sceDisplayGetFrameBuf(vm::ptr<SceDisplayFrameBuf> pFrameBuf, s32 iUpdateTimingMode)
 {
 	throw __FUNCTION__;
 }
@@ -92,6 +82,7 @@ psv_log_base sceDisplay("SceDisplay", []()
 	sceDisplay.on_load = nullptr;
 	sceDisplay.on_unload = nullptr;
 	sceDisplay.on_stop = nullptr;
+	sceDisplay.on_error = nullptr;
 
 	// SceDisplayUser
 	REG_FUNC(0x7A410B64, sceDisplaySetFrameBuf);

rpcs3/Emu/ARMv7/Modules/sceDisplay.h

@@ -0,0 +1,13 @@
+#pragma once
+
+struct SceDisplayFrameBuf
+{
+	le_t<u32> size;
+	vm::lptr<void> base;
+	le_t<u32> pitch;
+	le_t<u32> pixelformat;
+	le_t<u32> width;
+	le_t<u32> height;
+};
+
+extern psv_log_base sceDisplay;

rpcs3/Emu/ARMv7/Modules/sceFiber.cpp

@@ -2,80 +2,44 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceFiber;
+#include "sceFiber.h"
 
-typedef vm::psv::ptr<void(u32 argOnInitialize, u32 argOnRun)> SceFiberEntry;
+s32 _sceFiberInitializeImpl(vm::ptr<SceFiber> fiber, vm::ptr<const char> name, vm::ptr<SceFiberEntry> entry, u32 argOnInitialize, vm::ptr<void> addrContext, u32 sizeContext, vm::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
-
-struct SceFiber
-{
-	static const uint size = 128;
-	static const uint align = 8;
-	u64 padding[size / sizeof(u64)];
-};
-
-struct SceFiberOptParam 
-{
-	static const uint size = 128;
-	static const uint align = 8;
-	u64 padding[size / sizeof(u64)];
-};
-
-struct SceFiberInfo
-{
-	static const uint size = 128;
-	static const uint align = 8;
-
-	union
-	{
-		u64 padding[size / sizeof(u64)];
-
-		struct
-		{
-			SceFiberEntry entry;
-			u32 argOnInitialize;
-			vm::psv::ptr<void> addrContext;
-			s32 sizeContext;
-			char name[32];
-		};
-	};
-};
-
-s32 _sceFiberInitializeImpl(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<const char> name, SceFiberEntry entry, u32 argOnInitialize, vm::psv::ptr<void> addrContext, u32 sizeContext, vm::psv::ptr<const SceFiberOptParam> optParam, u32 buildVersion)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberOptParamInitialize(vm::psv::ptr<SceFiberOptParam> optParam)
+s32 sceFiberOptParamInitialize(vm::ptr<SceFiberOptParam> optParam)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberFinalize(vm::psv::ptr<SceFiber> fiber)
+s32 sceFiberFinalize(vm::ptr<SceFiber> fiber)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberRun(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnReturn)
+s32 sceFiberRun(vm::ptr<SceFiber> fiber, u32 argOnRunTo, vm::ptr<u32> argOnReturn)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberSwitch(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnRun)
+s32 sceFiberSwitch(vm::ptr<SceFiber> fiber, u32 argOnRunTo, vm::ptr<u32> argOnRun)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberGetSelf(vm::psv::pptr<SceFiber> fiber)
+s32 sceFiberGetSelf(vm::pptr<SceFiber> fiber)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberReturnToThread(u32 argOnReturn, vm::psv::ptr<u32> argOnRun)
+s32 sceFiberReturnToThread(u32 argOnReturn, vm::ptr<u32> argOnRun)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiberGetInfo(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<SceFiberInfo> fiberInfo)
+s32 sceFiberGetInfo(vm::ptr<SceFiber> fiber, vm::ptr<SceFiberInfo> fiberInfo)
 {
 	throw __FUNCTION__;
 }
@@ -88,6 +52,7 @@ psv_log_base sceFiber("SceFiber", []()
 	sceFiber.on_load = nullptr;
 	sceFiber.on_unload = nullptr;
 	sceFiber.on_stop = nullptr;
+	sceFiber.on_error = nullptr;
 
 	REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
 	//REG_FUNC(0xC6A3F9BB, _sceFiberInitializeWithInternalOptionImpl);

rpcs3/Emu/ARMv7/Modules/sceFiber.h

@@ -0,0 +1,38 @@
+#pragma once
+
+using SceFiberEntry = func_def<void(u32 argOnInitialize, u32 argOnRun)>;
+
+struct SceFiber
+{
+	le_t<u64> padding[16];
+};
+
+CHECK_SIZE_ALIGN(SceFiber, 128, 8);
+
+struct SceFiberOptParam
+{
+	le_t<u64> padding[16];
+};
+
+CHECK_SIZE_ALIGN(SceFiberOptParam, 128, 8);
+
+struct SceFiberInfo
+{
+	union
+	{
+		le_t<u64> padding[16];
+
+		struct
+		{
+			vm::lptr<SceFiberEntry> entry;
+			le_t<u32> argOnInitialize;
+			vm::lptr<void> addrContext;
+			le_t<s32> sizeContext;
+			char name[32];
+		};
+	};
+};
+
+CHECK_SIZE_ALIGN(SceFiberInfo, 128, 8);
+
+extern psv_log_base sceFiber;

rpcs3/Emu/ARMv7/Modules/sceFios.cpp

@@ -2,127 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceFios;
+#include "sceFios.h"
 
-typedef s64 SceFiosOffset;
+s32 sceFiosInitialize(vm::ptr<const SceFiosParams> pParameters)
-typedef s64 SceFiosSize;
-typedef u8 SceFiosOpEvent;
-typedef s32 SceFiosHandle;
-typedef SceFiosHandle SceFiosOp;
-typedef SceFiosHandle SceFiosFH;
-typedef SceFiosHandle SceFiosDH;
-typedef s64 SceFiosTime;
-typedef s8 SceFiosPriority;
-typedef SceFiosTime SceFiosTimeInterval;
-typedef u64 SceFiosDate;
-typedef s32 SceFiosOverlayID;
-
-typedef vm::psv::ptr<s32(vm::psv::ptr<void> pContext, SceFiosOp op, SceFiosOpEvent event, s32 err)> SceFiosOpCallback;
-typedef vm::psv::ptr<s32(vm::psv::ptr<const char> fmt, va_list ap)> SceFiosVprintfCallback;
-typedef vm::psv::ptr<vm::psv::ptr<void>(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 len)> SceFiosMemcpyCallback;
-
-enum SceFiosWhence : s32
-{
-	SCE_FIOS_SEEK_SET = 0,
-	SCE_FIOS_SEEK_CUR = 1,
-	SCE_FIOS_SEEK_END = 2
-};
-
-struct SceFiosBuffer
-{
-	vm::psv::ptr<void> pPtr;
-	u32 length;
-};
-
-struct SceFiosOpAttr
-{
-	SceFiosTime deadline;
-	SceFiosOpCallback pCallback;
-	vm::psv::ptr<void> pCallbackContext;
-	s32 priority : 8;
-	u32 opflags : 24;
-	u32 userTag;
-	vm::psv::ptr<void> userPtr;
-	vm::psv::ptr<void> pReserved;
-};
-
-struct SceFiosDirEntry
-{
-	SceFiosOffset fileSize;
-	u32 statFlags;
-	u16 nameLength;
-	u16 fullPathLength;
-	u16 offsetToName;
-	u16 reserved[3];
-	char fullPath[1024];
-};
-
-struct SceFiosStat
-{
-	SceFiosOffset fileSize;
-	SceFiosDate accessDate;
-	SceFiosDate modificationDate;
-	SceFiosDate creationDate;
-	u32 statFlags;
-	u32 reserved;
-	s64 uid;
-	s64 gid;
-	s64 dev;
-	s64 ino;
-	s64 mode;
-};
-
-struct SceFiosOpenParams
-{
-	u32 openFlags;
-	u32 reserved;
-	SceFiosBuffer buffer;
-};
-
-struct SceFiosTuple
-{
-	SceFiosOffset offset;
-	SceFiosSize size;
-	char path[1024];
-};
-
-struct SceFiosParams
-{
-	u32 initialized : 1;
-	u32 paramsSize : 14;
-	u32 pathMax : 16;
-	u32 profiling;
-	SceFiosBuffer opStorage;
-	SceFiosBuffer fhStorage;
-	SceFiosBuffer dhStorage;
-	SceFiosBuffer chunkStorage;
-	SceFiosVprintfCallback pVprintf;
-	SceFiosMemcpyCallback pMemcpy;
-	s32 threadPriority[2];
-	s32 threadAffinity[2];
-};
-
-struct SceFiosOverlay
-{
-	u8 type;
-	u8 order;
-	u8 reserved[10];
-	SceFiosOverlayID id;
-	char dst[292];
-	char src[292];
-};
-
-typedef vm::psv::ptr<void()> SceFiosIOFilterCallback;
-
-struct SceFiosPsarcDearchiverContext
-{
-	u32 sizeOfContext;
-	u32 workBufferSize;
-	vm::psv::ptr<void> pWorkBuffer;
-	s32 reserved[4];
-};
-
-s32 sceFiosInitialize(vm::psv::ptr<const SceFiosParams> pParameters)
 {
 	throw __FUNCTION__;
 }
@@ -132,37 +14,37 @@ void sceFiosTerminate()
 	throw __FUNCTION__;
 }
 
-bool sceFiosIsInitialized(vm::psv::ptr<SceFiosParams> pOutParameters)
+bool sceFiosIsInitialized(vm::ptr<SceFiosParams> pOutParameters)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosUpdateParameters(vm::psv::ptr<const SceFiosParams> pParameters)
+void sceFiosUpdateParameters(vm::ptr<const SceFiosParams> pParameters)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosSetGlobalDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
+void sceFiosSetGlobalDefaultOpAttr(vm::ptr<const SceFiosOpAttr> pAttr)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosGetGlobalDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+bool sceFiosGetGlobalDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosSetThreadDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
+void sceFiosSetThreadDefaultOpAttr(vm::ptr<const SceFiosOpAttr> pAttr)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosGetThreadDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+bool sceFiosGetThreadDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosGetDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+void sceFiosGetDefaultOpAttr(vm::ptr<SceFiosOpAttr> pOutAttr)
 {
 	throw __FUNCTION__;
 }
@@ -207,587 +89,587 @@ bool sceFiosIsIdle()
 	throw __FUNCTION__;
 }
 
-u32 sceFiosGetAllFHs(vm::psv::ptr<SceFiosFH> pOutArray, u32 arraySize)
+u32 sceFiosGetAllFHs(vm::ptr<s32> pOutArray, u32 arraySize)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceFiosGetAllDHs(vm::psv::ptr<SceFiosDH> pOutArray, u32 arraySize)
+u32 sceFiosGetAllDHs(vm::ptr<s32> pOutArray, u32 arraySize)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceFiosGetAllOps(vm::psv::ptr<SceFiosOp> pOutArray, u32 arraySize)
+u32 sceFiosGetAllOps(vm::ptr<s32> pOutArray, u32 arraySize)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosIsValidHandle(SceFiosHandle h)
+bool sceFiosIsValidHandle(s32 h)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosPathcmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB)
+s32 sceFiosPathcmp(vm::ptr<const char> pA, vm::ptr<const char> pB)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosPathncmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB, u32 n)
+s32 sceFiosPathncmp(vm::ptr<const char> pA, vm::ptr<const char> pB, u32 n)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosPrintf(vm::psv::ptr<const char> pFormat) // va_args...
+s32 sceFiosPrintf(vm::ptr<const char> pFormat) // va_args...
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosVprintf(vm::psv::ptr<const char> pFormat) // va_list
+s32 sceFiosVprintf(vm::ptr<const char> pFormat) // va_list
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFileExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
+s32 sceFiosFileExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosFileExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+bool sceFiosFileExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFileGetSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosSize> pOutSize)
+s32 sceFiosFileGetSize(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<s64> pOutSize)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFileGetSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s64 sceFiosFileGetSizeSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFileDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosFileDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosFileDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosDirectoryExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
+s32 sceFiosDirectoryExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosDirectoryExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+bool sceFiosDirectoryExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosDirectoryCreate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosDirectoryCreate(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryCreateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosDirectoryCreateSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosDirectoryDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosDirectoryDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDirectoryDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosDirectoryDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosExists(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<bool> pOutExists)
+s32 sceFiosExists(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<bool> pOutExists)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+bool sceFiosExistsSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosStat(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosStatSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosDelete(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+s32 sceFiosDeleteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosResolve(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
+s32 sceFiosResolve(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosResolveSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::ptr<SceFiosTuple> pOutTuple)
+s32 sceFiosResolveSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const SceFiosTuple> pInTuple, vm::ptr<SceFiosTuple> pOutTuple)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosRename(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
+s32 sceFiosRename(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pOldPath, vm::ptr<const char> pNewPath)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosRenameSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::ptr<const char> pNewPath)
+s32 sceFiosRenameSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pOldPath, vm::ptr<const char> pNewPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFileRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s32 sceFiosFileRead(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFileReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s64 sceFiosFileReadSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFileWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s32 sceFiosFileWrite(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<const void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFileWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s64 sceFiosFileWriteSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, vm::ptr<const void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFileTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
+s32 sceFiosFileTruncate(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFileTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
+s32 sceFiosFileTruncateSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pPath, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosFHOpen(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pPath, vm::ptr<const SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pPath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosFHOpenSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pPath, vm::ptr<const SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosFHStat(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
+s32 sceFiosFHStatSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<SceFiosStat> pOutStatus)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
+s32 sceFiosFHTruncate(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
+s32 sceFiosFHTruncateSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+s32 sceFiosFHSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHSyncSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+s32 sceFiosFHSyncSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
+s32 sceFiosFHRead(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
+s64 sceFiosFHReadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
+s32 sceFiosFHWrite(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
+s64 sceFiosFHWriteSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHReadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s32 sceFiosFHReadv(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHReadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s64 sceFiosFHReadvSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHWritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s32 sceFiosFHWritev(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHWritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt)
+s64 sceFiosFHWritevSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHPread(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s32 sceFiosFHPread(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHPreadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s64 sceFiosFHPreadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHPwrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s32 sceFiosFHPwrite(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHPwriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+s64 sceFiosFHPwriteSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const void> pBuf, s64 length, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHPreadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+s32 sceFiosFHPreadv(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHPreadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+s64 sceFiosFHPreadvSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHPwritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+s32 sceFiosFHPwritev(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHPwritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+s64 sceFiosFHPwritevSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh, vm::ptr<const SceFiosBuffer> iov, s32 iovcnt, s64 offset)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosFHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+s32 sceFiosFHClose(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosFHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+s32 sceFiosFHCloseSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOffset sceFiosFHSeek(SceFiosFH fh, SceFiosOffset offset, SceFiosWhence whence)
+s64 sceFiosFHSeek(s32 fh, s64 offset, SceFiosWhence whence)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOffset sceFiosFHTell(SceFiosFH fh)
+s64 sceFiosFHTell(s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const char> sceFiosFHGetPath(SceFiosFH fh)
+vm::ptr<const char> sceFiosFHGetPath(s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosFHGetSize(SceFiosFH fh)
+s64 sceFiosFHGetSize(s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(SceFiosFH fh)
+vm::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-//SceFiosOp sceFiosDHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
+s32 sceFiosDHOpen(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::ptr<const char> pPath, SceFiosBuffer buf)
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
-//
+
-//s32 sceFiosDHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
+s32 sceFiosDHOpenSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutDH, vm::ptr<const char> pPath, SceFiosBuffer buf)
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
 
-SceFiosOp sceFiosDHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
+s32 sceFiosDHRead(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
+s32 sceFiosDHReadSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh, vm::ptr<SceFiosDirEntry> pOutEntry)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosDHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
+s32 sceFiosDHClose(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosDHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
+s32 sceFiosDHCloseSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 dh)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const char> sceFiosDHGetPath(SceFiosDH dh)
+vm::ptr<const char> sceFiosDHGetPath(s32 dh)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosOpIsDone(SceFiosOp op)
+bool sceFiosOpIsDone(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOpWait(SceFiosOp op)
+s32 sceFiosOpWait(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOpWaitUntil(SceFiosOp op, SceFiosTime deadline)
+s32 sceFiosOpWaitUntil(s32 op, s64 deadline)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosOpDelete(SceFiosOp op)
+void sceFiosOpDelete(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOpSyncWait(SceFiosOp op)
+s32 sceFiosOpSyncWait(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosOpSyncWaitForIO(SceFiosOp op)
+s64 sceFiosOpSyncWaitForIO(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOpGetError(SceFiosOp op)
+s32 sceFiosOpGetError(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosOpCancel(SceFiosOp op)
+void sceFiosOpCancel(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-bool sceFiosOpIsCancelled(SceFiosOp op)
+bool sceFiosOpIsCancelled(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(SceFiosOp op)
+vm::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const char> sceFiosOpGetPath(SceFiosOp op)
+vm::ptr<const char> sceFiosOpGetPath(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<void> sceFiosOpGetBuffer(SceFiosOp op)
+vm::ptr<void> sceFiosOpGetBuffer(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOffset sceFiosOpGetOffset(SceFiosOp op)
+s64 sceFiosOpGetOffset(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosOpGetRequestCount(SceFiosOp op)
+s64 sceFiosOpGetRequestCount(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosOpGetActualCount(SceFiosOp op)
+s64 sceFiosOpGetActualCount(s32 op)
 {
 	throw __FUNCTION__;
 }
 
-void sceFiosOpReschedule(SceFiosOp op, SceFiosTime newDeadline)
+void sceFiosOpReschedule(s32 op, s64 newDeadline)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosTime sceFiosTimeGetCurrent()
+s64 sceFiosTimeGetCurrent()
 {
 	throw __FUNCTION__;
 }
 
-s64 sceFiosTimeIntervalToNanoseconds(SceFiosTimeInterval interval)
+s64 sceFiosTimeIntervalToNanoseconds(s64 interval)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosTimeInterval sceFiosTimeIntervalFromNanoseconds(s64 ns)
+s64 sceFiosTimeIntervalFromNanoseconds(s64 ns)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosDate sceFiosDateGetCurrent()
+u64 sceFiosDateGetCurrent()
 {
 	throw __FUNCTION__;
 }
 
-SceFiosDate sceFiosDateFromComponents(vm::psv::ptr<const tm> pComponents)
+u64 sceFiosDateFromComponents(vm::ptr<const tm> pComponents)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<tm> sceFiosDateToComponents(SceFiosDate date, vm::psv::ptr<tm> pOutComponents)
+vm::ptr<tm> sceFiosDateToComponents(u64 date, vm::ptr<tm> pOutComponents)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosDate sceFiosDateFromSceDateTime(vm::psv::ptr<const SceDateTime> pSceDateTime)
+u64 sceFiosDateFromSceDateTime(vm::ptr<const SceDateTime> pSceDateTime)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<SceDateTime> sceFiosDateToSceDateTime(SceFiosDate date, vm::psv::ptr<SceDateTime> pSceDateTime)
+vm::ptr<SceDateTime> sceFiosDateToSceDateTime(u64 date, vm::ptr<SceDateTime> pSceDateTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayAdd(vm::psv::ptr<const SceFiosOverlay> pOverlay, vm::psv::ptr<SceFiosOverlayID> pOutID)
+s32 sceFiosOverlayAdd(vm::ptr<const SceFiosOverlay> pOverlay, vm::ptr<s32> pOutID)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayRemove(SceFiosOverlayID id)
+s32 sceFiosOverlayRemove(s32 id)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayGetInfo(SceFiosOverlayID id, vm::psv::ptr<SceFiosOverlay> pOutOverlay)
+s32 sceFiosOverlayGetInfo(s32 id, vm::ptr<SceFiosOverlay> pOutOverlay)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayModify(SceFiosOverlayID id, vm::psv::ptr<const SceFiosOverlay> pNewValue)
+s32 sceFiosOverlayModify(s32 id, vm::ptr<const SceFiosOverlay> pNewValue)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayGetList(vm::psv::ptr<SceFiosOverlayID> pOutIDs, u32 maxIDs, vm::psv::ptr<u32> pActualIDs)
+s32 sceFiosOverlayGetList(vm::ptr<s32> pOutIDs, u32 maxIDs, vm::ptr<u32> pActualIDs)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::psv::ptr<const char> pInPath, vm::psv::ptr<char> pOutPath, u32 maxPath)
+s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::ptr<const char> pInPath, vm::ptr<char> pOutPath, u32 maxPath)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosOp sceFiosArchiveGetMountBufferSize(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosArchiveGetMountBufferSize(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pArchivePath, vm::ptr<const SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-SceFiosSize sceFiosArchiveGetMountBufferSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+s64 sceFiosArchiveGetMountBufferSizeSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<const char> pArchivePath, vm::ptr<const SceFiosOpenParams> pOpenParams)
 {
 	throw __FUNCTION__;
 }
 
-//SceFiosOp sceFiosArchiveMount(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosArchiveMount(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pArchivePath, vm::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::ptr<const SceFiosOpenParams> pOpenParams)
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
-//
+
-//s32 sceFiosArchiveMountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosFH> pOutFH, vm::psv::ptr<const char> pArchivePath, vm::psv::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::psv::ptr<const SceFiosOpenParams> pOpenParams)
+s32 sceFiosArchiveMountSync(vm::ptr<const SceFiosOpAttr> pAttr, vm::ptr<s32> pOutFH, vm::ptr<const char> pArchivePath, vm::ptr<const char> pMountPoint, SceFiosBuffer mountBuffer, vm::ptr<const SceFiosOpenParams> pOpenParams)
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
 
-SceFiosOp sceFiosArchiveUnmount(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+s32 sceFiosArchiveUnmount(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosArchiveUnmountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+s32 sceFiosArchiveUnmountSync(vm::ptr<const SceFiosOpAttr> pAttr, s32 fh)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<char> sceFiosDebugDumpError(s32 err, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+vm::ptr<char> sceFiosDebugDumpError(s32 err, vm::ptr<char> pBuffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<char> sceFiosDebugDumpOp(SceFiosOp op, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+vm::ptr<char> sceFiosDebugDumpOp(s32 op, vm::ptr<char> pBuffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<char> sceFiosDebugDumpFH(SceFiosFH fh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+vm::ptr<char> sceFiosDebugDumpFH(s32 fh, vm::ptr<char> pBuffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<char> sceFiosDebugDumpDH(SceFiosDH dh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+vm::ptr<char> sceFiosDebugDumpDH(s32 dh, vm::ptr<char> pBuffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<char> sceFiosDebugDumpDate(SceFiosDate date, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+vm::ptr<char> sceFiosDebugDumpDate(u64 date, vm::ptr<char> pBuffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosIOFilterAdd(s32 index, SceFiosIOFilterCallback pFilterCallback, vm::psv::ptr<void> pFilterContext)
+s32 sceFiosIOFilterAdd(s32 index, vm::ptr<SceFiosIOFilterCallback> pFilterCallback, vm::ptr<void> pFilterContext)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceFiosIOFilterGetInfo(s32 index, vm::psv::ptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::psv::pptr<void> pOutFilterContext)
+s32 sceFiosIOFilterGetInfo(s32 index, vm::pptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::pptr<void> pOutFilterContext)
 {
 	throw __FUNCTION__;
 }
@@ -809,6 +691,7 @@ psv_log_base sceFios("SceFios2", []()
 	sceFios.on_load = nullptr;
 	sceFios.on_unload = nullptr;
 	sceFios.on_stop = nullptr;
+	sceFios.on_error = nullptr;
 
 	REG_FUNC(0x15857180, sceFiosArchiveGetMountBufferSize);
 	REG_FUNC(0xDF3352FC, sceFiosArchiveGetMountBufferSizeSync);

rpcs3/Emu/ARMv7/Modules/sceFios.h

@@ -0,0 +1,113 @@
+#pragma once
+
+using SceFiosOpCallback = func_def<s32(vm::ptr<void> pContext, s32 op, u8 event, s32 err)>;
+using SceFiosVprintfCallback = func_def<s32(vm::cptr<char> fmt, va_list ap)>;
+using SceFiosMemcpyCallback = func_def<vm::ptr<void>(vm::ptr<void> dst, vm::cptr<void> src, u32 len)>;
+
+enum SceFiosWhence : s32
+{
+	SCE_FIOS_SEEK_SET = 0,
+	SCE_FIOS_SEEK_CUR = 1,
+	SCE_FIOS_SEEK_END = 2,
+};
+
+struct SceFiosBuffer
+{
+	vm::lptr<void> pPtr;
+	le_t<u32> length;
+};
+
+struct SceFiosOpAttr
+{
+	le_t<s64> deadline;
+	vm::lptr<SceFiosOpCallback> pCallback;
+	vm::lptr<void> pCallbackContext;
+
+	//le_t<s32> priority : 8;
+	//le_t<u32> opflags : 24;
+	le_t<u32> params; // priority, opflags
+
+	le_t<u32> userTag;
+	vm::lptr<void> userPtr;
+	vm::lptr<void> pReserved;
+};
+
+struct SceFiosDirEntry
+{
+	le_t<s64> fileSize;
+	le_t<u32> statFlags;
+	le_t<u16> nameLength;
+	le_t<u16> fullPathLength;
+	le_t<u16> offsetToName;
+	le_t<u16> reserved[3];
+	char fullPath[1024];
+};
+
+struct SceFiosStat
+{
+	le_t<s64> fileSize;
+	le_t<u64> accessDate;
+	le_t<u64> modificationDate;
+	le_t<u64> creationDate;
+	le_t<u32> statFlags;
+	le_t<u32> reserved;
+	le_t<s64> uid;
+	le_t<s64> gid;
+	le_t<s64> dev;
+	le_t<s64> ino;
+	le_t<s64> mode;
+};
+
+struct SceFiosOpenParams
+{
+	le_t<u32> openFlags;
+	le_t<u32> reserved;
+	SceFiosBuffer buffer;
+};
+
+struct SceFiosTuple
+{
+	le_t<s64> offset;
+	le_t<s64> size;
+	char path[1024];
+};
+
+struct SceFiosParams
+{
+	//le_t<u32> initialized : 1;
+	//le_t<u32> paramsSize : 14;
+	//le_t<u32> pathMax : 16;
+	le_t<u32> params; // initialized, paramsSize, pathMax
+
+	le_t<u32> profiling;
+	SceFiosBuffer opStorage;
+	SceFiosBuffer fhStorage;
+	SceFiosBuffer dhStorage;
+	SceFiosBuffer chunkStorage;
+	vm::lptr<SceFiosVprintfCallback> pVprintf;
+	vm::lptr<SceFiosMemcpyCallback> pMemcpy;
+	le_t<s32> threadPriority[2];
+	le_t<s32> threadAffinity[2];
+};
+
+struct SceFiosOverlay
+{
+	u8 type;
+	u8 order;
+	u8 reserved[10];
+	le_t<s32> id;
+	char dst[292];
+	char src[292];
+};
+
+using SceFiosIOFilterCallback = func_def<void()>;
+
+struct SceFiosPsarcDearchiverContext
+{
+	le_t<u32> sizeOfContext;
+	le_t<u32> workBufferSize;
+	vm::lptr<void> pWorkBuffer;
+	le_t<s32> reserved[4];
+};
+
+extern psv_log_base sceFios;

rpcs3/Emu/ARMv7/Modules/sceFpu.cpp

@@ -2,7 +2,79 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceFpu;
+#include "sceFpu.h"
+
+float sceFpuSinf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuCosf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuTanf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuAtanf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuAtan2f(float y, float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuAsinf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuAcosf(float x)
+{
+	throw __FUNCTION__;
+}
+
+
+float sceFpuLogf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuLog2f(float fs)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuLog10f(float fs)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuExpf(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuExp2f(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuExp10f(float x)
+{
+	throw __FUNCTION__;
+}
+
+float sceFpuPowf(float x, float y)
+{
+	throw __FUNCTION__;
+}
+
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceFpu, #name, name)
 
@@ -11,6 +83,7 @@ psv_log_base sceFpu("SceFpu", []()
 	sceFpu.on_load = nullptr;
 	sceFpu.on_unload = nullptr;
 	sceFpu.on_stop = nullptr;
+	sceFpu.on_error = nullptr;
 
 	//REG_FUNC(0x33E1AC14, sceFpuSinf);
 	//REG_FUNC(0xDB66BA89, sceFpuCosf);

rpcs3/Emu/ARMv7/Modules/sceFpu.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceFpu;

rpcs3/Emu/ARMv7/Modules/sceGxm.h

@@ -29,15 +29,15 @@ enum
 	SCE_GXM_ERROR_DRIVER = 0x805B0017,
 };
 
-typedef void(SceGxmDisplayQueueCallback)(vm::psv::ptr<const void> callbackData);
+using SceGxmDisplayQueueCallback = func_def<void(vm::cptr<void> callbackData)>;
 
 struct SceGxmInitializeParams
 {
-	u32 flags;
+	le_t<u32> flags;
-	u32 displayQueueMaxPendingCount;
+	le_t<u32> displayQueueMaxPendingCount;
-	vm::psv::ptr<SceGxmDisplayQueueCallback> displayQueueCallback;
+	vm::lptr<SceGxmDisplayQueueCallback> displayQueueCallback;
-	u32 displayQueueCallbackDataSize;
+	le_t<u32> displayQueueCallbackDataSize;
-	s32 parameterBufferSize;
+	le_t<s32> parameterBufferSize;
 };
 
 enum SceGxmMemoryAttribFlags : u32
@@ -1002,13 +1002,13 @@ enum SceGxmColorMask : u8
 
 struct SceGxmBlendInfo
 {
-	SceGxmColorMask colorMask;
+	u8 colorMask; // SceGxmColorMask
-	SceGxmBlendFunc colorFunc : 4;
+	u8 colorFunc : 4; // SceGxmBlendFunc
-	SceGxmBlendFunc alphaFunc : 4;
+	u8 alphaFunc : 4; // SceGxmBlendFunc
-	SceGxmBlendFactor colorSrc : 4;
+	u8 colorSrc : 4; // SceGxmBlendFactor
-	SceGxmBlendFactor colorDst : 4;
+	u8 colorDst : 4; // SceGxmBlendFactor
-	SceGxmBlendFactor alphaSrc : 4;
+	u8 alphaSrc : 4; // SceGxmBlendFactor
-	SceGxmBlendFactor alphaDst : 4;
+	u8 alphaDst : 4; // SceGxmBlendFactor
 };
 
 struct SceGxmRenderTarget;
@@ -1017,63 +1017,63 @@ struct SceGxmSyncObject;
 
 struct SceGxmVertexAttribute
 {
-	u16 streamIndex;
+	le_t<u16> streamIndex;
-	u16 offset;
+	le_t<u16> offset;
-	SceGxmAttributeFormat format;
+	u8 format; // SceGxmAttributeFormat
 	u8 componentCount;
-	u16 regIndex;
+	le_t<u16> regIndex;
 };
 
 struct SceGxmVertexStream
 {
-	u16 stride;
+	le_t<u16> stride;
-	u16 indexSource;
+	le_t<u16> indexSource;
 };
 
 struct SceGxmTexture
 {
-	u32 controlWords[4];
+	le_t<u32> controlWords[4];
 };
 
 struct SceGxmColorSurface
 {
-	u32 pbeSidebandWord;
+	le_t<u32> pbeSidebandWord;
-	u32 pbeEmitWords[6];
+	le_t<u32> pbeEmitWords[6];
-	u32 outputRegisterSize;
+	le_t<u32> outputRegisterSize;
 	SceGxmTexture backgroundTex;
 };
 
 struct SceGxmDepthStencilSurface
 {
-	u32 zlsControl;
+	le_t<u32> zlsControl;
-	vm::psv::ptr<void> depthData;
+	vm::lptr<void> depthData;
-	vm::psv::ptr<void> stencilData;
+	vm::lptr<void> stencilData;
-	float backgroundDepth;
+	le_t<float> backgroundDepth;
-	u32 backgroundControl;
+	le_t<u32> backgroundControl;
 };
 
 struct SceGxmAuxiliarySurface
 {
-	SceGxmColorFormat colorFormat;
+	le_t<u32> colorFormat; // SceGxmColorFormat
-	SceGxmColorSurfaceType type;
+	le_t<u32> type; // SceGxmColorSurfaceType
-	u32 width;
+	le_t<u32> width;
-	u32 height;
+	le_t<u32> height;
-	u32 stride;
+	le_t<u32> stride;
-	vm::psv::ptr<void> data;
+	vm::lptr<void> data;
 };
 
 struct SceGxmNotification
 {
-	vm::psv::ptr<volatile u32> address;
+	vm::lptr<volatile u32> address;
-	u32 value;
+	le_t<u32> value;
 };
 
 struct SceGxmValidRegion
 {
-	u32 xMin;
+	le_t<u32> xMin;
-	u32 yMin;
+	le_t<u32> yMin;
-	u32 xMax;
+	le_t<u32> xMax;
-	u32 yMax;
+	le_t<u32> yMax;
 };
 
 struct SceGxmContext;
@@ -1089,17 +1089,17 @@ enum
 
 struct SceGxmContextParams
 {
-	vm::psv::ptr<void> hostMem;
+	vm::lptr<void> hostMem;
-	u32 hostMemSize;
+	le_t<u32> hostMemSize;
-	vm::psv::ptr<void> vdmRingBufferMem;
+	vm::lptr<void> vdmRingBufferMem;
-	u32 vdmRingBufferMemSize;
+	le_t<u32> vdmRingBufferMemSize;
-	vm::psv::ptr<void> vertexRingBufferMem;
+	vm::lptr<void> vertexRingBufferMem;
-	u32 vertexRingBufferMemSize;
+	le_t<u32> vertexRingBufferMemSize;
-	vm::psv::ptr<void> fragmentRingBufferMem;
+	vm::lptr<void> fragmentRingBufferMem;
-	u32 fragmentRingBufferMemSize;
+	le_t<u32> fragmentRingBufferMemSize;
-	vm::psv::ptr<void> fragmentUsseRingBufferMem;
+	vm::lptr<void> fragmentUsseRingBufferMem;
-	u32 fragmentUsseRingBufferMemSize;
+	le_t<u32> fragmentUsseRingBufferMemSize;
-	u32 fragmentUsseRingBufferOffset;
+	le_t<u32> fragmentUsseRingBufferOffset;
 };
 
 struct SceGxmVertexProgram;
@@ -1115,17 +1115,17 @@ enum
 
 struct SceGxmPrecomputedVertexState
 {
-	u32 data[SCE_GXM_PRECOMPUTED_VERTEX_STATE_WORD_COUNT];
+	le_t<u32> data[SCE_GXM_PRECOMPUTED_VERTEX_STATE_WORD_COUNT];
 };
 
 struct SceGxmPrecomputedFragmentState
 {
-	u32 data[SCE_GXM_PRECOMPUTED_FRAGMENT_STATE_WORD_COUNT];
+	le_t<u32> data[SCE_GXM_PRECOMPUTED_FRAGMENT_STATE_WORD_COUNT];
 };
 
 struct SceGxmPrecomputedDraw
 {
-	u32 data[SCE_GXM_PRECOMPUTED_DRAW_WORD_COUNT];
+	le_t<u32> data[SCE_GXM_PRECOMPUTED_DRAW_WORD_COUNT];
 };
 
 enum : u32
@@ -1193,34 +1193,32 @@ struct SceGxmShaderPatcher;
 
 struct SceGxmRegisteredProgram;
 
-typedef vm::psv::ptr<SceGxmRegisteredProgram> SceGxmShaderPatcherId;
+using SceGxmShaderPatcherHostAllocCallback = func_def<vm::ptr<void>(vm::ptr<void> userData, u32 size)>;
-
+using SceGxmShaderPatcherHostFreeCallback = func_def<void(vm::ptr<void> userData, vm::ptr<void> mem)>;
-typedef vm::psv::ptr<void>(SceGxmShaderPatcherHostAllocCallback)(vm::psv::ptr<void> userData, u32 size);
+using SceGxmShaderPatcherBufferAllocCallback = func_def<vm::ptr<void>(vm::ptr<void> userData, u32 size)>;
-typedef void(SceGxmShaderPatcherHostFreeCallback)(vm::psv::ptr<void> userData, vm::psv::ptr<void> mem);
+using SceGxmShaderPatcherBufferFreeCallback = func_def<void(vm::ptr<void> userData, vm::ptr<void> mem)>;
-typedef vm::psv::ptr<void>(SceGxmShaderPatcherBufferAllocCallback)(vm::psv::ptr<void> userData, u32 size);
+using SceGxmShaderPatcherUsseAllocCallback = func_def<vm::ptr<void>(vm::ptr<void> userData, u32 size, vm::ptr<u32> usseOffset)>;
-typedef void(SceGxmShaderPatcherBufferFreeCallback)(vm::psv::ptr<void> userData, vm::psv::ptr<void> mem);
+using SceGxmShaderPatcherUsseFreeCallback = func_def<void(vm::ptr<void> userData, vm::ptr<void> mem)>;
-typedef vm::psv::ptr<void>(SceGxmShaderPatcherUsseAllocCallback)(vm::psv::ptr<void> userData, u32 size, vm::psv::ptr<u32> usseOffset);
-typedef void(SceGxmShaderPatcherUsseFreeCallback)(vm::psv::ptr<void> userData, vm::psv::ptr<void> mem);
 
 struct SceGxmShaderPatcherParams
 {
-	vm::psv::ptr<void> userData;
+	vm::lptr<void> userData;
-	vm::psv::ptr<SceGxmShaderPatcherHostAllocCallback> hostAllocCallback;
+	vm::lptr<SceGxmShaderPatcherHostAllocCallback> hostAllocCallback;
-	vm::psv::ptr<SceGxmShaderPatcherHostFreeCallback> hostFreeCallback;
+	vm::lptr<SceGxmShaderPatcherHostFreeCallback> hostFreeCallback;
-	vm::psv::ptr<SceGxmShaderPatcherBufferAllocCallback> bufferAllocCallback;
+	vm::lptr<SceGxmShaderPatcherBufferAllocCallback> bufferAllocCallback;
-	vm::psv::ptr<SceGxmShaderPatcherBufferFreeCallback> bufferFreeCallback;
+	vm::lptr<SceGxmShaderPatcherBufferFreeCallback> bufferFreeCallback;
-	vm::psv::ptr<void> bufferMem;
+	vm::lptr<void> bufferMem;
-	u32 bufferMemSize;
+	le_t<u32> bufferMemSize;
-	vm::psv::ptr<SceGxmShaderPatcherUsseAllocCallback> vertexUsseAllocCallback;
+	vm::lptr<SceGxmShaderPatcherUsseAllocCallback> vertexUsseAllocCallback;
-	vm::psv::ptr<SceGxmShaderPatcherUsseFreeCallback> vertexUsseFreeCallback;
+	vm::lptr<SceGxmShaderPatcherUsseFreeCallback> vertexUsseFreeCallback;
-	vm::psv::ptr<void> vertexUsseMem;
+	vm::lptr<void> vertexUsseMem;
-	u32 vertexUsseMemSize;
+	le_t<u32> vertexUsseMemSize;
-	u32 vertexUsseOffset;
+	le_t<u32> vertexUsseOffset;
-	vm::psv::ptr<SceGxmShaderPatcherUsseAllocCallback> fragmentUsseAllocCallback;
+	vm::lptr<SceGxmShaderPatcherUsseAllocCallback> fragmentUsseAllocCallback;
-	vm::psv::ptr<SceGxmShaderPatcherUsseFreeCallback> fragmentUsseFreeCallback;
+	vm::lptr<SceGxmShaderPatcherUsseFreeCallback> fragmentUsseFreeCallback;
-	vm::psv::ptr<void> fragmentUsseMem;
+	vm::lptr<void> fragmentUsseMem;
-	u32 fragmentUsseMemSize;
+	le_t<u32> fragmentUsseMemSize;
-	u32 fragmentUsseOffset;
+	le_t<u32> fragmentUsseOffset;
 };
 
 enum SceGxmRenderTargetFlags : u32
@@ -1230,15 +1228,15 @@ enum SceGxmRenderTargetFlags : u32
 
 struct SceGxmRenderTargetParams
 {
-	SceGxmRenderTargetFlags flags;
+	le_t<u32> flags; // SceGxmRenderTargetFlags
-	u16 width;
+	le_t<u16> width;
-	u16 height;
+	le_t<u16> height;
-	u16 scenesPerFrame;
+	le_t<u16> scenesPerFrame;
-	SceGxmMultisampleMode multisampleMode;
+	le_t<u16> multisampleMode; // SceGxmMultisampleMode
-	u32 multisampleLocations;
+	le_t<u32> multisampleLocations;
-	vm::psv::ptr<void> hostMem;
+	vm::lptr<void> hostMem;
-	u32 hostMemSize;
+	le_t<u32> hostMemSize;
-	s32 driverMemBlock;
+	le_t<s32> driverMemBlock;
 };
 
 extern psv_log_base sceGxm;

rpcs3/Emu/ARMv7/Modules/sceHttp.cpp

@@ -2,80 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceSsl.h"
+#include "sceHttp.h"
-
-extern psv_log_base sceHttp;
-
-enum SceHttpHttpVersion : s32
-{
-	SCE_HTTP_VERSION_1_0 = 1,
-	SCE_HTTP_VERSION_1_1
-};
-
-enum SceHttpProxyMode : s32
-{
-	SCE_HTTP_PROXY_AUTO,
-	SCE_HTTP_PROXY_MANUAL
-};
-
-enum SceHttpAddHeaderMode : s32
-{
-	SCE_HTTP_HEADER_OVERWRITE,
-	SCE_HTTP_HEADER_ADD
-};
-
-enum SceHttpAuthType : s32
-{
-	SCE_HTTP_AUTH_BASIC,
-	SCE_HTTP_AUTH_DIGEST,
-	SCE_HTTP_AUTH_RESERVED0,
-	SCE_HTTP_AUTH_RESERVED1,
-	SCE_HTTP_AUTH_RESERVED2
-};
-
-typedef vm::psv::ptr<s32(s32 request, SceHttpAuthType authType, vm::psv::ptr<const char> realm, vm::psv::ptr<char> username, vm::psv::ptr<char> password, s32 needEntity, vm::psv::pptr<u8> entityBody, vm::psv::ptr<u32> entitySize, vm::psv::ptr<s32> save, vm::psv::ptr<void> userArg)> SceHttpAuthInfoCallback;
-
-typedef vm::psv::ptr<s32(s32 request, s32 statusCode, vm::psv::ptr<s32> method, vm::psv::ptr<const char> location, vm::psv::ptr<void> userArg)> SceHttpRedirectCallback;
-
-struct SceHttpMemoryPoolStats
-{
-	u32 poolSize;
-	u32 maxInuseSize;
-	u32 currentInuseSize;
-	s32 reserved;
-};
-
-struct SceHttpUriElement
-{
-	s32 opaque;
-	vm::psv::ptr<char> scheme;
-	vm::psv::ptr<char> username;
-	vm::psv::ptr<char> password;
-	vm::psv::ptr<char> hostname;
-	vm::psv::ptr<char> path;
-	vm::psv::ptr<char> query;
-	vm::psv::ptr<char> fragment;
-	u16 port;
-	u8 reserved[10];
-};
-
-typedef vm::psv::ptr<s32(s32 request, vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookieHeader, u32 headerLen, vm::psv::ptr<void> userArg)> SceHttpCookieRecvCallback;
-
-typedef vm::psv::ptr<s32(s32 request, vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookieHeader, vm::psv::ptr<void> userArg)> SceHttpCookieSendCallback;
-
-struct SceHttpsData
-{
-	vm::psv::ptr<char> ptr;
-	u32 size;
-};
-
-struct SceHttpsCaList
-{
-	vm::psv::lpptr<SceSslCert> caCerts;
-	s32 caNum;
-};
-
-typedef vm::psv::ptr<s32(u32 verifyEsrr, vm::psv::ptr<const vm::psv::ptr<SceSslCert>> sslCert, s32 certNum, vm::psv::ptr<void> userArg)> SceHttpsCallback;
 
 s32 sceHttpInit(u32 poolSize)
 {
@@ -87,12 +14,12 @@ s32 sceHttpTerm()
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetMemoryPoolStats(vm::psv::ptr<SceHttpMemoryPoolStats> currentStat)
+s32 sceHttpGetMemoryPoolStats(vm::ptr<SceHttpMemoryPoolStats> currentStat)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateTemplate(vm::psv::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
+s32 sceHttpCreateTemplate(vm::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
 {
 	throw __FUNCTION__;
 }
@@ -102,12 +29,12 @@ s32 sceHttpDeleteTemplate(s32 tmplId)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateConnection(s32 tmplId, vm::psv::ptr<const char> serverName, vm::psv::ptr<const char> scheme, u16 port, s32 enableKeepalive)
+s32 sceHttpCreateConnection(s32 tmplId, vm::ptr<const char> serverName, vm::ptr<const char> scheme, u16 port, s32 enableKeepalive)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::psv::ptr<const char> url, s32 enableKeepalive)
+s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::ptr<const char> url, s32 enableKeepalive)
 {
 	throw __FUNCTION__;
 }
@@ -117,12 +44,12 @@ s32 sceHttpDeleteConnection(s32 connId)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateRequest(s32 connId, s32 method, vm::psv::ptr<const char> path, u64 contentLength)
+s32 sceHttpCreateRequest(s32 connId, s32 method, vm::ptr<const char> path, u64 contentLength)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::psv::ptr<const char> url, u64 contentLength)
+s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::ptr<const char> url, u64 contentLength)
 {
 	throw __FUNCTION__;
 }
@@ -147,7 +74,7 @@ s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpSendRequest(s32 reqId, vm::psv::ptr<const void> postData, u32 size)
+s32 sceHttpSendRequest(s32 reqId, vm::ptr<const void> postData, u32 size)
 {
 	throw __FUNCTION__;
 }
@@ -157,47 +84,47 @@ s32 sceHttpAbortRequest(s32 reqId)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetResponseContentLength(s32 reqId, vm::psv::ptr<u64> contentLength)
+s32 sceHttpGetResponseContentLength(s32 reqId, vm::ptr<u64> contentLength)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetStatusCode(s32 reqId, vm::psv::ptr<s32> statusCode)
+s32 sceHttpGetStatusCode(s32 reqId, vm::ptr<s32> statusCode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::psv::pptr<char> header, vm::psv::ptr<u32> headerSize)
+s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::pptr<char> header, vm::ptr<u32> headerSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpReadData(s32 reqId, vm::psv::ptr<void> data, u32 size)
+s32 sceHttpReadData(s32 reqId, vm::ptr<void> data, u32 size)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpAddRequestHeader(s32 id, vm::psv::ptr<const char> name, vm::psv::ptr<const char> value, u32 mode)
+s32 sceHttpAddRequestHeader(s32 id, vm::ptr<const char> name, vm::ptr<const char> value, u32 mode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpRemoveRequestHeader(s32 id, vm::psv::ptr<const char> name)
+s32 sceHttpRemoveRequestHeader(s32 id, vm::ptr<const char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpParseResponseHeader(vm::psv::ptr<const char> header, u32 headerLen, vm::psv::ptr<const char> fieldStr, vm::psv::pptr<const char> fieldValue, vm::psv::ptr<u32> valueLen)
+s32 sceHttpParseResponseHeader(vm::ptr<const char> header, u32 headerLen, vm::ptr<const char> fieldStr, vm::pptr<const char> fieldValue, vm::ptr<u32> valueLen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpParseStatusLine(vm::psv::ptr<const char> statusLine, u32 lineLen, vm::psv::ptr<s32> httpMajorVer, vm::psv::ptr<s32> httpMinorVer, vm::psv::ptr<s32> responseCode, vm::psv::pptr<const char> reasonPhrase, vm::psv::ptr<u32> phraseLen)
+s32 sceHttpParseStatusLine(vm::ptr<const char> statusLine, u32 lineLen, vm::ptr<s32> httpMajorVer, vm::ptr<s32> httpMinorVer, vm::ptr<s32> responseCode, vm::pptr<const char> reasonPhrase, vm::ptr<u32> phraseLen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpSetAuthInfoCallback(s32 id, SceHttpAuthInfoCallback cbfunc, vm::psv::ptr<void> userArg)
+s32 sceHttpSetAuthInfoCallback(s32 id, vm::ptr<SceHttpAuthInfoCallback> cbfunc, vm::ptr<void> userArg)
 {
 	throw __FUNCTION__;
 }
@@ -207,12 +134,12 @@ s32 sceHttpSetAuthEnabled(s32 id, s32 enable)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetAuthEnabled(s32 id, vm::psv::ptr<s32> enable)
+s32 sceHttpGetAuthEnabled(s32 id, vm::ptr<s32> enable)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpSetRedirectCallback(s32 id, SceHttpRedirectCallback cbfunc, vm::psv::ptr<void> userArg)
+s32 sceHttpSetRedirectCallback(s32 id, vm::ptr<SceHttpRedirectCallback> cbfunc, vm::ptr<void> userArg)
 {
 	throw __FUNCTION__;
 }
@@ -222,7 +149,7 @@ s32 sceHttpSetAutoRedirect(s32 id, s32 enable)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetAutoRedirect(s32 id, vm::psv::ptr<s32> enable)
+s32 sceHttpGetAutoRedirect(s32 id, vm::ptr<s32> enable)
 {
 	throw __FUNCTION__;
 }
@@ -252,32 +179,32 @@ s32 sceHttpSetRecvTimeOut(s32 id, u32 usec)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriEscape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const char> in)
+s32 sceHttpUriEscape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const char> in)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriUnescape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const char> in)
+s32 sceHttpUriUnescape(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const char> in)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriParse(vm::psv::ptr<SceHttpUriElement> out, vm::psv::ptr<const char> srcUrl, vm::psv::ptr<void> pool, vm::psv::ptr<u32> require, u32 prepare)
+s32 sceHttpUriParse(vm::ptr<SceHttpUriElement> out, vm::ptr<const char> srcUrl, vm::ptr<void> pool, vm::ptr<u32> require, u32 prepare)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriBuild(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::ptr<const SceHttpUriElement> srcElement, u32 option)
+s32 sceHttpUriBuild(vm::ptr<char> out, vm::ptr<u32> require, u32 prepare, vm::ptr<const SceHttpUriElement> srcElement, u32 option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriMerge(vm::psv::ptr<char> mergedUrl, vm::psv::ptr<const char> url, vm::psv::ptr<const char> relativeUrl, vm::psv::ptr<u32> require, u32 prepare, u32 option)
+s32 sceHttpUriMerge(vm::ptr<char> mergedUrl, vm::ptr<const char> url, vm::ptr<const char> relativeUrl, vm::ptr<u32> require, u32 prepare, u32 option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpUriSweepPath(vm::psv::ptr<char> dst, vm::psv::ptr<const char> src, u32 srcSize)
+s32 sceHttpUriSweepPath(vm::ptr<char> dst, vm::ptr<const char> src, u32 srcSize)
 {
 	throw __FUNCTION__;
 }
@@ -287,32 +214,32 @@ s32 sceHttpSetCookieEnabled(s32 id, s32 enable)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetCookieEnabled(s32 id, vm::psv::ptr<s32> enable)
+s32 sceHttpGetCookieEnabled(s32 id, vm::ptr<s32> enable)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpGetCookie(vm::psv::ptr<const char> url, vm::psv::ptr<char> cookie, vm::psv::ptr<u32> cookieLength, u32 prepare, s32 secure)
+s32 sceHttpGetCookie(vm::ptr<const char> url, vm::ptr<char> cookie, vm::ptr<u32> cookieLength, u32 prepare, s32 secure)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpAddCookie(vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookie, u32 cookieLength)
+s32 sceHttpAddCookie(vm::ptr<const char> url, vm::ptr<const char> cookie, u32 cookieLength)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpSetCookieRecvCallback(s32 id, SceHttpCookieRecvCallback cbfunc, vm::psv::ptr<void> userArg)
+s32 sceHttpSetCookieRecvCallback(s32 id, vm::ptr<SceHttpCookieRecvCallback> cbfunc, vm::ptr<void> userArg)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpSetCookieSendCallback(s32 id, SceHttpCookieSendCallback cbfunc, vm::psv::ptr<void> userArg)
+s32 sceHttpSetCookieSendCallback(s32 id, vm::ptr<SceHttpCookieSendCallback> cbfunc, vm::ptr<void> userArg)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpsLoadCert(s32 caCertNum, vm::psv::pptr<const SceHttpsData> caList, vm::psv::ptr<const SceHttpsData> cert, vm::psv::ptr<const SceHttpsData> privKey)
+s32 sceHttpsLoadCert(s32 caCertNum, vm::pptr<const SceHttpsData> caList, vm::ptr<const SceHttpsData> cert, vm::ptr<const SceHttpsData> privKey)
 {
 	throw __FUNCTION__;
 }
@@ -332,22 +259,22 @@ s32 sceHttpsDisableOption(u32 sslFlags)
 	throw __FUNCTION__;
 }
 
-s32 sceHttpsGetSslError(s32 id, vm::psv::ptr<s32> errNum, vm::psv::ptr<u32> detail)
+s32 sceHttpsGetSslError(s32 id, vm::ptr<s32> errNum, vm::ptr<u32> detail)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpsSetSslCallback(s32 id, SceHttpsCallback cbfunc, vm::psv::ptr<void> userArg)
+s32 sceHttpsSetSslCallback(s32 id, vm::ptr<SceHttpsCallback> cbfunc, vm::ptr<void> userArg)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpsGetCaList(vm::psv::ptr<SceHttpsCaList> caList)
+s32 sceHttpsGetCaList(vm::ptr<SceHttpsCaList> caList)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceHttpsFreeCaList(vm::psv::ptr<SceHttpsCaList> caList)
+s32 sceHttpsFreeCaList(vm::ptr<SceHttpsCaList> caList)
 {
 	throw __FUNCTION__;
 }
@@ -360,6 +287,7 @@ psv_log_base sceHttp("SceHttp", []()
 	sceHttp.on_load = nullptr;
 	sceHttp.on_unload = nullptr;
 	sceHttp.on_stop = nullptr;
+	sceHttp.on_error = nullptr;
 
 	REG_FUNC(0x214926D9, sceHttpInit);
 	REG_FUNC(0xC9076666, sceHttpTerm);

rpcs3/Emu/ARMv7/Modules/sceHttp.h

@@ -0,0 +1,74 @@
+#pragma once
+
+#include "sceSsl.h"
+
+enum SceHttpHttpVersion : s32
+{
+	SCE_HTTP_VERSION_1_0 = 1,
+	SCE_HTTP_VERSION_1_1
+};
+
+enum SceHttpProxyMode : s32
+{
+	SCE_HTTP_PROXY_AUTO,
+	SCE_HTTP_PROXY_MANUAL
+};
+
+enum SceHttpAddHeaderMode : s32
+{
+	SCE_HTTP_HEADER_OVERWRITE,
+	SCE_HTTP_HEADER_ADD
+};
+
+enum SceHttpAuthType : s32
+{
+	SCE_HTTP_AUTH_BASIC,
+	SCE_HTTP_AUTH_DIGEST,
+	SCE_HTTP_AUTH_RESERVED0,
+	SCE_HTTP_AUTH_RESERVED1,
+	SCE_HTTP_AUTH_RESERVED2
+};
+
+using SceHttpAuthInfoCallback = func_def<s32(s32 request, SceHttpAuthType authType, vm::cptr<char> realm, vm::ptr<char> username, vm::ptr<char> password, s32 needEntity, vm::pptr<u8> entityBody, vm::ptr<u32> entitySize, vm::ptr<s32> save, vm::ptr<void> userArg)>;
+using SceHttpRedirectCallback = func_def<s32(s32 request, s32 statusCode, vm::ptr<s32> method, vm::cptr<char> location, vm::ptr<void> userArg)>;
+
+struct SceHttpMemoryPoolStats
+{
+	le_t<u32> poolSize;
+	le_t<u32> maxInuseSize;
+	le_t<u32> currentInuseSize;
+	le_t<s32> reserved;
+};
+
+struct SceHttpUriElement
+{
+	le_t<s32> opaque;
+	vm::lptr<char> scheme;
+	vm::lptr<char> username;
+	vm::lptr<char> password;
+	vm::lptr<char> hostname;
+	vm::lptr<char> path;
+	vm::lptr<char> query;
+	vm::lptr<char> fragment;
+	le_t<u16> port;
+	u8 reserved[10];
+};
+
+using SceHttpCookieRecvCallback = func_def<s32(s32 request, vm::cptr<char> url, vm::cptr<char> cookieHeader, u32 headerLen, vm::ptr<void> userArg)>;
+using SceHttpCookieSendCallback = func_def<s32(s32 request, vm::cptr<char> url, vm::cptr<char> cookieHeader, vm::ptr<void> userArg)>;
+
+struct SceHttpsData
+{
+	vm::lptr<char> ptr;
+	le_t<u32> size;
+};
+
+struct SceHttpsCaList
+{
+	vm::lpptr<SceSslCert> caCerts;
+	le_t<s32> caNum;
+};
+
+using SceHttpsCallback = func_def<s32(u32 verifyEsrr, vm::cptr<vm::ptr<SceSslCert>> sslCert, s32 certNum, vm::ptr<void> userArg)>;
+
+extern psv_log_base sceHttp;

rpcs3/Emu/ARMv7/Modules/sceIme.cpp

@@ -4,7 +4,7 @@
 
 #include "sceIme.h"
 
-s32 sceImeOpen(vm::psv::ptr<SceImeParam> param)
+s32 sceImeOpen(vm::ptr<SceImeParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -14,12 +14,12 @@ s32 sceImeUpdate()
 	throw __FUNCTION__;
 }
 
-s32 sceImeSetCaret(vm::psv::ptr<const SceImeCaret> caret)
+s32 sceImeSetCaret(vm::ptr<const SceImeCaret> caret)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceImeSetPreeditGeometry(vm::psv::ptr<const SceImePreeditGeometry> preedit)
+s32 sceImeSetPreeditGeometry(vm::ptr<const SceImePreeditGeometry> preedit)
 {
 	throw __FUNCTION__;
 }
@@ -37,6 +37,7 @@ psv_log_base sceIme("SceIme", []()
 	sceIme.on_load = nullptr;
 	sceIme.on_unload = nullptr;
 	sceIme.on_stop = nullptr;
+	sceIme.on_error = nullptr;
 
 	REG_FUNC(0x0E050613, sceImeOpen);
 	REG_FUNC(0x71D6898A, sceImeUpdate);

rpcs3/Emu/ARMv7/Modules/sceIme.h

@@ -1,70 +1,70 @@
 #pragma once
 
-typedef s32(SceImeCharFilter)(u16 ch);
+using SceImeCharFilter = func_def<s32(u16 ch)>;
 
 struct SceImeRect
 {
-	u32 x;
+	le_t<u32> x;
-	u32 y;
+	le_t<u32> y;
-	u32 width;
+	le_t<u32> width;
-	u32 height;
+	le_t<u32> height;
 };
 
 struct SceImeEditText
 {
-	u32 preeditIndex;
+	le_t<u32> preeditIndex;
-	u32 preeditLength;
+	le_t<u32> preeditLength;
-	u32 caretIndex;
+	le_t<u32> caretIndex;
-	vm::psv::ptr<u16> str;
+	vm::lptr<u16> str;
 };
 
 union SceImeEventParam
 {
 	SceImeRect rect;
 	SceImeEditText text;
-	u32 caretIndex;
+	le_t<u32> caretIndex;
 };
 
 struct SceImeEvent
 {
-	u32 id;
+	le_t<u32> id;
 	SceImeEventParam param;
 };
 
 struct SceImeCaret
 {
-	u32 x;
+	le_t<u32> x;
-	u32 y;
+	le_t<u32> y;
-	u32 height;
+	le_t<u32> height;
-	u32 index;
+	le_t<u32> index;
 };
 
 struct SceImePreeditGeometry
 {
-	u32 x;
+	le_t<u32> x;
-	u32 y;
+	le_t<u32> y;
-	u32 height;
+	le_t<u32> height;
 };
 
-typedef void(SceImeEventHandler)(vm::psv::ptr<void> arg, vm::psv::ptr<const SceImeEvent> e);
+using SceImeEventHandler = func_def<void(vm::ptr<void> arg, vm::cptr<SceImeEvent> e)>;
 
 struct SceImeParam
 {
-	u32 size;
+	le_t<u32> size;
-	u32 inputMethod;
+	le_t<u32> inputMethod;
-	u64 supportedLanguages;
+	le_t<u64> supportedLanguages;
-	s32 languagesForced;
+	le_t<s32> languagesForced;
-	u32 type;
+	le_t<u32> type;
-	u32 option;
+	le_t<u32> option;
-	vm::psv::ptr<void> work;
+	vm::lptr<void> work;
-	vm::psv::ptr<void> arg;
+	vm::lptr<void> arg;
-	vm::psv::ptr<SceImeEventHandler> handler;
+	vm::lptr<SceImeEventHandler> handler;
-	vm::psv::ptr<SceImeCharFilter> filter;
+	vm::lptr<SceImeCharFilter> filter;
-	vm::psv::ptr<u32> initialText;
+	vm::lptr<u32> initialText;
-	u32 maxTextLength;
+	le_t<u32> maxTextLength;
-	vm::psv::ptr<u32> inputTextBuffer;
+	vm::lptr<u32> inputTextBuffer;
-	u32 reserved0;
+	le_t<u32> reserved0;
-	u32 reserved1;
+	le_t<u32> reserved1;
 };
 
 extern psv_log_base sceIme;

rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp

@@ -2,36 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceJpeg;
+#include "sceJpeg.h"
-
-struct SceJpegOutputInfo
-{
-	s32 colorSpace;
-	u16 imageWidth;
-	u16 imageHeight;
-	u32 outputBufferSize;
-	u32 tempBufferSize;
-	u32 coefBufferSize;
-
-	struct { u32 x, y; } pitch[4];
-};
-
-struct SceJpegSplitDecodeCtrl
-{
-	vm::psv::ptr<u8> pStreamBuffer;
-	u32 streamBufferSize;
-	vm::psv::ptr<u8> pWriteBuffer;
-	u32 writeBufferSize;
-	s32 isEndOfStream;
-	s32 decodeMode;
-
-	SceJpegOutputInfo outputInfo;
-
-	vm::psv::ptr<void> pOutputBuffer;
-	vm::psv::ptr<void> pCoefBuffer;
-
-	u32 internalData[3];
-};
 
 s32 sceJpegInitMJpeg(s32 maxSplitDecoder)
 {
@@ -44,34 +15,34 @@ s32 sceJpegFinishMJpeg()
 }
 
 s32 sceJpegDecodeMJpeg(
-	vm::psv::ptr<const u8> pJpeg,
+	vm::ptr<const u8> pJpeg,
 	u32 isize,
-	vm::psv::ptr<void> pRGBA,
+	vm::ptr<void> pRGBA,
 	u32 osize,
 	s32 decodeMode,
-	vm::psv::ptr<void> pTempBuffer,
+	vm::ptr<void> pTempBuffer,
 	u32 tempBufferSize,
-	vm::psv::ptr<void> pCoefBuffer,
+	vm::ptr<void> pCoefBuffer,
 	u32 coefBufferSize)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceJpegDecodeMJpegYCbCr(
-	vm::psv::ptr<const u8> pJpeg,
+	vm::ptr<const u8> pJpeg,
 	u32 isize,
-	vm::psv::ptr<u8> pYCbCr,
+	vm::ptr<u8> pYCbCr,
 	u32 osize,
 	s32 decodeMode,
-	vm::psv::ptr<void> pCoefBuffer,
+	vm::ptr<void> pCoefBuffer,
 	u32 coefBufferSize)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceJpegMJpegCsc(
-	vm::psv::ptr<void> pRGBA,
+	vm::ptr<void> pRGBA,
-	vm::psv::ptr<const u8> pYCbCr,
+	vm::ptr<const u8> pYCbCr,
 	s32 xysize,
 	s32 iFrameWidth,
 	s32 colorOption,
@@ -81,26 +52,26 @@ s32 sceJpegMJpegCsc(
 }
 
 s32 sceJpegGetOutputInfo(
-	vm::psv::ptr<const u8> pJpeg,
+	vm::ptr<const u8> pJpeg,
 	u32 isize,
 	s32 outputFormat,
 	s32 decodeMode,
-	vm::psv::ptr<SceJpegOutputInfo> pOutputInfo)
+	vm::ptr<SceJpegOutputInfo> pOutputInfo)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceJpegCreateSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
+s32 sceJpegCreateSplitDecoder(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceJpegDeleteSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
+s32 sceJpegDeleteSplitDecoder(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceJpegSplitDecodeMJpeg(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
+s32 sceJpegSplitDecodeMJpeg(vm::ptr<SceJpegSplitDecodeCtrl> pCtrl)
 {
 	throw __FUNCTION__;
 }
@@ -113,6 +84,7 @@ psv_log_base sceJpeg("SceJpeg", []()
 	sceJpeg.on_load = nullptr;
 	sceJpeg.on_unload = nullptr;
 	sceJpeg.on_stop = nullptr;
+	sceJpeg.on_error = nullptr;
 
 	REG_FUNC(0xB030773B, sceJpegInitMJpeg);
 	REG_FUNC(0x62842598, sceJpegFinishMJpeg);

rpcs3/Emu/ARMv7/Modules/sceJpeg.h

@@ -0,0 +1,38 @@
+#pragma once
+
+struct SceJpegOutputInfo
+{
+	le_t<s32> colorSpace;
+	le_t<u16> imageWidth;
+	le_t<u16> imageHeight;
+	le_t<u32> outputBufferSize;
+	le_t<u32> tempBufferSize;
+	le_t<u32> coefBufferSize;
+
+	struct _pitch_t
+	{
+		le_t<u32> x;
+		le_t<u32> y;
+	};
+
+	_pitch_t pitch[4];
+};
+
+struct SceJpegSplitDecodeCtrl
+{
+	vm::lptr<u8> pStreamBuffer;
+	le_t<u32> streamBufferSize;
+	vm::lptr<u8> pWriteBuffer;
+	le_t<u32> writeBufferSize;
+	le_t<s32> isEndOfStream;
+	le_t<s32> decodeMode;
+
+	SceJpegOutputInfo outputInfo;
+
+	vm::lptr<void> pOutputBuffer;
+	vm::lptr<void> pCoefBuffer;
+
+	le_t<u32> internalData[3];
+};
+
+extern psv_log_base sceJpeg;

rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp

@@ -2,9 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceJpegEnc;
+#include "sceJpegEnc.h"
-
-typedef vm::psv::ptr<void> SceJpegEncoderContext;
 
 s32 sceJpegEncoderGetContextSize()
 {
@@ -16,7 +14,7 @@ s32 sceJpegEncoderInit(
 	s32 iFrameWidth,
 	s32 iFrameHeight,
 	s32 pixelFormat,
-	vm::psv::ptr<void> pJpeg,
+	vm::ptr<void> pJpeg,
 	u32 oJpegbufSize)
 {
 	throw __FUNCTION__;
@@ -24,7 +22,7 @@ s32 sceJpegEncoderInit(
 
 s32 sceJpegEncoderEncode(
 	SceJpegEncoderContext context,
-	vm::psv::ptr<const void> pYCbCr)
+	vm::ptr<const void> pYCbCr)
 {
 	throw __FUNCTION__;
 }
@@ -58,7 +56,7 @@ s32 sceJpegEncoderSetHeaderMode(
 
 s32 sceJpegEncoderSetOutputAddr(
 	SceJpegEncoderContext context,
-	vm::psv::ptr<void> pJpeg,
+	vm::ptr<void> pJpeg,
 	u32 oJpegbufSize)
 {
 	throw __FUNCTION__;
@@ -66,8 +64,8 @@ s32 sceJpegEncoderSetOutputAddr(
 
 s32 sceJpegEncoderCsc(
 	SceJpegEncoderContext context,
-	vm::psv::ptr<void> pYCbCr,
+	vm::ptr<void> pYCbCr,
-	vm::psv::ptr<const void> pRGBA,
+	vm::ptr<const void> pRGBA,
 	s32 iFrameWidth,
 	s32 inputPixelFormat)
 {
@@ -82,6 +80,7 @@ psv_log_base sceJpegEnc("SceJpegEnc", []()
 	sceJpegEnc.on_load = nullptr;
 	sceJpegEnc.on_unload = nullptr;
 	sceJpegEnc.on_stop = nullptr;
+	sceJpegEnc.on_error = nullptr;
 
 	REG_FUNC(0x2B55844D, sceJpegEncoderGetContextSize);
 	REG_FUNC(0x88DA92B4, sceJpegEncoderInit);

rpcs3/Emu/ARMv7/Modules/sceJpegEnc.h

@@ -0,0 +1,5 @@
+#pragma once
+
+using SceJpegEncoderContext = vm::ptr<void>;
+
+extern psv_log_base sceJpegEnc;

rpcs3/Emu/ARMv7/Modules/sceLibKernel.cpp

@@ -13,8 +13,6 @@
 #include "psv_mutex.h"
 #include "psv_cond.h"
 
-#define RETURN_ERROR(code) { Emu.Pause(); sceLibKernel.Error("%s() failed: %s", __FUNCTION__, #code); return code; }
-
 s32 sceKernelAllocMemBlock(vm::ptr<const char> name, s32 type, u32 vsize, vm::ptr<SceKernelAllocMemBlockOpt> pOpt)
 {
 	throw __FUNCTION__;
@@ -68,14 +66,14 @@ s32 sceKernelStartThread(s32 threadId, u32 argSize, vm::ptr<const void> pArgBloc
 
 	if (!t)
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
+		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
 	// thread should be in DORMANT state, but it's not possible to check it correctly atm
 
 	if (t->IsAlive())
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_NOT_DORMANT);
+		return SCE_KERNEL_ERROR_NOT_DORMANT;
 	}
 
 	ARMv7Thread& thread = static_cast<ARMv7Thread&>(*t);
@@ -110,14 +108,14 @@ s32 sceKernelDeleteThread(s32 threadId)
 
 	if (!t)
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
+		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
 	// thread should be in DORMANT state, but it's not possible to check it correctly atm
 
 	if (t->IsAlive())
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_NOT_DORMANT);
+		return SCE_KERNEL_ERROR_NOT_DORMANT;
 	}
 
 	Emu.GetCPU().RemoveThread(threadId);
@@ -268,7 +266,7 @@ s32 sceKernelWaitThreadEnd(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32>
 
 	if (!t)
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
+		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
 	ARMv7Thread& thread = static_cast<ARMv7Thread&>(*t);
@@ -402,7 +400,7 @@ s32 sceKernelCreateEventFlag(vm::ptr<const char> pName, u32 attr, u32 initPatter
 		return id;
 	}
 
-	RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
+	return SCE_KERNEL_ERROR_ERROR;
 }
 
 s32 sceKernelDeleteEventFlag(s32 evfId)
@@ -466,7 +464,7 @@ s32 sceKernelCreateSema(vm::ptr<const char> pName, u32 attr, s32 initCount, s32
 		return id;
 	}
 
-	RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
+	return SCE_KERNEL_ERROR_ERROR;
 }
 
 s32 sceKernelDeleteSema(s32 semaId)
@@ -477,12 +475,12 @@ s32 sceKernelDeleteSema(s32 semaId)
 
 	if (!sema)
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
+		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
 	if (!g_psv_sema_list.remove(semaId))
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
+		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
 	return SCE_OK;
@@ -506,7 +504,7 @@ s32 sceKernelWaitSema(s32 semaId, s32 needCount, vm::ptr<u32> pTimeout)
 
 	if (!sema)
 	{
-		RETURN_ERROR(SCE_KERNEL_ERROR_INVALID_UID);
+		return SCE_KERNEL_ERROR_INVALID_UID;
 	}
 
 	sceLibKernel.Error("*** name = %s", sema->name);
@@ -550,7 +548,7 @@ s32 sceKernelCreateMutex(vm::ptr<const char> pName, u32 attr, s32 initCount, vm:
 		return id;
 	}
 
-	RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
+	return SCE_KERNEL_ERROR_ERROR;
 }
 
 s32 sceKernelDeleteMutex(s32 mutexId)
@@ -651,7 +649,7 @@ s32 sceKernelCreateCond(vm::ptr<const char> pName, u32 attr, s32 mutexId, vm::pt
 		return id;
 	}
 
-	RETURN_ERROR(SCE_KERNEL_ERROR_ERROR);
+	return SCE_KERNEL_ERROR_ERROR;
 }
 
 s32 sceKernelDeleteCond(s32 condId)
@@ -1022,6 +1020,7 @@ psv_log_base sceLibKernel("sceLibKernel", []()
 	sceLibKernel.on_load = nullptr;
 	sceLibKernel.on_unload = nullptr;
 	sceLibKernel.on_stop = nullptr;
+	//sceLibKernel.on_error = nullptr; // keep default error handler
 
 	// REG_FUNC(???, sceKernelGetEventInfo);
 

rpcs3/Emu/ARMv7/Modules/sceLibKernel.h

@@ -387,7 +387,7 @@ struct SceKernelCallbackInfo
 
 // Thread Manager definitions (events)
 
-using SceKernelThreadEventHandler = func_def<s32(s32 type, s32 threadId, s32 arg, vm::psv::ptr<void> pCommon)>;
+using SceKernelThreadEventHandler = func_def<s32(s32 type, s32 threadId, s32 arg, vm::ptr<void> pCommon)>;
 
 struct SceKernelEventInfo
 {

rpcs3/Emu/ARMv7/Modules/sceLibc.cpp

@@ -5,17 +5,15 @@
 #include "Emu/ARMv7/ARMv7Thread.h"
 #include "Emu/ARMv7/ARMv7Callback.h"
 
-extern psv_log_base sceLibc;
+#include "sceLibc.h"
 
-vm::psv::ptr<void> g_dso;
+vm::ptr<void> g_dso;
-
-typedef void(atexit_func_t)(vm::psv::ptr<void>);
 
 std::vector<std::function<void(ARMv7Context&)>> g_atexit;
 
 std::mutex g_atexit_mutex;
 
-std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g_count, u32 f_count, u32 v_count)
+std::string armv7_fmt(ARMv7Context& context, vm::cptr<char> fmt, u32 g_count, u32 f_count, u32 v_count)
 {
 	std::string result;
 
@@ -130,7 +128,7 @@ std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g
 			case 's':
 			{
 				// string
-				auto string = vm::psv::ptr<const char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
+				auto string = vm::cptr<char>::make(context.get_next_gpr_arg(g_count, f_count, v_count));
 
 				if (plus_sign || minus_sign || space_sign || number_sign || zero_padding || width || prec) break;
 
@@ -151,7 +149,7 @@ std::string armv7_fmt(ARMv7Context& context, vm::psv::ptr<const char> fmt, u32 g
 
 namespace sce_libc_func
 {
-	void __cxa_atexit(vm::psv::ptr<atexit_func_t> func, vm::psv::ptr<void> arg, vm::psv::ptr<void> dso)
+	void __cxa_atexit(vm::ptr<atexit_func_t> func, vm::ptr<void> arg, vm::ptr<void> dso)
 	{
 		sceLibc.Warning("__cxa_atexit(func=*0x%x, arg=*0x%x, dso=*0x%x)", func, arg, dso);
 		
@@ -163,7 +161,7 @@ namespace sce_libc_func
 		});
 	}
 
-	void __aeabi_atexit(vm::psv::ptr<void> arg, vm::psv::ptr<atexit_func_t> func, vm::psv::ptr<void> dso)
+	void __aeabi_atexit(vm::ptr<void> arg, vm::ptr<atexit_func_t> func, vm::ptr<void> dso)
 	{
 		sceLibc.Warning("__aeabi_atexit(arg=*0x%x, func=*0x%x, dso=*0x%x)", arg, func, dso);
 
@@ -202,7 +200,7 @@ namespace sce_libc_func
 		}
 	}
 
-	void printf(ARMv7Context& context, vm::psv::ptr<const char> fmt) // va_args...
+	void printf(ARMv7Context& context, vm::cptr<char> fmt) // va_args...
 	{
 		sceLibc.Warning("printf(fmt=*0x%x)", fmt);
 		sceLibc.Log("*** *fmt = '%s'", fmt.get_ptr());
@@ -213,7 +211,7 @@ namespace sce_libc_func
 		LOG_NOTICE(TTY, result);
 	}
 
-	void sprintf(ARMv7Context& context, vm::psv::ptr<char> str, vm::psv::ptr<const char> fmt) // va_args...
+	void sprintf(ARMv7Context& context, vm::ptr<char> str, vm::cptr<char> fmt) // va_args...
 	{
 		sceLibc.Warning("sprintf(str=*0x%x, fmt=*0x%x)", str, fmt);
 		sceLibc.Log("*** *fmt = '%s'", fmt.get_ptr());
@@ -224,28 +222,28 @@ namespace sce_libc_func
 		::memcpy(str.get_ptr(), result.c_str(), result.size() + 1);
 	}
 
-	void __cxa_set_dso_handle_main(vm::psv::ptr<void> dso)
+	void __cxa_set_dso_handle_main(vm::ptr<void> dso)
 	{
 		sceLibc.Warning("__cxa_set_dso_handle_main(dso=*0x%x)", dso);
 
 		g_dso = dso;
 	}
 
-	void memcpy(vm::psv::ptr<void> dst, vm::psv::ptr<const void> src, u32 size)
+	void memcpy(vm::ptr<void> dst, vm::cptr<void> src, u32 size)
 	{
 		sceLibc.Warning("memcpy(dst=*0x%x, src=*0x%x, size=0x%x)", dst, src, size);
 
 		::memcpy(dst.get_ptr(), src.get_ptr(), size);
 	}
 
-	void memset(vm::psv::ptr<void> dst, s32 value, u32 size)
+	void memset(vm::ptr<void> dst, s32 value, u32 size)
 	{
 		sceLibc.Warning("memset(dst=*0x%x, value=%d, size=0x%x)", dst, value, size);
 
 		::memset(dst.get_ptr(), value, size);
 	}
 
-	void _Assert(ARMv7Context& context, vm::psv::ptr<const char> text, vm::psv::ptr<const char> func)
+	void _Assert(ARMv7Context& context, vm::cptr<char> text, vm::cptr<char> func)
 	{
 		sceLibc.Error("_Assert(text=*0x%x, func=*0x%x)", text, func);
 
@@ -265,6 +263,7 @@ psv_log_base sceLibc("SceLibc", []()
 	sceLibc.on_load = nullptr;
 	sceLibc.on_unload = nullptr;
 	sceLibc.on_stop = nullptr;
+	sceLibc.on_error = nullptr;
 
 	REG_FUNC(0xE4531F85, _Assert);
 	//REG_FUNC(0xE71C5CDE, _Stoul);

rpcs3/Emu/ARMv7/Modules/sceLibc.h

@@ -0,0 +1,5 @@
+#pragma once
+
+using atexit_func_t = func_def<void(vm::ptr<void>)>;
+
+extern psv_log_base sceLibc;

rpcs3/Emu/ARMv7/Modules/sceLibm.cpp

@@ -2,7 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceLibm;
+#include "sceLibm.h"
 
 namespace sce_libm_func
 {
@@ -16,6 +16,7 @@ psv_log_base sceLibm("SceLibm", []()
 	sceLibm.on_load = nullptr;
 	sceLibm.on_unload = nullptr;
 	sceLibm.on_stop = nullptr;
+	sceLibm.on_error = nullptr;
 
 	//REG_FUNC(0xC73FE76D, _Exp);
 	//REG_FUNC(0xFF4EAE04, _FExp);

rpcs3/Emu/ARMv7/Modules/sceLibm.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceLibm;

rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.cpp

@@ -2,7 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceLibstdcxx;
+#include "sceLibstdcxx.h"
 
 namespace sce_libstdcxx_func
 {
@@ -30,6 +30,7 @@ psv_log_base sceLibstdcxx("SceLibstdcxx", []()
 	sceLibstdcxx.on_load = nullptr;
 	sceLibstdcxx.on_unload = nullptr;
 	sceLibstdcxx.on_stop = nullptr;
+	sceLibstdcxx.on_error = nullptr;
 
 	//REG_FUNC(0x52B0C625, std::bad_typeid::what() const);
 	//REG_FUNC(0x64D7D074, std::bad_typeid::_Doraise() const);

rpcs3/Emu/ARMv7/Modules/sceLibstdcxx.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceLibstdcxx;

rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp

@@ -2,9 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceLiveArea;
+#include "sceLiveArea.h"
 
-s32 sceLiveAreaResourceReplaceAll(vm::psv::ptr<const char> dirpath)
+s32 sceLiveAreaResourceReplaceAll(vm::cptr<char> dirpath)
 {
 	throw __FUNCTION__;
 }
@@ -21,6 +21,7 @@ psv_log_base sceLiveArea("SceLiveArea", []()
 	sceLiveArea.on_load = nullptr;
 	sceLiveArea.on_unload = nullptr;
 	sceLiveArea.on_stop = nullptr;
+	sceLiveArea.on_error = nullptr;
 
 	REG_FUNC(0xA4B506F9, sceLiveAreaResourceReplaceAll);
 	REG_FUNC(0x54A395FB, sceLiveAreaResourceGetStatus);

rpcs3/Emu/ARMv7/Modules/sceLiveArea.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceLiveArea;

rpcs3/Emu/ARMv7/Modules/sceLocation.cpp

@@ -2,171 +2,89 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceLocation;
+#include "sceLocation.h"
 
-typedef u8 SceLocationHandle;
+s32 sceLocationOpen(vm::ptr<u8> handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
-
-enum SceLocationLocationMethod : s32
-{
-	SCE_LOCATION_LMETHOD_NONE = 0,
-	SCE_LOCATION_LMETHOD_AGPS_AND_3G_AND_WIFI = 1,
-	SCE_LOCATION_LMETHOD_GPS_AND_WIFI = 2,
-	SCE_LOCATION_LMETHOD_WIFI = 3,
-	SCE_LOCATION_LMETHOD_3G = 4,
-	SCE_LOCATION_LMETHOD_GPS = 5
-};
-
-enum SceLocationHeadingMethod : s32
-{
-	SCE_LOCATION_HMETHOD_NONE = 0,
-	SCE_LOCATION_HMETHOD_AUTO = 1,
-	SCE_LOCATION_HMETHOD_VERTICAL = 2,
-	SCE_LOCATION_HMETHOD_HORIZONTAL = 3,
-	SCE_LOCATION_HMETHOD_CAMERA = 4
-};
-
-enum SceLocationDialogStatus : s32
-{
-	SCE_LOCATION_DIALOG_STATUS_IDLE = 0,
-	SCE_LOCATION_DIALOG_STATUS_RUNNING = 1,
-	SCE_LOCATION_DIALOG_STATUS_FINISHED = 2
-};
-
-enum SceLocationDialogResult : s32
-{
-	SCE_LOCATION_DIALOG_RESULT_NONE = 0,
-	SCE_LOCATION_DIALOG_RESULT_DISABLE = 1,
-	SCE_LOCATION_DIALOG_RESULT_ENABLE = 2
-};
-
-enum SceLocationPermissionApplicationStatus : s32
-{
-	SCE_LOCATION_PERMISSION_APPLICATION_NONE = 0,
-	SCE_LOCATION_PERMISSION_APPLICATION_INIT = 1,
-	SCE_LOCATION_PERMISSION_APPLICATION_DENY = 2,
-	SCE_LOCATION_PERMISSION_APPLICATION_ALLOW = 3
-};
-
-enum SceLocationPermissionStatus : s32
-{
-	SCE_LOCATION_PERMISSION_DENY = 0,
-	SCE_LOCATION_PERMISSION_ALLOW = 1
-};
-
-struct SceLocationLocationInfo
-{
-	double latitude;
-	double longitude;
-	double altitude;
-	float accuracy;
-	float reserve;
-	float direction;
-	float speed;
-	u64 timestamp;
-};
-
-struct SceLocationHeadingInfo
-{
-	float trueHeading;
-	float headingVectorX;
-	float headingVectorY;
-	float headingVectorZ;
-	float reserve;
-	float reserve2;
-	u64 timestamp;
-};
-
-typedef vm::psv::ptr<void(s32 result, SceLocationHandle handle, vm::psv::ptr<const SceLocationLocationInfo> location, vm::psv::ptr<void> userdata)> SceLocationLocationInfoCallback;
-typedef vm::psv::ptr<void(s32 result, SceLocationHandle handle, vm::psv::ptr<const SceLocationHeadingInfo> heading, vm::psv::ptr<void> userdata)> SceLocationHeadingInfoCallback;
-
-struct SceLocationPermissionInfo
-{
-	SceLocationPermissionStatus parentalstatus;
-	SceLocationPermissionStatus mainstatus;
-	SceLocationPermissionApplicationStatus applicationstatus;
-};
-
-s32 sceLocationOpen(vm::psv::ptr<SceLocationHandle> handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationClose(SceLocationHandle handle)
+s32 sceLocationClose(u8 handle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationReopen(SceLocationHandle handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
+s32 sceLocationReopen(u8 handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationGetMethod(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationMethod> lmethod, vm::psv::ptr<SceLocationHeadingMethod> hmethod)
+s32 sceLocationGetMethod(u8 handle, vm::ptr<SceLocationLocationMethod> lmethod, vm::ptr<SceLocationHeadingMethod> hmethod)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationGetLocation(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationInfo> linfo)
+s32 sceLocationGetLocation(u8 handle, vm::ptr<SceLocationLocationInfo> linfo)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationCancelGetLocation(SceLocationHandle handle)
+s32 sceLocationCancelGetLocation(u8 handle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationStartLocationCallback(SceLocationHandle handle, u32 distance, SceLocationLocationInfoCallback callback, vm::psv::ptr<void> userdata)
+s32 sceLocationStartLocationCallback(u8 handle, u32 distance, vm::ptr<SceLocationLocationInfoCallback> callback, vm::ptr<void> userdata)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationStopLocationCallback(SceLocationHandle handle)
+s32 sceLocationStopLocationCallback(u8 handle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationGetHeading(SceLocationHandle handle, vm::psv::ptr<SceLocationHeadingInfo> hinfo)
+s32 sceLocationGetHeading(u8 handle, vm::ptr<SceLocationHeadingInfo> hinfo)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationStartHeadingCallback(SceLocationHandle handle, u32 difference, SceLocationHeadingInfoCallback callback, vm::psv::ptr<void> userdata)
+s32 sceLocationStartHeadingCallback(u8 handle, u32 difference, vm::ptr<SceLocationHeadingInfoCallback> callback, vm::ptr<void> userdata)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationStopHeadingCallback(SceLocationHandle handle)
+s32 sceLocationStopHeadingCallback(u8 handle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationConfirm(SceLocationHandle handle)
+s32 sceLocationConfirm(u8 handle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationConfirmGetStatus(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogStatus> status)
+s32 sceLocationConfirmGetStatus(u8 handle, vm::ptr<SceLocationDialogStatus> status)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationConfirmGetResult(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogResult> result)
+s32 sceLocationConfirmGetResult(u8 handle, vm::ptr<SceLocationDialogResult> result)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationConfirmAbort(SceLocationHandle handle)
+s32 sceLocationConfirmAbort(u8 handle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationGetPermission(SceLocationHandle handle, vm::psv::ptr<SceLocationPermissionInfo> info)
+s32 sceLocationGetPermission(u8 handle, vm::ptr<SceLocationPermissionInfo> info)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceLocationSetGpsEmulationFile(vm::psv::ptr<char> filename)
+s32 sceLocationSetGpsEmulationFile(vm::ptr<char> filename)
 {
 	throw __FUNCTION__;
 }
@@ -179,6 +97,7 @@ psv_log_base sceLocation("SceLibLocation", []()
 	sceLocation.on_load = nullptr;
 	sceLocation.on_unload = nullptr;
 	sceLocation.on_stop = nullptr;
+	sceLocation.on_error = nullptr;
 
 	REG_FUNC(0xDD271661, sceLocationOpen);
 	REG_FUNC(0x14FE76E8, sceLocationClose);

rpcs3/Emu/ARMv7/Modules/sceLocation.h

@@ -0,0 +1,83 @@
+#pragma once
+
+enum SceLocationLocationMethod : s32
+{
+	SCE_LOCATION_LMETHOD_NONE = 0,
+	SCE_LOCATION_LMETHOD_AGPS_AND_3G_AND_WIFI = 1,
+	SCE_LOCATION_LMETHOD_GPS_AND_WIFI = 2,
+	SCE_LOCATION_LMETHOD_WIFI = 3,
+	SCE_LOCATION_LMETHOD_3G = 4,
+	SCE_LOCATION_LMETHOD_GPS = 5
+};
+
+enum SceLocationHeadingMethod : s32
+{
+	SCE_LOCATION_HMETHOD_NONE = 0,
+	SCE_LOCATION_HMETHOD_AUTO = 1,
+	SCE_LOCATION_HMETHOD_VERTICAL = 2,
+	SCE_LOCATION_HMETHOD_HORIZONTAL = 3,
+	SCE_LOCATION_HMETHOD_CAMERA = 4
+};
+
+enum SceLocationDialogStatus : s32
+{
+	SCE_LOCATION_DIALOG_STATUS_IDLE = 0,
+	SCE_LOCATION_DIALOG_STATUS_RUNNING = 1,
+	SCE_LOCATION_DIALOG_STATUS_FINISHED = 2
+};
+
+enum SceLocationDialogResult : s32
+{
+	SCE_LOCATION_DIALOG_RESULT_NONE = 0,
+	SCE_LOCATION_DIALOG_RESULT_DISABLE = 1,
+	SCE_LOCATION_DIALOG_RESULT_ENABLE = 2
+};
+
+enum SceLocationPermissionApplicationStatus : s32
+{
+	SCE_LOCATION_PERMISSION_APPLICATION_NONE = 0,
+	SCE_LOCATION_PERMISSION_APPLICATION_INIT = 1,
+	SCE_LOCATION_PERMISSION_APPLICATION_DENY = 2,
+	SCE_LOCATION_PERMISSION_APPLICATION_ALLOW = 3
+};
+
+enum SceLocationPermissionStatus : s32
+{
+	SCE_LOCATION_PERMISSION_DENY = 0,
+	SCE_LOCATION_PERMISSION_ALLOW = 1
+};
+
+struct SceLocationLocationInfo
+{
+	le_t<double> latitude;
+	le_t<double> longitude;
+	le_t<double> altitude;
+	le_t<float> accuracy;
+	le_t<float> reserve;
+	le_t<float> direction;
+	le_t<float> speed;
+	le_t<u64> timestamp;
+};
+
+struct SceLocationHeadingInfo
+{
+	le_t<float> trueHeading;
+	le_t<float> headingVectorX;
+	le_t<float> headingVectorY;
+	le_t<float> headingVectorZ;
+	le_t<float> reserve;
+	le_t<float> reserve2;
+	le_t<u64> timestamp;
+};
+
+using SceLocationLocationInfoCallback = func_def<void(s32 result, u8 handle, vm::cptr<SceLocationLocationInfo> location, vm::ptr<void> userdata)>;
+using SceLocationHeadingInfoCallback = func_def<void(s32 result, u8 handle, vm::cptr<SceLocationHeadingInfo> heading, vm::ptr<void> userdata)>;
+
+struct SceLocationPermissionInfo
+{
+	SceLocationPermissionStatus parentalstatus;
+	SceLocationPermissionStatus mainstatus;
+	SceLocationPermissionApplicationStatus applicationstatus;
+};
+
+extern psv_log_base sceLocation;

rpcs3/Emu/ARMv7/Modules/sceMd5.cpp

@@ -2,35 +2,24 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceMd5;
+#include "sceMd5.h"
 
-struct SceMd5Context
+s32 sceMd5Digest(vm::ptr<const void> plain, u32 len, vm::ptr<u8> digest)
-{
-	u32 h[4];
-	u32 pad;
-	u16 usRemains;
-	u16 usComputed;
-	u64 ullTotalLen;
-	u8 buf[64];
-	u8 result[64];
-};
-
-s32 sceMd5Digest(vm::psv::ptr<const void> plain, u32 len, vm::psv::ptr<u8> digest)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMd5BlockInit(vm::psv::ptr<SceMd5Context> pContext)
+s32 sceMd5BlockInit(vm::ptr<SceMd5Context> pContext)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMd5BlockUpdate(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<const void> plain, u32 len)
+s32 sceMd5BlockUpdate(vm::ptr<SceMd5Context> pContext, vm::ptr<const void> plain, u32 len)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMd5BlockResult(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<u8> digest)
+s32 sceMd5BlockResult(vm::ptr<SceMd5Context> pContext, vm::ptr<u8> digest)
 {
 	throw __FUNCTION__;
 }
@@ -42,6 +31,7 @@ psv_log_base sceMd5("SceMd5", []()
 	sceMd5.on_load = nullptr;
 	sceMd5.on_unload = nullptr;
 	sceMd5.on_stop = nullptr;
+	sceMd5.on_error = nullptr;
 
 	REG_FUNC(0xB845BCCB, sceMd5Digest);
 	REG_FUNC(0x4D6436F9, sceMd5BlockInit);

rpcs3/Emu/ARMv7/Modules/sceMd5.h

@@ -0,0 +1,14 @@
+#pragma once
+
+struct SceMd5Context
+{
+	le_t<u32> h[4];
+	le_t<u32> pad;
+	le_t<u16> usRemains;
+	le_t<u16> usComputed;
+	le_t<u64> ullTotalLen;
+	u8 buf[64];
+	u8 result[64];
+};
+
+extern psv_log_base sceMd5;

rpcs3/Emu/ARMv7/Modules/sceMotion.cpp

@@ -2,54 +2,27 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceMotion;
+#include "sceMotion.h"
 
-struct SceMotionState
+s32 sceMotionGetState(vm::ptr<SceMotionState> motionState)
-{
-	u32 timestamp;
-	SceFVector3 acceleration;
-	SceFVector3 angularVelocity;
-	u8 reserve1[12];
-	SceFQuaternion deviceQuat;
-	SceUMatrix4 rotationMatrix;
-	SceUMatrix4 nedMatrix;
-	u8 reserve2[4];
-	SceFVector3 basicOrientation;
-	u64 hostTimestamp;
-	u8 reserve3[40];
-};
-
-struct SceMotionSensorState
-{
-	SceFVector3 accelerometer;
-	SceFVector3 gyro;
-	u8 reserve1[12];
-	u32 timestamp;
-	u32 counter;
-	u8 reserve2[4];
-	u64 hostTimestamp;
-	u8 reserve3[8];
-};
-
-s32 sceMotionGetState(vm::psv::ptr<SceMotionState> motionState)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMotionGetSensorState(vm::psv::ptr<SceMotionSensorState> sensorState, s32 numRecords)
+s32 sceMotionGetSensorState(vm::ptr<SceMotionSensorState> sensorState, s32 numRecords)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceMotionGetBasicOrientation(vm::psv::ptr<SceFVector3> basicOrientation)
+s32 sceMotionGetBasicOrientation(vm::ptr<SceFVector3> basicOrientation)
 {
 	throw __FUNCTION__;
 }
 
-//s32 sceMotionRotateYaw(const float radians)
+s32 sceMotionRotateYaw(const float radians)
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
 
 s32 sceMotionGetTiltCorrection()
 {
@@ -71,15 +44,15 @@ s32 sceMotionSetDeadband(s32 setValue)
 	throw __FUNCTION__;
 }
 
-//s32 sceMotionSetAngleThreshold(const float angle)
+s32 sceMotionSetAngleThreshold(const float angle)
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
 
-//float sceMotionGetAngleThreshold()
+float sceMotionGetAngleThreshold()
-//{
+{
-//	throw __FUNCTION__;
+	throw __FUNCTION__;
-//}
+}
 
 s32 sceMotionReset()
 {
@@ -118,6 +91,7 @@ psv_log_base sceMotion("SceMotion", []()
 	sceMotion.on_load = nullptr;
 	sceMotion.on_unload = nullptr;
 	sceMotion.on_stop = nullptr;
+	sceMotion.on_error = nullptr;
 
 	REG_FUNC(0xBDB32767, sceMotionGetState);
 	REG_FUNC(0x47D679EA, sceMotionGetSensorState);

rpcs3/Emu/ARMv7/Modules/sceMotion.h

@@ -0,0 +1,30 @@
+#pragma once
+
+struct SceMotionState
+{
+	le_t<u32> timestamp;
+	SceFVector3 acceleration;
+	SceFVector3 angularVelocity;
+	u8 reserve1[12];
+	SceFQuaternion deviceQuat;
+	SceUMatrix4 rotationMatrix;
+	SceUMatrix4 nedMatrix;
+	u8 reserve2[4];
+	SceFVector3 basicOrientation;
+	le_t<u64> hostTimestamp;
+	u8 reserve3[40];
+};
+
+struct SceMotionSensorState
+{
+	SceFVector3 accelerometer;
+	SceFVector3 gyro;
+	u8 reserve1[12];
+	le_t<u32> timestamp;
+	le_t<u32> counter;
+	u8 reserve2[4];
+	le_t<u64> hostTimestamp;
+	u8 reserve3[8];
+};
+
+extern psv_log_base sceMotion;

rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp

@@ -2,20 +2,14 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceMt19937;
+#include "sceMt19937.h"
 
-struct SceMt19937Context
+s32 sceMt19937Init(vm::ptr<SceMt19937Context> pCtx, u32 seed)
-{
-	u32 count;
-	u32 state[624];
-};
-
-s32 sceMt19937Init(vm::psv::ptr<SceMt19937Context> pCtx, u32 seed)
 {
 	throw __FUNCTION__;
 }
 
-u32 sceMt19937UInt(vm::psv::ptr<SceMt19937Context> pCtx)
+u32 sceMt19937UInt(vm::ptr<SceMt19937Context> pCtx)
 {
 	throw __FUNCTION__;
 }
@@ -28,6 +22,7 @@ psv_log_base sceMt19937("SceMt19937", []()
 	sceMt19937.on_load = nullptr;
 	sceMt19937.on_unload = nullptr;
 	sceMt19937.on_stop = nullptr;
+	sceMt19937.on_error = nullptr;
 
 	REG_FUNC(0xEE5BA27C, sceMt19937Init);
 	REG_FUNC(0x29E43BB5, sceMt19937UInt);

rpcs3/Emu/ARMv7/Modules/sceMt19937.h

@@ -0,0 +1,9 @@
+#pragma once
+
+struct SceMt19937Context
+{
+	le_t<u32> count;
+	le_t<u32> state[624];
+};
+
+extern psv_log_base sceMt19937;

rpcs3/Emu/ARMv7/Modules/sceNet.cpp

@@ -4,7 +4,7 @@
 
 #include "sceNet.h"
 
-s32 sceNetSetDnsInfo(vm::psv::ptr<SceNetDnsInfo> info, s32 flags)
+s32 sceNetSetDnsInfo(vm::ptr<SceNetDnsInfo> info, s32 flags)
 {
 	throw __FUNCTION__;
 }
@@ -14,12 +14,12 @@ s32 sceNetClearDnsCache(s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetDumpCreate(vm::psv::ptr<const char> name, s32 len, s32 flags)
+s32 sceNetDumpCreate(vm::ptr<const char> name, s32 len, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetDumpRead(s32 id, vm::psv::ptr<void> buf, s32 len, vm::psv::ptr<s32> pflags)
+s32 sceNetDumpRead(s32 id, vm::ptr<void> buf, s32 len, vm::ptr<s32> pflags)
 {
 	throw __FUNCTION__;
 }
@@ -34,22 +34,22 @@ s32 sceNetDumpAbort(s32 id, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetEpollCreate(vm::psv::ptr<const char> name, s32 flags)
+s32 sceNetEpollCreate(vm::ptr<const char> name, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::psv::ptr<SceNetEpollEvent> event)
+s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::ptr<SceNetEpollEvent> event)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEpollWait(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
+s32 sceNetEpollWait(s32 eid, vm::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEpollWaitCB(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
+s32 sceNetEpollWaitCB(s32 eid, vm::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
 {
 	throw __FUNCTION__;
 }
@@ -64,32 +64,32 @@ s32 sceNetEpollAbort(s32 eid, s32 flags)
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<s32> sceNetErrnoLoc()
+vm::ptr<s32> sceNetErrnoLoc()
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEtherStrton(vm::psv::ptr<const char> str, vm::psv::ptr<SceNetEtherAddr> n)
+s32 sceNetEtherStrton(vm::ptr<const char> str, vm::ptr<SceNetEtherAddr> n)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEtherNtostr(vm::psv::ptr<const SceNetEtherAddr> n, vm::psv::ptr<char> str, u32 len)
+s32 sceNetEtherNtostr(vm::ptr<const SceNetEtherAddr> n, vm::ptr<char> str, u32 len)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetMacAddress(vm::psv::ptr<SceNetEtherAddr> addr, s32 flags)
+s32 sceNetGetMacAddress(vm::ptr<SceNetEtherAddr> addr, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const char> sceNetInetNtop(s32 af, vm::psv::ptr<const void> src, vm::psv::ptr<char> dst, SceNetSocklen_t size)
+vm::ptr<const char> sceNetInetNtop(s32 af, vm::ptr<const void> src, vm::ptr<char> dst, SceNetSocklen_t size)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetInetPton(s32 af, vm::psv::ptr<const char> src, vm::psv::ptr<void> dst)
+s32 sceNetInetPton(s32 af, vm::ptr<const char> src, vm::ptr<void> dst)
 {
 	throw __FUNCTION__;
 }
@@ -124,7 +124,7 @@ u16 sceNetNtohs(u16 net16)
 	throw __FUNCTION__;
 }
 
-s32 sceNetInit(vm::psv::ptr<SceNetInitParam> param)
+s32 sceNetInit(vm::ptr<SceNetInitParam> param)
 {
 	throw __FUNCTION__;
 }
@@ -149,32 +149,32 @@ s32 sceNetShowNetstat()
 	throw __FUNCTION__;
 }
 
-s32 sceNetEmulationSet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
+s32 sceNetEmulationSet(vm::ptr<SceNetEmulationParam> param, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetEmulationGet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
+s32 sceNetEmulationGet(vm::ptr<SceNetEmulationParam> param, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverCreate(vm::psv::ptr<const char> name, vm::psv::ptr<SceNetResolverParam> param, s32 flags)
+s32 sceNetResolverCreate(vm::ptr<const char> name, vm::ptr<SceNetResolverParam> param, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverStartNtoa(s32 rid, vm::psv::ptr<const char> hostname, vm::psv::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
+s32 sceNetResolverStartNtoa(s32 rid, vm::ptr<const char> hostname, vm::ptr<SceNetInAddr> addr, s32 timeout, s32 retry, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverStartAton(s32 rid, vm::psv::ptr<const SceNetInAddr> addr, vm::psv::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
+s32 sceNetResolverStartAton(s32 rid, vm::ptr<const SceNetInAddr> addr, vm::ptr<char> hostname, s32 len, s32 timeout, s32 retry, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetResolverGetError(s32 rid, vm::psv::ptr<s32> result)
+s32 sceNetResolverGetError(s32 rid, vm::ptr<s32> result)
 {
 	throw __FUNCTION__;
 }
@@ -189,37 +189,37 @@ s32 sceNetResolverAbort(s32 rid, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetSocket(vm::psv::ptr<const char> name, s32 domain, s32 type, s32 protocol)
+s32 sceNetSocket(vm::ptr<const char> name, s32 domain, s32 type, s32 protocol)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetAccept(s32 s, vm::psv::ptr<SceNetSockaddr> addr, vm::psv::ptr<SceNetSocklen_t> addrlen)
+s32 sceNetAccept(s32 s, vm::ptr<SceNetSockaddr> addr, vm::ptr<SceNetSocklen_t> addrlen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetBind(s32 s, vm::psv::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
+s32 sceNetBind(s32 s, vm::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetConnect(s32 s, vm::psv::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
+s32 sceNetConnect(s32 s, vm::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetpeername(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
+s32 sceNetGetpeername(s32 s, vm::ptr<SceNetSockaddr> name, vm::ptr<SceNetSocklen_t> namelen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetsockname(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
+s32 sceNetGetsockname(s32 s, vm::ptr<SceNetSockaddr> name, vm::ptr<SceNetSocklen_t> namelen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetsockopt(s32 s, s32 level, s32 optname, vm::psv::ptr<void> optval, vm::psv::ptr<SceNetSocklen_t> optlen)
+s32 sceNetGetsockopt(s32 s, s32 level, s32 optname, vm::ptr<void> optval, vm::ptr<SceNetSocklen_t> optlen)
 {
 	throw __FUNCTION__;
 }
@@ -229,37 +229,37 @@ s32 sceNetListen(s32 s, s32 backlog)
 	throw __FUNCTION__;
 }
 
-s32 sceNetRecv(s32 s, vm::psv::ptr<void> buf, u32 len, s32 flags)
+s32 sceNetRecv(s32 s, vm::ptr<void> buf, u32 len, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetRecvfrom(s32 s, vm::psv::ptr<void> buf, u32 len, s32 flags, vm::psv::ptr<SceNetSockaddr> from, vm::psv::ptr<SceNetSocklen_t> fromlen)
+s32 sceNetRecvfrom(s32 s, vm::ptr<void> buf, u32 len, s32 flags, vm::ptr<SceNetSockaddr> from, vm::ptr<SceNetSocklen_t> fromlen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetRecvmsg(s32 s, vm::psv::ptr<SceNetMsghdr> msg, s32 flags)
+s32 sceNetRecvmsg(s32 s, vm::ptr<SceNetMsghdr> msg, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSend(s32 s, vm::psv::ptr<const void> msg, u32 len, s32 flags)
+s32 sceNetSend(s32 s, vm::ptr<const void> msg, u32 len, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSendto(s32 s, vm::psv::ptr<const void> msg, u32 len, s32 flags, vm::psv::ptr<const SceNetSockaddr> to, SceNetSocklen_t tolen)
+s32 sceNetSendto(s32 s, vm::ptr<const void> msg, u32 len, s32 flags, vm::ptr<const SceNetSockaddr> to, SceNetSocklen_t tolen)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSendmsg(s32 s, vm::psv::ptr<const SceNetMsghdr> msg, s32 flags)
+s32 sceNetSendmsg(s32 s, vm::ptr<const SceNetMsghdr> msg, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::psv::ptr<const void> optval, SceNetSocklen_t optlen)
+s32 sceNetSetsockopt(s32 s, s32 level, s32 optname, vm::ptr<const void> optval, SceNetSocklen_t optlen)
 {
 	throw __FUNCTION__;
 }
@@ -279,17 +279,17 @@ s32 sceNetSocketAbort(s32 s, s32 flags)
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetSockInfo(s32 s, vm::psv::ptr<SceNetSockInfo> info, s32 n, s32 flags)
+s32 sceNetGetSockInfo(s32 s, vm::ptr<SceNetSockInfo> info, s32 n, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetSockIdInfo(vm::psv::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
+s32 sceNetGetSockIdInfo(vm::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetGetStatisticsInfo(vm::psv::ptr<SceNetStatisticsInfo> info, s32 flags)
+s32 sceNetGetStatisticsInfo(vm::ptr<SceNetStatisticsInfo> info, s32 flags)
 {
 	throw __FUNCTION__;
 }
@@ -302,6 +302,7 @@ psv_log_base sceNet("SceNet", []()
 	sceNet.on_load = nullptr;
 	sceNet.on_unload = nullptr;
 	sceNet.on_stop = nullptr;
+	sceNet.on_error = nullptr;
 
 	REG_FUNC(0xD62EF218, sceNetSetDnsInfo);
 	REG_FUNC(0xFEC1166D, sceNetClearDnsCache);

rpcs3/Emu/ARMv7/Modules/sceNet.h

@@ -1,22 +1,19 @@
 #pragma once
 
-typedef u32 SceNetInAddr_t;
-typedef u16 SceNetInPort_t;
-typedef u8 SceNetSaFamily_t;
 typedef u32 SceNetSocklen_t;
 
 struct SceNetInAddr
 {
-	SceNetInAddr_t s_addr;
+	le_t<u32> s_addr;
 };
 
 struct SceNetSockaddrIn
 {
 	u8 sin_len;
-	SceNetSaFamily_t sin_family;
+	u8 sin_family;
-	SceNetInPort_t sin_port;
+	le_t<u16> sin_port;
 	SceNetInAddr sin_addr;
-	SceNetInPort_t sin_vport;
+	le_t<u16> sin_vport;
 	char sin_zero[6];
 };
 
@@ -28,34 +25,34 @@ struct SceNetDnsInfo
 struct SceNetSockaddr
 {
 	u8 sa_len;
-	SceNetSaFamily_t sa_family;
+	u8 sa_family;
 	char sa_data[14];
 };
 
 struct SceNetEpollDataExt
 {
-	s32 id;
+	le_t<s32> id;
-	u32 data;
+	le_t<u32> data;
 };
 
 union SceNetEpollData
 {
-	vm::psv::ptr<void> ptr;
+	vm::lptr<void> ptr;
-	s32 fd;
+	le_t<s32> fd;
-	u32 _u32;
+	le_t<u32> _u32;
-	u64 _u64;
+	le_t<u64> _u64;
 	SceNetEpollDataExt ext;
 };
 
 struct SceNetEpollSystemData
 {
-	u32 system[4];
+	le_t<u32> system[4];
 };
 
 struct SceNetEpollEvent
 {
-	u32 events;
+	le_t<u32> events;
-	u32 reserved;
+	le_t<u32> reserved;
 	SceNetEpollSystemData system;
 	SceNetEpollData data;
 };
@@ -80,108 +77,106 @@ struct SceNetIpMreq
 
 struct SceNetInitParam
 {
-	vm::psv::ptr<void> memory;
+	vm::lptr<void> memory;
-	s32 size;
+	le_t<s32> size;
-	s32 flags;
+	le_t<s32> flags;
 };
 
 struct SceNetEmulationData
 {
-	u16 drop_rate;
+	le_t<u16> drop_rate;
-	u16 drop_duration;
+	le_t<u16> drop_duration;
-	u16 pass_duration;
+	le_t<u16> pass_duration;
-	u16 delay_time;
+	le_t<u16> delay_time;
-	u16 delay_jitter;
+	le_t<u16> delay_jitter;
-	u16 order_rate;
+	le_t<u16> order_rate;
-	u16 order_delay_time;
+	le_t<u16> order_delay_time;
-	u16 duplication_rate;
+	le_t<u16> duplication_rate;
-	u32 bps_limit;
+	le_t<u32> bps_limit;
-	u16 lower_size_limit;
+	le_t<u16> lower_size_limit;
-	u16 upper_size_limit;
+	le_t<u16> upper_size_limit;
-	u32 system_policy_pattern;
+	le_t<u32> system_policy_pattern;
-	u32 game_policy_pattern;
+	le_t<u32> game_policy_pattern;
-	u16 policy_flags[64];
+	le_t<u16> policy_flags[64];
 	u8 reserved[64];
 };
 
 struct SceNetEmulationParam
 {
-	u16 version;
+	le_t<u16> version;
-	u16 option_number;
+	le_t<u16> option_number;
-	u16 current_version;
+	le_t<u16> current_version;
-	u16 result;
+	le_t<u16> result;
-	u32 flags;
+	le_t<u32> flags;
-	u32 reserved1;
+	le_t<u32> reserved1;
 	SceNetEmulationData send;
 	SceNetEmulationData recv;
-	u32 seed;
+	le_t<u32> seed;
 	u8 reserved[44];
 };
 
-typedef vm::psv::ptr<vm::psv::ptr<void>(u32 size, s32 rid, vm::psv::ptr<const char> name, vm::psv::ptr<void> user)> SceNetResolverFunctionAllocate;
+using SceNetResolverFunctionAllocate = func_def<vm::ptr<void>(u32 size, s32 rid, vm::cptr<char> name, vm::ptr<void> user)>;
-
+using SceNetResolverFunctionFree = func_def<void(vm::ptr<void> ptr, s32 rid, vm::cptr<char> name, vm::ptr<void> user)>;
-typedef vm::psv::ptr<void(vm::psv::ptr<void> ptr, s32 rid, vm::psv::ptr<const char> name, vm::psv::ptr<void> user)> SceNetResolverFunctionFree;
 
 struct SceNetResolverParam
 {
-	SceNetResolverFunctionAllocate allocate;
+	vm::lptr<SceNetResolverFunctionAllocate> allocate;
-	SceNetResolverFunctionFree free;
+	vm::lptr<SceNetResolverFunctionFree> free;
-	vm::psv::ptr<void> user;
+	vm::lptr<void> user;
 };
 
 struct SceNetLinger
 {
-	s32 l_onoff;
+	le_t<s32> l_onoff;
-	s32 l_linger;
+	le_t<s32> l_linger;
 };
 
 struct SceNetIovec
 {
-	vm::psv::ptr<void> iov_base;
+	vm::lptr<void> iov_base;
-	u32 iov_len;
+	le_t<u32> iov_len;
 };
 
 struct SceNetMsghdr
 {
-	vm::psv::ptr<void> msg_name;
+	vm::lptr<void> msg_name;
-	SceNetSocklen_t msg_namelen;
+	le_t<u32> msg_namelen;
-	vm::psv::ptr<SceNetIovec> msg_iov;
+	vm::lptr<SceNetIovec> msg_iov;
-	s32 msg_iovlen;
+	le_t<s32> msg_iovlen;
-	vm::psv::ptr<void> msg_control;
+	vm::lptr<void> msg_control;
-	SceNetSocklen_t msg_controllen;
+	le_t<u32> msg_controllen;
-	s32 msg_flags;
+	le_t<s32> msg_flags;
 };
 
 struct SceNetSockInfo
 {
 	char name[32];
-	s32 pid;
+	le_t<s32> pid;
-	s32 s;
+	le_t<s32> s;
 	s8 socket_type;
 	s8 policy;
-	s16 reserved16;
+	le_t<s16> reserved16;
-	s32 recv_queue_length;
+	le_t<s32> recv_queue_length;
-	s32 send_queue_length;
+	le_t<s32> send_queue_length;
 	SceNetInAddr local_adr;
 	SceNetInAddr remote_adr;
-	SceNetInPort_t local_port;
+	le_t<u16> local_port;
-	SceNetInPort_t remote_port;
+	le_t<u16> remote_port;
-	SceNetInPort_t local_vport;
+	le_t<u16> local_vport;
-	SceNetInPort_t remote_vport;
+	le_t<u16> remote_vport;
-	s32 state;
+	le_t<s32> state;
-	s32 flags;
+	le_t<s32> flags;
-	s32 reserved[8];
+	le_t<s32> reserved[8];
 };
 
 struct SceNetStatisticsInfo
 {
-	s32 kernel_mem_free_size;
+	le_t<s32> kernel_mem_free_size;
-	s32 kernel_mem_free_min;
+	le_t<s32> kernel_mem_free_min;
-	s32 packet_count;
+	le_t<s32> packet_count;
-	s32 packet_qos_count;
+	le_t<s32> packet_qos_count;
-	s32 libnet_mem_free_size;
+	le_t<s32> libnet_mem_free_size;
-	s32 libnet_mem_free_min;
+	le_t<s32> libnet_mem_free_min;
 };
 
-
 extern psv_log_base sceNet;

rpcs3/Emu/ARMv7/Modules/sceNetCtl.cpp

@@ -2,51 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceNet.h"
+#include "sceNetCtl.h"
-
-extern psv_log_base sceNetCtl;
-
-union SceNetCtlInfo
-{
-	char cnf_name[65];
-	u32 device;
-	SceNetEtherAddr ether_addr;
-	u32 mtu;
-	u32 link;
-	SceNetEtherAddr bssid;
-	char ssid[33];
-	u32 wifi_security;
-	u32 rssi_dbm;
-	u32 rssi_percentage;
-	u32 channel;
-	u32 ip_config;
-	char dhcp_hostname[256];
-	char pppoe_auth_name[128];
-	char ip_address[16];
-	char netmask[16];
-	char default_route[16];
-	char primary_dns[16];
-	char secondary_dns[16];
-	u32 http_proxy_config;
-	char http_proxy_server[256];
-	u32 http_proxy_port;
-};
-
-struct SceNetCtlNatInfo
-{
-	u32 size;
-	s32 stun_status;
-	s32 nat_type;
-	SceNetInAddr mapped_addr;
-};
-
-struct SceNetCtlAdhocPeerInfo
-{
-	vm::psv::ptr<SceNetCtlAdhocPeerInfo> next;
-	SceNetInAddr inet_addr;
-};
-
-typedef vm::psv::ptr<void(s32 event_type, vm::psv::ptr<void> arg)> SceNetCtlCallback;
 
 s32 sceNetCtlInit()
 {
@@ -63,32 +19,32 @@ s32 sceNetCtlCheckCallback()
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlInetGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
+s32 sceNetCtlInetGetResult(s32 eventType, vm::ptr<s32> errorCode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlAdhocGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
+s32 sceNetCtlAdhocGetResult(s32 eventType, vm::ptr<s32> errorCode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlInetGetInfo(s32 code, vm::psv::ptr<SceNetCtlInfo> info)
+s32 sceNetCtlInetGetInfo(s32 code, vm::ptr<SceNetCtlInfo> info)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlInetGetState(vm::psv::ptr<s32> state)
+s32 sceNetCtlInetGetState(vm::ptr<s32> state)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlGetNatInfo(vm::psv::ptr<SceNetCtlNatInfo> natinfo)
+s32 sceNetCtlGetNatInfo(vm::ptr<SceNetCtlNatInfo> natinfo)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlInetRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
+s32 sceNetCtlInetRegisterCallback(vm::ptr<SceNetCtlCallback> func, vm::ptr<void> arg, vm::ptr<s32> cid)
 {
 	throw __FUNCTION__;
 }
@@ -98,7 +54,7 @@ s32 sceNetCtlInetUnregisterCallback(s32 cid)
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlAdhocRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
+s32 sceNetCtlAdhocRegisterCallback(vm::ptr<SceNetCtlCallback> func, vm::ptr<void> arg, vm::ptr<s32> cid)
 {
 	throw __FUNCTION__;
 }
@@ -108,7 +64,7 @@ s32 sceNetCtlAdhocUnregisterCallback(s32 cid)
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlAdhocGetState(vm::psv::ptr<s32> state)
+s32 sceNetCtlAdhocGetState(vm::ptr<s32> state)
 {
 	throw __FUNCTION__;
 }
@@ -118,12 +74,12 @@ s32 sceNetCtlAdhocDisconnect()
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlAdhocGetPeerList(vm::psv::ptr<u32> buflen, vm::psv::ptr<void> buf)
+s32 sceNetCtlAdhocGetPeerList(vm::ptr<u32> buflen, vm::ptr<void> buf)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNetCtlAdhocGetInAddr(vm::psv::ptr<SceNetInAddr> inaddr)
+s32 sceNetCtlAdhocGetInAddr(vm::ptr<SceNetInAddr> inaddr)
 {
 	throw __FUNCTION__;
 }
@@ -135,6 +91,7 @@ psv_log_base sceNetCtl("SceNetCtl", []()
 	sceNetCtl.on_load = nullptr;
 	sceNetCtl.on_unload = nullptr;
 	sceNetCtl.on_stop = nullptr;
+	sceNetCtl.on_error = nullptr;
 
 	REG_FUNC(0x495CA1DB, sceNetCtlInit);
 	REG_FUNC(0xCD188648, sceNetCtlTerm);

rpcs3/Emu/ARMv7/Modules/sceNetCtl.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "sceNet.h"
+
+union SceNetCtlInfo
+{
+	char cnf_name[65];
+	le_t<u32> device;
+	SceNetEtherAddr ether_addr;
+	le_t<u32> mtu;
+	le_t<u32> link;
+	SceNetEtherAddr bssid;
+	char ssid[33];
+	le_t<u32> wifi_security;
+	le_t<u32> rssi_dbm;
+	le_t<u32> rssi_percentage;
+	le_t<u32> channel;
+	le_t<u32> ip_config;
+	char dhcp_hostname[256];
+	char pppoe_auth_name[128];
+	char ip_address[16];
+	char netmask[16];
+	char default_route[16];
+	char primary_dns[16];
+	char secondary_dns[16];
+	le_t<u32> http_proxy_config;
+	char http_proxy_server[256];
+	le_t<u32> http_proxy_port;
+};
+
+struct SceNetCtlNatInfo
+{
+	le_t<u32> size;
+	le_t<s32> stun_status;
+	le_t<s32> nat_type;
+	SceNetInAddr mapped_addr;
+};
+
+struct SceNetCtlAdhocPeerInfo
+{
+	vm::lptr<SceNetCtlAdhocPeerInfo> next;
+	SceNetInAddr inet_addr;
+};
+
+using SceNetCtlCallback = func_def<void(s32 event_type, vm::ptr<void> arg)>;
+
+extern psv_log_base sceNetCtl;

rpcs3/Emu/ARMv7/Modules/sceNgs.cpp

@@ -2,123 +2,14 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceNgs;
+#include "sceNgs.h"
 
-struct SceNgsVoiceDefinition;
+s32 sceNgsSystemGetRequiredMemorySize(vm::ptr<const SceNgsSystemInitParams> pSynthParams, vm::ptr<u32> pnSize)
-
-typedef u32 SceNgsModuleID;
-typedef u32 SceNgsParamsID;
-typedef vm::psv::ptr<void> SceNgsHVoice;
-typedef vm::psv::ptr<void> SceNgsHPatch;
-typedef vm::psv::ptr<void> SceNgsHSynSystem;
-typedef vm::psv::ptr<void> SceNgsHRack;
-
-struct SceNgsModuleParamHeader
-{
-	s32 moduleId;
-	s32 chan;
-};
-
-struct SceNgsParamsDescriptor
-{
-	SceNgsParamsID id;
-	u32 size;
-};
-
-struct SceNgsBufferInfo
-{
-	vm::psv::ptr<void> data;
-	u32 size;
-};
-
-struct SceNgsVoicePreset
-{
-	s32 nNameOffset;
-	u32 uNameLength;
-	s32 nPresetDataOffset;
-	u32 uSizePresetData;
-	s32 nBypassFlagsOffset;
-	u32 uNumBypassFlags;
-};
-
-struct SceNgsSystemInitParams
-{
-	s32 nMaxRacks;
-	s32 nMaxVoices;
-	s32 nGranularity;
-	s32 nSampleRate;
-	s32 nMaxModules;
-};
-
-struct SceNgsRackDescription
-{
-	vm::psv::ptr<const SceNgsVoiceDefinition> pVoiceDefn;
-	s32 nVoices;
-	s32 nChannelsPerVoice;
-	s32 nMaxPatchesPerInput;
-	s32 nPatchesPerOutput;
-	vm::psv::ptr<void> pUserReleaseData;
-};
-
-struct SceNgsPatchSetupInfo
-{
-	SceNgsHVoice hVoiceSource;
-	s32 nSourceOutputIndex;
-	s32 nSourceOutputSubIndex;
-	SceNgsHVoice hVoiceDestination;
-	s32 nTargetInputIndex;
-};
-
-struct SceNgsVolumeMatrix
-{
-	float m[2][2];
-};
-
-struct SceNgsPatchRouteInfo
-{
-	s32 nOutputChannels;
-	s32 nInputChannels;
-	SceNgsVolumeMatrix vols;
-};
-
-struct SceNgsVoiceInfo
-{
-	u32 uVoiceState;
-	u32 uNumModules;
-	u32 uNumInputs;
-	u32 uNumOutputs;
-	u32 uNumPatchesPerOutput;
-};
-
-struct SceNgsCallbackInfo
-{
-	SceNgsHVoice hVoiceHandle;
-	SceNgsHRack hRackHandle;
-	SceNgsModuleID uModuleID;
-	s32 nCallbackData;
-	s32 nCallbackData2;
-	vm::psv::ptr<void> pCallbackPtr;
-	vm::psv::ptr<void> pUserData;
-};
-
-typedef vm::psv::ptr<void(vm::psv::ptr<const SceNgsCallbackInfo> pCallbackInfo)> SceNgsCallbackFunc;
-
-typedef SceNgsCallbackFunc SceNgsRackReleaseCallbackFunc;
-typedef SceNgsCallbackFunc SceNgsModuleCallbackFunc;
-typedef SceNgsCallbackFunc SceNgsParamsErrorCallbackFunc;
-
-struct SceSulphaNgsConfig
-{
-	u32 maxNamedObjects;
-	u32 maxTraceBufferBytes;
-};
-
-s32 sceNgsSystemGetRequiredMemorySize(vm::psv::ptr<const SceNgsSystemInitParams> pSynthParams, vm::psv::ptr<u32> pnSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsSystemInit(vm::psv::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::psv::ptr<const SceNgsSystemInitParams> pSynthParams, vm::psv::ptr<SceNgsHSynSystem> pSystemHandle)
+s32 sceNgsSystemInit(vm::ptr<void> pSynthSysMemory, const u32 uMemSize, vm::ptr<const SceNgsSystemInitParams> pSynthParams, vm::ptr<SceNgsHSynSystem> pSystemHandle)
 {
 	throw __FUNCTION__;
 }
@@ -143,7 +34,7 @@ s32 sceNgsSystemUnlock(SceNgsHSynSystem hSystemHandle)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
+s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
 {
 	throw __FUNCTION__;
 }
@@ -153,32 +44,32 @@ s32 sceNgsSystemSetFlags(SceNgsHSynSystem hSystemHandle, const u32 uSystemFlags)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::ptr<u32> pnSize)
+s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::ptr<const SceNgsRackDescription> pRackDesc, vm::ptr<u32> pnSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<SceNgsBufferInfo> pRackBuffer, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::ptr<SceNgsHRack> pRackHandle)
+s32 sceNgsRackInit(SceNgsHSynSystem hSystemHandle, vm::ptr<SceNgsBufferInfo> pRackBuffer, vm::ptr<const SceNgsRackDescription> pRackDesc, vm::ptr<SceNgsHRack> pRackHandle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::psv::ptr<SceNgsHVoice> pVoiceHandle)
+s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::ptr<SceNgsHVoice> pVoiceHandle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackRelease(SceNgsHRack hRackHandle, const SceNgsRackReleaseCallbackFunc callbackFuncPtr)
+s32 sceNgsRackRelease(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
+s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
+s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
 {
 	throw __FUNCTION__;
 }
@@ -208,12 +99,12 @@ s32 sceNgsVoiceResume(SceNgsHVoice hVoiceHandle)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pVoicePreset)
+s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsVoicePreset> pVoicePreset)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsParamsID uParamsInterfaceId, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
+s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const u32 uParamsInterfaceId, vm::ptr<SceNgsBufferInfo> pParamsBuffer)
 {
 	throw __FUNCTION__;
 }
@@ -223,7 +114,7 @@ s32 sceNgsVoiceUnlockParams(SceNgsHVoice hVoiceHandle, const u32 uModule)
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::psv::ptr<s32> pnErrorCount)
+s32 sceNgsVoiceSetParamsBlock(SceNgsHVoice hVoiceHandle, vm::ptr<const SceNgsModuleParamHeader> pParamData, const u32 uSize, vm::ptr<s32> pnErrorCount)
 {
 	throw __FUNCTION__;
 }
@@ -233,52 +124,52 @@ s32 sceNgsVoiceBypassModule(SceNgsHVoice hVoiceHandle, const u32 uModule, const
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsModuleCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
+s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr, vm::ptr<void> pUserData)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, const SceNgsCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
+s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, vm::ptr<SceNgsCallbackFunc> callbackFuncPtr, vm::ptr<void> pUserData)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<void> pMem, const u32 uMemSize)
+s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<void> pMem, const u32 uMemSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::psv::ptr<SceNgsVoiceInfo> pInfo)
+s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::ptr<SceNgsVoiceInfo> pInfo)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<SceNgsModuleID> pModuleType)
+s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<u32> pModuleType)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<u32> puBypassFlag)
+s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<u32> puBypassFlag)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<char> pszMessageBuffer)
+s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::ptr<char> pszMessageBuffer)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsPatchCreateRouting(vm::psv::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
+s32 sceNgsPatchCreateRouting(vm::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::ptr<SceNgsHPatch> pPatchHandle)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::psv::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::psv::ptr<SceNgsPatchSetupInfo> pSetup)
+s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::ptr<SceNgsPatchSetupInfo> pSetup)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
+s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::ptr<SceNgsHPatch> pPatchHandle)
 {
 	throw __FUNCTION__;
 }
@@ -288,112 +179,112 @@ s32 sceNgsPatchRemoveRouting(SceNgsHPatch hPatchHandle)
 	throw __FUNCTION__;
 }
 
-//s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, const s32 nInputChannel, const float fVol)
+s32 sceNgsVoicePatchSetVolume(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, const s32 nInputChannel, const float fVol)
-//{
-//	throw __FUNCTION__;
-//}
-
-s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::psv::ptr<const float> pVolumes, const s32 nVols)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::psv::ptr<const SceNgsVolumeMatrix> pMatrix)
+s32 sceNgsVoicePatchSetVolumes(SceNgsHPatch hPatchHandle, const s32 nOutputChannel, vm::ptr<const float> pVolumes, const s32 nVols)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, vm::psv::ptr<u32> puNumPresets)
+s32 sceNgsVoicePatchSetVolumesMatrix(SceNgsHPatch hPatchHandle, vm::ptr<const SceNgsVolumeMatrix> pMatrix)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, const u32 uPresetIndex, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
+s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, vm::ptr<u32> puNumPresets)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
+s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const u32 uModuleID, const u32 uPresetIndex, vm::ptr<SceNgsBufferInfo> pParamsBuffer)
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
 {
 	throw __FUNCTION__;
 }
 
-vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsGetDefaultConfig(vm::psv::ptr<SceSulphaNgsConfig> config)
+vm::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsGetNeededMemory(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<u32> sizeInBytes)
+s32 sceSulphaNgsGetDefaultConfig(vm::ptr<SceSulphaNgsConfig> config)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsInit(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<void> buffer, u32 sizeInBytes)
+s32 sceSulphaNgsGetNeededMemory(vm::ptr<const SceSulphaNgsConfig> config, vm::ptr<u32> sizeInBytes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsInit(vm::ptr<const SceSulphaNgsConfig> config, vm::ptr<void> buffer, u32 sizeInBytes)
 {
 	throw __FUNCTION__;
 }
@@ -403,27 +294,27 @@ s32 sceSulphaNgsShutdown()
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::psv::ptr<const char> name)
+s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::ptr<const char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::psv::ptr<const char> name)
+s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::ptr<const char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::psv::ptr<const char> name)
+s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::ptr<const char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsSetSampleName(vm::psv::ptr<const void> location, u32 length, vm::psv::ptr<const char> name)
+s32 sceSulphaNgsSetSampleName(vm::ptr<const void> location, u32 length, vm::ptr<const char> name)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSulphaNgsTrace(vm::psv::ptr<const char> message)
+s32 sceSulphaNgsTrace(vm::ptr<const char> message)
 {
 	throw __FUNCTION__;
 }
@@ -436,6 +327,7 @@ psv_log_base sceNgs("SceNgs", []()
 	sceNgs.on_load = nullptr;
 	sceNgs.on_unload = nullptr;
 	sceNgs.on_stop = nullptr;
+	sceNgs.on_error = nullptr;
 
 	REG_FUNC(0x6CE8B36F, sceNgsSystemGetRequiredMemorySize);
 	REG_FUNC(0xED14CF4A, sceNgsSystemInit);

rpcs3/Emu/ARMv7/Modules/sceNgs.h

@@ -0,0 +1,106 @@
+#pragma once
+
+struct SceNgsVoiceDefinition;
+
+using SceNgsHVoice = vm::ptr<void>;
+using SceNgsHPatch = vm::ptr<void>;
+using SceNgsHSynSystem = vm::ptr<void>;
+using SceNgsHRack = vm::ptr<void>;
+
+struct SceNgsModuleParamHeader
+{
+	le_t<s32> moduleId;
+	le_t<s32> chan;
+};
+
+struct SceNgsParamsDescriptor
+{
+	le_t<u32> id;
+	le_t<u32> size;
+};
+
+struct SceNgsBufferInfo
+{
+	vm::lptr<void> data;
+	le_t<u32> size;
+};
+
+struct SceNgsVoicePreset
+{
+	le_t<s32> nNameOffset;
+	le_t<u32> uNameLength;
+	le_t<s32> nPresetDataOffset;
+	le_t<u32> uSizePresetData;
+	le_t<s32> nBypassFlagsOffset;
+	le_t<u32> uNumBypassFlags;
+};
+
+struct SceNgsSystemInitParams
+{
+	le_t<s32> nMaxRacks;
+	le_t<s32> nMaxVoices;
+	le_t<s32> nGranularity;
+	le_t<s32> nSampleRate;
+	le_t<s32> nMaxModules;
+};
+
+struct SceNgsRackDescription
+{
+	vm::lptr<const SceNgsVoiceDefinition> pVoiceDefn;
+	le_t<s32> nVoices;
+	le_t<s32> nChannelsPerVoice;
+	le_t<s32> nMaxPatchesPerInput;
+	le_t<s32> nPatchesPerOutput;
+	vm::lptr<void> pUserReleaseData;
+};
+
+struct SceNgsPatchSetupInfo
+{
+	SceNgsHVoice hVoiceSource;
+	le_t<s32> nSourceOutputIndex;
+	le_t<s32> nSourceOutputSubIndex;
+	SceNgsHVoice hVoiceDestination;
+	le_t<s32> nTargetInputIndex;
+};
+
+struct SceNgsVolumeMatrix
+{
+	le_t<float> m[2][2];
+};
+
+struct SceNgsPatchRouteInfo
+{
+	le_t<s32> nOutputChannels;
+	le_t<s32> nInputChannels;
+	SceNgsVolumeMatrix vols;
+};
+
+struct SceNgsVoiceInfo
+{
+	le_t<u32> uVoiceState;
+	le_t<u32> uNumModules;
+	le_t<u32> uNumInputs;
+	le_t<u32> uNumOutputs;
+	le_t<u32> uNumPatchesPerOutput;
+};
+
+struct SceNgsCallbackInfo
+{
+	SceNgsHVoice hVoiceHandle;
+	SceNgsHRack hRackHandle;
+	le_t<u32> uModuleID;
+	le_t<s32> nCallbackData;
+	le_t<s32> nCallbackData2;
+	vm::lptr<void> pCallbackPtr;
+	vm::lptr<void> pUserData;
+};
+
+using SceNgsCallbackFunc = func_def<void(vm::cptr<SceNgsCallbackInfo> pCallbackInfo)>;
+
+struct SceSulphaNgsConfig
+{
+	le_t<u32> maxNamedObjects;
+	le_t<u32> maxTraceBufferBytes;
+};
+
+extern psv_log_base sceNgs;

rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp

@@ -2,123 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceNpCommon.h"
+#include "sceNpBasic.h"
 
-extern psv_log_base sceNpBasic;
+s32 sceNpBasicInit(vm::ptr<void> opt)
-
-enum SceNpBasicFriendListEventType : s32
-{
-	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
-	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
-	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
-	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
-};
-
-typedef vm::psv::ptr<void(SceNpBasicFriendListEventType eventType, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<void> userdata)> SceNpBasicFriendListEventHandler;
-
-enum SceNpBasicFriendOnlineStatusEventType : s32
-{
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
-};
-
-enum SceNpBasicFriendOnlineStatus : s32
-{
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
-	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
-};
-
-typedef vm::psv::ptr<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::psv::ptr<const SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::psv::ptr<void> userdata)> SceNpBasicFriendOnlineStatusEventHandler;
-
-enum SceNpBasicBlockListEventType : s32
-{
-	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
-	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
-	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
-	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
-};
-
-typedef vm::psv::ptr<void(SceNpBasicBlockListEventType eventType, vm::psv::ptr<const SceNpId> playerId, vm::psv::ptr<void> userdata)> SceNpBasicBlockListEventHandler;
-
-enum SceNpBasicFriendGamePresenceEventType : s32
-{
-	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
-	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
-	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
-};
-
-enum SceNpBasicInGamePresenceType
-{
-	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
-	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
-	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
-	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
-	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
-};
-
-struct SceNpBasicInGamePresence
-{
-	u32 sdkVersion;
-	SceNpBasicInGamePresenceType type;
-	char status[192];
-	u8 data[128];
-	u32 dataSize;
-};
-
-struct SceNpBasicGamePresence
-{
-	u32 size;
-	char title[128];
-	SceNpBasicInGamePresence inGamePresence;
-};
-
-typedef vm::psv::ptr<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<const SceNpBasicGamePresence> presence, vm::psv::ptr<void> userdata)> SceNpBasicFriendGamePresenceEventHandler;
-
-struct SceNpBasicInGameDataMessage
-{
-	u8 data[128];
-	u32 dataSize;
-};
-
-typedef vm::psv::ptr<void(vm::psv::ptr<const SceNpId> from, vm::psv::ptr<const SceNpBasicInGameDataMessage> message, vm::psv::ptr<void> userdata)> SceNpBasicInGameDataMessageEventHandler;
-
-struct SceNpBasicEventHandlers
-{
-	u32 sdkVersion;
-	SceNpBasicFriendListEventHandler friendListEventHandler;
-	SceNpBasicFriendOnlineStatusEventHandler friendOnlineStatusEventHandler;
-	SceNpBasicBlockListEventHandler blockListEventHandler;
-	SceNpBasicFriendGamePresenceEventHandler friendGamePresenceEventHandler;
-	SceNpBasicInGameDataMessageEventHandler inGameDataMessageEventHandler;
-};
-
-struct SceNpBasicPlaySessionLogDescription
-{
-	char text[512];
-};
-
-struct SceNpBasicPlaySessionLog
-{
-	u64 date;
-	SceNpId withWhom;
-	SceNpCommunicationId commId;
-	char title[128];
-	SceNpBasicPlaySessionLogDescription description;
-};
-
-enum SceNpBasicPlaySessionLogType : s32
-{
-	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
-	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
-	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
-	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
-};
-
-s32 sceNpBasicInit(vm::psv::ptr<void> opt)
 {
 	throw __FUNCTION__;
 }
@@ -128,7 +14,7 @@ s32 sceNpBasicTerm(ARMv7Context&)
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicRegisterHandler(vm::psv::ptr<const SceNpBasicEventHandlers> handlers, vm::psv::ptr<const SceNpCommunicationId> context, vm::psv::ptr<void> userdata)
+s32 sceNpBasicRegisterHandler(vm::ptr<const SceNpBasicEventHandlers> handlers, vm::ptr<const SceNpCommunicationId> context, vm::ptr<void> userdata)
 {
 	throw __FUNCTION__;
 }
@@ -143,42 +29,42 @@ s32 sceNpBasicCheckCallback()
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetFriendOnlineStatus(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicFriendOnlineStatus> status)
+s32 sceNpBasicGetFriendOnlineStatus(vm::ptr<const SceNpId> friendId, vm::ptr<SceNpBasicFriendOnlineStatus> status)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetGamePresenceOfFriend(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicGamePresence> presence)
+s32 sceNpBasicGetGamePresenceOfFriend(vm::ptr<const SceNpId> friendId, vm::ptr<SceNpBasicGamePresence> presence)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetFriendListEntryCount(vm::psv::ptr<u32> count)
+s32 sceNpBasicGetFriendListEntryCount(vm::ptr<u32> count)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
+s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32 numEntries, vm::ptr<u32> retrieved)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetBlockListEntryCount(vm::psv::ptr<u32> count)
+s32 sceNpBasicGetBlockListEntryCount(vm::ptr<u32> count)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
+s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::ptr<SceNpId> entries, u32 numEntries, vm::ptr<u32> retrieved)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicCheckIfPlayerIsBlocked(vm::psv::ptr<const SceNpId> player, vm::psv::ptr<u8> playerIsBlocked)
+s32 sceNpBasicCheckIfPlayerIsBlocked(vm::ptr<const SceNpId> player, vm::ptr<u8> playerIsBlocked)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicSetInGamePresence(vm::psv::ptr<const SceNpBasicInGamePresence> presence)
+s32 sceNpBasicSetInGamePresence(vm::ptr<const SceNpBasicInGamePresence> presence)
 {
 	throw __FUNCTION__;
 }
@@ -188,22 +74,22 @@ s32 sceNpBasicUnsetInGamePresence()
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicSendInGameDataMessage(vm::psv::ptr<const SceNpId> to, vm::psv::ptr<const SceNpBasicInGameDataMessage> message)
+s32 sceNpBasicSendInGameDataMessage(vm::ptr<const SceNpId> to, vm::ptr<const SceNpBasicInGameDataMessage> message)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicRecordPlaySessionLog(vm::psv::ptr<const SceNpId> withWhom, vm::psv::ptr<const SceNpBasicPlaySessionLogDescription> description)
+s32 sceNpBasicRecordPlaySessionLog(vm::ptr<const SceNpId> withWhom, vm::ptr<const SceNpBasicPlaySessionLogDescription> description)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::psv::ptr<u32> size)
+s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::ptr<u32> size)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::psv::ptr<SceNpBasicPlaySessionLog> log)
+s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::ptr<SceNpBasicPlaySessionLog> log)
 {
 	throw __FUNCTION__;
 }
@@ -215,6 +101,7 @@ psv_log_base sceNpBasic("SceNpBasic", []()
 	sceNpBasic.on_load = nullptr;
 	sceNpBasic.on_unload = nullptr;
 	sceNpBasic.on_stop = nullptr;
+	sceNpBasic.on_error = nullptr;
 
 	REG_FUNC(0xEFB91A99, sceNpBasicInit);
 	REG_FUNC(0x389BCB3B, sceNpBasicTerm);

rpcs3/Emu/ARMv7/Modules/sceNpBasic.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include "sceNpCommon.h"
+
+enum SceNpBasicFriendListEventType : s32
+{
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_ADDED = 3,
+	SCE_NP_BASIC_FRIEND_LIST_EVENT_TYPE_DELETED = 4
+};
+
+using SceNpBasicFriendListEventHandler = func_def<void(SceNpBasicFriendListEventType eventType, vm::cptr<SceNpId> friendId, vm::ptr<void> userdata)>;
+
+enum SceNpBasicFriendOnlineStatusEventType : s32
+{
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_EVENT_TYPE_UPDATED = 3
+};
+
+enum SceNpBasicFriendOnlineStatus : s32
+{
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_UNKNOWN = 0,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_OFFLINE = 1,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_STANDBY = 2,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_OUT_OF_CONTEXT = 3,
+	SCE_NP_BASIC_FRIEND_ONLINE_STATUS_ONLINE_IN_CONTEXT = 4
+};
+
+using SceNpBasicFriendOnlineStatusEventHandler = func_def<void(SceNpBasicFriendOnlineStatusEventType eventType, vm::cptr<SceNpId> friendId, SceNpBasicFriendOnlineStatus status, vm::ptr<void> userdata)>;
+
+enum SceNpBasicBlockListEventType : s32
+{
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_ADDED = 3,
+	SCE_NP_BASIC_BLOCK_LIST_EVENT_TYPE_DELETED = 4
+};
+
+using SceNpBasicBlockListEventHandler = func_def<void(SceNpBasicBlockListEventType eventType, vm::cptr<SceNpId> playerId, vm::ptr<void> userdata)>;
+
+enum SceNpBasicFriendGamePresenceEventType : s32
+{
+	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC = 1,
+	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_SYNC_DONE = 2,
+	SCE_NP_BASIC_FRIEND_GAME_PRESENCE_EVENT_TYPE_UPDATED = 3
+};
+
+enum SceNpBasicInGamePresenceType : s32
+{
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_UNKNOWN = -1,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_NONE = 0,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_DEFAULT = 1,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_JOINABLE = 2,
+	SCE_NP_BASIC_IN_GAME_PRESENCE_TYPE_MAX = 3
+};
+
+struct SceNpBasicInGamePresence
+{
+	le_t<u32> sdkVersion;
+	le_t<s32> type; // SceNpBasicInGamePresenceType
+	char status[192];
+	u8 data[128];
+	le_t<u32> dataSize;
+};
+
+struct SceNpBasicGamePresence
+{
+	le_t<u32> size;
+	char title[128];
+	SceNpBasicInGamePresence inGamePresence;
+};
+
+using SceNpBasicFriendGamePresenceEventHandler = func_def<void(SceNpBasicFriendGamePresenceEventType eventtype, vm::cptr<SceNpId> friendId, vm::cptr<SceNpBasicGamePresence> presence, vm::ptr<void> userdata)>;
+
+struct SceNpBasicInGameDataMessage
+{
+	u8 data[128];
+	le_t<u32> dataSize;
+};
+
+using SceNpBasicInGameDataMessageEventHandler = func_def<void(vm::cptr<SceNpId> from, vm::cptr<SceNpBasicInGameDataMessage> message, vm::ptr<void> userdata)>;
+
+struct SceNpBasicEventHandlers
+{
+	le_t<u32> sdkVersion;
+	vm::lptr<SceNpBasicFriendListEventHandler> friendListEventHandler;
+	vm::lptr<SceNpBasicFriendOnlineStatusEventHandler> friendOnlineStatusEventHandler;
+	vm::lptr<SceNpBasicBlockListEventHandler> blockListEventHandler;
+	vm::lptr<SceNpBasicFriendGamePresenceEventHandler> friendGamePresenceEventHandler;
+	vm::lptr<SceNpBasicInGameDataMessageEventHandler> inGameDataMessageEventHandler;
+};
+
+struct SceNpBasicPlaySessionLogDescription
+{
+	char text[512];
+};
+
+struct SceNpBasicPlaySessionLog
+{
+	le_t<u64> date;
+	SceNpId withWhom;
+	SceNpCommunicationId commId;
+	char title[128];
+	SceNpBasicPlaySessionLogDescription description;
+};
+
+enum SceNpBasicPlaySessionLogType : s32
+{
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_INVALID = -1,
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_ALL = 0,
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_BY_NP_COMM_ID = 1,
+	SCE_NP_BASIC_PLAY_SESSION_LOG_TYPE_MAX = 2
+};
+
+extern psv_log_base sceNpBasic;

rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp

@@ -14,47 +14,47 @@ s32 sceNpAuthTerm()
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthCreateStartRequest(vm::psv::ptr<const SceNpAuthRequestParameter> param)
+s32 sceNpAuthCreateStartRequest(vm::ptr<const SceNpAuthRequestParameter> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthDestroyRequest(SceNpAuthRequestId id)
+s32 sceNpAuthDestroyRequest(s32 id)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthAbortRequest(SceNpAuthRequestId id)
+s32 sceNpAuthAbortRequest(s32 id)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetTicket(SceNpAuthRequestId id, vm::psv::ptr<void> buf, u32 len)
+s32 sceNpAuthGetTicket(s32 id, vm::ptr<void> buf, u32 len)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetTicketParam(vm::psv::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::psv::ptr<SceNpTicketParam> param)
+s32 sceNpAuthGetTicketParam(vm::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::ptr<SceNpTicketParam> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetEntitlementIdList(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
+s32 sceNpAuthGetEntitlementIdList(vm::ptr<const u8> ticket, u32 ticketSize, vm::ptr<SceNpEntitlementId> entIdList, u32 entIdListNum)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpAuthGetEntitlementById(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::ptr<const char> entId, vm::psv::ptr<SceNpEntitlement> ent)
+s32 sceNpAuthGetEntitlementById(vm::ptr<const u8> ticket, u32 ticketSize, vm::ptr<const char> entId, vm::ptr<SceNpEntitlement> ent)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpCmpNpId(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2)
+s32 sceNpCmpNpId(vm::ptr<const SceNpId> npid1, vm::ptr<const SceNpId> npid2)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpCmpNpIdInOrder(vm::psv::ptr<const SceNpId> npid1, vm::psv::ptr<const SceNpId> npid2, vm::psv::ptr<s32> order)
+s32 sceNpCmpNpIdInOrder(vm::ptr<const SceNpId> npid1, vm::ptr<const SceNpId> npid2, vm::ptr<s32> order)
 {
 	throw __FUNCTION__;
 }
@@ -66,6 +66,7 @@ psv_log_base sceNpCommon("SceNpCommon", []()
 	sceNpCommon.on_load = nullptr;
 	sceNpCommon.on_unload = nullptr;
 	sceNpCommon.on_stop = nullptr;
+	sceNpCommon.on_error = nullptr;
 
 	REG_FUNC(0x441D8B4E, sceNpAuthInit);
 	REG_FUNC(0x6093B689, sceNpAuthTerm);

rpcs3/Emu/ARMv7/Modules/sceNpCommon.h

@@ -28,9 +28,9 @@ struct SceNpCommunicationSignature
 
 struct SceNpCommunicationConfig
 {
-	vm::psv::ptr<const SceNpCommunicationId> commId;
+	vm::lptr<const SceNpCommunicationId> commId;
-	vm::psv::ptr<const SceNpCommunicationPassphrase> commPassphrase;
+	vm::lptr<const SceNpCommunicationPassphrase> commPassphrase;
-	vm::psv::ptr<const SceNpCommunicationSignature> commSignature;
+	vm::lptr<const SceNpCommunicationSignature> commSignature;
 };
 
 struct SceNpCountryCode
@@ -69,16 +69,16 @@ struct SceNpUserInformation
 
 struct SceNpMyLanguages
 {
-	s32 language1;
+	le_t<s32> language1;
-	s32 language2;
+	le_t<s32> language2;
-	s32 language3;
+	le_t<s32> language3;
 	u8 padding[4];
 };
 
 struct SceNpAvatarImage
 {
 	u8 data[200 * 1024];
-	u32 size;
+	le_t<u32> size;
 	u8 reserved[12];
 };
 
@@ -94,45 +94,42 @@ struct SceNpAboutMe
 	char data[64];
 };
 
-typedef s32 SceNpAuthRequestId;
-typedef u64 SceNpTime;
-
 struct SceNpDate
 {
-	u16 year;
+	le_t<u16> year;
 	u8 month;
 	u8 day;
 };
 
 union SceNpTicketParam
 {
-	s32 _s32;
+	le_t<s32> _s32;
-	s64 _s64;
+	le_t<s64> _s64;
-	u32 _u32;
+	le_t<u32> _u32;
-	u64 _u64;
+	le_t<u64> _u64;
 	SceNpDate date;
 	u8 data[256];
 };
 
 struct SceNpTicketVersion
 {
-	u16 major;
+	le_t<u16> major;
-	u16 minor;
+	le_t<u16> minor;
 };
 
-typedef vm::psv::ptr<s32(SceNpAuthRequestId id, s32 result, vm::psv::ptr<void> arg)> SceNpAuthCallback;
+using SceNpAuthCallback = func_def<s32(s32 id, s32 result, vm::ptr<void> arg)>;
 
 struct SceNpAuthRequestParameter
 {
-	u32 size;
+	le_t<u32> size;
 	SceNpTicketVersion version;
-	vm::psv::ptr<const char> serviceId;
+	vm::lptr<const char> serviceId;
-	vm::psv::ptr<const void> cookie;
+	vm::lptr<const void> cookie;
-	u32 cookieSize;
+	le_t<u32> cookieSize;
-	vm::psv::ptr<const char> entitlementId;
+	vm::lptr<const char> entitlementId;
-	u32 consumedCount;
+	le_t<u32> consumedCount;
-	SceNpAuthCallback ticketCb;
+	vm::lptr<SceNpAuthCallback> ticketCb;
-	vm::psv::ptr<void> cbArg;
+	vm::lptr<void> cbArg;
 };
 
 struct SceNpEntitlementId
@@ -143,11 +140,11 @@ struct SceNpEntitlementId
 struct SceNpEntitlement
 {
 	SceNpEntitlementId id;
-	SceNpTime createdDate;
+	le_t<u64> createdDate;
-	SceNpTime expireDate;
+	le_t<u64> expireDate;
-	u32 type;
+	le_t<u32> type;
-	s32 remainingCount;
+	le_t<s32> remainingCount;
-	u32 consumedCount;
+	le_t<u32> consumedCount;
 	char padding[4];
 };
 

rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp

@@ -2,18 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceNpCommon.h"
+#include "sceNpManager.h"
 
-extern psv_log_base sceNpManager;
+s32 sceNpInit(vm::ptr<const SceNpCommunicationConfig> commConf, vm::ptr<SceNpOptParam> opt)
-
-struct SceNpOptParam
-{
-	u32 optParamSize;
-};
-
-typedef vm::psv::ptr<void(SceNpServiceState state, vm::psv::ptr<void> userdata)> SceNpServiceStateCallback;
-
-s32 sceNpInit(vm::psv::ptr<const SceNpCommunicationConfig> commConf, vm::psv::ptr<SceNpOptParam> opt)
 {
 	throw __FUNCTION__;
 }
@@ -28,12 +19,12 @@ s32 sceNpCheckCallback()
 	throw __FUNCTION__;
 }
 
-s32 sceNpGetServiceState(vm::psv::ptr<SceNpServiceState> state)
+s32 sceNpGetServiceState(vm::ptr<SceNpServiceState> state)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpRegisterServiceStateCallback(SceNpServiceStateCallback callback, vm::psv::ptr<void> userdata)
+s32 sceNpRegisterServiceStateCallback(vm::ptr<SceNpServiceStateCallback> callback, vm::ptr<void> userdata)
 {
 	throw __FUNCTION__;
 }
@@ -43,22 +34,22 @@ s32 sceNpUnregisterServiceStateCallback()
 	throw __FUNCTION__;
 }
 
-s32 sceNpManagerGetNpId(vm::psv::ptr<SceNpId> npId)
+s32 sceNpManagerGetNpId(vm::ptr<SceNpId> npId)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpManagerGetAccountRegion(vm::psv::ptr<SceNpCountryCode> countryCode, vm::psv::ptr<s32> languageCode)
+s32 sceNpManagerGetAccountRegion(vm::ptr<SceNpCountryCode> countryCode, vm::ptr<s32> languageCode)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpManagerGetContentRatingFlag(vm::psv::ptr<s32> isRestricted, vm::psv::ptr<s32> age)
+s32 sceNpManagerGetContentRatingFlag(vm::ptr<s32> isRestricted, vm::ptr<s32> age)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpManagerGetChatRestrictionFlag(vm::psv::ptr<s32> isRestricted)
+s32 sceNpManagerGetChatRestrictionFlag(vm::ptr<s32> isRestricted)
 {
 	throw __FUNCTION__;
 }
@@ -70,6 +61,7 @@ psv_log_base sceNpManager("SceNpManager", []()
 	sceNpManager.on_load = nullptr;
 	sceNpManager.on_unload = nullptr;
 	sceNpManager.on_stop = nullptr;
+	sceNpManager.on_error = nullptr;
 
 	REG_FUNC(0x04D9F484, sceNpInit);
 	REG_FUNC(0x19E40AE1, sceNpTerm);

rpcs3/Emu/ARMv7/Modules/sceNpManager.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "sceNpCommon.h"
+
+struct SceNpOptParam
+{
+	le_t<u32> optParamSize;
+};
+
+using SceNpServiceStateCallback = func_def<void(SceNpServiceState state, vm::ptr<void> userdata)>;
+
+extern psv_log_base sceNpManager;

rpcs3/Emu/ARMv7/Modules/sceNpMatching.h

@@ -0,0 +1,989 @@
+#pragma once
+
+#include "sceNet.h"
+#include "sceNpCommon.h"
+
+struct SceNpMatching2MemoryInfo
+{
+	le_t<u32> totalMemSize;
+	le_t<u32> curMemUsage;
+	le_t<u32> maxMemUsage;
+	u8 reserved[12];
+};
+
+struct SceNpMatching2SessionPassword
+{
+	u8 data[8];
+};
+
+struct SceNpMatching2PresenceOptionData
+{
+	u8 data[16];
+	le_t<u32> len;
+};
+
+struct SceNpMatching2IntAttr
+{
+	le_t<u16> id;
+	u8 padding[2];
+	le_t<u32> num;
+};
+
+
+struct SceNpMatching2BinAttr
+{
+	le_t<u16> id;
+	u8 padding[2];
+	vm::lptr<void> ptr;
+	le_t<u32> size;
+};
+
+
+struct SceNpMatching2RangeFilter
+{
+	le_t<u32> startIndex;
+	le_t<u32> max;
+};
+
+
+struct SceNpMatching2IntSearchFilter
+{
+	u8 searchOperator;
+	u8 padding[3];
+	SceNpMatching2IntAttr attr;
+};
+
+
+struct SceNpMatching2BinSearchFilter
+{
+	u8 searchOperator;
+	u8 padding[3];
+	SceNpMatching2BinAttr attr;
+};
+
+
+struct SceNpMatching2Range
+{
+	le_t<u32> startIndex;
+	le_t<u32> total;
+	le_t<u32> resultCount;
+};
+
+
+struct SceNpMatching2JoinedSessionInfo
+{
+	u8 sessionType;
+	u8 padding1[1];
+	le_t<u16> serverId;
+	le_t<u32> worldId;
+	le_t<u64> lobbyId;
+	le_t<u64> roomId;
+	le_t<u64> joinDate;
+};
+
+
+struct SceNpMatching2UserInfo
+{
+	vm::lptr<SceNpMatching2UserInfo> next;
+	SceNpId npId;
+	vm::lptr<SceNpMatching2BinAttr> userBinAttr;
+	le_t<u32> userBinAttrNum;
+	vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	le_t<u32> joinedSessionInfoNum;
+};
+
+struct SceNpMatching2Server
+{
+	le_t<u16> serverId;
+	u8 status;
+	u8 padding[1];
+};
+
+
+struct SceNpMatching2World
+{
+	vm::lptr<SceNpMatching2World> next;
+	le_t<u32> worldId;
+	le_t<u32> numOfLobby;
+	le_t<u32> maxNumOfTotalLobbyMember;
+	le_t<u32> curNumOfTotalLobbyMember;
+	le_t<u32> curNumOfRoom;
+	le_t<u32> curNumOfTotalRoomMember;
+	bool withEntitlementId;
+	SceNpEntitlementId entitlementId;
+	u8 padding[3];
+};
+
+struct SceNpMatching2LobbyMemberBinAttrInternal
+{
+	le_t<u64> updateDate;
+	SceNpMatching2BinAttr data;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2LobbyMemberDataInternal
+{
+	vm::lptr<SceNpMatching2LobbyMemberDataInternal> next;
+	SceNpId npId;
+
+	le_t<u64> joinDate;
+	le_t<u16> memberId;
+	u8 padding[2];
+
+	le_t<u32> flagAttr;
+
+	vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	le_t<u32> joinedSessionInfoNum;
+	vm::lptr<SceNpMatching2LobbyMemberBinAttrInternal> lobbyMemberBinAttrInternal;
+	le_t<u32> lobbyMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2LobbyMemberIdList
+{
+	vm::lptr<u16> memberId;
+	le_t<u32> memberIdNum;
+	le_t<u16> me;
+	u8 padding[6];
+};
+
+
+struct SceNpMatching2LobbyBinAttrInternal
+{
+	le_t<u64> updateDate;
+	le_t<u16> updateMemberId;
+	u8 padding[2];
+	SceNpMatching2BinAttr data;
+};
+
+
+struct SceNpMatching2LobbyDataExternal
+{
+	vm::lptr<SceNpMatching2LobbyDataExternal> next;
+	le_t<u16> serverId;
+	u8 padding1[2];
+	le_t<u32> worldId;
+	u8 padding2[4];
+	le_t<u64> lobbyId;
+	le_t<u32> maxSlot;
+	le_t<u32> curMemberNum;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2IntAttr> lobbySearchableIntAttrExternal;
+	le_t<u32> lobbySearchableIntAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> lobbySearchableBinAttrExternal;
+	le_t<u32> lobbySearchableBinAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> lobbyBinAttrExternal;
+	le_t<u32> lobbyBinAttrExternalNum;
+	u8 padding3[4];
+};
+
+
+struct SceNpMatching2LobbyDataInternal
+{
+	le_t<u16> serverId;
+	u8 padding1[2];
+	le_t<u32> worldId;
+	le_t<u64> lobbyId;
+
+	le_t<u32> maxSlot;
+	SceNpMatching2LobbyMemberIdList memberIdList;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2LobbyBinAttrInternal> lobbyBinAttrInternal;
+	le_t<u32> lobbyBinAttrInternalNum;
+};
+
+
+union SceNpMatching2LobbyMessageDestination
+{
+	le_t<u16> unicastTarget;
+
+	struct
+	{
+		vm::lptr<u16> memberId;
+		le_t<u32> memberIdNum;
+	}
+	multicastTarget;
+};
+
+struct SceNpMatching2GroupLabel
+{
+	u8 data[8];
+};
+
+struct SceNpMatching2RoomGroupConfig
+{
+	le_t<u32> slotNum;
+	bool withLabel;
+	SceNpMatching2GroupLabel label;
+	bool withPassword;
+	u8 padding[2];
+};
+
+
+struct SceNpMatching2RoomGroupPasswordConfig
+{
+	u8 groupId;
+	bool withPassword;
+	u8 padding[1];
+};
+
+
+struct SceNpMatching2RoomMemberBinAttrInternal
+{
+	le_t<u64> updateDate;
+	SceNpMatching2BinAttr data;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2RoomGroup
+{
+	u8 groupId;
+	bool withPassword;
+	bool withLabel;
+	u8 padding[1];
+	SceNpMatching2GroupLabel label;
+	le_t<u32> slotNum;
+	le_t<u32> curGroupMemberNum;
+};
+
+
+struct SceNpMatching2RoomMemberDataExternal
+{
+	vm::lptr<SceNpMatching2RoomMemberDataExternal> next;
+	SceNpId npId;
+	le_t<u64> joinDate;
+	u8 role;
+	u8 padding[7];
+};
+
+
+struct SceNpMatching2RoomMemberDataInternal
+{
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> next;
+	SceNpId npId;
+
+	le_t<u64> joinDate;
+	le_t<u16> memberId;
+	u8 teamId;
+	u8 padding1[1];
+
+	vm::lptr<SceNpMatching2RoomGroup> roomGroup;
+
+	u8 natType;
+	u8 padding2[3];
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2RoomMemberBinAttrInternal> roomMemberBinAttrInternal;
+	le_t<u32> roomMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2RoomMemberDataInternalList
+{
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> members;
+	le_t<u32> membersNum;
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> me;
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> owner;
+};
+
+
+struct SceNpMatching2RoomBinAttrInternal
+{
+	le_t<u64> updateDate;
+	le_t<u16> updateMemberId;
+	u8 padding[2];
+	SceNpMatching2BinAttr data;
+};
+
+
+struct SceNpMatching2RoomDataExternal
+{
+	vm::lptr<SceNpMatching2RoomDataExternal> next;
+
+	le_t<u16> maxSlot;
+	le_t<u16> curMemberNum;
+
+	le_t<u16> serverId;
+	u8 padding[2];
+	le_t<u32> worldId;
+	le_t<u64> lobbyId;
+	le_t<u64> roomId;
+
+	le_t<u64> passwordSlotMask;
+	le_t<u64> joinedSlotMask;
+	le_t<u16> publicSlotNum;
+	le_t<u16> privateSlotNum;
+	le_t<u16> openPublicSlotNum;
+	le_t<u16> openPrivateSlotNum;
+
+	vm::lptr<SceNpId> owner;
+	le_t<u32> flagAttr;
+
+	vm::lptr<SceNpMatching2RoomGroup> roomGroup;
+	le_t<u32> roomGroupNum;
+	vm::lptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
+	le_t<u32> roomSearchableIntAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
+	le_t<u32> roomSearchableBinAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> roomBinAttrExternal;
+	le_t<u32> roomBinAttrExternalNum;
+};
+
+
+struct SceNpMatching2RoomDataInternal
+{
+	le_t<u16> maxSlot;
+
+	le_t<u16> serverId;
+	le_t<u32> worldId;
+	le_t<u64> lobbyId;
+	le_t<u64> roomId;
+
+	le_t<u64> passwordSlotMask;
+	le_t<u64> joinedSlotMask;
+	le_t<u16> publicSlotNum;
+	le_t<u16> privateSlotNum;
+	le_t<u16> openPublicSlotNum;
+	le_t<u16> openPrivateSlotNum;
+
+	SceNpMatching2RoomMemberDataInternalList memberList;
+
+	vm::lptr<SceNpMatching2RoomGroup> roomGroup;
+	le_t<u32> roomGroupNum;
+
+	le_t<u32> flagAttr;
+	u8 padding[4];
+	vm::lptr<SceNpMatching2RoomBinAttrInternal> roomBinAttrInternal;
+	le_t<u32> roomBinAttrInternalNum;
+};
+
+
+union SceNpMatching2RoomMessageDestination
+{
+	le_t<u16> unicastTarget;
+
+	struct
+	{
+		vm::lptr<u16> memberId;
+		le_t<u32> memberIdNum;
+	}
+	multicastTarget;
+
+	u8 multicastTargetTeamId;
+};
+
+
+struct SceNpMatching2InvitationData
+{
+	vm::lptr<SceNpMatching2JoinedSessionInfo> targetSession;
+	le_t<u32> targetSessionNum;
+	vm::lptr<void> optData;
+	le_t<u32> optDataLen;
+};
+
+using SceNpMatching2RequestCallback = func_def<void(u16 ctxId, u32 reqId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
+using SceNpMatching2LobbyEventCallback = func_def<void(u16 ctxId, u64 lobbyId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
+using SceNpMatching2RoomEventCallback = func_def<void(u16 ctxId, u64 roomId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
+using SceNpMatching2LobbyMessageCallback = func_def<void(u16 ctxId, u64 lobbyId, u16 srcMemberId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
+using SceNpMatching2RoomMessageCallback = func_def<void(u16 ctxId, u64 roomId, u16 srcMemberId, u16 event, s32 errorCode, vm::cptr<void> data, vm::ptr<void> arg)>;
+using SceNpMatching2SignalingCallback = func_def<void(u16 ctxId, u64 roomId, u16 peerMemberId, u16 event, s32 errorCode, vm::ptr<void> arg)>;
+using SceNpMatching2ContextCallback = func_def<void(u16 ctxId, u16 event, u8 eventCause, s32 errorCode, vm::ptr<void> arg)>;
+
+struct SceNpMatching2RequestOptParam
+{
+	vm::lptr<SceNpMatching2RequestCallback> cbFunc;
+	vm::lptr<void> cbFuncArg;
+	le_t<u32> timeout;
+	le_t<u16> appReqId;
+	u8 padding[2];
+};
+
+
+struct SceNpMatching2GetWorldInfoListRequest
+{
+	le_t<u16> serverId;
+};
+
+
+
+struct SceNpMatching2GetWorldInfoListResponse
+{
+	vm::lptr<SceNpMatching2World> world;
+	le_t<u32> worldNum;
+};
+
+struct SceNpMatching2SetUserInfoRequest
+{
+	le_t<u16> serverId;
+	u8 padding[2];
+	vm::lptr<SceNpMatching2BinAttr> userBinAttr;
+	le_t<u32> userBinAttrNum;
+};
+
+
+struct SceNpMatching2GetUserInfoListRequest
+{
+	le_t<u16> serverId;
+	u8 padding[2];
+	vm::lptr<SceNpId> npId;
+	le_t<u32> npIdNum;
+	vm::lptr<u16> attrId;
+	le_t<u32> attrIdNum;
+	le_t<s32> option;
+};
+
+
+
+struct SceNpMatching2GetUserInfoListResponse
+{
+	vm::lptr<SceNpMatching2UserInfo> userInfo;
+	le_t<u32> userInfoNum;
+};
+
+
+struct SceNpMatching2GetRoomMemberDataExternalListRequest
+{
+	le_t<u64> roomId;
+};
+
+
+
+struct SceNpMatching2GetRoomMemberDataExternalListResponse
+{
+	vm::lptr<SceNpMatching2RoomMemberDataExternal> roomMemberDataExternal;
+	le_t<u32> roomMemberDataExternalNum;
+};
+
+
+struct SceNpMatching2SetRoomDataExternalRequest
+{
+	le_t<u64> roomId;
+	vm::lptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
+	le_t<u32> roomSearchableIntAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
+	le_t<u32> roomSearchableBinAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> roomBinAttrExternal;
+	le_t<u32> roomBinAttrExternalNum;
+};
+
+
+struct SceNpMatching2GetRoomDataExternalListRequest
+{
+	vm::lptr<u64> roomId;
+	le_t<u32> roomIdNum;
+	vm::lptr<const u16> attrId;
+	le_t<u32> attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetRoomDataExternalListResponse
+{
+	vm::lptr<SceNpMatching2RoomDataExternal> roomDataExternal;
+	le_t<u32> roomDataExternalNum;
+};
+
+struct SceNpMatching2SignalingOptParam
+{
+	u8 type;
+	u8 flag;
+	le_t<u16> hubMemberId;
+	u8 reserved2[4];
+};
+
+
+
+struct SceNpMatching2CreateJoinRoomRequest
+{
+	le_t<u32> worldId;
+	u8 padding1[4];
+	le_t<u64> lobbyId;
+
+	le_t<u32> maxSlot;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2BinAttr> roomBinAttrInternal;
+	le_t<u32> roomBinAttrInternalNum;
+	vm::lptr<SceNpMatching2IntAttr> roomSearchableIntAttrExternal;
+	le_t<u32> roomSearchableIntAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> roomSearchableBinAttrExternal;
+	le_t<u32> roomSearchableBinAttrExternalNum;
+	vm::lptr<SceNpMatching2BinAttr> roomBinAttrExternal;
+	le_t<u32> roomBinAttrExternalNum;
+	vm::lptr<SceNpMatching2SessionPassword> roomPassword;
+	vm::lptr<SceNpMatching2RoomGroupConfig> groupConfig;
+	le_t<u32> groupConfigNum;
+	vm::lptr<u64> passwordSlotMask;
+	vm::lptr<SceNpId> allowedUser;
+	le_t<u32> allowedUserNum;
+	vm::lptr<SceNpId> blockedUser;
+	le_t<u32> blockedUserNum;
+
+	vm::lptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
+	vm::lptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
+	le_t<u32> roomMemberBinAttrInternalNum;
+	u8 teamId;
+	u8 padding2[3];
+
+	vm::lptr<SceNpMatching2SignalingOptParam> sigOptParam;
+	u8 padding3[4];
+};
+
+
+
+struct SceNpMatching2CreateJoinRoomResponse
+{
+	vm::lptr<SceNpMatching2RoomDataInternal> roomDataInternal;
+};
+
+
+struct SceNpMatching2JoinRoomRequest
+{
+	le_t<u64> roomId;
+	vm::lptr<SceNpMatching2SessionPassword> roomPassword;
+	vm::lptr<SceNpMatching2GroupLabel> joinRoomGroupLabel;
+	vm::lptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
+	le_t<u32> roomMemberBinAttrInternalNum;
+	SceNpMatching2PresenceOptionData optData;
+	u8 teamId;
+	u8 padding[3];
+	vm::lptr<SceNpId> blockedUser;
+	le_t<u32> blockedUserNum;
+};
+
+
+
+struct SceNpMatching2JoinRoomResponse
+{
+	vm::lptr<SceNpMatching2RoomDataInternal> roomDataInternal;
+};
+
+
+struct SceNpMatching2LeaveRoomRequest
+{
+	le_t<u64> roomId;
+	SceNpMatching2PresenceOptionData optData;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2GrantRoomOwnerRequest
+{
+	le_t<u64> roomId;
+	le_t<u16> newOwner;
+	u8 padding[2];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2KickoutRoomMemberRequest
+{
+	le_t<u64> roomId;
+	le_t<u16> target;
+	u8 blockKickFlag;
+	u8 padding[1];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2SearchRoomRequest
+{
+	le_t<s32> option;
+	le_t<u32> worldId;
+	le_t<u64> lobbyId;
+	SceNpMatching2RangeFilter rangeFilter;
+	le_t<u32> flagFilter;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2IntSearchFilter> intFilter;
+	le_t<u32> intFilterNum;
+	vm::lptr<SceNpMatching2BinSearchFilter> binFilter;
+	le_t<u32> binFilterNum;
+	vm::lptr<u16> attrId;
+	le_t<u32> attrIdNum;
+};
+
+
+
+struct SceNpMatching2SearchRoomResponse
+{
+	SceNpMatching2Range range;
+	vm::lptr<SceNpMatching2RoomDataExternal> roomDataExternal;
+};
+
+
+struct SceNpMatching2SendRoomMessageRequest
+{
+	le_t<u64> roomId;
+	u8 castType;
+	u8 padding[3];
+	SceNpMatching2RoomMessageDestination dst;
+	vm::lcptr<void> msg;
+	le_t<u32> msgLen;
+	le_t<s32> option;
+};
+
+
+struct SceNpMatching2SendRoomChatMessageRequest
+{
+	le_t<u64> roomId;
+	u8 castType;
+	u8 padding[3];
+	SceNpMatching2RoomMessageDestination dst;
+	vm::lptr<const void> msg;
+	le_t<u32> msgLen;
+	le_t<s32> option;
+};
+
+
+
+struct SceNpMatching2SendRoomChatMessageResponse
+{
+	bool filtered;
+};
+
+
+struct SceNpMatching2SetRoomDataInternalRequest
+{
+	le_t<u64> roomId;
+	le_t<u32> flagFilter;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2BinAttr> roomBinAttrInternal;
+	le_t<u32> roomBinAttrInternalNum;
+	vm::lptr<SceNpMatching2RoomGroupPasswordConfig> passwordConfig;
+	le_t<u32> passwordConfigNum;
+	vm::lptr<u64> passwordSlotMask;
+	vm::lptr<u16> ownerPrivilegeRank;
+	le_t<u32> ownerPrivilegeRankNum;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2GetRoomDataInternalRequest
+{
+	le_t<u64> roomId;
+	vm::lcptr<u16> attrId;
+	le_t<u32> attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetRoomDataInternalResponse
+{
+	vm::lptr<SceNpMatching2RoomDataInternal> roomDataInternal;
+};
+
+
+struct SceNpMatching2SetRoomMemberDataInternalRequest
+{
+	le_t<u64> roomId;
+	le_t<u16> memberId;
+	u8 teamId;
+	u8 padding[5];
+	le_t<u32> flagFilter;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2BinAttr> roomMemberBinAttrInternal;
+	le_t<u32> roomMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2GetRoomMemberDataInternalRequest
+{
+	le_t<u64> roomId;
+	le_t<u16> memberId;
+	u8 padding[6];
+	vm::lcptr<u16> attrId;
+	le_t<u32> attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetRoomMemberDataInternalResponse
+{
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
+};
+
+
+struct SceNpMatching2SetSignalingOptParamRequest
+{
+	le_t<u64> roomId;
+	SceNpMatching2SignalingOptParam sigOptParam;
+};
+
+
+struct SceNpMatching2GetLobbyInfoListRequest
+{
+	le_t<u32> worldId;
+	SceNpMatching2RangeFilter rangeFilter;
+	vm::lptr<u16> attrId;
+	le_t<u32> attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetLobbyInfoListResponse
+{
+	SceNpMatching2Range range;
+	vm::lptr<SceNpMatching2LobbyDataExternal> lobbyDataExternal;
+};
+
+
+struct SceNpMatching2JoinLobbyRequest
+{
+	le_t<u64> lobbyId;
+	vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	le_t<u32> joinedSessionInfoNum;
+	vm::lptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
+	le_t<u32> lobbyMemberBinAttrInternalNum;
+	SceNpMatching2PresenceOptionData optData;
+	u8 padding[4];
+};
+
+
+
+struct SceNpMatching2JoinLobbyResponse
+{
+	vm::lptr<SceNpMatching2LobbyDataInternal> lobbyDataInternal;
+};
+
+
+struct SceNpMatching2LeaveLobbyRequest
+{
+	le_t<u64> lobbyId;
+	SceNpMatching2PresenceOptionData optData;
+	u8 padding[4];
+};
+
+
+struct SceNpMatching2SetLobbyMemberDataInternalRequest
+{
+	le_t<u64> lobbyId;
+	le_t<u16> memberId;
+	u8 padding1[2];
+	le_t<u32> flagFilter;
+	le_t<u32> flagAttr;
+	vm::lptr<SceNpMatching2JoinedSessionInfo> joinedSessionInfo;
+	le_t<u32> joinedSessionInfoNum;
+	vm::lptr<SceNpMatching2BinAttr> lobbyMemberBinAttrInternal;
+	le_t<u32> lobbyMemberBinAttrInternalNum;
+	u8 padding2[4];
+};
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalRequest
+{
+	le_t<u64> lobbyId;
+	le_t<u16> memberId;
+	u8 padding[6];
+	vm::lcptr<u16> attrId;
+	le_t<u32> attrIdNum;
+};
+
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalResponse
+{
+	vm::lptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
+};
+
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalListRequest
+{
+	le_t<u64> lobbyId;
+	vm::lptr<u16> memberId;
+	le_t<u32> memberIdNum;
+	vm::lcptr<u16> attrId;
+	le_t<u32> attrIdNum;
+	bool extendedData;
+	u8 padding[7];
+};
+
+
+
+struct SceNpMatching2GetLobbyMemberDataInternalListResponse
+{
+	vm::lptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
+	le_t<u32> lobbyMemberDataInternalNum;
+};
+
+
+struct SceNpMatching2SendLobbyChatMessageRequest
+{
+	le_t<u64> lobbyId;
+	u8 castType;
+	u8 padding[3];
+	SceNpMatching2LobbyMessageDestination dst;
+	vm::lcptr<void> msg;
+	le_t<u32> msgLen;
+	le_t<s32> option;
+};
+
+
+
+struct SceNpMatching2SendLobbyChatMessageResponse
+{
+	bool filtered;
+};
+
+
+struct SceNpMatching2SendLobbyInvitationRequest
+{
+	le_t<u64> lobbyId;
+	u8 castType;
+	u8 padding[3];
+	SceNpMatching2LobbyMessageDestination dst;
+	SceNpMatching2InvitationData invitationData;
+	le_t<s32> option;
+};
+
+
+struct SceNpMatching2RoomMemberUpdateInfo
+{
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> roomMemberDataInternal;
+	u8 eventCause;
+	u8 padding[3];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2RoomOwnerUpdateInfo
+{
+	le_t<u16> prevOwner;
+	le_t<u16> newOwner;
+	u8 eventCause;
+	u8 padding[3];
+	vm::lptr<SceNpMatching2SessionPassword> roomPassword;
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2RoomUpdateInfo
+{
+	u8 eventCause;
+	u8 padding[3];
+	le_t<s32> errorCode;
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2RoomDataInternalUpdateInfo
+{
+	vm::lptr<SceNpMatching2RoomDataInternal> newRoomDataInternal;
+	vm::lptr<u32> newFlagAttr;
+	vm::lptr<u32> prevFlagAttr;
+	vm::lptr<u64> newRoomPasswordSlotMask;
+	vm::lptr<u64> prevRoomPasswordSlotMask;
+	vm::lptr<SceNpMatching2RoomGroup> *newRoomGroup;
+	le_t<u32> newRoomGroupNum;
+	vm::lptr<SceNpMatching2RoomBinAttrInternal> *newRoomBinAttrInternal;
+	le_t<u32> newRoomBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2RoomMemberDataInternalUpdateInfo
+{
+	vm::lptr<SceNpMatching2RoomMemberDataInternal> newRoomMemberDataInternal;
+	vm::lptr<u32> newFlagAttr;
+	vm::lptr<u32> prevFlagAttr;
+	vm::lptr<u8> newTeamId;
+	vm::lptr<SceNpMatching2RoomMemberBinAttrInternal> *newRoomMemberBinAttrInternal;
+	le_t<u32> newRoomMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2SignalingOptParamUpdateInfo
+{
+	SceNpMatching2SignalingOptParam newSignalingOptParam;
+};
+
+
+struct SceNpMatching2RoomMessageInfo
+{
+	bool filtered;
+	u8 castType;
+	u8 padding[2];
+	vm::lptr<SceNpMatching2RoomMessageDestination> dst;
+	vm::lptr<SceNpId> srcMember;
+	vm::lcptr<void> msg;
+	le_t<u32> msgLen;
+};
+
+
+struct SceNpMatching2LobbyMemberUpdateInfo
+{
+	vm::lptr<SceNpMatching2LobbyMemberDataInternal> lobbyMemberDataInternal;
+	u8 eventCause;
+	u8 padding[3];
+	SceNpMatching2PresenceOptionData optData;
+};
+
+
+struct SceNpMatching2LobbyUpdateInfo
+{
+	u8 eventCause;
+	u8 padding[3];
+	le_t<s32> errorCode;
+};
+
+
+struct SceNpMatching2LobbyMemberDataInternalUpdateInfo
+{
+	le_t<u16> memberId;
+	u8 padding[2];
+	SceNpId npId;
+	le_t<u32> flagFilter;
+	le_t<u32> newFlagAttr;
+	vm::lptr<SceNpMatching2JoinedSessionInfo> newJoinedSessionInfo;
+	le_t<u32> newJoinedSessionInfoNum;
+	vm::lptr<SceNpMatching2LobbyMemberBinAttrInternal> newLobbyMemberBinAttrInternal;
+	le_t<u32> newLobbyMemberBinAttrInternalNum;
+};
+
+
+struct SceNpMatching2LobbyMessageInfo
+{
+	bool filtered;
+	u8 castType;
+	u8 padding[2];
+	vm::lptr<SceNpMatching2LobbyMessageDestination> dst;
+	vm::lptr<SceNpId> srcMember;
+	vm::lcptr<void> msg;
+	le_t<u32> msgLen;
+};
+
+
+struct SceNpMatching2LobbyInvitationInfo
+{
+	u8 castType;
+	u8 padding[3];
+	vm::lptr<SceNpMatching2LobbyMessageDestination> dst;
+	vm::lptr<SceNpId> srcMember;
+	SceNpMatching2InvitationData invitationData;
+};
+
+union SceNpMatching2SignalingConnectionInfo
+{
+	le_t<u32> rtt;
+	le_t<u32> bandwidth;
+	SceNpId npId;
+
+	struct
+	{
+		SceNetInAddr addr;
+		le_t<u16> port;
+		u8 padding[2];
+	}
+	address;
+
+	le_t<u32> packetLoss;
+};
+
+struct SceNpMatching2SignalingNetInfo
+{
+	le_t<u32> size;
+	SceNetInAddr localAddr;
+	SceNetInAddr mappedAddr;
+	le_t<s32> natStatus;
+};
+
+extern psv_log_base sceNpMatching;

rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp

@@ -2,66 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceNpCommon.h"
+#include "sceNpScore.h"
 
-extern psv_log_base sceNpScore;
+s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::ptr<void> option)
-
-typedef u32 SceNpScoreBoardId;
-typedef s64 SceNpScoreValue;
-typedef u32 SceNpScoreRankNumber;
-typedef s32 SceNpScorePcId;
-
-struct SceNpScoreGameInfo
-{
-	u32 infoSize;
-	u8 pad[4];
-	u8 data[192];
-};
-
-struct SceNpScoreComment
-{
-	char utf8Comment[64];
-};
-
-struct SceNpScoreRankData
-{
-	SceNpId npId;
-	u8 reserved[49];
-	u8 pad0[3];
-	SceNpScorePcId pcId;
-	SceNpScoreRankNumber serialRank;
-	SceNpScoreRankNumber rank;
-	SceNpScoreRankNumber highestRank;
-	s32 hasGameData;
-	u8 pad1[4];
-	SceNpScoreValue scoreValue;
-	u64 recordDate;
-};
-
-struct SceNpScorePlayerRankData
-{
-	s32 hasData;
-	u8 pad0[4];
-	SceNpScoreRankData rankData;
-};
-
-struct SceNpScoreBoardInfo
-{
-	u32 rankLimit;
-	u32 updateMode;
-	u32 sortMode;
-	u32 uploadNumLimit;
-	u32 uploadSizeLimit;
-};
-
-struct SceNpScoreNpIdPcId
-{
-	SceNpId npId;
-	SceNpScorePcId pcId;
-	u8 pad[4];
-};
-
-s32 sceNpScoreInit(s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -71,7 +14,7 @@ s32 sceNpScoreTerm(ARMv7Context&)
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpCommunicationPassphrase> passphrase, vm::psv::ptr<const SceNpId> selfNpId)
+s32 sceNpScoreCreateTitleCtx(vm::ptr<const SceNpCommunicationId> titleId, vm::ptr<const SceNpCommunicationPassphrase> passphrase, vm::ptr<const SceNpId> selfNpId)
 {
 	throw __FUNCTION__;
 }
@@ -101,86 +44,86 @@ s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connT
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreSetPlayerCharacterId(s32 id, SceNpScorePcId pcId)
+s32 sceNpScoreSetPlayerCharacterId(s32 id, s32 pcId)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreGetBoardInfo(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
+s32 sceNpScoreGetBoardInfo(s32 reqId, u32 boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreRecordScore(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	SceNpScoreValue score,
+	s64 score,
-	vm::psv::ptr<const SceNpScoreComment> scoreComment,
+	vm::ptr<const SceNpScoreComment> scoreComment,
-	vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::ptr<const SceNpScoreGameInfo> gameInfo,
-	vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
+	vm::ptr<u32> tmpRank,
-	vm::psv::ptr<const u64> compareDate,
+	vm::ptr<const u64> compareDate,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreRecordGameData(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	SceNpScoreValue score,
+	s64 score,
 	u32 totalSize,
 	u32 sendSize,
-	vm::psv::ptr<const void> data,
+	vm::ptr<const void> data,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetGameData(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	vm::psv::ptr<const SceNpId> npId,
+	vm::ptr<const SceNpId> npId,
-	vm::psv::ptr<u32> totalSize,
+	vm::ptr<u32> totalSize,
 	u32 recvSize,
-	vm::psv::ptr<void> data,
+	vm::ptr<void> data,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetRankingByNpId(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	vm::psv::ptr<const SceNpId> npIdArray,
+	vm::ptr<const SceNpId> npIdArray,
 	u32 npIdArraySize,
-	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
-	vm::psv::ptr<SceNpScoreComment> commentArray,
+	vm::ptr<SceNpScoreComment> commentArray,
 	u32 commentArraySize,
-	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	vm::ptr<SceNpScoreGameInfo> infoArray,
 	u32 infoArraySize,
 	u32 arrayNum,
-	vm::psv::ptr<u64> lastSortDate,
+	vm::ptr<u64> lastSortDate,
-	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::ptr<u32> totalRecord,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetRankingByRange(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	SceNpScoreRankNumber startSerialRank,
+	u32 startSerialRank,
-	vm::psv::ptr<SceNpScoreRankData> rankArray,
+	vm::ptr<SceNpScoreRankData> rankArray,
 	u32 rankArraySize,
-	vm::psv::ptr<SceNpScoreComment> commentArray,
+	vm::ptr<SceNpScoreComment> commentArray,
 	u32 commentArraySize,
-	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	vm::ptr<SceNpScoreGameInfo> infoArray,
 	u32 infoArraySize,
 	u32 arrayNum,
-	vm::psv::ptr<u64> lastSortDate,
+	vm::ptr<u64> lastSortDate,
-	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::ptr<u32> totalRecord,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -188,147 +131,147 @@ s32 sceNpScoreGetRankingByRange(
 
 s32 sceNpScoreGetRankingByNpIdPcId(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
+	vm::ptr<const SceNpScoreNpIdPcId> idArray,
 	u32 idArraySize,
-	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
-	vm::psv::ptr<SceNpScoreComment> commentArray,
+	vm::ptr<SceNpScoreComment> commentArray,
 	u32 commentArraySize,
-	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	vm::ptr<SceNpScoreGameInfo> infoArray,
 	u32 infoArraySize,
 	u32 arrayNum,
-	vm::psv::ptr<u64> lastSortDate,
+	vm::ptr<u64> lastSortDate,
-	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::ptr<u32> totalRecord,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreCensorComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
+s32 sceNpScoreCensorComment(s32 reqId, vm::ptr<const char> comment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreSanitizeComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
+s32 sceNpScoreSanitizeComment(s32 reqId, vm::ptr<const char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreWaitAsync(s32 id, vm::psv::ptr<s32> result)
+s32 sceNpScoreWaitAsync(s32 id, vm::ptr<s32> result)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScorePollAsync(s32 reqId, vm::psv::ptr<s32> result)
+s32 sceNpScorePollAsync(s32 reqId, vm::ptr<s32> result)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreGetBoardInfoAsync(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
+s32 sceNpScoreGetBoardInfoAsync(s32 reqId, u32 boardId, vm::ptr<SceNpScoreBoardInfo> boardInfo, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreRecordScoreAsync(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	SceNpScoreValue score,
+	s64 score,
-	vm::psv::ptr<const SceNpScoreComment> scoreComment,
+	vm::ptr<const SceNpScoreComment> scoreComment,
-	vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::ptr<const SceNpScoreGameInfo> gameInfo,
-	vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
+	vm::ptr<u32> tmpRank,
-	vm::psv::ptr<const u64> compareDate,
+	vm::ptr<const u64> compareDate,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreRecordGameDataAsync(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	SceNpScoreValue score,
+	s64 score,
 	u32 totalSize,
 	u32 sendSize,
-	vm::psv::ptr<const void> data,
+	vm::ptr<const void> data,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetGameDataAsync(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	vm::psv::ptr<const SceNpId> npId,
+	vm::ptr<const SceNpId> npId,
-	vm::psv::ptr<u32> totalSize,
+	vm::ptr<u32> totalSize,
 	u32 recvSize,
-	vm::psv::ptr<void> data,
+	vm::ptr<void> data,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetRankingByNpIdAsync(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	vm::psv::ptr<const SceNpId> npIdArray,
+	vm::ptr<const SceNpId> npIdArray,
 	u32 npIdArraySize,
-	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
-	vm::psv::ptr<SceNpScoreComment> commentArray,
+	vm::ptr<SceNpScoreComment> commentArray,
 	u32 commentArraySize,
-	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	vm::ptr<SceNpScoreGameInfo> infoArray,
 	u32 infoArraySize,
 	u32 arrayNum,
-	vm::psv::ptr<u64> lastSortDate,
+	vm::ptr<u64> lastSortDate,
-	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::ptr<u32> totalRecord,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetRankingByRangeAsync(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	SceNpScoreRankNumber startSerialRank,
+	u32 startSerialRank,
-	vm::psv::ptr<SceNpScoreRankData> rankArray,
+	vm::ptr<SceNpScoreRankData> rankArray,
 	u32 rankArraySize,
-	vm::psv::ptr<SceNpScoreComment> commentArray,
+	vm::ptr<SceNpScoreComment> commentArray,
 	u32 commentArraySize,
-	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	vm::ptr<SceNpScoreGameInfo> infoArray,
 	u32 infoArraySize,
 	u32 arrayNum,
-	vm::psv::ptr<u64> lastSortDate,
+	vm::ptr<u64> lastSortDate,
-	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::ptr<u32> totalRecord,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
 s32 sceNpScoreGetRankingByNpIdPcIdAsync(
 	s32 reqId,
-	SceNpScoreBoardId boardId,
+	u32 boardId,
-	vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
+	vm::ptr<const SceNpScoreNpIdPcId> idArray,
 	u32 idArraySize,
-	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	vm::ptr<SceNpScorePlayerRankData> rankArray,
 	u32 rankArraySize,
-	vm::psv::ptr<SceNpScoreComment> commentArray,
+	vm::ptr<SceNpScoreComment> commentArray,
 	u32 commentArraySize,
-	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	vm::ptr<SceNpScoreGameInfo> infoArray,
 	u32 infoArraySize,
 	u32 arrayNum,
-	vm::psv::ptr<u64> lastSortDate,
+	vm::ptr<u64> lastSortDate,
-	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::ptr<u32> totalRecord,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<void> option)
+s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::ptr<const char> comment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::ptr<char> sanitizedComment, vm::psv::ptr<void> option)
+s32 sceNpScoreSanitizeCommentAsync(s32 reqId, vm::ptr<const char> comment, vm::ptr<char> sanitizedComment, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -340,6 +283,7 @@ psv_log_base sceNpScore("SceNpScore", []()
 	sceNpScore.on_load = nullptr;
 	sceNpScore.on_unload = nullptr;
 	sceNpScore.on_stop = nullptr;
+	sceNpScore.on_error = nullptr;
 
 	REG_FUNC(0x0433069F, sceNpScoreInit);
 	REG_FUNC(0x2050F98F, sceNpScoreTerm);

rpcs3/Emu/ARMv7/Modules/sceNpScore.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "sceNpCommon.h"
+
+struct SceNpScoreGameInfo
+{
+	le_t<u32> infoSize;
+	u8 pad[4];
+	u8 data[192];
+};
+
+struct SceNpScoreComment
+{
+	char utf8Comment[64];
+};
+
+struct SceNpScoreRankData
+{
+	SceNpId npId;
+	u8 reserved[49];
+	u8 pad0[3];
+	le_t<s32> pcId;
+	le_t<u32> serialRank;
+	le_t<u32> rank;
+	le_t<u32> highestRank;
+	le_t<s32> hasGameData;
+	u8 pad1[4];
+	le_t<s64> scoreValue;
+	le_t<u64> recordDate;
+};
+
+struct SceNpScorePlayerRankData
+{
+	le_t<s32> hasData;
+	u8 pad0[4];
+	SceNpScoreRankData rankData;
+};
+
+struct SceNpScoreBoardInfo
+{
+	le_t<u32> rankLimit;
+	le_t<u32> updateMode;
+	le_t<u32> sortMode;
+	le_t<u32> uploadNumLimit;
+	le_t<u32> uploadSizeLimit;
+};
+
+struct SceNpScoreNpIdPcId
+{
+	SceNpId npId;
+	le_t<s32> pcId;
+	u8 pad[4];
+};
+
+extern psv_log_base sceNpScore;

rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp

@@ -2,19 +2,9 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-#include "sceNpCommon.h"
+#include "sceNpUtility.h"
 
-extern psv_log_base sceNpUtility;
+s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::ptr<void> option)
-
-struct SceNpBandwidthTestResult
-{
-	double uploadBps;
-	double downloadBps;
-	s32 result;
-	char padding[4];
-};
-
-s32 sceNpLookupInit(s32 usesAsync, s32 threadPriority, s32 cpuAffinityMask, vm::psv::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -24,7 +14,7 @@ s32 sceNpLookupTerm(ARMv7Context&)
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpId> selfNpId)
+s32 sceNpLookupCreateTitleCtx(vm::ptr<const SceNpCommunicationId> titleId, vm::ptr<const SceNpId> selfNpId)
 {
 	throw __FUNCTION__;
 }
@@ -54,22 +44,22 @@ s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 conn
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupWaitAsync(s32 reqId, vm::psv::ptr<s32> result)
+s32 sceNpLookupWaitAsync(s32 reqId, vm::ptr<s32> result)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupPollAsync(s32 reqId, vm::psv::ptr<s32> result)
+s32 sceNpLookupPollAsync(s32 reqId, vm::ptr<s32> result)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupNpId(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
+s32 sceNpLookupNpId(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
+s32 sceNpLookupNpIdAsync(s32 reqId, vm::ptr<const SceNpOnlineId> onlineId, vm::ptr<SceNpId> npId, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -77,15 +67,15 @@ s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId,
 s32 sceNpLookupUserProfile(
 	s32 reqId,
 	s32 avatarSizeType,
-	vm::psv::ptr<const SceNpId> npId,
+	vm::ptr<const SceNpId> npId,
-	vm::psv::ptr<SceNpUserInformation> userInfo,
+	vm::ptr<SceNpUserInformation> userInfo,
-	vm::psv::ptr<SceNpAboutMe> aboutMe,
+	vm::ptr<SceNpAboutMe> aboutMe,
-	vm::psv::ptr<SceNpMyLanguages> languages,
+	vm::ptr<SceNpMyLanguages> languages,
-	vm::psv::ptr<SceNpCountryCode> countryCode,
+	vm::ptr<SceNpCountryCode> countryCode,
-	vm::psv::ptr<void> avatarImageData,
+	vm::ptr<void> avatarImageData,
 	u32 avatarImageDataMaxSize,
-	vm::psv::ptr<u32> avatarImageDataSize,
+	vm::ptr<u32> avatarImageDataSize,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -93,25 +83,25 @@ s32 sceNpLookupUserProfile(
 s32 sceNpLookupUserProfileAsync(
 	s32 reqId,
 	s32 avatarSizeType,
-	vm::psv::ptr<const SceNpId> npId,
+	vm::ptr<const SceNpId> npId,
-	vm::psv::ptr<SceNpUserInformation> userInfo,
+	vm::ptr<SceNpUserInformation> userInfo,
-	vm::psv::ptr<SceNpAboutMe> aboutMe,
+	vm::ptr<SceNpAboutMe> aboutMe,
-	vm::psv::ptr<SceNpMyLanguages> languages,
+	vm::ptr<SceNpMyLanguages> languages,
-	vm::psv::ptr<SceNpCountryCode> countryCode,
+	vm::ptr<SceNpCountryCode> countryCode,
-	vm::psv::ptr<void> avatarImageData,
+	vm::ptr<void> avatarImageData,
 	u32 avatarImageDataMaxSize,
-	vm::psv::ptr<u32> avatarImageDataSize,
+	vm::ptr<u32> avatarImageDataSize,
-	vm::psv::ptr<void> option)
+	vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupAvatarImage(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
+s32 sceNpLookupAvatarImage(s32 reqId, vm::ptr<const SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
+s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::ptr<const SceNpAvatarUrl> avatarUrl, vm::ptr<SceNpAvatarImage> avatarImage, vm::ptr<void> option)
 {
 	throw __FUNCTION__;
 }
@@ -126,7 +116,7 @@ s32 sceNpBandwidthTestGetStatus()
 	throw __FUNCTION__;
 }
 
-s32 sceNpBandwidthTestShutdown(vm::psv::ptr<SceNpBandwidthTestResult> result)
+s32 sceNpBandwidthTestShutdown(vm::ptr<SceNpBandwidthTestResult> result)
 {
 	throw __FUNCTION__;
 }
@@ -143,6 +133,7 @@ psv_log_base sceNpUtility("SceNpUtility", []()
 	sceNpUtility.on_load = nullptr;
 	sceNpUtility.on_unload = nullptr;
 	sceNpUtility.on_stop = nullptr;
+	sceNpUtility.on_error = nullptr;
 
 	REG_FUNC(0x9246A673, sceNpLookupInit);
 	REG_FUNC(0x0158B61B, sceNpLookupTerm);

rpcs3/Emu/ARMv7/Modules/sceNpUtility.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "sceNpCommon.h"
+
+struct SceNpBandwidthTestResult
+{
+	le_t<double> uploadBps;
+	le_t<double> downloadBps;
+	le_t<s32> result;
+	char padding[4];
+};
+
+extern psv_log_base sceNpUtility;

rpcs3/Emu/ARMv7/Modules/scePerf.cpp

@@ -2,102 +2,10 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
+#include "scePerf.h"
+
 extern u64 get_system_time();
 
-#define RETURN_ERROR(code) { Emu.Pause(); scePerf.Error("%s() failed: %s", __FUNCTION__, #code); return code; }
-
-extern psv_log_base scePerf;
-
-enum
-{
-	// Error Codes
-	SCE_PERF_ERROR_INVALID_ARGUMENT = 0x80580000,
-};
-
-enum : s32
-{
-	// Thread IDs
-	SCE_PERF_ARM_PMON_THREAD_ID_ALL = -1,
-	SCE_PERF_ARM_PMON_THREAD_ID_SELF = 0,
-};
-
-enum : u32
-{
-	// Counter Numbers
-	SCE_PERF_ARM_PMON_CYCLE_COUNTER = 31,
-	SCE_PERF_ARM_PMON_COUNTER_5 = 5,
-	SCE_PERF_ARM_PMON_COUNTER_4 = 4,
-	SCE_PERF_ARM_PMON_COUNTER_3 = 3,
-	SCE_PERF_ARM_PMON_COUNTER_2 = 2,
-	SCE_PERF_ARM_PMON_COUNTER_1 = 1,
-	SCE_PERF_ARM_PMON_COUNTER_0 = 0,
-
-	// Counter Masks
-	SCE_PERF_ARM_PMON_COUNTER_MASK_5 = 0x20,
-	SCE_PERF_ARM_PMON_COUNTER_MASK_4 = 0x10,
-	SCE_PERF_ARM_PMON_COUNTER_MASK_3 = 0x08,
-	SCE_PERF_ARM_PMON_COUNTER_MASK_2 = 0x04,
-	SCE_PERF_ARM_PMON_COUNTER_MASK_1 = 0x02,
-	SCE_PERF_ARM_PMON_COUNTER_MASK_0 = 0x01,
-	SCE_PERF_ARM_PMON_COUNTER_MASK_ALL = 0x3f,
-};
-
-enum : u8
-{
-	// Performance Counter Events
-	SCE_PERF_ARM_PMON_SOFT_INCREMENT = 0x00,
-	SCE_PERF_ARM_PMON_ICACHE_MISS = 0x01,
-	SCE_PERF_ARM_PMON_ITLB_MISS = 0x02,
-	SCE_PERF_ARM_PMON_DCACHE_MISS = 0x03,
-	SCE_PERF_ARM_PMON_DCACHE_ACCESS = 0x04,
-	SCE_PERF_ARM_PMON_DTLB_MISS = 0x05,
-	SCE_PERF_ARM_PMON_DATA_READ = 0x06,
-	SCE_PERF_ARM_PMON_DATA_WRITE = 0x07,
-	SCE_PERF_ARM_PMON_EXCEPTION_TAKEN = 0x09,
-	SCE_PERF_ARM_PMON_EXCEPTION_RETURN = 0x0A,
-	SCE_PERF_ARM_PMON_WRITE_CONTEXTID = 0x0B,
-	SCE_PERF_ARM_PMON_SOFT_CHANGEPC = 0x0C,
-	SCE_PERF_ARM_PMON_IMMEDIATE_BRANCH = 0x0D,
-	SCE_PERF_ARM_PMON_UNALIGNED = 0x0F,
-	SCE_PERF_ARM_PMON_BRANCH_MISPREDICT = 0x10,
-	SCE_PERF_ARM_PMON_PREDICT_BRANCH = 0x12,
-	SCE_PERF_ARM_PMON_COHERENT_LF_MISS = 0x50,
-	SCE_PERF_ARM_PMON_COHERENT_LF_HIT = 0x51,
-	SCE_PERF_ARM_PMON_ICACHE_STALL = 0x60,
-	SCE_PERF_ARM_PMON_DCACHE_STALL = 0x61,
-	SCE_PERF_ARM_PMON_MAINTLB_STALL = 0x62,
-	SCE_PERF_ARM_PMON_STREX_PASSED = 0x63,
-	SCE_PERF_ARM_PMON_STREX_FAILED = 0x64,
-	SCE_PERF_ARM_PMON_DATA_EVICTION = 0x65,
-	SCE_PERF_ARM_PMON_ISSUE_NO_DISPATCH = 0x66,
-	SCE_PERF_ARM_PMON_ISSUE_EMPTY = 0x67,
-	SCE_PERF_ARM_PMON_INST_RENAME = 0x68,
-	SCE_PERF_ARM_PMON_PREDICT_FUNC_RET = 0x6E,
-	SCE_PERF_ARM_PMON_MAIN_PIPE = 0x70,
-	SCE_PERF_ARM_PMON_SECOND_PIPE = 0x71,
-	SCE_PERF_ARM_PMON_LS_PIPE = 0x72,
-	SCE_PERF_ARM_PMON_FPU_RENAME = 0x73,
-	SCE_PERF_ARM_PMON_PLD_STALL = 0x80,
-	SCE_PERF_ARM_PMON_WRITE_STALL = 0x81,
-	SCE_PERF_ARM_PMON_INST_MAINTLB_STALL = 0x82,
-	SCE_PERF_ARM_PMON_DATA_MAINTLB_STALL = 0x83,
-	SCE_PERF_ARM_PMON_INST_UTLB_STALL = 0x84,
-	SCE_PERF_ARM_PMON_DATA_UTLB_STALL = 0x85,
-	SCE_PERF_ARM_PMON_DMB_STALL = 0x86,
-	SCE_PERF_ARM_PMON_INTEGER_CLOCK = 0x8A,
-	SCE_PERF_ARM_PMON_DATAENGINE_CLOCK = 0x8B,
-	SCE_PERF_ARM_PMON_ISB = 0x90,
-	SCE_PERF_ARM_PMON_DSB = 0x91,
-	SCE_PERF_ARM_PMON_DMB = 0x92,
-	SCE_PERF_ARM_PMON_EXT_INTERRUPT = 0x93,
-	SCE_PERF_ARM_PMON_PLE_LINE_REQ_COMPLETED = 0xA0,
-	SCE_PERF_ARM_PMON_PLE_CHANNEL_SKIPPED = 0xA1,
-	SCE_PERF_ARM_PMON_PLE_FIFO_FLUSH = 0xA2,
-	SCE_PERF_ARM_PMON_PLE_REQ_COMPLETED = 0xA3,
-	SCE_PERF_ARM_PMON_PLE_FIFO_OVERFLOW = 0xA4,
-	SCE_PERF_ARM_PMON_PLE_REQ_PROGRAMMED = 0xA5,
-};
-
 s32 scePerfArmPmonReset(ARMv7Context& context, s32 threadId)
 {
 	scePerf.Warning("scePerfArmPmonReset(threadId=0x%x)", threadId);
@@ -123,7 +31,7 @@ s32 scePerfArmPmonSelectEvent(ARMv7Context& context, s32 threadId, u32 counter,
 
 	if (counter >= 6)
 	{
-		RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
+		return SCE_PERF_ERROR_INVALID_ARGUMENT;
 	}
 
 	u32 value = 0; // initial value
@@ -185,7 +93,7 @@ s32 scePerfArmPmonStop(ARMv7Context& context, s32 threadId)
 	return SCE_OK;
 }
 
-s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 counter, vm::psv::ptr<u32> pValue)
+s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 counter, vm::ptr<u32> pValue)
 {
 	scePerf.Warning("scePerfArmPmonGetCounterValue(threadId=0x%x, counter=%d, pValue=*0x%x)", threadId, counter, pValue);
 
@@ -196,7 +104,7 @@ s32 scePerfArmPmonGetCounterValue(ARMv7Context& context, s32 threadId, u32 count
 
 	if (counter >= 6 && counter != SCE_PERF_ARM_PMON_CYCLE_COUNTER)
 	{
-		RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
+		return SCE_PERF_ERROR_INVALID_ARGUMENT;
 	}
 
 	if (counter < 6)
@@ -217,7 +125,7 @@ s32 scePerfArmPmonSoftwareIncrement(ARMv7Context& context, u32 mask)
 
 	if (mask > SCE_PERF_ARM_PMON_COUNTER_MASK_ALL)
 	{
-		RETURN_ERROR(SCE_PERF_ERROR_INVALID_ARGUMENT);
+		return SCE_PERF_ERROR_INVALID_ARGUMENT;
 	}
 
 	for (u32 i = 0; i < 6; i++, mask >>= 1)
@@ -245,12 +153,12 @@ u32 scePerfGetTimebaseFrequency()
 	return 1;
 }
 
-s32 _sceRazorCpuInit(vm::psv::ptr<const void> pBufferBase, u32 bufferSize, u32 numPerfCounters, vm::psv::pptr<u32> psceRazorVars)
+s32 _sceRazorCpuInit(vm::cptr<void> pBufferBase, u32 bufferSize, u32 numPerfCounters, vm::pptr<u32> psceRazorVars)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRazorCpuPushMarker(vm::psv::ptr<const char> szLabel)
+s32 sceRazorCpuPushMarker(vm::cptr<char> szLabel)
 {
 	throw __FUNCTION__;
 }
@@ -272,6 +180,7 @@ psv_log_base scePerf("ScePerf", []()
 	scePerf.on_load = nullptr;
 	scePerf.on_unload = nullptr;
 	scePerf.on_stop = nullptr;
+	//scePerf.on_error = nullptr; // keep default error handler
 
 	REG_FUNC(0x35151735, scePerfArmPmonReset);
 	REG_FUNC(0x63CBEA8B, scePerfArmPmonSelectEvent);

rpcs3/Emu/ARMv7/Modules/scePerf.h

@@ -0,0 +1,93 @@
+#pragma once
+
+enum
+{
+	// Error Codes
+	SCE_PERF_ERROR_INVALID_ARGUMENT = 0x80580000,
+};
+
+enum : s32
+{
+	// Thread IDs
+	SCE_PERF_ARM_PMON_THREAD_ID_ALL = -1,
+	SCE_PERF_ARM_PMON_THREAD_ID_SELF = 0,
+};
+
+enum : u32
+{
+	// Counter Numbers
+	SCE_PERF_ARM_PMON_CYCLE_COUNTER = 31,
+	SCE_PERF_ARM_PMON_COUNTER_5 = 5,
+	SCE_PERF_ARM_PMON_COUNTER_4 = 4,
+	SCE_PERF_ARM_PMON_COUNTER_3 = 3,
+	SCE_PERF_ARM_PMON_COUNTER_2 = 2,
+	SCE_PERF_ARM_PMON_COUNTER_1 = 1,
+	SCE_PERF_ARM_PMON_COUNTER_0 = 0,
+
+	// Counter Masks
+	SCE_PERF_ARM_PMON_COUNTER_MASK_5 = 0x20,
+	SCE_PERF_ARM_PMON_COUNTER_MASK_4 = 0x10,
+	SCE_PERF_ARM_PMON_COUNTER_MASK_3 = 0x08,
+	SCE_PERF_ARM_PMON_COUNTER_MASK_2 = 0x04,
+	SCE_PERF_ARM_PMON_COUNTER_MASK_1 = 0x02,
+	SCE_PERF_ARM_PMON_COUNTER_MASK_0 = 0x01,
+	SCE_PERF_ARM_PMON_COUNTER_MASK_ALL = 0x3f,
+};
+
+enum : u8
+{
+	// Performance Counter Events
+	SCE_PERF_ARM_PMON_SOFT_INCREMENT = 0x00,
+	SCE_PERF_ARM_PMON_ICACHE_MISS = 0x01,
+	SCE_PERF_ARM_PMON_ITLB_MISS = 0x02,
+	SCE_PERF_ARM_PMON_DCACHE_MISS = 0x03,
+	SCE_PERF_ARM_PMON_DCACHE_ACCESS = 0x04,
+	SCE_PERF_ARM_PMON_DTLB_MISS = 0x05,
+	SCE_PERF_ARM_PMON_DATA_READ = 0x06,
+	SCE_PERF_ARM_PMON_DATA_WRITE = 0x07,
+	SCE_PERF_ARM_PMON_EXCEPTION_TAKEN = 0x09,
+	SCE_PERF_ARM_PMON_EXCEPTION_RETURN = 0x0A,
+	SCE_PERF_ARM_PMON_WRITE_CONTEXTID = 0x0B,
+	SCE_PERF_ARM_PMON_SOFT_CHANGEPC = 0x0C,
+	SCE_PERF_ARM_PMON_IMMEDIATE_BRANCH = 0x0D,
+	SCE_PERF_ARM_PMON_UNALIGNED = 0x0F,
+	SCE_PERF_ARM_PMON_BRANCH_MISPREDICT = 0x10,
+	SCE_PERF_ARM_PMON_PREDICT_BRANCH = 0x12,
+	SCE_PERF_ARM_PMON_COHERENT_LF_MISS = 0x50,
+	SCE_PERF_ARM_PMON_COHERENT_LF_HIT = 0x51,
+	SCE_PERF_ARM_PMON_ICACHE_STALL = 0x60,
+	SCE_PERF_ARM_PMON_DCACHE_STALL = 0x61,
+	SCE_PERF_ARM_PMON_MAINTLB_STALL = 0x62,
+	SCE_PERF_ARM_PMON_STREX_PASSED = 0x63,
+	SCE_PERF_ARM_PMON_STREX_FAILED = 0x64,
+	SCE_PERF_ARM_PMON_DATA_EVICTION = 0x65,
+	SCE_PERF_ARM_PMON_ISSUE_NO_DISPATCH = 0x66,
+	SCE_PERF_ARM_PMON_ISSUE_EMPTY = 0x67,
+	SCE_PERF_ARM_PMON_INST_RENAME = 0x68,
+	SCE_PERF_ARM_PMON_PREDICT_FUNC_RET = 0x6E,
+	SCE_PERF_ARM_PMON_MAIN_PIPE = 0x70,
+	SCE_PERF_ARM_PMON_SECOND_PIPE = 0x71,
+	SCE_PERF_ARM_PMON_LS_PIPE = 0x72,
+	SCE_PERF_ARM_PMON_FPU_RENAME = 0x73,
+	SCE_PERF_ARM_PMON_PLD_STALL = 0x80,
+	SCE_PERF_ARM_PMON_WRITE_STALL = 0x81,
+	SCE_PERF_ARM_PMON_INST_MAINTLB_STALL = 0x82,
+	SCE_PERF_ARM_PMON_DATA_MAINTLB_STALL = 0x83,
+	SCE_PERF_ARM_PMON_INST_UTLB_STALL = 0x84,
+	SCE_PERF_ARM_PMON_DATA_UTLB_STALL = 0x85,
+	SCE_PERF_ARM_PMON_DMB_STALL = 0x86,
+	SCE_PERF_ARM_PMON_INTEGER_CLOCK = 0x8A,
+	SCE_PERF_ARM_PMON_DATAENGINE_CLOCK = 0x8B,
+	SCE_PERF_ARM_PMON_ISB = 0x90,
+	SCE_PERF_ARM_PMON_DSB = 0x91,
+	SCE_PERF_ARM_PMON_DMB = 0x92,
+	SCE_PERF_ARM_PMON_EXT_INTERRUPT = 0x93,
+	SCE_PERF_ARM_PMON_PLE_LINE_REQ_COMPLETED = 0xA0,
+	SCE_PERF_ARM_PMON_PLE_CHANNEL_SKIPPED = 0xA1,
+	SCE_PERF_ARM_PMON_PLE_FIFO_FLUSH = 0xA2,
+	SCE_PERF_ARM_PMON_PLE_REQ_COMPLETED = 0xA3,
+	SCE_PERF_ARM_PMON_PLE_FIFO_OVERFLOW = 0xA4,
+	SCE_PERF_ARM_PMON_PLE_REQ_PROGRAMMED = 0xA5,
+};
+
+extern psv_log_base scePerf;

rpcs3/Emu/ARMv7/Modules/scePgf.cpp

@@ -2,7 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base scePgf;
+#include "scePgf.h"
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &scePgf, #name, name)
 
@@ -11,6 +11,7 @@ psv_log_base scePgf("ScePgf", []()
 	scePgf.on_load = nullptr;
 	scePgf.on_unload = nullptr;
 	scePgf.on_stop = nullptr;
+	scePgf.on_error = nullptr;
 
 	//REG_FUNC(0x1055ABA3, sceFontNewLib);
 	//REG_FUNC(0x07EE1733, sceFontDoneLib);

rpcs3/Emu/ARMv7/Modules/scePgf.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base scePgf;

rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp

@@ -2,39 +2,28 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base scePhotoExport;
+#include "scePhotoExport.h"
-
-struct ScePhotoExportParam
-{
-	u32 version;
-	vm::psv::ptr<const char> photoTitle;
-	vm::psv::ptr<const char> gameTitle;
-	vm::psv::ptr<const char> gameComment;
-	char reserved[32];
-};
-
-typedef vm::psv::ptr<s32(vm::psv::ptr<void>)> ScePhotoExportCancelFunc;
 
 s32 scePhotoExportFromData(
-	vm::psv::ptr<const void> photodata,
+	vm::ptr<const void> photodata,
 	s32 photodataSize,
-	vm::psv::ptr<const ScePhotoExportParam> param,
+	vm::ptr<const ScePhotoExportParam> param,
-	vm::psv::ptr<void> workMemory,
+	vm::ptr<void> workMemory,
-	ScePhotoExportCancelFunc cancelFunc,
+	vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
-	vm::psv::ptr<void> userdata,
+	vm::ptr<void> userdata,
-	vm::psv::ptr<char> exportedPath,
+	vm::ptr<char> exportedPath,
 	s32 exportedPathLength)
 {
 	throw __FUNCTION__;
 }
 
 s32 scePhotoExportFromFile(
-	vm::psv::ptr<const char> photodataPath,
+	vm::ptr<const char> photodataPath,
-	vm::psv::ptr<const ScePhotoExportParam> param,
+	vm::ptr<const ScePhotoExportParam> param,
-	vm::psv::ptr<void> workMemory,
+	vm::ptr<void> workMemory,
-	ScePhotoExportCancelFunc cancelFunc,
+	vm::ptr<ScePhotoExportCancelFunc> cancelFunc,
-	vm::psv::ptr<void> userdata,
+	vm::ptr<void> userdata,
-	vm::psv::ptr<char> exportedPath,
+	vm::ptr<char> exportedPath,
 	s32 exportedPathLength)
 {
 	throw __FUNCTION__;
@@ -47,6 +36,7 @@ psv_log_base scePhotoExport("ScePhotoExport", []()
 	scePhotoExport.on_load = nullptr;
 	scePhotoExport.on_unload = nullptr;
 	scePhotoExport.on_stop = nullptr;
+	scePhotoExport.on_error = nullptr;
 
 	REG_FUNC(0x70512321, scePhotoExportFromData);
 	REG_FUNC(0x84FD9FC5, scePhotoExportFromFile);

rpcs3/Emu/ARMv7/Modules/scePhotoExport.h

@@ -0,0 +1,14 @@
+#pragma once
+
+struct ScePhotoExportParam
+{
+	le_t<u32> version;
+	vm::lcptr<char> photoTitle;
+	vm::lcptr<char> gameTitle;
+	vm::lcptr<char> gameComment;
+	char reserved[32];
+};
+
+using ScePhotoExportCancelFunc = func_def<s32(vm::ptr<void>)>;
+
+extern psv_log_base scePhotoExport;

rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp

@@ -2,14 +2,14 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceRazorCapture;
+#include "sceRazorCapture.h"
 
-void sceRazorCaptureSetTrigger(u32 frameIndex, vm::psv::ptr<const char> captureFilename)
+void sceRazorCaptureSetTrigger(u32 frameIndex, vm::ptr<const char> captureFilename)
 {
 	throw __FUNCTION__;
 }
 
-void sceRazorCaptureSetTriggerNextFrame(vm::psv::ptr<const char> captureFilename)
+void sceRazorCaptureSetTriggerNextFrame(vm::ptr<const char> captureFilename)
 {
 	throw __FUNCTION__;
 }
@@ -26,6 +26,7 @@ psv_log_base sceRazorCapture("SceRazorCapture", []()
 	sceRazorCapture.on_load = nullptr;
 	sceRazorCapture.on_unload = nullptr;
 	sceRazorCapture.on_stop = nullptr;
+	sceRazorCapture.on_error = nullptr;
 
 	REG_FUNC(0x911E0AA0, sceRazorCaptureIsInProgress);
 	REG_FUNC(0xE916B538, sceRazorCaptureSetTrigger);

rpcs3/Emu/ARMv7/Modules/sceRazorCapture.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceRazorCapture;

rpcs3/Emu/ARMv7/Modules/sceRtc.cpp

@@ -2,39 +2,39 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceRtc;
+#include "sceRtc.h"
 
 u32 sceRtcGetTickResolution()
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetCurrentTick(vm::psv::ptr<u64> pTick)
+s32 sceRtcGetCurrentTick(vm::ptr<u64> pTick)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetCurrentClock(vm::psv::ptr<SceDateTime> pTime, s32 iTimeZone)
+s32 sceRtcGetCurrentClock(vm::ptr<SceDateTime> pTime, s32 iTimeZone)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetCurrentClockLocalTime(vm::psv::ptr<SceDateTime> pTime)
+s32 sceRtcGetCurrentClockLocalTime(vm::ptr<SceDateTime> pTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetCurrentNetworkTick(vm::psv::ptr<u64> pTick)
+s32 sceRtcGetCurrentNetworkTick(vm::ptr<u64> pTick)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcConvertUtcToLocalTime(vm::psv::ptr<const u64> pUtc, vm::psv::ptr<u64> pLocalTime)
+s32 sceRtcConvertUtcToLocalTime(vm::ptr<const u64> pUtc, vm::ptr<u64> pLocalTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcConvertLocalTimeToUtc(vm::psv::ptr<const u64> pLocalTime, vm::psv::ptr<u64> pUtc)
+s32 sceRtcConvertLocalTimeToUtc(vm::ptr<const u64> pLocalTime, vm::ptr<u64> pUtc)
 {
 	throw __FUNCTION__;
 }
@@ -54,137 +54,137 @@ s32 sceRtcGetDayOfWeek(s32 year, s32 month, s32 day)
 	throw __FUNCTION__;
 }
 
-s32 sceRtcCheckValid(vm::psv::ptr<const SceDateTime> pTime)
+s32 sceRtcCheckValid(vm::ptr<const SceDateTime> pTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcSetTime_t(vm::psv::ptr<SceDateTime> pTime, u32 iTime)
+s32 sceRtcSetTime_t(vm::ptr<SceDateTime> pTime, u32 iTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcSetTime64_t(vm::psv::ptr<SceDateTime> pTime, u64 ullTime)
+s32 sceRtcSetTime64_t(vm::ptr<SceDateTime> pTime, u64 ullTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetTime_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> piTime)
+s32 sceRtcGetTime_t(vm::ptr<const SceDateTime> pTime, vm::ptr<u32> piTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetTime64_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pullTime)
+s32 sceRtcGetTime64_t(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> pullTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcSetDosTime(vm::psv::ptr<SceDateTime> pTime, u32 uiDosTime)
+s32 sceRtcSetDosTime(vm::ptr<SceDateTime> pTime, u32 uiDosTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetDosTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> puiDosTime)
+s32 sceRtcGetDosTime(vm::ptr<const SceDateTime> pTime, vm::ptr<u32> puiDosTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcSetWin32FileTime(vm::psv::ptr<SceDateTime> pTime, u64 ulWin32Time)
+s32 sceRtcSetWin32FileTime(vm::ptr<SceDateTime> pTime, u64 ulWin32Time)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetWin32FileTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> ulWin32Time)
+s32 sceRtcGetWin32FileTime(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> ulWin32Time)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcSetTick(vm::psv::ptr<SceDateTime> pTime, vm::psv::ptr<const u64> pTick)
+s32 sceRtcSetTick(vm::ptr<SceDateTime> pTime, vm::ptr<const u64> pTick)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcGetTick(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pTick)
+s32 sceRtcGetTick(vm::ptr<const SceDateTime> pTime, vm::ptr<u64> pTick)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcCompareTick(vm::psv::ptr<const u64> pTick1, vm::psv::ptr<const u64> pTick2)
+s32 sceRtcCompareTick(vm::ptr<const u64> pTick1, vm::ptr<const u64> pTick2)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddTicks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddTicks(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddMicroseconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddMicroseconds(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddSeconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddSeconds(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddMinutes(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+s32 sceRtcTickAddMinutes(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, u64 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddHours(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddHours(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddDays(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddDays(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddWeeks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddWeeks(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddMonths(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddMonths(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcTickAddYears(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+s32 sceRtcTickAddYears(vm::ptr<u64> pTick0, vm::ptr<const u64> pTick1, s32 lAdd)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC2822(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
+s32 sceRtcFormatRFC2822(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC2822LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
+s32 sceRtcFormatRFC2822LocalTime(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC3339(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
+s32 sceRtcFormatRFC3339(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcFormatRFC3339LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
+s32 sceRtcFormatRFC3339LocalTime(vm::ptr<char> pszDateTime, vm::ptr<const u64> pUtc)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcParseDateTime(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
+s32 sceRtcParseDateTime(vm::ptr<u64> pUtc, vm::ptr<const char> pszDateTime)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceRtcParseRFC3339(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
+s32 sceRtcParseRFC3339(vm::ptr<u64> pUtc, vm::ptr<const char> pszDateTime)
 {
 	throw __FUNCTION__;
 }
@@ -197,6 +197,7 @@ psv_log_base sceRtc("SceRtc", []()
 	sceRtc.on_load = nullptr;
 	sceRtc.on_unload = nullptr;
 	sceRtc.on_stop = nullptr;
+	sceRtc.on_error = nullptr;
 
 	REG_FUNC(0x23F79274, sceRtcGetCurrentTick);
 	REG_FUNC(0xCDDD25FE, sceRtcGetCurrentNetworkTick);

rpcs3/Emu/ARMv7/Modules/sceRtc.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceRtc;

rpcs3/Emu/ARMv7/Modules/sceSas.cpp

@@ -2,24 +2,24 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceSas;
+#include "sceSas.h"
 
-s32 sceSasGetNeededMemorySize(vm::psv::ptr<const char> config, vm::psv::ptr<u32> outSize)
+s32 sceSasGetNeededMemorySize(vm::ptr<const char> config, vm::ptr<u32> outSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasInit(vm::psv::ptr<const char> config, vm::psv::ptr<void> buffer, u32 bufferSize)
+s32 sceSasInit(vm::ptr<const char> config, vm::ptr<void> buffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasInitWithGrain(vm::psv::ptr<const char> config, u32 grain, vm::psv::ptr<void> buffer, u32 bufferSize)
+s32 sceSasInitWithGrain(vm::ptr<const char> config, u32 grain, vm::ptr<void> buffer, u32 bufferSize)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasExit(vm::psv::pptr<void> outBuffer, vm::psv::ptr<u32> outBufferSize)
+s32 sceSasExit(vm::pptr<void> outBuffer, vm::ptr<u32> outBufferSize)
 {
 	throw __FUNCTION__;
 }
@@ -44,22 +44,22 @@ s32 sceSasGetOutputmode()
 	throw __FUNCTION__;
 }
 
-s32 sceSasCore(vm::psv::ptr<s16> out)
+s32 sceSasCore(vm::ptr<s16> out)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasCoreWithMix(vm::psv::ptr<s16> inOut, s32 lvol, s32 rvol)
+s32 sceSasCoreWithMix(vm::ptr<s16> inOut, s32 lvol, s32 rvol)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasSetVoice(s32 iVoiceNum, vm::psv::ptr<const void> vagBuf, u32 size, u32 loopflag)
+s32 sceSasSetVoice(s32 iVoiceNum, vm::ptr<const void> vagBuf, u32 size, u32 loopflag)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::psv::ptr<const void> pcmBuf, u32 size, s32 loopsize)
+s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::ptr<const void> pcmBuf, u32 size, s32 loopsize)
 {
 	throw __FUNCTION__;
 }
@@ -157,6 +157,7 @@ psv_log_base sceSas("SceSas", []()
 	sceSas.on_load = nullptr;
 	sceSas.on_unload = nullptr;
 	sceSas.on_stop = nullptr;
+	sceSas.on_error = nullptr;
 
 	//REG_FUNC(0xA2209C58, sceAsSetRegisterReportHandler);
 	//REG_FUNC(0xBB635544, sceAsSetUnregisterReportHandler);

rpcs3/Emu/ARMv7/Modules/sceSas.h

@@ -0,0 +1,3 @@
+#pragma once
+
+extern psv_log_base sceSas;

rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp

@@ -2,22 +2,14 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceScreenShot;
+#include "sceScreenShot.h"
 
-struct SceScreenShotParam
+s32 sceScreenShotSetParam(vm::ptr<const SceScreenShotParam> param)
-{
-	vm::psv::ptr<const char> photoTitle;
-	vm::psv::ptr<const char> gameTitle;
-	vm::psv::ptr<const char> gameComment;
-	vm::psv::ptr<void> reserved;
-};
-
-s32 sceScreenShotSetParam(vm::psv::ptr<const SceScreenShotParam> param)
 {
 	throw __FUNCTION__;
 }
 
-s32 sceScreenShotSetOverlayImage(vm::psv::ptr<const char> filePath, s32 offsetX, s32 offsetY)
+s32 sceScreenShotSetOverlayImage(vm::ptr<const char> filePath, s32 offsetX, s32 offsetY)
 {
 	throw __FUNCTION__;
 }
@@ -40,6 +32,7 @@ psv_log_base sceScreenShot("SceScreenShot", []()
 	sceScreenShot.on_load = nullptr;
 	sceScreenShot.on_unload = nullptr;
 	sceScreenShot.on_stop = nullptr;
+	sceScreenShot.on_error = nullptr;
 
 	REG_FUNC(0x05DB59C7, sceScreenShotSetParam);
 	REG_FUNC(0x7061665B, sceScreenShotSetOverlayImage);

rpcs3/Emu/ARMv7/Modules/sceScreenShot.h

@@ -0,0 +1,11 @@
+#pragma once
+
+struct SceScreenShotParam
+{
+	vm::lcptr<char> photoTitle;
+	vm::lcptr<char> gameTitle;
+	vm::lcptr<char> gameComment;
+	vm::lptr<void> reserved;
+};
+
+extern psv_log_base sceScreenShot;

rpcs3/Emu/ARMv7/Modules/sceSfmt.cpp

@@ -11,6 +11,7 @@ psv_log_base sceSfmt("SceSfmt", []()
 	sceSfmt.on_load = nullptr;
 	sceSfmt.on_unload = nullptr;
 	sceSfmt.on_stop = nullptr;
+	sceSfmt.on_error = nullptr;
 
 	//REG_FUNC(0x8FF464C9, sceSfmt11213InitGenRand);
 	//REG_FUNC(0xBAF5F058, sceSfmt11213InitByArray);

rpcs3/Emu/ARMv7/Modules/sceSha.cpp

@@ -11,6 +11,7 @@ psv_log_base sceSha("SceSha", []()
 	sceSha.on_load = nullptr;
 	sceSha.on_unload = nullptr;
 	sceSha.on_stop = nullptr;
+	sceSha.on_error = nullptr;
 
 	//REG_FUNC(0xD19A9AA8, sceSha0Digest);
 	//REG_FUNC(0xBCF6DB3A, sceSha0BlockInit);

rpcs3/Emu/ARMv7/Modules/sceSqlite.cpp

@@ -2,7 +2,7 @@
 #include "Emu/System.h"
 #include "Emu/ARMv7/PSVFuncList.h"
 
-extern psv_log_base sceSqlite;
+#include "sceSqlite.h"
 
 #define REG_FUNC(nid, name) reg_psv_func(nid, &sceSqlite, #name, name)
 
@@ -11,6 +11,7 @@ psv_log_base sceSqlite("SceSqlite", []()
 	sceSqlite.on_load = nullptr;
 	sceSqlite.on_unload = nullptr;
 	sceSqlite.on_stop = nullptr;
+	sceSqlite.on_error = nullptr;
 
 	//REG_FUNC(0x26E46324, sqlite3_libversion);
 	//REG_FUNC(0x4CCB58A2, sqlite3_sourceid);