TEST

.patch/boost/0001-clang-cl.patch

@@ -0,0 +1,13 @@
+diff --git a/libs/cobalt/include/boost/cobalt/concepts.hpp b/libs/cobalt/include/boost/cobalt/concepts.hpp
+index d49f2ec..a9bdb80 100644
+--- a/libs/cobalt/include/boost/cobalt/concepts.hpp
++++ b/libs/cobalt/include/boost/cobalt/concepts.hpp
+@@ -62,7 +62,7 @@ struct enable_awaitables
+ template <typename T>
+ concept with_get_executor = requires (T& t)
+ {
+-  {t.get_executor()} -> asio::execution::executor;
++  t.get_executor();
+ };
+ 
+ 

CMakeLists.txt

@@ -417,9 +417,12 @@ AddJsonPackage(boost)
 set(BOOST_NO_HEADERS ${Boost_ADDED})
 
 if (Boost_ADDED)
-    add_compile_definitions(YUZU_BOOST_v1)
+    if (MSVC OR ANDROID)
+        add_compile_definitions(YUZU_BOOST_v1)
+    endif()
+
     if (NOT MSVC OR CXX_CLANG)
-        # solaris sucks
+        # boost sucks
         if (SOLARIS)
             add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
         endif()
@@ -428,7 +431,8 @@ if (Boost_ADDED)
         target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
         target_compile_options(boost_asio INTERFACE
             $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
+            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>
+        )
     endif()
 endif()
 

cpmfile.json

@@ -6,19 +6,22 @@
         "version": "v0.19.0"
     },
     "boost": {
-        "artifact": "boost-%VERSION%.tar.zst",
+        "artifact": "%VERSION%-cmake.tar.xz",
         "find_args": "CONFIG OPTIONAL_COMPONENTS headers context system fiber filesystem",
-        "hash": "681d97be4386767662e230b2e7c9754d45e709cc5db4e747c23c27d1f5b0e87770bdf19b0bc44dcb0e8349324887bbb8fffb432098f4d0ce74a5043021a90afc",
+        "hash": "6ae6e94664fe7f2fb01976b59b276ac5df8085c7503fa829d810fbfe495960cfec44fa2c36e2cb23480bc19c956ed199d4952b02639a00a6c07625d4e7130c2d",
         "min_version": "1.57",
         "package": "Boost",
-        "repo": "eden-emulator/ext-boost",
-        "version": "1.92.0"
+        "patches": [
+            "0001-clang-cl.patch"
+        ],
+        "repo": "boostorg/boost",
+        "version": "boost-1.90.0"
     },
     "boost_headers": {
         "bundled": true,
-        "hash": "c5fa2cd72f6e6666b7963b97bc359c75284b8fb540c30f3629a028b85270c9bc66c8a051383964f2bd4c1e005a4691593d15696e7ef39ea87cf6cff9e5691fb2",
+        "hash": "4ef845775e2277a8104ded6ddf749aa262ce52cf8438042869a048f9a0156dd772fbbcfa74efa1378fecef339b7286f6fe4b4feb5c45d49966b35d08e3e83507",
         "repo": "boostorg/headers",
-        "version": "boost-1.91.0"
+        "version": "boost-1.90.0"
     },
     "catch2": {
         "hash": "7eea385d79d88a5690cde131fe7ccda97d5c54ea09d6f515000d7bf07c828809d61c1ac99912c1ee507cf933f61c1c47ecdcc45df7850ffa82714034b0fccf35",

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -27,6 +27,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
     RENDERER_ASYNC_PRESENTATION("async_presentation"),
     RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
+    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -785,6 +785,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.renderer_asynchronous_shaders_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
+                    titleId = R.string.renderer_unified_memory,
+                    descriptionId = R.string.renderer_unified_memory_description
+                )
+            )
             put(
                 SingleChoiceSetting(
                     IntSetting.FAST_GPU_TIME,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -558,6 +558,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.FIX_BLOOM_EFFECTS.key)
             add(BooleanSetting.EMULATE_BGR565.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
+            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
             add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
             add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)

src/android/app/src/main/res/values/strings.xml

@@ -605,6 +605,8 @@
     <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
     <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
+    <string name="renderer_unified_memory">Unified memory access</string>
+    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
     <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
     <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
     <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>

src/common/CMakeLists.txt

@@ -110,6 +110,7 @@ add_library(
     socket_types.h
     sparse_large_vector.cpp
     sparse_large_vector.h
+    spin_lock.h
     stb.cpp
     stb.h
     steady_clock.cpp

src/common/cpu_features.cpp

@@ -244,8 +244,7 @@ WallClock::WallClock(bool invariant_, u64 rdtsc_frequency_) noexcept
     , ns_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(NsRatio::den, rdtsc_frequency_) : 0}
     , us_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(UsRatio::den, rdtsc_frequency_) : 0}
     , ms_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(MsRatio::den, rdtsc_frequency_) : 0}
-    , rdtsc_ns_integer{invariant_ ? rdtsc_frequency_ / NsRatio::den : 1}
-    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_ % NsRatio::den, NsRatio::den) : 0}
+    , rdtsc_ns_factor{invariant_ ? GetFixedPoint64Factor(rdtsc_frequency_, NsRatio::den) : 1}
     , cntpct_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(CNTFRQ, rdtsc_frequency_) : 0}
     , gputick_rdtsc_factor{invariant_ ? GetFixedPoint64Factor(GPUTickFreq, rdtsc_frequency_) : 0}
     , invariant{invariant_}
@@ -292,7 +291,7 @@ bool WallClock::IsNative() const {
 }
 
 u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
-    return ns.count() * rdtsc_ns_integer + MultiplyHigh(ns.count(), rdtsc_ns_factor);
+    return invariant ? MultiplyHigh(ns.count(), rdtsc_ns_factor) : ns.count();
 }
 #elif defined(HAS_NCE)
 namespace {
@@ -417,7 +416,7 @@ u64 WallClock::NsToTicks(std::chrono::nanoseconds ns) const {
 const WallClock g_wall_clock = [] {
 #if defined(ARCHITECTURE_x86_64)
     auto const& caps = Common::g_cpu_caps;
-    return WallClock(caps.invariant_tsc && caps.tsc_frequency > std::nano::den, caps.tsc_frequency);
+    return WallClock(caps.invariant_tsc && caps.tsc_frequency >= std::nano::den, caps.tsc_frequency);
 #elif defined(HAS_NCE)
     return WallClock(false, 1);
 #else

src/common/cpu_features.h

@@ -96,7 +96,6 @@ public:
     u64 ns_rdtsc_factor;
     u64 us_rdtsc_factor;
     u64 ms_rdtsc_factor;
-    u64 rdtsc_ns_integer;
     u64 rdtsc_ns_factor;
     u64 cntpct_rdtsc_factor;
     u64 gputick_rdtsc_factor;

src/common/fs/path_util.cpp

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
-#include <cctype>
 #include <iostream>
 #include <sstream>
 #include "common/container/unordered_map.h"
@@ -481,80 +480,28 @@ std::string SanitizePath(std::string_view path_, DirectorySeparator directory_se
                            [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
                path.end());
 
-    std::string root;
-    std::string_view components{path};
-    bool drive_relative = false;
-
-#ifdef _WIN32
-    const bool network = path.size() > 1 && path[0] == type2 && path[1] == type2;
-    const bool drive =
-        path.size() > 1 && std::isalpha(static_cast<unsigned char>(path[0])) && path[1] == ':';
-
-    if (network) {
-        root.assign(2, type2);
-        components.remove_prefix(2);
-    } else if (drive) {
-        root.assign(path.data(), 2);
-        components.remove_prefix(2);
-        if (!components.empty() && components.front() == type2) {
-            root += type2;
-            components.remove_prefix(1);
-        } else {
-            drive_relative = true;
-        }
-    }
-#endif
-
-    if (root.empty() && !components.empty() && components.front() == type2) {
-        root += type2;
-        components.remove_prefix(1);
-    }
-
-    const auto path_parts = SplitPathComponents(components);
-    std::size_t root_component_count = 0;
-#ifdef _WIN32
-    if (network) {
-        root_component_count = 2;
-
-        const auto is_unc = [](std::string_view part) {
-            return part.size() == 3 && (part[0] == 'U' || part[0] == 'u') &&
-                   (part[1] == 'N' || part[1] == 'n') && (part[2] == 'C' || part[2] == 'c');
-        };
-        if (path_parts.size() >= 2 && path_parts[0] == "?" && is_unc(path_parts[1])) {
-            root_component_count = 4;
-        }
-    }
-#endif
-
+    const bool absolute = !path.empty() && path[0] == type2;
     std::vector<std::string_view> parts;
-    for (std::size_t i = 0; i < path_parts.size(); ++i) {
-        const auto part = path_parts[i];
-        if (i < root_component_count) {
-            parts.push_back(part);
-        } else if (part.empty() || part == ".") {
+
+    for (const auto part : SplitPathComponents(path))
+    {
+        if (part.empty() || part == ".")
             continue;
-        } else if (part == "..") {
-            if (parts.size() > root_component_count) {
-                parts.pop_back();
-            }
-        } else {
-            parts.push_back(part);
-        }
+        if (part == ".." && !parts.empty() && parts.back() != "..")
+            parts.pop_back();
+        else if (part != "..") parts.push_back(part);
     }
 
-    const std::size_t root_length = root.size();
-    std::string resolved = std::move(root);
-    for (std::size_t i = 0; i < parts.size(); ++i) {
-        if (i != 0 || (!resolved.empty() && resolved.back() != type2 && !drive_relative))
+    std::string resolved = absolute ? std::string(1, type2) : std::string{};
+    for (std::size_t i = 0; i < parts.size(); ++i)
+    {
+        if (i != 0)
             resolved += type2;
         resolved.append(parts[i].data(), parts[i].size());
     }
 
     path = std::move(resolved);
 
-    if (!path.empty() && path.size() == root_length) {
-        return path;
-    }
     return std::string(RemoveTrailingSlash(path));
 }
 

src/common/fs/path_util.h

@@ -347,9 +347,8 @@ enum class DirectorySeparator {
 // i.e. "C:\Users\Yuzu\Documents\save.bin" becomes {"C:", "Users", "Yuzu", "Documents", "save.bin" }
 [[nodiscard]] std::vector<std::string> SplitPathComponentsCopy(std::string_view filename);
 
-// Normalizes directory separators, removes duplicate and non-root trailing separators, and resolves
-// '.' and '..' components without traversing above the path root. Windows drive and UNC roots are
-// preserved.
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
 [[nodiscard]] std::string SanitizePath(
     std::string_view path,
     DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);

src/common/heap_tracker.cpp

@@ -4,34 +4,17 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <fstream>
 #include "common/heap_tracker.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
 #include "common/assert.h"
 
 namespace Common {
 
-namespace {
-
-s64 GetMaxPermissibleResidentMapCount() {
-    // Default value.
-    s64 value = 65530;
-
-    // Try to read how many mappings we can make.
-    std::ifstream s("/proc/sys/vm/max_map_count");
-    s >> value;
-
-    // Print, for debug.
-    LOG_INFO(HW_Memory, "Current maximum map count: {}", value);
-
-    // Allow 20000 maps for other code and to account for split inaccuracy.
-    return std::max<s64>(value - 20000, 0);
-}
-
-} // namespace
-
 HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
+    : m_buffer(buffer),
+      m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()),
+      m_max_resident_map_count(static_cast<s64>(GetPermissibleMapCount())) {}
 HeapTracker::~HeapTracker() = default;
 
 void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length,
@@ -85,7 +68,8 @@ void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_hea
 
             // If resident, erase from resident map.
             if (item->is_resident) {
-                ASSERT(--m_resident_map_count >= 0);
+                m_resident_map_count -= this->HostMapCount(item->paddr, item->size);
+                ASSERT(m_resident_map_count >= 0);
                 m_resident_mappings.erase(m_resident_mappings.iterator_to(*item));
             }
 
@@ -191,7 +175,7 @@ bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) {
 
         // This map is now resident.
         it->is_resident = true;
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(it->paddr, it->size);
         m_resident_mappings.insert(*it);
     }
 
@@ -213,17 +197,17 @@ void HeapTracker::RebuildSeparateHeapAddressSpace() {
     // Despite being worse in theory, this has proven to be better in practice than more
     // regularly dumping a smaller amount, because it significantly reduces average case
     // lock contention.
-    std::size_t const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
-    std::size_t const evict_count = m_resident_map_count - desired_count;
+    s64 const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
     auto it = m_resident_mappings.begin();
 
-    for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) {
+    while (m_resident_map_count > desired_count && it != m_resident_mappings.end()) {
         // Unmark and unmap.
         it->is_resident = false;
         m_buffer.Unmap(it->vaddr, it->size, false);
 
         // Advance.
-        ASSERT(--m_resident_map_count >= 0);
+        m_resident_map_count -= this->HostMapCount(it->paddr, it->size);
+        ASSERT(m_resident_map_count >= 0);
         it = m_resident_mappings.erase(it);
     }
 }
@@ -245,6 +229,7 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
     // Cache the original values.
     auto* const left = std::addressof(*it);
     const size_t orig_size = left->size;
+    const s64 orig_host_map_count = this->HostMapCount(left->paddr, orig_size);
 
     // Adjust the left map.
     const size_t left_size = offset - left->vaddr;
@@ -266,11 +251,20 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
 
     // If resident, also insert into resident map.
     if (right->is_resident) {
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(left->paddr, left->size) +
+                                this->HostMapCount(right->paddr, right->size) -
+                                orig_host_map_count;
         m_resident_mappings.insert(*right);
     }
 }
 
+s64 HeapTracker::HostMapCount(PAddr paddr, size_t size) const {
+    if (!m_has_hardware_buffer_backing) {
+        return size != 0 ? 1 : 0;
+    }
+    return static_cast<s64>(m_buffer.BackingMapCount(paddr, size));
+}
+
 HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) {
     const SeparateHeapMap key{
         .vaddr = offset,

src/common/heap_tracker.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -82,10 +85,13 @@ private:
 
     AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);
 
+    s64 HostMapCount(PAddr paddr, size_t size) const;
+
     void RebuildSeparateHeapAddressSpace();
 
 private:
     Common::HostMemory& m_buffer;
+    const bool m_has_hardware_buffer_backing;
     const s64 m_max_resident_map_count;
 
     std::shared_mutex m_rebuild_lock{};

src/common/host_memory.cpp

@@ -51,14 +51,65 @@
 
 #endif // ^^^ POSIX ^^^
 
+#include <atomic>
 #include <mutex>
 #include <random>
+#include <vector>
 
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
+#include "common/settings.h"
+
+#ifdef __ANDROID__
+#include <cerrno>
+#include <dlfcn.h>
+#include <sys/ioctl.h>
+#include <android/hardware_buffer.h>
+
+namespace {
+
+struct NativeHandle {
+    int version;
+    int numFds;
+    int numInts;
+    int data[1];
+};
+
+using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
+
+PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
+    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
+    if (lib == nullptr) {
+        return nullptr;
+    }
+    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
+        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
+}
+
+struct DmaBufSync {
+    u64 flags;
+};
+
+constexpr u64 DmaBufSyncRead = 1ULL << 0;
+constexpr u64 DmaBufSyncWrite = 1ULL << 1;
+constexpr u64 DmaBufSyncStart = 0ULL << 2;
+constexpr u64 DmaBufSyncEnd = 1ULL << 2;
+
+void SyncDmaBufCpuAccess(int fd, u64 phase) {
+    DmaBufSync sync{.flags = phase | DmaBufSyncRead | DmaBufSyncWrite};
+    while (ioctl(fd, _IOW('b', 0, DmaBufSync), &sync) != 0) {
+        if (errno != EINTR) {
+            return;
+        }
+    }
+}
+
+} // namespace
+#endif
 
 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -75,6 +126,12 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;
 
+static std::atomic<u64> committed_backing_size{};
+
+u64 GetCommittedBackingSize() noexcept {
+    return committed_backing_size.load(std::memory_order_relaxed);
+}
+
 #ifdef _WIN32
 
 // Manually imported for MinGW compatibility
@@ -122,7 +179,7 @@ static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
         , process{GetCurrentProcess()}
@@ -236,6 +293,10 @@ public:
         UNREACHABLE();
     }
 
+    bool IsBackingShared() const noexcept {
+        return true;
+    }
+
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
 
@@ -512,9 +573,10 @@ static int shm_open_anon(int flags, mode_t mode) {
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
+        , preferred_offset{preferred_offset_}
     {}
 
     bool Init() {
@@ -554,10 +616,15 @@ public:
             LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NOCORE, -1, 0));
             if (fd > 0) {
-                fd = -1;
                 close(fd);
             }
+            fd = -1;
         } else {
+#ifdef __ANDROID__
+            if (InitAhbBacking()) {
+                return InitVirtual();
+            }
+#endif
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
@@ -565,7 +632,10 @@ public:
             return false;
         }
 
-        // Virtual memory initialization
+        return InitVirtual();
+    }
+
+    bool InitVirtual() {
         virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
         if (virtual_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -578,6 +648,244 @@ public:
         return true;
     }
 
+#ifdef __ANDROID__
+    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
+        return AHardwareBuffer_Desc{
+            .width = static_cast<u32>(len),
+            .height = 1,
+            .layers = 1,
+            .format = AHARDWAREBUFFER_FORMAT_BLOB,
+            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
+            .stride = 0,
+            .rfu0 = 0,
+            .rfu1 = 0,
+        };
+    }
+
+    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
+        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
+        AHardwareBuffer* buffer{};
+        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+            return false;
+        }
+        const NativeHandle* const handle = get_native_handle(buffer);
+        if (handle == nullptr || handle->numFds < 1) {
+            AHardwareBuffer_release(buffer);
+            return false;
+        }
+        const int probe_fd = handle->data[0];
+        bool ok = true;
+        const auto try_map = [&](int prot, off_t offset) {
+            if (!ok) {
+                return;
+            }
+            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
+            if (ptr == MAP_FAILED) {
+                ok = false;
+                return;
+            }
+            munmap(ptr, PageAlignment);
+        };
+        try_map(PROT_READ | PROT_WRITE, 0);
+        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment));
+#ifdef ARCHITECTURE_arm64
+        try_map(PROT_READ | PROT_EXEC, 0);
+#endif
+        AHardwareBuffer_release(buffer);
+        return ok;
+    }
+
+    size_t ComputeAhbBudget(size_t window_size) const {
+        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
+        constexpr u64 BaselineFootprint = 6ULL << 30;
+        if (total_physical <= BaselineFootprint) {
+            return 0;
+        }
+        const u64 permissible_maps = Common::GetPermissibleMapCount();
+        if (permissible_maps == 0) {
+            return 0;
+        }
+        u64 budget = (total_physical - BaselineFootprint) / 2;
+        constexpr u64 MapSlotsPerWindow = 64;
+        const u64 affordable_windows = permissible_maps / MapSlotsPerWindow;
+        budget = (std::min)(budget, affordable_windows * window_size);
+        const u64 available = Common::GetAvailablePhysicalMemory();
+        if (available != 0) {
+            budget = (std::min)(budget, available / 2);
+        }
+        budget = (std::min)(budget, static_cast<u64>(backing_size));
+        budget = Common::AlignDown(budget, window_size);
+        constexpr u64 MinimumBudget = 256ULL << 20;
+        if (budget < MinimumBudget) {
+            return 0;
+        }
+        return static_cast<size_t>(budget);
+    }
+
+    bool InitAhbBacking() {
+        if (!Settings::values.use_unified_memory.GetValue()) {
+            return false;
+        }
+        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
+            ResolveGetNativeHandle();
+        if (get_native_handle == nullptr) {
+            return false;
+        }
+        constexpr size_t window_size = 256ULL << 20;
+        const size_t budget = ComputeAhbBudget(window_size);
+        if (budget == 0) {
+            return false;
+        }
+        if (!ProbeAhbBacking(get_native_handle)) {
+            return false;
+        }
+        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
+        const size_t max_windows = (std::min)(budget, aligned_backing) / window_size;
+
+        std::vector<AHardwareBuffer*> buffers;
+        std::vector<int> buffer_fds;
+        const auto cleanup = [&] {
+            for (AHardwareBuffer* buffer : buffers) {
+                AHardwareBuffer_release(buffer);
+            }
+            buffers.clear();
+            buffer_fds.clear();
+        };
+        for (size_t i = 0; i < max_windows; ++i) {
+            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
+            AHardwareBuffer* buffer{};
+            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+                break;
+            }
+            const NativeHandle* const handle = get_native_handle(buffer);
+            if (handle == nullptr || handle->numFds < 1) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            const int buffer_fd = handle->data[0];
+            const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
+            if (buffer_len < static_cast<off_t>(window_size)) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            buffers.push_back(buffer);
+            buffer_fds.push_back(buffer_fd);
+        }
+        const size_t num_windows = buffers.size();
+        if (num_windows == 0) {
+            return false;
+        }
+        const size_t region_size = num_windows * window_size;
+        const size_t region_base = Common::AlignDown(
+            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
+        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
+                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
+        if (base == MAP_FAILED) {
+            cleanup();
+            return false;
+        }
+        const auto map_over_reservation = [&](size_t offset, size_t len, int map_fd,
+                                              off_t map_offset) {
+            if (len == 0) {
+                return true;
+            }
+            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
+                     map_offset) == MAP_FAILED) {
+                munmap(base, backing_size);
+                cleanup();
+                return false;
+            }
+            return true;
+        };
+        if (!map_over_reservation(0, region_base, fd, 0)) {
+            return false;
+        }
+        for (size_t i = 0; i < num_windows; ++i) {
+            if (!map_over_reservation(region_base + i * window_size, window_size, buffer_fds[i],
+                                      0)) {
+                return false;
+            }
+        }
+        const size_t tail_offset = region_base + region_size;
+        if (!map_over_reservation(tail_offset, backing_size - tail_offset, fd,
+                                  static_cast<off_t>(tail_offset))) {
+            return false;
+        }
+        backing_base = base;
+        ahb_windows = std::move(buffers);
+        ahb_fds = std::move(buffer_fds);
+        ahb_window_size = window_size;
+        ahb_base = region_base;
+        ahb_bytes = region_size;
+        committed_backing_size.store(region_size, std::memory_order_relaxed);
+        for (const int window_fd : ahb_fds) {
+            SyncDmaBufCpuAccess(window_fd, DmaBufSyncStart);
+        }
+        return true;
+    }
+
+    void MapBackingRange(size_t virtual_offset, size_t host_offset, size_t length, int prot_flags) {
+        while (length > 0) {
+            int map_fd = fd;
+            off_t map_offset = static_cast<off_t>(host_offset);
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t relative = host_offset - ahb_base;
+                const size_t window = relative / ahb_window_size;
+                const size_t local = relative % ahb_window_size;
+                map_fd = ahb_fds[window];
+                map_offset = static_cast<off_t>(local);
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            void* const ret = mmap(virtual_base + virtual_offset, chunk, prot_flags,
+                                   MAP_SHARED | MAP_FIXED, map_fd, map_offset);
+            ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
+            virtual_offset += chunk;
+            host_offset += chunk;
+            length -= chunk;
+        }
+    }
+
+    size_t BackingMapCount(size_t host_offset, size_t length) const noexcept {
+        if (length == 0) {
+            return 0;
+        }
+        if (ahb_bytes == 0) {
+            return 1;
+        }
+        size_t count = 0;
+        while (length > 0) {
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t local = (host_offset - ahb_base) % ahb_window_size;
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            host_offset += chunk;
+            length -= chunk;
+            ++count;
+        }
+        return count;
+    }
+
+    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t AhbWindowSize() const noexcept {
+        return ahb_bytes != 0 ? ahb_window_size : 0;
+    }
+
+    size_t AhbBase() const noexcept {
+        return ahb_base;
+    }
+#endif
+
     ~Impl() {
         Release();
     }
@@ -606,6 +914,12 @@ public:
 #ifdef ARCHITECTURE_arm64
         if (True(perms & MemoryPermission::Execute))
             prot_flags |= PROT_EXEC;
+#endif
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
+            return;
+        }
 #endif
         int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
         void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -651,8 +965,18 @@ public:
         virtual_base = nullptr;
     }
 
+    bool IsBackingShared() const noexcept {
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            return true;
+        }
+#endif
+        return fd >= 0;
+    }
+
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
+    const size_t preferred_offset;
 
     u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
     u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
@@ -675,6 +999,21 @@ private:
             int ret = close(fd);
             ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
         }
+
+#ifdef __ANDROID__
+        for (const int window_fd : ahb_fds) {
+            SyncDmaBufCpuAccess(window_fd, DmaBufSyncEnd);
+        }
+        for (AHardwareBuffer* buffer : ahb_windows) {
+            AHardwareBuffer_release(buffer);
+        }
+        ahb_windows.clear();
+        ahb_fds.clear();
+        if (ahb_bytes != 0) {
+            committed_backing_size.store(0, std::memory_order_relaxed);
+            ahb_bytes = 0;
+        }
+#endif
     }
 
     void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -700,11 +1039,19 @@ private:
 
     int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
     FreeRegionManager free_manager{};
