add some new modules and functions

GPCS4/Emulator/RegisterModules.cpp

@@ -34,6 +34,7 @@ bool CEmulator::RegisterModules()
 		REGISTER_MODULE(g_ExpModuleSceHttp);
 		REGISTER_MODULE(g_ExpModuleSceIme);
 		REGISTER_MODULE(g_ExpModuleSceInvitationDialog);
+		REGISTER_MODULE(g_ExpModuleSceJobManager);
 		REGISTER_MODULE(g_ExpModuleSceJson);
 		REGISTER_MODULE(g_ExpModuleSceLibc);
 		REGISTER_MODULE(g_ExpModuleSceLibkernel);
@@ -53,6 +54,7 @@ bool CEmulator::RegisterModules()
 		REGISTER_MODULE(g_ExpModuleSceNpWebApi);
 		REGISTER_MODULE(g_ExpModuleScePad);
 		REGISTER_MODULE(g_ExpModuleScePlayGo);
+		REGISTER_MODULE(g_ExpModuleScePlayGoDialog);
 		REGISTER_MODULE(g_ExpModuleSceRtc);
 		REGISTER_MODULE(g_ExpModuleSceRudp);
 		REGISTER_MODULE(g_ExpModuleSceSaveData);

GPCS4/GPCS4.vcxproj

@@ -50,6 +50,7 @@
     <ClInclude Include="SceModules\SceHttp\sce_http.h" />
     <ClInclude Include="SceModules\SceIme\sce_ime.h" />
     <ClInclude Include="SceModules\SceInvitationDialog\sce_invitationdialog.h" />
+    <ClInclude Include="SceModules\SceJobManager\sce_jobmanager.h" />
     <ClInclude Include="SceModules\SceJson\sce_json.h" />
     <ClInclude Include="SceModules\SceLibc\sce_libc.h" />
     <ClInclude Include="SceModules\SceLibkernel\sce_kernel_file.h" />
@@ -71,6 +72,7 @@
     <ClInclude Include="SceModules\SceNpTus\sce_nptus.h" />
     <ClInclude Include="SceModules\SceNpWebApi\sce_npwebapi.h" />
     <ClInclude Include="SceModules\ScePad\sce_pad.h" />
+    <ClInclude Include="SceModules\ScePlayGoDialog\sce_playgodialog.h" />
     <ClInclude Include="SceModules\ScePlayGo\sce_playgo.h" />
     <ClInclude Include="SceModules\SceRtc\sce_rtc.h" />
     <ClInclude Include="SceModules\SceRudp\sce_rudp.h" />
@@ -129,6 +131,8 @@
     <ClCompile Include="SceModules\SceIme\sce_ime_export.cpp" />
     <ClCompile Include="SceModules\SceInvitationDialog\sce_invitationdialog.cpp" />
     <ClCompile Include="SceModules\SceInvitationDialog\sce_invitationdialog_export.cpp" />
+    <ClCompile Include="SceModules\SceJobManager\sce_jobmanager.cpp" />
+    <ClCompile Include="SceModules\SceJobManager\sce_jobmanager_export.cpp" />
     <ClCompile Include="SceModules\SceJson\sce_json.cpp" />
     <ClCompile Include="SceModules\SceJson\sce_json_export.cpp" />
     <ClCompile Include="SceModules\SceLibc\sce_libc.cpp" />
@@ -180,6 +184,8 @@
     <ClCompile Include="SceModules\SceNpWebApi\sce_npwebapi_export.cpp" />
     <ClCompile Include="SceModules\ScePad\sce_pad.cpp" />
     <ClCompile Include="SceModules\ScePad\sce_pad_export.cpp" />
+    <ClCompile Include="SceModules\ScePlayGoDialog\sce_playgodialog.cpp" />
+    <ClCompile Include="SceModules\ScePlayGoDialog\sce_playgodialog_export.cpp" />
     <ClCompile Include="SceModules\ScePlayGo\sce_playgo.cpp" />
     <ClCompile Include="SceModules\ScePlayGo\sce_playgo_export.cpp" />
     <ClCompile Include="SceModules\SceRtc\sce_rtc.cpp" />

GPCS4/GPCS4.vcxproj.filters

@@ -149,6 +149,12 @@
     <Filter Include="SceModules\SceAjm">
       <UniqueIdentifier>{f6b61ba3-f586-418a-9c5d-725446043ca6}</UniqueIdentifier>
     </Filter>
+    <Filter Include="SceModules\ScePlayGoDialog">
+      <UniqueIdentifier>{9207d33e-e4ec-4b6c-94c9-d27a7b08e5c3}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="SceModules\SceJobManager">
+      <UniqueIdentifier>{569e8466-32c7-451b-ba57-e408f98537b5}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="SceModules\SceLibc\sce_libc.h">
@@ -358,6 +364,12 @@
     <ClInclude Include="SceModules\SceLibkernel\sce_kernel_file.h">
       <Filter>SceModules\SceLibkernel</Filter>
     </ClInclude>
+    <ClInclude Include="SceModules\ScePlayGoDialog\sce_playgodialog.h">
+      <Filter>SceModules\ScePlayGoDialog</Filter>
+    </ClInclude>
+    <ClInclude Include="SceModules\SceJobManager\sce_jobmanager.h">
+      <Filter>SceModules\SceJobManager</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Loader\EbootObject.cpp">
@@ -693,6 +705,18 @@
     <ClCompile Include="SceModules\SceLibkernel\sce_kernel_file.cpp">
       <Filter>SceModules\SceLibkernel</Filter>
     </ClCompile>
+    <ClCompile Include="SceModules\ScePlayGoDialog\sce_playgodialog.cpp">
+      <Filter>SceModules\ScePlayGoDialog</Filter>
+    </ClCompile>
+    <ClCompile Include="SceModules\ScePlayGoDialog\sce_playgodialog_export.cpp">
+      <Filter>SceModules\ScePlayGoDialog</Filter>
+    </ClCompile>
+    <ClCompile Include="SceModules\SceJobManager\sce_jobmanager.cpp">
+      <Filter>SceModules\SceJobManager</Filter>
+    </ClCompile>
+    <ClCompile Include="SceModules\SceJobManager\sce_jobmanager_export.cpp">
+      <Filter>SceModules\SceJobManager</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <MASM Include="SceModules\SceLibc\sce_libc_string_asm.asm">

GPCS4/SceModules/SceFiber/sce_fiber.cpp

@@ -45,6 +45,12 @@ int PS4API sceFiberSwitch(void)
 	return SCE_OK;
 }
 
+int PS4API sceFiberGetSelf(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
 
 
 

GPCS4/SceModules/SceFiber/sce_fiber.h

@@ -40,5 +40,8 @@ int PS4API sceFiberRun(void);
 int PS4API sceFiberSwitch(void);
 
 
+int PS4API sceFiberGetSelf(void);
+
+
 
 

GPCS4/SceModules/SceFiber/sce_fiber_export.cpp

@@ -13,6 +13,7 @@ static const SCE_EXPORT_FUNCTION g_pSceFiber_libSceFiber_FunctionTable[] =
 	{ 0x074657DA1C7D0CCC, "sceFiberReturnToThread", (void*)sceFiberReturnToThread },
 	{ 0x6B42CBAD959A7343, "sceFiberRun", (void*)sceFiberRun },
 	{ 0x3C54F64BFB49ED49, "sceFiberSwitch", (void*)sceFiberSwitch },
+	{ 0xA7ECCB20E836EF35, "sceFiberGetSelf", (void*)sceFiberGetSelf },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceGnmDriver/sce_gnmdriver.cpp

@@ -606,5 +606,34 @@ int PS4API sceRazorIsLoaded(void)
 }
 
 
