2026-09-07 23:44:53

Signed-off-by: lizzie <lizzie@eden-emu.dev>

CMakeLists.txt

@@ -70,6 +70,26 @@ if (YUZU_STATIC_ROOM)
     set(fmt_FORCE_BUNDLED ON)
 endif()
 
+# my unity/jumbo build
+option(ENABLE_UNITY_BUILD "Enable Unity/Jumbo build" OFF)
+
+# 0 compiles all files in
+# not ideal, but if you're going gung-ho with a unity build, expect failure
+# MSVC physically can't compile that many files into one TU, so we limit it to 100.
+if (MSVC)
+    set(_unity_default 100)
+else()
+    set(_unity_default 0)
+endif()
+
+set(UNITY_BATCH_SIZE ${_unity_default} CACHE STRING "Unity build batch size")
+
+if(MSVC AND ENABLE_UNITY_BUILD)
+    message(STATUS "Unity build")
+    # Unity builds need big objects for MSVC...
+    add_compile_options(/bigobj)
+endif()
+
 # qt stuff
 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT_TRANSLATION "Enable translations for the Qt frontend" OFF)

docs/Options.md

@@ -39,6 +39,7 @@ These options control dependencies.
   - This option is subject for removal.
 - `YUZU_TESTS` (ON) Compile tests - requires Catch2
 - `ENABLE_LTO` (OFF) Enable link-time optimization
+- `ENABLE_UNITY_BUILD` (OFF) Enables "Unity/Jumbo" builds
   - Not recommended on Windows
   - UNIX may be better off appending `-flto=thin` to compiler args
 - `USE_FASTER_LINKER` (OFF) Check if a faster linker is available

src/CMakeLists.txt

@@ -7,6 +7,11 @@
 # Enable modules to include each other's files
 include_directories(.)
 
+if (ENABLE_UNITY_BUILD)
+    set(CMAKE_UNITY_BUILD ON)
+    set(CMAKE_UNITY_BUILD_BATCH_SIZE ${UNITY_BATCH_SIZE})
+endif()
+
 # Dynarmic
 if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64 OR ARCHITECTURE_riscv64 OR ARCHITECTURE_loongarch64) AND NOT YUZU_STATIC_ROOM)
     add_subdirectory(dynarmic)

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

@@ -3,7 +3,7 @@
 
     <!-- General application strings -->
     <string name="app_name" translatable="false">Eden</string>
