core: Reorganize

src/core/hle/libraries/libc/libc.cpp

@@ -1,19 +1,17 @@
-#include "libc.h"
-
+#include <cstdlib>
 #include "common/debug.h"
-#include <stdlib.h>
-
 #include "common/singleton.h"
 #include "common/log.h"
-#include "core/PS4/HLE/Libs.h"
 #include "core/hle/libraries/libc/libc.h"
 #include "core/hle/libraries/libc/libc_cxa.h"
 #include "core/hle/libraries/libc/libc_math.h"
 #include "core/hle/libraries/libc/libc_stdio.h"
 #include "core/hle/libraries/libc/libc_stdlib.h"
 #include "core/hle/libraries/libc/libc_string.h"
+#include "core/hle/libraries/libs.h"
 
 namespace Core::Libraries::LibC {
+
 constexpr bool log_file_libc = true;  // disable it to disable logging
 static u32 g_need_sceLibc = 1;
 
@@ -39,28 +37,41 @@ static PS4_SYSV_ABI int __cxa_atexit(void (*func)(void*), void* arg, void* dso_h
     return 0;
 }
 
-void PS4_SYSV_ABI __cxa_finalize(void* d) { __debugbreak(); }
+void PS4_SYSV_ABI __cxa_finalize(void* d) {
+    BREAKPOINT();
+}
 
-void PS4_SYSV_ABI __cxa_pure_virtual() { __debugbreak(); }
+void PS4_SYSV_ABI __cxa_pure_virtual() {
+    BREAKPOINT();
+}
 
-static PS4_SYSV_ABI void init_env() { PRINT_DUMMY_FUNCTION_NAME(); }
+static PS4_SYSV_ABI void init_env() {
+    PRINT_DUMMY_FUNCTION_NAME();
+}
 
-static PS4_SYSV_ABI void catchReturnFromMain(int status) { LOG_INFO_IF(log_file_libc, "catchReturnFromMain returned ={}\n", status); }
+static PS4_SYSV_ABI void catchReturnFromMain(int status) {
+    LOG_INFO_IF(log_file_libc, "catchReturnFromMain returned ={}\n", status);
+}
 
 static PS4_SYSV_ABI void _Assert() {
     PRINT_DUMMY_FUNCTION_NAME();
     BREAKPOINT();
 }
 
-PS4_SYSV_ABI void _ZdlPv(void* ptr) { std::free(ptr); }
+PS4_SYSV_ABI void _ZdlPv(void* ptr) {
+    std::free(ptr);
+}
+
 PS4_SYSV_ABI void _ZSt11_Xbad_allocv() {
     PRINT_DUMMY_FUNCTION_NAME();
     BREAKPOINT();
 }
+
 PS4_SYSV_ABI void _ZSt14_Xlength_errorPKc() {
     PRINT_DUMMY_FUNCTION_NAME();
     BREAKPOINT();
 }
+
 PS4_SYSV_ABI void* _Znwm(u64 count) {
     if (count == 0) {
         LOG_ERROR_IF(log_file_libc, "_Znwm count ={}\n", count);
@@ -70,7 +81,7 @@ PS4_SYSV_ABI void* _Znwm(u64 count) {
     return ptr;
 }
 
-void libcSymbolsRegister(SymbolsResolver* sym) {
+void libcSymbolsRegister(Loader::SymbolsResolver* sym) {
     // cxa functions
     LIB_FUNCTION("3GPpjQdAMTw", "libc", 1, "libc", 1, 1, __cxa_guard_acquire);
     LIB_FUNCTION("9rAeANT2tyE", "libc", 1, "libc", 1, 1, __cxa_guard_release);

src/core/hle/libraries/libc/libc.h

@@ -1,10 +1,11 @@
 #pragma once
 
-#include "common/types.h"
-#include "core/PS4/Loader/SymbolsResolver.h"
+namespace Core::Loader {
+class SymbolsResolver;
+}
 
 namespace Core::Libraries::LibC {
 
-void libcSymbolsRegister(SymbolsResolver* sym);
+void libcSymbolsRegister(Loader::SymbolsResolver* sym);
 
-}  // namespace Core::Libraries::LibC
+}  // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_cxa.cpp

@@ -6,6 +6,7 @@
 // adapted from https://opensource.apple.com/source/libcppabi/libcppabi-14/src/cxa_guard.cxx.auto.html
 
 namespace Core::Libraries::LibC {
+
 constexpr bool log_file_cxa = true;  // disable it to disable logging
 
 // This file implements the __cxa_guard_* functions as defined at:
@@ -145,4 +146,4 @@ void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object) {
     setNotInUse(guard_object);
 }
 
-}  // namespace Core::Libraries::LibC
+}  // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_cxa.h

@@ -5,7 +5,9 @@
 #include "common/types.h"
 
 namespace Core::Libraries::LibC {
+
 int PS4_SYSV_ABI __cxa_guard_acquire(u64* guard_object);
 void PS4_SYSV_ABI __cxa_guard_release(u64* guard_object);
 void PS4_SYSV_ABI __cxa_guard_abort(u64* guard_object);
-}  // namespace Core::Libraries::LibC
+
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_math.cpp

@@ -1,23 +1,38 @@
-#include "libc_math.h"
-
 #include <cmath>
+#include "core/hle/libraries/libc/libc_math.h"
 
 namespace Core::Libraries::LibC {
 
-float PS4_SYSV_ABI atan2f(float y, float x) { return std::atan2f(y, x); }
+float PS4_SYSV_ABI atan2f(float y, float x) {
+    return std::atan2f(y, x);
+}
 
-float PS4_SYSV_ABI acosf(float num) { return std::acosf(num); }
+float PS4_SYSV_ABI acosf(float num) {
+    return std::acosf(num);
+}
 
-float PS4_SYSV_ABI tanf(float num) { return std::tanf(num); }
+float PS4_SYSV_ABI tanf(float num) {
+    return std::tanf(num);
+}
 
-float PS4_SYSV_ABI asinf(float num) { return std::asinf(num); }
+float PS4_SYSV_ABI asinf(float num) {
+    return std::asinf(num);
+}
 
-double PS4_SYSV_ABI pow(double base, double exponent) { return std::pow(base, exponent); }
+double PS4_SYSV_ABI pow(double base, double exponent) {
+    return std::pow(base, exponent);
+}
 
-double PS4_SYSV_ABI _Sin(double x) { return std::sin(x); }
+double PS4_SYSV_ABI _Sin(double x) {
+    return std::sin(x);
+}
 
-float PS4_SYSV_ABI _Fsin(float arg) { return std::sinf(arg); }
+float PS4_SYSV_ABI _Fsin(float arg) {
+    return std::sinf(arg);
+}
 
-double PS4_SYSV_ABI exp2(double arg) { return std::exp2(arg); }
+double PS4_SYSV_ABI exp2(double arg) {
+    return std::exp2(arg);
+}
 
-}  // namespace Core::Libraries::LibC
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_math.h

@@ -3,6 +3,7 @@
 #include "common/types.h"
 
 namespace Core::Libraries::LibC {
+
 float PS4_SYSV_ABI atan2f(float y, float x);
 float PS4_SYSV_ABI acosf(float num);
 float PS4_SYSV_ABI tanf(float num);
@@ -11,4 +12,5 @@ double PS4_SYSV_ABI pow(double base, double exponent);
 double PS4_SYSV_ABI _Sin(double x);
 float PS4_SYSV_ABI _Fsin(float arg);
 double PS4_SYSV_ABI exp2(double arg);
-}  // namespace Core::Libraries::LibC
+
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_stdio.cpp

@@ -1,15 +1,16 @@
-#include "libc_stdio.h"
-
 #include "common/debug.h"
 #include "common/log.h"
+#include "core/hle/libraries/libc/libc_stdio.h"
 
 namespace Core::Libraries::LibC {
+
 constexpr bool log_file_libc = true;  // disable it to disable logging
 
 int PS4_SYSV_ABI printf(VA_ARGS) {
     VA_CTX(ctx);
     return printf_ctx(&ctx);
 }
+
 int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS) {
     int fd = _fileno(file);
     if (fd == 1 || fd == 2) {  // output stdout and stderr to console
@@ -21,8 +22,12 @@ int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS) {
     return 0;
 }
 
-int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg) { return vsnprintf_ctx(s, n, format, arg); }
+int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg) {
+    return vsnprintf_ctx(s, n, format, arg);
+}
 
-int PS4_SYSV_ABI puts(const char* s) { return std::puts(s); }
+int PS4_SYSV_ABI puts(const char* s) {
+    return std::puts(s);
+}
 
-}  // namespace Core::Libraries::LibC
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_stdio.h

