core: memory: Make current_page_table access thead safe.

core: memory: page_table: Make PageTable class thread safe.
Merge pull request #5196 from lat9nq/fix-conan-boost-2
2020-12-17 01:24:51 -08:00 · 2020-12-17 01:24:51 -08:00 · 2020-12-15 21:15:05 -08:00 · 2020-12-15 23:47:29 -05:00 · 2020-12-15 16:40:11 -08:00 · 2020-12-15 11:07:03 -08:00
196 changed files with 1474 additions and 1142 deletions
@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON

 ninja

@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_QT_TRANSLATION=ON
 ninja

 ccache -s
@@ -8,7 +8,7 @@ steps:
  displayName: 'Install vulkan-sdk'
 - script: python -m pip install --upgrade pip conan
  displayName: 'Install conan'
- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_UNICORN=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 16 2019" -A x64 --config Release -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DUSE_DISCORD_PRESENCE=ON -DDISPLAY_VERSION=${{ parameters['version'] }} .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
@@ -1,4 +1,4 @@
 #!/bin/bash -ex

 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/home/yuzu/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
@@ -113,6 +113,9 @@ if (NOT DEFINED ARCHITECTURE)
 endif()
 message(STATUS "Target architecture: ${ARCHITECTURE}")

+if (UNIX)
+    add_definitions(-DYUZU_UNIX=1)
+endif()

 # Configure C++ standard
 # ===========================
@@ -157,7 +160,6 @@ macro(yuzu_find_packages)
    # Capitalization matters here. We need the naming to match the generated paths from Conan
    set(REQUIRED_LIBS
    #    Cmake Pkg Prefix  Version     Conan Pkg
-        "Boost             1.73        boost/1.73.0"
        "Catch2            2.13        catch2/2.13.0"
        "fmt               7.1         fmt/7.1.2"
    # can't use until https://github.com/bincrafters/community/issues/1173
@@ -192,6 +194,22 @@ macro(yuzu_find_packages)
    unset(FN_FORCE_REQUIRED)
 endmacro()

+find_package(Boost 1.73.0 COMPONENTS context headers QUIET)
+if (Boost_FOUND)
+    set(Boost_LIBRARIES Boost::boost)
+    # Conditionally add Boost::context only if the active version of the Conan or system Boost package provides it
+    # The old version is missing Boost::context, so we want to avoid adding in that case
+    # The new version requires adding Boost::context to prevent linking issues
+    #
+    # This one is used by Conan on subsequent CMake configures, not the first configure.
+    if (TARGET Boost::context)
+        list(APPEND Boost_LIBRARIES Boost::context)
+    endif()
+else()
+    message(STATUS "Boost 1.73.0 or newer not found, falling back to Conan")
+    list(APPEND CONAN_REQUIRED_LIBS "boost/1.73.0")
+endif()
+
 # Attempt to locate any packages that are required and report the missing ones in CONAN_REQUIRED_LIBS
 yuzu_find_packages()

@@ -296,6 +314,17 @@ if (CONAN_REQUIRED_LIBS)
    # this time with required, so we bail if its not found.
    yuzu_find_packages(FORCE_REQUIRED)

+    if (NOT Boost_FOUND)
+        find_package(Boost 1.73.0 REQUIRED COMPONENTS context headers)
+        set(Boost_LIBRARIES Boost::boost)
+        # Conditionally add Boost::context only if the active version of the Conan Boost package provides it
+        # The old version is missing Boost::context, so we want to avoid adding in that case
+        # The new version requires adding Boost::context to prevent linking issues
+        if (TARGET Boost::context)
+            list(APPEND Boost_LIBRARIES Boost::context)
+        endif()
+    endif()
+    
    # Due to issues with variable scopes in functions, we need to also find_package(qt5) outside of the function
    if(ENABLE_QT)
        list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")
@@ -30,6 +30,7 @@ public:
        params.rate = sample_rate;
        params.channels = num_channels;
        params.format = CUBEB_SAMPLE_S16NE;
+        params.prefs = CUBEB_STREAM_PREF_PERSIST;
        switch (num_channels) {
        case 1:
            params.layout = CUBEB_LAYOUT_MONO;
@@ -209,7 +209,6 @@ else()
 endif()

 create_target_directory_groups(common)
-find_package(Boost 1.71 COMPONENTS context headers REQUIRED)

 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
 target_link_libraries(common PRIVATE lz4::lz4 xbyak)
@@ -10,16 +10,12 @@ PageTable::PageTable() = default;

 PageTable::~PageTable() noexcept = default;

-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                       bool has_attribute) {
+void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits) {
    const std::size_t num_page_table_entries{1ULL
                                             << (address_space_width_in_bits - page_size_in_bits)};
    pointers.resize(num_page_table_entries);
    backing_addr.resize(num_page_table_entries);
-
-    if (has_attribute) {
-        attributes.resize(num_page_table_entries);
-    }
+    attributes.resize(num_page_table_entries);
 }

 } // namespace Common
@@ -4,6 +4,7 @@

 #pragma once

+#include <mutex>
 #include <tuple>

 #include "common/common_types.h"
@@ -47,7 +48,8 @@ struct SpecialRegion {
 * A (reasonably) fast way of allowing switchable and remappable process address spaces. It loosely
 * mimics the way a real CPU page table works.
 */
-struct PageTable {
+class PageTable {
+public:
    PageTable();
    ~PageTable() noexcept;

@@ -62,12 +64,42 @@ struct PageTable {
     * a given address space.
     *
     * @param address_space_width_in_bits The address size width in bits.
-     * @param page_size_in_bits           The page size in bits.
-     * @param has_attribute               Whether or not this page has any backing attributes.
+     * @param page_size_in_bits The page size in bits.
     */
-    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                bool has_attribute);
+    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits);

+    struct Entry {
+        u8* const pointer;
+        const u64 backing_addr;
+        const Common::PageType attribute;
+    };
+
+    VirtualBuffer<u8*>& GetPointers() {
+        return pointers;
+    }
+
+    u64 GetBackingAddr(std::size_t base) {
+        std::lock_guard<std::mutex> lock(guard);
+        return backing_addr[base];
+    }
+
+    Entry GetEntry(std::size_t base) {
+        std::lock_guard<std::mutex> lock(guard);
+        return {
+            .pointer = pointers[base],
+            .backing_addr = backing_addr[base],
+            .attribute = attributes[base],
+        };
+    }
+
+    void SetEntry(std::size_t base, const Entry& entry) {
+        std::lock_guard<std::mutex> lock(guard);
+        pointers[base] = entry.pointer;
+        backing_addr[base] = entry.backing_addr;
+        attributes[base] = entry.attribute;
+    }
+
+private:
    /**
     * Vector of memory pointers backing each page. An entry can only be non-null if the
     * corresponding entry in the `attributes` vector is of type `Memory`.
@@ -77,6 +109,8 @@ struct PageTable {
    VirtualBuffer<u64> backing_addr;

    VirtualBuffer<PageType> attributes;
+
+    std::mutex guard;
 };

 } // namespace Common
@@ -10,7 +10,7 @@
 namespace detail {
 template <typename Func>
 struct ScopeExitHelper {
-    explicit ScopeExitHelper(Func&& func) : func(std::move(func)) {}
+    explicit ScopeExitHelper(Func&& func_) : func(std::move(func_)) {}
    ~ScopeExitHelper() {
        if (active) {
            func();
@@ -52,8 +52,8 @@ public:
 template <typename T>
 class Field : public FieldInterface {
 public:
-    Field(FieldType type, std::string name, T value)
-        : name(std::move(name)), type(type), value(std::move(value)) {}
+    Field(FieldType type_, std::string name_, T value_)
+        : name(std::move(name_)), type(type_), value(std::move(value_)) {}

    Field(const Field&) = default;
    Field& operator=(const Field&) = default;
@@ -11,25 +11,25 @@

 namespace Common::X64 {

-constexpr std::size_t RegToIndex(const Xbyak::Reg& reg) {
+constexpr size_t RegToIndex(const Xbyak::Reg& reg) {
    using Kind = Xbyak::Reg::Kind;
    ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
               "RegSet only support GPRs and XMM registers.");
    ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
+    return static_cast<size_t>(reg.getIdx()) + (reg.getKind() == Kind::REG ? 0 : 16);
 }

-constexpr Xbyak::Reg64 IndexToReg64(std::size_t reg_index) {
+constexpr Xbyak::Reg64 IndexToReg64(size_t reg_index) {
    ASSERT(reg_index < 16);
    return Xbyak::Reg64(static_cast<int>(reg_index));
 }

-constexpr Xbyak::Xmm IndexToXmm(std::size_t reg_index) {
+constexpr Xbyak::Xmm IndexToXmm(size_t reg_index) {
    ASSERT(reg_index >= 16 && reg_index < 32);
    return Xbyak::Xmm(static_cast<int>(reg_index - 16));
 }

-constexpr Xbyak::Reg IndexToReg(std::size_t reg_index) {
+constexpr Xbyak::Reg IndexToReg(size_t reg_index) {
    if (reg_index < 16) {
        return IndexToReg64(reg_index);
    } else {
@@ -182,7 +182,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
                                              size_t rsp_alignment, size_t needed_frame_size = 0) {
    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);

-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_GPRS[i]) {
            code.push(IndexToReg64(i));
        }
@@ -192,7 +192,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
        code.sub(code.rsp, frame_info.subtraction);
    }

-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_XMMS[i]) {
            code.movaps(code.xword[code.rsp + frame_info.xmm_offset], IndexToXmm(i));
            frame_info.xmm_offset += 0x10;
@@ -206,7 +206,7 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
                                           size_t rsp_alignment, size_t needed_frame_size = 0) {
    auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);

-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
        if (regs[i] && ABI_ALL_XMMS[i]) {
            code.movaps(IndexToXmm(i), code.xword[code.rsp + frame_info.xmm_offset]);
            frame_info.xmm_offset += 0x10;
@@ -218,8 +218,8 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
    }

    // GPRs need to be popped in reverse order
-    for (std::size_t j = 0; j < regs.size(); ++j) {
-        const std::size_t i = regs.size() - j - 1;
+    for (size_t j = 0; j < regs.size(); ++j) {
+        const size_t i = regs.size() - j - 1;
        if (regs[i] && ABI_ALL_GPRS[i]) {
            code.pop(IndexToReg64(i));
        }
@@ -41,6 +41,7 @@ add_library(core STATIC
    file_sys/bis_factory.h
    file_sys/card_image.cpp
    file_sys/card_image.h
+    file_sys/common_funcs.h
    file_sys/content_archive.cpp
    file_sys/content_archive.h
    file_sys/control_metadata.cpp
@@ -10,7 +10,7 @@
 #include "core/hardware_properties.h"

 namespace Common {
-struct PageTable;
+class PageTable;
 }

 namespace Kernel {
@@ -131,7 +131,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable&
    static constexpr std::size_t PAGE_BITS = 12;
    static constexpr std::size_t NUM_PAGE_TABLE_ENTRIES = 1 << (32 - PAGE_BITS);
    config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
-        page_table.pointers.data());
+        page_table.GetPointers().data());
    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;
@@ -150,7 +150,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
    config.callbacks = cb.get();

    // Memory
-    config.page_table = reinterpret_cast<void**>(page_table.pointers.data());
+    config.page_table = reinterpret_cast<void**>(page_table.GetPointers().data());
    config.page_table_address_space_bits = address_space_bits;
    config.silently_mirror_page_table = false;
    config.absolute_offset_page_table = true;
@@ -237,7 +237,7 @@ struct System::Impl {
            Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
        if (load_result != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
            Shutdown();

            return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
@@ -267,8 +267,7 @@ struct System::Impl {

        u64 title_id{0};
        if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
-            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
-                      static_cast<u32>(load_result));
+            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})", load_result);
        }
        perf_stats = std::make_unique<PerfStats>(title_id);
        // Reset counters and set time origin to current frame
@@ -0,0 +1,56 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace FileSys {
+
+constexpr u64 AOC_TITLE_ID_MASK = 0x7FF;
+constexpr u64 AOC_TITLE_ID_OFFSET = 0x1000;
+constexpr u64 BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
+
+/**
+ * Gets the base title ID from a given title ID.
+ *
+ * @param title_id The title ID.
+ * @returns The base title ID.
+ */
+[[nodiscard]] constexpr u64 GetBaseTitleID(u64 title_id) {
+    return title_id & BASE_TITLE_ID_MASK;
+}
+
+/**
+ * Gets the base title ID with a program index offset from a given title ID.
+ *
+ * @param title_id The title ID.
+ * @param program_index The program index.
+ * @returns The base title ID with a program index offset.
+ */
+[[nodiscard]] constexpr u64 GetBaseTitleIDWithProgramIndex(u64 title_id, u64 program_index) {
+    return GetBaseTitleID(title_id) + program_index;
+}
+
+/**
+ * Gets the AOC (Add-On Content) base title ID from a given title ID.
+ *
+ * @param title_id The title ID.
+ * @returns The AOC base title ID.
+ */
+[[nodiscard]] constexpr u64 GetAOCBaseTitleID(u64 title_id) {
+    return GetBaseTitleID(title_id) + AOC_TITLE_ID_OFFSET;
+}
+
+/**
+ * Gets the AOC (Add-On Content) ID from a given AOC title ID.
+ *
+ * @param aoc_title_id The AOC title ID.
+ * @returns The AOC ID.
+ */
+[[nodiscard]] constexpr u64 GetAOCID(u64 aoc_title_id) {
+    return aoc_title_id & AOC_TITLE_ID_MASK;
+}
+
+} // namespace FileSys
@@ -410,8 +410,9 @@ u8 NCA::GetCryptoRevision() const {
 std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
    const auto master_key_id = GetCryptoRevision();

-    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
-        return {};
+    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index)) {
+        return std::nullopt;
+    }

    std::vector<u8> key_area(header.key_area.begin(), header.key_area.end());
    Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -420,15 +421,17 @@ std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type
    cipher.Transcode(key_area.data(), key_area.size(), key_area.data(), Core::Crypto::Op::Decrypt);

    Core::Crypto::Key128 out;
-    if (type == NCASectionCryptoType::XTS)
+    if (type == NCASectionCryptoType::XTS) {
        std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
-    else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR)
+    } else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR) {
        std::copy(key_area.begin() + 0x20, key_area.begin() + 0x30, out.begin());
-    else
+    } else {
        LOG_CRITICAL(Crypto, "Called GetKeyAreaKey on invalid NCASectionCryptoType type={:02X}",
-                     static_cast<u8>(type));
+                     type);
+    }
+
    u128 out_128{};
-    memcpy(out_128.data(), out.data(), 16);
+    std::memcpy(out_128.data(), out.data(), sizeof(u128));
    LOG_TRACE(Crypto, "called with crypto_rev={:02X}, kak_index={:02X}, key={:016X}{:016X}",
              master_key_id, header.key_index, out_128[1], out_128[0]);

@@ -507,7 +510,7 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
        // TODO(DarkLordZach): Find a test case for XTS-encrypted NCAs
    default:
        LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
-                  static_cast<u8>(s_header.raw.header.crypto_type));
+                  s_header.raw.header.crypto_type);
        return nullptr;
    }
 }
@@ -516,15 +519,17 @@ Loader::ResultStatus NCA::GetStatus() const {
    return status;
 }

