Merge remote-tracking branch 'upstream/main'

CMakeLists.txt

@@ -276,6 +276,7 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp
                 src/core/libraries/save_data/dialog/savedatadialog_ui.h
                 src/core/libraries/system/sysmodule.cpp
                 src/core/libraries/system/sysmodule.h
+                src/core/libraries/system/system_error.h
                 src/core/libraries/system/systemservice.cpp
                 src/core/libraries/system/systemservice.h
                 src/core/libraries/system/userservice.cpp
@@ -317,6 +318,8 @@ set(SYSTEM_LIBS src/core/libraries/system/commondialog.cpp
                 src/core/libraries/remote_play/remoteplay.h
                 src/core/libraries/share_play/shareplay.cpp
                 src/core/libraries/share_play/shareplay.h
+                src/core/libraries/razor_cpu/razor_cpu.cpp
+                src/core/libraries/razor_cpu/razor_cpu.h
 )
 
 set(VIDEOOUT_LIB src/core/libraries/videoout/buffer.h

src/common/config.cpp

@@ -3,13 +3,14 @@
 
 #include <fstream>
 #include <string>
-#include <common/version.h>
 #include <fmt/core.h>
 #include <fmt/xchar.h> // for wstring support
 #include <toml.hpp>
-#include "common/logging/formatter.h"
+
 #include "common/path_util.h"
 #include "config.h"
+#include "logging/formatter.h"
+#include "version.h"
 
 namespace toml {
 template <typename TC, typename K>
@@ -81,7 +82,8 @@ std::vector<std::string> m_pkg_viewer;
 std::vector<std::string> m_elf_viewer;
 std::vector<std::string> m_recent_files;
 std::string emulator_language = "en";
-// Settings
+
+// Language
 u32 m_language = 1; // english
 
 bool isNeoMode() {
@@ -334,6 +336,7 @@ void setMainWindowGeometry(u32 x, u32 y, u32 w, u32 h) {
     main_window_geometry_w = w;
     main_window_geometry_h = h;
 }
+
 bool addGameInstallDir(const std::filesystem::path& dir) {
     if (std::find(settings_install_dirs.begin(), settings_install_dirs.end(), dir) ==
         settings_install_dirs.end()) {
@@ -342,47 +345,60 @@ bool addGameInstallDir(const std::filesystem::path& dir) {
     }
     return false;
 }
+
 void removeGameInstallDir(const std::filesystem::path& dir) {
     auto iterator = std::find(settings_install_dirs.begin(), settings_install_dirs.end(), dir);
     if (iterator != settings_install_dirs.end()) {
         settings_install_dirs.erase(iterator);
     }
 }
+
 void setAddonInstallDir(const std::filesystem::path& dir) {
     settings_addon_install_dir = dir;
 }
+
 void setMainWindowTheme(u32 theme) {
     mw_themes = theme;
 }
+
 void setIconSize(u32 size) {
     m_icon_size = size;
 }
+
 void setIconSizeGrid(u32 size) {
     m_icon_size_grid = size;
 }
+
 void setSliderPosition(u32 pos) {
     m_slider_pos = pos;
 }
+
 void setSliderPositionGrid(u32 pos) {
     m_slider_pos_grid = pos;
 }
+
 void setTableMode(u32 mode) {
     m_table_mode = mode;
 }
+
 void setMainWindowWidth(u32 width) {
     m_window_size_W = width;
 }
+
 void setMainWindowHeight(u32 height) {
     m_window_size_H = height;
 }
+
 void setPkgViewer(const std::vector<std::string>& pkgList) {
     m_pkg_viewer.resize(pkgList.size());
     m_pkg_viewer = pkgList;
 }
+
 void setElfViewer(const std::vector<std::string>& elfList) {
     m_elf_viewer.resize(elfList.size());
     m_elf_viewer = elfList;
 }
+
 void setRecentFiles(const std::vector<std::string>& recentFiles) {
     m_recent_files.resize(recentFiles.size());
     m_recent_files = recentFiles;
@@ -395,18 +411,23 @@ void setEmulatorLanguage(std::string language) {
 u32 getMainWindowGeometryX() {
     return main_window_geometry_x;
 }
+
 u32 getMainWindowGeometryY() {
     return main_window_geometry_y;
 }
+
 u32 getMainWindowGeometryW() {
     return main_window_geometry_w;
 }
+
 u32 getMainWindowGeometryH() {
     return main_window_geometry_h;
 }
+
 const std::vector<std::filesystem::path>& getGameInstallDirs() {
     return settings_install_dirs;
 }
+
 std::filesystem::path getAddonInstallDir() {
     if (settings_addon_install_dir.empty()) {
         // Default for users without a config file or a config file from before this option existed
@@ -414,36 +435,47 @@ std::filesystem::path getAddonInstallDir() {
     }
     return settings_addon_install_dir;
 }
+
 u32 getMainWindowTheme() {
     return mw_themes;
 }
+
 u32 getIconSize() {
     return m_icon_size;
 }
+
 u32 getIconSizeGrid() {
     return m_icon_size_grid;
 }
+
 u32 getSliderPosition() {
     return m_slider_pos;
 }
+
 u32 getSliderPositionGrid() {
     return m_slider_pos_grid;
 }
+
 u32 getTableMode() {
     return m_table_mode;
 }
+
 u32 getMainWindowWidth() {
     return m_window_size_W;
 }
+
 u32 getMainWindowHeight() {
     return m_window_size_H;
 }
+
 std::vector<std::string> getPkgViewer() {
     return m_pkg_viewer;
 }
+
 std::vector<std::string> getElfViewer() {
     return m_elf_viewer;
 }
+
 std::vector<std::string> getRecentFiles() {
     return m_recent_files;
 }
@@ -455,6 +487,7 @@ std::string getEmulatorLanguage() {
 u32 GetLanguage() {
     return m_language;
 }
+
 void load(const std::filesystem::path& path) {
     // If the configuration file does not exist, create it and return
     std::error_code error;
@@ -545,16 +578,10 @@ void load(const std::filesystem::path& path) {
         m_window_size_W = toml::find_or<int>(gui, "mw_width", 0);
         m_window_size_H = toml::find_or<int>(gui, "mw_height", 0);
 
-        // TODO Migration code, after a major release this should be removed.
+        const auto install_dir_array =
-        auto old_game_install_dir = toml::find_fs_path_or(gui, "installDir", {});
+            toml::find_or<std::vector<std::string>>(gui, "installDirs", {});
-        if (!old_game_install_dir.empty()) {
+        for (const auto& dir : install_dir_array) {
-            addGameInstallDir(std::filesystem::path{old_game_install_dir});
+            addGameInstallDir(std::filesystem::path{dir});
-        } else {
-            const auto install_dir_array =
-                toml::find_or<std::vector<std::string>>(gui, "installDirs", {});
-            for (const auto& dir : install_dir_array) {
-                addGameInstallDir(std::filesystem::path{dir});
-            }
         }
 
         settings_addon_install_dir = toml::find_fs_path_or(gui, "addonInstallDir", {});
@@ -575,6 +602,7 @@ void load(const std::filesystem::path& path) {
         m_language = toml::find_or<int>(settings, "consoleLanguage", 1);
     }
 }
+
 void save(const std::filesystem::path& path) {
     toml::value data;
 
@@ -655,9 +683,6 @@ void save(const std::filesystem::path& path) {
 
     data["Settings"]["consoleLanguage"] = m_language;
 
-    // TODO Migration code, after a major release this should be removed.
-    data.at("GUI").as_table().erase("installDir");
-
     std::ofstream file(path, std::ios::binary);
     file << data;
     file.close();

src/common/logging/filter.cpp

@@ -121,6 +121,7 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Lib, Fiber)                                                                                \
     SUB(Lib, Vdec2)                                                                                \
     SUB(Lib, Videodec)                                                                             \
+    SUB(Lib, RazorCpu)                                                                             \
     CLS(Frontend)                                                                                  \
     CLS(Render)                                                                                    \
     SUB(Render, Vulkan)                                                                            \

src/common/logging/types.h

@@ -88,6 +88,7 @@ enum class Class : u8 {
     Lib_Fiber,             ///< The LibSceFiber implementation.
     Lib_Vdec2,             ///< The LibSceVideodec2 implementation.
     Lib_Videodec,          ///< The LibSceVideodec implementation.
+    Lib_RazorCpu,          ///< The LibRazorCpu implementation.
     Frontend,              ///< Emulator UI
     Render,                ///< Video Core
     Render_Vulkan,         ///< Vulkan backend

src/core/libraries/kernel/file_system.cpp

@@ -502,7 +502,7 @@ s32 PS4_SYSV_ABI sceKernelFsync(int fd) {
 s32 PS4_SYSV_ABI posix_fsync(int fd) {
     s32 result = sceKernelFsync(fd);
     if (result < 0) {
-        LOG_ERROR(Kernel_Pthread, "posix_fstat: error = {}", result);
+        LOG_ERROR(Kernel_Pthread, "posix_fsync: error = {}", result);
         ErrSceToPosix(result);
         return -1;
     }

src/core/libraries/kernel/memory.cpp

@@ -10,6 +10,7 @@
 #include "common/singleton.h"
 #include "core/file_sys/fs.h"
 #include "core/libraries/error_codes.h"
+#include "core/libraries/kernel/kernel.h"
 #include "core/libraries/kernel/memory.h"
 #include "core/libraries/libs.h"
 #include "core/linker.h"
@@ -495,6 +496,16 @@ int PS4_SYSV_ABI sceKernelMunmap(void* addr, size_t len) {
     return SCE_OK;
 }
 
+int PS4_SYSV_ABI posix_munmap(void* addr, size_t len) {
+    int result = sceKernelMunmap(addr, len);
+    if (result < 0) {
+        LOG_ERROR(Kernel_Pthread, "posix_munmap: error = {}", result);
+        ErrSceToPosix(result);
+        return -1;
+    }
+    return result;
+}
+
 void RegisterMemory(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("rTXw65xmLIA", "libkernel", 1, "libkernel", 1, 1, sceKernelAllocateDirectMemory);
     LIB_FUNCTION("B+vc2AO2Zrc", "libkernel", 1, "libkernel", 1, 1,
@@ -517,6 +528,8 @@ void RegisterMemory(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("mL8NDH86iQI", "libkernel", 1, "libkernel", 1, 1, sceKernelMapNamedFlexibleMemory);
     LIB_FUNCTION("aNz11fnnzi4", "libkernel", 1, "libkernel", 1, 1,
                  sceKernelAvailableFlexibleMemorySize);
+    LIB_FUNCTION("aNz11fnnzi4", "libkernel_avlfmem", 1, "libkernel", 1, 1,
+                 sceKernelAvailableFlexibleMemorySize);
     LIB_FUNCTION("IWIBBdTHit4", "libkernel", 1, "libkernel", 1, 1, sceKernelMapFlexibleMemory);
     LIB_FUNCTION("p5EcQeEeJAE", "libkernel", 1, "libkernel", 1, 1,
                  _sceKernelRtldSetApplicationHeapAPI);
@@ -537,6 +550,8 @@ void RegisterMemory(Core::Loader::SymbolsResolver* sym) {
 
     LIB_FUNCTION("BPE9s9vQQXo", "libkernel", 1, "libkernel", 1, 1, posix_mmap);
     LIB_FUNCTION("BPE9s9vQQXo", "libScePosix", 1, "libkernel", 1, 1, posix_mmap);
+    LIB_FUNCTION("UqDGjXA5yUM", "libkernel", 1, "libkernel", 1, 1, posix_munmap);
+    LIB_FUNCTION("UqDGjXA5yUM", "libScePosix", 1, "libkernel", 1, 1, posix_munmap);
 }
 
 } // namespace Libraries::Kernel

src/core/libraries/kernel/threads/pthread.cpp

@@ -421,29 +421,27 @@ int PS4_SYSV_ABI scePthreadGetprio(PthreadT thread, int* priority) {
     return 0;
 }
 
-int PS4_SYSV_ABI scePthreadSetprio(PthreadT thread, int prio) {
+int PS4_SYSV_ABI posix_pthread_setprio(PthreadT thread, int prio) {
     SchedParam param;
-    int ret;
 
     param.sched_priority = prio;
 
     auto* thread_state = ThrState::Instance();
     if (thread == g_curthread) {
         g_curthread->lock.lock();
-    } else if (int ret = thread_state->FindThread(thread, /*include dead*/ 0)) {
+    } else if (int ret = thread_state->FindThread(thread, /*include dead*/ 0); ret != 0) {
         return ret;
     }
 
     if (thread->attr.sched_policy == SchedPolicy::Other || thread->attr.prio == prio) {
         thread->attr.prio = prio;
-        ret = 0;
     } else {
         // TODO: _thr_setscheduler
         thread->attr.prio = prio;
     }
 
     thread->lock.unlock();
-    return ret;
+    return 0;
 }
 
 enum class PthreadCancelState : u32 {
@@ -495,6 +493,8 @@ void RegisterThread(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("OxhIB8LB-PQ", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_create);
     LIB_FUNCTION("Jmi+9w9u0E4", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_create_name_np);
     LIB_FUNCTION("lZzFeSxPl08", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_setcancelstate);
+    LIB_FUNCTION("a2P9wYGeZvc", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_setprio);
+    LIB_FUNCTION("FIs3-UQT9sg", "libScePosix", 1, "libkernel", 1, 1, posix_pthread_getschedparam);
     LIB_FUNCTION("6XG4B33N09g", "libScePosix", 1, "libkernel", 1, 1, sched_yield);
 
     // Posix-Kernel
@@ -517,7 +517,7 @@ void RegisterThread(Core::Loader::SymbolsResolver* sym) {
     LIB_FUNCTION("T72hz6ffq08", "libkernel", 1, "libkernel", 1, 1, posix_pthread_yield);
     LIB_FUNCTION("EI-5-jlq2dE", "libkernel", 1, "libkernel", 1, 1, posix_pthread_getthreadid_np);
     LIB_FUNCTION("1tKyG7RlMJo", "libkernel", 1, "libkernel", 1, 1, scePthreadGetprio);
-    LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, scePthreadSetprio);
+    LIB_FUNCTION("W0Hpm2X0uPE", "libkernel", 1, "libkernel", 1, 1, ORBIS(posix_pthread_setprio));
     LIB_FUNCTION("rNhWz+lvOMU", "libkernel", 1, "libkernel", 1, 1, _sceKernelSetThreadDtors);
     LIB_FUNCTION("6XG4B33N09g", "libkernel", 1, "libkernel", 1, 1, sched_yield);
 }

src/core/libraries/kernel/threads/pthread_attr.cpp

@@ -303,6 +303,8 @@ void RegisterThreadAttr(Core::Loader::SymbolsResolver* sym) {
                  posix_pthread_attr_getstacksize);
     LIB_FUNCTION("VUT1ZSrHT0I", "libScePosix", 1, "libkernel", 1, 1,
                  posix_pthread_attr_getdetachstate);
+    LIB_FUNCTION("JKyG3SWyA10", "libScePosix", 1, "libkernel", 1, 1,
+                 posix_pthread_attr_setguardsize);
 
     // Orbis
     LIB_FUNCTION("4+h9EzwKF4I", "libkernel", 1, "libkernel", 1, 1,

src/core/libraries/kernel/threads/pthread_spec.cpp

@@ -150,6 +150,7 @@ void RegisterSpec(Core::Loader::SymbolsResolver* sym) {
 
     // Orbis
     LIB_FUNCTION("geDaqgH9lTg", "libkernel", 1, "libkernel", 1, 1, ORBIS(posix_pthread_key_create));
+    LIB_FUNCTION("PrdHuuDekhY", "libkernel", 1, "libkernel", 1, 1, ORBIS(posix_pthread_key_delete));
     LIB_FUNCTION("eoht7mQOCmo", "libkernel", 1, "libkernel", 1, 1, posix_pthread_getspecific);
     LIB_FUNCTION("+BzXYkqYeLE", "libkernel", 1, "libkernel", 1, 1,
                  ORBIS(posix_pthread_setspecific));

src/core/libraries/libs.cpp

@@ -28,6 +28,7 @@
 #include "core/libraries/pad/pad.h"
 #include "core/libraries/playgo/playgo.h"
 #include "core/libraries/random/random.h"
+#include "core/libraries/razor_cpu/razor_cpu.h"
 #include "core/libraries/remote_play/remoteplay.h"
 #include "core/libraries/rtc/rtc.h"
 #include "core/libraries/save_data/dialog/savedatadialog.h"
@@ -87,6 +88,7 @@ void InitHLELibs(Core::Loader::SymbolsResolver* sym) {
     Libraries::SharePlay::RegisterlibSceSharePlay(sym);
     Libraries::Remoteplay::RegisterlibSceRemoteplay(sym);
     Libraries::Videodec::RegisterlibSceVideodec(sym);
+    Libraries::RazorCpu::RegisterlibSceRazorCpu(sym);
 }
 
 } // namespace Libraries

src/core/libraries/razor_cpu/razor_cpu.cpp

@@ -0,0 +1,249 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "razor_cpu.h"
+
+#include "common/logging/log.h"
+#include "core/libraries/error_codes.h"
+#include "core/libraries/libs.h"
+
+namespace Libraries::RazorCpu {
+
+s32 PS4_SYSV_ABI sceRazorCpuBeginLogicalFileAccess() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void PS4_SYSV_ABI sceRazorCpuDisableFiberUserMarkers() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuEndLogicalFileAccess() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuFiberLogNameChange() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuFiberSwitch() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+bool PS4_SYSV_ABI sceRazorCpuFlushOccurred() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return false;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuGetDataTagStorageSize() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuGpuMarkerSync() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuInitDataTags() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuInitializeGpuMarkerContext() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuInitializeInternal() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+bool PS4_SYSV_ABI sceRazorCpuIsCapturing() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return false;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuJobManagerDispatch() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuJobManagerJob() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuJobManagerSequence() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuNamedSync() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuPlotValue() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuPopMarker() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuPushMarker() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuPushMarkerStatic() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuResizeTaggedBuffer() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void PS4_SYSV_ABI sceRazorCpuSetPopMarkerCallback() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+}
+
+void PS4_SYSV_ABI sceRazorCpuSetPushMarkerCallback() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+}
+
+void PS4_SYSV_ABI sceRazorCpuSetPushMarkerStaticCallback() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuShutdownDataTags() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuStartCaptureInternal() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuStopCaptureInternal() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuSync() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuTagArray() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuTagBuffer() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuUnTagBuffer() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuWorkloadRunBegin() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuWorkloadRunEnd() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuWorkloadSubmit() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+s32 PS4_SYSV_ABI sceRazorCpuWriteBookmark() {
+    LOG_DEBUG(Lib_RazorCpu, "(STUBBED) called");
+    return ORBIS_OK;
+}
+
+void RegisterlibSceRazorCpu(Core::Loader::SymbolsResolver* sym) {
+    LIB_FUNCTION("JFzLJBlYIJE", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuBeginLogicalFileAccess);
+    LIB_FUNCTION("SfRTRZ1Sh+U", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuDisableFiberUserMarkers);
+    LIB_FUNCTION("gVioM9cbiDs", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuEndLogicalFileAccess);
+    LIB_FUNCTION("G90IIOtgFQ0", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuFiberLogNameChange);
+    LIB_FUNCTION("PAytDtFGpqY", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuFiberSwitch);
+    LIB_FUNCTION("sPhrQD31ClM", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuFlushOccurred);
+    LIB_FUNCTION("B782NptkGUc", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuGetDataTagStorageSize);
+    LIB_FUNCTION("EH9Au2RlSrE", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuGpuMarkerSync);
+    LIB_FUNCTION("A7oRMdaOJP8", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuInitDataTags);
+    LIB_FUNCTION("NFwh-J-BrI0", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuInitializeGpuMarkerContext);
+    LIB_FUNCTION("ElNyedXaa4o", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuInitializeInternal);
+    LIB_FUNCTION("EboejOQvLL4", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuIsCapturing);
+    LIB_FUNCTION("dnEdyY4+klQ", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuJobManagerDispatch);
+    LIB_FUNCTION("KP+TBWGHlgs", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuJobManagerJob);
+    LIB_FUNCTION("9FowWFMEIM8", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuJobManagerSequence);
+    LIB_FUNCTION("XCuZoBSVFG8", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuNamedSync);
+    LIB_FUNCTION("njGikRrxkC0", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuPlotValue);
+    LIB_FUNCTION("YpkGsMXP3ew", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuPopMarker);
+    LIB_FUNCTION("zw+celG7zSI", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuPushMarker);
+    LIB_FUNCTION("uZrOwuNJX-M", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuPushMarkerStatic);
+    LIB_FUNCTION("D0yUjM33QqU", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuResizeTaggedBuffer);
+    LIB_FUNCTION("jqYWaTfgZs0", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuSetPopMarkerCallback);
+    LIB_FUNCTION("DJsHcEb94n0", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuSetPushMarkerCallback);
+    LIB_FUNCTION("EZtqozPTS4M", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuSetPushMarkerStaticCallback);
+    LIB_FUNCTION("emklx7RK-LY", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuShutdownDataTags);
+    LIB_FUNCTION("TIytAjYeaik", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuStartCaptureInternal);
+    LIB_FUNCTION("jWpkVWdMrsM", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuStopCaptureInternal);
+    LIB_FUNCTION("Ax7NjOzctIM", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuSync);
+    LIB_FUNCTION("we3oTKSPSTw", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuTagArray);
+    LIB_FUNCTION("vyjdThnQfQQ", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1, sceRazorCpuTagBuffer);
+    LIB_FUNCTION("0yNHPIkVTmw", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuUnTagBuffer);
+    LIB_FUNCTION("Crha9LvwvJM", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuWorkloadRunBegin);
+    LIB_FUNCTION("q1GxBfGHO0s", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuWorkloadRunEnd);
+    LIB_FUNCTION("6rUvx-6QmYc", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuWorkloadSubmit);
+    LIB_FUNCTION("G3brhegfyNg", "libSceRazorCpu", 1, "libSceRazorCpu", 1, 1,
+                 sceRazorCpuWriteBookmark);
+}
+
+} // namespace Libraries::RazorCpu

src/core/libraries/razor_cpu/razor_cpu.h

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/types.h"
+
+#include <atomic>
+#include <memory>
+
+namespace Core::Loader {
+class SymbolsResolver;
+}
+
+namespace Libraries::RazorCpu {
+void RegisterlibSceRazorCpu(Core::Loader::SymbolsResolver* sym);
+} // namespace Libraries::RazorCpu

src/core/libraries/system/sysmodule.cpp

@@ -9,6 +9,7 @@
 #include "core/libraries/error_codes.h"
 #include "core/libraries/libs.h"
 #include "core/libraries/system/sysmodule.h"
+#include "core/libraries/system/system_error.h"
 
 namespace Libraries::SysModule {
 
@@ -34,11 +35,19 @@ int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded() {
 
 int PS4_SYSV_ABI sceSysmoduleIsLoaded(OrbisSysModule id) {
     LOG_ERROR(Lib_SysModule, "(DUMMY) called module = {}", magic_enum::enum_name(id));
+    if (static_cast<u16>(id) == 0) {
+        LOG_ERROR(Lib_SysModule, "Invalid sysmodule ID: {:#x}", static_cast<u16>(id));
+        return ORBIS_SYSMODULE_INVALID_ID;
+    }
     return ORBIS_OK;
 }
 
-int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal() {
+int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal(OrbisSysModuleInternal id) {
-    LOG_ERROR(Lib_SysModule, "(STUBBED) called");
+    LOG_ERROR(Lib_SysModule, "(DUMMY) called module = {:#x}", static_cast<u32>(id));
+    if ((static_cast<u32>(id) & 0x7FFFFFFF) == 0) {
+        LOG_ERROR(Lib_SysModule, "Invalid internal sysmodule ID: {:#x}", static_cast<u32>(id));
+        return ORBIS_SYSMODULE_INVALID_ID;
+    }
     return ORBIS_OK;
 }
 

src/core/libraries/system/sysmodule.h

@@ -147,12 +147,16 @@ enum class OrbisSysModule : u16 {
     ORBIS_SYSMODULE_KEYBOARD = 0x0106,
 };
 
+enum class OrbisSysModuleInternal : u32 {
+    ORBIS_SYSMODULE_INTERNAL_RAZOR_CPU = 0x80000019, // libSceRazorCpu.sprx
+};
+
 int PS4_SYSV_ABI sceSysmoduleGetModuleHandleInternal();
 int PS4_SYSV_ABI sceSysmoduleGetModuleInfoForUnwind();
 int PS4_SYSV_ABI sceSysmoduleIsCalledFromSysModule();
 int PS4_SYSV_ABI sceSysmoduleIsCameraPreloaded();
 int PS4_SYSV_ABI sceSysmoduleIsLoaded(OrbisSysModule id);
-int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal();
+int PS4_SYSV_ABI sceSysmoduleIsLoadedInternal(OrbisSysModuleInternal id);
 int PS4_SYSV_ABI sceSysmoduleLoadModule(OrbisSysModule id);
 int PS4_SYSV_ABI sceSysmoduleLoadModuleByNameInternal();
 int PS4_SYSV_ABI sceSysmoduleLoadModuleInternal();

src/core/libraries/system/system_error.h

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+constexpr int ORBIS_SYSMODULE_INVALID_ID = 0x805A1000;
+constexpr int ORBIS_SYSMODULE_NOT_LOADED = 0x805A1001;
+constexpr int ORBIS_SYSMODULE_LOCK_FAILED = 0x805A10FF;

src/emulator.cpp

@@ -269,7 +269,7 @@ void Emulator::Run(const std::filesystem::path& file) {
 }
 
 void Emulator::LoadSystemModules(const std::filesystem::path& file, std::string game_serial) {
-    constexpr std::array<SysModules, 11> ModulesToLoad{
+    constexpr std::array<SysModules, 10> ModulesToLoad{
         {{"libSceNgs2.sprx", &Libraries::Ngs2::RegisterlibSceNgs2},
          {"libSceFiber.sprx", &Libraries::Fiber::RegisterlibSceFiber},
          {"libSceUlt.sprx", nullptr},
@@ -279,7 +279,6 @@ void Emulator::LoadSystemModules(const std::filesystem::path& file, std::string
          {"libSceDiscMap.sprx", &Libraries::DiscMap::RegisterlibSceDiscMap},
          {"libSceRtc.sprx", &Libraries::Rtc::RegisterlibSceRtc},
          {"libSceJpegEnc.sprx", nullptr},
-         {"libSceRazorCpu.sprx", nullptr},
          {"libSceCesCs.sprx", nullptr}}};
 
     std::vector<std::filesystem::path> found_modules;