Merge pull request #131 from shadps4-emu/ngs2_work

Trying for ngs2 lle

src/core/libraries/kernel/thread_management.cpp

@@ -899,6 +899,94 @@ int PS4_SYSV_ABI scePthreadDetach(ScePthread thread) {
     return ORBIS_OK;
 }
 
+ScePthread PS4_SYSV_ABI pthread_self() {
+    return g_pthread_self;
+}
+
+int PS4_SYSV_ABI scePthreadCondSignal(ScePthreadCond* cond) {
+    if (cond == nullptr) {
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+
+    int result = pthread_cond_signal(&(*cond)->cond);
+
+    LOG_INFO(Kernel_Pthread, "scePthreadCondSignal, result={}", result);
+
+    switch (result) {
+    case 0:
+        return SCE_OK;
+    case EBUSY:
+        return SCE_KERNEL_ERROR_EBUSY;
+    default:
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+}
+
+int PS4_SYSV_ABI scePthreadCondWait(ScePthreadCond* cond, ScePthreadMutex* mutex) {
+    if (cond == nullptr || *cond == nullptr) {
+        // return SCE_KERNEL_ERROR_EINVAL;
+        cond = static_cast<ScePthreadCond*>(createCond(cond)); // check this. Kero Blaster.
+    }
+    if (mutex == nullptr || *mutex == nullptr) {
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_cond_wait(&(*cond)->cond, &(*mutex)->pth_mutex);
+
+    LOG_INFO(Kernel_Pthread, "scePthreadCondWait, result={}", result);
+
+    switch (result) {
+    case 0:
+        return SCE_OK;
+    case EINTR:
+        return SCE_KERNEL_ERROR_EINTR;
+    case EAGAIN:
+        return SCE_KERNEL_ERROR_EAGAIN;
+    default:
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+}
+
+int PS4_SYSV_ABI scePthreadCondattrDestroy(ScePthreadCondattr* attr) {
+    if (attr == nullptr) {
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+    int result = pthread_condattr_destroy(&(*attr)->cond_attr);
+
+    LOG_INFO(Kernel_Pthread, "scePthreadCondattrDestroy: result = {} ", result);
+
+    switch (result) {
+    case 0:
+        return SCE_OK;
+    case ENOMEM:
+        return SCE_KERNEL_ERROR_ENOMEM;
+    default:
+        return SCE_KERNEL_ERROR_EINVAL;
+    }
+}
+
+int PS4_SYSV_ABI scePthreadMutexTrylock(ScePthreadMutex* mutex) {
+
+    if (mutex == nullptr) {
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+
+    int result = pthread_mutex_trylock(&(*mutex)->pth_mutex);
+    if (result != 0) {
+        LOG_INFO(Kernel_Pthread, "name={}, result={}", (*mutex)->name, result);
+    }
+    switch (result) {
+    case 0:
+        return ORBIS_OK;
+    case EAGAIN:
+        return ORBIS_KERNEL_ERROR_EAGAIN;
+    case EBUSY:
+        return ORBIS_KERNEL_ERROR_EBUSY;
+    case EINVAL:
+    default:
+        return ORBIS_KERNEL_ERROR_EINVAL;
+    }
+}
+
 void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("4+h9EzwKF4I", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetschedpolicy);
     LIB_FUNCTION("-Wreprtu0Qs", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetdetachstate);
@@ -909,6 +997,7 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("4qGrR6eoP9Y", "libkernel", 1, "libkernel", 1, 1, scePthreadDetach);
 
     LIB_FUNCTION("aI+OeCz8xrQ", "libkernel", 1, "libkernel", 1, 1, scePthreadSelf);
+    LIB_FUNCTION("EotR8a3ASf4", "libkernel", 1, "libkernel", 1, 1, pthread_self);
     LIB_FUNCTION("3qxgM4ezETA", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrSetaffinity);
     LIB_FUNCTION("8+s5BzZjxSg", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGetaffinity);
     LIB_FUNCTION("x1X76arYMxU", "libkernel", 1, "libkernel", 1, 1, scePthreadAttrGet);
@@ -927,10 +1016,14 @@ void pthreadSymbolsRegister(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("1FGvU0i9saQ", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexattrSetprotocol);
     LIB_FUNCTION("9UK1vLZQft4", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexLock);
     LIB_FUNCTION("tn3VlD0hG60", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexUnlock);
+    LIB_FUNCTION("upoVrzMHFeE", "libkernel", 1, "libkernel", 1, 1, scePthreadMutexTrylock);
     // cond calls
     LIB_FUNCTION("2Tb92quprl0", "libkernel", 1, "libkernel", 1, 1, scePthreadCondInit);
     LIB_FUNCTION("m5-2bsNfv7s", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrInit);
     LIB_FUNCTION("JGgj7Uvrl+A", "libkernel", 1, "libkernel", 1, 1, scePthreadCondBroadcast);
+    LIB_FUNCTION("WKAXJ4XBPQ4", "libkernel", 1, "libkernel", 1, 1, scePthreadCondWait);
+    LIB_FUNCTION("waPcxYiR3WA", "libkernel", 1, "libkernel", 1, 1, scePthreadCondattrDestroy);
+    LIB_FUNCTION("kDh-NfxgMtE", "libkernel", 1, "libkernel", 1, 1, scePthreadCondSignal);
     // posix calls
     LIB_FUNCTION("ttHNfU+qDBU", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_init);
     LIB_FUNCTION("7H0iTOciTLo", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_mutex_lock);

src/core/libraries/libc_internal/libc_internal.cpp

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <cmath>
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+#include "libc_internal.h"
+
+namespace Libraries::LibcInternal {
+
+void* PS4_SYSV_ABI internal_memset(void* s, int c, size_t n) {
+    return std::memset(s, c, n);
+}
+
+void* PS4_SYSV_ABI internal_memcpy(void* dest, const void* src, size_t n) {
+    return std::memcpy(dest, src, n);
+}
+
+int PS4_SYSV_ABI internal_memcpy_s(void* dest, rsize_t destsz, const void* src, rsize_t count) {
+#ifdef _WIN64
+    return memcpy_s(dest, destsz, src, count);
+#else
+    std::memcpy(dest, src, count);
+    return 0; // ALL OK
+#endif
+}
+
+int PS4_SYSV_ABI internal_strcpy_s(char* dest, rsize_t dest_size, const char* src) {
+#ifdef _WIN64
+    return strcpy_s(dest, dest_size, src);
+#else
+    std::strcpy(dest, src);
+    return 0; // ALL OK
+#endif
+}
+
+int PS4_SYSV_ABI internal_memcmp(const void* s1, const void* s2, size_t n) {
+    return std::memcmp(s1, s2, n);
+}
+
+float PS4_SYSV_ABI internal_expf(float x) {
+    return expf(x);
+}
+
+void RegisterlibSceLibcInternal(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("NFLs+dRJGNg", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_memcpy_s);
+    LIB_FUNCTION("Q3VBxCXhUHs", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_memcpy);
+    LIB_FUNCTION("8zTFvBIAIN8", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_memset);
+    LIB_FUNCTION("5Xa2ACNECdo", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_strcpy_s);
+    LIB_FUNCTION("DfivPArhucg", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1,
+                 internal_memcmp);
+    LIB_FUNCTION("8zsu04XNsZ4", "libSceLibcInternal", 1, "libSceLibcInternal", 1, 1, internal_expf);
+};
+
+} // namespace Libraries::LibcInternal

src/core/libraries/libc_internal/libc_internal.h

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::LibcInternal {
+void* PS4_SYSV_ABI internal_memset(void* s, int c, size_t n);
+void* PS4_SYSV_ABI internal_memcpy(void* dest, const void* src, size_t n);
+int PS4_SYSV_ABI internal_memcpy_s(void* dest, rsize_t destsz, const void* src, rsize_t count);
+int PS4_SYSV_ABI internal_strcpy_s(char* dest, rsize_t dest_size, const char* src);
+int PS4_SYSV_ABI internal_memcmp(const void* s1, const void* s2, size_t n);
+float PS4_SYSV_ABI internal_expf(float x);
+
+void RegisterlibSceLibcInternal(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::LibcInternal

src/core/libraries/libs.cpp

@@ -7,6 +7,7 @@
 #include "core/libraries/gnmdriver/gnmdriver.h"
 #include "core/libraries/kernel/libkernel.h"
 #include "core/libraries/libc/libc.h"
+#include "core/libraries/libc_internal/libc_internal.h"
 #include "core/libraries/libs.h"
 #include "core/libraries/network/http.h"
 #include "core/libraries/network/net.h"
@@ -57,6 +58,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::NpScore::RegisterlibSceNpScore(sym);
     Libraries::NpTrophy::RegisterlibSceNpTrophy(sym);
     Libraries::ScreenShot::RegisterlibSceScreenShot(sym);
+    Libraries::LibcInternal::RegisterlibSceLibcInternal(sym);
 }
 
 } // namespace Libraries