Android #15

2023-07-21 00:58:54 +00:00
53 changed files with 276 additions and 326 deletions
--- a/.ci/scripts/linux/docker.sh
+++ b/.ci/scripts/linux/docker.sh
@ -35,7 +35,7 @@ DESTDIR="$PWD/AppDir" ninja install
 rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester

 # Download tools needed to build an AppImage
-wget -nc https://raw.githubusercontent.com/yuzu-emu/ext-linux-bin/main/appimage/deploy-linux.sh
+wget -nc https://raw.githubusercontent.com/yuzu-emu/ext-linux-bin/main/gcc/deploy-linux.sh
 wget -nc https://raw.githubusercontent.com/yuzu-emu/AppImageKit-checkrt/old/AppRun.sh
 wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/exec-x86_64.so
 # Set executable bit
--- a/.ci/templates/build-msvc.yml
+++ b/.ci/templates/build-msvc.yml
@ -12,7 +12,7 @@ steps:
  inputs:
    targetType: 'filePath'
    filePath: './.ci/scripts/windows/install-vulkan-sdk.ps1'
- script: refreshenv && glslangValidator --version && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_ENABLE_LTO=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
+- script: refreshenv && glslangValidator --version && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_ENABLE_LTO=ON -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
--- a/src/android/app/src/main/jni/native.cpp
+++ b/src/android/app/src/main/jni/native.cpp
@ -449,7 +449,7 @@ private:
        loader->ReadTitle(entry.title);
        loader->ReadIcon(entry.icon);
        if (loader->GetFileType() == Loader::FileType::NRO) {
-            jauto loader_nro = reinterpret_cast<Loader::AppLoader_NRO*>(loader.get());
+            jauto loader_nro = dynamic_cast<Loader::AppLoader_NRO*>(loader.get());
            entry.isHomebrew = loader_nro->IsHomebrew();
        } else {
            entry.isHomebrew = false;
--- a/src/common/settings.cpp
+++ b/src/common/settings.cpp
@ -26,8 +26,7 @@ std::string GetTimeZoneString() {

    std::string location_name;
    if (time_zone_index == 0) { // Auto
-#if __cpp_lib_chrono >= 201907L && !defined(MINGW)
-        // Disabled for MinGW -- tzdb always returns Etc/UTC
+#if __cpp_lib_chrono >= 201907L
        try {
            const struct std::chrono::tzdb& time_zone_data = std::chrono::get_tzdb();
            const std::chrono::time_zone* current_zone = time_zone_data.current_zone();
--- a/src/common/time_zone.cpp
+++ b/src/common/time_zone.cpp
@ -4,13 +4,13 @@
 #include <chrono>
 #include <exception>
 #include <iomanip>
-#include <map>
 #include <sstream>
 #include <stdexcept>
 #include <fmt/chrono.h>
 #include <fmt/core.h>

 #include "common/logging/log.h"
+#include "common/settings.h"
 #include "common/time_zone.h"

 namespace Common::TimeZone {
@ -33,29 +33,32 @@ std::string GetDefaultTimeZone() {
    return "GMT";
 }

-// Results are not comparable to seconds since Epoch
-static std::time_t TmSpecToSeconds(const struct std::tm& spec) {
-    const int year = spec.tm_year - 1; // Years up to now
-    const int leap_years = year / 4 - year / 100;
-    std::time_t cumulative = spec.tm_year;
-    cumulative = cumulative * 365 + leap_years + spec.tm_yday; // Years to days
-    cumulative = cumulative * 24 + spec.tm_hour;               // Days to hours
-    cumulative = cumulative * 60 + spec.tm_min;                // Hours to minutes
-    cumulative = cumulative * 60 + spec.tm_sec;                // Minutes to seconds
-    return cumulative;
+static std::string GetOsTimeZoneOffset() {
+    const std::time_t t{std::time(nullptr)};
+    const std::tm tm{*std::localtime(&t)};
+
+    return fmt::format("{:%z}", tm);
+}
+
+static int ConvertOsTimeZoneOffsetToInt(const std::string& timezone) {
+    try {
+        return std::stoi(timezone);
+    } catch (const std::invalid_argument&) {
+        LOG_CRITICAL(Common, "invalid_argument with {}!", timezone);
+        return 0;
+    } catch (const std::out_of_range&) {
+        LOG_CRITICAL(Common, "out_of_range with {}!", timezone);
+        return 0;
+    }
 }

 std::chrono::seconds GetCurrentOffsetSeconds() {
-    const std::time_t t{std::time(nullptr)};
-    const std::tm local{*std::localtime(&t)};
-    const std::tm gmt{*std::gmtime(&t)};
+    const int offset{ConvertOsTimeZoneOffsetToInt(GetOsTimeZoneOffset())};

-    // gmt_seconds is a different offset than time(nullptr)
-    const auto gmt_seconds = TmSpecToSeconds(gmt);
-    const auto local_seconds = TmSpecToSeconds(local);
-    const auto seconds_offset = local_seconds - gmt_seconds;
+    int seconds{(offset / 100) * 60 * 60}; // Convert hour component to seconds
+    seconds += (offset % 100) * 60;        // Convert minute component to seconds

-    return std::chrono::seconds{seconds_offset};
+    return std::chrono::seconds{seconds};
 }

 // Key is [Hours * 100 + Minutes], multiplied by 100 if DST
@ -68,6 +71,11 @@ const static std::map<s64, const char*> off_timezones = {
 };

 std::string FindSystemTimeZone() {
+#if defined(MINGW)
+    // MinGW has broken strftime -- https://sourceforge.net/p/mingw-w64/bugs/793/
+    // e.g. fmt::format("{:%z}") -- returns "Eastern Daylight Time" when it should be "-0400"
+    return timezones[0];
+#else
    const s64 seconds = static_cast<s64>(GetCurrentOffsetSeconds().count());

    const s64 minutes = seconds / 60;
@ -89,6 +97,7 @@ std::string FindSystemTimeZone() {
        }
    }
    return fmt::format("Etc/GMT{:s}{:d}", hours > 0 ? "-" : "+", std::abs(hours));
+#endif
 }

 } // namespace Common::TimeZone
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@ -346,11 +346,11 @@ void ARM_Dynarmic_32::RewindBreakpointInstruction() {
 }

 ARM_Dynarmic_32::ARM_Dynarmic_32(System& system_, bool uses_wall_clock_,
-                                 DynarmicExclusiveMonitor& exclusive_monitor_,
-                                 std::size_t core_index_)
+                                 ExclusiveMonitor& exclusive_monitor_, std::size_t core_index_)
    : ARM_Interface{system_, uses_wall_clock_}, cb(std::make_unique<DynarmicCallbacks32>(*this)),
      cp15(std::make_shared<DynarmicCP15>(*this)), core_index{core_index_},
-      exclusive_monitor{exclusive_monitor_}, null_jit{MakeJit(nullptr)}, jit{null_jit.get()} {}
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor_)},
+      null_jit{MakeJit(nullptr)}, jit{null_jit.get()} {}

 ARM_Dynarmic_32::~ARM_Dynarmic_32() = default;

--- a/src/core/arm/dynarmic/arm_dynarmic_32.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.h
@ -12,7 +12,7 @@
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
-#include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
+#include "core/arm/exclusive_monitor.h"

 namespace Core::Memory {
 class Memory;
@ -28,8 +28,8 @@ class System;

 class ARM_Dynarmic_32 final : public ARM_Interface {
 public:
-    ARM_Dynarmic_32(System& system_, bool uses_wall_clock_,
-                    DynarmicExclusiveMonitor& exclusive_monitor_, std::size_t core_index_);
+    ARM_Dynarmic_32(System& system_, bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
+                    std::size_t core_index_);
    ~ARM_Dynarmic_32() override;

    void SetPC(u64 pc) override;
--- a/src/core/arm/dynarmic/arm_dynarmic_64.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.cpp
@ -405,11 +405,11 @@ void ARM_Dynarmic_64::RewindBreakpointInstruction() {
 }

 ARM_Dynarmic_64::ARM_Dynarmic_64(System& system_, bool uses_wall_clock_,
-                                 DynarmicExclusiveMonitor& exclusive_monitor_,
-                                 std::size_t core_index_)
+                                 ExclusiveMonitor& exclusive_monitor_, std::size_t core_index_)
    : ARM_Interface{system_, uses_wall_clock_},
      cb(std::make_unique<DynarmicCallbacks64>(*this)), core_index{core_index_},
-      exclusive_monitor{exclusive_monitor_}, null_jit{MakeJit(nullptr, 48)}, jit{null_jit.get()} {}
+      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor_)},
+      null_jit{MakeJit(nullptr, 48)}, jit{null_jit.get()} {}

 ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;