@@ -1,12 +1,13 @@
 #pragma once
 
 #include "common/types.h"
-
-#include "printf.h"
+#include "core/hle/libraries/libc/printf.h"
 
 namespace Core::Libraries::LibC {
+
 int PS4_SYSV_ABI printf(VA_ARGS);
 int PS4_SYSV_ABI vsnprintf(char* s, size_t n, const char* format, VaList* arg);
 int PS4_SYSV_ABI puts(const char* s);
 int PS4_SYSV_ABI fprintf(FILE* file, VA_ARGS);
-}  // namespace Core::Libraries::LibC
+
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_stdlib.cpp

@@ -1,14 +1,15 @@
-#include "libc_stdlib.h"
-
+#include <cstdlib>
 #include "common/log.h"
 #include "common/debug.h"
-
-#include <cstdlib>
+#include "core/hle/libraries/libc/libc_stdlib.h"
 
 namespace Core::Libraries::LibC {
+
 constexpr bool log_file_libc = true;  // disable it to disable logging
 
-void PS4_SYSV_ABI exit(int code) { std::exit(code); }
+void PS4_SYSV_ABI exit(int code) {
+    std::exit(code);
+}
 
 int PS4_SYSV_ABI atexit(void (*func)()) {
     int rt = std::atexit(func);
@@ -19,19 +20,28 @@ int PS4_SYSV_ABI atexit(void (*func)()) {
     return rt;
 }
 
-void* PS4_SYSV_ABI malloc(size_t size) { return std::malloc(size); }
+void* PS4_SYSV_ABI malloc(size_t size) {
+    return std::malloc(size);
+}
 
-void PS4_SYSV_ABI free(void* ptr) { std::free(ptr); }
+void PS4_SYSV_ABI free(void* ptr) {
+    std::free(ptr);
+}
 
 typedef int(PS4_SYSV_ABI* pfunc_QsortCmp)(const void*, const void*);
 thread_local static pfunc_QsortCmp compair_ps4;
 
-int qsort_compair(const void* arg1, const void* arg2) { return compair_ps4(arg1, arg2); }
+int qsort_compair(const void* arg1, const void* arg2) {
+    return compair_ps4(arg1, arg2);
+}
 
 void PS4_SYSV_ABI qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*)) {
     compair_ps4 = comp;
     std::qsort(ptr, count, size, qsort_compair);
 }
