2026-09-21 02:08:29

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

src/audio_core/adsp/adsp.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 2023 yuzu Emulator Project
@@ -19,6 +19,10 @@ ADSP::ADSP(Core::System& system, Sink::Sink& sink) {
     }
 }
 
+void ADSP::NotifyShutdown() {
+    opus_decoder->NotifyShutdown();
+}
+
 AudioRenderer::AudioRenderer& ADSP::AudioRenderer() {
     return *audio_renderer;
 }

src/audio_core/adsp/adsp.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 2023 yuzu Emulator Project
@@ -45,6 +45,7 @@ public:
     explicit ADSP(Core::System& system, Sink::Sink& sink);
     ~ADSP() = default;
 
+    void NotifyShutdown();
     AudioRenderer::AudioRenderer& AudioRenderer();
     OpusDecoder::OpusDecoder& OpusDecoder();
 

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

@@ -82,6 +82,9 @@ void OpusDecoder::Main(std::stop_token stop_token) {
 
     while (!stop_token.stop_requested()) {
         auto msg = Receive(Direction::DSP, stop_token);
+        if (stop_token.stop_requested())
+            break;
+
         switch (msg) {
         case Shutdown:
             Send(Direction::Host, Message::ShutdownOK);
@@ -266,4 +269,10 @@ void OpusDecoder::Main(std::stop_token stop_token) {
     }
 }
 
+void OpusDecoder::NotifyShutdown() {
+    init_thread.request_stop();
+    main_thread.request_stop();
+    Send(Direction::DSP, Message::Shutdown);
+}
+
 } // namespace AudioCore::ADSP::OpusDecoder

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

@@ -67,6 +67,8 @@ public:
         shared_memory = &shared_memory_;
     }
 
+    void NotifyShutdown();
+
 private:
     /**
      * Initializing thread, launched at audio_core boot to avoid blocking the main emu boot thread.

src/audio_core/audio_core.cpp

@@ -31,6 +31,11 @@ void AudioCore::CreateSinks() {
     input_sink = Sink::CreateSinkFromID(sink_id.GetValue(), audio_input_device_id.GetValue());
 }
 
+void AudioCore::NotifyShutdown() {
+    audio_manager->NotifyShutdown();
+    adsp->NotifyShutdown();
+}
+
 void AudioCore::Shutdown() {
     audio_manager->Shutdown();
 }

src/audio_core/audio_core.h

@@ -24,6 +24,8 @@ public:
     explicit AudioCore(Core::System& system);
     ~AudioCore();
 
+    void NotifyShutdown();
+
     /**
      * Shutdown the audio core.
      */

src/audio_core/audio_manager.cpp

@@ -17,7 +17,7 @@ AudioManager::AudioManager() {
         std::unique_lock l{events.GetAudioEventLock()};
         events.ClearEvents();
         while (!stop_token.stop_requested()) {
-            const auto timed_out{events.Wait(l, std::chrono::seconds(2))};
+            const auto timed_out = events.Wait(l, std::chrono::seconds{2});
             if (events.CheckAudioEventSet(Event::Type::Max)) {
                 break;
             }
@@ -34,6 +34,11 @@ AudioManager::AudioManager() {
     });
 }
 
+void AudioManager::NotifyShutdown() {
+    events.SetAudioEvent(Event::Type::Max, true);
+    thread.request_stop();
+}
+
 void AudioManager::Shutdown() {
     events.SetAudioEvent(Event::Type::Max, true);
     if (thread.joinable()) {

src/audio_core/audio_manager.h

@@ -39,9 +39,10 @@ class AudioManager {
 public:
     explicit AudioManager();
 
-    /**
-     * Shutdown the audio manager.
-     */
+    /// @brief Notify of impending shutdown
+    void NotifyShutdown();
+
+    /// @brief Shutdown the audio manager.
     void Shutdown();
 
     /**

src/audio_core/renderer/sink/circular_buffer_sink_info.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
 
@@ -35,7 +38,7 @@ void CircularBufferSinkInfo::Update(BehaviorInfo::ErrorInfo& error_info, OutStat
     auto current_params{reinterpret_cast<CircularBufferInParameter*>(parameter.data())};
     auto current_state{reinterpret_cast<CircularBufferState*>(state.data())};
 
-    if (in_use == buffer_params->in_use && !buffer_unmapped) {
+    if (in_use == bool(buffer_params->in_use) && !buffer_unmapped) {
         error_info.error_code = ResultSuccess;
         error_info.address = CpuAddr(0);
         out_status.writeOffset = current_state->last_pos2;

src/audio_core/renderer/sink/sink_info_base.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 2022 yuzu Emulator Project
@@ -31,10 +31,10 @@ public:
     };
 
     struct DeviceInParameter {
-        /* 0x000 */ char name[0x100];
+        /* 0x000 */ u8 name[0x100];
         /* 0x100 */ u32 input_count;
         /* 0x104 */ std::array<s8, MaxChannels> inputs;
-        /* 0x10A */ char unk10A[0x1];
+        /* 0x10A */ u8 unk10A[0x1];
         /* 0x10B */ bool downmix_enabled;
         /* 0x10C */ std::array<f32, 4> downmix_coeff;
     };
@@ -43,7 +43,7 @@ public:
     struct DeviceState {
         /* 0x00 */ UpsamplerInfo* upsampler_info;
         /* 0x08 */ std::array<Common::FixedPoint<16, 16>, 4> downmix_coeff;
-        /* 0x18 */ char unk18[0x18];
+        /* 0x18 */ u8 unk18[0x18];
     };
     static_assert(sizeof(DeviceState) == 0x30, "DeviceState has the wrong size!");
 
@@ -55,8 +55,8 @@ public:
         /* 0x14 */ u32 previous_pos;
         /* 0x18 */ SampleFormat format;
         /* 0x1C */ std::array<s8, MaxChannels> inputs;
-        /* 0x22 */ bool in_use;
-        /* 0x23 */ char unk23[0x5];
+        /* 0x22 */ u8 in_use;
+        /* 0x23 */ u8 unk23[0x5];
     };
     static_assert(sizeof(CircularBufferInParameter) == 0x28,
                   "CircularBufferInParameter has the wrong size!");
@@ -65,16 +65,16 @@ public:
         /* 0x00 */ u32 last_pos2;
         /* 0x04 */ s32 current_pos;
         /* 0x08 */ u32 last_pos;
-        /* 0x0C */ char unk0C[0x4];
+        /* 0x0C */ u8 unk0C[0x4];
         /* 0x10 */ AddressInfo address_info;
     };
     static_assert(sizeof(CircularBufferState) == 0x30, "CircularBufferState has the wrong size!");
 
     struct InParameter {
         /* 0x000 */ Type type;
-        /* 0x001 */ bool in_use;
+        /* 0x001 */ u8 in_use;
         /* 0x004 */ u32 node_id;
-        /* 0x008 */ char unk08[0x18];
+        /* 0x008 */ u8 unk08[0x18];
         union {
             /* 0x020 */ DeviceInParameter device;
             /* 0x020 */ CircularBufferInParameter circular_buffer;
@@ -84,7 +84,7 @@ public:
 
     struct OutStatus {
         /* 0x00 */ u32 writeOffset;
-        /* 0x04 */ char unk04[0x1C];
+        /* 0x04 */ u8 unk04[0x1C];
     }; // size == 0x20
     static_assert(sizeof(OutStatus) == 0x20, "SinkInfoBase::OutStatus has the wrong size!");
 
@@ -162,19 +162,18 @@ public:
     u8* GetParameter();
 
 protected:
-    /// Type of this sink
-    Type type{Type::Invalid};
-    /// Is this sink in use?
-    bool in_use{};
-    /// Is this sink's buffer unmapped? Circular only
-    bool buffer_unmapped{};
-    /// Node id for this sink
-    u32 node_id{};
     /// State buffer for this sink
     std::array<u8, (std::max)(sizeof(DeviceState), sizeof(CircularBufferState))> state{};
     /// Parameter buffer for this sink
-    std::array<u8, (std::max)(sizeof(DeviceInParameter), sizeof(CircularBufferInParameter))>
-        parameter{};
+    std::array<u8, (std::max)(sizeof(DeviceInParameter), sizeof(CircularBufferInParameter))> parameter{};
+    /// Type of this sink
+    Type type{Type::Invalid};
+    /// Node id for this sink
+    u32 node_id{};
+    /// Is this sink in use?
+    bool in_use : 1 = false;
+    /// Is this sink's buffer unmapped? Circular only
+    bool buffer_unmapped : 1 = false;
 };
 
 } // namespace AudioCore::Renderer

src/common/CMakeLists.txt

@@ -108,7 +108,8 @@ add_library(
     settings_setting.h
     slot_vector.h
     socket_types.h
-    spin_lock.h
+    sparse_large_vector.cpp
+    sparse_large_vector.h
     stb.cpp
     stb.h
     steady_clock.cpp
@@ -137,8 +138,6 @@ 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/fiber.cpp

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

src/common/host_memory.cpp

@@ -178,6 +178,14 @@ 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)) {
@@ -398,6 +406,10 @@ 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) {
@@ -422,7 +434,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, -1, 0);
+                 MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_NOCORE, -1, 0);
 
         // If we successfully mapped, we're done.
         if (reinterpret_cast<uintptr_t>(map_pointer) == hint_address) {
@@ -442,11 +454,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, -1, 0);
+    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER | MAP_NOCORE, -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, -1, 0);
+    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_NOCORE, -1, 0);
 }
 
 #endif
@@ -540,13 +552,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, -1, 0));
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_NOCORE, -1, 0));
             if (fd > 0) {
                 fd = -1;
                 close(fd);
             }
         } else {
-            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
+            backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NOCORE, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -570,6 +582,14 @@ 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);
@@ -690,12 +710,10 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
 {
 #if defined(__OPENORBIS__) || defined(__managarm__)
     LOG_WARNING(HW_Memory, "Platform doesn't support fastmem");
-    fallback_buffer.emplace(backing_size);
-    backing_base = fallback_buffer->data();
+    backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
     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;
@@ -706,16 +724,26 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
             virtual_base_offset = virtual_base - impl->virtual_base;
         }
     } else {
-        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();
+        fallback_buffer = true;
+        backing_base = static_cast<u8*>(impl->Allocate(backing_size));
         virtual_base = nullptr;
+        impl.reset();
     }
 #endif
 }
 
-HostMemory::~HostMemory() = default;
+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(HostMemory&&) noexcept = default;
 

src/common/host_memory.h

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

src/common/page_table.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 2019 yuzu Emulator Project
@@ -13,39 +13,11 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-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);
+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);
     current_address_space_width_in_bits = address_space_width_in_bits;
-    page_size = 1ULL << page_size_in_bits;
+    current_page_bits = page_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,
+    Unmapped = 0b00,
     /// Page is mapped to regular memory. This is the only type you can get pointers to.
-    Memory,
+    Memory = 0b01,
     /// Page is mapped to regular memory, but inaccessible from CPU fastmem and must use
     /// the callbacks.
-    DebugMemory,
+    DebugMemory = 0b10,
     /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
     /// invalidation
