[vulkan] skip staging buffer for uploads for UMA

initial implementation to skip staging buffer for uploads for unified memory access devices like android and igpus.

src/common/CMakeLists.txt

@@ -261,10 +261,4 @@ if(ANDROID)
     target_link_libraries(common PRIVATE android)
 endif()
 
-# IOPS (needed for power state) requires linking to IOKit
-if (APPLE)
-  find_library(IOKIT_LIBRARY IOKit REQUIRED)
-  target_link_libraries(common PRIVATE ${IOKIT_LIBRARY})
-endif()
-
 create_target_directory_groups(common)

src/common/host_memory.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -30,7 +30,6 @@
 #include <sys/random.h>
 #include <mach/vm_map.h>
 #include <mach/mach.h>
-#include <map>
 #endif
 
 // FreeBSD
@@ -397,68 +396,21 @@ private:
 
 #else // ^^^ Windows ^^^ vvv POSIX vvv
 
-// Use NCE friendly mapping techniques
-#if defined(ARCHITECTURE_arm64) && defined(HAS_NCE)
+#ifdef ARCHITECTURE_arm64
+
 static void* ChooseVirtualBase(size_t virtual_size) {
-    constexpr uintptr_t Map36BitSize = (1ULL << 36);
-#ifdef __APPLE__
-    // TODO: Fatal flaw, regions may change if map inserts elements, very rare, but MAY HAPPEN!
-    std::map<u64, u64> aspace_list;
-    kern_return_t krc = KERN_SUCCESS;
-    vm_address_t address = 0;
-    vm_size_t r_size = 0;
-    uint32_t depth = 1;
-    do {
-        struct vm_region_submap_info_64 info;
-        mach_msg_type_number_t count = VM_REGION_SUBMAP_INFO_COUNT_64;
-        krc = vm_region_recurse_64(mach_task_self(), &address, &r_size, &depth, (vm_region_info_64_t)&info, &count);
-        if (krc == KERN_INVALID_ADDRESS)
-            break;
-        if (info.is_submap){
-            depth++;
-        } else {
-            aspace_list.insert({ u64(address), u64(r_size) });
-            address += r_size;
-        }
-    } while(1);
-    for (auto it = aspace_list.begin(); it != aspace_list.end(); it++) {
-        auto const next = std::next(it);
-        // properties of hole
-        auto const addr = it->first + it->second;
-        auto const size = (next != aspace_list.end()) ? next->first - addr : std::numeric_limits<u64>::max() - addr;
-        ASSERT(next == aspace_list.end() || it->first < next->first);
-        if (size > virtual_size && uintptr_t(addr + size) >= Map36BitSize) {
-            // valid address for NCE
-            if (uintptr_t(addr) >= Map36BitSize) { //common case: hole after 39 bit
-                if (size >= virtual_size) {
-                    void* p = mmap(reinterpret_cast<void*>(addr), virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-                    if (p == MAP_FAILED)
-                        continue;
-                    return p;
-                }
-                // skip
-            } else { //edge case: hole before 39 bit
-                auto const rem_size = size - (Map36BitSize - uintptr_t(addr));
-                if (rem_size >= virtual_size) {
-                    void* p = mmap(reinterpret_cast<void*>(Map36BitSize), virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-                    if (p == MAP_FAILED)
-                        continue;
-                    return p;
-                }
-                // skip
-            }
-        }
-    }
-    UNREACHABLE();
-#else
     constexpr uintptr_t Map39BitSize = (1ULL << 39);
+    constexpr uintptr_t Map36BitSize = (1ULL << 36);
+
+    // This is not a cryptographic application, we just want something random.
+    std::mt19937_64 rng;
+
     // We want to ensure we are allocating at an address aligned to the L2 block size.
     // For Qualcomm devices, we must also allocate memory above 36 bits.
     const size_t lower = Map36BitSize / HugePageSize;
     const size_t upper = (Map39BitSize - virtual_size) / HugePageSize;
     const size_t range = upper - lower;
-    // This is not a cryptographic application, we just want something random.
-    std::mt19937_64 rng;
+
     // Try up to 64 times to allocate memory at random addresses in the range.
     for (int i = 0; i < 64; i++) {
         // Calculate a possible location.
@@ -482,9 +434,10 @@ static void* ChooseVirtualBase(size_t virtual_size) {
     }
 
     return MAP_FAILED;
-#endif
 }
+
 #else
+
 static void* ChooseVirtualBase(size_t virtual_size) {
 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__managarm__) || defined(__AIX__)
     void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
@@ -493,6 +446,7 @@ static void* ChooseVirtualBase(size_t virtual_size) {
 #endif
     return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }
+
 #endif
 
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
@@ -546,10 +500,9 @@ class HostMemory::Impl {
 public:
     explicit Impl(size_t backing_size_, size_t virtual_size_)
         : backing_size{backing_size_}, virtual_size{virtual_size_} {
-        // TODO: Solve all 4k paging issues
-        //long page_size = sysconf(_SC_PAGESIZE);
-        //ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging",
-        //           page_size);
+        long page_size = sysconf(_SC_PAGESIZE);
+        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging",
+                   page_size);
         // Backing memory initialization
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
         fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
@@ -619,21 +572,12 @@ public:
             prot_flags |= PROT_READ;
         if (True(perms & MemoryPermission::Write))
             prot_flags |= PROT_WRITE;
-        // W^X only supported (and needed) with NCE
-#ifdef HAS_NCE
+#ifdef ARCHITECTURE_arm64
         if (True(perms & MemoryPermission::Execute))
             prot_flags |= PROT_EXEC;
 #endif
         int flags = (fd > 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
-
-        u8* addr = virtual_base + virtual_offset;
-#ifdef __APPLE__
-        // The way Steve Jobs intended
-        addr = (u8*)trunc_page(u64(addr) + host_offset);
-        length = round_page(length);
-        host_offset = 0;
-#endif
-        void* ret = mmap(addr, length, prot_flags, flags, fd, host_offset);
+        void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
         ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
     }
 
@@ -658,21 +602,18 @@ public:
         AdjustMap(&virtual_offset, &length);
 
         int flags = PROT_NONE;
-        if (read)
+        if (read) {
             flags |= PROT_READ;
-        if (write)
+        }
+        if (write) {
             flags |= PROT_WRITE;
+        }
 #ifdef HAS_NCE
-        if (execute)
+        if (execute) {
             flags |= PROT_EXEC;
+        }
 #endif
-        u8* addr = virtual_base + virtual_offset;
-#ifdef __APPLE__
-        // The way Steve Jobs intended
-        addr = (u8*)trunc_page(u64(addr));
-        length = round_page(length);
-#endif
-        int ret = mprotect(addr, length, flags);
+        int ret = mprotect(virtual_base + virtual_offset, length, flags);
         ASSERT_MSG(ret == 0, "mprotect failed: {}", strerror(errno));
     }
 

src/common/signal_chain.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -13,16 +10,27 @@
 
 namespace Common {
 
-#ifdef __ANDROID__
 template <typename T>
 T* LookupLibcSymbol(const char* name) {
+#if defined(__BIONIC__)
     Common::DynamicLibrary provider("libc.so");
-    ASSERT_MSG(provider.IsOpen(), "Failed to open libc!");
+    if (!provider.IsOpen()) {
+        UNREACHABLE_MSG("Failed to open libc!");
+    }
+#else
+    // For other operating environments, we assume the symbol is not overridden.
+    const char* base = nullptr;
+    Common::DynamicLibrary provider(base);
+#endif
+
     void* sym = provider.GetSymbolAddress(name);
     if (sym == nullptr) {
         sym = dlsym(RTLD_DEFAULT, name);
     }
-    ASSERT_MSG(sym != nullptr, "Unable to find symbol {}!", name);
+    if (sym == nullptr) {
+        UNREACHABLE_MSG("Unable to find symbol {}!", name);
+    }
+
     return reinterpret_cast<T*>(sym);
 }
 
@@ -30,10 +38,5 @@ int SigAction(int signum, const struct sigaction* act, struct sigaction* oldact)
     static auto libc_sigaction = LookupLibcSymbol<decltype(sigaction)>("sigaction");
     return libc_sigaction(signum, act, oldact);
 }
-#else
-int SigAction(int signum, const struct sigaction* act, struct sigaction* oldact) {
-    return sigaction(signum, act, oldact);
-}
-#endif
 
 } // namespace Common

src/core/arm/nce/arm_nce.cpp

@@ -13,14 +13,12 @@
 #include "core/arm/nce/patcher.h"
 #include "core/core.h"
 #include "core/memory.h"
-#include "core/hle/kernel/k_process.h"
 
-#include "dynarmic/common/context.h"
+#include "core/hle/kernel/k_process.h"
 
 #include <signal.h>
 #include <sys/syscall.h>
 #include <unistd.h>
-#include <pthread.h>
 
 namespace Core {
 
@@ -35,67 +33,95 @@ static_assert(offsetof(NativeExecutionParameters, native_context) == TpidrEl0Nat
 static_assert(offsetof(NativeExecutionParameters, lock) == TpidrEl0Lock);
 static_assert(offsetof(NativeExecutionParameters, magic) == TpidrEl0TlsMagic);
 
+fpsimd_context* GetFloatingPointState(mcontext_t& host_ctx) {
+    _aarch64_ctx* header = reinterpret_cast<_aarch64_ctx*>(&host_ctx.__reserved);
+    while (header->magic != FPSIMD_MAGIC) {
+        header = reinterpret_cast<_aarch64_ctx*>(reinterpret_cast<char*>(header) + header->size);
+    }
+    return reinterpret_cast<fpsimd_context*>(header);
+}
+
 using namespace Common::Literals;
 constexpr u32 StackSize = 128_KiB;
 
 } // namespace
 
 void* ArmNce::RestoreGuestContext(void* raw_context) {
-    CTX_DECLARE(raw_context);
-    // Restore all guest state except tpidr_el0.
+    // Retrieve the host context.
+    auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext;
+
     // Thread-local parameters will be located in x9.
-    auto* tpidr = reinterpret_cast<NativeExecutionParameters*>(CTX_X(9));
+    auto* tpidr = reinterpret_cast<NativeExecutionParameters*>(host_ctx.regs[9]);
     auto* guest_ctx = static_cast<GuestContext*>(tpidr->native_context);
+
+    // Retrieve the host floating point state.
+    auto* fpctx = GetFloatingPointState(host_ctx);
+
     // Save host callee-saved registers.
-    std::memcpy(guest_ctx->host_ctx.host_saved_vregs.data(), &CTX_Q(8),
+    std::memcpy(guest_ctx->host_ctx.host_saved_vregs.data(), &fpctx->vregs[8],
                 sizeof(guest_ctx->host_ctx.host_saved_vregs));
+    std::memcpy(guest_ctx->host_ctx.host_saved_regs.data(), &host_ctx.regs[19],
+                sizeof(guest_ctx->host_ctx.host_saved_regs));
+
     // Save stack pointer.
-    guest_ctx->host_ctx.host_sp = CTX_SP;
-    CTX_PC = guest_ctx->sp;
-    CTX_SP = guest_ctx->pc;
-    CTX_PSTATE = guest_ctx->pstate;
-    CTX_FPCR = guest_ctx->fpcr;
-    CTX_FPSR = guest_ctx->fpsr;
-    std::memcpy(&CTX_X(0), guest_ctx->cpu_registers.data(), sizeof(guest_ctx->cpu_registers));
-    std::memcpy(&CTX_Q(0), guest_ctx->vector_registers.data(), sizeof(guest_ctx->vector_registers));
+    guest_ctx->host_ctx.host_sp = host_ctx.sp;
+
+    // Restore all guest state except tpidr_el0.
+    host_ctx.sp = guest_ctx->sp;
+    host_ctx.pc = guest_ctx->pc;
+    host_ctx.pstate = guest_ctx->pstate;
+    fpctx->fpcr = guest_ctx->fpcr;
+    fpctx->fpsr = guest_ctx->fpsr;
+    std::memcpy(host_ctx.regs, guest_ctx->cpu_registers.data(), sizeof(host_ctx.regs));
+    std::memcpy(fpctx->vregs, guest_ctx->vector_registers.data(), sizeof(fpctx->vregs));
+
     // Return the new thread-local storage pointer.
     return tpidr;
 }
 
 void ArmNce::SaveGuestContext(GuestContext* guest_ctx, void* raw_context) {
-    CTX_DECLARE(raw_context);
+    // Retrieve the host context.
+    auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext;
+
+    // Retrieve the host floating point state.
+    auto* fpctx = GetFloatingPointState(host_ctx);
+
     // Save all guest registers except tpidr_el0.
-    std::memcpy(guest_ctx->cpu_registers.data(), &CTX_X(0), sizeof(guest_ctx->cpu_registers));
-    std::memcpy(guest_ctx->vector_registers.data(), &CTX_Q(0), sizeof(guest_ctx->vector_registers));
-    guest_ctx->fpsr = CTX_FPSR;
-    guest_ctx->fpcr = CTX_FPCR;
-    guest_ctx->pc = CTX_PC;
-    guest_ctx->sp = CTX_SP;
-    guest_ctx->pstate = u32(CTX_PSTATE);
+    std::memcpy(guest_ctx->cpu_registers.data(), host_ctx.regs, sizeof(host_ctx.regs));
+    std::memcpy(guest_ctx->vector_registers.data(), fpctx->vregs, sizeof(fpctx->vregs));
+    guest_ctx->fpsr = fpctx->fpsr;
+    guest_ctx->fpcr = fpctx->fpcr;
+    guest_ctx->pstate = static_cast<u32>(host_ctx.pstate);
+    guest_ctx->pc = host_ctx.pc;
+    guest_ctx->sp = host_ctx.sp;
+
     // Restore stack pointer.
-    CTX_SP = guest_ctx->host_ctx.host_sp;
+    host_ctx.sp = guest_ctx->host_ctx.host_sp;
 
     // Restore host callee-saved registers.
-    std::memcpy(&CTX_X(19), guest_ctx->host_ctx.host_saved_regs.data(),
+    std::memcpy(&host_ctx.regs[19], guest_ctx->host_ctx.host_saved_regs.data(),
                 sizeof(guest_ctx->host_ctx.host_saved_regs));
-    std::memcpy(&CTX_Q(8), guest_ctx->host_ctx.host_saved_vregs.data(),
+    std::memcpy(&fpctx->vregs[8], guest_ctx->host_ctx.host_saved_vregs.data(),
                 sizeof(guest_ctx->host_ctx.host_saved_vregs));
+
     // Return from the call on exit by setting pc to x30.
-    CTX_PC = guest_ctx->host_ctx.host_saved_regs[11];
+    host_ctx.pc = guest_ctx->host_ctx.host_saved_regs[11];
+
     // Clear esr_el1 and return it.
-    CTX_X(0) = guest_ctx->esr_el1.exchange(0);
+    host_ctx.regs[0] = guest_ctx->esr_el1.exchange(0);
 }
 
 bool ArmNce::HandleFailedGuestFault(GuestContext* guest_ctx, void* raw_info, void* raw_context) {
-    CTX_DECLARE(raw_context);
+    auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext;
     auto* info = static_cast<siginfo_t*>(raw_info);
 
     // We can't handle the access, so determine why we crashed.
-    auto const is_prefetch_abort = CTX_PC == reinterpret_cast<u64>(info->si_addr);
+    const bool is_prefetch_abort = host_ctx.pc == reinterpret_cast<u64>(info->si_addr);
+
     // For data aborts, skip the instruction and return to guest code.
     // This will allow games to continue in many scenarios where they would otherwise crash.
     if (!is_prefetch_abort) {
-        CTX_PC += 4;
+        host_ctx.pc += 4;
         return true;
     }
 
@@ -116,13 +142,17 @@ bool ArmNce::HandleFailedGuestFault(GuestContext* guest_ctx, void* raw_info, voi
 }
 
 bool ArmNce::HandleGuestAlignmentFault(GuestContext* guest_ctx, void* raw_info, void* raw_context) {
-    CTX_DECLARE(raw_context);
-    auto& memory = guest_ctx->system->ApplicationMemory();
+    auto& host_ctx = static_cast<ucontext_t*>(raw_context)->uc_mcontext;
+    auto* fpctx = GetFloatingPointState(host_ctx);
+    auto& memory = guest_ctx->parent->m_running_thread->GetOwnerProcess()->GetMemory();
+
     // Match and execute an instruction.
-    if (auto next_pc = MatchAndExecuteOneInstruction(memory, raw_context); next_pc) {
-        CTX_PC = *next_pc;
+    auto next_pc = MatchAndExecuteOneInstruction(memory, &host_ctx, fpctx);
+    if (next_pc) {
+        host_ctx.pc = *next_pc;
         return true;
     }
+
     // We couldn't handle the access.
     return HandleFailedGuestFault(guest_ctx, raw_info, raw_context);
 }
@@ -246,51 +276,9 @@ ArmNce::ArmNce(System& system, bool uses_wall_clock, std::size_t core_index)
 
 ArmNce::~ArmNce() = default;
 
-// Borrowed from libusb
-static unsigned int posix_gettid(void) {
-    static thread_local unsigned int tl_tid;
-    int tid;
-    if (tl_tid)
-        return tl_tid;
-#if defined(__ANDROID__)
-    tid = gettid();
-#elif defined(__APPLE__)
-#ifdef HAVE_PTHREAD_THREADID_NP
-    uint64_t thread_id;
-    if (pthread_threadid_np(NULL, &thread_id) == 0)
-        tid = (int)thread_id;
-    else
-        tid = -1;
-#else
-    tid = (int)pthread_mach_thread_np(pthread_self());
-#endif
-#elif defined(__HAIKU__)
-    tid = get_pthread_thread_id(pthread_self());
-#elif defined(__linux__)
-    tid = (int)syscall(SYS_gettid);
-#elif defined(__NetBSD__)
-    tid = _lwp_self();
-#elif defined(__OpenBSD__)
-    /* The following only works with OpenBSD > 5.1 as it requires
-    * real thread support. For 5.1 and earlier, -1 is returned. */
-    tid = syscall(SYS_getthrid);
-#elif defined(__sun__)
-    tid = _lwp_self();
-#else
-    tid = -1;
-#endif
-    if (tid == -1) {
-        /* If we don't have a thread ID, at least return a unique
-        * value that can be used to distinguish individual
-        * threads. */
-        tid = (int)(intptr_t)pthread_self();
-    }
-    return tl_tid = (unsigned int)tid;
-}
-
 void ArmNce::Initialize() {
     if (m_thread_id == -1) {
-        m_thread_id = posix_gettid();
+        m_thread_id = gettid();
     }
 
     // Configure signal stack.
@@ -321,7 +309,7 @@ void ArmNce::Initialize() {
             &ArmNce::ReturnToRunCodeByExceptionLevelChangeSignalHandler);
         return_to_run_code_action.sa_mask = signal_mask;
         Common::SigAction(ReturnToRunCodeByExceptionLevelChangeSignal, &return_to_run_code_action,
-                        nullptr);
+                          nullptr);
 
         struct sigaction break_from_run_code_action {};
         break_from_run_code_action.sa_flags = SA_SIGINFO | SA_ONSTACK;
@@ -393,11 +381,7 @@ void ArmNce::SignalInterrupt(Kernel::KThread* thread) {
     if (params->is_running) {
         // We should signal to the running thread.
         // The running thread will unlock the thread context.
-#ifdef __linux__
         syscall(SYS_tkill, m_thread_id, BreakFromRunCodeSignal);
-#else
-        pthread_kill(pthread_t(m_thread_id), int(BreakFromRunCodeSignal));
-#endif
     } else {
         // If the thread is no longer running, we have nothing to do.
         UnlockThreadParameters(params);

src/core/arm/nce/arm_nce.s

@@ -9,15 +9,10 @@
 
 
 /* static HaltReason Core::ArmNce::ReturnToRunCodeByTrampoline(void* tpidr, Core::GuestContext* ctx, u64 trampoline_addr) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEy
-__ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEy:
-#else
 .section    .text._ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, "ax", %progbits
-.type       _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, %function
 .global     _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm
+.type       _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm, %function
 _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm:
-#endif
     /* Back up host sp to x3. */
     /* Back up host tpidr_el0 to x4. */
     mov     x3, sp
@@ -55,52 +50,38 @@ _ZN4Core6ArmNce27ReturnToRunCodeByTrampolineEPvPNS_12GuestContextEm:
 
 
 /* static HaltReason Core::ArmNce::ReturnToRunCodeByExceptionLevelChange(int tid, void* tpidr) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv
-__ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv:
-#else
 .section    .text._ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv, "ax", %progbits
-.type       _ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv, %function
 .global     _ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv
+.type       _ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv, %function
 _ZN4Core6ArmNce37ReturnToRunCodeByExceptionLevelChangeEiPv:
-#endif
     /* This jumps to the signal handler, which will restore the entire context. */
-    /* On entry, x0 = thread id, which is already in the right place. Even on macOS. */
-    mov     x9, x1 /* Move tpidr to x9 so it is not trampled. */
-    mov     x1, #(ReturnToRunCodeByExceptionLevelChangeSignal)
-#ifdef __APPLE__
-    /* I can never be happy, why no tkill in mach kernel? Ugh ... */
-    /* Signature: 328 AUE_PTHREADKILL ALL { int __pthread_kill(int thread_port, int sig); } */
-    mov     x16, #(328)
-    svc     #0x80 /* Tail call the signal handler. */
-    brk     #0xF000 /* See: https://discourse.llvm.org/t/stepping-over-a-brk-instruction-on-arm64/69766/7 */
-#else
-    /* Signature: int tgkill(pid_t tgid, pid_t tid, int sig); */
+    /* On entry, x0 = thread id, which is already in the right place. */
+
+    /* Move tpidr to x9 so it is not trampled. */
+    mov     x9, x1
+
+    /* Set up arguments. */
     mov     x8, #(__NR_tkill)
-    svc     #0 /* Tail call the signal handler. */
-    brk     #1000 /* Block execution from flowing here. */
-#endif
+    mov     x1, #(ReturnToRunCodeByExceptionLevelChangeSignal)
+
+    /* Tail call the signal handler. */
+    svc     #0
+
+    /* Block execution from flowing here. */
+    brk     #1000
+
 
 /* static void Core::ArmNce::ReturnToRunCodeByExceptionLevelChangeSignalHandler(int sig, void* info, void* raw_context) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_
-__ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_:
-#else
 .section    .text._ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, "ax", %progbits
-.type       _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, %function
 .global     _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_
+.type       _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_, %function
 _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_:
-#endif
     stp     x29, x30, [sp, #-0x10]!
     mov     x29, sp
 
     /* Call the context restorer with the raw context. */
     mov     x0, x2
-#ifdef __APPLE__
-    bl      __ZN4Core6ArmNce19RestoreGuestContextEPv
-#else
     bl      _ZN4Core6ArmNce19RestoreGuestContextEPv
-#endif
 
     /* Save the old value of tpidr_el0. */
     mrs     x8, tpidr_el0
@@ -111,11 +92,7 @@ _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_:
     msr     tpidr_el0, x0
 
     /* Unlock the context. */
-#ifdef __APPLE__
-    bl      __ZN4Core6ArmNce22UnlockThreadParametersEPv
-#else
     bl      _ZN4Core6ArmNce22UnlockThreadParametersEPv
-#endif
 
     /* Returning from here will enter the guest. */
     ldp     x29, x30, [sp], #0x10
@@ -123,15 +100,10 @@ _ZN4Core6ArmNce50ReturnToRunCodeByExceptionLevelChangeSignalHandlerEiPvS1_:
 
 
 /* static void Core::ArmNce::BreakFromRunCodeSignalHandler(int sig, void* info, void* raw_context) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_
-__ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_:
-#else
 .section    .text._ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_, "ax", %progbits
-.type       _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_, %function
 .global     _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_
+.type       _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_, %function
 _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_:
-#endif
     /* Check to see if we have the correct TLS magic. */
     mrs     x8, tpidr_el0
     ldr     w9, [x8, #(TpidrEl0TlsMagic)]
@@ -149,11 +121,7 @@ _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_:
 
     /* Tail call the restorer. */
     mov     x1, x2
-#ifdef __APPLE__
-    b       __ZN4Core6ArmNce16SaveGuestContextEPNS_12GuestContextEPv
-#else
     b       _ZN4Core6ArmNce16SaveGuestContextEPNS_12GuestContextEPv
-#endif
 
     /* Returning from here will enter host code. */
 
@@ -163,15 +131,10 @@ _ZN4Core6ArmNce29BreakFromRunCodeSignalHandlerEiPvS1_:
 
 
 /* static void Core::ArmNce::GuestAlignmentFaultSignalHandler(int sig, void* info, void* raw_context) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_
-__ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_:
-#else
 .section    .text._ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_, "ax", %progbits
-.type       _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_, %function
 .global     _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_
+.type       _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_, %function
 _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_:
-#endif
     /* Check to see if we have the correct TLS magic. */
     mrs     x8, tpidr_el0
     ldr     w9, [x8, #(TpidrEl0TlsMagic)]
@@ -183,11 +146,7 @@ _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_:
 
     /* Incorrect TLS magic, so this is a host fault. */
     /* Tail call the handler. */
-#ifdef __APPLE__
-    b       __ZN4Core6ArmNce24HandleHostAlignmentFaultEiPvS1_
-#else
     b       _ZN4Core6ArmNce24HandleHostAlignmentFaultEiPvS1_
-#endif
 
 1:
     /* Correct TLS magic, so this is a guest fault. */
@@ -204,11 +163,7 @@ _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_:
     msr     tpidr_el0, x3
 
     /* Call the handler. */
-#ifdef __APPLE__
-    bl       __ZN4Core6ArmNce25HandleGuestAlignmentFaultEPNS_12GuestContextEPvS3_
-#else
     bl       _ZN4Core6ArmNce25HandleGuestAlignmentFaultEPNS_12GuestContextEPvS3_
-#endif
 
     /* If the handler returned false, we want to preserve the host tpidr_el0. */
     cbz     x0, 2f
@@ -222,15 +177,10 @@ _ZN4Core6ArmNce32GuestAlignmentFaultSignalHandlerEiPvS1_:
     ret
 
 /* static void Core::ArmNce::GuestAccessFaultSignalHandler(int sig, void* info, void* raw_context) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_
-__ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_:
-#else
 .section    .text._ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_, "ax", %progbits
-.type       _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_, %function
 .global     _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_
+.type       _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_, %function
 _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_:
-#endif
     /* Check to see if we have the correct TLS magic. */
     mrs     x8, tpidr_el0
     ldr     w9, [x8, #(TpidrEl0TlsMagic)]
@@ -242,11 +192,7 @@ _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_:
 
     /* Incorrect TLS magic, so this is a host fault. */
     /* Tail call the handler. */
-#ifdef __APPLE__
-    b       __ZN4Core6ArmNce21HandleHostAccessFaultEiPvS1_
-#else
     b       _ZN4Core6ArmNce21HandleHostAccessFaultEiPvS1_
-#endif
 
 1:
     /* Correct TLS magic, so this is a guest fault. */
@@ -263,11 +209,7 @@ _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_:
     msr     tpidr_el0, x3
 
     /* Call the handler. */
-#ifdef __APPLE__
-    bl       __ZN4Core6ArmNce22HandleGuestAccessFaultEPNS_12GuestContextEPvS3_
-#else
     bl       _ZN4Core6ArmNce22HandleGuestAccessFaultEPNS_12GuestContextEPvS3_
-#endif
 
     /* If the handler returned false, we want to preserve the host tpidr_el0. */
     cbz     x0, 2f
@@ -282,15 +224,10 @@ _ZN4Core6ArmNce29GuestAccessFaultSignalHandlerEiPvS1_:
 
 
 /* static void Core::ArmNce::LockThreadParameters(void* tpidr) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce20LockThreadParametersEPv
-__ZN4Core6ArmNce20LockThreadParametersEPv:
-#else
 .section    .text._ZN4Core6ArmNce20LockThreadParametersEPv, "ax", %progbits
-.type       _ZN4Core6ArmNce20LockThreadParametersEPv, %function
 .global     _ZN4Core6ArmNce20LockThreadParametersEPv
+.type       _ZN4Core6ArmNce20LockThreadParametersEPv, %function
 _ZN4Core6ArmNce20LockThreadParametersEPv:
-#endif
     /* Offset to lock member. */
     add     x0, x0, #(TpidrEl0Lock)
 
@@ -315,15 +252,10 @@ _ZN4Core6ArmNce20LockThreadParametersEPv:
 
 
 /* static void Core::ArmNce::UnlockThreadParameters(void* tpidr) */
-#ifdef __APPLE__
-.global     __ZN4Core6ArmNce22UnlockThreadParametersEPv
-__ZN4Core6ArmNce22UnlockThreadParametersEPv:
-#else
 .section    .text._ZN4Core6ArmNce22UnlockThreadParametersEPv, "ax", %progbits
-.type       _ZN4Core6ArmNce22UnlockThreadParametersEPv, %function
 .global     _ZN4Core6ArmNce22UnlockThreadParametersEPv
+.type       _ZN4Core6ArmNce22UnlockThreadParametersEPv, %function
 _ZN4Core6ArmNce22UnlockThreadParametersEPv:
-#endif
     /* Offset to lock member. */
     add     x0, x0, #(TpidrEl0Lock)
 

src/core/arm/nce/arm_nce_asm_definitions.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 /* SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project */
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 
@@ -8,24 +5,22 @@
 
 #define __ASSEMBLY__
 
-#ifdef __APPLE__
-/* https://cpip.readthedocs.io/en/stable/_static/dictobject.c/signal.h_bbe000f9714f274340a28e000a369354.html */
-#define ReturnToRunCodeByExceptionLevelChangeSignal 31
-#define BreakFromRunCodeSignal 16
-#define GuestAccessFaultSignal 11
-#define GuestAlignmentFaultSignal 10
-#else
 #include <asm-generic/signal.h>
 #include <asm-generic/unistd.h>
+
 #define ReturnToRunCodeByExceptionLevelChangeSignal SIGUSR2
 #define BreakFromRunCodeSignal SIGURG
 #define GuestAccessFaultSignal SIGSEGV
 #define GuestAlignmentFaultSignal SIGBUS
-#endif
 
 #define GuestContextSp 0xF8
 #define GuestContextHostContext 0x320
 
+#define HostContextSpTpidrEl0 0xE0
+#define HostContextTpidrEl0 0xE8
+#define HostContextRegs 0x0
+#define HostContextVregs 0x60
+
 #define TpidrEl0NativeContext 0x10
 #define TpidrEl0Lock 0x18
 #define TpidrEl0TlsMagic 0x20
@@ -33,8 +28,3 @@
 
 #define SpinLockLocked 0
 #define SpinLockUnlocked 1
-
-#define HostContextSpTpidrEl0 0xE0
-#define HostContextTpidrEl0 0xE8
-#define HostContextRegs 0x0
-#define HostContextVregs 0x60

src/core/arm/nce/interpreter_visitor.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -7,8 +7,6 @@
 
 #include <numeric>
 #include "core/arm/nce/interpreter_visitor.h"
-#include "core/memory.h"
-#include "dynarmic/common/context.h"
 
 namespace Core {
 
@@ -763,25 +761,24 @@ bool InterpreterVisitor::LDR_reg_fpsimd(Imm<2> size, Imm<1> opc_1, Reg Rm, Imm<3
     return this->SIMDOffset(scale, shift, opc_0, Rm, option, Rn, Vt);
 }
 
-std::optional<u64> MatchAndExecuteOneInstruction(Core::Memory::Memory& memory, void* raw_context) {
-    CTX_DECLARE(raw_context);
-    std::span<u64, 31> regs(reinterpret_cast<u64*>(&CTX_X(0)), 31);
-    std::span<u128, 32> vregs(reinterpret_cast<u128*>(&CTX_Q(0)), 32);
+std::optional<u64> MatchAndExecuteOneInstruction(Core::Memory::Memory& memory, mcontext_t* context,
+                                                 fpsimd_context* fpsimd_context) {
+    std::span<u64, 31> regs(reinterpret_cast<u64*>(context->regs), 31);
+    std::span<u128, 32> vregs(reinterpret_cast<u128*>(fpsimd_context->vregs), 32);
+    u64& sp = *reinterpret_cast<u64*>(&context->sp);
+    const u64& pc = *reinterpret_cast<u64*>(&context->pc);
 
-    // Store temporal to not break aliasing rules :)
-    u64 tmp_sp = CTX_SP;
-    u64 tmp_pc = CTX_PC;
-    u32 instruction = memory.Read32(tmp_pc);
+    InterpreterVisitor visitor(memory, regs, vregs, sp, pc);
+    u32 instruction = memory.Read32(pc);
     bool was_executed = false;
-    InterpreterVisitor visitor(memory, regs, vregs, tmp_sp, tmp_pc);
+
     if (auto decoder = Dynarmic::A64::Decode<VisitorBase>(instruction)) {
         was_executed = decoder->get().call(visitor, instruction);
     } else {
         LOG_ERROR(Core_ARM, "Unallocated encoding: {:#x}", instruction);
     }
-    CTX_SP = tmp_sp;
-    CTX_PC = tmp_pc;
-    return was_executed ? std::optional<u64>(tmp_pc + 4) : std::nullopt;
+
+    return was_executed ? std::optional<u64>(pc + 4) : std::nullopt;
 }
 
 } // namespace Core

src/core/arm/nce/interpreter_visitor.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -9,7 +9,6 @@
 
 #include <atomic>
 #include <signal.h>
-#include <span>
 #include <unistd.h>
 #include <span>
 
@@ -106,6 +105,7 @@ private:
     const u64& m_pc;
 };
 
-std::optional<u64> MatchAndExecuteOneInstruction(Core::Memory::Memory& memory, void* raw_context);
+std::optional<u64> MatchAndExecuteOneInstruction(Core::Memory::Memory& memory, mcontext_t* context,
+                                                 fpsimd_context* fpsimd_context);
 
 } // namespace Core

src/video_core/buffer_cache/buffer_cache.h

@@ -739,12 +739,18 @@ void BufferCache<P>::BindHostIndexBuffer() {
     const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     if (!draw_state.inline_index_draw_indexes.empty()) [[unlikely]] {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
-            auto upload_staging = runtime.UploadStagingBuffer(size);
-            std::array<BufferCopy, 1> copies{
-                {BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
-            std::memcpy(upload_staging.mapped_span.data(),
-                        draw_state.inline_index_draw_indexes.data(), size);
-            runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true);
+            if (buffer.IsHostVisible()) {
+                // write directly to mapped buffer
+                std::memcpy(buffer.Mapped().data(),
+                            draw_state.inline_index_draw_indexes.data(), size);
+            } else {
+                auto upload_staging = runtime.UploadStagingBuffer(size);
+                std::array<BufferCopy, 1> copies{
+                    {BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
+                std::memcpy(upload_staging.mapped_span.data(),
+                            draw_state.inline_index_draw_indexes.data(), size);
+                runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true);
+            }
         } else {
             buffer.ImmediateUpload(0, draw_state.inline_index_draw_indexes);
         }
@@ -1590,6 +1596,15 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                         [[maybe_unused]] u64 total_size_bytes,
                                         [[maybe_unused]] std::span<BufferCopy> copies) {
     if constexpr (USE_MEMORY_MAPS) {
+        if (buffer.IsHostVisible() && runtime.CanReorderUpload(buffer, copies)) {
+            const std::span<u8> mapped_span = buffer.Mapped();
+            for (const BufferCopy& copy : copies) {
+                u8* const dst_pointer = mapped_span.data() + copy.dst_offset;
+                const DAddr device_addr = buffer.CpuAddr() + copy.dst_offset;
+                device_memory.ReadBlockUnsafe(device_addr, dst_pointer, copy.size);
+            }
+            return;
+        }
         auto upload_staging = runtime.UploadStagingBuffer(total_size_bytes);
         const std::span<u8> staging_pointer = upload_staging.mapped_span;
         for (BufferCopy& copy : copies) {
@@ -1634,16 +1649,22 @@ void BufferCache<P>::InlineMemoryImplementation(DAddr dest_address, size_t copy_
     SynchronizeBuffer(buffer, dest_address, static_cast<u32>(copy_size));
 
     if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
-        auto upload_staging = runtime.UploadStagingBuffer(copy_size);
-        std::array copies{BufferCopy{
-            .src_offset = upload_staging.offset,
-            .dst_offset = buffer.Offset(dest_address),
-            .size = copy_size,
-        }};
-        u8* const src_pointer = upload_staging.mapped_span.data();
-        std::memcpy(src_pointer, inlined_buffer.data(), copy_size);
-        const bool can_reorder = runtime.CanReorderUpload(buffer, copies);
-        runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true, can_reorder);
+        const u32 buffer_offset = buffer.Offset(dest_address);
+        if (buffer.IsHostVisible()) {
+            // write directly to mapped buffer
+            std::memcpy(buffer.Mapped().data() + buffer_offset, inlined_buffer.data(), copy_size);
+        } else {
+            auto upload_staging = runtime.UploadStagingBuffer(copy_size);
+            std::array copies{BufferCopy{
+                .src_offset = upload_staging.offset,
+                .dst_offset = buffer_offset,
+                .size = copy_size,
+            }};
+            u8* const src_pointer = upload_staging.mapped_span.data();
+            std::memcpy(src_pointer, inlined_buffer.data(), copy_size);
+            const bool can_reorder = runtime.CanReorderUpload(buffer, copies);
+            runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true, can_reorder);
+        }
     } else {
         buffer.ImmediateUpload(buffer.Offset(dest_address), inlined_buffer.first(copy_size));
     }

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -34,6 +34,14 @@ public:
 
     void MarkUsage(u64 offset, u64 size) {}
 
+    [[nodiscard]] bool IsHostVisible() const noexcept {
+        return false;
+    }
+
+    [[nodiscard]] std::span<u8> Mapped() noexcept {
+        return {};
+    }
+
     [[nodiscard]] GLuint View(u32 offset, u32 size, VideoCore::Surface::PixelFormat format);
 
     [[nodiscard]] GLuint64EXT HostGpuAddr() const noexcept {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -43,6 +43,14 @@ public:
         return tracker.IsUsed(offset, size);
     }
 
+    [[nodiscard]] bool IsHostVisible() const noexcept {
+        return buffer.IsHostVisible();
+    }
+
+    [[nodiscard]] std::span<u8> Mapped() noexcept {
+        return buffer.Mapped();
+    }
+
     void MarkUsage(u64 offset, u64 size) noexcept {
         tracker.Track(offset, size);
     }

src/video_core/renderer_vulkan/vk_descriptor_pool.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/video_core/vulkan_common/vk_enum_string_helper.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -8,7 +5,4 @@
 
 #include "video_core/vulkan_common/vulkan.h"
 
-#if defined(__APPLE__) && !defined(VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS)
-#   define VK_STRUCTURE_TYPE_OH_SURFACE_CREATE_INFO_OHOS VK_STRUCTURE_TYPE_SURFACE_CREATE_INFO_OHOS
-#endif
 #include <vulkan/vk_enum_string_helper.h>

src/video_core/vulkan_common/vulkan.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -11,7 +11,6 @@
 #define VK_USE_PLATFORM_WIN32_KHR
 #elif defined(__APPLE__)
 #define VK_USE_PLATFORM_METAL_EXT
-#define VK_USE_PLATFORM_MACOS_MVK
 #elif defined(__ANDROID__)
 #define VK_USE_PLATFORM_ANDROID_KHR
 #elif defined(__HAIKU__)
@@ -33,12 +32,6 @@
 #ifndef VK_KHR_MAINTENANCE_9_EXTENSION_NAME
 #define VK_KHR_MAINTENANCE_9_EXTENSION_NAME "VK_KHR_maintenance9"
 #endif
-#ifndef VK_EXT_METAL_SURFACE_EXTENSION_NAME
-#define VK_EXT_METAL_SURFACE_EXTENSION_NAME "VK_EXT_metal_surface"
-#endif
-#ifndef VK_MVK_MACOS_SURFACE_EXTENSION_NAME
-#define VK_MVK_MACOS_SURFACE_EXTENSION_NAME "VK_MVK_macos_surface"
-#endif
 
 // Sanitize macros
 #undef CreateEvent

src/video_core/vulkan_common/vulkan_device.h

@@ -798,6 +798,10 @@ public:
         return must_emulate_scaled_formats;
     }
 
+    bool HasUnifiedMemory() const {
+        return is_integrated;
+    }
+
     bool HasNullDescriptor() const {
         return features.robustness2.nullDescriptor;
     }

src/video_core/vulkan_common/vulkan_instance.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -48,8 +48,6 @@ namespace {
 #elif defined(__APPLE__)
     case Core::Frontend::WindowSystemType::Cocoa:
         extensions.push_back(VK_EXT_METAL_SURFACE_EXTENSION_NAME);
-        //extensions.push_back(VK_MVK_MACOS_SURFACE_EXTENSION_NAME);
-        //extensions.push_back(VK_MVK_MOLTENVK_EXTENSION_NAME);
         break;
 #elif defined(__ANDROID__)
     case Core::Frontend::WindowSystemType::Android:

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -259,7 +259,7 @@ namespace Vulkan {
     vk::Buffer
     MemoryAllocator::CreateBuffer(const VkBufferCreateInfo &ci, MemoryUsage usage) const
     {
-        const VmaAllocationCreateInfo alloc_ci = {
+        VmaAllocationCreateInfo alloc_ci = {
                 .flags = VMA_ALLOCATION_CREATE_WITHIN_BUDGET_BIT | MemoryUsageVmaFlags(usage),
                 .usage = MemoryUsageVma(usage),
                 .requiredFlags = 0,
@@ -270,6 +270,11 @@ namespace Vulkan {
                 .priority = 0.f,
         };
 
+        if (device.HasUnifiedMemory() && usage == MemoryUsage::DeviceLocal) {
+            alloc_ci.flags |= VMA_ALLOCATION_CREATE_MAPPED_BIT;
+            alloc_ci.preferredFlags |= VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
+        }
+
         VkBuffer handle{};
         VmaAllocationInfo alloc_info{};
         VmaAllocation allocation{};

src/video_core/vulkan_common/vulkan_surface.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -32,30 +32,15 @@ vk::SurfaceKHR CreateSurface(
     }
 #elif defined(__APPLE__)
     if (window_info.type == Core::Frontend::WindowSystemType::Cocoa) {
-        const VkMetalSurfaceCreateInfoEXT metal_ci = {
-            .sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT,
-            .pNext = nullptr,
-            .flags = 0,
+        const VkMetalSurfaceCreateInfoEXT macos_ci = {
             .pLayer = static_cast<const CAMetalLayer*>(window_info.render_surface),
         };
-        const auto vkCreateMetalSurfaceEXT = PFN_vkCreateMetalSurfaceEXT(dld.vkGetInstanceProcAddr(*instance, "vkCreateMetalSurfaceEXT"));
-        if (!vkCreateMetalSurfaceEXT || vkCreateMetalSurfaceEXT(*instance, &metal_ci, nullptr, &unsafe_surface) != VK_SUCCESS) {
-            // TODO: Way to fallback? - where's my vulkan headers
-            // Attempt to make a macOS surface instead then...
-            // This is the deprecated VkMacOSSurfaceCreateInfoMVK(3) version; but should work if the above failed
-            // https://registry.khronos.org/vulkan/specs/latest/man/html/VkMacOSSurfaceCreateInfoMVK.html
-            const VkMacOSSurfaceCreateInfoMVK macos_legacy_ci = {
-                .sType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK,
-                .pNext = nullptr,
-                .flags = 0,
-                .pView = static_cast<const void*>(window_info.render_surface),
-            };
-            const auto vkCreateMacOSSurfaceMVK = PFN_vkCreateMacOSSurfaceMVK(dld.vkGetInstanceProcAddr(*instance, "vkCreateMacOSSurfaceMVK"));
-            if (!vkCreateMacOSSurfaceMVK || vkCreateMacOSSurfaceMVK(*instance, &macos_legacy_ci, nullptr, &unsafe_surface) != VK_SUCCESS) {
-                LOG_ERROR(Render_Vulkan, "Failed to initialize Metal/macOS surface");
-                throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
-            }
-            LOG_ERROR(Render_Vulkan, "Failed to initialize Metal/macOS surface");
+        const auto vkCreateMetalSurfaceEXT = reinterpret_cast<PFN_vkCreateMetalSurfaceEXT>(
+            dld.vkGetInstanceProcAddr(*instance, "vkCreateMetalSurfaceEXT"));
+        if (!vkCreateMetalSurfaceEXT ||
+            vkCreateMetalSurfaceEXT(*instance, &macos_ci, nullptr, &unsafe_surface) != VK_SUCCESS) {
+            LOG_ERROR(Render_Vulkan, "Failed to initialize Metal surface");
+            throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
         }
     }
 #elif defined(__ANDROID__)

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -432,9 +432,10 @@ VkResult Free(VkDevice device, VkCommandPool handle, Span<VkCommandBuffer> buffe
 
 Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char*> extensions,
                           InstanceDispatch& dispatch) {
-    VkFlags ci_flags{};
 #ifdef __APPLE__
-    ci_flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
+    constexpr VkFlags ci_flags{VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR};
+#else
+    constexpr VkFlags ci_flags{};
 #endif
     // DO NOT TOUCH, breaks RNDA3!!
     // Don't know why, but gloom + yellow line glitch appears
@@ -462,7 +463,6 @@ Instance Instance::Create(u32 version, Span<const char*> layers, Span<const char
     if (!Proc(dispatch.vkDestroyInstance, dispatch, "vkDestroyInstance", instance)) {
         // We successfully created an instance but the destroy function couldn't be loaded.
         // This is a good moment to panic.
-        LOG_ERROR(Render_Vulkan, "No vkDestroyInstance found");
         throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
     }
     return Instance(instance, dispatch);