-int PS4_SYSV_ABI rand() { return std::rand(); }
 
-}  // namespace Core::Libraries::LibC
+int PS4_SYSV_ABI rand() {
+    return std::rand();
+}
+
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_stdlib.h

@@ -1,14 +1,15 @@
 #pragma once
 
+#include <cstddef>
 #include "common/types.h"
 
-#include <cstddef>
-
 namespace Core::Libraries::LibC {
+
 void PS4_SYSV_ABI exit(int code);
 int PS4_SYSV_ABI atexit(void (*func)());
 void* PS4_SYSV_ABI malloc(size_t size);
 void PS4_SYSV_ABI free(void* ptr);
 void PS4_SYSV_ABI qsort(void* ptr, size_t count, size_t size, int(PS4_SYSV_ABI* comp)(const void*, const void*));
 int PS4_SYSV_ABI rand();
-}  // namespace Core::Libraries::LibC
+
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_string.cpp

@@ -1,25 +1,42 @@
-#include "libc_string.h"
-
 #include <cstring>
+#include "core/hle/libraries/libc/libc_string.h"
 
 namespace Core::Libraries::LibC {
 
-int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n) { return std::memcmp(s1, s2, n); }
+int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n) {
+    return std::memcmp(s1, s2, n);
+}
 
-void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n) { return std::memcpy(dest, src, n); }
+void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n) {
+    return std::memcpy(dest, src, n);
+}
 
-void* PS4_SYSV_ABI memset(void* s, int c, size_t n) { return std::memset(s, c, n); }
+void* PS4_SYSV_ABI memset(void* s, int c, size_t n) {
+    return std::memset(s, c, n);
+}
 
-int PS4_SYSV_ABI strcmp(const char* str1, const char* str2) { return std::strcmp(str1, str2); }
+int PS4_SYSV_ABI strcmp(const char* str1, const char* str2) {
+    return std::strcmp(str1, str2);
+}
 
-char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count) { return std::strncpy(dest, src, count); }
+char* PS4_SYSV_ABI strncpy(char* dest, const char* src, size_t count) {
+    return std::strncpy(dest, src, count);
+}
 
-void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count) { return std::memmove(dest, src, count); }
+void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count) {
+    return std::memmove(dest, src, count);
+}
 
-char* PS4_SYSV_ABI strcpy(char* dest, const char* src) { return std::strcpy(dest, src); }
+char* PS4_SYSV_ABI strcpy(char* dest, const char* src) {
+    return std::strcpy(dest, src);
+}
 
-char* PS4_SYSV_ABI strcat(char* dest, const char* src) { return std::strcat(dest, src); }
+char* PS4_SYSV_ABI strcat(char* dest, const char* src) {
+    return std::strcat(dest, src);
+}
 