+
+#ifdef __ANDROID__
+    std::vector<AHardwareBuffer*> ahb_windows;
+    std::vector<int> ahb_fds;
+    size_t ahb_window_size{};
+    size_t ahb_base{};
+    size_t ahb_bytes{};
+#endif
 };
 
 #endif // ^^^ POSIX ^^^
 
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
     : backing_size(backing_size_)
     , virtual_size(virtual_size_)
 {
@@ -714,7 +1061,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
     virtual_base = nullptr;
 #else
     // Try to allocate a fastmem arena.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
     if (impl->Init()) {
         backing_base = impl->backing_base;
         virtual_base = impl->virtual_base;
@@ -794,6 +1141,46 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
     std::memset(backing_base + physical_offset, fill_value, length);
 }
 
+std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
+#else
+    return {};
+#endif
+}
+
+size_t HostMemory::BackingMapCount(size_t host_offset, size_t length) const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->BackingMapCount(host_offset, length) : (length != 0 ? 1 : 0);
+#else
+    return length != 0 ? 1 : 0;
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindowSize() : 0;
+#else
+    return 0;
+#endif
+}
+
+bool HostMemory::IsBackingShared() const noexcept {
+#if defined(__OPENORBIS__) || defined(__managarm__)
+    return false;
+#else
+    return impl && impl->IsBackingShared();
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferBase() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbBase() : 0;
+#else
+    return 0;
+#endif
+}
+
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
     if (impl) {

src/common/host_memory.h

@@ -8,11 +8,16 @@
 
 #include <memory>
 #include <optional>
+#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 
+struct AHardwareBuffer;
+
 namespace Common {
 
+[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
+
 enum class MemoryPermission : u32 {
     Read = 1 << 0,
     Write = 1 << 1,
@@ -27,7 +32,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
  */
 class HostMemory {
 public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0);
     ~HostMemory();
 
     /**
@@ -61,6 +66,20 @@ public:
         return backing_base;
     }
 
+    [[nodiscard]] size_t BackingSize() const noexcept {
+        return backing_size;
+    }
+
+    [[nodiscard]] size_t BackingMapCount(size_t host_offset, size_t length) const noexcept;
+
+    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
+
+    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
+
+    [[nodiscard]] bool IsBackingShared() const noexcept;
+
     [[nodiscard]] u8* VirtualBasePointer() noexcept {
         return virtual_base;
     }

src/common/memory_detect.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -17,6 +20,10 @@
 #endif
 #endif
 
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
 #include "common/memory_detect.h"
 
 namespace Common {
@@ -69,4 +76,61 @@ const MemoryInfo& GetMemInfo() {
     return mem_info;
 }
 
+u64 GetPermissibleMapCount() {
+    constexpr u64 DefaultMapCount = 65530;
+    constexpr u64 ReservedMaps = 20000;
+    u64 count = DefaultMapCount;
+#ifdef __linux__
+    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
+        char line[32];
+        if (std::fgets(line, sizeof(line), file) != nullptr) {
+            const u64 parsed = std::strtoull(line, nullptr, 10);
+            if (parsed != 0) {
+                count = parsed;
+            }
+        }
+        std::fclose(file);
+    }
+#endif
+    if (count <= ReservedMaps) {
+        return 0;
+    }
+    return count - ReservedMaps;
+}
+
+u64 GetAvailablePhysicalMemory() {
+#ifdef _WIN32
+    MEMORYSTATUSEX memorystatus;
+    memorystatus.dwLength = sizeof(memorystatus);
+    if (GlobalMemoryStatusEx(&memorystatus) == 0) {
+        return 0;
+    }
+    return memorystatus.ullAvailPhys;
+#elif defined(__linux__)
+    static constexpr char AvailableKey[] = "MemAvailable:";
+    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
+        char line[256];
+        u64 available = 0;
+        while (std::fgets(line, sizeof(line), file) != nullptr) {
+            if (std::strncmp(line, AvailableKey, sizeof(AvailableKey) - 1) != 0) {
+                continue;
+            }
+            available = std::strtoull(line + sizeof(AvailableKey) - 1, nullptr, 10) * 1024;
+            break;
+        }
+        std::fclose(file);
+        if (available != 0) {
+            return available;
+        }
+    }
+    struct sysinfo meminfo;
+    if (sysinfo(&meminfo) != 0) {
+        return 0;
+    }
+    return static_cast<u64>(meminfo.freeram) * static_cast<u64>(meminfo.mem_unit);
+#else
+    return 0;
+#endif
+}
+
 } // namespace Common

src/common/memory_detect.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,4 +21,8 @@ struct MemoryInfo {
  */
 [[nodiscard]] const MemoryInfo& GetMemInfo();
 
+[[nodiscard]] u64 GetPermissibleMapCount();
+
+[[nodiscard]] u64 GetAvailablePhysicalMemory();
+
 } // namespace Common

src/common/page_table.h

@@ -96,15 +96,15 @@ struct PageTable {
         }
 
         /// Write page info atomically
-        inline void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
+        constexpr void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
             data_raw.store(std::bit_cast<u64>(Data{marked, type, block, pointer}));
         }
 
-        inline void MarkRasterizerCached() noexcept {
+        constexpr void MarkRasterizerCached() noexcept {
             data_raw.fetch_or(0b111);
         }
 
-        inline void MarkDebug(u64 ptr, u16 block) noexcept {
+        constexpr void MarkDebug(u64 ptr, u16 block) noexcept {
             Store(true, PageType::DebugMemory, block, ptr);
         }
 

src/common/settings.h

@@ -666,6 +666,9 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
 
+    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
+                                               Category::RendererHacks};
+
     SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                   GpuUnswizzleSize::Large,
                                                   "gpu_unswizzle_texture_size",

src/common/sparse_large_vector.h

@@ -38,8 +38,7 @@ void FreeMemoryPages(void* base, std::size_t size) noexcept;
 
 /// A large page-aligned buffer that has optimized memory usage for zero-writes.
 template <typename T>
-    // MSVC doesn't regard structs with atomics as trivially copyable
-    // requires std::is_trivially_copyable_v<T>
+requires std::is_trivially_copyable_v<T>
 class SparseLargeVector final {
 public:
     constexpr SparseLargeVector() = default;

src/common/spin_lock.h

@@ -0,0 +1,50 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#elif defined(ARCHITECTURE_x86_64)
+#include <xmmintrin.h>
+#endif
+#include <atomic>
+
+namespace Common {
+
+/// @brief A lock similar to mutex that forces a thread to spin wait instead calling the
+/// supervisor. Should be used on short sequences of code.
+struct SpinLock {
+    SpinLock() noexcept = default;
+    SpinLock(const SpinLock&) noexcept = delete;
+    SpinLock& operator=(const SpinLock&) noexcept = delete;
+    SpinLock(SpinLock&&) noexcept = delete;
+    SpinLock& operator=(SpinLock&&) noexcept = delete;
+
+    inline void lock() noexcept {
+        while (lck.test_and_set(std::memory_order_acquire)) {
+#if defined(ARCHITECTURE_x86_64)
+            _mm_pause();
+#elif defined(ARCHITECTURE_arm64) && defined(_MSC_VER)
+            __yield();
+#elif defined(ARCHITECTURE_arm64)
+            asm("yield");
+#endif
+        }
+    }
+
+    inline void unlock() noexcept {
+        lck.clear(std::memory_order_release);
+    }
+
+    [[nodiscard]] inline bool try_lock() noexcept {
+        return !lck.test_and_set(std::memory_order_acquire);
+    }
+
+    std::atomic_flag lck = ATOMIC_FLAG_INIT;
+};
+
+} // namespace Common

src/common/uuid.cpp

@@ -208,9 +208,9 @@ UUID UUID::MakeRandomRFC4122V4() {
     return uuid;
 }
 
-UUID UUID::MakeRFC4122V5(std::span<u8, 16> sha1) {
+UUID UUID::MakeRFC4122V5(std::span<u8, 20> sha1) {
     UUID uuid{};
-    std::memcpy(&uuid.uuid, sha1.data(), sha1.size());
+    std::memcpy(&uuid.uuid, sha1.data(), sizeof(UUID));
     uuid.uuid[8] = 0x80 | (uuid.uuid[8] & 0x3F);
     uuid.uuid[6] = 0x50 | (uuid.uuid[6] & 0xF);
     return uuid;

src/common/uuid.h

@@ -104,7 +104,7 @@ struct UUID {
     /// @returns A random UUID that is RFC 4122 Version 4 compliant.
     [[nodiscard]] static UUID MakeRandomRFC4122V4();
 
-    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 16> sha1);
+    [[nodiscard]] static UUID MakeRFC4122V5(std::span<u8, 20> sha1);
 
     friend constexpr bool operator==(const UUID& lhs, const UUID& rhs) = default;
 };

src/core/CMakeLists.txt

@@ -796,8 +796,6 @@ add_library(core STATIC
     hle/service/ns/application_manager_interface.h
     hle/service/ns/application_version_interface.cpp
     hle/service/ns/application_version_interface.h
-    hle/service/ns/async_result.cpp
-    hle/service/ns/async_result.h
     hle/service/ns/content_management_interface.cpp
     hle/service/ns/content_management_interface.h
     hle/service/ns/develop_interface.cpp

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -22,15 +22,21 @@ DynarmicCallbacks32::DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess
     , m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}
 {}
 
-u64 DynarmicCallbacks32::MemoryRead(u32 vaddr, size_t size) {
-    CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);
-    switch (size) {
-    case sizeof(u64): return m_memory.Read64(vaddr);
-    case sizeof(u32): return m_memory.Read32(vaddr);
-    case sizeof(u16): return m_memory.Read16(vaddr);
-    case sizeof(u8): return m_memory.Read8(vaddr);
-    default: UNREACHABLE();
-    }
+u8 DynarmicCallbacks32::MemoryRead8(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read8(vaddr);
+}
+u16 DynarmicCallbacks32::MemoryRead16(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read16(vaddr);
+}
+u32 DynarmicCallbacks32::MemoryRead32(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read32(vaddr);
+}
+u64 DynarmicCallbacks32::MemoryRead64(u32 vaddr) {
+    CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read64(vaddr);
 }
 
 std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {
@@ -44,17 +50,27 @@ std::optional<u32> DynarmicCallbacks32::MemoryReadCode(u32 vaddr) {
     return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];
 }
 
-void DynarmicCallbacks32::MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) {
-    if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {
-        switch (size) {
-        case sizeof(u64): return m_memory.Write64(vaddr, value);
-        case sizeof(u32): return m_memory.Write32(vaddr, u32(value));
-        case sizeof(u16): return m_memory.Write16(vaddr, u16(value));
-        case sizeof(u8): return m_memory.Write8(vaddr, u8(value));
-        default: UNREACHABLE();
-        }
+void DynarmicCallbacks32::MemoryWrite8(u32 vaddr, u8 value) {
+    if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write8(vaddr, value);
     }
 }
+void DynarmicCallbacks32::MemoryWrite16(u32 vaddr, u16 value) {
+    if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write16(vaddr, value);
+    }
+}
+void DynarmicCallbacks32::MemoryWrite32(u32 vaddr, u32 value) {
+    if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write32(vaddr, value);
+    }
+}
+void DynarmicCallbacks32::MemoryWrite64(u32 vaddr, u64 value) {
+    if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write64(vaddr, value);
+    }
+}
+
 bool DynarmicCallbacks32::MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) {
     return CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write) &&
             m_memory.WriteExclusive8(vaddr, value, expected);
@@ -161,7 +177,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
         config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>(
             const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
         config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = uint8_t(0);
+        config.page_table_marked_bit = 0;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
         config.only_detect_misalignment_via_page_table_on_page_boundary = true;
@@ -177,7 +193,7 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
             Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
             // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
             // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
+            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
         }
     }
 

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -30,12 +30,18 @@ class System;
 class DynarmicCallbacks32 : public Dynarmic::A32::UserCallbacks {
 public:
     explicit DynarmicCallbacks32(ArmDynarmic32& parent, Kernel::KProcess* process);
-    u64 MemoryRead(u32 vaddr, size_t size) override;
+    u8 MemoryRead8(u32 vaddr) override;
+    u16 MemoryRead16(u32 vaddr) override;
+    u32 MemoryRead32(u32 vaddr) override;
+    u64 MemoryRead64(u32 vaddr) override;
     std::optional<u32> MemoryReadCode(u32 vaddr) override;
     void InstructionSynchronizationBarrierRaised() override {
         last_code_addr = u64(-1); //reset back, force refetch
     }
-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override;
+    void MemoryWrite8(u32 vaddr, u8 value) override;
+    void MemoryWrite16(u32 vaddr, u16 value) override;
+    void MemoryWrite32(u32 vaddr, u32 value) override;
+    void MemoryWrite64(u32 vaddr, u64 value) override;
     bool MemoryWriteExclusive8(u32 vaddr, u8 value, u8 expected) override;
     bool MemoryWriteExclusive16(u32 vaddr, u16 value, u16 expected) override;
     bool MemoryWriteExclusive32(u32 vaddr, u32 value, u32 expected) override;

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -10,7 +10,6 @@
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_process.h"
-#include "dynarmic/interface/A64/config.h"
 
 namespace Core {
 
@@ -22,15 +21,21 @@ DynarmicCallbacks64::DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess
     , m_check_memory_access{m_debugger_enabled || !Settings::values.cpuopt_ignore_memory_aborts.GetValue()}
 {}
 
-u64 DynarmicCallbacks64::MemoryRead(u64 vaddr, size_t size) {
-    CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Read);
-    switch (size) {
-    case sizeof(u64): return m_memory.Read64(vaddr);
-    case sizeof(u32): return m_memory.Read32(vaddr);
-    case sizeof(u16): return m_memory.Read16(vaddr);
-    case sizeof(u8): return m_memory.Read8(vaddr);
-    default: UNREACHABLE();
-    }
+u8 DynarmicCallbacks64::MemoryRead8(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read8(vaddr);
+}
+u16 DynarmicCallbacks64::MemoryRead16(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read16(vaddr);
+}
+u32 DynarmicCallbacks64::MemoryRead32(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read32(vaddr);
+}
+u64 DynarmicCallbacks64::MemoryRead64(u64 vaddr) {
+    CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Read);
+    return m_memory.Read64(vaddr);
 }
 Dynarmic::A64::Vector DynarmicCallbacks64::MemoryRead128(u64 vaddr) {
     CheckMemoryAccess(vaddr, 16, Kernel::DebugWatchpointType::Read);
@@ -48,15 +53,24 @@ std::optional<u32> DynarmicCallbacks64::MemoryReadCode(u64 vaddr) {
     return cached_code_page.inst[(vaddr & Core::Memory::YUZU_PAGEMASK) / sizeof(u32)];
 }
 
-void DynarmicCallbacks64::MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) {
-    if (CheckMemoryAccess(vaddr, size, Kernel::DebugWatchpointType::Write)) {
-        switch (size) {
-        case sizeof(u64): return m_memory.Write64(vaddr, u64(value));
-        case sizeof(u32): return m_memory.Write32(vaddr, u32(value));
-        case sizeof(u16): return m_memory.Write16(vaddr, u16(value));
-        case sizeof(u8): return m_memory.Write8(vaddr, u8(value));
-        default: UNREACHABLE();
-        }
+void DynarmicCallbacks64::MemoryWrite8(u64 vaddr, u8 value) {
+    if (CheckMemoryAccess(vaddr, 1, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write8(vaddr, value);
+    }
+}
+void DynarmicCallbacks64::MemoryWrite16(u64 vaddr, u16 value) {
+    if (CheckMemoryAccess(vaddr, 2, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write16(vaddr, value);
+    }
+}
+void DynarmicCallbacks64::MemoryWrite32(u64 vaddr, u32 value) {
+    if (CheckMemoryAccess(vaddr, 4, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write32(vaddr, value);
+    }
+}
+void DynarmicCallbacks64::MemoryWrite64(u64 vaddr, u64 value) {
+    if (CheckMemoryAccess(vaddr, 8, Kernel::DebugWatchpointType::Write)) {
+        m_memory.Write64(vaddr, value);
     }
 }
 void DynarmicCallbacks64::MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) {
@@ -202,7 +216,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
             const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
         config.page_table_address_space_bits = std::uint32_t(address_space_bits);
         config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
-        config.page_table_marked_bit = uint8_t(0);
+        config.page_table_marked_bit = 0;
         config.silently_mirror_page_table = false;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -221,7 +235,7 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
             Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize()) < (1ULL << 39)) {
             // Systems like FreeBSD allocate memory really low by default, and since we pack our page table entries,
             // we have to manually sign extend when our actual pointer is negative.
-            config.page_table_sign_extension = std::uint8_t(Common::PageTable::SIGN_BIT);
+            config.page_table_sign_extension = Common::PageTable::SIGN_BIT;
         }
     }
 

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -16,7 +16,6 @@
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
-#include "dynarmic/interface/A64/config.h"
 
 namespace Core::Memory {
 class Memory;
@@ -37,13 +36,19 @@ class DynarmicCallbacks64 : public Dynarmic::A64::UserCallbacks {
 public:
     explicit DynarmicCallbacks64(ArmDynarmic64& parent, Kernel::KProcess* process);
 
-    u64 MemoryRead(u64 vaddr, size_t size) override;
+    u8 MemoryRead8(u64 vaddr) override;
+    u16 MemoryRead16(u64 vaddr) override;
+    u32 MemoryRead32(u64 vaddr) override;
+    u64 MemoryRead64(u64 vaddr) override;
     Dynarmic::A64::Vector MemoryRead128(u64 vaddr) override;
     std::optional<u32> MemoryReadCode(u64 vaddr) override;
     void InstructionSynchronizationBarrierRaised() override {
         last_code_addr = u64(-1); //reset back, force refetch
     }
-    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, std::size_t size) override;
+    void MemoryWrite8(u64 vaddr, u8 value) override;
+    void MemoryWrite16(u64 vaddr, u16 value) override;
+    void MemoryWrite32(u64 vaddr, u32 value) override;
+    void MemoryWrite64(u64 vaddr, u64 value) override;
     void MemoryWrite128(u64 vaddr, Dynarmic::A64::Vector value) override;
     bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, std::uint8_t expected) override;
     bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, std::uint16_t expected) override;

src/core/core.cpp

@@ -120,6 +120,7 @@ struct System::Impl {
 
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -147,7 +148,8 @@ struct System::Impl {
             !device_memory.has_value() ||
             is_multicore != Settings::values.use_multi_core.GetValue() ||
             extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb);
+                                       Settings::MemoryLayout::Memory_4Gb) ||
+            unified_memory != Settings::values.use_unified_memory.GetValue();
 
         if (!must_reinitialize) {
             return;
@@ -158,6 +160,7 @@ struct System::Impl {
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout =
             Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         Initialize(system);
     }
@@ -535,6 +538,7 @@ struct System::Impl {
     std::atomic_bool is_powered_on{};
     bool is_multicore : 1 = false;
     bool extended_memory_layout : 1 = false;
+    bool unified_memory : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
 

src/core/device_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,9 +15,18 @@ constexpr size_t VirtualReserveSize = 1ULL << 38;
 constexpr size_t VirtualReserveSize = 1ULL << 39;
 #endif
 
+namespace {
+size_t ApplicationPoolOffset() {
+    using Init = Kernel::Board::Nintendo::Nx::KSystemControl::Init;
+    const size_t dram_size = Init::GetIntendedMemorySize();
+    const size_t application_pool_size = Init::GetApplicationPoolSize();
+    return dram_size > application_pool_size ? dram_size - application_pool_size : 0;
+}
+}
+
 DeviceMemory::DeviceMemory()
     : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             VirtualReserveSize} {}
+             VirtualReserveSize, ApplicationPoolOffset()} {}
 
 DeviceMemory::~DeviceMemory() = default;
 

src/core/device_memory_manager.h

@@ -20,6 +20,8 @@
 #include "common/scratch_buffer.h"
 #include "common/sparse_large_vector.h"
 
+struct AHardwareBuffer;
+
 namespace Core {
 
 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -95,6 +97,34 @@ public:
         ApplyOpOnPAddr(address, buffer, operation);
     }
 
+    u8* GetPhysicalBase() noexcept {
+        return reinterpret_cast<u8*>(physical_base);
+    }
+
+    const u8* GetPhysicalBase() const noexcept {
+        return reinterpret_cast<const u8*>(physical_base);
+    }
+
+    size_t GetPhysicalSize() const noexcept {
+        return physical_size;
+    }
+
+    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t GetBackingHardwareBufferWindowSize() const noexcept {
+        return ahb_window_size;
+    }
+
+    size_t GetBackingHardwareBufferBase() const noexcept {
+        return ahb_base;
+    }
+
+    bool IsBackingShared() const noexcept {
+        return backing_is_shared;
+    }
+
     PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
         PAddr subbits = PAddr(address & page_mask);
         auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -171,6 +201,11 @@ private:
     std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;
 
     const uintptr_t physical_base;
+    const size_t physical_size;
+    const std::span<AHardwareBuffer* const> ahb_windows;
+    const size_t ahb_window_size;
+    const size_t ahb_base;
+    const bool backing_is_shared;
     DeviceInterface* device_inter;
 
     struct TrackedEntry {

src/core/device_memory_manager.inc

@@ -171,6 +171,11 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
     : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
+    , physical_size{device_memory_.buffer.BackingSize()}
+    , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
+    , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
+    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
+    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
     , device_inter{nullptr}
     , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
     , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)

src/core/file_sys/ips_layer.cpp

@@ -100,7 +100,8 @@ VirtualFile PatchIPS(const VirtualFile& in, const VirtualFile& ips) {
 
 
 struct IPSwitchRecord {
-    std::vector<uint8_t> data;
+    std::array<uint8_t, 256 - sizeof(size_t)> data;
+    size_t count;
 };
 struct IPSwitchCompiler::IPSwitchPatch {
     ::Common::unordered_map<u32, IPSwitchRecord> records;
@@ -121,23 +122,22 @@ static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
     IPSwitchRecord r{};
     for (auto it = sv.cbegin(); it < sv.cend(); ) {
         if (*it == '\\' && it + 1 < sv.cend()) {
-            r.data.push_back([it]() {
-                switch (it[1]) {
-                case 'a': return '\a';
-                case 'b': return '\b';
-                case 'e': return '\e';
-                case 'f': return '\f';
-                case 'n': return '\n';
-                case 'r': return '\r';
-                case 't': return '\t';
-                case 'v': return '\v';
-                case '?': return '\?';
-                default: return it[1];
-                }
-            }());
+            switch (it[1]) {
+            case 'a': r.data[r.count] = '\a'; break;
+            case 'b': r.data[r.count] = '\b'; break;
+            case 'e': r.data[r.count] = '\e'; break;
+            case 'f': r.data[r.count] = '\f'; break;
+            case 'n': r.data[r.count] = '\n'; break;
+            case 'r': r.data[r.count] = '\r'; break;
+            case 't': r.data[r.count] = '\t'; break;
+            case 'v': r.data[r.count] = '\v'; break;
+            case '?': r.data[r.count] = '\?'; break;
+            default: r.data[r.count] = it[1]; break;
+            }
+            ++r.count;
             it += 2;
         } else {
-            r.data.push_back(*it);
+            ++r.count;
             ++it;
         }
     }
@@ -223,8 +223,8 @@ void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
                 if (start <= line.cend() && end <= line.cend()) {
                     // Actually IPS wants ordering from {lsb, ..., msb} -- so LE and BE are inverted, fun!
                     auto const hs = Common::HexStringToVector({start, end}, is_little_endian);
-                    r.data.resize(hs.size());
                     std::memcpy(r.data.data(), hs.data(), hs.size());
+                    r.count = hs.size();
                     LOG_INFO(Loader, "[H] value @ {:#08X}", offset);
                     patches.back().records.insert_or_assign(u32(offset), std::move(r));
                 } else {
@@ -293,7 +293,7 @@ VirtualFile IPSwitchCompiler::Apply(const VirtualFile& in) const {
         if (patch.enabled) {
             for (const auto& record : patch.records) {
                 if (record.first < in_data.size()) {
-                    auto replace_size = record.second.data.size();
+                    auto replace_size = record.second.count;
                     if (record.first + replace_size > in_data.size())
                         replace_size = in_data.size() - record.first;
                     std::memcpy(in_data.data() + record.first, record.second.data.data(), replace_size);

src/core/file_sys/patch_manager.cpp

@@ -9,7 +9,6 @@
 #include <cstddef>
 #include <cstring>
 
-#include "common/assert.h"
 #include "common/hex_util.h"
 #include "common/logging.h"
 #include "common/settings.h"
@@ -157,15 +156,12 @@ std::string GetUpdateVersionStringFromSlot(const ContentProvider* provider, u64
     NACP nacp{nacp_file};
     return nacp.GetVersionString();
 }
-YUZU_NO_INLINE std::optional<u64> GetParentApplicationId(const ContentProvider* provider, u64 title_id) {
-    return provider == nullptr ? std::nullopt : provider->GetParentApplicationId(title_id);
-}
 } // Anonymous namespace
 
 PatchManager::PatchManager(u64 title_id_,
                            const Service::FileSystem::FileSystemController& fs_controller_,
                            const ContentProvider& content_provider_)
-    : title_id{title_id_}, parent_title_id{GetParentApplicationId(std::addressof(content_provider_), title_id_)}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
+    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
 
 PatchManager::~PatchManager() = default;
 
@@ -173,35 +169,13 @@ u64 PatchManager::GetTitleID() const {
     return title_id;
 }
 
-VirtualDir PatchManager::GetModificationLoadRoot(bool sdmc) const {
-    const auto get_root = [&](u64 id) {
-        return sdmc ? fs_controller.GetSDMCModificationLoadRoot(id) : fs_controller.GetModificationLoadRoot(id);
-    };
-    auto root = get_root(title_id);
-    if (!parent_title_id) {
-        return root;
-    }
-    std::vector<VirtualDir> roots{std::move(root), get_root(*parent_title_id)};
-    std::erase(roots, nullptr);
-    return LayeredVfsDirectory::MakeLayeredDirectory(std::move(roots));
-}
-
-std::vector<std::string> PatchManager::GetDisabledAddons() const {
-    auto disabled = Settings::values.disabled_addons[title_id];
-    if (parent_title_id) {
-        const auto& shared = Settings::values.disabled_addons[*parent_title_id];
-        disabled.insert(disabled.end(), shared.begin(), shared.end());
-    }
-    return disabled;
-}
-
 VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     LOG_INFO(Loader, "Patching ExeFS for title_id={:016X}", title_id);
 
     if (exefs == nullptr)
         return exefs;
 
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
 
     bool update_disabled = true;
     std::optional<u32> enabled_version;
@@ -329,8 +303,8 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
     }
 
     // LayeredExeFS
-    const auto load_dir = GetModificationLoadRoot();
-    const auto sdmc_load_dir = GetModificationLoadRoot(true);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
 
     std::vector<VirtualDir> patch_dirs = {sdmc_load_dir};
     if (load_dir != nullptr) {
@@ -372,7 +346,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 }
 
 std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualDir>& patch_dirs, const std::string& build_id) const {
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto nso_build_id = fmt::format("{:0<64}", build_id);
 
     std::vector<VirtualFile> out;
@@ -431,7 +405,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 
     LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
 
-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return nso;
@@ -474,7 +448,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}, name={}", build_id, name);
 
-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return false;
@@ -488,13 +462,13 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_, std::string_view name)
 }
 
 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildID& build_id_) const {
-    const auto load_dir = GetModificationLoadRoot();
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return {};
     }
 
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
     auto patch_dirs = load_dir->GetSubdirectories();
     std::sort(patch_dirs.begin(), patch_dirs.end(), [](auto const& l, auto const& r) { return l->GetName() < r->GetName(); });
 
@@ -528,16 +502,17 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(const BuildI
     return out;
 }
 
-void PatchManager::ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const {
-    const auto load_dir = GetModificationLoadRoot();
-    const auto sdmc_load_dir = GetModificationLoadRoot(true);
+static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
+                           const Service::FileSystem::FileSystemController& fs_controller) {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
+    const auto sdmc_load_dir = fs_controller.GetSDMCModificationLoadRoot(title_id);
     if ((type != ContentRecordType::Program && type != ContentRecordType::Data &&
          type != ContentRecordType::HtmlDocument) ||
         (load_dir == nullptr && sdmc_load_dir == nullptr)) {
         return;
     }
 
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
     std::vector<VirtualDir> patch_dirs = load_dir->GetSubdirectories();
     if (std::find(disabled.cbegin(), disabled.cend(), "SDMC") == disabled.cend()) {
         patch_dirs.push_back(sdmc_load_dir);
@@ -616,7 +591,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto disabled = GetDisabledAddons();
+    const auto& disabled = Settings::values.disabled_addons[title_id];
 
     bool update_disabled = true;
     std::optional<u32> enabled_version;
@@ -723,7 +698,7 @@ VirtualFile PatchManager::PatchRomFS(const NCA* base_nca, VirtualFile base_romfs
 
     // LayeredFS
     if (apply_layeredfs) {
-        ApplyLayeredFS(romfs, type);
+        ApplyLayeredFS(romfs, title_id, type, fs_controller);
     }
 
     return romfs;
@@ -1097,22 +1072,15 @@ std::vector<Patch> PatchManager::GetPatches(VirtualFile update_raw) const {
 std::optional<u32> PatchManager::GetGameVersion() const {
     const auto update_tid = GetUpdateTitleID(title_id);
     if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
-        const auto version = content_provider.GetEntryVersion(update_tid);
-        return version || !parent_title_id ? version : content_provider.GetEntryVersion(GetUpdateTitleID(*parent_title_id));
+        return content_provider.GetEntryVersion(update_tid);
     }
 
-    const auto version = content_provider.GetEntryVersion(title_id);
-    return version || !parent_title_id ? version : content_provider.GetEntryVersion(*parent_title_id);
+    return content_provider.GetEntryVersion(title_id);
 }
 
 PatchManager::Metadata PatchManager::GetControlMetadata() const {
     const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr) {
-        if (parent_title_id) {
-            const auto control_id = content_provider.HasEntry(*parent_title_id, ContentRecordType::Control) ? *parent_title_id : GetUpdateTitleID(*parent_title_id);
-            const PatchManager parent{control_id, fs_controller, content_provider};
-            return parent.GetControlMetadata();
-        }
         return {};
     }
 

src/core/file_sys/patch_manager.h

@@ -109,14 +109,10 @@ public:
     [[nodiscard]] static PatchManager::Metadata GetMetadataFromBaseOrUpdate(Core::System& system, u64 application_id) noexcept;
 
 private:
-    [[nodiscard]] VirtualDir GetModificationLoadRoot(bool sdmc = false) const;
-    [[nodiscard]] std::vector<std::string> GetDisabledAddons() const;
-    void ApplyLayeredFS(VirtualFile& romfs, ContentRecordType type) const;
     [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
                                                           const std::string& build_id) const;
 
     u64 title_id;
-    std::optional<u64> parent_title_id;
     const Service::FileSystem::FileSystemController& fs_controller;
     const ContentProvider& content_provider;
 };

src/core/file_sys/registered_cache.cpp

@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <algorithm>
-#include <limits>
 #include <random>
 #include <regex>
 #include <openssl/evp.h>
@@ -349,22 +348,6 @@ std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
     return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
 }
 
-std::optional<u64> ContentProvider::GetParentApplicationId(u64 program_id) const {
-    const auto application_id = GetBaseTitleID(program_id);
-    const auto program_index = program_id - application_id;
-    if (program_index == 0 || program_index > std::numeric_limits<u8>::max()) {
-        return std::nullopt;
-    }
-    if (!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, program_id).empty()) {
-        return std::nullopt;
-    }
-    if ((!ListEntriesFilter(TitleType::Application, ContentRecordType::Meta, application_id).empty() && HasEntry(program_id, ContentRecordType::Program))
-     || (!ListEntriesFilter(TitleType::Update, ContentRecordType::Meta, GetUpdateTitleID(application_id)).empty() && HasEntry(GetUpdateTitleID(program_id), ContentRecordType::Program))) {
-        return application_id;
-    }
-    return std::nullopt;
-}
-
 PlaceholderCache::PlaceholderCache(VirtualDir dir_) : dir(std::move(dir_)) {}
 
 bool PlaceholderCache::Create(const NcaID& id, u64 size) const {

src/core/file_sys/registered_cache.h

@@ -100,8 +100,6 @@ public:
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
         std::optional<u64> title_id = {}) const = 0;
 
-    [[nodiscard]] std::optional<u64> GetParentApplicationId(u64 program_id) const;
-
 protected:
     // A single instance of KeyManager to be used by GetEntry()
     Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();

src/core/file_sys/savedata_factory.cpp

@@ -9,7 +9,6 @@
 #include "common/logging.h"
 #include "common/uuid.h"
 #include "core/core.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"
 
@@ -62,24 +61,17 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,
 
 SaveDataFactory::~SaveDataFactory() = default;
 
-std::string SaveDataFactory::GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const {
-    if (type == SaveDataType::Account || type == SaveDataType::Device) {
-        const auto requested_id = title_id != 0 ? title_id : program_id;
-        const auto parent_id = system.GetContentProvider().GetParentApplicationId(requested_id);
-        title_id = parent_id.value_or(requested_id);
-    }
-    return GetFullPath(program_id, dir, space, type, title_id, user_id, save_id);
-}
-
 VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
 
     return dir->CreateDirectoryRelative(save_directory);
 }
 
 VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
 
-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
@@ -162,7 +154,8 @@ std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future)
 
 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                                u128 user_id) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
@@ -180,7 +173,8 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 
 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                         SaveDataSize new_value) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());

src/core/file_sys/savedata_factory.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -50,7 +47,6 @@ public:
     void SetAutoCreate(bool state);
 
 private:
-    std::string GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const;
     Core::System& system;
     ProgramId program_id;
     VirtualDir dir;