--- a/src/core/arm/dynarmic/arm_dynarmic_64.h
+++ b/src/core/arm/dynarmic/arm_dynarmic_64.h
@ -11,7 +11,7 @@
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
-#include "core/arm/dynarmic/dynarmic_exclusive_monitor.h"
+#include "core/arm/exclusive_monitor.h"

 namespace Core::Memory {
 class Memory;
@ -25,8 +25,8 @@ class System;

 class ARM_Dynarmic_64 final : public ARM_Interface {
 public:
-    ARM_Dynarmic_64(System& system_, bool uses_wall_clock_,
-                    DynarmicExclusiveMonitor& exclusive_monitor_, std::size_t core_index_);
+    ARM_Dynarmic_64(System& system_, bool uses_wall_clock_, ExclusiveMonitor& exclusive_monitor_,
+                    std::size_t core_index_);
    ~ARM_Dynarmic_64() override;

    void SetPC(u64 pc) override;
--- a/src/core/arm/dynarmic/dynarmic_exclusive_monitor.h
+++ b/src/core/arm/dynarmic/dynarmic_exclusive_monitor.h
@ -6,6 +6,8 @@
 #include <dynarmic/interface/exclusive_monitor.h>

 #include "common/common_types.h"
+#include "core/arm/dynarmic/arm_dynarmic_32.h"
+#include "core/arm/dynarmic/arm_dynarmic_64.h"
 #include "core/arm/exclusive_monitor.h"

 namespace Core::Memory {
@ -14,9 +16,6 @@ class Memory;

 namespace Core {

-class ARM_Dynarmic_32;
-class ARM_Dynarmic_64;
-
 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
 public:
    explicit DynarmicExclusiveMonitor(Memory::Memory& memory_, std::size_t core_count_);
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@ -880,14 +880,6 @@ const FileSys::ContentProvider& System::GetContentProvider() const {
    return *impl->content_provider;
 }

-FileSys::ContentProviderUnion& System::GetContentProviderUnion() {
-    return *impl->content_provider;
-}
-
-const FileSys::ContentProviderUnion& System::GetContentProviderUnion() const {
-    return *impl->content_provider;
-}
-
 Service::FileSystem::FileSystemController& System::GetFileSystemController() {
    return impl->fs_controller;
 }
--- a/src/core/core.h
+++ b/src/core/core.h
@ -381,9 +381,6 @@ public:
    [[nodiscard]] FileSys::ContentProvider& GetContentProvider();
    [[nodiscard]] const FileSys::ContentProvider& GetContentProvider() const;

-    [[nodiscard]] FileSys::ContentProviderUnion& GetContentProviderUnion();
-    [[nodiscard]] const FileSys::ContentProviderUnion& GetContentProviderUnion() const;
-
    [[nodiscard]] Service::FileSystem::FileSystemController& GetFileSystemController();
    [[nodiscard]] const Service::FileSystem::FileSystemController& GetFileSystemController() const;

--- a/src/core/debugger/gdbstub.cpp
+++ b/src/core/debugger/gdbstub.cpp
@ -556,7 +556,7 @@ void GDBStub::HandleQuery(std::string_view command) {
        } else {
            SendReply(fmt::format(
                "TextSeg={:x}",
-                GetInteger(system.ApplicationProcess()->GetPageTable().GetCodeRegionStart())));
+                GetInteger(system.ApplicationProcess()->PageTable().GetCodeRegionStart())));
        }
    } else if (command.starts_with("Xfer:libraries:read::")) {
        Loader::AppLoader::Modules modules;
@ -731,7 +731,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
    std::string reply;

    auto* process = system.ApplicationProcess();
-    auto& page_table = process->GetPageTable();
+    auto& page_table = process->PageTable();

    const char* commands = "Commands:\n"
                           "  get fastmem\n"
--- a/src/core/hle/kernel/k_code_memory.cpp
+++ b/src/core/hle/kernel/k_code_memory.cpp
@ -25,7 +25,7 @@ Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, KProcessAddres
    m_owner = GetCurrentProcessPointer(m_kernel);

    // Get the owner page table.
-    auto& page_table = m_owner->GetPageTable();
+    auto& page_table = m_owner->PageTable();

    // Construct the page group.
    m_page_group.emplace(m_kernel, page_table.GetBlockInfoManager());
@ -53,7 +53,7 @@ void KCodeMemory::Finalize() {
    // Unlock.
    if (!m_is_mapped && !m_is_owner_mapped) {
        const size_t size = m_page_group->GetNumPages() * PageSize;
-        m_owner->GetPageTable().UnlockForCodeMemory(m_address, size, *m_page_group);
+        m_owner->PageTable().UnlockForCodeMemory(m_address, size, *m_page_group);
    }

    // Close the page group.
@ -75,7 +75,7 @@ Result KCodeMemory::Map(KProcessAddress address, size_t size) {
    R_UNLESS(!m_is_mapped, ResultInvalidState);

    // Map the memory.
-    R_TRY(GetCurrentProcess(m_kernel).GetPageTable().MapPageGroup(
+    R_TRY(GetCurrentProcess(m_kernel).PageTable().MapPageGroup(
        address, *m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));

    // Mark ourselves as mapped.
@ -92,8 +92,8 @@ Result KCodeMemory::Unmap(KProcessAddress address, size_t size) {
    KScopedLightLock lk(m_lock);

    // Unmap the memory.
-    R_TRY(GetCurrentProcess(m_kernel).GetPageTable().UnmapPageGroup(address, *m_page_group,
-                                                                    KMemoryState::CodeOut));
+    R_TRY(GetCurrentProcess(m_kernel).PageTable().UnmapPageGroup(address, *m_page_group,
+                                                                 KMemoryState::CodeOut));

    // Mark ourselves as unmapped.
    m_is_mapped = false;
@ -126,8 +126,8 @@ Result KCodeMemory::MapToOwner(KProcessAddress address, size_t size, Svc::Memory
    }

    // Map the memory.
-    R_TRY(m_owner->GetPageTable().MapPageGroup(address, *m_page_group, KMemoryState::GeneratedCode,
-                                               k_perm));
+    R_TRY(m_owner->PageTable().MapPageGroup(address, *m_page_group, KMemoryState::GeneratedCode,
+                                            k_perm));

    // Mark ourselves as mapped.
    m_is_owner_mapped = true;
@ -143,8 +143,7 @@ Result KCodeMemory::UnmapFromOwner(KProcessAddress address, size_t size) {
    KScopedLightLock lk(m_lock);

    // Unmap the memory.
-    R_TRY(m_owner->GetPageTable().UnmapPageGroup(address, *m_page_group,
-                                                 KMemoryState::GeneratedCode));
+    R_TRY(m_owner->PageTable().UnmapPageGroup(address, *m_page_group, KMemoryState::GeneratedCode));

    // Mark ourselves as unmapped.
    m_is_owner_mapped = false;
--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@ -388,6 +388,39 @@ public:
    constexpr size_t GetHeapSize() const {
        return m_current_heap_end - m_heap_region_start;
    }
+    constexpr bool IsInsideAddressSpace(KProcessAddress address, size_t size) const {
+        return m_address_space_start <= address && address + size - 1 <= m_address_space_end - 1;
+    }
+    constexpr bool IsOutsideAliasRegion(KProcessAddress address, size_t size) const {
+        return m_alias_region_start > address || address + size - 1 > m_alias_region_end - 1;
+    }
+    constexpr bool IsOutsideStackRegion(KProcessAddress address, size_t size) const {
+        return m_stack_region_start > address || address + size - 1 > m_stack_region_end - 1;
+    }
+    constexpr bool IsInvalidRegion(KProcessAddress address, size_t size) const {
+        return address + size - 1 > GetAliasCodeRegionStart() + GetAliasCodeRegionSize() - 1;
+    }
+    constexpr bool IsInsideHeapRegion(KProcessAddress address, size_t size) const {
+        return address + size > m_heap_region_start && m_heap_region_end > address;
+    }
+    constexpr bool IsInsideAliasRegion(KProcessAddress address, size_t size) const {
+        return address + size > m_alias_region_start && m_alias_region_end > address;
+    }
+    constexpr bool IsOutsideASLRRegion(KProcessAddress address, size_t size) const {
+        if (IsInvalidRegion(address, size)) {
+            return true;
+        }
+        if (IsInsideHeapRegion(address, size)) {
+            return true;
+        }
+        if (IsInsideAliasRegion(address, size)) {
+            return true;
+        }
+        return {};
+    }
+    constexpr bool IsInsideASLRRegion(KProcessAddress address, size_t size) const {
+        return !IsOutsideASLRRegion(address, size);
+    }
    constexpr size_t GetNumGuardPages() const {
        return IsKernel() ? 1 : 4;
    }
@ -403,14 +436,6 @@ public:
        return m_address_space_start <= addr && addr < addr + size &&
               addr + size - 1 <= m_address_space_end - 1;
    }
-    constexpr bool IsInAliasRegion(KProcessAddress addr, size_t size) const {
-        return this->Contains(addr, size) && m_alias_region_start <= addr &&
-               addr + size - 1 <= m_alias_region_end - 1;
-    }
-    constexpr bool IsInHeapRegion(KProcessAddress addr, size_t size) const {
-        return this->Contains(addr, size) && m_heap_region_start <= addr &&
-               addr + size - 1 <= m_heap_region_end - 1;
-    }

 public:
    static KVirtualAddress GetLinearMappedVirtualAddress(const KMemoryLayout& layout,
--- a/src/core/hle/kernel/k_process.cpp
+++ b/src/core/hle/kernel/k_process.cpp
@ -38,7 +38,7 @@ namespace {
 */
 void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority,
                     KProcessAddress stack_top) {
-    const KProcessAddress entry_point = owner_process.GetPageTable().GetCodeRegionStart();
+    const KProcessAddress entry_point = owner_process.PageTable().GetCodeRegionStart();
    ASSERT(owner_process.GetResourceLimit()->Reserve(LimitableResource::ThreadCountMax, 1));

    KThread* thread = KThread::Create(system.Kernel());
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@ -109,6 +109,16 @@ public:
    static Result Initialize(KProcess* process, Core::System& system, std::string process_name,
                             ProcessType type, KResourceLimit* res_limit);

+    /// Gets a reference to the process' page table.
+    KPageTable& PageTable() {
+        return m_page_table;
+    }
+
+    /// Gets const a reference to the process' page table.
+    const KPageTable& PageTable() const {
+        return m_page_table;
+    }
+
    /// Gets a reference to the process' page table.
    KPageTable& GetPageTable() {
        return m_page_table;
--- a/src/core/hle/kernel/k_shared_memory.cpp
+++ b/src/core/hle/kernel/k_shared_memory.cpp
@ -90,8 +90,8 @@ Result KSharedMemory::Map(KProcess& target_process, KProcessAddress address, std
        R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);
    }

-    R_RETURN(target_process.GetPageTable().MapPageGroup(
-        address, *m_page_group, KMemoryState::Shared, ConvertToKMemoryPermission(map_perm)));
+    R_RETURN(target_process.PageTable().MapPageGroup(address, *m_page_group, KMemoryState::Shared,
+                                                     ConvertToKMemoryPermission(map_perm)));
 }

 Result KSharedMemory::Unmap(KProcess& target_process, KProcessAddress address,
@ -100,7 +100,7 @@ Result KSharedMemory::Unmap(KProcess& target_process, KProcessAddress address,
    R_UNLESS(m_size == unmap_size, ResultInvalidSize);

    R_RETURN(
-        target_process.GetPageTable().UnmapPageGroup(address, *m_page_group, KMemoryState::Shared));
+        target_process.PageTable().UnmapPageGroup(address, *m_page_group, KMemoryState::Shared));
 }

 } // namespace Kernel
--- a/src/core/hle/kernel/k_thread_local_page.cpp
+++ b/src/core/hle/kernel/k_thread_local_page.cpp
@ -25,9 +25,9 @@ Result KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {

    // Map the address in.
    const auto phys_addr = kernel.System().DeviceMemory().GetPhysicalAddr(page_buf);
-    R_TRY(m_owner->GetPageTable().MapPages(std::addressof(m_virt_addr), 1, PageSize, phys_addr,
-                                           KMemoryState::ThreadLocal,
-                                           KMemoryPermission::UserReadWrite));
+    R_TRY(m_owner->PageTable().MapPages(std::addressof(m_virt_addr), 1, PageSize, phys_addr,
+                                        KMemoryState::ThreadLocal,
+                                        KMemoryPermission::UserReadWrite));

    // We succeeded.
    page_buf_guard.Cancel();
@ -37,11 +37,11 @@ Result KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {

 Result KThreadLocalPage::Finalize() {
    // Get the physical address of the page.
-    const KPhysicalAddress phys_addr = m_owner->GetPageTable().GetPhysicalAddr(m_virt_addr);
+    const KPhysicalAddress phys_addr = m_owner->PageTable().GetPhysicalAddr(m_virt_addr);
    ASSERT(phys_addr);

    // Unmap the page.
-    R_TRY(m_owner->GetPageTable().UnmapPages(this->GetAddress(), 1, KMemoryState::ThreadLocal));
+    R_TRY(m_owner->PageTable().UnmapPages(this->GetAddress(), 1, KMemoryState::ThreadLocal));

    // Free the page.
    KPageBuffer::Free(*m_kernel, KPageBuffer::FromPhysicalAddress(m_kernel->System(), phys_addr));
--- a/src/core/hle/kernel/physical_core.cpp
+++ b/src/core/hle/kernel/physical_core.cpp
@ -17,9 +17,7 @@ PhysicalCore::PhysicalCore(std::size_t core_index, Core::System& system, KSchedu
    // a 32-bit instance of Dynarmic. This should be abstracted out to a CPU manager.
    auto& kernel = system.Kernel();
    m_arm_interface = std::make_unique<Core::ARM_Dynarmic_64>(
-        system, kernel.IsMulticore(),
-        reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()),
-        m_core_index);
+        system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), m_core_index);
 #else
 #error Platform not supported yet.
 #endif
@ -33,9 +31,7 @@ void PhysicalCore::Initialize(bool is_64_bit) {
    if (!is_64_bit) {
        // We already initialized a 64-bit core, replace with a 32-bit one.
        m_arm_interface = std::make_unique<Core::ARM_Dynarmic_32>(
-            m_system, kernel.IsMulticore(),
-            reinterpret_cast<Core::DynarmicExclusiveMonitor&>(kernel.GetExclusiveMonitor()),
-            m_core_index);
+            m_system, kernel.IsMulticore(), kernel.GetExclusiveMonitor(), m_core_index);
    }
 #else
 #error Platform not supported yet.
--- a/src/core/hle/kernel/svc/svc_cache.cpp
+++ b/src/core/hle/kernel/svc/svc_cache.cpp
@ -42,7 +42,7 @@ Result FlushProcessDataCache(Core::System& system, Handle process_handle, u64 ad
    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);

    // Verify the region is within range.
-    auto& page_table = process->GetPageTable();
+    auto& page_table = process->PageTable();
    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);

    // Perform the operation.
--- a/src/core/hle/kernel/svc/svc_code_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_code_memory.cpp
@ -48,7 +48,7 @@ Result CreateCodeMemory(Core::System& system, Handle* out, u64 address, uint64_t
    SCOPE_EXIT({ code_mem->Close(); });

    // Verify that the region is in range.
-    R_UNLESS(GetCurrentProcess(system.Kernel()).GetPageTable().Contains(address, size),
+    R_UNLESS(GetCurrentProcess(system.Kernel()).PageTable().Contains(address, size),
             ResultInvalidCurrentMemory);

    // Initialize the code memory.
@ -92,7 +92,7 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
    case CodeMemoryOperation::Map: {
        // Check that the region is in range.
        R_UNLESS(GetCurrentProcess(system.Kernel())
-                     .GetPageTable()
+                     .PageTable()
                     .CanContain(address, size, KMemoryState::CodeOut),
                 ResultInvalidMemoryRegion);

@ -105,7 +105,7 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
    case CodeMemoryOperation::Unmap: {
        // Check that the region is in range.
        R_UNLESS(GetCurrentProcess(system.Kernel())
-                     .GetPageTable()
+                     .PageTable()
                     .CanContain(address, size, KMemoryState::CodeOut),
                 ResultInvalidMemoryRegion);

@ -117,8 +117,8 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
    } break;
    case CodeMemoryOperation::MapToOwner: {
        // Check that the region is in range.
-        R_UNLESS(code_mem->GetOwner()->GetPageTable().CanContain(address, size,
-                                                                 KMemoryState::GeneratedCode),
+        R_UNLESS(code_mem->GetOwner()->PageTable().CanContain(address, size,
+                                                              KMemoryState::GeneratedCode),
                 ResultInvalidMemoryRegion);

        // Check the memory permission.
@ -129,8 +129,8 @@ Result ControlCodeMemory(Core::System& system, Handle code_memory_handle,
    } break;
    case CodeMemoryOperation::UnmapFromOwner: {
        // Check that the region is in range.
-        R_UNLESS(code_mem->GetOwner()->GetPageTable().CanContain(address, size,
-                                                                 KMemoryState::GeneratedCode),
+        R_UNLESS(code_mem->GetOwner()->PageTable().CanContain(address, size,
+                                                              KMemoryState::GeneratedCode),
                 ResultInvalidMemoryRegion);

        // Check the memory permission.
--- a/src/core/hle/kernel/svc/svc_device_address_space.cpp
+++ b/src/core/hle/kernel/svc/svc_device_address_space.cpp
@ -107,7 +107,7 @@ Result MapDeviceAddressSpaceByForce(Core::System& system, Handle das_handle, Han
    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);

    // Validate that the process address is within range.
-    auto& page_table = process->GetPageTable();
+    auto& page_table = process->PageTable();
    R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);

    // Map.
@ -148,7 +148,7 @@ Result MapDeviceAddressSpaceAligned(Core::System& system, Handle das_handle, Han
    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);

    // Validate that the process address is within range.
-    auto& page_table = process->GetPageTable();
+    auto& page_table = process->PageTable();
    R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);

    // Map.
@ -180,7 +180,7 @@ Result UnmapDeviceAddressSpace(Core::System& system, Handle das_handle, Handle p
    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);

    // Validate that the process address is within range.
-    auto& page_table = process->GetPageTable();
+    auto& page_table = process->PageTable();
    R_UNLESS(page_table.Contains(process_address, size), ResultInvalidCurrentMemory);

    R_RETURN(das->Unmap(std::addressof(page_table), process_address, size, device_address));
--- a/src/core/hle/kernel/svc/svc_info.cpp
+++ b/src/core/hle/kernel/svc/svc_info.cpp
@ -54,35 +54,35 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
            R_SUCCEED();

        case InfoType::AliasRegionAddress:
-            *result = GetInteger(process->GetPageTable().GetAliasRegionStart());
+            *result = GetInteger(process->PageTable().GetAliasRegionStart());
            R_SUCCEED();

        case InfoType::AliasRegionSize:
-            *result = process->GetPageTable().GetAliasRegionSize();
+            *result = process->PageTable().GetAliasRegionSize();
            R_SUCCEED();

        case InfoType::HeapRegionAddress:
-            *result = GetInteger(process->GetPageTable().GetHeapRegionStart());
+            *result = GetInteger(process->PageTable().GetHeapRegionStart());
            R_SUCCEED();

        case InfoType::HeapRegionSize:
-            *result = process->GetPageTable().GetHeapRegionSize();
+            *result = process->PageTable().GetHeapRegionSize();
            R_SUCCEED();

        case InfoType::AslrRegionAddress:
-            *result = GetInteger(process->GetPageTable().GetAliasCodeRegionStart());
+            *result = GetInteger(process->PageTable().GetAliasCodeRegionStart());
            R_SUCCEED();

        case InfoType::AslrRegionSize:
-            *result = process->GetPageTable().GetAliasCodeRegionSize();
+            *result = process->PageTable().GetAliasCodeRegionSize();
            R_SUCCEED();

        case InfoType::StackRegionAddress:
-            *result = GetInteger(process->GetPageTable().GetStackRegionStart());
+            *result = GetInteger(process->PageTable().GetStackRegionStart());
            R_SUCCEED();

        case InfoType::StackRegionSize:
-            *result = process->GetPageTable().GetStackRegionSize();
+            *result = process->PageTable().GetStackRegionSize();
            R_SUCCEED();

        case InfoType::TotalMemorySize:
--- a/src/core/hle/kernel/svc/svc_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_memory.cpp
@ -63,13 +63,36 @@ Result MapUnmapMemorySanityChecks(const KPageTable& manager, u64 dst_addr, u64 s
        R_THROW(ResultInvalidCurrentMemory);
    }

-    if (!manager.Contains(src_addr, size)) {
+    if (!manager.IsInsideAddressSpace(src_addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}",
                  src_addr, size);
        R_THROW(ResultInvalidCurrentMemory);
    }

+    if (manager.IsOutsideStackRegion(dst_addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination is not within the stack region, addr=0x{:016X}, size=0x{:016X}",
+                  dst_addr, size);
+        R_THROW(ResultInvalidMemoryRegion);
+    }
+
+    if (manager.IsInsideHeapRegion(dst_addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination does not fit within the heap region, addr=0x{:016X}, "
+                  "size=0x{:016X}",
+                  dst_addr, size);
+        R_THROW(ResultInvalidMemoryRegion);
+    }
+
+    if (manager.IsInsideAliasRegion(dst_addr, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination does not fit within the map region, addr=0x{:016X}, "
+                  "size=0x{:016X}",
+                  dst_addr, size);
+        R_THROW(ResultInvalidMemoryRegion);
+    }
+
    R_SUCCEED();
 }

@ -89,7 +112,7 @@ Result SetMemoryPermission(Core::System& system, u64 address, u64 size, MemoryPe
    R_UNLESS(IsValidSetMemoryPermission(perm), ResultInvalidNewMemoryPermission);

    // Validate that the region is in range for the current process.
-    auto& page_table = GetCurrentProcess(system.Kernel()).GetPageTable();
+    auto& page_table = GetCurrentProcess(system.Kernel()).PageTable();
    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);

    // Set the memory attribute.
@ -113,7 +136,7 @@ Result SetMemoryAttribute(Core::System& system, u64 address, u64 size, u32 mask,
    R_UNLESS((mask | attr | SupportedMask) == SupportedMask, ResultInvalidCombination);

    // Validate that the region is in range for the current process.
-    auto& page_table{GetCurrentProcess(system.Kernel()).GetPageTable()};
+    auto& page_table{GetCurrentProcess(system.Kernel()).PageTable()};
    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);

    // Set the memory attribute.
@ -125,7 +148,7 @@ Result MapMemory(Core::System& system, u64 dst_addr, u64 src_addr, u64 size) {
    LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
              src_addr, size);

-    auto& page_table{GetCurrentProcess(system.Kernel()).GetPageTable()};
+    auto& page_table{GetCurrentProcess(system.Kernel()).PageTable()};

    if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
        result.IsError()) {
@ -140,7 +163,7 @@ Result UnmapMemory(Core::System& system, u64 dst_addr, u64 src_addr, u64 size) {
    LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
              src_addr, size);

-    auto& page_table{GetCurrentProcess(system.Kernel()).GetPageTable()};
+    auto& page_table{GetCurrentProcess(system.Kernel()).PageTable()};

    if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
        result.IsError()) {
--- a/src/core/hle/kernel/svc/svc_physical_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_physical_memory.cpp
@ -16,7 +16,7 @@ Result SetHeapSize(Core::System& system, u64* out_address, u64 size) {
    R_UNLESS(size < MainMemorySizeMax, ResultInvalidSize);

    // Set the heap size.
-    R_RETURN(GetCurrentProcess(system.Kernel()).GetPageTable().SetHeapSize(out_address, size));
+    R_RETURN(GetCurrentProcess(system.Kernel()).PageTable().SetHeapSize(out_address, size));
 }

 /// Maps memory at a desired address
@ -44,21 +44,21 @@ Result MapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
    }

    KProcess* const current_process{GetCurrentProcessPointer(system.Kernel())};
-    auto& page_table{current_process->GetPageTable()};
+    auto& page_table{current_process->PageTable()};

    if (current_process->GetSystemResourceSize() == 0) {
        LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
        R_THROW(ResultInvalidState);
    }

-    if (!page_table.Contains(addr, size)) {
+    if (!page_table.IsInsideAddressSpace(addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
                  size);
        R_THROW(ResultInvalidMemoryRegion);
    }

-    if (!page_table.IsInAliasRegion(addr, size)) {
+    if (page_table.IsOutsideAliasRegion(addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr,
                  size);
@ -93,21 +93,21 @@ Result UnmapPhysicalMemory(Core::System& system, u64 addr, u64 size) {
    }

    KProcess* const current_process{GetCurrentProcessPointer(system.Kernel())};
-    auto& page_table{current_process->GetPageTable()};
+    auto& page_table{current_process->PageTable()};

    if (current_process->GetSystemResourceSize() == 0) {
        LOG_ERROR(Kernel_SVC, "System Resource Size is zero");
        R_THROW(ResultInvalidState);
    }

-    if (!page_table.Contains(addr, size)) {
+    if (!page_table.IsInsideAddressSpace(addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Address is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
                  size);
        R_THROW(ResultInvalidMemoryRegion);
    }

-    if (!page_table.IsInAliasRegion(addr, size)) {
+    if (page_table.IsOutsideAliasRegion(addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Address is not within the alias region, addr=0x{:016X}, size=0x{:016X}", addr,
                  size);
--- a/src/core/hle/kernel/svc/svc_process.cpp
+++ b/src/core/hle/kernel/svc/svc_process.cpp
@ -66,8 +66,8 @@ Result GetProcessList(Core::System& system, s32* out_num_processes, u64 out_proc
    auto& kernel = system.Kernel();
    const auto total_copy_size = out_process_ids_size * sizeof(u64);

-    if (out_process_ids_size > 0 &&
-        !GetCurrentProcess(kernel).GetPageTable().Contains(out_process_ids, total_copy_size)) {
+    if (out_process_ids_size > 0 && !GetCurrentProcess(kernel).PageTable().IsInsideAddressSpace(
+                                        out_process_ids, total_copy_size)) {
        LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}",
                  out_process_ids, out_process_ids + total_copy_size);
        R_THROW(ResultInvalidCurrentMemory);
--- a/src/core/hle/kernel/svc/svc_process_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_process_memory.cpp
@ -49,7 +49,7 @@ Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, u
    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);

    // Validate that the address is in range.
-    auto& page_table = process->GetPageTable();
+    auto& page_table = process->PageTable();
    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);

    // Set the memory permission.
@ -77,8 +77,8 @@ Result MapProcessMemory(Core::System& system, u64 dst_address, Handle process_ha
    R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);

    // Get the page tables.
-    auto& dst_pt = dst_process->GetPageTable();
-    auto& src_pt = src_process->GetPageTable();
+    auto& dst_pt = dst_process->PageTable();
+    auto& src_pt = src_process->PageTable();

    // Validate that the mapping is in range.
    R_UNLESS(src_pt.Contains(src_address, size), ResultInvalidCurrentMemory);
@ -118,8 +118,8 @@ Result UnmapProcessMemory(Core::System& system, u64 dst_address, Handle process_
    R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);

    // Get the page tables.
-    auto& dst_pt = dst_process->GetPageTable();
-    auto& src_pt = src_process->GetPageTable();
+    auto& dst_pt = dst_process->PageTable();
+    auto& src_pt = src_process->PageTable();

    // Validate that the mapping is in range.
    R_UNLESS(src_pt.Contains(src_address, size), ResultInvalidCurrentMemory);
@ -178,8 +178,8 @@ Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst
        R_THROW(ResultInvalidHandle);
    }

-    auto& page_table = process->GetPageTable();
-    if (!page_table.Contains(src_address, size)) {
+    auto& page_table = process->PageTable();
+    if (!page_table.IsInsideAddressSpace(src_address, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Source address range is not within the address space (src_address=0x{:016X}, "
                  "size=0x{:016X}).",
@ -187,6 +187,14 @@ Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst
        R_THROW(ResultInvalidCurrentMemory);
    }

+    if (!page_table.IsInsideASLRRegion(dst_address, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
+                  "size=0x{:016X}).",
+                  dst_address, size);
+        R_THROW(ResultInvalidMemoryRegion);
+    }
+
    R_RETURN(page_table.MapCodeMemory(dst_address, src_address, size));
 }

@ -238,8 +246,8 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
        R_THROW(ResultInvalidHandle);
    }

-    auto& page_table = process->GetPageTable();
-    if (!page_table.Contains(src_address, size)) {
+    auto& page_table = process->PageTable();
+    if (!page_table.IsInsideAddressSpace(src_address, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Source address range is not within the address space (src_address=0x{:016X}, "
                  "size=0x{:016X}).",
@ -247,6 +255,14 @@ Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 d
        R_THROW(ResultInvalidCurrentMemory);
    }

+    if (!page_table.IsInsideASLRRegion(dst_address, size)) {
+        LOG_ERROR(Kernel_SVC,
+                  "Destination address range is not within the ASLR region (dst_address=0x{:016X}, "
+                  "size=0x{:016X}).",
+                  dst_address, size);
+        R_THROW(ResultInvalidMemoryRegion);
+    }
+
    R_RETURN(page_table.UnmapCodeMemory(dst_address, src_address, size,
                                        KPageTable::ICacheInvalidationStrategy::InvalidateAll));
 }
--- a/src/core/hle/kernel/svc/svc_query_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_query_memory.cpp
@ -31,7 +31,7 @@ Result QueryProcessMemory(Core::System& system, uint64_t out_memory_info, PageIn
    }

    auto& current_memory{GetCurrentMemory(system.Kernel())};
-    const auto memory_info{process->GetPageTable().QueryInfo(address).GetSvcMemoryInfo()};
+    const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};

    current_memory.WriteBlock(out_memory_info, std::addressof(memory_info), sizeof(memory_info));

--- a/src/core/hle/kernel/svc/svc_shared_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_shared_memory.cpp
@ -43,7 +43,7 @@ Result MapSharedMemory(Core::System& system, Handle shmem_handle, u64 address, u

    // Get the current process.
    auto& process = GetCurrentProcess(system.Kernel());
-    auto& page_table = process.GetPageTable();
+    auto& page_table = process.PageTable();

    // Get the shared memory.
    KScopedAutoObject shmem = process.GetHandleTable().GetObject<KSharedMemory>(shmem_handle);
@ -73,7 +73,7 @@ Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, u64 address,

    // Get the current process.
    auto& process = GetCurrentProcess(system.Kernel());
-    auto& page_table = process.GetPageTable();
+    auto& page_table = process.PageTable();

    // Get the shared memory.
    KScopedAutoObject shmem = process.GetHandleTable().GetObject<KSharedMemory>(shmem_handle);
--- a/src/core/hle/kernel/svc/svc_thread.cpp
+++ b/src/core/hle/kernel/svc/svc_thread.cpp
@ -236,7 +236,7 @@ Result GetThreadList(Core::System& system, s32* out_num_threads, u64 out_thread_
    const auto total_copy_size = out_thread_ids_size * sizeof(u64);

    if (out_thread_ids_size > 0 &&
-        !current_process->GetPageTable().Contains(out_thread_ids, total_copy_size)) {
+        !current_process->PageTable().IsInsideAddressSpace(out_thread_ids, total_copy_size)) {
        LOG_ERROR(Kernel_SVC, "Address range outside address space. begin=0x{:016X}, end=0x{:016X}",
                  out_thread_ids, out_thread_ids + total_copy_size);
        R_THROW(ResultInvalidCurrentMemory);
--- a/src/core/hle/kernel/svc/svc_transfer_memory.cpp
+++ b/src/core/hle/kernel/svc/svc_transfer_memory.cpp
@ -55,7 +55,7 @@ Result CreateTransferMemory(Core::System& system, Handle* out, u64 address, u64
    SCOPE_EXIT({ trmem->Close(); });

    // Ensure that the region is in range.
-    R_UNLESS(process.GetPageTable().Contains(address, size), ResultInvalidCurrentMemory);
+    R_UNLESS(process.PageTable().Contains(address, size), ResultInvalidCurrentMemory);

    // Initialize the transfer memory.
    R_TRY(trmem->Initialize(address, size, map_perm));
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@ -318,15 +318,15 @@ public:
                    return false;
                }

-                if (!page_table.Contains(out_addr, size)) {
+                if (!page_table.IsInsideAddressSpace(out_addr, size)) {
                    return false;
                }

-                if (page_table.IsInHeapRegion(out_addr, size)) {
+                if (page_table.IsInsideHeapRegion(out_addr, size)) {
                    return false;
                }

-                if (page_table.IsInAliasRegion(out_addr, size)) {
+                if (page_table.IsInsideAliasRegion(out_addr, size)) {
                    return false;
                }

@ -358,7 +358,7 @@ public:
    }

    ResultVal<VAddr> MapProcessCodeMemory(Kernel::KProcess* process, VAddr base_addr, u64 size) {
-        auto& page_table{process->GetPageTable()};
+        auto& page_table{process->PageTable()};
        VAddr addr{};

        for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
@ -382,7 +382,7 @@ public:
    ResultVal<VAddr> MapNro(Kernel::KProcess* process, VAddr nro_addr, std::size_t nro_size,
                            VAddr bss_addr, std::size_t bss_size, std::size_t size) {
        for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
-            auto& page_table{process->GetPageTable()};
+            auto& page_table{process->PageTable()};
            VAddr addr{};

            CASCADE_RESULT(addr, MapProcessCodeMemory(process, nro_addr, nro_size));
@ -437,12 +437,12 @@ public:
        CopyCode(nro_addr + nro_header.segment_headers[DATA_INDEX].memory_offset, data_start,
                 nro_header.segment_headers[DATA_INDEX].memory_size);

-        CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission(
+        CASCADE_CODE(process->PageTable().SetProcessMemoryPermission(
            text_start, ro_start - text_start, Kernel::Svc::MemoryPermission::ReadExecute));
-        CASCADE_CODE(process->GetPageTable().SetProcessMemoryPermission(
+        CASCADE_CODE(process->PageTable().SetProcessMemoryPermission(
            ro_start, data_start - ro_start, Kernel::Svc::MemoryPermission::Read));

-        return process->GetPageTable().SetProcessMemoryPermission(
+        return process->PageTable().SetProcessMemoryPermission(
            data_start, bss_end_addr - data_start, Kernel::Svc::MemoryPermission::ReadWrite);
    }

@ -571,7 +571,7 @@ public:

    Result UnmapNro(const NROInfo& info) {
        // Each region must be unmapped separately to validate memory state
-        auto& page_table{system.ApplicationProcess()->GetPageTable()};
+        auto& page_table{system.ApplicationProcess()->PageTable()};

        if (info.bss_size != 0) {
            CASCADE_CODE(page_table.UnmapCodeMemory(
@ -643,7 +643,7 @@ public:

        initialized = true;
        current_map_addr =
-            GetInteger(system.ApplicationProcess()->GetPageTable().GetAliasCodeRegionStart());
+            GetInteger(system.ApplicationProcess()->PageTable().GetAliasCodeRegionStart());

        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ResultSuccess);
--- a/src/core/hle/service/nfc/common/amiibo_crypto.cpp
+++ b/src/core/hle/service/nfc/common/amiibo_crypto.cpp
@ -180,7 +180,7 @@ std::vector<u8> GenerateInternalKey(const InternalKey& key, const HashSeed& seed
 }

 void CryptoInit(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, const HmacKey& hmac_key,
-                std::span<const u8> seed) {
+                const std::vector<u8>& seed) {
    // Initialize context
    ctx.used = false;
    ctx.counter = 0;
--- a/src/core/hle/service/nfc/common/amiibo_crypto.h
+++ b/src/core/hle/service/nfc/common/amiibo_crypto.h
@ -75,7 +75,7 @@ std::vector<u8> GenerateInternalKey(const InternalKey& key, const HashSeed& seed

 // Initializes mbedtls context
 void CryptoInit(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, const HmacKey& hmac_key,
-                std::span<const u8> seed);
+                const std::vector<u8>& seed);

 // Feeds data to mbedtls context to generate the derived key
 void CryptoStep(CryptoCtx& ctx, mbedtls_md_context_t& hmac_ctx, DrgbOutput& output);
--- a/src/core/hle/service/nfc/common/device.cpp
+++ b/src/core/hle/service/nfc/common/device.cpp
@ -34,6 +34,8 @@
 #include "core/hle/service/nfc/mifare_result.h"
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/time/time_zone_content_manager.h"
+#include "core/hle/service/time/time_zone_types.h"

 namespace Service::NFC {
 NfcDevice::NfcDevice(Core::HID::NpadIdType npad_id_, Core::System& system_,
@ -1484,7 +1486,6 @@ DeviceState NfcDevice::GetCurrentState() const {
 }

 Result NfcDevice::GetNpadId(Core::HID::NpadIdType& out_npad_id) const {
-    // TODO: This should get the npad id from nn::hid::system::GetXcdHandleForNpadWithNfc
    out_npad_id = npad_id;
    return ResultSuccess;
 }
--- a/src/core/hle/service/nfc/common/device_manager.cpp
+++ b/src/core/hle/service/nfc/common/device_manager.cpp
@ -1,8 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

-#include <algorithm>
-
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hid/hid_types.h"
@ -12,7 +10,6 @@
 #include "core/hle/service/nfc/common/device_manager.h"
 #include "core/hle/service/nfc/nfc_result.h"
 #include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/time_manager.h"

 namespace Service::NFC {

@ -54,53 +51,22 @@ Result DeviceManager::Finalize() {
    return ResultSuccess;
 }

-Result DeviceManager::ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices,
-                                  bool skip_fatal_errors) const {
-    std::scoped_lock lock{mutex};
-    if (max_allowed_devices < 1) {
-        return ResultInvalidArgument;
-    }
-
-    Result result = IsNfcParameterSet();
-    if (result.IsError()) {
-        return result;
-    }
-
-    result = IsNfcEnabled();
-    if (result.IsError()) {
-        return result;
-    }
-
-    result = IsNfcInitialized();
-    if (result.IsError()) {
-        return result;
-    }
-
+Result DeviceManager::ListDevices(std::vector<u64>& nfp_devices,
+                                  std::size_t max_allowed_devices) const {
    for (auto& device : devices) {
        if (nfp_devices.size() >= max_allowed_devices) {
            continue;
        }
-        if (skip_fatal_errors) {
-            constexpr u64 MinimumRecoveryTime = 60;
-            auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
-            const u64 elapsed_time = standard_steady_clock.GetCurrentTimePoint(system).time_point -
-                                     time_since_last_error;
-
-            if (time_since_last_error != 0 && elapsed_time < MinimumRecoveryTime) {
-                continue;
-            }
+        if (device->GetCurrentState() != DeviceState::Unavailable) {
+            nfp_devices.push_back(device->GetHandle());
        }
-        if (device->GetCurrentState() == DeviceState::Unavailable) {
-            continue;
-        }
-        nfp_devices.push_back(device->GetHandle());
    }

    if (nfp_devices.empty()) {
        return ResultDeviceNotFound;
    }

-    return result;
+    return ResultSuccess;
 }

 DeviceState DeviceManager::GetDeviceState(u64 device_handle) const {
@ -113,10 +79,10 @@ DeviceState DeviceManager::GetDeviceState(u64 device_handle) const {
        return device->GetCurrentState();
    }

-    return DeviceState::Finalized;
+    return DeviceState::Unavailable;
 }

-Result DeviceManager::GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) {
+Result DeviceManager::GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -162,7 +128,7 @@ Result DeviceManager::StopDetection(u64 device_handle) {
    return result;
 }

-Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info) {
+Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -176,46 +142,24 @@ Result DeviceManager::GetTagInfo(u64 device_handle, TagInfo& tag_info) {
    return result;
 }

-Result DeviceManager::AttachActivateEvent(Kernel::KReadableEvent** out_event,
-                                          u64 device_handle) const {
-    std::vector<u64> nfp_devices;
+Kernel::KReadableEvent& DeviceManager::AttachActivateEvent(u64 device_handle) const {
+    std::scoped_lock lock{mutex};
+
    std::shared_ptr<NfcDevice> device = nullptr;
-    Result result = ListDevices(nfp_devices, 9, false);
+    GetDeviceFromHandle(device_handle, device, false);

-    if (result.IsSuccess()) {
-        result = CheckHandleOnList(device_handle, nfp_devices);
-    }
-
-    if (result.IsSuccess()) {
-        result = GetDeviceFromHandle(device_handle, device, false);
-    }
-
-    if (result.IsSuccess()) {
-        *out_event = &device->GetActivateEvent();
-    }
-
-    return result;
+    // TODO: Return proper error code on failure
+    return device->GetActivateEvent();
 }

-Result DeviceManager::AttachDeactivateEvent(Kernel::KReadableEvent** out_event,
-                                            u64 device_handle) const {
-    std::vector<u64> nfp_devices;
+Kernel::KReadableEvent& DeviceManager::AttachDeactivateEvent(u64 device_handle) const {
+    std::scoped_lock lock{mutex};
+
    std::shared_ptr<NfcDevice> device = nullptr;
-    Result result = ListDevices(nfp_devices, 9, false);
+    GetDeviceFromHandle(device_handle, device, false);

-    if (result.IsSuccess()) {
-        result = CheckHandleOnList(device_handle, nfp_devices);
-    }
-
-    if (result.IsSuccess()) {
-        result = GetDeviceFromHandle(device_handle, device, false);
-    }
-
-    if (result.IsSuccess()) {
-        *out_event = &device->GetDeactivateEvent();
-    }
-
-    return result;
+    // TODO: Return proper error code on failure
+    return device->GetDeactivateEvent();
 }

 Result DeviceManager::ReadMifare(u64 device_handle,
@ -309,7 +253,7 @@ Result DeviceManager::OpenApplicationArea(u64 device_handle, u32 access_id) {
    return result;
 }

-Result DeviceManager::GetApplicationArea(u64 device_handle, std::span<u8> data) {
+Result DeviceManager::GetApplicationArea(u64 device_handle, std::span<u8> data) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -380,7 +324,7 @@ Result DeviceManager::CreateApplicationArea(u64 device_handle, u32 access_id,
    return result;
 }

-Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) {
+Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -394,7 +338,7 @@ Result DeviceManager::GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& regi
    return result;
 }

-Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) {
+Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -408,7 +352,7 @@ Result DeviceManager::GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_i
    return result;
 }

-Result DeviceManager::GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) {
+Result DeviceManager::GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -455,7 +399,7 @@ Result DeviceManager::Format(u64 device_handle) {
    return result;
 }

-Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) {
+Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -470,7 +414,7 @@ Result DeviceManager::GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info
 }

 Result DeviceManager::GetRegisterInfoPrivate(u64 device_handle,
-                                             NFP::RegisterInfoPrivate& register_info) {
+                                             NFP::RegisterInfoPrivate& register_info) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -527,7 +471,7 @@ Result DeviceManager::DeleteApplicationArea(u64 device_handle) {
    return result;
 }

-Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_application_area) {
+Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_application_area) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -541,7 +485,7 @@ Result DeviceManager::ExistsApplicationArea(u64 device_handle, bool& has_applica
    return result;
 }

-Result DeviceManager::GetAll(u64 device_handle, NFP::NfpData& nfp_data) {
+Result DeviceManager::GetAll(u64 device_handle, NFP::NfpData& nfp_data) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -597,7 +541,7 @@ Result DeviceManager::BreakTag(u64 device_handle, NFP::BreakType break_type) {
    return result;
 }

-Result DeviceManager::ReadBackupData(u64 device_handle, std::span<u8> data) {
+Result DeviceManager::ReadBackupData(u64 device_handle, std::span<u8> data) const {
    std::scoped_lock lock{mutex};

    std::shared_ptr<NfcDevice> device = nullptr;
@ -649,19 +593,6 @@ Result DeviceManager::WriteNtf(u64 device_handle, NFP::WriteType, std::span<cons
    return result;
 }

-Result DeviceManager::CheckHandleOnList(u64 device_handle,
-                                        const std::span<const u64> device_list) const {
-    if (device_list.size() < 1) {
-        return ResultDeviceNotFound;
-    }
-
-    if (std::find(device_list.begin(), device_list.end(), device_handle) != device_list.end()) {
-        return ResultSuccess;
-    }
-
-    return ResultDeviceNotFound;
-}
-
 Result DeviceManager::GetDeviceFromHandle(u64 handle, std::shared_ptr<NfcDevice>& nfc_device,
                                          bool check_state) const {
    if (check_state) {
@ -716,7 +647,7 @@ Result DeviceManager::GetDeviceHandle(u64 handle, std::shared_ptr<NfcDevice>& de
 }

 Result DeviceManager::VerifyDeviceResult(std::shared_ptr<NfcDevice> device,
-                                         Result operation_result) {
+                                         Result operation_result) const {
    if (operation_result.IsSuccess()) {
        return operation_result;
    }
@ -738,12 +669,6 @@ Result DeviceManager::VerifyDeviceResult(std::shared_ptr<NfcDevice> device,
        return device_state;
    }

-    if (operation_result == ResultUnknown112 || operation_result == ResultUnknown114 ||
-        operation_result == ResultUnknown115) {
-        auto& standard_steady_clock{system.GetTimeManager().GetStandardSteadyClockCore()};
-        time_since_last_error = standard_steady_clock.GetCurrentTimePoint(system).time_point;
-    }
-
    return operation_result;
 }

--- a/src/core/hle/service/nfc/common/device_manager.h
+++ b/src/core/hle/service/nfc/common/device_manager.h
@ -27,16 +27,15 @@ public:
    // Nfc device manager
    Result Initialize();
    Result Finalize();
-    Result ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices,
-                       bool skip_fatal_errors) const;
+    Result ListDevices(std::vector<u64>& nfp_devices, std::size_t max_allowed_devices) const;
    DeviceState GetDeviceState(u64 device_handle) const;
-    Result GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id);
+    Result GetNpadId(u64 device_handle, Core::HID::NpadIdType& npad_id) const;
    Kernel::KReadableEvent& AttachAvailabilityChangeEvent() const;
    Result StartDetection(u64 device_handle, NfcProtocol tag_protocol);
    Result StopDetection(u64 device_handle);
-    Result GetTagInfo(u64 device_handle, NFP::TagInfo& tag_info);
-    Result AttachActivateEvent(Kernel::KReadableEvent** event, u64 device_handle) const;
-    Result AttachDeactivateEvent(Kernel::KReadableEvent** event, u64 device_handle) const;
+    Result GetTagInfo(u64 device_handle, NFP::TagInfo& tag_info) const;
+    Kernel::KReadableEvent& AttachActivateEvent(u64 device_handle) const;
+    Kernel::KReadableEvent& AttachDeactivateEvent(u64 device_handle) const;
    Result ReadMifare(u64 device_handle,
                      const std::span<const MifareReadBlockParameter> read_parameters,
                      std::span<MifareReadBlockData> read_data);
@ -49,28 +48,28 @@ public:
    Result Mount(u64 device_handle, NFP::ModelType model_type, NFP::MountTarget mount_target);
    Result Unmount(u64 device_handle);
    Result OpenApplicationArea(u64 device_handle, u32 access_id);
-    Result GetApplicationArea(u64 device_handle, std::span<u8> data);
+    Result GetApplicationArea(u64 device_handle, std::span<u8> data) const;
    Result SetApplicationArea(u64 device_handle, std::span<const u8> data);
    Result Flush(u64 device_handle);
    Result Restore(u64 device_handle);
    Result CreateApplicationArea(u64 device_handle, u32 access_id, std::span<const u8> data);
-    Result GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info);
-    Result GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info);
-    Result GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info);
+    Result GetRegisterInfo(u64 device_handle, NFP::RegisterInfo& register_info) const;
+    Result GetCommonInfo(u64 device_handle, NFP::CommonInfo& common_info) const;
+    Result GetModelInfo(u64 device_handle, NFP::ModelInfo& model_info) const;
    u32 GetApplicationAreaSize() const;
    Result RecreateApplicationArea(u64 device_handle, u32 access_id, std::span<const u8> data);
    Result Format(u64 device_handle);
-    Result GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info);
-    Result GetRegisterInfoPrivate(u64 device_handle, NFP::RegisterInfoPrivate& register_info);
+    Result GetAdminInfo(u64 device_handle, NFP::AdminInfo& admin_info) const;
+    Result GetRegisterInfoPrivate(u64 device_handle, NFP::RegisterInfoPrivate& register_info) const;
    Result SetRegisterInfoPrivate(u64 device_handle, const NFP::RegisterInfoPrivate& register_info);
    Result DeleteRegisterInfo(u64 device_handle);
    Result DeleteApplicationArea(u64 device_handle);
-    Result ExistsApplicationArea(u64 device_handle, bool& has_application_area);
-    Result GetAll(u64 device_handle, NFP::NfpData& nfp_data);
+    Result ExistsApplicationArea(u64 device_handle, bool& has_application_area) const;
+    Result GetAll(u64 device_handle, NFP::NfpData& nfp_data) const;
    Result SetAll(u64 device_handle, const NFP::NfpData& nfp_data);
    Result FlushDebug(u64 device_handle);
    Result BreakTag(u64 device_handle, NFP::BreakType break_type);
-    Result ReadBackupData(u64 device_handle, std::span<u8> data);
+    Result ReadBackupData(u64 device_handle, std::span<u8> data) const;
    Result WriteBackupData(u64 device_handle, std::span<const u8> data);
    Result WriteNtf(u64 device_handle, NFP::WriteType, std::span<const u8> data);

@ -79,20 +78,17 @@ private:
    Result IsNfcParameterSet() const;
    Result IsNfcInitialized() const;

-    Result CheckHandleOnList(u64 device_handle, std::span<const u64> device_list) const;
-
    Result GetDeviceFromHandle(u64 handle, std::shared_ptr<NfcDevice>& device,
                               bool check_state) const;

    Result GetDeviceHandle(u64 handle, std::shared_ptr<NfcDevice>& device) const;
-    Result VerifyDeviceResult(std::shared_ptr<NfcDevice> device, Result operation_result);
+    Result VerifyDeviceResult(std::shared_ptr<NfcDevice> device, Result operation_result) const;
    Result CheckDeviceState(std::shared_ptr<NfcDevice> device) const;

    std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle);
    const std::optional<std::shared_ptr<NfcDevice>> GetNfcDevice(u64 handle) const;

    bool is_initialized = false;
-    u64 time_since_last_error = 0;
    mutable std::mutex mutex;
    std::array<std::shared_ptr<NfcDevice>, 10> devices{};

--- a/src/core/hle/service/nfc/nfc_interface.cpp
+++ b/src/core/hle/service/nfc/nfc_interface.cpp
@ -79,7 +79,7 @@ void NfcInterface::ListDevices(HLERequestContext& ctx) {
    const std::size_t max_allowed_devices = ctx.GetWriteBufferNumElements<u64>();
    LOG_DEBUG(Service_NFC, "called");

-    auto result = GetManager()->ListDevices(nfp_devices, max_allowed_devices, true);
+    auto result = GetManager()->ListDevices(nfp_devices, max_allowed_devices);
    result = TranslateResultToServiceError(result);

    if (result.IsError()) {
@ -190,13 +190,9 @@ void NfcInterface::AttachActivateEvent(HLERequestContext& ctx) {
    const auto device_handle{rp.Pop<u64>()};
    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);

-    Kernel::KReadableEvent* out_event = nullptr;
-    auto result = GetManager()->AttachActivateEvent(&out_event, device_handle);
-    result = TranslateResultToServiceError(result);
-
    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(result);
-    rb.PushCopyObjects(out_event);
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(GetManager()->AttachActivateEvent(device_handle));
 }

 void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
@ -204,13 +200,9 @@ void NfcInterface::AttachDeactivateEvent(HLERequestContext& ctx) {
    const auto device_handle{rp.Pop<u64>()};
    LOG_DEBUG(Service_NFC, "called, device_handle={}", device_handle);

-    Kernel::KReadableEvent* out_event = nullptr;
-    auto result = GetManager()->AttachDeactivateEvent(&out_event, device_handle);
-    result = TranslateResultToServiceError(result);
-
    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(result);
-    rb.PushCopyObjects(out_event);
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(GetManager()->AttachDeactivateEvent(device_handle));
 }

 void NfcInterface::ReadMifare(HLERequestContext& ctx) {
--- a/src/core/hle/service/nfc/nfc_result.h
+++ b/src/core/hle/service/nfc/nfc_result.h
@ -17,10 +17,7 @@ constexpr Result ResultNfcNotInitialized(ErrorModule::NFC, 77);
 constexpr Result ResultNfcDisabled(ErrorModule::NFC, 80);
 constexpr Result ResultWriteAmiiboFailed(ErrorModule::NFC, 88);
 constexpr Result ResultTagRemoved(ErrorModule::NFC, 97);
-constexpr Result ResultUnknown112(ErrorModule::NFC, 112);
 constexpr Result ResultUnableToAccessBackupFile(ErrorModule::NFC, 113);
-constexpr Result ResultUnknown114(ErrorModule::NFC, 114);
-constexpr Result ResultUnknown115(ErrorModule::NFC, 115);
 constexpr Result ResultRegistrationIsNotInitialized(ErrorModule::NFC, 120);
 constexpr Result ResultApplicationAreaIsNotInitialized(ErrorModule::NFC, 128);
 constexpr Result ResultCorruptedDataWithBackup(ErrorModule::NFC, 136);
--- a/src/core/hle/service/nvdrv/devices/nvmap.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvmap.cpp
@ -128,7 +128,7 @@ NvResult nvmap::IocAlloc(std::span<const u8> input, std::span<u8> output) {
    }
    bool is_out_io{};
    ASSERT(system.ApplicationProcess()
-               ->GetPageTable()
+               ->PageTable()
               .LockForMapDeviceAddressSpace(&is_out_io, handle_description->address,
                                             handle_description->size,
                                             Kernel::KMemoryPermission::None, true, false)
@ -255,7 +255,7 @@ NvResult nvmap::IocFree(std::span<const u8> input, std::span<u8> output) {
    if (auto freeInfo{file.FreeHandle(params.handle, false)}) {
        if (freeInfo->can_unlock) {
            ASSERT(system.ApplicationProcess()
-                       ->GetPageTable()
+                       ->PageTable()
                       .UnlockForDeviceAddressSpace(freeInfo->address, freeInfo->size)
                       .IsSuccess());
        }
--- a/src/core/hle/service/sockets/nsd.cpp
+++ b/src/core/hle/service/sockets/nsd.cpp
@ -10,15 +10,6 @@ namespace Service::Sockets {

 constexpr Result ResultOverflow{ErrorModule::NSD, 6};

-// This is nn::oe::ServerEnvironmentType
-enum class ServerEnvironmentType : u8 {
-    Dd,
-    Lp,
-    Sd,
-    Sp,
-    Dp,
-};
-
 NSD::NSD(Core::System& system_, const char* name) : ServiceFramework{system_, name} {
    // clang-format off
    static const FunctionInfo functions[] = {
@ -45,7 +36,7 @@ NSD::NSD(Core::System& system_, const char* name) : ServiceFramework{system_, na
        {62, nullptr, "DeleteSaveDataOfFsForTest"},
        {63, nullptr, "IsChangeEnvironmentIdentifierDisabled"},
        {64, nullptr, "SetWithoutDomainExchangeFqdns"},
-        {100, &NSD::GetApplicationServerEnvironmentType, "GetApplicationServerEnvironmentType"},
+        {100, nullptr, "GetApplicationServerEnvironmentType"},
        {101, nullptr, "SetApplicationServerEnvironmentType"},
        {102, nullptr, "DeleteApplicationServerEnvironmentType"},
    };
@ -103,12 +94,6 @@ void NSD::ResolveEx(HLERequestContext& ctx) {
    rb.Push(ResultSuccess);
 }

-void NSD::GetApplicationServerEnvironmentType(HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(static_cast<u32>(ServerEnvironmentType::Lp));
-}
-
 NSD::~NSD() = default;

 } // namespace Service::Sockets
--- a/src/core/hle/service/sockets/nsd.h
+++ b/src/core/hle/service/sockets/nsd.h
@ -19,7 +19,6 @@ public:
 private:
    void Resolve(HLERequestContext& ctx);
    void ResolveEx(HLERequestContext& ctx);
-    void GetApplicationServerEnvironmentType(HLERequestContext& ctx);
 };

 } // namespace Service::Sockets
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@ -153,7 +153,7 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect

    // Load NSO modules
    modules.clear();
-    const VAddr base_address{GetInteger(process.GetPageTable().GetCodeRegionStart())};
+    const VAddr base_address{GetInteger(process.PageTable().GetCodeRegionStart())};
    VAddr next_load_addr{base_address};
    const FileSys::PatchManager pm{metadata.GetTitleID(), system.GetFileSystemController(),
                                   system.GetContentProvider()};
--- a/src/core/loader/kip.cpp
+++ b/src/core/loader/kip.cpp
@ -96,7 +96,7 @@ AppLoader::LoadResult AppLoader_KIP::Load(Kernel::KProcess& process,
    }

    codeset.memory = std::move(program_image);
-    const VAddr base_address = GetInteger(process.GetPageTable().GetCodeRegionStart());
+    const VAddr base_address = GetInteger(process.PageTable().GetCodeRegionStart());
    process.LoadModule(std::move(codeset), base_address);

    LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", kip->GetName(), base_address);
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@ -203,7 +203,7 @@ static bool LoadNroImpl(Kernel::KProcess& process, const std::vector<u8>& data)

    // Load codeset for current process
    codeset.memory = std::move(program_image);
-    process.LoadModule(std::move(codeset), process.GetPageTable().GetCodeRegionStart());
+    process.LoadModule(std::move(codeset), process.PageTable().GetCodeRegionStart());

    return true;
 }
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@ -167,7 +167,7 @@ AppLoader_NSO::LoadResult AppLoader_NSO::Load(Kernel::KProcess& process, Core::S
    modules.clear();

    // Load module
-    const VAddr base_address = GetInteger(process.GetPageTable().GetCodeRegionStart());
+    const VAddr base_address = GetInteger(process.PageTable().GetCodeRegionStart());
    if (!LoadModule(process, system, *file, base_address, true, true)) {
        return {ResultStatus::ErrorLoadingNSO, {}};
    }
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@ -31,10 +31,10 @@ struct Memory::Impl {
    explicit Impl(Core::System& system_) : system{system_} {}

    void SetCurrentPageTable(Kernel::KProcess& process, u32 core_id) {
-        current_page_table = &process.GetPageTable().PageTableImpl();
+        current_page_table = &process.PageTable().PageTableImpl();
        current_page_table->fastmem_arena = system.DeviceMemory().buffer.VirtualBasePointer();

-        const std::size_t address_space_width = process.GetPageTable().GetAddressSpaceWidth();
+        const std::size_t address_space_width = process.PageTable().GetAddressSpaceWidth();

        system.ArmInterface(core_id).PageTableChanged(*current_page_table, address_space_width);
    }
@ -186,7 +186,7 @@ struct Memory::Impl {
    void WalkBlock(const Kernel::KProcess& process, const Common::ProcessAddress addr,
                   const std::size_t size, auto on_unmapped, auto on_memory, auto on_rasterizer,
                   auto increment) {
-        const auto& page_table = process.GetPageTable().PageTableImpl();
+        const auto& page_table = process.PageTable().PageTableImpl();
        std::size_t remaining_size = size;
        std::size_t page_index = addr >> YUZU_PAGEBITS;
        std::size_t page_offset = addr & YUZU_PAGEMASK;
@ -808,7 +808,7 @@ void Memory::UnmapRegion(Common::PageTable& page_table, Common::ProcessAddress b

 bool Memory::IsValidVirtualAddress(const Common::ProcessAddress vaddr) const {
    const Kernel::KProcess& process = *system.ApplicationProcess();
-    const auto& page_table = process.GetPageTable().PageTableImpl();
+    const auto& page_table = process.PageTable().PageTableImpl();
    const size_t page = vaddr >> YUZU_PAGEBITS;
    if (page >= page_table.pointers.size()) {
        return false;
--- a/src/core/memory/cheat_engine.cpp
+++ b/src/core/memory/cheat_engine.cpp
@ -199,7 +199,7 @@ void CheatEngine::Initialize() {
    metadata.process_id = system.ApplicationProcess()->GetProcessId();
    metadata.title_id = system.GetApplicationProcessProgramID();

-    const auto& page_table = system.ApplicationProcess()->GetPageTable();
+    const auto& page_table = system.ApplicationProcess()->PageTable();
    metadata.heap_extents = {
        .base = GetInteger(page_table.GetHeapRegionStart()),
        .size = page_table.GetHeapRegionSize(),
--- a/src/core/reporter.cpp
+++ b/src/core/reporter.cpp
@ -117,8 +117,8 @@ json GetProcessorStateDataAuto(Core::System& system) {
    arm.SaveContext(context);

    return GetProcessorStateData(process->Is64BitProcess() ? "AArch64" : "AArch32",
-                                 GetInteger(process->GetPageTable().GetCodeRegionStart()),
-                                 context.sp, context.pc, context.pstate, context.cpu_registers);
+                                 GetInteger(process->PageTable().GetCodeRegionStart()), context.sp,
+                                 context.pc, context.pstate, context.cpu_registers);
 }

 json GetBacktraceData(Core::System& system) {
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@ -442,11 +442,6 @@ void BufferCache<P>::UnbindComputeStorageBuffers() {
 template <class P>
 void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index, u32 cbuf_offset,
                                              bool is_written) {
-    if (ssbo_index >= channel_state->compute_storage_buffers.size()) [[unlikely]] {
-        LOG_ERROR(HW_GPU, "Storage buffer index {} exceeds maximum storage buffer count",
-                  ssbo_index);
-        return;
-    }
    channel_state->enabled_compute_storage_buffers |= 1U << ssbo_index;
    channel_state->written_compute_storage_buffers |= (is_written ? 1U : 0U) << ssbo_index;

@ -469,11 +464,6 @@ void BufferCache<P>::UnbindComputeTextureBuffers() {
 template <class P>
 void BufferCache<P>::BindComputeTextureBuffer(size_t tbo_index, GPUVAddr gpu_addr, u32 size,
                                              PixelFormat format, bool is_written, bool is_image) {
-    if (tbo_index >= channel_state->compute_texture_buffers.size()) [[unlikely]] {
-        LOG_ERROR(HW_GPU, "Texture buffer index {} exceeds maximum texture buffer count",
-                  tbo_index);
-        return;
-    }
    channel_state->enabled_compute_texture_buffers |= 1U << tbo_index;
    channel_state->written_compute_texture_buffers |= (is_written ? 1U : 0U) << tbo_index;
    if constexpr (SEPARATE_IMAGE_BUFFERS_BINDINGS) {
--- a/src/video_core/buffer_cache/buffer_cache_base.h
+++ b/src/video_core/buffer_cache/buffer_cache_base.h
@ -67,7 +67,7 @@ constexpr u32 NUM_TRANSFORM_FEEDBACK_BUFFERS = 4;
 constexpr u32 NUM_GRAPHICS_UNIFORM_BUFFERS = 18;
 constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;
 constexpr u32 NUM_STORAGE_BUFFERS = 16;
-constexpr u32 NUM_TEXTURE_BUFFERS = 32;
+constexpr u32 NUM_TEXTURE_BUFFERS = 16;
 constexpr u32 NUM_STAGES = 5;

 using UniformBufferSizes = std::array<std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES>;
--- a/src/yuzu/game_list_worker.cpp
+++ b/src/yuzu/game_list_worker.cpp
@ -235,7 +235,7 @@ GameListWorker::~GameListWorker() = default;
 void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
    using namespace FileSys;

-    const auto& cache = system.GetContentProviderUnion();
+    const auto& cache = dynamic_cast<ContentProviderUnion&>(system.GetContentProvider());

    auto installed_games = cache.ListEntriesFilterOrigin(std::nullopt, TitleType::Application,
                                                         ContentRecordType::Program);