-size_t PS4_SYSV_ABI strlen(const char* str) { return std::strlen(str); }
+size_t PS4_SYSV_ABI strlen(const char* str) {
+    return std::strlen(str);
+}
 
-}  // namespace Core::Libraries::LibC
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/libc_string.h

@@ -1,10 +1,10 @@
 #pragma once
 
+#include <cstddef>
 #include "common/types.h"
 
-#include <cstddef>
-
 namespace Core::Libraries::LibC {
+
 int PS4_SYSV_ABI memcmp(const void* s1, const void* s2, size_t n);
 void* PS4_SYSV_ABI memcpy(void* dest, const void* src, size_t n);
 void* PS4_SYSV_ABI memset(void* s, int c, size_t n);
@@ -14,4 +14,5 @@ void* PS4_SYSV_ABI memmove(void* dest, const void* src, std::size_t count);
 char* PS4_SYSV_ABI strcpy(char* destination, const char* source);
 char* PS4_SYSV_ABI strcat(char* dest, const char* src);
 size_t PS4_SYSV_ABI strlen(const char* str);
-}  // namespace Core::Libraries::LibC
+
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libc/va_ctx.h

@@ -103,4 +103,4 @@ T* vaArgPtr(VaList* l) {
     return vaArgOverflowArgArea<T*, 1, 8>(l);
 }
 
-}  // namespace Core::Libraries::LibC
+} // namespace Core::Libraries::LibC

src/core/hle/libraries/libkernel/file_system.cpp

@@ -1,10 +1,10 @@
-#include "file_system.h"
-
-#include <core/PS4/HLE/Libs.h>
 #include "common/log.h"
 #include "common/debug.h"
+#include "core/hle/libraries/libkernel/file_system.h"
+#include "core/hle/libraries/libs.h"
 
 namespace Core::Libraries::LibKernel {
+
 constexpr bool log_file_fs = true;  // disable it to disable logging
 
 int PS4_SYSV_ABI sceKernelOpen(const char* path, int flags, u16 mode) {
@@ -21,9 +21,9 @@ int PS4_SYSV_ABI open(const char* path, int flags, /* SceKernelMode*/ u16 mode)
     return result;
 }
 
-void fileSystemSymbolsRegister(SymbolsResolver* sym) {
+void fileSystemSymbolsRegister(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("1G3lF1Gg1k8", "libkernel", 1, "libkernel", 1, 1, sceKernelOpen);
     LIB_FUNCTION("wuCroIGjt2g", "libScePosix", 1, "libkernel", 1, 1, open);
 }
 
-}  // namespace Core::Libraries::LibKernel
+} // namespace Core::Libraries::LibKernel

src/core/hle/libraries/libkernel/file_system.h

@@ -1,13 +1,17 @@
 #pragma once
+
 #include "common/types.h"
-#include "core/PS4/Loader/SymbolsResolver.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
 
 namespace Core::Libraries::LibKernel {
+
 int PS4_SYSV_ABI sceKernelOpen(const char *path, int flags, /* SceKernelMode*/ u16 mode);
 
-// posix file system
 int PS4_SYSV_ABI open(const char *path, int flags, /* SceKernelMode*/ u16 mode);
 
+void fileSystemSymbolsRegister(Loader::SymbolsResolver *sym);
 
-void fileSystemSymbolsRegister(SymbolsResolver *sym);
-}  // namespace Core::Libraries::LibKernel
+} // namespace Core::Libraries::LibKernel

src/core/hle/libraries/libkernel/libkernel.cpp

