feat: macOS host support (Apple Silicon via Rosetta 2, Vulkan on MoltenVK)

CMakeLists.txt

@@ -344,6 +344,10 @@ set(LIBUSB_INSTALL_TARGETS OFF CACHE BOOL "" FORCE)
 set(LIBUSB_BUILD_TESTING OFF CACHE BOOL "" FORCE)
 set(LIBUSB_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
 set(LIBUSB_ENABLE_UDEV OFF CACHE BOOL "" FORCE)
+if(APPLE)
+    # Newer SDKs declare pipe2 as macOS 27+, so on older systems the weak symbol is null and libusb_init crashes; use pipe+fcntl.
+    set(HAVE_PIPE2 "" CACHE INTERNAL "")
+endif()
 add_subdirectory(3rdparty/libusb-cmake EXCLUDE_FROM_ALL)
 set_target_properties(usb-1.0 PROPERTIES POSITION_INDEPENDENT_CODE ON)
 

core/libs/CMakeLists.txt

@@ -60,6 +60,11 @@ function(configure_windows_unwind target)
                 COMMAND "${CMAKE_OBJCOPY}" --rename-section .eh_frame=.ehfram --rename-section .eh_fram=.ehfram "$<TARGET_FILE:${target}>"
                 VERBATIM
         )
+    elseif(APPLE)
+        # The guest unwinder (prx/libc/src/exception/Unwind.cpp) reads __eh_frame, but Apple clang emits compact
+        # unwind and ld64 keeps only __unwind_info, so a guest throw could not step out of these images' frames.
+        target_compile_options(${target} PRIVATE -femit-dwarf-unwind=always)
+        target_link_options(${target} PRIVATE LINKER:-no_compact_unwind)
     endif()
 endfunction()
 
@@ -310,6 +315,10 @@ if(BUILD_TESTING)
         target_link_options(patched_libraries_tests PRIVATE -static -static-libgcc -static-libstdc++)
     endif()
     add_test(NAME patched_libraries COMMAND patched_libraries_tests ${PATCHED_DIR})
+    if(APPLE)
+        # The first run after a rebuild waits for Rosetta to translate every patched library (minutes under a parallel suite); later runs take seconds.
+        set_tests_properties(patched_libraries PROPERTIES TIMEOUT 900)
+    endif()
     if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
         add_library(host_libstdcxx_exception_module SHARED tests/HostLibstdcxxExceptionModule.cpp)
         target_link_libraries(host_libstdcxx_exception_module PRIVATE ${PATCHED_DIR}/libc.prx)

core/libs/nid/tests/test_dynamic_strings.py

@@ -9,9 +9,32 @@
 DT_RPATH = 15
 DT_RUNPATH = 29
 SHT_DYNAMIC = 6
+MH_MAGIC_64 = 0xFEEDFACF
+LC_LOAD_DYLIB = 0x0C
+LC_RPATH = 0x8000001C
+
+
+def load_command_strings(image):
+    # macOS builds the fixture as Mach-O: LC_LOAD_DYLIB and LC_RPATH hold what DT_NEEDED and DT_RUNPATH hold in ELF.
+    commands, = struct.unpack_from("<I", image, 0x10)
+    entries = []
+    position = 0x20
+    for _ in range(commands):
+        command, size = struct.unpack_from("<II", image, position)
+        if command in (LC_LOAD_DYLIB, LC_RPATH):
+            offset, = struct.unpack_from("<I", image, position + 8)
+            assert offset < size, (command, offset, size)
+            start = position + offset
+            end = image.index(0, start)
+            assert end < position + size, (command, start, end)
+            entries.append((DT_NEEDED if command == LC_LOAD_DYLIB else DT_RUNPATH, image[start:end].decode()))
+        position += size
+    return entries
 
 
 def dynamic_strings(image):
+    if struct.unpack_from("<I", image, 0)[0] == MH_MAGIC_64:
+        return load_command_strings(image)
     shoff, = struct.unpack_from("<Q", image, 0x28)
     shentsize, shnum = struct.unpack_from("<HH", image, 0x3A)
     sections = [struct.unpack_from("<IIQQQQIIQQ", image, shoff + index * shentsize) for index in range(shnum)]