-    <string name="app_disclaimer">This software will run games for the Nintendo Switch game console. No game titles or keys are included.&lt;br /&gt;&lt;br /&gt;Before you begin, please locate your <![CDATA[<b> prod.keys </b>]]> file on your device storage.&lt;br /&gt;&lt;br /&gt;<![CDATA[<a href=\"https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/user/QuickStart.md\">Learn more</a>]]></string>
+    <string name="app_disclaimer">This software will run games for the Nintendo Switch game console. No game titles or keys are included.&lt;br /&gt;&lt;br /&gt;Before you begin, please locate your <![CDATA[<b> prod.keys </b>]]> file on your device storage.&lt;br /&gt;&lt;br /&gt;<![CDATA[<a href=\"https://yuzu-mirror.github.io/help/quickstart\">Learn more</a>]]></string>
     <string name="notice_notification_channel_name">Notices and errors</string>
     <string name="notice_notification_channel_id" translatable="false">noticesAndErrors</string>
     <string name="notice_notification_channel_description">Shows notifications when something goes wrong.</string>
@@ -933,7 +933,7 @@
     <string name="loader_error_file_not_found">ROM file does not exist</string>
 
     <string name="loader_requires_firmware">Game Requires Firmware</string>
-    <string name="loader_requires_firmware_description"><![CDATA[This game may require firmware to function properly, and you don\'t have any installed. Please install firmware before launching, or press \"OK\" to launch anyways.]]></string>
+    <string name="loader_requires_firmware_description"><![CDATA[The game you are trying to launch requires firmware to boot or to get past the opening menu. Please <a href=\"https://yuzu-mirror.github.io/help/quickstart\"> dump and install firmware</a>, or press \"OK\" to launch anyways.]]></string>
 
     <!-- Intent Launch strings -->
     <string name="searching_for_game">Searching for game...</string>

src/audio_core/adsp/apps/opus/opus_decode_object.cpp

@@ -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
 
@@ -5,17 +8,11 @@
 #include "common/assert.h"
 
 namespace AudioCore::ADSP::OpusDecoder {
-namespace {
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-} // namespace
 
 u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
-    if (!IsValidChannelCount(channel_count)) {
+    if (channel_count == 1 || channel_count == 2)
         return 0;
-    }
-    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
+    return u32(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
 }
 
 OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {

src/audio_core/adsp/apps/opus/opus_decoder.cpp

@@ -22,10 +22,6 @@ namespace AudioCore::ADSP::OpusDecoder {
 namespace {
 constexpr size_t OpusStreamCountMax = 255;
 
-bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
-}
-
 bool IsValidMultiStreamChannelCount(u32 channel_count) {
     return channel_count <= OpusStreamCountMax;
 }

src/audio_core/in/audio_in.cpp

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

src/audio_core/in/audio_in_system.cpp

@@ -16,6 +16,21 @@
 
 namespace AudioCore::AudioIn {
 
+// See texture_cache/util.h
+template<typename T, size_t N>
+#if BOOST_VERSION >= 108100 || __GNUC__ > 12
+[[nodiscard]] static inline boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+    return v;
+}
+#else
+[[nodiscard]] static inline std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+    std::vector<T> u;
+    for (auto const& e : v)
+        u.push_back(e);
+    return u;
+}
+#endif
+
 System::System(Core::System& system_, Kernel::KEvent* event_, const size_t session_id_)
     : system{system_}, buffer_event{event_},
       session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}
@@ -95,7 +110,7 @@ Result System::Start() {
 
     boost::container::static_vector<AudioBuffer, BufferCount> buffers_to_flush{};
     buffers.RegisterBuffers(buffers_to_flush);
-    session->AppendBuffers(buffers_to_flush);
+    session->AppendBuffers(FixStaticVectorADL(buffers_to_flush));
     session->SetRingSize(static_cast<u32>(buffers_to_flush.size()));
 
     return ResultSuccess;
@@ -140,7 +155,7 @@ void System::RegisterBuffers() {
     if (state == State::Started) {
         boost::container::static_vector<AudioBuffer, BufferCount> registered_buffers{};
         buffers.RegisterBuffers(registered_buffers);
-        session->AppendBuffers(registered_buffers);
+        session->AppendBuffers(FixStaticVectorADL(registered_buffers));
     }
 }
 

src/audio_core/out/audio_out_system.cpp

@@ -14,14 +14,15 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"
 
+namespace AudioCore::AudioOut {
 // See texture_cache/util.h
 template<typename T, size_t N>
 #if BOOST_VERSION >= 108100 || __GNUC__ > 12
-[[nodiscard]] boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+[[nodiscard]] static inline boost::container::static_vector<T, N> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
     return v;
 }
 #else
-[[nodiscard]] std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
+[[nodiscard]] static inline std::vector<T> FixStaticVectorADL(const boost::container::static_vector<T, N>& v) {
     std::vector<T> u;
     for (auto const& e : v)
         u.push_back(e);
@@ -29,8 +30,6 @@ template<typename T, size_t N>
 }
 #endif
 
-namespace AudioCore::AudioOut {
-
 System::System(Core::System& system_, Kernel::KEvent* event_, size_t session_id_)
     : system{system_}, buffer_event{event_},
       session_id{session_id_}, session{std::make_unique<DeviceSession>(system_)} {}

src/audio_core/renderer/command/effect/capture.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -16,7 +16,7 @@ namespace AudioCore::Renderer {
  * @param memory   - Core memory for writing.
  * @param aux_info - Memory address pointing to the AuxInfo to reset.
  */
-static void ResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_info) {
+static void CaptureResetAuxBufferDsp(Core::Memory::Memory& memory, const CpuAddr aux_info) {
     if (aux_info == 0) {
         LOG_ERROR(Service_Audio, "Aux info is 0!");
         return;
@@ -134,7 +134,7 @@ void CaptureCommand::Process(const AudioRenderer::CommandListProcessor& processo
         WriteAuxBufferDsp(*processor.memory, send_buffer_info, send_buffer, count_max, input_buffer,
                           processor.sample_count, write_offset, update_count);
     } else {
-        ResetAuxBufferDsp(*processor.memory, send_buffer_info);
+        CaptureResetAuxBufferDsp(*processor.memory, send_buffer_info);
     }
 }
 

src/common/CMakeLists.txt

@@ -89,6 +89,7 @@ add_library(
     param_package.h
     parent_of_member.h
     point.h
+    quaternion.h
     range_map.h
     range_mutex.h
     range_sets.h
@@ -108,8 +109,6 @@ add_library(
     settings_setting.h
     slot_vector.h
     socket_types.h
-    sparse_large_vector.cpp
-    sparse_large_vector.h
     spin_lock.h
     stb.cpp
     stb.h
@@ -139,6 +138,8 @@ add_library(
     uuid.cpp
     uuid.h
     vector_math.h
+    virtual_buffer.cpp
+    virtual_buffer.h
     zstd_compression.cpp
     zstd_compression.h
     fs/ryujinx_compat.h fs/ryujinx_compat.cpp

src/common/cityhash.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2011 Google, Inc.
 // SPDX-FileContributor: Geoff Pike
 // SPDX-FileContributor: Jyrki Alakuijala
@@ -27,8 +30,6 @@
 #define WORDS_BIGENDIAN 1
 #endif
 
-using namespace std;
-
 namespace Common {
 
 static u64 unaligned_load64(const char* p) {
@@ -135,18 +136,18 @@ static u64 HashLen17to32(const char* s, size_t len) {
 
 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
-static pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a, u64 b) {
+static std::pair<u64, u64> WeakHashLen32WithSeeds(u64 w, u64 x, u64 y, u64 z, u64 a, u64 b) {
     a += w;
     b = Rotate(b + a + z, 21);
     u64 c = a;
     a += x;
     a += y;
     b += Rotate(a, 44);
-    return make_pair(a + z, b + c);
+    return std::make_pair(a + z, b + c);
 }
 
 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
-static pair<u64, u64> WeakHashLen32WithSeeds(const char* s, u64 a, u64 b) {
+static std::pair<u64, u64> WeakHashLen32WithSeeds(const char* s, u64 a, u64 b) {
     return WeakHashLen32WithSeeds(Fetch64(s), Fetch64(s + 8), Fetch64(s + 16), Fetch64(s + 24), a,
                                   b);
 }
@@ -189,8 +190,8 @@ u64 CityHash64(const char* s, size_t len) {
     u64 x = Fetch64(s + len - 40);
     u64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
     u64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-    pair<u64, u64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-    pair<u64, u64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
+    std::pair<u64, u64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
+    std::pair<u64, u64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
     x = x * k1 + Fetch64(s);
 
     // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
@@ -258,7 +259,7 @@ u128 CityHash128WithSeed(const char* s, size_t len, u128 seed) {
 
     // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
     // v, w, x, y, and z.
-    pair<u64, u64> v, w;
+    std::pair<u64, u64> v, w;
     u64 x = seed[0];
     u64 y = seed[1];
     u64 z = len * k1;

src/common/fiber.cpp

@@ -9,6 +9,7 @@
 
 #include "common/assert.h"
 #include "common/fiber.h"
+#include "common/virtual_buffer.h"
 
 #include <boost/context/detail/fcontext.hpp>
 

src/common/host_memory.cpp

@@ -117,6 +117,7 @@ template <typename T>
 static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn) {
     if (!dll.GetSymbol(name, &pfn)) {
         LOG_CRITICAL(HW_Memory, "Failed to load {}", name);
+        throw std::bad_alloc{};
     }
 }
 
@@ -178,14 +179,6 @@ public:
         Release();
     }
 
-    void* Allocate(size_t size) {
-        auto* ptr = VirtualAlloc(nullptr, size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
-        if (ptr == nullptr) {
-            LOG_CRITICAL(HW_Memory, "Failed to allocate fallback buffer with size {:#x}, error {}", size, GetLastError());
-        }
-        return ptr;
-    }
-
     void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms) {
         std::unique_lock lock{placeholder_mutex};
         if (!IsNiechePlaceholder(virtual_offset, length)) {
@@ -406,10 +399,6 @@ private:
 // For managarm: see https://github.com/managarm/managarm/issues/1370
 #else // ^^^ Windows ^^^ vvv POSIX vvv
 
-#ifndef MAP_NOCORE
-#define MAP_NOCORE 0
-#endif
-
 #ifdef ARCHITECTURE_arm64
 
 static void* ChooseVirtualBase(size_t virtual_size) {
@@ -434,7 +423,7 @@ static void* ChooseVirtualBase(size_t virtual_size) {
         // Note: we may be able to take advantage of MAP_FIXED_NOREPLACE here.
         void* map_pointer =
             mmap(reinterpret_cast<void*>(hint_address), virtual_size, PROT_READ | PROT_WRITE,
-                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_NOCORE, -1, 0);
+                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 
         // If we successfully mapped, we're done.
         if (reinterpret_cast<uintptr_t>(map_pointer) == hint_address) {
@@ -454,11 +443,11 @@ static void* ChooseVirtualBase(size_t virtual_size) {
 
 static void* ChooseVirtualBase(size_t virtual_size) {
 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__managarm__) || defined(__AIX__)
-    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER | MAP_NOCORE, -1, 0);
+    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
     if (virtual_base != MAP_FAILED)
         return virtual_base;
 #endif
-    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_NOCORE, -1, 0);
+    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }
 
 #endif
@@ -552,13 +541,13 @@ public:
         }
         if (use_anon) {
             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));
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
             if (fd > 0) {
                 fd = -1;
                 close(fd);
             }
         } else {
-            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, fd, 0));
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -582,14 +571,6 @@ public:
         Release();
     }
 
-    void* Allocate(size_t size) {
-        auto* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
-        if (ptr == MAP_FAILED) {
-            LOG_CRITICAL(HW_Memory, "Failed to allocate fallback buffer with size {:#x}, {}", size, strerror(errno));
-        }
-        return ptr;
-    }
-
     void Map(size_t virtual_offset, size_t host_offset, size_t length, MemoryPermission perms) {
         // Intersect the range with our address space.
         AdjustMap(&virtual_offset, &length);
@@ -710,10 +691,12 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
 {
 #if defined(__OPENORBIS__) || defined(__managarm__)
     LOG_WARNING(HW_Memory, "Platform doesn't support fastmem");
-    backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+    fallback_buffer.emplace(backing_size);
+    backing_base = fallback_buffer->data();
     virtual_base = nullptr;
 #else
     // Try to allocate a fastmem arena.
+    // The implementation will fail with std::bad_alloc on errors.
     impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
     if (impl->Init()) {
         backing_base = impl->backing_base;
@@ -724,26 +707,16 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
             virtual_base_offset = virtual_base - impl->virtual_base;
         }
     } else {
-        LOG_WARNING(HW_Memory, "Platform can support fastmem, but can't create it");
-        fallback_buffer = true;
-        backing_base = static_cast<u8*>(impl->Allocate(backing_size));
-        virtual_base = nullptr;
         impl.reset();
+        LOG_WARNING(HW_Memory, "Platform can support fastmem, but can't create it");
+        fallback_buffer.emplace(backing_size);
+        backing_base = fallback_buffer->data();
+        virtual_base = nullptr;
     }
 #endif
 }
 
-HostMemory::~HostMemory() {
-#ifdef _WIN32
-    if (fallback_buffer) {
-        VirtualFree(backing_base, backing_size, MEM_RELEASE);
-    }
-#else
-    if (fallback_buffer) {
-        munmap(backing_base, backing_size);
-    }
-#endif
-}
+HostMemory::~HostMemory() = default;
 
 HostMemory::HostMemory(HostMemory&&) noexcept = default;
 

src/common/host_memory.h

@@ -10,6 +10,7 @@
 #include <optional>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
+#include "common/virtual_buffer.h"
 
 namespace Common {
 
@@ -85,7 +86,7 @@ private:
     u8* virtual_base{};
     size_t virtual_base_offset{};
     // Windows requires it for kernels whom lack proper support for some functions!
-    bool fallback_buffer{false};
+    std::optional<Common::VirtualBuffer<u8>> fallback_buffer;
 };
 
 } // namespace Common

src/common/httplib.h

@@ -16,3 +16,5 @@
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
 #endif
+
+#undef INVALID_SOCKET

src/common/page_table.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -13,11 +13,39 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_bits) {
-    auto const num_page_table_entries = 1ULL << (address_space_width_in_bits - page_bits);
-    entries.ResizeAndClear(num_page_table_entries);
+bool PageTable::BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_context,
+                               Common::ProcessAddress address) const {
+    out_context->next_offset = GetInteger(address);
+    out_context->next_page = address / page_size;
+
+    return this->ContinueTraversal(out_entry, out_context);
+}
+
+bool PageTable::ContinueTraversal(TraversalEntry* out_entry, TraversalContext* context) const {
+    // Setup invalid defaults.
+    out_entry->phys_addr = 0;
+    out_entry->block_size = page_size;
+    // Validate that we can read the actual entry.
+    if (auto const page = context->next_page; page < entries.size()) {
+        // Validate that the entry is mapped.
+        if (auto const paddr = entries[page].addr; paddr != 0) {
+            // Populate the results.
+            out_entry->phys_addr = paddr + context->next_offset;
+            context->next_page += 1;
+            context->next_offset += page_size;
+            return true;
+        }
+    }
+    context->next_page += 1;
+    context->next_offset += page_size;
+    return false;
+}
+
+void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits) {
+    auto const num_page_table_entries = 1ULL << (address_space_width_in_bits - page_size_in_bits);
+    entries.resize(num_page_table_entries);
     current_address_space_width_in_bits = address_space_width_in_bits;
-    current_page_bits = page_bits;
+    page_size = 1ULL << page_size_in_bits;
 }
 
 } // namespace Common

src/common/page_table.h

@@ -9,22 +9,22 @@
 #include <atomic>
 
 #include "common/common_types.h"
-#include "common/sparse_large_vector.h"
 #include "common/typed_address.h"
+#include "common/virtual_buffer.h"
 
 namespace Common {
 
 enum class PageType : u8 {
     /// Page is unmapped and should cause an access error.
-    Unmapped = 0b00,
+    Unmapped,
     /// Page is mapped to regular memory. This is the only type you can get pointers to.
-    Memory = 0b01,
+    Memory,
     /// Page is mapped to regular memory, but inaccessible from CPU fastmem and must use
     /// the callbacks.
-    DebugMemory = 0b10,
+    DebugMemory,
     /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
     /// invalidation
-    RasterizerCachedMemory = 0b11,
+    RasterizerCachedMemory,
 };
 
 /**
@@ -42,86 +42,57 @@ struct PageTable {
         u64 next_offset{};
     };
 
-    /// Masks out bits reserved for attribute tagging.
-    static constexpr u64 ATTRIBUTE_MASK = ((1ULL << 44) - 1) << 12;
-
-    /// Specifies sign bit for page table entries.
-    static constexpr u64 SIGN_BIT = 45 + 12; // 44 bits of data + page offset
+    /// Number of bits reserved for attribute tagging.
+    /// This can be at most the guaranteed alignment of the pointers in the page table.
+    static constexpr int ATTRIBUTE_BITS = 2;
 
     /**
-     * Atomic tuple of host pointer, page type, and block id.
-     * This uses the lower bits of a given pointer to store the attributes.
+     * Pair of host pointer and page type attribute.
+     * This uses the lower bits of a given pointer to store the attribute tag.
      * Writing and reading the pointer attribute pair is guaranteed to be atomic for the same method
      * call. In other words, they are guaranteed to be synchronized at all times.
      */
-    class PageEntryData {
+    class PageInfo {
     public:
-        struct Data {
-            Data(bool marked_, PageType type_, u16 block_, u64 page_)
-                : marked(static_cast<u64>(marked_)       & 0b1)
-                , type(static_cast<u64>(type_)           & ((1ULL << 2) - 1))
-                , block(static_cast<u64>(block_)         & ((1ULL << 9) - 1))
-                , page((page_ >> 12)                     & ((1ULL << 45) - 1))
-                , block2((static_cast<u64>(block_) >> 9) & ((1ULL << 7) - 1)) {}
-            u64 marked : 1;
-            u64 type   : 2;
-            u64 block  : 9;
-            u64 page   : 45; // 44 bits of actual data (64 - page offset (12) - reserved (8)) + a sign bit
-            u64 block2 : 7;
-        };
-
-        [[nodiscard]] Data Raw() const noexcept {
-            return std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed));
-        }
-
         /// Returns the page pointer
-        [[nodiscard]] uintptr_t Pointer(bool ignored_marked = false) const noexcept {
-            return ExtractPointer(std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed)), ignored_marked);
+        [[nodiscard]] uintptr_t Pointer() const noexcept {
+            return ExtractPointer(raw.load(std::memory_order_relaxed));
         }
 
         /// Returns the page type attribute
         [[nodiscard]] PageType Type() const noexcept {
-            return static_cast<PageType>(std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed)).type);
-        }
-
-        /// Returns the block identifier.
-        [[nodiscard]] u16 Block() const noexcept {
-            return ExtractBlock(std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed)));
+            return ExtractType(raw.load(std::memory_order_relaxed));
         }
 
         /// Returns the page pointer and attribute pair, extracted from the same atomic read
-        [[nodiscard]] std::tuple<uintptr_t, PageType, u16> PointerTypeBlock(bool ignore_marked = false) const noexcept {
-            const auto non_atomic_raw = std::bit_cast<Data>(data_raw.load(std::memory_order_relaxed));
-            return {ExtractPointer(non_atomic_raw, ignore_marked), static_cast<PageType>(non_atomic_raw.type), ExtractBlock(non_atomic_raw)};
+        [[nodiscard]] std::pair<uintptr_t, PageType> PointerType() const noexcept {
+            const uintptr_t non_atomic_raw = raw.load(std::memory_order_relaxed);
+            return {ExtractPointer(non_atomic_raw), ExtractType(non_atomic_raw)};
         }
 
-        /// Write page info atomically
-        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}));
+        /// Returns the raw representation of the page information.
+        /// Use ExtractPointer and ExtractType to unpack the value.
+        [[nodiscard]] uintptr_t Raw() const noexcept {
+            return raw.load(std::memory_order_relaxed);
         }
 
-        constexpr void MarkRasterizerCached() noexcept {
-            data_raw.fetch_or(0b111);
-        }
-
-        constexpr void MarkDebug(u64 ptr, u16 block) noexcept {
-            Store(true, PageType::DebugMemory, block, ptr);
+        /// Write a page pointer and type pair atomically
+        void Store(uintptr_t pointer, PageType type) noexcept {
+            raw.store(pointer | uintptr_t(type));
         }
 
         /// Unpack a pointer from a page info raw representation
-        [[nodiscard]] static uintptr_t ExtractPointer(Data raw, bool ignore_marked = false) noexcept {
-            return raw.marked && !ignore_marked ? 0
-                // shift raw.page's fake sign bit to the actual sign bit, then sign extend
-                : ((s64)(raw.page << (64 - 44))) >> (64 - 44 - 12);
+        [[nodiscard]] static uintptr_t ExtractPointer(uintptr_t raw) noexcept {
+            return raw & (~uintptr_t{0} << ATTRIBUTE_BITS);
         }
 
-        [[nodiscard]] static u16 ExtractBlock(Data raw) noexcept {
-            return static_cast<u16>(raw.block | (raw.block2 << 9));
+        /// Unpack a page type from a page info raw representation
+        [[nodiscard]] static PageType ExtractType(uintptr_t raw) noexcept {
+            return static_cast<PageType>(raw & ((uintptr_t{1} << ATTRIBUTE_BITS) - 1));
         }
 
     private:
-        std::atomic<u64> data_raw;
-        static_assert(sizeof(Data) == sizeof(std::atomic<u64>));
+        std::atomic<uintptr_t> raw;
     };
 
     PageTable();
@@ -129,8 +100,13 @@ struct PageTable {
 
     PageTable(const PageTable&) = delete;
     PageTable& operator=(const PageTable&) = delete;
-    PageTable(PageTable&&) noexcept = delete;
-    PageTable& operator=(PageTable&&) noexcept = delete;
+
+    PageTable(PageTable&&) noexcept = default;
+    PageTable& operator=(PageTable&&) noexcept = default;
+
+    bool BeginTraversal(TraversalEntry* out_entry, TraversalContext* out_context,
+                        Common::ProcessAddress address) const;
+    bool ContinueTraversal(TraversalEntry* out_entry, TraversalContext* context) const;
 
     /**
      * Resizes the page table to be able to accommodate enough pages within
@@ -145,14 +121,30 @@ struct PageTable {
         return current_address_space_width_in_bits;
     }
 
+    bool GetPhysicalAddress(Common::PhysicalAddress* out_phys_addr,
+                            Common::ProcessAddress virt_addr) const {
+        if (virt_addr > (1ULL << this->GetAddressSpaceBits())) {
+            return false;
+        }
+
+        *out_phys_addr = entries[virt_addr / page_size].addr + GetInteger(virt_addr);
+        return true;
+    }
+
     /// Vector of memory pointers backing each page. An entry can only be non-null if the
     /// corresponding attribute element is of type `Memory`.
-    SparseLargeVector<PageEntryData> entries;
-    static_assert(sizeof(PageEntryData) == 8);
+    struct PageEntryData {
+        PageInfo ptr;
+        u64 block;
+        u64 addr;
+        u64 padding;
+    };
+    VirtualBuffer<PageEntryData> entries;
+    static_assert(sizeof(PageEntryData) == 32);
 
     u8* fastmem_arena{};
     std::size_t current_address_space_width_in_bits{};
-    std::size_t current_page_bits{};
+    std::size_t page_size{};
 };
 
 } // namespace Common

src/common/quaternion.h

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2016 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/vector_math.h"
+
+namespace Common {
+
+template <typename T>
+class Quaternion {
+public:
+    Vec3<T> xyz;
+    T w{};
+
+    [[nodiscard]] Quaternion<decltype(-T{})> Inverse() const {
+        return {-xyz, w};
+    }
+
+    [[nodiscard]] Quaternion<decltype(T{} + T{})> operator+(const Quaternion& other) const {
+        return {xyz + other.xyz, w + other.w};
+    }
+
+    [[nodiscard]] Quaternion<decltype(T{} - T{})> operator-(const Quaternion& other) const {
+        return {xyz - other.xyz, w - other.w};
+    }
+
+    [[nodiscard]] Quaternion<decltype(T{} * T{} - T{} * T{})> operator*(
+        const Quaternion& other) const {
+        return {xyz * other.w + other.xyz * w + Cross(xyz, other.xyz),
+                w * other.w - Dot(xyz, other.xyz)};
+    }
+
+    [[nodiscard]] Quaternion<T> Normalized() const {
+        T length = std::sqrt(xyz.Length2() + w * w);
+        return {xyz / length, w / length};
+    }
+
+    [[nodiscard]] std::array<decltype(-T{}), 16> ToMatrix() const {
+        const T x2 = xyz[0] * xyz[0];
+        const T y2 = xyz[1] * xyz[1];
+        const T z2 = xyz[2] * xyz[2];
+
+        const T xy = xyz[0] * xyz[1];
+        const T wz = w * xyz[2];
+        const T xz = xyz[0] * xyz[2];
+        const T wy = w * xyz[1];
+        const T yz = xyz[1] * xyz[2];
+        const T wx = w * xyz[0];
+
+        return {1.0f - 2.0f * (y2 + z2),
+                2.0f * (xy + wz),
+                2.0f * (xz - wy),
+                0.0f,
+                2.0f * (xy - wz),
+                1.0f - 2.0f * (x2 + z2),
+                2.0f * (yz + wx),
+                0.0f,
+                2.0f * (xz + wy),
+                2.0f * (yz - wx),
+                1.0f - 2.0f * (x2 + y2),
+                0.0f,
+                0.0f,
+                0.0f,
+                0.0f,
+                1.0f};
+    }
+};
+
+template <typename T>
+[[nodiscard]] auto QuaternionRotate(const Quaternion<T>& q, const Vec3<T>& v) {
+    return v + 2 * Cross(q.xyz, Cross(q.xyz, v) + v * q.w);
+}
+
+[[nodiscard]] inline Quaternion<float> MakeQuaternion(const Vec3<float>& axis, float angle) {
+    return {axis * std::sin(angle / 2), std::cos(angle / 2)};
+}
+
+} // namespace Common

src/common/settings.h

@@ -858,7 +858,7 @@ struct Values {
     SwitchableSetting<std::string> program_args{linkage,
                                                 std::string(),
                                                 "program_args",
-                                                Category::Debugging,
+                                                Category::System,
                                                 Specialization::Default,
                                                 true,    // save_ - persist in config file
                                                 false};  // runtime_modifiable_ - startup-only
@@ -904,7 +904,7 @@ struct Values {
                                            0,
                                            65535,
                                            "debug_knobs",
-                                           Category::Debugging,
+                                           Category::System,
                                            Specialization::Countable,
                                            true,
                                            true};

src/common/sparse_large_vector.cpp

@@ -1,143 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-/* virtual_buffer.cpp */
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#ifdef _WIN32
-#include <windows.h>
-#include <mutex>
-#else
-#include <sys/mman.h>
-#endif
-
-#include "common/alignment.h"
-#include "common/assert.h"
-#include "common/sparse_large_vector.h"
-
-namespace Common {
-
-#ifdef _WIN32
-static std::vector<std::pair<u64, u64>> vector_regions {};
-
-// Workaround for handling non-commited memory accessed by Dynarmic; usually result of an error
-static LONG WINAPI FakePageFaultHandler(PEXCEPTION_POINTERS info) {
-    DWORD code = info->ExceptionRecord->ExceptionCode;
-    u64 exception_addr = reinterpret_cast<u64>(info->ExceptionRecord->ExceptionAddress);
-
-    if (code != EXCEPTION_ACCESS_VIOLATION) {
-        // Not our problem
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    u64 addr = 0, addr2 = 0;
-
-    for (auto region: vector_regions) {
-        auto addr_shifted = exception_addr >> HostPageBits;
-        if (region.first <= addr_shifted && addr_shifted <= region.second) {
-            addr = addr_shifted;
-        }
-
-        // Page-boundary accesses
-        if (auto addr_ = (exception_addr + 0x40) >> HostPageBits; addr_ != addr_shifted && region.first <= addr_ && addr_ <= region.second) {
-            addr2 = addr_;
-        }
-
-        if (addr != 0 || addr2 != 0) {
-            break;
-        }
-    }
-
-    if (addr == 0 && addr2 == 0) {
-        // Not our problem
-        return EXCEPTION_CONTINUE_SEARCH;
-    }
-
-    LOG_ERROR(HW_Memory, "Accessing an unallocated region of a SparseLargeVector at {:#x}; this shouldn't happen and is likely a Dynarmic error!", exception_addr);
-
-    // Commit this region
-    if (addr != 0) {
-        if (!CommitVectorPage(addr << HostPageBits, false)) {
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
-    }
-    // Commit next region if needed
-    if (addr2 != 0) {
-        if (!CommitVectorPage(addr2 << HostPageBits, false)) {
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
-    }
-
-    return EXCEPTION_CONTINUE_EXECUTION;
-}
-
-bool CommitVectorPage(uintptr_t addr, bool write) noexcept {
-    MEMORY_BASIC_INFORMATION info {};
-    auto res = VirtualQuery(reinterpret_cast<void*>(addr), &info, sizeof(info));
-    if (res == 0) {
-        LOG_CRITICAL(HW_Memory, "Failed to query large buffer region at {:#x} with error {}, will try committing anyway", addr, GetLastError());
-    } else if (info.State != MEM_RESERVE) {
-        LOG_ERROR(HW_Memory, "Tried to commit an unreserved large buffer region at {:#x} that is not mapped or is already committed (state {:#x})", addr, info.State);
-        return false;
-    }
-
-    auto perm = write ? PAGE_READWRITE : PAGE_READONLY;
-    void* res2 = VirtualAlloc(reinterpret_cast<LPVOID>(addr), HostPageSize, MEM_COMMIT, perm);
-    if (res2 == nullptr) {
-        LOG_ERROR(HW_Memory, "Failed to commit large buffer region at {:#x}, error {}", addr, GetLastError());
-        return false;
-    }
-
-    return true;
-}
-#endif
-
-#ifndef MAP_NOCORE
-#define MAP_NOCORE 0
-#endif
-
-void* AllocateMemoryPages(std::size_t size) noexcept {
-    if (auto page = HostPageSize; size % page != 0) {
-        LOG_WARNING(HW_Memory, "Allocating unaligned large vector with size {:#x}; aligning to {} page size", size, page);
-        size = AlignUp(size, page);
-    }
-
-#ifdef _WIN32
-    // We will never use this memory entirely so instead of committing it up front let's just reserve it and commit each page individually
-    void* base = VirtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
-
-    if (base != nullptr) {
-        vector_regions.emplace_back(reinterpret_cast<u64>(base), reinterpret_cast<u64>(base) + size);
-
-        static std::once_flag flag;
-        std::call_once(flag, []() { AddVectoredExceptionHandler(1, FakePageFaultHandler); });
-    } else {
-        // Try committing everything instead??
-        LOG_WARNING(HW_Memory, "Failed to reserve large vector region with error {}, trying to commit instead..", GetLastError());
-        base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
-    }
-    ASSERT_MSG(base, "Failed to reserve {:#x} sized region with error {}", size, GetLastError());
-#else
-    void* base = mmap(nullptr, size, PROT_READ, MAP_ANON | MAP_PRIVATE | MAP_NOCORE, -1, 0);
-    if (base == MAP_FAILED)
-        base = nullptr;
-    ASSERT_MSG(base, "Failed to allocate {:#x} sized region with error {}", size, strerror(errno));
-#endif
-    return base;
-}
-
-void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
-    if (auto page = HostPageSize; size % page != 0) {
-        size = AlignUp(size, page);
-    }
-    if (!base)
-        return;
-#ifdef _WIN32
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
-#else
-    ASSERT(munmap(base, size) == 0);
-#endif
-}
-
-} // namespace Common

src/common/sparse_large_vector.h

@@ -1,194 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-/* virtual_buffer.h */
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <bit>
-#include <utility>
-#include <vector>
-
-#ifndef _WIN32
-#include <unistd.h>
-#include <sys/mman.h>
-#endif
-
-#include "common/alignment.h"
-#include "common/assert.h"
-
-namespace Common {
-
-#ifdef _WIN32
-constexpr u64 HostPageSize = 0x1000;
-constexpr u64 HostPageBits = 12;
-constexpr u64 HostPageMask = ~(HostPageSize - 1);
-bool CommitVectorPage(uintptr_t addr, bool write) noexcept;
-#else
-const u64 HostPageSize = sysconf(_SC_PAGESIZE);
-const u64 HostPageBits = std::countr_zero(HostPageSize);
-const u64 HostPageMask = ~(HostPageSize - 1);
-#endif
-
-void* AllocateMemoryPages(std::size_t size) noexcept;
-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>
-requires std::is_trivially_copyable_v<T>
-class SparseLargeVector final {
-public:
-    constexpr SparseLargeVector() = default;
-
-    explicit SparseLargeVector(std::size_t count) noexcept
-        : alloc_size{count * sizeof(T)}
-    {
-        base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-
-        // each item in vector holds information for 64 pages
-        auto denom = HostPageSize * 64;
-        committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
-    }
-
-    ~SparseLargeVector() noexcept {
-        FreeMemoryPages(base_ptr, alloc_size);
-    }
-
-    SparseLargeVector(const SparseLargeVector&) = delete;
-    SparseLargeVector& operator=(const SparseLargeVector&) = delete;
-    SparseLargeVector(SparseLargeVector&& other) = delete;
-    SparseLargeVector& operator=(SparseLargeVector&& other) = delete;
-
-    void ResizeAndClear(std::size_t count) noexcept {
-        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
-            FreeMemoryPages(base_ptr, alloc_size);
-            alloc_size = new_size;
-            base_ptr = static_cast<T*>(AllocateMemoryPages(alloc_size));
-
-            auto denom = HostPageSize * 64;
-            committed_pages = std::vector<std::atomic<u64>>((alloc_size + denom - 1) / denom);
-        }
-    }
-
-    /// Returns a reference to the value of the requested index and allocates memory if needed.
-    T& GetAndFault(std::size_t index) noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            UNREACHABLE_MSG("Out of bounds RW access on SparseLargeVector @ {}", index);
-        }
-
-        if (!IsCommittedPage(index)) {
-            CommitPage(index);
-        }
-        return base_ptr[index];
-    }
-
-    /// Returns a reference to the value of the requested index if initialized, or will otherwise return a zero-initialized object.
-    const T& GetOrDefault(std::size_t index) const {
-#ifdef _WIN32
-        if (!IsCommittedPage(index)) {
-            return *reinterpret_cast<const T*>(&default_val);
-        }
-#endif
-        // On non-Windows, OS page table should optimize this by pointing to a zero page if unallocated.
-        return base_ptr[index];
-    }
-
-    void Set(std::size_t index, const T& value) noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "Out of bounds write on SparseLargeVector @ {}", index);
-            return;
-        }
-        if (!IsCommittedPage(index))
-            CommitPage(index);
-        base_ptr[index] = value;
-    }
-
-    void ZeroRegion(std::size_t start, std::size_t end_) noexcept {
-        u64 base = reinterpret_cast<u64>(&base_ptr[start]);
-        const u64 end = reinterpret_cast<u64>(&base_ptr[end_]);
-
-        const u64 end_page = AlignUp(base, HostPageSize);
-        const u64 first_size = (std::min)(end_page, end) - base;
-
-        if (IsCommittedPage(start / sizeof(T))) {
-            std::memset(reinterpret_cast<void*>(base), 0, first_size);
-        }
-
-        if (end <= end_page)
-            return;
-
-        base = end_page;
-
-        for (u64 page = base; page < end; page += HostPageSize) {
-            if (!IsCommittedPage((page - reinterpret_cast<u64>(base_ptr)) / sizeof(T))) {
-                continue;
-            }
-
-            std::memset(reinterpret_cast<void*>(page), 0, (std::min)( HostPageSize, end - page));
-        }
-    }
-
-    constexpr void CommitRegion(size_t index, size_t end_) {
-        const u64 base = static_cast<u64>(index) * sizeof(T);
-        const u64 end = static_cast<u64>(end_) * sizeof(T);
-
-        for (u64 page = AlignDown(base, HostPageSize); page < end; page += HostPageSize) {
-            if (!IsCommittedPage(page / sizeof(T))) {
-                CommitPage(page / sizeof(T));
-            }
-        }
-    }
-
-    constexpr T& GetUnchecked(size_t index) {
-        return base_ptr[index];
-    }
-
-    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
-        return GetOrDefault(index);
-    }
-
-    [[nodiscard]] constexpr const T* data() const noexcept {
-        return base_ptr;
-    }
-
-    [[nodiscard]] constexpr std::size_t size() const noexcept {
-        return alloc_size / sizeof(T);
-    }
-
-private:
-    [[nodiscard]] constexpr bool IsCommittedPage(std::size_t index) const noexcept {
-        if (index > alloc_size / sizeof(T)) {
-            LOG_CRITICAL(Common_Memory, "Out of bounds access on large vector @ {}", index);
-            return false;
-        }
-
-        auto page = (index * sizeof(T)) >> HostPageBits;
-        auto val = committed_pages[page >> 6].load(std::memory_order_acquire);
-        return (val >> (page & 63)) & 1;
-    }
-
-    constexpr void CommitPage(std::size_t index) noexcept {
-        auto page_index = (index * sizeof(T)) >> HostPageBits;
-        auto page = reinterpret_cast<uintptr_t>(base_ptr + index) & HostPageMask;
-#if defined(_WIN32)
-        CommitVectorPage(page, true);
-#else
-        mprotect(reinterpret_cast<void*>(page), HostPageSize, PROT_READ | PROT_WRITE);
-#endif
-
-        committed_pages[page_index >> 6].fetch_or(1ULL << (page_index & 63), std::memory_order_release);
-    }
-
-    std::size_t alloc_size{};
-    T* base_ptr{};
-
-    std::vector<std::atomic<u64>> committed_pages{};
-#ifdef _WIN32
-    const std::array<u8, sizeof(T)> default_val{};
-#endif
-};
-
-} // namespace Common

src/common/vector_math.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: 2014 Tony Wasserka
@@ -7,128 +7,752 @@
 
 #pragma once
 
+#ifdef __ARM_NEON
+#include <arm_neon.h>
+#endif
+
 #include <cmath>
 #include <type_traits>
 
 namespace Common {
 
-template <typename T, size_t N>
-class Vec {
+template <typename T>
+class Vec2;
+template <typename T>
+class Vec3;
+template <typename T>
+class Vec4;
+
+template <typename T>
+class Vec2 {
 public:
-    std::array<T, N> elems{};
+    T x{};
+    T y{};
 
-    constexpr Vec() = default;
-    constexpr Vec(T e0) noexcept : elems{e0} {}
-    constexpr Vec(T e0, T e1) noexcept : elems{e0, e1} {}
-    constexpr Vec(T e0, T e1, T e2) noexcept : elems{e0, e1, e2} {}
-    constexpr Vec(T e0, T e1, T e2, T e4) noexcept : elems{e0, e1, e2, e4} {}
-    //explicit constexpr Vec(const std::initializer_list<T> elems_) noexcept : elems{elems_} {}
+    constexpr Vec2() = default;
+    constexpr Vec2(const T& x_, const T& y_) : x(x_), y(y_) {}
 
-    [[nodiscard]] constexpr Vec<decltype(T{} + T{}), N> operator+(const Vec o) const noexcept {
-        Vec<decltype(T{} + T{}), N> r{};
-        for (size_t i = 0; i < N; ++i)
-            r.elems[i] = elems[i] + o.elems[i];
-        return r;
+    template <typename T2>
+    [[nodiscard]] constexpr Vec2<T2> Cast() const {
+        return Vec2<T2>(static_cast<T2>(x), static_cast<T2>(y));
     }
-    constexpr Vec<T, N> operator+=(const Vec<T, N> o) noexcept { return *this = *this + o; }
 
-    [[nodiscard]] constexpr Vec<decltype(T{} - T{}), N> operator-(const Vec o) const noexcept {
-        Vec<decltype(T{} - T{}), N> r{};
-        for (size_t i = 0; i < N; ++i)
-            r.elems[i] = elems[i] - o.elems[i];
-        return r;
+    [[nodiscard]] static constexpr Vec2 AssignToAll(const T& f) {
+        return Vec2{f, f};
+    }
+
+    [[nodiscard]] constexpr Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
+        return {x + other.x, y + other.y};
+    }
+    constexpr Vec2& operator+=(const Vec2& other) {
+        x += other.x;
+        y += other.y;
+        return *this;
+    }
+    [[nodiscard]] constexpr Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
+        return {x - other.x, y - other.y};
+    }
+    constexpr Vec2& operator-=(const Vec2& other) {
+        x -= other.x;
+        y -= other.y;
+        return *this;
     }
-    constexpr Vec<T, N> operator-=(const Vec<T, N> o) noexcept { return *this = *this - o; }
 
     template <typename U = T>
-    [[nodiscard]] constexpr Vec<std::enable_if_t<std::is_signed_v<U>, U>, N> operator-() const noexcept {
-        Vec<U, N> r{};
-        for (size_t i = 0; i < N; ++i)
-            r.elems[i] = -elems[i];
-        return r;
+    [[nodiscard]] constexpr Vec2<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
+        return {-x, -y};
+    }
+    [[nodiscard]] constexpr Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
+        return {x * other.x, y * other.y};
     }
 
-    [[nodiscard]] constexpr Vec<decltype(T{} * T{}), N> operator*(const Vec o) const noexcept {
-        Vec<decltype(T{} * T{}), N> r{};
-        for (size_t i = 0; i < N; ++i)
-            r.elems[i] = elems[i] * o.elems[i];
-        return r;
-    }
     template <typename V>
-    [[nodiscard]] constexpr Vec<decltype(T{} * V{}), N> operator*(const V f) const noexcept {
+    [[nodiscard]] constexpr Vec2<decltype(T{} * V{})> operator*(const V& f) const {
         using TV = decltype(T{} * V{});
         using C = std::common_type_t<T, V>;
-        Vec<TV, N> r{};
-        for (size_t i = 0; i < N; ++i)
-            r.elems[i] = TV(C(elems[i]) * C(f));
-        return r;
+
+        return {
+            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
+        };
     }
-    template <typename V>
-    constexpr Vec<T, N> operator*=(const V f) noexcept { return *this = *this * f; }
 
     template <typename V>
-    [[nodiscard]] constexpr Vec<decltype(T{} / V{}), N> operator/(const V f) const noexcept {
+    constexpr Vec2& operator*=(const V& f) {
+        *this = *this * f;
+        return *this;
+    }
+
+    template <typename V>
+    [[nodiscard]] constexpr Vec2<decltype(T{} / V{})> operator/(const V& f) const {
         using TV = decltype(T{} / V{});
         using C = std::common_type_t<T, V>;
-        Vec<TV, N> r{};
-        for (size_t i = 0; i < N; ++i)
-            r.elems[i] = TV(C(elems[i]) / C(f));
-        return r;
-    }
-    template <typename V>
-    constexpr Vec<T, N> operator/=(const V f) noexcept { return *this = *this / f; }
 
-    [[nodiscard]] constexpr T Length2() const noexcept {
-        T r{};
-        for (size_t i = 0; i < N; ++i)
-            r += elems[i] * elems[i];
-        return r;
-    }
-    // Only implemented for T=float
-    [[nodiscard]] T Length() const { return T(std::sqrt(float(Length2()))); }
-    [[nodiscard]] Vec<T, N> Normalized() const { return *this / Length(); }
-    [[nodiscard]] constexpr T& operator[](std::size_t i) noexcept { return elems[i]; }
-    [[nodiscard]] constexpr const T& operator[](std::size_t i) const noexcept { return elems[i]; }
-
-    [[nodiscard]] std::array<decltype(-T{}), 16> ToMatrix() const {
-        const T x2 = elems[0] * elems[0];
-        const T y2 = elems[1] * elems[1];
-        const T z2 = elems[2] * elems[2];
-
-        const T xy = elems[0] * elems[1];
-        const T wz = elems[3] * elems[2];
-        const T xz = elems[0] * elems[2];
-        const T wy = elems[3] * elems[1];
-        const T yz = elems[1] * elems[2];
-        const T wx = elems[3] * elems[0];
         return {
-            1.0f - 2.0f * (y2 + z2),
-            2.0f * (xy + wz),
-            2.0f * (xz - wy),
-            0.0f,
-            2.0f * (xy - wz),
-            1.0f - 2.0f * (x2 + z2),
-            2.0f * (yz + wx),
-            0.0f,
-            2.0f * (xz + wy),
-            2.0f * (yz - wx),
-            1.0f - 2.0f * (x2 + y2),
-            0.0f,
-            0.0f,
-            0.0f,
-            0.0f,
-            1.0f
+            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
         };
     }
+
+    template <typename V>
+    constexpr Vec2& operator/=(const V& f) {
+        *this = *this / f;
+        return *this;
+    }
+
+    [[nodiscard]] constexpr T Length2() const {
+        return x * x + y * y;
+    }
+
+    // Only implemented for T=float
+    [[nodiscard]] float Length() const;
+    [[nodiscard]] float Normalize(); // returns the previous length, which is often useful
+
+    [[nodiscard]] constexpr T& operator[](std::size_t i) {
+        return *((&x) + i);
+    }
+    [[nodiscard]] constexpr const T& operator[](std::size_t i) const {
+        return *((&x) + i);
+    }
+
+    constexpr void SetZero() {
+        x = 0;
+        y = 0;
+    }
+
+    // Common aliases: UV (texel coordinates), ST (texture coordinates)
+    [[nodiscard]] constexpr T& u() {
+        return x;
+    }
+    [[nodiscard]] constexpr T& v() {
+        return y;
+    }
+    [[nodiscard]] constexpr T& s() {
+        return x;
+    }
+    [[nodiscard]] constexpr T& t() {
+        return y;
+    }
+
+    [[nodiscard]] constexpr const T& u() const {
+        return x;
+    }
+    [[nodiscard]] constexpr const T& v() const {
+        return y;
+    }
+    [[nodiscard]] constexpr const T& s() const {
+        return x;
+    }
+    [[nodiscard]] constexpr const T& t() const {
+        return y;
+    }
+
+    // swizzlers - create a subvector of specific components
+    [[nodiscard]] constexpr Vec2 yx() const {
+        return Vec2(y, x);
+    }
+    [[nodiscard]] constexpr Vec2 vu() const {
+        return Vec2(y, x);
+    }
+    [[nodiscard]] constexpr Vec2 ts() const {
+        return Vec2(y, x);
+    }
 };
 
-template <typename T, size_t N, typename V>
-[[nodiscard]] constexpr Vec<T, N> operator*(const V f, const Vec<T, N> v) noexcept {
+template <typename T, typename V>
+[[nodiscard]] constexpr Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
     using C = std::common_type_t<T, V>;
-    Vec<T, N> r{};
-    for (size_t i = 0; i < N; ++i)
-        r.elems[i] = T(C(f) * C(v.elems[i]));
-    return r;
+
+    return Vec2<T>(static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.x)),
+                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.y)));
+}
+
+using Vec2f = Vec2<float>;
+
+template <>
+inline float Vec2<float>::Length() const {
+    return std::sqrt(x * x + y * y);
+}
+
+template <>
+inline float Vec2<float>::Normalize() {
+    float length = Length();
+    *this /= length;
+    return length;
+}
+
+template <typename T>
+class Vec3 {
+public:
+    T x{};
+    T y{};
+    T z{};
+
+    constexpr Vec3() = default;
+    constexpr Vec3(const T& x_, const T& y_, const T& z_) : x(x_), y(y_), z(z_) {}
+
+    template <typename T2>
+    [[nodiscard]] constexpr Vec3<T2> Cast() const {
+        return Vec3<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z));
+    }
+
+    [[nodiscard]] static constexpr Vec3 AssignToAll(const T& f) {
+        return Vec3(f, f, f);
+    }
+
+    [[nodiscard]] constexpr Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
+        return {x + other.x, y + other.y, z + other.z};
+    }
+
+    constexpr Vec3& operator+=(const Vec3& other) {
+        x += other.x;
+        y += other.y;
+        z += other.z;
+        return *this;
+    }
+
+    [[nodiscard]] constexpr Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
+        return {x - other.x, y - other.y, z - other.z};
+    }
+
+    constexpr Vec3& operator-=(const Vec3& other) {
+        x -= other.x;
+        y -= other.y;
+        z -= other.z;
+        return *this;
+    }
+
+    template <typename U = T>
+    [[nodiscard]] constexpr Vec3<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
+        return {-x, -y, -z};
+    }
+
+    [[nodiscard]] constexpr Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
+        return {x * other.x, y * other.y, z * other.z};
+    }
+
+    template <typename V>
+    [[nodiscard]] constexpr Vec3<decltype(T{} * V{})> operator*(const V& f) const {
+        using TV = decltype(T{} * V{});
+        using C = std::common_type_t<T, V>;
+
+        return {
+            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(z) * static_cast<C>(f)),
+        };
+    }
+
+    template <typename V>
+    constexpr Vec3& operator*=(const V& f) {
+        *this = *this * f;
+        return *this;
+    }
+    template <typename V>
+    [[nodiscard]] constexpr Vec3<decltype(T{} / V{})> operator/(const V& f) const {
+        using TV = decltype(T{} / V{});
+        using C = std::common_type_t<T, V>;
+
+        return {
+            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(z) / static_cast<C>(f)),
+        };
+    }
+
+    template <typename V>
+    constexpr Vec3& operator/=(const V& f) {
+        *this = *this / f;
+        return *this;
+    }
+
+    void RotateFromOrigin(float roll, float pitch, float yaw) {
+        float temp = y;
+        y = std::cos(roll) * y - std::sin(roll) * z;
+        z = std::sin(roll) * temp + std::cos(roll) * z;
+
+        temp = x;
+        x = std::cos(pitch) * x + std::sin(pitch) * z;
+        z = -std::sin(pitch) * temp + std::cos(pitch) * z;
+
+        temp = x;
+        x = std::cos(yaw) * x - std::sin(yaw) * y;
+        y = std::sin(yaw) * temp + std::cos(yaw) * y;
+    }
+
+    [[nodiscard]] constexpr T Length2() const {
+        return x * x + y * y + z * z;
+    }
+
+    // Only implemented for T=float
+    [[nodiscard]] float Length() const;
+    [[nodiscard]] Vec3 Normalized() const;
+    [[nodiscard]] float Normalize(); // returns the previous length, which is often useful
+
+    [[nodiscard]] constexpr T& operator[](std::size_t i) {
+        return *((&x) + i);
+    }
+
+    [[nodiscard]] constexpr const T& operator[](std::size_t i) const {
+        return *((&x) + i);
+    }
+
+    constexpr void SetZero() {
+        x = 0;
+        y = 0;
+        z = 0;
+    }
+
+    // Common aliases: UVW (texel coordinates), RGB (colors), STQ (texture coordinates)
+    [[nodiscard]] constexpr T& u() {
+        return x;
+    }
+    [[nodiscard]] constexpr T& v() {
+        return y;
+    }
+    [[nodiscard]] constexpr T& w() {
+        return z;
+    }
+
+    [[nodiscard]] constexpr T& r() {
+        return x;
+    }
+    [[nodiscard]] constexpr T& g() {
+        return y;
+    }
+    [[nodiscard]] constexpr T& b() {
+        return z;
+    }
+
+    [[nodiscard]] constexpr T& s() {
+        return x;
+    }
+    [[nodiscard]] constexpr T& t() {
+        return y;
+    }
+    [[nodiscard]] constexpr T& q() {
+        return z;
+    }
+
+    [[nodiscard]] constexpr const T& u() const {
+        return x;
+    }
+    [[nodiscard]] constexpr const T& v() const {
+        return y;
+    }
+    [[nodiscard]] constexpr const T& w() const {
+        return z;
+    }
+
+    [[nodiscard]] constexpr const T& r() const {
+        return x;
+    }
+    [[nodiscard]] constexpr const T& g() const {
+        return y;
+    }
+    [[nodiscard]] constexpr const T& b() const {
+        return z;
+    }
+
+    [[nodiscard]] constexpr const T& s() const {
+        return x;
+    }
+    [[nodiscard]] constexpr const T& t() const {
+        return y;
+    }
+    [[nodiscard]] constexpr const T& q() const {
+        return z;
+    }
+
+// swizzlers - create a subvector of specific components
+// e.g. Vec2 uv() { return Vec2(x,y); }
+// _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
+// component names (x<->r) and permutations (xy<->yx)
+#define _DEFINE_SWIZZLER2(a, b, name)                                                              \
+    [[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
+#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4)                                             \
+    _DEFINE_SWIZZLER2(a, b, a##b);                                                                 \
+    _DEFINE_SWIZZLER2(a, b, a2##b2);                                                               \
+    _DEFINE_SWIZZLER2(a, b, a3##b3);                                                               \
+    _DEFINE_SWIZZLER2(a, b, a4##b4);                                                               \
+    _DEFINE_SWIZZLER2(b, a, b##a);                                                                 \
+    _DEFINE_SWIZZLER2(b, a, b2##a2);                                                               \
+    _DEFINE_SWIZZLER2(b, a, b3##a3);                                                               \
+    _DEFINE_SWIZZLER2(b, a, b4##a4)
+
+    DEFINE_SWIZZLER2(x, y, r, g, u, v, s, t);
+    DEFINE_SWIZZLER2(x, z, r, b, u, w, s, q);
+    DEFINE_SWIZZLER2(y, z, g, b, v, w, t, q);
+#undef DEFINE_SWIZZLER2
+#undef _DEFINE_SWIZZLER2
+};
+
+template <typename T, typename V>
+[[nodiscard]] constexpr Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
+    using C = std::common_type_t<T, V>;
+
+    return Vec3<T>(static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.x)),
+                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.y)),
+                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.z)));
+}
+
+template <>
+inline float Vec3<float>::Length() const {
+    return std::sqrt(x * x + y * y + z * z);
+}
+
+template <>
+inline Vec3<float> Vec3<float>::Normalized() const {
+    return *this / Length();
+}
+
+template <>
+inline float Vec3<float>::Normalize() {
+    float length = Length();
+    *this /= length;
+    return length;
+}
+
+using Vec3f = Vec3<float>;
+
+template <typename T>
+class Vec4 {
+public:
+    T x{};
+    T y{};
+    T z{};
+    T w{};
+
+    constexpr Vec4() = default;
+    constexpr Vec4(const T& x_, const T& y_, const T& z_, const T& w_)
+        : x(x_), y(y_), z(z_), w(w_) {}
+
+    template <typename T2>
+    [[nodiscard]] constexpr Vec4<T2> Cast() const {
+        return Vec4<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z),
+                        static_cast<T2>(w));
+    }
+
+    [[nodiscard]] static constexpr Vec4 AssignToAll(const T& f) {
+        return Vec4(f, f, f, f);
+    }
+
+    [[nodiscard]] constexpr Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
+        return {x + other.x, y + other.y, z + other.z, w + other.w};
+    }
+
+    constexpr Vec4& operator+=(const Vec4& other) {
+        x += other.x;
+        y += other.y;
+        z += other.z;
+        w += other.w;
+        return *this;
+    }
+
+    [[nodiscard]] constexpr Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
+        return {x - other.x, y - other.y, z - other.z, w - other.w};
+    }
+
+    constexpr Vec4& operator-=(const Vec4& other) {
+        x -= other.x;
+        y -= other.y;
+        z -= other.z;
+        w -= other.w;
+        return *this;
+    }
+
+    template <typename U = T>
+    [[nodiscard]] constexpr Vec4<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
+        return {-x, -y, -z, -w};
+    }
+
+    [[nodiscard]] constexpr Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
+        return {x * other.x, y * other.y, z * other.z, w * other.w};
+    }
+
+    template <typename V>
+    [[nodiscard]] constexpr Vec4<decltype(T{} * V{})> operator*(const V& f) const {
+        using TV = decltype(T{} * V{});
+        using C = std::common_type_t<T, V>;
+
+        return {
+            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(z) * static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(w) * static_cast<C>(f)),
+        };
+    }
+
+    template <typename V>
+    constexpr Vec4& operator*=(const V& f) {
+        *this = *this * f;
+        return *this;
+    }
+
+    template <typename V>
+    [[nodiscard]] constexpr Vec4<decltype(T{} / V{})> operator/(const V& f) const {
+        using TV = decltype(T{} / V{});
+        using C = std::common_type_t<T, V>;
+
+        return {
+            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(z) / static_cast<C>(f)),
+            static_cast<TV>(static_cast<C>(w) / static_cast<C>(f)),
+        };
+    }
+
+    template <typename V>
+    constexpr Vec4& operator/=(const V& f) {
+        *this = *this / f;
+        return *this;
+    }
+
+    [[nodiscard]] constexpr T Length2() const {
+        return x * x + y * y + z * z + w * w;
+    }
+
+    [[nodiscard]] constexpr T& operator[](std::size_t i) {
+        return *((&x) + i);
+    }
+
+    [[nodiscard]] constexpr const T& operator[](std::size_t i) const {
+        return *((&x) + i);
+    }
+
+    constexpr void SetZero() {
+        x = 0;
+        y = 0;
+        z = 0;
+        w = 0;
+    }
+
+    // Common alias: RGBA (colors)
+    [[nodiscard]] constexpr T& r() {
+        return x;
+    }
+    [[nodiscard]] constexpr T& g() {
+        return y;
+    }
+    [[nodiscard]] constexpr T& b() {
+        return z;
+    }
+    [[nodiscard]] constexpr T& a() {
+        return w;
+    }
+
+    [[nodiscard]] constexpr const T& r() const {
+        return x;
+    }
+    [[nodiscard]] constexpr const T& g() const {
+        return y;
+    }
+    [[nodiscard]] constexpr const T& b() const {
+        return z;
+    }
+    [[nodiscard]] constexpr const T& a() const {
+        return w;
+    }
+
+// Swizzlers - Create a subvector of specific components
+// e.g. Vec2 uv() { return Vec2(x,y); }
+
+// _DEFINE_SWIZZLER2 defines a single such function
+// DEFINE_SWIZZLER2_COMP1 defines one-component functions for all component names (x<->r)
+// DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
+// permutations (xy<->yx)
+#define _DEFINE_SWIZZLER2(a, b, name)                                                              \
+    [[nodiscard]] constexpr Vec2<T> name() const { return Vec2<T>(a, b); }
+#define DEFINE_SWIZZLER2_COMP1(a, a2)                                                              \
+    _DEFINE_SWIZZLER2(a, a, a##a);                                                                 \
+    _DEFINE_SWIZZLER2(a, a, a2##a2)
+#define DEFINE_SWIZZLER2_COMP2(a, b, a2, b2)                                                       \
+    _DEFINE_SWIZZLER2(a, b, a##b);                                                                 \
+    _DEFINE_SWIZZLER2(a, b, a2##b2);                                                               \
+    _DEFINE_SWIZZLER2(b, a, b##a);                                                                 \
+    _DEFINE_SWIZZLER2(b, a, b2##a2)
+
+    DEFINE_SWIZZLER2_COMP2(x, y, r, g);
+    DEFINE_SWIZZLER2_COMP2(x, z, r, b);
+    DEFINE_SWIZZLER2_COMP2(x, w, r, a);
+    DEFINE_SWIZZLER2_COMP2(y, z, g, b);
+    DEFINE_SWIZZLER2_COMP2(y, w, g, a);
+    DEFINE_SWIZZLER2_COMP2(z, w, b, a);
+    DEFINE_SWIZZLER2_COMP1(x, r);
+    DEFINE_SWIZZLER2_COMP1(y, g);
+    DEFINE_SWIZZLER2_COMP1(z, b);
+    DEFINE_SWIZZLER2_COMP1(w, a);
+#undef DEFINE_SWIZZLER2_COMP1
+#undef DEFINE_SWIZZLER2_COMP2
+#undef _DEFINE_SWIZZLER2
+
+#define _DEFINE_SWIZZLER3(a, b, c, name)                                                           \
+    [[nodiscard]] constexpr Vec3<T> name() const { return Vec3<T>(a, b, c); }
+#define DEFINE_SWIZZLER3_COMP1(a, a2)                                                              \
+    _DEFINE_SWIZZLER3(a, a, a, a##a##a);                                                           \
+    _DEFINE_SWIZZLER3(a, a, a, a2##a2##a2)
+#define DEFINE_SWIZZLER3_COMP3(a, b, c, a2, b2, c2)                                                \
+    _DEFINE_SWIZZLER3(a, b, c, a##b##c);                                                           \
+    _DEFINE_SWIZZLER3(a, c, b, a##c##b);                                                           \
+    _DEFINE_SWIZZLER3(b, a, c, b##a##c);                                                           \
+    _DEFINE_SWIZZLER3(b, c, a, b##c##a);                                                           \
+    _DEFINE_SWIZZLER3(c, a, b, c##a##b);                                                           \
+    _DEFINE_SWIZZLER3(c, b, a, c##b##a);                                                           \
+    _DEFINE_SWIZZLER3(a, b, c, a2##b2##c2);                                                        \
+    _DEFINE_SWIZZLER3(a, c, b, a2##c2##b2);                                                        \
+    _DEFINE_SWIZZLER3(b, a, c, b2##a2##c2);                                                        \
+    _DEFINE_SWIZZLER3(b, c, a, b2##c2##a2);                                                        \
+    _DEFINE_SWIZZLER3(c, a, b, c2##a2##b2);                                                        \
+    _DEFINE_SWIZZLER3(c, b, a, c2##b2##a2)
+
+    DEFINE_SWIZZLER3_COMP3(x, y, z, r, g, b);
+    DEFINE_SWIZZLER3_COMP3(x, y, w, r, g, a);
+    DEFINE_SWIZZLER3_COMP3(x, z, w, r, b, a);
+    DEFINE_SWIZZLER3_COMP3(y, z, w, g, b, a);
+    DEFINE_SWIZZLER3_COMP1(x, r);
+    DEFINE_SWIZZLER3_COMP1(y, g);
+    DEFINE_SWIZZLER3_COMP1(z, b);
+    DEFINE_SWIZZLER3_COMP1(w, a);
+#undef DEFINE_SWIZZLER3_COMP1
+#undef DEFINE_SWIZZLER3_COMP3
+#undef _DEFINE_SWIZZLER3
+};
+
+template <typename T, typename V>
+[[nodiscard]] constexpr Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
+    using TV = decltype(V{} * T{});
+    using C = std::common_type_t<T, V>;
+
+    return {
+        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.x)),
+        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.y)),
+        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.z)),
+        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.w)),
+    };
+}
+
+using Vec4f = Vec4<float>;
+
+template <typename T>
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
+    return a.x * b.x + a.y * b.y;
+}
+
+template <typename T>
+[[nodiscard]] constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+
+template <typename T>
+[[nodiscard]] constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
+    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+}
+
+template <>
+[[nodiscard]] inline float Dot(const Vec4<float>& a, const Vec4<float>& b) {
+#ifdef __ARM_NEON
+    float32x4_t va = vld1q_f32(&a.x);
+    float32x4_t vb = vld1q_f32(&b.x);
+    float32x4_t result = vmulq_f32(va, vb);
+#if defined(__aarch64__) // Use vaddvq_f32 in ARMv8 architectures
+    return vaddvq_f32(result);
+#else // Use manual addition for older architectures
+    float32x2_t sum2 = vadd_f32(vget_high_f32(result), vget_low_f32(result));
+    return vget_lane_f32(vpadd_f32(sum2, sum2), 0);
+#endif
+#else
+    return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+#endif
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a,
+                                                                    const Vec3<T>& b) {
+    return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
+}
+
+// linear interpolation via float: 0.0=begin, 1.0=end
+template <typename X>
+[[nodiscard]] constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+                                                                     const float t) {
+    return begin * (1.f - t) + end * t;
+}
+
+// linear interpolation via int: 0=begin, base=end
+template <typename X, int base>
+[[nodiscard]] constexpr decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin,
+                                                                             const X& end,
+                                                                             const int t) {
+    return (begin * (base - t) + end * t) / base;
+}
+
+// bilinear interpolation. s is for interpolating x00-x01 and x10-x11, and t is for the second
+// interpolation.
+template <typename X>
+[[nodiscard]] constexpr auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11,
+                                            const float s, const float t) {
+    auto y0 = Lerp(x00, x01, s);
+    auto y1 = Lerp(x10, x11, s);
+    return Lerp(y0, y1, t);
+}
+
+// Utility vector factories
+template <typename T>
+[[nodiscard]] constexpr Vec2<T> MakeVec(const T& x, const T& y) {
+    return Vec2<T>{x, y};
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
+    return Vec3<T>{x, y, z};
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
+    return MakeVec(x, y, zw[0], zw[1]);
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
+    return MakeVec(xy[0], xy[1], z);
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
+    return MakeVec(x, yz[0], yz[1]);
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
+    return Vec4<T>{x, y, z, w};
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
+    return MakeVec(xy[0], xy[1], z, w);
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
+    return MakeVec(x, yz[0], yz[1], w);
+}
+
+// NOTE: This has priority over "Vec2<Vec2<T>> MakeVec(const Vec2<T>& x, const Vec2<T>& y)".
+//       Even if someone wanted to use an odd object like Vec2<Vec2<T>>, the compiler would error
+//       out soon enough due to misuse of the returned structure.
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
+    return MakeVec(xy[0], xy[1], zw[0], zw[1]);
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
+    return MakeVec(xyz[0], xyz[1], xyz[2], w);
+}
+
+template <typename T>
+[[nodiscard]] constexpr Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
+    return MakeVec(x, yzw[0], yzw[1], yzw[2]);
 }
 
 } // namespace Common

src/common/virtual_buffer.cpp

@@ -0,0 +1,44 @@
+// 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
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#include "common/assert.h"
+#include "common/virtual_buffer.h"
+
+namespace Common {
+
+void* AllocateMemoryPages(std::size_t size) noexcept {
+#ifdef _WIN32
+    void* base = VirtualAlloc(nullptr, size, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+    if (base == nullptr) {
+        // Probably failing to reserve is less likely than failing to commit
+        base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
+    }
+#else
+    void* base = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    if (base == MAP_FAILED)
+        base = nullptr;
+#endif
+    ASSERT(base);
+    return base;
+}
+
+void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
+    if (!base)
+        return;
+#ifdef _WIN32
+    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
+#else
+    ASSERT(munmap(base, size) == 0);
+#endif
+}
+
+} // namespace Common

src/common/virtual_buffer.h

@@ -0,0 +1,84 @@
+// 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
+
+#pragma once
+
+#include <utility>
+
+namespace Common {
+
+void* AllocateMemoryPages(std::size_t size) noexcept;
+void FreeMemoryPages(void* base, std::size_t size) noexcept;
+
+template <typename T>
+class VirtualBuffer final {
+public:
+    // TODO: Uncomment this and change Common::PageTable::PageInfo to be trivially constructible
+    // using std::atomic_ref once libc++ has support for it
+    // static_assert(
+    //     std::is_trivially_constructible_v<T>,
+    //     "T must be trivially constructible, as non-trivial constructors will not be executed "
+    //     "with the current allocator");
+
+    constexpr VirtualBuffer() = default;
+    explicit VirtualBuffer(std::size_t count) noexcept
+        : alloc_size{count * sizeof(T)}
+    {
+        base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
+    }
+
+    ~VirtualBuffer() noexcept {
+        FreeMemoryPages(base_ptr, alloc_size);
+    }
+
+    VirtualBuffer(const VirtualBuffer&) = delete;
+    VirtualBuffer& operator=(const VirtualBuffer&) = delete;
+
+    VirtualBuffer(VirtualBuffer&& other) noexcept
+        : alloc_size{std::exchange(other.alloc_size, 0)}
+        , base_ptr{std::exchange(other.base_ptr, nullptr)}
+    {}
+
+    VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
+        alloc_size = std::exchange(other.alloc_size, 0);
+        base_ptr = std::exchange(other.base_ptr, nullptr);
+        return *this;
+    }
+
+    void resize(std::size_t count) noexcept {
+        if (auto const new_size = count * sizeof(T); new_size != alloc_size) {
+            FreeMemoryPages(base_ptr, alloc_size);
+            alloc_size = new_size;
+            base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
+        }
+    }
+
+    [[nodiscard]] constexpr const T& operator[](std::size_t index) const noexcept {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] constexpr T& operator[](std::size_t index) noexcept {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] constexpr T* data() noexcept {
+        return base_ptr;
+    }
+
+    [[nodiscard]] constexpr const T* data() const noexcept {
+        return base_ptr;
+    }
+
+    [[nodiscard]] constexpr std::size_t size() const noexcept {
+        return alloc_size / sizeof(T);
+    }
+
+private:
+    std::size_t alloc_size{};
+    T* base_ptr{};
+};
+
+} // namespace Common

src/core/CMakeLists.txt

@@ -711,6 +711,8 @@ add_library(core STATIC
     hle/service/kernel_helpers.h
     hle/service/lbl/lbl.cpp
     hle/service/lbl/lbl.h
+    hle/service/ldn/client_process_monitor.cpp
+    hle/service/ldn/client_process_monitor.h
     hle/service/ldn/lan_discovery.cpp
     hle/service/ldn/lan_discovery.h
     hle/service/ldn/ldn.cpp
@@ -830,6 +832,8 @@ add_library(core STATIC
     hle/service/ns/system_update_control.h
     hle/service/ns/system_update_interface.cpp
     hle/service/ns/system_update_interface.h
+    hle/service/ns/vulnerability_manager_interface.cpp
+    hle/service/ns/vulnerability_manager_interface.h
     hle/service/nvdrv/core/container.cpp
     hle/service/nvdrv/core/container.h
     hle/service/nvdrv/core/heap_mapper.cpp
@@ -1063,6 +1067,8 @@ add_library(core STATIC
     hle/service/sockets/sockets.h
     hle/service/sockets/sockets_translate.cpp
     hle/service/sockets/sockets_translate.h
+    hle/service/spl/csrng.cpp
+    hle/service/spl/csrng.h
     hle/service/spl/spl.cpp
     hle/service/spl/spl.h
     hle/service/spl/spl_module.cpp

src/core/arm/dynarmic/arm_dynarmic.h

@@ -7,19 +7,18 @@
 #pragma once
 
 #include <dynarmic/interface/halt_reason.h>
-
 #include "core/arm/arm_interface.h"
 
 namespace Core {
 
-constexpr Dynarmic::HaltReason StepThread = Dynarmic::HaltReason::Step;
-constexpr Dynarmic::HaltReason DataAbort = Dynarmic::HaltReason::MemoryAbort;
-constexpr Dynarmic::HaltReason BreakLoop = Dynarmic::HaltReason::UserDefined2;
-constexpr Dynarmic::HaltReason SupervisorCall = Dynarmic::HaltReason::UserDefined3;
-constexpr Dynarmic::HaltReason InstructionBreakpoint = Dynarmic::HaltReason::UserDefined4;
-constexpr Dynarmic::HaltReason PrefetchAbort = Dynarmic::HaltReason::UserDefined6;
+inline constexpr Dynarmic::HaltReason StepThread = Dynarmic::HaltReason::Step;
+inline constexpr Dynarmic::HaltReason DataAbort = Dynarmic::HaltReason::MemoryAbort;
+inline constexpr Dynarmic::HaltReason BreakLoop = Dynarmic::HaltReason::UserDefined2;
+inline constexpr Dynarmic::HaltReason SupervisorCall = Dynarmic::HaltReason::UserDefined3;
+inline constexpr Dynarmic::HaltReason InstructionBreakpoint = Dynarmic::HaltReason::UserDefined4;
+inline constexpr Dynarmic::HaltReason PrefetchAbort = Dynarmic::HaltReason::UserDefined6;
 
-constexpr HaltReason TranslateHaltReason(Dynarmic::HaltReason hr) {
+[[nodiscard]] inline constexpr HaltReason TranslateHaltReason(Dynarmic::HaltReason hr) {
     static_assert(u64(HaltReason::StepThread) == u64(StepThread));
     static_assert(u64(HaltReason::DataAbort) == u64(DataAbort));
     static_assert(u64(HaltReason::BreakLoop) == u64(BreakLoop));

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -172,12 +172,12 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
     if (page_table) {
         constexpr size_t PageBits = 12;
         constexpr size_t NumPageTableEntries = 1 << (32 - PageBits);
+        constexpr size_t PageLog2Stride = 5;
+        static_assert(1 << PageLog2Stride == sizeof(Common::PageTable::PageEntryData));
 
-        // Dynarmic will not write to the page table, const_cast is safe here
-        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 = 0;
+        config.page_table = reinterpret_cast<std::array<std::uint8_t*, NumPageTableEntries>*>(page_table->entries.data());
+        config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
+        config.page_table_log2_stride = PageLog2Stride;
         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;
@@ -188,13 +188,6 @@ void ArmDynarmic32::MakeJit(Common::PageTable* page_table) {
 
         config.fastmem_exclusive_access = config.fastmem_pointer  != std::nullopt;
         config.recompile_on_exclusive_fastmem_failure = true;
-
-        if (reinterpret_cast<u64>(m_system.DeviceMemory().buffer.BackingBasePointer() +
-            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 = Common::PageTable::SIGN_BIT;
-        }
     }
 
     // Multi-process state
@@ -427,7 +420,6 @@ void ArmDynarmic32::SignalInterrupt(Kernel::KThread* thread) {
 }
 
 void ArmDynarmic32::ClearInstructionCache() {
-    m_cb->last_code_addr = u64(-1);
     m_jit->ClearCache();
 }
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -211,12 +211,13 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
 
     // Memory
     if (page_table) {
-        // Dynarmic will not write to the page table, const_cast is safe here
-        config.page_table = reinterpret_cast<void**>(
-            const_cast<Common::PageTable::PageEntryData*>(page_table->entries.data()));
+        constexpr size_t PageLog2Stride = 5;
+        static_assert(1 << PageLog2Stride == sizeof(Common::PageTable::PageEntryData));
+
+        config.page_table = reinterpret_cast<void**>(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 = 0;
+        config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
+        config.page_table_log2_stride = PageLog2Stride;
         config.silently_mirror_page_table = false;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -230,13 +231,6 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
 
         config.fastmem_exclusive_access = config.fastmem_pointer != std::nullopt;
         config.recompile_on_exclusive_fastmem_failure = true;
-
-        if (reinterpret_cast<u64>(m_system.DeviceMemory().buffer.BackingBasePointer() +
-            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 = Common::PageTable::SIGN_BIT;
-        }
     }
 
     // Multi-process state
@@ -453,7 +447,6 @@ void ArmDynarmic64::SignalInterrupt(Kernel::KThread* thread) {
 }
 
 void ArmDynarmic64::ClearInstructionCache() {
-    m_cb->last_code_addr = u64(-1);
     m_jit->ClearCache();
 }
 

src/core/arm/nce/instructions.h

@@ -121,10 +121,7 @@ union Exclusive {
     constexpr explicit Exclusive(u32 raw_) : raw{raw_} {}
 
     constexpr bool Verify() {
-        if (this->GetSig() != 0x10) return false;
-        const bool pair = decltype(l)::ExtractValue(raw) & 1;
-        const bool fixed_rt2 = decltype(rt2)::ExtractValue(raw) == 0b11111;
-        return pair || fixed_rt2;
+        return this->GetSig() == 0x10;
     }
 
     constexpr u32 GetSig() {

src/core/core_timing.cpp

@@ -38,6 +38,7 @@ constexpr u32 CpuClockTargetMhz(Settings::CpuClock clock) {
     }
 }
 
+#undef CreateEvent
 std::shared_ptr<EventType> CreateEvent(std::string name, TimedCallback&& callback) {
     return std::make_shared<EventType>(std::move(callback), std::move(name));
 }

src/core/device_memory.h

@@ -1,6 +1,3 @@
-// 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
 
@@ -29,11 +26,8 @@ public:
 
     template <typename T>
     Common::PhysicalAddress GetPhysicalAddr(const T* ptr) const {
-        return GetPhysicalAddr(reinterpret_cast<uintptr_t>(ptr));
-    }
-
-    Common::PhysicalAddress GetPhysicalAddr(uintptr_t ptr) const {
-        return (ptr - reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
+        return (reinterpret_cast<uintptr_t>(ptr) -
+                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
                DramMemoryMap::Base;
     }
 

src/core/device_memory_manager.h

@@ -18,7 +18,7 @@
 #include "common/common_types.h"
 #include "common/range_mutex.h"
 #include "common/scratch_buffer.h"
-#include "common/sparse_large_vector.h"
+#include "common/virtual_buffer.h"
 
 namespace Core {
 
@@ -178,8 +178,8 @@ private:
         u32 continuity_tracker;
         u32 compressed_physical_ptr;
     };
-    Common::SparseLargeVector<u32> compressed_device_addr;
-    Common::SparseLargeVector<TrackedEntry> tracked_entries;
+    Common::VirtualBuffer<u32> compressed_device_addr;
+    Common::VirtualBuffer<TrackedEntry> tracked_entries;
 
     // Process memory interfaces
 
@@ -200,8 +200,8 @@ private:
         return std::make_pair(asid, address);
     }
 
-    constexpr void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
-        tracked_entries.GetUnchecked(page_index).cpu_backing_address = address | (asid.id << asid_start_bit);
+    void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
+        tracked_entries[page_index].cpu_backing_address = address | (asid.id << asid_start_bit);
     }
 
     std::array<TranslationEntry, 4> t_slot{};

src/core/device_memory_manager.inc

@@ -177,6 +177,17 @@ DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memo
 {
     impl = std::make_unique<DeviceMemoryManagerAllocator<Traits>>();
     cached_pages = std::make_unique<CachedPages>();
+
+    const size_t total_virtual = device_as_size >> Memory::YUZU_PAGEBITS;
+    for (size_t i = 0; i < total_virtual; i++) {
+        tracked_entries[i].compressed_physical_ptr = 0;
+        tracked_entries[i].continuity_tracker = 1;
+        tracked_entries[i].cpu_backing_address = 0;
+    }
+    const size_t total_phys = 1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS);
+    for (size_t i = 0; i < total_phys; i++) {
+        compressed_device_addr[i] = 0;
+    }
 }
 
 template <typename Traits>
@@ -209,28 +220,26 @@ void DeviceMemoryManager<Traits>::Map(DAddr address, VAddr virtual_address, size
     size_t start_page_d = address >> Memory::YUZU_PAGEBITS;
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     std::scoped_lock lk(mapping_guard);
-
-    tracked_entries.CommitRegion(start_page_d, start_page_d + num_pages);
     for (size_t i = 0; i < num_pages; i++) {
         const VAddr new_vaddress = virtual_address + i * Memory::YUZU_PAGESIZE;
         auto* ptr = process_memory->GetPointerSilent(Common::ProcessAddress(new_vaddress));
         if (ptr == nullptr) [[unlikely]] {
-            tracked_entries.GetUnchecked(start_page_d + i).compressed_physical_ptr = 0;
+            tracked_entries[start_page_d + i].compressed_physical_ptr = 0;
             continue;
         }
         auto phys_addr = static_cast<u32>(GetRawPhysicalAddr(ptr) >> Memory::YUZU_PAGEBITS) + 1U;
-        tracked_entries.GetUnchecked(start_page_d + i).compressed_physical_ptr = phys_addr;
+        tracked_entries[start_page_d + i].compressed_physical_ptr = phys_addr;
         InsertCPUBacking(start_page_d + i, new_vaddress, asid);
         const u32 base_dev = compressed_device_addr[phys_addr - 1U];
         const u32 new_dev = static_cast<u32>(start_page_d + i);
         if (base_dev == 0) [[likely]] {
-            compressed_device_addr.GetAndFault(phys_addr - 1U) = new_dev;
+            compressed_device_addr[phys_addr - 1U] = new_dev;
             continue;
         }
         u32 start_id = base_dev & MULTI_MASK;
         if ((base_dev >> MULTI_FLAG_BITS) == 0) {
             start_id = impl->multi_dev_address.Register(base_dev);
-            compressed_device_addr.GetAndFault(phys_addr - 1U) = MULTI_FLAG | start_id;
+            compressed_device_addr[phys_addr - 1U] = MULTI_FLAG | start_id;
         }
         impl->multi_dev_address.Register(new_dev, start_id);
     }
@@ -246,26 +255,24 @@ void DeviceMemoryManager<Traits>::Unmap(DAddr address, size_t size) {
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     device_inter->InvalidateRegion(address, size);
     std::scoped_lock lk(mapping_guard);
-
-    tracked_entries.CommitRegion(start_page_d, start_page_d + num_pages); // should already be committed, but just in case
     for (size_t i = 0; i < num_pages; i++) {
-        auto& entry = tracked_entries.GetUnchecked(start_page_d + i);
-        auto phys_addr = entry.compressed_physical_ptr;
-        entry.compressed_physical_ptr = 0;
-        entry.cpu_backing_address = 0;
+        auto phys_addr = tracked_entries[start_page_d + i].compressed_physical_ptr;
+        tracked_entries[start_page_d + i].compressed_physical_ptr = 0;
+        tracked_entries[start_page_d + i].cpu_backing_address = 0;
         if (phys_addr != 0) [[likely]] {
-            u32& base_dev = compressed_device_addr.GetAndFault(phys_addr - 1U);
+            const u32 base_dev = compressed_device_addr[phys_addr - 1U];
             if ((base_dev >> MULTI_FLAG_BITS) == 0) [[likely]] {
-                base_dev = 0;
+                compressed_device_addr[phys_addr - 1] = 0;
                 continue;
             }
             const auto [more_entries, new_start] = impl->multi_dev_address.Unregister(
                 static_cast<u32>(start_page_d + i), base_dev & MULTI_MASK);
             if (!more_entries) {
-                base_dev = impl->multi_dev_address.ReleaseEntry(new_start);
+                compressed_device_addr[phys_addr - 1] =
+                    impl->multi_dev_address.ReleaseEntry(new_start);
                 continue;
             }
-            base_dev = new_start | MULTI_FLAG;
+            compressed_device_addr[phys_addr - 1] = new_start | MULTI_FLAG;
         }
     }
     t_slot = {};
@@ -278,8 +285,6 @@ void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtu
     size_t num_pages = Common::AlignUp(size, Memory::YUZU_PAGESIZE) >> Memory::YUZU_PAGEBITS;
     uintptr_t last_ptr = 0;
     size_t page_count = 1;
-
-    tracked_entries.CommitRegion(start_page_d, start_page_d + num_pages);
     for (size_t i = num_pages; i > 0; i--) {
         size_t index = i - 1;
         const VAddr new_vaddress = virtual_address + index * Memory::YUZU_PAGESIZE;
@@ -291,14 +296,14 @@ void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtu
             page_count = 1;
         }
         last_ptr = new_ptr;
-        tracked_entries.GetUnchecked(start_page_d + index).continuity_tracker = static_cast<u32>(page_count) - 1;
+        tracked_entries[start_page_d + index].continuity_tracker = static_cast<u32>(page_count);
     }
 }
 template <typename Traits>
 u8* DeviceMemoryManager<Traits>::GetSpan(const DAddr src_addr, const std::size_t size) {
     size_t page_index = src_addr >> page_bits;
     size_t subbits = src_addr & page_mask;
-    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker+1) << page_bits) >= size + subbits) {
+    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker) << page_bits) >= size + subbits) {
         return GetPointer<u8>(src_addr);
     }
     return nullptr;
@@ -308,7 +313,7 @@ template <typename Traits>
 const u8* DeviceMemoryManager<Traits>::GetSpan(const DAddr src_addr, const std::size_t size) const {
     size_t page_index = src_addr >> page_bits;
     size_t subbits = src_addr & page_mask;
-    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker+1) << page_bits) >= size + subbits) {
+    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker) << page_bits) >= size + subbits) {
         return GetPointer<u8>(src_addr);
     }
     return nullptr;
@@ -378,7 +383,7 @@ void DeviceMemoryManager<Traits>::WalkBlock(DAddr addr, std::size_t size, auto o
     std::size_t page_index = addr >> Memory::YUZU_PAGEBITS;
     std::size_t page_offset = addr & Memory::YUZU_PAGEMASK;
     while (remaining_size) {
-        const size_t next_pages = std::size_t(tracked_entries[page_index].continuity_tracker+1);
+        const size_t next_pages = std::size_t(tracked_entries[page_index].continuity_tracker);
         const std::size_t copy_amount = (std::min)((next_pages << Memory::YUZU_PAGEBITS) - page_offset, remaining_size);
         const auto current_vaddr = u64((page_index << Memory::YUZU_PAGEBITS) + page_offset);
         SCOPE_EXIT{

src/core/file_sys/fs_save_data_types.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -185,13 +185,13 @@ static_assert(sizeof(SaveDataFilter) == 0x48, "SaveDataFilter has invalid size."
 static_assert(std::is_trivially_copyable_v<SaveDataFilter>,
               "Data type must be trivially copyable.");
 
-struct HashSalt {
+struct SaveDataHashSalt {
     static constexpr size_t Size = 32;
 
     std::array<u8, Size> value;
 };
-static_assert(std::is_trivially_copyable_v<HashSalt>, "Data type must be trivially copyable.");
-static_assert(sizeof(HashSalt) == HashSalt::Size);
+static_assert(std::is_trivially_copyable_v<SaveDataHashSalt>, "Data type must be trivially copyable.");
+static_assert(sizeof(SaveDataHashSalt) == SaveDataHashSalt::Size);
 
 struct SaveDataCreationInfo2 {
 
@@ -210,7 +210,7 @@ struct SaveDataCreationInfo2 {
     u8 reserved1;
     bool is_hash_salt_enabled;
     u8 reserved2;
-    HashSalt hash_salt;
+    SaveDataHashSalt hash_salt;
     SaveDataMetaType meta_type;
     u8 reserved3;
     s32 meta_size;

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -1,3 +1,6 @@
+// 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
 
@@ -11,7 +14,7 @@
 #include "core/file_sys/vfs/vfs.h"
 #include "core/file_sys/vfs/vfs_vector.h"
 
-namespace FileSys {
+namespace FileSys::RomFSBuilder {
 
 constexpr u64 FS_MAX_PATH = 0x301;
 

src/core/file_sys/fsmitm_romfsbuild.h

@@ -1,3 +1,6 @@
+// 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
 
@@ -9,7 +12,7 @@
 #include "common/common_types.h"
 #include "core/file_sys/vfs/vfs.h"
 
-namespace FileSys {
+namespace FileSys::RomFSBuilder {
 
 struct RomFSBuildDirectoryContext;
 struct RomFSBuildFileContext;

src/core/file_sys/fssystem/fssystem_hierarchical_integrity_verification_storage.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -124,7 +121,6 @@ size_t HierarchicalIntegrityVerificationStorage::Read(u8* buffer, size_t size,
 }
 
 size_t HierarchicalIntegrityVerificationStorage::GetSize() const {
-    ASSERT(m_data_size >= 0);
     return m_data_size;
 }
 

src/core/file_sys/ips_layer.cpp

@@ -120,7 +120,7 @@ std::array<u8, 32> IPSwitchCompiler::GetBuildID() const {
 
 static IPSwitchRecord EscapeStringSequences(std::string_view sv) {
     IPSwitchRecord r{};
-    for (auto it = sv.cbegin(); it < sv.cend(); ) {
+    for (auto it = sv.cbegin(); it != sv.cend(); ) {
         if (*it == '\\' && it + 1 < sv.cend()) {
             switch (it[1]) {
             case 'a': r.data[r.count] = '\a'; break;
@@ -198,8 +198,6 @@ void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
                 LOG_WARNING(Loader, "Unknown flag {}", line);
                 break;
             }
-        } else if (patches.empty()) {
-            LOG_WARNING(Loader, "Invalid line not in a patch {}", line);
         } else {
             size_t offset = size_t(std::strtoul(line.data(), nullptr, 16));
             offset += size_t(offset_shift);
@@ -255,30 +253,25 @@ void IPSwitchCompiler::Parse(std::span<u8 const> bytes) {
             // now make a nominal preprocessed line: remove comments
             char quote = '\0';
             auto const sline_start = p;
-            auto last_char = p;
             for (; p < sline.cend(); ) {
                 // we dont check for "//", IPS checks for '/' only...
-                if (std::isspace(*p)) {
-                    ++p;
-                } else if ((!quote && p[0] == '/')
+                if ((!quote && p[0] == '/')
                 || (!quote && p[0] == '#')) {
                     break;
                 } else if (p[0] == '\"' || p[0] == '\'') {
                     quote = (p[0] == quote) ? '\0' : p[0];
                     ++p;
-                    last_char = p;
                 } else if (p + 1 < sline.cend() && p[0] == '\\') {
                     p += 2;
-                    last_char = p;
                 } else {
                     ++p;
-                    last_char = p;
                 }
             }
             // now we have the preprocessed string ;)
-            std::string_view const pp_str(sline_start, last_char);
-            if (pp_str.size() > 0 && !parse_line(pp_str))
+            std::string_view pp_str(sline_start, p);
+            if (pp_str.size() > 0 && !parse_line(pp_str)) {
                 break;
+            }
         }
     }
 }

src/core/file_sys/romfs.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -38,7 +38,7 @@ struct RomFSHeader {
 };
 static_assert(sizeof(RomFSHeader) == 0x50, "RomFSHeader has incorrect size.");
 
-struct DirectoryEntry {
+struct RomFSDirectoryEntry {
     u32_le parent;
     u32_le sibling;
     u32_le child_dir;
@@ -46,9 +46,9 @@ struct DirectoryEntry {
     u32_le hash;
     u32_le name_length;
 };
-static_assert(sizeof(DirectoryEntry) == 0x18, "DirectoryEntry has incorrect size.");
+static_assert(sizeof(RomFSDirectoryEntry) == 0x18, "RomFSDirectoryEntry has incorrect size.");
 
-struct FileEntry {
+struct RomFSFileEntry {
     u32_le parent;
     u32_le sibling;
     u64_le offset;
@@ -56,7 +56,7 @@ struct FileEntry {
     u32_le hash;
     u32_le name_length;
 };
-static_assert(sizeof(FileEntry) == 0x20, "FileEntry has incorrect size.");
+static_assert(sizeof(RomFSFileEntry) == 0x20, "RomFSFileEntry has incorrect size.");
 
 struct RomFSTraversalContext {
     RomFSHeader header;
@@ -84,14 +84,14 @@ std::pair<EntryType, std::string> GetEntry(const RomFSTraversalContext& ctx, siz
     return {entry, std::move(name)};
 }
 
-std::pair<DirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx,
+std::pair<RomFSDirectoryEntry, std::string> GetDirectoryEntry(const RomFSTraversalContext& ctx,
                                                          size_t directory_offset) {
-    return GetEntry<DirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset);
+    return GetEntry<RomFSDirectoryEntry, &RomFSTraversalContext::directory_meta>(ctx, directory_offset);
 }
 
-std::pair<FileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx,
+std::pair<RomFSFileEntry, std::string> GetFileEntry(const RomFSTraversalContext& ctx,
                                                size_t file_offset) {
-    return GetEntry<FileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset);
+    return GetEntry<RomFSFileEntry, &RomFSTraversalContext::file_meta>(ctx, file_offset);
 }
 
 void ProcessFile(const RomFSTraversalContext& ctx, u32 this_file_offset,
@@ -163,7 +163,7 @@ VirtualFile CreateRomFS(VirtualDir dir, VirtualDir ext) {
     if (dir == nullptr)
         return nullptr;
 
-    RomFSBuildContext ctx{dir, ext};
+    RomFSBuilder::RomFSBuildContext ctx{dir, ext};
     return ConcatenatedVfsFile::MakeConcatenatedFile(0, dir->GetName(), ctx.Build());
 }
 

src/core/file_sys/vfs/vfs.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -10,6 +10,12 @@
 #include "common/fs/path_util.h"
 #include "core/file_sys/vfs/vfs.h"
 
+#undef CreateFile
+#undef DeleteFile
+#undef CreateDirectory
+#undef CopyFile
+#undef MoveFile
+
 namespace FileSys {
 
 VfsFilesystem::VfsFilesystem(VirtualDir root_) : root(std::move(root_)) {}

src/core/file_sys/vfs/vfs_vector.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -99,6 +99,10 @@ private:
     std::string name;
 };
 
+#undef CreateFile
+#undef DeleteFile
+#undef CreateDirectory
+
 // An implementation of VfsDirectory that maintains two vectors for subdirectories and files.
 // Vector data is supplied upon construction.
 class VectorVfsDirectory : public VfsDirectory {

src/core/hle/kernel/k_page_table_base.cpp

@@ -635,36 +635,6 @@ Result KPageTableBase::CheckMemoryState(const KMemoryInfo& info, KMemoryState st
     R_SUCCEED();
 }
 
-bool KPageTableBase::BeginTraversal(const Common::PageTable &impl, TraversalEntry *out_entry, TraversalContext *out_context,
-    Common::ProcessAddress address) const {
-    out_context->next_offset = GetInteger(address);
-    out_context->next_page = GetInteger(address) >> PageBits;
-
-    return ContinueTraversal(impl, out_entry, out_context);
-}
-
-bool KPageTableBase::ContinueTraversal(const Common::PageTable &impl, TraversalEntry *out_entry,
-    TraversalContext *context) const {
-    // Setup invalid defaults.
-    out_entry->phys_addr = 0;
-    out_entry->block_size = PageSize;
-    // Validate that we can read the actual entry.
-    if (auto const page = context->next_page; page < impl.entries.size()) {
-        // Validate that the entry is mapped.
-        if (auto const paddr = impl.entries[page].Pointer(true); paddr != 0) {
-            // Populate the results and return true
-            out_entry->phys_addr = GetInteger(m_system.DeviceMemory().GetPhysicalAddr(paddr + context->next_offset));
-            context->next_page += 1;
-            context->next_offset += PageSize;
-            return true;
-        }
-    }
-    context->next_page += 1;
-    context->next_offset += PageSize;
-    // Otherwise return false
-    return false;
-}
-
 Result KPageTableBase::CheckMemoryStateContiguous(size_t* out_blocks_needed, KProcessAddress addr,
                                                   size_t size, KMemoryState state_mask,
                                                   KMemoryState state, KMemoryPermission perm_mask,
@@ -970,7 +940,7 @@ Result KPageTableBase::QueryMappingImpl(KProcessAddress* out, KPhysicalAddress a
     size_t tot_size = 0;
 
     next_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), region_start);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), region_start);
     next_entry.block_size =
         (next_entry.block_size - (GetInteger(region_start) & (next_entry.block_size - 1)));
 
@@ -1006,7 +976,7 @@ Result KPageTableBase::QueryMappingImpl(KProcessAddress* out, KPhysicalAddress a
             break;
         }
 
-        next_valid = ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+        next_valid = impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
     }
 
     // Check the last entry.
@@ -1784,7 +1754,7 @@ Result KPageTableBase::MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    R_UNLESS(BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), addr),
+    R_UNLESS(impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), addr),
              ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -1794,7 +1764,7 @@ Result KPageTableBase::MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_
 
     // Iterate, adding to group as we go.
     while (tot_size < size) {
-        R_UNLESS(ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context)),
+        R_UNLESS(impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context)),
                  ResultInvalidCurrentMemory);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -1858,7 +1828,7 @@ bool KPageTableBase::IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    if (!BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), addr)) {
+    if (!impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), addr)) {
         return false;
     }
 
@@ -1869,7 +1839,7 @@ bool KPageTableBase::IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr
 
     // Iterate, comparing expected to actual.
     while (tot_size < size) {
-        if (!ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context))) {
+        if (!impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context))) {
             return false;
         }
 
@@ -1926,7 +1896,7 @@ Result KPageTableBase::GetContiguousMemoryRangeWithState(
     // Begin a traversal.
     TraversalContext context;
     TraversalEntry cur_entry = {.phys_addr = 0, .block_size = 0};
-    R_UNLESS(BeginTraversal(impl, std::addressof(cur_entry), std::addressof(context), address),
+    R_UNLESS(impl.BeginTraversal(std::addressof(cur_entry), std::addressof(context), address),
              ResultInvalidCurrentMemory);
 
     // Traverse until we have enough size or we aren't contiguous any more.
@@ -1935,7 +1905,7 @@ Result KPageTableBase::GetContiguousMemoryRangeWithState(
     for (contig_size =
              cur_entry.block_size - (GetInteger(phys_address) & (cur_entry.block_size - 1));
          contig_size < size; contig_size += cur_entry.block_size) {
-        if (!ContinueTraversal(impl, std::addressof(cur_entry), std::addressof(context))) {
+        if (!impl.ContinueTraversal(std::addressof(cur_entry), std::addressof(context))) {
             break;
         }
         if (cur_entry.phys_addr != phys_address + contig_size) {
@@ -2364,7 +2334,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(m_impl, std::addressof(next_entry), std::addressof(context), virt_addr);
+            m_impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), virt_addr);
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         // Set tracking variables.
@@ -2375,7 +2345,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         while (true) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(m_impl, std::addressof(next_entry), std::addressof(context));
+                m_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             if (!traverse_valid) {
                 break;
             }
@@ -2597,7 +2567,7 @@ Result KPageTableBase::UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddre
         TraversalContext context;
         TraversalEntry next_entry;
         ASSERT(
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_address));
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_address));
 
         // Check that the physical region matches.
         R_UNLESS(next_entry.phys_addr == phys_addr, ResultInvalidMemoryRegion);
@@ -2607,7 +2577,7 @@ Result KPageTableBase::UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddre
                  next_entry.block_size - (GetInteger(phys_addr) & (next_entry.block_size - 1));
              checked_size < size; checked_size += next_entry.block_size) {
             // Continue the traversal.
-            ASSERT(ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context)));
+            ASSERT(impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context)));
 
             // Check that the physical region matches.
             R_UNLESS(next_entry.phys_addr == phys_addr + checked_size, ResultInvalidMemoryRegion);
@@ -3059,7 +3029,7 @@ Result KPageTableBase::InvalidateProcessDataCache(KProcessAddress address, size_
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), address);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3071,7 +3041,7 @@ Result KPageTableBase::InvalidateProcessDataCache(KProcessAddress address, size_
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3159,7 +3129,7 @@ Result KPageTableBase::ReadDebugMemory(KProcessAddress dst_address, KProcessAddr
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_address);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3197,7 +3167,7 @@ Result KPageTableBase::ReadDebugMemory(KProcessAddress dst_address, KProcessAddr
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3255,7 +3225,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_address);
+        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3297,7 +3267,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3758,7 +3728,7 @@ Result KPageTableBase::CopyMemoryFromLinearToUser(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3798,7 +3768,7 @@ Result KPageTableBase::CopyMemoryFromLinearToUser(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3852,7 +3822,7 @@ Result KPageTableBase::CopyMemoryFromLinearToKernel(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3875,7 +3845,7 @@ Result KPageTableBase::CopyMemoryFromLinearToKernel(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3932,7 +3902,7 @@ Result KPageTableBase::CopyMemoryFromUserToLinear(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3971,7 +3941,7 @@ Result KPageTableBase::CopyMemoryFromUserToLinear(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -4027,7 +3997,7 @@ Result KPageTableBase::CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, si
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_addr);
+            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -4050,7 +4020,7 @@ Result KPageTableBase::CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, si
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
+                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -4119,10 +4089,10 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
         bool traverse_valid;
 
         // Begin traversal.
-        traverse_valid = BeginTraversal(src_impl, std::addressof(src_next_entry),
+        traverse_valid = src_impl.BeginTraversal(std::addressof(src_next_entry),
                                                  std::addressof(src_context), src_addr);
         ASSERT(traverse_valid);
-        traverse_valid = BeginTraversal(dst_impl, std::addressof(dst_next_entry),
+        traverse_valid = dst_impl.BeginTraversal(std::addressof(dst_next_entry),
                                                  std::addressof(dst_context), dst_addr);
         ASSERT(traverse_valid);
 
@@ -4157,7 +4127,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
             if (ofs + cur_copy_size != size) {
                 if (cur_src_addr + cur_min_size == cur_src_block_addr + cur_src_size) {
                     // Continue the src traversal.
-                    traverse_valid = ContinueTraversal(src_impl, std::addressof(src_next_entry),
+                    traverse_valid = src_impl.ContinueTraversal(std::addressof(src_next_entry),
                                                                 std::addressof(src_context));
                     ASSERT(traverse_valid);
 
@@ -4168,7 +4138,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
                 if (cur_dst_addr + cur_min_size ==
                     dst_next_entry.phys_addr + dst_next_entry.block_size) {
                     // Continue the dst traversal.
-                    traverse_valid = ContinueTraversal(dst_impl, std::addressof(dst_next_entry),
+                    traverse_valid = dst_impl.ContinueTraversal(std::addressof(dst_next_entry),
                                                                 std::addressof(dst_context));
                     ASSERT(traverse_valid);
 
@@ -4253,10 +4223,10 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
         bool traverse_valid;
 
         // Begin traversal.
-        traverse_valid = BeginTraversal(src_impl, std::addressof(src_next_entry),
+        traverse_valid = src_impl.BeginTraversal(std::addressof(src_next_entry),
                                                  std::addressof(src_context), src_addr);
         ASSERT(traverse_valid);
-        traverse_valid = BeginTraversal(dst_impl, std::addressof(dst_next_entry),
+        traverse_valid = dst_impl.BeginTraversal(std::addressof(dst_next_entry),
                                                  std::addressof(dst_context), dst_addr);
         ASSERT(traverse_valid);
 
@@ -4291,7 +4261,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
             if (ofs + cur_copy_size != size) {
                 if (cur_src_addr + cur_min_size == cur_src_block_addr + cur_src_size) {
                     // Continue the src traversal.
-                    traverse_valid = ContinueTraversal(src_impl, std::addressof(src_next_entry),
+                    traverse_valid = src_impl.ContinueTraversal(std::addressof(src_next_entry),
                                                                 std::addressof(src_context));
                     ASSERT(traverse_valid);
 
@@ -4302,7 +4272,7 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
                 if (cur_dst_addr + cur_min_size ==
                     dst_next_entry.phys_addr + dst_next_entry.block_size) {
                     // Continue the dst traversal.
-                    traverse_valid = ContinueTraversal(dst_impl, std::addressof(dst_next_entry),
+                    traverse_valid = dst_impl.ContinueTraversal(std::addressof(dst_next_entry),
                                                                 std::addressof(dst_context));
                     ASSERT(traverse_valid);
 
@@ -4577,7 +4547,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    bool traverse_valid = BeginTraversal(src_impl, std::addressof(next_entry),
+    bool traverse_valid = src_impl.BeginTraversal(std::addressof(next_entry),
                                                   std::addressof(context), aligned_src_start);
     ASSERT(traverse_valid);
 
@@ -4627,7 +4597,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
         // If the block's size was one page, we may need to continue traversal.
         if (cur_block_size == 0 && aligned_src_size > PageSize) {
             traverse_valid =
-                ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
+                src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             cur_block_addr = next_entry.phys_addr;
@@ -4640,7 +4610,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
     while (aligned_src_start + tot_block_size < mapping_src_end) {
         // Continue the traversal.
         traverse_valid =
-            ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
+            src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         // Process the block.
@@ -4683,7 +4653,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
         if (mapped_block_end + cur_block_size < aligned_src_end &&
             cur_block_size == last_block_size) {
             traverse_valid =
-                ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
+                src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             cur_block_addr = next_entry.phys_addr;
@@ -5631,7 +5601,7 @@ Result KPageTableBase::UnmapProcessMemory(KProcessAddress dst_address, size_t si
             ContiguousRangeInfo(KPageTableBase& pt, KProcessAddress address, size_t size)
                 : m_pt(pt), m_remaining_size(size) {
                 // Begin a traversal.
-                ASSERT(m_pt.BeginTraversal(m_pt.GetImpl(), std::addressof(m_entry),
+                ASSERT(m_pt.GetImpl().BeginTraversal(std::addressof(m_entry),
                                                      std::addressof(m_context), address));
 
                 // Setup tracking fields.
@@ -5662,7 +5632,7 @@ Result KPageTableBase::UnmapProcessMemory(KProcessAddress dst_address, size_t si
             void DetermineContiguousBlockExtents() {
                 // Continue traversing until we're not contiguous, or we have enough.
                 while (m_cur_size < m_remaining_size) {
-                    ASSERT(m_pt.ContinueTraversal(m_pt.GetImpl(), std::addressof(m_entry),
+                    ASSERT(m_pt.GetImpl().ContinueTraversal(std::addressof(m_entry),
                                                             std::addressof(m_context)));
 
                     // If we're not contiguous, we're done.

src/core/hle/kernel/k_page_table_base.h

@@ -370,10 +370,6 @@ private:
                                  size_t num_pages, size_t alignment, size_t offset,
                                  size_t guard_pages) const;
 
-    bool BeginTraversal(const Common::PageTable& impl, TraversalEntry* out_entry, TraversalContext* out_context,
-                        Common::ProcessAddress address) const;
-    bool ContinueTraversal(const Common::PageTable& impl, TraversalEntry* out_entry, TraversalContext* context) const;
-
     Result CheckMemoryStateContiguous(size_t* out_blocks_needed, KProcessAddress addr, size_t size,
                                       KMemoryState state_mask, KMemoryState state,
                                       KMemoryPermission perm_mask, KMemoryPermission perm,
@@ -478,14 +474,7 @@ private:
         // Validate pre-conditions.
         ASSERT(this->IsLockedByCurrentThread());
 
-        if (virt_addr > (1ULL << m_address_space_width)) {
-            return false;
-        }
-
-        *out = m_system.DeviceMemory().GetPhysicalAddr(
-            this->GetImpl().entries[GetInteger(virt_addr) >> PageBits].Pointer(true) + GetInteger(virt_addr));
-
-        return true;
+        return this->GetImpl().GetPhysicalAddress(out, virt_addr);
     }
 
 public:

src/core/hle/kernel/svc.cpp

@@ -13,6 +13,10 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/svc.h"
 
+#undef OutputDebugString
+#undef GetObject
+#undef CreateProcess
+
 namespace Kernel::Svc {
 
 static uint32_t GetArg32(std::span<uint64_t, 8> args, int n) {
@@ -2501,15 +2505,14 @@ void Call(Core::System& system, u32 imm) {
     auto& process = GetCurrentProcess(kernel);
     std::array<uint64_t, 8> args;
     kernel.CurrentPhysicalCore().SaveSvcArguments(process, args);
-    //kernel.EnterSVCProfile();
     LOG_TRACE(Kernel_SVC, "{} [0]={:#x} [1]={:#x} [2]={:#x} [3]={:#x} [4]={:#x} [5]={:#x} [6]={:#x}",
-        imm, GetArg64(args, 0), GetArg64(args, 1), GetArg64(args, 2),
-        GetArg64(args, 3), GetArg64(args, 4), GetArg64(args, 5), GetArg64(args, 6));
-    if (process.Is64Bit()) {
+        imm, GetArg32(args, 0), GetArg32(args, 1), GetArg32(args, 2),
+        GetArg32(args, 3), GetArg32(args, 4), GetArg32(args, 5), GetArg32(args, 6));
+    //kernel.EnterSVCProfile();
+    if (process.Is64Bit())
         Call64(system, imm, args);
-    } else {
+    else
         Call32(system, imm, args);
-    }
     //kernel.ExitSVCProfile();
     kernel.CurrentPhysicalCore().LoadSvcArguments(process, args);
 }

src/core/hle/kernel/svc/svc_info.cpp

@@ -10,15 +10,17 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/svc.h"
-#include "core/hle/kernel/svc_results.h"
-#include "core/hle/kernel/svc_version.h"
 
 namespace Kernel::Svc {
 
 /// Gets system/memory information for the current process
-Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle handle, u64 info_sub_id) {
-    LOG_TRACE(Kernel_SVC, "called info_id={:#x}, info_sub_id={:#x}, handle={:#08x}", info_id_type, info_sub_id, handle);
-    u32 info_id = u32(info_id_type);
+Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle handle,
+               u64 info_sub_id) {
+    LOG_TRACE(Kernel_SVC, "called info_id={:#x}, info_sub_id={:#x}, handle={:#08x}",
+              info_id_type, info_sub_id, handle);
+
+    u32 info_id = static_cast<u32>(info_id_type);
+
     switch (info_id_type) {
     case InfoType::CoreMask:
     case InfoType::PriorityMask:
@@ -51,123 +53,152 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
         case InfoType::CoreMask:
             *result = process->GetCoreMask();
             R_SUCCEED();
+
         case InfoType::PriorityMask:
             *result = process->GetPriorityMask();
             R_SUCCEED();
+
         case InfoType::AliasRegionAddress:
             *result = GetInteger(process->GetPageTable().GetAliasRegionStart());
             R_SUCCEED();
+
         case InfoType::AliasRegionSize:
             *result = process->GetPageTable().GetAliasRegionSize();
             R_SUCCEED();
         case InfoType::HeapRegionAddress:
             *result = GetInteger(process->GetPageTable().GetHeapRegionStart());
             R_SUCCEED();
+
         case InfoType::HeapRegionSize:
             *result = process->GetPageTable().GetHeapRegionSize();
             R_SUCCEED();
+
         case InfoType::AslrRegionAddress:
             *result = GetInteger(process->GetPageTable().GetAliasCodeRegionStart());
             R_SUCCEED();
+
         case InfoType::AslrRegionSize:
             *result = process->GetPageTable().GetAliasCodeRegionSize();
             R_SUCCEED();
+
         case InfoType::StackRegionAddress:
             *result = GetInteger(process->GetPageTable().GetStackRegionStart());
             R_SUCCEED();
+
         case InfoType::StackRegionSize:
             *result = process->GetPageTable().GetStackRegionSize();
             R_SUCCEED();
+
         case InfoType::TotalMemorySize:
             *result = process->GetTotalUserPhysicalMemorySize(system.Kernel());
             R_SUCCEED();
+
         case InfoType::UsedMemorySize:
             *result = process->GetUsedUserPhysicalMemorySize(system.Kernel());
             R_SUCCEED();
+
         case InfoType::SystemResourceSizeTotal:
             *result = process->GetTotalSystemResourceSize();
             R_SUCCEED();
+
         case InfoType::SystemResourceSizeUsed:
             *result = process->GetUsedSystemResourceSize();
             R_SUCCEED();
+
         case InfoType::ProgramId:
             *result = process->GetProgramId();
             R_SUCCEED();
+
         case InfoType::UserExceptionContextAddress:
             *result = GetInteger(process->GetProcessLocalRegionAddress());
             R_SUCCEED();
+
         case InfoType::TotalNonSystemMemorySize:
             *result = process->GetTotalNonSystemUserPhysicalMemorySize(system.Kernel());
             R_SUCCEED();
+
         case InfoType::UsedNonSystemMemorySize:
             *result = process->GetUsedNonSystemUserPhysicalMemorySize(system.Kernel());
             R_SUCCEED();
+
         case InfoType::IsApplication:
             *result = process->IsApplication();
             R_SUCCEED();
+
         case InfoType::FreeThreadCount:
             if (KResourceLimit* resource_limit = process->GetResourceLimit();
                 resource_limit != nullptr) {
-                const auto current_value = resource_limit->GetCurrentValue(Svc::LimitableResource::ThreadCountMax);
-                const auto limit_value = resource_limit->GetLimitValue(Svc::LimitableResource::ThreadCountMax);
+                const auto current_value =
+                    resource_limit->GetCurrentValue(Svc::LimitableResource::ThreadCountMax);
+                const auto limit_value =
+                    resource_limit->GetLimitValue(Svc::LimitableResource::ThreadCountMax);
                 *result = limit_value - current_value;
             } else {
                 *result = 0;
             }
             R_SUCCEED();
+
         case InfoType::AliasRegionExtraSize: {
-            R_UNLESS(info_sub_id == 0, ResultInvalidCombination);
+            if (info_sub_id != 0) {
+                return ResultInvalidCombination;
+            }
+
             KProcess* current_process = GetCurrentProcessPointer(system.Kernel());
             *result = current_process->GetPageTable().GetAliasRegionExtraSize();
+
             R_SUCCEED();
         }
+
         default:
             break;
         }
+
         LOG_ERROR(Kernel_SVC, "Unimplemented svcGetInfo id={:#016x}", info_id);
         R_THROW(ResultInvalidEnumValue);
     }
+
     case InfoType::DebuggerAttached:
         *result = 0;
         R_SUCCEED();
+
     case InfoType::ResourceLimit: {
         R_UNLESS(handle == 0, ResultInvalidHandle);
         R_UNLESS(info_sub_id == 0, ResultInvalidCombination);
+
         KProcess* const current_process = GetCurrentProcessPointer(system.Kernel());
         KHandleTable& handle_table = current_process->GetHandleTable();
-        if (auto const resource_limit = current_process->GetResourceLimit(); resource_limit) {
-            Handle resource_handle{};
-            R_TRY(handle_table.Add(system.Kernel(), std::addressof(resource_handle), resource_limit));
-            *result = resource_handle;
-        } else {
+        const auto resource_limit = current_process->GetResourceLimit();
+        if (!resource_limit) {
             *result = Svc::InvalidHandle;
+            // Yes, the kernel considers this a successful operation.
+            R_SUCCEED();
         }
-        // Yes, the kernel considers this a successful operation either way.
+
+        Handle resource_handle{};
+        R_TRY(handle_table.Add(system.Kernel(), std::addressof(resource_handle), resource_limit));
+
+        *result = resource_handle;
         R_SUCCEED();
     }
+
     case InfoType::RandomEntropy:
         R_UNLESS(handle == 0, ResultInvalidHandle);
         R_UNLESS(info_sub_id < 4, ResultInvalidCombination);
+
         *result = GetCurrentProcess(system.Kernel()).GetRandomEntropy(info_sub_id);
         R_SUCCEED();
-    case InfoType::InitialProcessIdRange: {
-        LOG_WARNING(Kernel_SVC, "(STUBBED) Attempted to query privileged process id bounds, returned 0/64");
-        R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
-        switch (InitialProcessIdRangeInfo(info_sub_id)) {
-        case InitialProcessIdRangeInfo::Minimum:
-            *result = 0; //todo
-            R_SUCCEED();
-        case InitialProcessIdRangeInfo::Maximum:
-            *result = 64; //todo
-            R_SUCCEED();
-        default:
-            R_THROW(ResultInvalidCombination);
-        }
-    }
+
+    case InfoType::InitialProcessIdRange:
+        LOG_WARNING(Kernel_SVC,
+                    "(STUBBED) Attempted to query privileged process id bounds, returned 0");
+        *result = 0;
+        R_SUCCEED();
+
     case InfoType::ThreadTickCount: {
         constexpr u64 num_cpus = 4;
         if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id >= num_cpus) {
-            LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus, info_sub_id);
+            LOG_ERROR(Kernel_SVC, "Core count is out of range, expected {} but got {}", num_cpus,
+                      info_sub_id);
             R_THROW(ResultInvalidCombination);
         }
 
@@ -175,7 +206,8 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
             .GetHandleTable()
             .GetObject<KThread>(system.Kernel(), Handle(handle));
         if (thread.IsNull()) {
-            LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle={:#08x}", Handle(handle));
+            LOG_ERROR(Kernel_SVC, "Thread handle does not exist, handle={:#08x}",
+                      static_cast<Handle>(handle));
             R_THROW(ResultInvalidHandle);
         }
 
@@ -188,6 +220,7 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
         u64 out_ticks = 0;
         if (same_thread && info_sub_id == 0xFFFFFFFFFFFFFFFF) {
             const u64 thread_ticks = current_thread->GetCpuTime();
+
             out_ticks = thread_ticks + (core_timing.GetClockTicks() - prev_ctx_ticks);
         } else if (same_thread && info_sub_id == system.Kernel().CurrentPhysicalCoreIndex()) {
             out_ticks = core_timing.GetClockTicks() - prev_ctx_ticks;
@@ -197,40 +230,19 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
         R_SUCCEED();
     }
     case InfoType::IdleTickCount: {
-        // Verify the requested core is valid.
-        const bool core_valid =
-            (info_sub_id == 0xFFFFFFFFFFFFFFFF)
-            || (info_sub_id == u64(system.Kernel().CurrentPhysicalCoreIndex()));
-        R_UNLESS(core_valid, ResultInvalidCombination);
-
         // Verify the input handle is invalid.
         R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
 
+        // Verify the requested core is valid.
+        const bool core_valid =
+            (info_sub_id == 0xFFFFFFFFFFFFFFFF) ||
+            (info_sub_id == static_cast<u64>(system.Kernel().CurrentPhysicalCoreIndex()));
+        R_UNLESS(core_valid, ResultInvalidCombination);
+
         // Get the idle tick count.
         *result = system.Kernel().CurrentScheduler()->GetIdleThread()->GetCpuTime();
         R_SUCCEED();
     }
-    case InfoType::MesosphereMeta: {
-        enum MesosphereMetaInfo : u64 {
-            KernelVersion = 0,
-            IsKTraceEnabled = 1,
-            IsSingleStepEnabled = 2,
-        };
-        R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
-        switch (MesosphereMetaInfo(info_sub_id)) {
-        case MesosphereMetaInfo::KernelVersion:
-            *result = Kernel::Svc::SupportedKernelVersion;
-            R_SUCCEED();
-        case MesosphereMetaInfo::IsKTraceEnabled:
-            *result = 0;
-            R_SUCCEED();
-        case MesosphereMetaInfo::IsSingleStepEnabled:
-            *result = 0;
-            R_SUCCEED();
-        default:
-            R_THROW(ResultInvalidCombination);
-        }
-    }
     case InfoType::MesosphereCurrentProcess: {
         // Verify the input handle is invalid.
         R_UNLESS(handle == InvalidHandle, ResultInvalidHandle);
@@ -243,11 +255,13 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
         KHandleTable& handle_table = current_process->GetHandleTable();
 
         // Get a new handle for the current process.
-        Handle tmp{};
+        Handle tmp;
         R_TRY(handle_table.Add(system.Kernel(), std::addressof(tmp), current_process));
 
         // Set the output.
         *result = tmp;
+
+        // We succeeded.
         R_SUCCEED();
     }
     default:

src/core/hle/kernel/svc/svc_memory.cpp

@@ -11,7 +11,11 @@
 namespace Kernel::Svc {
 namespace {
 
-constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
+[[nodiscard]] inline constexpr bool IsValidSetAddressRange(u64 address, u64 size) {
+    return address + size > address;
+}
+
+[[nodiscard]] inline constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
     switch (perm) {
     case MemoryPermission::None:
     case MemoryPermission::Read:
@@ -22,13 +26,6 @@ constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
     }
 }
 
-// Checks if address + size is greater than the given address
-// This can return false if the size causes an overflow of a 64-bit type
-// or if the given size is zero.
-constexpr bool IsValidAddressRange(u64 address, u64 size) {
-    return address + size > address;
-}
-
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
@@ -53,14 +50,17 @@ Result MapUnmapMemorySanityChecks(const KProcessPageTable& manager, u64 dst_addr
         R_THROW(ResultInvalidSize);
     }
 
-    if (!IsValidAddressRange(dst_addr, size)) {
+    // Checks if address + size is greater than the given address
+    // This can return false if the size causes an overflow of a 64-bit type
+    // or if the given size is zero.
+    if (!IsValidSetAddressRange(dst_addr, size)) {
         LOG_ERROR(Kernel_SVC,
                   "Destination is not a valid address range, addr={:#016x}, size={:#016x}",
                   dst_addr, size);
         R_THROW(ResultInvalidCurrentMemory);
     }
 
-    if (!IsValidAddressRange(src_addr, size)) {
+    if (!IsValidSetAddressRange(src_addr, size)) {
         LOG_ERROR(Kernel_SVC, "Source is not a valid address range, addr={:#016x}, size={:#016x}",
                   src_addr, size);
         R_THROW(ResultInvalidCurrentMemory);

src/core/hle/kernel/svc/svc_process_memory.cpp

@@ -11,11 +11,11 @@
 namespace Kernel::Svc {
 namespace {
 
-constexpr bool IsValidAddressRange(u64 address, u64 size) {
+[[nodiscard]] inline constexpr bool IsValidAddressRange(u64 address, u64 size) {
     return address + size > address;
 }
 
-constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
+[[nodiscard]] inline constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
     switch (perm) {
     case Svc::MemoryPermission::None:
     case Svc::MemoryPermission::Read:

src/core/hle/service/acc/acc.cpp

@@ -1387,8 +1387,7 @@ public:
             {5, &ACC_U1::GetProfile, "GetProfile"},
             {6, nullptr, "GetProfileDigest"},
             {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
-            {51, &ACC_U1::TrySelectUserWithoutInteractionDeprecated, "TrySelectUserWithoutInteractionDeprecated"},
-            {52, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
+            {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
             {60, &ACC_U1::ListOpenContextStoredUsers, "ListOpenContextStoredUsers"},
             {99, nullptr, "DebugActivateOpenContextRetention"},
             {100, nullptr, "GetUserRegistrationNotifier"},

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

@@ -154,7 +154,6 @@ enum class AppletMessage : u32 {
     DetectLongPressingCaptureButton = 91,
     AlbumScreenShotTaken = 92,
     AlbumRecordingSaved = 93,
-    StartupLogoDisappeared = 95,
 };
 
 enum class LibraryAppletMode : u32 {

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

@@ -91,7 +91,6 @@ struct Applet {
     // Common state
     bool sleep_lock_enabled{};
     bool vr_mode_enabled{};
-    bool vr_mode_enabled_3d{};
     bool lcd_backlight_off_enabled{};
     APM::CpuBoostMode boost_mode{};
     bool request_exit_to_library_applet_at_execute_next_program_enabled{};

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

@@ -73,16 +73,20 @@ Result DisplayLayerManager::CreateManagedDisplayLayer(u64* out_layer_id) {
     R_TRY(m_manager_display_service->CreateManagedLayer(
         out_layer_id, 0, display_id, Service::AppletResourceUserId{m_process->GetProcessId()}));
 
+    m_manager_display_service->SetLayerVisibility(m_visible, *out_layer_id);
+    (void)m_display_service->GetContainer()->SetLayerStackMask(*out_layer_id,
+                                                              this->GetLayerStackMask());
+
     if (m_applet_id != AppletId::Application) {
         (void)m_manager_display_service->SetLayerBlending(m_blending_enabled, *out_layer_id);
         if (m_applet_id == AppletId::OverlayDisplay) {
-            (void)m_manager_display_service->SetLayerZIndex(-1, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(Overlay, *out_layer_id);
             (void)m_display_service->GetContainer()->SetLayerIsOverlay(*out_layer_id, true);
         } else {
-            (void)m_manager_display_service->SetLayerZIndex(1, *out_layer_id);
+            (void)m_manager_display_service->SetLayerZIndex(Foreground, *out_layer_id);
         }
     }
-    (void)m_display_service->GetContainer()->SetLayerZIndex(*out_layer_id, true);
+
     m_managed_display_layers.emplace(*out_layer_id);
 
     R_SUCCEED();
@@ -122,11 +126,12 @@ Result DisplayLayerManager::IsSystemBufferSharingEnabled() {
 
     // Ensure the overlay layer is visible
     m_manager_display_service->SetLayerVisibility(m_visible, m_system_shared_layer_id);
+    (void)m_display_service->GetContainer()->SetLayerStackMask(m_system_shared_layer_id,
+                                                              this->GetLayerStackMask());
     m_manager_display_service->SetLayerBlending(m_blending_enabled, m_system_shared_layer_id);
-    s32 initial_z = 1;
-    (void)m_display_service->GetContainer()->SetLayerZIndex(m_system_shared_layer_id, true);
+    s32 initial_z = Foreground;
     if (m_applet_id == AppletId::OverlayDisplay) {
-        initial_z = -1;
+        initial_z = Overlay;
         (void)m_display_service->GetContainer()->SetLayerIsOverlay(m_system_shared_layer_id, true);
     }
     m_manager_display_service->SetLayerZIndex(initial_z, m_system_shared_layer_id);

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -73,7 +73,8 @@ Result IAllSystemAppletProxiesService::OpenLibraryAppletProxy(
 
 Result IAllSystemAppletProxiesService::OpenOverlayAppletProxy(
     Out<SharedPointer<IOverlayAppletProxy>> out_overlay_applet_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
+    InCopyHandle<Kernel::KProcess> process_handle,
+    InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute) {
     LOG_WARNING(Service_AM, "called");
 
     if (const auto applet = this->GetAppletFromProcessId(pid); applet) {
@@ -88,7 +89,8 @@ Result IAllSystemAppletProxiesService::OpenOverlayAppletProxy(
 
 Result IAllSystemAppletProxiesService::OpenSystemApplicationProxy(
     Out<SharedPointer<IApplicationProxy>> out_system_application_proxy, ClientProcessId pid,
-    InCopyHandle<Kernel::KProcess> process_handle) {
+    InCopyHandle<Kernel::KProcess> process_handle,
+    InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute) {
     LOG_DEBUG(Service_AM, "called");
 
     if (const auto applet = this->GetAppletFromProcessId(pid); applet) {

src/core/hle/service/am/service/all_system_applet_proxies_service.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 2018 yuzu Emulator Project
@@ -36,13 +36,15 @@ private:
                                   InCopyHandle<Kernel::KProcess> process_handle,
                                   InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute);
     Result OpenOverlayAppletProxy(Out<SharedPointer<IOverlayAppletProxy>> out_overlay_applet_proxy,
-                           ClientProcessId pid, InCopyHandle<Kernel::KProcess> process_handle);
+                           ClientProcessId pid, InCopyHandle<Kernel::KProcess> process_handle,
+                           InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute);
     Result OpenLibraryAppletProxyOld(
         Out<SharedPointer<ILibraryAppletProxy>> out_library_applet_proxy, ClientProcessId pid,
         InCopyHandle<Kernel::KProcess> process_handle);
     Result OpenSystemApplicationProxy(
         Out<SharedPointer<IApplicationProxy>> out_system_application_proxy, ClientProcessId pid,
-        InCopyHandle<Kernel::KProcess> process_handle);
+        InCopyHandle<Kernel::KProcess> process_handle,
+        InLargeData<AppletAttribute, BufferAttr_HipcMapAlias> attribute);
     Result GetSystemProcessCommonFunctions();
     Result GetAppletAlternativeFunctions();
 

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

@@ -39,7 +39,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {14, nullptr, "GetWakeupCount"}, //11.0.0+
         {15, nullptr, "Unknown15"}, //19.0.0+
         {20, D<&ICommonStateGetter::PushToGeneralChannel>, "PushToGeneralChannel"},
-        {30, D<&ICommonStateGetter::GetHomeButtonReaderLockAccessor>, "GetHomeButtonReaderLockAccessor"},
+        {30, nullptr, "GetHomeButtonReaderLockAccessor"},
         {31, D<&ICommonStateGetter::GetReaderLockAccessorEx>, "GetReaderLockAccessorEx"}, //2.0.0+
         {32, D<&ICommonStateGetter::GetWriterLockAccessorEx>, "GetWriterLockAccessorEx"}, //7.0.0+
         {40, nullptr, "GetCradleFwVersion"}, //2.0.0+
@@ -65,7 +65,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {100, D<&ICommonStateGetter::SetHandlingHomeButtonShortPressedEnabled>, "SetHandlingHomeButtonShortPressedEnabled"},
         {110, nullptr, "OpenMyGpuErrorHandler"},
         {120, D<&ICommonStateGetter::GetAppletLaunchedHistory>, "GetAppletLaunchedHistory"}, //13.0.0+
-        {130, D<&ICommonStateGetter::EnableStartupLogoDisappearedMessage>, "EnableStartupLogoDisappearedMessage"}, //21.0.0+
+        {130, nullptr, "Unknown130"}, //21.0.0+
         {200, D<&ICommonStateGetter::GetOperationModeSystemInfo>, "GetOperationModeSystemInfo"},
         {300, D<&ICommonStateGetter::GetSettingsPlatformRegion>, "GetSettingsPlatformRegion"},
         {400, nullptr, "ActivateMigrationService"},
@@ -74,17 +74,14 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system_, std::shared_ptr<Ap
         {501, nullptr, "SuppressDisablingSleepTemporarily"},
         {502, nullptr, "IsSleepEnabled"},
         {503, nullptr, "IsDisablingSleepSuppressed"},
-        {600, nullptr, "SetHidInputMagnificationForApplication"}, //20.0.0+
+        {600, nullptr, "Unknown600"}, //20.0.0+
         {610, D<&ICommonStateGetter::Unknown610>, "Unknown610"}, //21.0.0+
         {611, D<&ICommonStateGetter::Unknown611>, "Unknown611"}, //22.0.0+
         {900, D<&ICommonStateGetter::SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled>, "SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled"}, //11.0.0+
         {910, nullptr, "GetLaunchRequiredTick"}, //17.0.0+
-        {1000, D<&ICommonStateGetter::BeginVrMode3d>, "BeginVrMode3d"}, //19.0.0+
-        {1001, D<&ICommonStateGetter::EndVrMode3d>, "EndVrMode3d"}, //19.0.0+
-        {1002, D<&ICommonStateGetter::IsVrModeEnabled3d>, "IsVrModeEnabled3d"}, //19.0.0+
-        {1003, D<&ICommonStateGetter::GetVrLaboGoggleViewport>, "GetVrLaboGoggleViewport"}, //21.0.0+
-        {1004, D<&ICommonStateGetter::GetPanelPhysicalSizeForSpecificTitle>, "GetPanelPhysicalSizeForSpecificTitle"}, //21.0.0+
-        {1005, D<&ICommonStateGetter::GetPanelResolutionForSpecificTitle>, "GetPanelResolutionForSpecificTitle"}, //21.0.0+
+        {1000, nullptr, "BeginVrMode3d"}, //19.0.0+
+        {1001, nullptr, "EndVrMode3d"}, //19.0.0+
+        {1002, nullptr, "IsVrModeEnabled3d"}, //19.0.0+
     };
     // clang-format on
 
@@ -314,12 +311,6 @@ Result ICommonStateGetter::PerformSystemButtonPressingIfInFocus(SystemButtonType
     R_SUCCEED();
 }
 
-Result ICommonStateGetter::EnableStartupLogoDisappearedMessage() {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    m_applet->lifecycle_manager.PushUnorderedMessage(system.Kernel(), AppletMessage::StartupLogoDisappeared);
-    R_SUCCEED();
-}
-
 Result ICommonStateGetter::GetOperationModeSystemInfo(Out<u32> out_operation_mode_system_info) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     *out_operation_mode_system_info = 0;
@@ -364,12 +355,6 @@ Result ICommonStateGetter::PushToGeneralChannel(SharedPointer<IStorage> storage)
     R_SUCCEED();
 }
 
-Result ICommonStateGetter::GetHomeButtonReaderLockAccessor(Out<SharedPointer<ILockAccessor>> out_lock_accessor) {
-    LOG_DEBUG(Service_AM, "called");
-    *out_lock_accessor = std::make_shared<ILockAccessor>(system);
-    R_SUCCEED();
-}
-
 Result ICommonStateGetter::SetHandlingHomeButtonShortPressedEnabled(bool enabled) {
     LOG_DEBUG(Service_AM, "called, enabled={} applet_id={}", enabled, m_applet->applet_id);
 
@@ -378,58 +363,14 @@ Result ICommonStateGetter::SetHandlingHomeButtonShortPressedEnabled(bool enabled
     R_SUCCEED();
 }
 
-Result ICommonStateGetter::Unknown610(u64 unk) {
+Result ICommonStateGetter::Unknown610() {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     R_SUCCEED();
 }
 
-Result ICommonStateGetter::Unknown611(u8 unk) {
+Result ICommonStateGetter::Unknown611() {
     LOG_WARNING(Service_AM, "(STUBBED) called");
     R_SUCCEED();
 }
 
-Result ICommonStateGetter::BeginVrMode3d() {
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->vr_mode_enabled_3d = true;
-    LOG_WARNING(Service_AM, "VR Mode is {}", m_applet->vr_mode_enabled_3d ? "on" : "off");
-    R_SUCCEED();
-}
-
-Result ICommonStateGetter::EndVrMode3d() {
-    std::scoped_lock lk{m_applet->lock};
-    m_applet->vr_mode_enabled_3d = false;
-    LOG_WARNING(Service_AM, "VR Mode is {}", m_applet->vr_mode_enabled_3d ? "on" : "off");
-    R_SUCCEED();
-}
-
-Result ICommonStateGetter::IsVrModeEnabled3d(Out<bool> out_is_vr_mode_enabled_3d) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    std::scoped_lock lk{m_applet->lock};
-    *out_is_vr_mode_enabled_3d = m_applet->vr_mode_enabled_3d;
-    R_SUCCEED();
-}
-
-Result ICommonStateGetter::GetVrLaboGoggleViewport(Out<s32> out_x, Out<s32> out_y, Out<s32> out_width, Out<s32> out_height) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_x = 0;
-    *out_y = 0;
-    *out_width = 1280;
-    *out_height = 720;
-    R_SUCCEED();
-}
-
-Result ICommonStateGetter::GetPanelPhysicalSizeForSpecificTitle(Out<f32> out_width, Out<f32> out_height) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_width = 137250.0f / 1000.0f;
-    *out_height = 77200.0f / 1000.0f;
-    R_SUCCEED();
-}
-
-Result ICommonStateGetter::GetPanelResolutionForSpecificTitle(Out<s32> out_width, Out<s32> out_height) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-    *out_width = 1280;
-    *out_height = 720;
-    R_SUCCEED();
-}
-
 } // namespace Service::AM

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

@@ -56,23 +56,15 @@ private:
     Result GetDefaultDisplayResolution(Out<s32> out_width, Out<s32> out_height);
     Result GetBuiltInDisplayType(Out<s32> out_display_type);
     Result PerformSystemButtonPressingIfInFocus(SystemButtonType type);
-    Result EnableStartupLogoDisappearedMessage();
     Result GetOperationModeSystemInfo(Out<u32> out_operation_mode_system_info);
     Result GetAppletLaunchedHistory(Out<s32> out_count,
                                     OutArray<AppletId, BufferAttr_HipcMapAlias> out_applet_ids);
     Result GetSettingsPlatformRegion(Out<Set::PlatformRegion> out_settings_platform_region);
     Result SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled();
     Result PushToGeneralChannel(SharedPointer<IStorage> storage); // cmd 20
-    Result GetHomeButtonReaderLockAccessor(Out<SharedPointer<ILockAccessor>> out_lock_accessor);
     Result SetHandlingHomeButtonShortPressedEnabled(bool enabled);
-    Result Unknown610(u64 unk);
-    Result Unknown611(u8 unk);
-    Result BeginVrMode3d();
-    Result EndVrMode3d();
-    Result IsVrModeEnabled3d(Out<bool> out_is_vr_mode_enabled_3d);
-    Result GetVrLaboGoggleViewport(Out<s32> out_x, Out<s32> out_y, Out<s32> out_width, Out<s32> out_height);
-    Result GetPanelPhysicalSizeForSpecificTitle(Out<f32> out_width, Out<f32> out_height);
-    Result GetPanelResolutionForSpecificTitle(Out<s32> out_width, Out<s32> out_height);
+    Result Unknown610();
+    Result Unknown611();
 
     void SetCpuBoostMode(HLERequestContext& ctx);
 

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

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -29,14 +26,17 @@ IStorage::~IStorage() = default;
 
 Result IStorage::Open(Out<SharedPointer<IStorageAccessor>> out_storage_accessor) {
     LOG_DEBUG(Service_AM, "called");
+
     R_UNLESS(m_impl->GetHandle() == nullptr, AM::ResultInvalidStorageType);
+
     *out_storage_accessor = std::make_shared<IStorageAccessor>(system, m_impl);
     R_SUCCEED();
 }
 
-Result IStorage::OpenTransferStorage(Out<SharedPointer<ITransferStorageAccessor>> out_transfer_storage_accessor) {
-    LOG_DEBUG(Service_AM, "called");
+Result IStorage::OpenTransferStorage(
+    Out<SharedPointer<ITransferStorageAccessor>> out_transfer_storage_accessor) {
     R_UNLESS(m_impl->GetHandle() != nullptr, AM::ResultInvalidStorageType);
+
     *out_transfer_storage_accessor = std::make_shared<ITransferStorageAccessor>(system, m_impl);
     R_SUCCEED();
 }

src/core/hle/service/audio/audio_in.cpp

@@ -9,13 +9,12 @@
 #include "core/hle/service/ipc_helpers.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioIn;
 
-IAudioIn::IAudioIn(Core::System& system_, Manager& manager, size_t session_id,
-                   const std::string& device_name, const AudioInParameter& in_params,
+IAudioIn::IAudioIn(Core::System& system_, AudioCore::AudioIn::Manager& manager, size_t session_id,
+                   const std::string& device_name, const AudioCore::AudioIn::AudioInParameter& in_params,
                    Kernel::KProcess* handle, u64 applet_resource_user_id)
     : ServiceFramework{system_, "IAudioIn"}, process{handle}, service_context{system_, "IAudioIn"},
-      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<In>(system_,
+      event{service_context.CreateEvent("AudioInEvent")}, impl{std::make_shared<AudioCore::AudioIn::In>(system_,
                                                                                     manager, event,
                                                                                     session_id)} {
     // clang-format off
@@ -71,12 +70,12 @@ Result IAudioIn::Stop() {
     R_RETURN(impl->StopSystem());
 }
 
-Result IAudioIn::AppendAudioInBuffer(InArray<AudioInBuffer, BufferAttr_HipcMapAlias> buffer,
+Result IAudioIn::AppendAudioInBuffer(InArray<AudioCore::AudioIn::AudioInBuffer, BufferAttr_HipcMapAlias> buffer,
                                      u64 buffer_client_ptr) {
     R_RETURN(this->AppendAudioInBufferAuto(buffer, buffer_client_ptr));
 }
 
-Result IAudioIn::AppendAudioInBufferAuto(InArray<AudioInBuffer, BufferAttr_HipcAutoSelect> buffer,
+Result IAudioIn::AppendAudioInBufferAuto(InArray<AudioCore::AudioIn::AudioInBuffer, BufferAttr_HipcAutoSelect> buffer,
                                          u64 buffer_client_ptr) {
     if (buffer.empty()) {
         LOG_ERROR(Service_Audio, "Input buffer is too small for an AudioInBuffer!");

src/core/hle/service/audio/audio_in_manager.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -7,7 +10,6 @@
 #include "core/hle/service/cmif_serialization.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioIn;
 
 IAudioInManager::IAudioInManager(Core::System& system_)
     : ServiceFramework{system_, "audin:u"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
@@ -34,11 +36,11 @@ Result IAudioInManager::ListAudioIns(
     R_RETURN(this->ListAudioInsAutoFiltered(out_audio_ins, out_count));
 }
 
-Result IAudioInManager::OpenAudioIn(Out<AudioInParameterInternal> out_parameter_internal,
+Result IAudioInManager::OpenAudioIn(Out<AudioCore::AudioIn::AudioInParameterInternal> out_parameter_internal,
                                     Out<SharedPointer<IAudioIn>> out_audio_in,
                                     OutArray<AudioDeviceName, BufferAttr_HipcMapAlias> out_name,
                                     InArray<AudioDeviceName, BufferAttr_HipcMapAlias> name,
-                                    AudioInParameter parameter,
+                                    AudioCore::AudioIn::AudioInParameter parameter,
                                     InCopyHandle<Kernel::KProcess> process_handle,
                                     ClientAppletResourceUserId aruid) {
     LOG_DEBUG(Service_Audio, "called");
@@ -53,9 +55,9 @@ Result IAudioInManager::ListAudioInsAuto(
 }
 
 Result IAudioInManager::OpenAudioInAuto(
-    Out<AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
+    Out<AudioCore::AudioIn::AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_name,
-    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioInParameter parameter,
+    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioCore::AudioIn::AudioInParameter parameter,
     InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid) {
     LOG_DEBUG(Service_Audio, "called");
     R_RETURN(this->OpenAudioInProtocolSpecified(out_parameter_internal, out_audio_in, out_name,
@@ -70,10 +72,10 @@ Result IAudioInManager::ListAudioInsAutoFiltered(
 }
 
 Result IAudioInManager::OpenAudioInProtocolSpecified(
-    Out<AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
+    Out<AudioCore::AudioIn::AudioInParameterInternal> out_parameter_internal, Out<SharedPointer<IAudioIn>> out_audio_in,
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_name,
     InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, Protocol protocol,
-    AudioInParameter parameter, InCopyHandle<Kernel::KProcess> process_handle,
+    AudioCore::AudioIn::AudioInParameter parameter, InCopyHandle<Kernel::KProcess> process_handle,
     ClientAppletResourceUserId aruid) {
     LOG_DEBUG(Service_Audio, "called");
 
@@ -104,7 +106,7 @@ Result IAudioInManager::OpenAudioInProtocolSpecified(
 
     auto& out_system = impl->sessions[new_session_id]->GetSystem();
     *out_parameter_internal =
-        AudioInParameterInternal{.sample_rate = out_system.GetSampleRate(),
+        AudioCore::AudioIn::AudioInParameterInternal{.sample_rate = out_system.GetSampleRate(),
                                  .channel_count = out_system.GetChannelCount(),
                                  .sample_format = static_cast<u32>(out_system.GetSampleFormat()),
                                  .state = static_cast<u32>(out_system.GetState())};

src/core/hle/service/audio/audio_out.cpp

@@ -13,10 +13,9 @@
 #include "core/hle/service/service.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioOut;
 
-IAudioOut::IAudioOut(Core::System& system_, Manager& manager, size_t session_id,
-                     const std::string& device_name, const AudioOutParameter& in_params,
+IAudioOut::IAudioOut(Core::System& system_, AudioCore::AudioOut::Manager& manager, size_t session_id,
+                     const std::string& device_name, const AudioCore::AudioOut::AudioOutParameter& in_params,
                      Kernel::KProcess* handle, u64 applet_resource_user_id)
     : ServiceFramework{system_, "IAudioOut"}, service_context{system_, "IAudioOut"},
       event{service_context.CreateEvent("AudioOutEvent")}, process{handle},
@@ -68,12 +67,12 @@ Result IAudioOut::Stop() {
 }
 
 Result IAudioOut::AppendAudioOutBuffer(
-    InArray<AudioOutBuffer, BufferAttr_HipcMapAlias> audio_out_buffer, u64 buffer_client_ptr) {
+    InArray<AudioCore::AudioOut::AudioOutBuffer, BufferAttr_HipcMapAlias> audio_out_buffer, u64 buffer_client_ptr) {
     R_RETURN(this->AppendAudioOutBufferAuto(audio_out_buffer, buffer_client_ptr));
 }
 
 Result IAudioOut::AppendAudioOutBufferAuto(
-    InArray<AudioOutBuffer, BufferAttr_HipcAutoSelect> audio_out_buffer, u64 buffer_client_ptr) {
+    InArray<AudioCore::AudioOut::AudioOutBuffer, BufferAttr_HipcAutoSelect> audio_out_buffer, u64 buffer_client_ptr) {
     if (audio_out_buffer.empty()) {
         LOG_ERROR(Service_Audio, "Input buffer is too small for an AudioOutBuffer!");
         R_THROW(Audio::ResultInsufficientBuffer);

src/core/hle/service/audio/audio_out_manager.cpp

@@ -11,7 +11,6 @@
 #include "core/memory.h"
 
 namespace Service::Audio {
-using namespace AudioCore::AudioOut;
 
 IAudioOutManager::IAudioOutManager(Core::System& system_)
     : ServiceFramework{system_, "audout:u"}
@@ -36,11 +35,11 @@ Result IAudioOutManager::ListAudioOuts(
     R_RETURN(this->ListAudioOutsAuto(out_audio_outs, out_count));
 }
 
-Result IAudioOutManager::OpenAudioOut(Out<AudioOutParameterInternal> out_parameter_internal,
+Result IAudioOutManager::OpenAudioOut(Out<AudioCore::AudioOut::AudioOutParameterInternal> out_parameter_internal,
                                       Out<SharedPointer<IAudioOut>> out_audio_out,
                                       OutArray<AudioDeviceName, BufferAttr_HipcMapAlias> out_name,
                                       InArray<AudioDeviceName, BufferAttr_HipcMapAlias> name,
-                                      AudioOutParameter parameter,
+                                      AudioCore::AudioOut::AudioOutParameter parameter,
                                       InCopyHandle<Kernel::KProcess> process_handle,
                                       ClientAppletResourceUserId aruid) {
     R_RETURN(this->OpenAudioOutAuto(out_parameter_internal, out_audio_out, out_name, name,
@@ -62,10 +61,10 @@ Result IAudioOutManager::ListAudioOutsAuto(
 }
 
 Result IAudioOutManager::OpenAudioOutAuto(
-    Out<AudioOutParameterInternal> out_parameter_internal,
+    Out<AudioCore::AudioOut::AudioOutParameterInternal> out_parameter_internal,
     Out<SharedPointer<IAudioOut>> out_audio_out,
     OutArray<AudioDeviceName, BufferAttr_HipcAutoSelect> out_name,
-    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioOutParameter parameter,
+    InArray<AudioDeviceName, BufferAttr_HipcAutoSelect> name, AudioCore::AudioOut::AudioOutParameter parameter,
     InCopyHandle<Kernel::KProcess> process_handle, ClientAppletResourceUserId aruid) {
     if (!process_handle) {
         LOG_ERROR(Service_Audio, "Failed to get process handle");
@@ -95,7 +94,7 @@ Result IAudioOutManager::OpenAudioOutAuto(
 
     auto& out_system = impl->sessions[new_session_id]->GetSystem();
     *out_parameter_internal =
-        AudioOutParameterInternal{.sample_rate = out_system.GetSampleRate(),
+        AudioCore::AudioOut::AudioOutParameterInternal{.sample_rate = out_system.GetSampleRate(),
                                   .channel_count = out_system.GetChannelCount(),
                                   .sample_format = static_cast<u32>(out_system.GetSampleFormat()),
                                   .state = static_cast<u32>(out_system.GetState())};

src/core/hle/service/audio/audio_renderer.cpp

@@ -4,21 +4,20 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "audio_core/renderer/audio_renderer.h"
 #include "core/hle/service/audio/audio_renderer.h"
 #include "core/hle/service/cmif_serialization.h"
 
 namespace Service::Audio {
-using namespace AudioCore::Renderer;
 
-IAudioRenderer::IAudioRenderer(Core::System& system_, Manager& manager_,
+IAudioRenderer::IAudioRenderer(Core::System& system_, AudioCore::Renderer::Manager& manager_,
                                AudioCore::AudioRendererParameterInternal& params,
                                Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                                Kernel::KProcess* process_handle_, u64 applet_resource_user_id,
                                s32 session_id)
     : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
       rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
-      impl{std::make_unique<Renderer>(system_, manager, rendered_event)}, process_handle{
-                                                                              process_handle_} {
+      impl{std::make_unique<AudioCore::Renderer::Renderer>(system_, manager, rendered_event)}, process_handle{process_handle_} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, D<&IAudioRenderer::GetSampleRate>, "GetSampleRate"},

src/core/hle/service/bcat/news/news_data_service.cpp

@@ -14,16 +14,13 @@
 #include <cstring>
 
 namespace Service::News {
-namespace {
 
-std::string_view ToStringView(std::span<const char> buf) {
+[[nodiscard]] inline std::string_view ToStringViewNDS(std::span<const char> buf) {
     const std::string_view sv{buf.data(), buf.size()};
     const auto nul = sv.find('\0');
     return nul == std::string_view::npos ? sv : sv.substr(0, nul);
 }
 
-} // namespace
-
 INewsDataService::INewsDataService(Core::System& system_)
     : ServiceFramework{system_, "INewsDataService"} {
     static const FunctionInfo functions[] = {
@@ -55,7 +52,7 @@ bool INewsDataService::TryOpen(std::string_view key, std::string_view user) {
 
     const auto list = NewsStorage::Instance().ListAll();
     if (!list.empty()) {
-        if (auto found = NewsStorage::Instance().FindByNewsId(ToStringView(list.front().news_id))) {
+        if (auto found = NewsStorage::Instance().FindByNewsId(ToStringViewNDS(list.front().news_id))) {
             opened_payload = std::move(found->payload);
             return true;
         }
@@ -67,7 +64,7 @@ bool INewsDataService::TryOpen(std::string_view key, std::string_view user) {
 Result INewsDataService::Open(InBuffer<BufferAttr_HipcMapAlias> name) {
     EnsureBuiltinNewsLoaded();
 
-    const auto key = ToStringView({reinterpret_cast<const char*>(name.data()), name.size()});
+    const auto key = ToStringViewNDS({reinterpret_cast<const char*>(name.data()), name.size()});
 
     if (TryOpen(key, {})) {
         R_SUCCEED();
@@ -79,8 +76,8 @@ Result INewsDataService::Open(InBuffer<BufferAttr_HipcMapAlias> name) {
 Result INewsDataService::OpenWithNewsRecordV1(NewsRecordV1 record) {
     EnsureBuiltinNewsLoaded();
 
-    const auto key = ToStringView(record.news_id);
-    const auto user = ToStringView(record.user_id);
+    const auto key = ToStringViewNDS(record.news_id);
+    const auto user = ToStringViewNDS(record.user_id);
 
     if (TryOpen(key, user)) {
         R_SUCCEED();
@@ -92,8 +89,8 @@ Result INewsDataService::OpenWithNewsRecordV1(NewsRecordV1 record) {
 Result INewsDataService::OpenWithNewsRecord(NewsRecord record) {
     EnsureBuiltinNewsLoaded();
 
-    const auto key = ToStringView(record.news_id);
-    const auto user = ToStringView(record.user_id);
+    const auto key = ToStringViewNDS(record.news_id);
+    const auto user = ToStringViewNDS(record.user_id);
 
     if (TryOpen(key, user)) {
         R_SUCCEED();

src/core/hle/service/bcat/news/news_database_service.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -15,13 +15,13 @@
 namespace Service::News {
 namespace {
 
-std::string_view ToStringView(std::span<const u8> buf) {
+[[nodiscard]] inline std::string_view ToStringView(std::span<const u8> buf) {
     if (buf.empty()) return {};
     auto data = reinterpret_cast<const char*>(buf.data());
     return {data, strnlen(data, buf.size())};
 }
 
-std::string_view ToStringView(std::span<const char> buf) {
+[[nodiscard]] inline std::string_view ToStringView(std::span<const char> buf) {
     if (buf.empty()) return {};
     return {buf.data(), strnlen(buf.data(), buf.size())};
 }

src/core/hle/service/bcat/news/overwrite_event_holder.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -6,6 +9,8 @@
 
 namespace Service::News {
 
+#undef CreateEvent
+
 IOverwriteEventHolder::IOverwriteEventHolder(Core::System& system_)
     : ServiceFramework{system_, "IOverwriteEventHolder"}, service_context{system_,
                                                                           "IOverwriteEventHolder"} {

src/core/hle/service/caps/caps_manager.cpp

@@ -18,6 +18,8 @@
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
+#undef GetCurrentTime
+
 namespace Service::Capture {
 
 AlbumManager::AlbumManager(Core::System& system_) : system{system_} {}

src/core/hle/service/fatal/fatal.cpp

@@ -19,6 +19,8 @@
 #include "core/hle/service/server_manager.h"
 #include "core/reporter.h"
 
+#undef far
+
 namespace Service::Fatal {
 
 Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,

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

@@ -32,6 +32,10 @@
 #include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
+#undef CreateFile
+#undef DeleteFile
+#undef CreateDirectory
+
 namespace Service::FileSystem {
 
 static FileSys::VirtualDir GetDirectoryRelativeWrapped(FileSys::VirtualDir base,
@@ -798,7 +802,7 @@ void LoopProcess(Core::System& system) {
     const auto FileSystemProxyFactory = [&] { return std::make_shared<FSP_SRV>(system); };
 
     server_manager->RegisterNamedService("fsp-ldr", std::make_shared<FSP_LDR>(system));
-    server_manager->RegisterNamedService("fsp-pr", std::make_shared<FSP_PR>(system));
+    server_manager->RegisterNamedService("fsp:pr", std::make_shared<FSP_PR>(system));
     server_manager->RegisterNamedService("fsp-srv", std::move(FileSystemProxyFactory));
     ServerManager::RunServer(std::move(server_manager));
 }

src/core/hle/service/hle_ipc.cpp

@@ -27,6 +27,8 @@
 #include "core/hle/service/ipc_helpers.h"
 #include "core/memory.h"
 
+#undef SendMessage
+
 namespace Service {
 
 SessionRequestHandler::SessionRequestHandler(Kernel::KernelCore& kernel_, const char* service_name_)

src/core/hle/service/i2c/i2c.cpp

@@ -32,6 +32,7 @@ public:
         RegisterHandlers(functions);
     }
     ~I2CSession() override = default;
+
     Result Send(InBuffer<BufferAttr_HipcMapAlias> in_data, u32 transaction_option) {
         LOG_WARNING(Service, "(stubbed) topt={}", transaction_option);
         R_THROW(ResultUnknown);
@@ -49,40 +50,21 @@ public:
         : ServiceFramework{system_, "i2c"}
     {
         static const FunctionInfo functions[] = {
-            {0, C<&I2C::OpenSessionForDev>, "OpenSessionForDev"},
+            {0, nullptr, "OpenSessionForDev"},
             {1, C<&I2C::OpenSession>, "OpenSession"},
-            {2, C<&I2C::HasDevice>, "HasDevice"},
-            {3, C<&I2C::HasDeviceForDev>, "HasDeviceForDev"},
-            {4, C<&I2C::OpenSession2>, "OpenSession2"},
+            {2, nullptr, "HasDevice"},
+            {3, nullptr, "HasDeviceForDev"},
+            {4, nullptr, "OpenSession2"},
         };
         RegisterHandlers(functions);
     }
     ~I2C() override = default;
-    Result OpenSessionForDev(OutInterface<I2CSession> out_session, s32 bus_idx, u32 slave_address, u32 addressing_mode, u32 speed_mode) {
+
+    Result OpenSession(I2CDevice device, OutInterface<I2CSession> out_session) {
         LOG_DEBUG(Service, "(stubbed)");
         *out_session = std::make_shared<I2CSession>(system);
         R_SUCCEED();
     }
-    Result OpenSession(OutInterface<I2CSession> out_session, I2CDevice device) {
-        LOG_DEBUG(Service, "(stubbed)");
-        *out_session = std::make_shared<I2CSession>(system);
-        R_SUCCEED();
-    }
-    Result HasDevice(Out<bool> out_has_device, I2CDevice device) {
-        LOG_DEBUG(Service, "(stubbed)");
-        *out_has_device = false;
-        R_SUCCEED();
-    }
-    Result HasDeviceForDev(Out<bool> out_has_device, I2CDevice device) {
-        LOG_DEBUG(Service, "(stubbed)");
-        *out_has_device = false;
-        R_SUCCEED();
-    }
-    Result OpenSession2(OutInterface<I2CSession> out_session, u32 device_code) {
-        LOG_DEBUG(Service, "(stubbed) device_code={}", device_code);
-        *out_session = std::make_shared<I2CSession>(system);
-        R_SUCCEED();
-    }
 };
 
 void LoopProcess(Core::System& system) {

src/core/hle/service/ldn/client_process_monitor.cpp

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/ldn/ldn_results.h"
+#include "core/hle/service/ldn/client_process_monitor.h"
+#include "core/hle/service/ipc_helpers.h"
+
+namespace Service::LDN {
+
+IClientProcessMonitor::IClientProcessMonitor(Core::System& system_)
+    : ServiceFramework{system_, "IClientProcessMonitor"} {
+    static const FunctionInfo functions[] = {
+        {0, D<&IClientProcessMonitor::RegisterClient>, "RegisterClient"},
+    };
+    RegisterHandlers(functions);
+}
+
+IClientProcessMonitor::~IClientProcessMonitor() = default;
+
+Result IClientProcessMonitor::RegisterClient() {
+    LOG_WARNING(Service_LDN, "(STUBBED) called");
+
+    R_SUCCEED();
+}
+
+} // namespace Service::LDN

src/core/hle/service/ldn/client_process_monitor.h

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::LDN {
+
+class IClientProcessMonitor final
+    : public ServiceFramework<IClientProcessMonitor> {
+public:
+    explicit IClientProcessMonitor(Core::System& system_);
+    ~IClientProcessMonitor() override;
+
+private:
+    Result RegisterClient();
+};
+
+} // namespace Service::LDN

src/core/hle/service/ldn/ldn.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -7,6 +7,7 @@
 #include "core/core.h"
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ldn/ldn.h"
+#include "core/hle/service/ldn/client_process_monitor.h"
 #include "core/hle/service/ldn/monitor_service.h"
 #include "core/hle/service/ldn/sf_monitor_service.h"
 #include "core/hle/service/ldn/sf_service.h"
@@ -16,26 +17,6 @@
 
 namespace Service::LDN {
 
-class IClientProcessMonitor final
-    : public ServiceFramework<IClientProcessMonitor> {
-public:
-    explicit IClientProcessMonitor(Core::System& system_)
-        : ServiceFramework{system_, "IClientProcessMonitor"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, D<&IClientProcessMonitor::RegisterClient>, "RegisterClient"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    ~IClientProcessMonitor() override = default;
-private:
-    Result RegisterClient(ClientProcessId pid) {
-        LOG_WARNING(Service_LDN, "(STUBBED) called");
-        R_SUCCEED();
-    }
-};
-
 class IMonitorServiceCreator final : public ServiceFramework<IMonitorServiceCreator> {
 public:
     explicit IMonitorServiceCreator(Core::System& system_) : ServiceFramework{system_, "ldn:m"} {
@@ -44,6 +25,7 @@ public:
             {0, C<&IMonitorServiceCreator::CreateMonitorService>, "CreateMonitorService"}
         };
         // clang-format on
+
         RegisterHandlers(functions);
     }
 

src/core/hle/service/nifm/nifm.cpp

@@ -212,8 +212,9 @@ struct NifmNetworkProfileData {
     NifmWirelessSettingData wireless_setting_data{};
     IpSettingData ip_setting_data{};
 };
+static_assert(sizeof(NifmNetworkProfileData) == 0x18E,
+              "NifmNetworkProfileData has incorrect size.");
 #pragma pack(pop)
-static_assert(sizeof(NifmNetworkProfileData) == 0x18E, "NifmNetworkProfileData has incorrect size.");
 
 struct PendingProfile {
     std::array<char, 0x21> ssid{};

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

@@ -139,7 +139,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {405, nullptr, "ListApplicationControlCacheEntryInfo"},
         {406, nullptr, "GetApplicationControlProperty"},
         {407, &IApplicationManagerInterface::ListApplicationTitle, "ListApplicationTitle"},
-        {408, &IApplicationManagerInterface::ListApplicationIcon, "ListApplicationIcon"},
+        {408, nullptr, "ListApplicationIcon"},
         {411, nullptr, "Unknown411"}, //19.0.0+
         {412, nullptr, "Unknown412"}, //19.0.0+
         {413, nullptr, "Unknown413"}, //19.0.0+
@@ -894,9 +894,4 @@ void IApplicationManagerInterface::ListApplicationTitle(HLERequestContext& ctx)
     IReadOnlyApplicationControlDataInterface(system).ListApplicationTitle(ctx);
 }
 
-void IApplicationManagerInterface::ListApplicationIcon(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NS, "called");
-    IReadOnlyApplicationControlDataInterface(system).ListApplicationIcon(ctx);
-}
-
 } // namespace Service::NS

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

@@ -78,7 +78,6 @@ public:
 
     void PushApplicationRecord(HLERequestContext& ctx);
     void ListApplicationTitle(HLERequestContext& ctx);
-    void ListApplicationIcon(HLERequestContext& ctx);
 
 private:
     KernelHelpers::ServiceContext service_context;

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

@@ -10,9 +10,7 @@
 #include "core/hle/service/ns/query_service.h"
 #include "core/hle/service/ns/service_getter_interface.h"
 #include "core/hle/service/ns/system_update_interface.h"
-#include "core/hle/service/ipc_helpers.h"
-#include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/ns/vulnerability_manager_interface.h"
 #include "core/hle/service/server_manager.h"
 
 namespace Service::NS {
@@ -41,43 +39,6 @@ public:
     }
 };
 
-class IVulnerabilityManagerInterface final
-    : public ServiceFramework<IVulnerabilityManagerInterface> {
-public:
-    explicit IVulnerabilityManagerInterface(Core::System& system_)
-        : ServiceFramework{system_, "ns:vm"} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {1200, D<&IVulnerabilityManagerInterface::NeedsUpdateVulnerability>, "NeedsUpdateVulnerability"},
-            {1201, nullptr, "UpdateSafeSystemVersionForDebug"},
-            {1202, nullptr, "GetSafeSystemVersion"},
-            {3100, D<&IVulnerabilityManagerInterface::GetSafeSystemVersionCheckInfo>, "GetSafeSystemVersionCheckInfo"},
-            {3101, nullptr, "RequestUpdateSafeSystemVersionCheckInfo"},
-            {3102, D<&IVulnerabilityManagerInterface::ResetSafeSystemVersionCheckInfo>, "ResetSafeSystemVersionCheckInfo"},
-        };
-        // clang-format on
-        RegisterHandlers(functions);
-    }
-    ~IVulnerabilityManagerInterface() override = default;
-
-    Result NeedsUpdateVulnerability(Out<bool> out_needs_update_vulnerability) {
-        LOG_WARNING(Service_NS, "(STUBBED)");
-        *out_needs_update_vulnerability = false;
-        R_SUCCEED();
-    }
-
-    Result GetSafeSystemVersionCheckInfo(Out<std::array<u8, 0x20>> out_system_version_check_info) {
-        LOG_WARNING(Service_NS, "(STUBBED)");
-        *out_system_version_check_info = {};
-        R_SUCCEED();
-    }
-
-    Result ResetSafeSystemVersionCheckInfo() {
-        LOG_WARNING(Service_NS, "(STUBBED)");
-        R_SUCCEED();
-    }
-};
-
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
 

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

@@ -10,17 +10,13 @@
 #include <string>
 
 #include "common/stb.h"
-#include "common/logging.h"
 #include "common/settings.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_transfer_memory.h"
-#include "core/hle/result.h"
 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/ns/ns_results.h"
@@ -76,26 +72,24 @@ void SanitizeJPEGImageSize(std::vector<u8>& image) {
 
 // IAsyncValue implementation for ListApplicationTitle
 // https://switchbrew.org/wiki/NS_services#ListApplicationTitle
-class IAsyncValue final : public ServiceFramework<IAsyncValue> {
+class IAsyncValueForListApplicationTitle final : public ServiceFramework<IAsyncValueForListApplicationTitle> {
 public:
-    explicit IAsyncValue(Core::System& system_, s32 offset, s32 size)
-        : ServiceFramework{system_, "IAsyncValue"}
-        , service_context{system_, "IAsyncValue"}
-        , data_offset{offset}
-        , data_size{size}
-    {
+    explicit IAsyncValueForListApplicationTitle(Core::System& system_, s32 offset, s32 size)
+        : ServiceFramework{system_, "IAsyncValue"}, service_context{system_, "IAsyncValue"},
+          data_offset{offset}, data_size{size} {
         static const FunctionInfo functions[] = {
-            {0, D<&IAsyncValue::GetSize>, "GetSize"},
-            {1, D<&IAsyncValue::Get>, "Get"},
-            {2, D<&IAsyncValue::Cancel>, "Cancel"},
-            {3, D<&IAsyncValue::GetErrorContext>, "GetErrorContext"},
+            {0, &IAsyncValueForListApplicationTitle::GetSize, "GetSize"},
+            {1, &IAsyncValueForListApplicationTitle::Get, "Get"},
+            {2, &IAsyncValueForListApplicationTitle::Cancel, "Cancel"},
+            {3, &IAsyncValueForListApplicationTitle::GetErrorContext, "GetErrorContext"},
         };
         RegisterHandlers(functions);
+
         completion_event = service_context.CreateEvent("IAsyncValue:Completion");
         completion_event->GetReadableEvent().Signal(system.Kernel());
     }
 
-    ~IAsyncValue() override {
+    ~IAsyncValueForListApplicationTitle() override {
         service_context.CloseEvent(completion_event);
     }
 
@@ -104,24 +98,35 @@ public:
     }
 
 private:
-    Result GetSize(Out<s64> out_data_size) {
+    void GetSize(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        *out_data_size = data_size;
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push<s64>(data_size);
     }
-    Result Get(OutBuffer<BufferAttr_HipcMapAlias> out_data_offset) {
+
+    void Get(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        std::memcpy(out_data_offset.data(), &data_offset, sizeof(s32));
-        R_SUCCEED();
+        std::vector<u8> buffer(sizeof(s32));
+        std::memcpy(buffer.data(), &data_offset, sizeof(s32));
+        ctx.WriteBuffer(buffer);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
-    Result Cancel() {
+
+    void Cancel(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
-    Result GetErrorContext() {
+
+    void GetErrorContext(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
+
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* completion_event{};
     s32 data_offset;
@@ -139,7 +144,6 @@ IReadOnlyApplicationControlDataInterface::IReadOnlyApplicationControlDataInterfa
         {3, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
         {4, nullptr, "SelectApplicationDesiredLanguage"},
         {5, D<&IReadOnlyApplicationControlDataInterface::GetApplicationControlData2>, "GetApplicationControlData"},
-        {10, &IReadOnlyApplicationControlDataInterface::ListApplicationIcon, "ListApplicationIcon"},
         {13, &IReadOnlyApplicationControlDataInterface::ListApplicationTitle, "ListApplicationTitle"},
         {19, D<&IReadOnlyApplicationControlDataInterface::GetApplicationControlData3>, "GetApplicationControlData"},
     };
@@ -156,7 +160,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
     LOG_INFO(Service_NS, "called with control_source={}, application_id={:016X}",
              application_control_source, application_id);
 
-    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(), system.GetContentProvider()};
+    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(),
+                                   system.GetContentProvider()};
     const auto control = pm.GetControlMetadata();
     const auto size = out_buffer.size();
 
@@ -164,7 +169,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
     const auto total_size = sizeof(FileSys::RawNACP) + icon_size;
 
     if (size < total_size) {
-        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min=0x4000)", size);
+        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min=0x4000)",
+                  size);
         R_THROW(ResultUnknown);
     }
 
@@ -172,7 +178,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
         const auto bytes = control.first->GetRawBytes();
         std::memcpy(out_buffer.data(), bytes.data(), bytes.size());
     } else {
-        LOG_WARNING(Service_NS, "missing NACP data for application_id={:016X}, defaulting to zero", application_id);
+        LOG_WARNING(Service_NS, "missing NACP data for application_id={:016X}, defaulting to zero",
+                    application_id);
         std::memset(out_buffer.data(), 0, sizeof(FileSys::RawNACP));
     }
 
@@ -197,12 +204,15 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationDesiredLanguage(
     // Convert to application language, get priority list
     const auto application_language = ConvertToApplicationLanguage(language_code);
     if (application_language == std::nullopt) {
-        LOG_ERROR(Service_NS, "Could not convert application language! language_code={}", language_code);
+        LOG_ERROR(Service_NS, "Could not convert application language! language_code={}",
+                  language_code);
         R_THROW(Service::NS::ResultApplicationLanguageNotFound);
     }
     const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
     if (!priority_list) {
-        LOG_ERROR(Service_NS, "Could not find application language priorities! application_language={}", *application_language);
+        LOG_ERROR(Service_NS,
+                  "Could not find application language priorities! application_language={}",
+                  *application_language);
         R_THROW(Service::NS::ResultApplicationLanguageNotFound);
     }
 
@@ -246,7 +256,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData2(
     const auto nacp_size = sizeof(FileSys::RawNACP);
 
     if (size < nacp_size) {
-        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min={:08X})", size, nacp_size);
+        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min={:08X})",
+                  size, nacp_size);
         R_THROW(ResultUnknown);
     }
 
@@ -297,81 +308,63 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData2(
     R_SUCCEED();
 }
 
-void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestContext& ctx) {
-    LOG_WARNING(Service_NS, "(stubbed)");
+
+void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
+    /*
+    IPC::RequestParser rp{ctx};
+    auto control_source = rp.PopRaw<u8>();
+    rp.Skip(7, false);
+    auto transfer_memory_size = rp.Pop<u64>();
+    */
+
     const auto app_ids_buffer = ctx.ReadBuffer();
-    const u64 app_count = app_ids_buffer.size() / sizeof(u64);
+    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();
-    size_t out_length = 0;
+
+    constexpr size_t title_entry_size = sizeof(FileSys::LanguageEntry);
+    const size_t total_data_size = app_count * title_entry_size;
+
+    constexpr s32 data_offset = 0;
+
     if (t_mem != nullptr && t_mem->GetOwner() != nullptr && app_count > 0) {
         auto& memory = t_mem->GetOwner()->GetMemory();
         const auto t_mem_address = t_mem->GetSourceAddress();
-        // u64 - app count
-        memory.WriteBlock(t_mem_address + out_length, &app_count, sizeof(u64));
-        out_length += sizeof(u64);
-        // [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()};
-            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);
-        }
-        // [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()};
-            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;
-            }
-        }
-    }
-    auto async_value = std::make_shared<IAsyncValue>(system, 0, s32(out_length));
-    IPC::ResponseBuilder rb{ctx, 2, 1, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, async_value->ReadableEvent());
-    rb.PushIpcInterface(ctx, std::move(async_value));
-}
 
-void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
-    const auto app_ids_buffer = ctx.ReadBuffer();
-    const size_t app_count = app_ids_buffer.size() / 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);
-    const size_t total_data_size = app_count * title_entry_size;
-    constexpr s32 data_offset = 0;
-    if (t_mem != nullptr && app_count > 0) {
-        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 = app_ids_buffer[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
+            const u64 app_id = application_ids[i];
+            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(),
+                                           system.GetContentProvider()};
             const auto control = pm.GetControlMetadata();
+
             FileSys::LanguageEntry entry{};
             if (control.first != nullptr) {
                 entry = control.first->GetLanguageEntry();
             }
+
             const size_t offset = i * title_entry_size;
             memory.WriteBlock(t_mem_address + offset, &entry, title_entry_size);
         }
     }
-    auto async_value = std::make_shared<IAsyncValue>(system, data_offset, s32(total_data_size));
+
+    auto async_value = std::make_shared<IAsyncValueForListApplicationTitle>(
+        system, data_offset, static_cast<s32>(total_data_size));
+
     IPC::ResponseBuilder rb{ctx, 2, 1, 1};
     rb.Push(ResultSuccess);
     rb.PushCopyObjects(ctx, async_value->ReadableEvent());
     rb.PushIpcInterface(ctx, std::move(async_value));
 }
 
-Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData3(OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u32> out_flags_a, Out<u32> out_flags_b, Out<u32> out_actual_size, ApplicationControlSource application_control_source, u8 flag1, u8 flag2, u64 application_id) {
+Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData3(
+   OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u32> out_flags_a, Out<u32> out_flags_b,
+   Out<u32> out_actual_size, ApplicationControlSource application_control_source, u8 flag1, u8 flag2, u64 application_id) {
     LOG_INFO(Service_NS, "called with control_source={}, flags=({:02X},{:02X}), application_id={:016X}",
              application_control_source, flag1, flag2, application_id);
 

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

@@ -34,7 +34,6 @@ public:
         u8 flag1,
         u8 flag2,
         u64 application_id);
-    void ListApplicationIcon(HLERequestContext& ctx);
     void ListApplicationTitle(HLERequestContext& ctx);
     Result GetApplicationControlData3(
         OutBuffer<BufferAttr_HipcMapAlias> out_buffer,

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

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -16,8 +16,10 @@ IReadOnlyApplicationRecordInterface::IReadOnlyApplicationRecordInterface(Core::S
     static const FunctionInfo functions[] = {
         {0, D<&IReadOnlyApplicationRecordInterface::HasApplicationRecord>, "HasApplicationRecord"},
         {1, nullptr, "NotifyApplicationFailure"},
-        {2, D<&IReadOnlyApplicationRecordInterface::IsDataCorruptedResult>, "IsDataCorruptedResult"},
-        {3, D<&IReadOnlyApplicationRecordInterface::ListApplicationRecord>, "ListApplicationRecord"},
+        {2, D<&IReadOnlyApplicationRecordInterface::IsDataCorruptedResult>,
+         "IsDataCorruptedResult"},
+        {3, D<&IReadOnlyApplicationRecordInterface::ListApplicationRecord>,
+         "ListApplicationRecord"},
     };
     // clang-format on
 

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

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/cmif_serialization.h"
+#include "core/hle/service/ns/vulnerability_manager_interface.h"
+
+namespace Service::NS {
+
+IVulnerabilityManagerInterface::IVulnerabilityManagerInterface(Core::System& system_)
+    : ServiceFramework{system_, "ns:vm"} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {1200, D<&IVulnerabilityManagerInterface::NeedsUpdateVulnerability>, "NeedsUpdateVulnerability"},
+        {1201, nullptr, "UpdateSafeSystemVersionForDebug"},
+        {1202, nullptr, "GetSafeSystemVersion"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+IVulnerabilityManagerInterface::~IVulnerabilityManagerInterface() = default;
+
+Result IVulnerabilityManagerInterface::NeedsUpdateVulnerability(
+    Out<bool> out_needs_update_vulnerability) {
+    LOG_WARNING(Service_NS, "(STUBBED) called");
+    *out_needs_update_vulnerability = false;
+    R_SUCCEED();
+}
+
+} // namespace Service::NS

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

@@ -0,0 +1,21 @@
+// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/cmif_types.h"
+#include "core/hle/service/service.h"
+
+namespace Service::NS {
+
+class IVulnerabilityManagerInterface final
+    : public ServiceFramework<IVulnerabilityManagerInterface> {
+public:
+    explicit IVulnerabilityManagerInterface(Core::System& system_);
+    ~IVulnerabilityManagerInterface() override;
+
+private:
+    Result NeedsUpdateVulnerability(Out<bool> out_needs_update_vulnerability);
+};
+
+} // namespace Service::NS

src/core/hle/service/psc/time/clocks/system_clock_core.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
 
@@ -10,6 +13,8 @@
 namespace Service::PSC::Time {
 class ContextWriter;
 
+#undef GetCurrentTime
+
 class SystemClockCore {
 public:
     explicit SystemClockCore(SteadyClockCore& steady_clock) : m_steady_clock{steady_clock} {}

src/core/hle/service/psc/time/system_clock.h

@@ -19,6 +19,8 @@ class System;
 
 namespace Service::PSC::Time {
 
+#undef GetCurrentTime
+
 class SystemClock final : public ServiceFramework<SystemClock> {
 public:
     explicit SystemClock(Core::System& system, SystemClockCore& system_clock_core, bool can_write_clock, bool can_write_uninitialized_clock);

src/core/hle/service/set/setting_formats/device_settings.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
 
@@ -33,15 +30,15 @@ struct DeviceSettings {
     INSERT_PADDING_BYTES(0x20); // Reserved
 
     // nn::settings::system::ConsoleSixAxisSensorAccelerationBias
-    Common::Vec<f32, 3> console_six_axis_sensor_acceleration_bias;
+    Common::Vec3<f32> console_six_axis_sensor_acceleration_bias;
     // nn::settings::system::ConsoleSixAxisSensorAngularVelocityBias
-    Common::Vec<f32, 3> console_six_axis_sensor_angular_velocity_bias;
+    Common::Vec3<f32> console_six_axis_sensor_angular_velocity_bias;
     // nn::settings::system::ConsoleSixAxisSensorAccelerationGain
     std::array<u8, 0x24> console_six_axis_sensor_acceleration_gain;
     // nn::settings::system::ConsoleSixAxisSensorAngularVelocityGain
     std::array<u8, 0x24> console_six_axis_sensor_angular_velocity_gain;
     // nn::settings::system::ConsoleSixAxisSensorAngularVelocityTimeBias
-    Common::Vec<f32, 3> console_six_axis_sensor_angular_velocity_time_bias;
+    Common::Vec3<f32> console_six_axis_sensor_angular_velocity_time_bias;
     // nn::settings::system::ConsoleSixAxisSensorAngularAcceleration
     std::array<u8, 0x24> console_six_axis_sensor_angular_acceleration;
 };

src/core/hle/service/set/setting_formats/system_settings.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 2018 yuzu Emulator Project
@@ -153,15 +153,15 @@ struct SystemSettings {
     INSERT_PADDING_BYTES(0x7FF8); // Reserved
 
     // nn::settings::system::ConsoleSixAxisSensorAccelerationBias
-    Common::Vec<f32, 3> console_six_axis_sensor_acceleration_bias;
+    Common::Vec3<f32> console_six_axis_sensor_acceleration_bias;
     // nn::settings::system::ConsoleSixAxisSensorAngularVelocityBias
-    Common::Vec<f32, 3> console_six_axis_sensor_angular_velocity_bias;
+    Common::Vec3<f32> console_six_axis_sensor_angular_velocity_bias;
     // nn::settings::system::ConsoleSixAxisSensorAccelerationGain
     std::array<u8, 0x24> console_six_axis_sensor_acceleration_gain;
     // nn::settings::system::ConsoleSixAxisSensorAngularVelocityGain
     std::array<u8, 0x24> console_six_axis_sensor_angular_velocity_gain;
     // nn::settings::system::ConsoleSixAxisSensorAngularVelocityTimeBias
-    Common::Vec<f32, 3> console_six_axis_sensor_angular_velocity_time_bias;
+    Common::Vec3<f32> console_six_axis_sensor_angular_velocity_time_bias;
     // nn::settings::system::ConsoleSixAxisSensorAngularAcceleration
     std::array<u8, 0x24> console_six_axis_sensor_angular_velocity_acceleration;
     INSERT_PADDING_BYTES(0x70); // Reserved

src/core/hle/service/spl/csrng.cpp

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/spl/csrng.h"
+
+namespace Service::SPL {
+
+CSRNG::CSRNG(Core::System& system_, std::shared_ptr<Module> module_)
+    : Interface(system_, std::move(module_), "csrng") {
+    static const FunctionInfo functions[] = {
+        {0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"},
+    };
+    RegisterHandlers(functions);
+}
+
+CSRNG::~CSRNG() = default;
+
+} // namespace Service::SPL

src/core/hle/service/spl/csrng.h

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/spl/spl_module.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::SPL {
+
+class CSRNG final : public Module::Interface {
+public:
+    explicit CSRNG(Core::System& system_, std::shared_ptr<Module> module_);
+    ~CSRNG() override;
+};
+
+} // namespace Service::SPL

src/core/hle/service/spl/spl_module.cpp

@@ -13,6 +13,7 @@
 #include "core/hle/api_version.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/hle/service/server_manager.h"
+#include "core/hle/service/spl/csrng.h"
 #include "core/hle/service/spl/spl.h"
 #include "core/hle/service/spl/spl_module.h"
 
@@ -202,18 +203,6 @@ Result Module::Interface::GetConfigImpl(u64* out_config, ConfigItem config_item)
     }
 }
 
-class CSRNG final : public Module::Interface {
-public:
-    explicit CSRNG(Core::System& system_, std::shared_ptr<Module> module_)
-        : Interface(system_, std::move(module_), "csrng") {
-        static const FunctionInfo functions[] = {
-            {0, &CSRNG::GenerateRandomBytes, "GenerateRandomBytes"},
-        };
-        RegisterHandlers(functions);
-    }
-    ~CSRNG() override = default;
-};
-
 void LoopProcess(Core::System& system) {
     auto server_manager = std::make_unique<ServerManager>(system);
     auto module = std::make_shared<Module>();

src/core/hle/service/vi/application_display_service.cpp

@@ -13,7 +13,6 @@
 #include "core/hle/service/vi/manager_display_service.h"
 #include "core/hle/service/vi/system_display_service.h"
 #include "core/hle/service/vi/vi_results.h"
-#include "service_creator.h"
 
 namespace Service::VI {
 
@@ -39,7 +38,6 @@ IApplicationDisplayService::IApplicationDisplayService(Core::System& system_,
         {2031, C<&IApplicationDisplayService::DestroyStrayLayer>, "DestroyStrayLayer"},
         {2101, C<&IApplicationDisplayService::SetLayerScalingMode>, "SetLayerScalingMode"},
         {2102, C<&IApplicationDisplayService::ConvertScalingMode>, "ConvertScalingMode"},
-        {2103, C<&IApplicationDisplayService::Cmd2103>, "Cmd2103"},
         {2450, C<&IApplicationDisplayService::GetIndirectLayerImageMap>, "GetIndirectLayerImageMap"},
         {2451, nullptr, "GetIndirectLayerImageCropMap"},
         {2460, C<&IApplicationDisplayService::GetIndirectLayerImageRequiredMemoryInfo>, "GetIndirectLayerImageRequiredMemoryInfo"},
@@ -291,11 +289,6 @@ Result IApplicationDisplayService::ConvertScalingMode(Out<ConvertedScaleMode> ou
     }
 }
 
-Result IApplicationDisplayService::Cmd2103(Out<std::array<u8, 0x18>> out_unk18) {
-    LOG_WARNING(Service_VI, "(stubbed)");
-    R_SUCCEED();
-}
-
 Result IApplicationDisplayService::GetIndirectLayerImageMap(
     Out<u64> out_size, Out<u64> out_stride,
     OutBuffer<BufferAttr_HipcMapTransferAllowsNonSecure | BufferAttr_HipcMapAlias> out_buffer,

src/core/hle/service/vi/application_display_service.h

@@ -64,7 +64,6 @@ public:
     Result GetDisplayVsyncEvent(OutCopyHandle<Kernel::KReadableEvent> out_vsync_event,
                                 u64 display_id);
     Result ConvertScalingMode(Out<ConvertedScaleMode> out_scaling_mode, NintendoScaleMode mode);
-    Result Cmd2103(Out<std::array<u8, 0x18>> out_unk18);
     Result GetIndirectLayerImageMap(
         Out<u64> out_size, Out<u64> out_stride,
         OutBuffer<BufferAttr_HipcMapTransferAllowsNonSecure | BufferAttr_HipcMapAlias> out_buffer,

src/core/hle/service/vi/shared_buffer_manager.cpp

@@ -300,6 +300,28 @@ Result SharedBufferManager::CreateSession(Kernel::KProcess* owner_process, u64*
             }
         }
 
+        // Claim a presentation slot range.
+        u32 slot_base = 0;
+
+        std::array<bool, SharedBufferMaxSessions> in_use{};
+        for (const auto& [existing_aruid, existing] : m_sessions) {
+            const u32 index = existing.presentation_slot_base / SharedBufferSlotsPerSession;
+
+            if (index < in_use.size())
+                in_use[index] = true;
+        }
+
+        u32 index = 0;
+        while (index < in_use.size() && in_use[index])
+            index++;
+
+        if (index >= in_use.size()) {
+            LOG_ERROR(Service_VI, "Out of shared buffer presentation slots ({} sessions)", SharedBufferMaxSessions);
+            R_THROW(VI::ResultOperationFailed);
+        }
+
+        slot_base = index * SharedBufferSlotsPerSession;
+
         // Map into process.
         Common::ProcessAddress map_address{};
         R_TRY(MapSharedBufferIntoProcessAddressSpace(std::addressof(map_address), m_buffer_page_group,
@@ -308,6 +330,7 @@ Result SharedBufferManager::CreateSession(Kernel::KProcess* owner_process, u64*
         // Create new session.
         auto [it, was_emplaced] = m_sessions.emplace(aruid, SharedBufferSession{});
         auto& session = it->second;
+        session.presentation_slot_base = slot_base;
 
         auto& container = m_nvdrv->GetContainer();
         session.session_id = container.OpenSession(owner_process);

src/core/loader/kip.cpp

@@ -17,11 +17,9 @@
 
 namespace Loader {
 
-namespace {
-constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
+[[nodiscard]] inline constexpr u32 PageAlignSizeKIP(u32 size) {
+    return u32((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
-} // Anonymous namespace
 
 AppLoader_KIP::AppLoader_KIP(FileSys::VirtualFile file_)
     : AppLoader(std::move(file_)), kip(std::make_unique<FileSys::KIP>(file)) {}
@@ -76,11 +74,11 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
                         kip->GetKernelCapabilities());
 
     Kernel::CodeSet codeset;
-    codeset.memory.resize(PageAlignSize(kip->GetBSSOffset()) + kip->GetBSSSize());
+    codeset.memory.resize(PageAlignSizeKIP(kip->GetBSSOffset()) + kip->GetBSSSize());
     const auto load_segment = [&codeset](Kernel::CodeSet::Segment& segment, std::span<const u8> data, u32 offset) {
         segment.addr = offset;
         segment.offset = offset;
-        segment.size = PageAlignSize(u32(data.size()));
+        segment.size = PageAlignSizeKIP(u32(data.size()));
         std::memcpy(codeset.memory.data() + offset, data.data(), data.size());
     };
     load_segment(codeset.CodeSegment(), kip->GetTextSection(), kip->GetTextOffset());

src/core/loader/nro.cpp

@@ -148,8 +148,8 @@ bool AppLoader_NRO::IsHomebrew() {
            nro_header.magic_ext2 == Common::MakeMagic('B', 'R', 'E', 'W');
 }
 
-static constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
+[[nodiscard]] inline constexpr u32 PageAlignSizeNRO(u32 size) {
+    return u32((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 
 static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
@@ -166,9 +166,9 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     }
 
     // Build program image
-    std::vector<u8> program_image(PageAlignSize(nro_header.file_size));
+    std::vector<u8> program_image(PageAlignSizeNRO(nro_header.file_size));
     std::memcpy(program_image.data(), data.data(), program_image.size());
-    if (program_image.size() != PageAlignSize(nro_header.file_size)) {
+    if (program_image.size() != PageAlignSizeNRO(nro_header.file_size)) {
         return {};
     }
 
@@ -176,11 +176,11 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     for (std::size_t i = 0; i < nro_header.segments.size(); ++i) {
         codeset.segments[i].addr = nro_header.segments[i].offset;
         codeset.segments[i].offset = nro_header.segments[i].offset;
-        codeset.segments[i].size = PageAlignSize(nro_header.segments[i].size);
+        codeset.segments[i].size = PageAlignSizeNRO(nro_header.segments[i].size);
     }
 
     // Default .bss to NRO header bss size if MOD0 section doesn't exist
-    u32 bss_size{PageAlignSize(nro_header.bss_size)};
+    u32 bss_size{PageAlignSizeNRO(nro_header.bss_size)};
 
     // Read MOD header
     ModHeader mod_header{};
@@ -190,7 +190,7 @@ static bool LoadNroImpl(Core::System& system, Kernel::KProcess& process,
     const bool has_mod_header{mod_header.magic == Common::MakeMagic('M', 'O', 'D', '0')};
     if (has_mod_header) {
         // Resize program image to include .bss section and page align each section
-        bss_size = PageAlignSize(mod_header.bss_end_offset - mod_header.bss_start_offset);
+        bss_size = PageAlignSizeNRO(mod_header.bss_end_offset - mod_header.bss_start_offset);
     }
 
     codeset.DataSegment().size += bss_size;

src/core/loader/nso.cpp

@@ -41,8 +41,8 @@ struct MODHeader {
 };
 static_assert(sizeof(MODHeader) == 0x1c, "MODHeader has incorrect size.");
 
-constexpr u32 PageAlignSize(u32 size) {
-    return static_cast<u32>((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
+[[nodiscard]] inline constexpr u32 PageAlignSizeNSO(u32 size) {
+    return u32((size + Core::Memory::YUZU_PAGEMASK) & ~Core::Memory::YUZU_PAGEMASK);
 }
 } // Anonymous namespace
 
@@ -128,11 +128,11 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::KProcess& process, Core::
     }
 
     codeset.DataSegment().size += nso_header.segments[2].bss_size;
-    u32 image_size = PageAlignSize(u32(codeset.memory.size()) + nso_header.segments[2].bss_size);
+    u32 image_size = PageAlignSizeNSO(u32(codeset.memory.size()) + nso_header.segments[2].bss_size);
     codeset.memory.resize(image_size);
 
     for (std::size_t i = 0; i < nso_header.segments.size(); ++i) {
-        codeset.segments[i].size = PageAlignSize(codeset.segments[i].size);
+        codeset.segments[i].size = PageAlignSizeNSO(codeset.segments[i].size);
     }
 
     // Apply patches if necessary

src/core/memory.cpp

@@ -101,10 +101,8 @@ struct Memory::Impl {
         }
 
         u64 protect_bytes = 0, protect_begin = 0;
-
-        current_page_table->entries.CommitRegion(vaddr >> YUZU_PAGEBITS, (vaddr + size) >> YUZU_PAGEBITS);
         for (u64 addr = vaddr; addr < vaddr + size; addr += YUZU_PAGESIZE) {
-            const Common::PageType page_type = current_page_table->entries.GetUnchecked(addr >> YUZU_PAGEBITS).Type();
+            const Common::PageType page_type = current_page_table->entries[addr >> YUZU_PAGEBITS].ptr.Type();
             switch (page_type) {
             case Common::PageType::RasterizerCachedMemory:
                 if (protect_bytes > 0) {
@@ -125,14 +123,16 @@ struct Memory::Impl {
     }
 
     [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
-        if (u64 paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Pointer(true); paddr)
-            return reinterpret_cast<u8*>(paddr) + vaddr;
+        Common::PhysicalAddress const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        if (paddr)
+            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
         return {};
     }
 
     [[nodiscard]] u8* GetPointerFromDebugMemory(u64 vaddr) const {
-        if (u64 paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Pointer(true); paddr)
-            return reinterpret_cast<u8*>(paddr) + vaddr;
+        const Common::PhysicalAddress paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
+        if (paddr != 0)
+            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
         return {};
     }
 
@@ -243,12 +243,10 @@ struct Memory::Impl {
         std::size_t page_index = addr >> YUZU_PAGEBITS;
         std::size_t page_offset = addr & YUZU_PAGEMASK;
         bool user_accessible = true;
-
-        current_page_table->entries.CommitRegion(page_index, page_index + (size >> YUZU_PAGEBITS) + 1);
         while (remaining_size != 0) {
             const std::size_t copy_amount = (std::min)(std::size_t(YUZU_PAGESIZE) - page_offset, remaining_size);
             const auto current_vaddr = u64((page_index << YUZU_PAGEBITS) + page_offset);
-            const auto [pointer, type, _] = current_page_table->entries.GetUnchecked(page_index).PointerTypeBlock();
+            const auto [pointer, type] = current_page_table->entries[page_index].ptr.PointerType();
             switch (type) {
             case Common::PageType::Unmapped: {
                 user_accessible = false;
@@ -299,10 +297,10 @@ struct Memory::Impl {
     }
 
     [[nodiscard]] inline const u8* GetSpan(const VAddr addr, const std::size_t size) const noexcept {
-        return (current_page_table->entries[addr >> YUZU_PAGEBITS].Block() == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].Block()) ? GetPointerSilent(addr) : nullptr;
+        return (current_page_table->entries[addr >> YUZU_PAGEBITS].block == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].block) ? GetPointerSilent(addr) : nullptr;
     }
     [[nodiscard]] inline u8* GetSpan(const VAddr addr, const std::size_t size) noexcept {
-        return (current_page_table->entries[addr >> YUZU_PAGEBITS].Block() == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].Block()) ? GetPointerSilent(addr) : nullptr;
+        return (current_page_table->entries[addr >> YUZU_PAGEBITS].block == current_page_table->entries[(addr + size) >> YUZU_PAGEBITS].block) ? GetPointerSilent(addr) : nullptr;
     }
 
     bool WriteBlockImpl(const Common::ProcessAddress addr, const void* buffer, const std::size_t size, bool unsafe) {
@@ -406,14 +404,11 @@ struct Memory::Impl {
         // The region is at a granularity of CPU pages.
 
         const u64 num_pages = ((vaddr + size - 1) >> YUZU_PAGEBITS) - (vaddr >> YUZU_PAGEBITS) + 1;
-
-        current_page_table->entries.CommitRegion(vaddr >> YUZU_PAGEBITS, (vaddr >> YUZU_PAGEBITS) + num_pages);
         for (u64 i = 0; i < num_pages; ++i, vaddr += YUZU_PAGESIZE) {
-            auto& entry = current_page_table->entries.GetUnchecked(vaddr >> YUZU_PAGEBITS);
-            const auto [pointer, type, block] = entry.PointerTypeBlock(true);
+            const Common::PageType page_type = current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Type();
             if (debug) {
                 // Switch page type to debug if now debug
-                switch (type) {
+                switch (page_type) {
                 case Common::PageType::Unmapped:
                     ASSERT(false && "Attempted to mark unmapped pages as debug");
                     break;
@@ -422,14 +417,14 @@ struct Memory::Impl {
                     // Page is already marked.
                     break;
                 case Common::PageType::Memory:
-                    entry.MarkDebug(pointer, block);
+                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::DebugMemory);
                     break;
                 default:
                     UNREACHABLE();
                 }
             } else {
                 // Switch page type to non-debug if now non-debug
-                switch (type) {
+                switch (page_type) {
                 case Common::PageType::Unmapped:
                     ASSERT(false && "Attempted to mark unmapped pages as non-debug");
                     break;
@@ -438,7 +433,8 @@ struct Memory::Impl {
                     // Don't mess with already non-debug or rasterizer memory.
                     break;
                 case Common::PageType::DebugMemory: {
-                    entry.Store(false, Common::PageType::Memory, block, pointer);
+                    u8* const pointer = GetPointerFromDebugMemory(vaddr & ~YUZU_PAGEMASK);
+                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(uintptr_t(pointer) - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
                     break;
                 }
                 default:
@@ -470,10 +466,8 @@ struct Memory::Impl {
         // is different). This assumes the specified GPU address region is contiguous as well.
 
         const u64 num_pages = ((vaddr + size - 1) >> YUZU_PAGEBITS) - (vaddr >> YUZU_PAGEBITS) + 1;
-        current_page_table->entries.CommitRegion(vaddr >> YUZU_PAGEBITS, (vaddr >> YUZU_PAGEBITS) + num_pages);
         for (u64 i = 0; i < num_pages; ++i, vaddr += YUZU_PAGESIZE) {
-            auto& entry = current_page_table->entries.GetUnchecked(vaddr >> YUZU_PAGEBITS);
-            const Common::PageType page_type = entry.Type();
+            const Common::PageType page_type= current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Type();
             if (cached) {
                 // Switch page type to cached if now cached
                 switch (page_type) {
@@ -483,7 +477,7 @@ struct Memory::Impl {
                     break;
                 case Common::PageType::DebugMemory:
                 case Common::PageType::Memory:
-                    entry.MarkRasterizerCached();
+                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::RasterizerCachedMemory);
                     break;
                 case Common::PageType::RasterizerCachedMemory:
                     // There can be more than one GPU region mapped per CPU region, so it's common
@@ -505,13 +499,13 @@ struct Memory::Impl {
                     // that this area is already unmarked as cached.
                     break;
                 case Common::PageType::RasterizerCachedMemory: {
-                    if (auto [ptr, _, block] = entry.PointerTypeBlock(true); ptr == 0) {
+                    if (u8* const pointer = GetPointerFromRasterizerCachedMemory(vaddr & ~YUZU_PAGEMASK); pointer == nullptr) {
                         // It's possible that this function has been called while updating the
                         // pagetable after unmapping a VMA. In that case the underlying VMA will no
                         // longer exist, and we should just leave the pagetable entry blank.
-                        entry.Store(false, Common::PageType::Unmapped, block, 0);
+                        current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::Unmapped);
                     } else {
-                        entry.Store(false, Common::PageType::Memory, block, ptr);
+                        current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(uintptr_t(pointer) - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
                     }
                     break;
                 }
@@ -545,18 +539,22 @@ struct Memory::Impl {
             ASSERT_MSG(type != Common::PageType::Memory,
                        "Mapping memory page without a pointer @ {:016x}", base * YUZU_PAGESIZE);
 
-            page_table.entries.ZeroRegion(base, end);
-        } else {
-            auto current_block = block_count.fetch_add(1, std::memory_order_relaxed);
-            ASSERT(current_block != 65535);
-
-            page_table.entries.CommitRegion(base, end);
             while (base != end) {
-                auto host_ptr = reinterpret_cast<u64>(system.DeviceMemory().GetPointer<u8>(target)) - (base << YUZU_PAGEBITS);;
-                auto& entry = page_table.entries.GetUnchecked(base);
+                page_table.entries[base].ptr.Store(0, type);
+                page_table.entries[base].addr = 0;
+                page_table.entries[base].block = 0;
+                base += 1;
+            }
+        } else {
+            auto orig_base = base;
+            while (base != end) {
+                auto host_ptr = uintptr_t(system.DeviceMemory().GetPointer<u8>(target)) - (base << YUZU_PAGEBITS);
+                auto backing = GetInteger(target) - (base << YUZU_PAGEBITS);
+                page_table.entries[base].ptr.Store(host_ptr, type);
+                page_table.entries[base].addr = backing;
+                page_table.entries[base].block = orig_base << YUZU_PAGEBITS;
 
-                entry.Store(false, type, current_block, host_ptr);
-                ASSERT_MSG(page_table.entries[base].Pointer(),
+                ASSERT_MSG(page_table.entries[base].ptr.Pointer(),
                            "memory mapping base yield a nullptr within the table");
 
                 base += 1;
@@ -571,11 +569,11 @@ struct Memory::Impl {
         vaddr &= 0xffffffffffffULL;
         if (AddressSpaceContains(*current_page_table, vaddr, 1)) [[likely]] {
             // Avoid adding any extra logic to this fast-path block
-            const auto raw = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Raw();
-            if (auto pointer = Common::PageTable::PageEntryData::ExtractPointer(raw); pointer) [[likely]] {
+            const uintptr_t raw_pointer = current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Raw();
+            if (const uintptr_t pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) [[likely]] {
                 return reinterpret_cast<u8*>(pointer + vaddr);
             } else {
-                switch (static_cast<Common::PageType>(raw.type)) {
+                switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
                 case Common::PageType::Memory:
                     ASSERT_MSG(false, "Mapped memory page without a pointer @ {:#016x}", vaddr);
                     return nullptr;
@@ -775,7 +773,6 @@ struct Memory::Impl {
 #else
     Common::HostMemory* host_buffer{};
 #endif
-    std::atomic<u16> block_count = 0;
 };
 
 Memory::Memory(Core::System& system_) : system{system_} {
@@ -814,7 +811,7 @@ bool Memory::IsValidVirtualAddress(const Common::ProcessAddress vaddr) const {
     if (page >= page_table.entries.size()) {
         return false;
     }
-    const auto [pointer, type, _] = page_table.entries[page].PointerTypeBlock();
+    const auto [pointer, type] = page_table.entries[page].ptr.PointerType();
     return pointer != 0 || type == Common::PageType::RasterizerCachedMemory ||
            type == Common::PageType::DebugMemory;
 }

src/core/memory/cheat_engine.cpp

@@ -21,6 +21,8 @@
 #include "hid_core/resource_manager.h"
 #include "hid_core/resources/npad/npad.h"
 
+#undef CreateEvent
+
 namespace Core::Memory {
 namespace {
 constexpr auto CHEAT_ENGINE_NS = std::chrono::nanoseconds{1000000000 / 12};

src/core/reporter.cpp

@@ -28,6 +28,8 @@
 #include "core/memory.h"
 #include "core/reporter.h"
 
+#undef far
+
 namespace {
 
 std::filesystem::path GetPath(std::string_view type, u64 title_id, std::string_view timestamp) {

src/core/tools/freezer.cpp

@@ -52,6 +52,8 @@ void MemoryWriteWidth(Core::Memory::Memory& memory, u32 width, VAddr addr, u64 v
 
 } // Anonymous namespace
 
+#undef CreateEvent
+
 Freezer::Freezer(Core::Timing::CoreTiming& core_timing_, Core::Memory::Memory& memory_)
     : core_timing{core_timing_}, memory{memory_} {
     event = Core::Timing::CreateEvent("MemoryFreezer::FrameCallback",

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

@@ -371,10 +371,8 @@ EmitConfig A32AddressSpace::GetEmitConfig() {
 
         .page_table_pointer = std::bit_cast<u64>(conf.page_table),
         .page_table_address_space_bits = 32,
-        .page_table_pointer_mask = conf.page_table_pointer_mask,
+        .page_table_pointer_mask_bits = conf.page_table_pointer_mask_bits,
         .page_table_log2_stride = conf.page_table_log2_stride,
-        .page_table_marked_bit = conf.page_table_marked_bit,
-        .page_table_sign_extension = conf.page_table_sign_extension,
         .silently_mirror_page_table = true,
         .absolute_offset_page_table = conf.absolute_offset_page_table,
         .detect_misaligned_access_via_page_table = conf.detect_misaligned_access_via_page_table,