@@ -0,0 +1,55 @@
+#include "common/log.h"
+#include "common/debug.h"
+#include "common/singleton.h"
+#include "core/loader/elf.h"
+#include "core/hle/kernel/Objects/physical_memory.h"
+#include "core/hle/kernel/cpu_management.h"
+#include "core/hle/kernel/event_queues.h"
+#include "core/hle/kernel/memory_management.h"
+#include "core/hle/libraries/libkernel/libkernel.h"
+#include "core/hle/libraries/libkernel/file_system.h"
+#include "core/hle/libraries/libkernel/time_management.h"
+#include "core/hle/libraries/libs.h"
+
+#ifdef _WIN64
+#include <windows.h>
+#endif
+
+namespace Core::Libraries::LibKernel {
+
+static u64 g_stack_chk_guard = 0xDEADBEEF54321ABC;  // dummy return
+
+int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len) {
+    BREAKPOINT();
+    return 0;
+}
+
+static PS4_SYSV_ABI void stack_chk_fail() {
+    BREAKPOINT();
+}
+
+int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) {
+    BREAKPOINT();
+}
+
+void LibKernel_Register(Loader::SymbolsResolver* sym) {
+    // obj
+    LIB_OBJ("f7uOxY9mM1U", "libkernel", 1, "libkernel", 1, 1, &g_stack_chk_guard);
+    // memory
+    LIB_FUNCTION("rTXw65xmLIA", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelAllocateDirectMemory);
+    LIB_FUNCTION("pO96TwzOm5E", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelGetDirectMemorySize);
+    LIB_FUNCTION("L-Q3LEjIbgA", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelMapDirectMemory);
+    LIB_FUNCTION("MBuItvba6z8", "libkernel", 1, "libkernel", 1, 1, sceKernelReleaseDirectMemory);
+    LIB_FUNCTION("cQke9UuBQOk", "libkernel", 1, "libkernel", 1, 1, sceKernelMunmap);
+    // equeue
+    LIB_FUNCTION("D0OdFMjp46I", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelCreateEqueue);
+    LIB_FUNCTION("fzyMKs9kim0", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelWaitEqueue);
+    // misc
+    LIB_FUNCTION("WslcK1FQcGI", "libkernel", 1, "libkernel", 1, 1, Kernel::sceKernelIsNeoMode);
+    LIB_FUNCTION("Ou3iL1abvng", "libkernel", 1, "libkernel", 1, 1, stack_chk_fail);
+    
+    Core::Libraries::LibKernel::fileSystemSymbolsRegister(sym);
+    Core::Libraries::LibKernel::timeSymbolsRegister(sym);
+}
+
+} // namespace Core::Libraries::LibKernel

src/core/hle/libraries/libkernel/libkernel.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <sys/types.h>
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Core::Libraries::LibKernel {
+
+int32_t PS4_SYSV_ABI sceKernelReleaseDirectMemory(off_t start, size_t len);
+
+void LibKernel_Register(Loader::SymbolsResolver* sym);
+
+} // namespace Core::Libraries::LibKernel

src/core/hle/libraries/libkernel/time_management.cpp