@@ -30,11 +53,15 @@ def dynamic_strings(image):
 
 
 def main():
-    entries = dynamic_strings(Path(sys.argv[1]).read_bytes())
+    image = Path(sys.argv[1]).read_bytes()
+    entries = dynamic_strings(image)
     runpaths = [value for tag, value in entries if tag in (DT_RPATH, DT_RUNPATH)]
     assert runpaths == ["$ORIGIN"], entries
     needed = [value for tag, value in entries if tag == DT_NEEDED]
-    assert needed and all(re.fullmatch(r"[\w.+-]+\.so(\.\d+)*", name) for name in needed), entries
+    if struct.unpack_from("<I", image, 0)[0] == MH_MAGIC_64:
+        assert needed and all(re.fullmatch(r"(/[\w.+-]+)+\.dylib", name) for name in needed), entries
+    else:
+        assert needed and all(re.fullmatch(r"[\w.+-]+\.so(\.\d+)*", name) for name in needed), entries
     print("NID patcher dynamic string tests passed")
 
 

core/libs/prx/libSceAgc/tests/StaticBuffer.cpp

@@ -1,5 +1,8 @@
 #include "prx/libSceAgc/Misc/include/StaticBuffer.hpp"
 #include "prx/libc/include/GuestArena.hpp"
+#ifdef __APPLE__
+#include "prx/libSceAgcDriver/Execution/include/Driver/DriverMemory.hpp"
+#endif
 
 #include <array>
 #include <cstdint>