+int PS4API _import_75EC17C39AE82ECD(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceGnmComputeWaitOnAddress(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceGnmComputeWaitSemaphore(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceGnmLogicalTcaUnitToPhysical(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+
 
 

GPCS4/SceModules/SceGnmDriver/sce_gnmdriver.h

@@ -280,5 +280,17 @@ int PS4API sceRazorCaptureImmediate(void);
 int PS4API sceRazorIsLoaded(void);
 
 
+int PS4API _import_75EC17C39AE82ECD(void);
+
+
+int PS4API sceGnmComputeWaitOnAddress(void);
+
+
+int PS4API sceGnmComputeWaitSemaphore(void);
+
+
+int PS4API sceGnmLogicalTcaUnitToPhysical(void);
+
+
 
 

GPCS4/SceModules/SceGnmDriver/sce_gnmdriver_export.cpp

@@ -93,6 +93,10 @@ static const SCE_EXPORT_FUNCTION g_pSceGnmDriver_libSceGnmDriver_FunctionTable[]
 	{ 0x577D55D3552249C6, "sceGnmUpdateVsShader", (void*)sceGnmUpdateVsShader },
 	{ 0xBBD60AA514477BF3, "sceRazorCaptureImmediate", (void*)sceRazorCaptureImmediate },
 	{ 0x7F7DCEAEBB9061B3, "sceRazorIsLoaded", (void*)sceRazorIsLoaded },
+	{ 0x75EC17C39AE82ECD, "_import_75EC17C39AE82ECD", (void*)_import_75EC17C39AE82ECD },
+	{ 0x7DFACD40EB21A30B, "sceGnmComputeWaitOnAddress", (void*)sceGnmComputeWaitOnAddress },
+	{ 0x1096A9365DBEA605, "sceGnmComputeWaitSemaphore", (void*)sceGnmComputeWaitSemaphore },
+	{ 0x2A5D19DCB1F4ED02, "sceGnmLogicalTcaUnitToPhysical", (void*)sceGnmLogicalTcaUnitToPhysical },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceHttp/sce_http.cpp

@@ -25,5 +25,136 @@ int PS4API sceHttpTerm(void)
 }
 
 
+int PS4API sceHttpAddRequestHeader(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpCreateConnectionWithURL(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpCreateRequestWithURL(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpCreateTemplate(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpDeleteConnection(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpDeleteRequest(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpDeleteTemplate(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpGetResponseContentLength(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpGetStatusCode(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpReadData(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSendRequest(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSetConnectTimeOut(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSetRecvTimeOut(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSetRequestContentLength(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSetResolveRetry(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSetResolveTimeOut(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpSetSendTimeOut(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceHttpUriEscape(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+
+
+
+
+
 
 

GPCS4/SceModules/SceHttp/sce_http.h

@@ -31,5 +31,59 @@ int PS4API sceHttpInit(void);
 int PS4API sceHttpTerm(void);
 
 
+int PS4API sceHttpAddRequestHeader(void);
+
+
+int PS4API sceHttpCreateConnectionWithURL(void);
+
+
+int PS4API sceHttpCreateRequestWithURL(void);
+
+
+int PS4API sceHttpCreateTemplate(void);
+
+
+int PS4API sceHttpDeleteConnection(void);
+
+
+int PS4API sceHttpDeleteRequest(void);
+
+
+int PS4API sceHttpDeleteTemplate(void);
+
+
+int PS4API sceHttpGetResponseContentLength(void);
+
+
+int PS4API sceHttpGetStatusCode(void);
+
+
+int PS4API sceHttpReadData(void);
+
+
+int PS4API sceHttpSendRequest(void);
+
+
+int PS4API sceHttpSetConnectTimeOut(void);
+
+
+int PS4API sceHttpSetRecvTimeOut(void);
+
+
+int PS4API sceHttpSetRequestContentLength(void);
+
+
+int PS4API sceHttpSetResolveRetry(void);
+
+
+int PS4API sceHttpSetResolveTimeOut(void);
+
+
+int PS4API sceHttpSetSendTimeOut(void);
+
+
+int PS4API sceHttpUriEscape(void);
+
+
 
 

GPCS4/SceModules/SceHttp/sce_http_export.cpp

@@ -10,6 +10,24 @@ static const SCE_EXPORT_FUNCTION g_pSceHttp_libSceHttp_FunctionTable[] =
 {
 	{ 0x03D715314B44A786, "sceHttpInit", (void*)sceHttpInit },
 	{ 0x224FCAA4B4E57FB4, "sceHttpTerm", (void*)sceHttpTerm },
+	{ 0x118DBC4F66E437B9, "sceHttpAddRequestHeader", (void*)sceHttpAddRequestHeader },
+	{ 0xAA0C43063A2B531B, "sceHttpCreateConnectionWithURL", (void*)sceHttpCreateConnectionWithURL },
+	{ 0x01EBB9C152A417DC, "sceHttpCreateRequestWithURL", (void*)sceHttpCreateRequestWithURL },
+	{ 0xD206233D347FE9C6, "sceHttpCreateTemplate", (void*)sceHttpCreateTemplate },
+	{ 0x3FA037CADA6C8987, "sceHttpDeleteConnection", (void*)sceHttpDeleteConnection },
+	{ 0xA9EEE867EBF83D60, "sceHttpDeleteRequest", (void*)sceHttpDeleteRequest },
+	{ 0xE08F2F129B84859F, "sceHttpDeleteTemplate", (void*)sceHttpDeleteTemplate },
+	{ 0xCAE3B61F652F9E8B, "sceHttpGetResponseContentLength", (void*)sceHttpGetResponseContentLength },
+	{ 0xD1AD9304D7C4DC15, "sceHttpGetStatusCode", (void*)sceHttpGetStatusCode },
+	{ 0x3F9A5DA3290F6139, "sceHttpReadData", (void*)sceHttpReadData },
+	{ 0xD5ED8137023F5F31, "sceHttpSendRequest", (void*)sceHttpSendRequest },
+	{ 0xD12F6D4C7D2EA935, "sceHttpSetConnectTimeOut", (void*)sceHttpSetConnectTimeOut },
+	{ 0xCA282BE15D3F1D33, "sceHttpSetRecvTimeOut", (void*)sceHttpSetRecvTimeOut },
+	{ 0x3D3885214C42A497, "sceHttpSetRequestContentLength", (void*)sceHttpSetRequestContentLength },
+	{ 0x2B57752EA6514074, "sceHttpSetResolveRetry", (void*)sceHttpSetResolveRetry },
+	{ 0x4DCFE10180CAB507, "sceHttpSetResolveTimeOut", (void*)sceHttpSetResolveTimeOut },
+	{ 0xC5E8057D9281565C, "sceHttpSetSendTimeOut", (void*)sceHttpSetSendTimeOut },
+	{ 0x62E396DDD0C02987, "sceHttpUriEscape", (void*)sceHttpUriEscape },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceJobManager/sce_jobmanager.cpp

@@ -0,0 +1,64 @@
+#include "sce_jobmanager.h"
+
+
+// Note:
+// The codebase is generated using GenerateCode.py
+// You may need to modify the code manually to fit development needs
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// library: libSceJobManager
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API _import_192F4349BCC2F8C6(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _import_366D81840C183459(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _import_55329ECDF62EFEFE(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _import_5BFC9781099AA335(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _import_721C67BECC717C16(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _import_730333CDD7AC2E56(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _import_E20D5E7B7E13307F(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+
+

GPCS4/SceModules/SceJobManager/sce_jobmanager.h

@@ -0,0 +1,50 @@
+/*
+ *    GPCS4
+ *    
+ *    This file implements:
+ *    module: libSceJobManager
+ *        library: libSceJobManager
+ *    
+ */
+
+#pragma once
+
+#include "sce_module_common.h"
+
+
+extern const SCE_EXPORT_MODULE g_ExpModuleSceJobManager;
+
+
+// Note:
+// The codebase is generated using GenerateCode.py
+// You may need to modify the code manually to fit development needs
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// library: libSceJobManager
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API _import_192F4349BCC2F8C6(void);
+
+
+int PS4API _import_366D81840C183459(void);
+
+
+int PS4API _import_55329ECDF62EFEFE(void);
+
+
+int PS4API _import_5BFC9781099AA335(void);
+
+
+int PS4API _import_721C67BECC717C16(void);
+
+
+int PS4API _import_730333CDD7AC2E56(void);
+
+
+int PS4API _import_E20D5E7B7E13307F(void);
+
+
+
+

GPCS4/SceModules/SceJobManager/sce_jobmanager_export.cpp

@@ -0,0 +1,33 @@
+#include "sce_jobmanager.h"
+
+
+// Note:
+// The codebase is generated using GenerateCode.py
+// You may need to modify the code manually to fit development needs
+
+
+static const SCE_EXPORT_FUNCTION g_pSceJobManager_libSceJobManager_FunctionTable[] =
+{
+	{ 0x192F4349BCC2F8C6, "_import_192F4349BCC2F8C6", (void*)_import_192F4349BCC2F8C6 },
+	{ 0x366D81840C183459, "_import_366D81840C183459", (void*)_import_366D81840C183459 },
+	{ 0x55329ECDF62EFEFE, "_import_55329ECDF62EFEFE", (void*)_import_55329ECDF62EFEFE },
+	{ 0x5BFC9781099AA335, "_import_5BFC9781099AA335", (void*)_import_5BFC9781099AA335 },
+	{ 0x721C67BECC717C16, "_import_721C67BECC717C16", (void*)_import_721C67BECC717C16 },
+	{ 0x730333CDD7AC2E56, "_import_730333CDD7AC2E56", (void*)_import_730333CDD7AC2E56 },
+	{ 0xE20D5E7B7E13307F, "_import_E20D5E7B7E13307F", (void*)_import_E20D5E7B7E13307F },
+	SCE_FUNCTION_ENTRY_END
+};
+
+static const SCE_EXPORT_LIBRARY g_pSceJobManager_LibTable[] =
+{
+	{ "libSceJobManager", g_pSceJobManager_libSceJobManager_FunctionTable },
+	SCE_LIBRARY_ENTRY_END
+};
+
+const SCE_EXPORT_MODULE g_ExpModuleSceJobManager =
+{
+	"libSceJobManager",
+	g_pSceJobManager_LibTable
+};
+
+

GPCS4/SceModules/SceLibc/sce_libc.cpp

@@ -148,7 +148,204 @@ int PS4API scec_longjmp(void)
 }
 
 
+int PS4API scec__Stdin(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec__ZSt11_Xbad_allocv(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec__ZSt7nothrow(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_ferror(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_fflush(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_fgets(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_freopen(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_getc(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_localeconv(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_localtime(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_mbstowcs(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_memalign(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_reallocalign(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_scalbn(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_scalbnf(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_set_constraint_handler_s(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_setvbuf(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_snprintf_s(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_srand(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_strcoll(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_strdup(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_strerror(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_strpbrk(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_strspn(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_wcsncpy(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scec_wcstombs(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 
 
 
+//////////////////////////////////////////////////////////////////////////
+// library: libc_setjmp
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API _longjmp(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API _setjmp(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
 

GPCS4/SceModules/SceLibc/sce_libc.h

@@ -328,7 +328,66 @@ int PS4API scec_wcsstr(void);
 
 int PS4API scec_wcstombs_s(void);
 
+int PS4API scec__Stdin(void);
+
+int PS4API scec__ZSt11_Xbad_allocv(void);
+
+int PS4API scec__ZSt7nothrow(void);
+
+int PS4API scec_ferror(void);
+
+int PS4API scec_fflush(void);
+
+int PS4API scec_fgets(void);
+
+int PS4API scec_freopen(void);
+
+int PS4API scec_getc(void);
+
+int PS4API scec_localeconv(void);
+
+int PS4API scec_localtime(void);
+
+int PS4API scec_mbstowcs(void);
+
+int PS4API scec_memalign(void);
+
+int PS4API scec_reallocalign(void);
+
+int PS4API scec_scalbn(void);
+
+int PS4API scec_scalbnf(void);
+
+int PS4API scec_set_constraint_handler_s(void);
+
+int PS4API scec_setvbuf(void);
+
+int PS4API scec_snprintf_s(void);
+
+int PS4API scec_srand(void);
+
+int PS4API scec_strcoll(void);
+
+int PS4API scec_strdup(void);
+
+int PS4API scec_strerror(void);
+
+int PS4API scec_strpbrk(void);
+
+int PS4API scec_strspn(void);
+
+int PS4API scec_wcsncpy(void);
+
+int PS4API scec_wcstombs(void);
 
 
 
+//////////////////////////////////////////////////////////////////////////
+// library: libc_setjmp
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API _longjmp(void);
+
+
+int PS4API _setjmp(void);
 

GPCS4/SceModules/SceLibc/sce_libc_export.cpp

@@ -157,12 +157,46 @@ static const SCE_EXPORT_FUNCTION g_pSceLibc_libc_FunctionTable[] =
 	{ 0xB0E38C959A32D698, "wcsrtombs", (void*)scec_wcsrtombs },
 	{ 0x583A686E322601BE, "wcsstr", (void*)scec_wcsstr },
 	{ 0xB192EB8F1FF2131E, "wcstombs_s", (void*)scec_wcstombs_s },
+	{ 0xD530E8FC89AA9097, "_Stdin", (void*)scec__Stdin },
+	{ 0x793D94B264DEC1B5, "_ZSt11_Xbad_allocv", (void*)scec__ZSt11_Xbad_allocv },
+	{ 0x34BC09DEAFBAE1B6, "_ZSt7nothrow", (void*)scec__ZSt7nothrow },
+	{ 0x007C7284DF7A772E, "ferror", (void*)scec_ferror },
+	{ 0x3148C2E256C7ACAE, "fflush", (void*)scec_fflush },
+	{ 0x29D3FF9D42E9B86C, "fgets", (void*)scec_fgets },
+	{ 0x8245A09F4A7501F5, "freopen", (void*)scec_freopen },
+	{ 0xF10EB424B27A46FE, "getc", (void*)scec_getc },
+	{ 0xD2195F5B53B801AE, "localeconv", (void*)scec_localeconv },
+	{ 0x79F84AFD84946184, "localtime", (void*)scec_localtime },
+	{ 0x554CE35E49CF3C1B, "mbstowcs", (void*)scec_mbstowcs },
+	{ 0x5237F72B332F4662, "memalign", (void*)scec_memalign },
+	{ 0x386C9B56E3C08406, "reallocalign", (void*)scec_reallocalign },
+	{ 0x28628179572A2637, "scalbn", (void*)scec_scalbn },
+	{ 0xF5FB356ED7CBA14B, "scalbnf", (void*)scec_scalbnf },
+	{ 0x10D2DF2891194E31, "set_constraint_handler_s", (void*)scec_set_constraint_handler_s },
+	{ 0x40C1722E8A8DC488, "setvbuf", (void*)scec_setvbuf },
+	{ 0xDC1CAD3CE42054A7, "snprintf_s", (void*)scec_snprintf_s },
+	{ 0x54F6C9C130A0304D, "srand", (void*)scec_srand },
+	{ 0x8236E66293FF5C94, "strcoll", (void*)scec_strcoll },
+	{ 0x83BCF3CCB0D81B0D, "strdup", (void*)scec_strdup },
+	{ 0x4486BA1A75A9FA25, "strerror", (void*)scec_strerror },
+	{ 0x90366FA15B2C0A04, "strpbrk", (void*)scec_strpbrk },
+	{ 0xFE453A6C1E0CFFE9, "strspn", (void*)scec_strspn },
+	{ 0xD27576D498D8087F, "wcsncpy", (void*)scec_wcsncpy },
+	{ 0xBFB4BB2E13F63897, "wcstombs", (void*)scec_wcstombs },
+	SCE_FUNCTION_ENTRY_END
+};
+
+static const SCE_EXPORT_FUNCTION g_pSceLibc_libc_setjmp_FunctionTable[] =
+{
+	{ 0xF85FBD8618BA93D4, "_longjmp", (void*)_longjmp },
+	{ 0xB23A64AE1BA0BD52, "_setjmp", (void*)_setjmp },
 	SCE_FUNCTION_ENTRY_END
 };
 
 static const SCE_EXPORT_LIBRARY g_pSceLibc_LibTable[] =
 {
 	{ "libc", g_pSceLibc_libc_FunctionTable },
+	{ "libc_setjmp", g_pSceLibc_libc_setjmp_FunctionTable },
 	SCE_LIBRARY_ENTRY_END
 };
 

GPCS4/SceModules/SceLibkernel/sce_libkernel.cpp

@@ -189,6 +189,240 @@ int PS4API sceKernelWaitSema(void)
 }
 
 
+int PS4API sceKernelBatchMap(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelCheckedReleaseDirectMemory(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelDlsym(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelGetDirectMemoryType(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelGetGPI(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelGetPageTableStats(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelGettimeofday(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelIsStack(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelLoadStartModule(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelMapNamedDirectMemory(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelMapNamedFlexibleMemory(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelMprotect(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelMtypeprotect(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelMunmap(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelQueryMemoryProtection(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelReserveVirtualRange(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelSetPrtAperture(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelSetVirtualRangeName(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelUuidCreate(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceKernelVirtualQuery(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadCancel(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadDetach(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadGetname(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadGetschedparam(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadGetspecific(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadKeyCreate(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadMutexTimedlock(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadMutexTrylock(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadSetschedparam(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePthreadSetspecific(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// library: libSceCoredump
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API sceCoredumpAttachMemoryRegion(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceCoredumpRegisterCoredumpHandler(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceCoredumpWriteUserData(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -231,5 +465,91 @@ int PS4API scek_usleep(void)
 }
 
 
+int PS4API scek_close(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_connect(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_pthread_setschedparam(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_recv(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_select(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_sem_destroy(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_sem_init(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_sem_post(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_sem_timedwait(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_sem_wait(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_send(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scek_shutdown(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+
+
 
 

GPCS4/SceModules/SceLibkernel/sce_libkernel.h

@@ -279,6 +279,109 @@ int PS4API scePthreadSetprio(void);
 int PS4API scePthreadYield(void);
 
 
+int PS4API sceKernelBatchMap(void);
+
+
+int PS4API sceKernelCheckedReleaseDirectMemory(void);
+
+
+int PS4API sceKernelDlsym(void);
+
+
+int PS4API sceKernelGetDirectMemoryType(void);
+
+
+int PS4API sceKernelGetGPI(void);
+
+
+int PS4API sceKernelGetPageTableStats(void);
+
+
+int PS4API sceKernelGettimeofday(void);
+
+
+int PS4API sceKernelIsStack(void);
+
+
+int PS4API sceKernelLoadStartModule(void);
+
+
+int PS4API sceKernelMapNamedDirectMemory(void);
+
+
+int PS4API sceKernelMapNamedFlexibleMemory(void);
+
+
+int PS4API sceKernelMprotect(void);
+
+
+int PS4API sceKernelMtypeprotect(void);
+
+
+int PS4API sceKernelMunmap(void);
+
+
+int PS4API sceKernelQueryMemoryProtection(void);
+
+
+int PS4API sceKernelReserveVirtualRange(void);
+
+
+int PS4API sceKernelSetPrtAperture(void);
+
+
+int PS4API sceKernelSetVirtualRangeName(void);
+
+
+int PS4API sceKernelUuidCreate(void);
+
+
+int PS4API sceKernelVirtualQuery(void);
+
+
+int PS4API scePthreadCancel(void);
+
+
+int PS4API scePthreadDetach(void);
+
+
+int PS4API scePthreadGetname(void);
+
+
+int PS4API scePthreadGetschedparam(void);
+
+
+int PS4API scePthreadGetspecific(void);
+
+
+int PS4API scePthreadKeyCreate(void);
+
+
+int PS4API scePthreadMutexTimedlock(void);
+
+
+int PS4API scePthreadMutexTrylock(void);
+
+
+int PS4API scePthreadSetschedparam(void);
+
+
+int PS4API scePthreadSetspecific(void);
+
+
+//////////////////////////////////////////////////////////////////////////
+// library: libSceCoredump
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API sceCoredumpAttachMemoryRegion(void);
+
+
+int PS4API sceCoredumpRegisterCoredumpHandler(void);
+
+
+int PS4API sceCoredumpWriteUserData(void);
+
+
 
 
 //////////////////////////////////////////////////////////////////////////
@@ -348,6 +451,42 @@ int PS4API scek_sched_yield(void);
 int PS4API scek_usleep(void);
 
 
+int PS4API scek_close(void);
+
+
+int PS4API scek_connect(void);
+
+
+int PS4API scek_pthread_setschedparam(void);
+
+
+int PS4API scek_recv(void);
+
+
+int PS4API scek_select(void);
+
+
+int PS4API scek_sem_destroy(void);
+
+
+int PS4API scek_sem_init(void);
+
+
+int PS4API scek_sem_post(void);
+
+
+int PS4API scek_sem_timedwait(void);
+
+
+int PS4API scek_sem_wait(void);
+
+
+int PS4API scek_send(void);
+
+
+int PS4API scek_shutdown(void);
+
+
 
 
 

GPCS4/SceModules/SceLibkernel/sce_libkernel_export.cpp

@@ -92,6 +92,44 @@ static const SCE_EXPORT_FUNCTION g_pSceLibkernel_libkernel_FunctionTable[] =
 	{ 0x6EDDC24C12A61B22, "scePthreadSetaffinity", (void*)scePthreadSetaffinity },
 	{ 0x5B41E99B65F4B8F1, "scePthreadSetprio", (void*)scePthreadSetprio },
 	{ 0x4FBDA1CFA7DFAB4F, "scePthreadYield", (void*)scePthreadYield },
+	{ 0xD92284C7A6D2ABFE, "sceKernelBatchMap", (void*)sceKernelBatchMap },
+	{ 0x8705523C29A9E6D3, "sceKernelCheckedReleaseDirectMemory", (void*)sceKernelCheckedReleaseDirectMemory },
+	{ 0x2F01BC8379E2AB00, "sceKernelDlsym", (void*)sceKernelDlsym },
+	{ 0x042F8E1B99BDF9BC, "sceKernelGetDirectMemoryType", (void*)sceKernelGetDirectMemoryType },
+	{ 0xE285D87BD5E69344, "sceKernelGetGPI", (void*)sceKernelGetGPI },
+	{ 0xB59DB2A6563C3016, "sceKernelGetPageTableStats", (void*)sceKernelGetPageTableStats },
+	{ 0x7A37A471A35036AD, "sceKernelGettimeofday", (void*)sceKernelGettimeofday },
+	{ 0xC83070540A250E08, "sceKernelIsStack", (void*)sceKernelIsStack },
+	{ 0xC33BEA4F852A297F, "sceKernelLoadStartModule", (void*)sceKernelLoadStartModule },
+	{ 0x35C6965317CC3484, "sceKernelMapNamedDirectMemory", (void*)sceKernelMapNamedDirectMemory },
+	{ 0x98BF0D0C7F3A8902, "sceKernelMapNamedFlexibleMemory", (void*)sceKernelMapNamedFlexibleMemory },
+	{ 0xBD23009B77316136, "sceKernelMprotect", (void*)sceKernelMprotect },
+	{ 0xF5B7DD2C8CAEC026, "sceKernelMtypeprotect", (void*)sceKernelMtypeprotect },
+	{ 0x71091EF54B8140E9, "sceKernelMunmap", (void*)sceKernelMunmap },
+	{ 0x58571F2F697389DA, "sceKernelQueryMemoryProtection", (void*)sceKernelQueryMemoryProtection },
+	{ 0xEE8C6FDCF3C2BA6A, "sceKernelReserveVirtualRange", (void*)sceKernelReserveVirtualRange },
+	{ 0x068858AFF17BFE2B, "sceKernelSetPrtAperture", (void*)sceKernelSetPrtAperture },
+	{ 0x0C6306DC9B21AD95, "sceKernelSetVirtualRangeName", (void*)sceKernelSetVirtualRangeName },
+	{ 0x5E3A28B22C3E5CF2, "sceKernelUuidCreate", (void*)sceKernelUuidCreate },
+	{ 0xAD58D1BC72745FA7, "sceKernelVirtualQuery", (void*)sceKernelVirtualQuery },
+	{ 0xA810E6A42C86B2C1, "scePthreadCancel", (void*)scePthreadCancel },
+	{ 0xE2A1AB47A7A83FD6, "scePthreadDetach", (void*)scePthreadDetach },
+	{ 0x1E8C3B07C39EB7A9, "scePthreadGetname", (void*)scePthreadGetname },
+	{ 0x3F8D644D6512DC42, "scePthreadGetschedparam", (void*)scePthreadGetschedparam },
+	{ 0x7A886DEE640E0A6A, "scePthreadGetspecific", (void*)scePthreadGetspecific },
+	{ 0x81E0DAAA01FD9538, "scePthreadKeyCreate", (void*)scePthreadKeyCreate },
+	{ 0x21A7C8D8FC5C3E74, "scePthreadMutexTimedlock", (void*)scePthreadMutexTimedlock },
+	{ 0xBA9A15AF330715E1, "scePthreadMutexTrylock", (void*)scePthreadMutexTrylock },
+	{ 0xA084454E3A082DB8, "scePthreadSetschedparam", (void*)scePthreadSetschedparam },
+	{ 0xF81CD7624A9878B1, "scePthreadSetspecific", (void*)scePthreadSetspecific },
+	SCE_FUNCTION_ENTRY_END
+};
+
+static const SCE_EXPORT_FUNCTION g_pSceLibkernel_libSceCoredump_FunctionTable[] =
+{
+	{ 0xF985F4CFF19448DC, "sceCoredumpAttachMemoryRegion", (void*)sceCoredumpAttachMemoryRegion },
+	{ 0xF332D27C47D6E405, "sceCoredumpRegisterCoredumpHandler", (void*)sceCoredumpRegisterCoredumpHandler },
+	{ 0x0DB6E48FA60759DA, "sceCoredumpWriteUserData", (void*)sceCoredumpWriteUserData },
 	SCE_FUNCTION_ENTRY_END
 };
 
@@ -118,12 +156,25 @@ static const SCE_EXPORT_FUNCTION g_pSceLibkernel_libScePosix_FunctionTable[] =
 	{ 0x128B51F1ADC049FE, "pthread_self", (void*)scek_pthread_self },
 	{ 0xE971B8077DCDD3D8, "sched_yield", (void*)scek_sched_yield },
 	{ 0x41CB5E4706EC9D5D, "usleep", (void*)scek_usleep },
+	{ 0x6D8FCF3BA261CE14, "close", (void*)scek_close },
+	{ 0x5D52FC4A8DD02549, "connect", (void*)scek_connect },
+	{ 0x5ECF617620FBB000, "pthread_setschedparam", (void*)scek_pthread_setschedparam },
+	{ 0x133F318E8F541781, "recv", (void*)scek_recv },
+	{ 0x4FC7C447EB481A09, "select", (void*)scek_select },
+	{ 0x7035B6DF7440C16A, "sem_destroy", (void*)scek_sem_destroy },
+	{ 0xA43B8F11FDE6E1F2, "sem_init", (void*)scek_sem_init },
+	{ 0x20A3FCB72A744149, "sem_post", (void*)scek_sem_post },
+	{ 0xC39207CAF6A183FA, "sem_timedwait", (void*)scek_sem_timedwait },
+	{ 0x602579746181702A, "sem_wait", (void*)scek_sem_wait },
+	{ 0x7D939E64838498BC, "send", (void*)scek_send },
+	{ 0x4D4BA2612DA413CB, "shutdown", (void*)scek_shutdown },
 	SCE_FUNCTION_ENTRY_END
 };
 
 static const SCE_EXPORT_LIBRARY g_pSceLibkernel_LibTable[] =
 {
 	{ "libkernel", g_pSceLibkernel_libkernel_FunctionTable },
+	{ "libSceCoredump", g_pSceLibkernel_libSceCoredump_FunctionTable },
 	{ "libScePosix", g_pSceLibkernel_libScePosix_FunctionTable },
 	SCE_LIBRARY_ENTRY_END
 };

GPCS4/SceModules/SceNet/sce_net.cpp

@@ -200,5 +200,33 @@ int PS4API sceNetTerm(void)
 }
 
 
+int PS4API sceNetGetMacAddress(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNetResolverCreate(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNetResolverDestroy(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNetResolverStartNtoa(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
 
 

GPCS4/SceModules/SceNet/sce_net.h

@@ -106,5 +106,17 @@ int PS4API sceNetSocketClose(void);
 int PS4API sceNetTerm(void);
 
 
+int PS4API sceNetGetMacAddress(void);
+
+
+int PS4API sceNetResolverCreate(void);
+
+
+int PS4API sceNetResolverDestroy(void);
+
+
+int PS4API sceNetResolverStartNtoa(void);
+
+
 
 

GPCS4/SceModules/SceNet/sce_net_export.cpp

@@ -35,6 +35,10 @@ static const SCE_EXPORT_FUNCTION g_pSceNet_libSceNet_FunctionTable[] =
 	{ 0xCC919FF318C59D01, "sceNetSocketAbort", (void*)sceNetSocketAbort },
 	{ 0xE398201336A43C94, "sceNetSocketClose", (void*)sceNetSocketClose },
 	{ 0x7131A473AFD30652, "sceNetTerm", (void*)sceNetTerm },
+	{ 0xE8E7346CBB0861ED, "sceNetGetMacAddress", (void*)sceNetGetMacAddress },
+	{ 0x0B85200C71CFBDDC, "sceNetResolverCreate", (void*)sceNetResolverCreate },
+	{ 0x9099581F9B8C0162, "sceNetResolverDestroy", (void*)sceNetResolverDestroy },
+	{ 0x35DF7559A5A61B6C, "sceNetResolverStartNtoa", (void*)sceNetResolverStartNtoa },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceNetCtl/sce_netctl.cpp

@@ -39,5 +39,12 @@ int PS4API sceNetCtlUnregisterCallback(void)
 }
 
 
+int PS4API sceNetCtlGetInfo(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
 
 

GPCS4/SceModules/SceNetCtl/sce_netctl.h

@@ -37,5 +37,8 @@ int PS4API sceNetCtlRegisterCallback(void);
 int PS4API sceNetCtlUnregisterCallback(void);
 
 
+int PS4API sceNetCtlGetInfo(void);
+
+
 
 

GPCS4/SceModules/SceNetCtl/sce_netctl_export.cpp

@@ -12,6 +12,7 @@ static const SCE_EXPORT_FUNCTION g_pSceNetCtl_libSceNetCtl_FunctionTable[] =
 	{ 0xD1C06076E3D147E3, "sceNetCtlGetResult", (void*)sceNetCtlGetResult },
 	{ 0x509F99ED0FB8724D, "sceNetCtlRegisterCallback", (void*)sceNetCtlRegisterCallback },
 	{ 0x46A9B63A764C0B3D, "sceNetCtlUnregisterCallback", (void*)sceNetCtlUnregisterCallback },
+	{ 0xA1BBB17538B0905F, "sceNetCtlGetInfo", (void*)sceNetCtlGetInfo },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceNpManager/sce_npmanager.cpp

@@ -144,5 +144,40 @@ int PS4API sceNpUnregisterStateCallback(void)
 }
 
 
+int PS4API sceNpCreateRequest(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNpGetAccountCountryA(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNpGetAccountDateOfBirthA(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNpGetAccountIdA(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceNpGetAccountLanguageA(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
 
 

GPCS4/SceModules/SceNpManager/sce_npmanager.h

@@ -82,5 +82,20 @@ int PS4API sceNpUnregisterPlusEventCallback(void);
 int PS4API sceNpUnregisterStateCallback(void);
 
 
+int PS4API sceNpCreateRequest(void);
+
+
+int PS4API sceNpGetAccountCountryA(void);
+
+
+int PS4API sceNpGetAccountDateOfBirthA(void);
+
+
+int PS4API sceNpGetAccountIdA(void);
+
+
+int PS4API sceNpGetAccountLanguageA(void);
+
+
 
 

GPCS4/SceModules/SceNpManager/sce_npmanager_export.cpp

@@ -27,6 +27,11 @@ static const SCE_EXPORT_FUNCTION g_pSceNpManager_libSceNpManager_FunctionTable[]
 	{ 0x71120B004BE7FBD3, "sceNpUnregisterNpReachabilityStateCallback", (void*)sceNpUnregisterNpReachabilityStateCallback },
 	{ 0xC558AA25D0E02A5D, "sceNpUnregisterPlusEventCallback", (void*)sceNpUnregisterPlusEventCallback },
 	{ 0x9A38D35E1F8D1D66, "sceNpUnregisterStateCallback", (void*)sceNpUnregisterStateCallback },
+	{ 0x1A92D00CD28809A7, "sceNpCreateRequest", (void*)sceNpCreateRequest },
+	{ 0x253FADD346B74F10, "sceNpGetAccountCountryA", (void*)sceNpGetAccountCountryA },
+	{ 0xAB733B5F304A0B7B, "sceNpGetAccountDateOfBirthA", (void*)sceNpGetAccountDateOfBirthA },
+	{ 0xADB9276948E9A96A, "sceNpGetAccountIdA", (void*)sceNpGetAccountIdA },
+	{ 0x4CF31B808C6FA20D, "sceNpGetAccountLanguageA", (void*)sceNpGetAccountLanguageA },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceNpTrophy/sce_nptrophy.cpp

@@ -60,5 +60,10 @@ int PS4API sceNpTrophyUnlockTrophy(void)
 }
 
 
+int PS4API sceNpTrophyAbortHandle(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 
 

GPCS4/SceModules/SceNpTrophy/sce_nptrophy.h

@@ -46,5 +46,5 @@ int PS4API sceNpTrophyRegisterContext(void);
 int PS4API sceNpTrophyUnlockTrophy(void);
 
 
-
+int PS4API sceNpTrophyAbortHandle(void);
 

GPCS4/SceModules/SceNpTrophy/sce_nptrophy_export.cpp

@@ -15,6 +15,7 @@ static const SCE_EXPORT_FUNCTION g_pSceNpTrophy_libSceNpTrophy_FunctionTable[] =
 	{ 0x2C7B9298EDD22DDF, "sceNpTrophyGetTrophyUnlockState", (void*)sceNpTrophyGetTrophyUnlockState },
 	{ 0x4C9080C6DA3D4845, "sceNpTrophyRegisterContext", (void*)sceNpTrophyRegisterContext },
 	{ 0xDBCC6645415AA3AF, "sceNpTrophyUnlockTrophy", (void*)sceNpTrophyUnlockTrophy },
+	{ 0x6939C7B3B5BFF549, "sceNpTrophyAbortHandle", (void*)sceNpTrophyAbortHandle },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceNpTus/sce_nptus.cpp

@@ -74,5 +74,16 @@ int PS4API sceNpTusTryAndSetVariableAsync(void)
 }
 
 
+int PS4API sceNpTssCreateNpTitleCtxA(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 
 
+int PS4API sceNpTssGetData(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+

GPCS4/SceModules/SceNpTus/sce_nptus.h

@@ -52,5 +52,11 @@ int PS4API sceNpTusSetMultiSlotVariableAsync(void);
 int PS4API sceNpTusTryAndSetVariableAsync(void);
 
 
+int PS4API sceNpTssCreateNpTitleCtxA(void);
+
+
+int PS4API sceNpTssGetData(void);
+
+
 
 

GPCS4/SceModules/SceNpTus/sce_nptus_export.cpp

@@ -17,6 +17,8 @@ static const SCE_EXPORT_FUNCTION g_pSceNpTus_libSceNpTus_FunctionTable[] =
 	{ 0xB7B6FA766A503622, "sceNpTusPollAsync", (void*)sceNpTusPollAsync },
 	{ 0xE49F4618C96E7716, "sceNpTusSetMultiSlotVariableAsync", (void*)sceNpTusSetMultiSlotVariableAsync },
 	{ 0xC507D1E758B891C9, "sceNpTusTryAndSetVariableAsync", (void*)sceNpTusTryAndSetVariableAsync },
+	{ 0x941B6B93EEE5935E, "sceNpTssCreateNpTitleCtxA", (void*)sceNpTssCreateNpTitleCtxA },
+	{ 0xFD2511F94A0B4BA7, "sceNpTssGetData", (void*)sceNpTssGetData },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceNpWebApi/sce_npwebapi.cpp

@@ -102,5 +102,12 @@ int PS4API sceNpWebApiTerminate(void)
 }
 
 
+int PS4API sceNpWebApiCreateContextA(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
 
 

GPCS4/SceModules/SceNpWebApi/sce_npwebapi.h

@@ -64,5 +64,7 @@ int PS4API sceNpWebApiSendRequest2(void);
 int PS4API sceNpWebApiTerminate(void);
 
 
+int PS4API sceNpWebApiCreateContextA(void);
+
 
 

GPCS4/SceModules/SceNpWebApi/sce_npwebapi_export.cpp

@@ -21,6 +21,7 @@ static const SCE_EXPORT_FUNCTION g_pSceNpWebApi_libSceNpWebApi_FunctionTable[] =
 	{ 0x0EC3CE4C4BD27BB3, "sceNpWebApiSendMultipartRequest2", (void*)sceNpWebApiSendMultipartRequest2 },
 	{ 0x2A335E67FDBDCAC4, "sceNpWebApiSendRequest2", (void*)sceNpWebApiSendRequest2 },
 	{ 0x6ACCF74ED22A185F, "sceNpWebApiTerminate", (void*)sceNpWebApiTerminate },
+	{ 0xCE4E9CEB9C68C8ED, "sceNpWebApiCreateContextA", (void*)sceNpWebApiCreateContextA },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/ScePad/sce_pad.cpp

@@ -67,5 +67,12 @@ int PS4API scePadSetVibration(void)
 }
 
 
+int PS4API scePadRead(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
 
 

GPCS4/SceModules/ScePad/sce_pad.h

@@ -49,5 +49,8 @@ int PS4API scePadSetLightBar(void);
 int PS4API scePadSetVibration(void);
 
 
+int PS4API scePadRead(void);
+
+
 
 

GPCS4/SceModules/ScePad/sce_pad_export.cpp

@@ -16,6 +16,7 @@ static const SCE_EXPORT_FUNCTION g_pScePad_libScePad_FunctionTable[] =
 	{ 0x0EC703D62F475F5C, "scePadResetLightBar", (void*)scePadResetLightBar },
 	{ 0x451E27A2F50410D6, "scePadSetLightBar", (void*)scePadSetLightBar },
 	{ 0xC8556739D1B1BD96, "scePadSetVibration", (void*)scePadSetVibration },
+	{ 0xAB570735F1B270B2, "scePadRead", (void*)scePadRead },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/ScePlayGo/sce_playgo.cpp

@@ -53,5 +53,39 @@ int PS4API scePlayGoTerminate(void)
 }
 
 
+int PS4API scePlayGoGetEta(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePlayGoGetInstallSpeed(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePlayGoGetLanguageMask(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePlayGoGetToDoList(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API scePlayGoSetLanguageMask(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
 
 

GPCS4/SceModules/ScePlayGo/sce_playgo.h

@@ -43,5 +43,20 @@ int PS4API scePlayGoOpen(void);
 int PS4API scePlayGoTerminate(void);
 
 
+int PS4API scePlayGoGetEta(void);
+
+
+int PS4API scePlayGoGetInstallSpeed(void);
+
+
+int PS4API scePlayGoGetLanguageMask(void);
+
+
+int PS4API scePlayGoGetToDoList(void);
+
+
+int PS4API scePlayGoSetLanguageMask(void);
+
+
 
 

GPCS4/SceModules/ScePlayGo/sce_playgo_export.cpp

@@ -14,6 +14,11 @@ static const SCE_EXPORT_FUNCTION g_pScePlayGo_libScePlayGo_FunctionTable[] =
 	{ 0xB6CE8695938A46B1, "scePlayGoInitialize", (void*)scePlayGoInitialize },
 	{ 0x3351A66B5A1CAC61, "scePlayGoOpen", (void*)scePlayGoOpen },
 	{ 0x30F7B411E04633F1, "scePlayGoTerminate", (void*)scePlayGoTerminate },
+	{ 0xBFA119FD859174CB, "scePlayGoGetEta", (void*)scePlayGoGetEta },
+	{ 0xAEF0527D38A67A31, "scePlayGoGetInstallSpeed", (void*)scePlayGoGetInstallSpeed },
+	{ 0xDCE31B61905A6B9D, "scePlayGoGetLanguageMask", (void*)scePlayGoGetLanguageMask },
+	{ 0x367EF32B09C0E6AD, "scePlayGoGetToDoList", (void*)scePlayGoGetToDoList },
+	{ 0x2E8B0B9473A936A4, "scePlayGoSetLanguageMask", (void*)scePlayGoSetLanguageMask },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/ScePlayGoDialog/sce_playgodialog.cpp

@@ -0,0 +1,22 @@
+#include "sce_playgodialog.h"
+
+
+// Note:
+// The codebase is generated using GenerateCode.py
+// You may need to modify the code manually to fit development needs
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// library: libScePlayGoDialog
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API scePlayGoDialogOpen(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+
+

GPCS4/SceModules/ScePlayGoDialog/sce_playgodialog.h

@@ -0,0 +1,32 @@
+/*
+ *    GPCS4
+ *    
+ *    This file implements:
+ *    module: libScePlayGoDialog
+ *        library: libScePlayGoDialog
+ *    
+ */
+
+#pragma once
+
+#include "sce_module_common.h"
+
+
+extern const SCE_EXPORT_MODULE g_ExpModuleScePlayGoDialog;
+
+
+// Note:
+// The codebase is generated using GenerateCode.py
+// You may need to modify the code manually to fit development needs
+
+
+
+//////////////////////////////////////////////////////////////////////////
+// library: libScePlayGoDialog
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API scePlayGoDialogOpen(void);
+
+
+
+

GPCS4/SceModules/ScePlayGoDialog/sce_playgodialog_export.cpp

@@ -0,0 +1,27 @@
+#include "sce_playgodialog.h"
+
+
+// Note:
+// The codebase is generated using GenerateCode.py
+// You may need to modify the code manually to fit development needs
+
+
+static const SCE_EXPORT_FUNCTION g_pScePlayGoDialog_libScePlayGoDialog_FunctionTable[] =
+{
+	{ 0x90777BDAE92A6F1C, "scePlayGoDialogOpen", (void*)scePlayGoDialogOpen },
+	SCE_FUNCTION_ENTRY_END
+};
+
+static const SCE_EXPORT_LIBRARY g_pScePlayGoDialog_LibTable[] =
+{
+	{ "libScePlayGoDialog", g_pScePlayGoDialog_libScePlayGoDialog_FunctionTable },
+	SCE_LIBRARY_ENTRY_END
+};
+
+const SCE_EXPORT_MODULE g_ExpModuleScePlayGoDialog =
+{
+	"libScePlayGoDialog",
+	g_pScePlayGoDialog_LibTable
+};
+
+

GPCS4/SceModules/SceRtc/sce_rtc.cpp

@@ -53,5 +53,19 @@ int PS4API sceRtcSetTick(void)
 }
 
 
+int PS4API sceRtcGetCurrentClock(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceRtcGetCurrentTick(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
 
 

GPCS4/SceModules/SceRtc/sce_rtc.h

@@ -43,5 +43,11 @@ int PS4API sceRtcGetTick(void);
 int PS4API sceRtcSetTick(void);
 
 
+int PS4API sceRtcGetCurrentClock(void);
+
+
+int PS4API sceRtcGetCurrentTick(void);
+
+
 
 

GPCS4/SceModules/SceRtc/sce_rtc_export.cpp

@@ -14,6 +14,8 @@ static const SCE_EXPORT_FUNCTION g_pSceRtc_libSceRtc_FunctionTable[] =
 	{ 0x0B220AFE2E177604, "sceRtcGetDayOfWeek", (void*)sceRtcGetDayOfWeek },
 	{ 0xF30FC7D7D8A9E3C2, "sceRtcGetTick", (void*)sceRtcGetTick },
 	{ 0xB9E7A06BABF7194C, "sceRtcSetTick", (void*)sceRtcSetTick },
+	{ 0xF257EF9D132AC043, "sceRtcGetCurrentClock", (void*)sceRtcGetCurrentClock },
+	{ 0xD7C076352D72F545, "sceRtcGetCurrentTick", (void*)sceRtcGetCurrentTick },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceSaveData/sce_savedata.cpp

@@ -74,5 +74,38 @@ int PS4API sceSaveDataUmount(void)
 }
 
 
+int PS4API sceSaveDataGetEventResult(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceSaveDataGetSaveDataMemory2(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceSaveDataSetSaveDataMemory2(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceSaveDataSetupSaveDataMemory2(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceSaveDataSyncSaveDataMemory(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 
 

GPCS4/SceModules/SceSaveData/sce_savedata.h

@@ -52,5 +52,19 @@ int PS4API sceSaveDataTerminate(void);
 int PS4API sceSaveDataUmount(void);
 
 
+int PS4API sceSaveDataGetEventResult(void);
+
+
+int PS4API sceSaveDataGetSaveDataMemory2(void);
+
+
+int PS4API sceSaveDataSetSaveDataMemory2(void);
+
+
+int PS4API sceSaveDataSetupSaveDataMemory2(void);
+
+
+int PS4API sceSaveDataSyncSaveDataMemory(void);
+
 
 

GPCS4/SceModules/SceSaveData/sce_savedata_export.cpp

@@ -17,6 +17,11 @@ static const SCE_EXPORT_FUNCTION g_pSceSaveData_libSceSaveData_FunctionTable[] =
 	{ 0xF39CEE97FFDE197B, "sceSaveDataSetParam", (void*)sceSaveDataSetParam },
 	{ 0xC8A0F2F12E722C0D, "sceSaveDataTerminate", (void*)sceSaveDataTerminate },
 	{ 0x04C47817F51E9371, "sceSaveDataUmount", (void*)sceSaveDataUmount },
+	{ 0x8FCC4AB62163D126, "sceSaveDataGetEventResult", (void*)sceSaveDataGetEventResult },
+	{ 0x43038EEEF7A09D5F, "sceSaveDataGetSaveDataMemory2", (void*)sceSaveDataGetSaveDataMemory2 },
+	{ 0x71DBB2F6FE18993E, "sceSaveDataSetSaveDataMemory2", (void*)sceSaveDataSetSaveDataMemory2 },
+	{ 0xA10C921147E05D10, "sceSaveDataSetupSaveDataMemory2", (void*)sceSaveDataSetupSaveDataMemory2 },
+	{ 0xC224FD8DE0BBC4FC, "sceSaveDataSyncSaveDataMemory", (void*)sceSaveDataSyncSaveDataMemory },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceSystemService/sce_systemservice.cpp

@@ -39,5 +39,20 @@ int PS4API sceSystemServiceReceiveEvent(void)
 }
 
 
+int PS4API sceSystemServiceGetDisplaySafeAreaInfo(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 
 
+//////////////////////////////////////////////////////////////////////////
+// library: libSceSystemServicePlatformPrivacy
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API sceSystemServiceGetPlatformPrivacySetting(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+

GPCS4/SceModules/SceSystemService/sce_systemservice.h

@@ -37,5 +37,12 @@ int PS4API sceSystemServiceParamGetInt(void);
 int PS4API sceSystemServiceReceiveEvent(void);
 
 
+int PS4API sceSystemServiceGetDisplaySafeAreaInfo(void);
 
 
+//////////////////////////////////////////////////////////////////////////
+// library: libSceSystemServicePlatformPrivacy
+//////////////////////////////////////////////////////////////////////////
+
+int PS4API sceSystemServiceGetPlatformPrivacySetting(void);
+

GPCS4/SceModules/SceSystemService/sce_systemservice_export.cpp

@@ -12,12 +12,20 @@ static const SCE_EXPORT_FUNCTION g_pSceSystemService_libSceSystemService_Functio
 	{ 0x568E55F0A0300A69, "sceSystemServiceHideSplashScreen", (void*)sceSystemServiceHideSplashScreen },
 	{ 0x7D9A38F2E9FB2CAE, "sceSystemServiceParamGetInt", (void*)sceSystemServiceParamGetInt },
 	{ 0xEB9E8B3104AB83A5, "sceSystemServiceReceiveEvent", (void*)sceSystemServiceReceiveEvent },
+	{ 0xD67DFBAB506F7396, "sceSystemServiceGetDisplaySafeAreaInfo", (void*)sceSystemServiceGetDisplaySafeAreaInfo },
+	SCE_FUNCTION_ENTRY_END
+};
+
+static const SCE_EXPORT_FUNCTION g_pSceSystemService_libSceSystemServicePlatformPrivacy_FunctionTable[] =
+{
+	{ 0x86FA0B62173872AD, "sceSystemServiceGetPlatformPrivacySetting", (void*)sceSystemServiceGetPlatformPrivacySetting },
 	SCE_FUNCTION_ENTRY_END
 };
 
 static const SCE_EXPORT_LIBRARY g_pSceSystemService_LibTable[] =
 {
 	{ "libSceSystemService", g_pSceSystemService_libSceSystemService_FunctionTable },
+	{ "libSceSystemServicePlatformPrivacy", g_pSceSystemService_libSceSystemServicePlatformPrivacy_FunctionTable },
 	SCE_LIBRARY_ENTRY_END
 };
 

GPCS4/SceModules/SceUserService/sce_userservice.cpp

@@ -39,5 +39,9 @@ int PS4API sceUserServiceTerminate(void)
 }
 
 
-
+int PS4API sceUserServiceGetUserName(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 

GPCS4/SceModules/SceUserService/sce_userservice.h

@@ -37,5 +37,8 @@ int PS4API sceUserServiceInitialize(void);
 int PS4API sceUserServiceTerminate(void);
 
 
+int PS4API sceUserServiceGetUserName(void);
+
+
 
 

GPCS4/SceModules/SceUserService/sce_userservice_export.cpp

@@ -12,6 +12,7 @@ static const SCE_EXPORT_FUNCTION g_pSceUserService_libSceUserService_FunctionTab
 	{ 0x09D5A9D281D61ABD, "sceUserServiceGetInitialUser", (void*)sceUserServiceGetInitialUser },
 	{ 0x8F760CBB531534DA, "sceUserServiceInitialize", (void*)sceUserServiceInitialize },
 	{ 0x6F01634BE6D7F660, "sceUserServiceTerminate", (void*)sceUserServiceTerminate },
+	{ 0xD71C5C3221AED9FA, "sceUserServiceGetUserName", (void*)sceUserServiceGetUserName },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/SceVideoOut/sce_videoout.cpp

@@ -53,5 +53,93 @@ int PS4API sceVideoOutSetFlipRate(void)
 }
 
 
+int PS4API sceVideoOutAddFlipEvent(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
 
 
+int PS4API sceVideoOutAdjustColor_(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutColorSettingsSetGamma_(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutConfigureOutputMode_(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutGetDeviceCapabilityInfo_(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutGetEventData(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutGetFlipStatus(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutIsFlipPending(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutModeSetAny_(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutSetWindowModeMargins(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutSubmitChangeBufferAttribute(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutSubmitFlip(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+
+
+int PS4API sceVideoOutWaitVblank(void)
+{
+	LOG_FIXME("Not implemented");
+	return SCE_OK;
+}
+

GPCS4/SceModules/SceVideoOut/sce_videoout.h

@@ -43,5 +43,41 @@ int PS4API sceVideoOutSetBufferAttribute(void);
 int PS4API sceVideoOutSetFlipRate(void);
 
 
+int PS4API sceVideoOutAddFlipEvent(void);
 
 
+int PS4API sceVideoOutAdjustColor_(void);
+
+
+int PS4API sceVideoOutColorSettingsSetGamma_(void);
+
+
+int PS4API sceVideoOutConfigureOutputMode_(void);
+
+
+int PS4API sceVideoOutGetDeviceCapabilityInfo_(void);
+
+
+int PS4API sceVideoOutGetEventData(void);
+
+
+int PS4API sceVideoOutGetFlipStatus(void);
+
+
+int PS4API sceVideoOutIsFlipPending(void);
+
+
+int PS4API sceVideoOutModeSetAny_(void);
+
+
+int PS4API sceVideoOutSetWindowModeMargins(void);
+
+
+int PS4API sceVideoOutSubmitChangeBufferAttribute(void);
+
+
+int PS4API sceVideoOutSubmitFlip(void);
+
+
+int PS4API sceVideoOutWaitVblank(void);
+

GPCS4/SceModules/SceVideoOut/sce_videoout_export.cpp

@@ -14,6 +14,19 @@ static const SCE_EXPORT_FUNCTION g_pSceVideoOut_libSceVideoOut_FunctionTable[] =
 	{ 0xC37058FAD0048906, "sceVideoOutRegisterBuffers", (void*)sceVideoOutRegisterBuffers },
 	{ 0x8BAFEC47DD56B7FE, "sceVideoOutSetBufferAttribute", (void*)sceVideoOutSetBufferAttribute },
 	{ 0x0818AEE26084D430, "sceVideoOutSetFlipRate", (void*)sceVideoOutSetFlipRate },
+	{ 0x1D7CE32BDC88DF49, "sceVideoOutAddFlipEvent", (void*)sceVideoOutAddFlipEvent },
+	{ 0xA6FF42239542F91D, "sceVideoOutAdjustColor_", (void*)sceVideoOutAdjustColor_ },
+	{ 0x0D886159B2527918, "sceVideoOutColorSettingsSetGamma_", (void*)sceVideoOutColorSettingsSetGamma_ },
+	{ 0x3756C4A09E12470E, "sceVideoOutConfigureOutputMode_", (void*)sceVideoOutConfigureOutputMode_ },
+	{ 0x90654B73786D404F, "sceVideoOutGetDeviceCapabilityInfo_", (void*)sceVideoOutGetDeviceCapabilityInfo_ },
+	{ 0xAD651370A7645334, "sceVideoOutGetEventData", (void*)sceVideoOutGetEventData },
+	{ 0x49B537770A7CD254, "sceVideoOutGetFlipStatus", (void*)sceVideoOutGetFlipStatus },
+	{ 0xCE05E27C74FD12B6, "sceVideoOutIsFlipPending", (void*)sceVideoOutIsFlipPending },
+	{ 0xA63903B20C658BA7, "sceVideoOutModeSetAny_", (void*)sceVideoOutModeSetAny_ },
+	{ 0x313C71ACE09E4A28, "sceVideoOutSetWindowModeMargins", (void*)sceVideoOutSetWindowModeMargins },
+	{ 0x20E7601E508653F9, "sceVideoOutSubmitChangeBufferAttribute", (void*)sceVideoOutSubmitChangeBufferAttribute },
+	{ 0x538E8DC0E889A72B, "sceVideoOutSubmitFlip", (void*)sceVideoOutSubmitFlip },
+	{ 0x8FA45A01495A2EFD, "sceVideoOutWaitVblank", (void*)sceVideoOutWaitVblank },
 	SCE_FUNCTION_ENTRY_END
 };
 

GPCS4/SceModules/sce_modules.h

@@ -16,6 +16,7 @@
 #include "SceHttp/sce_http.h"
 #include "SceIme/sce_ime.h"
 #include "SceInvitationDialog/sce_invitationdialog.h"
+#include "SceJobManager/sce_jobmanager.h"
 #include "SceJson/sce_json.h"
 #include "SceLibc/sce_libc.h"
 #include "SceLibkernel/sce_libkernel.h"
@@ -35,6 +36,7 @@
 #include "SceNpWebApi/sce_npwebapi.h"
 #include "ScePad/sce_pad.h"
 #include "ScePlayGo/sce_playgo.h"
+#include "ScePlayGoDialog/sce_playgodialog.h"
 #include "SceRtc/sce_rtc.h"
 #include "SceRudp/sce_rudp.h"
 #include "SceSaveData/sce_savedata.h"

Tools/import_modules_gow4_delta.txt

@@ -0,0 +1,147 @@
+libc libc 10D2DF2891194E31
+libc libc 28628179572A2637
+libc libc 29D3FF9D42E9B86C
+libc libc 3148C2E256C7ACAE
+libc libc 34BC09DEAFBAE1B6
+libc libc 386C9B56E3C08406
+libc libc 40C1722E8A8DC488
+libc libc 4486BA1A75A9FA25
+libc libc 5237F72B332F4662
+libc libc 54F6C9C130A0304D
+libc libc 554CE35E49CF3C1B
+libc libc 793D94B264DEC1B5
+libc libc 79F84AFD84946184
+libc libc 7C7284DF7A772E
+libc libc 8236E66293FF5C94
+libc libc 8245A09F4A7501F5
+libc libc 83BCF3CCB0D81B0D
+libc libc 90366FA15B2C0A04
+libc libc BFB4BB2E13F63897
+libc libc D2195F5B53B801AE
+libc libc D27576D498D8087F
+libc libc D530E8FC89AA9097
+libc libc DC1CAD3CE42054A7
+libc libc F10EB424B27A46FE
+libc libc F5FB356ED7CBA14B
+libc libc FE453A6C1E0CFFE9
+libc libc_setjmp B23A64AE1BA0BD52
+libc libc_setjmp F85FBD8618BA93D4
+libkernel libkernel 1E8C3B07C39EB7A9
+libkernel libkernel 21A7C8D8FC5C3E74
+libkernel libkernel 2F01BC8379E2AB00
+libkernel libkernel 35C6965317CC3484
+libkernel libkernel 3F8D644D6512DC42
+libkernel libkernel 42F8E1B99BDF9BC
+libkernel libkernel 58571F2F697389DA
+libkernel libkernel 5E3A28B22C3E5CF2
+libkernel libkernel 68858AFF17BFE2B
+libkernel libkernel 71091EF54B8140E9
+libkernel libkernel 7A37A471A35036AD
+libkernel libkernel 7A886DEE640E0A6A
+libkernel libkernel 81E0DAAA01FD9538
+libkernel libkernel 8705523C29A9E6D3
+libkernel libkernel 98BF0D0C7F3A8902
+libkernel libkernel A084454E3A082DB8
+libkernel libkernel A810E6A42C86B2C1
+libkernel libkernel AD58D1BC72745FA7
+libkernel libkernel B59DB2A6563C3016
+libkernel libkernel BA9A15AF330715E1
+libkernel libkernel BD23009B77316136
+libkernel libkernel C33BEA4F852A297F
+libkernel libkernel C6306DC9B21AD95
+libkernel libkernel C83070540A250E08
+libkernel libkernel D92284C7A6D2ABFE
+libkernel libkernel E285D87BD5E69344
+libkernel libkernel E2A1AB47A7A83FD6
+libkernel libkernel EE8C6FDCF3C2BA6A
+libkernel libkernel F5B7DD2C8CAEC026
+libkernel libkernel F81CD7624A9878B1
+libkernel libSceCoredump DB6E48FA60759DA
+libkernel libSceCoredump F332D27C47D6E405
+libkernel libSceCoredump F985F4CFF19448DC
+libkernel libScePosix 133F318E8F541781
+libkernel libScePosix 20A3FCB72A744149
+libkernel libScePosix 4D4BA2612DA413CB
+libkernel libScePosix 4FC7C447EB481A09
+libkernel libScePosix 5D52FC4A8DD02549
+libkernel libScePosix 5ECF617620FBB000
+libkernel libScePosix 602579746181702A
+libkernel libScePosix 6D8FCF3BA261CE14
+libkernel libScePosix 7035B6DF7440C16A
+libkernel libScePosix 7D939E64838498BC
+libkernel libScePosix A43B8F11FDE6E1F2
+libkernel libScePosix C39207CAF6A183FA
+libSceFiber libSceFiber A7ECCB20E836EF35
+libSceGnmDriver libSceGnmDriver 1096A9365DBEA605
+libSceGnmDriver libSceGnmDriver 2A5D19DCB1F4ED02
+libSceGnmDriver libSceGnmDriver 75EC17C39AE82ECD
+libSceGnmDriver libSceGnmDriver 7DFACD40EB21A30B
+libSceHttp libSceHttp 118DBC4F66E437B9
+libSceHttp libSceHttp 1EBB9C152A417DC
+libSceHttp libSceHttp 2B57752EA6514074
+libSceHttp libSceHttp 3D3885214C42A497
+libSceHttp libSceHttp 3F9A5DA3290F6139
+libSceHttp libSceHttp 3FA037CADA6C8987
+libSceHttp libSceHttp 4DCFE10180CAB507
+libSceHttp libSceHttp 62E396DDD0C02987
+libSceHttp libSceHttp A9EEE867EBF83D60
+libSceHttp libSceHttp AA0C43063A2B531B
+libSceHttp libSceHttp C5E8057D9281565C
+libSceHttp libSceHttp CA282BE15D3F1D33
+libSceHttp libSceHttp CAE3B61F652F9E8B
+libSceHttp libSceHttp D12F6D4C7D2EA935
+libSceHttp libSceHttp D1AD9304D7C4DC15
+libSceHttp libSceHttp D206233D347FE9C6
+libSceHttp libSceHttp D5ED8137023F5F31
+libSceHttp libSceHttp E08F2F129B84859F
+libSceJobManager libSceJobManager 192F4349BCC2F8C6
+libSceJobManager libSceJobManager 366D81840C183459
+libSceJobManager libSceJobManager 55329ECDF62EFEFE
+libSceJobManager libSceJobManager 5BFC9781099AA335
+libSceJobManager libSceJobManager 721C67BECC717C16
+libSceJobManager libSceJobManager 730333CDD7AC2E56
+libSceJobManager libSceJobManager E20D5E7B7E13307F
+libSceNet libSceNet 35DF7559A5A61B6C
+libSceNet libSceNet 9099581F9B8C0162
+libSceNet libSceNet B85200C71CFBDDC
+libSceNet libSceNet E8E7346CBB0861ED
+libSceNetCtl libSceNetCtl A1BBB17538B0905F
+libSceNpManager libSceNpManager 1A92D00CD28809A7
+libSceNpManager libSceNpManager 253FADD346B74F10
+libSceNpManager libSceNpManager 4CF31B808C6FA20D
+libSceNpManager libSceNpManager AB733B5F304A0B7B
+libSceNpManager libSceNpManager ADB9276948E9A96A
+libSceNpTrophy libSceNpTrophy 6939C7B3B5BFF549
+libSceNpTus libSceNpTus 941B6B93EEE5935E
+libSceNpTus libSceNpTus FD2511F94A0B4BA7
+libSceNpWebApi libSceNpWebApi CE4E9CEB9C68C8ED
+libScePad libScePad AB570735F1B270B2
+libScePlayGo libScePlayGo 2E8B0B9473A936A4
+libScePlayGo libScePlayGo 367EF32B09C0E6AD
+libScePlayGo libScePlayGo AEF0527D38A67A31
+libScePlayGo libScePlayGo BFA119FD859174CB
+libScePlayGo libScePlayGo DCE31B61905A6B9D
+libScePlayGoDialog libScePlayGoDialog 90777BDAE92A6F1C
+libSceRtc libSceRtc D7C076352D72F545
+libSceRtc libSceRtc F257EF9D132AC043
+libSceSaveData libSceSaveData 43038EEEF7A09D5F
+libSceSaveData libSceSaveData 71DBB2F6FE18993E
+libSceSaveData libSceSaveData 8FCC4AB62163D126
+libSceSaveData libSceSaveData A10C921147E05D10
+libSceSaveData libSceSaveData C224FD8DE0BBC4FC
+libSceSystemService libSceSystemService D67DFBAB506F7396
+libSceSystemService libSceSystemServicePlatformPrivacy 86FA0B62173872AD
+libSceUserService libSceUserService D71C5C3221AED9FA
+libSceVideoOut libSceVideoOut 1D7CE32BDC88DF49
+libSceVideoOut libSceVideoOut 20E7601E508653F9
+libSceVideoOut libSceVideoOut 313C71ACE09E4A28
+libSceVideoOut libSceVideoOut 3756C4A09E12470E
+libSceVideoOut libSceVideoOut 49B537770A7CD254
+libSceVideoOut libSceVideoOut 538E8DC0E889A72B
+libSceVideoOut libSceVideoOut 8FA45A01495A2EFD
+libSceVideoOut libSceVideoOut 90654B73786D404F
+libSceVideoOut libSceVideoOut A63903B20C658BA7
+libSceVideoOut libSceVideoOut A6FF42239542F91D
+libSceVideoOut libSceVideoOut AD651370A7645334
+libSceVideoOut libSceVideoOut CE05E27C74FD12B6
+libSceVideoOut libSceVideoOut D886159B2527918