@@ -1,20 +1,27 @@
-#include "time_management.h"
-
-#include <core/PS4/HLE/Libs.h>
+#include "core/hle/libraries/libkernel/time_management.h"
+#include "core/hle/libraries/libs.h"
 #include "Lib/Timer.h"
 #include "emuTimer.h"
 
 namespace Core::Libraries::LibKernel {
+
 u64 PS4_SYSV_ABI sceKernelGetProcessTime() {
     return static_cast<u64>(Emulator::emuTimer::getTimeMsec() * 1000.0);  // return time in microseconds
 }
-u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter() { return Emulator::emuTimer::getTimeCounter(); }
 
-u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() { return Emulator::emuTimer::getTimeFrequency(); }
+u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter() {
+    return Emulator::emuTimer::getTimeCounter();
+}
 
-u64 PS4_SYSV_ABI sceKernelReadTsc() { return Lib::Timer::getQueryPerformanceCounter(); }
+u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency() {
+    return Emulator::emuTimer::getTimeFrequency();
+}
 
-void timeSymbolsRegister(SymbolsResolver* sym) { 
+u64 PS4_SYSV_ABI sceKernelReadTsc() {
+    return Lib::Timer::getQueryPerformanceCounter();
+}
+
+void timeSymbolsRegister(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("4J2sUJmuHZQ", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTime); 
     LIB_FUNCTION("fgxnMeTNUtY", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTimeCounter);
     LIB_FUNCTION("BNowx2l588E", "libkernel", 1, "libkernel", 1, 1, sceKernelGetProcessTimeCounterFrequency);

src/core/hle/libraries/libkernel/time_management.h

@@ -1,13 +1,18 @@
 #pragma once
 
 #include "common/types.h"
-#include "core/PS4/Loader/SymbolsResolver.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
 
 namespace Core::Libraries::LibKernel {
+
 u64 PS4_SYSV_ABI sceKernelGetProcessTime();
 u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounter();
 u64 PS4_SYSV_ABI sceKernelGetProcessTimeCounterFrequency();
 u64 PS4_SYSV_ABI sceKernelReadTsc();
 
-void timeSymbolsRegister(SymbolsResolver* sym);
-}
+void timeSymbolsRegister(Loader::SymbolsResolver* sym);
+
+} // namespace Core::Libraries::LibKernel

src/core/hle/libraries/libpad/pad.cpp

@@ -1,18 +1,17 @@
-#include "pad.h"
-
-#include <core/PS4/HLE/ErrorCodes.h>
-#include <core/PS4/HLE/Libs.h>
-
-#include "common/singleton.h"
-#include "Emulator/Host/controller.h"
-#include "common/debug.h"
 #include "common/log.h"
+#include "common/singleton.h"
+#include "core/hle/libraries/libpad/pad.h"
+#include "core/hle/error_codes.h"
+#include "core/hle/libraries/libs.h"
+#include "Emulator/Host/controller.h"
 
 namespace Core::Libraries::LibPad {
 
 constexpr bool log_file_pad = true;  // disable it to disable logging
 
-int PS4_SYSV_ABI scePadInit() { return SCE_OK; }
+int PS4_SYSV_ABI scePadInit() {
+    return SCE_OK;
+}
 
 int PS4_SYSV_ABI scePadOpen(Core::Libraries::LibUserService::SceUserServiceUserId userId, s32 type, s32 index,
                             const ScePadOpenParam* pParam) {
@@ -47,7 +46,7 @@ int PS4_SYSV_ABI scePadReadState(int32_t handle, ScePadData* pData) {
     return SCE_OK;
 }
 
-void padSymbolsRegister(SymbolsResolver* sym) {
+void padSymbolsRegister(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("hv1luiJrqQM", "libScePad", 1, "libScePad", 1, 1, scePadInit);
     LIB_FUNCTION("xk0AcarP3V4", "libScePad", 1, "libScePad", 1, 1, scePadOpen);
     LIB_FUNCTION("YndgXqQVV7c", "libScePad", 1, "libScePad", 1, 1, scePadReadState);

src/core/hle/libraries/libpad/pad.h

@@ -1,30 +1,29 @@
 #pragma once
-#include "common/types.h"
 
-#include "core/PS4/Loader/SymbolsResolver.h"
-#include "core/hle/libraries/libuserservice/user_service.h"
+#include "common/types.h"
+#include "core/hle/libraries/libuserservice/libuserservice.h"
 
 namespace Core::Libraries::LibPad {
 
-typedef enum : u32 {
-    SCE_PAD_BUTTON_L3 = 0x00000002,
-    SCE_PAD_BUTTON_R3 = 0x00000004,
-    SCE_PAD_BUTTON_OPTIONS = 0x00000008,
-    SCE_PAD_BUTTON_UP = 0x00000010,
-    SCE_PAD_BUTTON_RIGHT = 0x00000020,
-    SCE_PAD_BUTTON_DOWN = 0x00000040,
-    SCE_PAD_BUTTON_LEFT = 0x00000080,
-    SCE_PAD_BUTTON_L2 = 0x00000100,
-    SCE_PAD_BUTTON_R2 = 0x00000200,
-    SCE_PAD_BUTTON_L1 = 0x00000400,
-    SCE_PAD_BUTTON_R1 = 0x00000800,
-    SCE_PAD_BUTTON_TRIANGLE = 0x00001000,
-    SCE_PAD_BUTTON_CIRCLE = 0x00002000,
-    SCE_PAD_BUTTON_CROSS = 0x00004000,
-    SCE_PAD_BUTTON_SQUARE = 0x00008000,
-    SCE_PAD_BUTTON_TOUCH_PAD = 0x00100000,
-    SCE_PAD_BUTTON_INTERCEPTED = 0x80000000,
-} ScePadButton;
+enum ScePadButton : u32 {
+    L3 = 0x00000002,
+    R3 = 0x00000004,
+    OPTIONS = 0x00000008,
+    UP = 0x00000010,
+    RIGHT = 0x00000020,
+    DOWN = 0x00000040,
+    LEFT = 0x00000080,
+    L2 = 0x00000100,
+    R2 = 0x00000200,
+    L1 = 0x00000400,
+    R1 = 0x00000800,
+    TRIANGLE = 0x00001000,
+    CIRCLE = 0x00002000,
+    CROSS = 0x00004000,
+    SQUARE = 0x00008000,
+    TOUCH_PAD = 0x00100000,
+    INTERCEPTED = 0x80000000,
+};
 
 struct ScePadOpenParam {
     u08 reserve[8];
@@ -88,11 +87,12 @@ struct ScePadData {
     uint8_t deviceUniqueDataLen;
     uint8_t deviceUniqueData[12];
 };
-// hle functions
+
 int PS4_SYSV_ABI scePadInit();
-int PS4_SYSV_ABI scePadOpen(Core::Libraries::LibUserService::SceUserServiceUserId userId, s32 type, s32 index,
+int PS4_SYSV_ABI scePadOpen(LibUserService::SceUserServiceUserId userId, s32 type, s32 index,
                             const ScePadOpenParam* pParam);
 int PS4_SYSV_ABI scePadReadState(int32_t handle, ScePadData* pData);
 
-void padSymbolsRegister(SymbolsResolver* sym);
-};  // namespace Core::Libraries::LibPad
+void padSymbolsRegister(Loader::SymbolsResolver* sym);
+
+};  // namespace Core::Libraries::LibPad

src/core/hle/libraries/libs.cpp

@@ -0,0 +1,22 @@
+#include "core/hle/libraries/libs.h"
+#include "core/PS4/HLE/Graphics/video_out.h"
+#include "core/hle/libraries/libkernel/libkernel.h"
+#include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
+#include "core/hle/libraries/libuserservice/libuserservice.h"
+#include "core/hle/libraries/libpad/pad.h"
+#include "core/hle/libraries/libsystemservice/system_service.h"
+#include "core/hle/libraries/libc/libc.h"
+
+namespace Core::Libraries {
+
+void InitHLELibs(Loader::SymbolsResolver* sym) {
+    LibKernel::LibKernel_Register(sym);
+    HLE::Libs::Graphics::VideoOut::videoOutRegisterLib(sym);
+    LibSceGnmDriver::LibSceGnmDriver_Register(sym);
+    LibUserService::userServiceSymbolsRegister(sym);
+    LibPad::padSymbolsRegister(sym);
+    LibSystemService::systemServiceSymbolsRegister(sym);
+    LibC::libcSymbolsRegister(sym);
+}
+
+}  // namespace Core::Libraries

src/core/hle/libraries/libs.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "core/loader/elf.h"
+#include "core/loader/symbols_resolver.h"
+
+#define LIB_FUNCTION(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function) \
+    {\
+    Loader::SymbolRes sr{}; \
+	sr.name = nid; \
+	sr.library = lib; \
+	sr.library_version = libversion;\
+	sr.module = mod;\
+	sr.module_version_major = moduleVersionMajor;\
+	sr.module_version_minor = moduleVersionMinor;\
+	sr.type = STT_FUN;\
+	auto func = reinterpret_cast<u64>(function);\
+	sym->AddSymbol(sr, func);\
+	}
+
+#define LIB_OBJ(nid, lib, libversion, mod, moduleVersionMajor, moduleVersionMinor, function) \
+    {                                                                                             \
+        Loader::SymbolRes sr{};                                                                   \
+        sr.name = nid;                                                                            \
+        sr.library = lib;                                                                         \
+        sr.library_version = libversion;                                                          \
+        sr.module = mod;                                                                          \
+        sr.module_version_major = moduleVersionMajor;                                             \
+        sr.module_version_minor = moduleVersionMinor;                                             \
+        sr.type = STT_OBJECT;                                                                        \
+        auto func = reinterpret_cast<u64>(function);                                              \
+        sym->AddSymbol(sr, func);                                                                 \
+    }
+
+#define PRINT_FUNCTION_NAME() \
+    { \
+     LOG_INFO_IF(true, "{}()\n", __func__); \
+    }
+
+#define PRINT_DUMMY_FUNCTION_NAME() \
+    { LOG_WARN_IF(true, "dummy {}()\n", __func__); }
+
+namespace Core::Libraries {
+
+void InitHLELibs(Loader::SymbolsResolver* sym);
+
+} // namespace Core::Libraries

src/core/hle/libraries/libscegnmdriver/libscegnmdriver.cpp

@@ -0,0 +1,24 @@
+#include "common/log.h"
+#include "core/PS4/GPU/gpu_memory.h"
+#include "core/hle/libraries/libscegnmdriver/libscegnmdriver.h"
+#include "core/hle/libraries/libs.h"
+#include "emulator.h"
+
+namespace Core::Libraries::LibSceGnmDriver {
+
+int32_t sceGnmSubmitDone() {
+    PRINT_DUMMY_FUNCTION_NAME();
+    return 0;
+}
+
+void sceGnmFlushGarlic() {
+    PRINT_FUNCTION_NAME();
+    GPU::flushGarlic(Emu::getGraphicCtx());
+}
+
+void LibSceGnmDriver_Register(Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("yvZ73uQUqrk", "libSceGnmDriver", 1, "libSceGnmDriver", 1, 1, sceGnmSubmitDone);
+    LIB_FUNCTION("iBt3Oe00Kvc", "libSceGnmDriver", 1, "libSceGnmDriver", 1, 1, sceGnmFlushGarlic);
+}
+    
+};

src/core/hle/libraries/libscegnmdriver/libscegnmdriver.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Core::Libraries::LibSceGnmDriver {
+
+int32_t sceGnmSubmitDone();
+void sceGnmFlushGarlic();
+
+void LibSceGnmDriver_Register(Loader::SymbolsResolver* sym);
+
+}; // namespace Core::Libraries::LibSceGnmDriver

src/core/hle/libraries/libsystemservice/system_service.cpp

@@ -1,7 +1,7 @@
-#include <core/PS4/HLE/ErrorCodes.h>
-#include <core/PS4/HLE/Libs.h>
 #include "common/log.h"
-#include "system_service.h"
+#include "core/hle/error_codes.h"
+#include "core/hle/libraries/libs.h"
+#include "core/hle/libraries/libsystemservice/system_service.h"
 
 namespace Core::Libraries::LibSystemService {
 
@@ -10,7 +10,9 @@ s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen() {
     return SCE_OK;
 }
 
-void systemServiceSymbolsRegister(SymbolsResolver* sym) {
-    LIB_FUNCTION("Vo5V8KAwCmk", "libSceSystemService", 1, "libSceSystemService", 1, 1, sceSystemServiceHideSplashScreen);
+void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("Vo5V8KAwCmk", "libSceSystemService", 1, "libSceSystemService", 1, 1,
+                 sceSystemServiceHideSplashScreen);
 }
-};  // namespace Emulator::HLE::Libraries::LibUserService
+
+}; // namespace Core::Libraries::LibSystemService

src/core/hle/libraries/libsystemservice/system_service.h

@@ -1,11 +1,15 @@
 #pragma once
-#include "core/PS4/Loader/SymbolsResolver.h"
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
 
 namespace Core::Libraries::LibSystemService {
 
-//HLE functions
 s32 PS4_SYSV_ABI sceSystemServiceHideSplashScreen();
 
-void systemServiceSymbolsRegister(SymbolsResolver* sym);
+void systemServiceSymbolsRegister(Loader::SymbolsResolver* sym);
 
-};  // namespace Emulator::HLE::Libraries::LibUserService
+}; // namespace Core::Libraries::LibSystemService

src/core/hle/libraries/libuserservice/libuserservice.cpp

@@ -1,9 +1,7 @@
-#include "user_service.h"
-
-#include <core/PS4/HLE/ErrorCodes.h>
-#include <core/PS4/HLE/Libs.h>
-
 #include "common/log.h"
+#include "core/hle/libraries/libuserservice/libuserservice.h"
+#include "core/hle/error_codes.h"
+#include "core/hle/libraries/libs.h"
 
 namespace Core::Libraries::LibUserService {
 
@@ -21,9 +19,10 @@ s32 PS4_SYSV_ABI sceUserServiceGetLoginUserIdList(SceUserServiceLoginUserIdList*
 
     return SCE_OK;
 }
-void userServiceSymbolsRegister(SymbolsResolver* sym) {
+
+void userServiceSymbolsRegister(Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("j3YMu1MVNNo", "libSceUserService", 1, "libSceUserService", 1, 1, sceUserServiceInitialize);
     LIB_FUNCTION("fPhymKNvK-A", "libSceUserService", 1, "libSceUserService", 1, 1, sceUserServiceGetLoginUserIdList);
 }
 
-}  // namespace Core::Libraries::LibUserService
+} // namespace Core::Libraries::LibUserService

src/core/hle/libraries/libuserservice/libuserservice.h

@@ -1,5 +1,10 @@
 #pragma once
-#include "core/PS4/Loader/SymbolsResolver.h"
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
 
 namespace Core::Libraries::LibUserService {
 
@@ -16,5 +21,6 @@ struct SceUserServiceLoginUserIdList {
 s32 PS4_SYSV_ABI sceUserServiceInitialize(const SceUserServiceInitializeParams* initParams);
 s32 PS4_SYSV_ABI sceUserServiceGetLoginUserIdList(SceUserServiceLoginUserIdList* userIdList);
 
-void userServiceSymbolsRegister(SymbolsResolver* sym);
-};  // namespace Emulator::HLE::Libraries::LibUserService
+void userServiceSymbolsRegister(Loader::SymbolsResolver* sym);
+
+}; // namespace Core::Libraries::LibUserService

src/core/hle/libraries/libuserservice/usr_mng_codes.h

@@ -0,0 +1,12 @@
+#pragma once
+
+//constants
+
+constexpr int SCE_USER_SERVICE_MAX_LOGIN_USERS = 4; //max users logged in at once
+constexpr int SCE_USER_SERVICE_MAX_USER_NAME_LENGTH = 16;//Max length for user name
+
+constexpr int SCE_USER_SERVICE_USER_ID_INVALID = -1;//invalid user ID
+constexpr int SCE_USER_SERVICE_USER_ID_SYSTEM = 255; //generic id for device
+constexpr int SCE_USER_SERVICE_USER_ID_EVERYONE = 254;  // generic id for user (mostly used in common dialogs)
+
+