-std::vector<std::shared_ptr<VfsFile>> NCA::GetFiles() const {
-    if (status != Loader::ResultStatus::Success)
+std::vector<VirtualFile> NCA::GetFiles() const {
+    if (status != Loader::ResultStatus::Success) {
        return {};
+    }
    return files;
 }

-std::vector<std::shared_ptr<VfsDirectory>> NCA::GetSubdirectories() const {
-    if (status != Loader::ResultStatus::Success)
+std::vector<VirtualDir> NCA::GetSubdirectories() const {
+    if (status != Loader::ResultStatus::Success) {
        return {};
+    }
    return dirs;
 }

@@ -532,7 +537,7 @@ std::string NCA::GetName() const {
    return file->GetName();
 }

-std::shared_ptr<VfsDirectory> NCA::GetParentDirectory() const {
+VirtualDir NCA::GetParentDirectory() const {
    return file->GetContainingDirectory();
 }

@@ -82,7 +82,7 @@ struct NCAHeader {
 };
 static_assert(sizeof(NCAHeader) == 0x400, "NCAHeader has incorrect size.");

-inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
+inline bool IsDirectoryExeFS(const VirtualDir& pfs) {
    // According to switchbrew, an exefs must only contain these two files:
    return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
@@ -104,10 +104,10 @@ public:

    Loader::ResultStatus GetStatus() const;

-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;
    std::string GetName() const override;
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    VirtualDir GetParentDirectory() const override;

    NCAContentType GetType() const;
    u64 GetTitleId() const;
@@ -191,7 +191,7 @@ bool BKTR::Resize(std::size_t new_size) {
    return false;
 }

-std::shared_ptr<VfsDirectory> BKTR::GetContainingDirectory() const {
+VirtualDir BKTR::GetContainingDirectory() const {
    return base_romfs->GetContainingDirectory();
 }

@@ -106,7 +106,7 @@ public:

    bool Resize(std::size_t new_size) override;

-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    VirtualDir GetContainingDirectory() const override;

    bool IsWritable() const override;

@@ -12,6 +12,7 @@
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/ips_layer.h"
@@ -30,7 +31,6 @@ namespace FileSys {
 namespace {

 constexpr u32 SINGLE_BYTE_MODULUS = 0x100;
-constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;

 constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
    "main",    "main.npdm", "rtld",    "sdk",     "subsdk0", "subsdk1", "subsdk2",
@@ -532,7 +532,7 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
    dlc_match.reserve(dlc_entries.size());
    std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
                 [this](const ContentProviderEntry& entry) {
-                     return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
+                     return GetBaseTitleID(entry.title_id) == title_id &&
                            content_provider.GetEntry(entry)->GetStatus() ==
                                Loader::ResultStatus::Success;
                 });
@@ -7,6 +7,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/file_sys/card_image.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -47,6 +48,27 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }

+ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
+    auto nca = content_provider.GetEntry(title_id, type);
+
+    if (nca == nullptr) {
+        // TODO: Find the right error code to use here
+        return RESULT_UNKNOWN;
+    }
+
+    const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
+
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
+}
+
+ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
+    u64 title_id, u8 program_index, ContentRecordType type) const {
+    const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index);
+
+    return OpenPatchedRomFS(res_title_id, type);
+}
+
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
                                          ContentRecordType type) const {
    const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
@@ -42,6 +42,10 @@ public:

    void SetPackedUpdate(VirtualFile update_raw);
    [[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    [[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFS(u64 title_id,
+                                                          ContentRecordType type) const;
+    [[nodiscard]] ResultVal<VirtualFile> OpenPatchedRomFSWithProgramIndex(
+        u64 title_id, u8 program_index, ContentRecordType type) const;
    [[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
                                              ContentRecordType type) const;

@@ -203,7 +203,7 @@ std::string VfsFile::GetFullPath() const {
    return GetContainingDirectory()->GetFullPath() + "/" + GetName();
 }

-std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(std::string_view path) const {
+VirtualFile VfsDirectory::GetFileRelative(std::string_view path) const {
    auto vec = Common::FS::SplitPathComponents(path);
    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
              vec.end());
@@ -231,7 +231,7 @@ std::shared_ptr<VfsFile> VfsDirectory::GetFileRelative(std::string_view path) co
    return dir->GetFile(vec.back());
 }

-std::shared_ptr<VfsFile> VfsDirectory::GetFileAbsolute(std::string_view path) const {
+VirtualFile VfsDirectory::GetFileAbsolute(std::string_view path) const {
    if (IsRoot()) {
        return GetFileRelative(path);
    }
@@ -239,7 +239,7 @@ std::shared_ptr<VfsFile> VfsDirectory::GetFileAbsolute(std::string_view path) co
    return GetParentDirectory()->GetFileAbsolute(path);
 }

-std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(std::string_view path) const {
+VirtualDir VfsDirectory::GetDirectoryRelative(std::string_view path) const {
    auto vec = Common::FS::SplitPathComponents(path);
    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
              vec.end());
@@ -261,7 +261,7 @@ std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryRelative(std::string_vie
    return dir;
 }

-std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryAbsolute(std::string_view path) const {
+VirtualDir VfsDirectory::GetDirectoryAbsolute(std::string_view path) const {
    if (IsRoot()) {
        return GetDirectoryRelative(path);
    }
@@ -269,14 +269,14 @@ std::shared_ptr<VfsDirectory> VfsDirectory::GetDirectoryAbsolute(std::string_vie
    return GetParentDirectory()->GetDirectoryAbsolute(path);
 }

-std::shared_ptr<VfsFile> VfsDirectory::GetFile(std::string_view name) const {
+VirtualFile VfsDirectory::GetFile(std::string_view name) const {
    const auto& files = GetFiles();
    const auto iter = std::find_if(files.begin(), files.end(),
                                   [&name](const auto& file1) { return name == file1->GetName(); });
    return iter == files.end() ? nullptr : *iter;
 }

-std::shared_ptr<VfsDirectory> VfsDirectory::GetSubdirectory(std::string_view name) const {
+VirtualDir VfsDirectory::GetSubdirectory(std::string_view name) const {
    const auto& subs = GetSubdirectories();
    const auto iter = std::find_if(subs.begin(), subs.end(),
                                   [&name](const auto& file1) { return name == file1->GetName(); });
@@ -301,7 +301,7 @@ std::size_t VfsDirectory::GetSize() const {
    return file_total + subdir_total;
 }

-std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(std::string_view path) {
+VirtualFile VfsDirectory::CreateFileRelative(std::string_view path) {
    auto vec = Common::FS::SplitPathComponents(path);
    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
              vec.end());
@@ -324,7 +324,7 @@ std::shared_ptr<VfsFile> VfsDirectory::CreateFileRelative(std::string_view path)
    return dir->CreateFileRelative(Common::FS::GetPathWithoutTop(path));
 }

-std::shared_ptr<VfsFile> VfsDirectory::CreateFileAbsolute(std::string_view path) {
+VirtualFile VfsDirectory::CreateFileAbsolute(std::string_view path) {
    if (IsRoot()) {
        return CreateFileRelative(path);
    }
@@ -332,7 +332,7 @@ std::shared_ptr<VfsFile> VfsDirectory::CreateFileAbsolute(std::string_view path)
    return GetParentDirectory()->CreateFileAbsolute(path);
 }

-std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(std::string_view path) {
+VirtualDir VfsDirectory::CreateDirectoryRelative(std::string_view path) {
    auto vec = Common::FS::SplitPathComponents(path);
    vec.erase(std::remove_if(vec.begin(), vec.end(), [](const auto& str) { return str.empty(); }),
              vec.end());
@@ -355,7 +355,7 @@ std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryRelative(std::string_
    return dir->CreateDirectoryRelative(Common::FS::GetPathWithoutTop(path));
 }

-std::shared_ptr<VfsDirectory> VfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
+VirtualDir VfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
    if (IsRoot()) {
        return CreateDirectoryRelative(path);
    }
@@ -446,27 +446,27 @@ bool ReadOnlyVfsDirectory::IsReadable() const {
    return true;
 }

-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateSubdirectory(std::string_view name) {
+VirtualDir ReadOnlyVfsDirectory::CreateSubdirectory(std::string_view name) {
    return nullptr;
 }

-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFile(std::string_view name) {
+VirtualFile ReadOnlyVfsDirectory::CreateFile(std::string_view name) {
    return nullptr;
 }

-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFileAbsolute(std::string_view path) {
+VirtualFile ReadOnlyVfsDirectory::CreateFileAbsolute(std::string_view path) {
    return nullptr;
 }

-std::shared_ptr<VfsFile> ReadOnlyVfsDirectory::CreateFileRelative(std::string_view path) {
+VirtualFile ReadOnlyVfsDirectory::CreateFileRelative(std::string_view path) {
    return nullptr;
 }

-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
+VirtualDir ReadOnlyVfsDirectory::CreateDirectoryAbsolute(std::string_view path) {
    return nullptr;
 }

-std::shared_ptr<VfsDirectory> ReadOnlyVfsDirectory::CreateDirectoryRelative(std::string_view path) {
+VirtualDir ReadOnlyVfsDirectory::CreateDirectoryRelative(std::string_view path) {
    return nullptr;
 }

@@ -91,7 +91,7 @@ public:
    // Resizes the file to new_size. Returns whether or not the operation was successful.
    virtual bool Resize(std::size_t new_size) = 0;
    // Gets a pointer to the directory containing this file, returning nullptr if there is none.
-    virtual std::shared_ptr<VfsDirectory> GetContainingDirectory() const = 0;
+    virtual VirtualDir GetContainingDirectory() const = 0;

    // Returns whether or not the file can be written to.
    virtual bool IsWritable() const = 0;
@@ -183,27 +183,27 @@ public:

    // Retrives the file located at path as if the current directory was root. Returns nullptr if
    // not found.
-    virtual std::shared_ptr<VfsFile> GetFileRelative(std::string_view path) const;
+    virtual VirtualFile GetFileRelative(std::string_view path) const;
    // Calls GetFileRelative(path) on the root of the current directory.
-    virtual std::shared_ptr<VfsFile> GetFileAbsolute(std::string_view path) const;
+    virtual VirtualFile GetFileAbsolute(std::string_view path) const;

    // Retrives the directory located at path as if the current directory was root. Returns nullptr
    // if not found.
-    virtual std::shared_ptr<VfsDirectory> GetDirectoryRelative(std::string_view path) const;
+    virtual VirtualDir GetDirectoryRelative(std::string_view path) const;
    // Calls GetDirectoryRelative(path) on the root of the current directory.
-    virtual std::shared_ptr<VfsDirectory> GetDirectoryAbsolute(std::string_view path) const;
+    virtual VirtualDir GetDirectoryAbsolute(std::string_view path) const;

    // Returns a vector containing all of the files in this directory.
-    virtual std::vector<std::shared_ptr<VfsFile>> GetFiles() const = 0;
+    virtual std::vector<VirtualFile> GetFiles() const = 0;
    // Returns the file with filename matching name. Returns nullptr if directory dosen't have a
    // file with name.
-    virtual std::shared_ptr<VfsFile> GetFile(std::string_view name) const;
+    virtual VirtualFile GetFile(std::string_view name) const;

    // Returns a vector containing all of the subdirectories in this directory.
-    virtual std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const = 0;
+    virtual std::vector<VirtualDir> GetSubdirectories() const = 0;
    // Returns the directory with name matching name. Returns nullptr if directory dosen't have a
    // directory with name.
-    virtual std::shared_ptr<VfsDirectory> GetSubdirectory(std::string_view name) const;
+    virtual VirtualDir GetSubdirectory(std::string_view name) const;

    // Returns whether or not the directory can be written to.
    virtual bool IsWritable() const = 0;
@@ -219,31 +219,31 @@ public:
    virtual std::size_t GetSize() const;
    // Returns the parent directory of this directory. Returns nullptr if this directory is root or
    // has no parent.
-    virtual std::shared_ptr<VfsDirectory> GetParentDirectory() const = 0;
+    virtual VirtualDir GetParentDirectory() const = 0;

    // Creates a new subdirectory with name name. Returns a pointer to the new directory or nullptr
    // if the operation failed.
-    virtual std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) = 0;
+    virtual VirtualDir CreateSubdirectory(std::string_view name) = 0;
    // Creates a new file with name name. Returns a pointer to the new file or nullptr if the
    // operation failed.
-    virtual std::shared_ptr<VfsFile> CreateFile(std::string_view name) = 0;
+    virtual VirtualFile CreateFile(std::string_view name) = 0;

    // Creates a new file at the path relative to this directory. Also creates directories if
    // they do not exist and is supported by this implementation. Returns nullptr on any failure.
-    virtual std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path);
+    virtual VirtualFile CreateFileRelative(std::string_view path);

    // Creates a new file at the path relative to root of this directory. Also creates directories
    // if they do not exist and is supported by this implementation. Returns nullptr on any failure.
-    virtual std::shared_ptr<VfsFile> CreateFileAbsolute(std::string_view path);
+    virtual VirtualFile CreateFileAbsolute(std::string_view path);

    // Creates a new directory at the path relative to this directory. Also creates directories if
    // they do not exist and is supported by this implementation. Returns nullptr on any failure.
-    virtual std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path);
+    virtual VirtualDir CreateDirectoryRelative(std::string_view path);

    // Creates a new directory at the path relative to root of this directory. Also creates
    // directories if they do not exist and is supported by this implementation. Returns nullptr on
    // any failure.
-    virtual std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path);
+    virtual VirtualDir CreateDirectoryAbsolute(std::string_view path);

    // Deletes the subdirectory with the given name and returns true on success.
    virtual bool DeleteSubdirectory(std::string_view name) = 0;
@@ -280,12 +280,12 @@ class ReadOnlyVfsDirectory : public VfsDirectory {
 public:
    bool IsWritable() const override;
    bool IsReadable() const override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFileAbsolute(std::string_view path) override;
-    std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryAbsolute(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path) override;
+    VirtualDir CreateSubdirectory(std::string_view name) override;
+    VirtualFile CreateFile(std::string_view name) override;
+    VirtualFile CreateFileAbsolute(std::string_view path) override;
+    VirtualFile CreateFileRelative(std::string_view path) override;
+    VirtualDir CreateDirectoryAbsolute(std::string_view path) override;
+    VirtualDir CreateDirectoryRelative(std::string_view path) override;
    bool DeleteSubdirectory(std::string_view name) override;
    bool DeleteSubdirectoryRecursive(std::string_view name) override;
    bool CleanSubdirectoryRecursive(std::string_view name) override;
@@ -46,7 +46,7 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(std::vector<VirtualFile> f
    if (files.size() == 1)
        return files[0];

-    return std::shared_ptr<VfsFile>(new ConcatenatedVfsFile(std::move(files), std::move(name)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(files), std::move(name)));
 }

 VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
@@ -71,20 +71,23 @@ VirtualFile ConcatenatedVfsFile::MakeConcatenatedFile(u8 filler_byte,
    if (files.begin()->first != 0)
        files.emplace(0, std::make_shared<StaticVfsFile>(filler_byte, files.begin()->first));

-    return std::shared_ptr<VfsFile>(new ConcatenatedVfsFile(std::move(files), std::move(name)));
+    return VirtualFile(new ConcatenatedVfsFile(std::move(files), std::move(name)));
 }

 std::string ConcatenatedVfsFile::GetName() const {
-    if (files.empty())
+    if (files.empty()) {
        return "";
-    if (!name.empty())
+    }
+    if (!name.empty()) {
        return name;
+    }
    return files.begin()->second->GetName();
 }

 std::size_t ConcatenatedVfsFile::GetSize() const {
-    if (files.empty())
+    if (files.empty()) {
        return 0;
+    }
    return files.rbegin()->first + files.rbegin()->second->GetSize();
 }

@@ -92,9 +95,10 @@ bool ConcatenatedVfsFile::Resize(std::size_t new_size) {
    return false;
 }

-std::shared_ptr<VfsDirectory> ConcatenatedVfsFile::GetContainingDirectory() const {
-    if (files.empty())
+VirtualDir ConcatenatedVfsFile::GetContainingDirectory() const {
+    if (files.empty()) {
        return nullptr;
+    }
    return files.begin()->second->GetContainingDirectory();
 }

@@ -31,7 +31,7 @@ public:
    std::string GetName() const override;
    std::size_t GetSize() const override;
    bool Resize(std::size_t new_size) override;
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    VirtualDir GetContainingDirectory() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
@@ -20,10 +20,10 @@ VirtualDir LayeredVfsDirectory::MakeLayeredDirectory(std::vector<VirtualDir> dir
    if (dirs.size() == 1)
        return dirs[0];

-    return std::shared_ptr<VfsDirectory>(new LayeredVfsDirectory(std::move(dirs), std::move(name)));
+    return VirtualDir(new LayeredVfsDirectory(std::move(dirs), std::move(name)));
 }

-std::shared_ptr<VfsFile> LayeredVfsDirectory::GetFileRelative(std::string_view path) const {
+VirtualFile LayeredVfsDirectory::GetFileRelative(std::string_view path) const {
    for (const auto& layer : dirs) {
        const auto file = layer->GetFileRelative(path);
        if (file != nullptr)
@@ -33,23 +33,23 @@ std::shared_ptr<VfsFile> LayeredVfsDirectory::GetFileRelative(std::string_view p
    return nullptr;
 }

-std::shared_ptr<VfsDirectory> LayeredVfsDirectory::GetDirectoryRelative(
-    std::string_view path) const {
+VirtualDir LayeredVfsDirectory::GetDirectoryRelative(std::string_view path) const {
    std::vector<VirtualDir> out;
    for (const auto& layer : dirs) {
        auto dir = layer->GetDirectoryRelative(path);
-        if (dir != nullptr)
+        if (dir != nullptr) {
            out.push_back(std::move(dir));
+        }
    }

    return MakeLayeredDirectory(std::move(out));
 }

-std::shared_ptr<VfsFile> LayeredVfsDirectory::GetFile(std::string_view name) const {
+VirtualFile LayeredVfsDirectory::GetFile(std::string_view name) const {
    return GetFileRelative(name);
 }

-std::shared_ptr<VfsDirectory> LayeredVfsDirectory::GetSubdirectory(std::string_view name) const {
+VirtualDir LayeredVfsDirectory::GetSubdirectory(std::string_view name) const {
    return GetDirectoryRelative(name);
 }

@@ -57,7 +57,7 @@ std::string LayeredVfsDirectory::GetFullPath() const {
    return dirs[0]->GetFullPath();
 }

-std::vector<std::shared_ptr<VfsFile>> LayeredVfsDirectory::GetFiles() const {
+std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
    std::vector<VirtualFile> out;
    for (const auto& layer : dirs) {
        for (const auto& file : layer->GetFiles()) {
@@ -72,7 +72,7 @@ std::vector<std::shared_ptr<VfsFile>> LayeredVfsDirectory::GetFiles() const {
    return out;
 }

-std::vector<std::shared_ptr<VfsDirectory>> LayeredVfsDirectory::GetSubdirectories() const {
+std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
    std::vector<std::string> names;
    for (const auto& layer : dirs) {
        for (const auto& sd : layer->GetSubdirectories()) {
@@ -101,15 +101,15 @@ std::string LayeredVfsDirectory::GetName() const {
    return name.empty() ? dirs[0]->GetName() : name;
 }

-std::shared_ptr<VfsDirectory> LayeredVfsDirectory::GetParentDirectory() const {
+VirtualDir LayeredVfsDirectory::GetParentDirectory() const {
    return dirs[0]->GetParentDirectory();
 }

-std::shared_ptr<VfsDirectory> LayeredVfsDirectory::CreateSubdirectory(std::string_view name) {
+VirtualDir LayeredVfsDirectory::CreateSubdirectory(std::string_view name) {
    return nullptr;
 }

-std::shared_ptr<VfsFile> LayeredVfsDirectory::CreateFile(std::string_view name) {
+VirtualFile LayeredVfsDirectory::CreateFile(std::string_view name) {
    return nullptr;
 }

@@ -21,20 +21,20 @@ public:
    /// Wrapper function to allow for more efficient handling of dirs.size() == 0, 1 cases.
    static VirtualDir MakeLayeredDirectory(std::vector<VirtualDir> dirs, std::string name = "");

-    std::shared_ptr<VfsFile> GetFileRelative(std::string_view path) const override;
-    std::shared_ptr<VfsDirectory> GetDirectoryRelative(std::string_view path) const override;
-    std::shared_ptr<VfsFile> GetFile(std::string_view name) const override;
-    std::shared_ptr<VfsDirectory> GetSubdirectory(std::string_view name) const override;
+    VirtualFile GetFileRelative(std::string_view path) const override;
+    VirtualDir GetDirectoryRelative(std::string_view path) const override;
+    VirtualFile GetFile(std::string_view name) const override;
+    VirtualDir GetSubdirectory(std::string_view name) const override;
    std::string GetFullPath() const override;

-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::string GetName() const override;
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
+    VirtualDir GetParentDirectory() const override;
+    VirtualDir CreateSubdirectory(std::string_view name) override;
+    VirtualFile CreateFile(std::string_view name) override;
    bool DeleteSubdirectory(std::string_view name) override;
    bool DeleteFile(std::string_view name) override;
    bool Rename(std::string_view name) override;
@@ -9,7 +9,7 @@

 namespace FileSys {

-OffsetVfsFile::OffsetVfsFile(std::shared_ptr<VfsFile> file_, std::size_t size_, std::size_t offset_,
+OffsetVfsFile::OffsetVfsFile(VirtualFile file_, std::size_t size_, std::size_t offset_,
                             std::string name_, VirtualDir parent_)
    : file(file_), offset(offset_), size(size_), name(std::move(name_)),
      parent(parent_ == nullptr ? file->GetContainingDirectory() : std::move(parent_)) {}
@@ -37,7 +37,7 @@ bool OffsetVfsFile::Resize(std::size_t new_size) {
    return true;
 }

-std::shared_ptr<VfsDirectory> OffsetVfsFile::GetContainingDirectory() const {
+VirtualDir OffsetVfsFile::GetContainingDirectory() const {
    return parent;
 }

@@ -17,14 +17,14 @@ namespace FileSys {
 // the size of this wrapper.
 class OffsetVfsFile : public VfsFile {
 public:
-    OffsetVfsFile(std::shared_ptr<VfsFile> file, std::size_t size, std::size_t offset = 0,
+    OffsetVfsFile(VirtualFile file, std::size_t size, std::size_t offset = 0,
                  std::string new_name = "", VirtualDir new_parent = nullptr);
    ~OffsetVfsFile() override;

    std::string GetName() const override;
    std::size_t GetSize() const override;
    bool Resize(std::size_t new_size) override;
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    VirtualDir GetContainingDirectory() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
@@ -42,7 +42,7 @@ public:
 private:
    std::size_t TrimToFit(std::size_t r_size, std::size_t r_offset) const;

-    std::shared_ptr<VfsFile> file;
+    VirtualFile file;
    std::size_t offset;
    std::size_t size;
    std::string name;
@@ -263,7 +263,7 @@ bool RealVfsFile::Resize(std::size_t new_size) {
    return backing->Resize(new_size);
 }

-std::shared_ptr<VfsDirectory> RealVfsFile::GetContainingDirectory() const {
+VirtualDir RealVfsFile::GetContainingDirectory() const {
    return base.OpenDirectory(parent_path, perms);
 }

@@ -352,7 +352,7 @@ RealVfsDirectory::RealVfsDirectory(RealVfsFilesystem& base_, const std::string&

 RealVfsDirectory::~RealVfsDirectory() = default;

-std::shared_ptr<VfsFile> RealVfsDirectory::GetFileRelative(std::string_view path) const {
+VirtualFile RealVfsDirectory::GetFileRelative(std::string_view path) const {
    const auto full_path = FS::SanitizePath(this->path + DIR_SEP + std::string(path));
    if (!FS::Exists(full_path) || FS::IsDirectory(full_path)) {
        return nullptr;
@@ -360,7 +360,7 @@ std::shared_ptr<VfsFile> RealVfsDirectory::GetFileRelative(std::string_view path
    return base.OpenFile(full_path, perms);
 }

-std::shared_ptr<VfsDirectory> RealVfsDirectory::GetDirectoryRelative(std::string_view path) const {
+VirtualDir RealVfsDirectory::GetDirectoryRelative(std::string_view path) const {
    const auto full_path = FS::SanitizePath(this->path + DIR_SEP + std::string(path));
    if (!FS::Exists(full_path) || !FS::IsDirectory(full_path)) {
        return nullptr;
@@ -368,20 +368,20 @@ std::shared_ptr<VfsDirectory> RealVfsDirectory::GetDirectoryRelative(std::string
    return base.OpenDirectory(full_path, perms);
 }

-std::shared_ptr<VfsFile> RealVfsDirectory::GetFile(std::string_view name) const {
+VirtualFile RealVfsDirectory::GetFile(std::string_view name) const {
    return GetFileRelative(name);
 }

-std::shared_ptr<VfsDirectory> RealVfsDirectory::GetSubdirectory(std::string_view name) const {
+VirtualDir RealVfsDirectory::GetSubdirectory(std::string_view name) const {
    return GetDirectoryRelative(name);
 }

-std::shared_ptr<VfsFile> RealVfsDirectory::CreateFileRelative(std::string_view path) {
+VirtualFile RealVfsDirectory::CreateFileRelative(std::string_view path) {
    const auto full_path = FS::SanitizePath(this->path + DIR_SEP + std::string(path));
    return base.CreateFile(full_path, perms);
 }

-std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateDirectoryRelative(std::string_view path) {
+VirtualDir RealVfsDirectory::CreateDirectoryRelative(std::string_view path) {
    const auto full_path = FS::SanitizePath(this->path + DIR_SEP + std::string(path));
    return base.CreateDirectory(full_path, perms);
 }
@@ -391,11 +391,11 @@ bool RealVfsDirectory::DeleteSubdirectoryRecursive(std::string_view name) {
    return base.DeleteDirectory(full_path);
 }

-std::vector<std::shared_ptr<VfsFile>> RealVfsDirectory::GetFiles() const {
+std::vector<VirtualFile> RealVfsDirectory::GetFiles() const {
    return IterateEntries<RealVfsFile, VfsFile>();
 }

-std::vector<std::shared_ptr<VfsDirectory>> RealVfsDirectory::GetSubdirectories() const {
+std::vector<VirtualDir> RealVfsDirectory::GetSubdirectories() const {
    return IterateEntries<RealVfsDirectory, VfsDirectory>();
 }

@@ -411,7 +411,7 @@ std::string RealVfsDirectory::GetName() const {
    return path_components.back();
 }

-std::shared_ptr<VfsDirectory> RealVfsDirectory::GetParentDirectory() const {
+VirtualDir RealVfsDirectory::GetParentDirectory() const {
    if (path_components.size() <= 1) {
        return nullptr;
    }
@@ -419,12 +419,12 @@ std::shared_ptr<VfsDirectory> RealVfsDirectory::GetParentDirectory() const {
    return base.OpenDirectory(parent_path, perms);
 }

-std::shared_ptr<VfsDirectory> RealVfsDirectory::CreateSubdirectory(std::string_view name) {
+VirtualDir RealVfsDirectory::CreateSubdirectory(std::string_view name) {
    const std::string subdir_path = (path + DIR_SEP).append(name);
    return base.CreateDirectory(subdir_path, perms);
 }

-std::shared_ptr<VfsFile> RealVfsDirectory::CreateFile(std::string_view name) {
+VirtualFile RealVfsDirectory::CreateFile(std::string_view name) {
    const std::string file_path = (path + DIR_SEP).append(name);
    return base.CreateFile(file_path, perms);
 }
@@ -50,7 +50,7 @@ public:
    std::string GetName() const override;
    std::size_t GetSize() const override;
    bool Resize(std::size_t new_size) override;
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    VirtualDir GetContainingDirectory() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
@@ -79,21 +79,21 @@ class RealVfsDirectory : public VfsDirectory {
 public:
    ~RealVfsDirectory() override;

-    std::shared_ptr<VfsFile> GetFileRelative(std::string_view path) const override;
-    std::shared_ptr<VfsDirectory> GetDirectoryRelative(std::string_view path) const override;
-    std::shared_ptr<VfsFile> GetFile(std::string_view name) const override;
-    std::shared_ptr<VfsDirectory> GetSubdirectory(std::string_view name) const override;
-    std::shared_ptr<VfsFile> CreateFileRelative(std::string_view path) override;
-    std::shared_ptr<VfsDirectory> CreateDirectoryRelative(std::string_view path) override;
+    VirtualFile GetFileRelative(std::string_view path) const override;
+    VirtualDir GetDirectoryRelative(std::string_view path) const override;
+    VirtualFile GetFile(std::string_view name) const override;
+    VirtualDir GetSubdirectory(std::string_view name) const override;
+    VirtualFile CreateFileRelative(std::string_view path) override;
+    VirtualDir CreateDirectoryRelative(std::string_view path) override;
    bool DeleteSubdirectoryRecursive(std::string_view name) override;
-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::string GetName() const override;
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
+    VirtualDir GetParentDirectory() const override;
+    VirtualDir CreateSubdirectory(std::string_view name) override;
+    VirtualFile CreateFile(std::string_view name) override;
    bool DeleteSubdirectory(std::string_view name) override;
    bool DeleteFile(std::string_view name) override;
    bool Rename(std::string_view name) override;
@@ -31,7 +31,7 @@ public:
        return true;
    }

-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override {
+    VirtualDir GetContainingDirectory() const override {
        return parent;
    }

@@ -25,7 +25,7 @@ bool VectorVfsFile::Resize(size_t new_size) {
    return true;
 }

-std::shared_ptr<VfsDirectory> VectorVfsFile::GetContainingDirectory() const {
+VirtualDir VectorVfsFile::GetContainingDirectory() const {
    return parent;
 }

@@ -68,11 +68,11 @@ VectorVfsDirectory::VectorVfsDirectory(std::vector<VirtualFile> files_,

 VectorVfsDirectory::~VectorVfsDirectory() = default;

-std::vector<std::shared_ptr<VfsFile>> VectorVfsDirectory::GetFiles() const {
+std::vector<VirtualFile> VectorVfsDirectory::GetFiles() const {
    return files;
 }

-std::vector<std::shared_ptr<VfsDirectory>> VectorVfsDirectory::GetSubdirectories() const {
+std::vector<VirtualDir> VectorVfsDirectory::GetSubdirectories() const {
    return dirs;
 }

@@ -88,7 +88,7 @@ std::string VectorVfsDirectory::GetName() const {
    return name;
 }

-std::shared_ptr<VfsDirectory> VectorVfsDirectory::GetParentDirectory() const {
+VirtualDir VectorVfsDirectory::GetParentDirectory() const {
    return parent;
 }

@@ -116,11 +116,11 @@ bool VectorVfsDirectory::Rename(std::string_view name_) {
    return true;
 }

-std::shared_ptr<VfsDirectory> VectorVfsDirectory::CreateSubdirectory(std::string_view name) {
+VirtualDir VectorVfsDirectory::CreateSubdirectory(std::string_view name) {
    return nullptr;
 }

-std::shared_ptr<VfsFile> VectorVfsDirectory::CreateFile(std::string_view name) {
+VirtualFile VectorVfsDirectory::CreateFile(std::string_view name) {
    return nullptr;
 }

@@ -17,9 +17,9 @@ namespace FileSys {
 template <std::size_t size>
 class ArrayVfsFile : public VfsFile {
 public:
-    explicit ArrayVfsFile(const std::array<u8, size>& data, std::string name = "",
-                          VirtualDir parent = nullptr)
-        : data(data), name(std::move(name)), parent(std::move(parent)) {}
+    explicit ArrayVfsFile(const std::array<u8, size>& data_, std::string name_ = "",
+                          VirtualDir parent_ = nullptr)
+        : data(data_), name(std::move(name_)), parent(std::move(parent_)) {}

    std::string GetName() const override {
        return name;
@@ -33,7 +33,7 @@ public:
        return false;
    }

-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override {
+    VirtualDir GetContainingDirectory() const override {
        return parent;
    }

@@ -51,12 +51,12 @@ public:
        return read;
    }

-    std::size_t Write(const u8* data, std::size_t length, std::size_t offset) override {
+    std::size_t Write(const u8* data_, std::size_t length, std::size_t offset) override {
        return 0;
    }

-    bool Rename(std::string_view name) override {
-        this->name = name;
+    bool Rename(std::string_view new_name) override {
+        name = new_name;
        return true;
    }

@@ -82,7 +82,7 @@ public:
    std::string GetName() const override;
    std::size_t GetSize() const override;
    bool Resize(std::size_t new_size) override;
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    VirtualDir GetContainingDirectory() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::size_t Read(u8* data, std::size_t length, std::size_t offset) const override;
@@ -106,17 +106,17 @@ public:
                                VirtualDir parent = nullptr);
    ~VectorVfsDirectory() override;

-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;
    bool IsWritable() const override;
    bool IsReadable() const override;
    std::string GetName() const override;
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    VirtualDir GetParentDirectory() const override;
    bool DeleteSubdirectory(std::string_view name) override;
    bool DeleteFile(std::string_view name) override;
    bool Rename(std::string_view name) override;
-    std::shared_ptr<VfsDirectory> CreateSubdirectory(std::string_view name) override;
-    std::shared_ptr<VfsFile> CreateFile(std::string_view name) override;
+    VirtualDir CreateSubdirectory(std::string_view name) override;
+    VirtualFile CreateFile(std::string_view name) override;

    virtual void AddFile(VirtualFile file);
    virtual void AddDirectory(VirtualDir dir);
@@ -152,11 +152,11 @@ NAXContentType NAX::GetContentType() const {
    return type;
 }

-std::vector<std::shared_ptr<VfsFile>> NAX::GetFiles() const {
+std::vector<VirtualFile> NAX::GetFiles() const {
    return {dec_file};
 }

-std::vector<std::shared_ptr<VfsDirectory>> NAX::GetSubdirectories() const {
+std::vector<VirtualDir> NAX::GetSubdirectories() const {
    return {};
 }

@@ -164,7 +164,7 @@ std::string NAX::GetName() const {
    return file->GetName();
 }

-std::shared_ptr<VfsDirectory> NAX::GetParentDirectory() const {
+VirtualDir NAX::GetParentDirectory() const {
    return file->GetContainingDirectory();
 }

@@ -47,13 +47,13 @@ public:

    NAXContentType GetContentType() const;

-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
+    std::vector<VirtualFile> GetFiles() const override;

-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;

    std::string GetName() const override;

-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    VirtualDir GetParentDirectory() const override;

 private:
    Loader::ResultStatus Parse(std::string_view path);
@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#include "common/logging/log.h"
 #include "core/frontend/applets/error.h"

 namespace Core::Frontend {
@@ -10,7 +11,7 @@ ErrorApplet::~ErrorApplet() = default;

 void DefaultErrorApplet::ShowError(ResultCode error, std::function<void()> finished) const {
    LOG_CRITICAL(Service_Fatal, "Application requested error display: {:04}-{:04} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
+                 error.module.Value(), error.description.Value(), error.raw);
 }

 void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::seconds time,
@@ -18,7 +19,7 @@ void DefaultErrorApplet::ShowErrorWithTimestamp(ResultCode error, std::chrono::s
    LOG_CRITICAL(
        Service_Fatal,
        "Application requested error display: {:04X}-{:04X} (raw={:08X}) with timestamp={:016X}",
-        static_cast<u32>(error.module.Value()), error.description.Value(), error.raw, time.count());
+        error.module.Value(), error.description.Value(), error.raw, time.count());
 }

 void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_text,
@@ -26,7 +27,7 @@ void DefaultErrorApplet::ShowCustomErrorText(ResultCode error, std::string main_
                                             std::function<void()> finished) const {
    LOG_CRITICAL(Service_Fatal,
                 "Application requested custom error with error_code={:04X}-{:04X} (raw={:08X})",
-                 static_cast<u32>(error.module.Value()), error.description.Value(), error.raw);
+                 error.module.Value(), error.description.Value(), error.raw);
    LOG_CRITICAL(Service_Fatal, "    Main Text: {}", main_text);
    LOG_CRITICAL(Service_Fatal, "    Detail Text: {}", detail_text);
 }
@@ -166,8 +166,23 @@ public:
        ValidateHeader();
    }

+    void PushImpl(s8 value);
+    void PushImpl(s16 value);
+    void PushImpl(s32 value);
+    void PushImpl(s64 value);
+    void PushImpl(u8 value);
+    void PushImpl(u16 value);
+    void PushImpl(u32 value);
+    void PushImpl(u64 value);
+    void PushImpl(float value);
+    void PushImpl(double value);
+    void PushImpl(bool value);
+    void PushImpl(ResultCode value);
+
    template <typename T>
-    void Push(T value);
+    void Push(T value) {
+        return PushImpl(value);
+    }

    template <typename First, typename... Other>
    void Push(const First& first_value, const Other&... other_values);
@@ -215,13 +230,11 @@ private:

 /// Push ///

-template <>
-inline void ResponseBuilder::Push(s32 value) {
+inline void ResponseBuilder::PushImpl(s32 value) {
    cmdbuf[index++] = static_cast<u32>(value);
 }

-template <>
-inline void ResponseBuilder::Push(u32 value) {
+inline void ResponseBuilder::PushImpl(u32 value) {
    cmdbuf[index++] = value;
 }

@@ -233,62 +246,52 @@ void ResponseBuilder::PushRaw(const T& value) {
    index += (sizeof(T) + 3) / 4; // round up to word length
 }

-template <>
-inline void ResponseBuilder::Push(ResultCode value) {
+inline void ResponseBuilder::PushImpl(ResultCode value) {
    // Result codes are actually 64-bit in the IPC buffer, but only the high part is discarded.
    Push(value.raw);
    Push<u32>(0);
 }

-template <>
-inline void ResponseBuilder::Push(s8 value) {
+inline void ResponseBuilder::PushImpl(s8 value) {
    PushRaw(value);
 }

-template <>
-inline void ResponseBuilder::Push(s16 value) {
+inline void ResponseBuilder::PushImpl(s16 value) {
    PushRaw(value);
 }

-template <>
-inline void ResponseBuilder::Push(s64 value) {
-    Push(static_cast<u32>(value));
-    Push(static_cast<u32>(value >> 32));
+inline void ResponseBuilder::PushImpl(s64 value) {
+    PushImpl(static_cast<u32>(value));
+    PushImpl(static_cast<u32>(value >> 32));
 }

-template <>
-inline void ResponseBuilder::Push(u8 value) {
+inline void ResponseBuilder::PushImpl(u8 value) {
    PushRaw(value);
 }

-template <>
-inline void ResponseBuilder::Push(u16 value) {
+inline void ResponseBuilder::PushImpl(u16 value) {
    PushRaw(value);
 }

-template <>
-inline void ResponseBuilder::Push(u64 value) {
-    Push(static_cast<u32>(value));
-    Push(static_cast<u32>(value >> 32));
+inline void ResponseBuilder::PushImpl(u64 value) {
+    PushImpl(static_cast<u32>(value));
+    PushImpl(static_cast<u32>(value >> 32));
 }

-template <>
-inline void ResponseBuilder::Push(float value) {
+inline void ResponseBuilder::PushImpl(float value) {
    u32 integral;
    std::memcpy(&integral, &value, sizeof(u32));
-    Push(integral);
+    PushImpl(integral);
 }

-template <>
-inline void ResponseBuilder::Push(double value) {
+inline void ResponseBuilder::PushImpl(double value) {
    u64 integral;
    std::memcpy(&integral, &value, sizeof(u64));
-    Push(integral);
+    PushImpl(integral);
 }

-template <>
-inline void ResponseBuilder::Push(bool value) {
-    Push(static_cast<u8>(value));
+inline void ResponseBuilder::PushImpl(bool value) {
+    PushImpl(static_cast<u8>(value));
 }

 template <typename First, typename... Other>
@@ -222,9 +222,9 @@ public:

 public:
    constexpr MemoryBlock() = default;
-    constexpr MemoryBlock(VAddr addr, std::size_t num_pages, MemoryState state,
-                          MemoryPermission perm, MemoryAttribute attribute)
-        : addr{addr}, num_pages(num_pages), state{state}, perm{perm}, attribute{attribute} {}
+    constexpr MemoryBlock(VAddr addr_, std::size_t num_pages_, MemoryState state_,
+                          MemoryPermission perm_, MemoryAttribute attribute_)
+        : addr{addr_}, num_pages(num_pages_), state{state_}, perm{perm_}, attribute{attribute_} {}

    constexpr VAddr GetAddress() const {
        return addr;
@@ -57,8 +57,8 @@ public:
 private:
    void MergeAdjacent(iterator it, iterator& next_it);

-    const VAddr start_addr;
-    const VAddr end_addr;
+    [[maybe_unused]] const VAddr start_addr;
+    [[maybe_unused]] const VAddr end_addr;

    MemoryBlockTree memory_block_tree;
 };
@@ -265,7 +265,7 @@ ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_t
    physical_memory_usage = 0;
    memory_pool = pool;

-    page_table_impl.Resize(address_space_width, PageBits, true);
+    page_table_impl.Resize(address_space_width, PageBits);

    return InitializeMemoryLayout(start, end);
 }
@@ -211,8 +211,9 @@ public:
    constexpr bool IsInsideASLRRegion(VAddr address, std::size_t size) const {
        return !IsOutsideASLRRegion(address, size);
    }
-    constexpr PAddr GetPhysicalAddr(VAddr addr) {
-        return page_table_impl.backing_addr[addr >> Memory::PageBits] + addr;
+
+    PAddr GetPhysicalAddr(VAddr addr) {
+        return page_table_impl.GetBackingAddr(addr >> Memory::PageBits) + addr;
    }

 private:
@@ -36,7 +36,7 @@ public:
    PhysicalCore& operator=(const PhysicalCore&) = delete;

    PhysicalCore(PhysicalCore&&) = default;
-    PhysicalCore& operator=(PhysicalCore&&) = default;
+    PhysicalCore& operator=(PhysicalCore&&) = delete;

    /// Initialize the core for the specified parameters.
    void Initialize(bool is_64_bit);
@@ -199,7 +199,7 @@ ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& s
        break;
    }

-    LOG_ERROR(Kernel, "Invalid capability type! type={}", static_cast<u32>(type));
+    LOG_ERROR(Kernel, "Invalid capability type! type={}", type);
    return ERR_INVALID_CAPABILITY_DESCRIPTOR;
 }

@@ -65,8 +65,8 @@ ResultCode ResourceLimit::SetLimitValue(ResourceType resource, s64 value) {
        limit[index] = value;
        return RESULT_SUCCESS;
    } else {
-        LOG_ERROR(Kernel, "Limit value is too large! resource={}, value={}, index={}",
-                  static_cast<u32>(resource), value, index);
+        LOG_ERROR(Kernel, "Limit value is too large! resource={}, value={}, index={}", resource,
+                  value, index);
        return ERR_INVALID_STATE;
    }
 }
@@ -130,8 +130,7 @@ ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& con
    }
    }

-    LOG_CRITICAL(IPC, "Unknown domain command={}",
-                 static_cast<int>(domain_message_header.command.Value()));
+    LOG_CRITICAL(IPC, "Unknown domain command={}", domain_message_header.command.Value());
    ASSERT(false);
    return RESULT_SUCCESS;
 }
@@ -234,8 +234,7 @@ static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 si

 static ResultCode SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask,
                                       u32 attribute) {
-    return SetMemoryAttribute(system, static_cast<VAddr>(address), static_cast<std::size_t>(size),
-                              mask, attribute);
+    return SetMemoryAttribute(system, address, size, mask, attribute);
 }

 /// Maps a memory range into a different range.
@@ -255,8 +254,7 @@ static ResultCode MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr
 }

 static ResultCode MapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
-    return MapMemory(system, static_cast<VAddr>(dst_addr), static_cast<VAddr>(src_addr),
-                     static_cast<std::size_t>(size));
+    return MapMemory(system, dst_addr, src_addr, size);
 }

 /// Unmaps a region that was previously mapped with svcMapMemory
@@ -276,8 +274,7 @@ static ResultCode UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_ad
 }

 static ResultCode UnmapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
-    return UnmapMemory(system, static_cast<VAddr>(dst_addr), static_cast<VAddr>(src_addr),
-                       static_cast<std::size_t>(size));
+    return UnmapMemory(system, dst_addr, src_addr, size);
 }

 /// Connect to an OS service given the port name, returns the handle to the port to out
@@ -531,8 +528,7 @@ static ResultCode ArbitrateLock(Core::System& system, Handle holding_thread_hand

 static ResultCode ArbitrateLock32(Core::System& system, Handle holding_thread_handle,
                                  u32 mutex_addr, Handle requesting_thread_handle) {
-    return ArbitrateLock(system, holding_thread_handle, static_cast<VAddr>(mutex_addr),
-                         requesting_thread_handle);
+    return ArbitrateLock(system, holding_thread_handle, mutex_addr, requesting_thread_handle);
 }

 /// Unlock a mutex
@@ -555,7 +551,7 @@ static ResultCode ArbitrateUnlock(Core::System& system, VAddr mutex_addr) {
 }

 static ResultCode ArbitrateUnlock32(Core::System& system, u32 mutex_addr) {
-    return ArbitrateUnlock(system, static_cast<VAddr>(mutex_addr));
+    return ArbitrateUnlock(system, mutex_addr);
 }

 enum class BreakType : u32 {
@@ -677,7 +673,7 @@ static void Break(Core::System& system, u32 reason, u64 info1, u64 info2) {
 }

 static void Break32(Core::System& system, u32 reason, u32 info1, u32 info2) {
-    Break(system, reason, static_cast<u64>(info1), static_cast<u64>(info2));
+    Break(system, reason, info1, info2);
 }

 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
@@ -948,7 +944,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, u64 ha

 static ResultCode GetInfo32(Core::System& system, u32* result_low, u32* result_high, u32 sub_id_low,
                            u32 info_id, u32 handle, u32 sub_id_high) {
-    const u64 sub_id{static_cast<u64>(sub_id_low | (static_cast<u64>(sub_id_high) << 32))};
+    const u64 sub_id{u64{sub_id_low} | (u64{sub_id_high} << 32)};
    u64 res_value{};

    const ResultCode result{GetInfo(system, &res_value, info_id, handle, sub_id)};
@@ -1009,7 +1005,7 @@ static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size)
 }

 static ResultCode MapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
-    return MapPhysicalMemory(system, static_cast<VAddr>(addr), static_cast<std::size_t>(size));
+    return MapPhysicalMemory(system, addr, size);
 }

 /// Unmaps memory previously mapped via MapPhysicalMemory
@@ -1063,7 +1059,7 @@ static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size
 }

 static ResultCode UnmapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
-    return UnmapPhysicalMemory(system, static_cast<VAddr>(addr), static_cast<std::size_t>(size));
+    return UnmapPhysicalMemory(system, addr, size);
 }

 /// Sets the thread activity
@@ -1144,7 +1140,7 @@ static ResultCode GetThreadContext(Core::System& system, VAddr thread_context, H
 }

 static ResultCode GetThreadContext32(Core::System& system, u32 thread_context, Handle handle) {
-    return GetThreadContext(system, static_cast<VAddr>(thread_context), handle);
+    return GetThreadContext(system, thread_context, handle);
 }

 /// Gets the priority for the specified thread
@@ -1281,8 +1277,7 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shared_memory_han

 static ResultCode MapSharedMemory32(Core::System& system, Handle shared_memory_handle, u32 addr,
                                    u32 size, u32 permissions) {
-    return MapSharedMemory(system, shared_memory_handle, static_cast<VAddr>(addr),
-                           static_cast<std::size_t>(size), permissions);
+    return MapSharedMemory(system, shared_memory_handle, addr, size, permissions);
 }

 static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_address,
@@ -1552,8 +1547,7 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e

 static ResultCode CreateThread32(Core::System& system, Handle* out_handle, u32 priority,
                                 u32 entry_point, u32 arg, u32 stack_top, s32 processor_id) {
-    return CreateThread(system, out_handle, static_cast<VAddr>(entry_point), static_cast<u64>(arg),
-                        static_cast<VAddr>(stack_top), priority, processor_id);
+    return CreateThread(system, out_handle, entry_point, arg, stack_top, priority, processor_id);
 }

 /// Starts the thread for the provided handle
@@ -1637,8 +1631,7 @@ static void SleepThread(Core::System& system, s64 nanoseconds) {
 }

 static void SleepThread32(Core::System& system, u32 nanoseconds_low, u32 nanoseconds_high) {
-    const s64 nanoseconds = static_cast<s64>(static_cast<u64>(nanoseconds_low) |
-                                             (static_cast<u64>(nanoseconds_high) << 32));
+    const auto nanoseconds = static_cast<s64>(u64{nanoseconds_low} | (u64{nanoseconds_high} << 32));
    SleepThread(system, nanoseconds);
 }

@@ -1724,10 +1717,8 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr mutex_add
 static ResultCode WaitProcessWideKeyAtomic32(Core::System& system, u32 mutex_addr,
                                             u32 condition_variable_addr, Handle thread_handle,
                                             u32 nanoseconds_low, u32 nanoseconds_high) {
-    const s64 nanoseconds =
-        static_cast<s64>(nanoseconds_low | (static_cast<u64>(nanoseconds_high) << 32));
-    return WaitProcessWideKeyAtomic(system, static_cast<VAddr>(mutex_addr),
-                                    static_cast<VAddr>(condition_variable_addr), thread_handle,
+    const auto nanoseconds = static_cast<s64>(nanoseconds_low | (u64{nanoseconds_high} << 32));
+    return WaitProcessWideKeyAtomic(system, mutex_addr, condition_variable_addr, thread_handle,
                                    nanoseconds);
 }

@@ -1833,8 +1824,8 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, u32 type,

 static ResultCode WaitForAddress32(Core::System& system, u32 address, u32 type, s32 value,
                                   u32 timeout_low, u32 timeout_high) {
-    s64 timeout = static_cast<s64>(timeout_low | (static_cast<u64>(timeout_high) << 32));
-    return WaitForAddress(system, static_cast<VAddr>(address), type, value, timeout);
+    const auto timeout = static_cast<s64>(timeout_low | (u64{timeout_high} << 32));
+    return WaitForAddress(system, address, type, value, timeout);
 }

 // Signals to an address (via Address Arbiter)
@@ -1862,7 +1853,7 @@ static ResultCode SignalToAddress(Core::System& system, VAddr address, u32 type,

 static ResultCode SignalToAddress32(Core::System& system, u32 address, u32 type, s32 value,
                                    s32 num_to_wake) {
-    return SignalToAddress(system, static_cast<VAddr>(address), type, value, num_to_wake);
+    return SignalToAddress(system, address, type, value, num_to_wake);
 }

 static void KernelDebug([[maybe_unused]] Core::System& system,
@@ -1893,7 +1884,7 @@ static u64 GetSystemTick(Core::System& system) {
 }

 static void GetSystemTick32(Core::System& system, u32* time_low, u32* time_high) {
-    u64 time = GetSystemTick(system);
+    const auto time = GetSystemTick(system);
    *time_low = static_cast<u32>(time);
    *time_high = static_cast<u32>(time >> 32);
 }
@@ -1984,8 +1975,7 @@ static ResultCode CreateTransferMemory(Core::System& system, Handle* handle, VAd

 static ResultCode CreateTransferMemory32(Core::System& system, Handle* handle, u32 addr, u32 size,
                                         u32 permissions) {
-    return CreateTransferMemory(system, handle, static_cast<VAddr>(addr),
-                                static_cast<std::size_t>(size), permissions);
+    return CreateTransferMemory(system, handle, addr, size, permissions);
 }

 static ResultCode GetThreadCoreMask(Core::System& system, Handle thread_handle, u32* core,
@@ -2075,8 +2065,7 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,

 static ResultCode SetThreadCoreMask32(Core::System& system, Handle thread_handle, u32 core,
                                      u32 affinity_mask_low, u32 affinity_mask_high) {
-    const u64 affinity_mask =
-        static_cast<u64>(affinity_mask_low) | (static_cast<u64>(affinity_mask_high) << 32);
+    const auto affinity_mask = u64{affinity_mask_low} | (u64{affinity_mask_high} << 32);
    return SetThreadCoreMask(system, thread_handle, core, affinity_mask);
 }

@@ -2341,9 +2330,10 @@ static ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAdd
    return RESULT_SUCCESS;
 }

-static ResultCode FlushProcessDataCache32(Core::System& system, Handle handle, u32 address,
-                                          u32 size) {
-    // Note(Blinkhawk): For emulation purposes of the data cache this is mostly a nope
+static ResultCode FlushProcessDataCache32([[maybe_unused]] Core::System& system,
+                                          [[maybe_unused]] Handle handle,
+                                          [[maybe_unused]] u32 address, [[maybe_unused]] u32 size) {
+    // Note(Blinkhawk): For emulation purposes of the data cache this is mostly a no-op,
    // as all emulation is done in the same cache level in host architecture, thus data cache
    // does not need flushing.
    LOG_DEBUG(Kernel_SVC, "called");
@@ -1092,14 +1092,14 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
    const auto applet_id = rp.PopRaw<Applets::AppletId>();
    const auto applet_mode = rp.PopRaw<u32>();

-    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",
-              static_cast<u32>(applet_id), applet_mode);
+    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}", applet_id,
+              applet_mode);

    const auto& applet_manager{system.GetAppletManager()};
    const auto applet = applet_manager.GetApplet(applet_id);

    if (applet == nullptr) {
-        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
+        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);

        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_UNKNOWN);
@@ -1290,7 +1290,7 @@ void IApplicationFunctions::PopLaunchParameter(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto kind = rp.PopEnum<LaunchParameterKind>();

-    LOG_DEBUG(Service_AM, "called, kind={:08X}", static_cast<u8>(kind));
+    LOG_DEBUG(Service_AM, "called, kind={:08X}", kind);

    if (kind == LaunchParameterKind::ApplicationSpecific && !launch_popped_application_specific) {
        const auto backend = BCAT::CreateBackendFromSettings(system, [this](u64 tid) {
@@ -1537,8 +1537,8 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto [type, user_id] = rp.PopRaw<Parameters>();

-    LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", static_cast<u8>(type),
-              user_id[1], user_id[0]);
+    LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", type, user_id[1],
+              user_id[0]);

    const auto size = system.GetFileSystemController().ReadSaveDataSize(
        type, system.CurrentProcess()->GetTitleID(), user_id);
@@ -29,14 +29,14 @@ static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
    npad_style_set.raw = private_arg.style_set;

    return {
-        .min_players = std::max(s8(1), header.player_count_min),
+        .min_players = std::max(s8{1}, header.player_count_min),
        .max_players = header.player_count_max,
        .keep_controllers_connected = header.enable_take_over_connection,
        .enable_single_mode = header.enable_single_mode,
        .enable_border_color = header.enable_identification_color,
-        .border_colors = identification_colors,
+        .border_colors = std::move(identification_colors),
        .enable_explain_text = enable_text,
-        .explain_text = text,
+        .explain_text = std::move(text),
        .allow_pro_controller = npad_style_set.pro_controller == 1,
        .allow_handheld = npad_style_set.handheld == 1,
        .allow_dual_joycons = npad_style_set.joycon_dual == 1,
@@ -227,15 +227,14 @@ void Controller::ConfigurationComplete() {
    // If enable_single_mode is enabled, player_count is 1 regardless of any other parameters.
    // Otherwise, only count connected players from P1-P8.
    result_info.player_count =
-        is_single_mode ? 1
-                       : static_cast<s8>(std::count_if(
-                             players.begin(), players.end() - 2,
-                             [](Settings::PlayerInput player) { return player.connected; }));
+        is_single_mode
+            ? 1
+            : static_cast<s8>(std::count_if(players.begin(), players.end() - 2,
+                                            [](const auto& player) { return player.connected; }));

-    result_info.selected_id = HID::Controller_NPad::IndexToNPad(
-        std::distance(players.begin(),
-                      std::find_if(players.begin(), players.end(),
-                                   [](Settings::PlayerInput player) { return player.connected; })));
+    result_info.selected_id = HID::Controller_NPad::IndexToNPad(std::distance(
+        players.begin(), std::find_if(players.begin(), players.end(),
+                                      [](const auto& player) { return player.connected; })));

    result_info.result = 0;

@@ -125,7 +125,7 @@ void Error::Initialize() {
        error_code = Decode64BitError(args->error_record.error_code_64);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
+        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", mode);
    }
 }

@@ -179,7 +179,7 @@ void Error::Execute() {
            error_code, std::chrono::seconds{args->error_record.posix_time}, callback);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", static_cast<u8>(mode));
+        UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", mode);
        DisplayCompleted();
    }
 }
@@ -90,7 +90,7 @@ void Auth::Execute() {
    const auto unimplemented_log = [this] {
        UNIMPLEMENTED_MSG("Unimplemented Auth applet type for type={:08X}, arg0={:02X}, "
                          "arg1={:02X}, arg2={:02X}",
-                          static_cast<u32>(type), arg0, arg1, arg2);
+                          type, arg0, arg1, arg2);
    };

    switch (type) {
@@ -136,7 +136,7 @@ void Auth::Execute() {
 }

 void Auth::AuthFinished(bool is_successful) {
-    this->successful = is_successful;
+    successful = is_successful;

    struct Return {
        ResultCode result_code;
@@ -193,7 +193,7 @@ void PhotoViewer::Execute() {
        frontend.ShowAllPhotos(callback);
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", static_cast<u8>(mode));
+        UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", mode);
    }
 }

@@ -7,6 +7,7 @@
 #include <vector>
 #include "common/logging/log.h"
 #include "core/core.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/nca_metadata.h"
@@ -23,11 +24,8 @@

 namespace Service::AOC {

-constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
-constexpr u64 DLC_BASE_TO_AOC_ID = 0x1000;
-
 static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
-    return (title_id & DLC_BASE_TITLE_ID_MASK) == base;
+    return FileSys::GetBaseTitleID(title_id) == base;
 }

 static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
@@ -48,6 +46,62 @@ static std::vector<u64> AccumulateAOCTitleIDs(Core::System& system) {
    return add_on_content;
 }

+class IPurchaseEventManager final : public ServiceFramework<IPurchaseEventManager> {
+public:
+    explicit IPurchaseEventManager(Core::System& system_)
+        : ServiceFramework{system_, "IPurchaseEventManager"} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &IPurchaseEventManager::SetDefaultDeliveryTarget, "SetDefaultDeliveryTarget"},
+            {1, &IPurchaseEventManager::SetDeliveryTarget, "SetDeliveryTarget"},
+            {2, &IPurchaseEventManager::GetPurchasedEventReadableHandle, "GetPurchasedEventReadableHandle"},
+            {3, nullptr, "PopPurchasedProductInfo"},
+            {4, nullptr, "PopPurchasedProductInfoWithUid"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+
+        purchased_event = Kernel::WritableEvent::CreateEventPair(
+            system.Kernel(), "IPurchaseEventManager:PurchasedEvent");
+    }
+
+private:
+    void SetDefaultDeliveryTarget(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        const auto unknown_1 = rp.Pop<u64>();
+        [[maybe_unused]] const auto unknown_2 = ctx.ReadBuffer();
+
+        LOG_WARNING(Service_AOC, "(STUBBED) called, unknown_1={}", unknown_1);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void SetDeliveryTarget(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        const auto unknown_1 = rp.Pop<u64>();
+        [[maybe_unused]] const auto unknown_2 = ctx.ReadBuffer();
+
+        LOG_WARNING(Service_AOC, "(STUBBED) called, unknown_1={}", unknown_1);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_SUCCESS);
+    }
+
+    void GetPurchasedEventReadableHandle(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_AOC, "called");
+
+        IPC::ResponseBuilder rb{ctx, 2, 1};
+        rb.Push(RESULT_SUCCESS);
+        rb.PushCopyObjects(purchased_event.readable);
+    }
+
+    Kernel::EventPair purchased_event;
+};
+
 AOC_U::AOC_U(Core::System& system_)
    : ServiceFramework{system_, "aoc:u"}, add_on_content{AccumulateAOCTitleIDs(system)} {
    // clang-format off
@@ -62,8 +116,8 @@ AOC_U::AOC_U(Core::System& system_)
        {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
        {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
        {9, nullptr, "GetAddOnContentLostErrorCode"},
-        {100, nullptr, "CreateEcPurchasedEventManager"},
-        {101, nullptr, "CreatePermanentEcPurchasedEventManager"},
+        {100, &AOC_U::CreateEcPurchasedEventManager, "CreateEcPurchasedEventManager"},
+        {101, &AOC_U::CreatePermanentEcPurchasedEventManager, "CreatePermanentEcPurchasedEventManager"},
    };
    // clang-format on

@@ -123,11 +177,11 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
    const auto& disabled = Settings::values.disabled_addons[current];
    if (std::find(disabled.begin(), disabled.end(), "DLC") == disabled.end()) {
        for (u64 content_id : add_on_content) {
-            if ((content_id & DLC_BASE_TITLE_ID_MASK) != current) {
+            if (FileSys::GetBaseTitleID(content_id) != current) {
                continue;
            }

-            out.push_back(static_cast<u32>(content_id & 0x7FF));
+            out.push_back(static_cast<u32>(FileSys::GetAOCID(content_id)));
        }
    }

@@ -169,7 +223,7 @@ void AOC_U::GetAddOnContentBaseId(Kernel::HLERequestContext& ctx) {

    const auto res = pm.GetControlMetadata();
    if (res.first == nullptr) {
-        rb.Push(title_id + DLC_BASE_TO_AOC_ID);
+        rb.Push(FileSys::GetAOCBaseTitleID(title_id));
        return;
    }

@@ -201,6 +255,22 @@ void AOC_U::GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx) {
    rb.PushCopyObjects(aoc_change_event.readable);
 }

+void AOC_U::CreateEcPurchasedEventManager(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IPurchaseEventManager>(system);
+}
+
+void AOC_U::CreatePermanentEcPurchasedEventManager(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AOC, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IPurchaseEventManager>(system);
+}
+
 void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
    std::make_shared<AOC_U>(system)->InstallAsService(service_manager);
 }
@@ -27,6 +27,8 @@ private:
    void GetAddOnContentBaseId(Kernel::HLERequestContext& ctx);
    void PrepareAddOnContent(Kernel::HLERequestContext& ctx);
    void GetAddOnContentListChangedEvent(Kernel::HLERequestContext& ctx);
+    void CreateEcPurchasedEventManager(Kernel::HLERequestContext& ctx);
+    void CreatePermanentEcPurchasedEventManager(Kernel::HLERequestContext& ctx);

    std::vector<u64> add_on_content;
    Kernel::EventPair aoc_change_event;
@@ -48,8 +48,7 @@ void Controller::SetPerformanceConfiguration(PerformanceMode mode,
                                   [config](const auto& entry) { return entry.first == config; });

    if (iter == config_to_speed.cend()) {
-        LOG_ERROR(Service_APM, "Invalid performance configuration value provided: {}",
-                  static_cast<u32>(config));
+        LOG_ERROR(Service_APM, "Invalid performance configuration value provided: {}", config);
        return;
    }

@@ -28,8 +28,7 @@ private:

        const auto mode = rp.PopEnum<PerformanceMode>();
        const auto config = rp.PopEnum<PerformanceConfiguration>();
-        LOG_DEBUG(Service_APM, "called mode={} config={}", static_cast<u32>(mode),
-                  static_cast<u32>(config));
+        LOG_DEBUG(Service_APM, "called mode={} config={}", mode, config);

        controller.SetPerformanceConfiguration(mode, config);

@@ -41,7 +40,7 @@ private:
        IPC::RequestParser rp{ctx};

        const auto mode = rp.PopEnum<PerformanceMode>();
-        LOG_DEBUG(Service_APM, "called mode={}", static_cast<u32>(mode));
+        LOG_DEBUG(Service_APM, "called mode={}", mode);

        IPC::ResponseBuilder rb{ctx, 3};
        rb.Push(RESULT_SUCCESS);
@@ -111,7 +110,7 @@ void APM_Sys::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto mode = rp.PopEnum<CpuBoostMode>();

-    LOG_DEBUG(Service_APM, "called, mode={:08X}", static_cast<u32>(mode));
+    LOG_DEBUG(Service_APM, "called, mode={:08X}", mode);

    controller.SetFromCpuBoostMode(mode);

@@ -483,7 +483,7 @@ Boxcat::StatusResult Boxcat::GetStatus(std::optional<std::string>& global,
            global = json["global"].get<std::string>();

        if (json["games"].is_array()) {
-            for (const auto object : json["games"]) {
+            for (const auto& object : json["games"]) {
                if (object.is_object() && object.find("name") != object.end()) {
                    EventStatus detail{};
                    if (object["header"].is_string()) {
@@ -111,8 +111,9 @@ static void GenerateErrorReport(Core::System& system, ResultCode error_code,

 static void ThrowFatalError(Core::System& system, ResultCode error_code, FatalType fatal_type,
                            const FatalInfo& info) {
-    LOG_ERROR(Service_Fatal, "Threw fatal error type {} with error code 0x{:X}",
-              static_cast<u32>(fatal_type), error_code.raw);
+    LOG_ERROR(Service_Fatal, "Threw fatal error type {} with error code 0x{:X}", fatal_type,
+              error_code.raw);
+
    switch (fatal_type) {
    case FatalType::ErrorReportAndScreen:
        GenerateErrorReport(system, error_code, info);
@@ -298,10 +298,35 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFSCurrentProcess()
    return romfs_factory->OpenCurrentProcess(system.CurrentProcess()->GetTitleID());
 }

+ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFS(
+    u64 title_id, FileSys::ContentRecordType type) const {
+    LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}", title_id);
+
+    if (romfs_factory == nullptr) {
+        // TODO: Find a better error code for this
+        return RESULT_UNKNOWN;
+    }
+
+    return romfs_factory->OpenPatchedRomFS(title_id, type);
+}
+
+ResultVal<FileSys::VirtualFile> FileSystemController::OpenPatchedRomFSWithProgramIndex(
+    u64 title_id, u8 program_index, FileSys::ContentRecordType type) const {
+    LOG_TRACE(Service_FS, "Opening patched RomFS for title_id={:016X}, program_index={}", title_id,
+              program_index);
+
+    if (romfs_factory == nullptr) {
+        // TODO: Find a better error code for this
+        return RESULT_UNKNOWN;
+    }
+
+    return romfs_factory->OpenPatchedRomFSWithProgramIndex(title_id, program_index, type);
+}
+
 ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(
    u64 title_id, FileSys::StorageId storage_id, FileSys::ContentRecordType type) const {
    LOG_TRACE(Service_FS, "Opening RomFS for title_id={:016X}, storage_id={:02X}, type={:02X}",
-              title_id, static_cast<u8>(storage_id), static_cast<u8>(type));
+              title_id, storage_id, type);

    if (romfs_factory == nullptr) {
        // TODO(bunnei): Find a better error code for this
@@ -313,8 +338,8 @@ ResultVal<FileSys::VirtualFile> FileSystemController::OpenRomFS(

 ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(
    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& save_struct) const {
-    LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}",
-              static_cast<u8>(space), save_struct.DebugInfo());
+    LOG_TRACE(Service_FS, "Creating Save Data for space_id={:01X}, save_struct={}", space,
+              save_struct.DebugInfo());

    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -325,8 +350,8 @@ ResultVal<FileSys::VirtualDir> FileSystemController::CreateSaveData(

 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(
    FileSys::SaveDataSpaceId space, const FileSys::SaveDataAttribute& attribute) const {
-    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}",
-              static_cast<u8>(space), attribute.DebugInfo());
+    LOG_TRACE(Service_FS, "Opening Save Data for space_id={:01X}, save_struct={}", space,
+              attribute.DebugInfo());

    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -337,7 +362,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveData(

 ResultVal<FileSys::VirtualDir> FileSystemController::OpenSaveDataSpace(
    FileSys::SaveDataSpaceId space) const {
-    LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", static_cast<u8>(space));
+    LOG_TRACE(Service_FS, "Opening Save Data Space for space_id={:01X}", space);

    if (save_data_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -358,7 +383,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenSDMC() const {

 ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(
    FileSys::BisPartitionId id) const {
-    LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", static_cast<u32>(id));
+    LOG_TRACE(Service_FS, "Opening BIS Partition with id={:08X}", id);

    if (bis_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -374,7 +399,7 @@ ResultVal<FileSys::VirtualDir> FileSystemController::OpenBISPartition(

 ResultVal<FileSys::VirtualFile> FileSystemController::OpenBISPartitionStorage(
    FileSys::BisPartitionId id) const {
-    LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", static_cast<u32>(id));
+    LOG_TRACE(Service_FS, "Opening BIS Partition Storage with id={:08X}", id);

    if (bis_factory == nullptr) {
        return FileSys::ERROR_ENTITY_NOT_FOUND;
@@ -66,6 +66,10 @@ public:

    void SetPackedUpdate(FileSys::VirtualFile update_raw);
    ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() const;
+    ResultVal<FileSys::VirtualFile> OpenPatchedRomFS(u64 title_id,
+                                                     FileSys::ContentRecordType type) const;
+    ResultVal<FileSys::VirtualFile> OpenPatchedRomFSWithProgramIndex(
+        u64 title_id, u8 program_index, FileSys::ContentRecordType type) const;
    ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
                                              FileSys::ContentRecordType type) const;
    ResultVal<FileSys::VirtualDir> CreateSaveData(
@@ -413,7 +413,7 @@ public:

        const auto mode = static_cast<FileSys::Mode>(rp.Pop<u32>());

-        LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, static_cast<u32>(mode));
+        LOG_DEBUG(Service_FS, "called. file={}, mode={}", name, mode);

        auto result = backend.OpenFile(name, mode);
        if (result.Failed()) {
@@ -553,8 +553,7 @@ private:
        const auto save_root = fsc.OpenSaveDataSpace(space);

        if (save_root.Failed() || *save_root == nullptr) {
-            LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!",
-                      static_cast<u8>(space));
+            LOG_ERROR(Service_FS, "The save root for the space_id={:02X} was invalid!", space);
            return;
        }

@@ -718,7 +717,7 @@ FSP_SRV::FSP_SRV(Core::System& system_)
        {202, &FSP_SRV::OpenDataStorageByDataId, "OpenDataStorageByDataId"},
        {203, &FSP_SRV::OpenPatchDataStorageByCurrentProcess, "OpenPatchDataStorageByCurrentProcess"},
        {204, nullptr, "OpenDataFileSystemByProgramIndex"},
-        {205, nullptr, "OpenDataStorageByProgramIndex"},
+        {205, &FSP_SRV::OpenDataStorageWithProgramIndex, "OpenDataStorageWithProgramIndex"},
        {400, nullptr, "OpenDeviceOperator"},
        {500, nullptr, "OpenSdCardDetectionEventNotifier"},
        {501, nullptr, "OpenGameCardDetectionEventNotifier"},
@@ -795,8 +794,7 @@ void FSP_SRV::OpenFileSystemWithPatch(Kernel::HLERequestContext& ctx) {

    const auto type = rp.PopRaw<FileSystemType>();
    const auto title_id = rp.PopRaw<u64>();
-    LOG_WARNING(Service_FS, "(STUBBED) called with type={}, title_id={:016X}",
-                static_cast<u8>(type), title_id);
+    LOG_WARNING(Service_FS, "(STUBBED) called with type={}, title_id={:016X}", type, title_id);

    IPC::ResponseBuilder rb{ctx, 2, 0, 0};
    rb.Push(RESULT_UNKNOWN);
@@ -883,7 +881,7 @@ void FSP_SRV::OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto space = rp.PopRaw<FileSys::SaveDataSpaceId>();
-    LOG_INFO(Service_FS, "called, space={}", static_cast<u8>(space));
+    LOG_INFO(Service_FS, "called, space={}", space);

    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
    rb.Push(RESULT_SUCCESS);
@@ -915,10 +913,10 @@ void FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
                "(STUBBED) called, flags={}, space_id={}, attribute.title_id={:016X}\n"
                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
                "attribute.type={}, attribute.rank={}, attribute.index={}",
-                flags, static_cast<u32>(parameters.space_id), parameters.attribute.title_id,
+                flags, parameters.space_id, parameters.attribute.title_id,
                parameters.attribute.user_id[1], parameters.attribute.user_id[0],
-                parameters.attribute.save_id, static_cast<u32>(parameters.attribute.type),
-                static_cast<u32>(parameters.attribute.rank), parameters.attribute.index);
+                parameters.attribute.save_id, parameters.attribute.type, parameters.attribute.rank,
+                parameters.attribute.index);

    IPC::ResponseBuilder rb{ctx, 3};
    rb.Push(RESULT_SUCCESS);
@@ -951,7 +949,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
    const auto title_id = rp.PopRaw<u64>();

    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, unknown={:08X}, title_id={:016X}",
-              static_cast<u8>(storage_id), unknown, title_id);
+              storage_id, unknown, title_id);

    auto data = fsc.OpenRomFS(title_id, storage_id, FileSys::ContentRecordType::Data);

@@ -968,7 +966,7 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
        // TODO(DarkLordZach): Find the right error code to use here
        LOG_ERROR(Service_FS,
                  "could not open data storage with title_id={:016X}, storage_id={:02X}", title_id,
-                  static_cast<u8>(storage_id));
+                  storage_id);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(RESULT_UNKNOWN);
        return;
@@ -987,21 +985,46 @@ void FSP_SRV::OpenDataStorageByDataId(Kernel::HLERequestContext& ctx) {
 void FSP_SRV::OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

-    auto storage_id = rp.PopRaw<FileSys::StorageId>();
-    auto title_id = rp.PopRaw<u64>();
+    const auto storage_id = rp.PopRaw<FileSys::StorageId>();
+    const auto title_id = rp.PopRaw<u64>();

-    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}",
-              static_cast<u8>(storage_id), title_id);
+    LOG_DEBUG(Service_FS, "called with storage_id={:02X}, title_id={:016X}", storage_id, title_id);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
 }

+void FSP_SRV::OpenDataStorageWithProgramIndex(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    const auto program_index = rp.PopRaw<u8>();
+
+    LOG_DEBUG(Service_FS, "called, program_index={}", program_index);
+
+    auto romfs = fsc.OpenPatchedRomFSWithProgramIndex(
+        system.CurrentProcess()->GetTitleID(), program_index, FileSys::ContentRecordType::Program);
+
+    if (romfs.Failed()) {
+        // TODO: Find the right error code to use here
+        LOG_ERROR(Service_FS, "could not open storage with program_index={}", program_index);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(RESULT_UNKNOWN);
+        return;
+    }
+
+    auto storage = std::make_shared<IStorage>(system, std::move(romfs.Unwrap()));
+
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushIpcInterface<IStorage>(std::move(storage));
+}
+
 void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    log_mode = rp.PopEnum<LogMode>();

-    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", static_cast<u32>(log_mode));
+    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", log_mode);

    IPC::ResponseBuilder rb{ctx, 2};
    rb.Push(RESULT_SUCCESS);
@@ -49,6 +49,7 @@ private:
    void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
    void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
    void OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
+    void OpenDataStorageWithProgramIndex(Kernel::HLERequestContext& ctx);
    void SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
    void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
    void OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx);
@@ -229,8 +229,7 @@ private:
            break;
        default:
            // HOS seems not have an error case for an unknown notification
-            LOG_WARNING(Service_ACC, "Unknown notification {:08X}",
-                        static_cast<u32>(notification.notification_type));
+            LOG_WARNING(Service_ACC, "Unknown notification {:08X}", notification.notification_type);
            break;
        }

@@ -116,6 +116,31 @@ u32 Controller_NPad::IndexToNPad(std::size_t index) {
    }
 }

+bool Controller_NPad::IsNpadIdValid(u32 npad_id) {
+    switch (npad_id) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+    case NPAD_UNKNOWN:
+    case NPAD_HANDHELD:
+        return true;
+    default:
+        LOG_ERROR(Service_HID, "Invalid npad id {}", npad_id);
+        return false;
+    }
+}
+
+bool Controller_NPad::IsDeviceHandleValid(const DeviceHandle& device_handle) {
+    return IsNpadIdValid(device_handle.npad_id) &&
+           device_handle.npad_type < NpadType::MaxNpadType &&
+           device_handle.device_index < DeviceIndex::MaxDeviceIndex;
+}
+
 Controller_NPad::Controller_NPad(Core::System& system) : ControllerBase(system), system(system) {}

 Controller_NPad::~Controller_NPad() {
@@ -742,6 +767,10 @@ bool Controller_NPad::VibrateControllerAtIndex(std::size_t npad_index, std::size

 void Controller_NPad::VibrateController(const DeviceHandle& vibration_device_handle,
                                        const VibrationValue& vibration_value) {
+    if (!IsDeviceHandleValid(vibration_device_handle)) {
+        return;
+    }
+
    if (!Settings::values.vibration_enabled.GetValue() && !permit_vibration_session_enabled) {
        return;
    }
@@ -798,12 +827,20 @@ void Controller_NPad::VibrateControllers(const std::vector<DeviceHandle>& vibrat

 Controller_NPad::VibrationValue Controller_NPad::GetLastVibration(
    const DeviceHandle& vibration_device_handle) const {
+    if (!IsDeviceHandleValid(vibration_device_handle)) {
+        return {};
+    }
+
    const auto npad_index = NPadIdToIndex(vibration_device_handle.npad_id);
    const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);
    return latest_vibration_values[npad_index][device_index];
 }

 void Controller_NPad::InitializeVibrationDevice(const DeviceHandle& vibration_device_handle) {
+    if (!IsDeviceHandleValid(vibration_device_handle)) {
+        return;
+    }
+
    const auto npad_index = NPadIdToIndex(vibration_device_handle.npad_id);
    const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);
    InitializeVibrationDeviceAtIndex(npad_index, device_index);
@@ -824,6 +861,10 @@ void Controller_NPad::SetPermitVibrationSession(bool permit_vibration_session) {
 }

 bool Controller_NPad::IsVibrationDeviceMounted(const DeviceHandle& vibration_device_handle) const {
+    if (!IsDeviceHandleValid(vibration_device_handle)) {
+        return false;
+    }
+
    const auto npad_index = NPadIdToIndex(vibration_device_handle.npad_id);
    const auto device_index = static_cast<std::size_t>(vibration_device_handle.device_index);
    return vibration_devices_mounted[npad_index][device_index];
@@ -56,12 +56,14 @@ public:
        JoyconLeft = 6,
        JoyconRight = 7,
        Pokeball = 9,
+        MaxNpadType = 10,
    };

    enum class DeviceIndex : u8 {
        Left = 0,
        Right = 1,
        None = 2,
+        MaxDeviceIndex = 3,
    };

    enum class GyroscopeZeroDriftMode : u32 {
@@ -213,6 +215,8 @@ public:
    static Settings::ControllerType MapNPadToSettingsType(Controller_NPad::NPadControllerType type);
    static std::size_t NPadIdToIndex(u32 npad_id);
    static u32 IndexToNPad(std::size_t index);
+    static bool IsNpadIdValid(u32 npad_id);
+    static bool IsDeviceHandleValid(const DeviceHandle& device_handle);

 private:
    struct CommonHeader {
@@ -68,7 +68,7 @@ private:
        IPC::RequestParser rp{ctx};
        const auto destination = rp.PopEnum<DestinationFlag>();

-        LOG_DEBUG(Service_LM, "called, destination={:08X}", static_cast<u32>(destination));
+        LOG_DEBUG(Service_LM, "called, destination={:08X}", destination);

        manager.SetDestination(destination);

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

 private:
-    FileSys::StorageId storage;
+    [[maybe_unused]] FileSys::StorageId storage;
 };

 class IRegisteredLocationResolver final : public ServiceFramework<IRegisteredLocationResolver> {
@@ -217,7 +217,7 @@ public:
            {1, nullptr, "RefreshDebugAvailability"},
            {2, nullptr, "ClearDebugResponse"},
            {3, nullptr, "RegisterDebugResponse"},
-            {4, nullptr, "IsLargeResourceAvailable"},
+            {4, &NIM_ECA::IsLargeResourceAvailable, "IsLargeResourceAvailable"},
        };
        // clang-format on

@@ -231,6 +231,18 @@ private:
        rb.Push(RESULT_SUCCESS);
        rb.PushIpcInterface<IShopServiceAccessServer>(system);
    }
+
+    void IsLargeResourceAvailable(Kernel::HLERequestContext& ctx) {
+        IPC::RequestParser rp{ctx};
+
+        const auto unknown{rp.Pop<u64>()};
+
+        LOG_INFO(Service_NIM, "(STUBBED) called, unknown={}", unknown);
+
+        IPC::ResponseBuilder rb{ctx, 3};
+        rb.Push(RESULT_SUCCESS);
+        rb.Push(false);
+    }
 };

 class NIM_SHP final : public ServiceFramework<NIM_SHP> {
@@ -182,21 +182,18 @@ PL_U::PL_U(Core::System& system_)
        }

        if (!romfs) {
-            LOG_ERROR(Service_NS, "Failed to find or synthesize {:016X}! Skipping",
-                      static_cast<u64>(font.first));
+            LOG_ERROR(Service_NS, "Failed to find or synthesize {:016X}! Skipping", font.first);
            continue;
        }

        const auto extracted_romfs = FileSys::ExtractRomFS(romfs);
        if (!extracted_romfs) {
-            LOG_ERROR(Service_NS, "Failed to extract RomFS for {:016X}! Skipping",
-                      static_cast<u64>(font.first));
+            LOG_ERROR(Service_NS, "Failed to extract RomFS for {:016X}! Skipping", font.first);
            continue;
        }
        const auto font_fp = extracted_romfs->GetFile(font.second);
        if (!font_fp) {
-            LOG_ERROR(Service_NS, "{:016X} has no file \"{}\"! Skipping",
-                      static_cast<u64>(font.first), font.second);
+            LOG_ERROR(Service_NS, "{:016X} has no file \"{}\"! Skipping", font.first, font.second);
            continue;
        }
        std::vector<u32> font_data_u32(font_fp->GetSize() / sizeof(u32));
@@ -18,39 +18,6 @@ public:
    explicit nvhost_nvdec_common(Core::System& system, std::shared_ptr<nvmap> nvmap_dev);
    ~nvhost_nvdec_common() override;

-    /**
-     * Handles an ioctl1 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl1(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            IoctlCtrl& ctrl) = 0;
-
-    /**
-     * Handles an ioctl2 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param inline_input A buffer containing the input data for the ioctl which has been inlined.
-     * @param output A buffer where the output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl2(Ioctl command, const std::vector<u8>& input,
-                            const std::vector<u8>& inline_input, std::vector<u8>& output,
-                            IoctlCtrl& ctrl) = 0;
-
-    /**
-     * Handles an ioctl3 request.
-     * @param command The ioctl command id.
-     * @param input A buffer containing the input data for the ioctl.
-     * @param output A buffer where the output data will be written to.
-     * @param inline_output A buffer where the inlined output data will be written to.
-     * @returns The result code of the ioctl.
-     */
-    virtual NvResult Ioctl3(Ioctl command, const std::vector<u8>& input, std::vector<u8>& output,
-                            std::vector<u8>& inline_output, IoctlCtrl& ctrl) = 0;
-
 protected:
    class BufferMap final {
    public:
@@ -153,7 +153,7 @@ void BufferQueue::Disconnect() {
 }

 u32 BufferQueue::Query(QueryType type) {
-    LOG_WARNING(Service, "(STUBBED) called type={}", static_cast<u32>(type));
+    LOG_WARNING(Service, "(STUBBED) called type={}", type);

    switch (type) {
    case QueryType::NativeWindowFormat:
@@ -65,7 +65,7 @@ private:
        }

        LOG_DEBUG(Service_PREPO, "called, type={:02X}, process_id={:016X}, data1_size={:016X}",
-                  static_cast<u8>(Type), process_id, data[0].size());
+                  Type, process_id, data[0].size());

        const auto& reporter{system.GetReporter()};
        reporter.SavePlayReport(Type, system.CurrentProcess()->GetTitleID(), data, process_id);
@@ -92,7 +92,7 @@ private:
        LOG_DEBUG(
            Service_PREPO,
            "called, type={:02X}, user_id={:016X}{:016X}, process_id={:016X}, data1_size={:016X}",
-            static_cast<u8>(Type), user_id[1], user_id[0], process_id, data[0].size());
+            Type, user_id[1], user_id[0], process_id, data[0].size());

        const auto& reporter{system.GetReporter()};
        reporter.SavePlayReport(Type, system.CurrentProcess()->GetTitleID(), data, process_id,
@@ -181,7 +181,7 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
        break;
    }
    default:
-        UNIMPLEMENTED_MSG("command_type={}", static_cast<int>(context.GetCommandType()));
+        UNIMPLEMENTED_MSG("command_type={}", context.GetCommandType());
    }

    context.WriteToOutgoingCommandBuffer(context.GetThread());
@@ -34,9 +34,9 @@ void GetFirmwareVersionImpl(Kernel::HLERequestContext& ctx, GetFirmwareVersionTy
    // consistence (currently reports as 5.1.0-0.0)
    const auto archive = FileSys::SystemArchive::SystemVersion();

-    const auto early_exit_failure = [&ctx](const std::string& desc, ResultCode code) {
+    const auto early_exit_failure = [&ctx](std::string_view desc, ResultCode code) {
        LOG_ERROR(Service_SET, "General failure while attempting to resolve firmware version ({}).",
-                  desc.c_str());
+                  desc);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(code);
    };
@@ -30,7 +30,7 @@ bool IsConnectionBased(Type type) {
    case Type::DGRAM:
        return false;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
        return false;
    }
 }
@@ -489,18 +489,18 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::vector<u
    }

    for (PollFD& pollfd : fds) {
-        ASSERT(pollfd.revents == 0);
+        ASSERT(False(pollfd.revents));

        if (pollfd.fd > static_cast<s32>(MAX_FD) || pollfd.fd < 0) {
            LOG_ERROR(Service, "File descriptor handle={} is invalid", pollfd.fd);
-            pollfd.revents = 0;
+            pollfd.revents = PollEvents{};
            return {0, Errno::SUCCESS};
        }

        const std::optional<FileDescriptor>& descriptor = file_descriptors[pollfd.fd];
        if (!descriptor) {
            LOG_ERROR(Service, "File descriptor handle={} is not allocated", pollfd.fd);
-            pollfd.revents = POLL_NVAL;
+            pollfd.revents = PollEvents::Nval;
            return {0, Errno::SUCCESS};
        }
    }
@@ -510,7 +510,7 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::vector<u
        Network::PollFD result;
        result.socket = file_descriptors[pollfd.fd]->socket.get();
        result.events = TranslatePollEventsToHost(pollfd.events);
-        result.revents = 0;
+        result.revents = Network::PollEvents{};
        return result;
    });

@@ -636,7 +636,7 @@ std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
        return {0, Errno::SUCCESS};
    }
    default:
-        UNIMPLEMENTED_MSG("Unimplemented cmd={}", static_cast<int>(cmd));
+        UNIMPLEMENTED_MSG("Unimplemented cmd={}", cmd);
        return {-1, Errno::SUCCESS};
    }
 }
@@ -679,7 +679,7 @@ Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, size_t optlen, con
    case OptName::RCVTIMEO:
        return Translate(socket->SetRcvTimeo(value));
    default:
-        UNIMPLEMENTED_MSG("Unimplemented optname={}", static_cast<int>(optname));
+        UNIMPLEMENTED_MSG("Unimplemented optname={}", optname);
        return Errno::SUCCESS;
    }
 }
@@ -69,10 +69,22 @@ struct SockAddrIn {
    std::array<u8, 8> zeroes;
 };

+enum class PollEvents : u16 {
+    // Using Pascal case because IN is a macro on Windows.
+    In = 1 << 0,
+    Pri = 1 << 1,
+    Out = 1 << 2,
+    Err = 1 << 3,
+    Hup = 1 << 4,
+    Nval = 1 << 5,
+};
+
+DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
+
 struct PollFD {
    s32 fd;
-    u16 events;
-    u16 revents;
+    PollEvents events;
+    PollEvents revents;
 };

 struct Linger {
@@ -80,13 +92,6 @@ struct Linger {
    u32 linger;
 };

-constexpr u16 POLL_IN = 0x01;
-constexpr u16 POLL_PRI = 0x02;
-constexpr u16 POLL_OUT = 0x04;
-constexpr u16 POLL_ERR = 0x08;
-constexpr u16 POLL_HUP = 0x10;
-constexpr u16 POLL_NVAL = 0x20;
-
 constexpr u32 FLAG_MSG_DONTWAIT = 0x80;

 constexpr u32 FLAG_O_NONBLOCK = 0x800;
@@ -27,7 +27,7 @@ Errno Translate(Network::Errno value) {
    case Network::Errno::NOTCONN:
        return Errno::NOTCONN;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented errno={}", static_cast<int>(value));
+        UNIMPLEMENTED_MSG("Unimplemented errno={}", value);
        return Errno::SUCCESS;
    }
 }
@@ -41,7 +41,7 @@ Network::Domain Translate(Domain domain) {
    case Domain::INET:
        return Network::Domain::INET;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
        return {};
    }
 }
@@ -51,7 +51,7 @@ Domain Translate(Network::Domain domain) {
    case Network::Domain::INET:
        return Domain::INET;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
        return {};
    }
 }
@@ -63,7 +63,7 @@ Network::Type Translate(Type type) {
    case Type::DGRAM:
        return Network::Type::DGRAM;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
    }
 }

@@ -84,48 +84,48 @@ Network::Protocol Translate(Type type, Protocol protocol) {
    case Protocol::UDP:
        return Network::Protocol::UDP;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented protocol={}", static_cast<int>(protocol));
+        UNIMPLEMENTED_MSG("Unimplemented protocol={}", protocol);
        return Network::Protocol::TCP;
    }
 }

-u16 TranslatePollEventsToHost(u32 flags) {
-    u32 result = 0;
-    const auto translate = [&result, &flags](u32 from, u32 to) {
-        if ((flags & from) != 0) {
+Network::PollEvents TranslatePollEventsToHost(PollEvents flags) {
+    Network::PollEvents result{};
+    const auto translate = [&result, &flags](PollEvents from, Network::PollEvents to) {
+        if (True(flags & from)) {
            flags &= ~from;
            result |= to;
        }
    };
-    translate(POLL_IN, Network::POLL_IN);
-    translate(POLL_PRI, Network::POLL_PRI);
-    translate(POLL_OUT, Network::POLL_OUT);
-    translate(POLL_ERR, Network::POLL_ERR);
-    translate(POLL_HUP, Network::POLL_HUP);
-    translate(POLL_NVAL, Network::POLL_NVAL);
+    translate(PollEvents::In, Network::PollEvents::In);
+    translate(PollEvents::Pri, Network::PollEvents::Pri);
+    translate(PollEvents::Out, Network::PollEvents::Out);
+    translate(PollEvents::Err, Network::PollEvents::Err);
+    translate(PollEvents::Hup, Network::PollEvents::Hup);
+    translate(PollEvents::Nval, Network::PollEvents::Nval);

-    UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags);
-    return static_cast<u16>(result);
+    UNIMPLEMENTED_IF_MSG((u16)flags != 0, "Unimplemented flags={}", (u16)flags);
+    return result;
 }

-u16 TranslatePollEventsToGuest(u32 flags) {
-    u32 result = 0;
-    const auto translate = [&result, &flags](u32 from, u32 to) {
-        if ((flags & from) != 0) {
+PollEvents TranslatePollEventsToGuest(Network::PollEvents flags) {
+    PollEvents result{};
+    const auto translate = [&result, &flags](Network::PollEvents from, PollEvents to) {
+        if (True(flags & from)) {
            flags &= ~from;
            result |= to;
        }
    };

-    translate(Network::POLL_IN, POLL_IN);
-    translate(Network::POLL_PRI, POLL_PRI);
-    translate(Network::POLL_OUT, POLL_OUT);
-    translate(Network::POLL_ERR, POLL_ERR);
-    translate(Network::POLL_HUP, POLL_HUP);
-    translate(Network::POLL_NVAL, POLL_NVAL);
+    translate(Network::PollEvents::In, PollEvents::In);
+    translate(Network::PollEvents::Pri, PollEvents::Pri);
+    translate(Network::PollEvents::Out, PollEvents::Out);
+    translate(Network::PollEvents::Err, PollEvents::Err);
+    translate(Network::PollEvents::Hup, PollEvents::Hup);
+    translate(Network::PollEvents::Nval, PollEvents::Nval);

-    UNIMPLEMENTED_IF_MSG(flags != 0, "Unimplemented flags={}", flags);
-    return static_cast<u16>(result);
+    UNIMPLEMENTED_IF_MSG((u16)flags != 0, "Unimplemented flags={}", (u16)flags);
+    return result;
 }

 Network::SockAddrIn Translate(SockAddrIn value) {
@@ -157,7 +157,7 @@ Network::ShutdownHow Translate(ShutdownHow how) {
    case ShutdownHow::RDWR:
        return Network::ShutdownHow::RDWR;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented how={}", static_cast<int>(how));
+        UNIMPLEMENTED_MSG("Unimplemented how={}", how);
        return {};
    }
 }
@@ -31,10 +31,10 @@ Network::Type Translate(Type type);
 Network::Protocol Translate(Type type, Protocol protocol);

 /// Translate abstract poll event flags to guest poll event flags
-u16 TranslatePollEventsToHost(u32 flags);
+Network::PollEvents TranslatePollEventsToHost(PollEvents flags);

 /// Translate guest poll event flags to abstract poll event flags
-u16 TranslatePollEventsToGuest(u32 flags);
+PollEvents TranslatePollEventsToGuest(Network::PollEvents flags);

 /// Translate guest socket address structure to abstract socket address structure
 Network::SockAddrIn Translate(SockAddrIn value);
@@ -528,7 +528,7 @@ private:
        const u32 flags = rp.Pop<u32>();

        LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
-                  static_cast<u32>(transaction), flags);
+                  transaction, flags);

        const auto guard = nv_flinger.Lock();
        auto& buffer_queue = nv_flinger.FindBufferQueue(id);
@@ -1066,8 +1066,8 @@ private:
        const auto scaling_mode = rp.PopEnum<NintendoScaleMode>();
        const u64 unknown = rp.Pop<u64>();

-        LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}",
-                  static_cast<u32>(scaling_mode), unknown);
+        LOG_DEBUG(Service_VI, "called. scaling_mode=0x{:08X}, unknown=0x{:016X}", scaling_mode,
+                  unknown);

        IPC::ResponseBuilder rb{ctx, 2};

@@ -1210,7 +1210,7 @@ private:
    void ConvertScalingMode(Kernel::HLERequestContext& ctx) {
        IPC::RequestParser rp{ctx};
        const auto mode = rp.PopEnum<NintendoScaleMode>();
-        LOG_DEBUG(Service_VI, "called mode={}", static_cast<u32>(mode));
+        LOG_DEBUG(Service_VI, "called mode={}", mode);

        const auto converted_mode = ConvertScalingModeImpl(mode);

@@ -1230,8 +1230,8 @@ private:
        const auto height = rp.Pop<u64>();
        LOG_DEBUG(Service_VI, "called width={}, height={}", width, height);

-        constexpr std::size_t base_size = 0x20000;
-        constexpr std::size_t alignment = 0x1000;
+        constexpr u64 base_size = 0x20000;
+        constexpr u64 alignment = 0x1000;
        const auto texture_size = width * height * 4;
        const auto out_size = (texture_size + base_size - 1) / base_size * base_size;

@@ -1311,7 +1311,7 @@ void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, Core::System&
    const auto policy = rp.PopEnum<Policy>();

    if (!IsValidServiceAccess(permission, policy)) {
-        LOG_ERROR(Service_VI, "Permission denied for policy {}", static_cast<u32>(policy));
+        LOG_ERROR(Service_VI, "Permission denied for policy {}", policy);
        IPC::ResponseBuilder rb{ctx, 2};
        rb.Push(ERR_PERMISSION_DENIED);
        return;
@@ -32,7 +32,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -21,7 +21,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -23,7 +23,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -28,7 +28,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -28,7 +28,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -32,7 +32,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -75,7 +75,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -34,7 +34,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -34,7 +34,7 @@ public:

    /**
     * Returns the type of the file
-     * @param file std::shared_ptr<VfsFile> open file
+     * @param file open file
     * @return FileType found, or FileType::Error if this loader doesn't know it
     */
    static FileType IdentifyType(const FileSys::VirtualFile& file);
@@ -4,6 +4,7 @@

 #include <algorithm>
 #include <cstring>
+#include <mutex>
 #include <optional>
 #include <utility>

@@ -31,6 +32,7 @@ struct Memory::Impl {
    explicit Impl(Core::System& system_) : system{system_} {}

    void SetCurrentPageTable(Kernel::Process& process, u32 core_id) {
+        std::lock_guard<std::mutex> lock(page_table_guard);
        current_page_table = &process.PageTable().PageTableImpl();

        const std::size_t address_space_width = process.PageTable().GetAddressSpaceWidth();
@@ -38,6 +40,11 @@ struct Memory::Impl {
        system.ArmInterface(core_id).PageTableChanged(*current_page_table, address_space_width);
    }

+    Common::PageTable& CurrentPageTable() {
+        std::lock_guard<std::mutex> lock(page_table_guard);
+        return *current_page_table;
+    }
+
    void MapMemoryRegion(Common::PageTable& page_table, VAddr base, u64 size, PAddr target) {
        ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:016X}", size);
        ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:016X}", base);
@@ -65,31 +72,30 @@ struct Memory::Impl {
        UNIMPLEMENTED();
    }

-    bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) const {
-        const auto& page_table = process.PageTable().PageTableImpl();
+    bool IsValidVirtualAddress(Kernel::Process& process, const VAddr vaddr) {
+        const auto entry = process.PageTable().PageTableImpl().GetEntry(vaddr >> PAGE_BITS);

-        const u8* const page_pointer = page_table.pointers[vaddr >> PAGE_BITS];
-        if (page_pointer != nullptr) {
+        if (entry.pointer != nullptr) {
            return true;
        }

-        if (page_table.attributes[vaddr >> PAGE_BITS] == Common::PageType::RasterizerCachedMemory) {
+        if (entry.attribute == Common::PageType::RasterizerCachedMemory) {
            return true;
        }

-        if (page_table.attributes[vaddr >> PAGE_BITS] != Common::PageType::Special) {
+        if (entry.attribute != Common::PageType::Special) {
            return false;
        }

        return false;
    }

-    bool IsValidVirtualAddress(VAddr vaddr) const {
+    bool IsValidVirtualAddress(VAddr vaddr) {
        return IsValidVirtualAddress(*system.CurrentProcess(), vaddr);
    }

-    u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) const {
-        const PAddr paddr{current_page_table->backing_addr[vaddr >> PAGE_BITS]};
+    u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) {
+        const PAddr paddr{CurrentPageTable().GetBackingAddr(vaddr >> PAGE_BITS)};

        if (!paddr) {
            return {};
@@ -98,14 +104,23 @@ struct Memory::Impl {
        return system.DeviceMemory().GetPointer(paddr) + vaddr;
    }

-    u8* GetPointer(const VAddr vaddr) const {
-        u8* const page_pointer{current_page_table->pointers[vaddr >> PAGE_BITS]};
-        if (page_pointer) {
-            return page_pointer + vaddr;
+    u8* GetPointerFromRasterizerCachedMemoryUnsafe(VAddr vaddr) {
+        const PAddr paddr{current_page_table->GetBackingAddr(vaddr >> PAGE_BITS)};
+
+        if (!paddr) {
+            return {};
        }

-        if (current_page_table->attributes[vaddr >> PAGE_BITS] ==
-            Common::PageType::RasterizerCachedMemory) {
+        return system.DeviceMemory().GetPointer(paddr) + vaddr;
+    }
+
+    u8* GetPointer(const VAddr vaddr) {
+        const auto entry = CurrentPageTable().GetEntry(vaddr >> PAGE_BITS);
+        if (entry.pointer) {
+            return entry.pointer + vaddr;
+        }
+
+        if (entry.attribute == Common::PageType::RasterizerCachedMemory) {
            return GetPointerFromRasterizerCachedMemory(vaddr);
        }

@@ -208,9 +223,9 @@ struct Memory::Impl {
        return string;
    }

-    void ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
+    void ReadBlock(Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
                   const std::size_t size) {
-        const auto& page_table = process.PageTable().PageTableImpl();
+        auto& page_table = process.PageTable().PageTableImpl();

        std::size_t remaining_size = size;
        std::size_t page_index = src_addr >> PAGE_BITS;
@@ -220,8 +235,9 @@ struct Memory::Impl {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto entry = page_table.GetEntry(page_index);

-            switch (page_table.attributes[page_index]) {
+            switch (entry.attribute) {
            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
@@ -232,8 +248,7 @@ struct Memory::Impl {
            case Common::PageType::Memory: {
                DEBUG_ASSERT(page_table.pointers[page_index]);

-                const u8* const src_ptr =
-                    page_table.pointers[page_index] + page_offset + (page_index << PAGE_BITS);
+                const u8* const src_ptr = entry.pointer + page_offset + (page_index << PAGE_BITS);
                std::memcpy(dest_buffer, src_ptr, copy_amount);
                break;
            }
@@ -254,9 +269,9 @@ struct Memory::Impl {
        }
    }

-    void ReadBlockUnsafe(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
+    void ReadBlockUnsafe(Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
                         const std::size_t size) {
-        const auto& page_table = process.PageTable().PageTableImpl();
+        auto& page_table = process.PageTable().PageTableImpl();

        std::size_t remaining_size = size;
        std::size_t page_index = src_addr >> PAGE_BITS;
@@ -266,8 +281,9 @@ struct Memory::Impl {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto entry = page_table.GetEntry(page_index);

-            switch (page_table.attributes[page_index]) {
+            switch (entry.attribute) {
            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
@@ -278,8 +294,7 @@ struct Memory::Impl {
            case Common::PageType::Memory: {
                DEBUG_ASSERT(page_table.pointers[page_index]);

-                const u8* const src_ptr =
-                    page_table.pointers[page_index] + page_offset + (page_index << PAGE_BITS);
+                const u8* const src_ptr = entry.pointer + page_offset + (page_index << PAGE_BITS);
                std::memcpy(dest_buffer, src_ptr, copy_amount);
                break;
            }
@@ -307,9 +322,9 @@ struct Memory::Impl {
        ReadBlockUnsafe(*system.CurrentProcess(), src_addr, dest_buffer, size);
    }

-    void WriteBlock(const Kernel::Process& process, const VAddr dest_addr, const void* src_buffer,
+    void WriteBlock(Kernel::Process& process, const VAddr dest_addr, const void* src_buffer,
                    const std::size_t size) {
-        const auto& page_table = process.PageTable().PageTableImpl();
+        auto& page_table = process.PageTable().PageTableImpl();
        std::size_t remaining_size = size;
        std::size_t page_index = dest_addr >> PAGE_BITS;
        std::size_t page_offset = dest_addr & PAGE_MASK;
@@ -318,8 +333,9 @@ struct Memory::Impl {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto entry = page_table.GetEntry(page_index);

-            switch (page_table.attributes[page_index]) {
+            switch (entry.attribute) {
            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
@@ -329,8 +345,7 @@ struct Memory::Impl {
            case Common::PageType::Memory: {
                DEBUG_ASSERT(page_table.pointers[page_index]);

-                u8* const dest_ptr =
-                    page_table.pointers[page_index] + page_offset + (page_index << PAGE_BITS);
+                u8* const dest_ptr = entry.pointer + page_offset + (page_index << PAGE_BITS);
                std::memcpy(dest_ptr, src_buffer, copy_amount);
                break;
            }
@@ -351,9 +366,9 @@ struct Memory::Impl {
        }
    }

-    void WriteBlockUnsafe(const Kernel::Process& process, const VAddr dest_addr,
-                          const void* src_buffer, const std::size_t size) {
-        const auto& page_table = process.PageTable().PageTableImpl();
+    void WriteBlockUnsafe(Kernel::Process& process, const VAddr dest_addr, const void* src_buffer,
+                          const std::size_t size) {
+        auto& page_table = process.PageTable().PageTableImpl();
        std::size_t remaining_size = size;
        std::size_t page_index = dest_addr >> PAGE_BITS;
        std::size_t page_offset = dest_addr & PAGE_MASK;
@@ -362,8 +377,9 @@ struct Memory::Impl {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto entry = page_table.GetEntry(page_index);

-            switch (page_table.attributes[page_index]) {
+            switch (entry.attribute) {
            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
@@ -373,8 +389,7 @@ struct Memory::Impl {
            case Common::PageType::Memory: {
                DEBUG_ASSERT(page_table.pointers[page_index]);

-                u8* const dest_ptr =
-                    page_table.pointers[page_index] + page_offset + (page_index << PAGE_BITS);
+                u8* const dest_ptr = entry.pointer + page_offset + (page_index << PAGE_BITS);
                std::memcpy(dest_ptr, src_buffer, copy_amount);
                break;
            }
@@ -402,8 +417,8 @@ struct Memory::Impl {
        WriteBlockUnsafe(*system.CurrentProcess(), dest_addr, src_buffer, size);
    }

-    void ZeroBlock(const Kernel::Process& process, const VAddr dest_addr, const std::size_t size) {
-        const auto& page_table = process.PageTable().PageTableImpl();
+    void ZeroBlock(Kernel::Process& process, const VAddr dest_addr, const std::size_t size) {
+        auto& page_table = process.PageTable().PageTableImpl();
        std::size_t remaining_size = size;
        std::size_t page_index = dest_addr >> PAGE_BITS;
        std::size_t page_offset = dest_addr & PAGE_MASK;
@@ -412,8 +427,9 @@ struct Memory::Impl {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto entry = page_table.GetEntry(page_index);

-            switch (page_table.attributes[page_index]) {
+            switch (entry.attribute) {
            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped ZeroBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
@@ -423,8 +439,7 @@ struct Memory::Impl {
            case Common::PageType::Memory: {
                DEBUG_ASSERT(page_table.pointers[page_index]);

-                u8* dest_ptr =
-                    page_table.pointers[page_index] + page_offset + (page_index << PAGE_BITS);
+                u8* dest_ptr = entry.pointer + page_offset + (page_index << PAGE_BITS);
                std::memset(dest_ptr, 0, copy_amount);
                break;
            }
@@ -448,9 +463,9 @@ struct Memory::Impl {
        ZeroBlock(*system.CurrentProcess(), dest_addr, size);
    }

-    void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
+    void CopyBlock(Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
                   const std::size_t size) {
-        const auto& page_table = process.PageTable().PageTableImpl();
+        auto& page_table = process.PageTable().PageTableImpl();
        std::size_t remaining_size = size;
        std::size_t page_index = src_addr >> PAGE_BITS;
        std::size_t page_offset = src_addr & PAGE_MASK;
@@ -459,8 +474,9 @@ struct Memory::Impl {
            const std::size_t copy_amount =
                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+            const auto entry = page_table.GetEntry(page_index);

-            switch (page_table.attributes[page_index]) {
+            switch (entry.attribute) {
            case Common::PageType::Unmapped: {
                LOG_ERROR(HW_Memory,
                          "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
@@ -470,8 +486,7 @@ struct Memory::Impl {
            }
            case Common::PageType::Memory: {
                DEBUG_ASSERT(page_table.pointers[page_index]);
-                const u8* src_ptr =
-                    page_table.pointers[page_index] + page_offset + (page_index << PAGE_BITS);
+                const u8* src_ptr = entry.pointer + page_offset + (page_index << PAGE_BITS);
                WriteBlock(process, dest_addr, src_ptr, copy_amount);
                break;
            }
@@ -507,20 +522,25 @@ struct Memory::Impl {
        // granularity of CPU pages, hence why we iterate on a CPU page basis (note: GPU page size
        // is different). This assumes the specified GPU address region is contiguous as well.

-        u64 num_pages = ((vaddr + size - 1) >> PAGE_BITS) - (vaddr >> PAGE_BITS) + 1;
+        const u64 num_pages = ((vaddr + size - 1) >> PAGE_BITS) - (vaddr >> PAGE_BITS) + 1;
+        std::lock_guard<std::mutex> lock(page_table_guard);
+
        for (unsigned i = 0; i < num_pages; ++i, vaddr += PAGE_SIZE) {
-            Common::PageType& page_type{current_page_table->attributes[vaddr >> PAGE_BITS]};
+            const auto base = vaddr >> PAGE_BITS;
+            auto entry = current_page_table->GetEntry(base);

            if (cached) {
                // Switch page type to cached if now cached
-                switch (page_type) {
+                switch (entry.attribute) {
                case Common::PageType::Unmapped:
                    // It is not necessary for a process to have this region mapped into its address
                    // space, for example, a system module need not have a VRAM mapping.
                    break;
                case Common::PageType::Memory:
-                    page_type = Common::PageType::RasterizerCachedMemory;
-                    current_page_table->pointers[vaddr >> PAGE_BITS] = nullptr;
+                    current_page_table->SetEntry(
+                        base, {.pointer = nullptr,
+                               .backing_addr = entry.backing_addr,
+                               .attribute = Common::PageType::RasterizerCachedMemory});
                    break;
                case Common::PageType::RasterizerCachedMemory:
                    // There can be more than one GPU region mapped per CPU region, so it's common
@@ -531,7 +551,7 @@ struct Memory::Impl {
                }
            } else {
                // Switch page type to uncached if now uncached
-                switch (page_type) {
+                switch (entry.attribute) {
                case Common::PageType::Unmapped:
                    // It is not necessary for a process to have this region mapped into its address
                    // space, for example, a system module need not have a VRAM mapping.
@@ -541,16 +561,20 @@ struct Memory::Impl {
                    // that this area is already unmarked as cached.
                    break;
                case Common::PageType::RasterizerCachedMemory: {
-                    u8* pointer{GetPointerFromRasterizerCachedMemory(vaddr & ~PAGE_MASK)};
+                    u8* pointer{GetPointerFromRasterizerCachedMemoryUnsafe(vaddr & ~PAGE_MASK)};
                    if (pointer == nullptr) {
                        // It's possible that this function has been called while updating the
                        // pagetable after unmapping a VMA. In that case the underlying VMA will no
                        // longer exist, and we should just leave the pagetable entry blank.
-                        page_type = Common::PageType::Unmapped;
+                        current_page_table->SetEntry(base,
+                                                     {.pointer = nullptr,
+                                                      .backing_addr = entry.backing_addr,
+                                                      .attribute = Common::PageType::Unmapped});
                    } else {
-                        current_page_table->pointers[vaddr >> PAGE_BITS] =
-                            pointer - (vaddr & ~PAGE_MASK);
-                        page_type = Common::PageType::Memory;
+                        current_page_table->SetEntry(base,
+                                                     {.pointer = pointer - (vaddr & ~PAGE_MASK),
+                                                      .backing_addr = entry.backing_addr,
+                                                      .attribute = Common::PageType::Memory});
                    }
                    break;
                }
@@ -580,37 +604,29 @@ struct Memory::Impl {
            auto& gpu = system.GPU();
            for (u64 i = 0; i < size; i++) {
                const auto page = base + i;
-                if (page_table.attributes[page] == Common::PageType::RasterizerCachedMemory) {
+                if (page_table.GetEntry(page).attribute ==
+                    Common::PageType::RasterizerCachedMemory) {
                    gpu.FlushAndInvalidateRegion(page << PAGE_BITS, PAGE_SIZE);
                }
            }
        }

        const VAddr end = base + size;
-        ASSERT_MSG(end <= page_table.pointers.size(), "out of range mapping at {:016X}",
-                   base + page_table.pointers.size());
-
        if (!target) {
            ASSERT_MSG(type != Common::PageType::Memory,
                       "Mapping memory page without a pointer @ {:016x}", base * PAGE_SIZE);

            while (base != end) {
-                page_table.attributes[base] = type;
-                page_table.pointers[base] = nullptr;
-                page_table.backing_addr[base] = 0;
-
+                page_table.SetEntry(base,
+                                    {.pointer = nullptr, .backing_addr = 0, .attribute = type});
                base += 1;
            }
        } else {
            while (base != end) {
-                page_table.pointers[base] =
-                    system.DeviceMemory().GetPointer(target) - (base << PAGE_BITS);
-                page_table.attributes[base] = type;
-                page_table.backing_addr[base] = target - (base << PAGE_BITS);
-
-                ASSERT_MSG(page_table.pointers[base],
-                           "memory mapping base yield a nullptr within the table");
-
+                page_table.SetEntry(base, {.pointer = system.DeviceMemory().GetPointer(target) -
+                                                      (base << PAGE_BITS),
+                                           .backing_addr = target - (base << PAGE_BITS),
+                                           .attribute = type});
                base += 1;
                target += PAGE_SIZE;
            }
@@ -630,16 +646,15 @@ struct Memory::Impl {
     */
    template <typename T>
    T Read(const VAddr vaddr) {
-        const u8* const page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
-        if (page_pointer != nullptr) {
+        const auto entry = CurrentPageTable().GetEntry(vaddr >> PAGE_BITS);
+        if (entry.pointer != nullptr) {
            // NOTE: Avoid adding any extra logic to this fast-path block
            T value;
-            std::memcpy(&value, &page_pointer[vaddr], sizeof(T));
+            std::memcpy(&value, &entry.pointer[vaddr], sizeof(T));
            return value;
        }

-        const Common::PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
-        switch (type) {
+        switch (entry.attribute) {
        case Common::PageType::Unmapped:
            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
            return 0;
@@ -667,20 +682,18 @@ struct Memory::Impl {
     * @tparam T The data type to write to memory. This type *must* be
     *           trivially copyable, otherwise the behavior of this function
     *           is undefined.
-     *
-     * @returns The instance of T write to the specified virtual address.
     */
    template <typename T>
    void Write(const VAddr vaddr, const T data) {
-        u8* const page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
-        if (page_pointer != nullptr) {
+        const auto entry = CurrentPageTable().GetEntry(vaddr >> PAGE_BITS);
+
+        if (entry.pointer != nullptr) {
            // NOTE: Avoid adding any extra logic to this fast-path block
-            std::memcpy(&page_pointer[vaddr], &data, sizeof(T));
+            std::memcpy(&entry.pointer[vaddr], &data, sizeof(T));
            return;
        }

-        const Common::PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
-        switch (type) {
+        switch (entry.attribute) {
        case Common::PageType::Unmapped:
            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
                      static_cast<u32>(data), vaddr);
@@ -701,15 +714,15 @@ struct Memory::Impl {

    template <typename T>
    bool WriteExclusive(const VAddr vaddr, const T data, const T expected) {
-        u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
-        if (page_pointer != nullptr) {
+        const auto entry = CurrentPageTable().GetEntry(vaddr >> PAGE_BITS);
+
+        if (entry.pointer != nullptr) {
            // NOTE: Avoid adding any extra logic to this fast-path block
-            auto* pointer = reinterpret_cast<volatile T*>(&page_pointer[vaddr]);
+            auto* pointer = reinterpret_cast<volatile T*>(&entry.pointer[vaddr]);
            return Common::AtomicCompareAndSwap(pointer, data, expected);
        }

-        const Common::PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
-        switch (type) {
+        switch (entry.attribute) {
        case Common::PageType::Unmapped:
            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
                      static_cast<u32>(data), vaddr);
@@ -730,15 +743,14 @@ struct Memory::Impl {
    }

    bool WriteExclusive128(const VAddr vaddr, const u128 data, const u128 expected) {
-        u8* const page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
-        if (page_pointer != nullptr) {
+        const auto entry = CurrentPageTable().GetEntry(vaddr >> PAGE_BITS);
+        if (entry.pointer != nullptr) {
            // NOTE: Avoid adding any extra logic to this fast-path block
-            auto* pointer = reinterpret_cast<volatile u64*>(&page_pointer[vaddr]);
+            auto* pointer = reinterpret_cast<volatile u64*>(&entry.pointer[vaddr]);
            return Common::AtomicCompareAndSwap(pointer, data, expected);
        }

-        const Common::PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
-        switch (type) {
+        switch (entry.attribute) {
        case Common::PageType::Unmapped:
            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}{:016X}", sizeof(data) * 8,
                      static_cast<u64>(data[1]), static_cast<u64>(data[0]), vaddr);
@@ -759,6 +771,7 @@ struct Memory::Impl {
    }

    Common::PageTable* current_page_table = nullptr;
+    std::mutex page_table_guard;
    Core::System& system;
 };

@@ -792,7 +805,7 @@ void Memory::RemoveDebugHook(Common::PageTable& page_table, VAddr base, u64 size
    impl->RemoveDebugHook(page_table, base, size, std::move(hook));
 }

-bool Memory::IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) const {
+bool Memory::IsValidVirtualAddress(Kernel::Process& process, const VAddr vaddr) const {
    return impl->IsValidVirtualAddress(process, vaddr);
 }

@@ -864,7 +877,7 @@ std::string Memory::ReadCString(VAddr vaddr, std::size_t max_length) {
    return impl->ReadCString(vaddr, max_length);
 }

-void Memory::ReadBlock(const Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
+void Memory::ReadBlock(Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
                       const std::size_t size) {
    impl->ReadBlock(process, src_addr, dest_buffer, size);
 }
@@ -873,8 +886,8 @@ void Memory::ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_
    impl->ReadBlock(src_addr, dest_buffer, size);
 }

-void Memory::ReadBlockUnsafe(const Kernel::Process& process, const VAddr src_addr,
-                             void* dest_buffer, const std::size_t size) {
+void Memory::ReadBlockUnsafe(Kernel::Process& process, const VAddr src_addr, void* dest_buffer,
+                             const std::size_t size) {
    impl->ReadBlockUnsafe(process, src_addr, dest_buffer, size);
 }

@@ -882,7 +895,7 @@ void Memory::ReadBlockUnsafe(const VAddr src_addr, void* dest_buffer, const std:
    impl->ReadBlockUnsafe(src_addr, dest_buffer, size);
 }

-void Memory::WriteBlock(const Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
+void Memory::WriteBlock(Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
                        std::size_t size) {
    impl->WriteBlock(process, dest_addr, src_buffer, size);
 }
@@ -891,8 +904,8 @@ void Memory::WriteBlock(const VAddr dest_addr, const void* src_buffer, const std
    impl->WriteBlock(dest_addr, src_buffer, size);
 }

-void Memory::WriteBlockUnsafe(const Kernel::Process& process, VAddr dest_addr,
-                              const void* src_buffer, std::size_t size) {
+void Memory::WriteBlockUnsafe(Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
+                              std::size_t size) {
    impl->WriteBlockUnsafe(process, dest_addr, src_buffer, size);
 }

@@ -901,7 +914,7 @@ void Memory::WriteBlockUnsafe(const VAddr dest_addr, const void* src_buffer,
    impl->WriteBlockUnsafe(dest_addr, src_buffer, size);
 }

-void Memory::ZeroBlock(const Kernel::Process& process, VAddr dest_addr, std::size_t size) {
+void Memory::ZeroBlock(Kernel::Process& process, VAddr dest_addr, std::size_t size) {
    impl->ZeroBlock(process, dest_addr, size);
 }

@@ -909,7 +922,7 @@ void Memory::ZeroBlock(VAddr dest_addr, std::size_t size) {
    impl->ZeroBlock(dest_addr, size);
 }

-void Memory::CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
+void Memory::CopyBlock(Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
                       const std::size_t size) {
    impl->CopyBlock(process, dest_addr, src_addr, size);
 }
@@ -11,7 +11,7 @@
 #include "common/memory_hook.h"

 namespace Common {
-struct PageTable;
+class PageTable;
 }

 namespace Core {
@@ -128,7 +128,7 @@ public:
     *
     * @returns True if the given virtual address is valid, false otherwise.
     */
-    bool IsValidVirtualAddress(const Kernel::Process& process, VAddr vaddr) const;
+    bool IsValidVirtualAddress(Kernel::Process& process, VAddr vaddr) const;

    /**
     * Checks whether or not the supplied address is a valid virtual
@@ -343,8 +343,7 @@ public:
     * @post The range [dest_buffer, size) contains the read bytes from the
     *       process' address space.
     */
-    void ReadBlock(const Kernel::Process& process, VAddr src_addr, void* dest_buffer,
-                   std::size_t size);
+    void ReadBlock(Kernel::Process& process, VAddr src_addr, void* dest_buffer, std::size_t size);

    /**
     * Reads a contiguous block of bytes from a specified process' address space.
@@ -364,7 +363,7 @@ public:
     * @post The range [dest_buffer, size) contains the read bytes from the
     *       process' address space.
     */
-    void ReadBlockUnsafe(const Kernel::Process& process, VAddr src_addr, void* dest_buffer,
+    void ReadBlockUnsafe(Kernel::Process& process, VAddr src_addr, void* dest_buffer,
                         std::size_t size);

    /**
@@ -424,7 +423,7 @@ public:
     *       and will mark that region as invalidated to caches that the active
     *       graphics backend may be maintaining over the course of execution.
     */
-    void WriteBlock(const Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
+    void WriteBlock(Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
                    std::size_t size);

    /**
@@ -444,7 +443,7 @@ public:
     *       will be ignored and an error will be logged.
     *
     */
-    void WriteBlockUnsafe(const Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
+    void WriteBlockUnsafe(Kernel::Process& process, VAddr dest_addr, const void* src_buffer,
                          std::size_t size);

    /**
@@ -496,7 +495,7 @@ public:
     * @post The range [dest_addr, size) within the process' address space is
     *       filled with zeroes.
     */
-    void ZeroBlock(const Kernel::Process& process, VAddr dest_addr, std::size_t size);
+    void ZeroBlock(Kernel::Process& process, VAddr dest_addr, std::size_t size);

    /**
     * Fills the specified address range within the current process' address space with zeroes.
@@ -521,8 +520,7 @@ public:
     * @post The range [dest_addr, size) within the process' address space contains the
     *       same data within the range [src_addr, size).
     */
-    void CopyBlock(const Kernel::Process& process, VAddr dest_addr, VAddr src_addr,
-                   std::size_t size);
+    void CopyBlock(Kernel::Process& process, VAddr dest_addr, VAddr src_addr, std::size_t size);

    /**
     * Copies data within the current process' address space to another location within the
@@ -11,7 +11,7 @@
 #ifdef _WIN32
 #define _WINSOCK_DEPRECATED_NO_WARNINGS // gethostname
 #include <winsock2.h>
-#elif __unix__
+#elif YUZU_UNIX
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
@@ -54,7 +54,7 @@ constexpr IPv4Address TranslateIPv4(in_addr addr) {
 sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
    sockaddr_in result;

-#ifdef __unix__
+#if YUZU_UNIX
    result.sin_len = sizeof(result);
 #endif

@@ -63,7 +63,7 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
        result.sin_family = AF_INET;
        break;
    default:
-        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", static_cast<int>(input.family));
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", input.family);
        result.sin_family = AF_INET;
        break;
    }
@@ -99,7 +99,7 @@ bool EnableNonBlock(SOCKET fd, bool enable) {
    return ioctlsocket(fd, FIONBIO, &value) != SOCKET_ERROR;
 }

-#elif __unix__ // ^ _WIN32 v __unix__
+#elif YUZU_UNIX // ^ _WIN32 v YUZU_UNIX

 using SOCKET = int;
 using WSAPOLLFD = pollfd;
@@ -133,7 +133,7 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
        result.sin_family = AF_INET;
        break;
    default:
-        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", static_cast<int>(input.family));
+        UNIMPLEMENTED_MSG("Unhandled sockaddr family={}", input.family);
        result.sin_family = AF_INET;
        break;
    }
@@ -186,7 +186,7 @@ int TranslateDomain(Domain domain) {
    case Domain::INET:
        return AF_INET;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented domain={}", static_cast<int>(domain));
+        UNIMPLEMENTED_MSG("Unimplemented domain={}", domain);
        return 0;
    }
 }
@@ -198,7 +198,7 @@ int TranslateType(Type type) {
    case Type::DGRAM:
        return SOCK_DGRAM;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented type={}", static_cast<int>(type));
+        UNIMPLEMENTED_MSG("Unimplemented type={}", type);
        return 0;
    }
 }
@@ -210,7 +210,7 @@ int TranslateProtocol(Protocol protocol) {
    case Protocol::UDP:
        return IPPROTO_UDP;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented protocol={}", static_cast<int>(protocol));
+        UNIMPLEMENTED_MSG("Unimplemented protocol={}", protocol);
        return 0;
    }
 }
@@ -238,49 +238,49 @@ SockAddrIn TranslateToSockAddrIn(sockaddr input_) {
    return result;
 }

-u16 TranslatePollEvents(u32 events) {
-    u32 result = 0;
+short TranslatePollEvents(PollEvents events) {
+    short result = 0;

-    if ((events & POLL_IN) != 0) {
-        events &= ~POLL_IN;
+    if (True(events & PollEvents::In)) {
+        events &= ~PollEvents::In;
        result |= POLLIN;
    }
-    if ((events & POLL_PRI) != 0) {
-        events &= ~POLL_PRI;
+    if (True(events & PollEvents::Pri)) {
+        events &= ~PollEvents::Pri;
 #ifdef _WIN32
        LOG_WARNING(Service, "Winsock doesn't support POLLPRI");
 #else
-        result |= POLL_PRI;
+        result |= POLLPRI;
 #endif
    }
-    if ((events & POLL_OUT) != 0) {
-        events &= ~POLL_OUT;
+    if (True(events & PollEvents::Out)) {
+        events &= ~PollEvents::Out;
        result |= POLLOUT;
    }

-    UNIMPLEMENTED_IF_MSG(events != 0, "Unhandled guest events=0x{:x}", events);
+    UNIMPLEMENTED_IF_MSG((u16)events != 0, "Unhandled guest events=0x{:x}", (u16)events);

-    return static_cast<u16>(result);
+    return result;
 }

-u16 TranslatePollRevents(u32 revents) {
-    u32 result = 0;
-    const auto translate = [&result, &revents](u32 host, u32 guest) {
+PollEvents TranslatePollRevents(short revents) {
+    PollEvents result{};
+    const auto translate = [&result, &revents](short host, PollEvents guest) {
        if ((revents & host) != 0) {
-            revents &= ~host;
+            revents &= static_cast<short>(~host);
            result |= guest;
        }
    };

-    translate(POLLIN, POLL_IN);
-    translate(POLLPRI, POLL_PRI);
-    translate(POLLOUT, POLL_OUT);
-    translate(POLLERR, POLL_ERR);
-    translate(POLLHUP, POLL_HUP);
+    translate(POLLIN, PollEvents::In);
+    translate(POLLPRI, PollEvents::Pri);
+    translate(POLLOUT, PollEvents::Out);
+    translate(POLLERR, PollEvents::Err);
+    translate(POLLHUP, PollEvents::Hup);

    UNIMPLEMENTED_IF_MSG(revents != 0, "Unhandled host revents=0x{:x}", revents);

-    return static_cast<u16>(result);
+    return result;
 }

 template <typename T>
@@ -350,7 +350,7 @@ std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {
    }

    for (size_t i = 0; i < num; ++i) {
-        pollfds[i].revents = TranslatePollRevents(static_cast<u32>(host_pollfds[i].revents));
+        pollfds[i].revents = TranslatePollRevents(host_pollfds[i].revents);
    }

    if (result > 0) {
@@ -482,7 +482,7 @@ Errno Socket::Shutdown(ShutdownHow how) {
        host_how = SD_BOTH;
        break;
    default:
-        UNIMPLEMENTED_MSG("Unimplemented flag how={}", static_cast<int>(how));
+        UNIMPLEMENTED_MSG("Unimplemented flag how={}", how);
        return Errno::SUCCESS;
    }
    if (shutdown(fd, host_how) != SOCKET_ERROR) {
@@ -61,18 +61,24 @@ struct SockAddrIn {
 };

 /// Cross-platform poll fd structure
-struct PollFD {
-    Socket* socket;
-    u16 events;
-    u16 revents;
+
+enum class PollEvents : u16 {
+    // Using Pascal case because IN is a macro on Windows.
+    In = 1 << 0,
+    Pri = 1 << 1,
+    Out = 1 << 2,
+    Err = 1 << 3,
+    Hup = 1 << 4,
+    Nval = 1 << 5,
 };

-constexpr u16 POLL_IN = 1 << 0;
-constexpr u16 POLL_PRI = 1 << 1;
-constexpr u16 POLL_OUT = 1 << 2;
-constexpr u16 POLL_ERR = 1 << 3;
-constexpr u16 POLL_HUP = 1 << 4;
-constexpr u16 POLL_NVAL = 1 << 5;
+DECLARE_ENUM_FLAG_OPERATORS(PollEvents);
+
+struct PollFD {
+    Socket* socket;
+    PollEvents events;
+    PollEvents revents;
+};

 class NetworkInstance {
 public:
@@ -9,7 +9,7 @@

 #if defined(_WIN32)
 #include <winsock.h>
-#elif !defined(__unix__)
+#elif !YUZU_UNIX
 #error "Platform not implemented"
 #endif

@@ -84,7 +84,7 @@ public:

 #if defined(_WIN32)
    SOCKET fd = INVALID_SOCKET;
-#elif defined(__unix__)
+#elif YUZU_UNIX
    int fd = -1;
 #endif
 };
@@ -180,6 +180,8 @@ struct Values {
    std::string motion_device;
    std::string udp_input_servers;

+    bool emulate_analog_keyboard;
+
    bool mouse_enabled;
    std::string mouse_device;
    MouseButtonsRaw mouse_buttons;
@@ -6,6 +6,7 @@
 #include <cmath>
 #include <thread>
 #include "common/math_util.h"
+#include "core/settings.h"
 #include "input_common/analog_from_button.h"

 namespace InputCommon {
@@ -112,7 +113,26 @@ public:
    }

    std::tuple<float, float> GetStatus() const override {
-        return std::make_tuple(std::cos(angle) * amplitude, std::sin(angle) * amplitude);
+        if (Settings::values.emulate_analog_keyboard) {
+            return std::make_tuple(std::cos(angle) * amplitude, std::sin(angle) * amplitude);
+        }
+        constexpr float SQRT_HALF = 0.707106781f;
+        int x = 0, y = 0;
+        if (right->GetStatus()) {
+            ++x;
+        }
+        if (left->GetStatus()) {
+            --x;
+        }
+        if (up->GetStatus()) {
+            ++y;
+        }
+        if (down->GetStatus()) {
+            --y;
+        }
+        const float coef = modifier->GetStatus() ? modifier_scale : 1.0f;
+        return std::make_tuple(static_cast<float>(x) * coef * (y == 0 ? 1.0f : SQRT_HALF),
+                               static_cast<float>(y) * coef * (x == 0 ? 1.0f : SQRT_HALF));
    }

    bool GetAnalogDirectionStatus(Input::AnalogDirection direction) const override {
@@ -13,7 +13,7 @@
 #include "core/hle/kernel/kernel.h"

 namespace Common {
-struct PageTable;
+class PageTable;
 }

 namespace ArmTests {
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bunnei	07378e4215	core: memory: Make current_page_table access thead safe.	2020-12-17 01:24:51 -08:00
bunnei	e74185588c	core: memory: page_table: Make PageTable class thread safe.	2020-12-17 01:24:51 -08:00
bunnei	ac3b4f918f	Merge pull request #5196 from lat9nq/fix-conan-boost-2 cmake/conan: Conditionally add target Boost::context	2020-12-15 21:15:05 -08:00
lat9nq	9b023a56a3	cmake/conan: Conditionally add target Boost::context Addresses an issue with the two competing versions of Conan's Boost package that are currently floating around. Adds the Boost::context target only if it's recognized by CMake as a target.	2020-12-15 23:47:29 -05:00
bunnei	f3db273753	Merge pull request #5190 from Morph1984/validate_device_handle controllers/npad: Validate device handles before use	2020-12-15 16:40:11 -08:00
bunnei	2e1b998d5e	Merge pull request #5119 from Morph1984/fs-opendatastoragewithprogramindex fsp_srv: Implement OpenDataStorageWithProgramIndex	2020-12-15 11:07:03 -08:00
bunnei	37bec068c2	Merge pull request #5157 from lioncash/array-dirty maxwell_3d: Remove unused dirty_pointer array	2020-12-15 00:35:47 -08:00
bunnei	df6427d30b	Merge pull request #5168 from Morph1984/aoc-PurchaseEventManager aoc_u: Stub IPurchaseEventManager and its service commands	2020-12-14 16:08:38 -08:00
bunnei	c96930fd9d	Merge pull request #5193 from lat9nq/fix-conan-boost cmake: Fix generating CMake configs and linking with Boost	2020-12-12 23:42:14 -08:00
lat9nq	292dd642ce	cmake: Fix generating CMake configs and linking with Boost Fixes regression by `761206cf81`, causing yuzu to not build on Linux with any version of Boost except a cached 1.73 Conan version from before about a day ago. Moves the Boost requirement out of the `REQUIRED_LIBS` psuedo-2D-array for Conan to instead be manually configured, using Conan as a fallback solution if the system does not meet our requirements. Requires any update from the linux-fresh container in order to build. DO NOT MERGE until someone with the MSVC toolchain can verify this works there, too.	2020-12-13 01:28:51 -05:00
bunnei	761206cf81	common: Update CMakeList to fix build issue with Boost.	2020-12-12 11:50:07 -08:00
Morph	1c773c0869	controllers/npad: Validate device handles before use Some games such as NEKOPARA Vol. 3 send invalid device handles when calling InitializeVibrationDevice. Introduce a check to validate the device handle before use.	2020-12-12 07:05:38 -05:00
bunnei	69b46dd607	Merge pull request #5183 from lioncash/alias2 vfs: Use existing type aliases consistently	2020-12-12 01:54:28 -08:00
bunnei	c918c6480f	Merge pull request #5187 from Morph1984/revert-stdfs fs: Revert all std::filesystem changes	2020-12-11 20:07:37 -08:00
bunnei	37194dd4e9	Merge pull request #5172 from lioncash/svc-wide svc: Remove unnecessary casts	2020-12-11 17:39:30 -08:00
Morph	4de079b256	Revert "Merge pull request #5173 from lioncash/common-fs" This reverts commit `ce5fcb6bb2`, reversing changes made to `6f41763061`.	2020-12-11 20:24:22 -05:00
Morph	8941cdb7d2	Revert "Merge pull request #5174 from ReinUsesLisp/fs-fix" This reverts commit `5fe55b16a1`, reversing changes made to `e94dd7e2c4`.	2020-12-11 20:24:22 -05:00
Morph	dfee6321cd	Revert "Merge pull request #5176 from Morph1984/fix-createfile" This reverts commit `6d6115475b`, reversing changes made to `5fe55b16a1`.	2020-12-11 20:24:22 -05:00
Morph	0195038c07	Revert "Merge pull request #5179 from ReinUsesLisp/fs-path" This reverts commit `4e94d0d53a`, reversing changes made to `6d6115475b`.	2020-12-11 20:21:46 -05:00
Morph	ac3ec5ed13	Revert "Merge pull request #5181 from Morph1984/5174-review" This reverts commit `cdb36aef9e`, reversing changes made to `5e9b77129f`.	2020-12-11 20:21:21 -05:00
bunnei	cdb36aef9e	Merge pull request #5181 from Morph1984/5174-review common/file_util: Address review comments of #5174	2020-12-10 15:52:11 -08:00
LC	5e9b77129f	Merge pull request #5184 from lat9nq/travis-linux-ccache-fix travis/linux: Use correct ccache directory	2020-12-10 15:01:47 -05:00
bunnei	2d47a5fd41	Merge pull request #5123 from Morph1984/nim-IsLargeResourceAvailable nim: Stub IsLargeResourceAvailable	2020-12-10 11:34:18 -08:00
lat9nq	3802474483	travis/linux: Use correct ccache directory Changes the bound ccache directory to `/home/yuzu/.ccache` instead of `/root/.ccache`, since the `/root` directory is not accessible by the `yuzu` user in the guest container.	2020-12-10 03:34:16 -05:00
bunnei	d1a2b3fb18	Merge pull request #5162 from lioncash/copy-shader gl_shader_decompiler: Elide unnecessary copies within DeclareConstantBuffers()	2020-12-10 00:11:11 -08:00
Lioncash	b1657b8c6b	vfs: Use existing type aliases consistently Makes use of the VirtualDir and VirtualFile aliases across the board instead of having a few isolated places that don't use it.	2020-12-10 01:44:43 -05:00
Morph	ec8548b414	common/file_util: Simplify the behavior of CreateFullPath	2020-12-09 19:28:11 -05:00
LC	4e94d0d53a	Merge pull request #5179 from ReinUsesLisp/fs-path common/file_util: Let std::filesystem cast from UTF16 to std::string	2020-12-09 17:25:09 -05:00
ReinUsesLisp	bab9cae71f	common/file_util: Let std::filesystem cast from UTF16 to std::string Fix invalid encoding paths when iterating over a directory on Windows.	2020-12-09 18:52:36 -03:00
Chloe	6d6115475b	Merge pull request #5176 from Morph1984/fix-createfile vfs_real: Fix CreateFile for files without a file extension	2020-12-09 22:47:03 +11:00
Morph	b06d6e3646	vfs_real: Fix CreateFile for files without a file extension	2020-12-09 06:34:49 -05:00
Morph	5fe55b16a1	Merge pull request #5174 from ReinUsesLisp/fs-fix common/file_util: Fix and deprecate CreateFullPath, add CreateDirs	2020-12-09 18:07:44 +08:00
ReinUsesLisp	5329834376	common/file_util: Fix and deprecate CreateFullPath, add CreateDirs Fix CreateFullPath to have its intended previous behavior (whatever that was), and deprecate it in favor of the new CreateDirs function. Unlike CreateDir, CreateDirs is marked as [[nodiscard]] to avoid new code ignoring its result value.	2020-12-09 05:42:03 -03:00
ReinUsesLisp	52f13f2339	common/file_util: Succeed on CreateDir when the directory exists	2020-12-09 05:21:08 -03:00
Rodrigo Locatti	e94dd7e2c4	Merge pull request #5142 from comex/xx-poll-events network, sockets: Replace `POLL_IN`, `POLL_OUT`, etc. constants with an `enum class PollEvents`	2020-12-09 03:52:20 -03:00
Rodrigo Locatti	ce5fcb6bb2	Merge pull request #5173 from lioncash/common-fs common/file_util: Make use of std::filesystem	2020-12-09 03:47:21 -03:00
Lioncash	20aad9e01a	file_util: Migrate remaining file handling functions over to std::filesystem Converts creation and deletion functions over to std::filesystem, simplifying our file-handling code. Notably with this, CopyDir will now function on Windows.	2020-12-09 01:24:05 -05:00
bunnei	6f41763061	Merge pull request #5166 from lioncash/log-cast core: Remove unnecessary enum casts in log calls	2020-12-08 21:58:13 -08:00
bunnei	05a703e15d	Merge pull request #5135 from Morph1984/applets-shadow applets: Resolve variable shadowing	2020-12-08 17:43:59 -08:00
Lioncash	0e54aa17e6	file_util: Migrate Exists() and IsDirectory() over to std::filesystem Greatly simplifies our file-handling code for these functions.	2020-12-08 18:36:53 -05:00
Lioncash	2de124e223	svc: Remove unnecessary casts Simplifies and removes some casts. In all cases, these were generally widening from a 32-bit unsigned type to a 64-bit unsigned type, so no information would be lost from the conversion.	2020-12-08 15:42:10 -05:00
LC	aeb100cffe	Merge pull request #5171 from lat9nq/ci-unicorn-cleanup ci: Remove `-DYUZU_USE_BUNDLED_UNICORN=ON`	2020-12-08 15:14:53 -05:00
lat9nq	f1d633cca7	ci: Remove `-DYUZU_USE_BUNDLED_UNICORN=ON` Unicorn has been removed, yet CI still enables building with Unicorn. This just cleans up a few leftovers by removing the variable from the CMake parameters in CI.	2020-12-08 15:06:02 -05:00
bunnei	6057dc46e5	Merge pull request #5167 from lioncash/doc-memory memory: Resolve -Wdocumentation warning for Write()	2020-12-08 11:47:04 -08:00
Morph	deff708cbe	IPurchaseEventManager: Implement GetPurchasedEventReadableHandle - Used by Pokémon Café Mix - Used by DOOM: Eternal	2020-12-08 13:39:19 -05:00
Morph	a9cfe06aaf	IPurchaseEventManager: Stub Set(Default)DeliveryTarget - Used by Pokémon Café Mix - Used by DOOM: Eternal	2020-12-08 13:39:13 -05:00
Morph	009bdb3558	aoc_u: Stub Create(Permanent)EcPurchasedEventManager - Used by Pokémon Café Mix - Used by DOOM: Eternal	2020-12-08 13:39:07 -05:00
Lioncash	a44ff5ed31	memory: Resolve -Wdocumentation warning for Write() Write() doesn't return anything, so the @returns tag shouldn't be present.	2020-12-08 12:44:58 -05:00
bunnei	00c6254129	Merge pull request #5156 from comex/xx-raws configure_motion_touch: Fix unescaped backslash in regex	2020-12-08 09:39:47 -08:00
Morph	e15039372e	fsp_srv: Implement OpenDataStorageWithProgramIndex - Used by RollerCoaster Tycoon 3: Complete Edition	2020-12-08 08:19:05 -05:00
Morph	0eb6c6cd83	file_sys: Consolidate common Title ID operations	2020-12-08 08:19:05 -05:00
Morph	51e6f8271a	Merge pull request #5165 from lioncash/copy-controller controller: Avoid unnecessary copies in ConfigurationComplete()	2020-12-08 20:48:45 +08:00
Lioncash	6b7320add4	core: Remove unnecessary enum casts in log calls Follows the video core PR. fmt doesn't require casts for enum classes anymore, so we can remove quite a few casts.	2020-12-07 23:02:23 -05:00
Lioncash	215cfbb757	controller: Use std::move within ConvertToFrontendParameters() Avoids unnecessary copies.	2020-12-07 22:04:16 -05:00
Lioncash	97dd67ad1c	controller: Avoid unnecessary copies in ConfigurationComplete() Avoids unnecessary 1072 byte copies when querying info about controllers.	2020-12-07 22:02:58 -05:00
Morph	607bb8d14b	Merge pull request #5020 from german77/AnalogfromButtonFix Disable analog joystick from buttons by default	2020-12-08 10:30:21 +08:00
german	b57ba7bfb6	Disable analog joystick from buttons by default	2020-12-07 19:34:52 -06:00
Rodrigo Locatti	3415890dd5	Merge pull request #5164 from lioncash/contains video_core: Make use of ordered container contains() where applicable	2020-12-07 21:55:51 -03:00
Rodrigo Locatti	4bd74ed4c7	Merge pull request #5163 from lioncash/concat ast: Improve string concat readability in operator()	2020-12-07 21:55:21 -03:00
bunnei	f782aecf4d	Merge pull request #5153 from comex/xx-unix CMakeLists,network: Create YUZU_UNIX macro to replace __unix__	2020-12-07 15:32:06 -08:00
Lioncash	09fa1d6a73	video_core: Make use of ordered container contains() where applicable With C++20, we can use the more concise contains() member function instead of comparing the result of the find() call with the end iterator.	2020-12-07 16:30:39 -05:00
Lioncash	45c5b084fd	ast: Improve string concat readability in operator() Provides an in-place format string to make it more pleasant to read.	2020-12-07 16:15:28 -05:00
Lioncash	edcbd47800	gl_shader_decompiler: Elide unnecessary copies within DeclareConstantBuffers() Resolves a -Wrange-loop-analysis warning.	2020-12-07 14:01:52 -05:00
bunnei	5cd051eced	Merge pull request #5149 from comex/xx-map-interval map_interval: Change field order to address uninitialized field warning	2020-12-07 10:14:02 -08:00
Rodrigo Locatti	12f3b13995	Merge pull request #5159 from lioncash/move-amend shader_ir: std::move node within DeclareAmend()	2020-12-07 04:58:01 -03:00
Rodrigo Locatti	3ef35207c1	Merge pull request #5160 from lioncash/buffer-header buffer_block: Remove unnecessary includes	2020-12-07 04:57:40 -03:00
Lioncash	5d2f18fbcd	buffer_block: Mark interface as nodiscard where applicable Prevents logic errors from occurring from unused values.	2020-12-07 01:53:40 -05:00
Lioncash	3954f14c6d	buffer_block: Remove unnecessary includes Reduces the amount of dependencies the header pulls in.	2020-12-07 01:52:16 -05:00
Rodrigo Locatti	9ae6224f12	Merge pull request #5158 from lioncash/video-fmt video_core: Remove unnecessary enum class casting in logging messages	2020-12-07 03:35:25 -03:00
bunnei	a58d57a60d	Merge pull request #5148 from comex/xx-unused-fields core: Mark unused fields as [[maybe_unused]]	2020-12-06 22:33:00 -08:00
bunnei	24cabf5e2f	Merge pull request #5154 from comex/xx-ipc hle: Type check ResponseBuilder::Push arguments, and fix use in vi.cpp	2020-12-06 22:32:04 -08:00
Lioncash	7234f436aa	shader_ir: std::move node within DeclareAmend() Same behavior, but elides an unnecessary atomic reference count increment and decrement.	2020-12-07 00:51:03 -05:00
Lioncash	4c5f5c9bf3	video_core: Remove unnecessary enum class casting in logging messages fmt now automatically prints the numeric value of an enum class member by default, so we don't need to use casts any more. Reduces the line noise a bit.	2020-12-07 00:41:50 -05:00
LC	8a00a0ade6	Merge pull request #5147 from comex/xx-purevirt nvdrv: Remove useless re-declaration of pure virtual methods that were already declared in the superclass	2020-12-07 00:08:46 -05:00
LC	43f0b42088	Merge pull request #5150 from comex/xx-boxcat boxcat: Avoid unnecessary object copy	2020-12-07 00:07:39 -05:00
LC	23aabe85e6	Merge pull request #5152 from comex/xx-override renderer_vulkan: Add missing `override` specifier	2020-12-07 00:07:17 -05:00
LC	69af6ada2f	Merge pull request #5136 from lioncash/video-shadow3 video_core: Resolve more variable shadowing scenarios pt.3	2020-12-07 00:06:53 -05:00
Lioncash	9e7a1f1351	maxwell_3d: Move member variables to end of class Follows our established coding style.	2020-12-06 20:56:00 -05:00
Lioncash	ce0712bf95	maxwell_3d: Resolve -Wdocumentation warning Removes a documentation comment for a non-existent member.	2020-12-06 20:48:12 -05:00
Lioncash	bcc5c4403a	maxwell_3d: Remove unused dirty_pointer array This is unused and removing it shrinks the structure by 3584 bytes.	2020-12-06 20:46:57 -05:00
comex	2dce2be138	configure_motion_touch: Fix unescaped backslash in regex Since this is inside a string literal, backslashes that are part of regex syntax have to be escaped. But that's ugly, so convert to a raw string instead.	2020-12-06 19:25:48 -05:00
comex	0791082b43	network, sockets: Replace `POLL_IN`, `POLL_OUT`, etc. constants with an `enum class PollEvents` Actually, two enum classes, since for some reason there are two separate yet identical `PollFD` types used in the codebase. I get that one is ABI-compatible with the Switch while the other is an abstract type used for the host, but why not use `WSAPOLLFD` directly for the latter? Anyway, why make this change? Because on Apple platforms, `POLL_IN`, `POLL_OUT`, etc. (with an underscore) are defined as macros in <sys/signal.h>. (This is inherited from FreeBSD.) So defining a variable with the same name causes a compile error. I could just rename the variables, but while I was at it I thought I might as well switch to an enum for stronger typing. Also, change the type used for values copied directly to/from the `events` and `revents` fields of the host native `pollfd`/`WSASPOLLFD`, from `u32` to `short`, as `short` is the correct canonical type on both Unix and Windows.	2020-12-06 19:14:42 -05:00
LC	5933667cb8	Merge pull request #5155 from comex/xx-default Fix "explicitly defaulted but implicitly deleted" warning	2020-12-06 19:05:39 -05:00
comex	e31cb50405	Fix "explicitly defaulted but implicitly deleted" warning `PhysicalCore`'s move assignment operator was declared as `= default`, but was implicitly deleted because `PhysicalCore` has fields of reference type. Switch to explicitly deleting it to avoid a Clang warning. The move constructor is still defaulted, and is required to exist due to the use of `std::vector<PhysicalCore>`.	2020-12-06 19:02:04 -05:00
comex	3373149fdc	hle: Type check ResponseBuilder::Push arguments, and fix use in vi.cpp - Add a type check so that calling Push with an invalid type produces a compile error rather than a linker error. - vi.cpp was calling Push with a variable of type `std::size_t`. There's no explicit overload for `size_t`, but there is one for `u64`, which on most platforms is the same type as `size_t`. On macOS, however, it isn't: both types are 64 bits, but `size_t` is `unsigned long` and `u64` is `unsigned long long`. Regardless, it makes more sense to explicitly use `u64` here instead of `size_t`.	2020-12-06 18:59:22 -05:00
comex	0e122c13ad	CMakeLists,network: Create YUZU_UNIX macro to replace __unix__ __unix__ is not predefined on Apple platforms even though they are Unix.	2020-12-06 18:56:40 -05:00
comex	eea5122d1b	renderer_vulkan: Add missing `override` specifier	2020-12-06 18:38:52 -05:00
comex	b8fbf6969c	map_interval: Change field order to address uninitialized field warning Clang complains about `new_chunk`'s constructor using the then-uninitialized `first_chunk` (even though it's just to get a pointer into it).	2020-12-06 18:37:23 -05:00
comex	feac654ba0	core: Mark unused fields as [[maybe_unused]]	2020-12-06 18:36:10 -05:00
comex	5cb1a343d1	boxcat: Avoid unnecessary object copy	2020-12-06 18:31:13 -05:00
LC	0dc234c5ea	Merge pull request #5146 from comex/xx-num video_core: Adjust `NUM` macro to avoid Clang warning	2020-12-06 18:30:40 -05:00
comex	716ae72aac	nvdrv: Remove useless re-declaration of pure virtual methods that were already declared in the superclass	2020-12-06 18:24:33 -05:00
comex	d637114c17	video_core: Adjust `NUM` macro to avoid Clang warning The previous definition was: #define NUM(field_name) (sizeof(Maxwell3D::Regs::field_name) / sizeof(u32)) In cases where `field_name` happens to refer to an array, Clang thinks `sizeof(an array value) / sizeof(a type)` is an instance of the idiom where `sizeof` is used to compute an array length. So it thinks the type in the denominator ought to be the array element type, and warns if it isn't, assuming this is a mistake. In reality, `NUM` is not used to get array lengths at all, so there is no mistake. Silence the warning by applying Clang's suggested workaround of parenthesizing the denominator.	2020-12-06 18:24:16 -05:00
Rodrigo Locatti	7e5f595b31	Merge pull request #5143 from comex/xx-users-size yuzu_cmd: Remove 'users_size'	2020-12-06 19:34:53 -03:00
Rodrigo Locatti	88959b0047	Merge pull request #5141 from comex/xx-true-false maxwell_dma: Rename RenderEnable::Mode::FALSE and TRUE to avoid name conflict	2020-12-06 19:34:24 -03:00
bunnei	dd05c7ec79	Merge pull request #5140 from FearlessTobi/port-5577 Port citra-emu/citra#5577: "Update cubeb and request a persistent stream session"	2020-12-06 01:53:02 -08:00
bunnei	53a04d6b5d	Merge pull request #5132 from lioncash/xbyak-abi xbyak_abi: Avoid implicit sign conversions	2020-12-06 01:22:43 -08:00
bunnei	c67c25db05	Merge pull request #5139 from lioncash/deprecated-qt game_list_p: Resolve deprecated usage of QVariant operator<	2020-12-06 00:45:23 -08:00
comex	a6e6cd5788	maxwell_dma: Rename RenderEnable::Mode::FALSE and TRUE to avoid name conflict On Apple platforms, FALSE and TRUE are defined as macros by <mach/boolean.h>, which is included by various system headers. Note that there appear to be no actual users of the names to fix up.	2020-12-05 17:59:02 -05:00
comex	9dc69fa07c	yuzu_cmd: Remove 'users_size' Specifically: const auto size = sdl2_config->GetInteger("System", "users_size", 0); The variable is never used, producing a warning. I wondered if this ought to be assigning something to in `Settings`, but nothing else in the codebase ever mentions a setting called "users_size", so I guess it's safe to remove...	2020-12-05 17:50:39 -05:00
Vitor Kiguchi	a1e7360273	Update cubeb and request a persistent stream session	2020-12-05 22:26:41 +01:00
Lioncash	f95602f152	video_core: Resolve more variable shadowing scenarios pt.3 Cleans out the rest of the occurrences of variable shadowing and makes any further occurrences of shadowing compiler errors.	2020-12-05 16:02:23 -05:00
Morph	f6d4a289d5	applets: Resolve variable shadowing	2020-12-05 08:37:13 -05:00
Lioncash	2c375013dd	xbyak_abi: Shorten std::size_t to size_t Makes for less reading.	2020-12-05 00:43:55 -05:00
Lioncash	b126267442	xbyak_abi: Avoid implicit sign conversions	2020-12-05 00:43:41 -05:00
Morph	c2f83c04cb	nim: Stub IsLargeResourceAvailable - Used by Immortals Fenyx Rising	2020-12-04 09:53:21 -05:00