Fix conflicts 2

rpcs3/Emu/ARMv7/ARMv7Decoder.cpp

@@ -29,8 +29,6 @@ struct ARMv7_opcode_t
 
 const ARMv7_opcode_t ARMv7_opcode_table[] =
 {
-	ARMv7_OP2(0xffff, 0x0000, T1, NULL_OP), // ???
-
 	ARMv7_OP4(0xffff, 0x0000, 0xf870, 0x0000, T1, HACK), // "Undefined" Thumb opcode used
 	ARMv7_OP4(0x0ff0, 0x00f0, 0x0070, 0x0090, A1, HACK), // "Undefined" ARM opcode used
 

rpcs3/Emu/ARMv7/ARMv7Interpreter.cpp

@@ -283,11 +283,6 @@ void ARMv7_instrs::UNK(ARMv7Context& context, const ARMv7Code code)
 	throw fmt::format("Unknown/illegal opcode: 0x%04x 0x%04x", code.code1, code.code0);
 }
 
-void ARMv7_instrs::NULL_OP(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
-{
-	throw fmt::format("Null opcode found: 0x%04x 0x%04x", code.code1, code.code0);
-}
-
 void ARMv7_instrs::HACK(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type)
 {
 	u32 cond, func;

rpcs3/Emu/ARMv7/ARMv7Interpreter.h

@@ -30,10 +30,7 @@ namespace ARMv7_instrs
 {
 	void UNK(ARMv7Context& context, const ARMv7Code code);
 
-	void NULL_OP(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
-
 	void HACK(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
-
 	void MRC_(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);
 
 	void ADC_IMM(ARMv7Context& context, const ARMv7Code code, const ARMv7_encoding type);

rpcs3/Emu/ARMv7/Modules/sceAppMgr.cpp

@@ -0,0 +1,48 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceAppMgr;
+
+struct SceAppMgrEvent
+{
+	s32 event;
+	s32 appId;
+	char param[56];
+};
+
+s32 sceAppMgrReceiveEventNum(vm::psv::ptr<s32> eventNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppMgrReceiveEvent(vm::psv::ptr<SceAppMgrEvent> appEvent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppMgrAcquireBgmPort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppMgrReleaseBgmPort()
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAppMgr, #name, name)
+
+psv_log_base sceAppMgr("SceAppMgr", []()
+{
+	sceAppMgr.on_load = nullptr;
+	sceAppMgr.on_unload = nullptr;
+	sceAppMgr.on_stop = nullptr;
+
+	REG_FUNC(0x47E5DD7D, sceAppMgrReceiveEventNum);
+	REG_FUNC(0xCFAD5A3A, sceAppMgrReceiveEvent);
+	REG_FUNC(0xF3D65520, sceAppMgrAcquireBgmPort);
+	REG_FUNC(0x96CBE713, sceAppMgrReleaseBgmPort);
+	//REG_FUNC(0x49255C91, sceAppMgrGetRunStatus);
+});

rpcs3/Emu/ARMv7/Modules/sceAppUtil.cpp

@@ -0,0 +1,94 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceAppUtil.h"
+
+s32 sceAppUtilInit(vm::psv::ptr<const SceAppUtilInitParam> initParam, vm::psv::ptr<SceAppUtilBootParam> bootParam)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilShutdown()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSaveDataSlotCreate(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSaveDataSlotDelete(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSaveDataSlotSetParam(u32 slotId, vm::psv::ptr<const SceAppUtilSaveDataSlotParam> param, vm::psv::ptr<const SceAppUtilSaveDataMountPoint> mountPoint)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSaveDataSlotGetParam(u32 slotId, vm::psv::ptr<SceAppUtilSaveDataSlotParam> param, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilPhotoMount()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilPhotoUmount()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSystemParamGetInt(u32 paramId, vm::psv::ptr<s32> value)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSystemParamGetString(u32 paramId, vm::psv::ptr<char> buf, u32 bufSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilSaveSafeMemory(vm::psv::ptr<const void> buf, u32 bufSize, s64 offset)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAppUtilLoadSafeMemory(vm::psv::ptr<void> buf, u32 bufSize, s64 offset)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAppUtil, #name, name)
+
+psv_log_base sceAppUtil("SceAppUtil", []()
+{
+	sceAppUtil.on_load = nullptr;
+	sceAppUtil.on_unload = nullptr;
+	sceAppUtil.on_stop = nullptr;
+
+	REG_FUNC(0xDAFFE671, sceAppUtilInit);
+	REG_FUNC(0xB220B00B, sceAppUtilShutdown);
+	REG_FUNC(0x7E8FE96A, sceAppUtilSaveDataSlotCreate);
+	REG_FUNC(0x266A7646, sceAppUtilSaveDataSlotDelete);
+	REG_FUNC(0x98630136, sceAppUtilSaveDataSlotSetParam);
+	REG_FUNC(0x93F0D89F, sceAppUtilSaveDataSlotGetParam);
+	REG_FUNC(0x1E2A6158, sceAppUtilSaveDataFileSave);
+	REG_FUNC(0xEE85804D, sceAppUtilPhotoMount);
+	REG_FUNC(0x9651B941, sceAppUtilPhotoUmount);
+	REG_FUNC(0x5DFB9CA0, sceAppUtilSystemParamGetInt);
+	REG_FUNC(0x6E6AA267, sceAppUtilSystemParamGetString);
+	REG_FUNC(0x9D8AC677, sceAppUtilSaveSafeMemory);
+	REG_FUNC(0x3424D772, sceAppUtilLoadSafeMemory);
+});

rpcs3/Emu/ARMv7/Modules/sceAppUtil.h

@@ -0,0 +1,69 @@
+#pragma once
+
+struct SceAppUtilInitParam
+{
+	u32 workBufSize;
+	char reserved[60];
+};
+
+struct SceAppUtilBootParam
+{
+	u32 attr;
+	u32 appVersion;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataMountPoint
+{
+	char data[16];
+};
+
+struct SceAppUtilSaveDataSlotParam
+{
+	u32 status;
+	char title[64];
+	char subTitle[128];
+	char detail[512];
+	char iconPath[64];
+	s32 userParam;
+	u32 sizeKB;
+	SceDateTime modifiedTime;
+	char reserved[48];
+};
+
+struct SceAppUtilSaveDataSlotEmptyParam
+{
+	vm::psv::ptr<char> title;
+	vm::psv::ptr<char> iconPath;
+	vm::psv::ptr<void> iconBuf;
+	u32 iconBufSize;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataSlot
+{
+	u32 id;
+	u32 status;
+	s32 userParam;
+	vm::psv::ptr<SceAppUtilSaveDataSlotEmptyParam> emptyParam;
+};
+
+struct SceAppUtilSaveDataFile
+{
+	vm::psv::ptr<const char> filePath;
+	vm::psv::ptr<void> buf;
+	u32 bufSize;
+	s64 offset;
+	u32 mode;
+	u32 progDelta;
+	char reserved[32];
+};
+
+struct SceAppUtilSaveDataFileSlot
+{
+	u32 id;
+	vm::psv::ptr<SceAppUtilSaveDataSlotParam> slotParam;
+	char reserved[32];
+};
+
+extern psv_log_base sceAppUtil;

rpcs3/Emu/ARMv7/Modules/sceAudio.cpp

@@ -0,0 +1,65 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceAudio;
+
+s32 sceAudioOutOpenPort(s32 portType, s32 len, s32 freq, s32 param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutReleasePort(s32 port)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutOutput(s32 port, vm::psv::ptr<void> ptr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutSetVolume(s32 port, s32 flag, vm::psv::ptr<s32> vol)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutSetConfig(s32 port, s32 len, s32 freq, s32 param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutGetConfig(s32 port, s32 configType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutGetRestSample(s32 port)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioOutGetAdopt(s32 portType)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudio, #name, name)
+
+psv_log_base sceAudio("SceAudio", []()
+{
+	sceAudio.on_load = nullptr;
+	sceAudio.on_unload = nullptr;
+	sceAudio.on_stop = nullptr;
+
+	REG_FUNC(0x5BC341E4, sceAudioOutOpenPort);
+	REG_FUNC(0x69E2E6B5, sceAudioOutReleasePort);
+	REG_FUNC(0x02DB3F5F, sceAudioOutOutput);
+	REG_FUNC(0x64167F11, sceAudioOutSetVolume);
+	REG_FUNC(0xB8BA0D07, sceAudioOutSetConfig);
+	REG_FUNC(0x9C8EDAEA, sceAudioOutGetConfig);
+	REG_FUNC(0x9A5370C4, sceAudioOutGetRestSample);
+	REG_FUNC(0x12FB1767, sceAudioOutGetAdopt);
+	//REG_FUNC(0xC6D8D775, sceAudioInRaw);
+});

rpcs3/Emu/ARMv7/Modules/sceAudioIn.cpp

@@ -0,0 +1,35 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceAudioIn;
+
+s32 sceAudioInOpenPort(s32 portType, s32 grain, s32 freq, s32 param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioInReleasePort(s32 port)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioInInput(s32 port, vm::psv::ptr<void> destPtr)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudioIn, #name, name)
+
+psv_log_base sceAudioIn("SceAudioIn", []()
+{
+	sceAudioIn.on_load = nullptr;
+	sceAudioIn.on_unload = nullptr;
+	sceAudioIn.on_stop = nullptr;
+
+	REG_FUNC(0x638ADD2D, sceAudioInInput);
+	REG_FUNC(0x39B50DC1, sceAudioInOpenPort);
+	REG_FUNC(0x3A61B8C4, sceAudioInReleasePort);
+	//REG_FUNC(0x566AC433, sceAudioInGetAdopt);
+});

rpcs3/Emu/ARMv7/Modules/sceAudiodec.cpp

@@ -0,0 +1,138 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceAudiodec;
+
+struct SceAudiodecInitStreamParam
+{
+	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__;
+}
+
+s32 sceAudiodecTermLibrary(u32 codecType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudiodecCreateDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl, u32 codecType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudiodecDeleteDecoder(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudiodecDecode(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudiodecClearContext(vm::psv::ptr<SceAudiodecCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudiodecGetInternalError(vm::psv::ptr<SceAudiodecCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudiodec, #name, name)
+
+psv_log_base sceAudiodec("SceAudiodec", []()
+{
+	sceAudiodec.on_load = nullptr;
+	sceAudiodec.on_unload = nullptr;
+	sceAudiodec.on_stop = nullptr;
+
+	REG_FUNC(0x445C2CEF, sceAudiodecInitLibrary);
+	REG_FUNC(0x45719B9D, sceAudiodecTermLibrary);
+	REG_FUNC(0x4DFD3AAA, sceAudiodecCreateDecoder);
+	REG_FUNC(0xE7A24E16, sceAudiodecDeleteDecoder);
+	REG_FUNC(0xCCDABA04, sceAudiodecDecode);
+	REG_FUNC(0xF72F9B64, sceAudiodecClearContext);
+	REG_FUNC(0x883B0CF5, sceAudiodecGetInternalError);
+});

rpcs3/Emu/ARMv7/Modules/sceAudioenc.cpp

@@ -0,0 +1,121 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceAudioenc;
+
+struct SceAudioencInitStreamParam
+{
+	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__;
+}
+
+s32 sceAudioencTermLibrary(u32 codecType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioencCreateEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl, u32 codecType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioencDeleteEncoder(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioencEncode(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioencClearContext(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioencGetOptInfo(vm::psv::ptr<SceAudioencCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAudioencGetInternalError(vm::psv::ptr<SceAudioencCtrl> pCtrl, vm::psv::ptr<s32> pInternalError)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceAudioenc, #name, name)
+
+psv_log_base sceAudioenc("SceAudioenc", []()
+{
+	sceAudioenc.on_load = nullptr;
+	sceAudioenc.on_unload = nullptr;
+	sceAudioenc.on_stop = nullptr;
+
+	REG_FUNC(0x76EE4DC6, sceAudioencInitLibrary);
+	REG_FUNC(0xAB32D022, sceAudioencTermLibrary);
+	REG_FUNC(0x64C04AE8, sceAudioencCreateEncoder);
+	REG_FUNC(0xC6BA5EE6, sceAudioencDeleteEncoder);
+	REG_FUNC(0xD85DB29C, sceAudioencEncode);
+	REG_FUNC(0x9386F42D, sceAudioencClearContext);
+	REG_FUNC(0xD01C63A3, sceAudioencGetOptInfo);
+	REG_FUNC(0x452246D0, sceAudioencGetInternalError);
+});

rpcs3/Emu/ARMv7/Modules/sceCamera.cpp

@@ -0,0 +1,299 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceCamera;
+
+struct SceCameraInfo
+{
+	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__;
+}
+
+s32 sceCameraClose(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraStart(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraStop(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraRead(s32 devnum, vm::psv::ptr<SceCameraRead> pRead)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraIsActive(s32 devnum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSaturation(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSaturation(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetBrightness(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetBrightness(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetContrast(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetContrast(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSharpness(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSharpness(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetReverse(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetReverse(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetEffect(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetEffect(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetEV(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetEV(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetZoom(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetZoom(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetAntiFlicker(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetAntiFlicker(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetISO(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetISO(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetGain(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetGain(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetWhiteBalance(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetWhiteBalance(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetBacklight(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetBacklight(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetNightmode(s32 devnum, vm::psv::ptr<s32> pMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetNightmode(s32 devnum, s32 mode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraLedSwitch(s32 devnum, s32 iSwitch)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraLedBlink(s32 devnum, s32 iOnCount, s32 iOffCount, s32 iBlinkCount)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetNoiseReductionForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetNoiseReductionForDebug(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraGetSharpnessOffForDebug(s32 devnum, vm::psv::ptr<s32> pLevel)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCameraSetSharpnessOffForDebug(s32 devnum, s32 level)
+{
+	throw __FUNCTION__;
+}
+
+void sceCameraUseCacheMemoryForTrial(s32 isCache)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCamera, #name, name)
+
+psv_log_base sceCamera("SceCamera", []()
+{
+	sceCamera.on_load = nullptr;
+	sceCamera.on_unload = nullptr;
+	sceCamera.on_stop = nullptr;
+
+	REG_FUNC(0xA462F801, sceCameraOpen);
+	REG_FUNC(0xCD6E1CFC, sceCameraClose);
+	REG_FUNC(0xA8FEAE35, sceCameraStart);
+	REG_FUNC(0x1DD9C9CE, sceCameraStop);
+	REG_FUNC(0x79B5C2DE, sceCameraRead);
+	REG_FUNC(0x103A75B8, sceCameraIsActive);
+	REG_FUNC(0x624F7653, sceCameraGetSaturation);
+	REG_FUNC(0xF9F7CA3D, sceCameraSetSaturation);
+	REG_FUNC(0x85D5951D, sceCameraGetBrightness);
+	REG_FUNC(0x98D71588, sceCameraSetBrightness);
+	REG_FUNC(0x8FBE84BE, sceCameraGetContrast);
+	REG_FUNC(0x06FB2900, sceCameraSetContrast);
+	REG_FUNC(0xAA72C3DC, sceCameraGetSharpness);
+	REG_FUNC(0xD1A5BB0B, sceCameraSetSharpness);
+	REG_FUNC(0x44F6043F, sceCameraGetReverse);
+	REG_FUNC(0x1175F477, sceCameraSetReverse);
+	REG_FUNC(0x7E8EF3B2, sceCameraGetEffect);
+	REG_FUNC(0xE9D2CFB1, sceCameraSetEffect);
+	REG_FUNC(0x8B5E6147, sceCameraGetEV);
+	REG_FUNC(0x62AFF0B8, sceCameraSetEV);
+	REG_FUNC(0x06D3816C, sceCameraGetZoom);
+	REG_FUNC(0xF7464216, sceCameraSetZoom);
+	REG_FUNC(0x9FDACB99, sceCameraGetAntiFlicker);
+	REG_FUNC(0xE312958A, sceCameraSetAntiFlicker);
+	REG_FUNC(0x4EBD5C68, sceCameraGetISO);
+	REG_FUNC(0x3CF630A1, sceCameraSetISO);
+	REG_FUNC(0x2C36D6F3, sceCameraGetGain);
+	REG_FUNC(0xE65CFE86, sceCameraSetGain);
+	REG_FUNC(0xDBFFA1DA, sceCameraGetWhiteBalance);
+	REG_FUNC(0x4D4514AC, sceCameraSetWhiteBalance);
+	REG_FUNC(0x8DD1292B, sceCameraGetBacklight);
+	REG_FUNC(0xAE071044, sceCameraSetBacklight);
+	REG_FUNC(0x12B6FF26, sceCameraGetNightmode);
+	REG_FUNC(0x3F26233E, sceCameraSetNightmode);
+	REG_FUNC(0xD02CFA5C, sceCameraLedSwitch);
+	REG_FUNC(0x89B16030, sceCameraLedBlink);
+	REG_FUNC(0x7670474C, sceCameraUseCacheMemoryForTrial);
+	REG_FUNC(0x27BB0528, sceCameraGetNoiseReductionForDebug);
+	REG_FUNC(0x233C9E27, sceCameraSetNoiseReductionForDebug);
+	REG_FUNC(0xC387F4DC, sceCameraGetSharpnessOffForDebug);
+	REG_FUNC(0xE22C2375, sceCameraSetSharpnessOffForDebug);
+});

rpcs3/Emu/ARMv7/Modules/sceCodecEngine.cpp

@@ -0,0 +1,46 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceCodecEngine;
+
+struct SceCodecEnginePmonProcessorLoad
+{
+	u32 size;
+	u32 average;
+};
+
+s32 sceCodecEnginePmonStart()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonStop()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonGetProcessorLoad(vm::psv::ptr<SceCodecEnginePmonProcessorLoad> pProcessorLoad)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceCodecEnginePmonReset()
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCodecEngine, #name, name)
+
+psv_log_base sceCodecEngine("SceCodecEngine", []()
+{
+	sceCodecEngine.on_load = nullptr;
+	sceCodecEngine.on_unload = nullptr;
+	sceCodecEngine.on_stop = nullptr;
+
+	REG_FUNC(0x3E718890, sceCodecEnginePmonStart);
+	REG_FUNC(0x268B1EF5, sceCodecEnginePmonStop);
+	REG_FUNC(0x859E4A68, sceCodecEnginePmonGetProcessorLoad);
+	REG_FUNC(0xA097E4C8, sceCodecEnginePmonReset);
+});

rpcs3/Emu/ARMv7/Modules/sceCommonDialog.cpp

@@ -0,0 +1,556 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceGxm.h"
+#include "sceAppUtil.h"
+#include "sceIme.h"
+
+extern psv_log_base sceCommonDialog;
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceMsgDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogGetResult(vm::psv::ptr<SceMsgDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogClose()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogProgressBarInc(s32 target, u32 delta)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMsgDialogProgressBarSetValue(s32 target, u32 rate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogInit(vm::psv::ptr<SceNetCheckDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceNetCheckDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogGetResult(vm::psv::ptr<SceNetCheckDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCheckDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogInit(vm::psv::ptr<const SceSaveDataDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceSaveDataDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogGetResult(vm::psv::ptr<SceSaveDataDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceSaveDataDialogGetSubStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogSubClose()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogContinue(vm::psv::ptr<const SceSaveDataDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogFinish(vm::psv::ptr<const SceSaveDataDialogFinishParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogProgressBarInc(s32 target, u32 delta)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSaveDataDialogProgressBarSetValue(s32 target, u32 rate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogInit(vm::psv::ptr<const SceImeDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus sceImeDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogGetResult(vm::psv::ptr<SceImeDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogInit(vm::psv::ptr<const ScePhotoImportDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus scePhotoImportDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogGetResult(vm::psv::ptr<ScePhotoImportDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoImportDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogInit(vm::psv::ptr<const ScePhotoReviewDialogParam> param)
+{
+	throw __FUNCTION__;
+}
+
+SceCommonDialogStatus scePhotoReviewDialogGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogGetResult(vm::psv::ptr<ScePhotoReviewDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoReviewDialogAbort()
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceCommonDialog, #name, name)
+
+psv_log_base sceCommonDialog("SceCommonDialog", []()
+{
+	sceCommonDialog.on_load = nullptr;
+	sceCommonDialog.on_unload = nullptr;
+	sceCommonDialog.on_stop = nullptr;
+
+	REG_FUNC(0x90530F2F, sceCommonDialogUpdate);
+	REG_FUNC(0x755FF270, sceMsgDialogInit);
+	REG_FUNC(0x4107019E, sceMsgDialogGetStatus);
+	REG_FUNC(0xC296D396, sceMsgDialogClose);
+	REG_FUNC(0x0CC66115, sceMsgDialogAbort);
+	REG_FUNC(0xBB3BFC89, sceMsgDialogGetResult);
+	REG_FUNC(0x81ACF695, sceMsgDialogTerm);
+	REG_FUNC(0x7BE0E08B, sceMsgDialogProgressBarInc);
+	REG_FUNC(0x9CDA5E0D, sceMsgDialogProgressBarSetValue);
+	REG_FUNC(0xA38A4A0D, sceNetCheckDialogInit);
+	REG_FUNC(0x8027292A, sceNetCheckDialogGetStatus);
+	REG_FUNC(0x2D8EDF09, sceNetCheckDialogAbort);
+	REG_FUNC(0xB05FCE9E, sceNetCheckDialogGetResult);
+	REG_FUNC(0x8BE51C15, sceNetCheckDialogTerm);
+	REG_FUNC(0xBF5248FA, sceSaveDataDialogInit);
+	REG_FUNC(0x6E258046, sceSaveDataDialogGetStatus);
+	REG_FUNC(0x013E7F74, sceSaveDataDialogAbort);
+	REG_FUNC(0xB2FF576E, sceSaveDataDialogGetResult);
+	REG_FUNC(0x2192A10A, sceSaveDataDialogTerm);
+	REG_FUNC(0x19192C8B, sceSaveDataDialogContinue);
+	REG_FUNC(0xBA0542CA, sceSaveDataDialogGetSubStatus);
+	REG_FUNC(0x415D6068, sceSaveDataDialogSubClose);
+	REG_FUNC(0x6C49924B, sceSaveDataDialogFinish);
+	REG_FUNC(0xBDE00A83, sceSaveDataDialogProgressBarInc);
+	REG_FUNC(0x5C322D1E, sceSaveDataDialogProgressBarSetValue);
+	REG_FUNC(0x1E7043BF, sceImeDialogInit);
+	REG_FUNC(0xCF0431FD, sceImeDialogGetStatus);
+	REG_FUNC(0x594A220E, sceImeDialogAbort);
+	REG_FUNC(0x2EB3D046, sceImeDialogGetResult);
+	REG_FUNC(0x838A3AF4, sceImeDialogTerm);
+	REG_FUNC(0x73EE7C9C, scePhotoImportDialogInit);
+	REG_FUNC(0x032206D8, scePhotoImportDialogGetStatus);
+	REG_FUNC(0xD855414C, scePhotoImportDialogGetResult);
+	REG_FUNC(0x7FE5BD77, scePhotoImportDialogTerm);
+	REG_FUNC(0x4B125581, scePhotoImportDialogAbort);
+	REG_FUNC(0xCD990375, scePhotoReviewDialogInit);
+	REG_FUNC(0xF4F600CA, scePhotoReviewDialogGetStatus);
+	REG_FUNC(0xFFA35858, scePhotoReviewDialogGetResult);
+	REG_FUNC(0xC700B2DF, scePhotoReviewDialogTerm);
+	REG_FUNC(0x74FF2A8B, scePhotoReviewDialogAbort);
+});

rpcs3/Emu/ARMv7/Modules/sceDbg.cpp

@@ -0,0 +1,46 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceDbg;
+
+enum SceDbgBreakOnErrorState : s32
+{
+	SCE_DBG_DISABLE_BREAK_ON_ERROR = 0,
+	SCE_DBG_ENABLE_BREAK_ON_ERROR
+};
+
+s32 sceDbgSetMinimumLogLevel(s32 minimumLogLevel)
+{
+	throw __FUNCTION__;
+}
+
+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...
+{
+	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...
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceDbg, #name, name)
+
+psv_log_base sceDbg("SceDbg", []()
+{
+	sceDbg.on_load = nullptr;
+	sceDbg.on_unload = nullptr;
+	sceDbg.on_stop = nullptr;
+
+	REG_FUNC(0x941622FA, sceDbgSetMinimumLogLevel);
+	REG_FUNC(0x1AF3678B, sceDbgAssertionHandler);
+	REG_FUNC(0x6605AB19, sceDbgLoggingHandler);
+	REG_FUNC(0xED4A00BA, sceDbgSetBreakOnErrorState);
+});

rpcs3/Emu/ARMv7/Modules/sceDeci4p.cpp

@@ -4,7 +4,7 @@
 
 extern psv_log_base sceDeci4p;
 
-typedef s32(*SceKernelDeci4pCallback)(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon);
+typedef vm::psv::ptr<s32(s32 notifyId, s32 notifyCount, s32 notifyArg, vm::psv::ptr<void> pCommon)> SceKernelDeci4pCallback;
 
 s32 sceKernelDeci4pOpen(vm::psv::ptr<const char> protoname, u32 protonum, u32 bufsize)
 {
@@ -45,4 +45,4 @@ psv_log_base sceDeci4p("SceDeci4pUserp", []()
 	REG_FUNC(0x971E1C66, sceKernelDeci4pRead);
 	REG_FUNC(0xCDA3AAAC, sceKernelDeci4pWrite);
 	REG_FUNC(0x73371F35, sceKernelDeci4pRegisterCallback);
-});
+});

rpcs3/Emu/ARMv7/Modules/sceDeflt.cpp

@@ -0,0 +1,93 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceDeflt;
+
+s32 sceGzipIsValid(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceGzipGetInfo(vm::psv::ptr<const void> pSrcGzip, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<vm::psv::ptr<const char>> ppszName, vm::psv::ptr<vm::psv::ptr<const char>> ppszComment, vm::psv::ptr<u16> pusCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceGzipGetName(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceGzipGetComment(vm::psv::ptr<const void> pSrcGzip)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const void> sceGzipGetCompressedData(vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZlibIsValid(vm::psv::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::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const void> sceZlibGetCompressedData(vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceZlibAdler32(u32 uiAdler, vm::psv::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::ptr<vm::psv::ptr<const void>> ppNext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceZipGetInfo(vm::psv::ptr<const void> pSrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvExtra, vm::psv::ptr<u32> puiCrc, vm::psv::ptr<vm::psv::ptr<const void>> ppvData)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceDeflt, #name, name)
+
+psv_log_base sceDeflt("SceDeflt", []()
+{
+	sceDeflt.on_load = nullptr;
+	sceDeflt.on_unload = nullptr;
+	sceDeflt.on_stop = nullptr;
+
+	REG_FUNC(0xCD83A464, sceZlibAdler32);
+	REG_FUNC(0x110D5050, sceDeflateDecompress);
+	REG_FUNC(0xE3CB51A3, sceGzipDecompress);
+	REG_FUNC(0xBABCF5CF, sceGzipGetComment);
+	REG_FUNC(0xE1844802, sceGzipGetCompressedData);
+	REG_FUNC(0x1B8E5862, sceGzipGetInfo);
+	REG_FUNC(0xAEBAABE6, sceGzipGetName);
+	REG_FUNC(0xDEDADC31, sceGzipIsValid);
+	REG_FUNC(0xE38F754D, sceZlibDecompress);
+	REG_FUNC(0xE680A65A, sceZlibGetCompressedData);
+	REG_FUNC(0x4C0A685D, sceZlibGetInfo);
+	REG_FUNC(0x14A0698D, sceZlibIsValid);
+});

rpcs3/Emu/ARMv7/Modules/sceFiber.cpp

@@ -0,0 +1,103 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceFiber;
+
+typedef vm::psv::ptr<void(u32 argOnInitialize, u32 argOnRun)> SceFiberEntry;
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberFinalize(vm::psv::ptr<SceFiber> fiber)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberRun(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnReturn)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberSwitch(vm::psv::ptr<SceFiber> fiber, u32 argOnRunTo, vm::psv::ptr<u32> argOnRun)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberGetSelf(vm::psv::ptr<vm::psv::ptr<SceFiber>> fiber)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberReturnToThread(u32 argOnReturn, vm::psv::ptr<u32> argOnRun)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiberGetInfo(vm::psv::ptr<SceFiber> fiber, vm::psv::ptr<SceFiberInfo> fiberInfo)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFiber, #name, name)
+
+psv_log_base sceFiber("SceFiber", []()
+{
+	sceFiber.on_load = nullptr;
+	sceFiber.on_unload = nullptr;
+	sceFiber.on_stop = nullptr;
+
+	REG_FUNC(0xF24A298C, _sceFiberInitializeImpl);
+	//REG_FUNC(0xC6A3F9BB, _sceFiberInitializeWithInternalOptionImpl);
+	//REG_FUNC(0x7D0C7DDB, _sceFiberAttachContextAndRun);
+	//REG_FUNC(0xE00B9AFE, _sceFiberAttachContextAndSwitch);
+	REG_FUNC(0x801AB334, sceFiberOptParamInitialize);
+	REG_FUNC(0xE160F844, sceFiberFinalize);
+	REG_FUNC(0x7DF23243, sceFiberRun);
+	REG_FUNC(0xE4283144, sceFiberSwitch);
+	REG_FUNC(0x414D8CA5, sceFiberGetSelf);
+	REG_FUNC(0x3B42921F, sceFiberReturnToThread);
+	REG_FUNC(0x189599B4, sceFiberGetInfo);
+});

rpcs3/Emu/ARMv7/Modules/sceFios.cpp

@@ -0,0 +1,945 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceFios;
+
+typedef s64 SceFiosOffset;
+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__;
+}
+
+void sceFiosTerminate()
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsInitialized(vm::psv::ptr<SceFiosParams> pOutParameters)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosUpdateParameters(vm::psv::ptr<const SceFiosParams> pParameters)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosSetGlobalDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosGetGlobalDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosSetThreadDefaultOpAttr(vm::psv::ptr<const SceFiosOpAttr> pAttr)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosGetThreadDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosGetDefaultOpAttr(vm::psv::ptr<SceFiosOpAttr> pOutAttr)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosSuspend()
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetSuspendCount()
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsSuspended()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosResume()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosShutdownAndCancelOps()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosCancelAllOps()
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosCloseAllFiles()
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsIdle()
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetAllFHs(vm::psv::ptr<SceFiosFH> pOutArray, u32 arraySize)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetAllDHs(vm::psv::ptr<SceFiosDH> pOutArray, u32 arraySize)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceFiosGetAllOps(vm::psv::ptr<SceFiosOp> pOutArray, u32 arraySize)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosIsValidHandle(SceFiosHandle h)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosPathcmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosPathncmp(vm::psv::ptr<const char> pA, vm::psv::ptr<const char> pB, u32 n)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosPrintf(vm::psv::ptr<const char> pFormat) // va_args...
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosVprintf(vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosFileExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFileGetSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFileDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosDirectoryExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDirectoryCreate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDirectoryCreateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDirectoryDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDirectoryDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosExistsSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDelete(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDeleteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosResolveSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const SceFiosTuple> pInTuple, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosRenameSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pOldPath, vm::psv::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)
+{
+	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)
+{
+	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)
+{
+	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)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFileTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFileTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pPath, SceFiosSize 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)
+{
+	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)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHStat(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHStatSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<SceFiosStat> pOutStatus)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHTruncate(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHTruncateSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHSyncSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHWrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHWriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHReadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHWritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPread(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPreadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPwrite(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPwriteSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const void> pBuf, SceFiosSize length, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPreadv(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPreadvSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHPwritev(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHPwritevSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh, vm::psv::ptr<const SceFiosBuffer> iov, s32 iovcnt, SceFiosOffset offset)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosFHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosFHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOffset sceFiosFHSeek(SceFiosFH fh, SceFiosOffset offset, SceFiosWhence whence)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOffset sceFiosFHTell(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceFiosFHGetPath(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosFHGetSize(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<SceFiosOpenParams> sceFiosFHGetOpenParams(SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+//SceFiosOp sceFiosDHOpen(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
+//{
+//	throw __FUNCTION__;
+//}
+//
+//s32 sceFiosDHOpenSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<SceFiosDH> pOutDH, vm::psv::ptr<const char> pPath, SceFiosBuffer buf)
+//{
+//	throw __FUNCTION__;
+//}
+
+SceFiosOp sceFiosDHRead(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDHReadSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh, vm::psv::ptr<SceFiosDirEntry> pOutEntry)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOp sceFiosDHClose(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosDHCloseSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosDH dh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceFiosDHGetPath(SceFiosDH dh)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosOpIsDone(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpWait(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpWaitUntil(SceFiosOp op, SceFiosTime deadline)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosOpDelete(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpSyncWait(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosOpSyncWaitForIO(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOpGetError(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosOpCancel(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+bool sceFiosOpIsCancelled(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceFiosOpAttr> sceFiosOpGetAttr(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const char> sceFiosOpGetPath(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<void> sceFiosOpGetBuffer(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosOffset sceFiosOpGetOffset(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosOpGetRequestCount(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosOpGetActualCount(SceFiosOp op)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosOpReschedule(SceFiosOp op, SceFiosTime newDeadline)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosTime sceFiosTimeGetCurrent()
+{
+	throw __FUNCTION__;
+}
+
+s64 sceFiosTimeIntervalToNanoseconds(SceFiosTimeInterval interval)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosTimeInterval sceFiosTimeIntervalFromNanoseconds(s64 ns)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosDate sceFiosDateGetCurrent()
+{
+	throw __FUNCTION__;
+}
+
+SceFiosDate sceFiosDateFromComponents(const struct vm::psv::ptr<tm> pComponents)
+{
+	throw __FUNCTION__;
+}
+
+struct vm::psv::ptr<tm> sceFiosDateToComponents(SceFiosDate date, struct vm::psv::ptr<tm> pOutComponents)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosDate sceFiosDateFromSceDateTime(vm::psv::ptr<const SceDateTime> pSceDateTime)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<SceDateTime> sceFiosDateToSceDateTime(SceFiosDate date, vm::psv::ptr<SceDateTime> pSceDateTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayAdd(vm::psv::ptr<const SceFiosOverlay> pOverlay, vm::psv::ptr<SceFiosOverlayID> pOutID)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayRemove(SceFiosOverlayID id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayGetInfo(SceFiosOverlayID id, vm::psv::ptr<SceFiosOverlay> pOutOverlay)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayModify(SceFiosOverlayID id, vm::psv::ptr<const SceFiosOverlay> pNewValue)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayGetList(vm::psv::ptr<SceFiosOverlayID> pOutIDs, u32 maxIDs, vm::psv::ptr<u32> pActualIDs)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosOverlayResolveSync(s32 resolveFlag, vm::psv::ptr<const char> pInPath, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+SceFiosSize sceFiosArchiveGetMountBufferSizeSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, vm::psv::ptr<const char> pArchivePath, vm::psv::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)
+//{
+//	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)
+//{
+//	throw __FUNCTION__;
+//}
+
+SceFiosOp sceFiosArchiveUnmount(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosArchiveUnmountSync(vm::psv::ptr<const SceFiosOpAttr> pAttr, SceFiosFH fh)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpError(s32 err, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpOp(SceFiosOp op, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpFH(SceFiosFH fh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpDH(SceFiosDH dh, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<char> sceFiosDebugDumpDate(SceFiosDate date, vm::psv::ptr<char> pBuffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosIOFilterAdd(s32 index, SceFiosIOFilterCallback pFilterCallback, vm::psv::ptr<void> pFilterContext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosIOFilterGetInfo(s32 index, vm::psv::ptr<SceFiosIOFilterCallback> pOutFilterCallback, vm::psv::ptr<vm::psv::ptr<void>> pOutFilterContext)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceFiosIOFilterRemove(s32 index)
+{
+	throw __FUNCTION__;
+}
+
+void sceFiosIOFilterPsarcDearchiver()
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFios, #name, name)
+
+psv_log_base sceFios("SceFios2", []()
+{
+	sceFios.on_load = nullptr;
+	sceFios.on_unload = nullptr;
+	sceFios.on_stop = nullptr;
+
+	REG_FUNC(0x15857180, sceFiosArchiveGetMountBufferSize);
+	REG_FUNC(0xDF3352FC, sceFiosArchiveGetMountBufferSizeSync);
+	//REG_FUNC(0x92E76BBD, sceFiosArchiveMount);
+	//REG_FUNC(0xC4822276, sceFiosArchiveMountSync);
+	REG_FUNC(0xFE1E1D28, sceFiosArchiveUnmount);
+	REG_FUNC(0xB26DC24D, sceFiosArchiveUnmountSync);
+	REG_FUNC(0x1E920B1D, sceFiosCancelAllOps);
+	REG_FUNC(0xF85C208B, sceFiosCloseAllFiles);
+	REG_FUNC(0xF6CACFC7, sceFiosDHClose);
+	REG_FUNC(0x1F3CC428, sceFiosDHCloseSync);
+	REG_FUNC(0x2B406DEB, sceFiosDHGetPath);
+	//REG_FUNC(0xEA9855BA, sceFiosDHOpen);
+	//REG_FUNC(0x34BC3713, sceFiosDHOpenSync);
+	REG_FUNC(0x72A0A851, sceFiosDHRead);
+	REG_FUNC(0xB7E79CAD, sceFiosDHReadSync);
+	REG_FUNC(0x280D284A, sceFiosDateFromComponents);
+	REG_FUNC(0x5C593C1E, sceFiosDateGetCurrent);
+	REG_FUNC(0x5CFF6EA0, sceFiosDateToComponents);
+	REG_FUNC(0x44B9F8EB, sceFiosDebugDumpDH);
+	REG_FUNC(0x159B1FA8, sceFiosDebugDumpDate);
+	REG_FUNC(0x51E677DF, sceFiosDebugDumpError);
+	REG_FUNC(0x5506ACAB, sceFiosDebugDumpFH);
+	REG_FUNC(0xE438D4F0, sceFiosDebugDumpOp);
+	REG_FUNC(0x764DFA7A, sceFiosDelete);
+	REG_FUNC(0xAAC54B44, sceFiosDeleteSync);
+	REG_FUNC(0x9198ED8B, sceFiosDirectoryCreate);
+	REG_FUNC(0xE037B076, sceFiosDirectoryCreateSync);
+	REG_FUNC(0xDA93677C, sceFiosDirectoryDelete);
+	REG_FUNC(0xB9573146, sceFiosDirectoryDeleteSync);
+	REG_FUNC(0x48D50D97, sceFiosDirectoryExists);
+	REG_FUNC(0x726E01BE, sceFiosDirectoryExistsSync);
+	REG_FUNC(0x6F12D8A5, sceFiosExists);
+	REG_FUNC(0x125EFD34, sceFiosExistsSync);
+	REG_FUNC(0xA88EDCA8, sceFiosFHClose);
+	REG_FUNC(0x45182328, sceFiosFHCloseSync);
+	REG_FUNC(0xC55DB73B, sceFiosFHGetOpenParams);
+	REG_FUNC(0x37143AE3, sceFiosFHGetPath);
+	REG_FUNC(0xC5C26581, sceFiosFHGetSize);
+	REG_FUNC(0xBF699BD4, sceFiosFHOpen);
+	REG_FUNC(0xC3E7C3DB, sceFiosFHOpenSync);
+	REG_FUNC(0x6A51E688, sceFiosFHPread);
+	REG_FUNC(0xE2805059, sceFiosFHPreadSync);
+	REG_FUNC(0x7C4E0C42, sceFiosFHPreadv);
+	REG_FUNC(0x4D42F95C, sceFiosFHPreadvSync);
+	REG_FUNC(0xCF1FAA6F, sceFiosFHPwrite);
+	REG_FUNC(0x1E962F57, sceFiosFHPwriteSync);
+	REG_FUNC(0xBBC9AFD5, sceFiosFHPwritev);
+	REG_FUNC(0x742ADDC4, sceFiosFHPwritevSync);
+	REG_FUNC(0xB09AFBDF, sceFiosFHRead);
+	REG_FUNC(0x76945919, sceFiosFHReadSync);
+	REG_FUNC(0x7DB0AFAF, sceFiosFHReadv);
+	REG_FUNC(0x1BC977FA, sceFiosFHReadvSync);
+	REG_FUNC(0xA75F3C4A, sceFiosFHSeek);
+	REG_FUNC(0xD97C4DF7, sceFiosFHStat);
+	REG_FUNC(0xF8BEAC88, sceFiosFHStatSync);
+	REG_FUNC(0xE485F35E, sceFiosFHSync);
+	REG_FUNC(0xA909CCE3, sceFiosFHSyncSync);
+	REG_FUNC(0xD7F33130, sceFiosFHTell);
+	REG_FUNC(0x2B39453B, sceFiosFHTruncate);
+	REG_FUNC(0xFEF940B7, sceFiosFHTruncateSync);
+	REG_FUNC(0xE663138E, sceFiosFHWrite);
+	REG_FUNC(0x984024E5, sceFiosFHWriteSync);
+	REG_FUNC(0x988DD7FF, sceFiosFHWritev);
+	REG_FUNC(0x267E6CE3, sceFiosFHWritevSync);
+	REG_FUNC(0xB647278B, sceFiosFileDelete);
+	REG_FUNC(0xB5302E30, sceFiosFileDeleteSync);
+	REG_FUNC(0x8758E62F, sceFiosFileExists);
+	REG_FUNC(0x233B070C, sceFiosFileExistsSync);
+	REG_FUNC(0x79D9BB50, sceFiosFileGetSize);
+	REG_FUNC(0x789215C3, sceFiosFileGetSizeSync);
+	REG_FUNC(0x84080161, sceFiosFileRead);
+	REG_FUNC(0x1C488B32, sceFiosFileReadSync);
+	REG_FUNC(0xC5513E13, sceFiosFileTruncate);
+	REG_FUNC(0x6E1252B8, sceFiosFileTruncateSync);
+	REG_FUNC(0x42C278E5, sceFiosFileWrite);
+	REG_FUNC(0x132B6DE6, sceFiosFileWriteSync);
+	REG_FUNC(0x681184A2, sceFiosGetAllDHs);
+	REG_FUNC(0x90AB9195, sceFiosGetAllFHs);
+	REG_FUNC(0x8F62832C, sceFiosGetAllOps);
+	REG_FUNC(0xC897F6A7, sceFiosGetDefaultOpAttr);
+	REG_FUNC(0x30583FCB, sceFiosGetGlobalDefaultOpAttr);
+	REG_FUNC(0x156EAFDC, sceFiosGetSuspendCount);
+	REG_FUNC(0xD55B8555, sceFiosIOFilterAdd);
+	REG_FUNC(0x7C9B14EB, sceFiosIOFilterGetInfo);
+	REG_FUNC(0x057252F2, sceFiosIOFilterPsarcDearchiver);
+	REG_FUNC(0x22E35018, sceFiosIOFilterRemove);
+	REG_FUNC(0x774C2C05, sceFiosInitialize);
+	REG_FUNC(0x29104BF3, sceFiosIsIdle);
+	REG_FUNC(0xF4F54E09, sceFiosIsInitialized);
+	REG_FUNC(0xD2466EA5, sceFiosIsSuspended);
+	REG_FUNC(0xB309E327, sceFiosIsValidHandle);
+	REG_FUNC(0x3904F205, sceFiosOpCancel);
+	REG_FUNC(0xE4EA92FA, sceFiosOpDelete);
+	REG_FUNC(0x218A43EE, sceFiosOpGetActualCount);
+	REG_FUNC(0xABFEE706, sceFiosOpGetAttr);
+	REG_FUNC(0x68C436E4, sceFiosOpGetBuffer);
+	REG_FUNC(0xBF099E16, sceFiosOpGetError);
+	REG_FUNC(0xF21213B9, sceFiosOpGetOffset);
+	REG_FUNC(0x157515CB, sceFiosOpGetPath);
+	REG_FUNC(0x9C1084C5, sceFiosOpGetRequestCount);
+	REG_FUNC(0x0C81D80E, sceFiosOpIsCancelled);
+	REG_FUNC(0x1B9A575E, sceFiosOpIsDone);
+	REG_FUNC(0x968CADBD, sceFiosOpReschedule);
+	REG_FUNC(0xE6A66C70, sceFiosOpSyncWait);
+	REG_FUNC(0x202079F9, sceFiosOpSyncWaitForIO);
+	REG_FUNC(0x2AC79DFC, sceFiosOpWait);
+	REG_FUNC(0xCC823B47, sceFiosOpWaitUntil);
+	REG_FUNC(0x27AE468B, sceFiosOverlayAdd);
+	REG_FUNC(0xF4C6B72A, sceFiosOverlayGetInfo);
+	REG_FUNC(0x1C0BCAD5, sceFiosOverlayGetList);
+	REG_FUNC(0x30F56704, sceFiosOverlayModify);
+	REG_FUNC(0xF3C84D0F, sceFiosOverlayRemove);
+	REG_FUNC(0x8A243E74, sceFiosOverlayResolveSync);
+	REG_FUNC(0x5E75937A, sceFiosPathcmp);
+	REG_FUNC(0xCC21C849, sceFiosPathncmp);
+	REG_FUNC(0xAF7FAADF, sceFiosPrintf);
+	REG_FUNC(0x25E399E5, sceFiosRename);
+	REG_FUNC(0x030306F4, sceFiosRenameSync);
+	REG_FUNC(0xD0B19C9F, sceFiosResolve);
+	REG_FUNC(0x7FF33797, sceFiosResolveSync);
+	REG_FUNC(0xBF2D3CC1, sceFiosResume);
+	REG_FUNC(0x4E2FD311, sceFiosSetGlobalDefaultOpAttr);
+	REG_FUNC(0x5B8D48C4, sceFiosShutdownAndCancelOps);
+	REG_FUNC(0xFF04AF72, sceFiosStat);
+	REG_FUNC(0xACBAF3E0, sceFiosStatSync);
+	REG_FUNC(0x510953DC, sceFiosSuspend);
+	REG_FUNC(0x2904B539, sceFiosTerminate);
+	REG_FUNC(0xE76C8EC3, sceFiosTimeGetCurrent);
+	REG_FUNC(0x35A82737, sceFiosTimeIntervalFromNanoseconds);
+	REG_FUNC(0x397BF626, sceFiosTimeIntervalToNanoseconds);
+	REG_FUNC(0x1915052A, sceFiosUpdateParameters);
+	REG_FUNC(0x5BA4BD6D, sceFiosVprintf);
+});

rpcs3/Emu/ARMv7/Modules/sceFpu.cpp

@@ -0,0 +1,29 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceFpu;
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceFpu, #name, name)
+
+psv_log_base sceFpu("SceFpu", []()
+{
+	sceFpu.on_load = nullptr;
+	sceFpu.on_unload = nullptr;
+	sceFpu.on_stop = nullptr;
+
+	//REG_FUNC(0x33E1AC14, sceFpuSinf);
+	//REG_FUNC(0xDB66BA89, sceFpuCosf);
+	//REG_FUNC(0x6FBDA1C9, sceFpuTanf);
+	//REG_FUNC(0x53FF26AF, sceFpuAtanf);
+	//REG_FUNC(0xC8A4989B, sceFpuAtan2f);
+	//REG_FUNC(0x4D1AE0F1, sceFpuAsinf);
+	//REG_FUNC(0x64A8F9FE, sceFpuAcosf);
+	//REG_FUNC(0x936F0D27, sceFpuLogf);
+	//REG_FUNC(0x19881EC8, sceFpuLog2f);
+	//REG_FUNC(0xABBB6168, sceFpuLog10f);
+	//REG_FUNC(0xEFA16C6E, sceFpuExpf);
+	//REG_FUNC(0xA3A88AD0, sceFpuExp2f);
+	//REG_FUNC(0x35652326, sceFpuExp10f);
+	//REG_FUNC(0xDF622E56, sceFpuPowf);
+});

rpcs3/Emu/ARMv7/Modules/sceGxm.cpp

@@ -257,23 +257,23 @@ void sceGxmSetBackPolygonMode(vm::psv::ptr<SceGxmContext> context, SceGxmPolygon
 	throw __FUNCTION__;
 }
 
-void sceGxmSetFrontStencilFunc(vm::psv::ptr<SceGxmContext> context, SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, uint8_t compareMask, uint8_t writeMask)
+void sceGxmSetFrontStencilFunc(vm::psv::ptr<SceGxmContext> context, SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, u8 compareMask, u8 writeMask)
 {
 	throw __FUNCTION__;
 }
 
 
-void sceGxmSetBackStencilFunc(vm::psv::ptr<SceGxmContext> context, SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, uint8_t compareMask, uint8_t writeMask)
+void sceGxmSetBackStencilFunc(vm::psv::ptr<SceGxmContext> context, SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, u8 compareMask, u8 writeMask)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmSetFrontDepthBias(vm::psv::ptr<SceGxmContext> context, int32_t factor, int32_t units)
+void sceGxmSetFrontDepthBias(vm::psv::ptr<SceGxmContext> context, s32 factor, s32 units)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmSetBackDepthBias(vm::psv::ptr<SceGxmContext> context, int32_t factor, int32_t units)
+void sceGxmSetBackDepthBias(vm::psv::ptr<SceGxmContext> context, s32 factor, s32 units)
 {
 	throw __FUNCTION__;
 }
@@ -463,12 +463,12 @@ s32 sceGxmDepthStencilSurfaceInitDisabled(vm::psv::ptr<SceGxmDepthStencilSurface
 //	throw __FUNCTION__;
 //}
 
-uint8_t sceGxmDepthStencilSurfaceGetBackgroundStencil(vm::psv::ptr<const SceGxmDepthStencilSurface> surface)
+u8 sceGxmDepthStencilSurfaceGetBackgroundStencil(vm::psv::ptr<const SceGxmDepthStencilSurface> surface)
 {
 	throw __FUNCTION__;
 }
 
-void sceGxmDepthStencilSurfaceSetBackgroundStencil(vm::psv::ptr<SceGxmDepthStencilSurface> surface, uint8_t backgroundStencil)
+void sceGxmDepthStencilSurfaceSetBackgroundStencil(vm::psv::ptr<SceGxmDepthStencilSurface> surface, u8 backgroundStencil)
 {
 	throw __FUNCTION__;
 }

rpcs3/Emu/ARMv7/Modules/sceGxm.h

@@ -1002,9 +1002,9 @@ enum SceGxmColorMask : u8
 
 struct SceGxmBlendInfo
 {
-	SceGxmColorMask	colorMask;
-	SceGxmBlendFunc	colorFunc : 4;
-	SceGxmBlendFunc	alphaFunc : 4;
+	SceGxmColorMask colorMask;
+	SceGxmBlendFunc colorFunc : 4;
+	SceGxmBlendFunc alphaFunc : 4;
 	SceGxmBlendFactor colorSrc : 4;
 	SceGxmBlendFactor colorDst : 4;
 	SceGxmBlendFactor alphaSrc : 4;

rpcs3/Emu/ARMv7/Modules/sceHttp.cpp

@@ -0,0 +1,431 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceSsl.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::ptr<vm::psv::ptr<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::ptr<vm::psv::ptr<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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetMemoryPoolStats(vm::psv::ptr<SceHttpMemoryPoolStats> currentStat)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpCreateTemplate(vm::psv::ptr<const char> userAgent, s32 httpVer, s32 autoProxyConf)
+{
+	throw __FUNCTION__;
+}
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpCreateConnectionWithURL(s32 tmplId, vm::psv::ptr<const char> url, s32 enableKeepalive)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpDeleteConnection(s32 connId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpCreateRequest(s32 connId, s32 method, vm::psv::ptr<const char> path, u64 contentLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpCreateRequestWithURL(s32 connId, s32 method, vm::psv::ptr<const char> url, u64 contentLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpDeleteRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetResponseHeaderMaxSize(s32 id, u32 headerSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetRecvBlockSize(s32 id, u32 blockSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetRequestContentLength(s32 id, u64 contentLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSendRequest(s32 reqId, vm::psv::ptr<const void> postData, u32 size)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpAbortRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetResponseContentLength(s32 reqId, vm::psv::ptr<u64> contentLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetStatusCode(s32 reqId, vm::psv::ptr<s32> statusCode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetAllResponseHeaders(s32 reqId, vm::psv::ptr<vm::psv::ptr<char>> header, vm::psv::ptr<u32> headerSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpReadData(s32 reqId, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpRemoveRequestHeader(s32 id, vm::psv::ptr<const char> name)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpParseResponseHeader(vm::psv::ptr<const char> header, u32 headerLen, vm::psv::ptr<const char> fieldStr, vm::psv::ptr<vm::psv::ptr<const char>> fieldValue, vm::psv::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::ptr<vm::psv::ptr<const char>> reasonPhrase, vm::psv::ptr<u32> phraseLen)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetAuthInfoCallback(s32 id, SceHttpAuthInfoCallback cbfunc, vm::psv::ptr<void> userArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetAuthEnabled(s32 id, s32 enable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetAuthEnabled(s32 id, vm::psv::ptr<s32> enable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetRedirectCallback(s32 id, SceHttpRedirectCallback cbfunc, vm::psv::ptr<void> userArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetAutoRedirect(s32 id, s32 enable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetAutoRedirect(s32 id, vm::psv::ptr<s32> enable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetResolveTimeOut(s32 id, u32 usec)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetResolveRetry(s32 id, s32 retry)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetConnectTimeOut(s32 id, u32 usec)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetSendTimeOut(s32 id, u32 usec)
+{
+	throw __FUNCTION__;
+}
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpUriUnescape(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpUriBuild(vm::psv::ptr<char> out, vm::psv::ptr<u32> require, u32 prepare, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpUriSweepPath(vm::psv::ptr<char> dst, vm::psv::ptr<const char> src, u32 srcSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetCookieEnabled(s32 id, s32 enable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpGetCookieEnabled(s32 id, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpAddCookie(vm::psv::ptr<const char> url, vm::psv::ptr<const char> cookie, u32 cookieLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetCookieRecvCallback(s32 id, SceHttpCookieRecvCallback cbfunc, vm::psv::ptr<void> userArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpSetCookieSendCallback(s32 id, SceHttpCookieSendCallback cbfunc, vm::psv::ptr<void> userArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsLoadCert(s32 caCertNum, vm::psv::ptr<vm::psv::ptr<const SceHttpsData>> caList, vm::psv::ptr<const SceHttpsData> cert, vm::psv::ptr<const SceHttpsData> privKey)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsUnloadCert()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsEnableOption(u32 sslFlags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsDisableOption(u32 sslFlags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsGetSslError(s32 id, vm::psv::ptr<s32> errNum, vm::psv::ptr<u32> detail)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsSetSslCallback(s32 id, SceHttpsCallback cbfunc, vm::psv::ptr<void> userArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsGetCaList(vm::psv::ptr<SceHttpsCaList> caList)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceHttpsFreeCaList(vm::psv::ptr<SceHttpsCaList> caList)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceHttp, #name, name)
+
+psv_log_base sceHttp("SceHttp", []()
+{
+	sceHttp.on_load = nullptr;
+	sceHttp.on_unload = nullptr;
+	sceHttp.on_stop = nullptr;
+
+	REG_FUNC(0x214926D9, sceHttpInit);
+	REG_FUNC(0xC9076666, sceHttpTerm);
+	REG_FUNC(0xF98CDFA9, sceHttpGetMemoryPoolStats);
+	REG_FUNC(0x62241DAB, sceHttpCreateTemplate);
+	REG_FUNC(0xEC85ECFB, sceHttpDeleteTemplate);
+	REG_FUNC(0xC616C200, sceHttpCreateConnectionWithURL);
+	REG_FUNC(0xAEB3307E, sceHttpCreateConnection);
+	REG_FUNC(0xF0F65C15, sceHttpDeleteConnection);
+	REG_FUNC(0xBD5DA1D0, sceHttpCreateRequestWithURL);
+	REG_FUNC(0xB0284270, sceHttpCreateRequest);
+	REG_FUNC(0x3D3D29AD, sceHttpDeleteRequest);
+	REG_FUNC(0x9CA58B99, sceHttpSendRequest);
+	REG_FUNC(0x7EDE3979, sceHttpReadData);
+	REG_FUNC(0xF580D304, sceHttpGetResponseContentLength);
+	REG_FUNC(0x27071691, sceHttpGetStatusCode);
+	REG_FUNC(0xEA61662F, sceHttpAbortRequest);
+	REG_FUNC(0x7B51B122, sceHttpAddRequestHeader);
+	REG_FUNC(0x5EB5F548, sceHttpRemoveRequestHeader);
+	REG_FUNC(0x11F6C27F, sceHttpGetAllResponseHeaders);
+	REG_FUNC(0x03A6C89E, sceHttpParseResponseHeader);
+	REG_FUNC(0x179C56DB, sceHttpParseStatusLine);
+	REG_FUNC(0x1DA2A673, sceHttpUriEscape);
+	REG_FUNC(0x1274D318, sceHttpUriUnescape);
+	REG_FUNC(0x1D45F24E, sceHttpUriParse);
+	REG_FUNC(0x47664424, sceHttpUriBuild);
+	REG_FUNC(0x75027D1D, sceHttpUriMerge);
+	REG_FUNC(0x50737A3F, sceHttpUriSweepPath);
+	REG_FUNC(0x37C30C90, sceHttpSetRequestContentLength);
+	REG_FUNC(0x11EC42D0, sceHttpSetAuthEnabled);
+	REG_FUNC(0x6727874C, sceHttpGetAuthEnabled);
+	REG_FUNC(0x34891C3F, sceHttpSetAutoRedirect);
+	REG_FUNC(0x6EAD73EB, sceHttpGetAutoRedirect);
+	REG_FUNC(0xE0A3A88D, sceHttpSetAuthInfoCallback);
+	REG_FUNC(0x4E08167D, sceHttpSetRedirectCallback);
+	REG_FUNC(0x8455B5B3, sceHttpSetResolveTimeOut);
+	REG_FUNC(0x9AB56EA7, sceHttpSetResolveRetry);
+	REG_FUNC(0x237CA86E, sceHttpSetConnectTimeOut);
+	REG_FUNC(0x8AE3F008, sceHttpSetSendTimeOut);
+	REG_FUNC(0x94BF196E, sceHttpSetRecvTimeOut);
+	//REG_FUNC(0x27A98BDA, sceHttpSetNonblock);
+	//REG_FUNC(0xD65746BC, sceHttpGetNonblock);
+	//REG_FUNC(0x5CEB6554, sceHttpSetEpollId);
+	//REG_FUNC(0x9E031D7C, sceHttpGetEpollId);
+	//REG_FUNC(0x94F7256A, sceHttpWaitRequest);
+	//REG_FUNC(0x7C99AF67, sceHttpCreateEpoll);
+	//REG_FUNC(0x0F1FD1B3, sceHttpSetEpoll);
+	//REG_FUNC(0xCFB1DA4B, sceHttpUnsetEpoll);
+	//REG_FUNC(0x65FE983F, sceHttpGetEpoll);
+	//REG_FUNC(0x07D9F8BB, sceHttpDestroyEpoll);
+	REG_FUNC(0xAEE573A3, sceHttpSetCookieEnabled);
+	REG_FUNC(0x1B6EF66E, sceHttpGetCookieEnabled);
+	REG_FUNC(0x70220BFA, sceHttpGetCookie);
+	REG_FUNC(0xBEDB988D, sceHttpAddCookie);
+	//REG_FUNC(0x4259FB9E, sceHttpCookieExport);
+	//REG_FUNC(0x9DF48282, sceHttpCookieImport);
+	REG_FUNC(0xD4F32A23, sceHttpSetCookieRecvCallback);
+	REG_FUNC(0x11C03867, sceHttpSetCookieSendCallback);
+	REG_FUNC(0xAE8D7C33, sceHttpsLoadCert);
+	REG_FUNC(0x8577833F, sceHttpsUnloadCert);
+	REG_FUNC(0x9FBE2869, sceHttpsEnableOption);
+	REG_FUNC(0xC6D60403, sceHttpsDisableOption);
+	//REG_FUNC(0x72CB0741, sceHttpsEnableOptionPrivate);
+	//REG_FUNC(0x00659635, sceHttpsDisableOptionPrivate);
+	REG_FUNC(0x2B79BDE0, sceHttpsGetSslError);
+	REG_FUNC(0xA0926037, sceHttpsSetSslCallback);
+	REG_FUNC(0xF71AA58D, sceHttpsGetCaList);
+	REG_FUNC(0x56C95D94, sceHttpsFreeCaList);
+});

rpcs3/Emu/ARMv7/Modules/sceIme.cpp

@@ -0,0 +1,46 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceIme.h"
+
+s32 sceImeOpen(vm::psv::ptr<SceImeParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeUpdate()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeSetCaret(vm::psv::ptr<const SceImeCaret> caret)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeSetPreeditGeometry(vm::psv::ptr<const SceImePreeditGeometry> preedit)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceImeClose()
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceIme, #name, name)
+
+psv_log_base sceIme("SceIme", []()
+{
+	sceIme.on_load = nullptr;
+	sceIme.on_unload = nullptr;
+	sceIme.on_stop = nullptr;
+
+	REG_FUNC(0x0E050613, sceImeOpen);
+	REG_FUNC(0x71D6898A, sceImeUpdate);
+	REG_FUNC(0x889A8421, sceImeClose);
+	REG_FUNC(0xD8342D2A, sceImeSetCaret);
+	REG_FUNC(0x7B1EFAA5, sceImeSetPreeditGeometry);
+});

rpcs3/Emu/ARMv7/Modules/sceIme.h

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

rpcs3/Emu/ARMv7/Modules/sceJpeg.cpp

@@ -0,0 +1,126 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceJpeg;
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegFinishMJpeg()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegDecodeMJpeg(
+	vm::psv::ptr<const u8> pJpeg,
+	u32 isize,
+	vm::psv::ptr<void> pRGBA,
+	u32 osize,
+	s32 decodeMode,
+	vm::psv::ptr<void> pTempBuffer,
+	u32 tempBufferSize,
+	vm::psv::ptr<void> pCoefBuffer,
+	u32 coefBufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegDecodeMJpegYCbCr(
+	vm::psv::ptr<const u8> pJpeg,
+	u32 isize,
+	vm::psv::ptr<u8> pYCbCr,
+	u32 osize,
+	s32 decodeMode,
+	vm::psv::ptr<void> pCoefBuffer,
+	u32 coefBufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegMJpegCsc(
+	vm::psv::ptr<void> pRGBA,
+	vm::psv::ptr<const u8> pYCbCr,
+	s32 xysize,
+	s32 iFrameWidth,
+	s32 colorOption,
+	s32 sampling)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegGetOutputInfo(
+	vm::psv::ptr<const u8> pJpeg,
+	u32 isize,
+	s32 outputFormat,
+	s32 decodeMode,
+	vm::psv::ptr<SceJpegOutputInfo> pOutputInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegCreateSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegDeleteSplitDecoder(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegSplitDecodeMJpeg(vm::psv::ptr<SceJpegSplitDecodeCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceJpeg, #name, name)
+
+psv_log_base sceJpeg("SceJpeg", []()
+{
+	sceJpeg.on_load = nullptr;
+	sceJpeg.on_unload = nullptr;
+	sceJpeg.on_stop = nullptr;
+
+	REG_FUNC(0xB030773B, sceJpegInitMJpeg);
+	REG_FUNC(0x62842598, sceJpegFinishMJpeg);
+	REG_FUNC(0x6215B095, sceJpegDecodeMJpeg);
+	REG_FUNC(0x2A769BD8, sceJpegDecodeMJpegYCbCr);
+	REG_FUNC(0xC2380E3A, sceJpegMJpegCsc);
+	REG_FUNC(0x353BA9B0, sceJpegGetOutputInfo);
+	REG_FUNC(0x123B4734, sceJpegCreateSplitDecoder);
+	REG_FUNC(0xDE8D5FA1, sceJpegDeleteSplitDecoder);
+	REG_FUNC(0x4598EC9C, sceJpegSplitDecodeMJpeg);
+});

rpcs3/Emu/ARMv7/Modules/sceJpegEnc.cpp

@@ -0,0 +1,95 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceJpegEnc;
+
+typedef vm::psv::ptr<void> SceJpegEncoderContext;
+
+s32 sceJpegEncoderGetContextSize()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderInit(
+	SceJpegEncoderContext context,
+	s32 iFrameWidth,
+	s32 iFrameHeight,
+	s32 pixelFormat,
+	vm::psv::ptr<void> pJpeg,
+	u32 oJpegbufSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderEncode(
+	SceJpegEncoderContext context,
+	vm::psv::ptr<const void> pYCbCr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderEnd(SceJpegEncoderContext context)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderSetValidRegion(
+	SceJpegEncoderContext context,
+	s32 iFrameWidth,
+	s32 iFrameHeight)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderSetCompressionRatio(
+	SceJpegEncoderContext context,
+	s32 compratio)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderSetHeaderMode(
+	SceJpegEncoderContext context,
+	s32 headerMode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderSetOutputAddr(
+	SceJpegEncoderContext context,
+	vm::psv::ptr<void> pJpeg,
+	u32 oJpegbufSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceJpegEncoderCsc(
+	SceJpegEncoderContext context,
+	vm::psv::ptr<void> pYCbCr,
+	vm::psv::ptr<const void> pRGBA,
+	s32 iFrameWidth,
+	s32 inputPixelFormat)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceJpegEnc, #name, name)
+
+psv_log_base sceJpegEnc("SceJpegEnc", []()
+{
+	sceJpegEnc.on_load = nullptr;
+	sceJpegEnc.on_unload = nullptr;
+	sceJpegEnc.on_stop = nullptr;
+
+	REG_FUNC(0x2B55844D, sceJpegEncoderGetContextSize);
+	REG_FUNC(0x88DA92B4, sceJpegEncoderInit);
+	REG_FUNC(0xC60DE94C, sceJpegEncoderEncode);
+	REG_FUNC(0xC87AA849, sceJpegEncoderEnd);
+	REG_FUNC(0x9511F3BC, sceJpegEncoderSetValidRegion);
+	REG_FUNC(0xB2B828EC, sceJpegEncoderSetCompressionRatio);
+	REG_FUNC(0x2F58B12C, sceJpegEncoderSetHeaderMode);
+	REG_FUNC(0x25D52D97, sceJpegEncoderSetOutputAddr);
+	REG_FUNC(0x824A7D4F, sceJpegEncoderCsc);
+});

rpcs3/Emu/ARMv7/Modules/sceLibc.cpp

@@ -18,6 +18,8 @@ namespace sce_libc_func
 	{
 		sceLibc.Error("__cxa_atexit(func=0x%x, arg=0x%x, dso=0x%x)", func, arg, dso);
 		
+		LV2_LOCK(0);
+
 		g_atexit.insert(g_atexit.begin(), [func, arg, dso](ARMv7Context& context)
 		{
 			func(context, arg);
@@ -28,6 +30,8 @@ namespace sce_libc_func
 	{
 		sceLibc.Error("__aeabi_atexit(arg=0x%x, func=0x%x, dso=0x%x)", arg, func, dso);
 
+		LV2_LOCK(0);
+
 		g_atexit.insert(g_atexit.begin(), [func, arg, dso](ARMv7Context& context)
 		{
 			func(context, arg);
@@ -38,6 +42,8 @@ namespace sce_libc_func
 	{
 		sceLibc.Error("exit()");
 		
+		LV2_LOCK(0);
+
 		for (auto func : g_atexit)
 		{
 			func(context);
@@ -156,7 +162,7 @@ namespace sce_libc_func
 	{
 		sceLibc.Error("_Assert(text=0x%x, func=0x%x)", text, func);
 
-		LOG_ERROR(TTY, "%s : %s", func.get_ptr(), text.get_ptr());
+		LOG_ERROR(TTY, "%s : %s\n", func.get_ptr(), text.get_ptr());
 		Emu.Pause();
 	}
 }

rpcs3/Emu/ARMv7/Modules/sceLiveArea.cpp

@@ -0,0 +1,27 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceLiveArea;
+
+s32 sceLiveAreaResourceReplaceAll(vm::psv::ptr<const char> dirpath)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLiveAreaResourceGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLiveArea, #name, name)
+
+psv_log_base sceLiveArea("SceLiveArea", []()
+{
+	sceLiveArea.on_load = nullptr;
+	sceLiveArea.on_unload = nullptr;
+	sceLiveArea.on_stop = nullptr;
+
+	REG_FUNC(0xA4B506F9, sceLiveAreaResourceReplaceAll);
+	REG_FUNC(0x54A395FB, sceLiveAreaResourceGetStatus);
+});

rpcs3/Emu/ARMv7/Modules/sceLocation.cpp

@@ -0,0 +1,202 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceLocation;
+
+typedef u8 SceLocationHandle;
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationReopen(SceLocationHandle handle, SceLocationLocationMethod lmethod, SceLocationHeadingMethod hmethod)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationGetMethod(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationMethod> lmethod, vm::psv::ptr<SceLocationHeadingMethod> hmethod)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationGetLocation(SceLocationHandle handle, vm::psv::ptr<SceLocationLocationInfo> linfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationCancelGetLocation(SceLocationHandle handle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationStartLocationCallback(SceLocationHandle handle, u32 distance, SceLocationLocationInfoCallback callback, vm::psv::ptr<void> userdata)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationStopLocationCallback(SceLocationHandle handle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationGetHeading(SceLocationHandle handle, vm::psv::ptr<SceLocationHeadingInfo> hinfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationStartHeadingCallback(SceLocationHandle handle, u32 difference, SceLocationHeadingInfoCallback callback, vm::psv::ptr<void> userdata)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationStopHeadingCallback(SceLocationHandle handle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationConfirm(SceLocationHandle handle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationConfirmGetStatus(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogStatus> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationConfirmGetResult(SceLocationHandle handle, vm::psv::ptr<SceLocationDialogResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationConfirmAbort(SceLocationHandle handle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationGetPermission(SceLocationHandle handle, vm::psv::ptr<SceLocationPermissionInfo> info)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceLocationSetGpsEmulationFile(vm::psv::ptr<char> filename)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceLocation, #name, name)
+
+psv_log_base sceLocation("SceLibLocation", []()
+{
+	sceLocation.on_load = nullptr;
+	sceLocation.on_unload = nullptr;
+	sceLocation.on_stop = nullptr;
+
+	REG_FUNC(0xDD271661, sceLocationOpen);
+	REG_FUNC(0x14FE76E8, sceLocationClose);
+	REG_FUNC(0xB1F55065, sceLocationReopen);
+	REG_FUNC(0x188CE004, sceLocationGetMethod);
+	REG_FUNC(0x15BC27C8, sceLocationGetLocation);
+	REG_FUNC(0x71503251, sceLocationCancelGetLocation);
+	REG_FUNC(0x12D1F0EA, sceLocationStartLocationCallback);
+	REG_FUNC(0xED378700, sceLocationStopLocationCallback);
+	REG_FUNC(0x4E9E5ED9, sceLocationGetHeading);
+	REG_FUNC(0x07D4DFE0, sceLocationStartHeadingCallback);
+	REG_FUNC(0x92E53F94, sceLocationStopHeadingCallback);
+	//REG_FUNC(0xE055BCF5, sceLocationSetHeapAllocator);
+	REG_FUNC(0xC895E567, sceLocationConfirm);
+	REG_FUNC(0x730FF842, sceLocationConfirmGetStatus);
+	REG_FUNC(0xFF016C13, sceLocationConfirmGetResult);
+	REG_FUNC(0xE3CBF875, sceLocationConfirmAbort);
+	REG_FUNC(0x482622C6, sceLocationGetPermission);
+	REG_FUNC(0xDE0A9EA4, sceLocationSetGpsEmulationFile);
+	//REG_FUNC(0x760D08FF, sceLocationConfirmSetMessage);
+});

rpcs3/Emu/ARMv7/Modules/sceMd5.cpp

@@ -0,0 +1,50 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceMd5;
+
+struct SceMd5Context
+{
+	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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMd5BlockUpdate(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<const void> plain, u32 len)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMd5BlockResult(vm::psv::ptr<SceMd5Context> pContext, vm::psv::ptr<u8> digest)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceMd5, #name, name)
+
+psv_log_base sceMd5("SceMd5", []()
+{
+	sceMd5.on_load = nullptr;
+	sceMd5.on_unload = nullptr;
+	sceMd5.on_stop = nullptr;
+
+	REG_FUNC(0xB845BCCB, sceMd5Digest);
+	REG_FUNC(0x4D6436F9, sceMd5BlockInit);
+	REG_FUNC(0x094A4902, sceMd5BlockUpdate);
+	REG_FUNC(0xB94ABF83, sceMd5BlockResult);
+});

rpcs3/Emu/ARMv7/Modules/sceMotion.cpp

@@ -0,0 +1,138 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceMotion;
+
+struct SceMotionState
+{
+	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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionGetBasicOrientation(vm::psv::ptr<SceFVector3> basicOrientation)
+{
+	throw __FUNCTION__;
+}
+
+//s32 sceMotionRotateYaw(const float radians)
+//{
+//	throw __FUNCTION__;
+//}
+
+s32 sceMotionGetTiltCorrection()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionSetTiltCorrection(s32 setValue)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionGetDeadband()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionSetDeadband(s32 setValue)
+{
+	throw __FUNCTION__;
+}
+
+//s32 sceMotionSetAngleThreshold(const float angle)
+//{
+//	throw __FUNCTION__;
+//}
+
+//float sceMotionGetAngleThreshold()
+//{
+//	throw __FUNCTION__;
+//}
+
+s32 sceMotionReset()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionMagnetometerOn()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionMagnetometerOff()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionGetMagnetometerState()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionStartSampling()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceMotionStopSampling()
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceMotion, #name, name)
+
+psv_log_base sceMotion("SceMotion", []()
+{
+	sceMotion.on_load = nullptr;
+	sceMotion.on_unload = nullptr;
+	sceMotion.on_stop = nullptr;
+
+	REG_FUNC(0xBDB32767, sceMotionGetState);
+	REG_FUNC(0x47D679EA, sceMotionGetSensorState);
+	REG_FUNC(0xC1652201, sceMotionGetTiltCorrection);
+	REG_FUNC(0xAF09FCDB, sceMotionSetTiltCorrection);
+	REG_FUNC(0x112E0EAE, sceMotionGetDeadband);
+	REG_FUNC(0x917EA390, sceMotionSetDeadband);
+	//REG_FUNC(0x20F00078, sceMotionRotateYaw);
+	REG_FUNC(0x0FD2CDA2, sceMotionReset);
+	REG_FUNC(0x28034AC9, sceMotionStartSampling);
+	REG_FUNC(0xAF32CB1D, sceMotionStopSampling);
+	//REG_FUNC(0xDACB2A41, sceMotionSetAngleThreshold);
+	//REG_FUNC(0x499B6C87, sceMotionGetAngleThreshold);
+	REG_FUNC(0x4F28BFE0, sceMotionGetBasicOrientation);
+	REG_FUNC(0x122A79F8, sceMotionMagnetometerOn);
+	REG_FUNC(0xC1A7395A, sceMotionMagnetometerOff);
+	REG_FUNC(0x3D4813AE, sceMotionGetMagnetometerState);
+});

rpcs3/Emu/ARMv7/Modules/sceMt19937.cpp

@@ -0,0 +1,34 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceMt19937;
+
+struct SceMt19937Context
+{
+	u32 count;
+	u32 state[624];
+};
+
+s32 sceMt19937Init(vm::psv::ptr<SceMt19937Context> pCtx, u32 seed)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceMt19937UInt(vm::psv::ptr<SceMt19937Context> pCtx)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceMt19937, #name, name)
+
+psv_log_base sceMt19937("SceMt19937", []()
+{
+	sceMt19937.on_load = nullptr;
+	sceMt19937.on_unload = nullptr;
+	sceMt19937.on_stop = nullptr;
+
+	REG_FUNC(0xEE5BA27C, sceMt19937Init);
+	REG_FUNC(0x29E43BB5, sceMt19937UInt);
+});

rpcs3/Emu/ARMv7/Modules/sceNet.cpp

@@ -0,0 +1,364 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNet.h"
+
+s32 sceNetSetDnsInfo(vm::psv::ptr<SceNetDnsInfo> info, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetClearDnsCache(s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetDumpCreate(vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetDumpDestroy(s32 id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetDumpAbort(s32 id, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEpollCreate(vm::psv::ptr<const char> name, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEpollControl(s32 eid, s32 op, s32 id, vm::psv::ptr<SceNetEpollEvent> event)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEpollWait(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEpollWaitCB(s32 eid, vm::psv::ptr<SceNetEpollEvent> events, s32 maxevents, s32 timeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEpollDestroy(s32 eid)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEpollAbort(s32 eid, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<s32> sceNetErrnoLoc()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEtherStrton(vm::psv::ptr<const char> str, vm::psv::ptr<SceNetEtherAddr> n)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEtherNtostr(vm::psv::ptr<const SceNetEtherAddr> n, vm::psv::ptr<char> str, u32 len)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetGetMacAddress(vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetInetPton(s32 af, vm::psv::ptr<const char> src, vm::psv::ptr<void> dst)
+{
+	throw __FUNCTION__;
+}
+
+u64 sceNetHtonll(u64 host64)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceNetHtonl(u32 host32)
+{
+	throw __FUNCTION__;
+}
+
+u16 sceNetHtons(u16 host16)
+{
+	throw __FUNCTION__;
+}
+
+u64 sceNetNtohll(u64 net64)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceNetNtohl(u32 net32)
+{
+	throw __FUNCTION__;
+}
+
+u16 sceNetNtohs(u16 net16)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetInit(vm::psv::ptr<SceNetInitParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetShowIfconfig()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetShowRoute()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetShowNetstat()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEmulationSet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetEmulationGet(vm::psv::ptr<SceNetEmulationParam> param, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetResolverCreate(vm::psv::ptr<const char> name, vm::psv::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)
+{
+	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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetResolverGetError(s32 rid, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetResolverDestroy(s32 rid)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetResolverAbort(s32 rid, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetSocket(vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetBind(s32 s, vm::psv::ptr<const SceNetSockaddr> addr, SceNetSocklen_t addrlen)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetConnect(s32 s, vm::psv::ptr<const SceNetSockaddr> name, SceNetSocklen_t namelen)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetGetpeername(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::ptr<SceNetSocklen_t> namelen)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetGetsockname(s32 s, vm::psv::ptr<SceNetSockaddr> name, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetListen(s32 s, s32 backlog)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetRecv(s32 s, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetRecvmsg(s32 s, vm::psv::ptr<SceNetMsghdr> msg, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetSend(s32 s, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetSendmsg(s32 s, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetShutdown(s32 s, s32 how)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetSocketClose(s32 s)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetSocketAbort(s32 s, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetGetSockInfo(s32 s, vm::psv::ptr<SceNetSockInfo> info, s32 n, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetGetSockIdInfo(vm::psv::ptr<SceNetFdSet> fds, s32 sockinfoflags, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetGetStatisticsInfo(vm::psv::ptr<SceNetStatisticsInfo> info, s32 flags)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNet, #name, name)
+
+psv_log_base sceNet("SceNet", []()
+{
+	sceNet.on_load = nullptr;
+	sceNet.on_unload = nullptr;
+	sceNet.on_stop = nullptr;
+
+	REG_FUNC(0xD62EF218, sceNetSetDnsInfo);
+	REG_FUNC(0xFEC1166D, sceNetClearDnsCache);
+	REG_FUNC(0xAFF9FA4D, sceNetDumpCreate);
+	REG_FUNC(0x04042925, sceNetDumpRead);
+	REG_FUNC(0x82DDCF63, sceNetDumpDestroy);
+	REG_FUNC(0x3B24E75F, sceNetDumpAbort);
+	REG_FUNC(0xF9D102AE, sceNetEpollCreate);
+	REG_FUNC(0x4C8764AC, sceNetEpollControl);
+	REG_FUNC(0x45CE337D, sceNetEpollWait);
+	REG_FUNC(0x92D3E767, sceNetEpollWaitCB);
+	REG_FUNC(0x7915CAF3, sceNetEpollDestroy);
+	REG_FUNC(0x93FCC4E8, sceNetEpollAbort);
+	REG_FUNC(0xE37F34AA, sceNetErrnoLoc);
+	REG_FUNC(0xEEC6D75F, sceNetEtherStrton);
+	REG_FUNC(0x84334EB2, sceNetEtherNtostr);
+	REG_FUNC(0x06C05518, sceNetGetMacAddress);
+	REG_FUNC(0x98839B74, sceNetInetNtop);
+	REG_FUNC(0xD5EEB048, sceNetInetPton);
+	REG_FUNC(0x12C19209, sceNetHtonll);
+	REG_FUNC(0x4C30B03C, sceNetHtonl);
+	REG_FUNC(0x9FA3207B, sceNetHtons);
+	REG_FUNC(0xFB3336A6, sceNetNtohll);
+	REG_FUNC(0xD2EAA645, sceNetNtohl);
+	REG_FUNC(0x07845128, sceNetNtohs);
+	REG_FUNC(0xEB03E265, sceNetInit);
+	REG_FUNC(0xEA3CC286, sceNetTerm);
+	REG_FUNC(0x658B903B, sceNetShowIfconfig);
+	REG_FUNC(0x6AB3B74B, sceNetShowRoute);
+	REG_FUNC(0x338EDC2E, sceNetShowNetstat);
+	REG_FUNC(0x561DFD03, sceNetEmulationSet);
+	REG_FUNC(0xAE3F4AC6, sceNetEmulationGet);
+	REG_FUNC(0x6DA29319, sceNetResolverCreate);
+	REG_FUNC(0x1EB11857, sceNetResolverStartNtoa);
+	REG_FUNC(0x0424AE26, sceNetResolverStartAton);
+	REG_FUNC(0x874EF500, sceNetResolverGetError);
+	REG_FUNC(0x3559F098, sceNetResolverDestroy);
+	REG_FUNC(0x38EBBD57, sceNetResolverAbort);
+	REG_FUNC(0xF084FCE3, sceNetSocket);
+	REG_FUNC(0x1ADF9BB1, sceNetAccept);
+	REG_FUNC(0x1296A94B, sceNetBind);
+	REG_FUNC(0x11E5B6F6, sceNetConnect);
+	REG_FUNC(0x2348D353, sceNetGetpeername);
+	REG_FUNC(0x1C66A6DB, sceNetGetsockname);
+	REG_FUNC(0xBA652062, sceNetGetsockopt);
+	REG_FUNC(0x7A8DA094, sceNetListen);
+	REG_FUNC(0x023643B7, sceNetRecv);
+	REG_FUNC(0xB226138B, sceNetRecvfrom);
+	REG_FUNC(0xDE94C6FE, sceNetRecvmsg);
+	REG_FUNC(0xE3DD8CD9, sceNetSend);
+	REG_FUNC(0x52DB31D5, sceNetSendto);
+	REG_FUNC(0x99C579AE, sceNetSendmsg);
+	REG_FUNC(0x065505CA, sceNetSetsockopt);
+	REG_FUNC(0x69E50BB5, sceNetShutdown);
+	REG_FUNC(0x29822B4D, sceNetSocketClose);
+	REG_FUNC(0x891C1B9B, sceNetSocketAbort);
+	REG_FUNC(0xB1AF6840, sceNetGetSockInfo);
+	REG_FUNC(0x138CF1D6, sceNetGetSockIdInfo);
+	REG_FUNC(0xA86F8FE5, sceNetGetStatisticsInfo);
+});

rpcs3/Emu/ARMv7/Modules/sceNet.h

@@ -0,0 +1,187 @@
+#pragma once
+
+typedef u32 SceNetInAddr_t;
+typedef u16 SceNetInPort_t;
+typedef u8 SceNetSaFamily_t;
+typedef u32 SceNetSocklen_t;
+
+struct SceNetInAddr
+{
+	SceNetInAddr_t s_addr;
+};
+
+struct SceNetSockaddrIn
+{
+	u8 sin_len;
+	SceNetSaFamily_t sin_family;
+	SceNetInPort_t sin_port;
+	SceNetInAddr sin_addr;
+	SceNetInPort_t sin_vport;
+	char sin_zero[6];
+};
+
+struct SceNetDnsInfo
+{
+	SceNetInAddr dns_addr[2];
+};
+
+struct SceNetSockaddr
+{
+	u8 sa_len;
+	SceNetSaFamily_t sa_family;
+	char sa_data[14];
+};
+
+struct SceNetEpollDataExt
+{
+	s32 id;
+	u32 data;
+};
+
+union SceNetEpollData
+{
+	vm::psv::ptr<void> ptr;
+	s32 fd;
+	u32 _u32;
+	u64 _u64;
+	SceNetEpollDataExt ext;
+};
+
+struct SceNetEpollSystemData
+{
+	u32 system[4];
+};
+
+struct SceNetEpollEvent
+{
+	u32 events;
+	u32 reserved;
+	SceNetEpollSystemData system;
+	SceNetEpollData data;
+};
+
+struct SceNetEtherAddr
+{
+	u8 data[6];
+};
+
+typedef u32 SceNetIdMask;
+
+struct SceNetFdSet
+{
+	SceNetIdMask bits[32];
+};
+
+struct SceNetIpMreq
+{
+	SceNetInAddr imr_multiaddr;
+	SceNetInAddr imr_interface;
+};
+
+struct SceNetInitParam
+{
+	vm::psv::ptr<void> memory;
+	s32 size;
+	s32 flags;
+};
+
+struct SceNetEmulationData
+{
+	u16 drop_rate;
+	u16 drop_duration;
+	u16 pass_duration;
+	u16 delay_time;
+	u16 delay_jitter;
+	u16 order_rate;
+	u16 order_delay_time;
+	u16 duplication_rate;
+	u32 bps_limit;
+	u16 lower_size_limit;
+	u16 upper_size_limit;
+	u32 system_policy_pattern;
+	u32 game_policy_pattern;
+	u16 policy_flags[64];
+	u8 reserved[64];
+};
+
+struct SceNetEmulationParam
+{
+	u16 version;
+	u16 option_number;
+	u16 current_version;
+	u16 result;
+	u32 flags;
+	u32 reserved1;
+	SceNetEmulationData send;
+	SceNetEmulationData recv;
+	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;
+
+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;
+	SceNetResolverFunctionFree free;
+	vm::psv::ptr<void> user;
+};
+
+struct SceNetLinger
+{
+	s32 l_onoff;
+	s32 l_linger;
+};
+
+struct SceNetIovec
+{
+	vm::psv::ptr<void> iov_base;
+	u32 iov_len;
+};
+
+struct SceNetMsghdr
+{
+	vm::psv::ptr<void> msg_name;
+	SceNetSocklen_t msg_namelen;
+	vm::psv::ptr<SceNetIovec> msg_iov;
+	s32 msg_iovlen;
+	vm::psv::ptr<void> msg_control;
+	SceNetSocklen_t msg_controllen;
+	s32 msg_flags;
+};
+
+struct SceNetSockInfo
+{
+	char name[32];
+	s32 pid;
+	s32 s;
+	s8 socket_type;
+	s8 policy;
+	s16 reserved16;
+	s32 recv_queue_length;
+	s32 send_queue_length;
+	SceNetInAddr local_adr;
+	SceNetInAddr remote_adr;
+	SceNetInPort_t local_port;
+	SceNetInPort_t remote_port;
+	SceNetInPort_t local_vport;
+	SceNetInPort_t remote_vport;
+	s32 state;
+	s32 flags;
+	s32 reserved[8];
+};
+
+struct SceNetStatisticsInfo
+{
+	s32 kernel_mem_free_size;
+	s32 kernel_mem_free_min;
+	s32 packet_count;
+	s32 packet_qos_count;
+	s32 libnet_mem_free_size;
+	s32 libnet_mem_free_min;
+};
+
+
+extern psv_log_base sceNet;

rpcs3/Emu/ARMv7/Modules/sceNetCtl.cpp

@@ -0,0 +1,155 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNet.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()
+{
+	throw __FUNCTION__;
+}
+
+void sceNetCtlTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlCheckCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlInetGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocGetResult(s32 eventType, vm::psv::ptr<s32> errorCode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlInetGetInfo(s32 code, vm::psv::ptr<SceNetCtlInfo> info)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlInetGetState(vm::psv::ptr<s32> state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlGetNatInfo(vm::psv::ptr<SceNetCtlNatInfo> natinfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlInetRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlInetUnregisterCallback(s32 cid)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocRegisterCallback(SceNetCtlCallback func, vm::psv::ptr<void> arg, vm::psv::ptr<s32> cid)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocUnregisterCallback(s32 cid)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocGetState(vm::psv::ptr<s32> state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocDisconnect()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocGetPeerList(vm::psv::ptr<u32> buflen, vm::psv::ptr<void> buf)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNetCtlAdhocGetInAddr(vm::psv::ptr<SceNetInAddr> inaddr)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNetCtl, #name, name)
+
+psv_log_base sceNetCtl("SceNetCtl", []()
+{
+	sceNetCtl.on_load = nullptr;
+	sceNetCtl.on_unload = nullptr;
+	sceNetCtl.on_stop = nullptr;
+
+	REG_FUNC(0x495CA1DB, sceNetCtlInit);
+	REG_FUNC(0xCD188648, sceNetCtlTerm);
+	REG_FUNC(0xDFFC3ED4, sceNetCtlCheckCallback);
+	REG_FUNC(0x6B20EC02, sceNetCtlInetGetResult);
+	REG_FUNC(0x7AE0ED19, sceNetCtlAdhocGetResult);
+	REG_FUNC(0xB26D07F3, sceNetCtlInetGetInfo);
+	REG_FUNC(0x6D26AC68, sceNetCtlInetGetState);
+	REG_FUNC(0xEAEE6185, sceNetCtlInetRegisterCallback);
+	REG_FUNC(0xD0C3BF3F, sceNetCtlInetUnregisterCallback);
+	REG_FUNC(0x4DDD6149, sceNetCtlGetNatInfo);
+	REG_FUNC(0x0961A561, sceNetCtlAdhocGetState);
+	REG_FUNC(0xFFA9D594, sceNetCtlAdhocRegisterCallback);
+	REG_FUNC(0xA4471E10, sceNetCtlAdhocUnregisterCallback);
+	REG_FUNC(0xED43B79A, sceNetCtlAdhocDisconnect);
+	REG_FUNC(0x77586C59, sceNetCtlAdhocGetPeerList);
+	REG_FUNC(0x7118C99D, sceNetCtlAdhocGetInAddr);
+});

rpcs3/Emu/ARMv7/Modules/sceNgs.cpp

@@ -0,0 +1,503 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceNgs;
+
+struct SceNgsVoiceDefinition;
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsSystemUpdate(SceNgsHSynSystem hSystemHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsSystemRelease(SceNgsHSynSystem hSystemHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsSystemLock(SceNgsHSynSystem hSystemHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsSystemUnlock(SceNgsHSynSystem hSystemHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsSystemSetParamErrorCallback(SceNgsHSynSystem hSystemHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsSystemSetFlags(SceNgsHSynSystem hSystemHandle, const u32 uSystemFlags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsRackGetRequiredMemorySize(SceNgsHSynSystem hSystemHandle, vm::psv::ptr<const SceNgsRackDescription> pRackDesc, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsRackGetVoiceHandle(SceNgsHRack hRackHandle, const u32 uIndex, vm::psv::ptr<SceNgsHVoice> pVoiceHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsRackRelease(SceNgsHRack hRackHandle, const SceNgsRackReleaseCallbackFunc callbackFuncPtr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsRackSetParamErrorCallback(SceNgsHRack hRackHandle, const SceNgsParamsErrorCallbackFunc callbackFuncPtr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceInit(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pPreset, const u32 uInitFlags)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoicePlay(SceNgsHVoice hVoiceHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceKeyOff(SceNgsHVoice hVoiceHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceKill(SceNgsHVoice hVoiceHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoicePause(SceNgsHVoice hVoiceHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceResume(SceNgsHVoice hVoiceHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceSetPreset(SceNgsHVoice hVoiceHandle, vm::psv::ptr<const SceNgsVoicePreset> pVoicePreset)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceLockParams(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsParamsID uParamsInterfaceId, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
+{
+	throw __FUNCTION__;
+}
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceBypassModule(SceNgsHVoice hVoiceHandle, const u32 uModule, const u32 uBypassFlag)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceSetModuleCallback(SceNgsHVoice hVoiceHandle, const u32 uModule, const SceNgsModuleCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceSetFinishedCallback(SceNgsHVoice hVoiceHandle, const SceNgsCallbackFunc callbackFuncPtr, vm::psv::ptr<void> pUserData)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceGetStateData(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<void> pMem, const u32 uMemSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceGetInfo(SceNgsHVoice hVoiceHandle, vm::psv::ptr<SceNgsVoiceInfo> pInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceGetModuleType(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<SceNgsModuleID> pModuleType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceGetModuleBypass(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<u32> puBypassFlag)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceGetParamsOutOfRange(SceNgsHVoice hVoiceHandle, const u32 uModule, vm::psv::ptr<char> pszMessageBuffer)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsPatchCreateRouting(vm::psv::ptr<const SceNgsPatchSetupInfo> pPatchInfo, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsPatchGetInfo(SceNgsHPatch hPatchHandle, vm::psv::ptr<SceNgsPatchRouteInfo> pRouteInfo, vm::psv::ptr<SceNgsPatchSetupInfo> pSetup)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsVoiceGetOutputPatch(SceNgsHVoice hVoiceHandle, const s32 nOutputIndex, const s32 nSubIndex, vm::psv::ptr<SceNgsHPatch> pPatchHandle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsPatchRemoveRouting(SceNgsHPatch hPatchHandle)
+{
+	throw __FUNCTION__;
+}
+
+//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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsModuleGetNumPresets(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, vm::psv::ptr<u32> puNumPresets)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNgsModuleGetPreset(SceNgsHSynSystem hSystemHandle, const SceNgsModuleID uModuleID, const u32 uPresetIndex, vm::psv::ptr<SceNgsBufferInfo> pParamsBuffer)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetCompressorSideChainBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDelayBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetDistortionBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEnvelopeBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetEqBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMasterBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetMixerBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetPauserBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetReverbBuss()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSasEmuVoice()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetSimpleVoice()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetTemplate1()
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<const SceNgsVoiceDefinition> sceNgsVoiceDefGetAtrac9Voice()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsGetDefaultConfig(vm::psv::ptr<SceSulphaNgsConfig> config)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsGetNeededMemory(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<u32> sizeInBytes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsInit(vm::psv::ptr<const SceSulphaNgsConfig> config, vm::psv::ptr<void> buffer, u32 sizeInBytes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsShutdown()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsSetSynthName(SceNgsHSynSystem synthHandle, vm::psv::ptr<const char> name)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsSetRackName(SceNgsHRack rackHandle, vm::psv::ptr<const char> name)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsSetVoiceName(SceNgsHVoice voiceHandle, vm::psv::ptr<const char> name)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsSetSampleName(vm::psv::ptr<const void> location, u32 length, vm::psv::ptr<const char> name)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNgsTrace(vm::psv::ptr<const char> message)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNgs, #name, name)
+
+psv_log_base sceNgs("SceNgs", []()
+{
+	sceNgs.on_load = nullptr;
+	sceNgs.on_unload = nullptr;
+	sceNgs.on_stop = nullptr;
+
+	REG_FUNC(0x6CE8B36F, sceNgsSystemGetRequiredMemorySize);
+	REG_FUNC(0xED14CF4A, sceNgsSystemInit);
+	REG_FUNC(0x684F080C, sceNgsSystemUpdate);
+	REG_FUNC(0x4A25BEBC, sceNgsSystemRelease);
+	REG_FUNC(0xB9D971F2, sceNgsSystemLock);
+	REG_FUNC(0x0A93EA96, sceNgsSystemUnlock);
+	REG_FUNC(0x5ADD22DC, sceNgsSystemSetParamErrorCallback);
+	REG_FUNC(0x64D80013, sceNgsSystemSetFlags);
+	REG_FUNC(0x477318C0, sceNgsRackGetRequiredMemorySize);
+	REG_FUNC(0x0A92E4EC, sceNgsRackInit);
+	REG_FUNC(0xFE1A98E9, sceNgsRackGetVoiceHandle);
+	REG_FUNC(0xDD5CA10B, sceNgsRackRelease);
+	REG_FUNC(0x534B6E3F, sceNgsRackSetParamErrorCallback);
+	REG_FUNC(0x1DDBEBEB, sceNgsVoiceInit);
+	REG_FUNC(0xFA0A0F34, sceNgsVoicePlay);
+	REG_FUNC(0xBB13373D, sceNgsVoiceKeyOff);
+	REG_FUNC(0x0E291AAD, sceNgsVoiceKill);
+	REG_FUNC(0xD7786E99, sceNgsVoicePause);
+	REG_FUNC(0x54CFB981, sceNgsVoiceResume);
+	REG_FUNC(0x8A88E665, sceNgsVoiceSetPreset);
+	REG_FUNC(0xAB6BEF8F, sceNgsVoiceLockParams);
+	REG_FUNC(0x3D46D8A7, sceNgsVoiceUnlockParams);
+	REG_FUNC(0xFB8174B1, sceNgsVoiceSetParamsBlock);
+	REG_FUNC(0x9AB87E71, sceNgsVoiceBypassModule);
+	REG_FUNC(0x24E909A8, sceNgsVoiceSetModuleCallback);
+	REG_FUNC(0x17A6F564, sceNgsVoiceSetFinishedCallback);
+	REG_FUNC(0xC9B8C0B4, sceNgsVoiceGetStateData);
+	REG_FUNC(0x5551410D, sceNgsVoiceGetInfo);
+	REG_FUNC(0xB307185E, sceNgsVoiceGetModuleType);
+	REG_FUNC(0x431BF3AB, sceNgsVoiceGetModuleBypass);
+	REG_FUNC(0xD668B49C, sceNgsPatchCreateRouting);
+	REG_FUNC(0x98703DBC, sceNgsPatchGetInfo);
+	REG_FUNC(0x01A52E3A, sceNgsVoiceGetOutputPatch);
+	REG_FUNC(0xD0C9AE5A, sceNgsPatchRemoveRouting);
+	//REG_FUNC(0xA3C807BC, sceNgsVoicePatchSetVolume);
+	REG_FUNC(0xBD6F57F0, sceNgsVoicePatchSetVolumes);
+	REG_FUNC(0xA0F5402D, sceNgsVoicePatchSetVolumesMatrix);
+	REG_FUNC(0xF6B68C31, sceNgsVoiceDefGetEnvelopeBuss);
+	REG_FUNC(0x9DCF50F5, sceNgsVoiceDefGetReverbBuss);
+	REG_FUNC(0x214485D6, sceNgsVoiceDefGetPauserBuss);
+	REG_FUNC(0xE0AC8776, sceNgsVoiceDefGetMixerBuss);
+	REG_FUNC(0x79A121D1, sceNgsVoiceDefGetMasterBuss);
+	REG_FUNC(0x0E0ACB68, sceNgsVoiceDefGetCompressorBuss);
+	REG_FUNC(0x1AF83512, sceNgsVoiceDefGetCompressorSideChainBuss);
+	REG_FUNC(0xAAD90DEB, sceNgsVoiceDefGetDistortionBuss);
+	REG_FUNC(0xF964120E, sceNgsVoiceDefGetEqBuss);
+	REG_FUNC(0xE9B572B7, sceNgsVoiceDefGetTemplate1);
+	REG_FUNC(0x0D5399CF, sceNgsVoiceDefGetSimpleVoice);
+	REG_FUNC(0x1F51C2BA, sceNgsVoiceDefGetSasEmuVoice);
+	REG_FUNC(0x4CBE08F3, sceNgsVoiceGetParamsOutOfRange);
+	REG_FUNC(0x14EF65A0, sceNgsVoiceDefGetAtrac9Voice);
+	REG_FUNC(0x4D705E3E, sceNgsVoiceDefGetDelayBuss);
+	REG_FUNC(0x5FD8AEDB, sceSulphaNgsGetDefaultConfig);
+	REG_FUNC(0x793E3E8C, sceSulphaNgsGetNeededMemory);
+	REG_FUNC(0xAFCD824F, sceSulphaNgsInit);
+	REG_FUNC(0xD124BFB1, sceSulphaNgsShutdown);
+	REG_FUNC(0x2F3F7515, sceSulphaNgsSetSynthName);
+	REG_FUNC(0x251AF6A9, sceSulphaNgsSetRackName);
+	REG_FUNC(0x508975BD, sceSulphaNgsSetVoiceName);
+	REG_FUNC(0x54EC5B8D, sceSulphaNgsSetSampleName);
+	REG_FUNC(0xDC7C0F05, sceSulphaNgsTrace);
+	REG_FUNC(0x5C71FE09, sceNgsModuleGetNumPresets);
+	REG_FUNC(0xC58298A7, sceNgsModuleGetPreset);
+});

rpcs3/Emu/ARMv7/Modules/sceNpBasic.cpp

@@ -0,0 +1,237 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNpCommon.h"
+
+extern psv_log_base sceNpBasic;
+
+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__;
+}
+
+s32 sceNpBasicTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicRegisterHandler(vm::psv::ptr<const SceNpBasicEventHandlers> handlers, vm::psv::ptr<const SceNpCommunicationId> context, vm::psv::ptr<void> userdata)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicUnregisterHandler(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicCheckCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetFriendOnlineStatus(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicFriendOnlineStatus> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetGamePresenceOfFriend(vm::psv::ptr<const SceNpId> friendId, vm::psv::ptr<SceNpBasicGamePresence> presence)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetFriendListEntryCount(vm::psv::ptr<u32> count)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetFriendListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetBlockListEntryCount(vm::psv::ptr<u32> count)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetBlockListEntries(u32 startIndex, vm::psv::ptr<SceNpId> entries, u32 numEntries, vm::psv::ptr<u32> retrieved)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicCheckIfPlayerIsBlocked(vm::psv::ptr<const SceNpId> player, vm::psv::ptr<u8> playerIsBlocked)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicSetInGamePresence(vm::psv::ptr<const SceNpBasicInGamePresence> presence)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicUnsetInGamePresence()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicSendInGameDataMessage(vm::psv::ptr<const SceNpId> to, vm::psv::ptr<const SceNpBasicInGameDataMessage> message)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicRecordPlaySessionLog(vm::psv::ptr<const SceNpId> withWhom, vm::psv::ptr<const SceNpBasicPlaySessionLogDescription> description)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetPlaySessionLogSize(SceNpBasicPlaySessionLogType type, vm::psv::ptr<u32> size)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBasicGetPlaySessionLog(SceNpBasicPlaySessionLogType type, u32 index, vm::psv::ptr<SceNpBasicPlaySessionLog> log)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpBasic, #name, name)
+
+psv_log_base sceNpBasic("SceNpBasic", []()
+{
+	sceNpBasic.on_load = nullptr;
+	sceNpBasic.on_unload = nullptr;
+	sceNpBasic.on_stop = nullptr;
+
+	REG_FUNC(0xEFB91A99, sceNpBasicInit);
+	REG_FUNC(0x389BCB3B, sceNpBasicTerm);
+	REG_FUNC(0x26E6E048, sceNpBasicRegisterHandler);
+	REG_FUNC(0x050AE072, sceNpBasicUnregisterHandler);
+	REG_FUNC(0x20146AEC, sceNpBasicCheckCallback);
+	REG_FUNC(0x5183A4B5, sceNpBasicGetFriendOnlineStatus);
+	REG_FUNC(0xEF8A91BC, sceNpBasicGetGamePresenceOfFriend);
+	REG_FUNC(0xDF41F308, sceNpBasicGetFriendListEntryCount);
+	REG_FUNC(0xFF07E787, sceNpBasicGetFriendListEntries);
+	REG_FUNC(0x407E1E6F, sceNpBasicGetBlockListEntryCount);
+	REG_FUNC(0x1211AE8E, sceNpBasicGetBlockListEntries);
+	REG_FUNC(0xF51545D8, sceNpBasicCheckIfPlayerIsBlocked);
+	REG_FUNC(0x51D75562, sceNpBasicSetInGamePresence);
+	REG_FUNC(0xD20C2370, sceNpBasicUnsetInGamePresence);
+	REG_FUNC(0x7A5020A5, sceNpBasicSendInGameDataMessage);
+	REG_FUNC(0x3B0A7F47, sceNpBasicRecordPlaySessionLog);
+	REG_FUNC(0xFB0F7FDF, sceNpBasicGetPlaySessionLogSize);
+	REG_FUNC(0x364531A8, sceNpBasicGetPlaySessionLog);
+});

rpcs3/Emu/ARMv7/Modules/sceNpCommon.cpp

@@ -0,0 +1,81 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNpCommon.h"
+
+s32 sceNpAuthInit()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthCreateStartRequest(vm::psv::ptr<const SceNpAuthRequestParameter> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthDestroyRequest(SceNpAuthRequestId id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthAbortRequest(SceNpAuthRequestId id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetTicket(SceNpAuthRequestId id, vm::psv::ptr<void> buf, u32 len)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetTicketParam(vm::psv::ptr<const u8> ticket, u32 ticketSize, s32 paramId, vm::psv::ptr<SceNpTicketParam> param)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpAuthGetEntitlementIdList(vm::psv::ptr<const u8> ticket, u32 ticketSize, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpCmpNpId(vm::psv::ptr<const SceNpId> npid1, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpCommon, #name, name)
+
+psv_log_base sceNpCommon("SceNpCommon", []()
+{
+	sceNpCommon.on_load = nullptr;
+	sceNpCommon.on_unload = nullptr;
+	sceNpCommon.on_stop = nullptr;
+
+	REG_FUNC(0x441D8B4E, sceNpAuthInit);
+	REG_FUNC(0x6093B689, sceNpAuthTerm);
+	REG_FUNC(0xED42079F, sceNpAuthCreateStartRequest);
+	REG_FUNC(0x14FC18AF, sceNpAuthDestroyRequest);
+	REG_FUNC(0xE2582575, sceNpAuthAbortRequest);
+	REG_FUNC(0x59608D1C, sceNpAuthGetTicket);
+	REG_FUNC(0xC1E23E01, sceNpAuthGetTicketParam);
+	REG_FUNC(0x3377CD37, sceNpAuthGetEntitlementIdList);
+	REG_FUNC(0xF93842F0, sceNpAuthGetEntitlementById);
+	REG_FUNC(0xFB8D82E5, sceNpCmpNpId);
+	REG_FUNC(0x6BC8150A, sceNpCmpNpIdInOrder);
+});

rpcs3/Emu/ARMv7/Modules/sceNpCommon.h

@@ -0,0 +1,154 @@
+#pragma once
+
+enum SceNpServiceState : s32
+{
+	SCE_NP_SERVICE_STATE_UNKNOWN = 0,
+	SCE_NP_SERVICE_STATE_SIGNED_OUT,
+	SCE_NP_SERVICE_STATE_SIGNED_IN,
+	SCE_NP_SERVICE_STATE_ONLINE
+};
+
+struct SceNpCommunicationId
+{
+	char data[9];
+	char term;
+	u8 num;
+	char dummy;
+};
+
+struct SceNpCommunicationPassphrase
+{
+	u8 data[128];
+};
+
+struct SceNpCommunicationSignature
+{
+	u8 data[160];
+};
+
+struct SceNpCommunicationConfig
+{
+	vm::psv::ptr<const SceNpCommunicationId> commId;
+	vm::psv::ptr<const SceNpCommunicationPassphrase> commPassphrase;
+	vm::psv::ptr<const SceNpCommunicationSignature> commSignature;
+};
+
+struct SceNpCountryCode
+{
+	char data[2];
+	char term;
+	char padding[1];
+};
+
+struct SceNpOnlineId
+{
+	char data[16];
+	char term;
+	char dummy[3];
+};
+
+struct SceNpId
+{
+	SceNpOnlineId handle;
+	u8 opt[8];
+	u8 reserved[8];
+};
+
+struct SceNpAvatarUrl
+{
+	char data[127];
+	char term;
+};
+
+struct SceNpUserInformation
+{
+	SceNpId userId;
+	SceNpAvatarUrl icon;
+	u8 reserved[52];
+};
+
+struct SceNpMyLanguages
+{
+	s32 language1;
+	s32 language2;
+	s32 language3;
+	u8 padding[4];
+};
+
+struct SceNpAvatarImage
+{
+	u8 data[200 * 1024];
+	u32 size;
+	u8 reserved[12];
+};
+
+enum SceNpAvatarSizeType : s32
+{
+	SCE_NP_AVATAR_SIZE_LARGE,
+	SCE_NP_AVATAR_SIZE_MIDDLE,
+	SCE_NP_AVATAR_SIZE_SMALL
+};
+
+struct SceNpAboutMe
+{
+	char data[64];
+};
+
+typedef s32 SceNpAuthRequestId;
+typedef u64 SceNpTime;
+
+struct SceNpDate
+{
+	u16 year;
+	u8 month;
+	u8 day;
+};
+
+union SceNpTicketParam
+{
+	s32 _s32;
+	s64 _s64;
+	u32 _u32;
+	u64 _u64;
+	SceNpDate date;
+	u8 data[256];
+};
+
+struct SceNpTicketVersion
+{
+	u16 major;
+	u16 minor;
+};
+
+typedef vm::psv::ptr<s32(SceNpAuthRequestId id, s32 result, vm::psv::ptr<void> arg)> SceNpAuthCallback;
+
+struct SceNpAuthRequestParameter
+{
+	u32 size;
+	SceNpTicketVersion version;
+	vm::psv::ptr<const char> serviceId;
+	vm::psv::ptr<const void> cookie;
+	u32 cookieSize;
+	vm::psv::ptr<const char> entitlementId;
+	u32 consumedCount;
+	SceNpAuthCallback ticketCb;
+	vm::psv::ptr<void> cbArg;
+};
+
+struct SceNpEntitlementId
+{
+	u8 data[32];
+};
+
+struct SceNpEntitlement
+{
+	SceNpEntitlementId id;
+	SceNpTime createdDate;
+	SceNpTime expireDate;
+	u32 type;
+	s32 remainingCount;
+	u32 consumedCount;
+	char padding[4];
+};
+
+extern psv_log_base sceNpCommon;

rpcs3/Emu/ARMv7/Modules/sceNpManager.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNpCommon.h"
+
+extern psv_log_base sceNpManager;
+
+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__;
+}
+
+s32 sceNpTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpCheckCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpGetServiceState(vm::psv::ptr<SceNpServiceState> state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpRegisterServiceStateCallback(SceNpServiceStateCallback callback, vm::psv::ptr<void> userdata)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpUnregisterServiceStateCallback()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetNpId(vm::psv::ptr<SceNpId> npId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetAccountRegion(vm::psv::ptr<SceNpCountryCode> countryCode, vm::psv::ptr<s32> languageCode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetContentRatingFlag(vm::psv::ptr<s32> isRestricted, vm::psv::ptr<s32> age)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpManagerGetChatRestrictionFlag(vm::psv::ptr<s32> isRestricted)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpManager, #name, name)
+
+psv_log_base sceNpManager("SceNpManager", []()
+{
+	sceNpManager.on_load = nullptr;
+	sceNpManager.on_unload = nullptr;
+	sceNpManager.on_stop = nullptr;
+
+	REG_FUNC(0x04D9F484, sceNpInit);
+	REG_FUNC(0x19E40AE1, sceNpTerm);
+	REG_FUNC(0x3C94B4B4, sceNpManagerGetNpId);
+	REG_FUNC(0x54060DF6, sceNpGetServiceState);
+	REG_FUNC(0x44239C35, sceNpRegisterServiceStateCallback);
+	REG_FUNC(0xD9E6E56C, sceNpUnregisterServiceStateCallback);
+	REG_FUNC(0x3B0AE9A9, sceNpCheckCallback);
+	REG_FUNC(0xFE835967, sceNpManagerGetAccountRegion);
+	REG_FUNC(0xAF0073B2, sceNpManagerGetContentRatingFlag);
+	REG_FUNC(0x60C575B1, sceNpManagerGetChatRestrictionFlag);
+});

rpcs3/Emu/ARMv7/Modules/sceNpScore.cpp

@@ -0,0 +1,373 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNpCommon.h"
+
+extern psv_log_base sceNpScore;
+
+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__;
+}
+
+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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreDeleteTitleCtx(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCreateRequest(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreDeleteRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreAbortRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreSetTimeout(s32 id, s32 resolveRetry, s32 resolveTimeout, s32 connTimeout, s32 sendTimeout, s32 recvTimeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreSetPlayerCharacterId(s32 id, SceNpScorePcId pcId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetBoardInfo(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordScore(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	vm::psv::ptr<const SceNpScoreComment> scoreComment,
+	vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
+	vm::psv::ptr<const u64> compareDate,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordGameData(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	u32 totalSize,
+	u32 sendSize,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetGameData(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<u32> totalSize,
+	u32 recvSize,
+	vm::psv::ptr<void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByNpId(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npIdArray,
+	u32 npIdArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByRange(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreRankNumber startSerialRank,
+	vm::psv::ptr<SceNpScoreRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+
+s32 sceNpScoreGetRankingByNpIdPcId(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
+	u32 idArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCensorComment(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreWaitAsync(s32 id, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScorePollAsync(s32 reqId, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetBoardInfoAsync(s32 reqId, SceNpScoreBoardId boardId, vm::psv::ptr<SceNpScoreBoardInfo> boardInfo, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordScoreAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	vm::psv::ptr<const SceNpScoreComment> scoreComment,
+	vm::psv::ptr<const SceNpScoreGameInfo> gameInfo,
+	vm::psv::ptr<SceNpScoreRankNumber> tmpRank,
+	vm::psv::ptr<const u64> compareDate,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreRecordGameDataAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreValue score,
+	u32 totalSize,
+	u32 sendSize,
+	vm::psv::ptr<const void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetGameDataAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<u32> totalSize,
+	u32 recvSize,
+	vm::psv::ptr<void> data,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByNpIdAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpId> npIdArray,
+	u32 npIdArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByRangeAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	SceNpScoreRankNumber startSerialRank,
+	vm::psv::ptr<SceNpScoreRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreGetRankingByNpIdPcIdAsync(
+	s32 reqId,
+	SceNpScoreBoardId boardId,
+	vm::psv::ptr<const SceNpScoreNpIdPcId> idArray,
+	u32 idArraySize,
+	vm::psv::ptr<SceNpScorePlayerRankData> rankArray,
+	u32 rankArraySize,
+	vm::psv::ptr<SceNpScoreComment> commentArray,
+	u32 commentArraySize,
+	vm::psv::ptr<SceNpScoreGameInfo> infoArray,
+	u32 infoArraySize,
+	u32 arrayNum,
+	vm::psv::ptr<u64> lastSortDate,
+	vm::psv::ptr<SceNpScoreRankNumber> totalRecord,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpScoreCensorCommentAsync(s32 reqId, vm::psv::ptr<const char> comment, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpScore, #name, name)
+
+psv_log_base sceNpScore("SceNpScore", []()
+{
+	sceNpScore.on_load = nullptr;
+	sceNpScore.on_unload = nullptr;
+	sceNpScore.on_stop = nullptr;
+
+	REG_FUNC(0x0433069F, sceNpScoreInit);
+	REG_FUNC(0x2050F98F, sceNpScoreTerm);
+	REG_FUNC(0x5685F225, sceNpScoreCreateTitleCtx);
+	REG_FUNC(0xD30D1993, sceNpScoreCreateRequest);
+	REG_FUNC(0xF52EA88A, sceNpScoreDeleteTitleCtx);
+	REG_FUNC(0xFFF24BB1, sceNpScoreDeleteRequest);
+	REG_FUNC(0x320C0277, sceNpScoreRecordScore);
+	REG_FUNC(0x24B09634, sceNpScoreRecordScoreAsync);
+	REG_FUNC(0xC2862B67, sceNpScoreRecordGameData);
+	REG_FUNC(0x40573917, sceNpScoreRecordGameDataAsync);
+	REG_FUNC(0xDFAD64D3, sceNpScoreGetGameData);
+	REG_FUNC(0xCE416993, sceNpScoreGetGameDataAsync);
+	REG_FUNC(0x427D3412, sceNpScoreGetRankingByRange);
+	REG_FUNC(0xC45E3FCD, sceNpScoreGetRankingByRangeAsync);
+	REG_FUNC(0xBAE55B34, sceNpScoreGetRankingByNpId);
+	REG_FUNC(0x45CD1D00, sceNpScoreGetRankingByNpIdAsync);
+	REG_FUNC(0x871F28AA, sceNpScoreGetRankingByNpIdPcId);
+	REG_FUNC(0xCE3A9544, sceNpScoreGetRankingByNpIdPcIdAsync);
+	REG_FUNC(0xA7E93CE1, sceNpScoreAbortRequest);
+	REG_FUNC(0x31733BF3, sceNpScoreWaitAsync);
+	REG_FUNC(0x9F2A7AC9, sceNpScorePollAsync);
+	REG_FUNC(0x00F90E7B, sceNpScoreGetBoardInfo);
+	REG_FUNC(0x3CD9974E, sceNpScoreGetBoardInfoAsync);
+	REG_FUNC(0xA0C94D46, sceNpScoreCensorComment);
+	REG_FUNC(0xAA0BBF8E, sceNpScoreCensorCommentAsync);
+	REG_FUNC(0x6FD2041A, sceNpScoreSanitizeComment);
+	REG_FUNC(0x15981858, sceNpScoreSanitizeCommentAsync);
+	REG_FUNC(0x5EF44841, sceNpScoreSetTimeout);
+	REG_FUNC(0x53D77883, sceNpScoreSetPlayerCharacterId);
+});

rpcs3/Emu/ARMv7/Modules/sceNpUtility.cpp

@@ -0,0 +1,167 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceNpCommon.h"
+
+extern psv_log_base sceNpUtility;
+
+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__;
+}
+
+s32 sceNpLookupTerm(ARMv7Context&)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupCreateTitleCtx(vm::psv::ptr<const SceNpCommunicationId> titleId, vm::psv::ptr<const SceNpId> selfNpId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupDeleteTitleCtx(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupCreateRequest(s32 titleCtxId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupDeleteRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupAbortRequest(s32 reqId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupSetTimeout(s32 id, s32 resolveRetry, u32 resolveTimeout, u32 connTimeout, u32 sendTimeout, u32 recvTimeout)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupWaitAsync(s32 reqId, vm::psv::ptr<s32> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupPollAsync(s32 reqId, vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupNpIdAsync(s32 reqId, vm::psv::ptr<const SceNpOnlineId> onlineId, vm::psv::ptr<SceNpId> npId, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupUserProfile(
+	s32 reqId,
+	s32 avatarSizeType,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<SceNpUserInformation> userInfo,
+	vm::psv::ptr<SceNpAboutMe> aboutMe,
+	vm::psv::ptr<SceNpMyLanguages> languages,
+	vm::psv::ptr<SceNpCountryCode> countryCode,
+	vm::psv::ptr<void> avatarImageData,
+	u32 avatarImageDataMaxSize,
+	vm::psv::ptr<u32> avatarImageDataSize,
+	vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupUserProfileAsync(
+	s32 reqId,
+	s32 avatarSizeType,
+	vm::psv::ptr<const SceNpId> npId,
+	vm::psv::ptr<SceNpUserInformation> userInfo,
+	vm::psv::ptr<SceNpAboutMe> aboutMe,
+	vm::psv::ptr<SceNpMyLanguages> languages,
+	vm::psv::ptr<SceNpCountryCode> countryCode,
+	vm::psv::ptr<void> avatarImageData,
+	u32 avatarImageDataMaxSize,
+	vm::psv::ptr<u32> avatarImageDataSize,
+	vm::psv::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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpLookupAvatarImageAsync(s32 reqId, vm::psv::ptr<const SceNpAvatarUrl> avatarUrl, vm::psv::ptr<SceNpAvatarImage> avatarImage, vm::psv::ptr<void> option)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestInitStart(s32 initPriority, s32 cpuAffinityMask)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestGetStatus()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestShutdown(vm::psv::ptr<SceNpBandwidthTestResult> result)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceNpBandwidthTestAbort()
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceNpUtility, #name, name)
+
+psv_log_base sceNpUtility("SceNpUtility", []()
+{
+	sceNpUtility.on_load = nullptr;
+	sceNpUtility.on_unload = nullptr;
+	sceNpUtility.on_stop = nullptr;
+
+	REG_FUNC(0x9246A673, sceNpLookupInit);
+	REG_FUNC(0x0158B61B, sceNpLookupTerm);
+	REG_FUNC(0x5110E17E, sceNpLookupCreateTitleCtx);
+	REG_FUNC(0x33B64699, sceNpLookupDeleteTitleCtx);
+	REG_FUNC(0x9E42E922, sceNpLookupCreateRequest);
+	REG_FUNC(0x8B608BF6, sceNpLookupDeleteRequest);
+	REG_FUNC(0x027587C4, sceNpLookupAbortRequest);
+	REG_FUNC(0xB0C9DC45, sceNpLookupSetTimeout);
+	REG_FUNC(0xCF956F23, sceNpLookupWaitAsync);
+	REG_FUNC(0xFCDBA234, sceNpLookupPollAsync);
+	REG_FUNC(0xB1A14879, sceNpLookupNpId);
+	REG_FUNC(0x5387BABB, sceNpLookupNpIdAsync);
+	REG_FUNC(0x6A1BF429, sceNpLookupUserProfile);
+	REG_FUNC(0xE5285E0F, sceNpLookupUserProfileAsync);
+	REG_FUNC(0xFDB0AE47, sceNpLookupAvatarImage);
+	REG_FUNC(0x282BD43C, sceNpLookupAvatarImageAsync);
+	REG_FUNC(0x081FA13C, sceNpBandwidthTestInitStart);
+	REG_FUNC(0xE0EBFBF6, sceNpBandwidthTestGetStatus);
+	REG_FUNC(0x58D92EFD, sceNpBandwidthTestShutdown);
+	REG_FUNC(0x32B068C4, sceNpBandwidthTestAbort);
+});

rpcs3/Emu/ARMv7/Modules/scePgf.cpp

@@ -0,0 +1,38 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base scePgf;
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &scePgf, #name, name)
+
+psv_log_base scePgf("ScePgf", []()
+{
+	scePgf.on_load = nullptr;
+	scePgf.on_unload = nullptr;
+	scePgf.on_stop = nullptr;
+
+	//REG_FUNC(0x1055ABA3, sceFontNewLib);
+	//REG_FUNC(0x07EE1733, sceFontDoneLib);
+	//REG_FUNC(0xDE47674C, sceFontSetResolution);
+	//REG_FUNC(0x9F842307, sceFontGetNumFontList);
+	//REG_FUNC(0xD56DCCEA, sceFontGetFontList);
+	//REG_FUNC(0x8DFBAE1B, sceFontFindOptimumFont);
+	//REG_FUNC(0x51061D87, sceFontFindFont);
+	//REG_FUNC(0xAB034738, sceFontGetFontInfoByIndexNumber);
+	//REG_FUNC(0xBD2DFCFF, sceFontOpen);
+	//REG_FUNC(0xE260E740, sceFontOpenUserFile);
+	//REG_FUNC(0xB23ED47C, sceFontOpenUserMemory);
+	//REG_FUNC(0x4A7293E9, sceFontClose);
+	//REG_FUNC(0xF9414FA2, sceFontGetFontInfo);
+	//REG_FUNC(0x6FD1BA65, sceFontGetCharInfo);
+	//REG_FUNC(0x70C86B3E, sceFontGetCharImageRect);
+	//REG_FUNC(0xAB45AAD3, sceFontGetCharGlyphImage);
+	//REG_FUNC(0xEB589530, sceFontGetCharGlyphImage_Clip);
+	//REG_FUNC(0x9E38F4D6, sceFontPixelToPointH);
+	//REG_FUNC(0x7B45E2D1, sceFontPixelToPointV);
+	//REG_FUNC(0x39B9AEFF, sceFontPointToPixelH);
+	//REG_FUNC(0x03F10EC8, sceFontPointToPixelV);
+	//REG_FUNC(0x8D5B44DF, sceFontSetAltCharacterCode);
+	//REG_FUNC(0x7D8CB13B, sceFontFlush);
+});

rpcs3/Emu/ARMv7/Modules/scePhotoExport.cpp

@@ -0,0 +1,53 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base scePhotoExport;
+
+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,
+	s32 photodataSize,
+	vm::psv::ptr<const ScePhotoExportParam> param,
+	vm::psv::ptr<void> workMemory,
+	ScePhotoExportCancelFunc cancelFunc,
+	vm::psv::ptr<void> userdata,
+	vm::psv::ptr<char> exportedPath,
+	s32 exportedPathLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 scePhotoExportFromFile(
+	vm::psv::ptr<const char> photodataPath,
+	vm::psv::ptr<const ScePhotoExportParam> param,
+	vm::psv::ptr<void> workMemory,
+	ScePhotoExportCancelFunc cancelFunc,
+	vm::psv::ptr<void> userdata,
+	vm::psv::ptr<char> exportedPath,
+	s32 exportedPathLength)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &scePhotoExport, #name, name)
+
+psv_log_base scePhotoExport("ScePhotoExport", []()
+{
+	scePhotoExport.on_load = nullptr;
+	scePhotoExport.on_unload = nullptr;
+	scePhotoExport.on_stop = nullptr;
+
+	REG_FUNC(0x70512321, scePhotoExportFromData);
+	REG_FUNC(0x84FD9FC5, scePhotoExportFromFile);
+});

rpcs3/Emu/ARMv7/Modules/sceRazorCapture.cpp

@@ -0,0 +1,33 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceRazorCapture;
+
+void sceRazorCaptureSetTrigger(u32 frameIndex, vm::psv::ptr<const char> captureFilename)
+{
+	throw __FUNCTION__;
+}
+
+void sceRazorCaptureSetTriggerNextFrame(vm::psv::ptr<const char> captureFilename)
+{
+	throw __FUNCTION__;
+}
+
+bool sceRazorCaptureIsInProgress()
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceRazorCapture, #name, name)
+
+psv_log_base sceRazorCapture("SceRazorCapture", []()
+{
+	sceRazorCapture.on_load = nullptr;
+	sceRazorCapture.on_unload = nullptr;
+	sceRazorCapture.on_stop = nullptr;
+
+	REG_FUNC(0x911E0AA0, sceRazorCaptureIsInProgress);
+	REG_FUNC(0xE916B538, sceRazorCaptureSetTrigger);
+	REG_FUNC(0x3D4B7E68, sceRazorCaptureSetTriggerNextFrame);
+});

rpcs3/Emu/ARMv7/Modules/sceRtc.cpp

@@ -0,0 +1,238 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceRtc;
+
+u32 sceRtcGetTickResolution()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetCurrentTick(vm::psv::ptr<u64> pTick)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetCurrentClock(vm::psv::ptr<SceDateTime> pTime, s32 iTimeZone)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetCurrentClockLocalTime(vm::psv::ptr<SceDateTime> pTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetCurrentNetworkTick(vm::psv::ptr<u64> pTick)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcConvertUtcToLocalTime(vm::psv::ptr<const u64> pUtc, vm::psv::ptr<u64> pLocalTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcConvertLocalTimeToUtc(vm::psv::ptr<const u64> pLocalTime, vm::psv::ptr<u64> pUtc)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcIsLeapYear(s32 year)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetDaysInMonth(s32 year, s32 month)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetDayOfWeek(s32 year, s32 month, s32 day)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcCheckValid(vm::psv::ptr<const SceDateTime> pTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcSetTime_t(vm::psv::ptr<SceDateTime> pTime, time_t iTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcSetTime64_t(vm::psv::ptr<SceDateTime> pTime, u64 ullTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetTime_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<time_t> piTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetTime64_t(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pullTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcSetDosTime(vm::psv::ptr<SceDateTime> pTime, u32 uiDosTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetDosTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u32> puiDosTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcSetWin32FileTime(vm::psv::ptr<SceDateTime> pTime, u64 ulWin32Time)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetWin32FileTime(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> ulWin32Time)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcSetTick(vm::psv::ptr<SceDateTime> pTime, vm::psv::ptr<const u64> pTick)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcGetTick(vm::psv::ptr<const SceDateTime> pTime, vm::psv::ptr<u64> pTick)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcCompareTick(vm::psv::ptr<const u64> pTick1, vm::psv::ptr<const u64> pTick2)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddTicks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddMicroseconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddSeconds(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddMinutes(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, u64 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddHours(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddDays(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddWeeks(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddMonths(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcTickAddYears(vm::psv::ptr<u64> pTick0, vm::psv::ptr<const u64> pTick1, s32 lAdd)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcFormatRFC2822(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcFormatRFC2822LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcFormatRFC3339(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc, s32 iTimeZoneMinutes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcFormatRFC3339LocalTime(vm::psv::ptr<char> pszDateTime, vm::psv::ptr<const u64> pUtc)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcParseDateTime(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceRtcParseRFC3339(vm::psv::ptr<u64> pUtc, vm::psv::ptr<const char> pszDateTime)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceRtc, #name, name)
+
+psv_log_base sceRtc("SceRtc", []()
+{
+	sceRtc.on_load = nullptr;
+	sceRtc.on_unload = nullptr;
+	sceRtc.on_stop = nullptr;
+
+	REG_FUNC(0x23F79274, sceRtcGetCurrentTick);
+	REG_FUNC(0xCDDD25FE, sceRtcGetCurrentNetworkTick);
+	REG_FUNC(0x70FDE8F1, sceRtcGetCurrentClock);
+	REG_FUNC(0x0572EDDC, sceRtcGetCurrentClockLocalTime);
+	REG_FUNC(0x1282C436, sceRtcConvertUtcToLocalTime);
+	REG_FUNC(0x0A05E201, sceRtcConvertLocalTimeToUtc);
+	REG_FUNC(0x42CA8EB5, sceRtcFormatRFC2822LocalTime);
+	REG_FUNC(0x147F2138, sceRtcFormatRFC2822);
+	REG_FUNC(0x742250A9, sceRtcFormatRFC3339LocalTime);
+	REG_FUNC(0xCCEA2B54, sceRtcFormatRFC3339);
+	REG_FUNC(0xF17FD8B5, sceRtcIsLeapYear);
+	REG_FUNC(0x49EB4556, sceRtcGetDaysInMonth);
+	REG_FUNC(0x2F3531EB, sceRtcGetDayOfWeek);
+	REG_FUNC(0xD7622935, sceRtcCheckValid);
+	REG_FUNC(0x3A332F81, sceRtcSetTime_t);
+	REG_FUNC(0xA6C36B6A, sceRtcSetTime64_t);
+	REG_FUNC(0x8DE6FEB7, sceRtcGetTime_t);
+	REG_FUNC(0xC995DE02, sceRtcGetTime64_t);
+	REG_FUNC(0xF8B22B07, sceRtcSetDosTime);
+	REG_FUNC(0x92ABEBAF, sceRtcGetDosTime);
+	REG_FUNC(0xA79A8846, sceRtcSetWin32FileTime);
+	REG_FUNC(0x8A95E119, sceRtcGetWin32FileTime);
+	REG_FUNC(0x811313B3, sceRtcGetTickResolution);
+	REG_FUNC(0xCD89F464, sceRtcSetTick);
+	REG_FUNC(0xF2B238E2, sceRtcGetTick);
+	REG_FUNC(0xC7385158, sceRtcCompareTick);
+	REG_FUNC(0x4559E2DB, sceRtcTickAddTicks);
+	REG_FUNC(0xAE26D920, sceRtcTickAddMicroseconds);
+	REG_FUNC(0x979AFD79, sceRtcTickAddSeconds);
+	REG_FUNC(0x4C358871, sceRtcTickAddMinutes);
+	REG_FUNC(0x6F193F55, sceRtcTickAddHours);
+	REG_FUNC(0x58DE3C70, sceRtcTickAddDays);
+	REG_FUNC(0xE713C640, sceRtcTickAddWeeks);
+	REG_FUNC(0x6321B4AA, sceRtcTickAddMonths);
+	REG_FUNC(0xDF6C3E1B, sceRtcTickAddYears);
+	REG_FUNC(0x2347CE12, sceRtcParseDateTime);
+	REG_FUNC(0x2D18AEEC, sceRtcParseRFC3339);
+});

rpcs3/Emu/ARMv7/Modules/sceSas.cpp

@@ -0,0 +1,210 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceSas;
+
+s32 sceSasGetNeededMemorySize(vm::psv::ptr<const char> config, vm::psv::ptr<u32> outSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasInit(vm::psv::ptr<const char> config, vm::psv::ptr<void> buffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasInitWithGrain(vm::psv::ptr<const char> config, u32 grain, vm::psv::ptr<void> buffer, u32 bufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasExit(vm::psv::ptr<vm::psv::ptr<void>> outBuffer, vm::psv::ptr<u32> outBufferSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetGrain(u32 grain)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasGetGrain()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetOutputmode(u32 outputmode)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasGetOutputmode()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasCore(vm::psv::ptr<s16> out)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasCoreWithMix(vm::psv::ptr<s16> inOut, s32 lvol, s32 rvol)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetVoice(s32 iVoiceNum, vm::psv::ptr<const void> vagBuf, u32 size, u32 loopflag)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetVoicePCM(s32 iVoiceNum, vm::psv::ptr<const void> pcmBuf, u32 size, s32 loopsize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetNoise(s32 iVoiceNum, u32 uClk)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetVolume(s32 iVoiceNum, s32 l, s32 r, s32 wl, s32 wr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetPitch(s32 iVoiceNum, s32 pitch)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetADSR(s32 iVoiceNum, u32 flag, u32 ar, u32 dr, u32 sr, u32 rr)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetADSRmode(s32 iVoiceNum, u32 flag, u32 am, u32 dm, u32 sm, u32 rm)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetSL(s32 iVoiceNum, u32 sl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetSimpleADSR(s32 iVoiceNum, u16 adsr1, u16 adsr2)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetKeyOn(s32 iVoiceNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetKeyOff(s32 iVoiceNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetPause(s32 iVoiceNum, u32 pauseFlag)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasGetPauseState(s32 iVoiceNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasGetEndState(s32 iVoiceNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasGetEnvelope(s32 iVoiceNum)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetEffect(s32 drySwitch, s32 wetSwitch)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetEffectType(s32 type)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetEffectVolume(s32 valL, s32 valR)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSasSetEffectParam(u32 delayTime, u32 feedback)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSas, #name, name)
+
+psv_log_base sceSas("SceSas", []()
+{
+	sceSas.on_load = nullptr;
+	sceSas.on_unload = nullptr;
+	sceSas.on_stop = nullptr;
+
+	//REG_FUNC(0xA2209C58, sceAsSetRegisterReportHandler);
+	//REG_FUNC(0xBB635544, sceAsSetUnregisterReportHandler);
+	//REG_FUNC(0xF578F0EF, sceAsGetSystemNeededMemory);
+	//REG_FUNC(0xAA8D4541, sceAsCreateSystem);
+	//REG_FUNC(0x139D29C0, sceAsDestroySystem);
+	//REG_FUNC(0xBE843EEC, sceAsLockParam);
+	//REG_FUNC(0xFF2380C4, sceAsUnlockParam);
+	//REG_FUNC(0x2549F436, sceAsSetEvent);
+	//REG_FUNC(0xDC26B9F2, sceAsGetState);
+	//REG_FUNC(0xB6220E73, sceAsSetBuss);
+	//REG_FUNC(0x1E608068, sceAsSetRacks);
+	//REG_FUNC(0x5835B473, sceAsSetGranularity);
+	//REG_FUNC(0xDFE6502F, sceAsGetGranularity);
+	//REG_FUNC(0xC72F1EEF, sceAsRender);
+	//REG_FUNC(0xCE23F057, sceAsLockUpdate);
+	//REG_FUNC(0x8BEF3C92, sceAsUnlockUpdate);
+	REG_FUNC(0x180C6824, sceSasGetNeededMemorySize);
+	REG_FUNC(0x449B5974, sceSasInit);
+	REG_FUNC(0x820D5F82, sceSasInitWithGrain);
+	REG_FUNC(0xBB7D6790, sceSasExit);
+	REG_FUNC(0x2B4A207C, sceSasSetGrain);
+	REG_FUNC(0x2BEA45BC, sceSasGetGrain);
+	REG_FUNC(0x44DDB3C4, sceSasSetOutputmode);
+	REG_FUNC(0x2C36E150, sceSasGetOutputmode);
+	REG_FUNC(0x7A4672B2, sceSasCore);
+	REG_FUNC(0xBD496983, sceSasCoreWithMix);
+	REG_FUNC(0x2B75F9BC, sceSasSetVoice);
+	REG_FUNC(0xB1756EFC, sceSasSetVoicePCM);
+	REG_FUNC(0xF1C63CB9, sceSasSetNoise);
+	REG_FUNC(0x0BE8204D, sceSasSetVolume);
+	//REG_FUNC(0x011788BE, sceSasSetDistortion);
+	REG_FUNC(0x2C48A08C, sceSasSetPitch);
+	REG_FUNC(0x18A5EFA2, sceSasSetADSR);
+	REG_FUNC(0x5207F9D2, sceSasSetADSRmode);
+	REG_FUNC(0xDE6227B8, sceSasSetSL);
+	REG_FUNC(0xECCE0DB8, sceSasSetSimpleADSR);
+	REG_FUNC(0xC838DB6F, sceSasSetKeyOn);
+	REG_FUNC(0x5E42ADAB, sceSasSetKeyOff);
+	REG_FUNC(0x59C7A9DF, sceSasSetPause);
+	REG_FUNC(0x007E63E6, sceSasGetEndState);
+	REG_FUNC(0xFD1A0CBF, sceSasGetPauseState);
+	REG_FUNC(0x296A9910, sceSasGetEnvelope);
+	REG_FUNC(0xB0444E69, sceSasSetEffect);
+	REG_FUNC(0xCDF2DDD5, sceSasSetEffectType);
+	REG_FUNC(0x55EDDBFA, sceSasSetEffectVolume);
+	REG_FUNC(0xBAD546A0, sceSasSetEffectParam);
+	//REG_FUNC(0xB6642276, sceSasGetDryPeak);
+	//REG_FUNC(0x4314F0E9, sceSasGetWetPeak);
+	//REG_FUNC(0x1568017A, sceSasGetPreMasterPeak);
+});

rpcs3/Emu/ARMv7/Modules/sceScreenShot.cpp

@@ -0,0 +1,48 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceScreenShot;
+
+struct SceScreenShotParam
+{
+	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)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceScreenShotDisable()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceScreenShotEnable()
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceScreenShot, #name, name)
+
+psv_log_base sceScreenShot("SceScreenShot", []()
+{
+	sceScreenShot.on_load = nullptr;
+	sceScreenShot.on_unload = nullptr;
+	sceScreenShot.on_stop = nullptr;
+
+	REG_FUNC(0x05DB59C7, sceScreenShotSetParam);
+	REG_FUNC(0x7061665B, sceScreenShotSetOverlayImage);
+	REG_FUNC(0x50AE9FF9, sceScreenShotDisable);
+	REG_FUNC(0x76E674D1, sceScreenShotEnable);
+});

rpcs3/Emu/ARMv7/Modules/sceSfmt.cpp

@@ -0,0 +1,84 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceSfmt;
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSfmt, #name, name)
+
+psv_log_base sceSfmt("SceSfmt", []()
+{
+	sceSfmt.on_load = nullptr;
+	sceSfmt.on_unload = nullptr;
+	sceSfmt.on_stop = nullptr;
+
+	//REG_FUNC(0x8FF464C9, sceSfmt11213InitGenRand);
+	//REG_FUNC(0xBAF5F058, sceSfmt11213InitByArray);
+	//REG_FUNC(0xFB281CD7, sceSfmt11213GenRand32);
+	//REG_FUNC(0xAFEDD6E1, sceSfmt11213GenRand64);
+	//REG_FUNC(0xFD696585, sceSfmt11213FillArray32);
+	//REG_FUNC(0x7A412A29, sceSfmt11213FillArray64);
+
+	//REG_FUNC(0x02E8D906, sceSfmt1279InitGenRand);
+	//REG_FUNC(0xC25D9ACE, sceSfmt1279InitByArray);
+	//REG_FUNC(0x9B4A48DF, sceSfmt1279GenRand32);
+	//REG_FUNC(0xA2C5EE14, sceSfmt1279GenRand64);
+	//REG_FUNC(0xE7F63838, sceSfmt1279FillArray32);
+	//REG_FUNC(0xDB3832EB, sceSfmt1279FillArray64);
+
+	//REG_FUNC(0xDC6B23B0, sceSfmt132049InitGenRand);
+	//REG_FUNC(0xDC69294A, sceSfmt132049InitByArray);
+	//REG_FUNC(0x795F9644, sceSfmt132049GenRand32);
+	//REG_FUNC(0xBBD80AC4, sceSfmt132049GenRand64);
+	//REG_FUNC(0xD891A99F, sceSfmt132049FillArray32);
+	//REG_FUNC(0x68AD7866, sceSfmt132049FillArray64);
+
+	//REG_FUNC(0x2AFACB0B, sceSfmt19937InitGenRand);
+	//REG_FUNC(0xAC496C8C, sceSfmt19937InitByArray);
+	//REG_FUNC(0xF0557157, sceSfmt19937GenRand32);
+	//REG_FUNC(0xE66F2502, sceSfmt19937GenRand64);
+	//REG_FUNC(0xA1C654D8, sceSfmt19937FillArray32);
+	//REG_FUNC(0xE74BA81C, sceSfmt19937FillArray64);
+
+	//REG_FUNC(0x86DDE4A7, sceSfmt216091InitGenRand);
+	//REG_FUNC(0xA9CF6616, sceSfmt216091InitByArray);
+	//REG_FUNC(0x4A972DCD, sceSfmt216091GenRand32);
+	//REG_FUNC(0x23369ABF, sceSfmt216091GenRand64);
+	//REG_FUNC(0xDD4256F0, sceSfmt216091FillArray32);
+	//REG_FUNC(0xA1CE5628, sceSfmt216091FillArray64);
+
+	//REG_FUNC(0xB8E5A0BB, sceSfmt2281InitGenRand);
+	//REG_FUNC(0xAB3AD459, sceSfmt2281InitByArray);
+	//REG_FUNC(0x84BB4ADB, sceSfmt2281GenRand32);
+	//REG_FUNC(0x3CC47146, sceSfmt2281GenRand64);
+	//REG_FUNC(0xBB89D8F0, sceSfmt2281FillArray32);
+	//REG_FUNC(0x17C10E2D, sceSfmt2281FillArray64);
+
+	//REG_FUNC(0xE9F8CB9A, sceSfmt4253InitGenRand);
+	//REG_FUNC(0xC4D7AA2D, sceSfmt4253InitByArray);
+	//REG_FUNC(0x8791E2EF, sceSfmt4253GenRand32);
+	//REG_FUNC(0x6C0E5E3C, sceSfmt4253GenRand64);
+	//REG_FUNC(0x59A1B9FC, sceSfmt4253FillArray32);
+	//REG_FUNC(0x01683CDD, sceSfmt4253FillArray64);
+
+	//REG_FUNC(0xCF1C8C38, sceSfmt44497InitGenRand);
+	//REG_FUNC(0x16D8AA5E, sceSfmt44497InitByArray);
+	//REG_FUNC(0xF869DFDC, sceSfmt44497GenRand32);
+	//REG_FUNC(0xD411A9A6, sceSfmt44497GenRand64);
+	//REG_FUNC(0x1C38322A, sceSfmt44497FillArray32);
+	//REG_FUNC(0x908F1122, sceSfmt44497FillArray64);
+
+	//REG_FUNC(0x76A5D8CA, sceSfmt607InitGenRand);
+	//REG_FUNC(0xCC6DABA0, sceSfmt607InitByArray);
+	//REG_FUNC(0x8A0BF859, sceSfmt607GenRand32);
+	//REG_FUNC(0x5E880862, sceSfmt607GenRand64);
+	//REG_FUNC(0xA288ADB9, sceSfmt607FillArray32);
+	//REG_FUNC(0x1520D408, sceSfmt607FillArray64);
+
+	//REG_FUNC(0x2FF42588, sceSfmt86243InitGenRand);
+	//REG_FUNC(0x81B67AB5, sceSfmt86243InitByArray);
+	//REG_FUNC(0x569BF903, sceSfmt86243GenRand32);
+	//REG_FUNC(0x8E25CBA8, sceSfmt86243GenRand64);
+	//REG_FUNC(0xC297E6B1, sceSfmt86243FillArray32);
+	//REG_FUNC(0xF7FFE87C, sceSfmt86243FillArray64);
+});

rpcs3/Emu/ARMv7/Modules/sceSha.cpp

@@ -0,0 +1,44 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceSha;
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSha, #name, name)
+
+psv_log_base sceSha("SceSha", []()
+{
+	sceSha.on_load = nullptr;
+	sceSha.on_unload = nullptr;
+	sceSha.on_stop = nullptr;
+
+	//REG_FUNC(0xD19A9AA8, sceSha0Digest);
+	//REG_FUNC(0xBCF6DB3A, sceSha0BlockInit);
+	//REG_FUNC(0x37EF2AFC, sceSha0BlockUpdate);
+	//REG_FUNC(0xBF0158C4, sceSha0BlockResult);
+
+	//REG_FUNC(0xE1215C9D, sceSha1Digest);
+	//REG_FUNC(0xB13D65AA, sceSha1BlockInit);
+	//REG_FUNC(0x9007205E, sceSha1BlockUpdate);
+	//REG_FUNC(0x0195DADF, sceSha1BlockResult);
+
+	//REG_FUNC(0x1346D270, sceSha224Digest);
+	//REG_FUNC(0x538F04CE, sceSha224BlockInit);
+	//REG_FUNC(0xB5FD0160, sceSha224BlockUpdate);
+	//REG_FUNC(0xA36ECF65, sceSha224BlockResult);
+
+	//REG_FUNC(0xA337079C, sceSha256Digest);
+	//REG_FUNC(0xE281374F, sceSha256BlockInit);
+	//REG_FUNC(0xDAECA1F8, sceSha256BlockUpdate);
+	//REG_FUNC(0x9B5BB4BA, sceSha256BlockResult);
+
+	//REG_FUNC(0xA602C694, sceSha384Digest);
+	//REG_FUNC(0x037AABE7, sceSha384BlockInit);
+	//REG_FUNC(0x4B99DBB8, sceSha384BlockUpdate);
+	//REG_FUNC(0x30D5C919, sceSha384BlockResult);
+
+	//REG_FUNC(0x5DC0B916, sceSha512Digest);
+	//REG_FUNC(0xE017A9CD, sceSha512BlockInit);
+	//REG_FUNC(0x669281E8, sceSha512BlockUpdate);
+	//REG_FUNC(0x26146A16, sceSha512BlockResult);
+});

rpcs3/Emu/ARMv7/Modules/sceSqlite.cpp

@@ -0,0 +1,187 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceSqlite;
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSqlite, #name, name)
+
+psv_log_base sceSqlite("SceSqlite", []()
+{
+	sceSqlite.on_load = nullptr;
+	sceSqlite.on_unload = nullptr;
+	sceSqlite.on_stop = nullptr;
+
+	//REG_FUNC(0x26E46324, sqlite3_libversion);
+	//REG_FUNC(0x4CCB58A2, sqlite3_sourceid);
+	//REG_FUNC(0x5982F404, sqlite3_libversion_number);
+	//REG_FUNC(0xA3B818DA, sqlite3_threadsafe);
+	//REG_FUNC(0x7DF94B79, sqlite3_close);
+	//REG_FUNC(0x2371E86A, sqlite3_exec);
+	//REG_FUNC(0xC22AF627, sqlite3_initialize);
+	//REG_FUNC(0x99B5A4A3, sqlite3_shutdown);
+	//REG_FUNC(0xBD304836, sqlite3_os_init);
+	//REG_FUNC(0x9CE7C4C3, sqlite3_os_end);
+	//REG_FUNC(0x96C5D388, sqlite3_config);
+	//REG_FUNC(0xADFB25C0, sqlite3_db_config);
+	//REG_FUNC(0x3892C4B8, sqlite3_extended_result_codes);
+	//REG_FUNC(0x301851A1, sqlite3_last_insert_rowid);
+	//REG_FUNC(0xF206FBA1, sqlite3_changes);
+	//REG_FUNC(0x02ADA92D, sqlite3_total_changes);
+	//REG_FUNC(0x3CB771AC, sqlite3_interrupt);
+	//REG_FUNC(0x2E28B2A7, sqlite3_complete);
+	//REG_FUNC(0x4EAB317B, sqlite3_complete16);
+	//REG_FUNC(0xB5B5D287, sqlite3_busy_handler);
+	//REG_FUNC(0xAE8E3630, sqlite3_busy_timeout);
+	//REG_FUNC(0xF2AB9C89, sqlite3_get_table);
+	//REG_FUNC(0x1FEC6959, sqlite3_free_table);
+	//REG_FUNC(0xE630216C, sqlite3_mprintf);
+	//REG_FUNC(0xC6372184, sqlite3_vmprintf);
+	//REG_FUNC(0xCC189941, sqlite3_snprintf);
+	//REG_FUNC(0xF01DEB95, sqlite3_malloc);
+	//REG_FUNC(0xD1CF5631, sqlite3_realloc);
+	//REG_FUNC(0xCBF0CA8A, sqlite3_free);
+	//REG_FUNC(0x8E4F6ED5, sqlite3_memory_used);
+	//REG_FUNC(0x2F33DAD6, sqlite3_memory_highwater);
+	//REG_FUNC(0x5A2590BF, sqlite3_randomness);
+	//REG_FUNC(0x77FB3458, sqlite3_set_authorizer);
+	//REG_FUNC(0xFC127A83, sqlite3_trace);
+	//REG_FUNC(0x48B789A1, sqlite3_profile);
+	//REG_FUNC(0x19165D04, sqlite3_progress_handler);
+	//REG_FUNC(0x8E506859, sqlite3_open);
+	//REG_FUNC(0x881EEDD8, sqlite3_open16);
+	//REG_FUNC(0xA1E98A41, sqlite3_open_v2);
+	//REG_FUNC(0xA7AAE2E7, sqlite3_errcode);
+	//REG_FUNC(0x91187282, sqlite3_extended_errcode);
+	//REG_FUNC(0xABFB8B6E, sqlite3_errmsg);
+	//REG_FUNC(0xF0DE1A97, sqlite3_errmsg16);
+	//REG_FUNC(0xDED2D517, sqlite3_limit);
+	//REG_FUNC(0x0C1B5509, sqlite3_prepare);
+	//REG_FUNC(0xBC4BDCF4, sqlite3_prepare_v2);
+	//REG_FUNC(0xC657CFB8, sqlite3_prepare16);
+	//REG_FUNC(0x426D81D2, sqlite3_prepare16_v2);
+	//REG_FUNC(0x082C36D4, sqlite3_sql);
+	//REG_FUNC(0x3F225D62, sqlite3_bind_blob);
+	//REG_FUNC(0xDE007F1B, sqlite3_bind_double);
+	//REG_FUNC(0x14ABCBCC, sqlite3_bind_int);
+	//REG_FUNC(0x43D967EF, sqlite3_bind_int64);
+	//REG_FUNC(0xFF8A9974, sqlite3_bind_null);
+	//REG_FUNC(0x613AB709, sqlite3_bind_text);
+	//REG_FUNC(0x9D0FEAEF, sqlite3_bind_text16);
+	//REG_FUNC(0x8A667D2A, sqlite3_bind_value);
+	//REG_FUNC(0x78FBA2D0, sqlite3_bind_zeroblob);
+	//REG_FUNC(0x17D4F00B, sqlite3_bind_parameter_count);
+	//REG_FUNC(0x96D3B5F9, sqlite3_bind_parameter_name);
+	//REG_FUNC(0xD4D2A5D8, sqlite3_bind_parameter_index);
+	//REG_FUNC(0x690947E2, sqlite3_clear_bindings);
+	//REG_FUNC(0x8567A8DE, sqlite3_column_count);
+	//REG_FUNC(0xBC422DF6, sqlite3_column_name);
+	//REG_FUNC(0x6EF9A642, sqlite3_column_name16);
+	//REG_FUNC(0x5AE92D67, sqlite3_column_decltype);
+	//REG_FUNC(0xE058DE60, sqlite3_column_decltype16);
+	//REG_FUNC(0xCA8755B7, sqlite3_step);
+	//REG_FUNC(0x61911935, sqlite3_data_count);
+	//REG_FUNC(0xFE237ED7, sqlite3_column_blob);
+	//REG_FUNC(0x36013FE4, sqlite3_column_bytes);
+	//REG_FUNC(0x439F160B, sqlite3_column_bytes16);
+	//REG_FUNC(0xC4866097, sqlite3_column_double);
+	//REG_FUNC(0xE5B6BA01, sqlite3_column_int);
+	//REG_FUNC(0x90BA0B88, sqlite3_column_int64);
+	//REG_FUNC(0x8E68D270, sqlite3_column_text);
+	//REG_FUNC(0xD7BD6B76, sqlite3_column_text16);
+	//REG_FUNC(0xDBB25C43, sqlite3_column_type);
+	//REG_FUNC(0x2227F21D, sqlite3_column_value);
+	//REG_FUNC(0xB656B7E2, sqlite3_finalize);
+	//REG_FUNC(0xA6ECC214, sqlite3_reset);
+	//REG_FUNC(0xB0543897, sqlite3_create_function);
+	//REG_FUNC(0x7655FA45, sqlite3_create_function16);
+	//REG_FUNC(0x6AB02532, sqlite3_aggregate_count);
+	//REG_FUNC(0xF8AA518B, sqlite3_expired);
+	//REG_FUNC(0x6EC012E5, sqlite3_transfer_bindings);
+	//REG_FUNC(0xF48E021B, sqlite3_global_recover);
+	//REG_FUNC(0x173C9C0B, sqlite3_thread_cleanup);
+	//REG_FUNC(0x56EDF517, sqlite3_memory_alarm);
+	//REG_FUNC(0xC9962B31, sqlite3_value_blob);
+	//REG_FUNC(0x5368EF1F, sqlite3_value_bytes);
+	//REG_FUNC(0x4D10900D, sqlite3_value_bytes16);
+	//REG_FUNC(0xF1F2C9BE, sqlite3_value_double);
+	//REG_FUNC(0x4809A520, sqlite3_value_int);
+	//REG_FUNC(0xA6581C04, sqlite3_value_int64);
+	//REG_FUNC(0x7EB97356, sqlite3_value_text);
+	//REG_FUNC(0x5BBE38C2, sqlite3_value_text16);
+	//REG_FUNC(0x014863A6, sqlite3_value_text16le);
+	//REG_FUNC(0x3B89AA8D, sqlite3_value_text16be);
+	//REG_FUNC(0xC5EEBB5D, sqlite3_value_type);
+	//REG_FUNC(0x81B7D43D, sqlite3_value_numeric_type);
+	//REG_FUNC(0xAA8BE477, sqlite3_aggregate_context);
+	//REG_FUNC(0x78FF81FB, sqlite3_user_data);
+	//REG_FUNC(0x74259C09, sqlite3_context_db_handle);
+	//REG_FUNC(0x394FC1CB, sqlite3_get_auxdata);
+	//REG_FUNC(0x129E01C9, sqlite3_set_auxdata);
+	//REG_FUNC(0x90CDF8C1, sqlite3_result_blob);
+	//REG_FUNC(0xC2A5C2F8, sqlite3_result_double);
+	//REG_FUNC(0x063BFACA, sqlite3_result_error);
+	//REG_FUNC(0xAB2AEB4A, sqlite3_result_error16);
+	//REG_FUNC(0xAB9EFF96, sqlite3_result_error_toobig);
+	//REG_FUNC(0x944E747A, sqlite3_result_error_nomem);
+	//REG_FUNC(0x1165223C, sqlite3_result_error_code);
+	//REG_FUNC(0x5C9CD9D4, sqlite3_result_int);
+	//REG_FUNC(0x0EF1AA07, sqlite3_result_int64);
+	//REG_FUNC(0x6DE09482, sqlite3_result_null);
+	//REG_FUNC(0x696B5E6A, sqlite3_result_text);
+	//REG_FUNC(0x3AF5D206, sqlite3_result_text16);
+	//REG_FUNC(0x845B4FC2, sqlite3_result_text16le);
+	//REG_FUNC(0xEE3E906A, sqlite3_result_text16be);
+	//REG_FUNC(0x09664492, sqlite3_result_value);
+	//REG_FUNC(0x3D463CF7, sqlite3_result_zeroblob);
+	//REG_FUNC(0xC61B63FB, sqlite3_create_collation);
+	//REG_FUNC(0x4B110AF2, sqlite3_create_collation_v2);
+	//REG_FUNC(0xF7FE99C8, sqlite3_create_collation16);
+	//REG_FUNC(0x836C99A3, sqlite3_collation_needed);
+	//REG_FUNC(0x537066CE, sqlite3_collation_needed16);
+	//REG_FUNC(0x6B88D1D4, sqlite3_sleep);
+	//REG_FUNC(0x0910C3CB, sqlite3_get_autocommit);
+	//REG_FUNC(0x2C62429E, sqlite3_db_handle);
+	//REG_FUNC(0xD257592A, sqlite3_next_stmt);
+	//REG_FUNC(0x4BAE6E3B, sqlite3_commit_hook);
+	//REG_FUNC(0x67F53D6B, sqlite3_rollback_hook);
+	//REG_FUNC(0xEB05FE87, sqlite3_update_hook);
+	//REG_FUNC(0xF0094BED, sqlite3_enable_shared_cache);
+	//REG_FUNC(0x8F99FBE5, sqlite3_release_memory);
+	//REG_FUNC(0xD1458BA7, sqlite3_soft_heap_limit);
+	//REG_FUNC(0xC9EA8E1F, sqlite3_load_extension);
+	//REG_FUNC(0x9BFC6F07, sqlite3_enable_load_extension);
+	//REG_FUNC(0x24738263, sqlite3_auto_extension);
+	//REG_FUNC(0xC4296FFD, sqlite3_reset_auto_extension);
+	//REG_FUNC(0x8970C45F, sqlite3_create_module);
+	//REG_FUNC(0x1AA3BC1A, sqlite3_create_module_v2);
+	//REG_FUNC(0x7E2A5E8F, sqlite3_declare_vtab);
+	//REG_FUNC(0xAF680D40, sqlite3_overload_function);
+	//REG_FUNC(0xD35B3E55, sqlite3_blob_open);
+	//REG_FUNC(0xC085A15D, sqlite3_blob_close);
+	//REG_FUNC(0xA07AEEE3, sqlite3_blob_bytes);
+	//REG_FUNC(0x71393AA4, sqlite3_blob_read);
+	//REG_FUNC(0xBDB46BCF, sqlite3_blob_write);
+	//REG_FUNC(0x0C6DD8C3, sqlite3_vfs_find);
+	//REG_FUNC(0x65F53B9C, sqlite3_vfs_register);
+	//REG_FUNC(0x69CF4171, sqlite3_vfs_unregister);
+	//REG_FUNC(0xEEB7839F, sqlite3_mutex_alloc);
+	//REG_FUNC(0x38E933E2, sqlite3_mutex_free);
+	//REG_FUNC(0x60DB89C0, sqlite3_mutex_enter);
+	//REG_FUNC(0x218D700E, sqlite3_mutex_try);
+	//REG_FUNC(0x545ABDDB, sqlite3_mutex_leave);
+	//REG_FUNC(0xA8E53D26, sqlite3_db_mutex);
+	//REG_FUNC(0xBB096FBD, sqlite3_file_control);
+	//REG_FUNC(0x324D4EFD, sqlite3_test_control);
+	//REG_FUNC(0xD8C435AA, sqlite3_status);
+	//REG_FUNC(0xB5DFAF6A, sqlite3_db_status);
+	//REG_FUNC(0xF7ABF5FA, sqlite3_stmt_status);
+	//REG_FUNC(0x91DDB12A, sqlite3_backup_init);
+	//REG_FUNC(0x2A15E081, sqlite3_backup_step);
+	//REG_FUNC(0x93A6B7EF, sqlite3_backup_finish);
+	//REG_FUNC(0x9962540B, sqlite3_backup_remaining);
+	//REG_FUNC(0x20D054CF, sqlite3_backup_pagecount);
+	//REG_FUNC(0x12E2FC18, sqlite3_strnicmp);
+	//REG_FUNC(0xB80D43C7, sqlite3_version);
+	//REG_FUNC(0x1AEC1F74, sqlite3_temp_directory);
+});

rpcs3/Emu/ARMv7/Modules/sceSsl.cpp

@@ -0,0 +1,82 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceSsl.h"
+
+s32 sceSslInit(u32 poolSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslTerm()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslGetMemoryPoolStats(vm::psv::ptr<SceSslMemoryPoolStats> currentStat)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslGetSerialNumber(vm::psv::ptr<SceSslCert> sslCert, vm::psv::ptr<vm::psv::ptr<const u8>> sboData, vm::psv::ptr<u32> sboLen)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<SceSslCertName> sceSslGetSubjectName(vm::psv::ptr<SceSslCert> sslCert)
+{
+	throw __FUNCTION__;
+}
+
+vm::psv::ptr<SceSslCertName> sceSslGetIssuerName(vm::psv::ptr<SceSslCert> sslCert)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslGetNotBefore(vm::psv::ptr<SceSslCert> sslCert, vm::psv::ptr<u64> begin)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslGetNotAfter(vm::psv::ptr<SceSslCert> sslCert, vm::psv::ptr<u64> limit)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslGetNameEntryCount(vm::psv::ptr<SceSslCertName> certName)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslGetNameEntryInfo(vm::psv::ptr<SceSslCertName> certName, s32 entryNum, vm::psv::ptr<char> oidname, u32 maxOidnameLen, vm::psv::ptr<u8> value, u32 maxValueLen, vm::psv::ptr<u32> valueLen)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSslFreeSslCertName(vm::psv::ptr<SceSslCertName> certName)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSsl, #name, name)
+
+psv_log_base sceSsl("SceSsl", []()
+{
+	sceSsl.on_load = nullptr;
+	sceSsl.on_unload = nullptr;
+	sceSsl.on_stop = nullptr;
+
+	REG_FUNC(0x3C733316, sceSslInit);
+	REG_FUNC(0x03CE6E3A, sceSslTerm);
+	REG_FUNC(0xBD203262, sceSslGetMemoryPoolStats);
+	REG_FUNC(0x901C5C15, sceSslGetSerialNumber);
+	REG_FUNC(0x9B2F1BC1, sceSslGetSubjectName);
+	REG_FUNC(0x412711E5, sceSslGetIssuerName);
+	REG_FUNC(0x70DEA174, sceSslGetNotBefore);
+	REG_FUNC(0xF5ED7B68, sceSslGetNotAfter);
+	REG_FUNC(0x95E14CA6, sceSslGetNameEntryCount);
+	REG_FUNC(0x2A857867, sceSslGetNameEntryInfo);
+	REG_FUNC(0xC73687E4, sceSslFreeSslCertName);
+});

rpcs3/Emu/ARMv7/Modules/sceSsl.h

@@ -0,0 +1,14 @@
+#pragma once
+
+typedef void SceSslCert;
+typedef void SceSslCertName;
+
+struct SceSslMemoryPoolStats
+{
+	u32 poolSize;
+	u32 maxInuseSize;
+	u32 currentInuseSize;
+	s32 reserved;
+};
+
+extern psv_log_base sceSsl;

rpcs3/Emu/ARMv7/Modules/sceSulpha.cpp

@@ -0,0 +1,116 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceSulpha;
+
+typedef vm::psv::ptr<void(vm::psv::ptr<void> arg)> SceSulphaCallback;
+
+struct SceSulphaConfig
+{
+	SceSulphaCallback notifyCallback;
+	u32 port;
+	u32 bookmarkCount;
+};
+
+struct SceSulphaAgentsRegister;
+typedef void SceSulphaHandle;
+
+s32 sceSulphaNetworkInit()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaNetworkShutdown()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaGetDefaultConfig(vm::psv::ptr<SceSulphaConfig> config)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaGetNeededMemory(vm::psv::ptr<const SceSulphaConfig> config, vm::psv::ptr<u32> sizeInBytes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaInit(vm::psv::ptr<const SceSulphaConfig> config, vm::psv::ptr<void> buffer, u32 sizeInBytes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaShutdown()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaUpdate()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaFileConnect(vm::psv::ptr<const char> filename)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaFileDisconnect()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaSetBookmark(vm::psv::ptr<const char> name, s32 id)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaAgentsGetNeededMemory(vm::psv::ptr<const SceSulphaAgentsRegister> config, vm::psv::ptr<u32> sizeInBytes)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaAgentsRegister(vm::psv::ptr<const SceSulphaAgentsRegister> config, vm::psv::ptr<void> buffer, u32 sizeInBytes, vm::psv::ptr<SceSulphaHandle> handles)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSulphaAgentsUnregister(vm::psv::ptr<const SceSulphaHandle> handles, u32 agentCount)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSulpha, #name, name)
+
+psv_log_base sceSulpha("SceSulpha", []()
+{
+	sceSulpha.on_load = nullptr;
+	sceSulpha.on_unload = nullptr;
+	sceSulpha.on_stop = nullptr;
+
+	REG_FUNC(0xB4668AEA, sceSulphaNetworkInit);
+	REG_FUNC(0x0FC71B72, sceSulphaNetworkShutdown);
+	REG_FUNC(0xA6A05C50, sceSulphaGetDefaultConfig);
+	REG_FUNC(0xD52E5A5A, sceSulphaGetNeededMemory);
+	REG_FUNC(0x324F158F, sceSulphaInit);
+	REG_FUNC(0x10770BA7, sceSulphaShutdown);
+	REG_FUNC(0x920EC7BF, sceSulphaUpdate);
+	REG_FUNC(0x7968A138, sceSulphaFileConnect);
+	REG_FUNC(0xB16E7B88, sceSulphaFileDisconnect);
+	REG_FUNC(0x5E15E164, sceSulphaSetBookmark);
+	REG_FUNC(0xC5752B6B, sceSulphaAgentsGetNeededMemory);
+	REG_FUNC(0x7ADB454D, sceSulphaAgentsRegister);
+	REG_FUNC(0x2A8B74D7, sceSulphaAgentsUnregister);
+	//REG_FUNC(0xDE7E2911, sceSulphaGetAgent);
+	//REG_FUNC(0xA41B7402, sceSulphaNodeNew);
+	//REG_FUNC(0xD44C9F86, sceSulphaNodeDelete);
+	//REG_FUNC(0xBF61F3B8, sceSulphaEventNew);
+	//REG_FUNC(0xD5D995A9, sceSulphaEventDelete);
+	//REG_FUNC(0xB0C2B9CE, sceSulphaEventAdd);
+	//REG_FUNC(0xBC6A2833, sceSulphaEventReport);
+	//REG_FUNC(0x29F0DA12, sceSulphaGetTimestamp);
+	//REG_FUNC(0x951D159D, sceSulphaLogSetLevel);
+	//REG_FUNC(0x5C6815C6, sceSulphaLogHandler);
+});

rpcs3/Emu/ARMv7/Modules/sceSystemGesture.cpp

@@ -0,0 +1,274 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceTouch.h"
+
+extern psv_log_base sceSystemGesture;
+
+enum SceSystemGestureTouchState : s32
+{
+	SCE_SYSTEM_GESTURE_TOUCH_STATE_INACTIVE = 0,
+	SCE_SYSTEM_GESTURE_TOUCH_STATE_BEGIN = 1,
+	SCE_SYSTEM_GESTURE_TOUCH_STATE_ACTIVE = 2,
+	SCE_SYSTEM_GESTURE_TOUCH_STATE_END = 3
+};
+
+enum SceSystemGestureType : s32
+{
+	SCE_SYSTEM_GESTURE_TYPE_TAP = 1,
+	SCE_SYSTEM_GESTURE_TYPE_DRAG = 2,
+	SCE_SYSTEM_GESTURE_TYPE_TAP_AND_HOLD = 4,
+	SCE_SYSTEM_GESTURE_TYPE_PINCH_OUT_IN = 8
+};
+
+struct SceSystemGestureVector2
+{
+	s16 x;
+	s16 y;
+};
+
+struct SceSystemGestureRectangle
+{
+	s16 x;
+	s16 y;
+	s16 width;
+	s16 height;
+};
+
+struct SceSystemGesturePrimitiveTouchEvent
+{
+	SceSystemGestureTouchState eventState;
+	u16 primitiveID;
+	SceSystemGestureVector2 pressedPosition;
+	s16 pressedForce;
+	SceSystemGestureVector2 currentPosition;
+	s16 currentForce;
+	SceSystemGestureVector2 deltaVector;
+	s16 deltaForce;
+	u64 deltaTime;
+	u64 elapsedTime;
+	u8 reserved[56];
+};
+
+struct SceSystemGesturePrimitiveTouchRecognizerParameter
+{
+	u8 reserved[64];
+};
+
+struct SceSystemGestureTouchRecognizer
+{
+	u64 reserved[307];
+};
+
+struct SceSystemGestureTouchRecognizerInformation
+{
+	SceSystemGestureType gestureType;
+	u32 touchPanelPortID;
+	SceSystemGestureRectangle rectangle;
+	u64 updatedTime;
+	u8 reserved[256];
+};
+
+struct SceSystemGestureTapRecognizerParameter
+{
+	u8 maxTapCount;
+	u8 reserved[63];
+};
+
+struct SceSystemGestureDragRecognizerParameter
+{
+	u8 reserved[64];
+};
+
+struct SceSystemGestureTapAndHoldRecognizerParameter
+{
+	u64 timeToInvokeEvent;
+	u8 reserved[56];
+};
+
+struct SceSystemGesturePinchOutInRecognizerParameter
+{
+	u8 reserved[64];
+};
+
+union SceSystemGestureTouchRecognizerParameter
+{
+	u8 parameterBuf[64];
+	SceSystemGestureTapRecognizerParameter tap;
+	SceSystemGestureDragRecognizerParameter drag;
+	SceSystemGestureTapAndHoldRecognizerParameter tapAndHold;
+	SceSystemGesturePinchOutInRecognizerParameter pinchOutIn;
+};
+
+struct SceSystemGestureTapEventProperty
+{
+	u16 primitiveID;
+	SceSystemGestureVector2 position;
+	u8 tappedCount;
+	u8 reserved[57];
+};
+
+struct SceSystemGestureDragEventProperty
+{
+	u16 primitiveID;
+	SceSystemGestureVector2 deltaVector;
+	SceSystemGestureVector2 currentPosition;
+	SceSystemGestureVector2 pressedPosition;
+	u8 reserved[50];
+};
+
+struct SceSystemGestureTapAndHoldEventProperty
+{
+	u16 primitiveID;
+	SceSystemGestureVector2 pressedPosition;
+	u8 reserved[58];
+};
+
+struct SceSystemGesturePinchOutInEventProperty
+{
+	float scale;
+
+	struct
+	{
+		u16 primitiveID;
+		SceSystemGestureVector2 currentPosition;
+		SceSystemGestureVector2 deltaVector;
+		SceSystemGestureVector2 pairedPosition;
+	} primitive[2];
+
+	u8 reserved[32];
+};
+
+struct SceSystemGestureTouchEvent
+{
+	u32 eventID;
+	SceSystemGestureTouchState eventState;
+	SceSystemGestureType gestureType;
+	u8 padding[4];
+	u64 updatedTime;
+
+	union
+	{
+		u8 propertyBuf[64];
+		SceSystemGestureTapEventProperty tap;
+		SceSystemGestureDragEventProperty drag;
+		SceSystemGestureTapAndHoldEventProperty tapAndHold;
+		SceSystemGesturePinchOutInEventProperty pinchOutIn;
+	} property;
+
+	u8 reserved[56];
+};
+
+s32 sceSystemGestureInitializePrimitiveTouchRecognizer(vm::psv::ptr<SceSystemGesturePrimitiveTouchRecognizerParameter> parameter)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureFinalizePrimitiveTouchRecognizer()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureResetPrimitiveTouchRecognizer()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureUpdatePrimitiveTouchRecognizer(vm::psv::ptr<const SceTouchData> pFrontData, vm::psv::ptr<const SceTouchData> pBackData)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetPrimitiveTouchEvents(vm::psv::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveEventBuffer, const u32 capacityOfBuffer, vm::psv::ptr<u32> numberOfEvent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetPrimitiveTouchEventsCount()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetPrimitiveTouchEventByIndex(const u32 index, vm::psv::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveTouchEvent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetPrimitiveTouchEventByPrimitiveID(const u16 primitiveID, vm::psv::ptr<SceSystemGesturePrimitiveTouchEvent> primitiveTouchEvent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureCreateTouchRecognizer(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, const SceSystemGestureType gestureType, const u8 touchPanelPortID, vm::psv::ptr<const SceSystemGestureRectangle> rectangle, vm::psv::ptr<const SceSystemGestureTouchRecognizerParameter> touchRecognizerParameter)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetTouchRecognizerInformation(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, vm::psv::ptr<SceSystemGestureTouchRecognizerInformation> information)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureResetTouchRecognizer(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureUpdateTouchRecognizer(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureUpdateTouchRecognizerRectangle(vm::psv::ptr<SceSystemGestureTouchRecognizer> touchRecognizer, vm::psv::ptr<const SceSystemGestureRectangle> rectangle)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetTouchEvents(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, vm::psv::ptr<SceSystemGestureTouchEvent> eventBuffer, const u32 capacityOfBuffer, vm::psv::ptr<u32> numberOfEvent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetTouchEventsCount(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetTouchEventByIndex(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, const u32 index, vm::psv::ptr<SceSystemGestureTouchEvent> touchEvent)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceSystemGestureGetTouchEventByEventID(vm::psv::ptr<const SceSystemGestureTouchRecognizer> touchRecognizer, const u32 eventID, vm::psv::ptr<SceSystemGestureTouchEvent> touchEvent)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceSystemGesture, #name, name)
+
+psv_log_base sceSystemGesture("SceSystemGesture", []()
+{
+	sceSystemGesture.on_load = nullptr;
+	sceSystemGesture.on_unload = nullptr;
+	sceSystemGesture.on_stop = nullptr;
+
+	REG_FUNC(0x6078A08B, sceSystemGestureInitializePrimitiveTouchRecognizer);
+	REG_FUNC(0xFD5A6504, sceSystemGestureResetPrimitiveTouchRecognizer);
+	REG_FUNC(0xB3875104, sceSystemGestureFinalizePrimitiveTouchRecognizer);
+	REG_FUNC(0xDF4C665A, sceSystemGestureUpdatePrimitiveTouchRecognizer);
+	REG_FUNC(0xC750D3DA, sceSystemGestureGetPrimitiveTouchEvents);
+	REG_FUNC(0xBAB8ECCB, sceSystemGestureGetPrimitiveTouchEventsCount);
+	REG_FUNC(0xE0577765, sceSystemGestureGetPrimitiveTouchEventByIndex);
+	REG_FUNC(0x480564C9, sceSystemGestureGetPrimitiveTouchEventByPrimitiveID);
+	REG_FUNC(0xC3367370, sceSystemGestureCreateTouchRecognizer);
+	REG_FUNC(0xF0DB1AE5, sceSystemGestureGetTouchRecognizerInformation);
+	REG_FUNC(0x0D941B90, sceSystemGestureResetTouchRecognizer);
+	REG_FUNC(0x851FB144, sceSystemGestureUpdateTouchRecognizer);
+	REG_FUNC(0xA9DB29F6, sceSystemGestureUpdateTouchRecognizerRectangle);
+	REG_FUNC(0x789D867C, sceSystemGestureGetTouchEvents);
+	REG_FUNC(0x13AD2218, sceSystemGestureGetTouchEventsCount);
+	REG_FUNC(0x74724147, sceSystemGestureGetTouchEventByIndex);
+	REG_FUNC(0x5570B83E, sceSystemGestureGetTouchEventByEventID);
+});

rpcs3/Emu/ARMv7/Modules/sceTouch.cpp

@@ -0,0 +1,46 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceTouch.h"
+
+s32 sceTouchGetPanelInfo(u32 port, vm::psv::ptr<SceTouchPanelInfo> pPanelInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceTouchRead(u32 port, vm::psv::ptr<SceTouchData> pData, u32 nBufs)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceTouchPeek(u32 port, vm::psv::ptr<SceTouchData> pData, u32 nBufs)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceTouchSetSamplingState(u32 port, u32 state)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceTouchGetSamplingState(u32 port, vm::psv::ptr<u32> pState)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceTouch, #name, name)
+
+psv_log_base sceTouch("SceTouch", []()
+{
+	sceTouch.on_load = nullptr;
+	sceTouch.on_unload = nullptr;
+	sceTouch.on_stop = nullptr;
+
+	REG_FUNC(0x169A1D58, sceTouchRead);
+	REG_FUNC(0xFF082DF0, sceTouchPeek);
+	REG_FUNC(0x1B9C5D14, sceTouchSetSamplingState);
+	REG_FUNC(0x26531526, sceTouchGetSamplingState);
+	REG_FUNC(0x10A2CA25, sceTouchGetPanelInfo);
+});

rpcs3/Emu/ARMv7/Modules/sceTouch.h

@@ -0,0 +1,36 @@
+#pragma once
+
+struct SceTouchPanelInfo
+{
+	s16 minAaX;
+	s16 minAaY;
+	s16 maxAaX;
+	s16 maxAaY;
+	s16 minDispX;
+	s16 minDispY;
+	s16 maxDispX;
+	s16 maxDispY;
+	u8 minForce;
+	u8 maxForce;
+	u8 rsv[30];
+};
+
+struct SceTouchReport
+{
+	u8 id;
+	u8 force;
+	s16 x;
+	s16 y;
+	s8 rsv[8];
+	u16 info;
+};
+
+struct SceTouchData
+{
+	u64 timeStamp;
+	u32 status;
+	u32 reportNum;
+	SceTouchReport report[8];
+};
+
+extern psv_log_base sceTouch;

rpcs3/Emu/ARMv7/Modules/sceUlt.cpp

@@ -0,0 +1,605 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+#include "sceLibKernel.h"
+
+extern psv_log_base sceUlt;
+
+#define CHECK_SIZE(type, size) static_assert(sizeof(type) == size, "Invalid " #type " size")
+
+struct _SceUltOptParamHeader
+{
+	s64 reserved[2];
+};
+
+struct SceUltWaitingQueueResourcePoolOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltWaitingQueueResourcePoolOptParam, 128);
+
+struct SceUltWaitingQueueResourcePool
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltWaitingQueueResourcePool, 256);
+
+struct SceUltQueueDataResourcePoolOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltQueueDataResourcePoolOptParam, 128);
+
+struct SceUltQueueDataResourcePool
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltQueueDataResourcePool, 256);
+
+struct SceUltMutexOptParam
+{
+	_SceUltOptParamHeader header;
+	u32 attribute;
+	u32 reserved_0;
+	u64 reserved[13];
+};
+
+CHECK_SIZE(SceUltMutexOptParam, 128);
+
+struct SceUltMutex
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltMutex, 256);
+
+struct SceUltConditionVariableOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltConditionVariableOptParam, 128);
+
+struct SceUltConditionVariable
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltConditionVariable, 256);
+
+struct SceUltQueueOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltQueueOptParam, 128);
+
+struct SceUltQueue
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltQueue, 256);
+
+struct SceUltReaderWriterLockOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltReaderWriterLockOptParam, 128);
+
+struct SceUltReaderWriterLock
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltReaderWriterLock, 256);
+
+struct SceUltSemaphoreOptParam
+{
+	_SceUltOptParamHeader header;
+	u64 reserved[14];
+};
+
+CHECK_SIZE(SceUltSemaphoreOptParam, 128);
+
+struct SceUltSemaphore
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltSemaphore, 256);
+
+struct SceUltUlthreadRuntimeOptParam
+{
+	_SceUltOptParamHeader header;
+
+	u32 oneShotThreadStackSize;
+	s32 workerThreadPriority;
+	u32 workerThreadCpuAffinityMask;
+	u32 workerThreadAttr;
+	vm::psv::ptr<const SceKernelThreadOptParam> workerThreadOptParam;
+
+	u64 reserved[11];
+};
+
+CHECK_SIZE(SceUltUlthreadRuntimeOptParam, 128);
+
+struct SceUltUlthreadRuntime
+{
+	u64 reserved[128];
+};
+
+CHECK_SIZE(SceUltUlthreadRuntime, 1024);
+
+struct SceUltUlthreadOptParam
+{
+	_SceUltOptParamHeader header;
+	u32 attribute;
+	u32 reserved_0;
+	u64 reserved[13];
+};
+
+CHECK_SIZE(SceUltUlthreadOptParam, 128);
+
+struct SceUltUlthread
+{
+	u64 reserved[32];
+};
+
+CHECK_SIZE(SceUltUlthread, 256);
+
+typedef vm::psv::ptr<s32(u32 arg)> SceUltUlthreadEntry;
+
+// Functions
+
+s32 _sceUltWaitingQueueResourcePoolOptParamInitialize(vm::psv::ptr<SceUltWaitingQueueResourcePoolOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltWaitingQueueResourcePoolGetWorkAreaSize(u32 numThreads, u32 numSyncObjects)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltWaitingQueueResourcePoolCreate(
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> pool,
+	vm::psv::ptr<const char> name,
+	u32 numThreads,
+	u32 numSyncObjects,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltWaitingQueueResourcePoolOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltWaitingQueueResourcePoolDestroy(vm::psv::ptr<SceUltWaitingQueueResourcePool> pool)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueDataResourcePoolOptParamInitialize(vm::psv::ptr<SceUltQueueDataResourcePoolOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltQueueDataResourcePoolGetWorkAreaSize(u32 numData, u32 dataSize, u32 numQueueObject)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueDataResourcePoolCreate(
+	vm::psv::ptr<SceUltQueueDataResourcePool> pool,
+	vm::psv::ptr<const char> name,
+	u32 numData,
+	u32 dataSize,
+	u32 numQueueObject,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltQueueDataResourcePoolOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueDataResourcePoolDestroy(vm::psv::ptr<SceUltQueueDataResourcePool> pool)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltMutexGetStandaloneWorkAreaSize(u32 waitingQueueDepth, u32 numConditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltMutexOptParamInitialize(vm::psv::ptr<SceUltMutexOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltMutexCreate(
+	vm::psv::ptr<SceUltMutex> mutex,
+	vm::psv::ptr<const char> name,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<const SceUltMutexOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltMutexCreateStandalone(
+	vm::psv::ptr<SceUltMutex> mutex,
+	vm::psv::ptr<const char> name,
+	u32 numConditionVariable,
+	u32 maxNumThreads,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltMutexOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexLock(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexTryLock(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexUnlock(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltMutexDestroy(vm::psv::ptr<SceUltMutex> mutex)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltConditionVariableOptParamInitialize(vm::psv::ptr<SceUltConditionVariableOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltConditionVariableCreate(
+	vm::psv::ptr<SceUltConditionVariable> conditionVariable,
+	vm::psv::ptr<const char> name,
+	vm::psv::ptr<SceUltMutex> mutex,
+	vm::psv::ptr<const SceUltConditionVariableOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableSignal(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableSignalAll(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableWait(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltConditionVariableDestroy(vm::psv::ptr<SceUltConditionVariable> conditionVariable)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueOptParamInitialize(vm::psv::ptr<SceUltQueueOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltQueueGetStandaloneWorkAreaSize(u32 queueDepth,
+	u32 dataSize,
+	u32 waitingQueueLength)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueCreate(
+	vm::psv::ptr<SceUltQueue> queue,
+	vm::psv::ptr<const char> _name,
+	u32 dataSize,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> resourcePool,
+	vm::psv::ptr<SceUltQueueDataResourcePool> queueResourcePool,
+	vm::psv::ptr<const SceUltQueueOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltQueueCreateStandalone(
+	vm::psv::ptr<SceUltQueue> queue,
+	vm::psv::ptr<const char> name,
+	u32 queueDepth,
+	u32 dataSize,
+	u32 waitingQueueLength,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltQueueOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueuePush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueTryPush(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<const void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueuePop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueTryPop(vm::psv::ptr<SceUltQueue> queue, vm::psv::ptr<void> data)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltQueueDestroy(vm::psv::ptr<SceUltQueue> queue)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltReaderWriterLockOptParamInitialize(vm::psv::ptr<SceUltReaderWriterLockOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltReaderWriterLockCreate(
+	vm::psv::ptr<SceUltReaderWriterLock> rwlock,
+	vm::psv::ptr<const char> name,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltReaderWriterLockCreateStandalone(
+	vm::psv::ptr<SceUltReaderWriterLock> rwlock,
+	vm::psv::ptr<const char> name,
+	u32 waitingQueueDepth,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltReaderWriterLockOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltReaderWriterLockGetStandaloneWorkAreaSize(u32 waitingQueueDepth)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockTryLockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockUnlockRead(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockTryLockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockUnlockWrite(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltReaderWriterLockDestroy(vm::psv::ptr<SceUltReaderWriterLock> rwlock)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltSemaphoreOptParamInitialize(vm::psv::ptr<SceUltSemaphoreOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltSemaphoreCreate(
+	vm::psv::ptr<SceUltSemaphore> semaphore,
+	vm::psv::ptr<const char> name,
+	s32 numInitialResource,
+	vm::psv::ptr<SceUltWaitingQueueResourcePool> waitingQueueResourcePool,
+	vm::psv::ptr<const SceUltSemaphoreOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreTryAcquire(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreRelease(vm::psv::ptr<SceUltSemaphore> semaphore, s32 numResource)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltSemaphoreDestroy(vm::psv::ptr<SceUltSemaphore> semaphore)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadRuntimeOptParamInitialize(vm::psv::ptr<SceUltUlthreadRuntimeOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+u32 sceUltUlthreadRuntimeGetWorkAreaSize(u32 numMaxUlthread, u32 numWorkerThread)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadRuntimeCreate(
+	vm::psv::ptr<SceUltUlthreadRuntime> runtime,
+	vm::psv::ptr<const char> name,
+	u32 numMaxUlthread,
+	u32 numWorkerThread,
+	vm::psv::ptr<void> workArea,
+	vm::psv::ptr<const SceUltUlthreadRuntimeOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadRuntimeDestroy(vm::psv::ptr<SceUltUlthreadRuntime> runtime)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadOptParamInitialize(vm::psv::ptr<SceUltUlthreadOptParam> optParam, u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 _sceUltUlthreadCreate(
+	vm::psv::ptr<SceUltUlthread> ulthread,
+	vm::psv::ptr<const char> name,
+	SceUltUlthreadEntry entry,
+	u32 arg,
+	vm::psv::ptr<void> context,
+	u32 sizeContext,
+	vm::psv::ptr<SceUltUlthreadRuntime> runtime,
+	vm::psv::ptr<const SceUltUlthreadOptParam> optParam,
+	u32 buildVersion)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadYield()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadExit(s32 status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadTryJoin(vm::psv::ptr<SceUltUlthread> ulthread, vm::psv::ptr<s32> status)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceUltUlthreadGetSelf(vm::psv::ptr<vm::psv::ptr<SceUltUlthread>> ulthread)
+{
+	throw __FUNCTION__;
+}
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceUlt, #name, name)
+
+psv_log_base sceUlt("SceUlt", []()
+{
+	sceUlt.on_load = nullptr;
+	sceUlt.on_unload = nullptr;
+	sceUlt.on_stop = nullptr;
+
+	REG_FUNC(0xEF094E35, _sceUltWaitingQueueResourcePoolOptParamInitialize);
+	REG_FUNC(0x644DA029, sceUltWaitingQueueResourcePoolGetWorkAreaSize);
+	REG_FUNC(0x62F9493E, _sceUltWaitingQueueResourcePoolCreate);
+	REG_FUNC(0xC9E96714, sceUltWaitingQueueResourcePoolDestroy);
+	REG_FUNC(0x8A4F88A2, _sceUltQueueDataResourcePoolOptParamInitialize);
+	REG_FUNC(0xECDA7FEE, sceUltQueueDataResourcePoolGetWorkAreaSize);
+	REG_FUNC(0x40856827, _sceUltQueueDataResourcePoolCreate);
+	REG_FUNC(0x2B8D33F1, sceUltQueueDataResourcePoolDestroy);
+	REG_FUNC(0x24D87E05, _sceUltMutexOptParamInitialize);
+	REG_FUNC(0x5AFEC7A1, _sceUltMutexCreate);
+	REG_FUNC(0x001EAC8A, sceUltMutexLock);
+	REG_FUNC(0xE5936A69, sceUltMutexTryLock);
+	REG_FUNC(0x897C9097, sceUltMutexUnlock);
+	REG_FUNC(0xEEBD9052, sceUltMutexDestroy);
+	REG_FUNC(0x0603FCC1, _sceUltConditionVariableOptParamInitialize);
+	REG_FUNC(0xD76A156C, _sceUltConditionVariableCreate);
+	REG_FUNC(0x9FE7CB9F, sceUltConditionVariableSignal);
+	REG_FUNC(0xEBB6FC1E, sceUltConditionVariableSignalAll);
+	REG_FUNC(0x2CD0F57C, sceUltConditionVariableWait);
+	REG_FUNC(0x53420ED2, sceUltConditionVariableDestroy);
+	REG_FUNC(0xF7A83023, _sceUltQueueOptParamInitialize);
+	REG_FUNC(0x14DA1BB4, _sceUltQueueCreate);
+	REG_FUNC(0xA7E78FF9, sceUltQueuePush);
+	REG_FUNC(0x6D356B29, sceUltQueueTryPush);
+	REG_FUNC(0x1AD58A53, sceUltQueuePop);
+	REG_FUNC(0x2A1A8EA6, sceUltQueueTryPop);
+	REG_FUNC(0xF37862DE, sceUltQueueDestroy);
+	REG_FUNC(0xD8334A1F, _sceUltReaderWriterLockOptParamInitialize);
+	REG_FUNC(0x2FB0EB32, _sceUltReaderWriterLockCreate);
+	REG_FUNC(0x9AD07630, sceUltReaderWriterLockLockRead);
+	REG_FUNC(0x2629C055, sceUltReaderWriterLockTryLockRead);
+	REG_FUNC(0x218D4743, sceUltReaderWriterLockUnlockRead);
+	REG_FUNC(0xF5F63E2C, sceUltReaderWriterLockLockWrite);
+	REG_FUNC(0x944FB222, sceUltReaderWriterLockTryLockWrite);
+	REG_FUNC(0x2A5741F5, sceUltReaderWriterLockUnlockWrite);
+	REG_FUNC(0xB1FEB79B, sceUltReaderWriterLockDestroy);
+	REG_FUNC(0x8E31B9FE, _sceUltSemaphoreOptParamInitialize);
+	REG_FUNC(0xDD59562C, _sceUltSemaphoreCreate);
+	REG_FUNC(0xF220D3AE, sceUltSemaphoreAcquire);
+	REG_FUNC(0xAF15606D, sceUltSemaphoreTryAcquire);
+	REG_FUNC(0x65376E2D, sceUltSemaphoreRelease);
+	REG_FUNC(0x8EC57420, sceUltSemaphoreDestroy);
+	REG_FUNC(0x8486DDE6, _sceUltUlthreadRuntimeOptParamInitialize);
+	REG_FUNC(0x5435C586, sceUltUlthreadRuntimeGetWorkAreaSize);
+	REG_FUNC(0x86DDA3AE, _sceUltUlthreadRuntimeCreate);
+	REG_FUNC(0x4E9A745C, sceUltUlthreadRuntimeDestroy);
+	REG_FUNC(0x7F373376, _sceUltUlthreadOptParamInitialize);
+	REG_FUNC(0xB1290375, _sceUltUlthreadCreate);
+	REG_FUNC(0xCAD57BAD, sceUltUlthreadYield);
+	REG_FUNC(0x1E401DF8, sceUltUlthreadExit);
+	REG_FUNC(0x63483381, sceUltUlthreadJoin);
+	REG_FUNC(0xB4CF88AC, sceUltUlthreadTryJoin);
+	REG_FUNC(0xA798C5D7, sceUltUlthreadGetSelf);
+});

rpcs3/Emu/ARMv7/Modules/sceVideodec.cpp

@@ -0,0 +1,206 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceVideodec;
+
+struct SceVideodecQueryInitInfoHwAvcdec
+{
+	u32 size;
+	u32 horizontal;
+	u32 vertical;
+	u32 numOfRefFrames;
+	u32 numOfStreams;
+};
+
+union SceVideodecQueryInitInfo
+{
+	u8 reserved[32];
+	SceVideodecQueryInitInfoHwAvcdec hwAvc;
+};
+
+struct SceVideodecTimeStamp
+{
+	u32 upper;
+	u32 lower;
+};
+
+struct SceAvcdecQueryDecoderInfo
+{
+	u32 horizontal;
+	u32 vertical;
+	u32 numOfRefFrames;
+
+};
+
+struct SceAvcdecDecoderInfo
+{
+	u32 frameMemSize;
+
+};
+
+struct SceAvcdecBuf
+{
+	vm::psv::ptr<void> pBuf;
+	u32 size;
+};
+
+struct SceAvcdecCtrl
+{
+	u32 handle;
+	SceAvcdecBuf frameBuf;
+};
+
+struct SceAvcdecAu
+{
+	SceVideodecTimeStamp pts;
+	SceVideodecTimeStamp dts;
+	SceAvcdecBuf es;
+};
+
+struct SceAvcdecInfo
+{
+	u32 numUnitsInTick;
+	u32 timeScale;
+	u8 fixedFrameRateFlag;
+
+	u8 aspectRatioIdc;
+	u16 sarWidth;
+	u16 sarHeight;
+
+	u8 colourPrimaries;
+	u8 transferCharacteristics;
+	u8 matrixCoefficients;
+
+	u8 videoFullRangeFlag;
+
+	u8 picStruct[2];
+	u8 ctType;
+
+	u8 padding[3];
+};
+
+struct SceAvcdecFrameOptionRGBA
+{
+	u8 alpha;
+	u8 cscCoefficient;
+	u8 reserved[14];
+};
+
+union SceAvcdecFrameOption
+{
+	u8 reserved[16];
+	SceAvcdecFrameOptionRGBA rgba;
+};
+
+
+struct SceAvcdecFrame
+{
+	u32 pixelType;
+	u32 framePitch;
+	u32 frameWidth;
+	u32 frameHeight;
+
+	u32 horizontalSize;
+	u32 verticalSize;
+
+	u32 frameCropLeftOffset;
+	u32 frameCropRightOffset;
+	u32 frameCropTopOffset;
+	u32 frameCropBottomOffset;
+
+	SceAvcdecFrameOption opt;
+
+	vm::psv::ptr<void> pPicture[2];
+};
+
+
+struct SceAvcdecPicture
+{
+	u32 size;
+	SceAvcdecFrame frame;
+	SceAvcdecInfo info;
+};
+
+struct SceAvcdecArrayPicture
+{
+	u32 numOfOutput;
+	u32 numOfElm;
+	vm::psv::ptr<vm::psv::ptr<SceAvcdecPicture>> pPicture;
+};
+
+
+s32 sceVideodecInitLibrary(u32 codecType, vm::psv::ptr<const SceVideodecQueryInitInfo> pInitInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVideodecTermLibrary(u32 codecType)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecQueryDecoderMemSize(u32 codecType, vm::psv::ptr<const SceAvcdecQueryDecoderInfo> pDecoderInfo, vm::psv::ptr<SceAvcdecDecoderInfo> pMemInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecCreateDecoder(u32 codecType, vm::psv::ptr<SceAvcdecCtrl> pCtrl, vm::psv::ptr<const SceAvcdecQueryDecoderInfo> pDecoderInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecDeleteDecoder(vm::psv::ptr<SceAvcdecCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecDecodeAvailableSize(vm::psv::ptr<SceAvcdecCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecDecode(vm::psv::ptr<SceAvcdecCtrl> pCtrl, vm::psv::ptr<const SceAvcdecAu> pAu, vm::psv::ptr<SceAvcdecArrayPicture> pArrayPicture)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecDecodeStop(vm::psv::ptr<SceAvcdecCtrl> pCtrl, vm::psv::ptr<SceAvcdecArrayPicture> pArrayPicture)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceAvcdecDecodeFlush(vm::psv::ptr<SceAvcdecCtrl> pCtrl)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceVideodec, #name, name)
+
+psv_log_base sceVideodec("SceVideodec", []()
+{
+	sceVideodec.on_load = nullptr;
+	sceVideodec.on_unload = nullptr;
+	sceVideodec.on_stop = nullptr;
+
+	REG_FUNC(0xF1AF65A3, sceVideodecInitLibrary);
+	REG_FUNC(0x3A5F4924, sceVideodecTermLibrary);
+	REG_FUNC(0x97E95EDB, sceAvcdecQueryDecoderMemSize);
+	REG_FUNC(0xE82BB69B, sceAvcdecCreateDecoder);
+	REG_FUNC(0x8A0E359E, sceAvcdecDeleteDecoder);
+	REG_FUNC(0x441673E3, sceAvcdecDecodeAvailableSize);
+	REG_FUNC(0xD6190A06, sceAvcdecDecode);
+	REG_FUNC(0x9648D853, sceAvcdecDecodeStop);
+	REG_FUNC(0x25F31020, sceAvcdecDecodeFlush);
+	//REG_FUNC(0xB2A428DB, sceAvcdecCsc);
+	//REG_FUNC(0x6C68A38F, sceAvcdecDecodeNalAu);
+	//REG_FUNC(0xC67C1A80, sceM4vdecQueryDecoderMemSize);
+	//REG_FUNC(0x17C6AC9E, sceM4vdecCreateDecoder);
+	//REG_FUNC(0x0EB2E4E7, sceM4vdecDeleteDecoder);
+	//REG_FUNC(0xA8CF1942, sceM4vdecDecodeAvailableSize);
+	//REG_FUNC(0x624664DB, sceM4vdecDecode);
+	//REG_FUNC(0x87CFD23B, sceM4vdecDecodeStop);
+	//REG_FUNC(0x7C460D75, sceM4vdecDecodeFlush);
+	//REG_FUNC(0xB4BC325B, sceM4vdecCsc);
+});

rpcs3/Emu/ARMv7/Modules/sceVoice.cpp

@@ -0,0 +1,286 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceVoice;
+
+enum SceVoicePortType : s32
+{
+	SCEVOICE_PORTTYPE_NULL = -1,
+	SCEVOICE_PORTTYPE_IN_DEVICE = 0,
+	SCEVOICE_PORTTYPE_IN_PCMAUDIO = 1,
+	SCEVOICE_PORTTYPE_IN_VOICE = 2,
+	SCEVOICE_PORTTYPE_OUT_PCMAUDIO = 3,
+	SCEVOICE_PORTTYPE_OUT_VOICE = 4,
+	SCEVOICE_PORTTYPE_OUT_DEVICE = 5
+};
+
+enum SceVoicePortState : s32
+{
+	SCEVOICE_PORTSTATE_NULL = -1,
+	SCEVOICE_PORTSTATE_IDLE = 0,
+	SCEVOICE_PORTSTATE_READY = 1,
+	SCEVOICE_PORTSTATE_BUFFERING = 2,
+	SCEVOICE_PORTSTATE_RUNNING = 3
+};
+
+enum SceVoiceBitRate : s32
+{
+	SCEVOICE_BITRATE_NULL = -1,
+	SCEVOICE_BITRATE_3850 = 3850,
+	SCEVOICE_BITRATE_4650 = 4650,
+	SCEVOICE_BITRATE_5700 = 5700,
+	SCEVOICE_BITRATE_7300 = 7300
+};
+
+enum SceVoiceSamplingRate : s32
+{
+	SCEVOICE_SAMPLINGRATE_NULL = -1,
+	SCEVOICE_SAMPLINGRATE_16000 = 16000
+};
+
+enum SceVoicePcmDataType : s32
+{
+	SCEVOICE_PCM_NULL = -1,
+	SCEVOICE_PCM_SHORT_LITTLE_ENDIAN = 0
+};
+
+enum SceVoiceVersion : s32
+{
+	SCEVOICE_VERSION_100 = 100
+};
+
+enum SceVoiceAppType : s32
+{
+	SCEVOICE_APPTYPE_GAME = 1 << 29
+};
+
+struct SceVoicePCMFormat
+{
+	SceVoicePcmDataType dataType;
+	SceVoiceSamplingRate sampleRate;
+};
+
+struct SceVoiceResourceInfo
+{
+	u16 maxInVoicePort;
+	u16 maxOutVoicePort;
+	u16 maxInDevicePort;
+	u16 maxOutDevicePort;
+	u16 maxTotalPort;
+};
+
+struct SceVoiceBasePortInfo
+{
+	SceVoicePortType portType;
+	SceVoicePortState state;
+	vm::psv::ptr<u32> pEdge;
+	u32 numByte;
+	u32 frameSize;
+	u16 numEdge;
+	u16 reserved;
+};
+
+struct SceVoicePortParam
+{
+	SceVoicePortType portType;
+	u16 threshold;
+	u16 bMute;
+	float volume;
+
+	union
+	{
+		struct
+		{
+			SceVoiceBitRate bitrate;
+		} voice;
+
+		struct
+		{
+			u32 bufSize;
+			SceVoicePCMFormat format;
+		} pcmaudio;
+
+
+		struct
+		{
+			u32 playerId;
+		} device;
+	};
+};
+
+typedef vm::psv::ptr<void(vm::psv::ptr<void> event)> SceVoiceEventCallback;
+
+struct SceVoiceInitParam
+{
+	s32 appType;
+	SceVoiceEventCallback onEvent;
+	u8 reserved[24];
+};
+
+struct SceVoiceStartParam
+{
+	s32 container;
+	u8 reserved[28];
+};
+
+s32 sceVoiceInit(vm::psv::ptr<SceVoiceInitParam> pArg, SceVoiceVersion version)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceEnd()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceStart(vm::psv::ptr<SceVoiceStartParam> pArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceStop()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceResetPort(u32 portId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceCreatePort(vm::psv::ptr<u32> portId, vm::psv::ptr<const SceVoicePortParam> pArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceUpdatePort(u32 portId, vm::psv::ptr<const SceVoicePortParam> pArg)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceConnectIPortToOPort(u32 ips, u32 ops)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceDisconnectIPortFromOPort(u32 ips, u32 ops)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceDeletePort(u32 portId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceWriteToIPort(u32 ips, vm::psv::ptr<const void> data, vm::psv::ptr<u32> size, s16 frameGaps)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceReadFromOPort(u32 ops, vm::psv::ptr<void> data, vm::psv::ptr<u32> size)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceSetMuteFlagAll(u16 bMuted)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceSetMuteFlag(u32 portId, u16 bMuted)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceGetMuteFlag(u32 portId, vm::psv::ptr<u16> bMuted)
+{
+	throw __FUNCTION__;
+}
+
+//s32 sceVoiceSetVolume(u32 portId, float volume)
+//{
+//	throw __FUNCTION__;
+//}
+
+s32 sceVoiceGetVolume(u32 portId, vm::psv::ptr<float> volume)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceSetBitRate(u32 portId, SceVoiceBitRate bitrate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceGetBitRate(u32 portId, vm::psv::ptr<u32> bitrate)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceGetPortInfo(u32 portId, vm::psv::ptr<SceVoiceBasePortInfo> pInfo)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoicePausePort(u32 portId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceResumePort(u32 portId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoicePausePortAll()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceResumePortAll()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceGetResourceInfo(vm::psv::ptr<SceVoiceResourceInfo> pInfo)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceVoice, #name, name)
+
+psv_log_base sceVoice("SceVoice", []()
+{
+	sceVoice.on_load = nullptr;
+	sceVoice.on_unload = nullptr;
+	sceVoice.on_stop = nullptr;
+
+	REG_FUNC(0xD02C00B4, sceVoiceGetBitRate);
+	REG_FUNC(0xC913F7E9, sceVoiceGetMuteFlag);
+	REG_FUNC(0x875CC80D, sceVoiceGetVolume);
+	REG_FUNC(0x02F58D6F, sceVoiceSetBitRate);
+	REG_FUNC(0x0B9E4AE2, sceVoiceSetMuteFlag);
+	REG_FUNC(0xDB90EAC4, sceVoiceSetMuteFlagAll);
+	//REG_FUNC(0xD93769E6, sceVoiceSetVolume);
+	REG_FUNC(0x6E46950E, sceVoiceGetResourceInfo);
+	REG_FUNC(0xAC98853E, sceVoiceEnd);
+	REG_FUNC(0x805CC20F, sceVoiceInit);
+	REG_FUNC(0xB2ED725B, sceVoiceStart);
+	REG_FUNC(0xC3868DF6, sceVoiceStop);
+	REG_FUNC(0x698BDAAE, sceVoiceConnectIPortToOPort);
+	REG_FUNC(0xFA4E57B1, sceVoiceCreatePort);
+	REG_FUNC(0xAE46564D, sceVoiceDeletePort);
+	REG_FUNC(0x5F0260F4, sceVoiceDisconnectIPortFromOPort);
+	REG_FUNC(0x5933CCFB, sceVoiceGetPortInfo);
+	REG_FUNC(0x23C6B16B, sceVoicePausePort);
+	REG_FUNC(0x39AA3884, sceVoicePausePortAll);
+	REG_FUNC(0x09E4D18C, sceVoiceReadFromOPort);
+	REG_FUNC(0x5E1CE910, sceVoiceResetPort);
+	REG_FUNC(0x2DE35411, sceVoiceResumePort);
+	REG_FUNC(0x1F93FC0C, sceVoiceResumePortAll);
+	REG_FUNC(0xCE855C50, sceVoiceUpdatePort);
+	REG_FUNC(0x0A22EC0E, sceVoiceWriteToIPort);
+});

rpcs3/Emu/ARMv7/Modules/sceVoiceQoS.cpp

@@ -0,0 +1,140 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceVoiceQoS;
+
+typedef s32 SceVoiceQoSLocalId;
+typedef s32 SceVoiceQoSRemoteId;
+typedef s32 SceVoiceQoSConnectionId;
+
+enum SceVoiceQoSAttributeId : s32
+{
+	SCE_VOICE_QOS_ATTR_MIC_VOLUME,
+	SCE_VOICE_QOS_ATTR_MIC_MUTE,
+	SCE_VOICE_QOS_ATTR_SPEAKER_VOLUME,
+	SCE_VOICE_QOS_ATTR_SPEAKER_MUTE,
+	SCE_VOICE_QOS_ATTR_DESIRED_OUT_BIT_RATE
+};
+
+enum SceVoiceQoSStatusId : s32
+{
+	SCE_VOICE_QOS_IN_BITRATE,
+	SCE_VOICE_QOS_OUT_BITRATE,
+	SCE_VOICE_QOS_OUT_READ_BITRATE,
+	SCE_VOICE_QOS_IN_FRAME_RECEIVED_RATIO,
+	SCE_VOICE_QOS_HEARTBEAT_FLAG
+};
+
+s32 sceVoiceQoSInit()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSEnd()
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSCreateLocalEndpoint(vm::psv::ptr<SceVoiceQoSLocalId> pLocalId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSDeleteLocalEndpoint(SceVoiceQoSLocalId localId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSCreateRemoteEndpoint(vm::psv::ptr<SceVoiceQoSRemoteId> pRemoteId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSDeleteRemoteEndpoint(SceVoiceQoSRemoteId remoteId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSConnect(vm::psv::ptr<SceVoiceQoSConnectionId> pConnectionId, SceVoiceQoSLocalId localId, SceVoiceQoSRemoteId remoteId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSDisconnect(SceVoiceQoSConnectionId connectionId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSGetLocalEndpoint(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<SceVoiceQoSLocalId> pLocalId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSGetRemoteEndpoint(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<SceVoiceQoSRemoteId> pRemoteId)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSSetLocalEndpointAttribute(SceVoiceQoSLocalId localId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<const void> pAttributeValue, s32 attributeSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSGetLocalEndpointAttribute(SceVoiceQoSLocalId localId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<void> pAttributeValue, s32 attributeSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSSetConnectionAttribute(SceVoiceQoSConnectionId connectionId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<const void> pAttributeValue, s32 attributeSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSGetConnectionAttribute(SceVoiceQoSConnectionId connectionId, SceVoiceQoSAttributeId attributeId, vm::psv::ptr<void> pAttributeValue, s32 attributeSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSGetStatus(SceVoiceQoSConnectionId connectionId, SceVoiceQoSStatusId statusId, vm::psv::ptr<void> pStatusValue, s32 statusSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSWritePacket(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<const void> pData, vm::psv::ptr<u32> pSize)
+{
+	throw __FUNCTION__;
+}
+
+s32 sceVoiceQoSReadPacket(SceVoiceQoSConnectionId connectionId, vm::psv::ptr<void> pData, vm::psv::ptr<u32> pSize)
+{
+	throw __FUNCTION__;
+}
+
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceVoiceQoS, #name, name)
+
+psv_log_base sceVoiceQoS("SceVoiceQos", []()
+{
+	sceVoiceQoS.on_load = nullptr;
+	sceVoiceQoS.on_unload = nullptr;
+	sceVoiceQoS.on_stop = nullptr;
+
+	REG_FUNC(0x4B5FFF1C, sceVoiceQoSInit);
+	REG_FUNC(0xFB0B747B, sceVoiceQoSEnd);
+	REG_FUNC(0xAAB54BE4, sceVoiceQoSCreateLocalEndpoint);
+	REG_FUNC(0x68FABF6F, sceVoiceQoSDeleteLocalEndpoint);
+	REG_FUNC(0xBAB98727, sceVoiceQoSCreateRemoteEndpoint);
+	REG_FUNC(0xC2F2C771, sceVoiceQoSDeleteRemoteEndpoint);
+	REG_FUNC(0xE0C5CEEE, sceVoiceQoSConnect);
+	REG_FUNC(0x3C7A08B0, sceVoiceQoSDisconnect);
+	REG_FUNC(0xE5B4527D, sceVoiceQoSGetLocalEndpoint);
+	REG_FUNC(0x876A9B9C, sceVoiceQoSGetRemoteEndpoint);
+	REG_FUNC(0x540CEBA5, sceVoiceQoSSetLocalEndpointAttribute);
+	REG_FUNC(0xC981AB3B, sceVoiceQoSGetLocalEndpointAttribute);
+	REG_FUNC(0xE757806F, sceVoiceQoSSetConnectionAttribute);
+	REG_FUNC(0xE81B8D44, sceVoiceQoSGetConnectionAttribute);
+	REG_FUNC(0xC9DC1425, sceVoiceQoSGetStatus);
+	REG_FUNC(0x2FE1F28F, sceVoiceQoSWritePacket);
+	REG_FUNC(0x2D613549, sceVoiceQoSReadPacket);
+});

rpcs3/Emu/ARMv7/Modules/sceXml.cpp

@@ -0,0 +1,201 @@
+#include "stdafx.h"
+#include "Emu/System.h"
+#include "Emu/ARMv7/PSVFuncList.h"
+
+extern psv_log_base sceXml;
+
+#define REG_FUNC(nid, name) reg_psv_func(nid, &sceXml, #name, name)
+
+psv_log_base sceXml("SceXml", []()
+{
+	sceXml.on_load = nullptr;
+	sceXml.on_unload = nullptr;
+	sceXml.on_stop = nullptr;
+
+	//REG_FUNC(0x57400A1A, _ZN3sce3Xml10SimpleDataC1EPKcj);
+	//REG_FUNC(0x7E582075, _ZN3sce3Xml10SimpleDataC1Ev);
+	//REG_FUNC(0x4CF0656B, _ZN3sce3Xml10SimpleDataC2EPKcj);
+	//REG_FUNC(0x95077028, _ZN3sce3Xml10SimpleDataC2Ev);
+	//REG_FUNC(0xECFA6A2A, _ZN3sce3Xml11Initializer10initializeEPKNS0_13InitParameterE);
+	//REG_FUNC(0x29824CD5, _ZN3sce3Xml11Initializer9terminateEv);
+	//REG_FUNC(0xBF13FDE6, _ZN3sce3Xml11InitializerC1Ev);
+	//REG_FUNC(0x94AAA71D, _ZN3sce3Xml11InitializerC2Ev);
+	//REG_FUNC(0xB4547C88, _ZN3sce3Xml11InitializerD1Ev);
+	//REG_FUNC(0xAAA08FA8, _ZN3sce3Xml11InitializerD2Ev);
+	//REG_FUNC(0x8D387E01, _ZN3sce3Xml12MemAllocatorC1Ev);
+	//REG_FUNC(0xE982E681, _ZN3sce3Xml12MemAllocatorC2Ev);
+	//REG_FUNC(0x90B82579, _ZN3sce3Xml12MemAllocatorD0Ev);
+	//REG_FUNC(0x56002B9D, _ZN3sce3Xml12MemAllocatorD1Ev);
+	//REG_FUNC(0x1BE022EA, _ZN3sce3Xml12MemAllocatorD2Ev);
+	//REG_FUNC(0x89AA847E, _ZN3sce3Xml13AttributeList10initializeEPKNS0_11InitializerE);
+	//REG_FUNC(0xD08EE434, _ZN3sce3Xml13AttributeList12addAttributeEPKNS0_6StringES4_);
+	//REG_FUNC(0xCCEE4E7C, _ZN3sce3Xml13AttributeList5clearEv);
+	//REG_FUNC(0x11FE5A65, _ZN3sce3Xml13AttributeList9terminateEv);
+	//REG_FUNC(0x9CBD82D4, _ZN3sce3Xml13AttributeListC1ERKS1_);
+	//REG_FUNC(0x542076D8, _ZN3sce3Xml13AttributeListC1Ev);
+	//REG_FUNC(0x87C89447, _ZN3sce3Xml13AttributeListC2ERKS1_);
+	//REG_FUNC(0x5D49542A, _ZN3sce3Xml13AttributeListC2Ev);
+	//REG_FUNC(0x38861841, _ZN3sce3Xml13AttributeListD1Ev);
+	//REG_FUNC(0x1B0B3976, _ZN3sce3Xml13AttributeListD2Ev);
+	//REG_FUNC(0x30520B78, _ZN3sce3Xml14VarAllocBuffer4copyEPKhjb);
+	//REG_FUNC(0x7D5A0041, _ZN3sce3Xml14VarAllocBuffer5clearEv);
+	//REG_FUNC(0xD95D3824, _ZN3sce3Xml14VarAllocBuffer7copyStrEPKcj);
+	//REG_FUNC(0xFE99676E, _ZN3sce3Xml14VarAllocBuffer7copyStrERKNS0_6StringE);
+	//REG_FUNC(0x82747F92, _ZN3sce3Xml14VarAllocBuffer7reserveEj);
+	//REG_FUNC(0xE93EACFC, _ZN3sce3Xml14VarAllocBuffer9terminateEv);
+	//REG_FUNC(0x8045D9C2, _ZN3sce3Xml14VarAllocBufferC1EPKNS0_11InitializerE);
+	//REG_FUNC(0xEF4FA027, _ZN3sce3Xml14VarAllocBufferC2EPKNS0_11InitializerE);
+	//REG_FUNC(0xD61CAAFC, _ZN3sce3Xml14VarAllocBufferD0Ev);
+	//REG_FUNC(0xD9217FC8, _ZN3sce3Xml14VarAllocBufferD1Ev);
+	//REG_FUNC(0x8A4B9379, _ZN3sce3Xml14VarAllocBufferD2Ev);
+	//REG_FUNC(0xB7770E5E, _ZN3sce3Xml18SerializeParameterC1Ev);
+	//REG_FUNC(0xF65270FC, _ZN3sce3Xml18SerializeParameterC2Ev);
+	//REG_FUNC(0x2CB61A7C, _ZN3sce3Xml20bXResultToResultTypeEi);
+	//REG_FUNC(0x59C5E9B2, _ZN3sce3Xml23getMemManagerDebugLevelEv);
+	//REG_FUNC(0xBA8B7374, _ZN3sce3Xml23setMemManagerDebugLevelEi);
+	//REG_FUNC(0xBBACFE87, _ZN3sce3Xml3Dom15DocumentBuilder10initializeEPKNS0_11InitializerE);
+	//REG_FUNC(0x1A29526B, _ZN3sce3Xml3Dom15DocumentBuilder11getDocumentEv);
+	//REG_FUNC(0xA2431C2B, _ZN3sce3Xml3Dom15DocumentBuilder16setResolveEntityEb);
+	//REG_FUNC(0xB8C4D13C, _ZN3sce3Xml3Dom15DocumentBuilder20setSkipIgnorableTextEb);
+	//REG_FUNC(0xF351D753, _ZN3sce3Xml3Dom15DocumentBuilder26setSkipIgnorableWhiteSpaceEb);
+	//REG_FUNC(0x7744DD14, _ZN3sce3Xml3Dom15DocumentBuilder5parseEPKNS0_6StringEb);
+	//REG_FUNC(0x42D59053, _ZN3sce3Xml3Dom15DocumentBuilder9terminateEv);
+	//REG_FUNC(0x702492EA, _ZN3sce3Xml3Dom15DocumentBuilderC1Ev);
+	//REG_FUNC(0x36F6BDF2, _ZN3sce3Xml3Dom15DocumentBuilderC2Ev);
+	//REG_FUNC(0x79C9322E, _ZN3sce3Xml3Dom15DocumentBuilderD0Ev);
+	//REG_FUNC(0x19D0E024, _ZN3sce3Xml3Dom15DocumentBuilderD1Ev);
+	//REG_FUNC(0x99C58389, _ZN3sce3Xml3Dom15DocumentBuilderD2Ev);
+	//REG_FUNC(0x3CA958D3, _ZN3sce3Xml3Dom4Node11removeChildEy);
+	//REG_FUNC(0x1B98BDBE, _ZN3sce3Xml3Dom4Node12insertBeforeEyy);
+	//REG_FUNC(0x26BA1E6E, _ZNK3sce3Xml3Dom4Node13hasAttributesEv);
+	//REG_FUNC(0xC6F4F6A8, _ZN3sce3Xml3Dom4Node13hasChildNodesEv);
+	//REG_FUNC(0x088C100E, _ZN3sce3Xml3Dom4NodeC1Ey);
+	//REG_FUNC(0x44CAF9E1, _ZN3sce3Xml3Dom4NodeC2Ey);
+	//REG_FUNC(0x8F2EB967, _ZN3sce3Xml3Dom4NodeD1Ev);
+	//REG_FUNC(0x241EFC0E, _ZN3sce3Xml3Dom4NodeD2Ev);
+	//REG_FUNC(0x6A16C2FF, _ZN3sce3Xml3Dom8Document10importNodeEyyPKS2_y);
+	//REG_FUNC(0xB4A33B78, _ZN3sce3Xml3Dom8Document10initializeEPKNS0_11InitializerE);
+	//REG_FUNC(0x18686B94, _ZN3sce3Xml3Dom8Document10insertNodeEyyy);
+	//REG_FUNC(0x49263CE5, _ZN3sce3Xml3Dom8Document11removeChildEyy);
+	//REG_FUNC(0xD945184A, _ZN3sce3Xml3Dom8Document11resetStatusEv);
+	//REG_FUNC(0x7B0A8F6C, _ZN3sce3Xml3Dom8Document11setWritableEv);
+	//REG_FUNC(0x0CBC1C3F, _ZN3sce3Xml3Dom8Document12importParentEPKS2_y);
+	//REG_FUNC(0x016A9ADB, _ZN3sce3Xml3Dom8Document12setAttrValueEyPKNS0_6StringES5_);
+	//REG_FUNC(0xEA19C7CF, _ZN3sce3Xml3Dom8Document12setAttributeEyPKNS0_6StringES5_);
+	//REG_FUNC(0x35C50B8B, _ZN3sce3Xml3Dom8Document13createElementEPKNS0_6StringEPKNS0_13AttributeListES5_);
+	//REG_FUNC(0xBCA5E62A, _ZN3sce3Xml3Dom8Document13recurseDeleteEy);
+	//REG_FUNC(0x8D19723F, _ZN3sce3Xml3Dom8Document14createTextNodeEPKNS0_6StringE);
+	//REG_FUNC(0x6220E98B, _ZN3sce3Xml3Dom8Document15addElementChildEyPKNS0_6StringEPKNS0_13AttributeListES5_);
+	//REG_FUNC(0xF1DB18B1, _ZN3sce3Xml3Dom8Document15removeAttributeEyPKNS0_6StringE);
+	//REG_FUNC(0x779036AB, _ZN3sce3Xml3Dom8Document16removeAttributesEy);
+	//REG_FUNC(0x0667B08D, _ZN3sce3Xml3Dom8Document16setAttributeListEyPKNS0_13AttributeListE);
+	//REG_FUNC(0xD2BFBC47, _ZNK3sce3Xml3Dom8Document20getElementsByTagNameEyPKNS0_6StringEPNS1_8NodeListE);
+	//REG_FUNC(0xDEFEAFD2, _ZN3sce3Xml3Dom8Document7setTextEyPKNS0_6StringE);
+	//REG_FUNC(0x87F8B4DA, _ZN3sce3Xml3Dom8Document9serializeEPKNS0_18SerializeParameterEPNS0_6StringE);
+	//REG_FUNC(0x4B7321FB, _ZN3sce3Xml3Dom8Document9terminateEv);
+	//REG_FUNC(0x1DD41C7A, _ZN3sce3Xml3Dom8DocumentC1ERKS2_);
+	//REG_FUNC(0x7B7107AD, _ZN3sce3Xml3Dom8DocumentC1Ev);
+	//REG_FUNC(0xF399F763, _ZN3sce3Xml3Dom8DocumentC2ERKS2_);
+	//REG_FUNC(0xE6BA9C73, _ZN3sce3Xml3Dom8DocumentC2Ev);
+	//REG_FUNC(0xFB207925, _ZN3sce3Xml3Dom8DocumentD1Ev);
+	//REG_FUNC(0x11A5F0A3, _ZN3sce3Xml3Dom8DocumentD2Ev);
+	//REG_FUNC(0xD622A7FE, _ZN3sce3Xml3Dom8DocumentaSERKS2_);
+	//REG_FUNC(0x860CC706, _ZN3sce3Xml3Dom8NodeList10initializeEPKNS0_11InitializerE);
+	//REG_FUNC(0x7A889374, _ZN3sce3Xml3Dom8NodeList10insertLastEy);
+	//REG_FUNC(0xE9995F58, _ZN3sce3Xml3Dom8NodeList10removeItemEy);
+	//REG_FUNC(0xFA921C6E, _ZN3sce3Xml3Dom8NodeList11insertFirstEy);
+	//REG_FUNC(0xCDD1D418, _ZNK3sce3Xml3Dom8NodeList4itemEj);
+	//REG_FUNC(0x508E9150, _ZN3sce3Xml3Dom8NodeList5clearEv);
+	//REG_FUNC(0xA41ED241, _ZNK3sce3Xml3Dom8NodeList8findItemEPKNS0_6StringE);
+	//REG_FUNC(0xE1AB441D, _ZNK3sce3Xml3Dom8NodeList8findItemEy);
+	//REG_FUNC(0xFB9EDBF9, _ZNK3sce3Xml3Dom8NodeList9getLengthEv);
+	//REG_FUNC(0x32B396AD, _ZN3sce3Xml3Dom8NodeList9terminateEv);
+	//REG_FUNC(0xB1CA0E34, _ZN3sce3Xml3Dom8NodeListC1ERKS2_);
+	//REG_FUNC(0x0580C02E, _ZN3sce3Xml3Dom8NodeListC1Ev);
+	//REG_FUNC(0xB97BF737, _ZN3sce3Xml3Dom8NodeListC2ERKS2_);
+	//REG_FUNC(0x684E57B9, _ZN3sce3Xml3Dom8NodeListC2Ev);
+	//REG_FUNC(0x92EBC9F8, _ZN3sce3Xml3Dom8NodeListD1Ev);
+	//REG_FUNC(0x2DF80037, _ZN3sce3Xml3Dom8NodeListD2Ev);
+	//REG_FUNC(0xBAD4AAFA, _ZNK3sce3Xml3Dom8NodeListixEj);
+	//REG_FUNC(0x874C8331, _ZN3sce3Xml3Sax6Parser10initializeEPKNS0_11InitializerE);
+	//REG_FUNC(0x4DB998E6, _ZN3sce3Xml3Sax6Parser11setUserDataEPv);
+	//REG_FUNC(0xB77BF8A0, _ZN3sce3Xml3Sax6Parser16setResolveEntityEb);
+	//REG_FUNC(0x1B2442A0, _ZN3sce3Xml3Sax6Parser18setDocumentHandlerEPNS1_15DocumentHandlerE);
+	//REG_FUNC(0xCE1DAE23, _ZN3sce3Xml3Sax6Parser26setSkipIgnorableWhiteSpaceEb);
+	//REG_FUNC(0x70D9FC8E, _ZN3sce3Xml3Sax6Parser5parseEPKNS0_6StringEb);
+	//REG_FUNC(0xA2B40FA7, _ZN3sce3Xml3Sax6Parser5resetEv);
+	//REG_FUNC(0xF2C8950D, _ZN3sce3Xml3Sax6Parser9terminateEv);
+	//REG_FUNC(0x60BF9988, _ZN3sce3Xml3Sax6ParserC1Ev);
+	//REG_FUNC(0x56390CA0, _ZN3sce3Xml3Sax6ParserC2Ev);
+	//REG_FUNC(0xA11C2AED, _ZN3sce3Xml3Sax6ParserD1Ev);
+	//REG_FUNC(0x02E8F7FA, _ZN3sce3Xml3Sax6ParserD2Ev);
+	//REG_FUNC(0xE5314387, _ZN3sce3Xml4Attr10initializeEPKNS0_11InitializerE);
+	//REG_FUNC(0x66D1B605, _ZN3sce3Xml4Attr7setNameEPKNS0_6StringE);
+	//REG_FUNC(0x7DD3059D, _ZN3sce3Xml4Attr8setValueEPKNS0_6StringE);
+	//REG_FUNC(0x67E0DF2B, _ZN3sce3Xml4Attr9terminateEv);
+	//REG_FUNC(0xC09ABF87, _ZN3sce3Xml4AttrC1ERKS1_);
+	//REG_FUNC(0xD016F1BC, _ZN3sce3Xml4AttrC1Ev);
+	//REG_FUNC(0xB4851BEC, _ZN3sce3Xml4AttrC2ERKS1_);
+	//REG_FUNC(0x0B3AE81B, _ZN3sce3Xml4AttrC2Ev);
+	//REG_FUNC(0x58E349A5, _ZN3sce3Xml4AttrD1Ev);
+	//REG_FUNC(0xB9E6F81A, _ZN3sce3Xml4AttrD2Ev);
+	//REG_FUNC(0xA5B902D4, _ZN3sce3Xml4AttraSERKS1_);
+	//REG_FUNC(0xA7E983E2, _ZN3sce3Xml4Util9strResultEi);
+	//REG_FUNC(0x035F013B, _ZN3sce3Xml6StringC1EPKc);
+	//REG_FUNC(0x0B5461E0, _ZN3sce3Xml6StringC1EPKcj);
+	//REG_FUNC(0x67191CC6, _ZN3sce3Xml6StringC1ERKS1_);
+	//REG_FUNC(0xA17502C1, _ZN3sce3Xml6StringC1Ev);
+	//REG_FUNC(0xECC1F1A4, _ZN3sce3Xml6StringC2EPKc);
+	//REG_FUNC(0x457CCE55, _ZN3sce3Xml6StringC2EPKcj);
+	//REG_FUNC(0xD785BA85, _ZN3sce3Xml6StringC2ERKS1_);
+	//REG_FUNC(0x8816F7EF, _ZN3sce3Xml6StringC2Ev);
+	//REG_FUNC(0x18758863, _ZN3sce3Xml6StringaSERKS1_);
+	//REG_FUNC(0x4F30F0CC, _ZNK3sce3Xml13AttributeList12getAttributeEPKNS0_6StringE);
+	//REG_FUNC(0x5ED0B2F9, _ZNK3sce3Xml13AttributeList12getAttributeEj);
+	//REG_FUNC(0x38AEB52E, _ZNK3sce3Xml13AttributeList9getLengthEv);
+	//REG_FUNC(0xEC96BFC6, _ZNK3sce3Xml3Dom13DocumentDebug13getStructSizeEv);
+	//REG_FUNC(0xE1100FC0, _ZNK3sce3Xml3Dom13DocumentDebug16getAttrTableSizeEv);
+	//REG_FUNC(0x6E1F1FFB, _ZNK3sce3Xml3Dom13DocumentDebug16getCharTableSizeEv);
+	//REG_FUNC(0x8F9CEE10, _ZNK3sce3Xml3Dom13DocumentDebug19getElementTableSizeEv);
+	//REG_FUNC(0xE1269956, _ZNK3sce3Xml3Dom4Node11getNodeNameEv);
+	//REG_FUNC(0xCED5E0FF, _ZNK3sce3Xml3Dom4Node11getNodeTypeEv);
+	//REG_FUNC(0x4F2D5541, _ZNK3sce3Xml3Dom4Node12getNodeValueEv);
+	//REG_FUNC(0xB405A149, _ZNK3sce3Xml3Dom4Node13getAttributesEv);
+	//REG_FUNC(0x117BEA8A, _ZNK3sce3Xml3Dom4Node13getChildNodesEv);
+	//REG_FUNC(0x639D219C, _ZNK3sce3Xml3Dom4Node13getFirstChildEv);
+	//REG_FUNC(0x3FD63FB8, _ZNK3sce3Xml3Dom4Node12getLastChildEv);
+	//REG_FUNC(0x1A46C0E1, _ZNK3sce3Xml3Dom4Node14getNextSiblingEv);
+	//REG_FUNC(0xD9757BC8, _ZNK3sce3Xml3Dom4Node14getParenetNodeEv);
+	//REG_FUNC(0x3E8122AB, _ZNK3sce3Xml3Dom4Node16getOwnerDocumentEv);
+	//REG_FUNC(0x22DBB221, _ZNK3sce3Xml3Dom8Document10getDocRootEv);
+	//REG_FUNC(0xE3D0A78A, _ZNK3sce3Xml3Dom8Document10getSiblingEy);
+	//REG_FUNC(0x2D370226, _ZNK3sce3Xml3Dom8Document10getXmlMetaEv);
+	//REG_FUNC(0xA4D99D40, _ZNK3sce3Xml3Dom8Document10isReadOnlyEv);
+	//REG_FUNC(0xCD65B91F, _ZNK3sce3Xml3Dom8Document11getAttrNameEy);
+	//REG_FUNC(0x883E1BFC, _ZNK3sce3Xml3Dom8Document11getNextAttrEy);
+	//REG_FUNC(0x471A22E8, _ZNK3sce3Xml3Dom8Document11getNodeNameEy);
+	//REG_FUNC(0x62D3CB44, _ZNK3sce3Xml3Dom8Document11getNodeTypeEy);
+	//REG_FUNC(0x28FD79E3, _ZNK3sce3Xml3Dom8Document11isAvailableEv);
+	//REG_FUNC(0x7C6A03FD, _ZNK3sce3Xml3Dom8Document12getAttrValueEy);
+	//REG_FUNC(0x9531C3CD, _ZNK3sce3Xml3Dom8Document12getAttributeEyPKNS0_6StringE);
+	//REG_FUNC(0xEC856072, _ZNK3sce3Xml3Dom8Document12getFirstAttrEy);
+	//REG_FUNC(0xFBCF0D3E, _ZNK3sce3Xml3Dom8Document12getLastChildEy);
+	//REG_FUNC(0xCDEC3F43, _ZNK3sce3Xml3Dom8Document13getAttributesEyPNS1_8NodeListE);
+	//REG_FUNC(0xFC61FDF1, _ZNK3sce3Xml3Dom8Document13getChildNodesEyPNS1_8NodeListE);
+	//REG_FUNC(0xDAC75E49, _ZNK3sce3Xml3Dom8Document13getEntityTypeEy);
+	//REG_FUNC(0xEA805296, _ZNK3sce3Xml3Dom8Document13hasAttributesEy);
+	//REG_FUNC(0xC5E7431A, _ZNK3sce3Xml3Dom8Document13hasChildNodesEy);
+	//REG_FUNC(0x0C1DDEC5, _ZNK3sce3Xml3Dom8Document14getSkippedTextEy);
+	//REG_FUNC(0xB34D9672, _ZNK3sce3Xml3Dom8Document7getRootEv);
+	//REG_FUNC(0x36ACFF5E, _ZNK3sce3Xml3Dom8Document7getTextEy);
+	//REG_FUNC(0x3028E05D, _ZNK3sce3Xml3Dom8Document13getFirstChildEy);
+	//REG_FUNC(0x161BA85E, _ZNK3sce3Xml3Dom8Document9getEntityEy);
+	//REG_FUNC(0xA98B5758, _ZNK3sce3Xml3Dom8Document9getParentEy);
+	//REG_FUNC(0xD428753A, _ZNK3sce3Xml3Dom8Document9getStatusEv);
+	//REG_FUNC(0x10530611, _ZNK3sce3Xml3Dom8NodeList11isAvailableEv);
+	//REG_FUNC(0x35134B85, _ZNK3sce3Xml4Attr7getNameEv);
+	//REG_FUNC(0x7834A2F7, _ZNK3sce3Xml4Attr8getValueEv);
+	//REG_FUNC(0x0D119AB3, _ZNK3sce3Xml3Dom4Node11isAvailableEv);
+	//REG_FUNC(0x1633846D, _ZNK3sce3Xml4Attr11isAvailableEv);
+	//REG_FUNC(0x58854322, _ZNK3sce3Xml13AttributeList11isAvailableEv);
+});

rpcs3/Emu/ARMv7/PSVFuncList.cpp

@@ -44,32 +44,132 @@ void execute_psv_func_by_index(ARMv7Context& context, u32 index)
 	context.thread.m_last_syscall = old_last_syscall;
 }
 
+extern psv_log_base sceAppMgr;
+extern psv_log_base sceAppUtil;
+extern psv_log_base sceAudio;
+extern psv_log_base sceAudiodec;
+extern psv_log_base sceAudioenc;
+extern psv_log_base sceAudioIn;
+extern psv_log_base sceCamera;
+extern psv_log_base sceCodecEngine;
+extern psv_log_base sceCommonDialog;
+extern psv_log_base sceCtrl;
+extern psv_log_base sceDbg;
+extern psv_log_base sceDeci4p;
+extern psv_log_base sceDeflt;
+extern psv_log_base sceDisplay;
+extern psv_log_base sceFiber;
+extern psv_log_base sceFios;
+extern psv_log_base sceFpu;
+extern psv_log_base sceGxm;
+extern psv_log_base sceHttp;
+extern psv_log_base sceIme;
+extern psv_log_base sceJpeg;
+extern psv_log_base sceJpegEnc;
 extern psv_log_base sceLibc;
+extern psv_log_base sceLibKernel;
 extern psv_log_base sceLibm;
 extern psv_log_base sceLibstdcxx;
-extern psv_log_base sceLibKernel;
-extern psv_log_base sceSysmodule;
+extern psv_log_base sceLiveArea;
+extern psv_log_base sceLocation;
+extern psv_log_base sceMd5;
+extern psv_log_base sceMotion;
+extern psv_log_base sceMt19937;
+extern psv_log_base sceNet;
+extern psv_log_base sceNetCtl;
+extern psv_log_base sceNgs;
+extern psv_log_base sceNpBasic;
+extern psv_log_base sceNpCommon;
+extern psv_log_base sceNpManager;
+extern psv_log_base sceNpMatching;
+extern psv_log_base sceNpScore;
+extern psv_log_base sceNpUtility;
 extern psv_log_base scePerf;
-extern psv_log_base sceCtrl;
-extern psv_log_base sceDeci4p;
-extern psv_log_base sceDisplay;
-extern psv_log_base sceGxm;
+extern psv_log_base scePgf;
+extern psv_log_base scePhotoExport;
+extern psv_log_base sceRazorCapture;
+extern psv_log_base sceRtc;
+extern psv_log_base sceSas;
+extern psv_log_base sceScreenShot;
+extern psv_log_base sceSfmt;
+extern psv_log_base sceSha;
+extern psv_log_base sceSqlite;
+extern psv_log_base sceSsl;
+extern psv_log_base sceSulpha;
+extern psv_log_base sceSysmodule;
+extern psv_log_base sceSystemGesture;
+extern psv_log_base sceTouch;
+extern psv_log_base sceUlt;
+extern psv_log_base sceVideodec;
+extern psv_log_base sceVoice;
+extern psv_log_base sceVoiceQoS;
+extern psv_log_base sceXml;
 
 void initialize_psv_modules()
 {
 	assert(!g_psv_func_list.size() && !g_psv_modules.size());
 
 	// fill module list
+	g_psv_modules.push_back(&sceAppMgr);
+	g_psv_modules.push_back(&sceAppUtil);
+	g_psv_modules.push_back(&sceAudio);
+	g_psv_modules.push_back(&sceAudiodec);
+	g_psv_modules.push_back(&sceAudioenc);
+	g_psv_modules.push_back(&sceAudioIn);
+	g_psv_modules.push_back(&sceCamera);
+	g_psv_modules.push_back(&sceCodecEngine);
+	g_psv_modules.push_back(&sceCommonDialog);
+	g_psv_modules.push_back(&sceCtrl);
+	g_psv_modules.push_back(&sceDbg);
+	g_psv_modules.push_back(&sceDeci4p);
+	g_psv_modules.push_back(&sceDeflt);
+	g_psv_modules.push_back(&sceDisplay);
+	g_psv_modules.push_back(&sceFiber);
+	g_psv_modules.push_back(&sceFios);
+	g_psv_modules.push_back(&sceFpu);
+	g_psv_modules.push_back(&sceGxm);
+	g_psv_modules.push_back(&sceHttp);
+	g_psv_modules.push_back(&sceIme);
+	g_psv_modules.push_back(&sceJpeg);
+	g_psv_modules.push_back(&sceJpegEnc);
 	g_psv_modules.push_back(&sceLibc);
+	g_psv_modules.push_back(&sceLibKernel);
 	g_psv_modules.push_back(&sceLibm);
 	g_psv_modules.push_back(&sceLibstdcxx);
-	g_psv_modules.push_back(&sceLibKernel);
-	g_psv_modules.push_back(&sceSysmodule);
+	g_psv_modules.push_back(&sceLiveArea);
+	g_psv_modules.push_back(&sceLocation);
+	g_psv_modules.push_back(&sceMd5);
+	g_psv_modules.push_back(&sceMotion);
+	g_psv_modules.push_back(&sceMt19937);
+	g_psv_modules.push_back(&sceNet);
+	g_psv_modules.push_back(&sceNetCtl);
+	g_psv_modules.push_back(&sceNgs);
+	g_psv_modules.push_back(&sceNpBasic);
+	g_psv_modules.push_back(&sceNpCommon);
+	g_psv_modules.push_back(&sceNpManager);
+	g_psv_modules.push_back(&sceNpMatching);
+	g_psv_modules.push_back(&sceNpScore);
+	g_psv_modules.push_back(&sceNpUtility);
 	g_psv_modules.push_back(&scePerf);
-	g_psv_modules.push_back(&sceCtrl);
-	g_psv_modules.push_back(&sceDeci4p);
-	g_psv_modules.push_back(&sceDisplay);
-	g_psv_modules.push_back(&sceGxm);
+	g_psv_modules.push_back(&scePgf);
+	g_psv_modules.push_back(&scePhotoExport);
+	g_psv_modules.push_back(&sceRazorCapture);
+	g_psv_modules.push_back(&sceRtc);
+	g_psv_modules.push_back(&sceSas);
+	g_psv_modules.push_back(&sceScreenShot);
+	g_psv_modules.push_back(&sceSfmt);
+	g_psv_modules.push_back(&sceSha);
+	g_psv_modules.push_back(&sceSqlite);
+	g_psv_modules.push_back(&sceSsl);
+	g_psv_modules.push_back(&sceSulpha);
+	g_psv_modules.push_back(&sceSysmodule);
+	g_psv_modules.push_back(&sceSystemGesture);
+	g_psv_modules.push_back(&sceTouch);
+	g_psv_modules.push_back(&sceUlt);
+	g_psv_modules.push_back(&sceVideodec);
+	g_psv_modules.push_back(&sceVoice);
+	g_psv_modules.push_back(&sceVoiceQoS);
+	g_psv_modules.push_back(&sceXml);
 
 	// setup special functions (without NIDs)
 	psv_func unimplemented;

rpcs3/Emu/ARMv7/PSVFuncList.h

@@ -647,3 +647,19 @@ struct SceDateTime
 	u16 second;
 	u32 microsecond;
 };
+
+struct SceFVector3
+{
+	float x, y, z;
+};
+
+struct SceFQuaternion
+{
+	float x, y, z, w;
+};
+
+union SceUMatrix4
+{
+	float f[4][4];
+	s32 i[4][4];
+};

rpcs3/Emu/Cell/PPUThread.cpp

@@ -15,6 +15,9 @@
 
 u64 rotate_mask[64][64];
 
+extern u32 ppu_get_tls(u32 thread);
+extern void ppu_free_tls(u32 thread);
+
 PPUThread& GetCurrentPPUThread()
 {
 	PPCThread* thread = GetCurrentPPCThread();
@@ -32,6 +35,7 @@ PPUThread::PPUThread() : PPCThread(CPU_THREAD_PPU)
 
 PPUThread::~PPUThread()
 {
+	ppu_free_tls(GetId());
 }
 
 void PPUThread::DoReset()
@@ -92,7 +96,7 @@ void PPUThread::InitRegs()
 	GPR[2] = rtoc;
 	//GPR[11] = entry;
 	//GPR[12] = Emu.GetMallocPageSize();
-	GPR[13] = Memory.PRXMem.GetStartAddr() + 0x7060;
+	GPR[13] = ppu_get_tls(GetId()) + 0x7000; // 0x7000 is usually subtracted from r13 to access first TLS element (details are not clear)
 
 	LR = Emu.GetCPUThreadExit();
 	CTR = PC;

rpcs3/Emu/FS/vfsDirBase.h

@@ -67,8 +67,9 @@ public:
 		{
 		}
 
-		iterator(const DirEntryInfo* data)
-			: data(data)
+		iterator(vfsDirBase* parent, const DirEntryInfo* data)
+			: parent(parent)
+			, data(data)
 		{
 		}
 
@@ -82,7 +83,7 @@ public:
 		{
 			const DirEntryInfo* olddata = data;
 			data = parent->Read();
-			return iterator(olddata);
+			return iterator(parent, olddata);
 		}
 
 		const DirEntryInfo* operator *()
@@ -90,7 +91,7 @@ public:
 			return data;
 		}
 
-		bool operator!=(iterator other) const
+		bool operator !=(iterator other) const
 		{
 			return data != other.data;
 		}
@@ -103,6 +104,6 @@ public:
 
 	iterator end()
 	{
-		return iterator((const DirEntryInfo*)nullptr);
+		return iterator(this, nullptr);
 	}
 };

rpcs3/Emu/Memory/Memory.cpp

@@ -17,11 +17,6 @@
 
 MemoryBase Memory;
 
-void MemoryBase::InvalidAddress(const char* func, const u64 addr)
-{
-	LOG_ERROR(MEMORY, "%s(): invalid address (0x%llx)", func, addr);
-}
-
 void MemoryBase::RegisterPages(u64 addr, u32 size)
 {
 	LV2_LOCK(0);
@@ -31,7 +26,7 @@ void MemoryBase::RegisterPages(u64 addr, u32 size)
 	{
 		if (i >= sizeof(m_pages) / sizeof(m_pages[0]))
 		{
-			InvalidAddress(__FUNCTION__, i * 4096);
+			LOG_ERROR(MEMORY, "%s(): invalid address 0x%llx", __FUNCTION__, i * 4096);
 			break;
 		}
 		if (m_pages[i])
@@ -52,7 +47,7 @@ void MemoryBase::UnregisterPages(u64 addr, u32 size)
 	{
 		if (i >= sizeof(m_pages) / sizeof(m_pages[0]))
 		{
-			InvalidAddress(__FUNCTION__, i * 4096);
+			LOG_ERROR(MEMORY, "%s(): invalid address 0x%llx", __FUNCTION__, i * 4096);
 			break;
 		}
 		if (!m_pages[i])

rpcs3/Emu/Memory/Memory.h

@@ -77,8 +77,6 @@ public:
 		return vm::g_base_addr;
 	}
 
-	__noinline void InvalidAddress(const char* func, const u64 addr);
-
 	void RegisterPages(u64 addr, u32 size);
 
 	void UnregisterPages(u64 addr, u32 size);

rpcs3/Emu/Memory/vm.cpp

@@ -66,6 +66,11 @@ namespace vm
 		return 0;
 	}
 
+	void error(const u64 addr, const char* func)
+	{
+		throw fmt::format("%s(): invalid address 0x%llx", func, addr);
+	}
+
 	namespace ps3
 	{
 		u32 main_alloc(u32 size)

rpcs3/Emu/Memory/vm.h

@@ -42,6 +42,8 @@ namespace vm
 
 	u32 get_addr(const void* real_pointer);
 
+	__noinline void error(const u64 addr, const char* func);
+
 	template<typename T>
 	struct cast_ptr
 	{
@@ -70,7 +72,7 @@ namespace vm
 			const u32 res = static_cast<u32>(addr);
 			if (res != addr)
 			{
-				throw fmt::format("%s(): invalid address 0x%llx", func, addr);
+				vm::error(addr, func);
 			}
 
 			return res;

rpcs3/Emu/Memory/vm_ptr.h

@@ -108,6 +108,8 @@ namespace vm
 		AT m_addr;
 		
 	public:
+		static_assert(!std::is_pointer<T>::value, "vm::_ptr_base<> error: invalid type (pointer)");
+		static_assert(!std::is_reference<T>::value, "vm::_ptr_base<> error: invalid type (reference)");
 		typedef typename std::remove_cv<T>::type type;
 
 		__forceinline static const u32 data_size()

rpcs3/Emu/RSX/GL/GLGSRender.h

@@ -21,7 +21,7 @@ u32 LinearToSwizzleAddress(u32 x, u32 y, u32 z, u32 log2_width, u32 log2_height,
 class GLTexture
 {
 	u32 m_id;
-	
+
 public:
 	GLTexture() : m_id(0)
 	{
@@ -166,11 +166,12 @@ public:
 	virtual ~GLGSRender();
 
 private:
-	void EnableVertexData(bool indexed_draw=false);
+	void EnableVertexData(bool indexed_draw = false);
 	void DisableVertexData();
 	void InitVertexData();
 	void InitFragmentData();
 
+	void Enable(bool enable, const u32 cap);
 	virtual void Close();
 	bool LoadProgram();
 	void WriteBuffers();
@@ -189,41 +190,7 @@ protected:
 	virtual void OnInitThread();
 	virtual void OnExitThread();
 	virtual void OnReset();
+	virtual void ExecCMD(u32 cmd);
 	virtual void ExecCMD();
-	virtual void Enable(u32 cmd, u32 enable);
-	virtual void ClearColor(u32 a, u32 r, u32 g, u32 b);
-	virtual void ClearStencil(u32 stencil);
-	virtual void ClearDepth(u32 depth);
-	virtual void ClearSurface(u32 mask);
-	virtual void ColorMask(bool a, bool r, bool g, bool b);
-	virtual void AlphaFunc(u32 func, float ref);
-	virtual void DepthFunc(u32 func);
-	virtual void DepthMask(u32 flag);
-	virtual void PolygonMode(u32 face, u32 mode);
-	virtual void PointSize(float size);
-	virtual void LogicOp(u32 opcode);
-	virtual void LineWidth(float width);
-	virtual void LineStipple(u16 factor, u16 pattern);
-	virtual void PolygonStipple(u32 pattern);
-	virtual void PrimitiveRestartIndex(u32 index);
-	virtual void CullFace(u32 mode);
-	virtual void FrontFace(u32 mode);
-	virtual void Fogi(u32 mode);
-	virtual void Fogf(float start, float end);
-	virtual void PolygonOffset(float factor, float bias);
-	virtual void DepthRangef(float min, float max);
-	virtual void BlendEquationSeparate(u16 rgb, u16 a);
-	virtual void BlendFuncSeparate(u16 srcRGB, u16 dstRGB, u16 srcAlpha, u16 dstAlpha);
-	virtual void BlendColor(u8 r, u8 g, u8 b, u8 a);
-	virtual void LightModeli(u32 enable);
-	virtual void ShadeModel(u32 mode);
-	virtual void DepthBoundsEXT(float min, float max);
-	virtual void Scissor(u16 x, u16 y, u16 width, u16 height);
-	virtual void StencilOp(u32 fail, u32 zfail, u32 zpass);
-	virtual void StencilMask(u32 mask);
-	virtual void StencilFunc(u32 func, u32 ref, u32 mask);
-	virtual void StencilOpSeparate(u32 mode, u32 fail, u32 zfail, u32 zpass);
-	virtual void StencilMaskSeparate(u32 mode, u32 mask);
-	virtual void StencilFuncSeparate(u32 mode, u32 func, u32 ref, u32 mask);
 	virtual void Flip();
 };

rpcs3/Emu/RSX/Null/NullGSRender.h

@@ -6,50 +6,44 @@ class NullGSRender
 {
 public:
 
-	NullGSRender() {}
-	virtual ~NullGSRender() {}
+	NullGSRender()
+	{
+	}
+
+	virtual ~NullGSRender()
+	{
+	}
 
 private:
-	virtual void OnInit() {}
-	virtual void OnInitThread() {}
-	virtual void OnExitThread() {}
-	virtual void OnReset() {}
-	virtual void Enable(u32 cmd, u32 enable) {}
-	virtual void ClearColor(u32 a, u32 r, u32 g, u32 b) {}
-	virtual void ClearStencil(u32 stencil) {}
-	virtual void ClearDepth(u32 depth) {}
-	virtual void ClearSurface(u32 mask) {}
-	virtual void ColorMask(bool a, bool r, bool g, bool b) {}
-	virtual void ExecCMD() {}
-	virtual void AlphaFunc(u32 func, float ref) {}
-	virtual void DepthFunc(u32 func) {}
-	virtual void DepthMask(u32 flag) {}
-	virtual void PolygonMode(u32 face, u32 mode) {}
-	virtual void PointSize(float size) {}
-	virtual void LogicOp(u32 opcode) {}
-	virtual void LineWidth(float width) {}
-	virtual void LineStipple(u16 factor, u16 pattern) {}
-	virtual void PolygonStipple(u32 pattern) {}
-	virtual void PrimitiveRestartIndex(u32 index) {}
-	virtual void CullFace(u32 mode) {}
-	virtual void FrontFace(u32 mode) {}
-	virtual void Fogi(u32 mode) {}
-	virtual void Fogf(float start, float end) {}
-	virtual void PolygonOffset(float factor, float bias) {}
-	virtual void DepthRangef(float min, float max) {}
-	virtual void BlendEquationSeparate(u16 rgb, u16 a) {}
-	virtual void BlendFuncSeparate(u16 srcRGB, u16 dstRGB, u16 srcAlpha, u16 dstAlpha) {}
-	virtual void BlendColor(u8 r, u8 g, u8 b, u8 a) {}
-	virtual void LightModeli(u32 enable) {}
-	virtual void ShadeModel(u32 mode) {}
-	virtual void DepthBoundsEXT(float min, float max) {}
-	virtual void Scissor(u16 x, u16 y, u16 width, u16 height) {}
-	virtual void StencilOp(u32 fail, u32 zfail, u32 zpass) {}
-	virtual void StencilMask(u32 mask) {}
-	virtual void StencilFunc(u32 func, u32 ref, u32 mask) {}
-	virtual void StencilOpSeparate(u32 mode, u32 fail, u32 zfail, u32 zpass) {}
-	virtual void StencilMaskSeparate(u32 mode, u32 mask) {}
-	virtual void StencilFuncSeparate(u32 mode, u32 func, u32 ref, u32 mask) {}
-	virtual void Flip() {}
-	virtual void Close() {}
-};
+	virtual void OnInit()
+	{
+	}
+
+	virtual void OnInitThread()
+	{
+	}
+
+	virtual void OnExitThread()
+	{
+	}
+
+	virtual void OnReset()
+	{
+	}
+
+	virtual void ExecCMD(u32 cmd)
+	{
+	}
+
+	virtual void ExecCMD()
+	{
+	}
+
+	virtual void Flip()
+	{
+	}
+
+	virtual void Close()
+	{
+	}
+};

rpcs3/Emu/RSX/RSXThread.h

@@ -90,7 +90,7 @@ struct RSXTransformConstant
 	}
 };
 
-class RSXThread  : public ThreadBase
+class RSXThread : public ThreadBase
 {
 public:
 	static const uint m_textures_count = 16;
@@ -501,7 +501,7 @@ protected:
 		m_front_face = 0x0901; // GL_CCW
 		m_cull_face = 0x0405; // GL_BACK
 		m_alpha_func = 0x0207; // GL_ALWAYS
-		m_alpha_ref = 0.0; 
+		m_alpha_ref = 0.0f;
 		m_logic_op = 0x1503; // GL_COPY
 		m_shade_mode = 0x1D01; // GL_SMOOTH
 		m_depth_mask = 1;
@@ -526,7 +526,7 @@ protected:
 		m_vertex_data_base_index = 0;
 
 		// Construct Stipple Pattern
-		for (size_t i = 0; i < 32; i++) 
+		for (size_t i = 0; i < 32; i++)
 		{
 			m_polygon_stipple_pattern[i] = 0xFFFFFFFF;
 		}
@@ -632,54 +632,20 @@ protected:
 	u32 OutOfArgsCount(const uint x, const u32 cmd, const u32 count, const u32 args_addr);
 	void DoCmd(const u32 fcmd, const u32 cmd, const u32 args_addr, const u32 count);
 	void NativeRescale(float width, float height);
-	
+
 	virtual void OnInit() = 0;
 	virtual void OnInitThread() = 0;
 	virtual void OnExitThread() = 0;
 	virtual void OnReset() = 0;
 	virtual void ExecCMD() = 0;
-	virtual void Enable(u32 cmd, u32 enable) = 0;
-	virtual void ClearColor(u32 a, u32 r, u32 g, u32 b) = 0;
-	virtual void ClearStencil(u32 stencil) = 0;
-	virtual void ClearDepth(u32 depth) = 0;
-	virtual void ClearSurface(u32 mask) = 0;
-	virtual void ColorMask(bool a, bool r, bool g, bool b) = 0;
-	virtual void AlphaFunc(u32 func, float ref) = 0;
-	virtual void DepthFunc(u32 func) = 0;
-	virtual void DepthMask(u32 flag) = 0;
-	virtual void PolygonMode(u32 face, u32 mode) = 0;
-	virtual void PointSize(float size) = 0;
-	virtual void LogicOp(u32 opcode) = 0;
-	virtual void LineWidth(float width) = 0;
-	virtual void LineStipple(u16 factor, u16 pattern) = 0;
-	virtual void PolygonStipple(u32 pattern) = 0;
-	virtual void PrimitiveRestartIndex(u32 index) = 0;
-	virtual void CullFace(u32 mode) = 0;
-	virtual void FrontFace(u32 mode) = 0;
-	virtual void Fogi(u32 mode) = 0;
-	virtual void Fogf(float start, float end) = 0;
-	virtual void PolygonOffset(float factor, float bias) = 0;
-	virtual void DepthRangef(float min, float max) = 0;
-	virtual void BlendEquationSeparate(u16 rgb, u16 a) = 0;
-	virtual void BlendFuncSeparate(u16 srcRGB, u16 dstRGB, u16 srcAlpha, u16 dstAlpha) = 0;
-	virtual void BlendColor(u8 r, u8 g, u8 b, u8 a) = 0;
-	virtual void LightModeli(u32 enable) = 0;
-	virtual void ShadeModel(u32 mode) = 0;
-	virtual void DepthBoundsEXT(float min, float max) = 0;
-	virtual void Scissor(u16 x, u16 y, u16 width, u16 height) = 0;
-	virtual void StencilOp(u32 fail, u32 zfail, u32 zpass) = 0;
-	virtual void StencilMask(u32 mask) = 0;
-	virtual void StencilFunc(u32 func, u32 ref, u32 mask) = 0;
-	virtual void StencilOpSeparate(u32 mode, u32 fail, u32 zfail, u32 zpass) = 0;
-	virtual void StencilMaskSeparate(u32 mode, u32 mask) = 0;
-	virtual void StencilFuncSeparate(u32 mode, u32 func, u32 ref, u32 mask) = 0;
+	virtual void ExecCMD(u32 cmd) = 0;
 	virtual void Flip() = 0;
 
 	void LoadVertexData(u32 first, u32 count)
 	{
 		for (u32 i = 0; i < m_vertex_count; ++i)
 		{
-			if(!m_vertex_data[i].IsEnabled()) continue;
+			if (!m_vertex_data[i].IsEnabled()) continue;
 
 			m_vertex_data[i].Load(first, count, m_vertex_data_base_offset, m_vertex_data_base_index);
 		}

rpcs3/Emu/SysCalls/Modules/cellSysutil.h

@@ -251,8 +251,8 @@ typedef void(CellWebBrowserUsrdata)(vm::ptr<void> usrdata);
 
 struct CellWebBrowserMimeSet
 {
-	vm::bptr<const char> const type;
-	vm::bptr<const char> const directory;
+	const vm::bptr<const char> type;
+	const vm::bptr<const char> directory;
 };
 
 struct CellWebBrowserPos

rpcs3/Emu/SysCalls/Modules/sceNp.h

@@ -1957,7 +1957,7 @@ struct SceNpScoreClanRankData
 	CellRtcTick recordDate;
 	SceNpId npId;
 	SceNpOnlineName onlineName;
-	uint8_t reserved[32];
+	u8 reserved[32];
 };
 
 // Clan ranking information to be obtained for a specified clan ID

rpcs3/Emu/SysCalls/Modules/sceNpClans.h

@@ -109,7 +109,7 @@ enum
 
 // Request handle for clan API
 struct SceNpClansRequest;
-typedef SceNpClansRequest* SceNpClansRequestHandle;
+typedef vm::ptr<SceNpClansRequest> SceNpClansRequestHandle;
 
 // Paging request structure
 struct SceNpClansPagingRequest

rpcs3/Emu/SysCalls/Modules/sysPrxForUser.cpp

@@ -23,11 +23,66 @@
 
 Module *sysPrxForUser = nullptr;
 
+u32 g_tls_size; // size of every thread's storage
+u32 g_tls_start; // start of TLS memory area
+u32 g_tls_image_addr; // address of TLS initialization area
+u32 g_tls_image_size; // size of TLS initialization area
+
+const u32 TLS_MAX = 256;
+std::array<std::atomic<u32>, TLS_MAX> g_tls_owners;
+
 void sys_initialize_tls()
 {
 	sysPrxForUser->Log("sys_initialize_tls()");
 }
 
+u32 ppu_get_tls(u32 thread)
+{
+	if (!g_tls_start)
+	{
+		g_tls_size = vm::cast(Emu.GetTLSMemsz(), "Emu.GetTLSMemsz"); // (not an address for vm::cast, but fine)
+		g_tls_start = vm::cast(Memory.Alloc(g_tls_size * TLS_MAX, 4096)); // memory for up to TLS_MAX threads
+		g_tls_image_addr = vm::cast(Emu.GetTLSAddr(), "Emu.GetTLSAddr");
+		g_tls_image_size = vm::cast(Emu.GetTLSFilesz(), "Emu.GetTLSFilesz");
+
+		sysPrxForUser->Warning("TLS initialized (g_tls_size=0x%x, g_tls_start=0x%x, g_tls_image_addr=0x%x, g_tls_image_size=0x%x)", g_tls_size, g_tls_start, g_tls_image_addr, g_tls_image_size);
+	}
+	
+	for (u32 i = 0; i < TLS_MAX; i++)
+	{
+		if (g_tls_owners[i] == thread)
+		{
+			return g_tls_start + i * g_tls_size; // if already initialized, return TLS address
+		}
+	}
+
+	for (u32 i = 0; i < TLS_MAX; i++)
+	{
+		u32 old = 0;
+		if (g_tls_owners[i].compare_exchange_strong(old, thread))
+		{
+			const u32 addr = g_tls_start + i * g_tls_size; // get TLS address
+			memset(vm::get_ptr(addr), 0, g_tls_size);      // fill TLS area with zeros
+			memcpy(vm::get_ptr(addr), vm::get_ptr(g_tls_image_addr), g_tls_image_size); // initialize from TLS image
+			return addr;
+		}
+	}
+
+	throw "Out of TLS memory";
+}
+
+void ppu_free_tls(u32 thread)
+{
+	for (auto& v : g_tls_owners)
+	{
+		u32 old = thread;
+		if (v.compare_exchange_strong(old, 0))
+		{
+			return;
+		}
+	}
+}
+
 int _sys_heap_create_heap(const u32 heap_addr, const u32 align, const u32 size)
 {
 	sysPrxForUser->Warning("_sys_heap_create_heap(heap_addr=0x%x, align=0x%x, size=0x%x)", heap_addr, align, size);
@@ -365,6 +420,15 @@ void sysPrxForUser_init(Module *pxThis)
 {
 	sysPrxForUser = pxThis;
 
+	g_tls_size = 0;
+	g_tls_start = 0;
+	g_tls_image_addr = 0;
+	g_tls_image_size = 0;
+	for (auto& v : g_tls_owners)
+	{
+		v.store(0, std::memory_order_relaxed);
+	}
+
 	// Setup random number generator
 	srand(time(NULL));
 

rpcs3/Loader/ELF32.cpp

@@ -1,4 +1,5 @@
 #include "stdafx.h"
+#include "Ini.h"
 #include "Utilities/Log.h"
 #include "Utilities/rFile.h"
 #include "Emu/FS/vfsStream.h"
@@ -102,6 +103,9 @@ namespace loader
 				u32 code_start = 0;
 				u32 code_end = 0;
 
+				u32 vnid_addr = 0;
+				std::unordered_map<u32, u32> vnid_list;
+
 				for (auto& shdr : m_shdrs)
 				{
 					// get secton name
@@ -165,15 +169,19 @@ namespace loader
 
 						for (u32 j = 0; j < shdr.data_le.sh_size / 4; j++)
 						{
-							u32 nid = fnid[j];
-							u32 addr = fstub[j];
+							const u32 nid = fnid[j];
+							const u32 addr = fstub[j];
 
 							if (auto func = get_psv_func_by_nid(nid))
 							{
 								if (func->module)
+								{
 									func->module->Notice("Imported function %s (nid=0x%08x, addr=0x%x)", func->name, nid, addr);
+								}
 								else
+								{
 									LOG_NOTICE(LOADER, "Imported function %s (nid=0x%08x, addr=0x%x)", func->name, nid, addr);
+								}
 
 								// writing Thumb code (temporarily, because it should be ARM)
 								vm::psv::write16(addr + 0, 0xf870); // HACK instruction (Thumb)
@@ -183,7 +191,7 @@ namespace loader
 							}
 							else
 							{
-								LOG_ERROR(LOADER, "Unimplemented function 0x%08x (addr=0x%x)", nid, addr);
+								LOG_ERROR(LOADER, "Unknown function 0x%08x (addr=0x%x)", nid, addr);
 
 								vm::psv::write16(addr + 0, 0xf870); // HACK instruction (Thumb)
 								vm::psv::write16(addr + 2, 0); // index 0 (unimplemented stub)
@@ -193,6 +201,44 @@ namespace loader
 							code_end = std::min<u32>(addr, code_end);
 						}
 					}
+					else if (!strcmp(name.c_str(), ".sceVNID.rodata"))
+					{
+						LOG_NOTICE(LOADER, ".sceVNID.rodata analysis...");
+
+						vnid_addr = shdr.data_le.sh_addr;
+					}
+					else if (!strcmp(name.c_str(), ".sceVStub.rodata"))
+					{
+						LOG_NOTICE(LOADER, ".sceVStub.rodata analysis...");
+
+						if (!vnid_addr)
+						{
+							if (shdr.data_le.sh_size)
+							{
+								LOG_ERROR(LOADER, ".sceVNID.rodata address not found, unable to process imports");
+							}
+							continue;
+						}
+
+						auto vnid = vm::psv::ptr<const u32>::make(vnid_addr);
+						auto vstub = vm::psv::ptr<const u32>::make(shdr.data_le.sh_addr);
+
+						for (u32 j = 0; j < shdr.data_le.sh_size / 4; j++)
+						{
+							const u32 nid = vnid[j];
+							const u32 addr = vstub[j];
+
+							LOG_ERROR(LOADER, "Unknown object 0x%08x (ref_addr=0x%x)", nid, addr);
+
+							// TODO: find imported object (vtable, typeinfo or something), assign it to vnid_list[addr]
+						}
+					}
+					else if (!strcmp(name.c_str(), ".tbss"))
+					{
+						LOG_NOTICE(LOADER, ".tbss analysis");
+
+						LOG_ERROR(LOADER, "TLS: size=0x%08x", shdr.data_le.sh_size);
+					}
 					else if (!strcmp(name.c_str(), ".sceRefs.rodata"))
 					{
 						LOG_NOTICE(LOADER, ".sceRefs.rodata analysis...");
@@ -203,39 +249,65 @@ namespace loader
 						{
 							switch (*code)
 							{
-							case 0x000000ff:
+							case 0x000000ff: // save address for future use
 							{
-								// save address for future use
 								data = *++code;
 								break;
 							}
-							case 0x0000002f:
+							case 0x0000002f: // movw r*,# instruction is replaced
 							{
-								// movw r12,# instruction will be replaced
+								if (!data) // probably, imported object
+								{
+									auto found = vnid_list.find(code.addr());
+									if (found != vnid_list.end())
+									{
+										data = found->second;
+									}
+								}
+
+								if (!data)
+								{
+									LOG_ERROR(LOADER, ".sceRefs: movw writing failed (ref_addr=0x%x, addr=0x%x)", code, code[1]);
+								}
+								else //if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: movw written at 0x%x (ref_addr=0x%x, data=0x%x)", code[1], code, data);
+								}
+
 								const u32 addr = *++code;
-								vm::psv::write16(addr + 0, 0xf240 | (data & 0x800) >> 1 | (data & 0xf000) >> 12); // MOVW
-								vm::psv::write16(addr + 2, 0x0c00 | (data & 0x700) << 4 | (data & 0xff));
-								//LOG_NOTICE(LOADER, "sceRefs: movw written at 0x%x (data=0x%x)", addr, data);
+								vm::psv::write16(addr + 0, vm::psv::read16(addr + 0) | (data & 0x800) >> 1 | (data & 0xf000) >> 12);
+								vm::psv::write16(addr + 2, vm::psv::read16(addr + 2) | (data & 0x700) << 4 | (data & 0xff));
 								break;
 							}
-							case 0x00000030:
+							case 0x00000030: // movt r*,# instruction is replaced
 							{
-								// movt r12,# instruction will be replaced
+								if (!data)
+								{
+									LOG_ERROR(LOADER, ".sceRefs: movt writing failed (ref_addr=0x%x, addr=0x%x)", code, code[1]);
+								}
+								else //if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: movt written at 0x%x (ref_addr=0x%x, data=0x%x)", code[1], code, data);
+								}
+
 								const u32 addr = *++code;
-								vm::psv::write16(addr + 0, 0xf2c0 | (data & 0x8000000) >> 17 | (data & 0xf0000000) >> 28); // MOVT
-								vm::psv::write16(addr + 2, 0x0c00 | (data & 0x7000000) >> 12 | (data & 0xff0000) >> 16);
-								//LOG_NOTICE(LOADER, "sceRefs: movt written at 0x%x (data=0x%x)", addr, data);
+								vm::psv::write16(addr + 0, vm::psv::read16(addr + 0) | (data & 0x8000000) >> 17 | (data & 0xf0000000) >> 28);
+								vm::psv::write16(addr + 2, vm::psv::read16(addr + 2) | (data & 0x7000000) >> 12 | (data & 0xff0000) >> 16);
 								break;
 							}
 							case 0x00000000:
 							{
-								// probably, no operation
-								//LOG_NOTICE(LOADER, "sceRefs: zero code");
+								data = 0;
+
+								if (Ini.HLELogging.GetValue())
+								{
+									LOG_NOTICE(LOADER, ".sceRefs: zero code found");
+								}
 								break;
 							}
 							default:
 							{
-								LOG_ERROR(LOADER, "sceRefs: unknown code found (0x%08x)", *code);
+								LOG_ERROR(LOADER, "Unknown code in .sceRefs section (0x%08x)", *code);
 							}
 							}
 						}

rpcs3/Loader/ELF64.cpp

@@ -356,7 +356,7 @@ namespace loader
 			ppu_thr_stop_data[1] = BLR();
 			Emu.SetCPUThreadStop(ppu_thr_stop_data.addr());
 
-			vm::write64(Memory.PRXMem.AllocAlign(0x10000), 0xDEADBEEFABADCAFE);
+			//vm::write64(Memory.PRXMem.AllocAlign(0x10000), 0xDEADBEEFABADCAFE);
 			/*
 			//TODO
 			static const int branch_size = 6 * 4;

rpcs3/emucore.vcxproj

@@ -58,16 +58,66 @@
     <ClCompile Include="Emu\ARMv7\ARMv7Thread.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\psv_event_flag.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\psv_sema.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceAppMgr.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceAppUtil.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudio.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudiodec.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudioenc.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudioIn.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceCamera.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceCodecEngine.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceCommonDialog.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceCtrl.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceDbg.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceDeci4p.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceDeflt.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceDisplay.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceFiber.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceFios.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceFpu.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceGxm.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceHttp.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceIme.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceJpeg.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceJpegEnc.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceLibKernel.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceLibc.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceLibm.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceLibstdcxx.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceLiveArea.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceLocation.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceMd5.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceMotion.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceMt19937.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNet.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNetCtl.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNgs.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpBasic.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpCommon.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpManager.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpMatching.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpScore.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpUtility.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\scePerf.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\scePgf.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\scePhotoExport.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceRazorCapture.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceRtc.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSas.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceScreenShot.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSfmt.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSha.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSqlite.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSsl.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSulpha.cpp" />
     <ClCompile Include="Emu\ARMv7\Modules\sceSysmodule.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceSystemGesture.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceTouch.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceUlt.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceVideodec.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceVoice.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceVoiceQoS.cpp" />
+    <ClCompile Include="Emu\ARMv7\Modules\sceXml.cpp" />
     <ClCompile Include="Emu\ARMv7\PSVFuncList.cpp" />
     <ClCompile Include="Emu\ARMv7\PSVObjectList.cpp" />
     <ClCompile Include="Emu\Audio\AL\OpenALThread.cpp" />
@@ -286,8 +336,14 @@
     <ClInclude Include="Emu\ARMv7\ARMv7Thread.h" />
     <ClInclude Include="Emu\ARMv7\Modules\psv_event_flag.h" />
     <ClInclude Include="Emu\ARMv7\Modules\psv_sema.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceAppUtil.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceGxm.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceIme.h" />
     <ClInclude Include="Emu\ARMv7\Modules\sceLibKernel.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceNet.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceNpCommon.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceSsl.h" />
+    <ClInclude Include="Emu\ARMv7\Modules\sceTouch.h" />
     <ClInclude Include="Emu\ARMv7\PSVFuncList.h" />
     <ClInclude Include="Emu\ARMv7\PSVObjectList.h" />
     <ClInclude Include="Emu\Audio\AL\OpenALThread.h" />

rpcs3/emucore.vcxproj.filters

@@ -698,6 +698,156 @@
     <ClCompile Include="Emu\ARMv7\Modules\sceGxm.cpp">
       <Filter>Emu\CPU\ARMv7\Modules</Filter>
     </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceAppMgr.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceAppUtil.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudio.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudiodec.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudioenc.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceAudioIn.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceCamera.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceCodecEngine.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceCommonDialog.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceDbg.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceDeflt.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceFiber.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceFios.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceFpu.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceHttp.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceIme.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceJpeg.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceJpegEnc.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceLiveArea.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceLocation.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceMd5.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceMotion.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceMt19937.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNet.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNetCtl.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNgs.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpBasic.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpCommon.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpManager.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpMatching.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpScore.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceNpUtility.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\scePgf.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\scePhotoExport.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceRazorCapture.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceRtc.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSas.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceScreenShot.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSqlite.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSsl.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSulpha.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSystemGesture.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceTouch.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceUlt.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceVideodec.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceVoice.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceVoiceQoS.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceXml.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSfmt.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
+    <ClCompile Include="Emu\ARMv7\Modules\sceSha.cpp">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="Crypto\aes.h">
@@ -1342,5 +1492,23 @@
     <ClInclude Include="Emu\ARMv7\Modules\sceGxm.h">
       <Filter>Emu\CPU\ARMv7\Modules</Filter>
     </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceAppUtil.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceIme.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceNet.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceSsl.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceTouch.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
+    <ClInclude Include="Emu\ARMv7\Modules\sceNpCommon.h">
+      <Filter>Emu\CPU\ARMv7\Modules</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>