-    RasterizerCachedMemory,
+    RasterizerCachedMemory = 0b11,
 };
 
 /**
@@ -42,57 +42,86 @@ struct PageTable {
         u64 next_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;
+    /// 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
 
     /**
-     * Pair of host pointer and page type attribute.
-     * This uses the lower bits of a given pointer to store the attribute tag.
+     * Atomic tuple of host pointer, page type, and block id.
+     * This uses the lower bits of a given pointer to store the attributes.
      * 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 PageInfo {
+    class PageEntryData {
     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() const noexcept {
-            return ExtractPointer(raw.load(std::memory_order_relaxed));
+        [[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);
         }
 
         /// Returns the page type attribute
         [[nodiscard]] PageType Type() const noexcept {
-            return ExtractType(raw.load(std::memory_order_relaxed));
+            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)));
         }
 
         /// Returns the page pointer and attribute pair, extracted from the same atomic read
-        [[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)};
+        [[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)};
         }
 
-        /// 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);
+        /// Write page info atomically
+        inline void Store(bool marked, PageType type, u16 block, uintptr_t pointer) noexcept {
+            data_raw.store(std::bit_cast<u64>(Data{marked, type, block, pointer}));
         }
 
-        /// Write a page pointer and type pair atomically
-        void Store(uintptr_t pointer, PageType type) noexcept {
-            raw.store(pointer | uintptr_t(type));
+        inline void MarkRasterizerCached() noexcept {
+            data_raw.fetch_or(0b111);
+        }
+
+        inline void MarkDebug(u64 ptr, u16 block) noexcept {
+            Store(true, PageType::DebugMemory, block, ptr);
         }
 
         /// Unpack a pointer from a page info raw representation
-        [[nodiscard]] static uintptr_t ExtractPointer(uintptr_t raw) noexcept {
-            return raw & (~uintptr_t{0} << ATTRIBUTE_BITS);
+        [[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);
         }
 
-        /// 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));
+        [[nodiscard]] static u16 ExtractBlock(Data raw) noexcept {
+            return static_cast<u16>(raw.block | (raw.block2 << 9));
         }
 
     private:
-        std::atomic<uintptr_t> raw;
+        std::atomic<u64> data_raw;
+        static_assert(sizeof(Data) == sizeof(std::atomic<u64>));
     };
 
     PageTable();
@@ -100,13 +129,8 @@ struct PageTable {
 
     PageTable(const PageTable&) = delete;
     PageTable& operator=(const PageTable&) = 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;
+    PageTable(PageTable&&) noexcept = delete;
+    PageTable& operator=(PageTable&&) noexcept = delete;
 
     /**
      * Resizes the page table to be able to accommodate enough pages within
@@ -121,30 +145,14 @@ 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`.
-    struct PageEntryData {
-        PageInfo ptr;
-        u64 block;
-        u64 addr;
-        u64 padding;
-    };
-    VirtualBuffer<PageEntryData> entries;
-    static_assert(sizeof(PageEntryData) == 32);
+    SparseLargeVector<PageEntryData> entries;
+    static_assert(sizeof(PageEntryData) == 8);
 
     u8* fastmem_arena{};
     std::size_t current_address_space_width_in_bits{};
-    std::size_t page_size{};
+    std::size_t current_page_bits{};
 };
 
 } // namespace Common

src/common/sparse_large_vector.cpp

@@ -0,0 +1,143 @@
+// 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

@@ -0,0 +1,195 @@
+// 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>
+    // MSVC doesn't regard structs with atomics as trivially copyable
+    // 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/virtual_buffer.cpp

@@ -1,44 +0,0 @@
-// 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

@@ -1,84 +0,0 @@
-// 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/arm/dynarmic/arm_dynarmic_32.cpp

@@ -156,12 +156,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));
 
-        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;
+        // 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 = uint8_t(0);
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
         config.only_detect_misalignment_via_page_table_on_page_boundary = true;
@@ -172,6 +172,13 @@ 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 = std::uint8_t(Common::PageTable::SIGN_BIT);
+        }
     }
 
     // Multi-process state
@@ -404,6 +411,7 @@ 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

@@ -197,13 +197,12 @@ void ArmDynarmic64::MakeJit(Common::PageTable* page_table, std::size_t address_s
 
     // Memory
     if (page_table) {
-        constexpr size_t PageLog2Stride = 5;
-        static_assert(1 << PageLog2Stride == sizeof(Common::PageTable::PageEntryData));
-
-        config.page_table = reinterpret_cast<void**>(page_table->entries.data());
+        // 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()));
         config.page_table_address_space_bits = std::uint32_t(address_space_bits);
-        config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
-        config.page_table_log2_stride = PageLog2Stride;
+        config.page_table_pointer_mask = Common::PageTable::ATTRIBUTE_MASK;
+        config.page_table_marked_bit = uint8_t(0);
         config.silently_mirror_page_table = false;
         config.absolute_offset_page_table = true;
         config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -217,6 +216,13 @@ 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 = std::uint8_t(Common::PageTable::SIGN_BIT);
+        }
     }
 
     // Multi-process state
@@ -433,6 +439,7 @@ void ArmDynarmic64::SignalInterrupt(Kernel::KThread* thread) {
 }
 
 void ArmDynarmic64::ClearInstructionCache() {
+    m_cb->last_code_addr = u64(-1);
     m_jit->ClearCache();
 }
 

src/core/core.cpp

@@ -110,8 +110,13 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 
 struct System::Impl {
     explicit Impl(System& system)
-        : kernel{system}, fs_controller{system}, hid_core{kernel}, cpu_manager{system},
-          reporter{system}, applet_manager{system}, frontend_applets{system}, profile_manager{} {}
+        : kernel{system}
+        , fs_controller{system}
+        , hid_core{kernel}
+        , cpu_manager{system}
+        , reporter{system}
+        , profile_manager{}
+    {}
 
     u64 program_id;
 
@@ -124,6 +129,12 @@ struct System::Impl {
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
 
+        applet_manager.emplace(system);
+        frontend_applets.emplace(system);
+        apm_controller.emplace(core_timing);
+        arp_manager.emplace();
+        profile_manager.emplace();
+
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr) {
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
@@ -133,7 +144,7 @@ struct System::Impl {
         }
 
         // Create default implementations of applets if one is not provided.
-        frontend_applets.SetDefaultAppletsIfMissing();
+        frontend_applets->SetDefaultAppletsIfMissing();
 
         auto const is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
 
@@ -376,7 +387,7 @@ struct System::Impl {
 
         // Register with applet manager
         // All threads are started, begin main process execution, now that we're in the clear
-        applet_manager.CreateAndInsertByFrontendAppletParameters(std::move(process), params);
+        applet_manager->CreateAndInsertByFrontendAppletParameters(std::move(process), params);
 
         if (Settings::values.gamecard_inserted) {
             if (Settings::values.gamecard_current_game) {
@@ -428,13 +439,27 @@ struct System::Impl {
         core_timing.SyncPause(false);
         Network::CancelPendingSocketOperations();
         kernel.SuspendEmulation(true);
-        kernel.CloseServices();
         kernel.ShutdownCores();
+
+        // Notify services helpers of shutdown
+        audio_core->NotifyShutdown();
+
+        // Wait for threads/services to join
+        kernel.CloseServices();
+
+        // service shutdown
         services.reset();
         service_manager.reset();
+        frontend_applets.reset();
+        applet_manager.reset();
+        apm_controller.reset();
+        arp_manager.reset();
+        profile_manager.reset();
+
         fs_controller.Reset();
         cheat_engine.reset();
         core_timing.ClearPendingEvents();
+        core_timing.Reset();
         app_loader.reset();
         audio_core.reset();
         gpu_core.reset();
@@ -452,7 +477,7 @@ struct System::Impl {
         }
 
         // Reset all glue registrations
-        arp_manager.ResetAll();
+        arp_manager->ResetAll();
 
         LOG_DEBUG(Core, "Shutdown OK");
     }
@@ -482,13 +507,13 @@ struct System::Impl {
     CpuManager cpu_manager;
     Reporter reporter;
     /// Applets
-    Service::AM::AppletManager applet_manager;
-    Service::AM::Frontend::FrontendAppletHolder frontend_applets;
+    std::optional<Service::AM::AppletManager> applet_manager;
+    std::optional<Service::AM::Frontend::FrontendAppletHolder> frontend_applets;
     /// APM (Performance) services
-    Service::APM::Controller apm_controller{core_timing};
+    std::optional<Service::APM::Controller> apm_controller;
     /// Service State
-    Service::Glue::ARPManager arp_manager;
-    Service::Account::ProfileManager profile_manager;
+    std::optional<Service::Glue::ARPManager> arp_manager;
+    std::optional<Service::Account::ProfileManager> profile_manager;
     /// Network instance
     Network::NetworkInstance network_instance;
     Core::SpeedLimiter speed_limiter;
@@ -815,19 +840,19 @@ void System::RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
 }
 
 void System::SetFrontendAppletSet(Service::AM::Frontend::FrontendAppletSet&& set) {
-    impl->frontend_applets.SetFrontendAppletSet(std::move(set));
+    impl->frontend_applets->SetFrontendAppletSet(std::move(set));
 }
 
 Service::AM::Frontend::FrontendAppletHolder& System::GetFrontendAppletHolder() {
-    return impl->frontend_applets;
+    return *impl->frontend_applets;
 }
 
 const Service::AM::Frontend::FrontendAppletHolder& System::GetFrontendAppletHolder() const {
-    return impl->frontend_applets;
+    return *impl->frontend_applets;
 }
 
 Service::AM::AppletManager& System::GetAppletManager() {
-    return impl->applet_manager;
+    return *impl->applet_manager;
 }
 
 void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
@@ -868,27 +893,27 @@ const Reporter& System::GetReporter() const {
 }
 
 Service::Glue::ARPManager& System::GetARPManager() {
-    return impl->arp_manager;
+    return *impl->arp_manager;
 }
 
 const Service::Glue::ARPManager& System::GetARPManager() const {
-    return impl->arp_manager;
+    return *impl->arp_manager;
 }
 
 Service::APM::Controller& System::GetAPMController() {
-    return impl->apm_controller;
+    return *impl->apm_controller;
 }
 
 const Service::APM::Controller& System::GetAPMController() const {
-    return impl->apm_controller;
+    return *impl->apm_controller;
 }
 
 Service::Account::ProfileManager& System::GetProfileManager() {
-    return impl->profile_manager;
+    return *impl->profile_manager;
 }
 
 const Service::Account::ProfileManager& System::GetProfileManager() const {
-    return impl->profile_manager;
+    return *impl->profile_manager;
 }
 
 void System::SetExitLocked(bool locked) {

src/core/core_timing.cpp

@@ -304,10 +304,10 @@ std::optional<s64> CoreTiming::Advance() {
 
 void CoreTiming::Reset() {
     paused = true;
-    pause_event.Set();
-    event.Set();
     if (timer_thread.joinable()) {
         timer_thread.request_stop();
+        pause_event.Set();
+        event.Set();
         timer_thread.join();
     }
     has_started = false;

src/core/device_memory.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -26,8 +29,11 @@ public:
 
     template <typename T>
     Common::PhysicalAddress GetPhysicalAddr(const T* ptr) const {
-        return (reinterpret_cast<uintptr_t>(ptr) -
-                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
+        return GetPhysicalAddr(reinterpret_cast<uintptr_t>(ptr));
+    }
+
+    Common::PhysicalAddress GetPhysicalAddr(uintptr_t ptr) const {
+        return (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/virtual_buffer.h"
+#include "common/sparse_large_vector.h"
 
 namespace Core {
 
@@ -178,8 +178,8 @@ private:
         u32 continuity_tracker;
         u32 compressed_physical_ptr;
     };
-    Common::VirtualBuffer<u32> compressed_device_addr;
-    Common::VirtualBuffer<TrackedEntry> tracked_entries;
+    Common::SparseLargeVector<u32> compressed_device_addr;
+    Common::SparseLargeVector<TrackedEntry> tracked_entries;
 
     // Process memory interfaces
 
@@ -200,8 +200,8 @@ private:
         return std::make_pair(asid, address);
     }
 
-    void InsertCPUBacking(size_t page_index, VAddr address, Asid asid) {
-        tracked_entries[page_index].cpu_backing_address = address | (asid.id << asid_start_bit);
+    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);
     }
 
     std::array<TranslationEntry, 4> t_slot{};

src/core/device_memory_manager.inc

@@ -177,17 +177,6 @@ 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>
@@ -220,26 +209,28 @@ 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[start_page_d + i].compressed_physical_ptr = 0;
+            tracked_entries.GetUnchecked(start_page_d + i).compressed_physical_ptr = 0;
             continue;
         }
         auto phys_addr = static_cast<u32>(GetRawPhysicalAddr(ptr) >> Memory::YUZU_PAGEBITS) + 1U;
-        tracked_entries[start_page_d + i].compressed_physical_ptr = phys_addr;
+        tracked_entries.GetUnchecked(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[phys_addr - 1U] = new_dev;
+            compressed_device_addr.GetAndFault(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[phys_addr - 1U] = MULTI_FLAG | start_id;
+            compressed_device_addr.GetAndFault(phys_addr - 1U) = MULTI_FLAG | start_id;
         }
         impl->multi_dev_address.Register(new_dev, start_id);
     }
@@ -255,24 +246,26 @@ 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 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;
+        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;
         if (phys_addr != 0) [[likely]] {
-            const u32 base_dev = compressed_device_addr[phys_addr - 1U];
+            u32& base_dev = compressed_device_addr.GetAndFault(phys_addr - 1U);
             if ((base_dev >> MULTI_FLAG_BITS) == 0) [[likely]] {
-                compressed_device_addr[phys_addr - 1] = 0;
+                base_dev = 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) {
-                compressed_device_addr[phys_addr - 1] =
-                    impl->multi_dev_address.ReleaseEntry(new_start);
+                base_dev = impl->multi_dev_address.ReleaseEntry(new_start);
                 continue;
             }
-            compressed_device_addr[phys_addr - 1] = new_start | MULTI_FLAG;
+            base_dev = new_start | MULTI_FLAG;
         }
     }
     t_slot = {};
@@ -285,6 +278,8 @@ 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;
@@ -296,14 +291,14 @@ void DeviceMemoryManager<Traits>::TrackContinuityImpl(DAddr address, VAddr virtu
             page_count = 1;
         }
         last_ptr = new_ptr;
-        tracked_entries[start_page_d + index].continuity_tracker = static_cast<u32>(page_count);
+        tracked_entries.GetUnchecked(start_page_d + index).continuity_tracker = static_cast<u32>(page_count) - 1;
     }
 }
 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) << page_bits) >= size + subbits) {
+    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker+1) << page_bits) >= size + subbits) {
         return GetPointer<u8>(src_addr);
     }
     return nullptr;
@@ -313,7 +308,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) << page_bits) >= size + subbits) {
+    if ((static_cast<size_t>(tracked_entries[page_index].continuity_tracker+1) << page_bits) >= size + subbits) {
         return GetPointer<u8>(src_addr);
     }
     return nullptr;
@@ -383,7 +378,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);
+        const size_t next_pages = std::size_t(tracked_entries[page_index].continuity_tracker+1);
         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/hle/kernel/global_scheduler_context.cpp

@@ -72,11 +72,9 @@ void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) noe
 
 void GlobalSchedulerContext::WakeupWaitingDummyThreads(KernelCore& kernel) noexcept {
     ASSERT(this->IsLocked());
-    if (m_woken_dummy_threads.size() > 0) {
-        for (auto* thread : m_woken_dummy_threads)
-            thread->DummyThreadEndWait(kernel);
-        m_woken_dummy_threads.clear();
-    }
+    for (auto* thread : m_woken_dummy_threads)
+        thread->DummyThreadEndWait(kernel);
+    m_woken_dummy_threads.clear();
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_page_table_base.cpp

@@ -635,6 +635,36 @@ 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,
@@ -940,7 +970,7 @@ Result KPageTableBase::QueryMappingImpl(KProcessAddress* out, KPhysicalAddress a
     size_t tot_size = 0;
 
     next_valid =
-        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), region_start);
+        BeginTraversal(impl, 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)));
 
@@ -976,7 +1006,7 @@ Result KPageTableBase::QueryMappingImpl(KProcessAddress* out, KPhysicalAddress a
             break;
         }
 
-        next_valid = impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+        next_valid = ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
     }
 
     // Check the last entry.
@@ -1754,7 +1784,7 @@ Result KPageTableBase::MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    R_UNLESS(impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), addr),
+    R_UNLESS(BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), addr),
              ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -1764,7 +1794,7 @@ Result KPageTableBase::MakePageGroup(KPageGroup& pg, KProcessAddress addr, size_
 
     // Iterate, adding to group as we go.
     while (tot_size < size) {
-        R_UNLESS(impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context)),
+        R_UNLESS(ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context)),
                  ResultInvalidCurrentMemory);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -1828,7 +1858,7 @@ bool KPageTableBase::IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    if (!impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), addr)) {
+    if (!BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), addr)) {
         return false;
     }
 
@@ -1839,7 +1869,7 @@ bool KPageTableBase::IsValidPageGroup(const KPageGroup& pg, KProcessAddress addr
 
     // Iterate, comparing expected to actual.
     while (tot_size < size) {
-        if (!impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context))) {
+        if (!ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context))) {
             return false;
         }
 
@@ -1896,7 +1926,7 @@ Result KPageTableBase::GetContiguousMemoryRangeWithState(
     // Begin a traversal.
     TraversalContext context;
     TraversalEntry cur_entry = {.phys_addr = 0, .block_size = 0};
-    R_UNLESS(impl.BeginTraversal(std::addressof(cur_entry), std::addressof(context), address),
+    R_UNLESS(BeginTraversal(impl, std::addressof(cur_entry), std::addressof(context), address),
              ResultInvalidCurrentMemory);
 
     // Traverse until we have enough size or we aren't contiguous any more.
@@ -1905,7 +1935,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 (!impl.ContinueTraversal(std::addressof(cur_entry), std::addressof(context))) {
+        if (!ContinueTraversal(impl, std::addressof(cur_entry), std::addressof(context))) {
             break;
         }
         if (cur_entry.phys_addr != phys_address + contig_size) {
@@ -2334,7 +2364,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            m_impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), virt_addr);
+            BeginTraversal(m_impl, std::addressof(next_entry), std::addressof(context), virt_addr);
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         // Set tracking variables.
@@ -2345,7 +2375,7 @@ Result KPageTableBase::QueryPhysicalAddress(Svc::lp64::PhysicalMemoryInfo* out,
         while (true) {
             // Continue the traversal.
             traverse_valid =
-                m_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(m_impl, std::addressof(next_entry), std::addressof(context));
             if (!traverse_valid) {
                 break;
             }
@@ -2567,7 +2597,7 @@ Result KPageTableBase::UnmapIoRegion(KProcessAddress dst_address, KPhysicalAddre
         TraversalContext context;
         TraversalEntry next_entry;
         ASSERT(
-            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_address));
+            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_address));
 
         // Check that the physical region matches.
         R_UNLESS(next_entry.phys_addr == phys_addr, ResultInvalidMemoryRegion);
@@ -2577,7 +2607,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(impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context)));
+            ASSERT(ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context)));
 
             // Check that the physical region matches.
             R_UNLESS(next_entry.phys_addr == phys_addr + checked_size, ResultInvalidMemoryRegion);
@@ -3029,7 +3059,7 @@ Result KPageTableBase::InvalidateProcessDataCache(KProcessAddress address, size_
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), address);
+        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3041,7 +3071,7 @@ Result KPageTableBase::InvalidateProcessDataCache(KProcessAddress address, size_
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
         R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3129,7 +3159,7 @@ Result KPageTableBase::ReadDebugMemory(KProcessAddress dst_address, KProcessAddr
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_address);
+        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3167,7 +3197,7 @@ Result KPageTableBase::ReadDebugMemory(KProcessAddress dst_address, KProcessAddr
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3225,7 +3255,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     TraversalContext context;
     TraversalEntry next_entry;
     bool traverse_valid =
-        impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_address);
+        BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_address);
     R_UNLESS(traverse_valid, ResultInvalidCurrentMemory);
 
     // Prepare tracking variables.
@@ -3267,7 +3297,7 @@ Result KPageTableBase::WriteDebugMemory(KProcessAddress dst_address, KProcessAdd
     while (tot_size < size) {
         // Continue the traversal.
         traverse_valid =
-            impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+            ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3728,7 +3758,7 @@ Result KPageTableBase::CopyMemoryFromLinearToUser(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_addr);
+            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3768,7 +3798,7 @@ Result KPageTableBase::CopyMemoryFromLinearToUser(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3822,7 +3852,7 @@ Result KPageTableBase::CopyMemoryFromLinearToKernel(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), src_addr);
+            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), src_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3845,7 +3875,7 @@ Result KPageTableBase::CopyMemoryFromLinearToKernel(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3902,7 +3932,7 @@ Result KPageTableBase::CopyMemoryFromUserToLinear(
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_addr);
+            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -3941,7 +3971,7 @@ Result KPageTableBase::CopyMemoryFromUserToLinear(
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -3997,7 +4027,7 @@ Result KPageTableBase::CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, si
         TraversalContext context;
         TraversalEntry next_entry;
         bool traverse_valid =
-            impl.BeginTraversal(std::addressof(next_entry), std::addressof(context), dst_addr);
+            BeginTraversal(impl, std::addressof(next_entry), std::addressof(context), dst_addr);
         ASSERT(traverse_valid);
 
         // Prepare tracking variables.
@@ -4020,7 +4050,7 @@ Result KPageTableBase::CopyMemoryFromKernelToLinear(KProcessAddress dst_addr, si
         while (tot_size < size) {
             // Continue the traversal.
             traverse_valid =
-                impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(impl, std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             if (next_entry.phys_addr != (cur_addr + cur_size)) {
@@ -4089,10 +4119,10 @@ Result KPageTableBase::CopyMemoryFromHeapToHeap(
         bool traverse_valid;
 
         // Begin traversal.
-        traverse_valid = src_impl.BeginTraversal(std::addressof(src_next_entry),
+        traverse_valid = BeginTraversal(src_impl, std::addressof(src_next_entry),
                                                  std::addressof(src_context), src_addr);
         ASSERT(traverse_valid);
-        traverse_valid = dst_impl.BeginTraversal(std::addressof(dst_next_entry),
+        traverse_valid = BeginTraversal(dst_impl, std::addressof(dst_next_entry),
                                                  std::addressof(dst_context), dst_addr);
         ASSERT(traverse_valid);
 
@@ -4127,7 +4157,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 = src_impl.ContinueTraversal(std::addressof(src_next_entry),
+                    traverse_valid = ContinueTraversal(src_impl, std::addressof(src_next_entry),
                                                                 std::addressof(src_context));
                     ASSERT(traverse_valid);
 
@@ -4138,7 +4168,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 = dst_impl.ContinueTraversal(std::addressof(dst_next_entry),
+                    traverse_valid = ContinueTraversal(dst_impl, std::addressof(dst_next_entry),
                                                                 std::addressof(dst_context));
                     ASSERT(traverse_valid);
 
@@ -4223,10 +4253,10 @@ Result KPageTableBase::CopyMemoryFromHeapToHeapWithoutCheckDestination(
         bool traverse_valid;
 
         // Begin traversal.
-        traverse_valid = src_impl.BeginTraversal(std::addressof(src_next_entry),
+        traverse_valid = BeginTraversal(src_impl, std::addressof(src_next_entry),
                                                  std::addressof(src_context), src_addr);
         ASSERT(traverse_valid);
-        traverse_valid = dst_impl.BeginTraversal(std::addressof(dst_next_entry),
+        traverse_valid = BeginTraversal(dst_impl, std::addressof(dst_next_entry),
                                                  std::addressof(dst_context), dst_addr);
         ASSERT(traverse_valid);
 
@@ -4261,7 +4291,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 = src_impl.ContinueTraversal(std::addressof(src_next_entry),
+                    traverse_valid = ContinueTraversal(src_impl, std::addressof(src_next_entry),
                                                                 std::addressof(src_context));
                     ASSERT(traverse_valid);
 
@@ -4272,7 +4302,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 = dst_impl.ContinueTraversal(std::addressof(dst_next_entry),
+                    traverse_valid = ContinueTraversal(dst_impl, std::addressof(dst_next_entry),
                                                                 std::addressof(dst_context));
                     ASSERT(traverse_valid);
 
@@ -4547,7 +4577,7 @@ Result KPageTableBase::SetupForIpcServer(KProcessAddress* out_addr, size_t size,
     // Begin traversal.
     TraversalContext context;
     TraversalEntry next_entry;
-    bool traverse_valid = src_impl.BeginTraversal(std::addressof(next_entry),
+    bool traverse_valid = BeginTraversal(src_impl, std::addressof(next_entry),
                                                   std::addressof(context), aligned_src_start);
     ASSERT(traverse_valid);
 
@@ -4597,7 +4627,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 =
-                src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             cur_block_addr = next_entry.phys_addr;
@@ -4610,7 +4640,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 =
-            src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+            ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
         ASSERT(traverse_valid);
 
         // Process the block.
@@ -4653,7 +4683,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 =
-                src_impl.ContinueTraversal(std::addressof(next_entry), std::addressof(context));
+                ContinueTraversal(src_impl, std::addressof(next_entry), std::addressof(context));
             ASSERT(traverse_valid);
 
             cur_block_addr = next_entry.phys_addr;
@@ -5601,7 +5631,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.GetImpl().BeginTraversal(std::addressof(m_entry),
+                ASSERT(m_pt.BeginTraversal(m_pt.GetImpl(), std::addressof(m_entry),
                                                      std::addressof(m_context), address));
 
                 // Setup tracking fields.
@@ -5632,7 +5662,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.GetImpl().ContinueTraversal(std::addressof(m_entry),
+                    ASSERT(m_pt.ContinueTraversal(m_pt.GetImpl(), 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,6 +370,10 @@ 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,
@@ -474,7 +478,14 @@ private:
         // Validate pre-conditions.
         ASSERT(this->IsLockedByCurrentThread());
 
-        return this->GetImpl().GetPhysicalAddress(out, virt_addr);
+        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;
     }
 
 public:

src/core/hle/kernel/k_process.cpp

@@ -59,7 +59,6 @@ Result TerminateChildren(KernelCore& kernel, KProcess* process, const KThread* t
         KThread* cur_child = nullptr;
         {
             KScopedLightLock proc_lk(process->GetListLock());
-
             auto& thread_list = process->GetThreadList();
             for (auto it = thread_list.begin(); it != thread_list.end(); ++it) {
                 if (KThread* thread = std::addressof(*it); thread != thread_to_not_terminate) {

src/core/hle/kernel/k_thread.cpp

@@ -1236,18 +1236,13 @@ namespace Kernel {
         KScopedSchedulerLock sl{kernel};
 
         // Determine if this is the first termination request.
-        const bool first_request = [&]() -> bool {
-            // Perform an atomic compare-and-swap from false to true.
-            bool expected = false;
-            return m_termination_requested.compare_exchange_strong(expected, true);
-        }();
-
+        // Perform an atomic compare-and-swap from false to true.
+        bool expected = false;
         // If this is the first request, start termination procedure.
-        if (first_request) {
+        if (m_termination_requested.compare_exchange_strong(expected, true)) {
             // If the thread is in initialized state, just change state to terminated.
             if (this->GetState() == ThreadState::Initialized) {
-                m_thread_state = ThreadState::Terminated;
-                return ThreadState::Terminated;
+                return m_thread_state = ThreadState::Terminated;
             }
 
             // Register the terminating dpc.
@@ -1281,7 +1276,6 @@ namespace Kernel {
                 m_wait_queue->CancelWait(kernel, this, ResultTerminationRequested, true);
             }
         }
-
         return this->GetState();
     }
 

src/core/hle/kernel/k_worker_task_manager.cpp

@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <thread>
 #include "common/assert.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_thread.h"
@@ -26,7 +27,15 @@ void KWorkerTask::DoWorkerTask(KernelCore& kernel) {
     }
 }
 
-KWorkerTaskManager::KWorkerTaskManager() : m_waiting_thread(1, "KWorkerTaskManager") {}
+KWorkerTaskManager::KWorkerTaskManager() {}
+
+KWorkerTaskManager::~KWorkerTaskManager() {
+    if (m_waiting_thread.joinable()) {
+        m_waiting_thread.request_stop();
+        m_task_cv.notify_one();
+        m_waiting_thread.join();
+    }
+}
 
 void KWorkerTaskManager::AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task) {
     ASSERT(type <= WorkerType::Count);
@@ -35,10 +44,31 @@ void KWorkerTaskManager::AddTask(KernelCore& kernel, WorkerType type, KWorkerTas
 
 void KWorkerTaskManager::AddTask(KernelCore& kernel, KWorkerTask* task) {
     KScopedSchedulerLock sl(kernel);
-    m_waiting_thread.QueueWork([&kernel, task]() {
-        // Do the task.
-        task->DoWorkerTask(kernel);
-    });
+
+    // spawn thread on demand
+    if (!m_waiting_thread.joinable()) {
+        LOG_INFO(Kernel, "spawning KWorkerTaskManager thread");
+        m_waiting_thread = std::jthread([&kernel, this](std::stop_token stop_token) {
+            while (!stop_token.stop_requested()) {
+                KWorkerTask* t;
+                {
+                    std::unique_lock lk{m_task_mutex};
+                    m_task_cv.wait(lk);
+                    if (stop_token.stop_requested())
+                        break;
+                    t = m_task_queue.back();
+                    m_task_queue.pop_back();
+                }
+                t->DoWorkerTask(kernel);
+            }
+        });
+    }
+
+    {
+        std::scoped_lock lk{m_task_mutex};
+        m_task_queue.emplace_back(task);
+    }
+    m_task_cv.notify_one();
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_worker_task_manager.h

@@ -1,8 +1,13 @@
+// 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
 
 #pragma once
 
+#include <condition_variable>
+#include <thread>
 #include "common/common_types.h"
 #include "common/thread_worker.h"
 
@@ -19,14 +24,16 @@ public:
     };
 
     KWorkerTaskManager();
+    ~KWorkerTaskManager();
 
     static void AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task);
-
 private:
     void AddTask(KernelCore& kernel, KWorkerTask* task);
+    std::jthread m_waiting_thread;
 
-private:
-    Common::ThreadWorker m_waiting_thread;
+    std::mutex m_task_mutex;
+    std::condition_variable m_task_cv;
+    std::vector<KWorkerTask*> m_task_queue;
 };
 
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -80,7 +80,9 @@ struct KernelCore::Impl {
     // so it will be statically given a TLS slot anyways.
     static inline thread_local ThreadLocalData tls_data = {};
 
-    explicit Impl(Core::System& system_, KernelCore& kernel_) : system{system_} {
+    explicit Impl(Core::System& system_, KernelCore& kernel_)
+        : system{system_}
+    {
         tls_data.lock = true;
     }
 
@@ -967,12 +969,16 @@ Kernel::KHardwareTimer& KernelCore::HardwareTimer() {
     return *impl->hardware_timer;
 }
 
-KAutoObjectWithListContainer& KernelCore::ObjectListContainer() {
-    return *impl->global_object_list_container;
+KAutoObjectWithListContainer* KernelCore::ObjectListContainer() {
+    if (!impl->global_object_list_container)
+        return nullptr;
+    return std::addressof(*impl->global_object_list_container);
 }
 
-const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const {
-    return *impl->global_object_list_container;
+const KAutoObjectWithListContainer* KernelCore::ObjectListContainer() const {
+    if (!impl->global_object_list_container)
+        return nullptr;
+    return std::addressof(*impl->global_object_list_container);
 }
 
 void KernelCore::PrepareReschedule(std::size_t id) {
@@ -1001,16 +1007,10 @@ void KernelCore::UnregisterInUseObject(KAutoObject* object) {
 
 void KernelCore::RunServer(std::unique_ptr<Service::ServerManager>&& server_manager) {
     auto* manager = server_manager.get();
-
-    {
+    if (!impl->is_shutting_down) {
         std::scoped_lock lk{impl->server_lock};
-        if (impl->is_shutting_down) {
-            return;
-        }
-
         impl->server_managers.emplace_back(std::move(server_manager));
     }
-
     manager->LoopProcess();
 }
 
@@ -1255,6 +1255,10 @@ void KernelCore::SuspendEmulation(bool suspended) {
 }
 
 void KernelCore::ShutdownCores() {
+    // Notify shutdown (pre-emptively)
+    for (auto& sm : impl->server_managers) {
+        sm->NotifyShutdown();
+    }
     impl->TerminateAllProcesses();
     KScopedSchedulerLock lk{*this};
     for (auto* thread : impl->shutdown_threads)

src/core/hle/kernel/kernel.h

@@ -175,9 +175,8 @@ public:
     /// Stops execution of 'id' core, in order to reschedule a new thread.
     void PrepareReschedule(std::size_t id);
 
-    KAutoObjectWithListContainer& ObjectListContainer();
-
-    const KAutoObjectWithListContainer& ObjectListContainer() const;
+    KAutoObjectWithListContainer* ObjectListContainer();
+    const KAutoObjectWithListContainer* ObjectListContainer() const;
 
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.

src/core/hle/kernel/slab_helpers.h

@@ -151,7 +151,8 @@ public:
         const bool is_initialized = this->IsInitialized();
         uintptr_t arg = 0;
         if (is_initialized) {
-            kernel.ObjectListContainer().Unregister(this);
+            if (auto const olc = kernel.ObjectListContainer(); olc)
+                olc->Unregister(this);
             arg = this->GetPostDestroyArgument();
             this->Finalize(kernel);
         }
@@ -175,7 +176,7 @@ public:
 public:
     static void InitializeSlabHeap(KernelCore& kernel, void* memory, size_t memory_size) {
         kernel.SlabHeap<Derived>().Initialize(memory, memory_size);
-        kernel.ObjectListContainer().Initialize();
+        kernel.ObjectListContainer()->Initialize();
     }
 
     static Derived* Create(KernelCore& kernel) {
@@ -186,7 +187,7 @@ public:
     }
 
     static void Register(KernelCore& kernel, Derived* obj) {
-        return kernel.ObjectListContainer().Register(obj);
+        return kernel.ObjectListContainer()->Register(obj);
     }
 
     static size_t GetObjectSize(KernelCore& kernel) {

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

@@ -26,24 +26,25 @@ EventObserver::EventObserver(Core::System& system, WindowSystem& window_system)
     m_window_system.SetEventObserver(this);
     m_wakeup_holder.SetUserData(static_cast<uintptr_t>(UserDataTag::WakeupEvent));
     m_wakeup_holder.LinkToMultiWait(std::addressof(m_multi_wait));
-    m_thread = std::jthread([this](std::stop_token stop_token) {
-        Common::SetCurrentThreadName("am:EventObserver");
+    system.Kernel().RunOnGuestCoreProcess("am:EventObserver", [this]() {
+        auto const stop_token = m_stop_source.get_token();
         while (!stop_token.stop_requested()) {
             auto* signaled_holder = this->WaitSignaled(stop_token);
-            if (!signaled_holder)
+            if (stop_token.stop_requested() || !signaled_holder)
                 break;
             this->Process(signaled_holder);
         }
+        m_process_cv.notify_one();
     });
 }
 
 EventObserver::~EventObserver() {
     // Signal thread and wait for processing to finish.
-    if (m_thread.joinable()) {
-        // Signal thread and wait for processing to finish.
-        m_thread.request_stop();
-        m_wakeup_event.Signal(m_system.Kernel());
-        m_thread.join();
+    m_stop_source.request_stop();
+    m_wakeup_event.Signal(m_system.Kernel());
+    {
+        std::unique_lock lk{m_process_mutex};
+        m_process_cv.wait(lk);
     }
 
     // Free remaining owned sessions.

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

@@ -6,6 +6,8 @@
 
 #pragma once
 
+#include <condition_variable>
+#include <stop_token>
 #include "common/polyfill_thread.h"
 #include "common/thread.h"
 #include "core/hle/service/kernel_helpers.h"
@@ -62,7 +64,9 @@ private:
     MultiWait m_deferred_wait_list;
 
     // Processing thread.
-    std::jthread m_thread{};
+    std::stop_source m_stop_source{};
+    std::mutex m_process_mutex;
+    std::condition_variable m_process_cv{};
 };
 
 } // namespace Service::AM

src/core/hle/service/glue/time/manager.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 2023 yuzu Emulator Project
@@ -90,10 +90,9 @@ static Service::PSC::Time::LocationName GetTimeZoneString(
 }
 
 TimeManager::TimeManager(Core::System& system)
-    : m_steady_clock_resource{system}, m_time_zone_binary{system}, m_worker{
-                                                                       system,
-                                                                       m_steady_clock_resource,
-                                                                       m_file_timestamp_worker} {
+    : m_steady_clock_resource{system}, m_time_zone_binary{system}
+    , m_worker{system, m_steady_clock_resource, m_file_timestamp_worker}
+{
     m_time_m =
         system.ServiceManager().GetService<Service::PSC::Time::ServiceManager>("time:m", true);
 

src/core/hle/service/glue/time/worker.cpp

@@ -20,15 +20,17 @@
 
 namespace Service::Glue::Time {
 
-TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource,
-                       FileTimestampWorker& file_timestamp_worker)
-    : m_system{system}, m_ctx{m_system, "Glue:TimeWorker"}, m_event{m_ctx.CreateEvent(
-                                                                "Glue:TimeWorker:Event")},
-      m_steady_clock_resource{steady_clock_resource},
-      m_file_timestamp_worker{file_timestamp_worker}, m_timer_steady_clock{m_ctx.CreateEvent(
-                                                          "Glue:TimeWorker:SteadyClockTimerEvent")},
-      m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")},
-      m_alarm_worker{m_system, m_steady_clock_resource}, m_pm_state_change_handler{m_alarm_worker} {
+TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady_clock_resource, FileTimestampWorker& file_timestamp_worker)
+    : m_system{system}
+    , m_ctx{m_system, "Glue:TimeWorker"}
+    , m_event{m_ctx.CreateEvent("Glue:TimeWorker:Event")}
+    , m_steady_clock_resource{steady_clock_resource}
+    , m_file_timestamp_worker{file_timestamp_worker}
+    , m_timer_steady_clock{m_ctx.CreateEvent("Glue:TimeWorker:SteadyClockTimerEvent")}
+    , m_timer_file_system{m_ctx.CreateEvent("Glue:TimeWorker:FileTimeTimerEvent")}
+    , m_alarm_worker{m_system, m_steady_clock_resource}
+    , m_pm_state_change_handler{m_alarm_worker}
+{
     m_timer_steady_clock_timing_event = Core::Timing::CreateEvent(
         "Time::SteadyClockEvent",
         [this](s64 time,
@@ -47,14 +49,16 @@ TimeWorker::TimeWorker(Core::System& system, StandardSteadyClockResource& steady
 }
 
 TimeWorker::~TimeWorker() {
+    // Wait for processing to stop
+    m_stop_source.request_stop();
     m_local_clock_event->Signal(m_system.Kernel());
     m_network_clock_event->Signal(m_system.Kernel());
     m_ephemeral_clock_event->Signal(m_system.Kernel());
-    std::this_thread::sleep_for(std::chrono::milliseconds(16));
-
-    m_thread.request_stop();
     m_event->Signal(m_system.Kernel());
-    m_thread.join();
+    {
+        std::unique_lock lk{m_process_mutex};
+        m_process_cv.wait(lk);
+    }
 
     m_ctx.CloseEvent(m_event);
     m_system.CoreTiming().UnscheduleEvent(m_timer_steady_clock_timing_event);
@@ -122,166 +126,162 @@ void TimeWorker::Initialize(std::shared_ptr<Service::PSC::Time::StaticService> t
 }
 
 void TimeWorker::StartThread() {
-    m_thread = std::jthread(std::bind_front(&TimeWorker::ThreadFunc, this));
-}
-
-void TimeWorker::ThreadFunc(std::stop_token stop_token) {
-    Common::SetCurrentThreadName("TimeWorker");
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::Low);
-
-    while (!stop_token.stop_requested()) {
-        enum class EventType : s32 {
-            Exit = 0,
-            PowerStateChange = 1,
-            SignalAlarms = 2,
-            UpdateLocalSystemClock = 3,
-            UpdateNetworkSystemClock = 4,
-            UpdateEphemeralSystemClock = 5,
-            UpdateSteadyClock = 6,
-            UpdateFileTimestamp = 7,
-            AutoCorrect = 8,
-        };
-
-        s32 index{};
-
-        if (m_pm_state_change_handler.m_priority != 0) {
-            // TODO: gIPmModuleService::GetEvent() 1
-            index = WaitAny(m_system.Kernel(),
-                            &m_event->GetReadableEvent(), // 0
-                            &m_alarm_worker.GetEvent()    // 1
-            );
-        } else {
-            // TODO: gIPmModuleService::GetEvent() 1
-            index = WaitAny(m_system.Kernel(),
-                            &m_event->GetReadableEvent(),                       // 0
-                            &m_alarm_worker.GetEvent(),                         // 1
-                            &m_alarm_worker.GetTimerEvent().GetReadableEvent(), // 2
-                            m_local_clock_event,                                // 3
-                            m_network_clock_event,                              // 4
-                            m_ephemeral_clock_event,                            // 5
-                            &m_timer_steady_clock->GetReadableEvent(),          // 6
-                            &m_timer_file_system->GetReadableEvent(),           // 7
-                            m_standard_user_auto_correct_clock_event            // 8
-            );
-        }
-
-        switch (static_cast<EventType>(index)) {
-        case EventType::Exit:
-            return;
-
-        case EventType::PowerStateChange:
-            m_alarm_worker.GetEvent().Clear(m_system.Kernel());
-            if (m_pm_state_change_handler.m_priority <= 1) {
-                m_alarm_worker.OnPowerStateChanged();
+    m_system.Kernel().RunOnGuestCoreProcess("TimeWorker", [this]() {
+        auto const stop_token = m_stop_source.get_token();
+        while (!stop_token.stop_requested()) {
+            enum class EventType : s32 {
+                Exit = 0,
+                PowerStateChange = 1,
+                SignalAlarms = 2,
+                UpdateLocalSystemClock = 3,
+                UpdateNetworkSystemClock = 4,
+                UpdateEphemeralSystemClock = 5,
+                UpdateSteadyClock = 6,
+                UpdateFileTimestamp = 7,
+                AutoCorrect = 8,
+            };
+            s32 index{};
+            if (m_pm_state_change_handler.m_priority != 0) {
+                // TODO: gIPmModuleService::GetEvent() 1
+                index = WaitAny(
+                    m_system.Kernel(),
+                    &m_event->GetReadableEvent(), // 0
+                    &m_alarm_worker.GetEvent()    // 1
+                );
+            } else {
+                // TODO: gIPmModuleService::GetEvent() 1
+                index = WaitAny(
+                    m_system.Kernel(),
+                    &m_event->GetReadableEvent(),                       // 0
+                    &m_alarm_worker.GetEvent(),                         // 1
+                    &m_alarm_worker.GetTimerEvent().GetReadableEvent(), // 2
+                    m_local_clock_event,                                // 3
+                    m_network_clock_event,                              // 4
+                    m_ephemeral_clock_event,                            // 5
+                    &m_timer_steady_clock->GetReadableEvent(),          // 6
+                    &m_timer_file_system->GetReadableEvent(),           // 7
+                    m_standard_user_auto_correct_clock_event            // 8
+                );
             }
-            break;
 
-        case EventType::SignalAlarms:
-            m_alarm_worker.GetTimerEvent().Clear(m_system.Kernel());
-            m_time_m->CheckAndSignalAlarms();
-            break;
+            if (stop_token.stop_requested())
+                break;
 
-        case EventType::UpdateLocalSystemClock: {
-            m_local_clock_event->Clear(m_system.Kernel());
+            switch (EventType(index)) {
+            case EventType::Exit:
+                return;
 
-            Service::PSC::Time::SystemClockContext context{};
-            R_ASSERT(m_local_clock->GetSystemClockContext(&context));
+            case EventType::PowerStateChange:
+                m_alarm_worker.GetEvent().Clear(m_system.Kernel());
+                if (m_pm_state_change_handler.m_priority <= 1) {
+                    m_alarm_worker.OnPowerStateChanged();
+                }
+                break;
 
-            m_set_sys->SetUserSystemClockContext(context);
-            m_file_timestamp_worker.SetFilesystemPosixTime();
-            break;
-        }
+            case EventType::SignalAlarms:
+                m_alarm_worker.GetTimerEvent().Clear(m_system.Kernel());
+                m_time_m->CheckAndSignalAlarms();
+                break;
 
-        case EventType::UpdateNetworkSystemClock: {
-            m_network_clock_event->Clear(m_system.Kernel());
+            case EventType::UpdateLocalSystemClock: {
+                m_local_clock_event->Clear(m_system.Kernel());
 
-            Service::PSC::Time::SystemClockContext context{};
-            R_ASSERT(m_network_clock->GetSystemClockContext(&context));
+                Service::PSC::Time::SystemClockContext context{};
+                R_ASSERT(m_local_clock->GetSystemClockContext(&context));
 
-            m_set_sys->SetNetworkSystemClockContext(context);
-
-            s64 time{};
-            if (m_network_clock->GetCurrentTime(&time) != ResultSuccess) {
+                m_set_sys->SetUserSystemClockContext(context);
+                m_file_timestamp_worker.SetFilesystemPosixTime();
                 break;
             }
 
-            [[maybe_unused]] auto offset_before{
-                m_ig_report_network_clock_context_set ? m_report_network_clock_context.offset : 0};
-            // TODO system report "standard_netclock_operation"
-            //              "clock_time" = time
-            //              "context_offset_before" = offset_before
-            //              "context_offset_after"  = context.offset
-            m_report_network_clock_context = context;
-            if (!m_ig_report_network_clock_context_set) {
-                m_ig_report_network_clock_context_set = true;
-            }
+            case EventType::UpdateNetworkSystemClock: {
+                m_network_clock_event->Clear(m_system.Kernel());
 
-            m_file_timestamp_worker.SetFilesystemPosixTime();
-            break;
-        }
+                Service::PSC::Time::SystemClockContext context{};
+                R_ASSERT(m_network_clock->GetSystemClockContext(&context));
 
-        case EventType::UpdateEphemeralSystemClock: {
-            m_ephemeral_clock_event->Clear(m_system.Kernel());
+                m_set_sys->SetNetworkSystemClockContext(context);
 
-            Service::PSC::Time::SystemClockContext context{};
-            auto res = m_ephemeral_clock->GetSystemClockContext(&context);
-            if (res != ResultSuccess) {
+                s64 time{};
+                if (m_network_clock->GetCurrentTime(&time) != ResultSuccess) {
+                    break;
+                }
+
+                [[maybe_unused]] auto offset_before{
+                    m_ig_report_network_clock_context_set ? m_report_network_clock_context.offset : 0};
+                // TODO system report "standard_netclock_operation"
+                //              "clock_time" = time
+                //              "context_offset_before" = offset_before
+                //              "context_offset_after"  = context.offset
+                m_report_network_clock_context = context;
+                if (!m_ig_report_network_clock_context_set) {
+                    m_ig_report_network_clock_context_set = true;
+                }
+
+                m_file_timestamp_worker.SetFilesystemPosixTime();
                 break;
             }
 
-            s64 time{};
-            res = m_ephemeral_clock->GetCurrentTime(&time);
-            if (res != ResultSuccess) {
+            case EventType::UpdateEphemeralSystemClock: {
+                m_ephemeral_clock_event->Clear(m_system.Kernel());
+
+                Service::PSC::Time::SystemClockContext context{};
+                auto res = m_ephemeral_clock->GetSystemClockContext(&context);
+                if (res != ResultSuccess) {
+                    break;
+                }
+
+                s64 time{};
+                res = m_ephemeral_clock->GetCurrentTime(&time);
+                if (res != ResultSuccess) {
+                    break;
+                }
+
+                [[maybe_unused]] auto offset_before{m_ig_report_ephemeral_clock_context_set
+                                                        ? m_report_ephemeral_clock_context.offset
+                                                        : 0};
+                // TODO system report "ephemeral_netclock_operation"
+                //              "clock_time" = time
+                //              "context_offset_before" = offset_before
+                //              "context_offset_after"  = context.offset
+                m_report_ephemeral_clock_context = context;
+                if (!m_ig_report_ephemeral_clock_context_set) {
+                    m_ig_report_ephemeral_clock_context_set = true;
+                }
                 break;
             }
 
-            [[maybe_unused]] auto offset_before{m_ig_report_ephemeral_clock_context_set
-                                                    ? m_report_ephemeral_clock_context.offset
-                                                    : 0};
-            // TODO system report "ephemeral_netclock_operation"
-            //              "clock_time" = time
-            //              "context_offset_before" = offset_before
-            //              "context_offset_after"  = context.offset
-            m_report_ephemeral_clock_context = context;
-            if (!m_ig_report_ephemeral_clock_context_set) {
-                m_ig_report_ephemeral_clock_context_set = true;
+            case EventType::UpdateSteadyClock:
+                m_timer_steady_clock->Clear(m_system.Kernel());
+
+                m_steady_clock_resource.UpdateTime();
+                m_time_m->SetStandardSteadyClockBaseTime(m_steady_clock_resource.GetTime());
+                break;
+
+            case EventType::UpdateFileTimestamp:
+                m_timer_file_system->Clear(m_system.Kernel());
+                m_file_timestamp_worker.SetFilesystemPosixTime();
+                break;
+
+            case EventType::AutoCorrect: {
+                m_standard_user_auto_correct_clock_event->Clear(m_system.Kernel());
+
+                bool automatic_correction{};
+                R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(&automatic_correction));
+
+                Service::PSC::Time::SteadyClockTimePoint time_point{};
+                R_ASSERT(m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&time_point));
+
+                m_set_sys->SetUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
+                m_set_sys->SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
+                break;
+            }
+            default:
+                UNREACHABLE();
             }
-            break;
         }
-
-        case EventType::UpdateSteadyClock:
-            m_timer_steady_clock->Clear(m_system.Kernel());
-
-            m_steady_clock_resource.UpdateTime();
-            m_time_m->SetStandardSteadyClockBaseTime(m_steady_clock_resource.GetTime());
-            break;
-
-        case EventType::UpdateFileTimestamp:
-            m_timer_file_system->Clear(m_system.Kernel());
-
-            m_file_timestamp_worker.SetFilesystemPosixTime();
-            break;
-
-        case EventType::AutoCorrect: {
-            m_standard_user_auto_correct_clock_event->Clear(m_system.Kernel());
-
-            bool automatic_correction{};
-            R_ASSERT(m_time_sm->IsStandardUserSystemClockAutomaticCorrectionEnabled(
-                &automatic_correction));
-
-            Service::PSC::Time::SteadyClockTimePoint time_point{};
-            R_ASSERT(
-                m_time_sm->GetStandardUserSystemClockAutomaticCorrectionUpdatedTime(&time_point));
-
-            m_set_sys->SetUserSystemClockAutomaticCorrectionEnabled(automatic_correction);
-            m_set_sys->SetUserSystemClockAutomaticCorrectionUpdatedTime(time_point);
-            break;
-        }
-
-        default:
-            UNREACHABLE();
-        }
-    }
+        m_process_cv.notify_one();
+    });
 }
 
 } // namespace Service::Glue::Time

src/core/hle/service/glue/time/worker.h

@@ -1,8 +1,12 @@
+// 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
 
 #pragma once
 
+#include <condition_variable>
 #include "common/common_types.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/glue/time/alarm_worker.h"
@@ -33,17 +37,17 @@ public:
 
     void StartThread();
 
-private:
     template <typename T>
     T GetSettingsItemValue(const std::string& category, const std::string& name);
 
-    void ThreadFunc(std::stop_token stop_token);
-
     Core::System& m_system;
     KernelHelpers::ServiceContext m_ctx;
     std::shared_ptr<Service::Set::ISystemSettingsServer> m_set_sys;
 
-    std::jthread m_thread;
+    std::mutex m_process_mutex;
+    std::condition_variable m_process_cv;
+    std::stop_source m_stop_source;
+
     Kernel::KEvent* m_event{};
     std::shared_ptr<Service::PSC::Time::ServiceManager> m_time_m;
     std::shared_ptr<Service::PSC::Time::StaticService> m_time_sm;

src/core/hle/service/server_manager.cpp

@@ -253,6 +253,13 @@ void ServerManager::StartAdditionalHostThreads(const char* name, size_t num_thre
     }
 }
 
+/// @brief Notifies that the system is shutting down (pre-emptively terminate threads)
+void ServerManager::NotifyShutdown() {
+    m_stop_source.request_stop();
+    // Wake them up regardless
+    m_wakeup_event->Signal(m_system.Kernel());
+}
+
 Result ServerManager::LoopProcess() {
     SCOPE_EXIT {
         m_stopped.Set();
@@ -285,9 +292,8 @@ MultiWaitHolder* ServerManager::WaitSignaled() {
         this->LinkDeferred();
 
         // If we're done, return before we start waiting.
-        if (m_stop_source.stop_requested()) {
+        if (m_stop_source.stop_requested())
             return nullptr;
-        }
 
         auto* selected = m_multi_wait.WaitAny(m_system.Kernel());
         if (selected == std::addressof(*m_wakeup_holder)) {

src/core/hle/service/server_manager.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
 
@@ -49,6 +52,7 @@ public:
 
     Result LoopProcess();
     void StartAdditionalHostThreads(const char* name, size_t num_threads);
+    void NotifyShutdown();
 
     static void RunServer(std::unique_ptr<ServerManager>&& server);
 

src/core/hle/service/services.cpp

@@ -117,7 +117,6 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
         {"friends",    &Friend::LoopProcess},
         {"settings",   &Set::LoopProcess},
         {"psc",        &PSC::LoopProcess},
-        {"glue",       &Glue::LoopProcess},
         {"grc",        &GRC::LoopProcess},
         {"hid",        &HID::LoopProcess},
         {"jit",        &JIT::LoopProcess},
@@ -153,6 +152,7 @@ Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system
         {"usb",        &USB::LoopProcess},
         {"i2c",        &I2C::LoopProcess},
         {"gpio",        &GPIO::LoopProcess},
+        {"glue",       &Glue::LoopProcess},
     })
         kernel.RunOnGuestCoreProcess(std::string(e.first), [&system, f = e.second] { f(system); });
 }

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

@@ -11,6 +11,7 @@
 #include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/hle/kernel/kernel.h"
 #include "core/hle/service/vi/conductor.h"
 #include "core/hle/service/vi/container.h"
 #include "core/hle/service/vi/display_list.h"
@@ -29,24 +30,29 @@ Conductor::Conductor(Core::System& system, Container& container, DisplayList& di
     });
 
     if (system.IsMulticore()) {
-        m_event = Core::Timing::CreateEvent(
-            "ScreenComposition",
-            [this](s64 time,
-                   std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-                m_signal.Set();
-                return std::chrono::nanoseconds(this->GetNextTicks());
-            });
+        m_event = Core::Timing::CreateEvent("ScreenComposition", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            m_signal.Set();
+            return std::chrono::nanoseconds(this->GetNextTicks());
+        });
 
         system.CoreTiming().ScheduleLoopingEvent(FrameNs, FrameNs, m_event);
-        m_thread = std::jthread([this](std::stop_token token) { this->VsyncThread(token); });
-    } else {
-        m_event = Core::Timing::CreateEvent(
-            "ScreenComposition",
-            [this](s64 time,
-                   std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+        m_thread = system.Kernel().RunOnHostCoreThread("VSyncThread", [this]() {
+            auto const stop_token = m_thread.get_stop_token();
+            Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
+            Common::SetCurrentThreadToPerformanceCores();
+            while (!stop_token.stop_requested()) {
+                m_signal.Wait();
+                if (stop_token.stop_requested() || m_system.IsShuttingDown()) {
+                    break;
+                }
                 this->ProcessVsync();
-                return std::chrono::nanoseconds(this->GetNextTicks());
-            });
+            }
+        });
+    } else {
+        m_event = Core::Timing::CreateEvent("ScreenComposition", [this](s64 time, std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
+            this->ProcessVsync();
+            return std::chrono::nanoseconds(this->GetNextTicks());
+        });
 
         system.CoreTiming().ScheduleLoopingEvent(FrameNs, FrameNs, m_event);
     }
@@ -54,10 +60,10 @@ Conductor::Conductor(Core::System& system, Container& container, DisplayList& di
 
 Conductor::~Conductor() {
     m_system.CoreTiming().UnscheduleEvent(m_event);
-
-    if (m_system.IsMulticore()) {
+    if (m_thread.joinable()) {
         m_thread.request_stop();
         m_signal.Set();
+        m_thread.join();
     }
 }
 
@@ -83,22 +89,6 @@ void Conductor::ProcessVsync() {
     }
 }
 
-void Conductor::VsyncThread(std::stop_token token) {
-    Common::SetCurrentThreadName("VSyncThread");
-    Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
-    Common::SetCurrentThreadToPerformanceCores();
-
-    while (!token.stop_requested()) {
-        m_signal.Wait();
-
-        if (m_system.IsShuttingDown()) {
-            return;
-        }
-
-        this->ProcessVsync();
-    }
-}
-
 s64 Conductor::GetNextTicks() const {
     const auto& settings = Settings::values;
     auto speed_scale = 1.f;

src/core/memory.cpp

@@ -101,8 +101,10 @@ 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[addr >> YUZU_PAGEBITS].ptr.Type();
+            const Common::PageType page_type = current_page_table->entries.GetUnchecked(addr >> YUZU_PAGEBITS).Type();
             switch (page_type) {
             case Common::PageType::RasterizerCachedMemory:
                 if (protect_bytes > 0) {
@@ -123,16 +125,14 @@ struct Memory::Impl {
     }
 
     [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(u64 vaddr) const {
-        Common::PhysicalAddress const paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
-        if (paddr)
-            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
+        if (u64 paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Pointer(true); paddr)
+            return reinterpret_cast<u8*>(paddr) + vaddr;
         return {};
     }
 
     [[nodiscard]] u8* GetPointerFromDebugMemory(u64 vaddr) const {
-        const Common::PhysicalAddress paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].addr;
-        if (paddr != 0)
-            return system.DeviceMemory().GetPointer<u8>(paddr + vaddr);
+        if (u64 paddr = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Pointer(true); paddr)
+            return reinterpret_cast<u8*>(paddr) + vaddr;
         return {};
     }
 
@@ -243,10 +243,12 @@ 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[page_index].ptr.PointerType();
+            const auto [pointer, type, _] = current_page_table->entries.GetUnchecked(page_index).PointerTypeBlock();
             switch (type) {
             case Common::PageType::Unmapped: {
                 user_accessible = false;
@@ -297,10 +299,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) {
@@ -404,11 +406,14 @@ 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) {
-            const Common::PageType page_type = current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Type();
+            auto& entry = current_page_table->entries.GetUnchecked(vaddr >> YUZU_PAGEBITS);
+            const auto [pointer, type, block] = entry.PointerTypeBlock(true);
             if (debug) {
                 // Switch page type to debug if now debug
-                switch (page_type) {
+                switch (type) {
                 case Common::PageType::Unmapped:
                     ASSERT(false && "Attempted to mark unmapped pages as debug");
                     break;
@@ -417,14 +422,14 @@ struct Memory::Impl {
                     // Page is already marked.
                     break;
                 case Common::PageType::Memory:
-                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::DebugMemory);
+                    entry.MarkDebug(pointer, block);
                     break;
                 default:
                     UNREACHABLE();
                 }
             } else {
                 // Switch page type to non-debug if now non-debug
-                switch (page_type) {
+                switch (type) {
                 case Common::PageType::Unmapped:
                     ASSERT(false && "Attempted to mark unmapped pages as non-debug");
                     break;
@@ -433,8 +438,7 @@ struct Memory::Impl {
                     // Don't mess with already non-debug or rasterizer memory.
                     break;
                 case Common::PageType::DebugMemory: {
-                    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);
+                    entry.Store(false, Common::PageType::Memory, block, pointer);
                     break;
                 }
                 default:
@@ -466,8 +470,10 @@ 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) {
-            const Common::PageType page_type= current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Type();
+            auto& entry = current_page_table->entries.GetUnchecked(vaddr >> YUZU_PAGEBITS);
+            const Common::PageType page_type = entry.Type();
             if (cached) {
                 // Switch page type to cached if now cached
                 switch (page_type) {
@@ -477,7 +483,7 @@ struct Memory::Impl {
                     break;
                 case Common::PageType::DebugMemory:
                 case Common::PageType::Memory:
-                    current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::RasterizerCachedMemory);
+                    entry.MarkRasterizerCached();
                     break;
                 case Common::PageType::RasterizerCachedMemory:
                     // There can be more than one GPU region mapped per CPU region, so it's common
@@ -499,13 +505,13 @@ struct Memory::Impl {
                     // that this area is already unmarked as cached.
                     break;
                 case Common::PageType::RasterizerCachedMemory: {
-                    if (u8* const pointer = GetPointerFromRasterizerCachedMemory(vaddr & ~YUZU_PAGEMASK); pointer == nullptr) {
+                    if (auto [ptr, _, block] = entry.PointerTypeBlock(true); ptr == 0) {
                         // 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.
-                        current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(0, Common::PageType::Unmapped);
+                        entry.Store(false, Common::PageType::Unmapped, block, 0);
                     } else {
-                        current_page_table->entries[vaddr >> YUZU_PAGEBITS].ptr.Store(uintptr_t(pointer) - (vaddr & ~YUZU_PAGEMASK), Common::PageType::Memory);
+                        entry.Store(false, Common::PageType::Memory, block, ptr);
                     }
                     break;
                 }
@@ -539,22 +545,18 @@ struct Memory::Impl {
             ASSERT_MSG(type != Common::PageType::Memory,
                        "Mapping memory page without a pointer @ {:016x}", base * YUZU_PAGESIZE);
 
-            while (base != end) {
-                page_table.entries[base].ptr.Store(0, type);
-                page_table.entries[base].addr = 0;
-                page_table.entries[base].block = 0;
-                base += 1;
-            }
+            page_table.entries.ZeroRegion(base, end);
         } 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;
+            auto current_block = block_count.fetch_add(1, std::memory_order_relaxed);
+            ASSERT(current_block != 65535);
 
-                ASSERT_MSG(page_table.entries[base].ptr.Pointer(),
+            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);
+
+                entry.Store(false, type, current_block, host_ptr);
+                ASSERT_MSG(page_table.entries[base].Pointer(),
                            "memory mapping base yield a nullptr within the table");
 
                 base += 1;
@@ -569,11 +571,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 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]] {
+            const auto raw = current_page_table->entries[vaddr >> YUZU_PAGEBITS].Raw();
+            if (auto pointer = Common::PageTable::PageEntryData::ExtractPointer(raw); pointer) [[likely]] {
                 return reinterpret_cast<u8*>(pointer + vaddr);
             } else {
-                switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+                switch (static_cast<Common::PageType>(raw.type)) {
                 case Common::PageType::Memory:
                     ASSERT_MSG(false, "Mapped memory page without a pointer @ {:#016x}", vaddr);
                     return nullptr;
@@ -773,6 +775,7 @@ struct Memory::Impl {
 #else
     Common::HostMemory* host_buffer{};
 #endif
+    std::atomic<u16> block_count = 0;
 };
 
 Memory::Memory(Core::System& system_) : system{system_} {
@@ -811,7 +814,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].ptr.PointerType();
+    const auto [pointer, type, _] = page_table.entries[page].PointerTypeBlock();
     return pointer != 0 || type == Common::PageType::RasterizerCachedMemory ||
            type == Common::PageType::DebugMemory;
 }

src/core/memory/dmnt_cheat_vm.cpp

@@ -1,6 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+// gcc14 bug
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/memory/dmnt_cheat_types.h"
@@ -1266,3 +1275,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
 }
 
 } // namespace Core::Memory
+
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif

src/core/memory/dmnt_cheat_vm.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 2019 yuzu Emulator Project
@@ -254,14 +254,16 @@ struct UnrecognizedInstruction {
 
 struct CheatVmOpcode {
     bool begin_conditional_block{};
-    std::variant<StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
-                 LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
-                 PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
-                 PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
-                 BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
-                 SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
-                 ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction>
-        opcode{};
+    std::variant<
+        std::monostate,
+        StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
+        LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
+        PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
+        PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
+        BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
+        SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
+        ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction
+    > opcode{};
 };
 
 class DmntCheatVm {

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

@@ -407,8 +407,10 @@ EmitConfig A32AddressSpace::GetEmitConfig() {
 
         .page_table_pointer = std::bit_cast<u64>(conf.page_table),
         .page_table_address_space_bits = 32,
-        .page_table_pointer_mask_bits = conf.page_table_pointer_mask_bits,
+        .page_table_pointer_mask = conf.page_table_pointer_mask,
         .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,

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

@@ -579,8 +579,10 @@ EmitConfig A64AddressSpace::GetEmitConfig() {
 
         .page_table_pointer = std::bit_cast<u64>(conf.page_table),
         .page_table_address_space_bits = conf.page_table_address_space_bits,
-        .page_table_pointer_mask_bits = conf.page_table_pointer_mask_bits,
+        .page_table_pointer_mask = conf.page_table_pointer_mask,
         .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 = conf.silently_mirror_page_table,
         .absolute_offset_page_table = conf.absolute_offset_page_table,
         .detect_misaligned_access_via_page_table = conf.detect_misaligned_access_via_page_table,

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64.h

@@ -128,8 +128,10 @@ struct EmitConfig {
     // Page table
     u64 page_table_pointer;
     std::size_t page_table_address_space_bits;
-    int page_table_pointer_mask_bits;
+    u64 page_table_pointer_mask;
     std::size_t page_table_log2_stride;
+    std::optional<std::uint8_t> page_table_marked_bit;
+    std::optional<std::uint8_t> page_table_sign_extension;
     bool silently_mirror_page_table;
     bool absolute_offset_page_table;
     u8 detect_misaligned_access_via_page_table;

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_memory.cpp

@@ -273,9 +273,18 @@ std::pair<oaknut::XReg, oaknut::XReg> InlinePageTableEmitVAddrLookup(oaknut::Cod
     // load x0 = *<(u8*)pagetable + index>
     code.LDR(Xscratch0, Xpagetable, Xscratch0);
 
-    if (ctx.conf.page_table_pointer_mask_bits != 0) {
-        const u64 mask = u64(~u64(0)) << ctx.conf.page_table_pointer_mask_bits;
-        code.AND(Xscratch0, Xscratch0, mask);
+    if (ctx.conf.page_table_marked_bit) {
+        code.TST(Xscratch0, 1ULL << *ctx.conf.page_table_marked_bit);
+        code.B(NE, *fallback);
+    }
+
+    if (ctx.conf.page_table_pointer_mask != 0) {
+        code.AND(Xscratch0, Xscratch0, ctx.conf.page_table_pointer_mask);
+    }
+
+    // TODO: combine this with page_table_pointer_mask
+    if (ctx.conf.page_table_sign_extension) {
+        code.SBFM(Xscratch0, Xscratch0, 0, *ctx.conf.page_table_sign_extension);
     }
 
     code.CBZ(Xscratch0, *fallback);

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <bit>
+#include <utility>
 #include "dynarmic/backend/x64/xbyak.h"
 
 #include "dynarmic/backend/x64/a32_emit_x64.h"
@@ -78,27 +79,46 @@ Xbyak::RegExp EmitVAddrLookup(BlockOfCode& code, EmitContext& ctx, size_t bitsiz
 template<>
 [[maybe_unused]] Xbyak::RegExp EmitVAddrLookup<A32EmitContext>(BlockOfCode& code, A32EmitContext& ctx, size_t bitsize, Xbyak::Label& abort, Xbyak::Reg64 vaddr) {
     const Xbyak::Reg64 page = ctx.reg_alloc.ScratchGpr(code);
-    const Xbyak::Reg32 tmp = ctx.conf.absolute_offset_page_table ? page.cvt32() : ctx.reg_alloc.ScratchGpr(code).cvt32();
+    const Xbyak::Reg64 tmp = ctx.conf.absolute_offset_page_table && ctx.conf.page_table_pointer_mask == 0 ? page : ctx.reg_alloc.ScratchGpr(code);
 
-    EmitDetectMisalignedVAddr(code, ctx, bitsize, abort, vaddr, tmp.cvt64());
+    EmitDetectMisalignedVAddr(code, ctx, bitsize, abort, vaddr, tmp);
 
-    // TODO: This code assumes vaddr has been zext from 32-bits to 64-bits.
-
-    code.mov(tmp, vaddr.cvt32());
+    code.mov(tmp, vaddr);
     code.shr(tmp, int(page_table_const_bits));
-    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-    code.mov(page, qword[r14 + tmp.cvt64()]);
-    if (ctx.conf.page_table_pointer_mask_bits == 0) {
-        code.test(page, page);
+
+    if (ctx.conf.page_table_log2_stride > 3) {
+        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+        code.mov(page, qword[r14 + tmp.cvt64()]);
     } else {
-        code.and_(page, ~u32(0) << ctx.conf.page_table_pointer_mask_bits);
+        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
     }
+
+    // check for marked bit, use as unmapped if marked
+	if (ctx.conf.page_table_marked_bit) {
+        code.bt(page, *ctx.conf.page_table_marked_bit);
+        code.jc(abort, code.T_NEAR);
+	}
+    // mask away attributes
+    if (ctx.conf.page_table_pointer_mask == 0) {
+        code.test(page, page);
+    } else if (std::in_range<s32>(ctx.conf.page_table_pointer_mask)) {
+        code.and_(page, ctx.conf.page_table_pointer_mask);
+    } else {
+        code.mov(tmp, ctx.conf.page_table_pointer_mask);
+        code.and_(page, tmp);
+    }
+    // check for sign bit, apply sign extension as needed
+    if (ctx.conf.page_table_sign_extension) {
+        code.shl(page, 63 - int(*ctx.conf.page_table_sign_extension));
+        code.sar(page, 63 - int(*ctx.conf.page_table_sign_extension));
+    }
+
     code.jz(abort, code.T_NEAR);
     if (ctx.conf.absolute_offset_page_table) {
         return page + vaddr;
     }
-    code.mov(tmp, vaddr.cvt32());
-    code.and_(tmp, static_cast<u32>(page_table_const_mask));
+    code.mov(tmp, vaddr);
+    code.and_(tmp, u32(page_table_const_mask));
     return page + tmp.cvt64();
 }
 
@@ -108,7 +128,7 @@ template<>
     const size_t unused_top_bits = 64 - ctx.conf.page_table_address_space_bits;
 
     const Xbyak::Reg64 page = ctx.reg_alloc.ScratchGpr(code);
-    const Xbyak::Reg64 tmp = ctx.conf.absolute_offset_page_table ? page : ctx.reg_alloc.ScratchGpr(code);
+    const Xbyak::Reg64 tmp = ctx.conf.absolute_offset_page_table && ctx.conf.page_table_pointer_mask == 0 ? page : ctx.reg_alloc.ScratchGpr(code);
 
     EmitDetectMisalignedVAddr(code, ctx, bitsize, abort, vaddr, tmp);
 
@@ -141,13 +161,39 @@ template<>
         code.jnz(abort, code.T_NEAR);
     }
 
-    code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-    code.mov(page, qword[r14 + tmp]);
-    if (ctx.conf.page_table_pointer_mask_bits == 0) {
-        code.test(page, page);
+    if (ctx.conf.page_table_log2_stride > 3) {
+        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+        code.mov(page, qword[r14 + tmp.cvt64()]);
     } else {
-        code.and_(page, ~u32(0) << ctx.conf.page_table_pointer_mask_bits);
+        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
     }
+
+    // check for marked bit, use as unmapped if marked
+    if (ctx.conf.page_table_marked_bit) {
+        auto const marked_bit = *ctx.conf.page_table_marked_bit;
+        if (s64(s32(1 << marked_bit)) == s64(1 << marked_bit)) {
+            code.test(page, s32(1 << marked_bit));
+            code.jnz(abort, code.T_NEAR);
+        } else {
+            code.bt(page, marked_bit);
+            code.jc(abort, code.T_NEAR);
+        }
+    }
+    // mask away attributes
+    if (ctx.conf.page_table_pointer_mask == 0) {
+        code.test(page, page);
+    } else if (s64(s32(ctx.conf.page_table_pointer_mask)) == s64(ctx.conf.page_table_pointer_mask)) {
+        code.and_(page, ctx.conf.page_table_pointer_mask);
+    } else {
+        code.mov(tmp, ctx.conf.page_table_pointer_mask);
+        code.and_(page, tmp);
+    }
+    // check for sign bit, apply sign extension as needed
+    if (ctx.conf.page_table_sign_extension) {
+        code.shl(page, *ctx.conf.page_table_sign_extension);
+        code.sar(page, *ctx.conf.page_table_sign_extension);
+    }
+
     code.jz(abort, code.T_NEAR);
     if (ctx.conf.absolute_offset_page_table) {
         return page + vaddr;

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

@@ -155,14 +155,23 @@ struct UserConfig {
     /// Maximum size is limited by the maximum length of a x86_64 / arm64 jump.
     std::uint32_t code_cache_size = 128 * 1024 * 1024;  // bytes
 
-    /// Masks out the first N bits in host pointers from the page table.
+    /// Applies a bit mask to the bits in host pointers from the page table.
     /// The intention behind this is to allow users of Dynarmic to pack attributes in the
     /// same integer and update the pointer attribute pair atomically.
-    /// If the configured value is 3, all pointers will be forcefully aligned to 8 bytes.
-    std::int32_t page_table_pointer_mask_bits = 0;
+    /// If the configured value is ~(0b111ULL), all pointers will be forcefully aligned to 8 bytes.
+    std::uint64_t page_table_pointer_mask = 0;
 
-    // Log2 of the size per page entry, value should be either 3 or 4
-    std::size_t page_table_log2_stride = 3;
+    /// Log2 of the size per page entry, value should be either 3 or 4
+    std::uint32_t page_table_log2_stride = 3;
+
+    /// Setting this value has Dynarmic check the specified bit of the page pointer provided by page table.
+    /// If the bit is set to 1, Dynarmic will treat it as unmapped.
+    /// This bit should be included as part of `page_table_pointer_mask_bits`.
+    std::optional<std::uint8_t> page_table_marked_bit = std::nullopt;
+
+    /// If this value is set, Dynarmic will sign extend the page table pointer by this bit.
+    /// Useful for compacting bits into the page table and should be used as part of `page_table_pointer_mask`.
+    std::optional<std::uint8_t> page_table_sign_extension = std::nullopt;
 
     /// Select the architecture version to use.
     /// There are minor behavioural differences between versions.

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

@@ -169,14 +169,23 @@ struct UserConfig {
     /// This is only used if page_table is not nullptr.
     std::uint32_t page_table_address_space_bits = 36;
 
-    /// Masks out the first N bits in host pointers from the page table.
+    /// Applies a bit mask to the bits in host pointers from the page table.
     /// The intention behind this is to allow users of Dynarmic to pack attributes in the
     /// same integer and update the pointer attribute pair atomically.
-    /// If the configured value is 3, all pointers will be forcefully aligned to 8 bytes.
-    std::int32_t page_table_pointer_mask_bits = 0;
+    /// If the configured value is ~(0b111ULL), all pointers will be forcefully aligned to 8 bytes.
+    std::uint64_t page_table_pointer_mask = 0;
 
-    // Log2 of the size per page entry, value should be either 3 or 4
-    std::size_t page_table_log2_stride = 3;
+    /// Log2 of the size per page entry, value should be either 3 or 4
+    std::uint32_t page_table_log2_stride = 3;
+
+    /// Setting this value has Dynarmic check the specified bit of the page pointer provided by page table.
+    /// If the bit is set to 1, Dynarmic will treat it as unmapped.
+    /// This bit should be included as part of `page_table_pointer_mask`.
+    std::optional<std::uint8_t> page_table_marked_bit = std::nullopt;
+
+    /// If this value is set, Dynarmic will sign extend the page table pointer by this bit.
+    /// Useful for compacting bits into the page table and should be used as part of `page_table_pointer_mask`.
+    std::optional<std::uint8_t> page_table_sign_extension = std::nullopt;
 
     /// Counter-timer frequency register. The value of the register is not interpreted by
     /// dynarmic.

src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp

@@ -79,8 +79,10 @@ void NpadAbstractButtonHandler::UpdateAllButtonLifo() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-        UpdateButtonLifo(npad_entry, data->aruid);
+        if (auto const shfmt = data->shared_memory_format; shfmt) {
+            auto& npad_entry = shfmt->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+            UpdateButtonLifo(npad_entry, data->aruid);
+        }
     }
 }
 
@@ -88,19 +90,19 @@ void NpadAbstractButtonHandler::UpdateCoreBatteryState() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-        UpdateButtonLifo(npad_entry, data->aruid);
+        if (auto const shfmt = data->shared_memory_format; shfmt) {
+            auto& npad_entry = shfmt->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+            UpdateButtonLifo(npad_entry, data->aruid);
+        }
     }
 }
 
 void NpadAbstractButtonHandler::UpdateButtonState(u64 aruid) {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
-    auto* data = applet_resource_holder->applet_resource->GetAruidData(aruid);
-    if (data == nullptr) {
-        return;
+    if (auto data = applet_resource_holder->applet_resource->GetAruidData(aruid); data) {
+        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+        UpdateButtonLifo(npad_entry, aruid);
     }
-    auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-    UpdateButtonLifo(npad_entry, aruid);
 }
 
 Result NpadAbstractButtonHandler::SetHomeProtection(bool is_enabled, u64 aruid) {

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -496,31 +496,30 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
 }
 
 void PatchPhiNodes(IR::Program& program, EmitContext& ctx) {
-            // Flatten all leading PHIs from each block into a vector
-            std::vector<IR::Inst*> phi_instructions;
-            for (IR::Block* block : program.blocks) {
-                for (auto it = block->begin(); it != block->end(); ++it) {
-                    if (it->GetOpcode() != IR::Opcode::Phi)
-                        break;
-                    phi_instructions.push_back(&*it);
-                }
-            }
-
-            if (phi_instructions.empty()) {
-                return; // nothing to patch
-            }
-
-            // Start "before" first PHI; advance on phi_arg == 0
-            size_t phi_index = static_cast<size_t>(-1);
-
-            ctx.PatchDeferredPhi([&](size_t phi_arg, Id parent) -> std::pair<Id, Id> {
-                if (phi_arg == 0) {
-                    ++phi_index;
-                }
-                IR::Inst* phi = phi_instructions[phi_index];
-                return { ctx.Def(phi->Arg(phi_arg)), parent };
-            });
+    // Flatten all leading PHIs from each block into a vector
+    std::vector<IR::Inst*> phi_instructions;
+    for (IR::Block* block : program.blocks) {
+        for (auto it = block->begin(); it != block->end(); ++it) {
+            if (it->GetOpcode() != IR::Opcode::Phi)
+                break;
+            phi_instructions.push_back(&*it);
         }
+    }
+
+    if (phi_instructions.empty()) {
+        return; // nothing to patch
+    }
+
+    // Start "before" first PHI; advance on phi_arg == 0
+    size_t phi_index = size_t(-1);
+    ctx.PatchDeferredPhi([&ctx, &phi_index, phi_insts = std::move(phi_instructions)](size_t phi_arg, Id parent) -> std::pair<Id, Id> {
+        if (phi_arg == 0) {
+            ++phi_index;
+        }
+        IR::Inst* phi = phi_insts[phi_index];
+        return { ctx.Def(phi->Arg(phi_arg)), parent };
+    });
+}
 } // Anonymous namespace
 
 std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info, IR::Program& program, Bindings& bindings) {

src/video_core/memory_manager.cpp

@@ -46,8 +46,8 @@ MemoryManager::MemoryManager(Core::System& system_, MaxwellDeviceMemoryManager&
     page_table_mask = page_table_size - 1;
     big_page_table_mask = big_page_table_size - 1;
 
+    big_page_table_dev.ResizeAndClear(big_page_table_size);
     big_entries.resize(big_page_table_size / 32, 0);
-    big_page_table_dev.resize(big_page_table_size);
     big_page_continuous.resize(big_page_table_size / continuous_bits, 0);
     entries.resize(page_table_size / 32, 0);
 }
@@ -143,7 +143,7 @@ GPUVAddr MemoryManager::BigPageTableOp(GPUVAddr gpu_addr, [[maybe_unused]] DAddr
             const DAddr current_dev_addr = dev_addr + offset;
             const auto index = PageEntryIndex(current_gpu_addr, true);
             const u32 sub_value = static_cast<u32>(current_dev_addr >> cpu_page_bits);
-            big_page_table_dev[index] = sub_value;
+            big_page_table_dev.Set(index, sub_value);
             const bool is_continuous = ([&] {
                 uintptr_t base_ptr{
                     reinterpret_cast<uintptr_t>(memory.GetPointer<u8>(current_dev_addr))};

src/video_core/memory_manager.h

@@ -17,7 +17,7 @@
 #include "common/multi_level_page_table.h"
 #include "common/range_map.h"
 #include "common/scratch_buffer.h"
-#include "common/virtual_buffer.h"
+#include "common/sparse_large_vector.h"
 #include "video_core/invalidation_accumulator.h"
 #include "video_core/cache_types.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
@@ -214,7 +214,7 @@ private:
 
     Common::MultiLevelPageTable<u32> page_table;
     Common::RangeMap<GPUVAddr, PTEKind> kind_map;
-    Common::VirtualBuffer<u32> big_page_table_dev;
+    Common::SparseLargeVector<u32> big_page_table_dev;
 
     std::vector<u64> big_page_continuous;
     boost::container::small_vector<std::pair<DAddr, std::size_t>, 32> page_stash{};

src/yuzu_headless/main.cpp

@@ -0,0 +1,122 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: 2014 Citra Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <mutex>
+#include <regex>
+#include <string>
+
+#include "common/logging.h"
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/cpu_manager.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/vfs/vfs_real.h"
+#include "core/hle/service/am/applet_manager.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/loader/loader.h"
+#include "frontend_common/config.h"
+#include "input_common/main.h"
+#include "video_core/gpu.h"
+#include "video_core/renderer_base.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl3.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl3_null.h"
+#include "yuzu_cmd/emu_window/emu_window_sdl3_vk.h"
+
+class EmuWindow_Headless : public Core::Frontend::EmuWindow {
+public:
+    explicit EmuWindow_Headless() = default;
+    ~EmuWindow_Headless() = default;
+
+    bool IsShown() const override {
+        return true;
+    }
+    void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override {
+
+    }
+    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override {
+        return std::make_unique<DummyContext>();
+    }
+};
+
+int main(int argc, char *argv[]) {
+    struct {
+        Core::System system{};
+        EmuWindow_Headless emu_window{};
+    } state = {};
+
+    Common::Log::Initialize();
+    Common::Log::SetColorConsoleBackendEnabled(true);
+    Common::Log::Start();
+
+    if (argc < 2) {
+        LOG_CRITICAL(Frontend, "Usage: {} [ms-to-run] [file]", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    std::chrono::milliseconds time_quanta = std::chrono::milliseconds{atoi(argv[1])};
+    auto const time_end = std::chrono::steady_clock::now() + time_quanta;
+    std::string filepath = argv[2];
+
+    // apply the log_filter setting
+    // the logger was initialized before and doesn't pick up the filter on its own
+    Common::Log::Filter filter;
+    filter.ParseFilterString("*:Info");
+    Common::Log::SetGlobalFilter(filter);
+
+    if (filepath.empty()) {
+        LOG_CRITICAL(Frontend, "Failed to load ROM: No ROM specified");
+        return EXIT_FAILURE;
+    }
+
+    state.system.Initialize();
+
+    InputCommon::InputSubsystem input_subsystem{};
+
+    // Apply the command line arguments
+    state.system.ApplySettings();
+    Settings::values.renderer_backend.SetValue(Settings::RendererBackend::Null);
+
+    state.system.SetContentProvider(std::make_unique<FileSys::ContentProviderUnion>());
+    state.system.SetFilesystem(std::make_shared<FileSys::RealVfsFilesystem>());
+    state.system.GetFileSystemController().CreateFactories(*state.system.GetFilesystem());
+    state.system.GetUserChannel().clear();
+
+    Service::AM::FrontendAppletParameters load_parameters{
+        .applet_id = Service::AM::AppletId::Application,
+    };
+    if (auto const load_result = state.system.Load(state.emu_window, filepath, load_parameters); load_result != Core::SystemResultStatus::Success) {
+        LOG_CRITICAL(Frontend, "load result = {}", u32(load_result));
+        // shutdown
+        void(state.system.Pause());
+        state.system.DetachDebugger();
+        state.system.ShutdownMainProcess();
+        return EXIT_FAILURE;
+    }
+    // Core is loaded, start the GPU (makes the GPU contexts current to this thread)
+    state.system.GPU().Start();
+    state.system.GetCpuManager().OnGpuReady();
+    // don't do anything, SDL3 already exists for us :D
+    state.system.RegisterExitCallback([] {});
+    void(state.system.Run());
+    if (state.system.DebuggerEnabled())
+        state.system.InitializeDebugger();
+    while (state.system.IsPoweredOn() && !state.system.GetExitRequested()) {
+        auto const time_now = std::chrono::steady_clock::now();
+        if (time_now > time_end)
+            break;
+    }
+    // shutdown
+    void(state.system.Pause());
+    state.system.DetachDebugger();
+    state.system.ShutdownMainProcess();
+    return EXIT_SUCCESS;
+}
+
+#define VMA_IMPLEMENTATION
+#include "video_core/vulkan_common/vma.h"