Merge branch 'main' into bb-hacks

.github/workflows/macos-qt.yml

@@ -50,7 +50,6 @@ jobs:
       run: |
         mkdir upload
         mv ${{github.workspace}}/build/shadps4.app upload
-        mv ${{github.workspace}}/build/translations upload
         macdeployqt upload/shadps4.app
         tar cf shadps4-macos-qt.tar.gz -C upload .
 

.github/workflows/windows-qt.yml

@@ -40,7 +40,6 @@ jobs:
       run: |
         mkdir upload
         move build/Release/shadPS4.exe upload
-        move build/translations upload
         windeployqt --dir upload upload/shadPS4.exe
 
     - name: Upload executable

CMakeLists.txt

@@ -636,7 +636,7 @@ target_link_libraries(shadps4 PRIVATE Boost::headers GPUOpen::VulkanMemoryAlloca
 
 if (APPLE)
   # Reserve system-managed memory space.
-  target_link_options(shadps4 PRIVATE -Wl,-no_pie,-no_fixup_chains,-no_huge,-pagezero_size,0x400000,-segaddr,GUEST_SYSTEM,0x400000,-image_base,0x10000000000)
+  target_link_options(shadps4 PRIVATE -Wl,-no_pie,-no_fixup_chains,-no_huge,-pagezero_size,0x400000,-segaddr,GUEST_SYSTEM,0x400000,-image_base,0x20000000000)
 
   # Link MoltenVK for Vulkan support
   find_library(MOLTENVK MoltenVK REQUIRED)

src/core/cpu_patches.cpp

@@ -126,39 +126,35 @@ static Xbyak::Reg AllocateScratchRegister(
 static pthread_key_t stack_pointer_slot;
 static pthread_key_t patch_stack_slot;
 static std::once_flag patch_context_slots_init_flag;
+static constexpr u32 patch_stack_size = 0x1000;
 
 static_assert(sizeof(void*) == sizeof(u64),
               "Cannot fit a register inside a thread local storage slot.");
 
+static void FreePatchStack(void* patch_stack) {
+    // Subtract back to the bottom of the stack for free.
+    std::free(static_cast<u8*>(patch_stack) - patch_stack_size);
+}
+
 static void InitializePatchContextSlots() {
     ASSERT_MSG(pthread_key_create(&stack_pointer_slot, nullptr) == 0,
                "Unable to allocate thread-local register for stack pointer.");
-    ASSERT_MSG(pthread_key_create(&patch_stack_slot, nullptr) == 0,
+    ASSERT_MSG(pthread_key_create(&patch_stack_slot, FreePatchStack) == 0,
                "Unable to allocate thread-local register for patch stack.");
 }
 
 void InitializeThreadPatchStack() {
     std::call_once(patch_context_slots_init_flag, InitializePatchContextSlots);
 
-    const auto* patch_stack = std::malloc(0x1000);
-    pthread_setspecific(patch_stack_slot, patch_stack);
-}
-
-void CleanupThreadPatchStack() {
-    std::call_once(patch_context_slots_init_flag, InitializePatchContextSlots);
-
-    auto* patch_stack = pthread_getspecific(patch_stack_slot);
-    if (patch_stack != nullptr) {
-        std::free(patch_stack);
-        pthread_setspecific(patch_stack_slot, nullptr);
-    }
+    pthread_setspecific(patch_stack_slot,
+                        static_cast<u8*>(std::malloc(patch_stack_size)) + patch_stack_size);
 }
 
 /// Saves the stack pointer to thread local storage and loads the patch stack.
 static void SaveStack(Xbyak::CodeGenerator& c) {
     std::call_once(patch_context_slots_init_flag, InitializePatchContextSlots);
 
-    // Save stack pointer and load patch stack.
+    // Save original stack pointer and load patch stack.
     c.putSeg(gs);
     c.mov(qword[reinterpret_cast<void*>(stack_pointer_slot * sizeof(void*))], rsp);
     c.putSeg(gs);
@@ -184,10 +180,6 @@ void InitializeThreadPatchStack() {
     // No-op
 }
 
-void CleanupThreadPatchStack() {
-    // No-op
-}
-
 /// Saves the stack pointer to thread local storage and loads the patch stack.
 static void SaveStack(Xbyak::CodeGenerator& c) {
     UNIMPLEMENTED();
@@ -244,7 +236,7 @@ static void RestoreContext(Xbyak::CodeGenerator& c, const Xbyak::Operand& dst) {
         if (!dst.isREG() || dst.getIdx() != reg) {
             c.pop(Xbyak::Reg64(reg));
         } else {
-            c.add(rsp, 4);
+            c.add(rsp, 8);
         }
     }
     RestoreStack(c);

src/core/file_format/pkg.cpp

@@ -258,6 +258,11 @@ bool PKG::Extract(const std::filesystem::path& filepath, const std::filesystem::
 
         // Retrieve PFSC from decrypted pfs_image.
         pfsc_offset = GetPFSCOffset(pfs_decrypted);
+        if (pfsc_offset == (u32)-1) {
+            failreason = "Could not retrieve PFSC from decrypted pfs_image";
+            return false;
+        }
+        
         std::memcpy(pfsc.data(), pfs_decrypted.data() + pfsc_offset, length - pfsc_offset);
 
         PFSCHdr pfsChdr;

src/core/libraries/gnmdriver/gnmdriver.cpp

@@ -2346,9 +2346,9 @@ s32 PS4_SYSV_ABI sceGnmUpdateVsShader(u32* cmdbuf, u32 size, const u32* vs_regs,
     return ORBIS_OK;
 }
 
-int PS4_SYSV_ABI sceGnmValidateCommandBuffers() {
-    LOG_ERROR(Lib_GnmDriver, "(STUBBED) called");
-    return ORBIS_OK;
+s32 PS4_SYSV_ABI sceGnmValidateCommandBuffers() {
+    LOG_TRACE(Lib_GnmDriver, "called");
+    return ORBIS_GNM_ERROR_VALIDATION_NOT_ENABLED; // not available in retail FW;
 }
 
 int PS4_SYSV_ABI sceGnmValidateDisableDiagnostics() {

src/core/libraries/gnmdriver/gnmdriver.h

@@ -223,7 +223,7 @@ s32 PS4_SYSV_ABI sceGnmUpdatePsShader(u32* cmdbuf, u32 size, const u32* ps_regs)
 s32 PS4_SYSV_ABI sceGnmUpdatePsShader350(u32* cmdbuf, u32 size, const u32* ps_regs);
 s32 PS4_SYSV_ABI sceGnmUpdateVsShader(u32* cmdbuf, u32 size, const u32* vs_regs,
                                       u32 shader_modifier);
-int PS4_SYSV_ABI sceGnmValidateCommandBuffers();
+s32 PS4_SYSV_ABI sceGnmValidateCommandBuffers();
 int PS4_SYSV_ABI sceGnmValidateDisableDiagnostics();
 int PS4_SYSV_ABI sceGnmValidateDisableDiagnostics2();
 int PS4_SYSV_ABI sceGnmValidateDispatchCommandBuffers();

src/core/libraries/kernel/thread_management.cpp

@@ -987,15 +987,14 @@ static void cleanup_thread(void* arg) {
             destructor(value);
         }
     }
-    Core::CleanupThreadPatchStack();
     thread->is_almost_done = true;
 }
 
 static void* run_thread(void* arg) {
     auto* thread = static_cast<ScePthread>(arg);
     Common::SetCurrentThreadName(thread->name.c_str());
-    auto* linker = Common::Singleton<Core::Linker>::Instance();
     Core::InitializeThreadPatchStack();
+    auto* linker = Common::Singleton<Core::Linker>::Instance();
     linker->InitTlsForThread(false);
     void* ret = nullptr;
     g_pthread_self = thread;

src/core/linker.cpp

@@ -85,8 +85,8 @@ void Linker::Execute() {
 
     // Init primary thread.
     Common::SetCurrentThreadName("GAME_MainThread");
-    Libraries::Kernel::pthreadInitSelfMainThread();
     InitializeThreadPatchStack();
+    Libraries::Kernel::pthreadInitSelfMainThread();
     InitTlsForThread(true);
 
     // Start shared library modules
@@ -106,8 +106,6 @@ void Linker::Execute() {
             RunMainEntry(m->GetEntryAddress(), &p, ProgramExitFunc);
         }
     }
-
-    CleanupThreadPatchStack();
 }
 
 s32 Linker::LoadModule(const std::filesystem::path& elf_name, bool is_dynamic) {

src/video_core/renderer_vulkan/vk_instance.cpp

@@ -220,12 +220,12 @@ bool Instance::CreateDevice() {
     const bool maintenance5 = add_extension(VK_KHR_MAINTENANCE_5_EXTENSION_NAME);
     add_extension(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
     add_extension(VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME);
-    const bool has_sync2 = add_extension(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
 
-    if (has_sync2) {
-        has_nv_checkpoints = Config::isMarkersEnabled()
-                                 ? add_extension(VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME)
-                                 : false;
+    if (Config::isMarkersEnabled()) {
+        const bool has_sync2 = add_extension(VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME);
+        if (has_sync2) {
+            has_nv_checkpoints = add_extension(VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME);
+        }
     }
 
 #ifdef __APPLE__