actually seed rand

.gitmodules

@@ -40,9 +40,3 @@
 [submodule "Vulkan-Headers"]
     path = externals/Vulkan-Headers
     url = https://github.com/KhronosGroup/Vulkan-Headers.git
-[submodule "externals/zstd"]
-    path = externals/zstd
-    url = https://github.com/facebook/zstd
-[submodule "sirit"]
-    path = externals/sirit
-    url = https://github.com/ReinUsesLisp/sirit

.travis/macos/deps.sh

@@ -1,6 +1,5 @@
 #!/bin/sh -ex
 
 brew update
-brew install p7zip qt5 sdl2 ccache
+brew install dylibbundler p7zip qt5 sdl2 ccache
 brew outdated cmake || brew upgrade cmake
-pip3 install macpack

.travis/macos/upload.sh

@@ -11,19 +11,92 @@ mkdir "$REV_NAME"
 cp build/bin/yuzu-cmd "$REV_NAME"
 cp -r build/bin/yuzu.app "$REV_NAME"
 
-# move libs into folder for deployment
-macpack "${REV_NAME}/yuzu.app/Contents/MacOS/yuzu" -d "../Frameworks"
-# move qt frameworks into app bundle for deployment
-$(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app" -executable="${REV_NAME}/yuzu.app/Contents/MacOS/yuzu"
+# move qt libs into app bundle for deployment
+$(brew --prefix)/opt/qt5/bin/macdeployqt "${REV_NAME}/yuzu.app"
 
-# move libs into folder for deployment
-macpack "${REV_NAME}/yuzu-cmd" -d "libs"
+# move SDL2 libs into folder for deployment
+dylibbundler -b -x "${REV_NAME}/yuzu-cmd" -cd -d "${REV_NAME}/libs" -p "@executable_path/libs/"
+
+# Make the changes to make the yuzu app standalone (i.e. not dependent on the current brew installation).
+# To do this, the absolute references to each and every QT framework must be re-written to point to the local frameworks
+# (in the Contents/Frameworks folder).
+# The "install_name_tool" is used to do so.
+
+# Coreutils is a hack to coerce Homebrew to point to the absolute Cellar path (symlink dereferenced). i.e:
+# ls -l /usr/local/opt/qt5:: /usr/local/opt/qt5 -> ../Cellar/qt5/5.6.1-1
+# grealpath ../Cellar/qt5/5.6.1-1:: /usr/local/Cellar/qt5/5.6.1-1
+brew install coreutils || brew upgrade coreutils || true
+
+REV_NAME_ALT=$REV_NAME/
+# grealpath is located in coreutils, there is no "realpath" for OS X :(
+QT_BREWS_PATH=$(grealpath "$(brew --prefix qt5)")
+BREW_PATH=$(brew --prefix)
+QT_VERSION_NUM=5
+
+$BREW_PATH/opt/qt5/bin/macdeployqt "${REV_NAME_ALT}yuzu.app" \
+    -executable="${REV_NAME_ALT}yuzu.app/Contents/MacOS/yuzu"
+
+# These are the files that macdeployqt packed into Contents/Frameworks/ - we don't want those, so we replace them.
+declare -a macos_libs=("QtCore" "QtWidgets" "QtGui" "QtOpenGL" "QtPrintSupport")
+
+for macos_lib in "${macos_libs[@]}"
+do
+    SC_FRAMEWORK_PART=$macos_lib.framework/Versions/$QT_VERSION_NUM/$macos_lib
+    # Replace macdeployqt versions of the Frameworks with our own (from /usr/local/opt/qt5/lib/)
+    cp "$BREW_PATH/opt/qt5/lib/$SC_FRAMEWORK_PART" "${REV_NAME_ALT}yuzu.app/Contents/Frameworks/$SC_FRAMEWORK_PART"
+
+    # Replace references within the embedded Framework files with "internal" versions.
+    for macos_lib2 in "${macos_libs[@]}"
+    do
+        # Since brew references both the non-symlinked and symlink paths of QT5, it needs to be duplicated.
+        # /usr/local/Cellar/qt5/5.6.1-1/lib and /usr/local/opt/qt5/lib both resolve to the same files.
+        # So the two lines below are effectively duplicates when resolved as a path, but as strings, they aren't.
+        RM_FRAMEWORK_PART=$macos_lib2.framework/Versions/$QT_VERSION_NUM/$macos_lib2
+        install_name_tool -change \
+            $QT_BREWS_PATH/lib/$RM_FRAMEWORK_PART \
+            @executable_path/../Frameworks/$RM_FRAMEWORK_PART \
+            "${REV_NAME_ALT}yuzu.app/Contents/Frameworks/$SC_FRAMEWORK_PART"
+        install_name_tool -change \
+            "$BREW_PATH/opt/qt5/lib/$RM_FRAMEWORK_PART" \
+            @executable_path/../Frameworks/$RM_FRAMEWORK_PART \
+            "${REV_NAME_ALT}yuzu.app/Contents/Frameworks/$SC_FRAMEWORK_PART"
+    done
+done
+
+# Handles `This application failed to start because it could not find or load the Qt platform plugin "cocoa"`
+# Which manifests itself as:
+# "Exception Type: EXC_CRASH (SIGABRT) | Exception Codes: 0x0000000000000000, 0x0000000000000000 | Exception Note: EXC_CORPSE_NOTIFY"
+# There may be more dylibs needed to be fixed...
+declare -a macos_plugins=("Plugins/platforms/libqcocoa.dylib")
+
+for macos_lib in "${macos_plugins[@]}"
+do
+    install_name_tool -id @executable_path/../$macos_lib "${REV_NAME_ALT}yuzu.app/Contents/$macos_lib"
+    for macos_lib2 in "${macos_libs[@]}"
+    do
+        RM_FRAMEWORK_PART=$macos_lib2.framework/Versions/$QT_VERSION_NUM/$macos_lib2
+        install_name_tool -change \
+            $QT_BREWS_PATH/lib/$RM_FRAMEWORK_PART \
+            @executable_path/../Frameworks/$RM_FRAMEWORK_PART \
+            "${REV_NAME_ALT}yuzu.app/Contents/$macos_lib"
+        install_name_tool -change \
+            "$BREW_PATH/opt/qt5/lib/$RM_FRAMEWORK_PART" \
+            @executable_path/../Frameworks/$RM_FRAMEWORK_PART \
+            "${REV_NAME_ALT}yuzu.app/Contents/$macos_lib"
+    done
+done
+
+for macos_lib in "${macos_libs[@]}"
+do
+    # Debugging info for Travis-CI
+    otool -L "${REV_NAME_ALT}yuzu.app/Contents/Frameworks/$macos_lib.framework/Versions/$QT_VERSION_NUM/$macos_lib"
+done
 
 # Make the yuzu.app application launch a debugging terminal.
 # Store away the actual binary
-mv ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu-bin
+mv ${REV_NAME_ALT}yuzu.app/Contents/MacOS/yuzu ${REV_NAME_ALT}yuzu.app/Contents/MacOS/yuzu-bin
 
-cat > ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu <<EOL
+cat > ${REV_NAME_ALT}yuzu.app/Contents/MacOS/yuzu <<EOL
 #!/usr/bin/env bash
 cd "\`dirname "\$0"\`"
 chmod +x yuzu-bin
@@ -32,9 +105,6 @@ EOL
 # Content that will serve as the launching script for yuzu (within the .app folder)
 
 # Make the launching script executable
-chmod +x ${REV_NAME}/yuzu.app/Contents/MacOS/yuzu
-
-# Verify loader instructions
-find "$REV_NAME" -exec otool -L {} \;
+chmod +x ${REV_NAME_ALT}yuzu.app/Contents/MacOS/yuzu
 
 . .travis/common/post-upload.sh

CMakeLists.txt

@@ -309,7 +309,7 @@ if (CLANG_FORMAT)
     set(CCOMMENT "Running clang format against all the .h and .cpp files in src/")
     if (WIN32)
         add_custom_target(clang-format
-            COMMAND powershell.exe -Command "Get-ChildItem '${SRCS}/*' -Include *.cpp,*.h -Recurse | Foreach {&'${CLANG_FORMAT}' -i $_.fullname}"
+            COMMAND powershell.exe -Command "Get-ChildItem ${SRCS}/* -Include *.cpp,*.h -Recurse | Foreach {${CLANG_FORMAT} -i $_.fullname}"
             COMMENT ${CCOMMENT})
     elseif(MINGW)
         add_custom_target(clang-format

externals/CMakeLists.txt

@@ -49,10 +49,6 @@ add_subdirectory(open_source_archives EXCLUDE_FROM_ALL)
 add_library(unicorn-headers INTERFACE)
 target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
 
-# Zstandard
-add_subdirectory(zstd/build/cmake EXCLUDE_FROM_ALL)
-target_include_directories(libzstd_static INTERFACE ./zstd/lib)
-
 # SoundTouch
 add_subdirectory(soundtouch)
 
@@ -72,11 +68,6 @@ if (USE_DISCORD_PRESENCE)
     target_include_directories(discord-rpc INTERFACE ./discord-rpc/include)
 endif()
 
-# Sirit
-if (ENABLE_VULKAN)
-    add_subdirectory(sirit)
-endif()
-
 if (ENABLE_WEB_SERVICE)
     # LibreSSL
     set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")

src/common/CMakeLists.txt

@@ -91,8 +91,6 @@ add_library(common STATIC
     logging/log.h
     logging/text_formatter.cpp
     logging/text_formatter.h
-    lz4_compression.cpp
-    lz4_compression.h
     math_util.h
     memory_hook.cpp
     memory_hook.h
@@ -125,8 +123,6 @@ add_library(common STATIC
     uint128.h
     vector_math.h
     web_result.h
-    zstd_compression.cpp
-    zstd_compression.h
 )
 
 if(ARCHITECTURE_x86_64)
@@ -140,4 +136,3 @@ endif()
 create_target_directory_groups(common)
 
 target_link_libraries(common PUBLIC Boost::boost fmt microprofile)
-target_link_libraries(common PRIVATE lz4_static libzstd_static)

src/common/assert.h

@@ -57,21 +57,3 @@ __declspec(noinline, noreturn)
 
 #define UNIMPLEMENTED_IF(cond) ASSERT_MSG(!(cond), "Unimplemented code!")
 #define UNIMPLEMENTED_IF_MSG(cond, ...) ASSERT_MSG(!(cond), __VA_ARGS__)
-
-// If the assert is ignored, execute _b_
-#define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
-    do {                                                                                           \
-        ASSERT(_a_);                                                                               \
-        if (!(_a_)) {                                                                              \
-            _b_                                                                                    \
-        }                                                                                          \
-    } while (0)
-
-// If the assert is ignored, execute _b_
-#define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
-    do {                                                                                           \
-        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
-        if (!(_a_)) {                                                                              \
-            _b_                                                                                    \
-        }                                                                                          \
-    } while (0)

src/common/bit_util.h

@@ -32,7 +32,7 @@ inline u32 CountLeadingZeroes32(u32 value) {
     return 32;
 }
 
-inline u32 CountLeadingZeroes64(u64 value) {
+inline u64 CountLeadingZeroes64(u64 value) {
     unsigned long leading_zero = 0;
 
     if (_BitScanReverse64(&leading_zero, value) != 0) {
@@ -47,15 +47,15 @@ inline u32 CountLeadingZeroes32(u32 value) {
         return 32;
     }
 
-    return static_cast<u32>(__builtin_clz(value));
+    return __builtin_clz(value);
 }
 
-inline u32 CountLeadingZeroes64(u64 value) {
+inline u64 CountLeadingZeroes64(u64 value) {
     if (value == 0) {
         return 64;
     }
 
-    return static_cast<u32>(__builtin_clzll(value));
+    return __builtin_clzll(value);
 }
 #endif
 
@@ -70,7 +70,7 @@ inline u32 CountTrailingZeroes32(u32 value) {
     return 32;
 }
 
-inline u32 CountTrailingZeroes64(u64 value) {
+inline u64 CountTrailingZeroes64(u64 value) {
     unsigned long trailing_zero = 0;
 
     if (_BitScanForward64(&trailing_zero, value) != 0) {
@@ -85,15 +85,15 @@ inline u32 CountTrailingZeroes32(u32 value) {
         return 32;
     }
 
-    return static_cast<u32>(__builtin_ctz(value));
+    return __builtin_ctz(value);
 }
 
-inline u32 CountTrailingZeroes64(u64 value) {
+inline u64 CountTrailingZeroes64(u64 value) {
     if (value == 0) {
         return 64;
     }
 
-    return static_cast<u32>(__builtin_ctzll(value));
+    return __builtin_ctzll(value);
 }
 #endif
 

src/common/detached_tasks.cpp

@@ -16,22 +16,22 @@ DetachedTasks::DetachedTasks() {
 }
 
 void DetachedTasks::WaitForAllTasks() {
-    std::unique_lock lock{mutex};
+    std::unique_lock<std::mutex> lock(mutex);
     cv.wait(lock, [this]() { return count == 0; });
 }
 
 DetachedTasks::~DetachedTasks() {
-    std::unique_lock lock{mutex};
+    std::unique_lock<std::mutex> lock(mutex);
     ASSERT(count == 0);
     instance = nullptr;
 }
 
 void DetachedTasks::AddTask(std::function<void()> task) {
-    std::unique_lock lock{instance->mutex};
+    std::unique_lock<std::mutex> lock(instance->mutex);
     ++instance->count;
     std::thread([task{std::move(task)}]() {
         task();
-        std::unique_lock lock{instance->mutex};
+        std::unique_lock<std::mutex> lock(instance->mutex);
         --instance->count;
         std::notify_all_at_thread_exit(instance->cv, std::move(lock));
     })

src/common/logging/backend.cpp

@@ -46,12 +46,12 @@ public:
     }
 
     void AddBackend(std::unique_ptr<Backend> backend) {
-        std::lock_guard lock{writing_mutex};
+        std::lock_guard<std::mutex> lock(writing_mutex);
         backends.push_back(std::move(backend));
     }
 
     void RemoveBackend(std::string_view backend_name) {
-        std::lock_guard lock{writing_mutex};
+        std::lock_guard<std::mutex> lock(writing_mutex);
         const auto it =
             std::remove_if(backends.begin(), backends.end(),
                            [&backend_name](const auto& i) { return backend_name == i->GetName(); });
@@ -80,7 +80,7 @@ private:
         backend_thread = std::thread([&] {
             Entry entry;
             auto write_logs = [&](Entry& e) {
-                std::lock_guard lock{writing_mutex};
+                std::lock_guard<std::mutex> lock(writing_mutex);
                 for (const auto& backend : backends) {
                     backend->Write(e);
                 }

src/common/lz4_compression.cpp

@@ -1,76 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <lz4hc.h>
-
-#include "common/assert.h"
-#include "common/lz4_compression.h"
-
-namespace Common::Compression {
-
-std::vector<u8> CompressDataLZ4(const u8* source, std::size_t source_size) {
-    ASSERT_MSG(source_size <= LZ4_MAX_INPUT_SIZE, "Source size exceeds LZ4 maximum input size");
-
-    const auto source_size_int = static_cast<int>(source_size);
-    const int max_compressed_size = LZ4_compressBound(source_size_int);
-    std::vector<u8> compressed(max_compressed_size);
-
-    const int compressed_size = LZ4_compress_default(reinterpret_cast<const char*>(source),
-                                                     reinterpret_cast<char*>(compressed.data()),
-                                                     source_size_int, max_compressed_size);
-
-    if (compressed_size <= 0) {
-        // Compression failed
-        return {};
-    }
-
-    compressed.resize(compressed_size);
-
-    return compressed;
-}
-
-std::vector<u8> CompressDataLZ4HC(const u8* source, std::size_t source_size,
-                                  s32 compression_level) {
-    ASSERT_MSG(source_size <= LZ4_MAX_INPUT_SIZE, "Source size exceeds LZ4 maximum input size");
-
-    compression_level = std::clamp(compression_level, LZ4HC_CLEVEL_MIN, LZ4HC_CLEVEL_MAX);
-
-    const auto source_size_int = static_cast<int>(source_size);
-    const int max_compressed_size = LZ4_compressBound(source_size_int);
-    std::vector<u8> compressed(max_compressed_size);
-
-    const int compressed_size = LZ4_compress_HC(
-        reinterpret_cast<const char*>(source), reinterpret_cast<char*>(compressed.data()),
-        source_size_int, max_compressed_size, compression_level);
-
-    if (compressed_size <= 0) {
-        // Compression failed
-        return {};
-    }
-
-    compressed.resize(compressed_size);
-
-    return compressed;
-}
-
-std::vector<u8> CompressDataLZ4HCMax(const u8* source, std::size_t source_size) {
-    return CompressDataLZ4HC(source, source_size, LZ4HC_CLEVEL_MAX);
-}
-
-std::vector<u8> DecompressDataLZ4(const std::vector<u8>& compressed,
-                                  std::size_t uncompressed_size) {
-    std::vector<u8> uncompressed(uncompressed_size);
-    const int size_check = LZ4_decompress_safe(reinterpret_cast<const char*>(compressed.data()),
-                                               reinterpret_cast<char*>(uncompressed.data()),
-                                               static_cast<int>(compressed.size()),
-                                               static_cast<int>(uncompressed.size()));
-    if (static_cast<int>(uncompressed_size) != size_check) {
-        // Decompression failed
-        return {};
-    }
-    return uncompressed;
-}
-
-} // namespace Common::Compression

src/common/lz4_compression.h

@@ -1,57 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-
-#include "common/common_types.h"
-
-namespace Common::Compression {
-
-/**
- * Compresses a source memory region with LZ4 and returns the compressed data in a vector.
- *
- * @param source the uncompressed source memory region.
- * @param source_size the size in bytes of the uncompressed source memory region.
- *
- * @return the compressed data.
- */
-std::vector<u8> CompressDataLZ4(const u8* source, std::size_t source_size);
-
-/**
- * Utilizes the LZ4 subalgorithm LZ4HC with the specified compression level. Higher compression
- * levels result in a smaller compressed size, but require more CPU time for compression. The
- * compression level has almost no impact on decompression speed. Data compressed with LZ4HC can
- * also be decompressed with the default LZ4 decompression.
- *
- * @param source the uncompressed source memory region.
- * @param source_size the size in bytes of the uncompressed source memory region.
- * @param compression_level the used compression level. Should be between 3 and 12.
- *
- * @return the compressed data.
- */
-std::vector<u8> CompressDataLZ4HC(const u8* source, std::size_t source_size, s32 compression_level);
-
-/**
- * Utilizes the LZ4 subalgorithm LZ4HC with the highest possible compression level.
- *
- * @param source the uncompressed source memory region.
- * @param source_size the size in bytes of the uncompressed source memory region.
- *
- * @return the compressed data.
- */
-std::vector<u8> CompressDataLZ4HCMax(const u8* source, std::size_t source_size);
-
-/**
- * Decompresses a source memory region with LZ4 and returns the uncompressed data in a vector.
- *
- * @param compressed the compressed source memory region.
- * @param uncompressed_size the size in bytes of the uncompressed data.
- *
- * @return the decompressed data.
- */
-std::vector<u8> DecompressDataLZ4(const std::vector<u8>& compressed, std::size_t uncompressed_size);
-
-} // namespace Common::Compression

src/common/multi_level_queue.h

@@ -72,7 +72,7 @@ public:
                 u64 prios = mlq.used_priorities;
                 prios &= ~((1ULL << (current_priority + 1)) - 1);
                 if (prios == 0) {
-                    current_priority = static_cast<u32>(mlq.depth());
+                    current_priority = mlq.depth();
                 } else {
                     current_priority = CountTrailingZeroes64(prios);
                     it = GetBeginItForPrio();

src/common/scope_exit.h

@@ -20,7 +20,7 @@ struct ScopeExitHelper {
 
 template <typename Func>
 ScopeExitHelper<Func> ScopeExit(Func&& func) {
-    return ScopeExitHelper<Func>(std::forward<Func>(func));
+    return ScopeExitHelper<Func>(std::move(func));
 }
 } // namespace detail
 

src/common/swap.h

@@ -21,6 +21,11 @@
 
 #if defined(_MSC_VER)
 #include <cstdlib>
+#elif defined(__linux__)
+#include <byteswap.h>
+#elif defined(__Bitrig__) || defined(__DragonFly__) || defined(__FreeBSD__) ||                     \
+    defined(__NetBSD__) || defined(__OpenBSD__)
+#include <sys/endian.h>
 #endif
 #include <cstring>
 #include "common/common_types.h"
@@ -57,49 +62,86 @@
 namespace Common {
 
 #ifdef _MSC_VER
-[[nodiscard]] inline u16 swap16(u16 data) noexcept {
-    return _byteswap_ushort(data);
+inline u16 swap16(u16 _data) {
+    return _byteswap_ushort(_data);
 }
-[[nodiscard]] inline u32 swap32(u32 data) noexcept {
-    return _byteswap_ulong(data);
+inline u32 swap32(u32 _data) {
+    return _byteswap_ulong(_data);
 }
-[[nodiscard]] inline u64 swap64(u64 data) noexcept {
-    return _byteswap_uint64(data);
+inline u64 swap64(u64 _data) {
+    return _byteswap_uint64(_data);
 }
-#elif defined(__clang__) || defined(__GNUC__)
-#if defined(__Bitrig__) || defined(__OpenBSD__)
+#elif defined(ARCHITECTURE_ARM) && (__ARM_ARCH >= 6)
+inline u16 swap16(u16 _data) {
+    u32 data = _data;
+    __asm__("rev16 %0, %1\n" : "=l"(data) : "l"(data));
+    return (u16)data;
+}
+inline u32 swap32(u32 _data) {
+    __asm__("rev %0, %1\n" : "=l"(_data) : "l"(_data));
+    return _data;
+}
+inline u64 swap64(u64 _data) {
+    return ((u64)swap32(_data) << 32) | swap32(_data >> 32);
+}
+#elif __linux__
+inline u16 swap16(u16 _data) {
+    return bswap_16(_data);
+}
+inline u32 swap32(u32 _data) {
+    return bswap_32(_data);
+}
+inline u64 swap64(u64 _data) {
+    return bswap_64(_data);
+}
+#elif __APPLE__
+inline __attribute__((always_inline)) u16 swap16(u16 _data) {
+    return (_data >> 8) | (_data << 8);
+}
+inline __attribute__((always_inline)) u32 swap32(u32 _data) {
+    return __builtin_bswap32(_data);
+}
+inline __attribute__((always_inline)) u64 swap64(u64 _data) {
+    return __builtin_bswap64(_data);
+}
+#elif defined(__Bitrig__) || defined(__OpenBSD__)
 // redefine swap16, swap32, swap64 as inline functions
 #undef swap16
 #undef swap32
 #undef swap64
-#endif
-[[nodiscard]] inline u16 swap16(u16 data) noexcept {
-    return __builtin_bswap16(data);
+inline u16 swap16(u16 _data) {
+    return __swap16(_data);
 }
-[[nodiscard]] inline u32 swap32(u32 data) noexcept {
-    return __builtin_bswap32(data);
+inline u32 swap32(u32 _data) {
+    return __swap32(_data);
 }
-[[nodiscard]] inline u64 swap64(u64 data) noexcept {
-    return __builtin_bswap64(data);
+inline u64 swap64(u64 _data) {
+    return __swap64(_data);
+}
+#elif defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__)
+inline u16 swap16(u16 _data) {
+    return bswap16(_data);
+}
+inline u32 swap32(u32 _data) {
+    return bswap32(_data);
+}
+inline u64 swap64(u64 _data) {
+    return bswap64(_data);
 }
 #else
-// Generic implementation.
-[[nodiscard]] inline u16 swap16(u16 data) noexcept {
+// Slow generic implementation.
+inline u16 swap16(u16 data) {
     return (data >> 8) | (data << 8);
 }
-[[nodiscard]] inline u32 swap32(u32 data) noexcept {
-    return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) |
-           ((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
+inline u32 swap32(u32 data) {
+    return (swap16(data) << 16) | swap16(data >> 16);
 }
-[[nodiscard]] inline u64 swap64(u64 data) noexcept {
-    return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) |
-           ((data & 0x0000FF0000000000ULL) >> 24) | ((data & 0x000000FF00000000ULL) >> 8) |
-           ((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
-           ((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
+inline u64 swap64(u64 data) {
+    return ((u64)swap32(data) << 32) | swap32(data >> 32);
 }
 #endif
 
-[[nodiscard]] inline float swapf(float f) noexcept {
+inline float swapf(float f) {
     static_assert(sizeof(u32) == sizeof(float), "float must be the same size as uint32_t.");
 
     u32 value;
@@ -111,7 +153,7 @@ namespace Common {
     return f;
 }
 
-[[nodiscard]] inline double swapd(double f) noexcept {
+inline double swapd(double f) {
     static_assert(sizeof(u64) == sizeof(double), "double must be the same size as uint64_t.");
 
     u64 value;

src/common/thread.h

@@ -15,7 +15,7 @@ namespace Common {
 class Event {
 public:
     void Set() {
-        std::lock_guard lk{mutex};
+        std::lock_guard<std::mutex> lk(mutex);
         if (!is_set) {
             is_set = true;
             condvar.notify_one();
@@ -23,14 +23,14 @@ public:
     }
 
     void Wait() {
-        std::unique_lock lk{mutex};
+        std::unique_lock<std::mutex> lk(mutex);
         condvar.wait(lk, [&] { return is_set; });
         is_set = false;
     }
 
     template <class Clock, class Duration>
     bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
-        std::unique_lock lk{mutex};
+        std::unique_lock<std::mutex> lk(mutex);
         if (!condvar.wait_until(lk, time, [this] { return is_set; }))
             return false;
         is_set = false;
@@ -38,7 +38,7 @@ public:
     }
 
     void Reset() {
-        std::unique_lock lk{mutex};
+        std::unique_lock<std::mutex> lk(mutex);
         // no other action required, since wait loops on the predicate and any lingering signal will
         // get cleared on the first iteration
         is_set = false;
@@ -56,7 +56,7 @@ public:
 
     /// Blocks until all "count" threads have called Sync()
     void Sync() {
-        std::unique_lock lk{mutex};
+        std::unique_lock<std::mutex> lk(mutex);
         const std::size_t current_generation = generation;
 
         if (++waiting == count) {

src/common/threadsafe_queue.h

@@ -78,7 +78,7 @@ public:
 
     T PopWait() {
         if (Empty()) {
-            std::unique_lock lock{cv_mutex};
+            std::unique_lock<std::mutex> lock(cv_mutex);
             cv.wait(lock, [this]() { return !Empty(); });
         }
         T t;
@@ -137,7 +137,7 @@ public:
 
     template <typename Arg>
     void Push(Arg&& t) {
-        std::lock_guard lock{write_lock};
+        std::lock_guard<std::mutex> lock(write_lock);
         spsc_queue.Push(t);
     }
 

src/common/zstd_compression.cpp

@@ -1,53 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <algorithm>
-#include <zstd.h>
-
-#include "common/assert.h"
-#include "common/zstd_compression.h"
-
-namespace Common::Compression {
-
-std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32 compression_level) {
-    compression_level = std::clamp(compression_level, 1, ZSTD_maxCLevel());
-
-    const std::size_t max_compressed_size = ZSTD_compressBound(source_size);
-    std::vector<u8> compressed(max_compressed_size);
-
-    const std::size_t compressed_size =
-        ZSTD_compress(compressed.data(), compressed.size(), source, source_size, compression_level);
-
-    if (ZSTD_isError(compressed_size)) {
-        // Compression failed
-        return {};
-    }
-
-    compressed.resize(compressed_size);
-
-    return compressed;
-}
-
-std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size) {
-    return CompressDataZSTD(source, source_size, ZSTD_CLEVEL_DEFAULT);
-}
-
-std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed) {
-    const std::size_t decompressed_size =
-        ZSTD_getDecompressedSize(compressed.data(), compressed.size());
-    std::vector<u8> decompressed(decompressed_size);
-
-    const std::size_t uncompressed_result_size = ZSTD_decompress(
-        decompressed.data(), decompressed.size(), compressed.data(), compressed.size());
-
-    if (decompressed_size != uncompressed_result_size || ZSTD_isError(uncompressed_result_size)) {
-        // Decompression failed
-        return {};
-    }
-    return decompressed;
-}
-
-} // namespace Common::Compression

src/common/zstd_compression.h

@@ -1,44 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-
-#include "common/common_types.h"
-
-namespace Common::Compression {
-
-/**
- * Compresses a source memory region with Zstandard and returns the compressed data in a vector.
- *
- * @param source the uncompressed source memory region.
- * @param source_size the size in bytes of the uncompressed source memory region.
- * @param compression_level the used compression level. Should be between 1 and 22.
- *
- * @return the compressed data.
- */
-std::vector<u8> CompressDataZSTD(const u8* source, std::size_t source_size, s32 compression_level);
-
-/**
- * Compresses a source memory region with Zstandard with the default compression level and returns
- * the compressed data in a vector.
- *
- * @param source the uncompressed source memory region.
- * @param source_size the size in bytes of the uncompressed source memory region.
- *
- * @return the compressed data.
- */
-std::vector<u8> CompressDataZSTDDefault(const u8* source, std::size_t source_size);
-
-/**
- * Decompresses a source memory region with Zstandard and returns the uncompressed data in a vector.
- *
- * @param compressed the compressed source memory region.
- *
- * @return the decompressed data.
- */
-std::vector<u8> DecompressDataZSTD(const std::vector<u8>& compressed);
-
-} // namespace Common::Compression

src/core/CMakeLists.txt

@@ -458,7 +458,7 @@ add_library(core STATIC
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt mbedtls opus unicorn open_source_archives)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives)
 if (ENABLE_WEB_SERVICE)
     target_compile_definitions(core PRIVATE -DENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)

src/core/arm/dynarmic/arm_dynarmic.cpp

@@ -14,7 +14,6 @@
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/gdbstub/gdbstub.h"
-#include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/vm_manager.h"
@@ -27,6 +26,7 @@ using Vector = Dynarmic::A64::Vector;
 class ARM_Dynarmic_Callbacks : public Dynarmic::A64::UserCallbacks {
 public:
     explicit ARM_Dynarmic_Callbacks(ARM_Dynarmic& parent) : parent(parent) {}
+    ~ARM_Dynarmic_Callbacks() = default;
 
     u8 MemoryRead8(u64 vaddr) override {
         return Memory::Read8(vaddr);
@@ -100,7 +100,7 @@ public:
     }
 
     void CallSVC(u32 swi) override {
-        Kernel::CallSVC(parent.system, swi);
+        Kernel::CallSVC(swi);
     }
 
     void AddTicks(u64 ticks) override {
@@ -113,14 +113,14 @@ public:
         // Always execute at least one tick.
         amortized_ticks = std::max<u64>(amortized_ticks, 1);
 
-        parent.system.CoreTiming().AddTicks(amortized_ticks);
+        parent.core_timing.AddTicks(amortized_ticks);
         num_interpreted_instructions = 0;
     }
     u64 GetTicksRemaining() override {
-        return std::max(parent.system.CoreTiming().GetDowncount(), 0);
+        return std::max(parent.core_timing.GetDowncount(), 0);
     }
     u64 GetCNTPCT() override {
-        return Timing::CpuCyclesToClockCycles(parent.system.CoreTiming().GetTicks());
+        return Timing::CpuCyclesToClockCycles(parent.core_timing.GetTicks());
     }
 
     ARM_Dynarmic& parent;
@@ -130,7 +130,7 @@ public:
 };
 
 std::unique_ptr<Dynarmic::A64::Jit> ARM_Dynarmic::MakeJit() const {
-    auto* current_process = system.Kernel().CurrentProcess();
+    auto* current_process = Core::CurrentProcess();
     auto** const page_table = current_process->VMManager().page_table.pointers.data();
 
     Dynarmic::A64::UserConfig config;
@@ -164,6 +164,7 @@ MICROPROFILE_DEFINE(ARM_Jit_Dynarmic, "ARM JIT", "Dynarmic", MP_RGB(255, 64, 64)
 
 void ARM_Dynarmic::Run() {
     MICROPROFILE_SCOPE(ARM_Jit_Dynarmic);
+    ASSERT(Memory::GetCurrentPageTable() == current_page_table);
 
     jit->Run();
 }
@@ -172,10 +173,10 @@ void ARM_Dynarmic::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
 
-ARM_Dynarmic::ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor,
+ARM_Dynarmic::ARM_Dynarmic(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
                            std::size_t core_index)
-    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{system},
-      core_index{core_index}, system{system},
+    : cb(std::make_unique<ARM_Dynarmic_Callbacks>(*this)), inner_unicorn{core_timing},
+      core_index{core_index}, core_timing{core_timing},
       exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {
     ThreadContext ctx{};
     inner_unicorn.SaveContext(ctx);
@@ -278,6 +279,7 @@ void ARM_Dynarmic::ClearExclusiveState() {
 
 void ARM_Dynarmic::PageTableChanged() {
     jit = MakeJit();
+    current_page_table = Memory::GetCurrentPageTable();
 }
 
 DynarmicExclusiveMonitor::DynarmicExclusiveMonitor(std::size_t core_count) : monitor(core_count) {}

src/core/arm/dynarmic/arm_dynarmic.h

@@ -12,16 +12,24 @@
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
 
+namespace Common {
+struct PageTable;
+}
+
+namespace Core::Timing {
+class CoreTiming;
+}
+
 namespace Core {
 
 class ARM_Dynarmic_Callbacks;
 class DynarmicExclusiveMonitor;
-class System;
 
 class ARM_Dynarmic final : public ARM_Interface {
 public:
-    ARM_Dynarmic(System& system, ExclusiveMonitor& exclusive_monitor, std::size_t core_index);
-    ~ARM_Dynarmic() override;
+    ARM_Dynarmic(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
+                 std::size_t core_index);
+    ~ARM_Dynarmic();
 
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
@@ -59,14 +67,16 @@ private:
     ARM_Unicorn inner_unicorn;
 
     std::size_t core_index;
-    System& system;
+    Timing::CoreTiming& core_timing;
     DynarmicExclusiveMonitor& exclusive_monitor;
+
+    Common::PageTable* current_page_table = nullptr;
 };
 
 class DynarmicExclusiveMonitor final : public ExclusiveMonitor {
 public:
     explicit DynarmicExclusiveMonitor(std::size_t core_count);
-    ~DynarmicExclusiveMonitor() override;
+    ~DynarmicExclusiveMonitor();
 
     void SetExclusive(std::size_t core_index, VAddr addr) override;
     void ClearExclusive() override;

src/core/arm/unicorn/arm_unicorn.cpp

@@ -10,6 +10,7 @@
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/svc.h"
+#include "core/memory.h"
 
 namespace Core {
 
@@ -48,6 +49,20 @@ static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_
     }
 }
 
+static void InterruptHook(uc_engine* uc, u32 intNo, void* user_data) {
+    u32 esr{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
+
+    auto ec = esr >> 26;
+    auto iss = esr & 0xFFFFFF;
+
+    switch (ec) {
+    case 0x15: // SVC
+        Kernel::CallSVC(iss);
+        break;
+    }
+}
+
 static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
                                void* user_data) {
     ARM_Interface::ThreadContext ctx{};
@@ -57,7 +72,7 @@ static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int si
     return {};
 }
 
-ARM_Unicorn::ARM_Unicorn(System& system) : system{system} {
+ARM_Unicorn::ARM_Unicorn(Timing::CoreTiming& core_timing) : core_timing{core_timing} {
     CHECKED(uc_open(UC_ARCH_ARM64, UC_MODE_ARM, &uc));
 
     auto fpv = 3 << 20;
@@ -162,7 +177,7 @@ void ARM_Unicorn::Run() {
     if (GDBStub::IsServerEnabled()) {
         ExecuteInstructions(std::max(4000000, 0));
     } else {
-        ExecuteInstructions(std::max(system.CoreTiming().GetDowncount(), 0));
+        ExecuteInstructions(std::max(core_timing.GetDowncount(), 0));
     }
 }
 
@@ -175,15 +190,14 @@ MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
 void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
     MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
     CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
-    system.CoreTiming().AddTicks(num_instructions);
+    core_timing.AddTicks(num_instructions);
     if (GDBStub::IsServerEnabled()) {
-        if (last_bkpt_hit && last_bkpt.type == GDBStub::BreakpointType::Execute) {
+        if (last_bkpt_hit) {
             uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
         }
-
         Kernel::Thread* thread = Kernel::GetCurrentThread();
         SaveContext(thread->GetContext());
-        if (last_bkpt_hit || GDBStub::IsMemoryBreak() || GDBStub::GetCpuStepFlag()) {
+        if (last_bkpt_hit || GDBStub::GetCpuStepFlag()) {
             last_bkpt_hit = false;
             GDBStub::Break();
             GDBStub::SendTrap(thread, 5);
@@ -258,20 +272,4 @@ void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
     last_bkpt_hit = true;
 }
 
-void ARM_Unicorn::InterruptHook(uc_engine* uc, u32 int_no, void* user_data) {
-    u32 esr{};
-    CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
-
-    const auto ec = esr >> 26;
-    const auto iss = esr & 0xFFFFFF;
-
-    auto* const arm_instance = static_cast<ARM_Unicorn*>(user_data);
-
-    switch (ec) {
-    case 0x15: // SVC
-        Kernel::CallSVC(arm_instance->system, iss);
-        break;
-    }
-}
-
 } // namespace Core

src/core/arm/unicorn/arm_unicorn.h

@@ -9,14 +9,16 @@
 #include "core/arm/arm_interface.h"
 #include "core/gdbstub/gdbstub.h"
 
-namespace Core {
+namespace Core::Timing {
+class CoreTiming;
+}
 
-class System;
+namespace Core {
 
 class ARM_Unicorn final : public ARM_Interface {
 public:
-    explicit ARM_Unicorn(System& system);
-    ~ARM_Unicorn() override;
+    explicit ARM_Unicorn(Timing::CoreTiming& core_timing);
+    ~ARM_Unicorn();
 
     void MapBackingMemory(VAddr address, std::size_t size, u8* memory,
                           Kernel::VMAPermission perms) override;
@@ -45,12 +47,10 @@ public:
     void RecordBreak(GDBStub::BreakpointAddress bkpt);
 
 private:
-    static void InterruptHook(uc_engine* uc, u32 int_no, void* user_data);
-
     uc_engine* uc{};
-    System& system;
+    Timing::CoreTiming& core_timing;
     GDBStub::BreakpointAddress last_bkpt{};
-    bool last_bkpt_hit = false;
+    bool last_bkpt_hit;
 };
 
 } // namespace Core

src/core/core.cpp

@@ -17,7 +17,6 @@
 #include "core/core_timing.h"
 #include "core/cpu_core_manager.h"
 #include "core/file_sys/mode.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
@@ -109,8 +108,6 @@ struct System::Impl {
         // Create a default fs if one doesn't already exist.
         if (virtual_filesystem == nullptr)
             virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-        if (content_provider == nullptr)
-            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
 
         /// Create default implementations of applets if one is not provided.
         if (profile_selector == nullptr)
@@ -252,8 +249,6 @@ struct System::Impl {
     Kernel::KernelCore kernel;
     /// RealVfsFilesystem instance
     FileSys::VirtualFilesystem virtual_filesystem;
-    /// ContentProviderUnion instance
-    std::unique_ptr<FileSys::ContentProviderUnion> content_provider;
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<VideoCore::RendererBase> renderer;
@@ -493,27 +488,6 @@ const Frontend::SoftwareKeyboardApplet& System::GetSoftwareKeyboard() const {
     return *impl->software_keyboard;
 }
 
-void System::SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider) {
-    impl->content_provider = std::move(provider);
-}
-
-FileSys::ContentProvider& System::GetContentProvider() {
-    return *impl->content_provider;
-}
-
-const FileSys::ContentProvider& System::GetContentProvider() const {
-    return *impl->content_provider;
-}
-
-void System::RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
-                                     FileSys::ContentProvider* provider) {
-    impl->content_provider->SetSlot(slot, provider);
-}
-
-void System::ClearContentProvider(FileSys::ContentProviderUnionSlot slot) {
-    impl->content_provider->ClearSlot(slot);
-}
-
 void System::SetWebBrowser(std::unique_ptr<Frontend::WebBrowserApplet> applet) {
     impl->web_browser = std::move(applet);
 }

src/core/core.h

@@ -21,9 +21,6 @@ class WebBrowserApplet;
 
 namespace FileSys {
 class CheatList;
-class ContentProvider;
-class ContentProviderUnion;
-enum class ContentProviderUnionSlot;
 class VfsFilesystem;
 } // namespace FileSys
 
@@ -273,17 +270,6 @@ public:
     Frontend::WebBrowserApplet& GetWebBrowser();
     const Frontend::WebBrowserApplet& GetWebBrowser() const;
 
-    void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
-
-    FileSys::ContentProvider& GetContentProvider();
-
-    const FileSys::ContentProvider& GetContentProvider() const;
-
-    void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
-                                 FileSys::ContentProvider* provider);
-
-    void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
-
 private:
     System();
 

src/core/core_cpu.cpp

@@ -22,7 +22,7 @@
 namespace Core {
 
 void CpuBarrier::NotifyEnd() {
-    std::unique_lock lock{mutex};
+    std::unique_lock<std::mutex> lock(mutex);
     end = true;
     condition.notify_all();
 }
@@ -34,7 +34,7 @@ bool CpuBarrier::Rendezvous() {
     }
 
     if (!end) {
-        std::unique_lock lock{mutex};
+        std::unique_lock<std::mutex> lock(mutex);
 
         --cores_waiting;
         if (!cores_waiting) {
@@ -55,13 +55,13 @@ Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_ba
     : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
     if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
-        arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
+        arm_interface = std::make_unique<ARM_Dynarmic>(core_timing, exclusive_monitor, core_index);
 #else
-        arm_interface = std::make_unique<ARM_Unicorn>(system);
+        arm_interface = std::make_unique<ARM_Unicorn>();
         LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
 #endif
     } else {
-        arm_interface = std::make_unique<ARM_Unicorn>(system);
+        arm_interface = std::make_unique<ARM_Unicorn>(core_timing);
     }
 
     scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
@@ -131,7 +131,7 @@ void Cpu::Reschedule() {
 
     reschedule_pending = false;
     // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock{HLE::g_hle_lock};
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
     scheduler->Reschedule();
 }
 

src/core/crypto/key_manager.cpp

@@ -22,7 +22,6 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
 #include "core/crypto/partition_data_manager.h"
@@ -795,7 +794,7 @@ void KeyManager::DeriveBase() {
 
 void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // ETicket keys
-    const auto es = Core::System::GetInstance().GetContentProvider().GetEntry(
+    const auto es = Service::FileSystem::GetUnionContents().GetEntry(
         0x0100000000000033, FileSys::ContentRecordType::Program);
 
     if (es == nullptr)

src/core/file_sys/control_metadata.cpp

@@ -67,7 +67,7 @@ std::string NACP::GetDeveloperName(Language language) const {
 }
 
 u64 NACP::GetTitleId() const {
-    return raw.save_data_owner_id;
+    return raw.title_id;
 }
 
 u64 NACP::GetDLCBaseTitleId() const {
@@ -80,11 +80,11 @@ std::string NACP::GetVersionString() const {
 }
 
 u64 NACP::GetDefaultNormalSaveSize() const {
-    return raw.user_account_save_data_size;
+    return raw.normal_save_data_size;
 }
 
 u64 NACP::GetDefaultJournalSaveSize() const {
-    return raw.user_account_save_data_journal_size;
+    return raw.journal_sava_data_size;
 }
 
 std::vector<u8> NACP::GetRawBytes() const {

src/core/file_sys/control_metadata.h

@@ -38,35 +38,23 @@ struct RawNACP {
     u8 video_capture_mode;
     bool data_loss_confirmation;
     INSERT_PADDING_BYTES(1);
-    u64_le presence_group_id;
+    u64_le title_id;
     std::array<u8, 0x20> rating_age;
     std::array<char, 0x10> version_string;
     u64_le dlc_base_title_id;
-    u64_le save_data_owner_id;
-    u64_le user_account_save_data_size;
-    u64_le user_account_save_data_journal_size;
-    u64_le device_save_data_size;
-    u64_le device_save_data_journal_size;
-    u64_le bcat_delivery_cache_storage_size;
-    char application_error_code_category[8];
+    u64_le title_id_2;
+    u64_le normal_save_data_size;
+    u64_le journal_sava_data_size;
+    INSERT_PADDING_BYTES(0x18);
+    u64_le product_code;
     std::array<u64_le, 0x8> local_communication;
     u8 logo_type;
     u8 logo_handling;
     bool runtime_add_on_content_install;
     INSERT_PADDING_BYTES(5);
-    u64_le seed_for_pseudo_device_id;
-    std::array<u8, 0x41> bcat_passphrase;
-    INSERT_PADDING_BYTES(7);
-    u64_le user_account_save_data_max_size;
-    u64_le user_account_save_data_max_journal_size;
-    u64_le device_save_data_max_size;
-    u64_le device_save_data_max_journal_size;
-    u64_le temporary_storage_size;
-    u64_le cache_storage_size;
-    u64_le cache_storage_journal_size;
-    u64_le cache_storage_data_and_journal_max_size;
-    u64_le cache_storage_max_index;
-    INSERT_PADDING_BYTES(0xE70);
+    u64_le title_id_update;
+    std::array<u8, 0x40> bcat_passphrase;
+    INSERT_PADDING_BYTES(0xEC0);
 };
 static_assert(sizeof(RawNACP) == 0x4000, "RawNACP has incorrect size.");
 

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -23,7 +23,6 @@
  */
 
 #include <cstring>
-#include <string_view>
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "core/file_sys/fsmitm_romfsbuild.h"
@@ -98,8 +97,7 @@ struct RomFSBuildFileContext {
     VirtualFile source;
 };
 
-static u32 romfs_calc_path_hash(u32 parent, std::string_view path, u32 start,
-                                std::size_t path_len) {
+static u32 romfs_calc_path_hash(u32 parent, std::string path, u32 start, std::size_t path_len) {
     u32 hash = parent ^ 123456789;
     for (u32 i = 0; i < path_len; i++) {
         hash = (hash >> 5) | (hash << 27);

src/core/file_sys/nca_metadata.cpp

@@ -10,6 +10,14 @@
 
 namespace FileSys {
 
+bool operator>=(TitleType lhs, TitleType rhs) {
+    return static_cast<std::size_t>(lhs) >= static_cast<std::size_t>(rhs);
+}
+
+bool operator<=(TitleType lhs, TitleType rhs) {
+    return static_cast<std::size_t>(lhs) <= static_cast<std::size_t>(rhs);
+}
+
 CNMT::CNMT(VirtualFile file) {
     if (file->ReadObject(&header) != sizeof(CNMTHeader))
         return;

src/core/file_sys/nca_metadata.h

@@ -29,6 +29,9 @@ enum class TitleType : u8 {
     DeltaTitle = 0x83,
 };
 
+bool operator>=(TitleType lhs, TitleType rhs);
+bool operator<=(TitleType lhs, TitleType rhs);
+
 enum class ContentRecordType : u8 {
     Meta = 0,
     Program = 1,

src/core/file_sys/patch_manager.cpp

@@ -10,7 +10,6 @@
 #include "common/file_util.h"
 #include "common/hex_util.h"
 #include "common/logging/log.h"
-#include "core/core.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/ips_layer.h"
@@ -70,7 +69,7 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
         }
     }
 
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
+    const auto installed = Service::FileSystem::GetUnionContents();
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
@@ -156,7 +155,7 @@ std::vector<VirtualFile> PatchManager::CollectPatches(const std::vector<VirtualD
     return out;
 }
 
-std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::string& name) const {
+std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso) const {
     if (nso.size() < sizeof(Loader::NSOHeader)) {
         return nso;
     }
@@ -172,19 +171,18 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
     if (Settings::values.dump_nso) {
-        LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
-                 title_id);
+        LOG_INFO(Loader, "Dumping NSO for build_id={}, title_id={:016X}", build_id, title_id);
         const auto dump_dir = Service::FileSystem::GetModificationDumpRoot(title_id);
         if (dump_dir != nullptr) {
             const auto nso_dir = GetOrCreateDirectoryRelative(dump_dir, "/nso");
-            const auto file = nso_dir->CreateFile(fmt::format("{}-{}.nso", name, build_id));
+            const auto file = nso_dir->CreateFile(fmt::format("{}.nso", build_id));
 
             file->Resize(nso.size());
             file->WriteBytes(nso);
         }
     }
 
-    LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
+    LOG_INFO(Loader, "Patching NSO for build_id={}", build_id);
 
     const auto load_dir = Service::FileSystem::GetModificationLoadRoot(title_id);
     auto patch_dirs = load_dir->GetSubdirectories();
@@ -347,7 +345,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     if (romfs == nullptr)
         return romfs;
 
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
+    const auto installed = Service::FileSystem::GetUnionContents();
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
@@ -394,7 +392,7 @@ static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
 std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
     VirtualFile update_raw) const {
     std::map<std::string, std::string, std::less<>> out;
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
+    const auto installed = Service::FileSystem::GetUnionContents();
     const auto& disabled = Settings::values.disabled_addons[title_id];
 
     // Game Updates
@@ -468,10 +466,10 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 
     // DLC
     const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
-    std::vector<ContentProviderEntry> dlc_match;
+    std::vector<RegisteredCacheEntry> dlc_match;
     dlc_match.reserve(dlc_entries.size());
     std::copy_if(dlc_entries.begin(), dlc_entries.end(), std::back_inserter(dlc_match),
-                 [this, &installed](const ContentProviderEntry& entry) {
+                 [this, &installed](const RegisteredCacheEntry& entry) {
                      return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
                             installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
                  });
@@ -494,7 +492,7 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
 }
 
 std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
+    const auto installed{Service::FileSystem::GetUnionContents()};
 
     const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr)

src/core/file_sys/patch_manager.h

@@ -44,7 +44,7 @@ public:
     // Currently tracked NSO patches:
     // - IPS
     // - IPSwitch
-    std::vector<u8> PatchNSO(const std::vector<u8>& nso, const std::string& name) const;
+    std::vector<u8> PatchNSO(const std::vector<u8>& nso) const;
 
     // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
     // Used to prevent expensive copies in NSO loader.

src/core/file_sys/program_metadata.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <cstddef>
+#include <cstring>
 #include <vector>
 
 #include "common/logging/log.h"
@@ -16,30 +17,28 @@ ProgramMetadata::ProgramMetadata() = default;
 ProgramMetadata::~ProgramMetadata() = default;
 
 Loader::ResultStatus ProgramMetadata::Load(VirtualFile file) {
-    const std::size_t total_size = file->GetSize();
-    if (total_size < sizeof(Header)) {
+    std::size_t total_size = static_cast<std::size_t>(file->GetSize());
+    if (total_size < sizeof(Header))
         return Loader::ResultStatus::ErrorBadNPDMHeader;
-    }
 
-    if (sizeof(Header) != file->ReadObject(&npdm_header)) {
+    // TODO(DarkLordZach): Use ReadObject when Header/AcidHeader becomes trivially copyable.
+    std::vector<u8> npdm_header_data = file->ReadBytes(sizeof(Header));
+    if (sizeof(Header) != npdm_header_data.size())
         return Loader::ResultStatus::ErrorBadNPDMHeader;
-    }
+    std::memcpy(&npdm_header, npdm_header_data.data(), sizeof(Header));
 
-    if (sizeof(AcidHeader) != file->ReadObject(&acid_header, npdm_header.acid_offset)) {
+    std::vector<u8> acid_header_data = file->ReadBytes(sizeof(AcidHeader), npdm_header.acid_offset);
+    if (sizeof(AcidHeader) != acid_header_data.size())
         return Loader::ResultStatus::ErrorBadACIDHeader;
-    }
+    std::memcpy(&acid_header, acid_header_data.data(), sizeof(AcidHeader));
 
-    if (sizeof(AciHeader) != file->ReadObject(&aci_header, npdm_header.aci_offset)) {
+    if (sizeof(AciHeader) != file->ReadObject(&aci_header, npdm_header.aci_offset))
         return Loader::ResultStatus::ErrorBadACIHeader;
-    }
 
-    if (sizeof(FileAccessControl) != file->ReadObject(&acid_file_access, acid_header.fac_offset)) {
+    if (sizeof(FileAccessControl) != file->ReadObject(&acid_file_access, acid_header.fac_offset))
         return Loader::ResultStatus::ErrorBadFileAccessControl;
-    }
-
-    if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset)) {
+    if (sizeof(FileAccessHeader) != file->ReadObject(&aci_file_access, aci_header.fah_offset))
         return Loader::ResultStatus::ErrorBadFileAccessHeader;
-    }
 
     aci_kernel_capabilities.resize(aci_header.kac_size / sizeof(u32));
     const u64 read_size = aci_header.kac_size;

src/core/file_sys/program_metadata.h

@@ -58,6 +58,7 @@ public:
     void Print() const;
 
 private:
+    // TODO(DarkLordZach): BitField is not trivially copyable.
     struct Header {
         std::array<char, 4> magic;
         std::array<u8, 8> reserved;
@@ -84,6 +85,7 @@ private:
 
     static_assert(sizeof(Header) == 0x80, "NPDM header structure size is wrong");
 
+    // TODO(DarkLordZach): BitField is not trivially copyable.
     struct AcidHeader {
         std::array<u8, 0x100> signature;
         std::array<u8, 0x100> nca_modulus;

src/core/file_sys/registered_cache.cpp

@@ -23,19 +23,19 @@ namespace FileSys {
 // The size of blocks to use when vfs raw copying into nand.
 constexpr size_t VFS_RC_LARGE_COPY_BLOCK = 0x400000;
 
-std::string ContentProviderEntry::DebugInfo() const {
+std::string RegisteredCacheEntry::DebugInfo() const {
     return fmt::format("title_id={:016X}, content_type={:02X}", title_id, static_cast<u8>(type));
 }
 
-bool operator<(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs) {
+bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
     return (lhs.title_id < rhs.title_id) || (lhs.title_id == rhs.title_id && lhs.type < rhs.type);
 }
 
-bool operator==(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs) {
+bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
     return std::tie(lhs.title_id, lhs.type) == std::tie(rhs.title_id, rhs.type);
 }
 
-bool operator!=(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs) {
+bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs) {
     return !operator==(lhs, rhs);
 }
 
@@ -84,7 +84,7 @@ static std::string GetCNMTName(TitleType type, u64 title_id) {
     return fmt::format("{}_{:016x}.cnmt", TITLE_TYPE_NAMES[index], title_id);
 }
 
-ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
+static ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     switch (type) {
     case NCAContentType::Program:
         // TODO(DarkLordZach): Differentiate between Program and Patch
@@ -104,28 +104,6 @@ ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
     }
 }
 
-ContentProvider::~ContentProvider() = default;
-
-bool ContentProvider::HasEntry(ContentProviderEntry entry) const {
-    return HasEntry(entry.title_id, entry.type);
-}
-
-VirtualFile ContentProvider::GetEntryUnparsed(ContentProviderEntry entry) const {
-    return GetEntryUnparsed(entry.title_id, entry.type);
-}
-
-VirtualFile ContentProvider::GetEntryRaw(ContentProviderEntry entry) const {
-    return GetEntryRaw(entry.title_id, entry.type);
-}
-
-std::unique_ptr<NCA> ContentProvider::GetEntry(ContentProviderEntry entry) const {
-    return GetEntry(entry.title_id, entry.type);
-}
-
-std::vector<ContentProviderEntry> ContentProvider::ListEntries() const {
-    return ListEntriesFilter(std::nullopt, std::nullopt, std::nullopt);
-}
-
 VirtualFile RegisteredCache::OpenFileOrDirectoryConcat(const VirtualDir& dir,
                                                        std::string_view path) const {
     const auto file = dir->GetFileRelative(path);
@@ -183,8 +161,8 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
     return file;
 }
 
-static std::optional<NcaID> CheckMapForContentRecord(const std::map<u64, CNMT>& map, u64 title_id,
-                                                     ContentRecordType type) {
+static std::optional<NcaID> CheckMapForContentRecord(
+    const boost::container::flat_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
     if (map.find(title_id) == map.end())
         return {};
 
@@ -290,7 +268,7 @@ void RegisteredCache::Refresh() {
     AccumulateYuzuMeta();
 }
 
-RegisteredCache::RegisteredCache(VirtualDir dir_, ContentProviderParsingFunction parsing_function)
+RegisteredCache::RegisteredCache(VirtualDir dir_, RegisteredCacheParsingFunction parsing_function)
     : dir(std::move(dir_)), parser(std::move(parsing_function)) {
     Refresh();
 }
@@ -301,11 +279,19 @@ bool RegisteredCache::HasEntry(u64 title_id, ContentRecordType type) const {
     return GetEntryRaw(title_id, type) != nullptr;
 }
 
+bool RegisteredCache::HasEntry(RegisteredCacheEntry entry) const {
+    return GetEntryRaw(entry) != nullptr;
+}
+
 VirtualFile RegisteredCache::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
     const auto id = GetNcaIDFromMetadata(title_id, type);
     return id ? GetFileAtID(*id) : nullptr;
 }
 
+VirtualFile RegisteredCache::GetEntryUnparsed(RegisteredCacheEntry entry) const {
+    return GetEntryUnparsed(entry.title_id, entry.type);
+}
+
 std::optional<u32> RegisteredCache::GetEntryVersion(u64 title_id) const {
     const auto meta_iter = meta.find(title_id);
     if (meta_iter != meta.end())
@@ -323,6 +309,10 @@ VirtualFile RegisteredCache::GetEntryRaw(u64 title_id, ContentRecordType type) c
     return id ? parser(GetFileAtID(*id), *id) : nullptr;
 }
 
+VirtualFile RegisteredCache::GetEntryRaw(RegisteredCacheEntry entry) const {
+    return GetEntryRaw(entry.title_id, entry.type);
+}
+
 std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType type) const {
     const auto raw = GetEntryRaw(title_id, type);
     if (raw == nullptr)
@@ -330,6 +320,10 @@ std::unique_ptr<NCA> RegisteredCache::GetEntry(u64 title_id, ContentRecordType t
     return std::make_unique<NCA>(raw, nullptr, 0, keys);
 }
 
+std::unique_ptr<NCA> RegisteredCache::GetEntry(RegisteredCacheEntry entry) const {
+    return GetEntry(entry.title_id, entry.type);
+}
+
 template <typename T>
 void RegisteredCache::IterateAllMetadata(
     std::vector<T>& out, std::function<T(const CNMT&, const ContentRecord&)> proc,
@@ -354,14 +348,25 @@ void RegisteredCache::IterateAllMetadata(
     }
 }
 
-std::vector<ContentProviderEntry> RegisteredCache::ListEntriesFilter(
-    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
-    std::optional<u64> title_id) const {
-    std::vector<ContentProviderEntry> out;
-    IterateAllMetadata<ContentProviderEntry>(
+std::vector<RegisteredCacheEntry> RegisteredCache::ListEntries() const {
+    std::vector<RegisteredCacheEntry> out;
+    IterateAllMetadata<RegisteredCacheEntry>(
         out,
         [](const CNMT& c, const ContentRecord& r) {
-            return ContentProviderEntry{c.GetTitleID(), r.type};
+            return RegisteredCacheEntry{c.GetTitleID(), r.type};
+        },
+        [](const CNMT& c, const ContentRecord& r) { return true; });
+    return out;
+}
+
+std::vector<RegisteredCacheEntry> RegisteredCache::ListEntriesFilter(
+    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
+    std::optional<u64> title_id) const {
+    std::vector<RegisteredCacheEntry> out;
+    IterateAllMetadata<RegisteredCacheEntry>(
+        out,
+        [](const CNMT& c, const ContentRecord& r) {
+            return RegisteredCacheEntry{c.GetTitleID(), r.type};
         },
         [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
             if (title_type && *title_type != c.GetType())
@@ -516,56 +521,37 @@ bool RegisteredCache::RawInstallYuzuMeta(const CNMT& cnmt) {
                         }) != yuzu_meta.end();
 }
 
-ContentProviderUnion::~ContentProviderUnion() = default;
+RegisteredCacheUnion::RegisteredCacheUnion(std::vector<RegisteredCache*> caches)
+    : caches(std::move(caches)) {}
 
-void ContentProviderUnion::SetSlot(ContentProviderUnionSlot slot, ContentProvider* provider) {
-    providers[slot] = provider;
+void RegisteredCacheUnion::Refresh() {
+    for (const auto& c : caches)
+        c->Refresh();
 }
 
-void ContentProviderUnion::ClearSlot(ContentProviderUnionSlot slot) {
-    providers[slot] = nullptr;
+bool RegisteredCacheUnion::HasEntry(u64 title_id, ContentRecordType type) const {
+    return std::any_of(caches.begin(), caches.end(), [title_id, type](const auto& cache) {
+        return cache->HasEntry(title_id, type);
+    });
 }
 
-void ContentProviderUnion::Refresh() {
-    for (auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
-
-        provider.second->Refresh();
-    }
+bool RegisteredCacheUnion::HasEntry(RegisteredCacheEntry entry) const {
+    return HasEntry(entry.title_id, entry.type);
 }
 
-bool ContentProviderUnion::HasEntry(u64 title_id, ContentRecordType type) const {
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
-
-        if (provider.second->HasEntry(title_id, type))
-            return true;
-    }
-
-    return false;
-}
-
-std::optional<u32> ContentProviderUnion::GetEntryVersion(u64 title_id) const {
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
-
-        const auto res = provider.second->GetEntryVersion(title_id);
-        if (res != std::nullopt)
+std::optional<u32> RegisteredCacheUnion::GetEntryVersion(u64 title_id) const {
+    for (const auto& c : caches) {
+        const auto res = c->GetEntryVersion(title_id);
+        if (res)
             return res;
     }
 
-    return std::nullopt;
+    return {};
 }
 
-VirtualFile ContentProviderUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
-
-        const auto res = provider.second->GetEntryUnparsed(title_id, type);
+VirtualFile RegisteredCacheUnion::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
+    for (const auto& c : caches) {
+        const auto res = c->GetEntryUnparsed(title_id, type);
         if (res != nullptr)
             return res;
     }
@@ -573,12 +559,13 @@ VirtualFile ContentProviderUnion::GetEntryUnparsed(u64 title_id, ContentRecordTy
     return nullptr;
 }
 
-VirtualFile ContentProviderUnion::GetEntryRaw(u64 title_id, ContentRecordType type) const {
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
+VirtualFile RegisteredCacheUnion::GetEntryUnparsed(RegisteredCacheEntry entry) const {
+    return GetEntryUnparsed(entry.title_id, entry.type);
+}
 
-        const auto res = provider.second->GetEntryRaw(title_id, type);
+VirtualFile RegisteredCacheUnion::GetEntryRaw(u64 title_id, ContentRecordType type) const {
+    for (const auto& c : caches) {
+        const auto res = c->GetEntryRaw(title_id, type);
         if (res != nullptr)
             return res;
     }
@@ -586,30 +573,30 @@ VirtualFile ContentProviderUnion::GetEntryRaw(u64 title_id, ContentRecordType ty
     return nullptr;
 }
 
-std::unique_ptr<NCA> ContentProviderUnion::GetEntry(u64 title_id, ContentRecordType type) const {
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
-
-        auto res = provider.second->GetEntry(title_id, type);
-        if (res != nullptr)
-            return res;
-    }
-
-    return nullptr;
+VirtualFile RegisteredCacheUnion::GetEntryRaw(RegisteredCacheEntry entry) const {
+    return GetEntryRaw(entry.title_id, entry.type);
 }
 
-std::vector<ContentProviderEntry> ContentProviderUnion::ListEntriesFilter(
-    std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
-    std::optional<u64> title_id) const {
-    std::vector<ContentProviderEntry> out;
+std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(u64 title_id, ContentRecordType type) const {
+    const auto raw = GetEntryRaw(title_id, type);
+    if (raw == nullptr)
+        return nullptr;
+    return std::make_unique<NCA>(raw);
+}
 
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
+std::unique_ptr<NCA> RegisteredCacheUnion::GetEntry(RegisteredCacheEntry entry) const {
+    return GetEntry(entry.title_id, entry.type);
+}
 
-        const auto vec = provider.second->ListEntriesFilter(title_type, record_type, title_id);
-        std::copy(vec.begin(), vec.end(), std::back_inserter(out));
+std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntries() const {
+    std::vector<RegisteredCacheEntry> out;
+    for (const auto& c : caches) {
+        c->IterateAllMetadata<RegisteredCacheEntry>(
+            out,
+            [](const CNMT& c, const ContentRecord& r) {
+                return RegisteredCacheEntry{c.GetTitleID(), r.type};
+            },
+            [](const CNMT& c, const ContentRecord& r) { return true; });
     }
 
     std::sort(out.begin(), out.end());
@@ -617,87 +604,25 @@ std::vector<ContentProviderEntry> ContentProviderUnion::ListEntriesFilter(
     return out;
 }
 
-std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>>
-ContentProviderUnion::ListEntriesFilterOrigin(std::optional<ContentProviderUnionSlot> origin,
-                                              std::optional<TitleType> title_type,
-                                              std::optional<ContentRecordType> record_type,
-                                              std::optional<u64> title_id) const {
-    std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>> out;
-
-    for (const auto& provider : providers) {
-        if (provider.second == nullptr)
-            continue;
-
-        if (origin.has_value() && *origin != provider.first)
-            continue;
-
-        const auto vec = provider.second->ListEntriesFilter(title_type, record_type, title_id);
-        std::transform(vec.begin(), vec.end(), std::back_inserter(out),
-                       [&provider](const ContentProviderEntry& entry) {
-                           return std::make_pair(provider.first, entry);
-                       });
-    }
-
-    std::sort(out.begin(), out.end());
-    out.erase(std::unique(out.begin(), out.end()), out.end());
-    return out;
-}
-
-ManualContentProvider::~ManualContentProvider() = default;
-
-void ManualContentProvider::AddEntry(TitleType title_type, ContentRecordType content_type,
-                                     u64 title_id, VirtualFile file) {
-    entries.insert_or_assign({title_type, content_type, title_id}, file);
-}
-
-void ManualContentProvider::ClearAllEntries() {
-    entries.clear();
-}
-
-void ManualContentProvider::Refresh() {}
-
-bool ManualContentProvider::HasEntry(u64 title_id, ContentRecordType type) const {
-    return GetEntryRaw(title_id, type) != nullptr;
-}
-
-std::optional<u32> ManualContentProvider::GetEntryVersion(u64 title_id) const {
-    return std::nullopt;
-}
-
-VirtualFile ManualContentProvider::GetEntryUnparsed(u64 title_id, ContentRecordType type) const {
-    return GetEntryRaw(title_id, type);
-}
-
-VirtualFile ManualContentProvider::GetEntryRaw(u64 title_id, ContentRecordType type) const {
-    const auto iter =
-        std::find_if(entries.begin(), entries.end(), [title_id, type](const auto& entry) {
-            const auto [title_type, content_type, e_title_id] = entry.first;
-            return content_type == type && e_title_id == title_id;
-        });
-    if (iter == entries.end())
-        return nullptr;
-    return iter->second;
-}
-
-std::unique_ptr<NCA> ManualContentProvider::GetEntry(u64 title_id, ContentRecordType type) const {
-    const auto res = GetEntryRaw(title_id, type);
-    if (res == nullptr)
-        return nullptr;
-    return std::make_unique<NCA>(res, nullptr, 0, keys);
-}
-
-std::vector<ContentProviderEntry> ManualContentProvider::ListEntriesFilter(
+std::vector<RegisteredCacheEntry> RegisteredCacheUnion::ListEntriesFilter(
     std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
     std::optional<u64> title_id) const {
-    std::vector<ContentProviderEntry> out;
-
-    for (const auto& entry : entries) {
-        const auto [e_title_type, e_content_type, e_title_id] = entry.first;
-        if ((title_type == std::nullopt || e_title_type == *title_type) &&
-            (record_type == std::nullopt || e_content_type == *record_type) &&
-            (title_id == std::nullopt || e_title_id == *title_id)) {
-            out.emplace_back(ContentProviderEntry{e_title_id, e_content_type});
-        }
+    std::vector<RegisteredCacheEntry> out;
+    for (const auto& c : caches) {
+        c->IterateAllMetadata<RegisteredCacheEntry>(
+            out,
+            [](const CNMT& c, const ContentRecord& r) {
+                return RegisteredCacheEntry{c.GetTitleID(), r.type};
+            },
+            [&title_type, &record_type, &title_id](const CNMT& c, const ContentRecord& r) {
+                if (title_type && *title_type != c.GetType())
+                    return false;
+                if (record_type && *record_type != r.type)
+                    return false;
+                if (title_id && *title_id != c.GetTitleID())
+                    return false;
+                return true;
+            });
     }
 
     std::sort(out.begin(), out.end());

src/core/file_sys/registered_cache.h

@@ -21,13 +21,12 @@ class NSP;
 class XCI;
 
 enum class ContentRecordType : u8;
-enum class NCAContentType : u8;
 enum class TitleType : u8;
 
 struct ContentRecord;
 
 using NcaID = std::array<u8, 0x10>;
-using ContentProviderParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
+using RegisteredCacheParsingFunction = std::function<VirtualFile(const VirtualFile&, const NcaID&)>;
 using VfsCopyFunction = std::function<bool(const VirtualFile&, const VirtualFile&, size_t)>;
 
 enum class InstallResult {
@@ -37,7 +36,7 @@ enum class InstallResult {
     ErrorMetaFailed,
 };
 
-struct ContentProviderEntry {
+struct RegisteredCacheEntry {
     u64 title_id;
     ContentRecordType type;
 
@@ -48,46 +47,12 @@ constexpr u64 GetUpdateTitleID(u64 base_title_id) {
     return base_title_id | 0x800;
 }
 
-ContentRecordType GetCRTypeFromNCAType(NCAContentType type);
-
 // boost flat_map requires operator< for O(log(n)) lookups.
-bool operator<(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs);
+bool operator<(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
 
 // std unique requires operator== to identify duplicates.
-bool operator==(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs);
-bool operator!=(const ContentProviderEntry& lhs, const ContentProviderEntry& rhs);
-
-class ContentProvider {
-public:
-    virtual ~ContentProvider();
-
-    virtual void Refresh() = 0;
-
-    virtual bool HasEntry(u64 title_id, ContentRecordType type) const = 0;
-    virtual bool HasEntry(ContentProviderEntry entry) const;
-
-    virtual std::optional<u32> GetEntryVersion(u64 title_id) const = 0;
-
-    virtual VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const = 0;
-    virtual VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const;
-
-    virtual VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const = 0;
-    virtual VirtualFile GetEntryRaw(ContentProviderEntry entry) const;
-
-    virtual std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const = 0;
-    virtual std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const;
-
-    virtual std::vector<ContentProviderEntry> ListEntries() const;
-
-    // If a parameter is not std::nullopt, it will be filtered for from all entries.
-    virtual std::vector<ContentProviderEntry> ListEntriesFilter(
-        std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
-        std::optional<u64> title_id = {}) const = 0;
-
-protected:
-    // A single instance of KeyManager to be used by GetEntry()
-    Core::Crypto::KeyManager keys;
-};
+bool operator==(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
+bool operator!=(const RegisteredCacheEntry& lhs, const RegisteredCacheEntry& rhs);
 
 /*
  * A class that catalogues NCAs in the registered directory structure.
@@ -102,32 +67,39 @@ protected:
  * (This impl also supports substituting the nca dir for an nca file, as that's more convenient
  * when 4GB splitting can be ignored.)
  */
-class RegisteredCache : public ContentProvider {
+class RegisteredCache {
+    friend class RegisteredCacheUnion;
+
 public:
     // Parsing function defines the conversion from raw file to NCA. If there are other steps
     // besides creating the NCA from the file (e.g. NAX0 on SD Card), that should go in a custom
     // parsing function.
     explicit RegisteredCache(VirtualDir dir,
-                             ContentProviderParsingFunction parsing_function =
+                             RegisteredCacheParsingFunction parsing_function =
                                  [](const VirtualFile& file, const NcaID& id) { return file; });
-    ~RegisteredCache() override;
+    ~RegisteredCache();
 
-    void Refresh() override;
+    void Refresh();
 
-    bool HasEntry(u64 title_id, ContentRecordType type) const override;
+    bool HasEntry(u64 title_id, ContentRecordType type) const;
+    bool HasEntry(RegisteredCacheEntry entry) const;
 
-    std::optional<u32> GetEntryVersion(u64 title_id) const override;
+    std::optional<u32> GetEntryVersion(u64 title_id) const;
 
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const override;
+    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
+    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
 
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const override;
+    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
+    VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
 
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const override;
+    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
+    std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
 
+    std::vector<RegisteredCacheEntry> ListEntries() const;
     // If a parameter is not std::nullopt, it will be filtered for from all entries.
-    std::vector<ContentProviderEntry> ListEntriesFilter(
+    std::vector<RegisteredCacheEntry> ListEntriesFilter(
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
-        std::optional<u64> title_id = {}) const override;
+        std::optional<u64> title_id = {}) const;
 
     // Raw copies all the ncas from the xci/nsp to the csache. Does some quick checks to make sure
     // there is a meta NCA and all of them are accessible.
@@ -159,70 +131,46 @@ private:
     bool RawInstallYuzuMeta(const CNMT& cnmt);
 
     VirtualDir dir;
-    ContentProviderParsingFunction parser;
+    RegisteredCacheParsingFunction parser;
+    Core::Crypto::KeyManager keys;
 
     // maps tid -> NcaID of meta
-    std::map<u64, NcaID> meta_id;
+    boost::container::flat_map<u64, NcaID> meta_id;
     // maps tid -> meta
-    std::map<u64, CNMT> meta;
+    boost::container::flat_map<u64, CNMT> meta;
     // maps tid -> meta for CNMT in yuzu_meta
-    std::map<u64, CNMT> yuzu_meta;
+    boost::container::flat_map<u64, CNMT> yuzu_meta;
 };
 
-enum class ContentProviderUnionSlot {
-    SysNAND,        ///< System NAND
-    UserNAND,       ///< User NAND
-    SDMC,           ///< SD Card
-    FrontendManual, ///< Frontend-defined game list or similar
-};
-
-// Combines multiple ContentProvider(s) (i.e. SysNAND, UserNAND, SDMC) into one interface.
-class ContentProviderUnion : public ContentProvider {
+// Combines multiple RegisteredCaches (i.e. SysNAND, UserNAND, SDMC) into one interface.
+class RegisteredCacheUnion {
 public:
-    ~ContentProviderUnion() override;
+    explicit RegisteredCacheUnion(std::vector<RegisteredCache*> caches);
 
-    void SetSlot(ContentProviderUnionSlot slot, ContentProvider* provider);
-    void ClearSlot(ContentProviderUnionSlot slot);
+    void Refresh();
 
-    void Refresh() override;
-    bool HasEntry(u64 title_id, ContentRecordType type) const override;
-    std::optional<u32> GetEntryVersion(u64 title_id) const override;
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const override;
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const override;
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const override;
-    std::vector<ContentProviderEntry> ListEntriesFilter(
-        std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
-        std::optional<u64> title_id) const override;
+    bool HasEntry(u64 title_id, ContentRecordType type) const;
+    bool HasEntry(RegisteredCacheEntry entry) const;
 
-    std::vector<std::pair<ContentProviderUnionSlot, ContentProviderEntry>> ListEntriesFilterOrigin(
-        std::optional<ContentProviderUnionSlot> origin = {},
+    std::optional<u32> GetEntryVersion(u64 title_id) const;
+
+    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const;
+    VirtualFile GetEntryUnparsed(RegisteredCacheEntry entry) const;
+
+    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const;
+    VirtualFile GetEntryRaw(RegisteredCacheEntry entry) const;
+
+    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const;
+    std::unique_ptr<NCA> GetEntry(RegisteredCacheEntry entry) const;
+
+    std::vector<RegisteredCacheEntry> ListEntries() const;
+    // If a parameter is not std::nullopt, it will be filtered for from all entries.
+    std::vector<RegisteredCacheEntry> ListEntriesFilter(
         std::optional<TitleType> title_type = {}, std::optional<ContentRecordType> record_type = {},
         std::optional<u64> title_id = {}) const;
 
 private:
-    std::map<ContentProviderUnionSlot, ContentProvider*> providers;
-};
-
-class ManualContentProvider : public ContentProvider {
-public:
-    ~ManualContentProvider() override;
-
-    void AddEntry(TitleType title_type, ContentRecordType content_type, u64 title_id,
-                  VirtualFile file);
-    void ClearAllEntries();
-
-    void Refresh() override;
-    bool HasEntry(u64 title_id, ContentRecordType type) const override;
-    std::optional<u32> GetEntryVersion(u64 title_id) const override;
-    VirtualFile GetEntryUnparsed(u64 title_id, ContentRecordType type) const override;
-    VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const override;
-    std::unique_ptr<NCA> GetEntry(u64 title_id, ContentRecordType type) const override;
-    std::vector<ContentProviderEntry> ListEntriesFilter(
-        std::optional<TitleType> title_type, std::optional<ContentRecordType> record_type,
-        std::optional<u64> title_id) const override;
-
-private:
-    std::map<std::tuple<TitleType, ContentRecordType, u64>, VirtualFile> entries;
+    std::vector<RegisteredCache*> caches;
 };
 
 } // namespace FileSys

src/core/file_sys/romfs_factory.cpp

@@ -48,7 +48,7 @@ ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, Conte
 
     switch (storage) {
     case StorageId::None:
-        res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
+        res = Service::FileSystem::GetUnionContents().GetEntry(title_id, type);
         break;
     case StorageId::NandSystem:
         res = Service::FileSystem::GetSystemNANDContents()->GetEntry(title_id, type);

src/core/file_sys/savedata_factory.cpp

@@ -16,10 +16,8 @@ namespace FileSys {
 constexpr char SAVE_DATA_SIZE_FILENAME[] = ".yuzu_save_size";
 
 std::string SaveDataDescriptor::DebugInfo() const {
-    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}, "
-                       "rank={}, index={}]",
-                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id,
-                       static_cast<u8>(rank), index);
+    return fmt::format("[type={:02X}, title_id={:016X}, user_id={:016X}{:016X}, save_id={:016X}]",
+                       static_cast<u8>(type), title_id, user_id[1], user_id[0], save_id);
 }
 
 SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save_directory)) {
@@ -30,7 +28,7 @@ SaveDataFactory::SaveDataFactory(VirtualDir save_directory) : dir(std::move(save
 
 SaveDataFactory::~SaveDataFactory() = default;
 
-ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataDescriptor& meta) {
+ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space, SaveDataDescriptor meta) {
     if (meta.type == SaveDataType::SystemSaveData || meta.type == SaveDataType::SaveData) {
         if (meta.zero_1 != 0) {
             LOG_WARNING(Service_FS,

src/core/file_sys/savedata_factory.h

@@ -32,19 +32,12 @@ enum class SaveDataType : u8 {
     CacheStorage = 5,
 };
 
-enum class SaveDataRank : u8 {
-    Primary,
-    Secondary,
-};
-
 struct SaveDataDescriptor {
     u64_le title_id;
     u128 user_id;
     u64_le save_id;
     SaveDataType type;
-    SaveDataRank rank;
-    u16_le index;
-    INSERT_PADDING_BYTES(4);
+    INSERT_PADDING_BYTES(7);
     u64_le zero_1;
     u64_le zero_2;
     u64_le zero_3;
@@ -64,7 +57,7 @@ public:
     explicit SaveDataFactory(VirtualDir dir);
     ~SaveDataFactory();
 
-    ResultVal<VirtualDir> Open(SaveDataSpaceId space, const SaveDataDescriptor& meta);
+    ResultVal<VirtualDir> Open(SaveDataSpaceId space, SaveDataDescriptor meta);
 
     VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
 

src/core/file_sys/submission_package.cpp

@@ -143,12 +143,11 @@ std::multimap<u64, std::shared_ptr<NCA>> NSP::GetNCAsByTitleID() const {
     return out;
 }
 
-std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>>
-NSP::GetNCAs() const {
+std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> NSP::GetNCAs() const {
     return ncas;
 }
 
-std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type, TitleType title_type) const {
+std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type) const {
     if (extracted)
         LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
 
@@ -156,14 +155,14 @@ std::shared_ptr<NCA> NSP::GetNCA(u64 title_id, ContentRecordType type, TitleType
     if (title_id_iter == ncas.end())
         return nullptr;
 
-    const auto type_iter = title_id_iter->second.find({title_type, type});
+    const auto type_iter = title_id_iter->second.find(type);
     if (type_iter == title_id_iter->second.end())
         return nullptr;
 
     return type_iter->second;
 }
 
-VirtualFile NSP::GetNCAFile(u64 title_id, ContentRecordType type, TitleType title_type) const {
+VirtualFile NSP::GetNCAFile(u64 title_id, ContentRecordType type) const {
     if (extracted)
         LOG_WARNING(Service_FS, "called on an NSP that is of type extracted.");
     const auto nca = GetNCA(title_id, type);
@@ -241,7 +240,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
             const CNMT cnmt(inner_file);
             auto& ncas_title = ncas[cnmt.GetTitleID()];
 
-            ncas_title[{cnmt.GetType(), ContentRecordType::Meta}] = nca;
+            ncas_title[ContentRecordType::Meta] = nca;
             for (const auto& rec : cnmt.GetContentRecords()) {
                 const auto id_string = Common::HexArrayToString(rec.nca_id, false);
                 const auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
@@ -259,7 +258,7 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
                     (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
                      (cnmt.GetTitleID() & 0x800) != 0)) {
-                    ncas_title[{cnmt.GetType(), rec.type}] = std::move(next_nca);
+                    ncas_title[rec.type] = std::move(next_nca);
                 }
             }
 

src/core/file_sys/submission_package.h

@@ -42,12 +42,9 @@ public:
     // Type 0 Only (Collection of NCAs + Certificate + Ticket + Meta XML)
     std::vector<std::shared_ptr<NCA>> GetNCAsCollapsed() const;
     std::multimap<u64, std::shared_ptr<NCA>> GetNCAsByTitleID() const;
-    std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>> GetNCAs()
-        const;
-    std::shared_ptr<NCA> GetNCA(u64 title_id, ContentRecordType type,
-                                TitleType title_type = TitleType::Application) const;
-    VirtualFile GetNCAFile(u64 title_id, ContentRecordType type,
-                           TitleType title_type = TitleType::Application) const;
+    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> GetNCAs() const;
+    std::shared_ptr<NCA> GetNCA(u64 title_id, ContentRecordType type) const;
+    VirtualFile GetNCAFile(u64 title_id, ContentRecordType type) const;
     std::vector<Core::Crypto::Key128> GetTitlekey() const;
 
     std::vector<VirtualFile> GetFiles() const override;
@@ -70,7 +67,7 @@ private:
 
     std::shared_ptr<PartitionFilesystem> pfs;
     // Map title id -> {map type -> NCA}
-    std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>> ncas;
+    std::map<u64, std::map<ContentRecordType, std::shared_ptr<NCA>>> ncas;
     std::vector<VirtualFile> ticket_files;
 
     Core::Crypto::KeyManager keys;

src/core/frontend/emu_window.cpp

@@ -30,7 +30,7 @@ private:
         explicit Device(std::weak_ptr<TouchState>&& touch_state) : touch_state(touch_state) {}
         std::tuple<float, float, bool> GetStatus() const override {
             if (auto state = touch_state.lock()) {
-                std::lock_guard guard{state->mutex};
+                std::lock_guard<std::mutex> guard(state->mutex);
                 return std::make_tuple(state->touch_x, state->touch_y, state->touch_pressed);
             }
             return std::make_tuple(0.0f, 0.0f, false);
@@ -81,7 +81,7 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) {
     if (!IsWithinTouchscreen(framebuffer_layout, framebuffer_x, framebuffer_y))
         return;
 
-    std::lock_guard guard{touch_state->mutex};
+    std::lock_guard<std::mutex> guard(touch_state->mutex);
     touch_state->touch_x = static_cast<float>(framebuffer_x - framebuffer_layout.screen.left) /
                            (framebuffer_layout.screen.right - framebuffer_layout.screen.left);
     touch_state->touch_y = static_cast<float>(framebuffer_y - framebuffer_layout.screen.top) /
@@ -91,7 +91,7 @@ void EmuWindow::TouchPressed(unsigned framebuffer_x, unsigned framebuffer_y) {
 }
 
 void EmuWindow::TouchReleased() {
-    std::lock_guard guard{touch_state->mutex};
+    std::lock_guard<std::mutex> guard(touch_state->mutex);
     touch_state->touch_pressed = false;
     touch_state->touch_x = 0;
     touch_state->touch_y = 0;

src/core/frontend/emu_window.h

@@ -12,23 +12,6 @@
 
 namespace Core::Frontend {
 
-/**
- * Represents a graphics context that can be used for background computation or drawing. If the
- * graphics backend doesn't require the context, then the implementation of these methods can be
- * stubs
- */
-class GraphicsContext {
-public:
-    /// Makes the graphics context current for the caller thread
-    virtual void MakeCurrent() = 0;
-
-    /// Releases (dunno if this is the "right" word) the context from the caller thread
-    virtual void DoneCurrent() = 0;
-
-    /// Swap buffers to display the next frame
-    virtual void SwapBuffers() = 0;
-};
-
 /**
  * Abstraction class used to provide an interface between emulation code and the frontend
  * (e.g. SDL, QGLWidget, GLFW, etc...).
@@ -47,7 +30,7 @@ public:
  * - DO NOT TREAT THIS CLASS AS A GUI TOOLKIT ABSTRACTION LAYER. That's not what it is. Please
  *   re-read the upper points again and think about it if you don't see this.
  */
-class EmuWindow : public GraphicsContext {
+class EmuWindow {
 public:
     /// Data structure to store emuwindow configuration
     struct WindowConfig {
@@ -57,21 +40,17 @@ public:
         std::pair<unsigned, unsigned> min_client_area_size;
     };
 
+    /// Swap buffers to display the next frame
+    virtual void SwapBuffers() = 0;
+
     /// Polls window events
     virtual void PollEvents() = 0;
 
-    /**
-     * Returns a GraphicsContext that the frontend provides that is shared with the emu window. This
-     * context can be used from other threads for background graphics computation. If the frontend
-     * is using a graphics backend that doesn't need anything specific to run on a different thread,
-     * then it can use a stubbed implemenation for GraphicsContext.
-     *
-     * If the return value is null, then the core should assume that the frontend cannot provide a
-     * Shared Context
-     */
-    virtual std::unique_ptr<GraphicsContext> CreateSharedContext() const {
-        return nullptr;
-    }
+    /// Makes the graphics context current for the caller thread
+    virtual void MakeCurrent() = 0;
+
+    /// Releases (dunno if this is the "right" word) the GLFW context from the caller thread
+    virtual void DoneCurrent() = 0;
 
     /**
      * Signal that a touch pressed event has occurred (e.g. mouse click pressed)

src/core/gdbstub/gdbstub.cpp

@@ -1030,7 +1030,7 @@ static void Step() {
 
 /// Tell the CPU if we hit a memory breakpoint.
 bool IsMemoryBreak() {
-    if (!IsConnected()) {
+    if (IsConnected()) {
         return false;
     }
 

src/core/hle/ipc_helpers.h

@@ -139,8 +139,10 @@ public:
             context->AddDomainObject(std::move(iface));
         } else {
             auto& kernel = Core::System::GetInstance().Kernel();
-            auto [server, client] =
+            auto sessions =
                 Kernel::ServerSession::CreateSessionPair(kernel, iface->GetServiceName());
+            auto server = std::get<Kernel::SharedPtr<Kernel::ServerSession>>(sessions);
+            auto client = std::get<Kernel::SharedPtr<Kernel::ClientSession>>(sessions);
             iface->ClientConnected(server);
             context->AddMoveObject(std::move(client));
         }

src/core/hle/kernel/client_port.cpp

@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <tuple>
+
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
 #include "core/hle/kernel/errors.h"
@@ -29,18 +31,18 @@ ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     active_sessions++;
 
     // Create a new session pair, let the created sessions inherit the parent port's HLE handler.
-    auto [server, client] = ServerSession::CreateSessionPair(kernel, server_port->GetName(), this);
+    auto sessions = ServerSession::CreateSessionPair(kernel, server_port->GetName(), this);
 
     if (server_port->HasHLEHandler()) {
-        server_port->GetHLEHandler()->ClientConnected(server);
+        server_port->GetHLEHandler()->ClientConnected(std::get<SharedPtr<ServerSession>>(sessions));
     } else {
-        server_port->AppendPendingSession(server);
+        server_port->AppendPendingSession(std::get<SharedPtr<ServerSession>>(sessions));
     }
 
     // Wake the threads waiting on the ServerPort
     server_port->WakeupAllWaitingThreads();
 
-    return MakeResult(client);
+    return MakeResult(std::get<SharedPtr<ClientSession>>(sessions));
 }
 
 void ClientPort::ConnectionClosed() {

src/core/hle/kernel/client_port.h

@@ -25,7 +25,7 @@ public:
         return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::ClientPort;
+    static const HandleType HANDLE_TYPE = HandleType::ClientPort;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/client_session.h

@@ -29,7 +29,7 @@ public:
         return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::ClientSession;
+    static const HandleType HANDLE_TYPE = HandleType::ClientSession;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/kernel/code_set.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cstddef>
+#include <memory>
 #include <vector>
 
 #include "common/common_types.h"
@@ -77,7 +78,7 @@ struct CodeSet final {
     }
 
     /// The overall data that backs this code set.
-    std::vector<u8> memory;
+    std::shared_ptr<std::vector<u8>> memory;
 
     /// The segments that comprise this code set.
     std::array<Segment, 3> segments;

src/core/hle/kernel/kernel.cpp

@@ -21,7 +21,6 @@
 #include "core/hle/kernel/thread.h"
 #include "core/hle/lock.h"
 #include "core/hle/result.h"
-#include "core/memory.h"
 
 namespace Kernel {
 
@@ -35,7 +34,7 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] s64 cycles_
     const auto& system = Core::System::GetInstance();
 
     // Lock the global kernel mutex when we enter the kernel HLE.
-    std::lock_guard lock{HLE::g_hle_lock};
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
 
     SharedPtr<Thread> thread =
         system.Kernel().RetrieveThreadFromWakeupCallbackHandleTable(proper_handle);
@@ -116,7 +115,7 @@ struct KernelCore::Impl {
 
     // Creates the default system resource limit
     void InitializeSystemResourceLimit(KernelCore& kernel) {
-        system_resource_limit = ResourceLimit::Create(kernel);
+        system_resource_limit = ResourceLimit::Create(kernel, "System");
 
         // If setting the default system values fails, then something seriously wrong has occurred.
         ASSERT(system_resource_limit->SetLimitValue(ResourceType::PhysicalMemory, 0x200000000)
@@ -182,7 +181,6 @@ void KernelCore::AppendNewProcess(SharedPtr<Process> process) {
 
 void KernelCore::MakeCurrentProcess(Process* process) {
     impl->current_process = process;
-    Memory::SetCurrentPageTable(&process->VMManager().page_table);
 }
 
 Process* KernelCore::CurrentProcess() {
@@ -193,10 +191,6 @@ const Process* KernelCore::CurrentProcess() const {
     return impl->current_process;
 }
 
-const std::vector<SharedPtr<Process>>& KernelCore::GetProcessList() const {
-    return impl->process_list;
-}
-
 void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
     impl->named_ports.emplace(std::move(name), std::move(port));
 }

src/core/hle/kernel/kernel.h

@@ -72,9 +72,6 @@ public:
     /// Retrieves a const pointer to the current process.
     const Process* CurrentProcess() const;
 
-    /// Retrieves the list of processes.
-    const std::vector<SharedPtr<Process>>& GetProcessList() const;
-
     /// Adds a port to the named port table
     void AddNamedPort(std::string name, SharedPtr<ClientPort> port);
 

src/core/hle/kernel/object.cpp

@@ -24,6 +24,7 @@ bool Object::IsWaitable() const {
     case HandleType::WritableEvent:
     case HandleType::SharedMemory:
     case HandleType::TransferMemory:
+    case HandleType::AddressArbiter:
     case HandleType::ResourceLimit:
     case HandleType::ClientPort:
     case HandleType::ClientSession:

src/core/hle/kernel/object.h

@@ -25,6 +25,7 @@ enum class HandleType : u32 {
     TransferMemory,
     Thread,
     Process,
+    AddressArbiter,
     ResourceLimit,
     ClientPort,
     ServerPort,

src/core/hle/kernel/process.cpp

@@ -32,6 +32,9 @@ namespace {
  * @param priority The priority to give the main thread
  */
 void SetupMainThread(Process& owner_process, KernelCore& kernel, VAddr entry_point, u32 priority) {
+    // Setup page table so we can write to memory
+    Memory::SetCurrentPageTable(&owner_process.VMManager().page_table);
+
     // Initialize new "main" thread
     const VAddr stack_top = owner_process.VMManager().GetTLSIORegionEndAddress();
     auto thread_res = Thread::Create(kernel, "main", entry_point, priority, 0,
@@ -40,8 +43,9 @@ void SetupMainThread(Process& owner_process, KernelCore& kernel, VAddr entry_poi
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    const Handle thread_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
-    thread->GetContext().cpu_registers[1] = thread_handle;
+    const Handle guest_handle = owner_process.GetHandleTable().Create(thread).Unwrap();
+    thread->SetGuestHandle(guest_handle);
+    thread->GetContext().cpu_registers[1] = guest_handle;
 
     // Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
     thread->ResumeFromWait();
@@ -76,14 +80,6 @@ u64 Process::GetTotalPhysicalMemoryUsed() const {
     return vm_manager.GetCurrentHeapSize() + main_thread_stack_size + code_memory_size;
 }
 
-void Process::RegisterThread(const Thread* thread) {
-    thread_list.push_back(thread);
-}
-
-void Process::UnregisterThread(const Thread* thread) {
-    thread_list.remove(thread);
-}
-
 ResultCode Process::ClearSignalState() {
     if (status == ProcessStatus::Exited) {
         LOG_ERROR(Kernel, "called on a terminated process instance.");
@@ -105,8 +101,6 @@ ResultCode Process::LoadFromMetadata(const FileSys::ProgramMetadata& metadata) {
     is_64bit_process = metadata.Is64BitProgram();
 
     vm_manager.Reset(metadata.GetAddressSpaceType());
-    // Ensure that the potentially resized page table is seen by CPU backends.
-    Memory::SetCurrentPageTable(&vm_manager.page_table);
 
     const auto& caps = metadata.GetKernelCapabilities();
     const auto capability_init_result =
@@ -224,13 +218,11 @@ void Process::FreeTLSSlot(VAddr tls_address) {
 }
 
 void Process::LoadModule(CodeSet module_, VAddr base_addr) {
-    const auto memory = std::make_shared<std::vector<u8>>(std::move(module_.memory));
-
     const auto MapSegment = [&](const CodeSet::Segment& segment, VMAPermission permissions,
                                 MemoryState memory_state) {
         const auto vma = vm_manager
-                             .MapMemoryBlock(segment.addr + base_addr, memory, segment.offset,
-                                             segment.size, memory_state)
+                             .MapMemoryBlock(segment.addr + base_addr, module_.memory,
+                                             segment.offset, segment.size, memory_state)
                              .Unwrap();
         vm_manager.Reprotect(vma, permissions);
     };
@@ -240,7 +232,7 @@ void Process::LoadModule(CodeSet module_, VAddr base_addr) {
     MapSegment(module_.RODataSegment(), VMAPermission::Read, MemoryState::CodeData);
     MapSegment(module_.DataSegment(), VMAPermission::ReadWrite, MemoryState::CodeData);
 
-    code_memory_size += module_.memory.size();
+    code_memory_size += module_.memory->size();
 
     // Clear instruction cache in CPU JIT
     system.InvalidateCpuInstructionCaches();
@@ -255,7 +247,7 @@ void Process::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "Object unavailable!");
 }
 
-bool Process::ShouldWait(const Thread* thread) const {
+bool Process::ShouldWait(Thread* thread) const {
     return !is_signaled;
 }
 

src/core/hle/kernel/process.h

@@ -7,7 +7,6 @@
 #include <array>
 #include <bitset>
 #include <cstddef>
-#include <list>
 #include <string>
 #include <vector>
 #include <boost/container/static_vector.hpp>
@@ -85,7 +84,7 @@ public:
         return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::Process;
+    static const HandleType HANDLE_TYPE = HandleType::Process;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -190,19 +189,6 @@ public:
     /// Retrieves the total physical memory used by this process in bytes.
     u64 GetTotalPhysicalMemoryUsed() const;
 
-    /// Gets the list of all threads created with this process as their owner.
-    const std::list<const Thread*>& GetThreadList() const {
-        return thread_list;
-    }
-
-    /// Registers a thread as being created under this process,
-    /// adding it to this process' thread list.
-    void RegisterThread(const Thread* thread);
-
-    /// Unregisters a thread from this process, removing it
-    /// from this process' thread list.
-    void UnregisterThread(const Thread* thread);
-
     /// Clears the signaled state of the process if and only if it's signaled.
     ///
     /// @pre The process must not be already terminated. If this is called on a
@@ -251,7 +237,7 @@ private:
     ~Process() override;
 
     /// Checks if the specified thread should wait until this process is available.
-    bool ShouldWait(const Thread* thread) const override;
+    bool ShouldWait(Thread* thread) const override;
 
     /// Acquires/locks this process for the specified thread if it's available.
     void Acquire(Thread* thread) override;
@@ -322,9 +308,6 @@ private:
     /// Random values for svcGetInfo RandomEntropy
     std::array<u64, RANDOM_ENTROPY_SIZE> random_entropy;
 
-    /// List of threads that are running with this process as their owner.
-    std::list<const Thread*> thread_list;
-
     /// System context
     Core::System& system;
 

src/core/hle/kernel/readable_event.cpp

@@ -14,7 +14,7 @@ namespace Kernel {
 ReadableEvent::ReadableEvent(KernelCore& kernel) : WaitObject{kernel} {}
 ReadableEvent::~ReadableEvent() = default;
 
-bool ReadableEvent::ShouldWait(const Thread* thread) const {
+bool ReadableEvent::ShouldWait(Thread* thread) const {
     return !signaled;
 }
 

src/core/hle/kernel/readable_event.h

@@ -31,12 +31,12 @@ public:
         return reset_type;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::ReadableEvent;
+    static const HandleType HANDLE_TYPE = HandleType::ReadableEvent;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
 
-    bool ShouldWait(const Thread* thread) const override;
+    bool ShouldWait(Thread* thread) const override;
     void Acquire(Thread* thread) override;
 
     /// Unconditionally clears the readable event's state.

src/core/hle/kernel/resource_limit.cpp

@@ -16,8 +16,11 @@ constexpr std::size_t ResourceTypeToIndex(ResourceType type) {
 ResourceLimit::ResourceLimit(KernelCore& kernel) : Object{kernel} {}
 ResourceLimit::~ResourceLimit() = default;
 
-SharedPtr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel) {
-    return new ResourceLimit(kernel);
+SharedPtr<ResourceLimit> ResourceLimit::Create(KernelCore& kernel, std::string name) {
+    SharedPtr<ResourceLimit> resource_limit(new ResourceLimit(kernel));
+
+    resource_limit->name = std::move(name);
+    return resource_limit;
 }
 
 s64 ResourceLimit::GetCurrentResourceValue(ResourceType resource) const {

src/core/hle/kernel/resource_limit.h

@@ -31,17 +31,19 @@ constexpr bool IsValidResourceType(ResourceType type) {
 
 class ResourceLimit final : public Object {
 public:
-    /// Creates a resource limit object.
-    static SharedPtr<ResourceLimit> Create(KernelCore& kernel);
+    /**
+     * Creates a resource limit object.
+     */
+    static SharedPtr<ResourceLimit> Create(KernelCore& kernel, std::string name = "Unknown");
 
     std::string GetTypeName() const override {
         return "ResourceLimit";
     }
     std::string GetName() const override {
-        return GetTypeName();
+        return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::ResourceLimit;
+    static const HandleType HANDLE_TYPE = HandleType::ResourceLimit;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -93,6 +95,9 @@ private:
     ResourceArray limits{};
     /// Current resource limit values.
     ResourceArray values{};
+
+    /// Name of resource limit object.
+    std::string name;
 };
 
 } // namespace Kernel

src/core/hle/kernel/scheduler.cpp

@@ -101,6 +101,7 @@ void Scheduler::SwitchContext(Thread* new_thread) {
         auto* const thread_owner_process = current_thread->GetOwnerProcess();
         if (previous_process != thread_owner_process) {
             system.Kernel().MakeCurrentProcess(thread_owner_process);
+            Memory::SetCurrentPageTable(&thread_owner_process->VMManager().page_table);
         }
 
         cpu_core.LoadContext(new_thread->GetContext());

src/core/hle/kernel/server_port.cpp

@@ -30,7 +30,7 @@ void ServerPort::AppendPendingSession(SharedPtr<ServerSession> pending_session)
     pending_sessions.push_back(std::move(pending_session));
 }
 
-bool ServerPort::ShouldWait(const Thread* thread) const {
+bool ServerPort::ShouldWait(Thread* thread) const {
     // If there are no pending sessions, we wait until a new one is added.
     return pending_sessions.empty();
 }
@@ -39,8 +39,9 @@ void ServerPort::Acquire(Thread* thread) {
     ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
 }
 
-ServerPort::PortPair ServerPort::CreatePortPair(KernelCore& kernel, u32 max_sessions,
-                                                std::string name) {
+std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> ServerPort::CreatePortPair(
+    KernelCore& kernel, u32 max_sessions, std::string name) {
+
     SharedPtr<ServerPort> server_port(new ServerPort(kernel));
     SharedPtr<ClientPort> client_port(new ClientPort(kernel));
 
@@ -50,7 +51,7 @@ ServerPort::PortPair ServerPort::CreatePortPair(KernelCore& kernel, u32 max_sess
     client_port->max_sessions = max_sessions;
     client_port->active_sessions = 0;
 
-    return std::make_pair(std::move(server_port), std::move(client_port));
+    return std::make_tuple(std::move(server_port), std::move(client_port));
 }
 
 } // namespace Kernel

src/core/hle/kernel/server_port.h

@@ -6,7 +6,7 @@
 
 #include <memory>
 #include <string>
-#include <utility>
+#include <tuple>
 #include <vector>
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
@@ -23,7 +23,6 @@ class SessionRequestHandler;
 class ServerPort final : public WaitObject {
 public:
     using HLEHandler = std::shared_ptr<SessionRequestHandler>;
-    using PortPair = std::pair<SharedPtr<ServerPort>, SharedPtr<ClientPort>>;
 
     /**
      * Creates a pair of ServerPort and an associated ClientPort.
@@ -33,8 +32,8 @@ public:
      * @param name Optional name of the ports
      * @return The created port tuple
      */
-    static PortPair CreatePortPair(KernelCore& kernel, u32 max_sessions,
-                                   std::string name = "UnknownPort");
+    static std::tuple<SharedPtr<ServerPort>, SharedPtr<ClientPort>> CreatePortPair(
+        KernelCore& kernel, u32 max_sessions, std::string name = "UnknownPort");
 
     std::string GetTypeName() const override {
         return "ServerPort";
@@ -43,7 +42,7 @@ public:
         return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::ServerPort;
+    static const HandleType HANDLE_TYPE = HandleType::ServerPort;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -76,7 +75,7 @@ public:
     /// waiting to be accepted by this port.
     void AppendPendingSession(SharedPtr<ServerSession> pending_session);
 
-    bool ShouldWait(const Thread* thread) const override;
+    bool ShouldWait(Thread* thread) const override;
     void Acquire(Thread* thread) override;
 
 private:

src/core/hle/kernel/server_session.cpp

@@ -28,9 +28,11 @@ ServerSession::~ServerSession() {
     // the emulated application.
 
     // Decrease the port's connection count.
-    if (parent->port) {
+    if (parent->port)
         parent->port->ConnectionClosed();
-    }
+
+    // TODO(Subv): Wake up all the ClientSession's waiting threads and set
+    // the SendSyncRequest result to 0xC920181A.
 
     parent->server = nullptr;
 }
@@ -44,7 +46,7 @@ ResultVal<SharedPtr<ServerSession>> ServerSession::Create(KernelCore& kernel, st
     return MakeResult(std::move(server_session));
 }
 
-bool ServerSession::ShouldWait(const Thread* thread) const {
+bool ServerSession::ShouldWait(Thread* thread) const {
     // Closed sessions should never wait, an error will be returned from svcReplyAndReceive.
     if (parent->client == nullptr)
         return false;
@@ -72,6 +74,9 @@ void ServerSession::ClientDisconnected() {
         handler->ClientDisconnected(this);
     }
 
+    // TODO(Subv): Force a wake up of all the ServerSession's waiting threads and set
+    // their WaitSynchronization result to 0xC920181A.
+
     // Clean up the list of client threads with pending requests, they are unneeded now that the
     // client endpoint is closed.
     pending_requesting_threads.clear();
@@ -199,6 +204,6 @@ ServerSession::SessionPair ServerSession::CreateSessionPair(KernelCore& kernel,
     client_session->parent = parent;
     server_session->parent = parent;
 
-    return std::make_pair(std::move(server_session), std::move(client_session));
+    return std::make_tuple(std::move(server_session), std::move(client_session));
 }
 } // namespace Kernel

src/core/hle/kernel/server_session.h

@@ -6,7 +6,6 @@
 
 #include <memory>
 #include <string>
-#include <utility>
 #include <vector>
 
 #include "core/hle/kernel/object.h"
@@ -42,11 +41,7 @@ public:
         return "ServerSession";
     }
 
-    std::string GetName() const override {
-        return name;
-    }
-
-    static constexpr HandleType HANDLE_TYPE = HandleType::ServerSession;
+    static const HandleType HANDLE_TYPE = HandleType::ServerSession;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -59,7 +54,7 @@ public:
         return parent.get();
     }
 
-    using SessionPair = std::pair<SharedPtr<ServerSession>, SharedPtr<ClientSession>>;
+    using SessionPair = std::tuple<SharedPtr<ServerSession>, SharedPtr<ClientSession>>;
 
     /**
      * Creates a pair of ServerSession and an associated ClientSession.
@@ -87,7 +82,7 @@ public:
      */
     ResultCode HandleSyncRequest(SharedPtr<Thread> thread);
 
-    bool ShouldWait(const Thread* thread) const override;
+    bool ShouldWait(Thread* thread) const override;
 
     void Acquire(Thread* thread) override;
 

src/core/hle/kernel/shared_memory.cpp

@@ -9,6 +9,7 @@
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/shared_memory.h"
+#include "core/memory.h"
 
 namespace Kernel {
 
@@ -118,15 +119,7 @@ ResultCode SharedMemory::Map(Process& target_process, VAddr address, MemoryPermi
                                                      ConvertPermissions(permissions));
 }
 
-ResultCode SharedMemory::Unmap(Process& target_process, VAddr address, u64 unmap_size) {
-    if (unmap_size != size) {
-        LOG_ERROR(Kernel,
-                  "Invalid size passed to Unmap. Size must be equal to the size of the "
-                  "memory managed. Shared memory size=0x{:016X}, Unmap size=0x{:016X}",
-                  size, unmap_size);
-        return ERR_INVALID_SIZE;
-    }
-
+ResultCode SharedMemory::Unmap(Process& target_process, VAddr address) {
     // TODO(Subv): Verify what happens if the application tries to unmap an address that is not
     // mapped to a SharedMemory.
     return target_process.VMManager().UnmapRange(address, size);

src/core/hle/kernel/shared_memory.h

@@ -76,7 +76,7 @@ public:
         return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::SharedMemory;
+    static const HandleType HANDLE_TYPE = HandleType::SharedMemory;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
@@ -104,17 +104,11 @@ public:
 
     /**
      * Unmaps a shared memory block from the specified address in system memory
-     *
      * @param target_process Process from which to unmap the memory block.
-     * @param address        Address in system memory where the shared memory block is mapped.
-     * @param unmap_size     The amount of bytes to unmap from this shared memory instance.
-     *
+     * @param address Address in system memory where the shared memory block is mapped
      * @return Result code of the unmap operation
-     *
-     * @pre The given size to unmap must be the same size as the amount of memory managed by
-     *      the SharedMemory instance itself, otherwise ERR_INVALID_SIZE will be returned.
      */
-    ResultCode Unmap(Process& target_process, VAddr address, u64 unmap_size);
+    ResultCode Unmap(Process& target_process, VAddr address);
 
     /**
      * Gets a pointer to the shared memory block

src/core/hle/kernel/svc.h

@@ -6,12 +6,8 @@
 
 #include "common/common_types.h"
 
-namespace Core {
-class System;
-}
-
 namespace Kernel {
 
-void CallSVC(Core::System& system, u32 immediate);
+void CallSVC(u32 immediate);
 
 } // namespace Kernel

src/core/hle/kernel/svc_wrap.h

@@ -11,319 +11,270 @@
 
 namespace Kernel {
 
-static inline u64 Param(const Core::System& system, int n) {
-    return system.CurrentArmInterface().GetReg(n);
+static inline u64 Param(int n) {
+    return Core::CurrentArmInterface().GetReg(n);
 }
 
 /**
  * HLE a function return from the current ARM userland process
- * @param system System context
- * @param result Result to return
+ * @param res Result to return
  */
-static inline void FuncReturn(Core::System& system, u64 result) {
-    system.CurrentArmInterface().SetReg(0, result);
+static inline void FuncReturn(u64 res) {
+    Core::CurrentArmInterface().SetReg(0, res);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type ResultCode
 
-template <ResultCode func(Core::System&, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0)).raw);
+template <ResultCode func(u64)>
+void SvcWrap() {
+    FuncReturn(func(Param(0)).raw);
 }
 
-template <ResultCode func(Core::System&, u32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
+template <ResultCode func(u32)>
+void SvcWrap() {
+    FuncReturn(func(static_cast<u32>(Param(0))).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(
-        system,
-        func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw);
+template <ResultCode func(u32, u32)>
+void SvcWrap() {
+    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1))).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u64, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
-                            Param(system, 2), Param(system, 3))
-                           .raw);
-}
-
-template <ResultCode func(Core::System&, u32*)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32*)>
+void SvcWrap() {
     u32 param = 0;
-    const u32 retval = func(system, &param).raw;
-    system.CurrentArmInterface().SetReg(1, param);
-    FuncReturn(system, retval);
+    const u32 retval = func(&param).raw;
+    Core::CurrentArmInterface().SetReg(1, param);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32*, u32)>
+void SvcWrap() {
     u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval = func(&param_1, static_cast<u32>(Param(1))).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u32*)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32*, u32*)>
+void SvcWrap() {
     u32 param_1 = 0;
     u32 param_2 = 0;
-    const u32 retval = func(system, &param_1, &param_2).raw;
+    const u32 retval = func(&param_1, &param_2).raw;
 
-    auto& arm_interface = system.CurrentArmInterface();
+    auto& arm_interface = Core::CurrentArmInterface();
     arm_interface.SetReg(1, param_1);
     arm_interface.SetReg(2, param_2);
 
-    FuncReturn(system, retval);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32*, u64)>
+void SvcWrap() {
     u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1)).raw;
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    const u32 retval = func(&param_1, Param(1)).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64, u32)>
-void SvcWrap(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval =
-        func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2))).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
-template <ResultCode func(Core::System&, u64*, u32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u64*, u32)>
+void SvcWrap() {
     u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    const u32 retval = func(&param_1, static_cast<u32>(Param(1))).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u64, s32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<s32>(Param(system, 1))).raw);
+template <ResultCode func(u64, s32)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), static_cast<s32>(Param(1))).raw);
 }
 
-template <ResultCode func(Core::System&, u64, u32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1))).raw);
+template <ResultCode func(u64, u32)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), static_cast<u32>(Param(1))).raw);
 }
 
-template <ResultCode func(Core::System&, u64*, u64)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u64*, u64)>
+void SvcWrap() {
     u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1)).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval = func(&param_1, Param(1)).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u64*, u32, u32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u64*, u32, u32)>
+void SvcWrap() {
     u64 param_1 = 0;
-    const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1)),
-                            static_cast<u32>(Param(system, 2)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval = func(&param_1, static_cast<u32>(Param(1)), static_cast<u32>(Param(2))).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1)).raw);
+template <ResultCode func(u32, u64)>
+void SvcWrap() {
+    FuncReturn(func(static_cast<u32>(Param(0)), Param(1)).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u32, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
-                            static_cast<u32>(Param(system, 1)), Param(system, 2))
-                           .raw);
+template <ResultCode func(u32, u32, u64)>
+void SvcWrap() {
+    FuncReturn(func(static_cast<u32>(Param(0)), static_cast<u32>(Param(1)), Param(2)).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u32*, u64*)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32, u32*, u64*)>
+void SvcWrap() {
     u32 param_1 = 0;
     u64 param_2 = 0;
-    const ResultCode retval = func(system, static_cast<u32>(Param(system, 2)), &param_1, &param_2);
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    system.CurrentArmInterface().SetReg(2, param_2);
-    FuncReturn(system, retval.raw);
+    ResultCode retval = func(static_cast<u32>(Param(2)), &param_1, &param_2);
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    Core::CurrentArmInterface().SetReg(2, param_2);
+    FuncReturn(retval.raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u32, u32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
-                           .raw);
-}
-
-template <ResultCode func(Core::System&, u64, u64, u32, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)), Param(system, 3))
-                           .raw);
-}
-
-template <ResultCode func(Core::System&, u32, u64, u32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)))
-                           .raw);
-}
-
-template <ResultCode func(Core::System&, u64, u64, u64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1), Param(system, 2)).raw);
-}
-
-template <ResultCode func(Core::System&, u64, u64, u32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u64, u64, u32, u32)>
+void SvcWrap() {
     FuncReturn(
-        system,
-        func(system, Param(system, 0), Param(system, 1), static_cast<u32>(Param(system, 2))).raw);
+        func(Param(0), Param(1), static_cast<u32>(Param(2)), static_cast<u32>(Param(3))).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u64, u32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
-                            Param(system, 2), static_cast<u32>(Param(system, 3)))
-                           .raw);
+template <ResultCode func(u64, u64, u32, u64)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2)), Param(3)).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u64)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32, u64, u32)>
+void SvcWrap() {
+    FuncReturn(func(static_cast<u32>(Param(0)), Param(1), static_cast<u32>(Param(2))).raw);
+}
+
+template <ResultCode func(u64, u64, u64)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), Param(1), Param(2)).raw);
+}
+
+template <ResultCode func(u64, u64, u32)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), Param(1), static_cast<u32>(Param(2))).raw);
+}
+
+template <ResultCode func(u32, u64, u64, u32)>
+void SvcWrap() {
     FuncReturn(
-        system,
-        func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2)).raw);
+        func(static_cast<u32>(Param(0)), Param(1), Param(2), static_cast<u32>(Param(3))).raw);
 }
 
-template <ResultCode func(Core::System&, u32*, u64, u64, s64)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32, u64, u64)>
+void SvcWrap() {
+    FuncReturn(func(static_cast<u32>(Param(0)), Param(1), Param(2)).raw);
+}
+
+template <ResultCode func(u32*, u64, u64, s64)>
+void SvcWrap() {
     u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
-                            static_cast<s64>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    ResultCode retval =
+        func(&param_1, Param(1), static_cast<u32>(Param(2)), static_cast<s64>(Param(3)));
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval.raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u32, s64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
-                            static_cast<u32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
-                           .raw);
+template <ResultCode func(u64, u64, u32, s64)>
+void SvcWrap() {
+    FuncReturn(
+        func(Param(0), Param(1), static_cast<u32>(Param(2)), static_cast<s64>(Param(3))).raw);
 }
 
-template <ResultCode func(Core::System&, u64*, u64, u64, u64)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u64*, u64, u64, u64)>
+void SvcWrap() {
     u64 param_1 = 0;
-    const u32 retval =
-        func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3)).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval = func(&param_1, Param(1), Param(2), Param(3)).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64, u64, u64, u32, s32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32*, u64, u64, u64, u32, s32)>
+void SvcWrap() {
     u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3),
-                            static_cast<u32>(Param(system, 4)), static_cast<s32>(Param(system, 5)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval = func(&param_1, Param(1), Param(2), Param(3), static_cast<u32>(Param(4)),
+                      static_cast<s32>(Param(5)))
+                     .raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64, u64, u32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(u32*, u64, u64, u32)>
+void SvcWrap() {
     u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2),
-                            static_cast<u32>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval = func(&param_1, Param(1), Param(2), static_cast<u32>(Param(3))).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, Handle*, u64, u32, u32)>
-void SvcWrap(Core::System& system) {
+template <ResultCode func(Handle*, u64, u32, u32)>
+void SvcWrap() {
     u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
-                            static_cast<u32>(Param(system, 3)))
-                           .raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
+    u32 retval =
+        func(&param_1, Param(1), static_cast<u32>(Param(2)), static_cast<u32>(Param(3))).raw;
+    Core::CurrentArmInterface().SetReg(1, param_1);
+    FuncReturn(retval);
 }
 
-template <ResultCode func(Core::System&, u64, u32, s32, s64)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
-                            static_cast<s32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
-                           .raw);
+template <ResultCode func(u64, u32, s32, s64)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), static_cast<u32>(Param(1)), static_cast<s32>(Param(2)),
+                    static_cast<s64>(Param(3)))
+                   .raw);
 }
 
-template <ResultCode func(Core::System&, u64, u32, s32, s32)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
-                            static_cast<s32>(Param(system, 2)), static_cast<s32>(Param(system, 3)))
-                           .raw);
+template <ResultCode func(u64, u32, s32, s32)>
+void SvcWrap() {
+    FuncReturn(func(Param(0), static_cast<u32>(Param(1)), static_cast<s32>(Param(2)),
+                    static_cast<s32>(Param(3)))
+                   .raw);
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type u32
 
-template <u32 func(Core::System&)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system));
+template <u32 func()>
+void SvcWrap() {
+    FuncReturn(func());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Function wrappers that return type u64
 
-template <u64 func(Core::System&)>
-void SvcWrap(Core::System& system) {
-    FuncReturn(system, func(system));
+template <u64 func()>
+void SvcWrap() {
+    FuncReturn(func());
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 /// Function wrappers that return type void
 
-template <void func(Core::System&)>
-void SvcWrap(Core::System& system) {
-    func(system);
+template <void func()>
+void SvcWrap() {
+    func();
 }
 
-template <void func(Core::System&, s64)>
-void SvcWrap(Core::System& system) {
-    func(system, static_cast<s64>(Param(system, 0)));
+template <void func(s64)>
+void SvcWrap() {
+    func(static_cast<s64>(Param(0)));
 }
 
-template <void func(Core::System&, u64, u64)>
-void SvcWrap(Core::System& system) {
-    func(system, Param(system, 0), Param(system, 1));
+template <void func(u64, u64 len)>
+void SvcWrap() {
+    func(Param(0), Param(1));
 }
 
-template <void func(Core::System&, u64, u64, u64)>
-void SvcWrap(Core::System& system) {
-    func(system, Param(system, 0), Param(system, 1), Param(system, 2));
+template <void func(u64, u64, u64)>
+void SvcWrap() {
+    func(Param(0), Param(1), Param(2));
 }
 
-template <void func(Core::System&, u32, u64, u64)>
-void SvcWrap(Core::System& system) {
-    func(system, static_cast<u32>(Param(system, 0)), Param(system, 1), Param(system, 2));
+template <void func(u32, u64, u64)>
+void SvcWrap() {
+    func(static_cast<u32>(Param(0)), Param(1), Param(2));
 }
 
 } // namespace Kernel

src/core/hle/kernel/thread.cpp

@@ -28,7 +28,7 @@
 
 namespace Kernel {
 
-bool Thread::ShouldWait(const Thread* thread) const {
+bool Thread::ShouldWait(Thread* thread) const {
     return status != ThreadStatus::Dead;
 }
 
@@ -62,8 +62,6 @@ void Thread::Stop() {
     }
     wait_objects.clear();
 
-    owner_process->UnregisterThread(this);
-
     // Mark the TLS slot in the thread's page as free.
     owner_process->FreeTLSSlot(tls_address);
 }
@@ -204,8 +202,6 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->scheduler->AddThread(thread);
     thread->tls_address = thread->owner_process->MarkNextAvailableTLSSlotAsUsed(*thread);
 
-    thread->owner_process->RegisterThread(thread.get());
-
     // TODO(peachum): move to ScheduleThread() when scheduler is added so selected core is used
     // to initialize the context
     ResetThreadContext(thread->context, stack_top, entry_point, arg);
@@ -220,6 +216,11 @@ void Thread::SetPriority(u32 priority) {
     UpdatePriority();
 }
 
+void Thread::BoostPriority(u32 priority) {
+    scheduler->SetThreadPriority(this, priority);
+    current_priority = priority;
+}
+
 void Thread::SetWaitSynchronizationResult(ResultCode result) {
     context.cpu_registers[0] = result.raw;
 }
@@ -228,16 +229,16 @@ void Thread::SetWaitSynchronizationOutput(s32 output) {
     context.cpu_registers[1] = output;
 }
 
-s32 Thread::GetWaitObjectIndex(const WaitObject* object) const {
+s32 Thread::GetWaitObjectIndex(WaitObject* object) const {
     ASSERT_MSG(!wait_objects.empty(), "Thread is not waiting for anything");
-    const auto match = std::find(wait_objects.rbegin(), wait_objects.rend(), object);
+    auto match = std::find(wait_objects.rbegin(), wait_objects.rend(), object);
     return static_cast<s32>(std::distance(match, wait_objects.rend()) - 1);
 }
 
 VAddr Thread::GetCommandBufferAddress() const {
     // Offset from the start of TLS at which the IPC command buffer begins.
-    constexpr u64 command_header_offset = 0x80;
-    return GetTLSAddress() + command_header_offset;
+    static constexpr int CommandHeaderOffset = 0x80;
+    return GetTLSAddress() + CommandHeaderOffset;
 }
 
 void Thread::SetStatus(ThreadStatus new_status) {
@@ -366,7 +367,7 @@ void Thread::ChangeScheduler() {
     system.CpuCore(processor_id).PrepareReschedule();
 }
 
-bool Thread::AllWaitObjectsReady() const {
+bool Thread::AllWaitObjectsReady() {
     return std::none_of(
         wait_objects.begin(), wait_objects.end(),
         [this](const SharedPtr<WaitObject>& object) { return object->ShouldWait(this); });

src/core/hle/kernel/thread.h

@@ -102,21 +102,16 @@ public:
     std::string GetName() const override {
         return name;
     }
-
-    void SetName(std::string new_name) {
-        name = std::move(new_name);
-    }
-
     std::string GetTypeName() const override {
         return "Thread";
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::Thread;
+    static const HandleType HANDLE_TYPE = HandleType::Thread;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }
 
-    bool ShouldWait(const Thread* thread) const override;
+    bool ShouldWait(Thread* thread) const override;
     void Acquire(Thread* thread) override;
 
     /**
@@ -141,6 +136,12 @@ public:
      */
     void SetPriority(u32 priority);
 
+    /**
+     * Temporarily boosts the thread's priority until the next time it is scheduled
+     * @param priority The new priority
+     */
+    void BoostPriority(u32 priority);
+
     /// Adds a thread to the list of threads that are waiting for a lock held by this thread.
     void AddMutexWaiter(SharedPtr<Thread> thread);
 
@@ -204,7 +205,7 @@ public:
      * object in the list.
      * @param object Object to query the index of.
      */
-    s32 GetWaitObjectIndex(const WaitObject* object) const;
+    s32 GetWaitObjectIndex(WaitObject* object) const;
 
     /**
      * Stops a thread, invalidating it from further use
@@ -298,7 +299,7 @@ public:
     }
 
     /// Determines whether all the objects this thread is waiting on are ready.
-    bool AllWaitObjectsReady() const;
+    bool AllWaitObjectsReady();
 
     const MutexWaitingThreads& GetMutexWaitingThreads() const {
         return wait_mutex_threads;
@@ -344,6 +345,10 @@ public:
         arb_wait_address = address;
     }
 
+    void SetGuestHandle(Handle handle) {
+        guest_handle = handle;
+    }
+
     bool HasWakeupCallback() const {
         return wakeup_callback != nullptr;
     }
@@ -437,6 +442,9 @@ private:
     /// If waiting for an AddressArbiter, this is the address being waited on.
     VAddr arb_wait_address{0};
 
+    /// Handle used by guest emulated application to access this thread
+    Handle guest_handle = 0;
+
     /// Handle used as userdata to reference this object when inserting into the CoreTiming queue.
     Handle callback_handle = 0;
 

src/core/hle/kernel/transfer_memory.cpp

@@ -14,8 +14,8 @@ namespace Kernel {
 TransferMemory::TransferMemory(KernelCore& kernel) : Object{kernel} {}
 TransferMemory::~TransferMemory() = default;
 
-SharedPtr<TransferMemory> TransferMemory::Create(KernelCore& kernel, VAddr base_address, u64 size,
-                                                 MemoryPermission permissions) {
+SharedPtr<TransferMemory> TransferMemory::Create(KernelCore& kernel, VAddr base_address,
+                                                 size_t size, MemoryPermission permissions) {
     SharedPtr<TransferMemory> transfer_memory{new TransferMemory(kernel)};
 
     transfer_memory->base_address = base_address;
@@ -26,15 +26,7 @@ SharedPtr<TransferMemory> TransferMemory::Create(KernelCore& kernel, VAddr base_
     return transfer_memory;
 }
 
-const u8* TransferMemory::GetPointer() const {
-    return backing_block.get()->data();
-}
-
-u64 TransferMemory::GetSize() const {
-    return memory_size;
-}
-
-ResultCode TransferMemory::MapMemory(VAddr address, u64 size, MemoryPermission permissions) {
+ResultCode TransferMemory::MapMemory(VAddr address, size_t size, MemoryPermission permissions) {
     if (memory_size != size) {
         return ERR_INVALID_SIZE;
     }
@@ -47,13 +39,13 @@ ResultCode TransferMemory::MapMemory(VAddr address, u64 size, MemoryPermission p
         return ERR_INVALID_STATE;
     }
 
-    backing_block = std::make_shared<std::vector<u8>>(size);
-
     const auto map_state = owner_permissions == MemoryPermission::None
                                ? MemoryState::TransferMemoryIsolated
                                : MemoryState::TransferMemory;
     auto& vm_manager = owner_process->VMManager();
-    const auto map_result = vm_manager.MapMemoryBlock(address, backing_block, 0, size, map_state);
+    const auto map_result = vm_manager.MapMemoryBlock(
+        address, std::make_shared<std::vector<u8>>(size), 0, size, map_state);
+
     if (map_result.Failed()) {
         return map_result.Code();
     }
@@ -62,7 +54,7 @@ ResultCode TransferMemory::MapMemory(VAddr address, u64 size, MemoryPermission p
     return RESULT_SUCCESS;
 }
 
-ResultCode TransferMemory::UnmapMemory(VAddr address, u64 size) {
+ResultCode TransferMemory::UnmapMemory(VAddr address, size_t size) {
     if (memory_size != size) {
         return ERR_INVALID_SIZE;
     }

src/core/hle/kernel/transfer_memory.h

@@ -4,9 +4,6 @@
 
 #pragma once
 
-#include <memory>
-#include <vector>
-
 #include "core/hle/kernel/object.h"
 
 union ResultCode;
@@ -28,7 +25,7 @@ class TransferMemory final : public Object {
 public:
     static constexpr HandleType HANDLE_TYPE = HandleType::TransferMemory;
 
-    static SharedPtr<TransferMemory> Create(KernelCore& kernel, VAddr base_address, u64 size,
+    static SharedPtr<TransferMemory> Create(KernelCore& kernel, VAddr base_address, size_t size,
                                             MemoryPermission permissions);
 
     TransferMemory(const TransferMemory&) = delete;
@@ -49,12 +46,6 @@ public:
         return HANDLE_TYPE;
     }
 
-    /// Gets a pointer to the backing block of this instance.
-    const u8* GetPointer() const;
-
-    /// Gets the size of the memory backing this instance in bytes.
-    u64 GetSize() const;
-
     /// Attempts to map transfer memory with the given range and memory permissions.
     ///
     /// @param address     The base address to being mapping memory at.
@@ -65,7 +56,7 @@ public:
     ///      the same values that were given when creating the transfer memory
     ///      instance.
     ///
-    ResultCode MapMemory(VAddr address, u64 size, MemoryPermission permissions);
+    ResultCode MapMemory(VAddr address, size_t size, MemoryPermission permissions);
 
     /// Unmaps the transfer memory with the given range
     ///
@@ -75,20 +66,17 @@ public:
     /// @pre The given address and size must be the same as the ones used
     ///      to create the transfer memory instance.
     ///
-    ResultCode UnmapMemory(VAddr address, u64 size);
+    ResultCode UnmapMemory(VAddr address, size_t size);
 
 private:
     explicit TransferMemory(KernelCore& kernel);
     ~TransferMemory() override;
 
-    /// Memory block backing this instance.
-    std::shared_ptr<std::vector<u8>> backing_block;
-
     /// The base address for the memory managed by this instance.
     VAddr base_address = 0;
 
     /// Size of the memory, in bytes, that this instance manages.
-    u64 memory_size = 0;
+    size_t memory_size = 0;
 
     /// The memory permissions that are applied to this instance.
     MemoryPermission owner_permissions{};

src/core/hle/kernel/vm_manager.cpp

@@ -302,86 +302,6 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
     return MakeResult<VAddr>(heap_region_base);
 }
 
-ResultCode VMManager::MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
-    constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
-    const auto src_check_result = CheckRangeState(
-        src_address, size, MemoryState::All, MemoryState::Heap, VMAPermission::All,
-        VMAPermission::ReadWrite, MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
-
-    if (src_check_result.Failed()) {
-        return src_check_result.Code();
-    }
-
-    const auto mirror_result =
-        MirrorMemory(dst_address, src_address, size, MemoryState::ModuleCode);
-    if (mirror_result.IsError()) {
-        return mirror_result;
-    }
-
-    // Ensure we lock the source memory region.
-    const auto src_vma_result = CarveVMARange(src_address, size);
-    if (src_vma_result.Failed()) {
-        return src_vma_result.Code();
-    }
-    auto src_vma_iter = *src_vma_result;
-    src_vma_iter->second.attribute = MemoryAttribute::Locked;
-    Reprotect(src_vma_iter, VMAPermission::Read);
-
-    // The destination memory region is fine as is, however we need to make it read-only.
-    return ReprotectRange(dst_address, size, VMAPermission::Read);
-}
-
-ResultCode VMManager::UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64 size) {
-    constexpr auto ignore_attribute = MemoryAttribute::LockedForIPC | MemoryAttribute::DeviceMapped;
-    const auto src_check_result = CheckRangeState(
-        src_address, size, MemoryState::All, MemoryState::Heap, VMAPermission::None,
-        VMAPermission::None, MemoryAttribute::Mask, MemoryAttribute::Locked, ignore_attribute);
-
-    if (src_check_result.Failed()) {
-        return src_check_result.Code();
-    }
-
-    // Yes, the kernel only checks the first page of the region.
-    const auto dst_check_result =
-        CheckRangeState(dst_address, Memory::PAGE_SIZE, MemoryState::FlagModule,
-                        MemoryState::FlagModule, VMAPermission::None, VMAPermission::None,
-                        MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
-
-    if (dst_check_result.Failed()) {
-        return dst_check_result.Code();
-    }
-
-    const auto dst_memory_state = std::get<MemoryState>(*dst_check_result);
-    const auto dst_contiguous_check_result = CheckRangeState(
-        dst_address, size, MemoryState::All, dst_memory_state, VMAPermission::None,
-        VMAPermission::None, MemoryAttribute::Mask, MemoryAttribute::None, ignore_attribute);
-
-    if (dst_contiguous_check_result.Failed()) {
-        return dst_contiguous_check_result.Code();
-    }
-
-    const auto unmap_result = UnmapRange(dst_address, size);
-    if (unmap_result.IsError()) {
-        return unmap_result;
-    }
-
-    // With the mirrored portion unmapped, restore the original region's traits.
-    const auto src_vma_result = CarveVMARange(src_address, size);
-    if (src_vma_result.Failed()) {
-        return src_vma_result.Code();
-    }
-    auto src_vma_iter = *src_vma_result;
-    src_vma_iter->second.state = MemoryState::Heap;
-    src_vma_iter->second.attribute = MemoryAttribute::None;
-    Reprotect(src_vma_iter, VMAPermission::ReadWrite);
-
-    if (dst_memory_state == MemoryState::ModuleCode) {
-        Core::System::GetInstance().InvalidateCpuInstructionCaches();
-    }
-
-    return unmap_result;
-}
-
 MemoryInfo VMManager::QueryMemory(VAddr address) const {
     const auto vma = FindVMA(address);
     MemoryInfo memory_info{};

src/core/hle/kernel/vm_manager.h

@@ -43,9 +43,6 @@ enum class VMAPermission : u8 {
     ReadExecute = Read | Execute,
     WriteExecute = Write | Execute,
     ReadWriteExecute = Read | Write | Execute,
-
-    // Used as a wildcard when checking permissions across memory ranges
-    All = 0xFF,
 };
 
 constexpr VMAPermission operator|(VMAPermission lhs, VMAPermission rhs) {
@@ -155,9 +152,6 @@ enum class MemoryState : u32 {
     FlagUncached                    = 1U << 24,
     FlagCodeMemory                  = 1U << 25,
 
-    // Wildcard used in range checking to indicate all states.
-    All                             = 0xFFFFFFFF,
-
     // Convenience flag sets to reduce repetition
     IPCFlags = FlagIPC0 | FlagIPC3 | FlagIPC1,
 
@@ -421,49 +415,6 @@ public:
     ///
     ResultVal<VAddr> SetHeapSize(u64 size);
 
-    /// Maps a region of memory as code memory.
-    ///
-    /// @param dst_address The base address of the region to create the aliasing memory region.
-    /// @param src_address The base address of the region to be aliased.
-    /// @param size        The total amount of memory to map in bytes.
-    ///
-    /// @pre Both memory regions lie within the actual addressable address space.
-    ///
-    /// @post After this function finishes execution, assuming success, then the address range
-    ///       [dst_address, dst_address+size) will alias the memory region,
-    ///       [src_address, src_address+size).
-    ///       <p>
-    ///       What this also entails is as follows:
-    ///          1. The aliased region gains the Locked memory attribute.
-    ///          2. The aliased region becomes read-only.
-    ///          3. The aliasing region becomes read-only.
-    ///          4. The aliasing region is created with a memory state of MemoryState::CodeModule.
-    ///
-    ResultCode MapCodeMemory(VAddr dst_address, VAddr src_address, u64 size);
-
-    /// Unmaps a region of memory designated as code module memory.
-    ///
-    /// @param dst_address The base address of the memory region aliasing the source memory region.
-    /// @param src_address The base address of the memory region being aliased.
-    /// @param size        The size of the memory region to unmap in bytes.
-    ///
-    /// @pre Both memory ranges lie within the actual addressable address space.
-    ///
-    /// @pre The memory region being unmapped has been previously been mapped
-    ///      by a call to MapCodeMemory.
-    ///
-    /// @post After execution of the function, if successful. the aliasing memory region
-    ///       will be unmapped and the aliased region will have various traits about it
-    ///       restored to what they were prior to the original mapping call preceding
-    ///       this function call.
-    ///       <p>
-    ///       What this also entails is as follows:
-    ///           1. The state of the memory region will now indicate a general heap region.
-    ///           2. All memory attributes for the memory region are cleared.
-    ///           3. Memory permissions for the region are restored to user read/write.
-    ///
-    ResultCode UnmapCodeMemory(VAddr dst_address, VAddr src_address, u64 size);
-
     /// Queries the memory manager for information about the given address.
     ///
     /// @param address The address to query the memory manager about for information.

src/core/hle/kernel/wait_object.h

@@ -24,7 +24,7 @@ public:
      * @param thread The thread about which we're deciding.
      * @return True if the current thread should wait due to this object being unavailable
      */
-    virtual bool ShouldWait(const Thread* thread) const = 0;
+    virtual bool ShouldWait(Thread* thread) const = 0;
 
     /// Acquire/lock the object for the specified thread if it is available
     virtual void Acquire(Thread* thread) = 0;

src/core/hle/kernel/writable_event.h

@@ -37,7 +37,7 @@ public:
         return name;
     }
 
-    static constexpr HandleType HANDLE_TYPE = HandleType::WritableEvent;
+    static const HandleType HANDLE_TYPE = HandleType::WritableEvent;
     HandleType GetHandleType() const override {
         return HANDLE_TYPE;
     }

src/core/hle/result.h

@@ -119,6 +119,10 @@ union ResultCode {
     BitField<0, 9, ErrorModule> module;
     BitField<9, 13, u32> description;
 
+    // The last bit of `level` is checked by apps and the kernel to determine if a result code is an
+    // error
+    BitField<31, 1, u32> is_error;
+
     constexpr explicit ResultCode(u32 raw) : raw(raw) {}
 
     constexpr ResultCode(ErrorModule module_, u32 description_)

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

@@ -137,7 +137,6 @@ private:
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
     IManagerForApplication() : ServiceFramework("IManagerForApplication") {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
             {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
@@ -146,10 +145,7 @@ public:
             {130, nullptr, "GetNintendoAccountUserResourceCacheForApplication"},
             {150, nullptr, "CreateAuthorizationRequest"},
             {160, nullptr, "StoreOpenContext"},
-            {170, nullptr, "LoadNetworkServiceLicenseKindAsync"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 

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

@@ -8,7 +8,6 @@ namespace Service::Account {
 
 ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:su") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_SU::GetUserCount, "GetUserCount"},
         {1, &ACC_SU::GetUserExistence, "GetUserExistence"},
@@ -20,7 +19,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_SU::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_SU::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
-        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
         {102, nullptr, "GetBaasAccountManagerForSystemService"},
@@ -31,8 +29,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
-        {130, nullptr, "ActivateOpenContextRetention"},
-        {140, nullptr, "ListQualifiedUsers"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
         {200, nullptr, "BeginUserRegistration"},
@@ -52,8 +48,6 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {998, nullptr, "DebugSetUserStateClose"},
         {999, nullptr, "DebugSetUserStateOpen"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -8,7 +8,6 @@ namespace Service::Account {
 
 ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:u0") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U0::GetUserCount, "GetUserCount"},
         {1, &ACC_U0::GetUserExistence, "GetUserExistence"},
@@ -20,7 +19,6 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_U0::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_U0::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
-        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, &ACC_U0::InitializeApplicationInfo, "InitializeApplicationInfo"},
         {101, &ACC_U0::GetBaasAccountManagerForApplication, "GetBaasAccountManagerForApplication"},
         {102, nullptr, "AuthenticateApplicationAsync"},
@@ -29,13 +27,7 @@ ACC_U0::ACC_U0(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {120, nullptr, "CreateGuestLoginRequest"},
         {130, nullptr, "LoadOpenContext"},
-        {131, nullptr, "ListOpenContextStoredUsers"},
-        {140, nullptr, "InitializeApplicationInfo"},
-        {141, nullptr, "ListQualifiedUsers"},
-        {150, nullptr, "IsUserAccountSwitchLocked"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -8,7 +8,6 @@ namespace Service::Account {
 
 ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> profile_manager)
     : Module::Interface(std::move(module), std::move(profile_manager), "acc:u1") {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ACC_U1::GetUserCount, "GetUserCount"},
         {1, &ACC_U1::GetUserExistence, "GetUserExistence"},
@@ -20,7 +19,6 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {50, &ACC_U1::IsUserRegistrationRequestPermitted, "IsUserRegistrationRequestPermitted"},
         {51, &ACC_U1::TrySelectUserWithoutInteraction, "TrySelectUserWithoutInteraction"},
         {60, nullptr, "ListOpenContextStoredUsers"},
-        {99, nullptr, "DebugActivateOpenContextRetention"},
         {100, nullptr, "GetUserRegistrationNotifier"},
         {101, nullptr, "GetUserStateChangeNotifier"},
         {102, nullptr, "GetBaasAccountManagerForSystemService"},
@@ -31,16 +29,12 @@ ACC_U1::ACC_U1(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
         {111, nullptr, "ClearSaveDataThumbnail"},
         {112, nullptr, "LoadSaveDataThumbnail"},
         {113, nullptr, "GetSaveDataThumbnailExistence"},
-        {130, nullptr, "ActivateOpenContextRetention"},
-        {140, nullptr, "ListQualifiedUsers"},
         {190, nullptr, "GetUserLastOpenedApplication"},
         {191, nullptr, "ActivateOpenContextHolder"},
         {997, nullptr, "DebugInvalidateTokenCacheForUser"},
         {998, nullptr, "DebugSetUserStateClose"},
         {999, nullptr, "DebugSetUserStateOpen"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 }
 

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

@@ -13,7 +13,7 @@
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/readable_event.h"
-#include "core/hle/kernel/transfer_memory.h"
+#include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/am/am.h"
@@ -224,7 +224,6 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {
         {20, nullptr, "InvalidateTransitionLayer"},
         {30, nullptr, "RequestLaunchApplicationWithUserAndArgumentForDebug"},
         {40, nullptr, "GetAppletResourceUsageInfo"},
-        {41, nullptr, "SetCpuBoostModeForApplet"},
     };
     // clang-format on
 
@@ -240,8 +239,8 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {0, nullptr, "Exit"},
         {1, &ISelfController::LockExit, "LockExit"},
         {2, &ISelfController::UnlockExit, "UnlockExit"},
-        {3, &ISelfController::EnterFatalSection, "EnterFatalSection"},
-        {4, &ISelfController::LeaveFatalSection, "LeaveFatalSection"},
+        {3, nullptr, "EnterFatalSection"},
+        {4, nullptr, "LeaveFatalSection"},
         {9, &ISelfController::GetLibraryAppletLaunchableEvent, "GetLibraryAppletLaunchableEvent"},
         {10, &ISelfController::SetScreenShotPermission, "SetScreenShotPermission"},
         {11, &ISelfController::SetOperationModeChangedNotification, "SetOperationModeChangedNotification"},
@@ -257,7 +256,6 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {40, &ISelfController::CreateManagedDisplayLayer, "CreateManagedDisplayLayer"},
         {41, nullptr, "IsSystemBufferSharingEnabled"},
         {42, nullptr, "GetSystemSharedLayerHandle"},
-        {43, nullptr, "GetSystemSharedBufferHandle"},
         {50, &ISelfController::SetHandlesRequestToDisplay, "SetHandlesRequestToDisplay"},
         {51, nullptr, "ApproveToDisplay"},
         {60, nullptr, "OverrideAutoSleepTimeAndDimmingTime"},
@@ -271,11 +269,9 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
         {68, nullptr, "SetAutoSleepDisabled"},
         {69, nullptr, "IsAutoSleepDisabled"},
         {70, nullptr, "ReportMultimediaError"},
-        {71, nullptr, "GetCurrentIlluminanceEx"},
         {80, nullptr, "SetWirelessPriorityMode"},
         {90, nullptr, "GetAccumulatedSuspendedTickValue"},
         {91, nullptr, "GetAccumulatedSuspendedTickChangedEvent"},
-        {100, nullptr, "SetAlbumImageTakenNotificationEnabled"},
         {1000, nullptr, "GetDebugStorageChannel"},
     };
     // clang-format on
@@ -289,54 +285,41 @@ ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger
 
 ISelfController::~ISelfController() = default;
 
-void ISelfController::LockExit(Kernel::HLERequestContext& ctx) {
+void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
+    // Takes 3 input u8s with each field located immediately after the previous
+    // u8, these are bool flags. No output.
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::RequestParser rp{ctx};
+
+    struct FocusHandlingModeParams {
+        u8 unknown0;
+        u8 unknown1;
+        u8 unknown2;
+    };
+    auto flags = rp.PopRaw<FocusHandlingModeParams>();
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void ISelfController::SetRestartMessageEnabled(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
-void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
+void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+
+    bool flag = rp.Pop<bool>();
+    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(RESULT_SUCCESS);
 }
 
-void ISelfController::EnterFatalSection(Kernel::HLERequestContext& ctx) {
-    ++num_fatal_sections_entered;
-    LOG_DEBUG(Service_AM, "called. Num fatal sections entered: {}", num_fatal_sections_entered);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ISelfController::LeaveFatalSection(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called.");
-
-    // Entry and exit of fatal sections must be balanced.
-    if (num_fatal_sections_entered == 0) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultCode{ErrorModule::AM, 512});
-        return;
-    }
-
-    --num_fatal_sections_entered;
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    launchable_event.writable->Signal();
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(launchable_event.readable);
-}
-
 void ISelfController::SetScreenShotPermission(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
@@ -354,42 +337,6 @@ void ISelfController::SetOperationModeChangedNotification(Kernel::HLERequestCont
     rb.Push(RESULT_SUCCESS);
 }
 
-void ISelfController::SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-
-    bool flag = rp.Pop<bool>();
-    LOG_WARNING(Service_AM, "(STUBBED) called flag={}", flag);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ISelfController::SetFocusHandlingMode(Kernel::HLERequestContext& ctx) {
-    // Takes 3 input u8s with each field located immediately after the previous
-    // u8, these are bool flags. No output.
-    IPC::RequestParser rp{ctx};
-
-    struct FocusHandlingModeParams {
-        u8 unknown0;
-        u8 unknown1;
-        u8 unknown2;
-    };
-    const auto flags = rp.PopRaw<FocusHandlingModeParams>();
-
-    LOG_WARNING(Service_AM, "(STUBBED) called. unknown0={}, unknown1={}, unknown2={}",
-                flags.unknown0, flags.unknown1, flags.unknown2);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void ISelfController::SetRestartMessageEnabled(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx) {
     // Takes 3 input u8s with each field located immediately after the previous
     // u8, these are bool flags. No output.
@@ -402,6 +349,30 @@ void ISelfController::SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext&
     rb.Push(RESULT_SUCCESS);
 }
 
+void ISelfController::LockExit(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void ISelfController::UnlockExit(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(RESULT_SUCCESS);
+}
+
+void ISelfController::GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx) {
+    LOG_WARNING(Service_AM, "(STUBBED) called");
+
+    launchable_event.writable->Signal();
+
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(RESULT_SUCCESS);
+    rb.PushCopyObjects(launchable_event.readable);
+}
+
 void ISelfController::SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx) {
     LOG_WARNING(Service_AM, "(STUBBED) called");
 
@@ -520,20 +491,11 @@ ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_q
         {50, nullptr, "IsVrModeEnabled"},
         {51, nullptr, "SetVrModeEnabled"},
         {52, nullptr, "SwitchLcdBacklight"},
-        {53, nullptr, "BeginVrModeEx"},
-        {54, nullptr, "EndVrModeEx"},
         {55, nullptr, "IsInControllerFirmwareUpdateSection"},
         {60, &ICommonStateGetter::GetDefaultDisplayResolution, "GetDefaultDisplayResolution"},
         {61, &ICommonStateGetter::GetDefaultDisplayResolutionChangeEvent, "GetDefaultDisplayResolutionChangeEvent"},
         {62, nullptr, "GetHdcpAuthenticationState"},
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
-        {64, nullptr, "SetTvPowerStateMatchingMode"},
-        {65, nullptr, "GetApplicationIdByContentActionName"},
-        {66, nullptr, "SetCpuBoostMode"},
-        {80, nullptr, "PerformSystemButtonPressingIfInFocus"},
-        {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
-        {91, nullptr, "GetCurrentPerformanceConfiguration"},
-        {200, nullptr, "GetOperationModeSystemInfo"},
     };
     // clang-format on
 
@@ -945,19 +907,19 @@ void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContex
     rp.SetCurrentOffset(3);
     const auto handle{rp.Pop<Kernel::Handle>()};
 
-    const auto transfer_mem =
-        Core::System::GetInstance().CurrentProcess()->GetHandleTable().Get<Kernel::TransferMemory>(
+    const auto shared_mem =
+        Core::System::GetInstance().CurrentProcess()->GetHandleTable().Get<Kernel::SharedMemory>(
             handle);
 
-    if (transfer_mem == nullptr) {
+    if (shared_mem == nullptr) {
         LOG_ERROR(Service_AM, "shared_mem is a nullpr for handle={:08X}", handle);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(ResultCode(-1));
         return;
     }
 
-    const u8* const mem_begin = transfer_mem->GetPointer();
-    const u8* const mem_end = mem_begin + transfer_mem->GetSize();
+    const u8* mem_begin = shared_mem->GetPointer();
+    const u8* mem_end = mem_begin + shared_mem->GetSize();
     std::vector<u8> memory{mem_begin, mem_end};
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
@@ -973,8 +935,6 @@ IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationF
         {11, nullptr, "CreateApplicationAndPushAndRequestToStartForQuest"},
         {12, nullptr, "CreateApplicationAndRequestToStart"},
         {13, &IApplicationFunctions::CreateApplicationAndRequestToStartForQuest, "CreateApplicationAndRequestToStartForQuest"},
-        {14, nullptr, "CreateApplicationWithAttributeAndPushAndRequestToStartForQuest"},
-        {15, nullptr, "CreateApplicationWithAttributeAndRequestToStartForQuest"},
         {20, &IApplicationFunctions::EnsureSaveData, "EnsureSaveData"},
         {21, &IApplicationFunctions::GetDesiredLanguage, "GetDesiredLanguage"},
         {22, &IApplicationFunctions::SetTerminateResult, "SetTerminateResult"},
@@ -1248,7 +1208,6 @@ IGlobalStateController::IGlobalStateController() : ServiceFramework("IGlobalStat
         {2, nullptr, "StartSleepSequence"},
         {3, nullptr, "StartShutdownSequence"},
         {4, nullptr, "StartRebootSequence"},
-        {9, nullptr, "IsAutoPowerDownRequested"},
         {10, nullptr, "LoadAndApplyIdlePolicySettings"},
         {11, nullptr, "NotifyCecSettingsChanged"},
         {12, nullptr, "SetDefaultHomeButtonLongPressTime"},

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

@@ -117,19 +117,17 @@ public:
     ~ISelfController() override;
 
 private:
-    void LockExit(Kernel::HLERequestContext& ctx);
-    void UnlockExit(Kernel::HLERequestContext& ctx);
-    void EnterFatalSection(Kernel::HLERequestContext& ctx);
-    void LeaveFatalSection(Kernel::HLERequestContext& ctx);
-    void GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx);
-    void SetScreenShotPermission(Kernel::HLERequestContext& ctx);
-    void SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx);
-    void SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx);
     void SetFocusHandlingMode(Kernel::HLERequestContext& ctx);
     void SetRestartMessageEnabled(Kernel::HLERequestContext& ctx);
+    void SetPerformanceModeChangedNotification(Kernel::HLERequestContext& ctx);
+    void SetOperationModeChangedNotification(Kernel::HLERequestContext& ctx);
     void SetOutOfFocusSuspendingEnabled(Kernel::HLERequestContext& ctx);
+    void LockExit(Kernel::HLERequestContext& ctx);
+    void UnlockExit(Kernel::HLERequestContext& ctx);
+    void GetLibraryAppletLaunchableEvent(Kernel::HLERequestContext& ctx);
     void SetScreenShotImageOrientation(Kernel::HLERequestContext& ctx);
     void CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx);
+    void SetScreenShotPermission(Kernel::HLERequestContext& ctx);
     void SetHandlesRequestToDisplay(Kernel::HLERequestContext& ctx);
     void SetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
     void GetIdleTimeDetectionExtension(Kernel::HLERequestContext& ctx);
@@ -137,7 +135,6 @@ private:
     std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
     Kernel::EventPair launchable_event;
     u32 idle_time_detection_extension = 0;
-    u64 num_fatal_sections_entered = 0;
 };
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {

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

@@ -16,7 +16,6 @@ public:
                                  std::shared_ptr<AppletMessageQueue> msg_queue)
         : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)) {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ILibraryAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &ILibraryAppletProxy::GetSelfController, "GetSelfController"},
@@ -26,11 +25,8 @@ public:
             {10, &ILibraryAppletProxy::GetProcessWindingController, "GetProcessWindingController"},
             {11, &ILibraryAppletProxy::GetLibraryAppletCreator, "GetLibraryAppletCreator"},
             {20, &ILibraryAppletProxy::GetApplicationFunctions, "GetApplicationFunctions"},
-            {21, nullptr, "GetAppletCommonFunctions"},
             {1000, &ILibraryAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 
@@ -117,7 +113,6 @@ public:
                                 std::shared_ptr<AppletMessageQueue> msg_queue)
         : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)),
           msg_queue(std::move(msg_queue)) {
-        // clang-format off
         static const FunctionInfo functions[] = {
             {0, &ISystemAppletProxy::GetCommonStateGetter, "GetCommonStateGetter"},
             {1, &ISystemAppletProxy::GetSelfController, "GetSelfController"},
@@ -129,11 +124,8 @@ public:
             {20, &ISystemAppletProxy::GetHomeMenuFunctions, "GetHomeMenuFunctions"},
             {21, &ISystemAppletProxy::GetGlobalStateController, "GetGlobalStateController"},
             {22, &ISystemAppletProxy::GetApplicationCreator, "GetApplicationCreator"},
-            {23, nullptr, "GetAppletCommonFunctions"},
             {1000, &ISystemAppletProxy::GetDebugFunctions, "GetDebugFunctions"},
         };
-        // clang-format on
-
         RegisterHandlers(functions);
     }
 

src/core/hle/service/am/applets/web_browser.cpp

@@ -86,7 +86,7 @@ static FileSys::VirtualFile GetManualRomFS() {
     if (loader.ReadManualRomFS(out) == Loader::ResultStatus::Success)
         return out;
 
-    const auto& installed{Core::System::GetInstance().GetContentProvider()};
+    const auto& installed{FileSystem::GetUnionContents()};
     const auto res = installed.GetEntry(Core::System::GetInstance().CurrentProcess()->GetTitleID(),
                                         FileSys::ContentRecordType::Manual);
 

src/core/hle/service/aoc/aoc_u.cpp

@@ -33,11 +33,11 @@ static bool CheckAOCTitleIDMatchesBase(u64 title_id, u64 base) {
 
 static std::vector<u64> AccumulateAOCTitleIDs() {
     std::vector<u64> add_on_content;
-    const auto& rcu = Core::System::GetInstance().GetContentProvider();
+    const auto rcu = FileSystem::GetUnionContents();
     const auto list =
         rcu.ListEntriesFilter(FileSys::TitleType::AOC, FileSys::ContentRecordType::Data);
     std::transform(list.begin(), list.end(), std::back_inserter(add_on_content),
-                   [](const FileSys::ContentProviderEntry& rce) { return rce.title_id; });
+                   [](const FileSys::RegisteredCacheEntry& rce) { return rce.title_id; });
     add_on_content.erase(
         std::remove_if(
             add_on_content.begin(), add_on_content.end(),
@@ -50,7 +50,6 @@ static std::vector<u64> AccumulateAOCTitleIDs() {
 }
 
 AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs()) {
-    // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "CountAddOnContentByApplicationId"},
         {1, nullptr, "ListAddOnContentByApplicationId"},
@@ -61,10 +60,7 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
         {6, nullptr, "PrepareAddOnContentByApplicationId"},
         {7, &AOC_U::PrepareAddOnContent, "PrepareAddOnContent"},
         {8, &AOC_U::GetAddOnContentListChangedEvent, "GetAddOnContentListChangedEvent"},
-        {100, nullptr, "CreateEcPurchasedEventManager"},
     };
-    // clang-format on
-
     RegisterHandlers(functions);
 
     auto& kernel = Core::System::GetInstance().Kernel();

src/core/hle/service/apm/interface.cpp

@@ -87,8 +87,6 @@ APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
         {3, nullptr, "GetLastThrottlingState"},
         {4, nullptr, "ClearLastThrottlingState"},
         {5, nullptr, "LoadAndApplySettings"},
-        {6, nullptr, "SetCpuBoostMode"},
-        {7, nullptr, "GetCurrentPerformanceConfiguration"},
     };
     // clang-format on
 

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

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/audio/audctl.h"
 
 namespace Service::Audio {
@@ -13,8 +11,8 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {
     static const FunctionInfo functions[] = {
         {0, nullptr, "GetTargetVolume"},
         {1, nullptr, "SetTargetVolume"},
-        {2, &AudCtl::GetTargetVolumeMin, "GetTargetVolumeMin"},
-        {3, &AudCtl::GetTargetVolumeMax, "GetTargetVolumeMax"},
+        {2, nullptr, "GetTargetVolumeMin"},
+        {3, nullptr, "GetTargetVolumeMax"},
         {4, nullptr, "IsTargetMute"},
         {5, nullptr, "SetTargetMute"},
         {6, nullptr, "IsTargetConnected"},
@@ -46,28 +44,4 @@ AudCtl::AudCtl() : ServiceFramework{"audctl"} {
 
 AudCtl::~AudCtl() = default;
 
-void AudCtl::GetTargetVolumeMin(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Audio, "called.");
-
-    // This service function is currently hardcoded on the
-    // actual console to this value (as of 6.0.0).
-    constexpr s32 target_min_volume = 0;
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(target_min_volume);
-}
-
-void AudCtl::GetTargetVolumeMax(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Audio, "called.");
-
-    // This service function is currently hardcoded on the
-    // actual console to this value (as of 6.0.0).
-    constexpr s32 target_max_volume = 15;
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(target_max_volume);
-}
-
 } // namespace Service::Audio

src/core/hle/service/audio/audctl.h

@@ -12,10 +12,6 @@ class AudCtl final : public ServiceFramework<AudCtl> {
 public:
     explicit AudCtl();
     ~AudCtl() override;
-
-private:
-    void GetTargetVolumeMin(Kernel::HLERequestContext& ctx);
-    void GetTargetVolumeMax(Kernel::HLERequestContext& ctx);
 };
 
 } // namespace Service::Audio

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

@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audin_u.h"
 
 namespace Service::Audio {
@@ -25,12 +28,12 @@ public:
             {11, nullptr, "GetAudioInBufferCount"},
             {12, nullptr, "SetAudioInDeviceGain"},
             {13, nullptr, "GetAudioInDeviceGain"},
-            {14, nullptr, "FlushAudioInBuffers"},
         };
         // clang-format on
 
         RegisterHandlers(functions);
     }
+    ~IAudioIn() = default;
 };
 
 AudInU::AudInU() : ServiceFramework("audin:u") {

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

@@ -44,7 +44,7 @@ public:
               std::string&& unique_name)
         : ServiceFramework("IAudioOut"), audio_core(audio_core),
           device_name(std::move(device_name)), audio_params(audio_params) {
-        // clang-format off
+
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
             {1, &IAudioOut::StartAudioOut, "StartAudioOut"},
@@ -58,10 +58,7 @@ public:
             {9, &IAudioOut::GetAudioOutBufferCount, "GetAudioOutBufferCount"},
             {10, nullptr, "GetAudioOutPlayedSampleCount"},
             {11, nullptr, "FlushAudioOutBuffers"},
-            {12, nullptr, "SetAudioOutVolume"},
-            {13, nullptr, "GetAudioOutVolume"},
         };
-        // clang-format on
         RegisterHandlers(functions);
 
         // This is the event handle used to check if the audio buffer was released
@@ -153,6 +150,7 @@ private:
     void GetReleasedAudioOutBufferImpl(Kernel::HLERequestContext& ctx) {
         LOG_DEBUG(Service_Audio, "called {}", ctx.Description());
 
+        IPC::RequestParser rp{ctx};
         const u64 max_count{ctx.GetWriteBufferSize() / sizeof(u64)};
         const auto released_buffers{audio_core.GetTagsAndReleaseBuffers(stream, max_count)};
 
@@ -196,9 +194,12 @@ private:
 void AudOutU::ListAudioOutsImpl(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Audio, "called");
 
+    IPC::RequestParser rp{ctx};
+
     ctx.WriteBuffer(DefaultDevice);
 
     IPC::ResponseBuilder rb{ctx, 3};
+
     rb.Push(RESULT_SUCCESS);
     rb.Push<u32>(1); // Amount of audio devices
 }

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

@@ -2,6 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/audio/audrec_u.h"
 
 namespace Service::Audio {
@@ -27,6 +30,7 @@ public:
 
         RegisterHandlers(functions);
     }
+    ~IFinalOutputRecorder() = default;
 };
 
 AudRecU::AudRecU() : ServiceFramework("audrec:u") {

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

@@ -10,7 +10,6 @@
 #include "common/alignment.h"
 #include "common/common_funcs.h"
 #include "common/logging/log.h"
-#include "common/string_util.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
@@ -185,6 +184,7 @@ public:
 private:
     void ListAudioDeviceName(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
 
         constexpr std::array<char, 15> audio_interface{{"AudioInterface"}};
         ctx.WriteBuffer(audio_interface);
@@ -195,13 +195,13 @@ private:
     }
 
     void SetAudioDeviceOutputVolume(Kernel::HLERequestContext& ctx) {
+        LOG_WARNING(Service_Audio, "(STUBBED) called");
+
         IPC::RequestParser rp{ctx};
-        const f32 volume = rp.Pop<f32>();
+        f32 volume = static_cast<f32>(rp.Pop<u32>());
 
-        const auto device_name_buffer = ctx.ReadBuffer();
-        const std::string name = Common::StringFromBuffer(device_name_buffer);
-
-        LOG_WARNING(Service_Audio, "(STUBBED) called. name={}, volume={}", name, volume);
+        auto file_buffer = ctx.ReadBuffer();
+        auto end = std::find(file_buffer.begin(), file_buffer.end(), '\0');
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -209,6 +209,7 @@ private:
 
     void GetActiveAudioDeviceName(Kernel::HLERequestContext& ctx) {
         LOG_WARNING(Service_Audio, "(STUBBED) called");
+        IPC::RequestParser rp{ctx};
 
         constexpr std::array<char, 12> audio_interface{{"AudioDevice"}};
         ctx.WriteBuffer(audio_interface);

src/core/hle/service/btdrv/btdrv.cpp

@@ -154,8 +154,7 @@ public:
             {96, nullptr, "GetLeHidEventInfo"},
             {97, nullptr, "RegisterBleHidEvent"},
             {98, nullptr, "SetLeScanParameter"},
-            {256, nullptr, "GetIsManufacturingMode"},
-            {257, nullptr, "EmulateBluetoothCrash"},
+            {256, nullptr, "GetIsManufacturingMode"}
         };
         // clang-format on