src/core/frontend/applets/controller.cpp

@@ -12,7 +12,6 @@
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/hid_core.h"
 #include "hid_core/hid_types.h"
-#include <array>
 
 namespace Core::Frontend {
 
@@ -30,39 +29,23 @@ void DefaultControllerApplet::ReconfigureControllers(ReconfigureCallback callbac
 
     const std::size_t min_supported_players =
         parameters.enable_single_mode ? 1 : parameters.min_players;
-    using Core::HID::NpadStyleIndex;
-    const std::size_t max_supported_players = parameters.enable_single_mode ? 1 : parameters.max_players;
-    std::size_t num_selected_players = 0;
-    std::array<bool, HID::HIDCore::available_controllers> keep_connected{};
 
-    // reserve existing AND valid players before filling slots. include Handheld, but not other
-    for (std::size_t index = 0; index < hid_core.available_controllers - 1; ++index) {
-        const auto* controller = hid_core.GetEmulatedControllerByIndex(index);
-        if (!parameters.keep_controllers_connected || !controller->IsConnected() || num_selected_players >= max_supported_players) continue;
-
-        const auto style = controller->GetNpadStyleIndex();
-        keep_connected[index] =
-            (style == NpadStyleIndex::Fullkey && parameters.allow_pro_controller) ||
-            (style == NpadStyleIndex::JoyconDual && parameters.allow_dual_joycons) ||
-            (style == NpadStyleIndex::JoyconLeft && parameters.allow_left_joycon) ||
-            (style == NpadStyleIndex::JoyconRight && parameters.allow_right_joycon) ||
-            (style == NpadStyleIndex::Handheld && parameters.enable_single_mode && parameters.allow_handheld && !Settings::IsDockedMode()) ||
-            (style == NpadStyleIndex::GameCube && parameters.allow_gamecube_controller);
-        num_selected_players += keep_connected[index];
-    }
+    // Disconnect Handheld first.
     auto* handheld = hid_core.GetEmulatedController(Core::HID::NpadIdType::Handheld);
-    if (!keep_connected[hid_core.available_controllers - 2]) handheld->Disconnect();
+    handheld->Disconnect();
 
     // Deduce the best configuration based on the input parameters.
     for (std::size_t index = 0; index < hid_core.available_controllers - 2; ++index) {
         auto* controller = hid_core.GetEmulatedControllerByIndex(index);
 
-        if (keep_connected[index]) continue;
+        // First, disconnect all controllers regardless of the value of keep_controllers_connected.
+        // This makes it easy to connect the desired controllers.
         controller->Disconnect();
 
-        // only add players still needed to reach the minimum
-        if (num_selected_players >= min_supported_players) continue;
-        ++num_selected_players;
+        // Only connect the minimum number of required players.
+        if (index >= min_supported_players) {
+            continue;
+        }
 
         // Connect controllers based on the following priority list from highest to lowest priority:
         // Pro Controller -> Dual Joycons -> Left Joycon/Right Joycon -> Handheld

src/core/hle/kernel/k_scheduler.cpp

@@ -465,10 +465,6 @@ void KScheduler::ScheduleImplFiber(KernelCore& kernel) {
         // Check if we need scheduling. If we do, then we can't complete the switch and should
         // retry.
         if (m_state.needs_scheduling.load(std::memory_order_seq_cst)) {
-            // Some libc++ lazily init mutex
-            [[maybe_unused]] auto const can_lock = highest_priority_thread->m_context_guard.try_lock();
-            DEBUG_ASSERT(!can_lock);
-
             // Our switch failed.
             // We should unlock the thread context, and then retry.
             highest_priority_thread->m_context_guard.unlock();
@@ -500,10 +496,6 @@ void KScheduler::Unload(KernelCore& kernel, KThread* thread) {
 
     // Check if the thread is terminated by checking the DPC flags.
     if ((thread->GetStackParameters().dpc_flags & static_cast<u32>(DpcFlag::Terminated)) == 0) {
-        // Some libc++ lazily init mutex
-        [[maybe_unused]] auto const can_lock = thread->m_context_guard.try_lock();
-        DEBUG_ASSERT(!can_lock);
-
         // The thread isn't terminated, so we want to unlock it.
         thread->m_context_guard.unlock();
     }

src/core/hle/kernel/k_slab_heap.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 2020 yuzu Emulator Project
@@ -12,6 +12,7 @@
 #include "common/atomic_ops.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/spin_lock.h"
 
 namespace Kernel {
 
@@ -29,7 +30,7 @@ public:
     };
 
 public:
-    KSlabHeapImpl() = default;
+    constexpr KSlabHeapImpl() = default;
 
     void Initialize() {
         ASSERT(m_head == nullptr);
@@ -67,7 +68,7 @@ public:
 
 private:
     std::atomic<Node*> m_head{};
-    std::mutex m_lock;
+    Common::SpinLock m_lock;
 };
 
 } // namespace impl

src/core/hle/kernel/k_thread.h

@@ -19,6 +19,7 @@
 
 #include "common/intrusive_red_black_tree.h"
 #include "common/scratch_buffer.h"
+#include "common/spin_lock.h"
 #include "core/arm/arm_interface.h"
 #include "core/hle/kernel/k_affinity_mask.h"
 #include "core/hle/kernel/k_light_lock.h"
@@ -919,7 +920,7 @@ private:
     bool m_resource_limit_release_hint{};
     bool m_is_kernel_address_key{};
     StackParameters m_stack_parameters{};
-    std::mutex m_context_guard{};
+    Common::SpinLock m_context_guard{};
 
     // For emulation
     std::shared_ptr<Common::Fiber> m_host_context{};

src/core/hle/service/acc/profile_manager.h

@@ -23,12 +23,6 @@ constexpr std::size_t profile_username_size{32};
 using ProfileUsername = std::array<u8, profile_username_size>;
 using UserIDArray = std::array<Common::UUID, MAX_USERS>;
 
-// This is nn::account::Uid
-struct Uid {
-    std::array<u8, 0x10> unk0;
-};
-static_assert(sizeof(Uid) == 0x10);
-
 /// Contains extra data related to a user.
 /// TODO: RE this structure
 struct UserData {

src/core/hle/service/am/lifecycle_manager.h

@@ -92,13 +92,6 @@ public:
         }
     }
 
-    void RequestFocusStateChangedNotification(Kernel::KernelCore& kernel) {
-        if (m_focus_state_changed_notification_enabled) {
-            m_has_focus_state_changed = true;
-            this->SignalSystemEventIfNeeded(kernel);
-        }
-    }
-
     void OnOperationAndPerformanceModeChanged(Kernel::KernelCore& kernel);
 
 public:

src/core/hle/service/am/service/application_functions.cpp

@@ -347,22 +347,21 @@ Result IApplicationFunctions::NotifyRunning(Out<bool> out_became_running) {
 
 Result IApplicationFunctions::GetPseudoDeviceId(Out<Common::UUID> out_pseudo_device_id) {
     LOG_WARNING(Service_AM, "(stubbed)");
-    R_UNLESS(out_pseudo_device_id != nullptr, ResultUnknown);
+    R_UNLESS(out_pseudo_device_id, ResultUnknown);
 
     // This should be hashed with the device specific hash
     // for now this will do
     const auto res = FileSys::PatchManager::GetMetadataFromBaseOrUpdate(system, m_applet->program_id);
-    R_UNLESS(res.first != nullptr, ResultUnknown);
-    std::array<u8, EVP_MAX_MD_SIZE> hash;
+    u8 hash[EVP_MAX_MD_SIZE];
     unsigned int hash_len = 0;
     auto const seed = res.first->raw.seed_for_pseudo_device_id;
     EVP_MD_CTX *ctx = EVP_MD_CTX_new();
     auto const algorithm = EVP_sha1();
     EVP_DigestInit_ex(ctx, algorithm, nullptr);
     EVP_DigestUpdate(ctx, &seed, sizeof(seed));
-    EVP_DigestFinal_ex(ctx, hash.data(), &hash_len);
+    EVP_DigestFinal_ex(ctx, hash, &hash_len);
     EVP_MD_CTX_free(ctx);
-    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 16>{hash.begin(), hash.begin() + 16});
+    *out_pseudo_device_id = Common::UUID::MakeRFC4122V5(std::span<u8, 20>{hash, std::size(hash)});
     R_SUCCEED();
 }
 

src/core/hle/service/am/service/library_applet_accessor.cpp

@@ -164,15 +164,15 @@ Result ILibraryAppletAccessor::PushInData(SharedPointer<IStorage> storage) {
 Result ILibraryAppletAccessor::PopOutData(Out<SharedPointer<IStorage>> out_storage) {
     LOG_DEBUG(Service_AM, "called");
 
-    R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
     if (auto caller_applet = m_applet->caller_applet.lock(); caller_applet) {
-        std::scoped_lock lk{caller_applet->lock};
-        const bool focus_state_changed = caller_applet->lifecycle_manager.UpdateRequestedFocusState();
-        const bool is_front_app = m_applet->frontend && caller_applet->lifecycle_manager.IsApplication();
-        if (focus_state_changed) caller_applet->lifecycle_manager.SignalSystemEventIfNeeded(system.Kernel());
-        else if (is_front_app) caller_applet->lifecycle_manager.RequestFocusStateChangedNotification(system.Kernel());
+        caller_applet->lifecycle_manager.GetSystemEvent().Signal(system.Kernel());
+        caller_applet->lifecycle_manager.RequestResumeNotification();
+        caller_applet->lifecycle_manager.GetSystemEvent().Clear(system.Kernel());
+        caller_applet->lifecycle_manager.UpdateRequestedFocusState();
     }
 
+    R_TRY(m_broker->GetOutData().Pop(system.Kernel(), out_storage.Get()));
+
     if (m_applet->applet_id == AppletId::ProfileSelect && *out_storage) {
         auto impl = (*out_storage)->GetImpl();
 

src/core/hle/service/filesystem/fsp/fsp_srv.cpp

@@ -154,9 +154,6 @@ FSP_SRV::FSP_SRV(Core::System& system_)
         {720, nullptr, "AbandonAccessFailure"},
         {800, nullptr, "GetAndClearFileSystemProxyErrorInfo"},
         {810, nullptr, "RegisterProgramIndexMapInfo"},
-        {820, nullptr, "GetContentStorageInfoIndex"},
-        {830, nullptr, "EncryptStreamPlaySaveData"},
-        {831, nullptr, "DecryptStreamPlaySaveData"},
         {1000, nullptr, "SetBisRootForHost"},
         {1001, nullptr, "SetSaveDataSize"},
         {1002, nullptr, "SetSaveDataRootPath"},

src/core/hle/service/hid/hid_system_server.cpp

@@ -121,7 +121,7 @@ IHidSystemServer::IHidSystemServer(Core::System& system_, std::shared_ptr<Resour
         {547, nullptr, "GetAllowedBluetoothLinksCount"},
         {548, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevices"},
         {549, nullptr, "GetConnectableRegisteredDevices"},
-        {551, &IHidSystemServer::GetRegisteredDevices, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+ //mocked via 548 for Diablo 3 (at least)
+        {551, nullptr, "GetRegisteredDevicesForControllerSupport"}, //20.0.0+
         {700, nullptr, "ActivateUniquePad"},
         {702, &IHidSystemServer::AcquireUniquePadConnectionEventHandle, "AcquireUniquePadConnectionEventHandle"},
         {703, &IHidSystemServer::GetUniquePadIds, "GetUniquePadIds"},
@@ -758,7 +758,7 @@ void IHidSystemServer::AcquireDeviceRegisteredEventForControllerSupport(HLEReque
 }
 
 void IHidSystemServer::GetRegisteredDevices(HLERequestContext& ctx) {
-    LOG_WARNING(Service_HID, "(STUBBED) called, command={}", ctx.GetCommand()); //548 or 551
+    LOG_WARNING(Service_HID, "(STUBBED) called");
 
     struct RegisterData {
         std::array<u8, 0x68> data;

src/core/hle/service/ipc_helpers.h

@@ -22,7 +22,6 @@
 
 namespace IPC {
 
-constexpr Result ResultNotSupported{ErrorModule::HIPC, 1};
 constexpr Result ResultSessionClosed{ErrorModule::HIPC, 301};
 
 struct ResponseBuilder {

src/core/hle/service/jit/jit_context.cpp

@@ -71,14 +71,17 @@ public:
     void InstructionSynchronizationBarrierRaised() override {
         last_code_addr = u64(-1); //reset back, force refetch
     }
-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return ReadMemory<u64>(vaddr);
-        case sizeof(u32): return ReadMemory<u32>(vaddr);
-        case sizeof(u16): return ReadMemory<u16>(vaddr);
-        case sizeof(u8): return ReadMemory<u8>(vaddr);
-        default: UNREACHABLE();
-        }
+    u8 MemoryRead8(u64 vaddr) override {
+        return ReadMemory<u8>(vaddr);
+    }
+    u16 MemoryRead16(u64 vaddr) override {
+        return ReadMemory<u16>(vaddr);
+    }
+    u32 MemoryRead32(u64 vaddr) override {
+        return ReadMemory<u32>(vaddr);
+    }
+    u64 MemoryRead64(u64 vaddr) override {
+        return ReadMemory<u64>(vaddr);
     }
     u128 MemoryRead128(u64 vaddr) override {
         return ReadMemory<u128>(vaddr);
@@ -86,19 +89,22 @@ public:
     std::string MemoryReadCString(u64 vaddr) {
         std::string result{};
         u8 next;
-        while ((next = u8(MemoryRead(vaddr++, sizeof(u8)))) != 0)
+        while ((next = MemoryRead8(vaddr++)) != 0)
             result += char(next);
         return result;
     }
 
-    void MemoryWrite(u64 vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64): WriteMemory<u64>(vaddr, u64(value)); break;
-        case sizeof(u32): WriteMemory<u32>(vaddr, u32(value)); break;
-        case sizeof(u16): WriteMemory<u16>(vaddr, u16(value)); break;
-        case sizeof(u8): WriteMemory<u8>(vaddr, u8(value)); break;
-        default: UNREACHABLE();
-        }
+    void MemoryWrite8(u64 vaddr, u8 value) override {
+        WriteMemory<u8>(vaddr, value);
+    }
+    void MemoryWrite16(u64 vaddr, u16 value) override {
+        WriteMemory<u16>(vaddr, value);
+    }
+    void MemoryWrite32(u64 vaddr, u32 value) override {
+        WriteMemory<u32>(vaddr, value);
+    }
+    void MemoryWrite64(u64 vaddr, u64 value) override {
+        WriteMemory<u64>(vaddr, value);
     }
     void MemoryWrite128(u64 vaddr, u128 value) override {
         WriteMemory<u128>(vaddr, value);
@@ -187,14 +193,14 @@ public:
         // The loaded NRO file has ELF relocations that must be processed before it can run.
         // Normally this would be processed by RTLD, but in HLE context, we don't have
         // the linker available, so we have to do it ourselves.
-        const VAddr mod_offset{callbacks->MemoryRead(4, sizeof(u32))};
-        if (callbacks->MemoryRead(mod_offset, sizeof(u32)) != Common::MakeMagic('M', 'O', 'D', '0'))
+        const VAddr mod_offset{callbacks->MemoryRead32(4)};
+        if (callbacks->MemoryRead32(mod_offset) != Common::MakeMagic('M', 'O', 'D', '0'))
             return false;
 
         // For more info about dynamic entries, see the ELF ABI specification:
         // https://refspecs.linuxbase.org/elf/gabi4+/ch5.dynamic.html
         // https://refspecs.linuxbase.org/elf/gabi4+/ch4.reloc.html
-        VAddr dynamic_offset{mod_offset + callbacks->MemoryRead(mod_offset + 4, sizeof(u32))};
+        VAddr dynamic_offset{mod_offset + callbacks->MemoryRead32(mod_offset + 4)};
         VAddr rela_dyn = 0, relr_dyn = 0;
         size_t num_rela = 0, num_relr = 0;
         while (true) {
@@ -216,8 +222,8 @@ public:
         for (size_t i = 0; i < num_rela; i++) {
             const auto rela{callbacks->ReadMemory<Elf64_Rela>(rela_dyn + i * sizeof(Elf64_Rela))};
             if (Elf64RelType(rela.r_info) == ElfAArch64Relative) {
-                const VAddr contents{callbacks->MemoryRead(rela.r_offset, sizeof(u64))};
-                callbacks->MemoryWrite(rela.r_offset, contents + rela.r_addend, sizeof(u64));
+                const VAddr contents{callbacks->MemoryRead64(rela.r_offset)};
+                callbacks->MemoryWrite64(rela.r_offset, contents + rela.r_addend);
             }
         }
 
@@ -225,7 +231,7 @@ public:
         for (size_t i = 0; i < num_relr; i++) {
             const auto relr = callbacks->ReadMemory<Elf64_Relr>(relr_dyn + i * sizeof(Elf64_Relr));
             const auto incr = [&](VAddr where) {
-                callbacks->MemoryWrite(where, callbacks->MemoryRead(where, sizeof(u64)) + relocbase, sizeof(u64));
+                callbacks->MemoryWrite64(where, callbacks->MemoryRead64(where) + relocbase);
             };
             if ((relr & 1) == 0) {
                 // where pointer
@@ -288,7 +294,7 @@ public:
         if (argument_stack.size() > 8) {
             const VAddr new_sp = Common::AlignDown(top_of_stack - (argument_stack.size() - 8) * sizeof(u64), STACK_ALIGN);
             for (size_t i = 8; i < argument_stack.size(); i++)
-                callbacks->MemoryWrite(new_sp + (i - 8) * sizeof(u64), argument_stack[i], sizeof(u64));
+                callbacks->MemoryWrite64(new_sp + (i - 8) * sizeof(u64), argument_stack[i]);
             jit->SetSP(new_sp);
         }
         // Reset the call state for the next invocation
@@ -379,17 +385,17 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {
 
         if (dest < src) {
             for (size_t i = 0; i < n; i++)
-                MemoryWrite(dest + i, u8(MemoryRead(src + i, sizeof(u8))), sizeof(u8));
+                MemoryWrite8(dest + i, MemoryRead8(src + i));
         } else {
             for (size_t i = n; i > 0; i--)
-                MemoryWrite(dest + i - 1, u8(MemoryRead(src + i - 1, sizeof(u8))), sizeof(u8));
+                MemoryWrite8(dest + i - 1, MemoryRead8(src + i - 1));
         }
     } else if (pc == parent.helpers[size_t(HelperFn::Memset)]) {
         const VAddr dest{parent.jit->GetRegister(0)};
         const u64 c{parent.jit->GetRegister(1)};
         const size_t n{parent.jit->GetRegister(2)};
         for (size_t i = 0; i < n; i++)
-            MemoryWrite(dest + i, u8(c), sizeof(u8));
+            MemoryWrite8(dest + i, u8(c));
     } else if (pc == parent.helpers[size_t(HelperFn::Resolve)]) {
         // X0 contains a char* for a symbol to resolve
         const auto name{MemoryReadCString(parent.jit->GetRegister(0))};
@@ -416,7 +422,7 @@ void DynarmicCallbacks64::CallSVC(u32 swi) {
 }
 
 void DynarmicCallbacks64::ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) {
-    auto const inst = MemoryRead(pc, sizeof(u32));
+    auto const inst = MemoryRead32(pc);
     LOG_CRITICAL(Service_JIT, "{} PC @ {:08x}, data = {:08x}", exception, pc, inst);
     parent.jit->HaltExecution();
 }

src/core/hle/service/ngc/ngc.cpp

@@ -6,16 +6,10 @@
 
 #include "common/string_util.h"
 #include "core/core.h"
-#include "core/hle/kernel/k_client_session.h"
-#include "core/hle/result.h"
-#include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/ngc/ngc.h"
 #include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "frontend_common/firmware_manager.h"
 
 namespace Service::NGC {
 
@@ -172,123 +166,12 @@ public:
     }
 };
 
-struct SaveDataHandle {
-    u64 unk0;
-};
-static_assert(sizeof(SaveDataHandle) == 0x08);
-
-class IUserShimScopedObject final : public ServiceFramework<IUserShimScopedObject> {
-public:
-    explicit IUserShimScopedObject(Core::System& system_) : ServiceFramework(system_, "IUserShimScopedObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {450, nullptr, "InitializeForSaveData"},
-            {451, nullptr, "FinalizeForSaveData"},
-            {452, D<&IUserShimScopedObject::OpenSaveData>, "OpenSaveData"},
-            {453, nullptr, "CloseSaveData"},
-            {454, D<&IUserShimScopedObject::ReadSaveSlot>, "ReadSaveSlot"},
-            {455, D<&IUserShimScopedObject::WriteSaveSlot>, "WriteSaveSlot"},
-            {456, nullptr, "FlushSaveSlot"},
-            {457, nullptr, "CommitSaveData"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-    Result OpenSaveData(Account::Uid unk0, Out<SaveDataHandle> unk1) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result ReadSaveSlot(s32 offset, SaveDataHandle handle, OutBuffer<BufferAttr_HipcAutoSelect> out_data, Out<u32> out_size) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result WriteSaveSlot(s32 offset, SaveDataHandle handle, InBuffer<BufferAttr_HipcAutoSelect> out_data) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        // to implement
-        R_SUCCEED();
-    }
-};
-
-class IUserService final : public ServiceFramework<IUserService> {
-public:
-    explicit IUserService(Core::System& system_) : ServiceFramework(system_, "stpl:u") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0 , D<&IUserService::Cmd0>, "Cmd0"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    Result Cmd0(u32 unk0, OutInterface<IUserShimScopedObject> out_interface) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        *out_interface = std::make_shared<IUserShimScopedObject>(system);
-        R_SUCCEED();
-    }
-};
-
-class ISystemShimScopedObject final : public ServiceFramework<ISystemShimScopedObject> {
-public:
-    explicit ISystemShimScopedObject(Core::System& system_) : ServiceFramework(system_, "ISystemShimScopedObject") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {106, nullptr, "Cmd106"},
-            {107, nullptr, "Cmd107"},
-            {108, D<&ISystemShimScopedObject::Cmd108>, "Cmd108"},
-            {207, nullptr, "Cmd207"},
-            {208, D<&ISystemShimScopedObject::Cmd208>, "Cmd208"},
-            {209, nullptr, "Cmd209"},
-            {210, nullptr, "Cmd210"},
-            {211, nullptr, "Cmd211"},
-            {212, nullptr, "Cmd212"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-
-    Result Cmd108() {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-
-    Result Cmd208(Out<std::array<u8, 0x20>> unk0) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        R_THROW(IPC::ResultNotSupported);
-    }
-};
-
-class ISystemService final : public ServiceFramework<ISystemService> {
-public:
-    explicit ISystemService(Core::System& system_) : ServiceFramework(system_, "stpl:sys") {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0 , D<&ISystemService::Cmd0>, "Cmd0"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    Result Cmd0(OutInterface<ISystemShimScopedObject> out_interface) {
-        LOG_WARNING(Service_NGC, "stubbed");
-        *out_interface = std::make_shared<ISystemShimScopedObject>(system);
-        R_SUCCEED();
-    }
-};
-
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 
     server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system), 4);
     server_manager->RegisterNamedService("ngct:s", std::make_shared<IServiceWithManagementApi>(system), 4);
     server_manager->RegisterNamedService("ngc:u", std::make_shared<NgcServiceImpl>(system), 4);
-
-    // +23.0.0
-    if (FirmwareManager::GetFirmwareVersion(system).first.major >= 23) {
-        server_manager->RegisterNamedService("stpl:u", std::make_shared<IUserService>(system), 4);
-        server_manager->RegisterNamedService("stpl:sys", std::make_shared<ISystemService>(system), 4);
-    }
-
     ServerManager::RunServer(std::move(server_manager));
 }
 

src/core/hle/service/ns/application_manager_interface.cpp

@@ -228,9 +228,9 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {930, nullptr, "Unknown930"}, //20.0.0+
         {931, nullptr, "Unknown931"}, //20.0.0+
         {933, nullptr, "Unknown933"}, //20.0.0+
-        {934, nullptr, "Unknown934"}, //21.0.0+
-        {935, nullptr, "Unknown935"}, //21.0.0+
-        {936, D<&IApplicationManagerInterface::Unknown936>, "Unknown936"}, //21.0.0+
+        {934, nullptr, "Unknown934"}, //20.0.0+
+        {935, nullptr, "Unknown935"}, //20.0.0+
+        {936, nullptr, "Unknown936"}, //20.0.0+
         {1000, nullptr, "RequestVerifyApplicationDeprecated"},
         {1001, nullptr, "CorruptApplicationForDebug"},
         {1002, nullptr, "RequestVerifyAddOnContentsRights"},
@@ -422,7 +422,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {4039, nullptr, "Unknown4039"}, //20.0.0+
         {4040, nullptr, "Unknown4040"}, //20.0.0+
         {4041, nullptr, "Unknown4041"}, //20.0.0+
-        {4042, D<&IApplicationManagerInterface::Unknown4042>, "Unknown4042"}, //20.0.0+
+        {4042, nullptr, "Unknown4042"}, //20.0.0+
         {4043, nullptr, "Unknown4043"}, //20.0.0+
         {4044, nullptr, "Unknown4044"}, //20.0.0+
         {4045, nullptr, "Unknown4045"}, //20.0.0+
@@ -639,12 +639,6 @@ Result IApplicationManagerInterface::IsGameCardApplicationRunning(Out<bool> out_
     R_SUCCEED();
 }
 
-Result IApplicationManagerInterface::Unknown936(Out<u64> out_result) {
-    LOG_WARNING(Service_NS, "(STUBBED) called.");
-    *out_result = 0;
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::IsAnyApplicationEntityInstalled(
     Out<bool> out_is_any_application_entity_installed) {
     LOG_WARNING(Service_NS, "(STUBBED) called");
@@ -868,15 +862,6 @@ Result IApplicationManagerInterface::Unknown4023(Out<u64> out_result) {
     R_SUCCEED();
 }
 
-Result IApplicationManagerInterface::Unknown4042(OutInterface<IAsyncResult> out_interface,
-                                                 OutCopyHandle<Kernel::KReadableEvent> out_event,
-                                                 u64 arg1, u64 arg2) {
-    LOG_WARNING(Service_NS, "(STUBBED) called, arg1={:016X}, arg2={:016X}", arg1, arg2);
-    *out_event = unknown_event.GetHandle();
-    *out_interface = std::make_shared<IAsyncResult>(system, &unknown_event);
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::Unknown4053() {
     LOG_WARNING(Service_NS, "(STUBBED) called.");
     R_SUCCEED();

src/core/hle/service/ns/application_manager_interface.h

@@ -7,7 +7,6 @@
 #pragma once
 
 #include "core/hle/service/cmif_types.h"
-#include "core/hle/service/ns/async_result.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/os/event.h"
@@ -35,7 +34,6 @@ public:
     Result GetGameCardMountFailureEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result GetGameCardWakenReadyEvent(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result IsGameCardApplicationRunning(Out<bool> out_is_running);
-    Result Unknown936(Out<u64> out_result);
     Result IsAnyApplicationEntityInstalled(Out<bool> out_is_any_application_entity_installed);
     Result GetApplicationViewDeprecated(
         OutArray<ApplicationViewV19, BufferAttr_HipcMapAlias> out_application_views,
@@ -73,9 +71,6 @@ public:
                                   InBuffer<BufferAttr_HipcMapAlias> logo_path_buffer);
     Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result Unknown4023(Out<u64> out_result);
-    Result Unknown4042(OutInterface<IAsyncResult> out_interface,
-                       OutCopyHandle<Kernel::KReadableEvent> out_event,
-                       u64 arg1, u64 arg2);
     Result Unknown4053();
     Result Unknown4105();
 

src/core/hle/service/ns/async_result.cpp

@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/ns/async_result.h"
-
-#include <cstring>
-
-namespace Service::NS {
-
-IAsyncResult::IAsyncResult(Core::System& system_, Service::Event* event_)
-    : ServiceFramework{system_, "nn::ns::detail::IAsyncResult"}, event{event_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, nullptr, "Get"},
-        {1, D<&IAsyncResult::Cancel>, "Cancel"},
-        {2, nullptr, "GetErrorContext"}, // 4.0.0+
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-IAsyncResult::~IAsyncResult() = default;
-
-Result IAsyncResult::Cancel() {
-    LOG_DEBUG(Service_NS, "called");
-    if (event != nullptr) {
-        event->Signal(system.Kernel());
-    }
-
-    R_SUCCEED();
-}
-
-} // namespace Service::NS

src/core/hle/service/ns/async_result.h

@@ -1,19 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/hle/service/service.h"
-
-namespace Service::NS {
-
-class IAsyncResult final : public ServiceFramework<IAsyncResult> {
-public:
-    explicit IAsyncResult(Core::System& system_, Service::Event* event_);
-    ~IAsyncResult() override;
-
-private:
-    Result Cancel();
-
-    Service::Event* event{};
-};
-
-} // namespace Service::NS

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -311,30 +311,27 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
         // u64 - app count
         memory.WriteBlock(t_mem_address + out_length, &app_count, sizeof(u64));
         out_length += sizeof(u64);
-        ASSERT(out_length <= t_mem->GetSize());
         // [list of u64] - size of icons
         for (size_t i = 0; i < app_count; ++i) {
             const u64 app_id = app_ids_buffer[i];
             const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                u64 full_size = control.second->GetSize();
-                memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
-            }
+            const auto control = pm.GetControlMetadata();
+            u64 full_size = control.second->GetSize();
+            memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
             out_length += sizeof(u64);
-            ASSERT(out_length <= t_mem->GetSize());
         }
         // [list of raw icon data]
+        std::vector<u8> full_icon_data;
         for (size_t i = 0; i < app_count; ++i) {
             const u64 app_id = app_ids_buffer[i];
             const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            if (const auto control = pm.GetControlMetadata(); control.second) {
-                if (auto const full_size = control.second->GetSize(); full_size > 0) {
-                    std::vector<u8> full_icon_data(full_size);
-                    control.second->Read(full_icon_data.data(), full_size, 0);
-                    memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
-                    out_length += full_size;
-                    ASSERT(out_length <= t_mem->GetSize());
-                }
+            const auto control = pm.GetControlMetadata();
+            auto const full_size = control.second->GetSize();
+            if (full_size > 0) {
+                full_icon_data.resize(full_size);
+                control.second->Read(full_icon_data.data(), full_size, 0);
+                memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
+                out_length += full_size;
             }
         }
     }
@@ -348,12 +345,6 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestCon
 void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
     const auto app_ids_buffer = ctx.ReadBuffer();
     const size_t app_count = app_ids_buffer.size() / sizeof(u64);
-
-    std::vector<u64> application_ids(app_count);
-    if (app_count > 0) {
-        std::memcpy(application_ids.data(), app_ids_buffer.data(), app_count * sizeof(u64));
-    }
-
     auto t_mem_obj = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(ctx.GetCopyHandle(0));
     auto* t_mem = t_mem_obj.GetPointerUnsafe();
     constexpr size_t title_entry_size = sizeof(FileSys::LanguageEntry);
@@ -363,9 +354,8 @@ void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestCo
         auto& memory = system.ApplicationMemory();
         const auto t_mem_address = t_mem->GetSourceAddress();
         for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = application_ids[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(),
-                                           system.GetContentProvider()};
+            const u64 app_id = app_ids_buffer[i];
+            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
             const auto control = pm.GetControlMetadata();
             FileSys::LanguageEntry entry{};
             if (control.first != nullptr) {

src/core/hle/service/ssl/ssl.cpp

@@ -48,12 +48,6 @@ enum class OptionType : u32 {
     EnableAlpn = 3,
 };
 
-// This is nn::ssl::sf::RenegotiationMode
-enum RenegotiationMode : u32 {
-    None = 0, ///< None
-    Secure = 1, ///< Secure
-};
-
 // This is nn::ssl::sf::SslVersion
 struct SslVersion {
     union {
@@ -81,34 +75,34 @@ public:
           shared_data{shared_data_in}, backend{std::move(backend_in)} {
         // clang-format off
         static const FunctionInfo functions[] = {
-            {0, D<&ISslConnection::SetSocketDescriptor>, "SetSocketDescriptor"},
-            {1, D<&ISslConnection::SetHostName>, "SetHostName"},
-            {2, D<&ISslConnection::SetVerifyOption>, "SetVerifyOption"},
-            {3, D<&ISslConnection::SetIoMode>, "SetIoMode"},
-            {4, D<&ISslConnection::GetSocketDescriptor>, "GetSocketDescriptor"},
-            {5, D<&ISslConnection::GetHostName>, "GetHostName"},
+            {0, &ISslConnection::SetSocketDescriptor, "SetSocketDescriptor"},
+            {1, &ISslConnection::SetHostName, "SetHostName"},
+            {2, &ISslConnection::SetVerifyOption, "SetVerifyOption"},
+            {3, &ISslConnection::SetIoMode, "SetIoMode"},
+            {4, nullptr, "GetSocketDescriptor"},
+            {5, nullptr, "GetHostName"},
             {6, nullptr, "GetVerifyOption"},
-            {7, D<&ISslConnection::GetIoMode>, "GetIoMode"},
-            {8, D<&ISslConnection::DoHandshake>, "DoHandshake"},
+            {7, nullptr, "GetIoMode"},
+            {8, &ISslConnection::DoHandshake, "DoHandshake"},
             {9, &ISslConnection::DoHandshakeGetServerCert, "DoHandshakeGetServerCert"},
-            {10, D<&ISslConnection::Read>, "Read"},
-            {11, D<&ISslConnection::Write>, "Write"},
-            {12, D<&ISslConnection::Pending>, "Pending"},
-            {13, D<&ISslConnection::Peek>, "Peek"},
-            {14, D<&ISslConnection::Poll>, "Poll"},
-            {15, D<&ISslConnection::GetVerifyCertError>, "GetVerifyCertError"},
-            {16, D<&ISslConnection::GetNeededServerCertBufferSize>, "GetNeededServerCertBufferSize"},
-            {17, D<&ISslConnection::SetSessionCacheMode>, "SetSessionCacheMode"},
-            {18, D<&ISslConnection::GetSessionCacheMode>, "GetSessionCacheMode"},
-            {19, D<&ISslConnection::FlushSessionCache>, "FlushSessionCache"},
-            {20, D<&ISslConnection::SetRenegotiationMode>, "SetRenegotiationMode"},
-            {21, D<&ISslConnection::GetRenegotiationMode>, "GetRenegotiationMode"},
-            {22, D<&ISslConnection::SetOption>, "SetOption"},
-            {23, D<&ISslConnection::GetOption>, "GetOption"},
+            {10, &ISslConnection::Read, "Read"},
+            {11, &ISslConnection::Write, "Write"},
+            {12, &ISslConnection::Pending, "Pending"},
+            {13, nullptr, "Peek"},
+            {14, nullptr, "Poll"},
+            {15, nullptr, "GetVerifyCertError"},
+            {16, nullptr, "GetNeededServerCertBufferSize"},
+            {17, &ISslConnection::SetSessionCacheMode, "SetSessionCacheMode"},
+            {18, nullptr, "GetSessionCacheMode"},
+            {19, nullptr, "FlushSessionCache"},
+            {20, nullptr, "SetRenegotiationMode"},
+            {21, nullptr, "GetRenegotiationMode"},
+            {22, &ISslConnection::SetOption, "SetOption"},
+            {23, &ISslConnection::GetOption, "GetOption"},
             {24, nullptr, "GetVerifyCertErrors"},
             {25, nullptr, "GetCipherInfo"},
-            {26, D<&ISslConnection::SetNextAlpnProto>, "SetNextAlpnProto"},
-            {27, D<&ISslConnection::GetNextAlpnProto>, "GetNextAlpnProto"},
+            {26, &ISslConnection::SetNextAlpnProto, "SetNextAlpnProto"},
+            {27, &ISslConnection::GetNextAlpnProto, "GetNextAlpnProto"},
             {28, nullptr, "SetDtlsSocketDescriptor"},
             {29, nullptr, "GetDtlsHandshakeTimeout"},
             {30, nullptr, "SetPrivateOption"},
@@ -147,6 +141,80 @@ public:
     }
 
 private:
+    SslVersion ssl_version;
+    std::shared_ptr<SslContextSharedData> shared_data;
+    std::unique_ptr<SSLConnectionBackend> backend;
+    std::optional<int> fd_to_close;
+    bool do_not_close_socket = false;
+    bool get_server_cert_chain = false;
+    bool skip_default_verify = false;
+    bool enable_alpn = false;
+    std::shared_ptr<Network::SocketBase> socket;
+    std::vector<u8> next_alpn_proto;
+    bool did_handshake = false;
+    u32 verify_option = 0;
+
+    Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
+        LOG_DEBUG(Service_SSL, "called, fd={}", fd);
+        ASSERT(!did_handshake);
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
+        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
+
+        auto const res_v = bsd->DuplicateSocketImpl(fd);
+        if (auto *res = std::get_if<s32>(&res_v)) {
+            const s32 duplicated_fd = *res;
+            if (do_not_close_socket) {
+                *out_fd = duplicated_fd;
+            } else {
+                *out_fd = -1;
+                fd_to_close = duplicated_fd;
+            }
+            std::optional<std::shared_ptr<Network::SocketBase>> sock = bsd->GetSocket(duplicated_fd);
+            if (!sock.has_value()) {
+                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", duplicated_fd);
+                return ResultInvalidSocket;
+            }
+            socket = std::move(*sock);
+            backend->SetSocket(socket);
+            return ResultSuccess;
+        }
+        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", fd);
+        return ResultInvalidSocket;
+    }
+
+    Result SetHostNameImpl(const std::string& hostname) {
+        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
+        ASSERT(!did_handshake);
+        return backend->SetHostName(hostname);
+    }
+
+    Result SetVerifyOptionImpl(u32 option) {
+        ASSERT(!did_handshake);
+        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
+        verify_option = 0;
+        backend->SetVerifyOption(0);
+        return ResultSuccess;
+    }
+
+    Result SetIoModeImpl(u32 input_mode) {
+        auto mode = static_cast<IoMode>(input_mode);
+        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
+        ASSERT_OR_EXECUTE(socket, { return ResultNoSocket; });
+
+        const bool non_block = mode == IoMode::NonBlocking;
+        const Network::Errno error = socket->SetNonBlock(non_block);
+        if (error != Network::Errno::SUCCESS) {
+            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
+        }
+        return ResultSuccess;
+    }
+
+    Result SetSessionCacheModeImpl(u32 mode) {
+        ASSERT(!did_handshake);
+        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
+        return ResultSuccess;
+    }
+
     Result DoHandshakeImpl() {
         ASSERT_OR_EXECUTE(!did_handshake && socket, { return ResultNoSocket; });
         Result res = backend->DoHandshake();
@@ -166,17 +234,19 @@ private:
         };
         if (!get_server_cert_chain) {
             // Just return the first one, unencoded.
-            ASSERT_OR_EXECUTE_MSG(!certs.empty(), { return {}; }, "Should be at least one server cert");
+            ASSERT_OR_EXECUTE_MSG(
+                !certs.empty(), { return {}; }, "Should be at least one server cert");
             return certs[0];
         }
         std::vector<u8> ret;
-        Header header{0x4E4D684374726543, u32(certs.size()), 0};
+        Header header{0x4E4D684374726543, static_cast<u32>(certs.size()), 0};
         ret.insert(ret.end(), reinterpret_cast<u8*>(&header), reinterpret_cast<u8*>(&header + 1));
         size_t data_offset = sizeof(Header) + certs.size() * sizeof(EntryHeader);
         for (auto& cert : certs) {
-            EntryHeader entry_header{u32(cert.size()), u32(data_offset)};
+            EntryHeader entry_header{static_cast<u32>(cert.size()), static_cast<u32>(data_offset)};
             data_offset += cert.size();
-            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header), reinterpret_cast<u8*>(&entry_header + 1));
+            ret.insert(ret.end(), reinterpret_cast<u8*>(&entry_header),
+                       reinterpret_cast<u8*>(&entry_header + 1));
         }
         for (auto& cert : certs) {
             ret.insert(ret.end(), cert.begin(), cert.end());
@@ -184,77 +254,65 @@ private:
         return ret;
     }
 
-    Result SetSocketDescriptor(s32 in_fd, Out<s32> out_fd) {
-        LOG_DEBUG(Service_SSL, "called, fd={}", in_fd);
-        ASSERT(!did_handshake);
-        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
-        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });
-
-        auto const res_v = bsd->DuplicateSocketImpl(in_fd);
-        if (auto *res = std::get_if<s32>(&res_v)) {
-            const s32 dup_fd = *res;
-            *out_fd = do_not_close_socket ? dup_fd : -1;
-            if (!do_not_close_socket)
-                fd_to_close = dup_fd;
-            auto const sock = bsd->GetSocket(dup_fd);
-            if (!sock.has_value()) {
-                LOG_ERROR(Service_SSL, "invalid socket fd {} after duplication", dup_fd);
-                return ResultInvalidSocket;
-            }
-            socket = std::move(*sock);
-            backend->SetSocket(std::move(socket));
-            return ResultSuccess;
+    Result ReadImpl(std::vector<u8>* out_data) {
+        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
+        size_t actual_size{};
+        Result res = backend->Read(&actual_size, *out_data);
+        if (res != ResultSuccess) {
+            return res;
         }
-        LOG_ERROR(Service_SSL, "Failed to duplicate socket with fd {}", in_fd);
-        return ResultInvalidSocket;
+        out_data->resize(actual_size);
+        return res;
     }
 
-    Result SetHostName(InBuffer<BufferAttr_HipcMapAlias> buf) {
-        auto const hostname = Common::StringFromBuffer(buf);
-        LOG_DEBUG(Service_SSL, "called. hostname={}", hostname);
-        ASSERT(!did_handshake);
-        return backend->SetHostName(hostname.c_str());
+    Result WriteImpl(size_t* out_size, std::span<const u8> data) {
+        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
+        return backend->Write(out_size, data);
     }
 
-    Result SetVerifyOption(u32 option) {
-        LOG_DEBUG(Service_SSL, "called. option={} (forcing 0)", option);
-        ASSERT(!did_handshake);
-        verify_option = 0;
-        backend->SetVerifyOption(0);
-        R_SUCCEED();
+    Result PendingImpl(s32* out_pending) {
+        LOG_WARNING(Service_SSL, "(STUBBED) called.");
+        *out_pending = 0;
+        return ResultSuccess;
     }
 
-    Result SetIoMode(u32 input_mode) {
-        auto mode = IoMode(input_mode);
-        ASSERT(mode == IoMode::Blocking || mode == IoMode::NonBlocking);
-        R_UNLESS(socket, ResultNoSocket);
-        const bool non_block = mode == IoMode::NonBlocking;
-        const Network::Errno error = socket->SetNonBlock(non_block);
-        if (error != Network::Errno::SUCCESS) {
-            LOG_ERROR(Service_SSL, "Failed to set native socket non-block flag to {}", non_block);
-        }
-        R_SUCCEED();
+    void SetSocketDescriptor(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const s32 in_fd = rp.Pop<s32>();
+        s32 out_fd{-1};
+        const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push<s32>(out_fd);
     }
 
-    Result GetSocketDescriptor(Out<u32> out_fd) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        *out_fd = uint32_t(socket->GetFD());
-        R_SUCCEED();
+    void SetHostName(HLERequestContext& ctx) {
+        const std::string hostname = Common::StringFromBuffer(ctx.ReadBuffer());
+        const Result res = SetHostNameImpl(hostname);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
     }
 
-    Result GetHostName(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        ASSERT(!did_handshake);
-        return backend->GetHostName(std::span<u8>{data.begin(), data.end()}, out_size);
+    void SetVerifyOption(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 option = rp.Pop<u32>();
+        const Result res = SetVerifyOptionImpl(option);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
     }
 
-    Result GetIoMode(Out<u32> out_mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
+    void SetIoMode(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 mode = rp.Pop<u32>();
+        const Result res = SetIoModeImpl(mode);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
     }
 
-    Result DoHandshake() {
-        return DoHandshakeImpl();
+    void DoHandshake(HLERequestContext& ctx) {
+        const Result res = DoHandshakeImpl();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
     }
 
     void DoHandshakeGetServerCert(HLERequestContext& ctx) {
@@ -293,158 +351,131 @@ private:
         rb.PushRaw(out);
     }
 
-    Result Read(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        R_UNLESS(did_handshake, ResultInternalError);
-        size_t tmp{};
-        auto const res = backend->Read(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void Read(HLERequestContext& ctx) {
+        std::vector<u8> output_bytes(ctx.GetWriteBufferSize());
+        const Result res = ReadImpl(&output_bytes);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        if (res == ResultSuccess) {
+            rb.Push(static_cast<u32>(output_bytes.size()));
+            ctx.WriteBuffer(output_bytes);
+        } else {
+            rb.Push(static_cast<u32>(0));
+        }
     }
 
-    Result Write(InBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        R_UNLESS(did_handshake, ResultInternalError);
-        size_t tmp{};
-        auto const res = backend->Write(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void Write(HLERequestContext& ctx) {
+        size_t write_size{0};
+        const Result res = WriteImpl(&write_size, ctx.ReadBuffer());
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push(static_cast<u32>(write_size));
     }
 
-    Result Pending(Out<s32> out_pending_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        *out_pending_size = s32(backend->Pending());
-        R_SUCCEED();
+    void Pending(HLERequestContext& ctx) {
+        s32 pending_size{0};
+        const Result res = PendingImpl(&pending_size);
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(res);
+        rb.Push<s32>(pending_size);
     }
 
-    Result Peek(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> out_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        size_t tmp{};
-        auto const res = backend->Peek(&tmp, data);
-        *out_size = u32(tmp);
-        return res;
+    void SetSessionCacheMode(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const u32 mode = rp.Pop<u32>();
+        const Result res = SetSessionCacheModeImpl(mode);
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(res);
     }
 
-    Result Poll(u32 in_pollevent, u32 timer, Out<u32> out_pollevent) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
+    void SetOption(HLERequestContext& ctx) {
+        struct Parameters {
+            OptionType option;
+            s32 value;
+        };
+        static_assert(sizeof(Parameters) == 0x8, "Parameters is an invalid size");
 
-    Result GetVerifyCertError() {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
+        IPC::RequestParser rp{ctx};
+        const auto parameters = rp.PopRaw<Parameters>();
 
-    Result GetNeededServerCertBufferSize(Out<u32> out_needed_buffer_size) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
-
-    Result SetSessionCacheMode(u32 mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED) called. value={}", mode);
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result GetSessionCacheMode(Out<u32> mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result FlushSessionCache() {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_UNLESS(!did_handshake, ResultInternalError);
-        R_SUCCEED();
-    }
-
-    Result SetRenegotiationMode(RenegotiationMode mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        backend->SetRenegotiationMode(u32(mode));
-        R_SUCCEED();
-    }
-
-    Result GetRenegotiationMode(Out<RenegotiationMode> mode) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        u32 tmp{};
-        auto const res = backend->GetRenegotiationMode(&tmp);
-        *mode = RenegotiationMode(tmp);
-        return res;
-    }
-
-    Result SetOption(OptionType option, s32 value) {
-        switch (option) {
+        switch (parameters.option) {
         case OptionType::DoNotCloseSocket:
-            do_not_close_socket = bool(value);
+            do_not_close_socket = static_cast<bool>(parameters.value);
             break;
         case OptionType::GetServerCertChain:
-            get_server_cert_chain = bool(value);
+            get_server_cert_chain = static_cast<bool>(parameters.value);
             break;
         case OptionType::SkipDefaultVerify:
-            skip_default_verify = bool(value);
+            skip_default_verify = static_cast<bool>(parameters.value);
             break;
         case OptionType::EnableAlpn:
-            enable_alpn = bool(value);
+            enable_alpn = static_cast<bool>(parameters.value);
             break;
         default:
-            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", option, value);
+            LOG_WARNING(Service_SSL, "Unknown option={}, value={}", parameters.option,
+                        parameters.value);
         }
-        R_SUCCEED();
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
 
-    Result GetOption(OptionType option, Out<u8> value) {
+    void GetOption(HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+        const auto option = rp.PopRaw<OptionType>();
+
+        u8 value = 0;
+
         switch (option) {
         case OptionType::DoNotCloseSocket:
-            *value = u8(do_not_close_socket);
+            value = static_cast<u8>(do_not_close_socket);
             break;
         case OptionType::GetServerCertChain:
-            *value = u8(get_server_cert_chain);
+            value = static_cast<u8>(get_server_cert_chain);
             break;
         case OptionType::SkipDefaultVerify:
-            *value = u8(skip_default_verify);
+            value = static_cast<u8>(skip_default_verify);
             break;
         case OptionType::EnableAlpn:
-            *value = u8(enable_alpn);
+            value = static_cast<u8>(enable_alpn);
             break;
         default:
-            LOG_WARNING(Service_SSL, "Unknown option={}", u32(option));
-            *value = 0;
+            LOG_WARNING(Service_SSL, "Unknown option={}", option);
+            value = 0;
             break;
         }
-        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", u32(option), *value);
-        R_SUCCEED();
+
+        LOG_DEBUG(Service_SSL, "GetOption called, option={}, ret value={}", option, value);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u8>(value);
     }
 
-    Result SetNextAlpnProto(InBuffer<BufferAttr_HipcMapAlias> data) {
-        auto const to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
-        next_alpn_proto.assign(data.begin(), data.begin() + to_write);
+    void SetNextAlpnProto(HLERequestContext& ctx) {
+        const auto data = ctx.ReadBuffer(0);
+        next_alpn_proto.assign(data.begin(), data.end());
+
         LOG_DEBUG(Service_SSL, "SetNextAlpnProto called, size={}", next_alpn_proto.size());
-        R_SUCCEED();
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
 
-    Result GetNextAlpnProto(OutBuffer<BufferAttr_HipcMapAlias> data, Out<u32> to_write) {
-        *to_write = u32((std::min)(next_alpn_proto.size(), data.size()));
-        next_alpn_proto.assign(data.begin(), data.begin() + *to_write);
-        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", *to_write);
-        R_SUCCEED();
+    void GetNextAlpnProto(HLERequestContext& ctx) {
+        const size_t writable = ctx.GetWriteBufferSize();
+        const size_t to_write = (std::min)(next_alpn_proto.size(), writable);
+
+        if (to_write != 0) {
+            ctx.WriteBuffer(std::span<const u8>(next_alpn_proto.data(), to_write));
+        }
+
+        LOG_DEBUG(Service_SSL, "GetNextAlpnProto called, size={}", to_write);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(ResultSuccess);
+        rb.Push<u32>(static_cast<u32>(to_write));
     }
-
-    Result GetVerifyCertErrors(OutBuffer<BufferAttr_HipcMapAlias> unk0, Out<u32> unk1, Out<u32> unk2) {
-        LOG_WARNING(Service_SSL, "(STUBBED)");
-        R_SUCCEED();
-    }
-
-    SslVersion ssl_version;
-    std::shared_ptr<SslContextSharedData> shared_data;
-    std::unique_ptr<SSLConnectionBackend> backend;
-    std::optional<int> fd_to_close;
-    std::shared_ptr<Network::SocketBase> socket;
-    std::vector<u8> next_alpn_proto;
-    u32 verify_option = 0;
-
-    bool do_not_close_socket = false;
-    bool get_server_cert_chain = false;
-    bool skip_default_verify = false;
-    bool enable_alpn = false;
-    bool did_handshake = false;
 };
 
 class ISslContext final : public ServiceFramework<ISslContext> {
@@ -461,7 +492,7 @@ public:
             {5, &ISslContext::ImportClientPki, "ImportClientPki"},
             {6, nullptr, "RemoveServerPki"},
             {7, nullptr, "RemoveClientPki"},
-            {8, D<&ISslContext::RegisterInternalPki>, "RegisterInternalPki"},
+            {8, nullptr, "RegisterInternalPki"},
             {9, nullptr, "AddPolicyOid"},
             {10, nullptr, "ImportCrl"},
             {11, nullptr, "RemoveCrl"},
@@ -556,11 +587,6 @@ private:
         rb.Push(ResultSuccess);
         rb.Push(client_id);
     }
-
-    Result RegisterInternalPki() {
-        LOG_WARNING(Service_SSL, "(STUBBED) called");
-        R_SUCCEED();
-    }
 };
 
 class ISslService final : public ServiceFramework<ISslService> {

src/core/hle/service/ssl/ssl_backend.h

@@ -36,17 +36,12 @@ class SSLConnectionBackend {
 public:
     virtual ~SSLConnectionBackend() {}
     virtual void SetSocket(std::shared_ptr<Network::SocketBase> socket) = 0;
+    virtual Result SetHostName(const std::string& hostname) = 0;
     virtual void SetVerifyOption(u32 option) = 0;
     virtual Result DoHandshake() = 0;
     virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
-    virtual Result Peek(size_t* out_size, std::span<u8> data) = 0;
     virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
     virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
-    virtual Result SetHostName(const char* hostname) = 0;
-    virtual Result GetHostName(std::span<u8> hostname, u32* out_size) = 0;
-    virtual int Pending() = 0;
-    virtual Result SetRenegotiationMode(u32 mode) = 0;
-    virtual Result GetRenegotiationMode(u32* mode) = 0;
 };
 
 Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -157,30 +157,18 @@ public:
         socket = std::move(socket_in);
     }
 
-    Result SetHostName(const char* hostname) override {
+    Result SetHostName(const std::string& hostname) override {
         if (!skip_cert_verification) {
-            if (!SSL_set1_host(ssl, hostname)) {
+            if (!SSL_set1_host(ssl, hostname.c_str())) {
                 LOG_ERROR(Service_SSL, "SSL_set1_host({}) failed", hostname);
                 return CheckOpenSSLErrors();
             }
         }
-        if (!SSL_set_tlsext_host_name(ssl, hostname)) { // hostname for SNI
+        if (!SSL_set_tlsext_host_name(ssl, hostname.c_str())) { // hostname for SNI
             LOG_ERROR(Service_SSL, "SSL_set_tlsext_host_name({}) failed", hostname);
             return CheckOpenSSLErrors();
         }
-        R_SUCCEED();
-    }
-
-    Result GetHostName(std::span<u8> data, u32* out_size) override {
-        auto const peer_name = SSL_get0_peername(ssl);
-        if (peer_name == nullptr) {
-            LOG_ERROR(Service_SSL, "SSL_get0_peername()");
-            return CheckOpenSSLErrors();
-        }
-        auto const s = std::string{peer_name};
-        *out_size = u32(s.size());
-        std::memcpy(data.data(), s.data(), (std::min)(s.size(), data.size()));
-        R_SUCCEED();
+        return ResultSuccess;
     }
 
     void SetVerifyOption(u32 option) override {
@@ -225,13 +213,6 @@ public:
         return HandleReturn("SSL_read_ex", out_size, ret);
     }
 
-    Result Peek(size_t* out_size, std::span<u8> data) override {
-        auto const n = (std::min)(data.size(), *out_size);
-        const int ret = SSL_peek(ssl, data.data(), int(n));
-        *out_size = n;
-        return HandleReturn("SSL_write_ex", out_size, ret);
-    }
-
     Result Write(size_t* out_size, std::span<const u8> data) override {
         const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
         return HandleReturn("SSL_write_ex", out_size, ret);
@@ -282,25 +263,7 @@ public:
             out_certs->emplace_back(buf, buf + len);
             OPENSSL_free(buf);
         }
-        R_SUCCEED();
-    }
-
-    int Pending() override {
-        return SSL_pending(ssl);
-    }
-
-    Result SetRenegotiationMode(u32 mode) override {
-        if (mode == 0) {
-            SSL_CTX_set_options(ssl_ctx, SSL_OP_NO_RENEGOTIATION);
-        } else {
-            SSL_CTX_set_options(ssl_ctx, SSL_OP_ALLOW_CLIENT_RENEGOTIATION);
-        }
-        R_SUCCEED();
-    }
-
-    Result GetRenegotiationMode(u32* mode) override {
-        *mode = SSL_get_secure_renegotiation_support(ssl) ? 1 : 0;
-        R_SUCCEED();
+        return ResultSuccess;
     }
 
     ~SSLConnectionBackendOpenSSL() {

src/core/tools/freezer.cpp

@@ -33,10 +33,18 @@ u64 MemoryReadWidth(Core::Memory::Memory& memory, u32 width, VAddr addr) {
 
 void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 value) {
     switch (width) {
-    case sizeof(u64): return memory.Write64(addr, value);
-    case sizeof(u32): return memory.Write32(addr, u32(value));
-    case sizeof(u16): return memory.Write16(addr, u16(value));
-    case sizeof(u8): return memory.Write8(addr, u8(value));
+    case 1:
+        memory.Write8(addr, static_cast<u8>(value));
+        break;
+    case 2:
+        memory.Write16(addr, static_cast<u16>(value));
+        break;
+    case 4:
+        memory.Write32(addr, static_cast<u32>(value));
+        break;
+    case 8:
+        memory.Write64(addr, value);
+        break;
     default:
         UNREACHABLE();
     }

src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cpp

@@ -82,7 +82,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const
 
     auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr) -> T {
         return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-            return (conf.callbacks->*callback)(vaddr, sizeof(T));
+            return (conf.callbacks->*callback)(vaddr);
         });
     };
 
@@ -136,9 +136,12 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, const
     oaknut::Label l_addr, l_this;
 
     auto fn = [](const A32::UserConfig& conf, A32::VAddr vaddr, T value) -> u32 {
-        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {
-            return (conf.callbacks->*callback)(vaddr, value, expected);
-        }) ? 0 : 1;
+        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,
+                                                            [&](T expected) -> bool {
+                                                                return (conf.callbacks->*callback)(vaddr, value, expected);
+                                                            })
+                 ? 0
+                 : 1;
     };
 
     void* target = code.xptr<void*>();
@@ -176,14 +179,26 @@ void A32AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-    prelude_info.read_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
-    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u8>(code, conf);
-    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u16>(code, conf);
-    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u32>(code, conf);
-    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u64>(code, conf);
-    prelude_info.write_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.read_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.read_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.read_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.read_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead64>(code, conf.callbacks);
+    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead8, u8>(code, conf);
+    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead16, u16>(code, conf);
+    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead32, u32>(code, conf);
+    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead64, u64>(code, conf);
+    prelude_info.write_memory_8 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.write_memory_16 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.write_memory_32 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.write_memory_64 = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
     prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
     prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);
     prelude_info.exclusive_write_memory_32 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive32, u32>(code, conf);

src/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cpp

@@ -81,7 +81,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const
 
     auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr) -> T {
         return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-            return (conf.callbacks->*callback)(vaddr, sizeof(T));
+            return (conf.callbacks->*callback)(vaddr);
         });
     };
 
@@ -133,10 +133,14 @@ static void* EmitExclusiveWriteCallTrampoline(oaknut::CodeGenerator& code, const
     using namespace oaknut::util;
 
     oaknut::Label l_addr, l_this;
+
     auto fn = [](const A64::UserConfig& conf, A64::VAddr vaddr, T value) -> u32 {
-        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr, [&](T expected) -> bool {
-            return (conf.callbacks->*callback)(vaddr, value, expected);
-        }) ? 0 : 1;
+        return conf.global_monitor->DoExclusiveOperation<T>(conf.processor_id, vaddr,
+                                                            [&](T expected) -> bool {
+                                                                return (conf.callbacks->*callback)(vaddr, value, expected);
+                                                            })
+                 ? 0
+                 : 1;
     };
 
     void* target = code.xptr<void*>();
@@ -342,18 +346,30 @@ void A64AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-    prelude_info.read_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.read_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.read_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.read_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.read_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);
     prelude_info.read_memory_128 = EmitRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead8>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead16>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead32>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead64>(code, conf.callbacks);
     prelude_info.wrapped_read_memory_128 = EmitWrappedRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u8>(code, conf);
-    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u16>(code, conf);
-    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u32>(code, conf);
-    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u64>(code, conf);
+    prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead8, u8>(code, conf);
+    prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead16, u16>(code, conf);
+    prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead32, u32>(code, conf);
+    prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead64, u64>(code, conf);
     prelude_info.exclusive_read_memory_128 = EmitExclusiveRead128CallTrampoline(code, conf);
-    prelude_info.write_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.write_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.write_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.write_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.write_memory_64 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
     prelude_info.write_memory_128 = EmitWrite128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite8>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite16>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite32>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite64>(code, conf.callbacks);
     prelude_info.wrapped_write_memory_128 = EmitWrappedWrite128CallTrampoline(code, conf.callbacks);
     prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
     prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);

src/dynarmic/src/dynarmic/backend/arm64/address_space.cpp

@@ -145,42 +145,32 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
         case LinkTarget::ReturnFromRunCode:
             c.B(prelude_info.return_from_run_code);
             break;
-        // { this, vaddr, size }
         case LinkTarget::ReadMemory8:
-            c.LDR(X2, 1);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_8);
             break;
         case LinkTarget::ReadMemory16:
-            c.LDR(X2, 2);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_16);
             break;
         case LinkTarget::ReadMemory32:
-            c.LDR(X2, 4);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_32);
             break;
         case LinkTarget::ReadMemory64:
-            c.LDR(X2, 8);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_64);
             break;
         case LinkTarget::ReadMemory128:
             c.BL(prelude_info.read_memory_128);
             break;
-        // { this, vaddr, size }
         case LinkTarget::WrappedReadMemory8:
-            c.LDR(X2, 1);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_8);
             break;
         case LinkTarget::WrappedReadMemory16:
-            c.LDR(X2, 2);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_16);
             break;
         case LinkTarget::WrappedReadMemory32:
-            c.LDR(X2, 4);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_32);
             break;
         case LinkTarget::WrappedReadMemory64:
-            c.LDR(X2, 8);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_64);
             break;
         case LinkTarget::WrappedReadMemory128:
             c.BL(prelude_info.wrapped_read_memory_128);
@@ -200,41 +190,32 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
         case LinkTarget::ExclusiveReadMemory128:
             c.BL(prelude_info.exclusive_read_memory_128);
             break;
-        // { this, vaddr, value, size }
         case LinkTarget::WriteMemory8:
-            c.LDR(X3, 1);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_8);
             break;
         case LinkTarget::WriteMemory16:
-            c.LDR(X3, 2);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_16);
             break;
         case LinkTarget::WriteMemory32:
-            c.LDR(X3, 4);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_32);
             break;
         case LinkTarget::WriteMemory64:
-            c.LDR(X3, 8);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_64);
             break;
         case LinkTarget::WriteMemory128:
             c.BL(prelude_info.write_memory_128);
             break;
         case LinkTarget::WrappedWriteMemory8:
-            c.LDR(X3, 1);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_8);
             break;
         case LinkTarget::WrappedWriteMemory16:
-            c.LDR(X3, 2);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_16);
             break;
         case LinkTarget::WrappedWriteMemory32:
-            c.LDR(X3, 4);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_32);
             break;
         case LinkTarget::WrappedWriteMemory64:
-            c.LDR(X3, 8);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_64);
             break;
         case LinkTarget::WrappedWriteMemory128:
             c.BL(prelude_info.wrapped_write_memory_128);

src/dynarmic/src/dynarmic/backend/arm64/address_space.h

@@ -93,18 +93,30 @@ protected:
         void* return_to_dispatcher;
         void* return_from_run_code;
 
-        void* read_memory;
+        void* read_memory_8;
+        void* read_memory_16;
+        void* read_memory_32;
+        void* read_memory_64;
         void* read_memory_128;
-        void* wrapped_read_memory;
+        void* wrapped_read_memory_8;
+        void* wrapped_read_memory_16;
+        void* wrapped_read_memory_32;
+        void* wrapped_read_memory_64;
         void* wrapped_read_memory_128;
         void* exclusive_read_memory_8;
         void* exclusive_read_memory_16;
         void* exclusive_read_memory_32;
         void* exclusive_read_memory_64;
         void* exclusive_read_memory_128;
-        void* write_memory;
+        void* write_memory_8;
+        void* write_memory_16;
+        void* write_memory_32;
+        void* write_memory_64;
         void* write_memory_128;
-        void* wrapped_write_memory;
+        void* wrapped_write_memory_8;
+        void* wrapped_write_memory_16;
+        void* wrapped_write_memory_32;
+        void* wrapped_write_memory_64;
         void* wrapped_write_memory_128;
         void* exclusive_write_memory_8;
         void* exclusive_write_memory_16;

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cpp

@@ -11,7 +11,8 @@
 #include <tuple>
 #include <utility>
 
-#include "common/logging.h"
+#include <fmt/format.h>
+#include <fmt/ostream.h>
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include "dynarmic/backend/x64/xbyak.h"
 
@@ -30,16 +31,16 @@ using namespace Xbyak::util;
 void A32EmitX64::GenFastmemFallbacks() {
     const std::initializer_list<int> idxes{0, 1, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
     const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{
-        {8, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {16, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {32, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {64, Devirtualize<&A32::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {8, Devirtualize<&A32::UserCallbacks::MemoryRead8>(conf.callbacks)},
+        {16, Devirtualize<&A32::UserCallbacks::MemoryRead16>(conf.callbacks)},
+        {32, Devirtualize<&A32::UserCallbacks::MemoryRead32>(conf.callbacks)},
+        {64, Devirtualize<&A32::UserCallbacks::MemoryRead64>(conf.callbacks)},
     }};
     const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{
-        {8, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {16, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {32, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {64, Devirtualize<&A32::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {8, Devirtualize<&A32::UserCallbacks::MemoryWrite8>(conf.callbacks)},
+        {16, Devirtualize<&A32::UserCallbacks::MemoryWrite16>(conf.callbacks)},
+        {32, Devirtualize<&A32::UserCallbacks::MemoryWrite32>(conf.callbacks)},
+        {64, Devirtualize<&A32::UserCallbacks::MemoryWrite64>(conf.callbacks)},
     }};
     const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{
         {8, Devirtualize<&A32::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},
@@ -55,12 +56,12 @@ void A32EmitX64::GenFastmemFallbacks() {
                     code.align();
                     read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                     ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));
-                    // params = { this, vaddr, size }
                     if (vaddr_idx != code.ABI_PARAM2.getIdx()) {
                         code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});
                     }
-                    code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                     callback.EmitCall(code);
                     if (value_idx != code.ABI_RETURN.getIdx()) {
                         code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);
@@ -75,7 +76,6 @@ void A32EmitX64::GenFastmemFallbacks() {
                     code.align();
                     write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                     ABI_PushCallerSaveRegistersAndAdjustStack(code);
-                    // params = { this, vaddr, value, size }
                     if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {
                         code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);
                     } else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {
@@ -92,9 +92,10 @@ void A32EmitX64::GenFastmemFallbacks() {
                         }
                     }
                     code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);
-                    code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);
                     callback.EmitCall(code);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                     ABI_PopCallerSaveRegistersAndAdjustStack(code);
                     code.ret();
                     PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a32_write_fallback_{}", bitsize));
@@ -137,35 +138,35 @@ void A32EmitX64::GenFastmemFallbacks() {
 #undef Axx
 
 void A32EmitX64::EmitA32ReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32ReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32ReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32ReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32WriteMemory8(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<8, &A32::UserCallbacks::MemoryWrite8>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32WriteMemory16(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<16, &A32::UserCallbacks::MemoryWrite16>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32WriteMemory32(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<32, &A32::UserCallbacks::MemoryWrite32>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32WriteMemory64(A32EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<64, &A32::UserCallbacks::MemoryWrite64>(ctx, inst);
 }
 
 void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {
@@ -174,33 +175,33 @@ void A32EmitX64::EmitA32ClearExclusive(A32EmitContext&, IR::Inst*) {
 
 void A32EmitX64::EmitA32ExclusiveReadMemory8(A32EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<8, &A32::UserCallbacks::MemoryRead8>(ctx, inst);
     }
 }
 
 void A32EmitX64::EmitA32ExclusiveReadMemory16(A32EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<16, &A32::UserCallbacks::MemoryRead16>(ctx, inst);
     }
 }
 
 void A32EmitX64::EmitA32ExclusiveReadMemory32(A32EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<32, &A32::UserCallbacks::MemoryRead32>(ctx, inst);
     }
 }
 
 void A32EmitX64::EmitA32ExclusiveReadMemory64(A32EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<64, &A32::UserCallbacks::MemoryRead64>(ctx, inst);
     }
 }
 

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cpp

@@ -11,7 +11,8 @@
 #include <tuple>
 #include <utility>
 
-#include "common/logging.h"
+#include <fmt/format.h>
+#include <fmt/ostream.h>
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include "dynarmic/backend/x64/xbyak.h"
 
@@ -114,16 +115,16 @@ void A64EmitX64::GenMemory128Accessors() {
 void A64EmitX64::GenFastmemFallbacks() {
     const std::initializer_list<int> idxes{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
     const std::array<std::pair<size_t, ArgCallback>, 4> read_callbacks{{
-        {8, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {16, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {32, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
-        {64, Devirtualize<&A64::UserCallbacks::MemoryRead>(conf.callbacks)},
+        {8, Devirtualize<&A64::UserCallbacks::MemoryRead8>(conf.callbacks)},
+        {16, Devirtualize<&A64::UserCallbacks::MemoryRead16>(conf.callbacks)},
+        {32, Devirtualize<&A64::UserCallbacks::MemoryRead32>(conf.callbacks)},
+        {64, Devirtualize<&A64::UserCallbacks::MemoryRead64>(conf.callbacks)},
     }};
     const std::array<std::pair<size_t, ArgCallback>, 4> write_callbacks{{
-        {8, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {16, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {32, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
-        {64, Devirtualize<&A64::UserCallbacks::MemoryWrite>(conf.callbacks)},
+        {8, Devirtualize<&A64::UserCallbacks::MemoryWrite8>(conf.callbacks)},
+        {16, Devirtualize<&A64::UserCallbacks::MemoryWrite16>(conf.callbacks)},
+        {32, Devirtualize<&A64::UserCallbacks::MemoryWrite32>(conf.callbacks)},
+        {64, Devirtualize<&A64::UserCallbacks::MemoryWrite64>(conf.callbacks)},
     }};
     const std::array<std::pair<size_t, ArgCallback>, 4> exclusive_write_callbacks{{
         {8, Devirtualize<&A64::UserCallbacks::MemoryWriteExclusive8>(conf.callbacks)},
@@ -203,12 +204,12 @@ void A64EmitX64::GenFastmemFallbacks() {
                     code.align();
                     read_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                     ABI_PushCallerSaveRegistersAndAdjustStackExcept(code, HostLocRegIdx(value_idx));
-                    // params = { this, vaddr, size }
                     if (vaddr_idx != code.ABI_PARAM2.getIdx()) {
                         code.mov(code.ABI_PARAM2, Xbyak::Reg64{vaddr_idx});
                     }
-                    code.mov(code.ABI_PARAM3, bitsize / CHAR_BIT);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                     callback.EmitCall(code);
                     if (value_idx != code.ABI_RETURN.getIdx()) {
                         code.mov(Xbyak::Reg64{value_idx}, code.ABI_RETURN);
@@ -223,7 +224,6 @@ void A64EmitX64::GenFastmemFallbacks() {
                     code.align();
                     write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)] = code.getCurr<void (*)()>();
                     ABI_PushCallerSaveRegistersAndAdjustStack(code);
-                    // params = { this, vaddr, value, size }
                     if (vaddr_idx == code.ABI_PARAM3.getIdx() && value_idx == code.ABI_PARAM2.getIdx()) {
                         code.xchg(code.ABI_PARAM2, code.ABI_PARAM3);
                     } else if (vaddr_idx == code.ABI_PARAM3.getIdx()) {
@@ -240,9 +240,10 @@ void A64EmitX64::GenFastmemFallbacks() {
                         }
                     }
                     code.ZeroExtendFrom(bitsize, code.ABI_PARAM3);
-                    code.mov(code.ABI_PARAM4, bitsize / CHAR_BIT);
                     callback.EmitCall(code);
-                    if (ordered) code.mfence();
+                    if (ordered) {
+                        code.mfence();
+                    }
                     ABI_PopCallerSaveRegistersAndAdjustStack(code);
                     code.ret();
                     PerfMapRegister(write_fallbacks[std::make_tuple(ordered, bitsize, vaddr_idx, value_idx)], code.getCurr(), fmt::format("a64_write_fallback_{}", bitsize));
@@ -285,19 +286,19 @@ void A64EmitX64::GenFastmemFallbacks() {
 #undef Axx
 
 void A64EmitX64::EmitA64ReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64ReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64ReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64ReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+    EmitMemoryRead<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {
@@ -305,23 +306,23 @@ void A64EmitX64::EmitA64ReadMemory128(A64EmitContext& ctx, IR::Inst* inst) {
 }
 
 void A64EmitX64::EmitA64WriteMemory8(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<8, &A64::UserCallbacks::MemoryWrite8>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64WriteMemory16(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<16, &A64::UserCallbacks::MemoryWrite16>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64WriteMemory32(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<32, &A64::UserCallbacks::MemoryWrite32>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64WriteMemory64(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<64, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64WriteMemory128(A64EmitContext& ctx, IR::Inst* inst) {
-    EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite>(ctx, inst);
+    EmitMemoryWrite<128, &A64::UserCallbacks::MemoryWrite64>(ctx, inst);
 }
 
 void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {
@@ -330,33 +331,33 @@ void A64EmitX64::EmitA64ClearExclusive(A64EmitContext&, IR::Inst*) {
 
 void A64EmitX64::EmitA64ExclusiveReadMemory8(A64EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<8, &A64::UserCallbacks::MemoryRead8>(ctx, inst);
     }
 }
 
 void A64EmitX64::EmitA64ExclusiveReadMemory16(A64EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<16, &A64::UserCallbacks::MemoryRead16>(ctx, inst);
     }
 }
 
 void A64EmitX64::EmitA64ExclusiveReadMemory32(A64EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<32, &A64::UserCallbacks::MemoryRead32>(ctx, inst);
     }
 }
 
 void A64EmitX64::EmitA64ExclusiveReadMemory64(A64EmitContext& ctx, IR::Inst* inst) {
     if (conf.fastmem_exclusive_access) {
-        EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemoryInline<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
     } else {
-        EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead>(ctx, inst);
+        EmitExclusiveReadMemory<64, &A64::UserCallbacks::MemoryRead64>(ctx, inst);
     }
 }
 

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 /* This file is part of the dynarmic project.
  * Copyright (c) 2022 MerryMage
  * SPDX-License-Identifier: 0BSD
@@ -14,6 +11,10 @@
 #define AxxJitState CONCATENATE_TOKENS(Axx, JitState)
 #define AxxUserConfig Axx::UserConfig
 
+namespace {
+using Vector = std::array<u64, 2>;
+}
+
 std::optional<AxxEmitX64::DoNotFastmemMarker> AxxEmitX64::ShouldFastmem(AxxEmitContext& ctx, IR::Inst* inst) const {
     if (!conf.fastmem_pointer || !exception_handler.SupportsFastmem()) {
         return std::nullopt;
@@ -27,19 +28,22 @@ std::optional<AxxEmitX64::DoNotFastmemMarker> AxxEmitX64::ShouldFastmem(AxxEmitC
 }
 
 FakeCall AxxEmitX64::FastmemCallback(u64 rip_) {
-    if (auto const it = fastmem_patch_info.find(rip_); it != fastmem_patch_info.end()) {
+    const auto iter = fastmem_patch_info.find(rip_);
+    if (iter != fastmem_patch_info.end()) {
         FakeCall result{
-            .call_rip = it->second.callback,
-            .ret_rip = it->second.resume_rip,
+            .call_rip = iter->second.callback,
+            .ret_rip = iter->second.resume_rip,
         };
-        if (it->second.recompile) {
-            const auto marker = it->second.marker;
+        if (iter->second.recompile) {
+            const auto marker = iter->second.marker;
             do_not_fastmem.insert(marker);
             InvalidateBasicBlocks({std::get<0>(marker)});
         }
         return result;
     }
-    UNREACHABLE_MSG("SIGSEGV @ JIT, rip={:#016x}", rip_); //("iter != fastmem_patch_info.end()");
+    fmt::print("dynarmic: Segfault happened within JITted code at rip = {:016x}\n"
+        "Segfault wasn't at a fastmem patch location!\n", rip_);
+    UNREACHABLE(); //("iter != fastmem_patch_info.end()");
 }
 
 template<std::size_t bitsize, auto callback>
@@ -52,13 +56,16 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
         // Neither fastmem nor page table: Use callbacks
         if constexpr (bitsize == 128) {
             ctx.reg_alloc.HostCall(code, nullptr, {}, args[1]);
-            if (ordered) code.mfence();
+            if (ordered) {
+                code.mfence();
+            }
             code.CallFunction(memory_read_128);
             ctx.reg_alloc.DefineValue(code, inst, xmm1);
         } else {
             ctx.reg_alloc.HostCall(code, inst, {}, args[1]);
-            code.mov(code.ABI_PARAM3.cvt32(), bitsize / CHAR_BIT);
-            if (ordered) code.mfence();
+            if (ordered) {
+                code.mfence();
+            }
             Devirtualize<callback>(conf.callbacks).EmitCall(code);
             code.ZeroExtendFrom(bitsize, code.ABI_RETURN);
         }
@@ -76,17 +83,22 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
 
     const Xbyak::Reg64 vaddr = ctx.reg_alloc.UseGpr(code, args[1]);
     const int value_idx = bitsize == 128 ? ctx.reg_alloc.ScratchXmm(code).getIdx() : ctx.reg_alloc.ScratchGpr(code).getIdx();
+
     const auto wrapped_fn = read_fallbacks[std::make_tuple(ordered, bitsize, vaddr.getIdx(), value_idx)];
 
     SharedLabel abort = ctx.GenSharedLabel(), end = ctx.GenSharedLabel();
+
     if (fastmem_marker) {
         // Use fastmem
         bool require_abort_handling = false;
         const auto src_ptr = EmitFastmemVAddr(code, ctx, *abort, vaddr, require_abort_handling);
+
         const auto location = EmitReadMemoryMov<bitsize>(code, value_idx, src_ptr, ordered);
+
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
             code.L(*abort);
             code.call(wrapped_fn);
+
             fastmem_patch_info.emplace(
                 std::bit_cast<u64>(location),
                 FastmemPatchInfo{
@@ -95,23 +107,25 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
                     *fastmem_marker,
                     conf.recompile_on_fastmem_failure,
                 });
+
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else if (conf.page_table) {
+    } else {
         // Use page table
+        ASSERT(conf.page_table);
         const auto src_ptr = EmitVAddrLookup(code, ctx, bitsize, *abort, vaddr);
         EmitReadMemoryMov<bitsize>(code, value_idx, src_ptr, ordered);
+
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
             code.L(*abort);
             code.call(wrapped_fn);
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else {
-        UNREACHABLE();
     }
     code.L(*end);
+
     if constexpr (bitsize == 128) {
         ctx.reg_alloc.DefineValue(code, inst, Xbyak::Xmm{value_idx});
     } else {
@@ -134,12 +148,12 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             ctx.reg_alloc.HostCall(code, nullptr);
             code.CallFunction(memory_write_128);
         } else {
-            // { this, vaddr, value, size }
             ctx.reg_alloc.HostCall(code, nullptr, {}, args[1], args[2]);
-            code.mov(code.ABI_PARAM4.cvt32(), bitsize / CHAR_BIT);
             Devirtualize<callback>(conf.callbacks).EmitCall(code);
         }
-        if (ordered) code.mfence();
+        if (ordered) {
+            code.mfence();
+        }
         EmitCheckMemoryAbort(ctx, inst);
         return;
     }
@@ -154,16 +168,18 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
 
     const Xbyak::Reg64 vaddr = ctx.reg_alloc.UseGpr(code, args[1]);
     const int value_idx = bitsize == 128
-        ? ctx.reg_alloc.UseXmm(code, args[2]).getIdx()
-        : (ordered ? ctx.reg_alloc.UseScratchGpr(code, args[2]).getIdx() : ctx.reg_alloc.UseGpr(code, args[2]).getIdx());
+                            ? ctx.reg_alloc.UseXmm(code, args[2]).getIdx()
+                            : (ordered ? ctx.reg_alloc.UseScratchGpr(code, args[2]).getIdx() : ctx.reg_alloc.UseGpr(code, args[2]).getIdx());
 
     const auto wrapped_fn = write_fallbacks[std::make_tuple(ordered, bitsize, vaddr.getIdx(), value_idx)];
 
     SharedLabel abort = ctx.GenSharedLabel(), end = ctx.GenSharedLabel();
+
     if (fastmem_marker) {
         // Use fastmem
         bool require_abort_handling = false;
         const auto dest_ptr = EmitFastmemVAddr(code, ctx, *abort, vaddr, require_abort_handling);
+
         const auto location = EmitWriteMemoryMov<bitsize>(code, dest_ptr, value_idx, ordered);
 
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
@@ -182,8 +198,9 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else if (conf.page_table) {
+    } else {
         // Use page table
+        ASSERT(conf.page_table);
         const auto dest_ptr = EmitVAddrLookup(code, ctx, bitsize, *abort, vaddr);
         EmitWriteMemoryMov<bitsize>(code, dest_ptr, value_idx, ordered);
 
@@ -193,8 +210,6 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else {
-        UNREACHABLE();
     }
     code.L(*end);
 }
@@ -215,11 +230,12 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
         if (ordered) {
             code.mfence();
         }
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {
-            return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
-                return (conf.callbacks->*callback)(vaddr, bitsize / CHAR_BIT);
+        code.CallLambda(
+            [](AxxUserConfig& conf, Axx::VAddr vaddr) -> T {
+                return conf.global_monitor->ReadAndMark<T>(conf.processor_id, vaddr, [&]() -> T {
+                    return (conf.callbacks->*callback)(vaddr);
+                });
             });
-        });
         code.ZeroExtendFrom(bitsize, code.ABI_RETURN);
     } else {
         const Xbyak::Xmm result = ctx.reg_alloc.ScratchXmm(code);
@@ -234,11 +250,12 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
         if (ordered) {
             code.mfence();
         }
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, u128& ret) {
-            ret = conf.global_monitor->ReadAndMark<u128>(conf.processor_id, vaddr, [&]() -> u128 {
-                return (conf.callbacks->*callback)(vaddr);
+        code.CallLambda(
+            [](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
+                ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
+                    return (conf.callbacks->*callback)(vaddr);
+                });
             });
-        });
         code.movups(result, xword[rsp + ABI_SHADOW_SPACE]);
         ctx.reg_alloc.ReleaseStackSpace(code, 16 + ABI_SHADOW_SPACE);
 
@@ -286,8 +303,8 @@ void AxxEmitX64::EmitExclusiveWriteMemory(AxxEmitContext& ctx, IR::Inst* inst) {
         ctx.reg_alloc.AllocStackSpace(code, 16 + ABI_SHADOW_SPACE);
         code.lea(code.ABI_PARAM3, ptr[rsp + ABI_SHADOW_SPACE]);
         code.movaps(xword[code.ABI_PARAM3], xmm1);
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, u128& value) -> u32 {
-            return conf.global_monitor->DoExclusiveOperation<u128>(conf.processor_id, vaddr, [&](u128 expected) -> bool {
+        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& value) -> u32 {
+            return conf.global_monitor->DoExclusiveOperation<Vector>(conf.processor_id, vaddr, [&](Vector expected) -> bool {
                 return (conf.callbacks->*callback)(vaddr, value, expected);
             }) ? 0 : 1;
         });

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -90,7 +90,7 @@ template<>
         code.shl(tmp, int(ctx.conf.page_table_log2_stride));
         code.mov(page, qword[r14 + tmp.cvt64()]);
     } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        code.mov(page, qword[r14 + tmp.cvt64() * int(ctx.conf.page_table_log2_stride)]);
     }
 
     // check for marked bit, use as unmapped if marked
@@ -135,16 +135,10 @@ template<>
     if (unused_top_bits == 0) {
         code.mov(tmp, vaddr);
         code.shr(tmp, int(page_table_const_bits));
-        if (ctx.conf.page_table_log2_stride > 3) {
-            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-            code.mov(page, qword[r14 + tmp.cvt64()]);
-        } else {
-            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-        }
     } else if (ctx.conf.silently_mirror_page_table) {
         if (valid_page_index_bits >= 32) {
             if (code.HasHostFeature(HostFeature::BMI2)) {
-                auto const bit_count = ctx.reg_alloc.ScratchGpr(code);
+                const Xbyak::Reg64 bit_count = ctx.reg_alloc.ScratchGpr(code);
                 code.mov(bit_count, unused_top_bits);
                 code.bzhi(tmp, vaddr, bit_count);
                 code.shr(tmp, int(page_table_const_bits));
@@ -159,33 +153,17 @@ template<>
             code.shr(tmp, int(page_table_const_bits));
             code.and_(tmp, u32((1 << valid_page_index_bits) - 1));
         }
-        if (ctx.conf.page_table_log2_stride > 3) {
-            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-            code.mov(page, qword[r14 + tmp.cvt64()]);
-        } else {
-            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-        }
     } else {
-        // Common VA sizes: 39 - 12 => 27, 42 - 12 => 30
-        // Check if bits outside of VA space are non-zero
         ASSERT(valid_page_index_bits < 32);
         code.mov(tmp, vaddr);
-        if (ctx.conf.check_halt_on_memory_access) {
-            auto const tmp2 = ctx.reg_alloc.ScratchGpr(code);
-            code.mov(tmp2, u64(-(1ull << valid_page_index_bits) << page_table_const_bits));
-            code.test(tmp, tmp2);
-            code.jnz(abort, code.T_NEAR);
-            ctx.reg_alloc.Release(tmp2);
-        }
         code.shr(tmp, int(page_table_const_bits));
-        if (ctx.conf.page_table_log2_stride > 3) {
-            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-            code.mov(page, qword[r14 + tmp.cvt64()]);
-        } else {
-            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
-        }
+        code.test(tmp, u32(-(1 << valid_page_index_bits)));
+        code.jnz(abort, code.T_NEAR);
     }
 
+    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+    code.mov(page, qword[r14 + tmp]);
+
     // check for marked bit, use as unmapped if marked
     if (ctx.conf.page_table_marked_bit) {
         code.bt(page, *ctx.conf.page_table_marked_bit);
@@ -200,7 +178,6 @@ template<>
         code.mov(tmp, ctx.conf.page_table_pointer_mask);
         code.and_(page, tmp);
     }
-    // check for sign bit, apply sign extension as needed
     if (ctx.conf.page_table_sign_extension) {
         code.shl(page, *ctx.conf.page_table_sign_extension);
         code.sar(page, *ctx.conf.page_table_sign_extension);
@@ -211,7 +188,7 @@ template<>
         return page + vaddr;
     }
     code.mov(tmp, vaddr);
-    code.and_(tmp, u32(page_table_const_mask));
+    code.and_(tmp, static_cast<u32>(page_table_const_mask));
     return page + tmp;
 }
 

src/dynarmic/src/dynarmic/interface/A32/config.h

@@ -66,9 +66,7 @@ struct UserCallbacks : public TranslateCallbacks {
 
     // All reads through this callback are 4-byte aligned.
     // Memory must be interpreted as little endian.
-    std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override {
-        return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));
-    }
+    std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) override { return MemoryRead32(vaddr); }
 
     // This function is called before the instruction at pc is read.
     // IR code can be emitted by the callee prior to instruction handling.
@@ -82,10 +80,16 @@ struct UserCallbacks : public TranslateCallbacks {
 
     // Reads through these callbacks may not be aligned.
     // Memory must be interpreted as if ENDIANSTATE == 0, endianness will be corrected by the JIT.
-    virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;
+    virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;
+    virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;
+    virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;
+    virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;
 
     // Writes through these callbacks may not be aligned.
-    virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;
+    virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;
+    virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;
+    virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;
+    virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;
 
     // Writes through these callbacks may not be aligned.
     virtual bool MemoryWriteExclusive8(VAddr /*vaddr*/, std::uint8_t /*value*/, std::uint8_t /*expected*/) { return false; }

src/dynarmic/src/dynarmic/interface/A64/config.h

@@ -89,16 +89,20 @@ struct UserCallbacks {
 
     // All reads through this callback are 4-byte aligned.
     // Memory must be interpreted as little endian.
-    virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) {
-        return std::uint32_t(MemoryRead(vaddr, sizeof(std::uint32_t)));
-    }
+    virtual std::optional<std::uint32_t> MemoryReadCode(VAddr vaddr) { return MemoryRead32(vaddr); }
 
     // Reads through these callbacks may not be aligned.
-    virtual std::uint64_t MemoryRead(VAddr vaddr, std::size_t size) = 0;
+    virtual std::uint8_t MemoryRead8(VAddr vaddr) = 0;
+    virtual std::uint16_t MemoryRead16(VAddr vaddr) = 0;
+    virtual std::uint32_t MemoryRead32(VAddr vaddr) = 0;
+    virtual std::uint64_t MemoryRead64(VAddr vaddr) = 0;
     virtual Vector MemoryRead128(VAddr vaddr) = 0;
 
     // Writes through these callbacks may not be aligned.
-    virtual void MemoryWrite(VAddr vaddr, std::uint64_t value, std::size_t size) = 0;
+    virtual void MemoryWrite8(VAddr vaddr, std::uint8_t value) = 0;
+    virtual void MemoryWrite16(VAddr vaddr, std::uint16_t value) = 0;
+    virtual void MemoryWrite32(VAddr vaddr, std::uint32_t value) = 0;
+    virtual void MemoryWrite64(VAddr vaddr, std::uint64_t value) = 0;
     virtual void MemoryWrite128(VAddr vaddr, Vector value) = 0;
 
     // Writes through these callbacks may not be aligned.

src/dynarmic/src/dynarmic/ir/opt_passes.cpp

@@ -40,7 +40,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
             if (inst.AreAllArgsImmediates()) {
                 const u32 vaddr = inst.GetArg(1).GetU32();
                 if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u8 value_from_memory = u8(cb->MemoryRead(vaddr, sizeof(u8)));
+                    const u8 value_from_memory = cb->MemoryRead8(vaddr);
                     inst.ReplaceUsesWith(IR::Value{value_from_memory});
                 }
             }
@@ -51,7 +51,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
             if (inst.AreAllArgsImmediates()) {
                 const u32 vaddr = inst.GetArg(1).GetU32();
                 if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u16 value_from_memory = u16(cb->MemoryRead(vaddr, sizeof(u16)));
+                    const u16 value_from_memory = cb->MemoryRead16(vaddr);
                     inst.ReplaceUsesWith(IR::Value{value_from_memory});
                 }
             }
@@ -62,7 +62,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
             if (inst.AreAllArgsImmediates()) {
                 const u32 vaddr = inst.GetArg(1).GetU32();
                 if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u32 value_from_memory = u32(cb->MemoryRead(vaddr, sizeof(u32)));
+                    const u32 value_from_memory = cb->MemoryRead32(vaddr);
                     inst.ReplaceUsesWith(IR::Value{value_from_memory});
                 }
             }
@@ -73,7 +73,7 @@ static void ConstantMemoryReads(IR::Block& block, A32::UserCallbacks* cb) {
             if (inst.AreAllArgsImmediates()) {
                 const u32 vaddr = inst.GetArg(1).GetU32();
                 if (cb->IsReadOnlyMemory(vaddr)) {
-                    const u64 value_from_memory = u64(cb->MemoryRead(vaddr, sizeof(u64)));
+                    const u64 value_from_memory = cb->MemoryRead64(vaddr);
                     inst.ReplaceUsesWith(IR::Value{value_from_memory});
                 }
             }

src/dynarmic/tests/A32/fuzz_thumb.cpp

@@ -503,7 +503,7 @@ TEST_CASE("Fuzz Thumb32 instructions set", "[JitX64][Thumb][Thumb32]") {
     }
 }
 
-TEST_CASE("Verify fix for off by one error in MemoryRead<32> worked", "[Thumb][Thumb16]") {
+TEST_CASE("Verify fix for off by one error in MemoryRead32 worked", "[Thumb][Thumb16]") {
     ThumbTestEnv test_env;
 
     // Prepare test subjects

src/dynarmic/tests/A32/test_arm_instructions.cpp

@@ -553,9 +553,9 @@ TEST_CASE("arm: Memory access (fastmem)", "[arm][A32]") {
     memset(backing_memory, 0, memory_size);
     memcpy(backing_memory + 0x100, "Lorem ipsum dolor sit amet, consectetur adipiscing elit.", 57);
 
-    env.MemoryWrite(0, 0xE5904000, sizeof(u32));  // LDR R4, [R0]
-    env.MemoryWrite(4, 0xE5814000, sizeof(u32));  // STR R4, [R1]
-    env.MemoryWrite(8, 0xEAFFFFFE, sizeof(u32));  // B .
+    env.MemoryWrite32(0, 0xE5904000);  // LDR R4, [R0]
+    env.MemoryWrite32(4, 0xE5814000);  // STR R4, [R1]
+    env.MemoryWrite32(8, 0xEAFFFFFE);  // B .
     jit.Regs()[0] = 0x100;
     jit.Regs()[1] = 0x1F0;
     jit.Regs()[15] = 0;       // PC = 0

src/dynarmic/tests/A32/testenv.h

@@ -16,7 +16,6 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
-#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
 #include "dynarmic/interface/A32/a32.h"
 
 template<typename InstructionType_, u32 infinite_loop_u32>
@@ -60,51 +59,42 @@ public:
         return infinite_loop_u32;  // B .
     }
 
-    u64 MemoryRead(u32 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8): {
-            if (IsInCodeMem(vaddr))
-                return reinterpret_cast<u8*>(code_mem.data())[vaddr];
-            if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end())
-                return iter->second;
-            return u8(vaddr);
+    std::uint8_t MemoryRead8(u32 vaddr) override {
+        if (IsInCodeMem(vaddr)) {
+            return reinterpret_cast<u8*>(code_mem.data())[vaddr];
         }
-        default:
-            std::abort();
+        if (auto iter = modified_memory.find(vaddr); iter != modified_memory.end()) {
+            return iter->second;
         }
+        return static_cast<u8>(vaddr);
+    }
+    std::uint16_t MemoryRead16(u32 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+    std::uint32_t MemoryRead32(u32 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+    std::uint64_t MemoryRead64(u32 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
     }
 
-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            if (vaddr < code_mem.size() * sizeof(u32))
-                code_mem_modified_by_guest = true;
-            modified_memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
+    void MemoryWrite8(u32 vaddr, std::uint8_t value) override {
+        if (vaddr < code_mem.size() * sizeof(u32)) {
+            code_mem_modified_by_guest = true;
         }
+        modified_memory[vaddr] = value;
+    }
+    void MemoryWrite16(u32 vaddr, std::uint16_t value) override {
+        MemoryWrite8(vaddr, static_cast<u8>(value));
+        MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));
+    }
+    void MemoryWrite32(u32 vaddr, std::uint32_t value) override {
+        MemoryWrite16(vaddr, static_cast<u16>(value));
+        MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));
+    }
+    void MemoryWrite64(u32 vaddr, std::uint64_t value) override {
+        MemoryWrite32(vaddr, static_cast<u32>(value));
+        MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
     }
 
     void CallSVC(std::uint32_t swi) override {
@@ -153,41 +143,46 @@ public:
         return read<std::uint32_t>(vaddr);
     }
 
-    u64 MemoryRead(u32 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return read<u64>(vaddr);
-        case sizeof(u32): return read<u32>(vaddr);
-        case sizeof(u16): return read<u16>(vaddr);
-        case sizeof(u8): return read<u8>(vaddr);
-        default:
-            std::abort();
-        }
+    std::uint8_t MemoryRead8(std::uint32_t vaddr) override {
+        return read<std::uint8_t>(vaddr);
+    }
+    std::uint16_t MemoryRead16(std::uint32_t vaddr) override {
+        return read<std::uint16_t>(vaddr);
+    }
+    std::uint32_t MemoryRead32(std::uint32_t vaddr) override {
+        return read<std::uint32_t>(vaddr);
+    }
+    std::uint64_t MemoryRead64(std::uint32_t vaddr) override {
+        return read<std::uint64_t>(vaddr);
     }
 
-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, std::uint64_t value, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return write<u64>(vaddr, u64(value));
-        case sizeof(u32): return write<u32>(vaddr, u32(value));
-        case sizeof(u16): return write<u16>(vaddr, u16(value));
-        case sizeof(u8): return write<u8>(vaddr, u8(value));
-        default: std::abort();
-        }
+    void MemoryWrite8(std::uint32_t vaddr, std::uint8_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite16(std::uint32_t vaddr, std::uint16_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite32(std::uint32_t vaddr, std::uint32_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite64(std::uint32_t vaddr, std::uint64_t value) override {
+        write(vaddr, value);
     }
 
-    bool MemoryWriteExclusive8(Dynarmic::A32::VAddr vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u8));
+    bool MemoryWriteExclusive8(std::uint32_t vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
+        MemoryWrite8(vaddr, value);
         return true;
     }
-    bool MemoryWriteExclusive16(Dynarmic::A32::VAddr vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u16));
+    bool MemoryWriteExclusive16(std::uint32_t vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
+        MemoryWrite16(vaddr, value);
         return true;
     }
-    bool MemoryWriteExclusive32(Dynarmic::A32::VAddr vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u32));
+    bool MemoryWriteExclusive32(std::uint32_t vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
+        MemoryWrite32(vaddr, value);
         return true;
     }
-    bool MemoryWriteExclusive64(Dynarmic::A32::VAddr vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u64));
+    bool MemoryWriteExclusive64(std::uint32_t vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
+        MemoryWrite64(vaddr, value);
         return true;
     }
 

src/dynarmic/tests/A64/fibonacci.cpp

@@ -25,55 +25,48 @@ public:
     u64 ticks_left = 0;
     ::Common::unordered_map<u64, u8> memory{};
 
-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8):
-            return memory[vaddr];
-        default:
-            std::abort();
-        }
+    u8 MemoryRead8(u64 vaddr) override {
+        return memory[vaddr];
+    }
+
+    u16 MemoryRead16(u64 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+
+    u32 MemoryRead32(u64 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+
+    u64 MemoryRead64(u64 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
     }
 
     std::array<u64, 2> MemoryRead128(u64 vaddr) override {
-        return {
-            MemoryRead(vaddr, sizeof(u64)),
-            MemoryRead(vaddr + sizeof(u64), sizeof(u64))
-        };
+        return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};
     }
 
-    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
-        }
+    void MemoryWrite8(u64 vaddr, u8 value) override {
+        memory[vaddr] = value;
     }
+
+    void MemoryWrite16(u64 vaddr, u16 value) override {
+        MemoryWrite8(vaddr, u8(value));
+        MemoryWrite8(vaddr + 1, u8(value >> 8));
+    }
+
+    void MemoryWrite32(u64 vaddr, u32 value) override {
+        MemoryWrite16(vaddr, u16(value));
+        MemoryWrite16(vaddr + 2, u16(value >> 16));
+    }
+
+    void MemoryWrite64(u64 vaddr, u64 value) override {
+        MemoryWrite32(vaddr, u32(value));
+        MemoryWrite32(vaddr + 4, u32(value >> 32));
+    }
+
     void MemoryWrite128(u64 vaddr, std::array<u64, 2> value) override {
-        MemoryWrite(vaddr, value[0], sizeof(u64));
-        MemoryWrite(vaddr + 8, value[1], sizeof(u64));
+        MemoryWrite64(vaddr, value[0]);
+        MemoryWrite64(vaddr + 8, value[1]);
     }
 
     void CallSVC(u32) override {
@@ -142,9 +135,9 @@ TEST_CASE("A64: fibonacci", "[a64]") {
     code.RET();
 
     for (size_t i = 0; i < 1024; i++) {
-        env.MemoryWrite(i * 4, instructions[i], sizeof(u32));
+        env.MemoryWrite32(i * 4, instructions[i]);
     }
-    env.MemoryWrite(8888, 0xd4200000, sizeof(u32));
+    env.MemoryWrite32(8888, 0xd4200000);
     cpu.SetRegister(30, 8888);
 
     cpu.SetRegister(0, 10);

src/dynarmic/tests/A64/testenv.h

@@ -12,7 +12,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/interface/A64/a64.h"
-#include "dynarmic/interface/A64/config.h"
 
 using Vector = Dynarmic::A64::Vector;
 
@@ -35,79 +34,64 @@ public:
         return code_mem[index];
     }
 
-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8): {
-            if (IsInCodeMem(vaddr))
-                return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];
-            if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())
-                return it->second;
-            return u8(vaddr);
-        }
-        default:
-            std::abort();
+    std::uint8_t MemoryRead8(u64 vaddr) override {
+        if (IsInCodeMem(vaddr)) {
+            return reinterpret_cast<u8*>(code_mem.data())[vaddr - code_mem_start_address];
         }
+        if (auto const it = modified_memory.find(vaddr); it != modified_memory.end())
+            return it->second;
+        return u8(vaddr);
+    }
+    std::uint16_t MemoryRead16(u64 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+    std::uint32_t MemoryRead32(u64 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+    std::uint64_t MemoryRead64(u64 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
     }
-
     Vector MemoryRead128(u64 vaddr) override {
-        return {
-            MemoryRead(vaddr, sizeof(u64)),
-            MemoryRead(vaddr + 8, sizeof(u64))
-        };
+        return {MemoryRead64(vaddr), MemoryRead64(vaddr + 8)};
     }
 
-    void MemoryWrite(Dynarmic::A64::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            if (IsInCodeMem(vaddr)) {
-                code_mem_modified_by_guest = true;
-            }
-            modified_memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
+    void MemoryWrite8(u64 vaddr, std::uint8_t value) override {
+        if (IsInCodeMem(vaddr)) {
+            code_mem_modified_by_guest = true;
         }
+        modified_memory[vaddr] = value;
+    }
+    void MemoryWrite16(u64 vaddr, std::uint16_t value) override {
+        MemoryWrite8(vaddr, u8(value));
+        MemoryWrite8(vaddr + 1, u8(value >> 8));
+    }
+    void MemoryWrite32(u64 vaddr, std::uint32_t value) override {
+        MemoryWrite16(vaddr, u16(value));
+        MemoryWrite16(vaddr + 2, u16(value >> 16));
+    }
+    void MemoryWrite64(u64 vaddr, std::uint64_t value) override {
+        MemoryWrite32(vaddr, u32(value));
+        MemoryWrite32(vaddr + 4, u32(value >> 32));
     }
     void MemoryWrite128(u64 vaddr, Vector value) override {
-        MemoryWrite(vaddr, value[0], sizeof(u64));
-        MemoryWrite(vaddr + 8, value[1], sizeof(u64));
+        MemoryWrite64(vaddr, value[0]);
+        MemoryWrite64(vaddr + 8, value[1]);
     }
 
     bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u8));
+        MemoryWrite8(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u16));
+        MemoryWrite16(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u32));
+        MemoryWrite32(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u64));
+        MemoryWrite64(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {
@@ -161,46 +145,52 @@ public:
         return read<std::uint32_t>(vaddr);
     }
 
-    u64 MemoryRead(u64 vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return read<u64>(vaddr);
-        case sizeof(u32): return read<u32>(vaddr);
-        case sizeof(u16): return read<u16>(vaddr);
-        case sizeof(u8): return read<u8>(vaddr);
-        default: std::abort();
-        }
+    std::uint8_t MemoryRead8(u64 vaddr) override {
+        return read<std::uint8_t>(vaddr);
+    }
+    std::uint16_t MemoryRead16(u64 vaddr) override {
+        return read<std::uint16_t>(vaddr);
+    }
+    std::uint32_t MemoryRead32(u64 vaddr) override {
+        return read<std::uint32_t>(vaddr);
+    }
+    std::uint64_t MemoryRead64(u64 vaddr) override {
+        return read<std::uint64_t>(vaddr);
     }
     Vector MemoryRead128(u64 vaddr) override {
         return read<Vector>(vaddr);
     }
 
-    void MemoryWrite(u64 vaddr, std::uint64_t value, size_t size) override {
-        switch (size) {
-        case sizeof(u64): return write<u64>(vaddr, u64(value));
-        case sizeof(u32): return write<u32>(vaddr, u32(value));
-        case sizeof(u16): return write<u16>(vaddr, u16(value));
-        case sizeof(u8): return write<u8>(vaddr, u8(value));
-        default: std::abort();
-        }
+    void MemoryWrite8(u64 vaddr, std::uint8_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite16(u64 vaddr, std::uint16_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite32(u64 vaddr, std::uint32_t value) override {
+        write(vaddr, value);
+    }
+    void MemoryWrite64(u64 vaddr, std::uint64_t value) override {
+        write(vaddr, value);
     }
     void MemoryWrite128(u64 vaddr, Vector value) override {
         write(vaddr, value);
     }
 
     bool MemoryWriteExclusive8(u64 vaddr, std::uint8_t value, [[maybe_unused]] std::uint8_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u8));
+        MemoryWrite8(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive16(u64 vaddr, std::uint16_t value, [[maybe_unused]] std::uint16_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u16));
+        MemoryWrite16(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive32(u64 vaddr, std::uint32_t value, [[maybe_unused]] std::uint32_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u32));
+        MemoryWrite32(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive64(u64 vaddr, std::uint64_t value, [[maybe_unused]] std::uint64_t expected) override {
-        MemoryWrite(vaddr, value, sizeof(u64));
+        MemoryWrite64(vaddr, value);
         return true;
     }
     bool MemoryWriteExclusive128(u64 vaddr, Vector value, [[maybe_unused]] Vector expected) override {

src/dynarmic/tests/print_info.cpp

@@ -18,7 +18,6 @@
 #include <fmt/format.h>
 #include <fmt/ostream.h>
 #include <fmt/ranges.h>
-#include "dynarmic/frontend/A32/translate/translate_callbacks.h"
 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"
 
@@ -119,47 +118,36 @@ public:
     u64 ticks_left = 0;
     std::map<u32, u8> memory;
 
-    u64 MemoryRead(Dynarmic::A32::VAddr vaddr, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            return MemoryRead(vaddr, sizeof(u32))
-                | MemoryRead(vaddr + sizeof(u32), sizeof(u32)) << 32;
-        case sizeof(u32):
-            return MemoryRead(vaddr, sizeof(u16))
-                | MemoryRead(vaddr + sizeof(u16), sizeof(u16)) << 16;
-        case sizeof(u16):
-            return MemoryRead(vaddr, sizeof(u8))
-                | MemoryRead(vaddr + sizeof(u8), sizeof(u8)) << 8;
-        case sizeof(u8): {
-            if (auto const it = memory.find(vaddr); it != memory.end())
-                return it->second;
-            return 0;
-        }
-        default:
-            std::abort();
+    std::uint8_t MemoryRead8(u32 vaddr) override {
+        if (auto iter = memory.find(vaddr); iter != memory.end()) {
+            return iter->second;
         }
+        return 0;
+    }
+    std::uint16_t MemoryRead16(u32 vaddr) override {
+        return u16(MemoryRead8(vaddr)) | u16(MemoryRead8(vaddr + 1)) << 8;
+    }
+    std::uint32_t MemoryRead32(u32 vaddr) override {
+        return u32(MemoryRead16(vaddr)) | u32(MemoryRead16(vaddr + 2)) << 16;
+    }
+    std::uint64_t MemoryRead64(u32 vaddr) override {
+        return u64(MemoryRead32(vaddr)) | u64(MemoryRead32(vaddr + 4)) << 32;
     }
 
-    void MemoryWrite(Dynarmic::A32::VAddr vaddr, u64 value, size_t size) override {
-        switch (size) {
-        case sizeof(u64):
-            MemoryWrite(vaddr, u32(value), sizeof(u32));
-            MemoryWrite(vaddr + 4, u32(value >> 32), sizeof(u32));
-            break;
-        case sizeof(u32):
-            MemoryWrite(vaddr, u16(value), sizeof(u16));
-            MemoryWrite(vaddr + 2, u16(value >> 16), sizeof(u16));
-            break;
-        case sizeof(u16):
-            MemoryWrite(vaddr, u8(value), sizeof(u8));
-            MemoryWrite(vaddr + 1, u8(value >> 8), sizeof(u8));
-            break;
-        case sizeof(u8):
-            memory[vaddr] = value;
-            break;
-        default:
-            std::abort();
-        }
+    void MemoryWrite8(u32 vaddr, std::uint8_t value) override {
+        memory[vaddr] = value;
+    }
+    void MemoryWrite16(u32 vaddr, std::uint16_t value) override {
+        MemoryWrite8(vaddr, static_cast<u8>(value));
+        MemoryWrite8(vaddr + 1, static_cast<u8>(value >> 8));
+    }
+    void MemoryWrite32(u32 vaddr, std::uint32_t value) override {
+        MemoryWrite16(vaddr, static_cast<u16>(value));
+        MemoryWrite16(vaddr + 2, static_cast<u16>(value >> 16));
+    }
+    void MemoryWrite64(u32 vaddr, std::uint64_t value) override {
+        MemoryWrite32(vaddr, static_cast<u32>(value));
+        MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
     }
 
     void CallSVC(std::uint32_t swi) override {
@@ -243,7 +231,7 @@ void ExecuteA32Instruction(u32 instruction) {
             if (const auto address = get_value()) {
                 fmt::print("value: ");
                 if (const auto value = get_value()) {
-                    env.MemoryWrite(*address, *value, sizeof(u32));
+                    env.MemoryWrite32(*address, *value);
                     fmt::print("> mem[{:#08x}] = {:#08x}\n", *address, *value);
                 }
             }
@@ -259,8 +247,8 @@ void ExecuteA32Instruction(u32 instruction) {
     cpu.SetFpscr(fpscr);
 
     const u32 initial_pc = regs[15];
-    env.MemoryWrite(initial_pc + 0, instruction, sizeof(u32));
-    env.MemoryWrite(initial_pc + 4, 0xEAFFFFFE, sizeof(u32));  // B +0
+    env.MemoryWrite32(initial_pc + 0, instruction);
+    env.MemoryWrite32(initial_pc + 4, 0xEAFFFFFE);  // B +0
 
     cpu.Run();
     fmt::print("{}", fmt::join(cpu.Disassemble(), "\n"));

src/dynarmic/tests/unicorn_emu/a32_unicorn.cpp

@@ -290,7 +290,7 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type
         auto page = std::make_unique<Page>();
         page->address = base_address;
         for (size_t i = 0; i < page->data.size(); ++i)
-            page->data[i] = u8(this_->testenv.MemoryRead(u32(base_address + i), sizeof(u8)));
+            page->data[i] = this_->testenv.MemoryRead8(static_cast<u32>(base_address + i));
 
         uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());
         if (err == UC_ERR_MAP)
@@ -321,7 +321,24 @@ bool A32Unicorn<TestEnvironment>::UnmappedMemoryHook(uc_engine* uc, uc_mem_type
 template<class TestEnvironment>
 bool A32Unicorn<TestEnvironment>::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u32 start_address, int size, u64 value, void* user_data) {
     auto* this_ = static_cast<A32Unicorn*>(user_data);
-    this_->testenv.MemoryWrite(start_address, value, size);
+
+    switch (size) {
+    case 1:
+        this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));
+        break;
+    case 2:
+        this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));
+        break;
+    case 4:
+        this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));
+        break;
+    case 8:
+        this_->testenv.MemoryWrite64(start_address, value);
+        break;
+    default:
+        UNREACHABLE();
+    }
+
     return true;
 }
 

src/dynarmic/tests/unicorn_emu/a64_unicorn.cpp

@@ -197,7 +197,7 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 sta
         auto page = std::make_unique<Page>();
         page->address = base_address;
         for (size_t i = 0; i < page->data.size(); ++i)
-            page->data[i] = u8(this_->testenv.MemoryRead(base_address + i, sizeof(u8)));
+            page->data[i] = this_->testenv.MemoryRead8(base_address + i);
 
         uc_err err = uc_mem_map_ptr(uc, base_address, page->data.size(), permissions, page->data.data());
         if (err == UC_ERR_MAP)
@@ -227,6 +227,23 @@ bool A64Unicorn::UnmappedMemoryHook(uc_engine* uc, uc_mem_type /*type*/, u64 sta
 
 bool A64Unicorn::MemoryWriteHook(uc_engine* /*uc*/, uc_mem_type /*type*/, u64 start_address, int size, u64 value, void* user_data) {
     auto* this_ = static_cast<A64Unicorn*>(user_data);
-    this_->testenv.MemoryWrite(start_address, value, size);
+
+    switch (size) {
+    case 1:
+        this_->testenv.MemoryWrite8(start_address, static_cast<u8>(value));
+        break;
+    case 2:
+        this_->testenv.MemoryWrite16(start_address, static_cast<u16>(value));
+        break;
+    case 4:
+        this_->testenv.MemoryWrite32(start_address, static_cast<u32>(value));
+        break;
+    case 8:
+        this_->testenv.MemoryWrite64(start_address, value);
+        break;
+    default:
+        UNREACHABLE();
+    }
+
     return true;
 }

src/hid_core/resources/npad/npad.cpp

@@ -398,21 +398,21 @@ void NPad::InitNewlyAddedController(Kernel::KernelCore& kernel, u64 aruid, Core:
 void NPad::WriteEmptyEntry(NpadInternalState* npad) {
     NPadGenericState dummy_pad_state{};
     NpadGcTriggerState dummy_gc_state{};
-    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->fullkey_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->fullkey_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->handheld_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->handheld_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_dual_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->joy_dual_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_left_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->joy_left_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->joy_right_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->joy_right_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->palma_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->palma_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_pad_state.sampling_number = npad->system_ext_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->system_ext_lifo.WriteNextEntry(dummy_pad_state);
-    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().state.sampling_number + 1;
+    dummy_gc_state.sampling_number = npad->gc_trigger_lifo.ReadCurrentEntry().sampling_number + 1;
     npad->gc_trigger_lifo.WriteNextEntry(dummy_gc_state);
 }
 

src/qt_common/config/shared_translation.cpp

@@ -23,7 +23,7 @@ namespace ConfigurationShared {
 
 std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
     std::unique_ptr<TranslationMap> translations = std::make_unique<TranslationMap>();
-    const auto& tr = [](const char* text) -> QString { return QCoreApplication::translate("ConfigurationShared", text); };
+    const auto& tr = [parent](const char* text) -> QString { return parent->tr(text); };
 
 #define INSERT(SETTINGS, ID, NAME, TOOLTIP)                                                        \
     translations->insert(std::pair{SETTINGS::values.ID.Id(), std::pair{(NAME), (TOOLTIP)}})
@@ -151,9 +151,6 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA "
               "can produce a more stable picture in lower resolutions."));
     INSERT(Settings, post_shader_chain, QString(), QString());
-    INSERT(Settings, post_shader_preset, QString(), QString());
-    INSERT(Settings, post_shader_enabled, tr("Enable post-processing effects"),
-           tr("Applies post-processing effects to the final image."));
     INSERT(Settings, fullscreen_mode, tr("Fullscreen Mode:"),
            tr("The method used to render the window in fullscreen.\nBorderless offers the best "
               "compatibility with the on-screen keyboard that some games request for "
@@ -231,6 +228,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
     INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
            tr("May reduce shader stutter."));
+    INSERT(Settings, use_unified_memory, tr("Enable unified memory access"),
+           tr("Lets the GPU write buffer readbacks directly into guest memory."));
     INSERT(Settings, gpu_clock, tr("GPU Clocks"),
            tr("Makes the game believe GPU work finishes faster than it does, so it stops lowering "
               "resolution and render distance to fit the Switch's clocks."));
@@ -371,8 +370,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
 std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent) {
     std::unique_ptr<ComboboxTranslationMap> translations =
         std::make_unique<ComboboxTranslationMap>();
-    const auto& tr = [](const char* text, const char* context = "") {
-        return QCoreApplication::translate("ConfigurationShared", text, context);
+    const auto& tr = [&](const char* text, const char* context = "") {
+        return parent->tr(text, context);
     };
 
 #define PAIR(ENUM, VALUE, TRANSLATION) {static_cast<u32>(Settings::ENUM::VALUE), (TRANSLATION)}

src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp

@@ -13,6 +13,7 @@
 namespace Shader::Backend::SPIRV {
 namespace {
 Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
+    offset = ctx.BoundSharedOffset(offset, 4 + index_offset * 4);
     const Id shift_id{ctx.Const(2U)};
     Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
     if (index_offset > 0) {
@@ -160,7 +161,8 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {
 Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {
     if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {
         const Id shift_id{ctx.Const(3U)};
-        const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
+        const Id index{
+            ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.BoundSharedOffset(offset, 8), shift_id)};
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u64, ctx.shared_memory_u64, ctx.u32_zero_value, index)};
         const auto [scope, semantics]{AtomicArgs(ctx)};

src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cpp

@@ -31,6 +31,7 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)
 } // Anonymous namespace
 
 Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -42,6 +43,7 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -53,6 +55,7 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -63,6 +66,7 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -73,6 +77,7 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 4);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};
         return ctx.OpLoad(ctx.U32[1], pointer);
@@ -82,6 +87,7 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 8);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
         return ctx.OpLoad(ctx.U32[2], pointer);
@@ -97,6 +103,7 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 16);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
         return ctx.OpLoad(ctx.U32[4], pointer);
@@ -113,6 +120,7 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
 }
 
 void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -123,6 +131,7 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));
@@ -132,6 +141,7 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 4);
     Id pointer{};
     if (ctx.uses_explicit_workgroup_layout) {
         pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);
@@ -144,6 +154,7 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 8);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
         ctx.OpStore(pointer, value);
@@ -159,6 +170,7 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 16);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
         ctx.OpStore(pointer, value);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -600,6 +600,16 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
     }
 }
 
+Id EmitContext::BoundSharedOffset(Id offset, u32 access_bytes) {
+    if (shared_memory_declared_bytes == 0) {
+        return offset;
+    }
+    const u32 last_valid{shared_memory_declared_bytes > access_bytes
+                             ? shared_memory_declared_bytes - access_bytes
+                             : 0U};
+    return OpUMin(U32[1], offset, Const(last_valid));
+}
+
 void EmitContext::DefineSharedMemory(const IR::Program& program) {
     uses_explicit_workgroup_layout =
         profile.support_explicit_workgroup_layout &&
@@ -608,8 +618,15 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
     if (program.shared_memory_size == 0) {
         return;
     }
+    const u32 device_limit{profile.max_shared_memory_size};
+    const u32 shared_memory_size{device_limit != 0 && program.shared_memory_size > device_limit
+                                     ? device_limit
+                                     : program.shared_memory_size};
+    if (shared_memory_size != program.shared_memory_size) {
+        shared_memory_declared_bytes = shared_memory_size;
+    }
     const auto make{[&](Id element_type, u32 element_size) {
-        const u32 num_elements{Common::DivCeil(program.shared_memory_size, element_size)};
+        const u32 num_elements{Common::DivCeil(shared_memory_size, element_size)};
         const Id array_type{TypeArray(element_type, Const(num_elements))};
         Decorate(array_type, spv::Decoration::ArrayStride, element_size);
 
@@ -644,7 +661,7 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
         std::tie(shared_memory_u32x4, shared_u32x4, std::ignore) = make(U32[4], 16);
         return;
     }
-    const u32 num_elements{Common::DivCeil(program.shared_memory_size, 4U)};
+    const u32 num_elements{Common::DivCeil(shared_memory_size, 4U)};
     const Id type{TypeArray(U32[1], Const(num_elements))};
     shared_memory_u32_type = TypePointer(spv::StorageClass::Workgroup, type);
 

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -312,6 +312,8 @@ public:
     Id local_memory{};
 
     bool uses_explicit_workgroup_layout{};
+    u32 shared_memory_declared_bytes{};
+    [[nodiscard]] Id BoundSharedOffset(Id offset, u32 access_bytes);
     Id shared_memory_u8{};
     Id shared_memory_u16{};
     Id shared_memory_u32{};

src/shader_recompiler/profile.h

@@ -105,6 +105,9 @@ struct Profile {
 
     u32 gl_max_compute_smem_size{};
 
+    /// Largest workgroup shared memory allocation the device accepts, 0 when unconstrained
+    u32 max_shared_memory_size{};
+
     /// Maxwell and earlier nVidia architectures have broken robust support
     bool has_broken_robust{};
 

src/video_core/buffer_cache/buffer_cache.h

@@ -78,6 +78,11 @@ void BufferCache<P>::TickFrame() {
         return;
     }
     runtime.TickFrame(slot_buffers);
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!unified_written_ranges.Empty() && runtime.KnownGpuTick() >= unified_write_tick) {
+            unified_written_ranges.Clear();
+        }
+    }
 
     // Calculate hits and shots and move hit bits to the right
     const u32 hits = std::reduce(channel_state->uniform_cache_hits.begin(),
@@ -565,7 +570,8 @@ void BufferCache<P>::FlushCachedWrites() {
 
 template <class P>
 bool BufferCache<P>::HasUncommittedFlushes() const noexcept {
-    return !uncommitted_gpu_modified_ranges.Empty() || !committed_gpu_modified_ranges.empty();
+    return !uncommitted_gpu_modified_ranges.Empty() || !committed_gpu_modified_ranges.empty() ||
+           uncommitted_unified_writes;
 }
 
 template <class P>
@@ -578,14 +584,22 @@ void BufferCache<P>::AccumulateFlushes() {
 
 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    return (!async_buffers.empty() && async_buffers.front().has_value());
+    if (async_buffers.empty()) {
+        return false;
+    }
+    return async_buffers.front().has_value() ||
+           !pending_downloads.front().unified_copies.empty() ||
+           pending_downloads.front().unified_writes;
 }
 
 template <class P>
 void BufferCache<P>::CommitAsyncFlushesHigh() {
     AccumulateFlushes();
+    const bool unified_writes = uncommitted_unified_writes;
+    uncommitted_unified_writes = false;
 
     if (committed_gpu_modified_ranges.empty()) {
+        pending_downloads.emplace_back(AsyncDownloadBatch{.unified_writes = unified_writes});
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
@@ -645,27 +659,85 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     }
     committed_gpu_modified_ranges.clear();
     if (downloads.empty()) {
+        pending_downloads.emplace_back(AsyncDownloadBatch{.unified_writes = unified_writes});
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
-    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true);
-    boost::container::small_vector<BufferCopy, 4> normalized_copies;
-    runtime.PreCopyBarrier();
+
+    struct QueuedUnifiedCopy {
+        u64 window;
+        BufferId buffer_id;
+        boost::container::small_vector<BufferCopy, 16> copies;
+    };
+
+    AsyncDownloadBatch batch;
+    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> staging_downloads;
+    boost::container::small_vector<QueuedUnifiedCopy, 4> unified_copy_queue;
+    boost::container::small_vector<u64, 4> window_ids;
+    UnifiedWindowGroups groups;
+    u64 staging_size_bytes = 0;
     for (auto& [copy, buffer_id] : downloads) {
-        copy.dst_offset += download_staging.offset;
-        const std::array copies{copy};
-        BufferCopy second_copy{copy};
         Buffer& buffer = slot_buffers[buffer_id];
-        second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
-        const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset);
+        const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
+        bool unified = false;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory()) {
+                window_ids.clear();
+                groups.clear();
+                unified = ResolveUnifiedWindows(orig_device_addr, copy.src_offset, copy.size,
+                                                window_ids, groups);
+            }
+        }
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(orig_device_addr);
+        if (unified) {
+            async_downloads.Add(orig_device_addr, copy.size);
+            buffer.MarkUsage(copy.src_offset, copy.size);
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                unified_copy_queue.push_back(
+                    QueuedUnifiedCopy{window_ids[i], buffer_id, std::move(groups[i])});
+            }
+            batch.unified_copies.push_back(record);
+            continue;
+        }
+        copy.dst_offset = staging_size_bytes;
+        constexpr u64 align = 64ULL;
+        staging_size_bytes += (copy.size + align - 1) & ~(align - 1ULL);
+        staging_downloads.push_back({copy, buffer_id});
+    }
+
+    std::optional<Async_Buffer> download_staging;
+    if (!staging_downloads.empty()) {
+        download_staging = runtime.DownloadStagingBuffer(staging_size_bytes, true);
+    }
+    runtime.PreCopyBarrier();
+    for (auto& [copy, buffer_id] : staging_downloads) {
+        copy.dst_offset += download_staging->offset;
+        const std::array copies{copy};
+        Buffer& buffer = slot_buffers[buffer_id];
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
+        const DAddr orig_device_addr = static_cast<DAddr>(record.src_offset);
         async_downloads.Add(orig_device_addr, copy.size);
         buffer.MarkUsage(copy.src_offset, copy.size);
-        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
-        normalized_copies.push_back(second_copy);
+        runtime.CopyBuffer(download_staging->buffer, buffer, copies, false);
+        batch.staging_copies.push_back(record);
+    }
+    if constexpr (USE_UNIFIED_MEMORY) {
+        for (const auto& queued : unified_copy_queue) {
+            const std::span<const BufferCopy> group_span(queued.copies.data(),
+                                                         queued.copies.size());
+            runtime.CopyToUnifiedMemory(queued.window, slot_buffers[queued.buffer_id], group_span);
+        }
+        if (!unified_copy_queue.empty()) {
+            runtime.FlushUnifiedMemoryCopies();
+            runtime.UnifiedMemoryHostBarrier();
+        }
     }
     runtime.PostCopyBarrier();
-    pending_downloads.emplace_back(std::move(normalized_copies));
-    async_buffers.emplace_back(download_staging);
+    batch.unified_writes = unified_writes;
+    pending_downloads.emplace_back(std::move(batch));
+    async_buffers.emplace_back(std::move(download_staging));
 }
 
 template <class P>
@@ -680,32 +752,49 @@ void BufferCache<P>::PopAsyncFlushes() {
 
 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
+    struct Writeback {
+        DAddr addr;
+        const u8* src;
+        u64 size;
+    };
+    boost::container::small_vector<Writeback, 8> writebacks;
+    {
+        std::scoped_lock lock{mutex};
     if (async_buffers.empty()) {
         return;
     }
-    if (!async_buffers.front().has_value()) {
-        async_buffers.pop_front();
-        return;
-    }
-    auto& downloads = pending_downloads.front();
+        auto& batch = pending_downloads.front();
     auto& async_buffer = async_buffers.front();
-    u8* base = async_buffer->mapped_span.data();
+        if (async_buffer.has_value()) {
+            const u8* base = async_buffer->mapped_span.data();
     const size_t base_offset = async_buffer->offset;
-    for (const auto& copy : downloads) {
+            for (const auto& copy : batch.staging_copies) {
         const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
         const u64 dst_offset = copy.dst_offset - base_offset;
         const u8* read_mapped_memory = base + dst_offset;
-        async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-            device_memory.WriteBlockUnsafe(start, &read_mapped_memory[start - device_addr],
-                                           end - start);
+                async_downloads.ForEachInRange(
+                    device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+                        writebacks.push_back(
+                            {start, &read_mapped_memory[start - device_addr], end - start});
         });
         async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
             gpu_modified_ranges.Subtract(start, end - start);
         });
     }
     async_buffers_death_ring.emplace_back(*async_buffer);
+        }
+        for (const auto& copy : batch.unified_copies) {
+            const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+                gpu_modified_ranges.Subtract(start, end - start);
+            });
+        }
     async_buffers.pop_front();
     pending_downloads.pop_front();
+    }
+    for (const auto& wb : writebacks) {
+        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
+    }
 }
 
 template <class P>
@@ -749,6 +838,9 @@ void BufferCache<P>::BindHostIndexBuffer() {
     const u32 size = channel_state->index_buffer.size;
     const auto& draw_state = maxwell3d->draw_manager.draw_state;
     if (draw_state.inline_index_draw_indexes.empty()) {
+        if (BindVirtualIndexBuffer()) {
+            return;
+        }
         SynchronizeBuffer(buffer, channel_state->index_buffer.device_addr, size);
     } else {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
@@ -802,6 +894,7 @@ void BufferCache<P>::UpdateVertexBufferSlot(u32 index, const Binding& binding) {
         enabled_vertex_buffers_mask |= (1u << index);
     } else {
         enabled_vertex_buffers_mask &= ~(1u << index);
+        virtual_vertex_buffers_mask &= ~(1u << index);
     }
 }
 
@@ -834,8 +927,16 @@ void BufferCache<P>::BindHostVertexBuffers() {
             const Binding& binding = VertexBufferSlot(index);
             Buffer& buffer = slot_buffers[binding.buffer_id];
             TouchBuffer(buffer, binding.buffer_id);
+            if (StageVirtualVertexBuffer(index, binding, false)) {
+                continue;
+            }
+            bool needs_bind = flags[Dirty::VertexBuffer0 + index];
+            if (((virtual_vertex_buffers_mask >> index) & 1) != 0) {
+                virtual_vertex_buffers_mask &= ~(1u << index);
+                needs_bind = true;
+            }
             SynchronizeBuffer(buffer, binding.device_addr, binding.size);
-            if (!flags[Dirty::VertexBuffer0 + index]) {
+            if (!needs_bind) {
                 flush_bindings();
                 continue;
             }
@@ -856,6 +957,7 @@ void BufferCache<P>::BindHostVertexBuffers() {
             last_index = index;
         }
         flush_bindings();
+        BindStagedVertexBuffers();
     } else {
         HostBindings<typename P::Buffer> host_bindings;
         bool any_valid{false};
@@ -864,8 +966,17 @@ void BufferCache<P>::BindHostVertexBuffers() {
             const Binding& binding = channel_state->vertex_buffers[index];
             Buffer& buffer = slot_buffers[binding.buffer_id];
             TouchBuffer(buffer, binding.buffer_id);
+            if (((enabled_vertex_buffers_mask >> index) & 1) != 0 &&
+                StageVirtualVertexBuffer(index, binding, true)) {
+                continue;
+            }
+            bool needs_bind = flags[Dirty::VertexBuffer0 + index];
+            if (((virtual_vertex_buffers_mask >> index) & 1) != 0) {
+                virtual_vertex_buffers_mask &= ~(1u << index);
+                needs_bind = true;
+            }
             SynchronizeBuffer(buffer, binding.device_addr, binding.size);
-            if (!flags[Dirty::VertexBuffer0 + index]) {
+            if (!needs_bind) {
                 continue;
             }
             flags[Dirty::VertexBuffer0 + index] = false;
@@ -894,6 +1005,7 @@ void BufferCache<P>::BindHostVertexBuffers() {
             }
             runtime.BindVertexBuffers(host_bindings);
         }
+        BindStagedVertexBuffers();
     }
 }
 
@@ -949,8 +1061,12 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     }();
     const bool use_fast_buffer = needs_alignment_stream
         || (has_host_buffer && size <= channel_state->uniform_buffer_skip_cache_size
-            && !memory_tracker.IsRegionGpuModified(device_addr, size));
+            && !memory_tracker.IsRegionGpuModified(device_addr, size)
+            && !HasPendingUnifiedWrites(device_addr, size));
     if (use_fast_buffer) {
+        if (needs_alignment_stream) {
+            WaitForUnifiedWrites(device_addr, size);
+        }
         if constexpr (IS_OPENGL) {
             if (runtime.HasFastBufferSubData()) {
                 // Fast path for Nvidia
@@ -1046,6 +1162,34 @@ void BufferCache<P>::ResolveMultiRangeStorage(Binding& binding, bool is_written,
 template <class P>
 bool BufferCache<P>::BindMultiRangeStorage(const Binding& binding, bool is_written,
                                            std::span<const MultiRangeSegment> pool) {
+    if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}, bool{}); }) {
+        const u64 key = GeometryKey(binding.gpu_addr, 0);
+        if (!PushMultiRangeSources(binding, is_written, pool, key)) {
+            return false;
+        }
+        return runtime.BindMultiRangeStorageBuffer(key, is_written);
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+u64 BufferCache<P>::GeometryKey(GPUVAddr gpu_addr, u64 salt) const {
+    return ((static_cast<u64>(gpu_memory->GetID()) << 48) ^ gpu_addr) ^ salt;
+}
+
+template <class P>
+u32 BufferCache<P>::ClampToMappedRange(GPUVAddr gpu_addr, u32 size) const {
+    const size_t mapped = gpu_memory->MaxMappedRange(gpu_addr, size);
+    if (mapped == 0 || mapped >= size) {
+        return size;
+    }
+    return static_cast<u32>(mapped);
+}
+
+template <class P>
+bool BufferCache<P>::PushMultiRangeSources(const Binding& binding, bool is_written,
+                                           std::span<const MultiRangeSegment> pool, u64 key) {
     if constexpr (requires { runtime.BindMultiRangeStorageBuffer(u64{}, bool{}); }) {
         if (binding.segment_count < 2) {
             return false;
@@ -1053,23 +1197,273 @@ bool BufferCache<P>::BindMultiRangeStorage(const Binding& binding, bool is_writt
         if (binding.segment_first + binding.segment_count > pool.size()) {
             return false;
         }
-        const u64 key = (static_cast<u64>(gpu_memory->GetID()) << 48) ^ binding.gpu_addr;
+        const std::span<const MultiRangeSegment> segments =
+            pool.subspan(binding.segment_first, binding.segment_count);
+        boost::container::small_vector<BufferId, 8> buffer_ids;
+        for (const MultiRangeSegment& segment : segments) {
+            BufferId buffer_id = segment.buffer_id;
+            if (!buffer_id) {
+                buffer_id = page_table[segment.device_addr >> CACHING_PAGEBITS];
+            }
+            if (!buffer_id ||
+                !slot_buffers[buffer_id].IsInBounds(segment.device_addr, segment.size)) {
+                return false;
+            }
+            buffer_ids.push_back(buffer_id);
+        }
         runtime.ResetMultiRange();
         for (u32 index = 0; index < binding.segment_count; ++index) {
-            const MultiRangeSegment& segment = pool[binding.segment_first + index];
-            Buffer& buffer = slot_buffers[segment.buffer_id];
-            TouchBuffer(buffer, segment.buffer_id);
-            if (SynchronizeBuffer(buffer, segment.device_addr, segment.size)) {
+            const MultiRangeSegment& segment = segments[index];
+            const BufferId buffer_id = buffer_ids[index];
+            Buffer& buffer = slot_buffers[buffer_id];
+            TouchBuffer(buffer, buffer_id);
+            if (!SynchronizeBuffer(buffer, segment.device_addr, segment.size)) {
                 runtime.InvalidateMultiRange(key);
             }
             const u32 offset = buffer.Offset(segment.device_addr);
             buffer.MarkUsage(offset, segment.size);
             if (is_written) {
-                MarkWrittenBuffer(segment.buffer_id, segment.device_addr, segment.size);
+                MarkWrittenBuffer(buffer_id, segment.device_addr, segment.size);
             }
             runtime.PushMultiRangeSource(buffer, offset, segment.size);
         }
-        return runtime.BindMultiRangeStorageBuffer(key, is_written);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::TryResolveUnifiedSegments(
+    [[maybe_unused]] const Binding& binding,
+    [[maybe_unused]] std::span<const MultiRangeSegment> pool,
+    [[maybe_unused]] UnifiedExtents& extents) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        extents.clear();
+        const auto push = [&](DAddr device_addr, u64 size) {
+            const std::optional<u64> relative = TryResolveUnifiedRange(device_addr, size);
+            if (!relative) {
+                return false;
+            }
+            if (!extents.empty() && extents.back().relative + extents.back().size == *relative) {
+                extents.back().size += size;
+                return true;
+            }
+            extents.push_back(UnifiedExtent{.relative = *relative, .size = size});
+            return true;
+        };
+        if (binding.segment_count < 2) {
+            return push(binding.device_addr, binding.size);
+        }
+        if (binding.segment_first + binding.segment_count > pool.size()) {
+            return false;
+        }
+        for (const MultiRangeSegment& segment :
+             pool.subspan(binding.segment_first, binding.segment_count)) {
+            if (!push(segment.device_addr, segment.size)) {
+                return false;
+            }
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void BufferCache<P>::ResolveGeometrySegments([[maybe_unused]] bool is_indexed) {
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        const auto& draw_state = maxwell3d->draw_manager.draw_state;
+        if (is_indexed && draw_state.inline_index_draw_indexes.empty()) {
+            ResolveMultiRangeStorage(channel_state->index_buffer, false, graphics_segments);
+        }
+        u32 enabled_mask = enabled_vertex_buffers_mask;
+        while (enabled_mask != 0) {
+            const u32 index = std::countr_zero(enabled_mask);
+            enabled_mask &= enabled_mask - 1;
+            Binding& slot = VertexBufferSlot(index);
+            ResolveMultiRangeStorage(slot, false, graphics_segments);
+            Binding& channel_binding = channel_state->vertex_buffers[index];
+            channel_binding.segment_first = slot.segment_first;
+            channel_binding.segment_count = slot.segment_count;
+        }
+    }
+}
+
+template <class P>
+bool BufferCache<P>::StageVirtualVertexBuffer([[maybe_unused]] u32 index,
+                                              [[maybe_unused]] const Binding& binding,
+                                              [[maybe_unused]] bool force) {
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        auto& flags = maxwell3d->dirty.flags;
+        const bool rebind = force || flags[Dirty::VertexBuffer0 + index] ||
+                            ((virtual_vertex_buffers_mask >> index) & 1) == 0;
+        const u32 stride = maxwell3d->regs.vertex_streams[index].stride;
+        const u64 salt = VERTEX_GEOMETRY_SALT + (u64{index} << 40);
+        bool staged = false;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            UnifiedExtents extents;
+            if (TryResolveUnifiedSegments(binding, graphics_segments, extents)) {
+                const u64 view_key = GeometryKey(binding.gpu_addr, salt + VIEW_GEOMETRY_SALT);
+                staged = runtime.StageUnifiedVertexBuffer(index, view_key, extents, binding.size,
+                                                          stride, rebind);
+            }
+        }
+        if (!staged) {
+            const u64 key = GeometryKey(binding.gpu_addr, salt);
+            if (PushMultiRangeSources(binding, false, graphics_segments, key)) {
+                staged = runtime.StageMultiRangeVertexBuffer(index, key, binding.size, stride,
+                                                             rebind);
+            }
+        }
+        if (!staged) {
+            return false;
+        }
+        flags[Dirty::VertexBuffer0 + index] = false;
+        virtual_vertex_buffers_mask |= 1u << index;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::BindVirtualIndexBuffer() {
+    if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT &&
+                  requires { runtime.BindStagedVertexBuffers(); }) {
+        const Binding& binding = channel_state->index_buffer;
+        const auto& draw_state = maxwell3d->draw_manager.draw_state;
+        const auto& index_ref = draw_state.index_buffer;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            UnifiedExtents extents;
+            const u64 view_key =
+                GeometryKey(binding.gpu_addr, INDEX_GEOMETRY_SALT + VIEW_GEOMETRY_SALT);
+            if (TryResolveUnifiedSegments(binding, graphics_segments, extents) &&
+                runtime.BindUnifiedIndexBuffer(draw_state.topology, index_ref.format,
+                                               index_ref.first, index_ref.count, view_key,
+                                               extents, binding.size)) {
+                return true;
+            }
+        }
+        const u64 key = GeometryKey(binding.gpu_addr, INDEX_GEOMETRY_SALT);
+        if (!PushMultiRangeSources(binding, false, graphics_segments, key)) {
+            return false;
+        }
+        return runtime.BindMultiRangeIndexBuffer(draw_state.topology, index_ref.format,
+                                                 index_ref.first, index_ref.count, key,
+                                                 binding.size);
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void BufferCache<P>::BindStagedVertexBuffers() {
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        runtime.BindStagedVertexBuffers();
+    }
+}
+
+template <class P>
+bool BufferCache<P>::HasPendingUnifiedWrites([[maybe_unused]] DAddr device_addr,
+                                             [[maybe_unused]] u64 size) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (unified_written_ranges.Empty()) {
+            return false;
+        }
+        if (runtime.KnownGpuTick() >= unified_write_tick) {
+            unified_written_ranges.Clear();
+            return false;
+        }
+        bool overlaps = false;
+        unified_written_ranges.ForEachInRange(device_addr, size,
+                                              [&overlaps](DAddr, DAddr) { overlaps = true; });
+        return overlaps;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+void BufferCache<P>::WaitForUnifiedWrites([[maybe_unused]] DAddr device_addr,
+                                          [[maybe_unused]] u64 size) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!HasPendingUnifiedWrites(device_addr, size)) {
+            return;
+        }
+        runtime.Wait(unified_write_tick);
+        unified_written_ranges.Clear();
+    }
+}
+
+template <class P>
+template <typename Func>
+bool BufferCache<P>::CopyUnifiedWrites([[maybe_unused]] Buffer& buffer,
+                                       [[maybe_unused]] DAddr device_addr,
+                                       [[maybe_unused]] u64 size,
+                                       [[maybe_unused]] Func&& add_upload) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (!HasPendingUnifiedWrites(device_addr, size)) {
+            return false;
+        }
+        boost::container::small_vector<std::pair<DAddr, DAddr>, 4> overlaps;
+        unified_written_ranges.ForEachInRange(device_addr, size,
+                                              [&overlaps](DAddr start, DAddr end) {
+                                                  overlaps.emplace_back(start, end);
+                                              });
+        const DAddr buffer_start = buffer.CpuAddr();
+        boost::container::small_vector<u64, 4> window_ids;
+        UnifiedWindowGroups groups;
+        for (const auto& [start, end] : overlaps) {
+            if (!ResolveUnifiedWindows(start, start - buffer_start, end - start, window_ids,
+                                       groups)) {
+                runtime.Wait(unified_write_tick);
+                unified_written_ranges.Clear();
+                return false;
+            }
+        }
+        for (size_t i = 0; i < window_ids.size(); ++i) {
+            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyFromUnifiedMemory(window_ids[i], buffer, group_span);
+        }
+        DAddr cursor = device_addr;
+        for (const auto& [start, end] : overlaps) {
+            buffer.MarkUsage(start - buffer_start, end - start);
+            if (start > cursor) {
+                add_upload(cursor, start - cursor);
+            }
+            cursor = end;
+        }
+        if (cursor < device_addr + size) {
+            add_upload(cursor, device_addr + size - cursor);
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::BindUnifiedStorage([[maybe_unused]] const Binding& binding,
+                                        [[maybe_unused]] bool is_written) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        const auto relative = TryResolveUnifiedRange(binding.device_addr, binding.size);
+        if (!relative) {
+            return false;
+        }
+        const auto range = runtime.ResolveUnifiedStorage(*relative, binding.size);
+        if (!range) {
+            return false;
+        }
+        if (is_written) {
+            memory_tracker.MarkRegionAsCpuModified(binding.device_addr, binding.size);
+            unified_written_ranges.Add(binding.device_addr, binding.size);
+            unified_write_tick = runtime.CurrentTick();
+            uncommitted_unified_writes = true;
+        }
+        runtime.BindStorageBuffer(range->buffer, range->address, range->offset,
+                                  binding.size, is_written);
+        return true;
     } else {
         return false;
     }
@@ -1086,7 +1480,11 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
         }
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
+        if (BindUnifiedStorage(binding, is_written)) {
+            return;
+        }
         const u32 size = binding.size;
+
         SynchronizeBuffer(buffer, binding.device_addr, size);
 
         const u32 offset = buffer.Offset(binding.device_addr);
@@ -1195,6 +1593,7 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {
         }();
         if constexpr (!IS_OPENGL) {
             if (needs_alignment_stream) {
+                WaitForUnifiedWrites(binding.device_addr, size);
                 const std::span<u8> span =
                     runtime.BindMappedUniformBuffer(0, binding_index, size);
                 device_memory.ReadBlockUnsafe(binding.device_addr, span.data(), size);
@@ -1226,6 +1625,9 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
         }
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
+        if (BindUnifiedStorage(binding, is_written)) {
+            return;
+        }
         const u32 size = binding.size;
         SynchronizeBuffer(buffer, binding.device_addr, size);
 
@@ -1282,6 +1684,7 @@ void BufferCache<P>::DoUpdateGraphicsBuffers(bool is_indexed) {
             UpdateIndexBuffer();
         }
         UpdateVertexBuffers();
+        ResolveGeometrySegments(is_indexed);
         UpdateTransformFeedbackBuffers();
         for (size_t stage = 0; stage < NUM_STAGES; ++stage) {
             UpdateUniformBuffers(stage);
@@ -1338,13 +1741,17 @@ void BufferCache<P>::UpdateIndexBuffer() {
     const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(gpu_addr_begin);
     const u32 address_size = static_cast<u32>(gpu_addr_end - gpu_addr_begin);
     const u32 draw_size = (index_buffer_ref.count + index_buffer_ref.first) * u32(index_buffer_ref.FormatSizeInBytes());
-    const u32 size = (std::min)(address_size, draw_size);
+    u32 size = (std::min)(address_size, draw_size);
     if (size == 0 || !device_addr) {
         channel_state->index_buffer = NULL_BINDING;
         return;
     }
+    if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        size = ClampToMappedRange(gpu_addr_begin, size);
+    }
     channel_state->index_buffer = Binding{
         .device_addr = *device_addr,
+        .gpu_addr = gpu_addr_begin,
         .size = size,
         .buffer_id = FindBuffer(*device_addr, size, false),
     };
@@ -1382,10 +1789,13 @@ void BufferCache<P>::UpdateVertexBuffer(u32 index) {
     }
     if (!gpu_memory->IsWithinGPUAddressRange(gpu_addr_end) || size >= 64_MiB) {
         size = static_cast<u32>(gpu_memory->MaxContinuousRange(gpu_addr_begin, size));
+    } else if constexpr (requires { runtime.BindStagedVertexBuffers(); }) {
+        size = ClampToMappedRange(gpu_addr_begin, size);
     }
     const BufferId buffer_id = FindBuffer(*device_addr, size, false);
     const Binding binding{
         .device_addr = *device_addr,
+        .gpu_addr = gpu_addr_begin,
         .size = size,
         .buffer_id = buffer_id,
     };
@@ -1742,16 +2152,28 @@ bool BufferCache<P>::SynchronizeBuffer(Buffer& buffer, DAddr device_addr, u32 si
     u64 total_size_bytes = 0;
     u64 largest_copy = 0;
     const DAddr buffer_start = buffer.cpu_addr_cached;
-    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+    const auto add_upload = [&](u64 upload_addr, u64 upload_size) {
         upload_copies.push_back(BufferCopy{
             .src_offset = total_size_bytes,
-            .dst_offset = device_addr_out - buffer_start,
-            .size = range_size,
+            .dst_offset = upload_addr - buffer_start,
+            .size = upload_size,
         });
-        total_size_bytes += range_size;
-        largest_copy = (std::max)(largest_copy, range_size);
+        total_size_bytes += upload_size;
+        largest_copy = (std::max)(largest_copy, upload_size);
+    };
+    bool copied_from_windows = false;
+    memory_tracker.ForEachUploadRange(device_addr, size, [&](u64 device_addr_out, u64 range_size) {
+        if (CopyUnifiedWrites(buffer, device_addr_out, range_size, add_upload)) {
+            copied_from_windows = true;
+            return;
+        }
+        add_upload(device_addr_out, range_size);
     });
     if (total_size_bytes == 0) {
+        if (copied_from_windows) {
+            any_buffer_uploaded = true;
+            return false;
+        }
         return true;
     }
     const std::span<BufferCopy> copies_span(upload_copies.data(), upload_copies.size());
@@ -1799,6 +2221,130 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
     }
 }
 
+template <class P>
+bool BufferCache<P>::ResolveUnifiedWindows(
+    [[maybe_unused]] DAddr device_addr, [[maybe_unused]] u64 buffer_offset,
+    [[maybe_unused]] u64 size, [[maybe_unused]] boost::container::small_vector<u64, 4>& window_ids,
+    [[maybe_unused]] UnifiedWindowGroups& groups) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        const u8* const physical_base = device_memory.GetPhysicalBase();
+        const u64 unified_base = runtime.UnifiedMemoryBase();
+        const u64 unified_size = runtime.UnifiedMemorySize();
+        const u64 window_size = runtime.UnifiedMemoryWindowSize();
+        if (window_size == 0) {
+            return false;
+        }
+        const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                if (window_ids[i] == window) {
+                    return groups[i];
+                }
+            }
+            window_ids.push_back(window);
+            groups.emplace_back();
+            return groups.back();
+        };
+        u64 downloaded = 0;
+        while (downloaded < size) {
+            const DAddr page_addr = device_addr + downloaded;
+            const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
+            if (ptr == nullptr) {
+                return false;
+            }
+            const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
+            u64 chunk = (std::min)(size - downloaded,
+                                   static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
+            const u64 phys_offset = static_cast<u64>(ptr - physical_base);
+            if (phys_offset < unified_base || phys_offset - unified_base + chunk > unified_size) {
+                return false;
+            }
+            const u64 relative = phys_offset - unified_base;
+            const u64 window = relative / window_size;
+            const u64 local_offset = relative % window_size;
+            chunk = (std::min)(chunk, window_size - local_offset);
+            auto& group = group_for(window);
+            if (!group.empty()) {
+                BufferCopy& last = group.back();
+                if (last.src_offset + last.size == buffer_offset + downloaded &&
+                    last.dst_offset + last.size == local_offset) {
+                    last.size += chunk;
+                    downloaded += chunk;
+                    continue;
+                }
+            }
+            group.push_back(BufferCopy{
+                .src_offset = buffer_offset + downloaded,
+                .dst_offset = local_offset,
+                .size = chunk,
+            });
+            downloaded += chunk;
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+std::optional<u64> BufferCache<P>::TryResolveUnifiedRange([[maybe_unused]] DAddr device_addr,
+                                                          [[maybe_unused]] u64 size) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        if (size == 0 || !runtime.IsUnifiedMemoryBindable()) {
+            return std::nullopt;
+        }
+        const u8* const first = device_memory.GetSpan(device_addr, size);
+        if (first == nullptr) {
+            return std::nullopt;
+        }
+        const u64 phys_offset = static_cast<u64>(first - device_memory.GetPhysicalBase());
+        const u64 unified_base = runtime.UnifiedMemoryBase();
+        if (phys_offset < unified_base) {
+            return std::nullopt;
+        }
+        const u64 relative = phys_offset - unified_base;
+        const u64 unified_size = runtime.UnifiedMemorySize();
+        if (relative >= unified_size || unified_size - relative < size) {
+            return std::nullopt;
+        }
+        if (memory_tracker.IsRegionGpuModified(device_addr, size) ||
+            IsRegionGpuModified(device_addr, size)) {
+            return std::nullopt;
+        }
+        return relative;
+    } else {
+        return std::nullopt;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
+                                              [[maybe_unused]] std::span<BufferCopy> copies) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        boost::container::small_vector<u64, 4> window_ids;
+        UnifiedWindowGroups groups;
+        for (const BufferCopy& copy : copies) {
+            if (!ResolveUnifiedWindows(buffer.CpuAddr() + copy.src_offset, copy.src_offset,
+                                       copy.size, window_ids, groups)) {
+                return false;
+            }
+        }
+        for (const BufferCopy& copy : copies) {
+            buffer.MarkUsage(copy.src_offset, copy.size);
+        }
+        runtime.PreCopyBarrier();
+        for (size_t i = 0; i < window_ids.size(); ++i) {
+            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
+        }
+        runtime.FlushUnifiedMemoryCopies();
+        runtime.UnifiedMemoryHostBarrier();
+        runtime.Finish();
+        return true;
+    } else {
+        return false;
+    }
+}
+
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                         [[maybe_unused]] u64 total_size_bytes,
@@ -1902,6 +2448,12 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
     }
 
     if constexpr (USE_MEMORY_MAPS) {
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory() &&
+                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
+                return;
+            }
+        }
         auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
         const u8* const mapped_memory = download_staging.mapped_span.data();
         const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());
@@ -1963,6 +2515,15 @@ void BufferCache<P>::DeleteBuffer(BufferId buffer_id, bool do_not_mark) {
     replace(channel_state->transform_feedback_buffers);
     replace(channel_state->compute_uniform_buffers);
     replace(channel_state->compute_storage_buffers);
+    const auto drop_segments = [buffer_id](std::vector<MultiRangeSegment>& pool) {
+        for (MultiRangeSegment& segment : pool) {
+            if (segment.buffer_id == buffer_id) {
+                segment.buffer_id = BufferId{};
+            }
+        }
+    };
+    drop_segments(graphics_segments);
+    drop_segments(compute_segments);
 
     // Mark the whole buffer as CPU written to stop tracking CPU writes
     if (!do_not_mark) {

src/video_core/buffer_cache/buffer_cache_base.h

@@ -12,6 +12,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
+#include <optional>
 #include <numeric>
 #include <span>
 #include <vector>
@@ -95,6 +96,11 @@ struct MultiRangeSegment {
     u32 size{};
 };
 
+struct UnifiedExtent {
+    u64 relative{};
+    u64 size{};
+};
+
 struct TextureBufferBinding : Binding {
     PixelFormat format;
 };
@@ -190,6 +196,10 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
     static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS;
     static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS;
+    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;
+    static constexpr u64 VERTEX_GEOMETRY_SALT = u64{1} << 47;
+    static constexpr u64 INDEX_GEOMETRY_SALT = u64{1} << 46;
+    static constexpr u64 VIEW_GEOMETRY_SALT = u64{1} << 45;
 
 #ifdef YUZU_LEGACY
     static constexpr s64 TARGET_THRESHOLD = 3_GiB;
@@ -228,6 +238,11 @@ public:
     bool BindMultiRangeStorage(const Binding& binding, bool is_written,
                                std::span<const MultiRangeSegment> pool);
 
+    bool BindUnifiedStorage(const Binding& binding, bool is_written);
+
+    bool PushMultiRangeSources(const Binding& binding, bool is_written,
+                               std::span<const MultiRangeSegment> pool, u64 key);
+
     void ResolveMultiRangeStorage(Binding& binding, bool is_written,
                                   std::vector<MultiRangeSegment>& pool);
 
@@ -462,6 +477,41 @@ private:
 
     void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);
 
+    bool TryUnifiedDownloadMemory(Buffer& buffer, std::span<BufferCopy> copies);
+
+    std::optional<u64> TryResolveUnifiedRange(DAddr device_addr, u64 size);
+
+    using UnifiedExtents = boost::container::small_vector<UnifiedExtent, 8>;
+
+    bool TryResolveUnifiedSegments(const Binding& binding, std::span<const MultiRangeSegment> pool,
+                                   UnifiedExtents& extents);
+
+    void ResolveGeometrySegments(bool is_indexed);
+
+    bool StageVirtualVertexBuffer(u32 index, const Binding& binding, bool force);
+
+    bool BindVirtualIndexBuffer();
+
+    void BindStagedVertexBuffers();
+
+    [[nodiscard]] u64 GeometryKey(GPUVAddr gpu_addr, u64 salt) const;
+
+    [[nodiscard]] u32 ClampToMappedRange(GPUVAddr gpu_addr, u32 size) const;
+
+    bool HasPendingUnifiedWrites(DAddr device_addr, u64 size);
+
+    void WaitForUnifiedWrites(DAddr device_addr, u64 size);
+
+    template <typename Func>
+    bool CopyUnifiedWrites(Buffer& buffer, DAddr device_addr, u64 size, Func&& add_upload);
+
+    using UnifiedWindowGroups =
+        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4>;
+
+    bool ResolveUnifiedWindows(DAddr device_addr, u64 buffer_offset, u64 size,
+                               boost::container::small_vector<u64, 4>& window_ids,
+                               UnifiedWindowGroups& groups);
+
     void DownloadBufferMemory(Buffer& buffer_id);
 
     void DownloadBufferMemory(Buffer& buffer_id, DAddr device_addr, u64 size);
@@ -506,6 +556,7 @@ private:
     u32 last_index_count = 0;
 
     u32 enabled_vertex_buffers_mask = 0;
+    u32 virtual_vertex_buffers_mask = 0;
     u64 vertex_buffers_serial = 0;
     std::array<Binding, 32> v_buffer{};
 
@@ -515,11 +566,20 @@ private:
     Common::RangeSet<DAddr> uncommitted_gpu_modified_ranges;
     Common::RangeSet<DAddr> gpu_modified_ranges;
     std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;
+    Common::RangeSet<DAddr> unified_written_ranges;
+    u64 unified_write_tick = 0;
+    bool uncommitted_unified_writes = false;
 
     // Async Buffers
+    struct AsyncDownloadBatch {
+        boost::container::small_vector<BufferCopy, 4> staging_copies;
+        boost::container::small_vector<BufferCopy, 4> unified_copies;
+        bool unified_writes = false;
+    };
+
     Common::OverlapRangeSet<DAddr> async_downloads;
     std::deque<std::optional<Async_Buffer>> async_buffers;
-    std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
+    std::deque<AsyncDownloadBatch> pending_downloads;
     std::optional<Async_Buffer> current_buffer;
 
     std::deque<Async_Buffer> async_buffers_death_ring;

src/video_core/host_shaders/CMakeLists.txt

@@ -16,13 +16,16 @@ set(GLSL_INCLUDES
 set(SHADER_FILES
     ${CMAKE_CURRENT_SOURCE_DIR}/astc_decoder.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_float.frag
+    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_swizzle_2d_buffer.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d.comp
+    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_2d_buffer.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_color_msaa.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_msaa.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/blit_depth_stencil_msaa.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_bcn.comp
+    ${CMAKE_CURRENT_SOURCE_DIR}/block_linear_unswizzle_3d_buffer.comp
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d24s8.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_abgr8_to_d32f.frag
     ${CMAKE_CURRENT_SOURCE_DIR}/convert_d32f_to_abgr8.frag

src/video_core/host_shaders/block_linear_swizzle_2d_buffer.comp

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 430
+
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_BUFFER 1
+
+layout(push_constant) uniform PushConstants {
+    uvec3 dim;
+    uint bytes_per_block_log2;
+
+    uvec3 origin;
+    uint layer_stride;
+
+    uint block_size;
+    uint x_shift;
+    uint block_height;
+    uint block_height_mask;
+} pc;
+
+layout(binding = BINDING_INPUT_BUFFER, std430) readonly buffer InputBuffer {
+    uint in_u32[];
+};
+
+layout(binding = BINDING_OUTPUT_BUFFER, std430) buffer OutputBuffer {
+    uint out_u32[];
+};
+
+layout(local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
+
+const uint GOB_SIZE_X = 64;
+const uint GOB_SIZE_Y = 8;
+
+const uint GOB_SIZE_X_SHIFT = 6;
+const uint GOB_SIZE_Y_SHIFT = 3;
+const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
+
+const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
+
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
+uint SwizzleOffset(uvec2 pos) {
+    pos = pos & SWIZZLE_MASK;
+    return SwizzleTable(pos.y * 64u + pos.x);
+}
+
+void main() {
+    uvec3 coord = gl_GlobalInvocationID;
+    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
+        return;
+    }
+
+    uvec3 pos = coord + pc.origin;
+    pos.x <<= pc.bytes_per_block_log2;
+
+    uint swizzle = SwizzleOffset(pos.xy);
+    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
+
+    uint offset = 0u;
+    offset += pos.z * pc.layer_stride;
+    offset += (block_y >> pc.block_height) * pc.block_size;
+    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
+    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
+    offset += swizzle;
+
+    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
+    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
+    uint in_idx = linear_index * words;
+    uint out_idx = offset >> 2u;
+
+    for (uint word = 0u; word < words; ++word) {
+        out_u32[out_idx + word] = in_u32[in_idx + word];
+    }
+}

src/video_core/host_shaders/block_linear_unswizzle_2d_buffer.comp

@@ -0,0 +1,104 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 430
+
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_8bit_storage : require
+
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_BUFFER 1
+
+layout(push_constant) uniform PushConstants {
+    uvec3 dim;
+    uint bytes_per_block_log2;
+
+    uvec3 origin;
+    uint layer_stride;
+
+    uint block_size;
+    uint x_shift;
+    uint block_height;
+    uint block_height_mask;
+} pc;
+
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32 { uint u32data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64 { uvec2 u64data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU128 { uvec4 u128data[]; };
+
+layout(binding = BINDING_OUTPUT_BUFFER, std430) writeonly buffer OutputBuffer {
+    uint out_u32[];
+};
+
+layout(local_size_x = 16, local_size_y = 8, local_size_z = 1) in;
+
+const uint GOB_SIZE_X = 64;
+const uint GOB_SIZE_Y = 8;
+
+const uint GOB_SIZE_X_SHIFT = 6;
+const uint GOB_SIZE_Y_SHIFT = 3;
+const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
+
+const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
+
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
+uint SwizzleOffset(uvec2 pos) {
+    pos = pos & SWIZZLE_MASK;
+    return SwizzleTable(pos.y * 64u + pos.x);
+}
+
+uvec4 ReadTexel(uint offset) {
+    switch (pc.bytes_per_block_log2) {
+    case 2u:
+        return uvec4(u32data[offset / 4u], 0u, 0u, 0u);
+    case 3u:
+        return uvec4(u64data[offset / 8u], 0u, 0u);
+    case 4u:
+        return u128data[offset / 16u];
+    }
+    return uvec4(0u);
+}
+
+void main() {
+    uvec3 coord = gl_GlobalInvocationID;
+    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
+        return;
+    }
+
+    uvec3 pos = coord + pc.origin;
+    pos.x <<= pc.bytes_per_block_log2;
+
+    uint swizzle = SwizzleOffset(pos.xy);
+    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
+
+    uint offset = 0u;
+    offset += pos.z * pc.layer_stride;
+    offset += (block_y >> pc.block_height) * pc.block_size;
+    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
+    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
+    offset += swizzle;
+
+    uvec4 texel = ReadTexel(offset);
+
+    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
+    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
+    uint out_idx = linear_index * words;
+
+    out_u32[out_idx] = texel.x;
+    if (words > 1u) {
+        out_u32[out_idx + 1u] = texel.y;
+    }
+    if (words > 2u) {
+        out_u32[out_idx + 2u] = texel.z;
+        out_u32[out_idx + 3u] = texel.w;
+    }
+}

src/video_core/host_shaders/block_linear_unswizzle_3d_buffer.comp

@@ -0,0 +1,105 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#version 430
+
+#define BINDING_INPUT_BUFFER 0
+#define BINDING_OUTPUT_BUFFER 1
+
+layout(push_constant) uniform PushConstants {
+    uvec3 dim;
+    uint bytes_per_block_log2;
+
+    uvec3 origin;
+    uint slice_size;
+
+    uint block_size;
+    uint x_shift;
+    uint block_height;
+    uint block_height_mask;
+
+    uint block_depth;
+    uint block_depth_mask;
+} pc;
+
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU32 { uint u32data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU64 { uvec2 u64data[]; };
+layout(binding = BINDING_INPUT_BUFFER, std430) buffer InputBufferU128 { uvec4 u128data[]; };
+
+layout(binding = BINDING_OUTPUT_BUFFER, std430) writeonly buffer OutputBuffer {
+    uint out_u32[];
+};
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 4) in;
+
+const uint GOB_SIZE_X = 64;
+const uint GOB_SIZE_Y = 8;
+
+const uint GOB_SIZE_X_SHIFT = 6;
+const uint GOB_SIZE_Y_SHIFT = 3;
+const uint GOB_SIZE_SHIFT = GOB_SIZE_X_SHIFT + GOB_SIZE_Y_SHIFT;
+
+const uvec2 SWIZZLE_MASK = uvec2(GOB_SIZE_X - 1u, GOB_SIZE_Y - 1u);
+
+uint SwizzleTable(uint pos) {
+    const uint t[8] = uint[](
+        0x12100200, 0x13110301, 0x16140604, 0x17150705,
+        0x1a180a08, 0x1b190b09, 0x1e1c0e0c, 0x1f1d0f0d
+    );
+    const uint i = pos >> 4;
+    const uint h = (t[i / 4] >> ((i % 4) * 8)) & 0xff;
+    return (h << 4) | (pos & 0xf);
+}
+
+uint SwizzleOffset(uvec2 pos) {
+    pos = pos & SWIZZLE_MASK;
+    return SwizzleTable(pos.y * 64u + pos.x);
+}
+
+uvec4 ReadTexel(uint offset) {
+    switch (pc.bytes_per_block_log2) {
+    case 2u:
+        return uvec4(u32data[offset / 4u], 0u, 0u, 0u);
+    case 3u:
+        return uvec4(u64data[offset / 8u], 0u, 0u);
+    case 4u:
+        return u128data[offset / 16u];
+    }
+    return uvec4(0u);
+}
+
+void main() {
+    uvec3 coord = gl_GlobalInvocationID;
+    if (coord.x >= pc.dim.x || coord.y >= pc.dim.y || coord.z >= pc.dim.z) {
+        return;
+    }
+
+    uvec3 pos = coord + pc.origin;
+    pos.x <<= pc.bytes_per_block_log2;
+
+    uint swizzle = SwizzleOffset(pos.xy);
+    uint block_y = pos.y >> GOB_SIZE_Y_SHIFT;
+
+    uint offset = 0u;
+    offset += (pos.z >> pc.block_depth) * pc.slice_size;
+    offset += (pos.z & pc.block_depth_mask) << (GOB_SIZE_SHIFT + pc.block_height);
+    offset += (block_y >> pc.block_height) * pc.block_size;
+    offset += (block_y & pc.block_height_mask) << GOB_SIZE_SHIFT;
+    offset += (pos.x >> GOB_SIZE_X_SHIFT) << pc.x_shift;
+    offset += swizzle;
+
+    uvec4 texel = ReadTexel(offset);
+
+    uint words = 1u << (pc.bytes_per_block_log2 - 2u);
+    uint linear_index = coord.x + coord.y * pc.dim.x + coord.z * pc.dim.x * pc.dim.y;
+    uint out_idx = linear_index * words;
+
+    out_u32[out_idx] = texel.x;
+    if (words > 1u) {
+        out_u32[out_idx + 1u] = texel.y;
+    }
+    if (words > 2u) {
+        out_u32[out_idx + 2u] = texel.z;
+        out_u32[out_idx + 3u] = texel.w;
+    }
+}

src/video_core/host_shaders/sgsr1_shader_mobile.frag

@@ -6,9 +6,9 @@
 precision highp float;
 precision highp int;
 
-// Operation modes: RGBA -> 1, RGBY -> 3, LERP -> 4
-#define OPERATION_MODE 1
 #define EDGE_THRESHOLD (8.0 / 255.0)
+#define DIRECTION_EPSILON 6.5e-05
+#define DEVIATION_FLOOR 6.0e-02
 
 layout(push_constant) uniform constants {
     vec2 scale;
@@ -21,20 +21,37 @@ layout(set = 0, binding = 0) uniform sampler2D sampler0;
 layout(location=0) in vec2 texcoord;
 layout(location=0) out vec4 frag_color;
 
-vec4 weightY(vec4 dx, vec4 dy, vec4 std) {
-    vec4 x = ((dx * dx) + (dy * dy)) * 0.55f + std;
-    return (x - 1.f) * (x - 4.f) * 3.8125f; // approx. of (x - 1) * (x - 4)^3
+mediump vec4 fastLanczos2(mediump vec4 x) {
+    mediump vec4 wA = x - 4.0f;
+    mediump vec4 wB = x * wA - wA;
+    wA *= wA;
+    return wB * wA;
+}
+
+mediump vec2 edgeDirection(mediump vec4 left, mediump vec4 right) {
+    mediump float RxLz = right.x - left.z;
+    mediump float RwLy = right.w - left.y;
+    mediump vec2 delta = vec2(RxLz + RwLy, RxLz - RwLy);
+    mediump float length_inv =
+        inversesqrt((delta.x * delta.x + DIRECTION_EPSILON) + delta.y * delta.y);
+    return delta * length_inv;
+}
+
+mediump vec4 weightY(mediump vec4 dx, mediump vec4 dy, mediump vec4 c, mediump float std,
+                     mediump vec2 dir) {
+    mediump vec4 edge_dis = dx * dir.y + dy * dir.x;
+    mediump vec4 x = (dx * dx + dy * dy) +
+                     (edge_dis * edge_dis) * (clamp((c * c) * std, 0.0f, 1.0f) * 0.7f - 1.0f);
+    return fastLanczos2(x);
 }
 
 void main() {
-    vec4 color = textureLod(sampler0, texcoord.xy, 0.0f);
-    // image coord
-    vec2 icoord = (texcoord * size + vec2(-0.5f, 0.5f));
-    vec2 icoord_pixel = floor(icoord);
-    vec2 coord = icoord_pixel * scale;
-    vec2 pl = icoord - icoord_pixel;
-    // left: 0, right: 1, upDown: 2
-    mat3x4 dg = mat3x4(
+    mediump vec4 color = textureLod(sampler0, texcoord.xy, 0.0f);
+    highp vec2 icoord = (texcoord * size + vec2(-0.5f, 0.5f));
+    highp vec2 icoord_pixel = floor(icoord);
+    highp vec2 coord = icoord_pixel * scale;
+    mediump vec2 pl = icoord - icoord_pixel;
+    mediump mat3x4 dg = mat3x4(
         textureGather(sampler0, coord, 1),
         textureGather(sampler0, coord + vec2(2.f * scale.x, 0.0f), 1),
         vec4(
@@ -42,42 +59,40 @@ void main() {
             textureGather(sampler0, coord + vec2(scale.x, +scale.y), 1).yx
         )
     );
-    float edgeVote = abs(dg[0].z - dg[0].y) + abs(color.y - dg[0].y) + abs(color.y - dg[0].z);
+    mediump float edgeVote =
+        abs(dg[0].z - dg[0].y) + abs(color.y - dg[0].y) + abs(color.y - dg[0].z);
     if (edgeVote > EDGE_THRESHOLD) {
-        float mean = (dg[0].y + dg[0].z + dg[1].x + dg[1].w) * 0.25f;
+        mediump float mean = (dg[0].y + dg[0].z + dg[1].x + dg[1].w) * 0.25f;
         dg = dg - mean;
-        vec4 sum = abs(dg[0]) + abs(dg[1]) + abs(dg[2]);
-        float std = 2.181818f / (sum.x + sum.y + sum.z + sum.w);
-        mat2x4 w = mat2x4(
-            weightY(
-                pl.xxxx + vec4(+1.0f, +0.0f, +0.0f, +1.0f),
-                pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
-                clamp(abs(dg[0]) * std, 0.0f, 1.0f)
-            ) + weightY(
-                pl.xxxx + vec4(-1.0f, -2.0f, -2.0f, -1.0f),
-                pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
-                clamp(abs(dg[1]) * std, 0.0f, 1.0f)
-            ) + weightY(
-                pl.xxxx + vec4(+0.0f, -1.0f, -1.0f, +0.0f),
-                pl.yyyy + vec4(+1.0f, +1.0f, -2.0f, -2.0f),
-                clamp(abs(dg[2]) * std, 0.0f, 1.0f)
-            ),
-            dg[0] + dg[1] + dg[2]
+        mediump float sum = dot(abs(dg[0]) + abs(dg[1]) + abs(dg[2]), vec4(1.0f));
+        mediump float sum_mean = 1.014185e+01f / max(sum, DEVIATION_FLOOR);
+        mediump float std = sum_mean * sum_mean;
+        mediump vec2 dir = edgeDirection(dg[0], dg[1]);
+        mediump vec4 w0 = weightY(
+            pl.xxxx + vec4(+1.0f, +0.0f, +0.0f, +1.0f),
+            pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
+            dg[0], std, dir
         );
-        // compute final y with bounds
-        vec2 yb = vec2(
-            min(min(dg[0].y, dg[0].z), min(dg[1].x, dg[1].w)), // min
-            max(max(dg[0].y, dg[0].z), max(dg[1].x, dg[1].w))  // max
+        mediump vec4 w1 = weightY(
+            pl.xxxx + vec4(-1.0f, -2.0f, -2.0f, -1.0f),
+            pl.yyyy + vec4(-1.0f, -1.0f, +0.0f, +0.0f),
+            dg[1], std, dir
         );
-        vec2 fvy = vec2(
-            w[0].x + w[0].y + w[0].z + w[0].w,
-            w[1].x + w[1].y + w[1].z + w[1].w
+        mediump vec4 w2 = weightY(
+            pl.xxxx + vec4(+0.0f, -1.0f, -1.0f, +0.0f),
+            pl.yyyy + vec4(+1.0f, +1.0f, -2.0f, -2.0f),
+            dg[2], std, dir
         );
-        float fy = clamp((fvy.y / fvy.x) * edge_sharpness, yb[0], yb[1]);
-        // Smooth high contrast input
-        float dy = clamp(fy - color.y + mean, -23.0f / 255.0f, 23.0f / 255.0f);
+        mediump float sum_w = dot(w0 + w1 + w2, vec4(1.0f));
+        mediump float sum_wc = dot(w0 * dg[0] + w1 * dg[1] + w2 * dg[2], vec4(1.0f));
+        mediump vec2 yb = vec2(
+            min(min(dg[0].y, dg[0].z), min(dg[1].x, dg[1].w)),
+            max(max(dg[0].y, dg[0].z), max(dg[1].x, dg[1].w))
+        );
+        mediump float fy = clamp((sum_wc / sum_w) * edge_sharpness, yb[0], yb[1]);
+        mediump float dy = clamp(fy - color.y + mean, -23.0f / 255.0f, 23.0f / 255.0f);
         color = clamp(color + dy, 0.0f, 1.0f);
     }
-    color.w = 1.0f;  //assume alpha channel is not used
+    color.w = 1.0f;
     frag_color.xyzw = color;
-}
+}

src/video_core/memory_manager.cpp

@@ -529,6 +529,29 @@ size_t MemoryManager::MaxContinuousRange(GPUVAddr gpu_addr, size_t size) const {
     return range_so_far;
 }
 
+size_t MemoryManager::MaxMappedRange(GPUVAddr gpu_addr, size_t size) const {
+    size_t range_so_far = 0;
+    bool stopped{false};
+    auto stop = [&]([[maybe_unused]] std::size_t page_index, [[maybe_unused]] std::size_t offset,
+                    [[maybe_unused]] std::size_t copy_amount) {
+        stopped = true;
+        return true;
+    };
+    auto accumulate = [&]([[maybe_unused]] std::size_t page_index,
+                          [[maybe_unused]] std::size_t offset, std::size_t copy_amount) {
+        range_so_far += copy_amount;
+        return false;
+    };
+    auto check_short_pages = [&](std::size_t page_index, std::size_t offset,
+                                 std::size_t copy_amount) {
+        GPUVAddr base = (page_index << big_page_bits) + offset;
+        MemoryOperation(base, copy_amount, false, accumulate, stop, stop);
+        return stopped;
+    };
+    MemoryOperation(gpu_addr, size, true, accumulate, stop, check_short_pages);
+    return range_so_far;
+}
+
 size_t MemoryManager::GetMemoryLayoutSize(GPUVAddr gpu_addr, size_t max_size) const {
     std::unique_lock<std::mutex> lock(guard);
     return kind_map.GetContinuousSizeFrom(gpu_addr);

src/video_core/memory_manager.h

@@ -141,6 +141,8 @@ public:
 
     size_t MaxContinuousRange(GPUVAddr gpu_addr, size_t size) const;
 
+    size_t MaxMappedRange(GPUVAddr gpu_addr, size_t size) const;
+
     bool IsWithinGPUAddressRange(GPUVAddr gpu_addr) const {
         return gpu_addr < address_space_size;
     }

src/video_core/renderer_opengl/gl_buffer_cache.h

@@ -262,6 +262,7 @@ struct BufferCacheParams {
 
     // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false;
+    static constexpr bool USE_UNIFIED_MEMORY = false;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -238,6 +238,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .has_gl_bool_ref_bug = device.HasBoolRefBug(),
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
+          .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
           .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
           // Use the host limit, but never more than the guest can produce. Maxwell exposes 8 clip
           // distances and the SPIR-V output array is sized for at most 8, so clamping here keeps a