@@ -9,7 +12,12 @@
 
 namespace {
 
+#ifdef __APPLE__
+// macOS owns the console's 0xfe0040000; the driver keeps its block lower in the guest range (DriverMemory.hpp).
+constexpr std::uintptr_t StaticTable = AgcDriver::DriverDetail::RetargetPs5DriverMemory(0xfe0040000ull) + GuestArena::GuestAddressOffset;
+#else
 constexpr std::uintptr_t StaticTable = 0xfe0040000ull + GuestArena::GuestAddressOffset;
+#endif
 constexpr int InvalidStaticBuffer = static_cast<int>(0x8a6c000bu);
 
 void check(bool condition, const char* message) {

core/libs/prx/libSceAgcDriver/CMakeLists.txt

@@ -803,7 +803,8 @@ if(BUILD_TESTING)
     if(WIN32)
         set_tests_properties(agc_thread_priority PROPERTIES ENVIRONMENT_MODIFICATION
             "PATH=path_list_prepend:$<TARGET_FILE_DIR:libc>")
-    else()
+    elseif(NOT APPLE)
+        # The refusal is provoked by pointing rtkit's D-Bus at nothing; macOS has no rtkit to refuse.
         foreach(mode rt high)
             add_test(NAME agc_thread_priority_refused_${mode} COMMAND agc_thread_priority_tests refused)
             set_tests_properties(agc_thread_priority_refused_${mode} PROPERTIES ENVIRONMENT
@@ -2885,7 +2886,7 @@ if(BUILD_TESTING)
         set_tests_properties(agc_driver_pm4_failure agc_driver_pm4_failure_inline agc_descriptor_pool_reset_failure agc_descriptor_cache agc_driver_address_space_teardown PROPERTIES ENVIRONMENT_MODIFICATION
             "PATH=path_list_prepend:$<TARGET_FILE_DIR:libc>")
     endif()
-    if(NOT WIN32)
+    if(NOT WIN32 AND NOT APPLE)
         add_test(NAME agc_driver_pm4_priority_refused COMMAND agc_driver_pm4_tests priority-refused)
         set_tests_properties(agc_driver_pm4_priority_refused PROPERTIES ENVIRONMENT
             "ANYPS5_NO_SHADER_CACHE=1;APS5_THREAD_PRIORITY=high;DBUS_SYSTEM_BUS_ADDRESS=unix:path=/nonexistent/aps5-no-rtkit" SKIP_RETURN_CODE 77)

core/libs/prx/libSceAgcDriver/Execution/include/Driver/DriverMemory.hpp

@@ -0,0 +1,26 @@
+#ifndef CORE_LIBS_PRX_LIBSCEAGCDRIVER_EXECUTION_INCLUDE_DRIVER_DRIVERMEMORY_HPP
+#define CORE_LIBS_PRX_LIBSCEAGCDRIVER_EXECUTION_INCLUDE_DRIVER_DRIVERMEMORY_HPP
+
+#ifdef __APPLE__
+
+#include <cstdint>
+
+namespace AgcDriver::DriverDetail {
+
+// The AGC driver's own guest block (the FS table, its routine table and routine; Lifecycle.cpp) is at
+// 0xfe0000000 on the console. macOS itself owns 0xfc0000000-0x1000000000 with maximum protection none, so on macOS
+// the block sits lower in the same system-reserved guest range, and guest shaders that build an address inside the
+// console block are retargeted to it (ShaderRegistry.cpp).
+constexpr std::uint64_t Ps5DriverMemoryBase = 0xfe0000000ull;
+constexpr std::uint64_t MacOsDriverMemoryBase = 0xee0000000ull;
+constexpr std::uint64_t DriverMemorySpan = 2u << 20u;
+
+constexpr std::uint64_t RetargetPs5DriverMemory(std::uint64_t address) {
+    return address >= Ps5DriverMemoryBase && address - Ps5DriverMemoryBase < DriverMemorySpan ? address - Ps5DriverMemoryBase + MacOsDriverMemoryBase : address;
+}
+
+}
+
+#endif
+
+#endif

core/libs/prx/libSceAgcDriver/Execution/include/SubgroupBarrier.hpp

@@ -6,6 +6,10 @@
 namespace AgcDriver {
 
 inline bool SubgroupControlBarrierUsable(VkDriverId driver) {
+#ifdef __APPLE__
+    // MoltenVK lowers a subgroup-scope control barrier to threadgroup_barrier, which waves skipping a branch never meet.
+    if (driver == VK_DRIVER_ID_MOLTENVK) return false;
+#endif
     return driver != VK_DRIVER_ID_AMD_PROPRIETARY;
 }
 

core/libs/prx/libSceAgcDriver/Execution/src/Driver/Draw/DrawDecode.cpp

@@ -183,6 +183,12 @@ std::shared_ptr<DrawDecode> Driver::decodeDraw(const QueueState& queue, const Su
     Graphics::NormalizeUnusedViewportDepth(product->state, product->pixel);
     Graphics::ApplyDepthRemap(context, product->state);
     product->pixel.targetExportPacking = Graphics::ExportPackings(product->state);
+#ifdef __APPLE__
+    // Graphics::DecodeState marks unsigned integer targets fed by 32-bit exports; their pixel shader output becomes uint4.
+    for (const auto& color : product->state.colors) {
+        if (color.metalUintOutput && color.exportIndex < product->pixel.metalTargetOutputMode.size()) product->pixel.metalTargetOutputMode[color.exportIndex] = 7u;
+    }
+#endif
     product->pixel.dualSourceBlend = product->state.dualSourceBlend;
     product->pixel.reversedBlend = product->state.reversedBlend;
     product->pixel.alphaToCoverage = product->state.alphaToCoverage;

core/libs/prx/libSceAgcDriver/Execution/src/Driver/Lifecycle.cpp

@@ -32,6 +32,11 @@
 #include <pthread.h>
 #include <sys/mman.h>
 #endif
+#ifdef __APPLE__
+#include "prx/libSceAgcDriver/Execution/include/Driver/DriverMemory.hpp"
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#endif
 
 namespace AgcDriver::DriverDetail {
 
@@ -53,9 +58,15 @@ void PrintFailure(std::exception_ptr error) {
     std::fflush(stderr);
 }
 
+#ifdef __APPLE__
+constexpr std::uint64_t DriverMemoryAddress = MacOsDriverMemoryBase;
+constexpr std::size_t DriverMemoryBytes = DriverMemorySpan;
+constexpr std::uint64_t FsTableAddress = RetargetPs5DriverMemory(0xfe0040000ull);
+#else
 constexpr std::uint64_t DriverMemoryAddress = 0xfe0000000ull + GuestArena::GuestAddressOffset;
 constexpr std::size_t DriverMemoryBytes = 2u << 20u;
 constexpr std::uint64_t FsTableAddress = DriverMemoryAddress + 0x40000ull;
+#endif
 constexpr std::uint64_t FsTableSlotBytes = 16u;
 constexpr std::uint64_t FsTableSlots = 6u;
 constexpr std::uint64_t FsRoutineRecords = 8u;
@@ -72,6 +83,21 @@ void MapDriverMemory() {
 #ifdef _WIN32
     mapped = reinterpret_cast<void*>(DriverMemoryAddress);
     GuestArena::GuestArenaCommit_nid_postfix(mapped, DriverMemoryBytes, PAGE_READWRITE, DriverMemoryBytes);
+#elif defined(__APPLE__)
+    // The block is in the guest arena's system-reserved range. When the arena holds it as an inaccessible
+    // reservation, only that reservation is replaced; otherwise the range must be free, and a hint the kernel honours
+    // exactly stands in for MAP_FIXED_NOREPLACE, which macOS lacks.
+    mach_vm_address_t region = DriverMemoryAddress;
+    mach_vm_size_t regionBytes = 0;
+    vm_region_basic_info_data_64_t info{};
+    mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
+    mach_port_t object = MACH_PORT_NULL;
+    const bool reservation = mach_vm_region(mach_task_self(), &region, &regionBytes, VM_REGION_BASIC_INFO_64, reinterpret_cast<vm_region_info_t>(&info), &count, &object) == KERN_SUCCESS &&
+        region <= DriverMemoryAddress && DriverMemoryAddress + DriverMemoryBytes <= region + regionBytes && info.protection == VM_PROT_NONE &&
+        (info.max_protection & (VM_PROT_READ | VM_PROT_WRITE)) == (VM_PROT_READ | VM_PROT_WRITE);
+    mapped = mmap(reinterpret_cast<void*>(DriverMemoryAddress), DriverMemoryBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | (reservation ? MAP_FIXED : 0), -1, 0);
+    if (mapped == MAP_FAILED) throw std::system_error(errno, std::generic_category(), "map the AGC driver memory");
+    if (!reservation && reinterpret_cast<std::uint64_t>(mapped) != DriverMemoryAddress) munmap(mapped, DriverMemoryBytes);
 #else
     mapped = mmap(reinterpret_cast<void*>(DriverMemoryAddress), DriverMemoryBytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED_NOREPLACE, -1, 0);
     if (mapped == MAP_FAILED) throw std::system_error(errno, std::generic_category(), "map the AGC driver memory");
@@ -105,6 +131,11 @@ bool StackHoldsImport() {
         std::uintptr_t low = 0;
         std::uintptr_t high = 0;
         Bounds() {
+#ifdef __APPLE__
+            const auto self = pthread_self();
+            high = reinterpret_cast<std::uintptr_t>(pthread_get_stackaddr_np(self));
+            low = high - pthread_get_stacksize_np(self);
+#else
             pthread_attr_t attributes;
             if (pthread_getattr_np(pthread_self(), &attributes) != 0) return;
             void* base = nullptr;
@@ -114,6 +145,7 @@ bool StackHoldsImport() {
                 high = low + size;
             }
             pthread_attr_destroy(&attributes);
+#endif
         }
     };
     thread_local const Bounds bounds;

core/libs/prx/libSceAgcDriver/Execution/src/Driver/Shaders/ShaderRegistry.cpp

@@ -3,6 +3,9 @@
 #include "prx/libSceAgcDriver/Execution/include/PerformanceTimer.hpp"
 #include "prx/libSceAgcDriver/Execution/include/ProfileOutput.hpp"
 #include "prx/libSceAgcDriver/Execution/include/Driver/Driver.hpp"
+#ifdef __APPLE__
+#include "prx/libSceAgcDriver/Execution/include/Driver/DriverMemory.hpp"
+#endif
 #include "prx/libSceAgcDriver/Execution/include/Driver/Draw/DrawPipeline.hpp"
 #include "prx/libSceAgcDriver/Execution/include/Driver/Shaders/ShaderRegistry.hpp"
 #include "prx/libSceAgcDriver/Graphics/include/PipelineLibrary.hpp"
@@ -1004,6 +1007,22 @@ std::vector<ShaderRecompiler::TableCallee> ReadTableCallees(const ShaderRecompil
     for (const auto target : targets) callees.push_back({target, ReadUserDataCallee(target, call.linkRegister)});
     return callees;
 }
+#ifdef __APPLE__
+
+// Rewrites one s_mov_b32 that builds half of a driver-block pointer: its literal word, or its inline integer.
+void RetargetPointerMove(std::vector<std::uint32_t>& code, std::uint32_t programCounter, std::uint32_t value) {
+    const auto word = programCounter / 4u;
+    if (word >= code.size()) throw std::logic_error("a retargeted driver-memory pointer move is outside the linked code");
+    const auto source = code[word] & 0xffu;
+    if (source == 0xffu && word + 1u < code.size()) {
+        code[word + 1u] = value;
+    } else if (source >= 0x80u && source <= 0xc0u && value <= 64u) {
+        code[word] = (code[word] & ~0xffu) | (0x80u + value);
+    } else {
+        throw std::runtime_error("a driver-memory pointer move at program counter " + hexText(programCounter) + " cannot hold its macOS address " + hexText(value));
+    }
+}
+#endif
 
 ShaderRecompiler::LinkedCalls LinkUserDataCallees(const ShaderRecompiler::RecompileRequest& request) {
     if (request.shader.stage != ShaderRecompiler::ShaderStage::Compute) return {};
@@ -1012,7 +1031,22 @@ ShaderRecompiler::LinkedCalls LinkUserDataCallees(const ShaderRecompiler::Recomp
     const auto program = ShaderRecompiler::RdnaInstructionDecoder{}.Decode(code);
     const ShaderRecompiler::SwappcInfo swappc{false, request.context.userDataBaseRegister, static_cast<std::uint32_t>(request.context.userData.size()), request.context.waveSize};
     const auto calls = ShaderRecompiler::FindUserDataCalls(program, swappc);
+#ifdef __APPLE__
+    // The driver block is not at its console address on macOS (DriverMemory.hpp): a table pointer the shader builds
+    // inside it is moved, both for the callee lookup here and in the code the GPU runs.
+    auto tableCalls = ShaderRecompiler::FindTableCalls(program, swappc);
+    std::vector<std::pair<std::uint32_t, std::uint32_t>> pointerMoves;
+    for (auto& call : tableCalls) {
+        if (!call.constantPointer) continue;
+        const auto moved = RetargetPs5DriverMemory(*call.constantPointer);
+        if (moved == *call.constantPointer) continue;
+        if (static_cast<std::uint32_t>(moved) != static_cast<std::uint32_t>(*call.constantPointer)) pointerMoves.push_back({call.pointerLowWriter, static_cast<std::uint32_t>(moved)});
+        pointerMoves.push_back({call.pointerHighWriter, static_cast<std::uint32_t>(moved >> 32u)});
+        call.constantPointer = moved;
+    }
+#else
     const auto tableCalls = ShaderRecompiler::FindTableCalls(program, swappc);
+#endif
     if (calls.empty() && tableCalls.empty()) return {};
     std::vector<std::vector<std::uint32_t>> callees;
     for (const auto& call : calls) {
@@ -1033,7 +1067,13 @@ ShaderRecompiler::LinkedCalls LinkUserDataCallees(const ShaderRecompiler::Recomp
             throw std::runtime_error("AGC driver: compute shader " + hexText(request.shader.codeAddress) + " calls a target loaded from a table at program counter " + hexText(call.programCounter) + ", but " + error.what());
         }
     }
+#ifdef __APPLE__
+    auto linked = ShaderRecompiler::LinkCalls(program, calls, callees, tableCalls, tableCallees);
+    for (const auto& [programCounter, value] : pointerMoves) RetargetPointerMove(linked.code, programCounter, value);
+    return linked;
+#else
     return ShaderRecompiler::LinkCalls(program, calls, callees, tableCalls, tableCallees);
+#endif
 }
 
 }
@@ -1489,8 +1529,14 @@ class RegistrationPreparePool {
 
 private:
     static std::mutex& Lifecycle() {
+#ifdef __APPLE__
+        // Driver shutdown can run after static destruction; Darwin fails to lock a destroyed mutex, so keep it alive.
+        static auto* lifecycle = new std::mutex;
+        return *lifecycle;
+#else
         static std::mutex lifecycle;
         return lifecycle;
+#endif
     }
 
     static bool& Closing() {