vk_texture_cache: Support image store on sRGB images with VkImageViewUsageCreateInfo

Vulkan 1.0 didn't support creating sRGB image views on an ABGR8 VkImage
with storage usage bits. VK_KHR_maintenance2 addressed this allowing to
reduce the usage bits on a VkImageView.

To allow image store on non-sRGB image views when the VkImage is created
with sRGB, always create VkImages without sRGB and add the sRGB format
on the view.

.ci/scripts/common/post-upload.sh

@@ -15,5 +15,5 @@ mv "${REV_NAME}-source.tar.xz" $RELEASE_NAME
 7z a "$REV_NAME.7z" $RELEASE_NAME
 
 # move the compiled archive into the artifacts directory to be uploaded by travis releases
-mv "$ARCHIVE_NAME" artifacts/
-mv "$REV_NAME.7z" artifacts/
+mv "$ARCHIVE_NAME" "${ARTIFACTS_DIR}/"
+mv "$REV_NAME.7z" "${ARTIFACTS_DIR}/"

.ci/scripts/common/pre-upload.sh

@@ -2,5 +2,6 @@
 
 GITDATE="`git show -s --date=short --format='%ad' | sed 's/-//g'`"
 GITREV="`git show -s --format='%h'`"
+ARTIFACTS_DIR="artifacts"
 
-mkdir -p artifacts
+mkdir -p "${ARTIFACTS_DIR}/"

.ci/scripts/linux/docker.sh

@@ -1,14 +1,49 @@
 #!/bin/bash -ex
 
+# Exit on error, rather than continuing with the rest of the script.
+set -e
+
 cd /yuzu
 
 ccache -s
 
 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON
+cmake .. -DDISPLAY_VERSION=$1 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DCMAKE_INSTALL_PREFIX="/usr"
 
-ninja
+make -j$(nproc)
 
 ccache -s
 
 ctest -VV -C Release
+
+make install DESTDIR=AppDir
+rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester
+
+# Download tools needed to build an AppImage
+wget -nc https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage
+wget -nc https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-x86_64.AppImage
+wget -nc https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/AppRun-patched-x86_64
+wget -nc https://github.com/darealshinji/AppImageKit-checkrt/releases/download/continuous/exec-x86_64.so
+# Set executable bit
+chmod 755 \
+    AppRun-patched-x86_64 \
+    exec-x86_64.so \
+    linuxdeploy-x86_64.AppImage \
+    linuxdeploy-plugin-qt-x86_64.AppImage
+
+# Workaround for https://github.com/AppImage/AppImageKit/issues/828
+export APPIMAGE_EXTRACT_AND_RUN=1
+
+mkdir -p AppDir/usr/optional
+mkdir -p AppDir/usr/optional/libstdc++
+mkdir -p AppDir/usr/optional/libgcc_s
+
+# Deploy yuzu's needed dependencies
+./linuxdeploy-x86_64.AppImage --appdir AppDir --plugin qt
+
+# Workaround for building yuzu with GCC 10 but also trying to distribute it to Ubuntu 18.04 et al.
+# See https://github.com/darealshinji/AppImageKit-checkrt
+cp exec-x86_64.so AppDir/usr/optional/exec.so
+cp AppRun-patched-x86_64 AppDir/AppRun
+cp --dereference /usr/lib/x86_64-linux-gnu/libstdc++.so.6 AppDir/usr/optional/libstdc++/libstdc++.so.6
+cp --dereference /lib/x86_64-linux-gnu/libgcc_s.so.1 AppDir/usr/optional/libgcc_s/libgcc_s.so.1

.ci/scripts/linux/upload.sh

@@ -2,6 +2,7 @@
 
 . .ci/scripts/common/pre-upload.sh
 
+APPIMAGE_NAME="yuzu-${GITDATE}-${GITREV}.AppImage"
 REV_NAME="yuzu-linux-${GITDATE}-${GITREV}"
 ARCHIVE_NAME="${REV_NAME}.tar.xz"
 COMPRESSION_FLAGS="-cJvf"
@@ -17,4 +18,24 @@ mkdir "$DIR_NAME"
 cp build/bin/yuzu-cmd "$DIR_NAME"
 cp build/bin/yuzu "$DIR_NAME"
 
+# Build an AppImage
+cd build
+
+wget -nc https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
+chmod 755 appimagetool-x86_64.AppImage
+
+if [ "${RELEASE_NAME}" = "mainline" ]; then
+    # Generate update information if releasing to mainline
+    ./appimagetool-x86_64.AppImage -u "gh-releases-zsync|yuzu-emu|yuzu-${RELEASE_NAME}|latest|yuzu-*.AppImage.zsync" AppDir "${APPIMAGE_NAME}"
+else
+    ./appimagetool-x86_64.AppImage AppDir "${APPIMAGE_NAME}"
+fi
+cd ..
+
+# Copy the AppImage and update info to the artifacts directory and avoid compressing it
+cp "build/${APPIMAGE_NAME}" "${ARTIFACTS_DIR}/"
+if [ -f "build/${APPIMAGE_NAME}.zsync" ]; then
+    cp "build/${APPIMAGE_NAME}.zsync" "${ARTIFACTS_DIR}/"
+fi
+
 . .ci/scripts/common/post-upload.sh

.ci/scripts/windows/docker.sh

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

.ci/templates/build-msvc.yml

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

.travis/linux/build.sh

@@ -1,4 +1,4 @@
 #!/bin/bash -ex
 
 mkdir -p "$HOME/.ccache"
-docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/root/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh
+docker run -e ENABLE_COMPATIBILITY_REPORTING --env-file .travis/common/travis-ci.env -v $(pwd):/yuzu -v "$HOME/.ccache":/home/yuzu/.ccache yuzuemu/build-environments:linux-fresh /bin/bash /yuzu/.travis/linux/docker.sh

CMakeLists.txt

@@ -24,10 +24,12 @@ option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implemen
 
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
-option(ENABLE_VULKAN "Enables Vulkan backend" ON)
-
 option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence" OFF)
 
+if (NOT ENABLE_WEB_SERVICE)
+    set(YUZU_ENABLE_BOXCAT OFF)
+endif()
+
 # Default to a Release build
 get_property(IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if (NOT IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
@@ -113,6 +115,9 @@ if (NOT DEFINED ARCHITECTURE)
 endif()
 message(STATUS "Target architecture: ${ARCHITECTURE}")
 
+if (UNIX)
+    add_definitions(-DYUZU_UNIX=1)
+endif()
 
 # Configure C++ standard
 # ===========================
@@ -157,7 +162,6 @@ macro(yuzu_find_packages)
     # Capitalization matters here. We need the naming to match the generated paths from Conan
     set(REQUIRED_LIBS
     #    Cmake Pkg Prefix  Version     Conan Pkg
-        "Boost             1.73        boost/1.73.0"
         "Catch2            2.13        catch2/2.13.0"
         "fmt               7.1         fmt/7.1.2"
     # can't use until https://github.com/bincrafters/community/issues/1173
@@ -165,7 +169,7 @@ macro(yuzu_find_packages)
         "lz4               1.8         lz4/1.9.2"
         "nlohmann_json     3.8         nlohmann_json/3.8.0"
         "ZLIB              1.2         zlib/1.2.11"
-        "zstd              1.4         zstd/1.4.5"
+        "zstd              1.4         zstd/1.4.8"
     )
 
     foreach(PACKAGE ${REQUIRED_LIBS})
@@ -192,6 +196,22 @@ macro(yuzu_find_packages)
     unset(FN_FORCE_REQUIRED)
 endmacro()
 
+find_package(Boost 1.73.0 COMPONENTS context headers QUIET)
+if (Boost_FOUND)
+    set(Boost_LIBRARIES Boost::boost)
+    # Conditionally add Boost::context only if the active version of the Conan or system Boost package provides it
+    # The old version is missing Boost::context, so we want to avoid adding in that case
+    # The new version requires adding Boost::context to prevent linking issues
+    #
+    # This one is used by Conan on subsequent CMake configures, not the first configure.
+    if (TARGET Boost::context)
+        list(APPEND Boost_LIBRARIES Boost::context)
+    endif()
+else()
+    message(STATUS "Boost 1.73.0 or newer not found, falling back to Conan")
+    list(APPEND CONAN_REQUIRED_LIBS "boost/1.73.0")
+endif()
+
 # Attempt to locate any packages that are required and report the missing ones in CONAN_REQUIRED_LIBS
 yuzu_find_packages()
 
@@ -223,7 +243,7 @@ if(ENABLE_QT)
     if (YUZU_USE_QT_WEB_ENGINE)
         find_package(Qt5 COMPONENTS WebEngineCore WebEngineWidgets)
     endif()
-	
+
     if (ENABLE_QT_TRANSLATION)
         find_package(Qt5 REQUIRED COMPONENTS LinguistTools ${QT_PREFIX_HINT})
     endif()
@@ -296,6 +316,17 @@ if (CONAN_REQUIRED_LIBS)
     # this time with required, so we bail if its not found.
     yuzu_find_packages(FORCE_REQUIRED)
 
+    if (NOT Boost_FOUND)
+        find_package(Boost 1.73.0 REQUIRED COMPONENTS context headers)
+        set(Boost_LIBRARIES Boost::boost)
+        # Conditionally add Boost::context only if the active version of the Conan Boost package provides it
+        # The old version is missing Boost::context, so we want to avoid adding in that case
+        # The new version requires adding Boost::context to prevent linking issues
+        if (TARGET Boost::context)
+            list(APPEND Boost_LIBRARIES Boost::context)
+        endif()
+    endif()
+
     # Due to issues with variable scopes in functions, we need to also find_package(qt5) outside of the function
     if(ENABLE_QT)
         list(APPEND CMAKE_MODULE_PATH "${CONAN_QT_ROOT_RELEASE}")

README.md

@@ -30,7 +30,6 @@ If you want to contribute to the user interface translation, please check out th
 
 * __Windows__: [Windows Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Windows)
 * __Linux__: [Linux Build](https://github.com/yuzu-emu/yuzu/wiki/Building-For-Linux)
-* __macOS__: [macOS Build](https://github.com/yuzu-emu/yuzu/wiki/Building-for-macOS)
 
 
 ### Support

externals/CMakeLists.txt

@@ -61,9 +61,7 @@ if (USE_DISCORD_PRESENCE)
 endif()
 
 # Sirit
-if (ENABLE_VULKAN)
-    add_subdirectory(sirit)
-endif()
+add_subdirectory(sirit)
 
 # libzip
 find_package(Libzip 1.5)

src/CMakeLists.txt

@@ -45,10 +45,15 @@ if (MSVC)
 
         # Warnings
         /W3
+        /we4062 # enumerator 'identifier' in a switch of enum 'enumeration' is not handled
+        /we4101 # 'identifier': unreferenced local variable
+        /we4265 # 'class': class has virtual functions, but destructor is not virtual
+        /we4388 # signed/unsigned mismatch
         /we4547 # 'operator' : operator before comma has no effect; expected operator with side-effect
         /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
         /we4555 # Expression has no effect; expected expression with side-effect
         /we4834 # Discarding return value of function with 'nodiscard' attribute
+        /we5038 # data member 'member1' will be initialized after data member 'member2'
     )
 
     # /GS- - No stack buffer overflow checks
@@ -62,10 +67,15 @@ else()
         -Werror=implicit-fallthrough
         -Werror=missing-declarations
         -Werror=reorder
+        -Werror=switch
+        -Werror=uninitialized
+        -Werror=unused-function
         -Werror=unused-result
+        -Werror=unused-variable
         -Wextra
         -Wmissing-declarations
         -Wno-attributes
+        -Wno-invalid-offsetof
         -Wno-unused-parameter
     )
 
@@ -120,7 +130,6 @@ add_subdirectory(tests)
 
 if (ENABLE_SDL2)
     add_subdirectory(yuzu_cmd)
-    add_subdirectory(yuzu_tester)
 endif()
 
 if (ENABLE_QT)

src/audio_core/CMakeLists.txt

@@ -51,6 +51,8 @@ if (NOT MSVC)
         -Werror=implicit-fallthrough
         -Werror=reorder
         -Werror=sign-compare
+        -Werror=shadow
+        -Werror=unused-parameter
         -Werror=unused-variable
 
         $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>

src/audio_core/algorithm/filter.cpp

@@ -31,8 +31,8 @@ Filter Filter::LowPass(double cutoff, double Q) {
 
 Filter::Filter() : Filter(1.0, 0.0, 0.0, 1.0, 0.0, 0.0) {}
 
-Filter::Filter(double a0, double a1, double a2, double b0, double b1, double b2)
-    : a1(a1 / a0), a2(a2 / a0), b0(b0 / a0), b1(b1 / a0), b2(b2 / a0) {}
+Filter::Filter(double a0_, double a1_, double a2_, double b0_, double b1_, double b2_)
+    : a1(a1_ / a0_), a2(a2_ / a0_), b0(b0_ / a0_), b1(b1_ / a0_), b2(b2_ / a0_) {}
 
 void Filter::Process(std::vector<s16>& signal) {
     const std::size_t num_frames = signal.size() / 2;
@@ -69,7 +69,7 @@ CascadingFilter CascadingFilter::LowPass(double cutoff, std::size_t cascade_size
 }
 
 CascadingFilter::CascadingFilter() = default;
-CascadingFilter::CascadingFilter(std::vector<Filter> filters) : filters(std::move(filters)) {}
+CascadingFilter::CascadingFilter(std::vector<Filter> filters_) : filters(std::move(filters_)) {}
 
 void CascadingFilter::Process(std::vector<s16>& signal) {
     for (auto& filter : filters) {

src/audio_core/algorithm/filter.h

@@ -25,7 +25,7 @@ public:
     /// Passthrough filter.
     Filter();
 
-    Filter(double a0, double a1, double a2, double b0, double b1, double b2);
+    Filter(double a0_, double a1_, double a2_, double b0_, double b1_, double b2_);
 
     void Process(std::vector<s16>& signal);
 
@@ -51,7 +51,7 @@ public:
     /// Passthrough.
     CascadingFilter();
 
-    explicit CascadingFilter(std::vector<Filter> filters);
+    explicit CascadingFilter(std::vector<Filter> filters_);
 
     void Process(std::vector<s16>& signal);
 

src/audio_core/algorithm/interpolate.cpp

@@ -218,7 +218,7 @@ void Resample(s32* output, const s32* input, s32 pitch, s32& fraction, std::size
         const auto l2 = lut[lut_index + 2];
         const auto l3 = lut[lut_index + 3];
 
-        const auto s0 = static_cast<s32>(input[index]);
+        const auto s0 = static_cast<s32>(input[index + 0]);
         const auto s1 = static_cast<s32>(input[index + 1]);
         const auto s2 = static_cast<s32>(input[index + 2]);
         const auto s3 = static_cast<s32>(input[index + 3]);

src/audio_core/audio_out.cpp

@@ -43,6 +43,10 @@ std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream,
     return stream->GetTagsAndReleaseBuffers(max_count);
 }
 
+std::vector<Buffer::Tag> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream) {
+    return stream->GetTagsAndReleaseBuffers();
+}
+
 void AudioOut::StartStream(StreamPtr stream) {
     stream->Play();
 }

src/audio_core/audio_out.h

@@ -31,6 +31,9 @@ public:
     /// Returns a vector of recently released buffers specified by tag for the specified stream
     std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream, std::size_t max_count);
 
+    /// Returns a vector of all recently released buffers specified by tag for the specified stream
+    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(StreamPtr stream);
+
     /// Starts an audio stream for playback
     void StartStream(StreamPtr stream);
 

src/audio_core/audio_renderer.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <limits>
 #include <vector>
 
 #include "audio_core/audio_out.h"
@@ -10,32 +11,81 @@
 #include "audio_core/info_updater.h"
 #include "audio_core/voice_context.h"
 #include "common/logging/log.h"
-#include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 #include "core/settings.h"
 
+namespace {
+[[nodiscard]] static constexpr s16 ClampToS16(s32 value) {
+    return static_cast<s16>(std::clamp(value, s32{std::numeric_limits<s16>::min()},
+                                       s32{std::numeric_limits<s16>::max()}));
+}
+
+[[nodiscard]] static constexpr s16 Mix2To1(s16 l_channel, s16 r_channel) {
+    // Mix 50% from left and 50% from right channel
+    constexpr float l_mix_amount = 50.0f / 100.0f;
+    constexpr float r_mix_amount = 50.0f / 100.0f;
+    return ClampToS16(static_cast<s32>((static_cast<float>(l_channel) * l_mix_amount) +
+                                       (static_cast<float>(r_channel) * r_mix_amount)));
+}
+
+[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2(s16 fl_channel, s16 fr_channel,
+                                                            s16 fc_channel,
+                                                            [[maybe_unused]] s16 lf_channel,
+                                                            s16 bl_channel, s16 br_channel) {
+    // Front channels are mixed 36.94%, Center channels are mixed to be 26.12% & the back channels
+    // are mixed to be 36.94%
+
+    constexpr float front_mix_amount = 36.94f / 100.0f;
+    constexpr float center_mix_amount = 26.12f / 100.0f;
+    constexpr float back_mix_amount = 36.94f / 100.0f;
+
+    // Mix 50% from left and 50% from right channel
+    const auto left = front_mix_amount * static_cast<float>(fl_channel) +
+                      center_mix_amount * static_cast<float>(fc_channel) +
+                      back_mix_amount * static_cast<float>(bl_channel);
+
+    const auto right = front_mix_amount * static_cast<float>(fr_channel) +
+                       center_mix_amount * static_cast<float>(fc_channel) +
+                       back_mix_amount * static_cast<float>(br_channel);
+
+    return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
+}
+
+[[nodiscard]] static constexpr std::tuple<s16, s16> Mix6To2WithCoefficients(
+    s16 fl_channel, s16 fr_channel, s16 fc_channel, s16 lf_channel, s16 bl_channel, s16 br_channel,
+    const std::array<float_le, 4>& coeff) {
+    const auto left =
+        static_cast<float>(fl_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(bl_channel) * coeff[0];
+
+    const auto right =
+        static_cast<float>(fr_channel) * coeff[0] + static_cast<float>(fc_channel) * coeff[1] +
+        static_cast<float>(lf_channel) * coeff[2] + static_cast<float>(br_channel) * coeff[0];
+
+    return {ClampToS16(static_cast<s32>(left)), ClampToS16(static_cast<s32>(right))};
+}
+
+} // namespace
+
 namespace AudioCore {
 AudioRenderer::AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
                              AudioCommon::AudioRendererParameter params,
-                             std::shared_ptr<Kernel::WritableEvent> buffer_event,
+                             Stream::ReleaseCallback&& release_callback,
                              std::size_t instance_number)
-    : worker_params{params}, buffer_event{buffer_event},
-      memory_pool_info(params.effect_count + params.voice_count * 4),
+    : worker_params{params}, memory_pool_info(params.effect_count + params.voice_count * 4),
       voice_context(params.voice_count), effect_context(params.effect_count), mix_context(),
       sink_context(params.sink_count), splitter_context(),
       voices(params.voice_count), memory{memory_},
       command_generator(worker_params, voice_context, mix_context, splitter_context, effect_context,
-                        memory),
-      temp_mix_buffer(AudioCommon::TOTAL_TEMP_MIX_SIZE) {
+                        memory) {
     behavior_info.SetUserRevision(params.revision);
     splitter_context.Initialize(behavior_info, params.splitter_count,
                                 params.num_splitter_send_channels);
     mix_context.Initialize(behavior_info, params.submix_count + 1, params.effect_count);
     audio_out = std::make_unique<AudioCore::AudioOut>();
-    stream =
-        audio_out->OpenStream(core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
-                              fmt::format("AudioRenderer-Instance{}", instance_number),
-                              [=]() { buffer_event->Signal(); });
+    stream = audio_out->OpenStream(
+        core_timing, params.sample_rate, AudioCommon::STREAM_NUM_CHANNELS,
+        fmt::format("AudioRenderer-Instance{}", instance_number), std::move(release_callback));
     audio_out->StartStream(stream);
 
     QueueMixedBuffer(0);
@@ -62,10 +112,6 @@ Stream::State AudioRenderer::GetStreamState() const {
     return stream->GetState();
 }
 
-static constexpr s16 ClampToS16(s32 value) {
-    return static_cast<s16>(std::clamp(value, -32768, 32767));
-}
-
 ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_params,
                                               std::vector<u8>& output_params) {
 
@@ -104,8 +150,8 @@ ResultCode AudioRenderer::UpdateAudioRenderer(const std::vector<u8>& input_param
         }
     }
 
-    auto mix_result = info_updater.UpdateMixes(mix_context, worker_params.mix_buffer_count,
-                                               splitter_context, effect_context);
+    const auto mix_result = info_updater.UpdateMixes(mix_context, worker_params.mix_buffer_count,
+                                                     splitter_context, effect_context);
 
     if (mix_result.IsError()) {
         LOG_ERROR(Audio, "Failed to update mix parameters");
@@ -194,20 +240,22 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
         for (std::size_t i = 0; i < BUFFER_SIZE; i++) {
             if (channel_count == 1) {
                 const auto sample = ClampToS16(mix_buffers[0][i]);
-                buffer[i * stream_channel_count + 0] = sample;
-                if (stream_channel_count > 1) {
-                    buffer[i * stream_channel_count + 1] = sample;
+
+                // Place sample in all channels
+                for (u32 channel = 0; channel < stream_channel_count; channel++) {
+                    buffer[i * stream_channel_count + channel] = sample;
                 }
+
                 if (stream_channel_count == 6) {
-                    buffer[i * stream_channel_count + 2] = sample;
-                    buffer[i * stream_channel_count + 4] = sample;
-                    buffer[i * stream_channel_count + 5] = sample;
+                    // Output stream has a LF channel, mute it!
+                    buffer[i * stream_channel_count + 3] = 0;
                 }
+
             } else if (channel_count == 2) {
                 const auto l_sample = ClampToS16(mix_buffers[0][i]);
                 const auto r_sample = ClampToS16(mix_buffers[1][i]);
                 if (stream_channel_count == 1) {
-                    buffer[i * stream_channel_count + 0] = l_sample;
+                    buffer[i * stream_channel_count + 0] = Mix2To1(l_sample, r_sample);
                 } else if (stream_channel_count == 2) {
                     buffer[i * stream_channel_count + 0] = l_sample;
                     buffer[i * stream_channel_count + 1] = r_sample;
@@ -215,8 +263,8 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                     buffer[i * stream_channel_count + 0] = l_sample;
                     buffer[i * stream_channel_count + 1] = r_sample;
 
-                    buffer[i * stream_channel_count + 2] =
-                        ClampToS16((static_cast<s32>(l_sample) + static_cast<s32>(r_sample)) / 2);
+                    // Combine both left and right channels to the center channel
+                    buffer[i * stream_channel_count + 2] = Mix2To1(l_sample, r_sample);
 
                     buffer[i * stream_channel_count + 4] = l_sample;
                     buffer[i * stream_channel_count + 5] = r_sample;
@@ -231,17 +279,25 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
                 const auto br_sample = ClampToS16(mix_buffers[5][i]);
 
                 if (stream_channel_count == 1) {
-                    buffer[i * stream_channel_count + 0] = fc_sample;
+                    // Games seem to ignore the center channel half the time, we use the front left
+                    // and right channel for mixing as that's where majority of the audio goes
+                    buffer[i * stream_channel_count + 0] = Mix2To1(fl_sample, fr_sample);
                 } else if (stream_channel_count == 2) {
-                    buffer[i * stream_channel_count + 0] =
-                        static_cast<s16>(0.3694f * static_cast<float>(fl_sample) +
-                                         0.2612f * static_cast<float>(fc_sample) +
-                                         0.3694f * static_cast<float>(bl_sample));
-                    buffer[i * stream_channel_count + 1] =
-                        static_cast<s16>(0.3694f * static_cast<float>(fr_sample) +
-                                         0.2612f * static_cast<float>(fc_sample) +
-                                         0.3694f * static_cast<float>(br_sample));
+                    // Mix all channels into 2 channels
+                    if (sink_context.HasDownMixingCoefficients()) {
+                        const auto [left, right] = Mix6To2WithCoefficients(
+                            fl_sample, fr_sample, fc_sample, lf_sample, bl_sample, br_sample,
+                            sink_context.GetDownmixCoefficients());
+                        buffer[i * stream_channel_count + 0] = left;
+                        buffer[i * stream_channel_count + 1] = right;
+                    } else {
+                        const auto [left, right] = Mix6To2(fl_sample, fr_sample, fc_sample,
+                                                           lf_sample, bl_sample, br_sample);
+                        buffer[i * stream_channel_count + 0] = left;
+                        buffer[i * stream_channel_count + 1] = right;
+                    }
                 } else if (stream_channel_count == 6) {
+                    // Pass through
                     buffer[i * stream_channel_count + 0] = fl_sample;
                     buffer[i * stream_channel_count + 1] = fr_sample;
                     buffer[i * stream_channel_count + 2] = fc_sample;
@@ -259,7 +315,7 @@ void AudioRenderer::QueueMixedBuffer(Buffer::Tag tag) {
 }
 
 void AudioRenderer::ReleaseAndQueueBuffers() {
-    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream, 2)};
+    const auto released_buffers{audio_out->GetTagsAndReleaseBuffers(stream)};
     for (const auto& tag : released_buffers) {
         QueueMixedBuffer(tag);
     }

src/audio_core/audio_renderer.h

@@ -27,46 +27,35 @@ namespace Core::Timing {
 class CoreTiming;
 }
 
-namespace Kernel {
-class WritableEvent;
-}
-
 namespace Core::Memory {
 class Memory;
 }
 
 namespace AudioCore {
-using DSPStateHolder = std::array<VoiceState*, 6>;
+using DSPStateHolder = std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT>;
 
 class AudioOut;
 
-struct RendererInfo {
-    u64_le elasped_frame_count{};
-    INSERT_PADDING_WORDS(2);
-};
-static_assert(sizeof(RendererInfo) == 0x10, "RendererInfo is an invalid size");
-
 class AudioRenderer {
 public:
     AudioRenderer(Core::Timing::CoreTiming& core_timing, Core::Memory::Memory& memory_,
                   AudioCommon::AudioRendererParameter params,
-                  std::shared_ptr<Kernel::WritableEvent> buffer_event, std::size_t instance_number);
+                  Stream::ReleaseCallback&& release_callback, std::size_t instance_number);
     ~AudioRenderer();
 
-    ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
-                                   std::vector<u8>& output_params);
+    [[nodiscard]] ResultCode UpdateAudioRenderer(const std::vector<u8>& input_params,
+                                                 std::vector<u8>& output_params);
     void QueueMixedBuffer(Buffer::Tag tag);
     void ReleaseAndQueueBuffers();
-    u32 GetSampleRate() const;
-    u32 GetSampleCount() const;
-    u32 GetMixBufferCount() const;
-    Stream::State GetStreamState() const;
+    [[nodiscard]] u32 GetSampleRate() const;
+    [[nodiscard]] u32 GetSampleCount() const;
+    [[nodiscard]] u32 GetMixBufferCount() const;
+    [[nodiscard]] Stream::State GetStreamState() const;
 
 private:
     BehaviorInfo behavior_info{};
 
     AudioCommon::AudioRendererParameter worker_params;
-    std::shared_ptr<Kernel::WritableEvent> buffer_event;
     std::vector<ServerMemoryPoolInfo> memory_pool_info;
     VoiceContext voice_context;
     EffectContext effect_context;
@@ -79,7 +68,6 @@ private:
     Core::Memory::Memory& memory;
     CommandGenerator command_generator;
     std::size_t elapsed_frame_count{};
-    std::vector<s32> temp_mix_buffer{};
 };
 
 } // namespace AudioCore

src/audio_core/behavior_info.h

@@ -43,22 +43,22 @@ public:
     void ClearError();
     void UpdateFlags(u64_le dest_flags);
     void SetUserRevision(u32_le revision);
-    u32_le GetUserRevision() const;
-    u32_le GetProcessRevision() const;
+    [[nodiscard]] u32_le GetUserRevision() const;
+    [[nodiscard]] u32_le GetProcessRevision() const;
 
-    bool IsAdpcmLoopContextBugFixed() const;
-    bool IsSplitterSupported() const;
-    bool IsLongSizePreDelaySupported() const;
-    bool IsAudioRendererProcessingTimeLimit80PercentSupported() const;
-    bool IsAudioRendererProcessingTimeLimit75PercentSupported() const;
-    bool IsAudioRendererProcessingTimeLimit70PercentSupported() const;
-    bool IsElapsedFrameCountSupported() const;
-    bool IsMemoryPoolForceMappingEnabled() const;
-    bool IsFlushVoiceWaveBuffersSupported() const;
-    bool IsVoicePlayedSampleCountResetAtLoopPointSupported() const;
-    bool IsVoicePitchAndSrcSkippedSupported() const;
-    bool IsMixInParameterDirtyOnlyUpdateSupported() const;
-    bool IsSplitterBugFixed() const;
+    [[nodiscard]] bool IsAdpcmLoopContextBugFixed() const;
+    [[nodiscard]] bool IsSplitterSupported() const;
+    [[nodiscard]] bool IsLongSizePreDelaySupported() const;
+    [[nodiscard]] bool IsAudioRendererProcessingTimeLimit80PercentSupported() const;
+    [[nodiscard]] bool IsAudioRendererProcessingTimeLimit75PercentSupported() const;
+    [[nodiscard]] bool IsAudioRendererProcessingTimeLimit70PercentSupported() const;
+    [[nodiscard]] bool IsElapsedFrameCountSupported() const;
+    [[nodiscard]] bool IsMemoryPoolForceMappingEnabled() const;
+    [[nodiscard]] bool IsFlushVoiceWaveBuffersSupported() const;
+    [[nodiscard]] bool IsVoicePlayedSampleCountResetAtLoopPointSupported() const;
+    [[nodiscard]] bool IsVoicePitchAndSrcSkippedSupported() const;
+    [[nodiscard]] bool IsMixInParameterDirtyOnlyUpdateSupported() const;
+    [[nodiscard]] bool IsSplitterBugFixed() const;
     void CopyErrorInfo(OutParams& dst);
 
 private:

src/audio_core/buffer.h

@@ -18,7 +18,7 @@ class Buffer {
 public:
     using Tag = u64;
 
-    Buffer(Tag tag, std::vector<s16>&& samples) : tag{tag}, samples{std::move(samples)} {}
+    Buffer(Tag tag_, std::vector<s16>&& samples_) : tag{tag_}, samples{std::move(samples_)} {}
 
     /// Returns the raw audio data for the buffer
     std::vector<s16>& GetSamples() {

src/audio_core/command_generator.cpp

@@ -67,12 +67,12 @@ s32 ApplyMixDepop(s32* output, s32 first_sample, s32 delta, s32 sample_count) {
 
 } // namespace
 
-CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_params,
-                                   VoiceContext& voice_context, MixContext& mix_context,
-                                   SplitterContext& splitter_context, EffectContext& effect_context,
-                                   Core::Memory::Memory& memory)
-    : worker_params(worker_params), voice_context(voice_context), mix_context(mix_context),
-      splitter_context(splitter_context), effect_context(effect_context), memory(memory),
+CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_params_,
+                                   VoiceContext& voice_context_, MixContext& mix_context_,
+                                   SplitterContext& splitter_context_,
+                                   EffectContext& effect_context_, Core::Memory::Memory& memory_)
+    : worker_params(worker_params_), voice_context(voice_context_), mix_context(mix_context_),
+      splitter_context(splitter_context_), effect_context(effect_context_), memory(memory_),
       mix_buffer((worker_params.mix_buffer_count + AudioCommon::MAX_CHANNEL_COUNT) *
                  worker_params.sample_count),
       sample_buffer(MIX_BUFFER_SIZE),
@@ -255,7 +255,8 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
 
 void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voice_info,
                                                            VoiceState& dsp_state,
-                                                           s32 mix_buffer_count, s32 channel) {
+                                                           [[maybe_unused]] s32 mix_buffer_count,
+                                                           [[maybe_unused]] s32 channel) {
     for (std::size_t i = 0; i < AudioCommon::MAX_BIQUAD_FILTERS; i++) {
         const auto& in_params = voice_info.GetInParams();
         auto& biquad_filter = in_params.biquad_filter[i];
@@ -278,9 +279,12 @@ void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voic
     }
 }
 
-void AudioCore::CommandGenerator::GenerateBiquadFilterCommand(
-    s32 mix_buffer, const BiquadFilterParameter& params, std::array<s64, 2>& state,
-    std::size_t input_offset, std::size_t output_offset, s32 sample_count, s32 node_id) {
+void CommandGenerator::GenerateBiquadFilterCommand([[maybe_unused]] s32 mix_buffer_id,
+                                                   const BiquadFilterParameter& params,
+                                                   std::array<s64, 2>& state,
+                                                   std::size_t input_offset,
+                                                   std::size_t output_offset, s32 sample_count,
+                                                   s32 node_id) {
     if (dumping_frame) {
         LOG_DEBUG(Audio,
                   "(DSP_TRACE) GenerateBiquadFilterCommand node_id={}, "
@@ -714,7 +718,8 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
 }
 
 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
-                                  s32 sample_count, s32 channel, std::size_t mix_offset) {
+                                  s32 sample_count, [[maybe_unused]] s32 channel,
+                                  std::size_t mix_offset) {
     const auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {

src/audio_core/command_generator.h

@@ -25,10 +25,10 @@ using MixVolumeBuffer = std::array<float, AudioCommon::MAX_MIX_BUFFERS>;
 
 class CommandGenerator {
 public:
-    explicit CommandGenerator(AudioCommon::AudioRendererParameter& worker_params,
-                              VoiceContext& voice_context, MixContext& mix_context,
-                              SplitterContext& splitter_context, EffectContext& effect_context,
-                              Core::Memory::Memory& memory);
+    explicit CommandGenerator(AudioCommon::AudioRendererParameter& worker_params_,
+                              VoiceContext& voice_context_, MixContext& mix_context_,
+                              SplitterContext& splitter_context_, EffectContext& effect_context_,
+                              Core::Memory::Memory& memory_);
     ~CommandGenerator();
 
     void ClearMixBuffers();
@@ -39,13 +39,13 @@ public:
     void PreCommand();
     void PostCommand();
 
-    s32* GetChannelMixBuffer(s32 channel);
-    const s32* GetChannelMixBuffer(s32 channel) const;
-    s32* GetMixBuffer(std::size_t index);
-    const s32* GetMixBuffer(std::size_t index) const;
-    std::size_t GetMixChannelBufferOffset(s32 channel) const;
+    [[nodiscard]] s32* GetChannelMixBuffer(s32 channel);
+    [[nodiscard]] const s32* GetChannelMixBuffer(s32 channel) const;
+    [[nodiscard]] s32* GetMixBuffer(std::size_t index);
+    [[nodiscard]] const s32* GetMixBuffer(std::size_t index) const;
+    [[nodiscard]] std::size_t GetMixChannelBufferOffset(s32 channel) const;
 
-    std::size_t GetTotalMixBufferCount() const;
+    [[nodiscard]] std::size_t GetTotalMixBufferCount() const;
 
 private:
     void GenerateDataSourceCommand(ServerVoiceInfo& voice_info, VoiceState& dsp_state, s32 channel);
@@ -73,7 +73,7 @@ private:
     void GenerateI3dl2ReverbEffectCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
     void GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
     void GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled);
-    ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);
+    [[nodiscard]] ServerSplitterDestinationData* GetDestinationData(s32 splitter_id, s32 index);
 
     s32 WriteAuxBuffer(AuxInfoDSP& dsp_info, VAddr send_buffer, u32 max_samples, const s32* data,
                        u32 sample_count, u32 write_offset, u32 write_count);

src/audio_core/common.h

@@ -22,7 +22,7 @@ constexpr std::size_t MAX_CHANNEL_COUNT = 6;
 constexpr std::size_t MAX_WAVE_BUFFERS = 4;
 constexpr std::size_t MAX_SAMPLE_HISTORY = 4;
 constexpr u32 STREAM_SAMPLE_RATE = 48000;
-constexpr u32 STREAM_NUM_CHANNELS = 6;
+constexpr u32 STREAM_NUM_CHANNELS = 2;
 constexpr s32 NO_SPLITTER = -1;
 constexpr s32 NO_MIX = 0x7fffffff;
 constexpr s32 NO_FINAL_MIX = std::numeric_limits<s32>::min();

src/audio_core/cubeb_sink.cpp

@@ -21,15 +21,16 @@ namespace AudioCore {
 
 class CubebSinkStream final : public SinkStream {
 public:
-    CubebSinkStream(cubeb* ctx, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
+    CubebSinkStream(cubeb* ctx_, u32 sample_rate, u32 num_channels_, cubeb_devid output_device,
                     const std::string& name)
-        : ctx{ctx}, num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate,
-                                                                            num_channels} {
+        : ctx{ctx_}, num_channels{std::min(num_channels_, 6u)}, time_stretch{sample_rate,
+                                                                             num_channels} {
 
         cubeb_stream_params params{};
         params.rate = sample_rate;
         params.channels = num_channels;
         params.format = CUBEB_SAMPLE_S16NE;
+        params.prefs = CUBEB_STREAM_PREF_PERSIST;
         switch (num_channels) {
         case 1:
             params.layout = CUBEB_LAYOUT_MONO;
@@ -192,8 +193,9 @@ SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels,
     return *sink_streams.back();
 }
 
-long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
-                                   void* output_buffer, long num_frames) {
+long CubebSinkStream::DataCallback([[maybe_unused]] cubeb_stream* stream, void* user_data,
+                                   [[maybe_unused]] const void* input_buffer, void* output_buffer,
+                                   long num_frames) {
     auto* impl = static_cast<CubebSinkStream*>(user_data);
     auto* buffer = static_cast<u8*>(output_buffer);
 
@@ -236,7 +238,9 @@ long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const
     return num_frames;
 }
 
-void CubebSinkStream::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
+void CubebSinkStream::StateCallback([[maybe_unused]] cubeb_stream* stream,
+                                    [[maybe_unused]] void* user_data,
+                                    [[maybe_unused]] cubeb_state state) {}
 
 std::vector<std::string> ListCubebSinkDevices() {
     std::vector<std::string> device_list;

src/audio_core/effect_context.cpp

@@ -12,7 +12,7 @@ bool ValidChannelCountForEffect(s32 channel_count) {
 }
 } // namespace
 
-EffectContext::EffectContext(std::size_t effect_count) : effect_count(effect_count) {
+EffectContext::EffectContext(std::size_t effect_count_) : effect_count(effect_count_) {
     effects.reserve(effect_count);
     std::generate_n(std::back_inserter(effects), effect_count,
                     [] { return std::make_unique<EffectStubbed>(); });
@@ -61,13 +61,13 @@ const EffectBase* EffectContext::GetInfo(std::size_t i) const {
     return effects.at(i).get();
 }
 
-EffectStubbed::EffectStubbed() : EffectBase::EffectBase(EffectType::Invalid) {}
+EffectStubbed::EffectStubbed() : EffectBase(EffectType::Invalid) {}
 EffectStubbed::~EffectStubbed() = default;
 
-void EffectStubbed::Update(EffectInfo::InParams& in_params) {}
+void EffectStubbed::Update([[maybe_unused]] EffectInfo::InParams& in_params) {}
 void EffectStubbed::UpdateForCommandGeneration() {}
 
-EffectBase::EffectBase(EffectType effect_type) : effect_type(effect_type) {}
+EffectBase::EffectBase(EffectType effect_type_) : effect_type(effect_type_) {}
 EffectBase::~EffectBase() = default;
 
 UsageState EffectBase::GetUsage() const {
@@ -90,32 +90,32 @@ s32 EffectBase::GetProcessingOrder() const {
     return processing_order;
 }
 
-EffectI3dl2Reverb::EffectI3dl2Reverb() : EffectGeneric::EffectGeneric(EffectType::I3dl2Reverb) {}
+EffectI3dl2Reverb::EffectI3dl2Reverb() : EffectGeneric(EffectType::I3dl2Reverb) {}
 EffectI3dl2Reverb::~EffectI3dl2Reverb() = default;
 
 void EffectI3dl2Reverb::Update(EffectInfo::InParams& in_params) {
-    auto& internal_params = GetParams();
+    auto& params = GetParams();
     const auto* reverb_params = reinterpret_cast<I3dl2ReverbParams*>(in_params.raw.data());
     if (!ValidChannelCountForEffect(reverb_params->max_channels)) {
         UNREACHABLE_MSG("Invalid reverb max channel count {}", reverb_params->max_channels);
         return;
     }
 
-    const auto last_status = internal_params.status;
+    const auto last_status = params.status;
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    internal_params = *reverb_params;
+    params = *reverb_params;
     if (!ValidChannelCountForEffect(reverb_params->channel_count)) {
-        internal_params.channel_count = internal_params.max_channels;
+        params.channel_count = params.max_channels;
     }
     enabled = in_params.is_enabled;
     if (last_status != ParameterStatus::Updated) {
-        internal_params.status = last_status;
+        params.status = last_status;
     }
 
     if (in_params.is_new || skipped) {
         usage = UsageState::Initialized;
-        internal_params.status = ParameterStatus::Initialized;
+        params.status = ParameterStatus::Initialized;
         skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
     }
 }
@@ -129,15 +129,15 @@ void EffectI3dl2Reverb::UpdateForCommandGeneration() {
     GetParams().status = ParameterStatus::Updated;
 }
 
-EffectBiquadFilter::EffectBiquadFilter() : EffectGeneric::EffectGeneric(EffectType::BiquadFilter) {}
+EffectBiquadFilter::EffectBiquadFilter() : EffectGeneric(EffectType::BiquadFilter) {}
 EffectBiquadFilter::~EffectBiquadFilter() = default;
 
 void EffectBiquadFilter::Update(EffectInfo::InParams& in_params) {
-    auto& internal_params = GetParams();
+    auto& params = GetParams();
     const auto* biquad_params = reinterpret_cast<BiquadFilterParams*>(in_params.raw.data());
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    internal_params = *biquad_params;
+    params = *biquad_params;
     enabled = in_params.is_enabled;
 }
 
@@ -150,7 +150,7 @@ void EffectBiquadFilter::UpdateForCommandGeneration() {
     GetParams().status = ParameterStatus::Updated;
 }
 
-EffectAuxInfo::EffectAuxInfo() : EffectGeneric::EffectGeneric(EffectType::Aux) {}
+EffectAuxInfo::EffectAuxInfo() : EffectGeneric(EffectType::Aux) {}
 EffectAuxInfo::~EffectAuxInfo() = default;
 
 void EffectAuxInfo::Update(EffectInfo::InParams& in_params) {
@@ -200,32 +200,32 @@ VAddr EffectAuxInfo::GetRecvBuffer() const {
     return recv_buffer;
 }
 
-EffectDelay::EffectDelay() : EffectGeneric::EffectGeneric(EffectType::Delay) {}
+EffectDelay::EffectDelay() : EffectGeneric(EffectType::Delay) {}
 EffectDelay::~EffectDelay() = default;
 
 void EffectDelay::Update(EffectInfo::InParams& in_params) {
     const auto* delay_params = reinterpret_cast<DelayParams*>(in_params.raw.data());
-    auto& internal_params = GetParams();
+    auto& params = GetParams();
     if (!ValidChannelCountForEffect(delay_params->max_channels)) {
         return;
     }
 
-    const auto last_status = internal_params.status;
+    const auto last_status = params.status;
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    internal_params = *delay_params;
+    params = *delay_params;
     if (!ValidChannelCountForEffect(delay_params->channels)) {
-        internal_params.channels = internal_params.max_channels;
+        params.channels = params.max_channels;
     }
     enabled = in_params.is_enabled;
 
     if (last_status != ParameterStatus::Updated) {
-        internal_params.status = last_status;
+        params.status = last_status;
     }
 
     if (in_params.is_new || skipped) {
         usage = UsageState::Initialized;
-        internal_params.status = ParameterStatus::Initialized;
+        params.status = ParameterStatus::Initialized;
         skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
     }
 }
@@ -239,7 +239,7 @@ void EffectDelay::UpdateForCommandGeneration() {
     GetParams().status = ParameterStatus::Updated;
 }
 
-EffectBufferMixer::EffectBufferMixer() : EffectGeneric::EffectGeneric(EffectType::BufferMixer) {}
+EffectBufferMixer::EffectBufferMixer() : EffectGeneric(EffectType::BufferMixer) {}
 EffectBufferMixer::~EffectBufferMixer() = default;
 
 void EffectBufferMixer::Update(EffectInfo::InParams& in_params) {
@@ -257,32 +257,32 @@ void EffectBufferMixer::UpdateForCommandGeneration() {
     }
 }
 
-EffectReverb::EffectReverb() : EffectGeneric::EffectGeneric(EffectType::Reverb) {}
+EffectReverb::EffectReverb() : EffectGeneric(EffectType::Reverb) {}
 EffectReverb::~EffectReverb() = default;
 
 void EffectReverb::Update(EffectInfo::InParams& in_params) {
     const auto* reverb_params = reinterpret_cast<ReverbParams*>(in_params.raw.data());
-    auto& internal_params = GetParams();
+    auto& params = GetParams();
     if (!ValidChannelCountForEffect(reverb_params->max_channels)) {
         return;
     }
 
-    const auto last_status = internal_params.status;
+    const auto last_status = params.status;
     mix_id = in_params.mix_id;
     processing_order = in_params.processing_order;
-    internal_params = *reverb_params;
+    params = *reverb_params;
     if (!ValidChannelCountForEffect(reverb_params->channels)) {
-        internal_params.channels = internal_params.max_channels;
+        params.channels = params.max_channels;
     }
     enabled = in_params.is_enabled;
 
     if (last_status != ParameterStatus::Updated) {
-        internal_params.status = last_status;
+        params.status = last_status;
     }
 
     if (in_params.is_new || skipped) {
         usage = UsageState::Initialized;
-        internal_params.status = ParameterStatus::Initialized;
+        params.status = ParameterStatus::Initialized;
         skipped = in_params.buffer_address == 0 || in_params.buffer_size == 0;
     }
 }

src/audio_core/effect_context.h

@@ -184,16 +184,16 @@ struct AuxAddress {
 
 class EffectBase {
 public:
-    explicit EffectBase(EffectType effect_type);
+    explicit EffectBase(EffectType effect_type_);
     virtual ~EffectBase();
 
     virtual void Update(EffectInfo::InParams& in_params) = 0;
     virtual void UpdateForCommandGeneration() = 0;
-    UsageState GetUsage() const;
-    EffectType GetType() const;
-    bool IsEnabled() const;
-    s32 GetMixID() const;
-    s32 GetProcessingOrder() const;
+    [[nodiscard]] UsageState GetUsage() const;
+    [[nodiscard]] EffectType GetType() const;
+    [[nodiscard]] bool IsEnabled() const;
+    [[nodiscard]] s32 GetMixID() const;
+    [[nodiscard]] s32 GetProcessingOrder() const;
 
 protected:
     UsageState usage{UsageState::Invalid};
@@ -206,7 +206,7 @@ protected:
 template <typename T>
 class EffectGeneric : public EffectBase {
 public:
-    explicit EffectGeneric(EffectType effect_type) : EffectBase(effect_type) {}
+    explicit EffectGeneric(EffectType effect_type_) : EffectBase(effect_type_) {}
 
     T& GetParams() {
         return internal_params;
@@ -257,10 +257,10 @@ public:
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
-    VAddr GetSendInfo() const;
-    VAddr GetSendBuffer() const;
-    VAddr GetRecvInfo() const;
-    VAddr GetRecvBuffer() const;
+    [[nodiscard]] VAddr GetSendInfo() const;
+    [[nodiscard]] VAddr GetSendBuffer() const;
+    [[nodiscard]] VAddr GetRecvInfo() const;
+    [[nodiscard]] VAddr GetRecvBuffer() const;
 
 private:
     VAddr send_info{};
@@ -306,13 +306,13 @@ private:
 
 class EffectContext {
 public:
-    explicit EffectContext(std::size_t effect_count);
+    explicit EffectContext(std::size_t effect_count_);
     ~EffectContext();
 
-    std::size_t GetCount() const;
-    EffectBase* GetInfo(std::size_t i);
-    EffectBase* RetargetEffect(std::size_t i, EffectType effect);
-    const EffectBase* GetInfo(std::size_t i) const;
+    [[nodiscard]] std::size_t GetCount() const;
+    [[nodiscard]] EffectBase* GetInfo(std::size_t i);
+    [[nodiscard]] EffectBase* RetargetEffect(std::size_t i, EffectType effect);
+    [[nodiscard]] const EffectBase* GetInfo(std::size_t i) const;
 
 private:
     std::size_t effect_count{};

src/audio_core/info_updater.cpp

@@ -14,9 +14,9 @@
 
 namespace AudioCore {
 
-InfoUpdater::InfoUpdater(const std::vector<u8>& in_params, std::vector<u8>& out_params,
-                         BehaviorInfo& behavior_info)
-    : in_params(in_params), out_params(out_params), behavior_info(behavior_info) {
+InfoUpdater::InfoUpdater(const std::vector<u8>& in_params_, std::vector<u8>& out_params_,
+                         BehaviorInfo& behavior_info_)
+    : in_params(in_params_), out_params(out_params_), behavior_info(behavior_info_) {
     ASSERT(
         AudioCommon::CanConsumeBuffer(in_params.size(), 0, sizeof(AudioCommon::UpdateDataHeader)));
     std::memcpy(&input_header, in_params.data(), sizeof(AudioCommon::UpdateDataHeader));
@@ -135,8 +135,8 @@ bool InfoUpdater::UpdateVoiceChannelResources(VoiceContext& voice_context) {
 }
 
 bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
-                               std::vector<ServerMemoryPoolInfo>& memory_pool_info,
-                               VAddr audio_codec_dsp_addr) {
+                               [[maybe_unused]] std::vector<ServerMemoryPoolInfo>& memory_pool_info,
+                               [[maybe_unused]] VAddr audio_codec_dsp_addr) {
     const auto voice_count = voice_context.GetVoiceCount();
     std::vector<VoiceInfo::InParams> voice_in(voice_count);
     std::vector<VoiceInfo::OutParams> voice_out(voice_count);
@@ -165,28 +165,28 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
 
     // Update our voices
     for (std::size_t i = 0; i < voice_count; i++) {
-        auto& in_params = voice_in[i];
-        const auto channel_count = static_cast<std::size_t>(in_params.channel_count);
+        auto& voice_in_params = voice_in[i];
+        const auto channel_count = static_cast<std::size_t>(voice_in_params.channel_count);
         // Skip if it's not currently in use
-        if (!in_params.is_in_use) {
+        if (!voice_in_params.is_in_use) {
             continue;
         }
         // Voice states for each channel
         std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT> voice_states{};
-        ASSERT(static_cast<std::size_t>(in_params.id) < voice_count);
+        ASSERT(static_cast<std::size_t>(voice_in_params.id) < voice_count);
 
         // Grab our current voice info
-        auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(in_params.id));
+        auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(voice_in_params.id));
 
         ASSERT(channel_count <= AudioCommon::MAX_CHANNEL_COUNT);
 
         // Get all our channel voice states
         for (std::size_t channel = 0; channel < channel_count; channel++) {
             voice_states[channel] =
-                &voice_context.GetState(in_params.voice_channel_resource_ids[channel]);
+                &voice_context.GetState(voice_in_params.voice_channel_resource_ids[channel]);
         }
 
-        if (in_params.is_new) {
+        if (voice_in_params.is_new) {
             // Default our values for our voice
             voice_info.Initialize();
             if (channel_count == 0 || channel_count > AudioCommon::MAX_CHANNEL_COUNT) {
@@ -200,12 +200,12 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         }
 
         // Update our voice
-        voice_info.UpdateParameters(in_params, behavior_info);
+        voice_info.UpdateParameters(voice_in_params, behavior_info);
         // TODO(ogniK): Handle mapping errors with behavior info based on in params response
 
         // Update our wave buffers
-        voice_info.UpdateWaveBuffers(in_params, voice_states, behavior_info);
-        voice_info.WriteOutStatus(voice_out[i], in_params, voice_states);
+        voice_info.UpdateWaveBuffers(voice_in_params, voice_states, behavior_info);
+        voice_info.WriteOutStatus(voice_out[i], voice_in_params, voice_states);
     }
 
     if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, voice_out_size)) {
@@ -445,7 +445,7 @@ bool InfoUpdater::UpdatePerformanceBuffer() {
     return true;
 }
 
-bool InfoUpdater::UpdateErrorInfo(BehaviorInfo& in_behavior_info) {
+bool InfoUpdater::UpdateErrorInfo([[maybe_unused]] BehaviorInfo& in_behavior_info) {
     const auto total_beahvior_info_out = sizeof(BehaviorInfo::OutParams);
 
     if (!AudioCommon::CanConsumeBuffer(out_params.size(), output_offset, total_beahvior_info_out)) {

src/audio_core/info_updater.h

@@ -21,8 +21,8 @@ class SplitterContext;
 class InfoUpdater {
 public:
     // TODO(ogniK): Pass process handle when we support it
-    InfoUpdater(const std::vector<u8>& in_params, std::vector<u8>& out_params,
-                BehaviorInfo& behavior_info);
+    InfoUpdater(const std::vector<u8>& in_params_, std::vector<u8>& out_params_,
+                BehaviorInfo& behavior_info_);
     ~InfoUpdater();
 
     bool UpdateBehaviorInfo(BehaviorInfo& in_behavior_info);

src/audio_core/memory_pool.cpp

@@ -10,11 +10,10 @@ namespace AudioCore {
 
 ServerMemoryPoolInfo::ServerMemoryPoolInfo() = default;
 ServerMemoryPoolInfo::~ServerMemoryPoolInfo() = default;
-bool ServerMemoryPoolInfo::Update(const ServerMemoryPoolInfo::InParams& in_params,
-                                  ServerMemoryPoolInfo::OutParams& out_params) {
+
+bool ServerMemoryPoolInfo::Update(const InParams& in_params, OutParams& out_params) {
     // Our state does not need to be changed
-    if (in_params.state != ServerMemoryPoolInfo::State::RequestAttach &&
-        in_params.state != ServerMemoryPoolInfo::State::RequestDetach) {
+    if (in_params.state != State::RequestAttach && in_params.state != State::RequestDetach) {
         return true;
     }
 
@@ -32,11 +31,11 @@ bool ServerMemoryPoolInfo::Update(const ServerMemoryPoolInfo::InParams& in_param
         return false;
     }
 
-    if (in_params.state == ServerMemoryPoolInfo::State::RequestAttach) {
+    if (in_params.state == State::RequestAttach) {
         cpu_address = in_params.address;
         size = in_params.size;
         used = true;
-        out_params.state = ServerMemoryPoolInfo::State::Attached;
+        out_params.state = State::Attached;
     } else {
         // Unexpected address
         if (cpu_address != in_params.address) {
@@ -54,7 +53,7 @@ bool ServerMemoryPoolInfo::Update(const ServerMemoryPoolInfo::InParams& in_param
         cpu_address = 0;
         size = 0;
         used = false;
-        out_params.state = ServerMemoryPoolInfo::State::Detached;
+        out_params.state = State::Detached;
     }
     return true;
 }

src/audio_core/memory_pool.h

@@ -28,19 +28,18 @@ public:
     struct InParams {
         u64_le address{};
         u64_le size{};
-        ServerMemoryPoolInfo::State state{};
+        State state{};
         INSERT_PADDING_WORDS(3);
     };
-    static_assert(sizeof(ServerMemoryPoolInfo::InParams) == 0x20, "InParams are an invalid size");
+    static_assert(sizeof(InParams) == 0x20, "InParams are an invalid size");
 
     struct OutParams {
-        ServerMemoryPoolInfo::State state{};
+        State state{};
         INSERT_PADDING_WORDS(3);
     };
-    static_assert(sizeof(ServerMemoryPoolInfo::OutParams) == 0x10, "OutParams are an invalid size");
+    static_assert(sizeof(OutParams) == 0x10, "OutParams are an invalid size");
 
-    bool Update(const ServerMemoryPoolInfo::InParams& in_params,
-                ServerMemoryPoolInfo::OutParams& out_params);
+    bool Update(const InParams& in_params, OutParams& out_params);
 
 private:
     // There's another entry here which is the DSP address, however since we're not talking to the

src/audio_core/mix_context.h

@@ -62,17 +62,17 @@ public:
     ServerMixInfo();
     ~ServerMixInfo();
 
-    const ServerMixInfo::InParams& GetInParams() const;
-    ServerMixInfo::InParams& GetInParams();
+    [[nodiscard]] const ServerMixInfo::InParams& GetInParams() const;
+    [[nodiscard]] ServerMixInfo::InParams& GetInParams();
 
     bool Update(EdgeMatrix& edge_matrix, const MixInfo::InParams& mix_in,
                 BehaviorInfo& behavior_info, SplitterContext& splitter_context,
                 EffectContext& effect_context);
-    bool HasAnyConnection() const;
+    [[nodiscard]] bool HasAnyConnection() const;
     void Cleanup();
     void SetEffectCount(std::size_t count);
     void ResetEffectProcessingOrder();
-    s32 GetEffectOrder(std::size_t i) const;
+    [[nodiscard]] s32 GetEffectOrder(std::size_t i) const;
 
 private:
     std::vector<s32> effect_processing_order;
@@ -91,15 +91,15 @@ public:
     void SortInfo();
     bool TsortInfo(SplitterContext& splitter_context);
 
-    std::size_t GetCount() const;
-    ServerMixInfo& GetInfo(std::size_t i);
-    const ServerMixInfo& GetInfo(std::size_t i) const;
-    ServerMixInfo& GetSortedInfo(std::size_t i);
-    const ServerMixInfo& GetSortedInfo(std::size_t i) const;
-    ServerMixInfo& GetFinalMixInfo();
-    const ServerMixInfo& GetFinalMixInfo() const;
-    EdgeMatrix& GetEdgeMatrix();
-    const EdgeMatrix& GetEdgeMatrix() const;
+    [[nodiscard]] std::size_t GetCount() const;
+    [[nodiscard]] ServerMixInfo& GetInfo(std::size_t i);
+    [[nodiscard]] const ServerMixInfo& GetInfo(std::size_t i) const;
+    [[nodiscard]] ServerMixInfo& GetSortedInfo(std::size_t i);
+    [[nodiscard]] const ServerMixInfo& GetSortedInfo(std::size_t i) const;
+    [[nodiscard]] ServerMixInfo& GetFinalMixInfo();
+    [[nodiscard]] const ServerMixInfo& GetFinalMixInfo() const;
+    [[nodiscard]] EdgeMatrix& GetEdgeMatrix();
+    [[nodiscard]] const EdgeMatrix& GetEdgeMatrix() const;
 
 private:
     void CalcMixBufferOffset();

src/audio_core/sink_context.cpp

@@ -5,17 +5,23 @@
 #include "audio_core/sink_context.h"
 
 namespace AudioCore {
-SinkContext::SinkContext(std::size_t sink_count) : sink_count(sink_count) {}
+SinkContext::SinkContext(std::size_t sink_count_) : sink_count{sink_count_} {}
 SinkContext::~SinkContext() = default;
 
 std::size_t SinkContext::GetCount() const {
     return sink_count;
 }
 
-void SinkContext::UpdateMainSink(SinkInfo::InParams& in) {
+void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
+    ASSERT(in.type == SinkTypes::Device);
+
+    has_downmix_coefs = in.device.down_matrix_enabled;
+    if (has_downmix_coefs) {
+        downmix_coefficients = in.device.down_matrix_coef;
+    }
     in_use = in.in_use;
     use_count = in.device.input_count;
-    std::memcpy(buffers.data(), in.device.input.data(), AudioCommon::MAX_CHANNEL_COUNT);
+    buffers = in.device.input;
 }
 
 bool SinkContext::InUse() const {
@@ -28,4 +34,12 @@ std::vector<u8> SinkContext::OutputBuffers() const {
     return buffer_ret;
 }
 
+bool SinkContext::HasDownMixingCoefficients() const {
+    return has_downmix_coefs;
+}
+
+const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
+    return downmix_coefficients;
+}
+
 } // namespace AudioCore

src/audio_core/sink_context.h

@@ -11,6 +11,8 @@
 
 namespace AudioCore {
 
+using DownmixCoefficients = std::array<float_le, 4>;
+
 enum class SinkTypes : u8 {
     Invalid = 0,
     Device = 1,
@@ -38,21 +40,21 @@ public:
         SinkSampleFormat sample_format;
         std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> input;
         bool in_use;
-        INSERT_UNION_PADDING_BYTES(5);
+        INSERT_PADDING_BYTES_NOINIT(5);
     };
-    static_assert(sizeof(SinkInfo::CircularBufferIn) == 0x28,
+    static_assert(sizeof(CircularBufferIn) == 0x28,
                   "SinkInfo::CircularBufferIn is in invalid size");
 
     struct DeviceIn {
         std::array<u8, 255> device_name;
-        INSERT_UNION_PADDING_BYTES(1);
+        INSERT_PADDING_BYTES_NOINIT(1);
         s32_le input_count;
         std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> input;
-        INSERT_UNION_PADDING_BYTES(1);
+        INSERT_PADDING_BYTES_NOINIT(1);
         bool down_matrix_enabled;
-        std::array<float_le, 4> down_matrix_coef;
+        DownmixCoefficients down_matrix_coef;
     };
-    static_assert(sizeof(SinkInfo::DeviceIn) == 0x11c, "SinkInfo::DeviceIn is an invalid size");
+    static_assert(sizeof(DeviceIn) == 0x11c, "SinkInfo::DeviceIn is an invalid size");
 
     struct InParams {
         SinkTypes type{};
@@ -62,28 +64,33 @@ public:
         INSERT_PADDING_WORDS(6);
         union {
             // std::array<u8, 0x120> raw{};
-            SinkInfo::DeviceIn device;
-            SinkInfo::CircularBufferIn circular_buffer;
+            DeviceIn device;
+            CircularBufferIn circular_buffer;
         };
     };
-    static_assert(sizeof(SinkInfo::InParams) == 0x140, "SinkInfo::InParams are an invalid size!");
+    static_assert(sizeof(InParams) == 0x140, "SinkInfo::InParams are an invalid size!");
 };
 
 class SinkContext {
 public:
-    explicit SinkContext(std::size_t sink_count);
+    explicit SinkContext(std::size_t sink_count_);
     ~SinkContext();
 
-    std::size_t GetCount() const;
+    [[nodiscard]] std::size_t GetCount() const;
 
-    void UpdateMainSink(SinkInfo::InParams& in);
-    bool InUse() const;
-    std::vector<u8> OutputBuffers() const;
+    void UpdateMainSink(const SinkInfo::InParams& in);
+    [[nodiscard]] bool InUse() const;
+    [[nodiscard]] std::vector<u8> OutputBuffers() const;
+
+    [[nodiscard]] bool HasDownMixingCoefficients() const;
+    [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;
 
 private:
     bool in_use{false};
     s32 use_count{};
     std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
     std::size_t sink_count{};
+    bool has_downmix_coefs{false};
+    DownmixCoefficients downmix_coefficients{};
 };
 } // namespace AudioCore

src/audio_core/splitter_context.cpp

@@ -10,7 +10,7 @@
 
 namespace AudioCore {
 
-ServerSplitterDestinationData::ServerSplitterDestinationData(s32 id) : id(id) {}
+ServerSplitterDestinationData::ServerSplitterDestinationData(s32 id_) : id{id_} {}
 ServerSplitterDestinationData::~ServerSplitterDestinationData() = default;
 
 void ServerSplitterDestinationData::Update(SplitterInfo::InDestinationParams& header) {
@@ -87,7 +87,7 @@ void ServerSplitterDestinationData::UpdateInternalState() {
     needs_update = false;
 }
 
-ServerSplitterInfo::ServerSplitterInfo(s32 id) : id(id) {}
+ServerSplitterInfo::ServerSplitterInfo(s32 id_) : id(id_) {}
 ServerSplitterInfo::~ServerSplitterInfo() = default;
 
 void ServerSplitterInfo::InitializeInfos() {
@@ -121,7 +121,7 @@ const ServerSplitterDestinationData* ServerSplitterInfo::GetHead() const {
 }
 
 ServerSplitterDestinationData* ServerSplitterInfo::GetData(std::size_t depth) {
-    auto current_head = head;
+    auto* current_head = head;
     for (std::size_t i = 0; i < depth; i++) {
         if (current_head == nullptr) {
             return nullptr;
@@ -132,7 +132,7 @@ ServerSplitterDestinationData* ServerSplitterInfo::GetData(std::size_t depth) {
 }
 
 const ServerSplitterDestinationData* ServerSplitterInfo::GetData(std::size_t depth) const {
-    auto current_head = head;
+    auto* current_head = head;
     for (std::size_t i = 0; i < depth; i++) {
         if (current_head == nullptr) {
             return nullptr;
@@ -245,7 +245,7 @@ ServerSplitterDestinationData* SplitterContext::GetDestinationData(std::size_t i
 const ServerSplitterDestinationData* SplitterContext::GetDestinationData(std::size_t info,
                                                                          std::size_t data) const {
     ASSERT(info < info_count);
-    auto& cur_info = GetInfo(info);
+    const auto& cur_info = GetInfo(info);
     return cur_info.GetData(data);
 }
 
@@ -267,11 +267,11 @@ std::size_t SplitterContext::GetDataCount() const {
     return data_count;
 }
 
-void SplitterContext::Setup(std::size_t _info_count, std::size_t _data_count,
+void SplitterContext::Setup(std::size_t info_count_, std::size_t data_count_,
                             bool is_splitter_bug_fixed) {
 
-    info_count = _info_count;
-    data_count = _data_count;
+    info_count = info_count_;
+    data_count = data_count_;
 
     for (std::size_t i = 0; i < info_count; i++) {
         auto& splitter = infos.emplace_back(static_cast<s32>(i));
@@ -364,7 +364,7 @@ bool SplitterContext::RecomposeDestination(ServerSplitterInfo& info,
     // Clear our current destinations
     auto* current_head = info.GetHead();
     while (current_head != nullptr) {
-        auto next_head = current_head->GetNextDestination();
+        auto* next_head = current_head->GetNextDestination();
         current_head->SetNextDestination(nullptr);
         current_head = next_head;
     }
@@ -471,8 +471,8 @@ bool NodeStates::DepthFirstSearch(EdgeMatrix& edge_matrix) {
                 continue;
             }
 
-            const auto node_count = edge_matrix.GetNodeCount();
-            for (s32 j = 0; j < static_cast<s32>(node_count); j++) {
+            const auto edge_node_count = edge_matrix.GetNodeCount();
+            for (s32 j = 0; j < static_cast<s32>(edge_node_count); j++) {
                 // Check if our node is connected to our edge matrix
                 if (!edge_matrix.Connected(current_stack_index, j)) {
                     continue;

src/audio_core/splitter_context.h

@@ -63,7 +63,7 @@ public:
     NodeStates();
     ~NodeStates();
 
-    void Initialize(std::size_t _node_count);
+    void Initialize(std::size_t node_count_);
     bool Tsort(EdgeMatrix& edge_matrix);
     std::size_t GetIndexPos() const;
     const std::vector<s32>& GetIndexList() const;
@@ -72,15 +72,15 @@ private:
     void PushTsortResult(s32 index);
     bool DepthFirstSearch(EdgeMatrix& edge_matrix);
     void ResetState();
-    void UpdateState(NodeStates::State state, std::size_t i);
-    NodeStates::State GetState(std::size_t i);
+    void UpdateState(State state, std::size_t i);
+    State GetState(std::size_t i);
 
     std::size_t node_count{};
     std::vector<bool> was_node_found{};
     std::vector<bool> was_node_completed{};
     std::size_t index_pos{};
     std::vector<s32> index_list{};
-    NodeStates::Stack index_stack{};
+    Stack index_stack{};
 };
 
 enum class SplitterMagic : u32_le {
@@ -97,8 +97,7 @@ public:
         s32_le data_count{};
         INSERT_PADDING_WORDS(5);
     };
-    static_assert(sizeof(SplitterInfo::InHeader) == 0x20,
-                  "SplitterInfo::InHeader is an invalid size");
+    static_assert(sizeof(InHeader) == 0x20, "SplitterInfo::InHeader is an invalid size");
 
     struct InInfoPrams {
         SplitterMagic magic{};
@@ -107,8 +106,7 @@ public:
         s32_le length{};
         s32_le resource_id_base{};
     };
-    static_assert(sizeof(SplitterInfo::InInfoPrams) == 0x14,
-                  "SplitterInfo::InInfoPrams is an invalid size");
+    static_assert(sizeof(InInfoPrams) == 0x14, "SplitterInfo::InInfoPrams is an invalid size");
 
     struct InDestinationParams {
         SplitterMagic magic{};
@@ -118,13 +116,13 @@ public:
         bool in_use{};
         INSERT_PADDING_BYTES(3);
     };
-    static_assert(sizeof(SplitterInfo::InDestinationParams) == 0x70,
+    static_assert(sizeof(InDestinationParams) == 0x70,
                   "SplitterInfo::InDestinationParams is an invalid size");
 };
 
 class ServerSplitterDestinationData {
 public:
-    explicit ServerSplitterDestinationData(s32 id);
+    explicit ServerSplitterDestinationData(s32 id_);
     ~ServerSplitterDestinationData();
 
     void Update(SplitterInfo::InDestinationParams& header);
@@ -153,7 +151,7 @@ private:
 
 class ServerSplitterInfo {
 public:
-    explicit ServerSplitterInfo(s32 id);
+    explicit ServerSplitterInfo(s32 id_);
     ~ServerSplitterInfo();
 
     void InitializeInfos();

src/audio_core/stream.cpp

@@ -31,10 +31,10 @@ u32 Stream::GetNumChannels() const {
     return {};
 }
 
-Stream::Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format format,
-               ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_)
-    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
-      sink_stream{sink_stream}, core_timing{core_timing}, name{std::move(name_)} {
+Stream::Stream(Core::Timing::CoreTiming& core_timing_, u32 sample_rate_, Format format_,
+               ReleaseCallback&& release_callback_, SinkStream& sink_stream_, std::string&& name_)
+    : sample_rate{sample_rate_}, format{format_}, release_callback{std::move(release_callback_)},
+      sink_stream{sink_stream_}, core_timing{core_timing_}, name{std::move(name_)} {
     release_event =
         Core::Timing::CreateEvent(name, [this](std::uintptr_t, std::chrono::nanoseconds ns_late) {
             ReleaseActiveBuffer(ns_late);
@@ -122,7 +122,7 @@ bool Stream::QueueBuffer(BufferPtr&& buffer) {
     return false;
 }
 
-bool Stream::ContainsBuffer(Buffer::Tag tag) const {
+bool Stream::ContainsBuffer([[maybe_unused]] Buffer::Tag tag) const {
     UNIMPLEMENTED();
     return {};
 }
@@ -130,7 +130,25 @@ bool Stream::ContainsBuffer(Buffer::Tag tag) const {
 std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers(std::size_t max_count) {
     std::vector<Buffer::Tag> tags;
     for (std::size_t count = 0; count < max_count && !released_buffers.empty(); ++count) {
-        tags.push_back(released_buffers.front()->GetTag());
+        if (released_buffers.front()) {
+            tags.push_back(released_buffers.front()->GetTag());
+        } else {
+            ASSERT_MSG(false, "Invalid tag in released_buffers!");
+        }
+        released_buffers.pop();
+    }
+    return tags;
+}
+
+std::vector<Buffer::Tag> Stream::GetTagsAndReleaseBuffers() {
+    std::vector<Buffer::Tag> tags;
+    tags.reserve(released_buffers.size());
+    while (!released_buffers.empty()) {
+        if (released_buffers.front()) {
+            tags.push_back(released_buffers.front()->GetTag());
+        } else {
+            ASSERT_MSG(false, "Invalid tag in released_buffers!");
+        }
         released_buffers.pop();
     }
     return tags;

src/audio_core/stream.h

@@ -44,8 +44,8 @@ public:
     /// Callback function type, used to change guest state on a buffer being released
     using ReleaseCallback = std::function<void()>;
 
-    Stream(Core::Timing::CoreTiming& core_timing, u32 sample_rate, Format format,
-           ReleaseCallback&& release_callback, SinkStream& sink_stream, std::string&& name_);
+    Stream(Core::Timing::CoreTiming& core_timing_, u32 sample_rate_, Format format_,
+           ReleaseCallback&& release_callback_, SinkStream& sink_stream_, std::string&& name_);
 
     /// Plays the audio stream
     void Play();
@@ -57,37 +57,40 @@ public:
     bool QueueBuffer(BufferPtr&& buffer);
 
     /// Returns true if the audio stream contains a buffer with the specified tag
-    bool ContainsBuffer(Buffer::Tag tag) const;
+    [[nodiscard]] bool ContainsBuffer(Buffer::Tag tag) const;
 
     /// Returns a vector of recently released buffers specified by tag
-    std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(std::size_t max_count);
+    [[nodiscard]] std::vector<Buffer::Tag> GetTagsAndReleaseBuffers(std::size_t max_count);
+
+    /// Returns a vector of all recently released buffers specified by tag
+    [[nodiscard]] std::vector<Buffer::Tag> GetTagsAndReleaseBuffers();
 
     void SetVolume(float volume);
 
-    float GetVolume() const {
+    [[nodiscard]] float GetVolume() const {
         return game_volume;
     }
 
     /// Returns true if the stream is currently playing
-    bool IsPlaying() const {
+    [[nodiscard]] bool IsPlaying() const {
         return state == State::Playing;
     }
 
     /// Returns the number of queued buffers
-    std::size_t GetQueueSize() const {
+    [[nodiscard]] std::size_t GetQueueSize() const {
         return queued_buffers.size();
     }
 
     /// Gets the sample rate
-    u32 GetSampleRate() const {
+    [[nodiscard]] u32 GetSampleRate() const {
         return sample_rate;
     }
 
     /// Gets the number of channels
-    u32 GetNumChannels() const;
+    [[nodiscard]] u32 GetNumChannels() const;
 
     /// Get the state
-    State GetState() const;
+    [[nodiscard]] State GetState() const;
 
 private:
     /// Plays the next queued buffer in the audio stream, starting playback if necessary
@@ -97,7 +100,7 @@ private:
     void ReleaseActiveBuffer(std::chrono::nanoseconds ns_late = {});
 
     /// Gets the number of core cycles when the specified buffer will be released
-    std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;
+    [[nodiscard]] std::chrono::nanoseconds GetBufferReleaseNS(const Buffer& buffer) const;
 
     u32 sample_rate;                  ///< Sample rate of the stream
     Format format;                    ///< Format of the stream

src/audio_core/voice_context.cpp

@@ -8,7 +8,7 @@
 
 namespace AudioCore {
 
-ServerVoiceChannelResource::ServerVoiceChannelResource(s32 id) : id(id) {}
+ServerVoiceChannelResource::ServerVoiceChannelResource(s32 id_) : id(id_) {}
 ServerVoiceChannelResource::~ServerVoiceChannelResource() = default;
 
 bool ServerVoiceChannelResource::InUse() const {
@@ -209,7 +209,8 @@ void ServerVoiceInfo::UpdateWaveBuffers(
 
 void ServerVoiceInfo::UpdateWaveBuffer(ServerWaveBuffer& out_wavebuffer,
                                        const WaveBuffer& in_wave_buffer, SampleFormat sample_format,
-                                       bool is_buffer_valid, BehaviorInfo& behavior_info) {
+                                       bool is_buffer_valid,
+                                       [[maybe_unused]] BehaviorInfo& behavior_info) {
     if (!is_buffer_valid && out_wavebuffer.sent_to_dsp) {
         out_wavebuffer.buffer_address = 0;
         out_wavebuffer.buffer_size = 0;
@@ -400,7 +401,7 @@ bool ServerVoiceInfo::HasValidWaveBuffer(const VoiceState* state) const {
     return std::find(valid_wb.begin(), valid_wb.end(), true) != valid_wb.end();
 }
 
-VoiceContext::VoiceContext(std::size_t voice_count) : voice_count(voice_count) {
+VoiceContext::VoiceContext(std::size_t voice_count_) : voice_count{voice_count_} {
     for (std::size_t i = 0; i < voice_count; i++) {
         voice_channel_resources.emplace_back(static_cast<s32>(i));
         sorted_voice_info.push_back(&voice_info.emplace_back());

src/audio_core/voice_context.h

@@ -118,12 +118,12 @@ public:
         bool in_use{};
         INSERT_PADDING_BYTES(11);
     };
-    static_assert(sizeof(VoiceChannelResource::InParams) == 0x70, "InParams is an invalid size");
+    static_assert(sizeof(InParams) == 0x70, "InParams is an invalid size");
 };
 
 class ServerVoiceChannelResource {
 public:
-    explicit ServerVoiceChannelResource(s32 id);
+    explicit ServerVoiceChannelResource(s32 id_);
     ~ServerVoiceChannelResource();
 
     bool InUse() const;
@@ -174,7 +174,7 @@ public:
         BehaviorFlags behavior_flags{};
         INSERT_PADDING_BYTES(16);
     };
-    static_assert(sizeof(VoiceInfo::InParams) == 0x170, "InParams is an invalid size");
+    static_assert(sizeof(InParams) == 0x170, "InParams is an invalid size");
 
     struct OutParams {
         u64_le played_sample_count{};
@@ -182,7 +182,7 @@ public:
         u8 voice_dropped{};
         INSERT_PADDING_BYTES(3);
     };
-    static_assert(sizeof(VoiceInfo::OutParams) == 0x10, "OutParams is an invalid size");
+    static_assert(sizeof(OutParams) == 0x10, "OutParams is an invalid size");
 };
 
 class ServerVoiceInfo {
@@ -263,7 +263,7 @@ private:
 
 class VoiceContext {
 public:
-    VoiceContext(std::size_t voice_count);
+    explicit VoiceContext(std::size_t voice_count_);
     ~VoiceContext();
 
     std::size_t GetVoiceCount() const;

src/common/CMakeLists.txt

@@ -102,15 +102,17 @@ add_library(common STATIC
     atomic_ops.h
     detached_tasks.cpp
     detached_tasks.h
+    bit_cast.h
     bit_field.h
+    bit_set.h
     bit_util.h
     cityhash.cpp
     cityhash.h
-    color.h
     common_funcs.h
     common_paths.h
     common_types.h
     concepts.h
+    div_ceil.h
     dynamic_library.cpp
     dynamic_library.h
     fiber.cpp
@@ -120,6 +122,7 @@ add_library(common STATIC
     hash.h
     hex_util.cpp
     hex_util.h
+    intrusive_red_black_tree.h
     logging/backend.cpp
     logging/backend.h
     logging/filter.cpp
@@ -132,17 +135,15 @@ add_library(common STATIC
     math_util.h
     memory_detect.cpp
     memory_detect.h
-    memory_hook.cpp
-    memory_hook.h
     microprofile.cpp
     microprofile.h
     microprofileui.h
     misc.cpp
-    multi_level_queue.h
     page_table.cpp
     page_table.h
     param_package.cpp
     param_package.h
+    parent_of_member.h
     quaternion.h
     ring_buffer.h
     scm_rev.cpp
@@ -160,11 +161,12 @@ add_library(common STATIC
     thread.cpp
     thread.h
     thread_queue_list.h
+    thread_worker.cpp
+    thread_worker.h
     threadsafe_queue.h
     time_zone.cpp
     time_zone.h
-    timer.cpp
-    timer.h
+    tree.h
     uint128.cpp
     uint128.h
     uuid.cpp
@@ -207,7 +209,6 @@ else()
 endif()
 
 create_target_directory_groups(common)
-find_package(Boost 1.71 COMPONENTS context headers REQUIRED)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
 target_link_libraries(common PRIVATE lz4::lz4 xbyak)

src/common/alignment.h

@@ -9,50 +9,45 @@
 namespace Common {
 
 template <typename T>
-[[nodiscard]] constexpr T AlignUp(T value, std::size_t size) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUp(T value, size_t size) {
     auto mod{static_cast<T>(value % size)};
     value -= mod;
     return static_cast<T>(mod == T{0} ? value : value + size);
 }
 
 template <typename T>
-[[nodiscard]] constexpr T AlignDown(T value, std::size_t size) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignUpLog2(T value, size_t align_log2) {
+    return static_cast<T>((value + ((1ULL << align_log2) - 1)) >> align_log2 << align_log2);
+}
+
+template <typename T>
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr T AlignDown(T value, size_t size) {
     return static_cast<T>(value - value % size);
 }
 
 template <typename T>
-[[nodiscard]] constexpr T AlignBits(T value, std::size_t align) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
-    return static_cast<T>((value + ((1ULL << align) - 1)) >> align << align);
-}
-
-template <typename T>
-[[nodiscard]] constexpr bool Is4KBAligned(T value) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool Is4KBAligned(T value) {
     return (value & 0xFFF) == 0;
 }
 
 template <typename T>
-[[nodiscard]] constexpr bool IsWordAligned(T value) {
-    static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
+requires std::is_unsigned_v<T>[[nodiscard]] constexpr bool IsWordAligned(T value) {
     return (value & 0b11) == 0;
 }
 
 template <typename T>
-[[nodiscard]] constexpr bool IsAligned(T value, std::size_t alignment) {
-    using U = typename std::make_unsigned<T>::type;
+requires std::is_integral_v<T>[[nodiscard]] constexpr bool IsAligned(T value, size_t alignment) {
+    using U = typename std::make_unsigned_t<T>;
     const U mask = static_cast<U>(alignment - 1);
     return (value & mask) == 0;
 }
 
-template <typename T, std::size_t Align = 16>
+template <typename T, size_t Align = 16>
 class AlignmentAllocator {
 public:
     using value_type = T;
-    using size_type = std::size_t;
-    using difference_type = std::ptrdiff_t;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
 
     using propagate_on_container_copy_assignment = std::true_type;
     using propagate_on_container_move_assignment = std::true_type;

src/common/bit_cast.h

@@ -0,0 +1,22 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstring>
+#include <type_traits>
+
+namespace Common {
+
+template <typename To, typename From>
+[[nodiscard]] std::enable_if_t<sizeof(To) == sizeof(From) && std::is_trivially_copyable_v<From> &&
+                                   std::is_trivially_copyable_v<To>,
+                               To>
+BitCast(const From& src) noexcept {
+    To dst;
+    std::memcpy(&dst, &src, sizeof(To));
+    return dst;
+}
+
+} // namespace Common

src/common/bit_set.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <array>
+#include <bit>
+
+#include "common/alignment.h"
+#include "common/bit_util.h"
+#include "common/common_types.h"
+
+namespace Common {
+
+namespace impl {
+
+template <typename Storage, size_t N>
+class BitSet {
+
+public:
+    constexpr BitSet() = default;
+
+    constexpr void SetBit(size_t i) {
+        this->words[i / FlagsPerWord] |= GetBitMask(i % FlagsPerWord);
+    }
+
+    constexpr void ClearBit(size_t i) {
+        this->words[i / FlagsPerWord] &= ~GetBitMask(i % FlagsPerWord);
+    }
+
+    constexpr size_t CountLeadingZero() const {
+        for (size_t i = 0; i < NumWords; i++) {
+            if (this->words[i]) {
+                return FlagsPerWord * i + CountLeadingZeroImpl(this->words[i]);
+            }
+        }
+        return FlagsPerWord * NumWords;
+    }
+
+    constexpr size_t GetNextSet(size_t n) const {
+        for (size_t i = (n + 1) / FlagsPerWord; i < NumWords; i++) {
+            Storage word = this->words[i];
+            if (!IsAligned(n + 1, FlagsPerWord)) {
+                word &= GetBitMask(n % FlagsPerWord) - 1;
+            }
+            if (word) {
+                return FlagsPerWord * i + CountLeadingZeroImpl(word);
+            }
+        }
+        return FlagsPerWord * NumWords;
+    }
+
+private:
+    static_assert(std::is_unsigned_v<Storage>);
+    static_assert(sizeof(Storage) <= sizeof(u64));
+
+    static constexpr size_t FlagsPerWord = BitSize<Storage>();
+    static constexpr size_t NumWords = AlignUp(N, FlagsPerWord) / FlagsPerWord;
+
+    static constexpr auto CountLeadingZeroImpl(Storage word) {
+        return std::countl_zero(static_cast<unsigned long long>(word)) -
+               (BitSize<unsigned long long>() - FlagsPerWord);
+    }
+
+    static constexpr Storage GetBitMask(size_t bit) {
+        return Storage(1) << (FlagsPerWord - 1 - bit);
+    }
+
+    std::array<Storage, NumWords> words{};
+};
+
+} // namespace impl
+
+template <size_t N>
+using BitSet8 = impl::BitSet<u8, N>;
+
+template <size_t N>
+using BitSet16 = impl::BitSet<u16, N>;
+
+template <size_t N>
+using BitSet32 = impl::BitSet<u32, N>;
+
+template <size_t N>
+using BitSet64 = impl::BitSet<u64, N>;
+
+} // namespace Common

src/common/bit_util.h

@@ -21,82 +21,6 @@ template <typename T>
     return sizeof(T) * CHAR_BIT;
 }
 
-#ifdef _MSC_VER
-[[nodiscard]] inline u32 CountLeadingZeroes32(u32 value) {
-    unsigned long leading_zero = 0;
-
-    if (_BitScanReverse(&leading_zero, value) != 0) {
-        return 31 - leading_zero;
-    }
-
-    return 32;
-}
-
-[[nodiscard]] inline u32 CountLeadingZeroes64(u64 value) {
-    unsigned long leading_zero = 0;
-
-    if (_BitScanReverse64(&leading_zero, value) != 0) {
-        return 63 - leading_zero;
-    }
-
-    return 64;
-}
-#else
-[[nodiscard]] inline u32 CountLeadingZeroes32(u32 value) {
-    if (value == 0) {
-        return 32;
-    }
-
-    return static_cast<u32>(__builtin_clz(value));
-}
-
-[[nodiscard]] inline u32 CountLeadingZeroes64(u64 value) {
-    if (value == 0) {
-        return 64;
-    }
-
-    return static_cast<u32>(__builtin_clzll(value));
-}
-#endif
-
-#ifdef _MSC_VER
-[[nodiscard]] inline u32 CountTrailingZeroes32(u32 value) {
-    unsigned long trailing_zero = 0;
-
-    if (_BitScanForward(&trailing_zero, value) != 0) {
-        return trailing_zero;
-    }
-
-    return 32;
-}
-
-[[nodiscard]] inline u32 CountTrailingZeroes64(u64 value) {
-    unsigned long trailing_zero = 0;
-
-    if (_BitScanForward64(&trailing_zero, value) != 0) {
-        return trailing_zero;
-    }
-
-    return 64;
-}
-#else
-[[nodiscard]] inline u32 CountTrailingZeroes32(u32 value) {
-    if (value == 0) {
-        return 32;
-    }
-
-    return static_cast<u32>(__builtin_ctz(value));
-}
-
-[[nodiscard]] inline u32 CountTrailingZeroes64(u64 value) {
-    if (value == 0) {
-        return 64;
-    }
-
-    return static_cast<u32>(__builtin_ctzll(value));
-}
-#endif
-
 #ifdef _MSC_VER
 
 [[nodiscard]] inline u32 MostSignificantBit32(const u32 value) {

src/common/color.h

@@ -1,271 +0,0 @@
-// Copyright 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstring>
-
-#include "common/common_types.h"
-#include "common/swap.h"
-#include "common/vector_math.h"
-
-namespace Common::Color {
-
-/// Convert a 1-bit color component to 8 bit
-[[nodiscard]] constexpr u8 Convert1To8(u8 value) {
-    return value * 255;
-}
-
-/// Convert a 4-bit color component to 8 bit
-[[nodiscard]] constexpr u8 Convert4To8(u8 value) {
-    return (value << 4) | value;
-}
-
-/// Convert a 5-bit color component to 8 bit
-[[nodiscard]] constexpr u8 Convert5To8(u8 value) {
-    return (value << 3) | (value >> 2);
-}
-
-/// Convert a 6-bit color component to 8 bit
-[[nodiscard]] constexpr u8 Convert6To8(u8 value) {
-    return (value << 2) | (value >> 4);
-}
-
-/// Convert a 8-bit color component to 1 bit
-[[nodiscard]] constexpr u8 Convert8To1(u8 value) {
-    return value >> 7;
-}
-
-/// Convert a 8-bit color component to 4 bit
-[[nodiscard]] constexpr u8 Convert8To4(u8 value) {
-    return value >> 4;
-}
-
-/// Convert a 8-bit color component to 5 bit
-[[nodiscard]] constexpr u8 Convert8To5(u8 value) {
-    return value >> 3;
-}
-
-/// Convert a 8-bit color component to 6 bit
-[[nodiscard]] constexpr u8 Convert8To6(u8 value) {
-    return value >> 2;
-}
-
-/**
- * Decode a color stored in RGBA8 format
- * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
- */
-[[nodiscard]] inline Common::Vec4<u8> DecodeRGBA8(const u8* bytes) {
-    return {bytes[3], bytes[2], bytes[1], bytes[0]};
-}
-
-/**
- * Decode a color stored in RGB8 format
- * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
- */
-[[nodiscard]] inline Common::Vec4<u8> DecodeRGB8(const u8* bytes) {
-    return {bytes[2], bytes[1], bytes[0], 255};
-}
-
-/**
- * Decode a color stored in RG8 (aka HILO8) format
- * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
- */
-[[nodiscard]] inline Common::Vec4<u8> DecodeRG8(const u8* bytes) {
-    return {bytes[1], bytes[0], 0, 255};
-}
-
-/**
- * Decode a color stored in RGB565 format
- * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
- */
-[[nodiscard]] inline Common::Vec4<u8> DecodeRGB565(const u8* bytes) {
-    u16_le pixel;
-    std::memcpy(&pixel, bytes, sizeof(pixel));
-    return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
-            Convert5To8(pixel & 0x1F), 255};
-}
-
-/**
- * Decode a color stored in RGB5A1 format
- * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
- */
-[[nodiscard]] inline Common::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
-    u16_le pixel;
-    std::memcpy(&pixel, bytes, sizeof(pixel));
-    return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
-            Convert5To8((pixel >> 1) & 0x1F), Convert1To8(pixel & 0x1)};
-}
-
-/**
- * Decode a color stored in RGBA4 format
- * @param bytes Pointer to encoded source color
- * @return Result color decoded as Common::Vec4<u8>
- */
-[[nodiscard]] inline Common::Vec4<u8> DecodeRGBA4(const u8* bytes) {
-    u16_le pixel;
-    std::memcpy(&pixel, bytes, sizeof(pixel));
-    return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
-            Convert4To8((pixel >> 4) & 0xF), Convert4To8(pixel & 0xF)};
-}
-
-/**
- * Decode a depth value stored in D16 format
- * @param bytes Pointer to encoded source value
- * @return Depth value as an u32
- */
-[[nodiscard]] inline u32 DecodeD16(const u8* bytes) {
-    u16_le data;
-    std::memcpy(&data, bytes, sizeof(data));
-    return data;
-}
-
-/**
- * Decode a depth value stored in D24 format
- * @param bytes Pointer to encoded source value
- * @return Depth value as an u32
- */
-[[nodiscard]] inline u32 DecodeD24(const u8* bytes) {
-    return (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
-}
-
-/**
- * Decode a depth value and a stencil value stored in D24S8 format
- * @param bytes Pointer to encoded source values
- * @return Resulting values stored as a Common::Vec2
- */
-[[nodiscard]] inline Common::Vec2<u32> DecodeD24S8(const u8* bytes) {
-    return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
-}
-
-/**
- * Encode a color as RGBA8 format
- * @param color Source color to encode
- * @param bytes Destination pointer to store encoded color
- */
-inline void EncodeRGBA8(const Common::Vec4<u8>& color, u8* bytes) {
-    bytes[3] = color.r();
-    bytes[2] = color.g();
-    bytes[1] = color.b();
-    bytes[0] = color.a();
-}
-
-/**
- * Encode a color as RGB8 format
- * @param color Source color to encode
- * @param bytes Destination pointer to store encoded color
- */
-inline void EncodeRGB8(const Common::Vec4<u8>& color, u8* bytes) {
-    bytes[2] = color.r();
-    bytes[1] = color.g();
-    bytes[0] = color.b();
-}
-
-/**
- * Encode a color as RG8 (aka HILO8) format
- * @param color Source color to encode
- * @param bytes Destination pointer to store encoded color
- */
-inline void EncodeRG8(const Common::Vec4<u8>& color, u8* bytes) {
-    bytes[1] = color.r();
-    bytes[0] = color.g();
-}
-/**
- * Encode a color as RGB565 format
- * @param color Source color to encode
- * @param bytes Destination pointer to store encoded color
- */
-inline void EncodeRGB565(const Common::Vec4<u8>& color, u8* bytes) {
-    const u16_le data =
-        (Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
-
-    std::memcpy(bytes, &data, sizeof(data));
-}
-
-/**
- * Encode a color as RGB5A1 format
- * @param color Source color to encode
- * @param bytes Destination pointer to store encoded color
- */
-inline void EncodeRGB5A1(const Common::Vec4<u8>& color, u8* bytes) {
-    const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
-                        (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
-
-    std::memcpy(bytes, &data, sizeof(data));
-}
-
-/**
- * Encode a color as RGBA4 format
- * @param color Source color to encode
- * @param bytes Destination pointer to store encoded color
- */
-inline void EncodeRGBA4(const Common::Vec4<u8>& color, u8* bytes) {
-    const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
-                     (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
-
-    std::memcpy(bytes, &data, sizeof(data));
-}
-
-/**
- * Encode a 16 bit depth value as D16 format
- * @param value 16 bit source depth value to encode
- * @param bytes Pointer where to store the encoded value
- */
-inline void EncodeD16(u32 value, u8* bytes) {
-    const u16_le data = static_cast<u16>(value);
-    std::memcpy(bytes, &data, sizeof(data));
-}
-
-/**
- * Encode a 24 bit depth value as D24 format
- * @param value 24 bit source depth value to encode
- * @param bytes Pointer where to store the encoded value
- */
-inline void EncodeD24(u32 value, u8* bytes) {
-    bytes[0] = value & 0xFF;
-    bytes[1] = (value >> 8) & 0xFF;
-    bytes[2] = (value >> 16) & 0xFF;
-}
-
-/**
- * Encode a 24 bit depth and 8 bit stencil values as D24S8 format
- * @param depth 24 bit source depth value to encode
- * @param stencil 8 bit source stencil value to encode
- * @param bytes Pointer where to store the encoded value
- */
-inline void EncodeD24S8(u32 depth, u8 stencil, u8* bytes) {
-    bytes[0] = depth & 0xFF;
-    bytes[1] = (depth >> 8) & 0xFF;
-    bytes[2] = (depth >> 16) & 0xFF;
-    bytes[3] = stencil;
-}
-
-/**
- * Encode a 24 bit depth value as D24X8 format (32 bits per pixel with 8 bits unused)
- * @param depth 24 bit source depth value to encode
- * @param bytes Pointer where to store the encoded value
- * @note unused bits will not be modified
- */
-inline void EncodeD24X8(u32 depth, u8* bytes) {
-    bytes[0] = depth & 0xFF;
-    bytes[1] = (depth >> 8) & 0xFF;
-    bytes[2] = (depth >> 16) & 0xFF;
-}
-
-/**
- * Encode an 8 bit stencil value as X24S8 format (32 bits per pixel with 24 bits unused)
- * @param stencil 8 bit source stencil value to encode
- * @param bytes Pointer where to store the encoded value
- * @note unused bits will not be modified
- */
-inline void EncodeX24S8(u8 stencil, u8* bytes) {
-    bytes[3] = stencil;
-}
-
-} // namespace Common::Color

src/common/common_funcs.h

@@ -24,10 +24,10 @@
 #define INSERT_PADDING_WORDS(num_words)                                                            \
     std::array<u32, num_words> CONCAT2(pad, __LINE__) {}
 
-/// These are similar to the INSERT_PADDING_* macros, but are needed for padding unions. This is
-/// because unions can only be initialized by one member.
-#define INSERT_UNION_PADDING_BYTES(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
-#define INSERT_UNION_PADDING_WORDS(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
+/// These are similar to the INSERT_PADDING_* macros but do not zero-initialize the contents.
+/// This keeps the structure trivial to construct.
+#define INSERT_PADDING_BYTES_NOINIT(num_bytes) std::array<u8, num_bytes> CONCAT2(pad, __LINE__)
+#define INSERT_PADDING_WORDS_NOINIT(num_words) std::array<u32, num_words> CONCAT2(pad, __LINE__)
 
 #ifndef _MSC_VER
 
@@ -93,6 +93,14 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         return static_cast<T>(key) == 0;                                                           \
     }
 
+/// Evaluates a boolean expression, and returns a result unless that expression is true.
+#define R_UNLESS(expr, res)                                                                        \
+    {                                                                                              \
+        if (!(expr)) {                                                                             \
+            return res;                                                                            \
+        }                                                                                          \
+    }
+
 namespace Common {
 
 [[nodiscard]] constexpr u32 MakeMagic(char a, char b, char c, char d) {

src/common/concepts.h

@@ -31,4 +31,8 @@ concept DerivedFrom = requires {
     std::is_convertible_v<const volatile Derived*, const volatile Base*>;
 };
 
+// TODO: Replace with std::convertible_to when libc++ implements it.
+template <typename From, typename To>
+concept ConvertibleTo = std::is_convertible_v<From, To>;
+
 } // namespace Common

src/common/div_ceil.h

@@ -0,0 +1,26 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstddef>
+#include <type_traits>
+
+namespace Common {
+
+/// Ceiled integer division.
+template <typename N, typename D>
+requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeil(N number,
+                                                                                        D divisor) {
+    return static_cast<N>((static_cast<D>(number) + divisor - 1) / divisor);
+}
+
+/// Ceiled integer division with logarithmic divisor in base 2
+template <typename N, typename D>
+requires std::is_integral_v<N>&& std::is_unsigned_v<D>[[nodiscard]] constexpr N DivCeilLog2(
+    N value, D alignment_log2) {
+    return static_cast<N>((static_cast<D>(value) + (D(1) << alignment_log2) - 1) >> alignment_log2);
+}
+
+} // namespace Common

src/common/fiber.cpp

@@ -5,18 +5,20 @@
 #include "common/assert.h"
 #include "common/fiber.h"
 #include "common/spin_lock.h"
+#include "common/virtual_buffer.h"
 
-#if defined(_WIN32) || defined(WIN32)
-#include <windows.h>
-#else
 #include <boost/context/detail/fcontext.hpp>
-#endif
 
 namespace Common {
 
-constexpr std::size_t default_stack_size = 256 * 1024; // 256kb
+constexpr std::size_t default_stack_size = 256 * 1024;
 
 struct Fiber::FiberImpl {
+    FiberImpl() : stack{default_stack_size}, rewind_stack{default_stack_size} {}
+
+    VirtualBuffer<u8> stack;
+    VirtualBuffer<u8> rewind_stack;
+
     SpinLock guard{};
     std::function<void(void*)> entry_point;
     std::function<void(void*)> rewind_point;
@@ -26,17 +28,10 @@ struct Fiber::FiberImpl {
     bool is_thread_fiber{};
     bool released{};
 
-#if defined(_WIN32) || defined(WIN32)
-    LPVOID handle = nullptr;
-    LPVOID rewind_handle = nullptr;
-#else
-    alignas(64) std::array<u8, default_stack_size> stack;
-    alignas(64) std::array<u8, default_stack_size> rewind_stack;
-    u8* stack_limit;
-    u8* rewind_stack_limit;
-    boost::context::detail::fcontext_t context;
-    boost::context::detail::fcontext_t rewind_context;
-#endif
+    u8* stack_limit{};
+    u8* rewind_stack_limit{};
+    boost::context::detail::fcontext_t context{};
+    boost::context::detail::fcontext_t rewind_context{};
 };
 
 void Fiber::SetStartParameter(void* new_parameter) {
@@ -48,95 +43,6 @@ void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewin
     impl->rewind_parameter = rewind_param;
 }
 
-#if defined(_WIN32) || defined(WIN32)
-
-void Fiber::Start() {
-    ASSERT(impl->previous_fiber != nullptr);
-    impl->previous_fiber->impl->guard.unlock();
-    impl->previous_fiber.reset();
-    impl->entry_point(impl->start_parameter);
-    UNREACHABLE();
-}
-
-void Fiber::OnRewind() {
-    ASSERT(impl->handle != nullptr);
-    DeleteFiber(impl->handle);
-    impl->handle = impl->rewind_handle;
-    impl->rewind_handle = nullptr;
-    impl->rewind_point(impl->rewind_parameter);
-    UNREACHABLE();
-}
-
-void Fiber::FiberStartFunc(void* fiber_parameter) {
-    auto* fiber = static_cast<Fiber*>(fiber_parameter);
-    fiber->Start();
-}
-
-void Fiber::RewindStartFunc(void* fiber_parameter) {
-    auto* fiber = static_cast<Fiber*>(fiber_parameter);
-    fiber->OnRewind();
-}
-
-Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
-    : impl{std::make_unique<FiberImpl>()} {
-    impl->entry_point = std::move(entry_point_func);
-    impl->start_parameter = start_parameter;
-    impl->handle = CreateFiber(default_stack_size, &FiberStartFunc, this);
-}
-
-Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}
-
-Fiber::~Fiber() {
-    if (impl->released) {
-        return;
-    }
-    // Make sure the Fiber is not being used
-    const bool locked = impl->guard.try_lock();
-    ASSERT_MSG(locked, "Destroying a fiber that's still running");
-    if (locked) {
-        impl->guard.unlock();
-    }
-    DeleteFiber(impl->handle);
-}
-
-void Fiber::Exit() {
-    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
-    if (!impl->is_thread_fiber) {
-        return;
-    }
-    ConvertFiberToThread();
-    impl->guard.unlock();
-    impl->released = true;
-}
-
-void Fiber::Rewind() {
-    ASSERT(impl->rewind_point);
-    ASSERT(impl->rewind_handle == nullptr);
-    impl->rewind_handle = CreateFiber(default_stack_size, &RewindStartFunc, this);
-    SwitchToFiber(impl->rewind_handle);
-}
-
-void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
-    ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
-    ASSERT_MSG(to != nullptr, "Next fiber is null!");
-    to->impl->guard.lock();
-    to->impl->previous_fiber = from;
-    SwitchToFiber(to->impl->handle);
-    ASSERT(from->impl->previous_fiber != nullptr);
-    from->impl->previous_fiber->impl->guard.unlock();
-    from->impl->previous_fiber.reset();
-}
-
-std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
-    std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
-    fiber->impl->guard.lock();
-    fiber->impl->handle = ConvertThreadToFiber(nullptr);
-    fiber->impl->is_thread_fiber = true;
-    return fiber;
-}
-
-#else
-
 void Fiber::Start(boost::context::detail::transfer_t& transfer) {
     ASSERT(impl->previous_fiber != nullptr);
     impl->previous_fiber->impl->context = transfer.fctx;
@@ -229,5 +135,4 @@ std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
     return fiber;
 }
 
-#endif
 } // namespace Common

src/common/fiber.h

@@ -7,11 +7,9 @@
 #include <functional>
 #include <memory>
 
-#if !defined(_WIN32) && !defined(WIN32)
 namespace boost::context::detail {
 struct transfer_t;
 }
-#endif
 
 namespace Common {
 
@@ -59,17 +57,10 @@ public:
 private:
     Fiber();
 
-#if defined(_WIN32) || defined(WIN32)
-    void OnRewind();
-    void Start();
-    static void FiberStartFunc(void* fiber_parameter);
-    static void RewindStartFunc(void* fiber_parameter);
-#else
     void OnRewind(boost::context::detail::transfer_t& transfer);
     void Start(boost::context::detail::transfer_t& transfer);
     static void FiberStartFunc(boost::context::detail::transfer_t transfer);
     static void RewindStartFunc(boost::context::detail::transfer_t transfer);
-#endif
 
     struct FiberImpl;
     std::unique_ptr<FiberImpl> impl;

src/common/intrusive_red_black_tree.h

@@ -0,0 +1,627 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/parent_of_member.h"
+#include "common/tree.h"
+
+namespace Common {
+
+namespace impl {
+
+class IntrusiveRedBlackTreeImpl;
+
+}
+
+struct IntrusiveRedBlackTreeNode {
+
+private:
+    RB_ENTRY(IntrusiveRedBlackTreeNode) entry{};
+
+    friend class impl::IntrusiveRedBlackTreeImpl;
+
+    template <class, class, class>
+    friend class IntrusiveRedBlackTree;
+
+public:
+    constexpr IntrusiveRedBlackTreeNode() = default;
+};
+
+template <class T, class Traits, class Comparator>
+class IntrusiveRedBlackTree;
+
+namespace impl {
+
+class IntrusiveRedBlackTreeImpl {
+
+private:
+    template <class, class, class>
+    friend class ::Common::IntrusiveRedBlackTree;
+
+private:
+    RB_HEAD(IntrusiveRedBlackTreeRoot, IntrusiveRedBlackTreeNode);
+    using RootType = IntrusiveRedBlackTreeRoot;
+
+private:
+    IntrusiveRedBlackTreeRoot root;
+
+public:
+    template <bool Const>
+    class Iterator;
+
+    using value_type = IntrusiveRedBlackTreeNode;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer = value_type*;
+    using const_pointer = const value_type*;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = Iterator<false>;
+    using const_iterator = Iterator<true>;
+
+    template <bool Const>
+    class Iterator {
+    public:
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type = typename IntrusiveRedBlackTreeImpl::value_type;
+        using difference_type = typename IntrusiveRedBlackTreeImpl::difference_type;
+        using pointer = std::conditional_t<Const, IntrusiveRedBlackTreeImpl::const_pointer,
+                                           IntrusiveRedBlackTreeImpl::pointer>;
+        using reference = std::conditional_t<Const, IntrusiveRedBlackTreeImpl::const_reference,
+                                             IntrusiveRedBlackTreeImpl::reference>;
+
+    private:
+        pointer node;
+
+    public:
+        explicit Iterator(pointer n) : node(n) {}
+
+        bool operator==(const Iterator& rhs) const {
+            return this->node == rhs.node;
+        }
+
+        bool operator!=(const Iterator& rhs) const {
+            return !(*this == rhs);
+        }
+
+        pointer operator->() const {
+            return this->node;
+        }
+
+        reference operator*() const {
+            return *this->node;
+        }
+
+        Iterator& operator++() {
+            this->node = GetNext(this->node);
+            return *this;
+        }
+
+        Iterator& operator--() {
+            this->node = GetPrev(this->node);
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            const Iterator it{*this};
+            ++(*this);
+            return it;
+        }
+
+        Iterator operator--(int) {
+            const Iterator it{*this};
+            --(*this);
+            return it;
+        }
+
+        operator Iterator<true>() const {
+            return Iterator<true>(this->node);
+        }
+    };
+
+protected:
+    // Generate static implementations for non-comparison operations for IntrusiveRedBlackTreeRoot.
+    RB_GENERATE_WITHOUT_COMPARE_STATIC(IntrusiveRedBlackTreeRoot, IntrusiveRedBlackTreeNode, entry);
+
+private:
+    // Define accessors using RB_* functions.
+    constexpr void InitializeImpl() {
+        RB_INIT(&this->root);
+    }
+
+    bool EmptyImpl() const {
+        return RB_EMPTY(&this->root);
+    }
+
+    IntrusiveRedBlackTreeNode* GetMinImpl() const {
+        return RB_MIN(IntrusiveRedBlackTreeRoot,
+                      const_cast<IntrusiveRedBlackTreeRoot*>(&this->root));
+    }
+
+    IntrusiveRedBlackTreeNode* GetMaxImpl() const {
+        return RB_MAX(IntrusiveRedBlackTreeRoot,
+                      const_cast<IntrusiveRedBlackTreeRoot*>(&this->root));
+    }
+
+    IntrusiveRedBlackTreeNode* RemoveImpl(IntrusiveRedBlackTreeNode* node) {
+        return RB_REMOVE(IntrusiveRedBlackTreeRoot, &this->root, node);
+    }
+
+public:
+    static IntrusiveRedBlackTreeNode* GetNext(IntrusiveRedBlackTreeNode* node) {
+        return RB_NEXT(IntrusiveRedBlackTreeRoot, nullptr, node);
+    }
+
+    static IntrusiveRedBlackTreeNode* GetPrev(IntrusiveRedBlackTreeNode* node) {
+        return RB_PREV(IntrusiveRedBlackTreeRoot, nullptr, node);
+    }
+
+    static IntrusiveRedBlackTreeNode const* GetNext(const IntrusiveRedBlackTreeNode* node) {
+        return static_cast<const IntrusiveRedBlackTreeNode*>(
+            GetNext(const_cast<IntrusiveRedBlackTreeNode*>(node)));
+    }
+
+    static IntrusiveRedBlackTreeNode const* GetPrev(const IntrusiveRedBlackTreeNode* node) {
+        return static_cast<const IntrusiveRedBlackTreeNode*>(
+            GetPrev(const_cast<IntrusiveRedBlackTreeNode*>(node)));
+    }
+
+public:
+    constexpr IntrusiveRedBlackTreeImpl() : root() {
+        this->InitializeImpl();
+    }
+
+    // Iterator accessors.
+    iterator begin() {
+        return iterator(this->GetMinImpl());
+    }
+
+    const_iterator begin() const {
+        return const_iterator(this->GetMinImpl());
+    }
+
+    iterator end() {
+        return iterator(static_cast<IntrusiveRedBlackTreeNode*>(nullptr));
+    }
+
+    const_iterator end() const {
+        return const_iterator(static_cast<const IntrusiveRedBlackTreeNode*>(nullptr));
+    }
+
+    const_iterator cbegin() const {
+        return this->begin();
+    }
+
+    const_iterator cend() const {
+        return this->end();
+    }
+
+    iterator iterator_to(reference ref) {
+        return iterator(&ref);
+    }
+
+    const_iterator iterator_to(const_reference ref) const {
+        return const_iterator(&ref);
+    }
+
+    // Content management.
+    bool empty() const {
+        return this->EmptyImpl();
+    }
+
+    reference back() {
+        return *this->GetMaxImpl();
+    }
+
+    const_reference back() const {
+        return *this->GetMaxImpl();
+    }
+
+    reference front() {
+        return *this->GetMinImpl();
+    }
+
+    const_reference front() const {
+        return *this->GetMinImpl();
+    }
+
+    iterator erase(iterator it) {
+        auto cur = std::addressof(*it);
+        auto next = GetNext(cur);
+        this->RemoveImpl(cur);
+        return iterator(next);
+    }
+};
+
+} // namespace impl
+
+template <typename T>
+concept HasLightCompareType = requires {
+    { std::is_same<typename T::LightCompareType, void>::value }
+    ->std::convertible_to<bool>;
+};
+
+namespace impl {
+
+template <typename T, typename Default>
+consteval auto* GetLightCompareType() {
+    if constexpr (HasLightCompareType<T>) {
+        return static_cast<typename T::LightCompareType*>(nullptr);
+    } else {
+        return static_cast<Default*>(nullptr);
+    }
+}
+
+} // namespace impl
+
+template <typename T, typename Default>
+using LightCompareType = std::remove_pointer_t<decltype(impl::GetLightCompareType<T, Default>())>;
+
+template <class T, class Traits, class Comparator>
+class IntrusiveRedBlackTree {
+
+public:
+    using ImplType = impl::IntrusiveRedBlackTreeImpl;
+
+private:
+    ImplType impl{};
+
+public:
+    struct IntrusiveRedBlackTreeRootWithCompare : ImplType::IntrusiveRedBlackTreeRoot {};
+
+    template <bool Const>
+    class Iterator;
+
+    using value_type = T;
+    using size_type = size_t;
+    using difference_type = ptrdiff_t;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = Iterator<false>;
+    using const_iterator = Iterator<true>;
+
+    using light_value_type = LightCompareType<Comparator, value_type>;
+    using const_light_pointer = const light_value_type*;
+    using const_light_reference = const light_value_type&;
+
+    template <bool Const>
+    class Iterator {
+    public:
+        friend class IntrusiveRedBlackTree<T, Traits, Comparator>;
+
+        using ImplIterator =
+            std::conditional_t<Const, ImplType::const_iterator, ImplType::iterator>;
+
+        using iterator_category = std::bidirectional_iterator_tag;
+        using value_type = typename IntrusiveRedBlackTree::value_type;
+        using difference_type = typename IntrusiveRedBlackTree::difference_type;
+        using pointer = std::conditional_t<Const, IntrusiveRedBlackTree::const_pointer,
+                                           IntrusiveRedBlackTree::pointer>;
+        using reference = std::conditional_t<Const, IntrusiveRedBlackTree::const_reference,
+                                             IntrusiveRedBlackTree::reference>;
+
+    private:
+        ImplIterator iterator;
+
+    private:
+        explicit Iterator(ImplIterator it) : iterator(it) {}
+
+        explicit Iterator(typename std::conditional<Const, ImplType::const_iterator,
+                                                    ImplType::iterator>::type::pointer ptr)
+            : iterator(ptr) {}
+
+        ImplIterator GetImplIterator() const {
+            return this->iterator;
+        }
+
+    public:
+        bool operator==(const Iterator& rhs) const {
+            return this->iterator == rhs.iterator;
+        }
+
+        bool operator!=(const Iterator& rhs) const {
+            return !(*this == rhs);
+        }
+
+        pointer operator->() const {
+            return Traits::GetParent(std::addressof(*this->iterator));
+        }
+
+        reference operator*() const {
+            return *Traits::GetParent(std::addressof(*this->iterator));
+        }
+
+        Iterator& operator++() {
+            ++this->iterator;
+            return *this;
+        }
+
+        Iterator& operator--() {
+            --this->iterator;
+            return *this;
+        }
+
+        Iterator operator++(int) {
+            const Iterator it{*this};
+            ++this->iterator;
+            return it;
+        }
+
+        Iterator operator--(int) {
+            const Iterator it{*this};
+            --this->iterator;
+            return it;
+        }
+
+        operator Iterator<true>() const {
+            return Iterator<true>(this->iterator);
+        }
+    };
+
+private:
+    // Generate static implementations for comparison operations for IntrusiveRedBlackTreeRoot.
+    RB_GENERATE_WITH_COMPARE_STATIC(IntrusiveRedBlackTreeRootWithCompare, IntrusiveRedBlackTreeNode,
+                                    entry, CompareImpl, LightCompareImpl);
+
+private:
+    static int CompareImpl(const IntrusiveRedBlackTreeNode* lhs,
+                           const IntrusiveRedBlackTreeNode* rhs) {
+        return Comparator::Compare(*Traits::GetParent(lhs), *Traits::GetParent(rhs));
+    }
+
+    static int LightCompareImpl(const void* elm, const IntrusiveRedBlackTreeNode* rhs) {
+        return Comparator::Compare(*static_cast<const_light_pointer>(elm), *Traits::GetParent(rhs));
+    }
+
+    // Define accessors using RB_* functions.
+    IntrusiveRedBlackTreeNode* InsertImpl(IntrusiveRedBlackTreeNode* node) {
+        return RB_INSERT(IntrusiveRedBlackTreeRootWithCompare,
+                         static_cast<IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root),
+                         node);
+    }
+
+    IntrusiveRedBlackTreeNode* FindImpl(const IntrusiveRedBlackTreeNode* node) const {
+        return RB_FIND(
+            IntrusiveRedBlackTreeRootWithCompare,
+            const_cast<IntrusiveRedBlackTreeRootWithCompare*>(
+                static_cast<const IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root)),
+            const_cast<IntrusiveRedBlackTreeNode*>(node));
+    }
+
+    IntrusiveRedBlackTreeNode* NFindImpl(const IntrusiveRedBlackTreeNode* node) const {
+        return RB_NFIND(
+            IntrusiveRedBlackTreeRootWithCompare,
+            const_cast<IntrusiveRedBlackTreeRootWithCompare*>(
+                static_cast<const IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root)),
+            const_cast<IntrusiveRedBlackTreeNode*>(node));
+    }
+
+    IntrusiveRedBlackTreeNode* FindLightImpl(const_light_pointer lelm) const {
+        return RB_FIND_LIGHT(
+            IntrusiveRedBlackTreeRootWithCompare,
+            const_cast<IntrusiveRedBlackTreeRootWithCompare*>(
+                static_cast<const IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root)),
+            static_cast<const void*>(lelm));
+    }
+
+    IntrusiveRedBlackTreeNode* NFindLightImpl(const_light_pointer lelm) const {
+        return RB_NFIND_LIGHT(
+            IntrusiveRedBlackTreeRootWithCompare,
+            const_cast<IntrusiveRedBlackTreeRootWithCompare*>(
+                static_cast<const IntrusiveRedBlackTreeRootWithCompare*>(&this->impl.root)),
+            static_cast<const void*>(lelm));
+    }
+
+public:
+    constexpr IntrusiveRedBlackTree() = default;
+
+    // Iterator accessors.
+    iterator begin() {
+        return iterator(this->impl.begin());
+    }
+
+    const_iterator begin() const {
+        return const_iterator(this->impl.begin());
+    }
+
+    iterator end() {
+        return iterator(this->impl.end());
+    }
+
+    const_iterator end() const {
+        return const_iterator(this->impl.end());
+    }
+
+    const_iterator cbegin() const {
+        return this->begin();
+    }
+
+    const_iterator cend() const {
+        return this->end();
+    }
+
+    iterator iterator_to(reference ref) {
+        return iterator(this->impl.iterator_to(*Traits::GetNode(std::addressof(ref))));
+    }
+
+    const_iterator iterator_to(const_reference ref) const {
+        return const_iterator(this->impl.iterator_to(*Traits::GetNode(std::addressof(ref))));
+    }
+
+    // Content management.
+    bool empty() const {
+        return this->impl.empty();
+    }
+
+    reference back() {
+        return *Traits::GetParent(std::addressof(this->impl.back()));
+    }
+
+    const_reference back() const {
+        return *Traits::GetParent(std::addressof(this->impl.back()));
+    }
+
+    reference front() {
+        return *Traits::GetParent(std::addressof(this->impl.front()));
+    }
+
+    const_reference front() const {
+        return *Traits::GetParent(std::addressof(this->impl.front()));
+    }
+
+    iterator erase(iterator it) {
+        return iterator(this->impl.erase(it.GetImplIterator()));
+    }
+
+    iterator insert(reference ref) {
+        ImplType::pointer node = Traits::GetNode(std::addressof(ref));
+        this->InsertImpl(node);
+        return iterator(node);
+    }
+
+    iterator find(const_reference ref) const {
+        return iterator(this->FindImpl(Traits::GetNode(std::addressof(ref))));
+    }
+
+    iterator nfind(const_reference ref) const {
+        return iterator(this->NFindImpl(Traits::GetNode(std::addressof(ref))));
+    }
+
+    iterator find_light(const_light_reference ref) const {
+        return iterator(this->FindLightImpl(std::addressof(ref)));
+    }
+
+    iterator nfind_light(const_light_reference ref) const {
+        return iterator(this->NFindLightImpl(std::addressof(ref)));
+    }
+};
+
+template <auto T, class Derived = impl::GetParentType<T>>
+class IntrusiveRedBlackTreeMemberTraits;
+
+template <class Parent, IntrusiveRedBlackTreeNode Parent::*Member, class Derived>
+class IntrusiveRedBlackTreeMemberTraits<Member, Derived> {
+public:
+    template <class Comparator>
+    using TreeType = IntrusiveRedBlackTree<Derived, IntrusiveRedBlackTreeMemberTraits, Comparator>;
+    using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
+
+private:
+    template <class, class, class>
+    friend class IntrusiveRedBlackTree;
+
+    friend class impl::IntrusiveRedBlackTreeImpl;
+
+    static constexpr IntrusiveRedBlackTreeNode* GetNode(Derived* parent) {
+        return std::addressof(parent->*Member);
+    }
+
+    static constexpr IntrusiveRedBlackTreeNode const* GetNode(Derived const* parent) {
+        return std::addressof(parent->*Member);
+    }
+
+    static constexpr Derived* GetParent(IntrusiveRedBlackTreeNode* node) {
+        return GetParentPointer<Member, Derived>(node);
+    }
+
+    static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
+        return GetParentPointer<Member, Derived>(node);
+    }
+
+private:
+    static constexpr TypedStorage<Derived> DerivedStorage = {};
+    static_assert(GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage));
+};
+
+template <auto T, class Derived = impl::GetParentType<T>>
+class IntrusiveRedBlackTreeMemberTraitsDeferredAssert;
+
+template <class Parent, IntrusiveRedBlackTreeNode Parent::*Member, class Derived>
+class IntrusiveRedBlackTreeMemberTraitsDeferredAssert<Member, Derived> {
+public:
+    template <class Comparator>
+    using TreeType =
+        IntrusiveRedBlackTree<Derived, IntrusiveRedBlackTreeMemberTraitsDeferredAssert, Comparator>;
+    using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
+
+    static constexpr bool IsValid() {
+        TypedStorage<Derived> DerivedStorage = {};
+        return GetParent(GetNode(GetPointer(DerivedStorage))) == GetPointer(DerivedStorage);
+    }
+
+private:
+    template <class, class, class>
+    friend class IntrusiveRedBlackTree;
+
+    friend class impl::IntrusiveRedBlackTreeImpl;
+
+    static constexpr IntrusiveRedBlackTreeNode* GetNode(Derived* parent) {
+        return std::addressof(parent->*Member);
+    }
+
+    static constexpr IntrusiveRedBlackTreeNode const* GetNode(Derived const* parent) {
+        return std::addressof(parent->*Member);
+    }
+
+    static constexpr Derived* GetParent(IntrusiveRedBlackTreeNode* node) {
+        return GetParentPointer<Member, Derived>(node);
+    }
+
+    static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
+        return GetParentPointer<Member, Derived>(node);
+    }
+};
+
+template <class Derived>
+class IntrusiveRedBlackTreeBaseNode : public IntrusiveRedBlackTreeNode {
+public:
+    constexpr Derived* GetPrev() {
+        return static_cast<Derived*>(impl::IntrusiveRedBlackTreeImpl::GetPrev(this));
+    }
+    constexpr const Derived* GetPrev() const {
+        return static_cast<const Derived*>(impl::IntrusiveRedBlackTreeImpl::GetPrev(this));
+    }
+
+    constexpr Derived* GetNext() {
+        return static_cast<Derived*>(impl::IntrusiveRedBlackTreeImpl::GetNext(this));
+    }
+    constexpr const Derived* GetNext() const {
+        return static_cast<const Derived*>(impl::IntrusiveRedBlackTreeImpl::GetNext(this));
+    }
+};
+
+template <class Derived>
+class IntrusiveRedBlackTreeBaseTraits {
+public:
+    template <class Comparator>
+    using TreeType = IntrusiveRedBlackTree<Derived, IntrusiveRedBlackTreeBaseTraits, Comparator>;
+    using TreeTypeImpl = impl::IntrusiveRedBlackTreeImpl;
+
+private:
+    template <class, class, class>
+    friend class IntrusiveRedBlackTree;
+
+    friend class impl::IntrusiveRedBlackTreeImpl;
+
+    static constexpr IntrusiveRedBlackTreeNode* GetNode(Derived* parent) {
+        return static_cast<IntrusiveRedBlackTreeNode*>(parent);
+    }
+
+    static constexpr IntrusiveRedBlackTreeNode const* GetNode(Derived const* parent) {
+        return static_cast<const IntrusiveRedBlackTreeNode*>(parent);
+    }
+
+    static constexpr Derived* GetParent(IntrusiveRedBlackTreeNode* node) {
+        return static_cast<Derived*>(node);
+    }
+
+    static constexpr Derived const* GetParent(const IntrusiveRedBlackTreeNode* node) {
+        return static_cast<const Derived*>(node);
+    }
+};
+
+} // namespace Common

src/common/logging/backend.cpp

@@ -23,6 +23,7 @@
 #include "common/logging/text_formatter.h"
 #include "common/string_util.h"
 #include "common/threadsafe_queue.h"
+#include "core/settings.h"
 
 namespace Log {
 
@@ -144,18 +145,35 @@ void ColorConsoleBackend::Write(const Entry& entry) {
     PrintColoredMessage(entry);
 }
 
-// _SH_DENYWR allows read only access to the file for other programs.
-// It is #defined to 0 on other platforms
-FileBackend::FileBackend(const std::string& filename)
-    : file(filename, "w", _SH_DENYWR), bytes_written(0) {}
+FileBackend::FileBackend(const std::string& filename) : bytes_written(0) {
+    if (Common::FS::Exists(filename + ".old.txt")) {
+        Common::FS::Delete(filename + ".old.txt");
+    }
+    if (Common::FS::Exists(filename)) {
+        Common::FS::Rename(filename, filename + ".old.txt");
+    }
+
+    // _SH_DENYWR allows read only access to the file for other programs.
+    // It is #defined to 0 on other platforms
+    file = Common::FS::IOFile(filename, "w", _SH_DENYWR);
+}
 
 void FileBackend::Write(const Entry& entry) {
     // prevent logs from going over the maximum size (in case its spamming and the user doesn't
     // know)
-    constexpr std::size_t MAX_BYTES_WRITTEN = 50 * 1024L * 1024L;
-    if (!file.IsOpen() || bytes_written > MAX_BYTES_WRITTEN) {
+    constexpr std::size_t MAX_BYTES_WRITTEN = 100 * 1024 * 1024;
+    constexpr std::size_t MAX_BYTES_WRITTEN_EXTENDED = 1024 * 1024 * 1024;
+
+    if (!file.IsOpen()) {
         return;
     }
+
+    if (Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN_EXTENDED) {
+        return;
+    } else if (!Settings::values.extended_logging && bytes_written > MAX_BYTES_WRITTEN) {
+        return;
+    }
+
     bytes_written += file.WriteString(FormatLogMessage(entry).append(1, '\n'));
     if (entry.log_level >= Level::Error) {
         file.Flush();
@@ -222,6 +240,7 @@ void DebuggerBackend::Write(const Entry& entry) {
     SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \
+    SUB(Service, OLSC)                                                                             \
     SUB(Service, PCIE)                                                                             \
     SUB(Service, PCTL)                                                                             \
     SUB(Service, PCV)                                                                              \

src/common/logging/log.h

@@ -95,6 +95,7 @@ enum class Class : ClassType {
     Service_NPNS,      ///< The NPNS service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service
+    Service_OLSC,      ///< The OLSC service
     Service_PCIE,      ///< The PCIe service
     Service_PCTL,      ///< The PCTL (Parental control) service
     Service_PCV,       ///< The PCV service

src/common/memory_hook.cpp

@@ -1,11 +0,0 @@
-// Copyright 2018 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/memory_hook.h"
-
-namespace Common {
-
-MemoryHook::~MemoryHook() = default;
-
-} // namespace Common

src/common/memory_hook.h

@@ -1,47 +0,0 @@
-// Copyright 2016 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <memory>
-#include <optional>
-
-#include "common/common_types.h"
-
-namespace Common {
-
-/**
- * Memory hooks have two purposes:
- * 1. To allow reads and writes to a region of memory to be intercepted. This is used to implement
- *    texture forwarding and memory breakpoints for debugging.
- * 2. To allow for the implementation of MMIO devices.
- *
- * A hook may be mapped to multiple regions of memory.
- *
- * If a std::nullopt or false is returned from a function, the read/write request is passed through
- * to the underlying memory region.
- */
-class MemoryHook {
-public:
-    virtual ~MemoryHook();
-
-    virtual std::optional<bool> IsValidAddress(VAddr addr) = 0;
-
-    virtual std::optional<u8> Read8(VAddr addr) = 0;
-    virtual std::optional<u16> Read16(VAddr addr) = 0;
-    virtual std::optional<u32> Read32(VAddr addr) = 0;
-    virtual std::optional<u64> Read64(VAddr addr) = 0;
-
-    virtual bool ReadBlock(VAddr src_addr, void* dest_buffer, std::size_t size) = 0;
-
-    virtual bool Write8(VAddr addr, u8 data) = 0;
-    virtual bool Write16(VAddr addr, u16 data) = 0;
-    virtual bool Write32(VAddr addr, u32 data) = 0;
-    virtual bool Write64(VAddr addr, u64 data) = 0;
-
-    virtual bool WriteBlock(VAddr dest_addr, const void* src_buffer, std::size_t size) = 0;
-};
-
-using MemoryHookPointer = std::shared_ptr<MemoryHook>;
-} // namespace Common

src/common/multi_level_queue.h

@@ -1,345 +0,0 @@
-// Copyright 2019 TuxSH
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <iterator>
-#include <list>
-#include <utility>
-
-#include "common/bit_util.h"
-#include "common/common_types.h"
-
-namespace Common {
-
-/**
- * A MultiLevelQueue is a type of priority queue which has the following characteristics:
- * - iteratable through each of its elements.
- * - back can be obtained.
- * - O(1) add, lookup (both front and back)
- * - discrete priorities and a max of 64 priorities (limited domain)
- * This type of priority queue is normaly used for managing threads within an scheduler
- */
-template <typename T, std::size_t Depth>
-class MultiLevelQueue {
-public:
-    using value_type = T;
-    using reference = value_type&;
-    using const_reference = const value_type&;
-    using pointer = value_type*;
-    using const_pointer = const value_type*;
-
-    using difference_type = typename std::pointer_traits<pointer>::difference_type;
-    using size_type = std::size_t;
-
-    template <bool is_constant>
-    class iterator_impl {
-    public:
-        using iterator_category = std::bidirectional_iterator_tag;
-        using value_type = T;
-        using pointer = std::conditional_t<is_constant, T*, const T*>;
-        using reference = std::conditional_t<is_constant, const T&, T&>;
-        using difference_type = typename std::pointer_traits<pointer>::difference_type;
-
-        friend bool operator==(const iterator_impl& lhs, const iterator_impl& rhs) {
-            if (lhs.IsEnd() && rhs.IsEnd())
-                return true;
-            return std::tie(lhs.current_priority, lhs.it) == std::tie(rhs.current_priority, rhs.it);
-        }
-
-        friend bool operator!=(const iterator_impl& lhs, const iterator_impl& rhs) {
-            return !operator==(lhs, rhs);
-        }
-
-        reference operator*() const {
-            return *it;
-        }
-
-        pointer operator->() const {
-            return it.operator->();
-        }
-
-        iterator_impl& operator++() {
-            if (IsEnd()) {
-                return *this;
-            }
-
-            ++it;
-
-            if (it == GetEndItForPrio()) {
-                u64 prios = mlq.used_priorities;
-                prios &= ~((1ULL << (current_priority + 1)) - 1);
-                if (prios == 0) {
-                    current_priority = static_cast<u32>(mlq.depth());
-                } else {
-                    current_priority = CountTrailingZeroes64(prios);
-                    it = GetBeginItForPrio();
-                }
-            }
-            return *this;
-        }
-
-        iterator_impl& operator--() {
-            if (IsEnd()) {
-                if (mlq.used_priorities != 0) {
-                    current_priority = 63 - CountLeadingZeroes64(mlq.used_priorities);
-                    it = GetEndItForPrio();
-                    --it;
-                }
-            } else if (it == GetBeginItForPrio()) {
-                u64 prios = mlq.used_priorities;
-                prios &= (1ULL << current_priority) - 1;
-                if (prios != 0) {
-                    current_priority = CountTrailingZeroes64(prios);
-                    it = GetEndItForPrio();
-                    --it;
-                }
-            } else {
-                --it;
-            }
-            return *this;
-        }
-
-        iterator_impl operator++(int) {
-            const iterator_impl v{*this};
-            ++(*this);
-            return v;
-        }
-
-        iterator_impl operator--(int) {
-            const iterator_impl v{*this};
-            --(*this);
-            return v;
-        }
-
-        // allow implicit const->non-const
-        iterator_impl(const iterator_impl<false>& other)
-            : mlq(other.mlq), it(other.it), current_priority(other.current_priority) {}
-
-        iterator_impl(const iterator_impl<true>& other)
-            : mlq(other.mlq), it(other.it), current_priority(other.current_priority) {}
-
-        iterator_impl& operator=(const iterator_impl<false>& other) {
-            mlq = other.mlq;
-            it = other.it;
-            current_priority = other.current_priority;
-            return *this;
-        }
-
-        friend class iterator_impl<true>;
-        iterator_impl() = default;
-
-    private:
-        friend class MultiLevelQueue;
-        using container_ref =
-            std::conditional_t<is_constant, const MultiLevelQueue&, MultiLevelQueue&>;
-        using list_iterator = std::conditional_t<is_constant, typename std::list<T>::const_iterator,
-                                                 typename std::list<T>::iterator>;
-
-        explicit iterator_impl(container_ref mlq, list_iterator it, u32 current_priority)
-            : mlq(mlq), it(it), current_priority(current_priority) {}
-        explicit iterator_impl(container_ref mlq, u32 current_priority)
-            : mlq(mlq), it(), current_priority(current_priority) {}
-
-        bool IsEnd() const {
-            return current_priority == mlq.depth();
-        }
-
-        list_iterator GetBeginItForPrio() const {
-            return mlq.levels[current_priority].begin();
-        }
-
-        list_iterator GetEndItForPrio() const {
-            return mlq.levels[current_priority].end();
-        }
-
-        container_ref mlq;
-        list_iterator it;
-        u32 current_priority;
-    };
-
-    using iterator = iterator_impl<false>;
-    using const_iterator = iterator_impl<true>;
-
-    void add(const T& element, u32 priority, bool send_back = true) {
-        if (send_back)
-            levels[priority].push_back(element);
-        else
-            levels[priority].push_front(element);
-        used_priorities |= 1ULL << priority;
-    }
-
-    void remove(const T& element, u32 priority) {
-        auto it = ListIterateTo(levels[priority], element);
-        if (it == levels[priority].end())
-            return;
-        levels[priority].erase(it);
-        if (levels[priority].empty()) {
-            used_priorities &= ~(1ULL << priority);
-        }
-    }
-
-    void adjust(const T& element, u32 old_priority, u32 new_priority, bool adjust_front = false) {
-        remove(element, old_priority);
-        add(element, new_priority, !adjust_front);
-    }
-    void adjust(const_iterator it, u32 old_priority, u32 new_priority, bool adjust_front = false) {
-        adjust(*it, old_priority, new_priority, adjust_front);
-    }
-
-    void transfer_to_front(const T& element, u32 priority, MultiLevelQueue& other) {
-        ListSplice(other.levels[priority], other.levels[priority].begin(), levels[priority],
-                   ListIterateTo(levels[priority], element));
-
-        other.used_priorities |= 1ULL << priority;
-
-        if (levels[priority].empty()) {
-            used_priorities &= ~(1ULL << priority);
-        }
-    }
-
-    void transfer_to_front(const_iterator it, u32 priority, MultiLevelQueue& other) {
-        transfer_to_front(*it, priority, other);
-    }
-
-    void transfer_to_back(const T& element, u32 priority, MultiLevelQueue& other) {
-        ListSplice(other.levels[priority], other.levels[priority].end(), levels[priority],
-                   ListIterateTo(levels[priority], element));
-
-        other.used_priorities |= 1ULL << priority;
-
-        if (levels[priority].empty()) {
-            used_priorities &= ~(1ULL << priority);
-        }
-    }
-
-    void transfer_to_back(const_iterator it, u32 priority, MultiLevelQueue& other) {
-        transfer_to_back(*it, priority, other);
-    }
-
-    void yield(u32 priority, std::size_t n = 1) {
-        ListShiftForward(levels[priority], n);
-    }
-
-    [[nodiscard]] std::size_t depth() const {
-        return Depth;
-    }
-
-    [[nodiscard]] std::size_t size(u32 priority) const {
-        return levels[priority].size();
-    }
-
-    [[nodiscard]] std::size_t size() const {
-        u64 priorities = used_priorities;
-        std::size_t size = 0;
-        while (priorities != 0) {
-            const u64 current_priority = CountTrailingZeroes64(priorities);
-            size += levels[current_priority].size();
-            priorities &= ~(1ULL << current_priority);
-        }
-        return size;
-    }
-
-    [[nodiscard]] bool empty() const {
-        return used_priorities == 0;
-    }
-
-    [[nodiscard]] bool empty(u32 priority) const {
-        return (used_priorities & (1ULL << priority)) == 0;
-    }
-
-    [[nodiscard]] u32 highest_priority_set(u32 max_priority = 0) const {
-        const u64 priorities =
-            max_priority == 0 ? used_priorities : (used_priorities & ~((1ULL << max_priority) - 1));
-        return priorities == 0 ? Depth : static_cast<u32>(CountTrailingZeroes64(priorities));
-    }
-
-    [[nodiscard]] u32 lowest_priority_set(u32 min_priority = Depth - 1) const {
-        const u64 priorities = min_priority >= Depth - 1
-                                   ? used_priorities
-                                   : (used_priorities & ((1ULL << (min_priority + 1)) - 1));
-        return priorities == 0 ? Depth : 63 - CountLeadingZeroes64(priorities);
-    }
-
-    [[nodiscard]] const_iterator cbegin(u32 max_prio = 0) const {
-        const u32 priority = highest_priority_set(max_prio);
-        return priority == Depth ? cend()
-                                 : const_iterator{*this, levels[priority].cbegin(), priority};
-    }
-    [[nodiscard]] const_iterator begin(u32 max_prio = 0) const {
-        return cbegin(max_prio);
-    }
-    [[nodiscard]] iterator begin(u32 max_prio = 0) {
-        const u32 priority = highest_priority_set(max_prio);
-        return priority == Depth ? end() : iterator{*this, levels[priority].begin(), priority};
-    }
-
-    [[nodiscard]] const_iterator cend(u32 min_prio = Depth - 1) const {
-        return min_prio == Depth - 1 ? const_iterator{*this, Depth} : cbegin(min_prio + 1);
-    }
-    [[nodiscard]] const_iterator end(u32 min_prio = Depth - 1) const {
-        return cend(min_prio);
-    }
-    [[nodiscard]] iterator end(u32 min_prio = Depth - 1) {
-        return min_prio == Depth - 1 ? iterator{*this, Depth} : begin(min_prio + 1);
-    }
-
-    [[nodiscard]] T& front(u32 max_priority = 0) {
-        const u32 priority = highest_priority_set(max_priority);
-        return levels[priority == Depth ? 0 : priority].front();
-    }
-    [[nodiscard]] const T& front(u32 max_priority = 0) const {
-        const u32 priority = highest_priority_set(max_priority);
-        return levels[priority == Depth ? 0 : priority].front();
-    }
-
-    [[nodiscard]] T& back(u32 min_priority = Depth - 1) {
-        const u32 priority = lowest_priority_set(min_priority); // intended
-        return levels[priority == Depth ? 63 : priority].back();
-    }
-    [[nodiscard]] const T& back(u32 min_priority = Depth - 1) const {
-        const u32 priority = lowest_priority_set(min_priority); // intended
-        return levels[priority == Depth ? 63 : priority].back();
-    }
-
-    void clear() {
-        used_priorities = 0;
-        for (std::size_t i = 0; i < Depth; i++) {
-            levels[i].clear();
-        }
-    }
-
-private:
-    using const_list_iterator = typename std::list<T>::const_iterator;
-
-    static void ListShiftForward(std::list<T>& list, const std::size_t shift = 1) {
-        if (shift >= list.size()) {
-            return;
-        }
-
-        const auto begin_range = list.begin();
-        const auto end_range = std::next(begin_range, shift);
-        list.splice(list.end(), list, begin_range, end_range);
-    }
-
-    static void ListSplice(std::list<T>& in_list, const_list_iterator position,
-                           std::list<T>& out_list, const_list_iterator element) {
-        in_list.splice(position, out_list, element);
-    }
-
-    [[nodiscard]] static const_list_iterator ListIterateTo(const std::list<T>& list,
-                                                           const T& element) {
-        auto it = list.cbegin();
-        while (it != list.cend() && *it != element) {
-            ++it;
-        }
-        return it;
-    }
-
-    std::array<std::list<T>, Depth> levels;
-    u64 used_priorities = 0;
-};
-
-} // namespace Common

src/common/page_table.cpp

@@ -10,16 +10,10 @@ PageTable::PageTable() = default;
 
 PageTable::~PageTable() noexcept = default;
 
-void PageTable::Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                       bool has_attribute) {
-    const std::size_t num_page_table_entries{1ULL
-                                             << (address_space_width_in_bits - page_size_in_bits)};
+void PageTable::Resize(size_t address_space_width_in_bits, size_t page_size_in_bits) {
+    const size_t num_page_table_entries{1ULL << (address_space_width_in_bits - page_size_in_bits)};
     pointers.resize(num_page_table_entries);
     backing_addr.resize(num_page_table_entries);
-
-    if (has_attribute) {
-        attributes.resize(num_page_table_entries);
-    }
 }
 
 } // namespace Common

src/common/page_table.h

@@ -4,10 +4,10 @@
 
 #pragma once
 
+#include <atomic>
 #include <tuple>
 
 #include "common/common_types.h"
-#include "common/memory_hook.h"
 #include "common/virtual_buffer.h"
 
 namespace Common {
@@ -20,27 +20,6 @@ enum class PageType : u8 {
     /// Page is mapped to regular memory, but also needs to check for rasterizer cache flushing and
     /// invalidation
     RasterizerCachedMemory,
-    /// Page is mapped to a I/O region. Writing and reading to this page is handled by functions.
-    Special,
-    /// Page is allocated for use.
-    Allocated,
-};
-
-struct SpecialRegion {
-    enum class Type {
-        DebugHook,
-        IODevice,
-    } type;
-
-    MemoryHookPointer handler;
-
-    [[nodiscard]] bool operator<(const SpecialRegion& other) const {
-        return std::tie(type, handler) < std::tie(other.type, other.handler);
-    }
-
-    [[nodiscard]] bool operator==(const SpecialRegion& other) const {
-        return std::tie(type, handler) == std::tie(other.type, other.handler);
-    }
 };
 
 /**
@@ -48,6 +27,59 @@ struct SpecialRegion {
  * mimics the way a real CPU page table works.
  */
 struct PageTable {
+    /// Number of bits reserved for attribute tagging.
+    /// This can be at most the guaranteed alignment of the pointers in the page table.
+    static constexpr int ATTRIBUTE_BITS = 2;
+
+    /**
+     * Pair of host pointer and page type attribute.
+     * This uses the lower bits of a given pointer to store the attribute tag.
+     * Writing and reading the pointer attribute pair is guaranteed to be atomic for the same method
+     * call. In other words, they are guaranteed to be synchronized at all times.
+     */
+    class PageInfo {
+    public:
+        /// Returns the page pointer
+        [[nodiscard]] u8* Pointer() const noexcept {
+            return ExtractPointer(raw.load(std::memory_order_relaxed));
+        }
+
+        /// Returns the page type attribute
+        [[nodiscard]] PageType Type() const noexcept {
+            return ExtractType(raw.load(std::memory_order_relaxed));
+        }
+
+        /// Returns the page pointer and attribute pair, extracted from the same atomic read
+        [[nodiscard]] std::pair<u8*, PageType> PointerType() const noexcept {
+            const uintptr_t non_atomic_raw = raw.load(std::memory_order_relaxed);
+            return {ExtractPointer(non_atomic_raw), ExtractType(non_atomic_raw)};
+        }
+
+        /// Returns the raw representation of the page information.
+        /// Use ExtractPointer and ExtractType to unpack the value.
+        [[nodiscard]] uintptr_t Raw() const noexcept {
+            return raw.load(std::memory_order_relaxed);
+        }
+
+        /// Write a page pointer and type pair atomically
+        void Store(u8* pointer, PageType type) noexcept {
+            raw.store(reinterpret_cast<uintptr_t>(pointer) | static_cast<uintptr_t>(type));
+        }
+
+        /// Unpack a pointer from a page info raw representation
+        [[nodiscard]] static u8* ExtractPointer(uintptr_t raw) noexcept {
+            return reinterpret_cast<u8*>(raw & (~uintptr_t{0} << ATTRIBUTE_BITS));
+        }
+
+        /// Unpack a page type from a page info raw representation
+        [[nodiscard]] static PageType ExtractType(uintptr_t raw) noexcept {
+            return static_cast<PageType>(raw & ((uintptr_t{1} << ATTRIBUTE_BITS) - 1));
+        }
+
+    private:
+        std::atomic<uintptr_t> raw;
+    };
+
     PageTable();
     ~PageTable() noexcept;
 
@@ -58,25 +90,21 @@ struct PageTable {
     PageTable& operator=(PageTable&&) noexcept = default;
 
     /**
-     * Resizes the page table to be able to accomodate enough pages within
+     * Resizes the page table to be able to accommodate enough pages within
      * a given address space.
      *
      * @param address_space_width_in_bits The address size width in bits.
      * @param page_size_in_bits           The page size in bits.
-     * @param has_attribute               Whether or not this page has any backing attributes.
      */
-    void Resize(std::size_t address_space_width_in_bits, std::size_t page_size_in_bits,
-                bool has_attribute);
+    void Resize(size_t address_space_width_in_bits, size_t page_size_in_bits);
 
     /**
      * Vector of memory pointers backing each page. An entry can only be non-null if the
-     * corresponding entry in the `attributes` vector is of type `Memory`.
+     * corresponding attribute element is of type `Memory`.
      */
-    VirtualBuffer<u8*> pointers;
+    VirtualBuffer<PageInfo> pointers;
 
     VirtualBuffer<u64> backing_addr;
-
-    VirtualBuffer<PageType> attributes;
 };
 
 } // namespace Common

src/common/parent_of_member.h

@@ -0,0 +1,191 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <type_traits>
+
+#include "common/assert.h"
+#include "common/common_types.h"
+
+namespace Common {
+namespace detail {
+template <typename T, size_t Size, size_t Align>
+struct TypedStorageImpl {
+    std::aligned_storage_t<Size, Align> storage_;
+};
+} // namespace detail
+
+template <typename T>
+using TypedStorage = detail::TypedStorageImpl<T, sizeof(T), alignof(T)>;
+
+template <typename T>
+static constexpr T* GetPointer(TypedStorage<T>& ts) {
+    return static_cast<T*>(static_cast<void*>(std::addressof(ts.storage_)));
+}
+
+template <typename T>
+static constexpr const T* GetPointer(const TypedStorage<T>& ts) {
+    return static_cast<const T*>(static_cast<const void*>(std::addressof(ts.storage_)));
+}
+
+namespace impl {
+
+template <size_t MaxDepth>
+struct OffsetOfUnionHolder {
+    template <typename ParentType, typename MemberType, size_t Offset>
+    union UnionImpl {
+        using PaddingMember = char;
+        static constexpr size_t GetOffset() {
+            return Offset;
+        }
+
+#pragma pack(push, 1)
+        struct {
+            PaddingMember padding[Offset];
+            MemberType members[(sizeof(ParentType) / sizeof(MemberType)) + 1];
+        } data;
+#pragma pack(pop)
+        UnionImpl<ParentType, MemberType, Offset + 1> next_union;
+    };
+
+    template <typename ParentType, typename MemberType>
+    union UnionImpl<ParentType, MemberType, 0> {
+        static constexpr size_t GetOffset() {
+            return 0;
+        }
+
+        struct {
+            MemberType members[(sizeof(ParentType) / sizeof(MemberType)) + 1];
+        } data;
+        UnionImpl<ParentType, MemberType, 1> next_union;
+    };
+
+    template <typename ParentType, typename MemberType>
+    union UnionImpl<ParentType, MemberType, MaxDepth> {};
+};
+
+template <typename ParentType, typename MemberType>
+struct OffsetOfCalculator {
+    using UnionHolder =
+        typename OffsetOfUnionHolder<sizeof(MemberType)>::template UnionImpl<ParentType, MemberType,
+                                                                             0>;
+    union Union {
+        char c{};
+        UnionHolder first_union;
+        TypedStorage<ParentType> parent;
+
+        constexpr Union() : c() {}
+    };
+    static constexpr Union U = {};
+
+    static constexpr const MemberType* GetNextAddress(const MemberType* start,
+                                                      const MemberType* target) {
+        while (start < target) {
+            start++;
+        }
+        return start;
+    }
+
+    static constexpr std::ptrdiff_t GetDifference(const MemberType* start,
+                                                  const MemberType* target) {
+        return (target - start) * sizeof(MemberType);
+    }
+
+    template <typename CurUnion>
+    static constexpr std::ptrdiff_t OffsetOfImpl(MemberType ParentType::*member,
+                                                 CurUnion& cur_union) {
+        constexpr size_t Offset = CurUnion::GetOffset();
+        const auto target = std::addressof(GetPointer(U.parent)->*member);
+        const auto start = std::addressof(cur_union.data.members[0]);
+        const auto next = GetNextAddress(start, target);
+
+        if (next != target) {
+            if constexpr (Offset < sizeof(MemberType) - 1) {
+                return OffsetOfImpl(member, cur_union.next_union);
+            } else {
+                UNREACHABLE();
+            }
+        }
+
+        return (next - start) * sizeof(MemberType) + Offset;
+    }
+
+    static constexpr std::ptrdiff_t OffsetOf(MemberType ParentType::*member) {
+        return OffsetOfImpl(member, U.first_union);
+    }
+};
+
+template <typename T>
+struct GetMemberPointerTraits;
+
+template <typename P, typename M>
+struct GetMemberPointerTraits<M P::*> {
+    using Parent = P;
+    using Member = M;
+};
+
+template <auto MemberPtr>
+using GetParentType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Parent;
+
+template <auto MemberPtr>
+using GetMemberType = typename GetMemberPointerTraits<decltype(MemberPtr)>::Member;
+
+template <auto MemberPtr, typename RealParentType = GetParentType<MemberPtr>>
+static inline std::ptrdiff_t OffsetOf = [] {
+    using DeducedParentType = GetParentType<MemberPtr>;
+    using MemberType = GetMemberType<MemberPtr>;
+    static_assert(std::is_base_of<DeducedParentType, RealParentType>::value ||
+                  std::is_same<RealParentType, DeducedParentType>::value);
+
+    return OffsetOfCalculator<RealParentType, MemberType>::OffsetOf(MemberPtr);
+}();
+
+} // namespace impl
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType& GetParentReference(impl::GetMemberType<MemberPtr>* member) {
+    std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>;
+    return *static_cast<RealParentType*>(
+        static_cast<void*>(static_cast<uint8_t*>(static_cast<void*>(member)) - Offset));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType const& GetParentReference(impl::GetMemberType<MemberPtr> const* member) {
+    std::ptrdiff_t Offset = impl::OffsetOf<MemberPtr, RealParentType>;
+    return *static_cast<const RealParentType*>(static_cast<const void*>(
+        static_cast<const uint8_t*>(static_cast<const void*>(member)) - Offset));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType* GetParentPointer(impl::GetMemberType<MemberPtr>* member) {
+    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType const* GetParentPointer(impl::GetMemberType<MemberPtr> const* member) {
+    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType& GetParentReference(impl::GetMemberType<MemberPtr>& member) {
+    return GetParentReference<MemberPtr, RealParentType>(std::addressof(member));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType const& GetParentReference(impl::GetMemberType<MemberPtr> const& member) {
+    return GetParentReference<MemberPtr, RealParentType>(std::addressof(member));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType* GetParentPointer(impl::GetMemberType<MemberPtr>& member) {
+    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
+}
+
+template <auto MemberPtr, typename RealParentType = impl::GetParentType<MemberPtr>>
+constexpr RealParentType const* GetParentPointer(impl::GetMemberType<MemberPtr> const& member) {
+    return std::addressof(GetParentReference<MemberPtr, RealParentType>(member));
+}
+
+} // namespace Common

src/common/scope_exit.h

@@ -10,7 +10,7 @@
 namespace detail {
 template <typename Func>
 struct ScopeExitHelper {
-    explicit ScopeExitHelper(Func&& func) : func(std::move(func)) {}
+    explicit ScopeExitHelper(Func&& func_) : func(std::move(func_)) {}
     ~ScopeExitHelper() {
         if (active) {
             func();

src/common/swap.h

@@ -394,7 +394,7 @@ public:
     template <typename S, typename T2, typename F2>
     friend S operator%(const S& p, const swapped_t v);
 
-    // Arithmetics + assignements
+    // Arithmetics + assignments
     template <typename S, typename T2, typename F2>
     friend S operator+=(const S& p, const swapped_t v);
 
@@ -451,7 +451,7 @@ S operator%(const S& i, const swap_struct_t<T, F> v) {
     return i % v.swap();
 }
 
-// Arithmetics + assignements
+// Arithmetics + assignments
 template <typename S, typename T, typename F>
 S& operator+=(S& i, const swap_struct_t<T, F> v) {
     i += v.swap();

src/common/telemetry.h

@@ -52,8 +52,8 @@ public:
 template <typename T>
 class Field : public FieldInterface {
 public:
-    Field(FieldType type, std::string name, T value)
-        : name(std::move(name)), type(type), value(std::move(value)) {}
+    Field(FieldType type_, std::string name_, T value_)
+        : name(std::move(name_)), type(type_), value(std::move(value_)) {}
 
     Field(const Field&) = default;
     Field& operator=(const Field&) = default;

src/common/thread_worker.cpp

@@ -0,0 +1,58 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/thread.h"
+#include "common/thread_worker.h"
+
+namespace Common {
+
+ThreadWorker::ThreadWorker(std::size_t num_workers, const std::string& name) {
+    for (std::size_t i = 0; i < num_workers; ++i)
+        threads.emplace_back([this, thread_name{std::string{name}}] {
+            Common::SetCurrentThreadName(thread_name.c_str());
+
+            // Wait for first request
+            {
+                std::unique_lock lock{queue_mutex};
+                condition.wait(lock, [this] { return stop || !requests.empty(); });
+            }
+
+            while (true) {
+                std::function<void()> task;
+
+                {
+                    std::unique_lock lock{queue_mutex};
+                    condition.wait(lock, [this] { return stop || !requests.empty(); });
+                    if (stop || requests.empty()) {
+                        return;
+                    }
+                    task = std::move(requests.front());
+                    requests.pop();
+                }
+
+                task();
+            }
+        });
+}
+
+ThreadWorker::~ThreadWorker() {
+    {
+        std::unique_lock lock{queue_mutex};
+        stop = true;
+    }
+    condition.notify_all();
+    for (std::thread& thread : threads) {
+        thread.join();
+    }
+}
+
+void ThreadWorker::QueueWork(std::function<void()>&& work) {
+    {
+        std::unique_lock lock{queue_mutex};
+        requests.emplace(work);
+    }
+    condition.notify_one();
+}
+
+} // namespace Common

src/common/thread_worker.h

@@ -0,0 +1,30 @@
+// Copyright 2020 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <vector>
+#include <queue>
+
+namespace Common {
+
+class ThreadWorker final {
+public:
+    explicit ThreadWorker(std::size_t num_workers, const std::string& name);
+    ~ThreadWorker();
+    void QueueWork(std::function<void()>&& work);
+
+private:
+    std::vector<std::thread> threads;
+    std::queue<std::function<void()>> requests;
+    std::mutex queue_mutex;
+    std::condition_variable condition;
+    std::atomic_bool stop{};
+};
+
+} // namespace Common

src/common/timer.cpp

@@ -1,159 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <ctime>
-#include <fmt/format.h>
-#include "common/common_types.h"
-#include "common/string_util.h"
-#include "common/timer.h"
-
-namespace Common {
-
-std::chrono::milliseconds Timer::GetTimeMs() {
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::system_clock::now().time_since_epoch());
-}
-
-// --------------------------------------------
-// Initiate, Start, Stop, and Update the time
-// --------------------------------------------
-
-// Set initial values for the class
-Timer::Timer() : m_LastTime(0), m_StartTime(0), m_Running(false) {
-    Update();
-}
-
-// Write the starting time
-void Timer::Start() {
-    m_StartTime = GetTimeMs();
-    m_Running = true;
-}
-
-// Stop the timer
-void Timer::Stop() {
-    // Write the final time
-    m_LastTime = GetTimeMs();
-    m_Running = false;
-}
-
-// Update the last time variable
-void Timer::Update() {
-    m_LastTime = GetTimeMs();
-    // TODO(ector) - QPF
-}
-
-// -------------------------------------
-// Get time difference and elapsed time
-// -------------------------------------
-
-// Get the number of milliseconds since the last Update()
-std::chrono::milliseconds Timer::GetTimeDifference() {
-    return GetTimeMs() - m_LastTime;
-}
-
-// Add the time difference since the last Update() to the starting time.
-// This is used to compensate for a paused game.
-void Timer::AddTimeDifference() {
-    m_StartTime += GetTimeDifference();
-}
-
-// Get the time elapsed since the Start()
-std::chrono::milliseconds Timer::GetTimeElapsed() {
-    // If we have not started yet, return 1 (because then I don't
-    // have to change the FPS calculation in CoreRerecording.cpp .
-    if (m_StartTime.count() == 0)
-        return std::chrono::milliseconds(1);
-
-    // Return the final timer time if the timer is stopped
-    if (!m_Running)
-        return (m_LastTime - m_StartTime);
-
-    return (GetTimeMs() - m_StartTime);
-}
-
-// Get the formatted time elapsed since the Start()
-std::string Timer::GetTimeElapsedFormatted() const {
-    // If we have not started yet, return zero
-    if (m_StartTime.count() == 0)
-        return "00:00:00:000";
-
-    // The number of milliseconds since the start.
-    // Use a different value if the timer is stopped.
-    std::chrono::milliseconds Milliseconds;
-    if (m_Running)
-        Milliseconds = GetTimeMs() - m_StartTime;
-    else
-        Milliseconds = m_LastTime - m_StartTime;
-    // Seconds
-    std::chrono::seconds Seconds = std::chrono::duration_cast<std::chrono::seconds>(Milliseconds);
-    // Minutes
-    std::chrono::minutes Minutes = std::chrono::duration_cast<std::chrono::minutes>(Milliseconds);
-    // Hours
-    std::chrono::hours Hours = std::chrono::duration_cast<std::chrono::hours>(Milliseconds);
-
-    std::string TmpStr = fmt::format("{:02}:{:02}:{:02}:{:03}", Hours.count(), Minutes.count() % 60,
-                                     Seconds.count() % 60, Milliseconds.count() % 1000);
-    return TmpStr;
-}
-
-// Get the number of seconds since January 1 1970
-std::chrono::seconds Timer::GetTimeSinceJan1970() {
-    return std::chrono::duration_cast<std::chrono::seconds>(GetTimeMs());
-}
-
-std::chrono::seconds Timer::GetLocalTimeSinceJan1970() {
-    time_t sysTime, tzDiff, tzDST;
-    struct tm* gmTime;
-
-    time(&sysTime);
-
-    // Account for DST where needed
-    gmTime = localtime(&sysTime);
-    if (gmTime->tm_isdst == 1)
-        tzDST = 3600;
-    else
-        tzDST = 0;
-
-    // Lazy way to get local time in sec
-    gmTime = gmtime(&sysTime);
-    tzDiff = sysTime - mktime(gmTime);
-
-    return std::chrono::seconds(sysTime + tzDiff + tzDST);
-}
-
-// Return the current time formatted as Minutes:Seconds:Milliseconds
-// in the form 00:00:000.
-std::string Timer::GetTimeFormatted() {
-    time_t sysTime;
-    struct tm* gmTime;
-    char tmp[13];
-
-    time(&sysTime);
-    gmTime = localtime(&sysTime);
-
-    strftime(tmp, 6, "%M:%S", gmTime);
-
-    u64 milliseconds = static_cast<u64>(GetTimeMs().count()) % 1000;
-    return fmt::format("{}:{:03}", tmp, milliseconds);
-}
-
-// Returns a timestamp with decimals for precise time comparisons
-// ----------------
-double Timer::GetDoubleTime() {
-    // Get continuous timestamp
-    auto tmp_seconds = static_cast<u64>(GetTimeSinceJan1970().count());
-    const auto ms = static_cast<double>(static_cast<u64>(GetTimeMs().count()) % 1000);
-
-    // Remove a few years. We only really want enough seconds to make
-    // sure that we are detecting actual actions, perhaps 60 seconds is
-    // enough really, but I leave a year of seconds anyway, in case the
-    // user's clock is incorrect or something like that.
-    tmp_seconds = tmp_seconds - (38 * 365 * 24 * 60 * 60);
-
-    // Make a smaller integer that fits in the double
-    const auto seconds = static_cast<u32>(tmp_seconds);
-    return seconds + ms;
-}
-
-} // Namespace Common

src/common/timer.h

@@ -1,41 +0,0 @@
-// Copyright 2013 Dolphin Emulator Project / 2014 Citra Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <chrono>
-#include <string>
-#include "common/common_types.h"
-
-namespace Common {
-class Timer {
-public:
-    Timer();
-
-    void Start();
-    void Stop();
-    void Update();
-
-    // The time difference is always returned in milliseconds, regardless of alternative internal
-    // representation
-    [[nodiscard]] std::chrono::milliseconds GetTimeDifference();
-    void AddTimeDifference();
-
-    [[nodiscard]] static std::chrono::seconds GetTimeSinceJan1970();
-    [[nodiscard]] static std::chrono::seconds GetLocalTimeSinceJan1970();
-    [[nodiscard]] static double GetDoubleTime();
-
-    [[nodiscard]] static std::string GetTimeFormatted();
-    [[nodiscard]] std::string GetTimeElapsedFormatted() const;
-    [[nodiscard]] std::chrono::milliseconds GetTimeElapsed();
-
-    [[nodiscard]] static std::chrono::milliseconds GetTimeMs();
-
-private:
-    std::chrono::milliseconds m_LastTime;
-    std::chrono::milliseconds m_StartTime;
-    bool m_Running;
-};
-
-} // Namespace Common

src/common/tree.h

@@ -0,0 +1,822 @@
+/* $NetBSD: tree.h,v 1.8 2004/03/28 19:38:30 provos Exp $ */
+/* $OpenBSD: tree.h,v 1.7 2002/10/17 21:51:54 art Exp $ */
+/* $FreeBSD$ */
+
+/*-
+ * Copyright 2002 Niels Provos <provos@citi.umich.edu>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _SYS_TREE_H_
+#define _SYS_TREE_H_
+
+/* FreeBSD <sys/cdefs.h> has a lot of defines we don't really want. */
+/* tree.h only actually uses __inline and __unused, so we'll just define those. */
+
+/* #include <sys/cdefs.h> */
+
+#ifndef __inline
+#define __inline inline
+#endif
+
+/*
+ * This file defines data structures for different types of trees:
+ * splay trees and red-black trees.
+ *
+ * A splay tree is a self-organizing data structure.  Every operation
+ * on the tree causes a splay to happen.  The splay moves the requested
+ * node to the root of the tree and partly rebalances it.
+ *
+ * This has the benefit that request locality causes faster lookups as
+ * the requested nodes move to the top of the tree.  On the other hand,
+ * every lookup causes memory writes.
+ *
+ * The Balance Theorem bounds the total access time for m operations
+ * and n inserts on an initially empty tree as O((m + n)lg n).  The
+ * amortized cost for a sequence of m accesses to a splay tree is O(lg n);
+ *
+ * A red-black tree is a binary search tree with the node color as an
+ * extra attribute.  It fulfills a set of conditions:
+ * - every search path from the root to a leaf consists of the
+ *   same number of black nodes,
+ * - each red node (except for the root) has a black parent,
+ * - each leaf node is black.
+ *
+ * Every operation on a red-black tree is bounded as O(lg n).
+ * The maximum height of a red-black tree is 2lg (n+1).
+ */
+
+#define SPLAY_HEAD(name, type)                                                                     \
+    struct name {                                                                                  \
+        struct type* sph_root; /* root of the tree */                                              \
+    }
+
+#define SPLAY_INITIALIZER(root)                                                                    \
+    { NULL }
+
+#define SPLAY_INIT(root)                                                                           \
+    do {                                                                                           \
+        (root)->sph_root = NULL;                                                                   \
+    } while (/*CONSTCOND*/ 0)
+
+#define SPLAY_ENTRY(type)                                                                          \
+    struct {                                                                                       \
+        struct type* spe_left;  /* left element */                                                 \
+        struct type* spe_right; /* right element */                                                \
+    }
+
+#define SPLAY_LEFT(elm, field) (elm)->field.spe_left
+#define SPLAY_RIGHT(elm, field) (elm)->field.spe_right
+#define SPLAY_ROOT(head) (head)->sph_root
+#define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL)
+
+/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */
+#define SPLAY_ROTATE_RIGHT(head, tmp, field)                                                       \
+    do {                                                                                           \
+        SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field);                             \
+        SPLAY_RIGHT(tmp, field) = (head)->sph_root;                                                \
+        (head)->sph_root = tmp;                                                                    \
+    } while (/*CONSTCOND*/ 0)
+
+#define SPLAY_ROTATE_LEFT(head, tmp, field)                                                        \
+    do {                                                                                           \
+        SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field);                             \
+        SPLAY_LEFT(tmp, field) = (head)->sph_root;                                                 \
+        (head)->sph_root = tmp;                                                                    \
+    } while (/*CONSTCOND*/ 0)
+
+#define SPLAY_LINKLEFT(head, tmp, field)                                                           \
+    do {                                                                                           \
+        SPLAY_LEFT(tmp, field) = (head)->sph_root;                                                 \
+        tmp = (head)->sph_root;                                                                    \
+        (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);                                    \
+    } while (/*CONSTCOND*/ 0)
+
+#define SPLAY_LINKRIGHT(head, tmp, field)                                                          \
+    do {                                                                                           \
+        SPLAY_RIGHT(tmp, field) = (head)->sph_root;                                                \
+        tmp = (head)->sph_root;                                                                    \
+        (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);                                   \
+    } while (/*CONSTCOND*/ 0)
+
+#define SPLAY_ASSEMBLE(head, node, left, right, field)                                             \
+    do {                                                                                           \
+        SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field);                            \
+        SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);                           \
+        SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field);                            \
+        SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field);                            \
+    } while (/*CONSTCOND*/ 0)
+
+/* Generates prototypes and inline functions */
+
+#define SPLAY_PROTOTYPE(name, type, field, cmp)                                                    \
+    void name##_SPLAY(struct name*, struct type*);                                                 \
+    void name##_SPLAY_MINMAX(struct name*, int);                                                   \
+    struct type* name##_SPLAY_INSERT(struct name*, struct type*);                                  \
+    struct type* name##_SPLAY_REMOVE(struct name*, struct type*);                                  \
+                                                                                                   \
+    /* Finds the node with the same key as elm */                                                  \
+    static __inline struct type* name##_SPLAY_FIND(struct name* head, struct type* elm) {          \
+        if (SPLAY_EMPTY(head))                                                                     \
+            return (NULL);                                                                         \
+        name##_SPLAY(head, elm);                                                                   \
+        if ((cmp)(elm, (head)->sph_root) == 0)                                                     \
+            return (head->sph_root);                                                               \
+        return (NULL);                                                                             \
+    }                                                                                              \
+                                                                                                   \
+    static __inline struct type* name##_SPLAY_NEXT(struct name* head, struct type* elm) {          \
+        name##_SPLAY(head, elm);                                                                   \
+        if (SPLAY_RIGHT(elm, field) != NULL) {                                                     \
+            elm = SPLAY_RIGHT(elm, field);                                                         \
+            while (SPLAY_LEFT(elm, field) != NULL) {                                               \
+                elm = SPLAY_LEFT(elm, field);                                                      \
+            }                                                                                      \
+        } else                                                                                     \
+            elm = NULL;                                                                            \
+        return (elm);                                                                              \
+    }                                                                                              \
+                                                                                                   \
+    static __inline struct type* name##_SPLAY_MIN_MAX(struct name* head, int val) {                \
+        name##_SPLAY_MINMAX(head, val);                                                            \
+        return (SPLAY_ROOT(head));                                                                 \
+    }
+
+/* Main splay operation.
+ * Moves node close to the key of elm to top
+ */
+#define SPLAY_GENERATE(name, type, field, cmp)                                                     \
+    struct type* name##_SPLAY_INSERT(struct name* head, struct type* elm) {                        \
+        if (SPLAY_EMPTY(head)) {                                                                   \
+            SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL;                               \
+        } else {                                                                                   \
+            int __comp;                                                                            \
+            name##_SPLAY(head, elm);                                                               \
+            __comp = (cmp)(elm, (head)->sph_root);                                                 \
+            if (__comp < 0) {                                                                      \
+                SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field);                      \
+                SPLAY_RIGHT(elm, field) = (head)->sph_root;                                        \
+                SPLAY_LEFT((head)->sph_root, field) = NULL;                                        \
+            } else if (__comp > 0) {                                                               \
+                SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field);                    \
+                SPLAY_LEFT(elm, field) = (head)->sph_root;                                         \
+                SPLAY_RIGHT((head)->sph_root, field) = NULL;                                       \
+            } else                                                                                 \
+                return ((head)->sph_root);                                                         \
+        }                                                                                          \
+        (head)->sph_root = (elm);                                                                  \
+        return (NULL);                                                                             \
+    }                                                                                              \
+                                                                                                   \
+    struct type* name##_SPLAY_REMOVE(struct name* head, struct type* elm) {                        \
+        struct type* __tmp;                                                                        \
+        if (SPLAY_EMPTY(head))                                                                     \
+            return (NULL);                                                                         \
+        name##_SPLAY(head, elm);                                                                   \
+        if ((cmp)(elm, (head)->sph_root) == 0) {                                                   \
+            if (SPLAY_LEFT((head)->sph_root, field) == NULL) {                                     \
+                (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);                           \
+            } else {                                                                               \
+                __tmp = SPLAY_RIGHT((head)->sph_root, field);                                      \
+                (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);                            \
+                name##_SPLAY(head, elm);                                                           \
+                SPLAY_RIGHT((head)->sph_root, field) = __tmp;                                      \
+            }                                                                                      \
+            return (elm);                                                                          \
+        }                                                                                          \
+        return (NULL);                                                                             \
+    }                                                                                              \
+                                                                                                   \
+    void name##_SPLAY(struct name* head, struct type* elm) {                                       \
+        struct type __node, *__left, *__right, *__tmp;                                             \
+        int __comp;                                                                                \
+                                                                                                   \
+        SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;                           \
+        __left = __right = &__node;                                                                \
+                                                                                                   \
+        while ((__comp = (cmp)(elm, (head)->sph_root)) != 0) {                                     \
+            if (__comp < 0) {                                                                      \
+                __tmp = SPLAY_LEFT((head)->sph_root, field);                                       \
+                if (__tmp == NULL)                                                                 \
+                    break;                                                                         \
+                if ((cmp)(elm, __tmp) < 0) {                                                       \
+                    SPLAY_ROTATE_RIGHT(head, __tmp, field);                                        \
+                    if (SPLAY_LEFT((head)->sph_root, field) == NULL)                               \
+                        break;                                                                     \
+                }                                                                                  \
+                SPLAY_LINKLEFT(head, __right, field);                                              \
+            } else if (__comp > 0) {                                                               \
+                __tmp = SPLAY_RIGHT((head)->sph_root, field);                                      \
+                if (__tmp == NULL)                                                                 \
+                    break;                                                                         \
+                if ((cmp)(elm, __tmp) > 0) {                                                       \
+                    SPLAY_ROTATE_LEFT(head, __tmp, field);                                         \
+                    if (SPLAY_RIGHT((head)->sph_root, field) == NULL)                              \
+                        break;                                                                     \
+                }                                                                                  \
+                SPLAY_LINKRIGHT(head, __left, field);                                              \
+            }                                                                                      \
+        }                                                                                          \
+        SPLAY_ASSEMBLE(head, &__node, __left, __right, field);                                     \
+    }                                                                                              \
+                                                                                                   \
+    /* Splay with either the minimum or the maximum element                                        \
+     * Used to find minimum or maximum element in tree.                                            \
+     */                                                                                            \
+    void name##_SPLAY_MINMAX(struct name* head, int __comp) {                                      \
+        struct type __node, *__left, *__right, *__tmp;                                             \
+                                                                                                   \
+        SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;                           \
+        __left = __right = &__node;                                                                \
+                                                                                                   \
+        while (1) {                                                                                \
+            if (__comp < 0) {                                                                      \
+                __tmp = SPLAY_LEFT((head)->sph_root, field);                                       \
+                if (__tmp == NULL)                                                                 \
+                    break;                                                                         \
+                if (__comp < 0) {                                                                  \
+                    SPLAY_ROTATE_RIGHT(head, __tmp, field);                                        \
+                    if (SPLAY_LEFT((head)->sph_root, field) == NULL)                               \
+                        break;                                                                     \
+                }                                                                                  \
+                SPLAY_LINKLEFT(head, __right, field);                                              \
+            } else if (__comp > 0) {                                                               \
+                __tmp = SPLAY_RIGHT((head)->sph_root, field);                                      \
+                if (__tmp == NULL)                                                                 \
+                    break;                                                                         \
+                if (__comp > 0) {                                                                  \
+                    SPLAY_ROTATE_LEFT(head, __tmp, field);                                         \
+                    if (SPLAY_RIGHT((head)->sph_root, field) == NULL)                              \
+                        break;                                                                     \
+                }                                                                                  \
+                SPLAY_LINKRIGHT(head, __left, field);                                              \
+            }                                                                                      \
+        }                                                                                          \
+        SPLAY_ASSEMBLE(head, &__node, __left, __right, field);                                     \
+    }
+
+#define SPLAY_NEGINF -1
+#define SPLAY_INF 1
+
+#define SPLAY_INSERT(name, x, y) name##_SPLAY_INSERT(x, y)
+#define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y)
+#define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y)
+#define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y)
+#define SPLAY_MIN(name, x) (SPLAY_EMPTY(x) ? NULL : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
+#define SPLAY_MAX(name, x) (SPLAY_EMPTY(x) ? NULL : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
+
+#define SPLAY_FOREACH(x, name, head)                                                               \
+    for ((x) = SPLAY_MIN(name, head); (x) != NULL; (x) = SPLAY_NEXT(name, head, x))
+
+/* Macros that define a red-black tree */
+#define RB_HEAD(name, type)                                                                        \
+    struct name {                                                                                  \
+        struct type* rbh_root; /* root of the tree */                                              \
+    }
+
+#define RB_INITIALIZER(root)                                                                       \
+    { NULL }
+
+#define RB_INIT(root)                                                                              \
+    do {                                                                                           \
+        (root)->rbh_root = NULL;                                                                   \
+    } while (/*CONSTCOND*/ 0)
+
+#define RB_BLACK 0
+#define RB_RED 1
+#define RB_ENTRY(type)                                                                             \
+    struct {                                                                                       \
+        struct type* rbe_left;   /* left element */                                                \
+        struct type* rbe_right;  /* right element */                                               \
+        struct type* rbe_parent; /* parent element */                                              \
+        int rbe_color;           /* node color */                                                  \
+    }
+
+#define RB_LEFT(elm, field) (elm)->field.rbe_left
+#define RB_RIGHT(elm, field) (elm)->field.rbe_right
+#define RB_PARENT(elm, field) (elm)->field.rbe_parent
+#define RB_COLOR(elm, field) (elm)->field.rbe_color
+#define RB_ROOT(head) (head)->rbh_root
+#define RB_EMPTY(head) (RB_ROOT(head) == NULL)
+
+#define RB_SET(elm, parent, field)                                                                 \
+    do {                                                                                           \
+        RB_PARENT(elm, field) = parent;                                                            \
+        RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL;                                         \
+        RB_COLOR(elm, field) = RB_RED;                                                             \
+    } while (/*CONSTCOND*/ 0)
+
+#define RB_SET_BLACKRED(black, red, field)                                                         \
+    do {                                                                                           \
+        RB_COLOR(black, field) = RB_BLACK;                                                         \
+        RB_COLOR(red, field) = RB_RED;                                                             \
+    } while (/*CONSTCOND*/ 0)
+
+#ifndef RB_AUGMENT
+#define RB_AUGMENT(x)                                                                              \
+    do {                                                                                           \
+    } while (0)
+#endif
+
+#define RB_ROTATE_LEFT(head, elm, tmp, field)                                                      \
+    do {                                                                                           \
+        (tmp) = RB_RIGHT(elm, field);                                                              \
+        if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) {                                \
+            RB_PARENT(RB_LEFT(tmp, field), field) = (elm);                                         \
+        }                                                                                          \
+        RB_AUGMENT(elm);                                                                           \
+        if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {                             \
+            if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))                                    \
+                RB_LEFT(RB_PARENT(elm, field), field) = (tmp);                                     \
+            else                                                                                   \
+                RB_RIGHT(RB_PARENT(elm, field), field) = (tmp);                                    \
+        } else                                                                                     \
+            (head)->rbh_root = (tmp);                                                              \
+        RB_LEFT(tmp, field) = (elm);                                                               \
+        RB_PARENT(elm, field) = (tmp);                                                             \
+        RB_AUGMENT(tmp);                                                                           \
+        if ((RB_PARENT(tmp, field)))                                                               \
+            RB_AUGMENT(RB_PARENT(tmp, field));                                                     \
+    } while (/*CONSTCOND*/ 0)
+
+#define RB_ROTATE_RIGHT(head, elm, tmp, field)                                                     \
+    do {                                                                                           \
+        (tmp) = RB_LEFT(elm, field);                                                               \
+        if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) {                                \
+            RB_PARENT(RB_RIGHT(tmp, field), field) = (elm);                                        \
+        }                                                                                          \
+        RB_AUGMENT(elm);                                                                           \
+        if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) {                             \
+            if ((elm) == RB_LEFT(RB_PARENT(elm, field), field))                                    \
+                RB_LEFT(RB_PARENT(elm, field), field) = (tmp);                                     \
+            else                                                                                   \
+                RB_RIGHT(RB_PARENT(elm, field), field) = (tmp);                                    \
+        } else                                                                                     \
+            (head)->rbh_root = (tmp);                                                              \
+        RB_RIGHT(tmp, field) = (elm);                                                              \
+        RB_PARENT(elm, field) = (tmp);                                                             \
+        RB_AUGMENT(tmp);                                                                           \
+        if ((RB_PARENT(tmp, field)))                                                               \
+            RB_AUGMENT(RB_PARENT(tmp, field));                                                     \
+    } while (/*CONSTCOND*/ 0)
+
+/* Generates prototypes and inline functions */
+#define RB_PROTOTYPE(name, type, field, cmp) RB_PROTOTYPE_INTERNAL(name, type, field, cmp, )
+#define RB_PROTOTYPE_STATIC(name, type, field, cmp)                                                \
+    RB_PROTOTYPE_INTERNAL(name, type, field, cmp, static)
+#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr)                                        \
+    RB_PROTOTYPE_INSERT_COLOR(name, type, attr);                                                   \
+    RB_PROTOTYPE_REMOVE_COLOR(name, type, attr);                                                   \
+    RB_PROTOTYPE_INSERT(name, type, attr);                                                         \
+    RB_PROTOTYPE_REMOVE(name, type, attr);                                                         \
+    RB_PROTOTYPE_FIND(name, type, attr);                                                           \
+    RB_PROTOTYPE_NFIND(name, type, attr);                                                          \
+    RB_PROTOTYPE_FIND_LIGHT(name, type, attr);                                                     \
+    RB_PROTOTYPE_NFIND_LIGHT(name, type, attr);                                                    \
+    RB_PROTOTYPE_NEXT(name, type, attr);                                                           \
+    RB_PROTOTYPE_PREV(name, type, attr);                                                           \
+    RB_PROTOTYPE_MINMAX(name, type, attr);
+#define RB_PROTOTYPE_INSERT_COLOR(name, type, attr)                                                \
+    attr void name##_RB_INSERT_COLOR(struct name*, struct type*)
+#define RB_PROTOTYPE_REMOVE_COLOR(name, type, attr)                                                \
+    attr void name##_RB_REMOVE_COLOR(struct name*, struct type*, struct type*)
+#define RB_PROTOTYPE_REMOVE(name, type, attr)                                                      \
+    attr struct type* name##_RB_REMOVE(struct name*, struct type*)
+#define RB_PROTOTYPE_INSERT(name, type, attr)                                                      \
+    attr struct type* name##_RB_INSERT(struct name*, struct type*)
+#define RB_PROTOTYPE_FIND(name, type, attr)                                                        \
+    attr struct type* name##_RB_FIND(struct name*, struct type*)
+#define RB_PROTOTYPE_NFIND(name, type, attr)                                                       \
+    attr struct type* name##_RB_NFIND(struct name*, struct type*)
+#define RB_PROTOTYPE_FIND_LIGHT(name, type, attr)                                                  \
+    attr struct type* name##_RB_FIND_LIGHT(struct name*, const void*)
+#define RB_PROTOTYPE_NFIND_LIGHT(name, type, attr)                                                 \
+    attr struct type* name##_RB_NFIND_LIGHT(struct name*, const void*)
+#define RB_PROTOTYPE_NEXT(name, type, attr) attr struct type* name##_RB_NEXT(struct type*)
+#define RB_PROTOTYPE_PREV(name, type, attr) attr struct type* name##_RB_PREV(struct type*)
+#define RB_PROTOTYPE_MINMAX(name, type, attr) attr struct type* name##_RB_MINMAX(struct name*, int)
+
+/* Main rb operation.
+ * Moves node close to the key of elm to top
+ */
+#define RB_GENERATE_WITHOUT_COMPARE(name, type, field)                                             \
+    RB_GENERATE_WITHOUT_COMPARE_INTERNAL(name, type, field, )
+#define RB_GENERATE_WITHOUT_COMPARE_STATIC(name, type, field)                                      \
+    RB_GENERATE_WITHOUT_COMPARE_INTERNAL(name, type, field, static)
+#define RB_GENERATE_WITHOUT_COMPARE_INTERNAL(name, type, field, attr)                              \
+    RB_GENERATE_REMOVE_COLOR(name, type, field, attr)                                              \
+    RB_GENERATE_REMOVE(name, type, field, attr)                                                    \
+    RB_GENERATE_NEXT(name, type, field, attr)                                                      \
+    RB_GENERATE_PREV(name, type, field, attr)                                                      \
+    RB_GENERATE_MINMAX(name, type, field, attr)
+
+#define RB_GENERATE_WITH_COMPARE(name, type, field, cmp, lcmp)                                     \
+    RB_GENERATE_WITH_COMPARE_INTERNAL(name, type, field, cmp, lcmp, )
+#define RB_GENERATE_WITH_COMPARE_STATIC(name, type, field, cmp, lcmp)                              \
+    RB_GENERATE_WITH_COMPARE_INTERNAL(name, type, field, cmp, lcmp, static)
+#define RB_GENERATE_WITH_COMPARE_INTERNAL(name, type, field, cmp, lcmp, attr)                      \
+    RB_GENERATE_INSERT_COLOR(name, type, field, attr)                                              \
+    RB_GENERATE_INSERT(name, type, field, cmp, attr)                                               \
+    RB_GENERATE_FIND(name, type, field, cmp, attr)                                                 \
+    RB_GENERATE_NFIND(name, type, field, cmp, attr)                                                \
+    RB_GENERATE_FIND_LIGHT(name, type, field, lcmp, attr)                                          \
+    RB_GENERATE_NFIND_LIGHT(name, type, field, lcmp, attr)
+
+#define RB_GENERATE_ALL(name, type, field, cmp) RB_GENERATE_ALL_INTERNAL(name, type, field, cmp, )
+#define RB_GENERATE_ALL_STATIC(name, type, field, cmp)                                             \
+    RB_GENERATE_ALL_INTERNAL(name, type, field, cmp, static)
+#define RB_GENERATE_ALL_INTERNAL(name, type, field, cmp, attr)                                     \
+    RB_GENERATE_WITHOUT_COMPARE_INTERNAL(name, type, field, attr)                                  \
+    RB_GENERATE_WITH_COMPARE_INTERNAL(name, type, field, cmp, attr)
+
+#define RB_GENERATE_INSERT_COLOR(name, type, field, attr)                                          \
+    attr void name##_RB_INSERT_COLOR(struct name* head, struct type* elm) {                        \
+        struct type *parent, *gparent, *tmp;                                                       \
+        while ((parent = RB_PARENT(elm, field)) != NULL && RB_COLOR(parent, field) == RB_RED) {    \
+            gparent = RB_PARENT(parent, field);                                                    \
+            if (parent == RB_LEFT(gparent, field)) {                                               \
+                tmp = RB_RIGHT(gparent, field);                                                    \
+                if (tmp && RB_COLOR(tmp, field) == RB_RED) {                                       \
+                    RB_COLOR(tmp, field) = RB_BLACK;                                               \
+                    RB_SET_BLACKRED(parent, gparent, field);                                       \
+                    elm = gparent;                                                                 \
+                    continue;                                                                      \
+                }                                                                                  \
+                if (RB_RIGHT(parent, field) == elm) {                                              \
+                    RB_ROTATE_LEFT(head, parent, tmp, field);                                      \
+                    tmp = parent;                                                                  \
+                    parent = elm;                                                                  \
+                    elm = tmp;                                                                     \
+                }                                                                                  \
+                RB_SET_BLACKRED(parent, gparent, field);                                           \
+                RB_ROTATE_RIGHT(head, gparent, tmp, field);                                        \
+            } else {                                                                               \
+                tmp = RB_LEFT(gparent, field);                                                     \
+                if (tmp && RB_COLOR(tmp, field) == RB_RED) {                                       \
+                    RB_COLOR(tmp, field) = RB_BLACK;                                               \
+                    RB_SET_BLACKRED(parent, gparent, field);                                       \
+                    elm = gparent;                                                                 \
+                    continue;                                                                      \
+                }                                                                                  \
+                if (RB_LEFT(parent, field) == elm) {                                               \
+                    RB_ROTATE_RIGHT(head, parent, tmp, field);                                     \
+                    tmp = parent;                                                                  \
+                    parent = elm;                                                                  \
+                    elm = tmp;                                                                     \
+                }                                                                                  \
+                RB_SET_BLACKRED(parent, gparent, field);                                           \
+                RB_ROTATE_LEFT(head, gparent, tmp, field);                                         \
+            }                                                                                      \
+        }                                                                                          \
+        RB_COLOR(head->rbh_root, field) = RB_BLACK;                                                \
+    }
+
+#define RB_GENERATE_REMOVE_COLOR(name, type, field, attr)                                          \
+    attr void name##_RB_REMOVE_COLOR(struct name* head, struct type* parent, struct type* elm) {   \
+        struct type* tmp;                                                                          \
+        while ((elm == NULL || RB_COLOR(elm, field) == RB_BLACK) && elm != RB_ROOT(head)) {        \
+            if (RB_LEFT(parent, field) == elm) {                                                   \
+                tmp = RB_RIGHT(parent, field);                                                     \
+                if (RB_COLOR(tmp, field) == RB_RED) {                                              \
+                    RB_SET_BLACKRED(tmp, parent, field);                                           \
+                    RB_ROTATE_LEFT(head, parent, tmp, field);                                      \
+                    tmp = RB_RIGHT(parent, field);                                                 \
+                }                                                                                  \
+                if ((RB_LEFT(tmp, field) == NULL ||                                                \
+                     RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&                          \
+                    (RB_RIGHT(tmp, field) == NULL ||                                               \
+                     RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {                         \
+                    RB_COLOR(tmp, field) = RB_RED;                                                 \
+                    elm = parent;                                                                  \
+                    parent = RB_PARENT(elm, field);                                                \
+                } else {                                                                           \
+                    if (RB_RIGHT(tmp, field) == NULL ||                                            \
+                        RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) {                       \
+                        struct type* oleft;                                                        \
+                        if ((oleft = RB_LEFT(tmp, field)) != NULL)                                 \
+                            RB_COLOR(oleft, field) = RB_BLACK;                                     \
+                        RB_COLOR(tmp, field) = RB_RED;                                             \
+                        RB_ROTATE_RIGHT(head, tmp, oleft, field);                                  \
+                        tmp = RB_RIGHT(parent, field);                                             \
+                    }                                                                              \
+                    RB_COLOR(tmp, field) = RB_COLOR(parent, field);                                \
+                    RB_COLOR(parent, field) = RB_BLACK;                                            \
+                    if (RB_RIGHT(tmp, field))                                                      \
+                        RB_COLOR(RB_RIGHT(tmp, field), field) = RB_BLACK;                          \
+                    RB_ROTATE_LEFT(head, parent, tmp, field);                                      \
+                    elm = RB_ROOT(head);                                                           \
+                    break;                                                                         \
+                }                                                                                  \
+            } else {                                                                               \
+                tmp = RB_LEFT(parent, field);                                                      \
+                if (RB_COLOR(tmp, field) == RB_RED) {                                              \
+                    RB_SET_BLACKRED(tmp, parent, field);                                           \
+                    RB_ROTATE_RIGHT(head, parent, tmp, field);                                     \
+                    tmp = RB_LEFT(parent, field);                                                  \
+                }                                                                                  \
+                if ((RB_LEFT(tmp, field) == NULL ||                                                \
+                     RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&                          \
+                    (RB_RIGHT(tmp, field) == NULL ||                                               \
+                     RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {                         \
+                    RB_COLOR(tmp, field) = RB_RED;                                                 \
+                    elm = parent;                                                                  \
+                    parent = RB_PARENT(elm, field);                                                \
+                } else {                                                                           \
+                    if (RB_LEFT(tmp, field) == NULL ||                                             \
+                        RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) {                        \
+                        struct type* oright;                                                       \
+                        if ((oright = RB_RIGHT(tmp, field)) != NULL)                               \
+                            RB_COLOR(oright, field) = RB_BLACK;                                    \
+                        RB_COLOR(tmp, field) = RB_RED;                                             \
+                        RB_ROTATE_LEFT(head, tmp, oright, field);                                  \
+                        tmp = RB_LEFT(parent, field);                                              \
+                    }                                                                              \
+                    RB_COLOR(tmp, field) = RB_COLOR(parent, field);                                \
+                    RB_COLOR(parent, field) = RB_BLACK;                                            \
+                    if (RB_LEFT(tmp, field))                                                       \
+                        RB_COLOR(RB_LEFT(tmp, field), field) = RB_BLACK;                           \
+                    RB_ROTATE_RIGHT(head, parent, tmp, field);                                     \
+                    elm = RB_ROOT(head);                                                           \
+                    break;                                                                         \
+                }                                                                                  \
+            }                                                                                      \
+        }                                                                                          \
+        if (elm)                                                                                   \
+            RB_COLOR(elm, field) = RB_BLACK;                                                       \
+    }
+
+#define RB_GENERATE_REMOVE(name, type, field, attr)                                                \
+    attr struct type* name##_RB_REMOVE(struct name* head, struct type* elm) {                      \
+        struct type *child, *parent, *old = elm;                                                   \
+        int color;                                                                                 \
+        if (RB_LEFT(elm, field) == NULL)                                                           \
+            child = RB_RIGHT(elm, field);                                                          \
+        else if (RB_RIGHT(elm, field) == NULL)                                                     \
+            child = RB_LEFT(elm, field);                                                           \
+        else {                                                                                     \
+            struct type* left;                                                                     \
+            elm = RB_RIGHT(elm, field);                                                            \
+            while ((left = RB_LEFT(elm, field)) != NULL)                                           \
+                elm = left;                                                                        \
+            child = RB_RIGHT(elm, field);                                                          \
+            parent = RB_PARENT(elm, field);                                                        \
+            color = RB_COLOR(elm, field);                                                          \
+            if (child)                                                                             \
+                RB_PARENT(child, field) = parent;                                                  \
+            if (parent) {                                                                          \
+                if (RB_LEFT(parent, field) == elm)                                                 \
+                    RB_LEFT(parent, field) = child;                                                \
+                else                                                                               \
+                    RB_RIGHT(parent, field) = child;                                               \
+                RB_AUGMENT(parent);                                                                \
+            } else                                                                                 \
+                RB_ROOT(head) = child;                                                             \
+            if (RB_PARENT(elm, field) == old)                                                      \
+                parent = elm;                                                                      \
+            (elm)->field = (old)->field;                                                           \
+            if (RB_PARENT(old, field)) {                                                           \
+                if (RB_LEFT(RB_PARENT(old, field), field) == old)                                  \
+                    RB_LEFT(RB_PARENT(old, field), field) = elm;                                   \
+                else                                                                               \
+                    RB_RIGHT(RB_PARENT(old, field), field) = elm;                                  \
+                RB_AUGMENT(RB_PARENT(old, field));                                                 \
+            } else                                                                                 \
+                RB_ROOT(head) = elm;                                                               \
+            RB_PARENT(RB_LEFT(old, field), field) = elm;                                           \
+            if (RB_RIGHT(old, field))                                                              \
+                RB_PARENT(RB_RIGHT(old, field), field) = elm;                                      \
+            if (parent) {                                                                          \
+                left = parent;                                                                     \
+                do {                                                                               \
+                    RB_AUGMENT(left);                                                              \
+                } while ((left = RB_PARENT(left, field)) != NULL);                                 \
+            }                                                                                      \
+            goto color;                                                                            \
+        }                                                                                          \
+        parent = RB_PARENT(elm, field);                                                            \
+        color = RB_COLOR(elm, field);                                                              \
+        if (child)                                                                                 \
+            RB_PARENT(child, field) = parent;                                                      \
+        if (parent) {                                                                              \
+            if (RB_LEFT(parent, field) == elm)                                                     \
+                RB_LEFT(parent, field) = child;                                                    \
+            else                                                                                   \
+                RB_RIGHT(parent, field) = child;                                                   \
+            RB_AUGMENT(parent);                                                                    \
+        } else                                                                                     \
+            RB_ROOT(head) = child;                                                                 \
+    color:                                                                                         \
+        if (color == RB_BLACK)                                                                     \
+            name##_RB_REMOVE_COLOR(head, parent, child);                                           \
+        return (old);                                                                              \
+    }
+
+#define RB_GENERATE_INSERT(name, type, field, cmp, attr)                                           \
+    /* Inserts a node into the RB tree */                                                          \
+    attr struct type* name##_RB_INSERT(struct name* head, struct type* elm) {                      \
+        struct type* tmp;                                                                          \
+        struct type* parent = NULL;                                                                \
+        int comp = 0;                                                                              \
+        tmp = RB_ROOT(head);                                                                       \
+        while (tmp) {                                                                              \
+            parent = tmp;                                                                          \
+            comp = (cmp)(elm, parent);                                                             \
+            if (comp < 0)                                                                          \
+                tmp = RB_LEFT(tmp, field);                                                         \
+            else if (comp > 0)                                                                     \
+                tmp = RB_RIGHT(tmp, field);                                                        \
+            else                                                                                   \
+                return (tmp);                                                                      \
+        }                                                                                          \
+        RB_SET(elm, parent, field);                                                                \
+        if (parent != NULL) {                                                                      \
+            if (comp < 0)                                                                          \
+                RB_LEFT(parent, field) = elm;                                                      \
+            else                                                                                   \
+                RB_RIGHT(parent, field) = elm;                                                     \
+            RB_AUGMENT(parent);                                                                    \
+        } else                                                                                     \
+            RB_ROOT(head) = elm;                                                                   \
+        name##_RB_INSERT_COLOR(head, elm);                                                         \
+        return (NULL);                                                                             \
+    }
+
+#define RB_GENERATE_FIND(name, type, field, cmp, attr)                                             \
+    /* Finds the node with the same key as elm */                                                  \
+    attr struct type* name##_RB_FIND(struct name* head, struct type* elm) {                        \
+        struct type* tmp = RB_ROOT(head);                                                          \
+        int comp;                                                                                  \
+        while (tmp) {                                                                              \
+            comp = cmp(elm, tmp);                                                                  \
+            if (comp < 0)                                                                          \
+                tmp = RB_LEFT(tmp, field);                                                         \
+            else if (comp > 0)                                                                     \
+                tmp = RB_RIGHT(tmp, field);                                                        \
+            else                                                                                   \
+                return (tmp);                                                                      \
+        }                                                                                          \
+        return (NULL);                                                                             \
+    }
+
+#define RB_GENERATE_NFIND(name, type, field, cmp, attr)                                            \
+    /* Finds the first node greater than or equal to the search key */                             \
+    attr struct type* name##_RB_NFIND(struct name* head, struct type* elm) {                       \
+        struct type* tmp = RB_ROOT(head);                                                          \
+        struct type* res = NULL;                                                                   \
+        int comp;                                                                                  \
+        while (tmp) {                                                                              \
+            comp = cmp(elm, tmp);                                                                  \
+            if (comp < 0) {                                                                        \
+                res = tmp;                                                                         \
+                tmp = RB_LEFT(tmp, field);                                                         \
+            } else if (comp > 0)                                                                   \
+                tmp = RB_RIGHT(tmp, field);                                                        \
+            else                                                                                   \
+                return (tmp);                                                                      \
+        }                                                                                          \
+        return (res);                                                                              \
+    }
+
+#define RB_GENERATE_FIND_LIGHT(name, type, field, lcmp, attr)                                      \
+    /* Finds the node with the same key as elm */                                                  \
+    attr struct type* name##_RB_FIND_LIGHT(struct name* head, const void* lelm) {                  \
+        struct type* tmp = RB_ROOT(head);                                                          \
+        int comp;                                                                                  \
+        while (tmp) {                                                                              \
+            comp = lcmp(lelm, tmp);                                                                \
+            if (comp < 0)                                                                          \
+                tmp = RB_LEFT(tmp, field);                                                         \
+            else if (comp > 0)                                                                     \
+                tmp = RB_RIGHT(tmp, field);                                                        \
+            else                                                                                   \
+                return (tmp);                                                                      \
+        }                                                                                          \
+        return (NULL);                                                                             \
+    }
+
+#define RB_GENERATE_NFIND_LIGHT(name, type, field, lcmp, attr)                                     \
+    /* Finds the first node greater than or equal to the search key */                             \
+    attr struct type* name##_RB_NFIND_LIGHT(struct name* head, const void* lelm) {                 \
+        struct type* tmp = RB_ROOT(head);                                                          \
+        struct type* res = NULL;                                                                   \
+        int comp;                                                                                  \
+        while (tmp) {                                                                              \
+            comp = lcmp(lelm, tmp);                                                                \
+            if (comp < 0) {                                                                        \
+                res = tmp;                                                                         \
+                tmp = RB_LEFT(tmp, field);                                                         \
+            } else if (comp > 0)                                                                   \
+                tmp = RB_RIGHT(tmp, field);                                                        \
+            else                                                                                   \
+                return (tmp);                                                                      \
+        }                                                                                          \
+        return (res);                                                                              \
+    }
+
+#define RB_GENERATE_NEXT(name, type, field, attr)                                                  \
+    /* ARGSUSED */                                                                                 \
+    attr struct type* name##_RB_NEXT(struct type* elm) {                                           \
+        if (RB_RIGHT(elm, field)) {                                                                \
+            elm = RB_RIGHT(elm, field);                                                            \
+            while (RB_LEFT(elm, field))                                                            \
+                elm = RB_LEFT(elm, field);                                                         \
+        } else {                                                                                   \
+            if (RB_PARENT(elm, field) && (elm == RB_LEFT(RB_PARENT(elm, field), field)))           \
+                elm = RB_PARENT(elm, field);                                                       \
+            else {                                                                                 \
+                while (RB_PARENT(elm, field) && (elm == RB_RIGHT(RB_PARENT(elm, field), field)))   \
+                    elm = RB_PARENT(elm, field);                                                   \
+                elm = RB_PARENT(elm, field);                                                       \
+            }                                                                                      \
+        }                                                                                          \
+        return (elm);                                                                              \
+    }
+
+#define RB_GENERATE_PREV(name, type, field, attr)                                                  \
+    /* ARGSUSED */                                                                                 \
+    attr struct type* name##_RB_PREV(struct type* elm) {                                           \
+        if (RB_LEFT(elm, field)) {                                                                 \
+            elm = RB_LEFT(elm, field);                                                             \
+            while (RB_RIGHT(elm, field))                                                           \
+                elm = RB_RIGHT(elm, field);                                                        \
+        } else {                                                                                   \
+            if (RB_PARENT(elm, field) && (elm == RB_RIGHT(RB_PARENT(elm, field), field)))          \
+                elm = RB_PARENT(elm, field);                                                       \
+            else {                                                                                 \
+                while (RB_PARENT(elm, field) && (elm == RB_LEFT(RB_PARENT(elm, field), field)))    \
+                    elm = RB_PARENT(elm, field);                                                   \
+                elm = RB_PARENT(elm, field);                                                       \
+            }                                                                                      \
+        }                                                                                          \
+        return (elm);                                                                              \
+    }
+
+#define RB_GENERATE_MINMAX(name, type, field, attr)                                                \
+    attr struct type* name##_RB_MINMAX(struct name* head, int val) {                               \
+        struct type* tmp = RB_ROOT(head);                                                          \
+        struct type* parent = NULL;                                                                \
+        while (tmp) {                                                                              \
+            parent = tmp;                                                                          \
+            if (val < 0)                                                                           \
+                tmp = RB_LEFT(tmp, field);                                                         \
+            else                                                                                   \
+                tmp = RB_RIGHT(tmp, field);                                                        \
+        }                                                                                          \
+        return (parent);                                                                           \
+    }
+
+#define RB_NEGINF -1
+#define RB_INF 1
+
+#define RB_INSERT(name, x, y) name##_RB_INSERT(x, y)
+#define RB_REMOVE(name, x, y) name##_RB_REMOVE(x, y)
+#define RB_FIND(name, x, y) name##_RB_FIND(x, y)
+#define RB_NFIND(name, x, y) name##_RB_NFIND(x, y)
+#define RB_FIND_LIGHT(name, x, y) name##_RB_FIND_LIGHT(x, y)
+#define RB_NFIND_LIGHT(name, x, y) name##_RB_NFIND_LIGHT(x, y)
+#define RB_NEXT(name, x, y) name##_RB_NEXT(y)
+#define RB_PREV(name, x, y) name##_RB_PREV(y)
+#define RB_MIN(name, x) name##_RB_MINMAX(x, RB_NEGINF)
+#define RB_MAX(name, x) name##_RB_MINMAX(x, RB_INF)
+
+#define RB_FOREACH(x, name, head)                                                                  \
+    for ((x) = RB_MIN(name, head); (x) != NULL; (x) = name##_RB_NEXT(x))
+
+#define RB_FOREACH_FROM(x, name, y)                                                                \
+    for ((x) = (y); ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL); (x) = (y))
+
+#define RB_FOREACH_SAFE(x, name, head, y)                                                          \
+    for ((x) = RB_MIN(name, head); ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL);        \
+         (x) = (y))
+
+#define RB_FOREACH_REVERSE(x, name, head)                                                          \
+    for ((x) = RB_MAX(name, head); (x) != NULL; (x) = name##_RB_PREV(x))
+
+#define RB_FOREACH_REVERSE_FROM(x, name, y)                                                        \
+    for ((x) = (y); ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL); (x) = (y))
+
+#define RB_FOREACH_REVERSE_SAFE(x, name, head, y)                                                  \
+    for ((x) = RB_MAX(name, head); ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL);        \
+         (x) = (y))
+
+#endif /* _SYS_TREE_H_ */

src/common/virtual_buffer.h

@@ -15,10 +15,12 @@ void FreeMemoryPages(void* base, std::size_t size) noexcept;
 template <typename T>
 class VirtualBuffer final {
 public:
-    static_assert(
-        std::is_trivially_constructible_v<T>,
-        "T must be trivially constructible, as non-trivial constructors will not be executed "
-        "with the current allocator");
+    // TODO: Uncomment this and change Common::PageTable::PageInfo to be trivially constructible
+    // using std::atomic_ref once libc++ has support for it
+    // static_assert(
+    //     std::is_trivially_constructible_v<T>,
+    //     "T must be trivially constructible, as non-trivial constructors will not be executed "
+    //     "with the current allocator");
 
     constexpr VirtualBuffer() = default;
     explicit VirtualBuffer(std::size_t count) : alloc_size{count * sizeof(T)} {
@@ -43,9 +45,14 @@ public:
     }
 
     void resize(std::size_t count) {
+        const auto new_size = count * sizeof(T);
+        if (new_size == alloc_size) {
+            return;
+        }
+
         FreeMemoryPages(base_ptr, alloc_size);
 
-        alloc_size = count * sizeof(T);
+        alloc_size = new_size;
         base_ptr = reinterpret_cast<T*>(AllocateMemoryPages(alloc_size));
     }
 

src/common/wall_clock.cpp

@@ -17,8 +17,8 @@ using base_time_point = std::chrono::time_point<base_timer>;
 
 class StandardWallClock final : public WallClock {
 public:
-    StandardWallClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency)
-        : WallClock(emulated_cpu_frequency, emulated_clock_frequency, false) {
+    explicit StandardWallClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_)
+        : WallClock(emulated_cpu_frequency_, emulated_clock_frequency_, false) {
         start_time = base_timer::now();
     }
 

src/common/wall_clock.h

@@ -38,9 +38,9 @@ public:
     }
 
 protected:
-    WallClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency, bool is_native)
-        : emulated_cpu_frequency{emulated_cpu_frequency},
-          emulated_clock_frequency{emulated_clock_frequency}, is_native{is_native} {}
+    explicit WallClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_, bool is_native_)
+        : emulated_cpu_frequency{emulated_cpu_frequency_},
+          emulated_clock_frequency{emulated_clock_frequency_}, is_native{is_native_} {}
 
     u64 emulated_cpu_frequency;
     u64 emulated_clock_frequency;

src/common/x64/native_clock.cpp

@@ -43,10 +43,10 @@ u64 EstimateRDTSCFrequency() {
 }
 
 namespace X64 {
-NativeClock::NativeClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency,
-                         u64 rtsc_frequency)
-    : WallClock(emulated_cpu_frequency, emulated_clock_frequency, true), rtsc_frequency{
-                                                                             rtsc_frequency} {
+NativeClock::NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_,
+                         u64 rtsc_frequency_)
+    : WallClock(emulated_cpu_frequency_, emulated_clock_frequency_, true), rtsc_frequency{
+                                                                               rtsc_frequency_} {
     _mm_mfence();
     last_measure = __rdtsc();
     accumulated_ticks = 0U;

src/common/x64/native_clock.h

@@ -14,7 +14,8 @@ namespace Common {
 namespace X64 {
 class NativeClock final : public WallClock {
 public:
-    NativeClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency, u64 rtsc_frequency);
+    explicit NativeClock(u64 emulated_cpu_frequency_, u64 emulated_clock_frequency_,
+                         u64 rtsc_frequency_);
 
     std::chrono::nanoseconds GetTimeNS() override;
 

src/common/x64/xbyak_abi.h

@@ -11,25 +11,25 @@
 
 namespace Common::X64 {
 
-constexpr std::size_t RegToIndex(const Xbyak::Reg& reg) {
+constexpr size_t RegToIndex(const Xbyak::Reg& reg) {
     using Kind = Xbyak::Reg::Kind;
     ASSERT_MSG((reg.getKind() & (Kind::REG | Kind::XMM)) != 0,
                "RegSet only support GPRs and XMM registers.");
     ASSERT_MSG(reg.getIdx() < 16, "RegSet only supports XXM0-15.");
-    return reg.getIdx() + (reg.getKind() == Kind::REG ? 0 : 16);
+    return static_cast<size_t>(reg.getIdx()) + (reg.getKind() == Kind::REG ? 0 : 16);
 }
 
-constexpr Xbyak::Reg64 IndexToReg64(std::size_t reg_index) {
+constexpr Xbyak::Reg64 IndexToReg64(size_t reg_index) {
     ASSERT(reg_index < 16);
     return Xbyak::Reg64(static_cast<int>(reg_index));
 }
 
-constexpr Xbyak::Xmm IndexToXmm(std::size_t reg_index) {
+constexpr Xbyak::Xmm IndexToXmm(size_t reg_index) {
     ASSERT(reg_index >= 16 && reg_index < 32);
     return Xbyak::Xmm(static_cast<int>(reg_index - 16));
 }
 
-constexpr Xbyak::Reg IndexToReg(std::size_t reg_index) {
+constexpr Xbyak::Reg IndexToReg(size_t reg_index) {
     if (reg_index < 16) {
         return IndexToReg64(reg_index);
     } else {
@@ -182,7 +182,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
                                               size_t rsp_alignment, size_t needed_frame_size = 0) {
     auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
 
-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
         if (regs[i] && ABI_ALL_GPRS[i]) {
             code.push(IndexToReg64(i));
         }
@@ -192,7 +192,7 @@ inline size_t ABI_PushRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::b
         code.sub(code.rsp, frame_info.subtraction);
     }
 
-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
         if (regs[i] && ABI_ALL_XMMS[i]) {
             code.movaps(code.xword[code.rsp + frame_info.xmm_offset], IndexToXmm(i));
             frame_info.xmm_offset += 0x10;
@@ -206,7 +206,7 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
                                            size_t rsp_alignment, size_t needed_frame_size = 0) {
     auto frame_info = ABI_CalculateFrameSize(regs, rsp_alignment, needed_frame_size);
 
-    for (std::size_t i = 0; i < regs.size(); ++i) {
+    for (size_t i = 0; i < regs.size(); ++i) {
         if (regs[i] && ABI_ALL_XMMS[i]) {
             code.movaps(IndexToXmm(i), code.xword[code.rsp + frame_info.xmm_offset]);
             frame_info.xmm_offset += 0x10;
@@ -218,8 +218,8 @@ inline void ABI_PopRegistersAndAdjustStack(Xbyak::CodeGenerator& code, std::bits
     }
 
     // GPRs need to be popped in reverse order
-    for (std::size_t j = 0; j < regs.size(); ++j) {
-        const std::size_t i = regs.size() - j - 1;
+    for (size_t j = 0; j < regs.size(); ++j) {
+        const size_t i = regs.size() - j - 1;
         if (regs[i] && ABI_ALL_GPRS[i]) {
             code.pop(IndexToReg64(i));
         }

src/core/CMakeLists.txt

@@ -41,6 +41,7 @@ add_library(core STATIC
     file_sys/bis_factory.h
     file_sys/card_image.cpp
     file_sys/card_image.h
+    file_sys/common_funcs.h
     file_sys/content_archive.cpp
     file_sys/content_archive.h
     file_sys/control_metadata.cpp
@@ -134,15 +135,13 @@ add_library(core STATIC
     frontend/emu_window.h
     frontend/framebuffer_layout.cpp
     frontend/framebuffer_layout.h
+    frontend/input_interpreter.cpp
+    frontend/input_interpreter.h
     frontend/input.h
-    gdbstub/gdbstub.cpp
-    gdbstub/gdbstub.h
     hardware_interrupt_manager.cpp
     hardware_interrupt_manager.h
     hle/ipc.h
     hle/ipc_helpers.h
-    hle/kernel/address_arbiter.cpp
-    hle/kernel/address_arbiter.h
     hle/kernel/client_port.cpp
     hle/kernel/client_port.h
     hle/kernel/client_session.cpp
@@ -150,10 +149,25 @@ add_library(core STATIC
     hle/kernel/code_set.cpp
     hle/kernel/code_set.h
     hle/kernel/errors.h
+    hle/kernel/global_scheduler_context.cpp
+    hle/kernel/global_scheduler_context.h
     hle/kernel/handle_table.cpp
     hle/kernel/handle_table.h
     hle/kernel/hle_ipc.cpp
     hle/kernel/hle_ipc.h
+    hle/kernel/k_address_arbiter.cpp
+    hle/kernel/k_address_arbiter.h
+    hle/kernel/k_affinity_mask.h
+    hle/kernel/k_condition_variable.cpp
+    hle/kernel/k_condition_variable.h
+    hle/kernel/k_priority_queue.h
+    hle/kernel/k_scheduler.cpp
+    hle/kernel/k_scheduler.h
+    hle/kernel/k_scheduler_lock.h
+    hle/kernel/k_scoped_lock.h
+    hle/kernel/k_scoped_scheduler_lock_and_sleep.h
+    hle/kernel/k_synchronization_object.cpp
+    hle/kernel/k_synchronization_object.h
     hle/kernel/kernel.cpp
     hle/kernel/kernel.h
     hle/kernel/memory/address_space_info.cpp
@@ -173,8 +187,6 @@ add_library(core STATIC
     hle/kernel/memory/slab_heap.h
     hle/kernel/memory/system_control.cpp
     hle/kernel/memory/system_control.h
-    hle/kernel/mutex.cpp
-    hle/kernel/mutex.h
     hle/kernel/object.cpp
     hle/kernel/object.h
     hle/kernel/physical_core.cpp
@@ -188,24 +200,22 @@ add_library(core STATIC
     hle/kernel/readable_event.h
     hle/kernel/resource_limit.cpp
     hle/kernel/resource_limit.h
-    hle/kernel/scheduler.cpp
-    hle/kernel/scheduler.h
     hle/kernel/server_port.cpp
     hle/kernel/server_port.h
     hle/kernel/server_session.cpp
     hle/kernel/server_session.h
+    hle/kernel/service_thread.cpp
+    hle/kernel/service_thread.h
     hle/kernel/session.cpp
     hle/kernel/session.h
     hle/kernel/shared_memory.cpp
     hle/kernel/shared_memory.h
     hle/kernel/svc.cpp
     hle/kernel/svc.h
+    hle/kernel/svc_common.h
+    hle/kernel/svc_results.h
     hle/kernel/svc_types.h
     hle/kernel/svc_wrap.h
-    hle/kernel/synchronization_object.cpp
-    hle/kernel/synchronization_object.h
-    hle/kernel/synchronization.cpp
-    hle/kernel/synchronization.h
     hle/kernel/thread.cpp
     hle/kernel/thread.h
     hle/kernel/time_manager.cpp
@@ -458,6 +468,8 @@ add_library(core STATIC
     hle/service/nvflinger/buffer_queue.h
     hle/service/nvflinger/nvflinger.cpp
     hle/service/nvflinger/nvflinger.h
+    hle/service/olsc/olsc.cpp
+    hle/service/olsc/olsc.h
     hle/service/pcie/pcie.cpp
     hle/service/pcie/pcie.h
     hle/service/pctl/module.cpp
@@ -490,7 +502,6 @@ add_library(core STATIC
     hle/service/sm/controller.h
     hle/service/sm/sm.cpp
     hle/service/sm/sm.h
-    hle/service/sockets/blocking_worker.h
     hle/service/sockets/bsd.cpp
     hle/service/sockets/bsd.h
     hle/service/sockets/ethc.cpp
@@ -624,15 +635,15 @@ if (MSVC)
         /we4267
         # 'context' : truncation from 'type1' to 'type2'
         /we4305
+        # 'function' : not all control paths return a value
+        /we4715
     )
 else()
     target_compile_options(core PRIVATE
         -Werror=conversion
         -Werror=ignored-qualifiers
         -Werror=implicit-fallthrough
-        -Werror=reorder
         -Werror=sign-compare
-        -Werror=unused-variable
 
         $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
         $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>

src/core/arm/arm_interface.h

@@ -26,9 +26,10 @@ using CPUInterrupts = std::array<CPUInterruptHandler, Core::Hardware::NUM_CPU_CO
 /// Generic ARMv8 CPU interface
 class ARM_Interface : NonCopyable {
 public:
-    explicit ARM_Interface(System& system_, CPUInterrupts& interrupt_handlers, bool uses_wall_clock)
-        : system{system_}, interrupt_handlers{interrupt_handlers}, uses_wall_clock{
-                                                                       uses_wall_clock} {}
+    explicit ARM_Interface(System& system_, CPUInterrupts& interrupt_handlers_,
+                           bool uses_wall_clock_)
+        : system{system_}, interrupt_handlers{interrupt_handlers_}, uses_wall_clock{
+                                                                        uses_wall_clock_} {}
     virtual ~ARM_Interface() = default;
 
     struct ThreadContext32 {
@@ -64,15 +65,25 @@ public:
     /// Step CPU by one instruction
     virtual void Step() = 0;
 
+    /// Exits execution from a callback, the callback must rewind the stack
+    virtual void ExceptionalExit() = 0;
+
     /// Clear all instruction cache
     virtual void ClearInstructionCache() = 0;
 
-    /// Notifies CPU emulation that the current page table has changed.
-    ///
-    /// @param new_page_table                 The new page table.
-    /// @param new_address_space_size_in_bits The new usable size of the address space in bits.
-    ///                                       This can be either 32, 36, or 39 on official software.
-    ///
+    /**
+     * Clear instruction cache range
+     * @param addr Start address of the cache range to clear
+     * @param size Size of the cache range to clear, starting at addr
+     */
+    virtual void InvalidateCacheRange(VAddr addr, std::size_t size) = 0;
+
+    /**
+     * Notifies CPU emulation that the current page table has changed.
+     *  @param new_page_table                 The new page table.
+     *  @param new_address_space_size_in_bits The new usable size of the address space in bits.
+     *                                        This can be either 32, 36, or 39 on official software.
+     */
     virtual void PageTableChanged(Common::PageTable& new_page_table,
                                   std::size_t new_address_space_size_in_bits) = 0;
 

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -71,15 +71,8 @@ public:
     }
 
     void ExceptionRaised(u32 pc, Dynarmic::A32::Exception exception) override {
-        switch (exception) {
-        case Dynarmic::A32::Exception::UndefinedInstruction:
-        case Dynarmic::A32::Exception::UnpredictableInstruction:
-            break;
-        case Dynarmic::A32::Exception::Breakpoint:
-            break;
-        }
         LOG_CRITICAL(Core_ARM, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
-                     static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
+                     exception, pc, MemoryReadCode(pc));
         UNIMPLEMENTED();
     }
 
@@ -133,6 +126,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable&
     config.page_table = reinterpret_cast<std::array<std::uint8_t*, NUM_PAGE_TABLE_ENTRIES>*>(
         page_table.pointers.data());
     config.absolute_offset_page_table = true;
+    config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
     config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
     config.only_detect_misalignment_via_page_table_on_page_boundary = true;
 
@@ -180,6 +174,9 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable&
         if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
+            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
+        }
     }
 
     return std::make_unique<Dynarmic::A32::Jit>(config);
@@ -189,6 +186,10 @@ void ARM_Dynarmic_32::Run() {
     jit->Run();
 }
 
+void ARM_Dynarmic_32::ExceptionalExit() {
+    jit->ExceptionalExit();
+}
+
 void ARM_Dynarmic_32::Step() {
     jit->Step();
 }
@@ -282,7 +283,17 @@ void ARM_Dynarmic_32::ClearInstructionCache() {
     jit->ClearCache();
 }
 
+void ARM_Dynarmic_32::InvalidateCacheRange(VAddr addr, std::size_t size) {
+    if (!jit) {
+        return;
+    }
+    jit->InvalidateCacheRange(static_cast<u32>(addr), size);
+}
+
 void ARM_Dynarmic_32::ClearExclusiveState() {
+    if (!jit) {
+        return;
+    }
     jit->ClearExclusiveState();
 }
 

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -42,6 +42,7 @@ public:
     u32 GetPSTATE() const override;
     void SetPSTATE(u32 pstate) override;
     void Run() override;
+    void ExceptionalExit() override;
     void Step() override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
@@ -58,6 +59,7 @@ public:
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
+    void InvalidateCacheRange(VAddr addr, std::size_t size) override;
     void PageTableChanged(Common::PageTable& new_page_table,
                           std::size_t new_address_space_size_in_bits) override;
 

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -14,10 +14,9 @@
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/gdbstub/gdbstub.h"
 #include "core/hardware_properties.h"
+#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/svc.h"
 #include "core/memory.h"
 #include "core/settings.h"
@@ -96,16 +95,6 @@ public:
         case Dynarmic::A64::Exception::Yield:
             return;
         case Dynarmic::A64::Exception::Breakpoint:
-            if (GDBStub::IsServerEnabled()) {
-                parent.jit->HaltExecution();
-                parent.SetPC(pc);
-                Kernel::Thread* const thread = parent.system.CurrentScheduler().GetCurrentThread();
-                parent.SaveContext(thread->GetContext64());
-                GDBStub::Break();
-                GDBStub::SendTrap(thread, 5);
-                return;
-            }
-            [[fallthrough]];
         default:
             ASSERT_MSG(false, "ExceptionRaised(exception = {}, pc = {:08X}, code = {:08X})",
                        static_cast<std::size_t>(exception), pc, MemoryReadCode(pc));
@@ -163,6 +152,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
     // Memory
     config.page_table = reinterpret_cast<void**>(page_table.pointers.data());
     config.page_table_address_space_bits = address_space_bits;
+    config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
     config.silently_mirror_page_table = false;
     config.absolute_offset_page_table = true;
     config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
@@ -222,6 +212,9 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable&
         if (Settings::values.cpuopt_unsafe_reduce_fp_error) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_ReducedErrorFP;
         }
+        if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
+            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
+        }
     }
 
     return std::make_shared<Dynarmic::A64::Jit>(config);
@@ -231,6 +224,10 @@ void ARM_Dynarmic_64::Run() {
     jit->Run();
 }
 
+void ARM_Dynarmic_64::ExceptionalExit() {
+    jit->ExceptionalExit();
+}
+
 void ARM_Dynarmic_64::Step() {
     cb->InterpreterFallback(jit->GetPC(), 1);
 }
@@ -329,7 +326,17 @@ void ARM_Dynarmic_64::ClearInstructionCache() {
     jit->ClearCache();
 }
 
+void ARM_Dynarmic_64::InvalidateCacheRange(VAddr addr, std::size_t size) {
+    if (!jit) {
+        return;
+    }
+    jit->InvalidateCacheRange(addr, size);
+}
+
 void ARM_Dynarmic_64::ClearExclusiveState() {
+    if (!jit) {
+        return;
+    }
     jit->ClearExclusiveState();
 }
 

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -40,6 +40,7 @@ public:
     void SetPSTATE(u32 pstate) override;
     void Run() override;
     void Step() override;
+    void ExceptionalExit() override;
     VAddr GetTlsAddress() const override;
     void SetTlsAddress(VAddr address) override;
     void SetTPIDR_EL0(u64 value) override;
@@ -55,6 +56,7 @@ public:
     void ClearExclusiveState() override;
 
     void ClearInstructionCache() override;
+    void InvalidateCacheRange(VAddr addr, std::size_t size) override;
     void PageTableChanged(Common::PageTable& new_page_table,
                           std::size_t new_address_space_size_in_bits) override;
 

src/core/core.cpp

@@ -25,13 +25,12 @@
 #include "core/file_sys/sdmc_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/gdbstub/gdbstub.h"
 #include "core/hardware_interrupt_manager.h"
 #include "core/hle/kernel/client_port.h"
+#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/apm/controller.h"
@@ -92,33 +91,43 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
     std::string dir_name;
     std::string filename;
     Common::SplitPath(path, &dir_name, &filename, nullptr);
+
     if (filename == "00") {
         const auto dir = vfs->OpenDirectory(dir_name, FileSys::Mode::Read);
         std::vector<FileSys::VirtualFile> concat;
-        for (u8 i = 0; i < 0x10; ++i) {
-            auto next = dir->GetFile(fmt::format("{:02X}", i));
-            if (next != nullptr)
+
+        for (u32 i = 0; i < 0x10; ++i) {
+            const auto file_name = fmt::format("{:02X}", i);
+            auto next = dir->GetFile(file_name);
+
+            if (next != nullptr) {
                 concat.push_back(std::move(next));
-            else {
-                next = dir->GetFile(fmt::format("{:02x}", i));
-                if (next != nullptr)
-                    concat.push_back(std::move(next));
-                else
+            } else {
+                next = dir->GetFile(file_name);
+
+                if (next == nullptr) {
                     break;
+                }
+
+                concat.push_back(std::move(next));
             }
         }
 
-        if (concat.empty())
+        if (concat.empty()) {
             return nullptr;
+        }
 
-        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(concat, dir->GetName());
+        return FileSys::ConcatenatedVfsFile::MakeConcatenatedFile(std::move(concat),
+                                                                  dir->GetName());
     }
 
-    if (Common::FS::IsDirectory(path))
-        return vfs->OpenFile(path + "/" + "main", FileSys::Mode::Read);
+    if (Common::FS::IsDirectory(path)) {
+        return vfs->OpenFile(path + "/main", FileSys::Mode::Read);
+    }
 
     return vfs->OpenFile(path, FileSys::Mode::Read);
 }
+
 struct System::Impl {
     explicit Impl(System& system)
         : kernel{system}, fs_controller{system}, memory{system},
@@ -145,12 +154,12 @@ struct System::Impl {
     }
 
     ResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
-        LOG_DEBUG(HW_Memory, "initialized OK");
+        LOG_DEBUG(Core, "initialized OK");
 
         device_memory = std::make_unique<Core::DeviceMemory>();
 
         is_multicore = Settings::values.use_multi_core.GetValue();
-        is_async_gpu = is_multicore || Settings::values.use_asynchronous_gpu_emulation.GetValue();
+        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
 
         kernel.SetMulticore(is_multicore);
         cpu_manager.SetMulticore(is_multicore);
@@ -186,11 +195,8 @@ struct System::Impl {
         }
 
         service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
-
-        Service::Init(service_manager, system);
-        GDBStub::DeferStart();
-
-        interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
+        services = std::make_unique<Service::Services>(service_manager, system);
+        interrupt_manager = std::make_unique<Hardware::InterruptManager>(system);
 
         // Initialize time manager, which must happen after kernel is created
         time_manager.Initialize();
@@ -208,9 +214,11 @@ struct System::Impl {
         return ResultStatus::Success;
     }
 
-    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
-                      const std::string& filepath) {
-        app_loader = Loader::GetLoader(GetGameFileFromPath(virtual_filesystem, filepath));
+    ResultStatus Load(System& system, Frontend::EmuWindow& emu_window, const std::string& filepath,
+                      std::size_t program_index) {
+        app_loader = Loader::GetLoader(system, GetGameFileFromPath(virtual_filesystem, filepath),
+                                       program_index);
+
         if (!app_loader) {
             LOG_CRITICAL(Core, "Failed to obtain loader for {}!", filepath);
             return ResultStatus::ErrorGetLoader;
@@ -224,12 +232,12 @@ struct System::Impl {
             return init_result;
         }
 
-        telemetry_session->AddInitialInfo(*app_loader);
+        telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
         auto main_process =
             Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {
-            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
+            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
             Shutdown();
 
             return static_cast<ResultStatus>(static_cast<u32>(ResultStatus::ErrorLoader) +
@@ -237,6 +245,7 @@ struct System::Impl {
         }
         AddGlueRegistrationForProcess(*app_loader, *main_process);
         kernel.MakeCurrentProcess(main_process.get());
+        kernel.InitializeCores();
 
         // Initialize cheat engine
         if (cheat_engine) {
@@ -258,8 +267,7 @@ struct System::Impl {
 
         u64 title_id{0};
         if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
-            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
-                      static_cast<u32>(load_result));
+            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})", load_result);
         }
         perf_stats = std::make_unique<PerfStats>(title_id);
         // Reset counters and set time origin to current frame
@@ -295,19 +303,17 @@ struct System::Impl {
         }
 
         // Shutdown emulation session
-        GDBStub::Shutdown();
-        Service::Shutdown();
+        services.reset();
         service_manager.reset();
         cheat_engine.reset();
         telemetry_session.reset();
-        device_memory.reset();
 
         // Close all CPU/threading state
         cpu_manager.Shutdown();
 
         // Shutdown kernel and core timing
-        kernel.Shutdown();
         core_timing.Shutdown();
+        kernel.Shutdown();
 
         // Close app loader
         app_loader.reset();
@@ -338,7 +344,7 @@ struct System::Impl {
         Service::Glue::ApplicationLaunchProperty launch{};
         launch.title_id = process.GetTitleID();
 
-        FileSys::PatchManager pm{launch.title_id};
+        FileSys::PatchManager pm{launch.title_id, fs_controller, *content_provider};
         launch.version = pm.GetGameVersion().value_or(0);
 
         // TODO(DarkLordZach): When FSController/Game Card Support is added, if
@@ -398,6 +404,9 @@ struct System::Impl {
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
+    /// Services
+    std::unique_ptr<Service::Services> services;
+
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
@@ -413,6 +422,8 @@ struct System::Impl {
     bool is_multicore{};
     bool is_async_gpu{};
 
+    ExecuteProgramCallback execute_program_callback;
+
     std::array<u64, Core::Hardware::NUM_CPU_CORES> dynarmic_ticks{};
     std::array<MicroProfileToken, Core::Hardware::NUM_CPU_CORES> microprofile_dynarmic{};
 };
@@ -444,8 +455,17 @@ void System::InvalidateCpuInstructionCaches() {
     impl->kernel.InvalidateAllInstructionCaches();
 }
 
-System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
-    return impl->Load(*this, emu_window, filepath);
+void System::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
+    impl->kernel.InvalidateCpuInstructionCacheRange(addr, size);
+}
+
+void System::Shutdown() {
+    impl->Shutdown();
+}
+
+System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
+                                  std::size_t program_index) {
+    return impl->Load(*this, emu_window, filepath, program_index);
 }
 
 bool System::IsPoweredOn() const {
@@ -473,11 +493,11 @@ const TelemetrySession& System::TelemetrySession() const {
 }
 
 ARM_Interface& System::CurrentArmInterface() {
-    return impl->kernel.CurrentScheduler().GetCurrentThread()->ArmInterface();
+    return impl->kernel.CurrentPhysicalCore().ArmInterface();
 }
 
 const ARM_Interface& System::CurrentArmInterface() const {
-    return impl->kernel.CurrentScheduler().GetCurrentThread()->ArmInterface();
+    return impl->kernel.CurrentPhysicalCore().ArmInterface();
 }
 
 std::size_t System::CurrentCoreIndex() const {
@@ -486,14 +506,6 @@ std::size_t System::CurrentCoreIndex() const {
     return core;
 }
 
-Kernel::Scheduler& System::CurrentScheduler() {
-    return impl->kernel.CurrentScheduler();
-}
-
-const Kernel::Scheduler& System::CurrentScheduler() const {
-    return impl->kernel.CurrentScheduler();
-}
-
 Kernel::PhysicalCore& System::CurrentPhysicalCore() {
     return impl->kernel.CurrentPhysicalCore();
 }
@@ -502,22 +514,14 @@ const Kernel::PhysicalCore& System::CurrentPhysicalCore() const {
     return impl->kernel.CurrentPhysicalCore();
 }
 
-Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
-    return impl->kernel.Scheduler(core_index);
-}
-
-const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
-    return impl->kernel.Scheduler(core_index);
+/// Gets the global scheduler
+Kernel::GlobalSchedulerContext& System::GlobalSchedulerContext() {
+    return impl->kernel.GlobalSchedulerContext();
 }
 
 /// Gets the global scheduler
-Kernel::GlobalScheduler& System::GlobalScheduler() {
-    return impl->kernel.GlobalScheduler();
-}
-
-/// Gets the global scheduler
-const Kernel::GlobalScheduler& System::GlobalScheduler() const {
-    return impl->kernel.GlobalScheduler();
+const Kernel::GlobalSchedulerContext& System::GlobalSchedulerContext() const {
+    return impl->kernel.GlobalSchedulerContext();
 }
 
 Kernel::Process* System::CurrentProcess() {
@@ -537,15 +541,11 @@ const Kernel::Process* System::CurrentProcess() const {
 }
 
 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    auto* thread = impl->kernel.Scheduler(core_index).GetCurrentThread();
-    ASSERT(thread && !thread->IsHLEThread());
-    return thread->ArmInterface();
+    return impl->kernel.PhysicalCore(core_index).ArmInterface();
 }
 
 const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
-    auto* thread = impl->kernel.Scheduler(core_index).GetCurrentThread();
-    ASSERT(thread && !thread->IsHLEThread());
-    return thread->ArmInterface();
+    return impl->kernel.PhysicalCore(core_index).ArmInterface();
 }
 
 ExclusiveMonitor& System::Monitor() {
@@ -632,7 +632,11 @@ const std::string& System::GetStatusDetails() const {
     return impl->status_details;
 }
 
-Loader::AppLoader& System::GetAppLoader() const {
+Loader::AppLoader& System::GetAppLoader() {
+    return *impl->app_loader;
+}
+
+const Loader::AppLoader& System::GetAppLoader() const {
     return *impl->app_loader;
 }
 
@@ -748,14 +752,6 @@ const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
     return impl->build_id;
 }
 
-System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(*this, emu_window);
-}
-
-void System::Shutdown() {
-    impl->Shutdown();
-}
-
 Service::SM::ServiceManager& System::ServiceManager() {
     return *impl->service_manager;
 }
@@ -786,4 +782,16 @@ bool System::IsMulticore() const {
     return impl->is_multicore;
 }
 
+void System::RegisterExecuteProgramCallback(ExecuteProgramCallback&& callback) {
+    impl->execute_program_callback = std::move(callback);
+}
+
+void System::ExecuteProgram(std::size_t program_index) {
+    if (impl->execute_program_callback) {
+        impl->execute_program_callback(program_index);
+    } else {
+        LOG_CRITICAL(Core, "execute_program_callback must be initialized by the frontend");
+    }
+}
+
 } // namespace Core

src/core/core.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <cstddef>
+#include <functional>
 #include <memory>
 #include <string>
 #include <vector>
@@ -25,11 +26,11 @@ class VfsFilesystem;
 } // namespace FileSys
 
 namespace Kernel {
-class GlobalScheduler;
+class GlobalSchedulerContext;
 class KernelCore;
 class PhysicalCore;
 class Process;
-class Scheduler;
+class KScheduler;
 } // namespace Kernel
 
 namespace Loader {
@@ -144,19 +145,19 @@ public:
      * Run the OS and Application
      * This function will start emulation and run the relevant devices
      */
-    ResultStatus Run();
+    [[nodiscard]] ResultStatus Run();
 
     /**
      * Pause the OS and Application
      * This function will pause emulation and stop the relevant devices
      */
-    ResultStatus Pause();
+    [[nodiscard]] ResultStatus Pause();
 
     /**
      * Step the CPU one instruction
      * @return Result status, indicating whether or not the operation succeeded.
      */
-    ResultStatus SingleStep();
+    [[nodiscard]] ResultStatus SingleStep();
 
     /**
      * Invalidate the CPU instruction caches
@@ -165,6 +166,8 @@ public:
      */
     void InvalidateCpuInstructionCaches();
 
+    void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
+
     /// Shutdown the emulated system.
     void Shutdown();
 
@@ -173,22 +176,24 @@ public:
      * @param emu_window Reference to the host-system window used for video output and keyboard
      *                   input.
      * @param filepath String path to the executable application to load on the host file system.
+     * @param program_index Specifies the index within the container of the program to launch.
      * @returns ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath);
+    [[nodiscard]] ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath,
+                                    std::size_t program_index = 0);
 
     /**
      * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
      * application).
      * @returns True if the emulated system is powered on, otherwise false.
      */
-    bool IsPoweredOn() const;
+    [[nodiscard]] bool IsPoweredOn() const;
 
     /// Gets a reference to the telemetry session for this emulation session.
-    Core::TelemetrySession& TelemetrySession();
+    [[nodiscard]] Core::TelemetrySession& TelemetrySession();
 
     /// Gets a reference to the telemetry session for this emulation session.
-    const Core::TelemetrySession& TelemetrySession() const;
+    [[nodiscard]] const Core::TelemetrySession& TelemetrySession() const;
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
@@ -197,185 +202,166 @@ public:
     void PrepareReschedule(u32 core_index);
 
     /// Gets and resets core performance statistics
-    PerfStatsResults GetAndResetPerfStats();
+    [[nodiscard]] PerfStatsResults GetAndResetPerfStats();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    ARM_Interface& CurrentArmInterface();
+    [[nodiscard]] ARM_Interface& CurrentArmInterface();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    const ARM_Interface& CurrentArmInterface() const;
+    [[nodiscard]] const ARM_Interface& CurrentArmInterface() const;
 
     /// Gets the index of the currently running CPU core
-    std::size_t CurrentCoreIndex() const;
-
-    /// Gets the scheduler for the CPU core that is currently running
-    Kernel::Scheduler& CurrentScheduler();
-
-    /// Gets the scheduler for the CPU core that is currently running
-    const Kernel::Scheduler& CurrentScheduler() const;
+    [[nodiscard]] std::size_t CurrentCoreIndex() const;
 
     /// Gets the physical core for the CPU core that is currently running
-    Kernel::PhysicalCore& CurrentPhysicalCore();
+    [[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore();
 
     /// Gets the physical core for the CPU core that is currently running
-    const Kernel::PhysicalCore& CurrentPhysicalCore() const;
+    [[nodiscard]] const Kernel::PhysicalCore& CurrentPhysicalCore() const;
 
     /// Gets a reference to an ARM interface for the CPU core with the specified index
-    ARM_Interface& ArmInterface(std::size_t core_index);
+    [[nodiscard]] ARM_Interface& ArmInterface(std::size_t core_index);
 
     /// Gets a const reference to an ARM interface from the CPU core with the specified index
-    const ARM_Interface& ArmInterface(std::size_t core_index) const;
+    [[nodiscard]] const ARM_Interface& ArmInterface(std::size_t core_index) const;
 
-    CpuManager& GetCpuManager();
+    /// Gets a reference to the underlying CPU manager.
+    [[nodiscard]] CpuManager& GetCpuManager();
 
-    const CpuManager& GetCpuManager() const;
+    /// Gets a const reference to the underlying CPU manager
+    [[nodiscard]] const CpuManager& GetCpuManager() const;
 
     /// Gets a reference to the exclusive monitor
-    ExclusiveMonitor& Monitor();
+    [[nodiscard]] ExclusiveMonitor& Monitor();
 
     /// Gets a constant reference to the exclusive monitor
-    const ExclusiveMonitor& Monitor() const;
+    [[nodiscard]] const ExclusiveMonitor& Monitor() const;
 
     /// Gets a mutable reference to the system memory instance.
-    Core::Memory::Memory& Memory();
+    [[nodiscard]] Core::Memory::Memory& Memory();
 
     /// Gets a constant reference to the system memory instance.
-    const Core::Memory::Memory& Memory() const;
+    [[nodiscard]] const Core::Memory::Memory& Memory() const;
 
     /// Gets a mutable reference to the GPU interface
-    Tegra::GPU& GPU();
+    [[nodiscard]] Tegra::GPU& GPU();
 
     /// Gets an immutable reference to the GPU interface.
-    const Tegra::GPU& GPU() const;
+    [[nodiscard]] const Tegra::GPU& GPU() const;
 
     /// Gets a mutable reference to the renderer.
-    VideoCore::RendererBase& Renderer();
+    [[nodiscard]] VideoCore::RendererBase& Renderer();
 
     /// Gets an immutable reference to the renderer.
-    const VideoCore::RendererBase& Renderer() const;
-
-    /// Gets the scheduler for the CPU core with the specified index
-    Kernel::Scheduler& Scheduler(std::size_t core_index);
-
-    /// Gets the scheduler for the CPU core with the specified index
-    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
+    [[nodiscard]] const VideoCore::RendererBase& Renderer() const;
 
     /// Gets the global scheduler
-    Kernel::GlobalScheduler& GlobalScheduler();
+    [[nodiscard]] Kernel::GlobalSchedulerContext& GlobalSchedulerContext();
 
     /// Gets the global scheduler
-    const Kernel::GlobalScheduler& GlobalScheduler() const;
+    [[nodiscard]] const Kernel::GlobalSchedulerContext& GlobalSchedulerContext() const;
 
     /// Gets the manager for the guest device memory
-    Core::DeviceMemory& DeviceMemory();
+    [[nodiscard]] Core::DeviceMemory& DeviceMemory();
 
     /// Gets the manager for the guest device memory
-    const Core::DeviceMemory& DeviceMemory() const;
+    [[nodiscard]] const Core::DeviceMemory& DeviceMemory() const;
 
     /// Provides a pointer to the current process
-    Kernel::Process* CurrentProcess();
+    [[nodiscard]] Kernel::Process* CurrentProcess();
 
     /// Provides a constant pointer to the current process.
-    const Kernel::Process* CurrentProcess() const;
+    [[nodiscard]] const Kernel::Process* CurrentProcess() const;
 
     /// Provides a reference to the core timing instance.
-    Timing::CoreTiming& CoreTiming();
+    [[nodiscard]] Timing::CoreTiming& CoreTiming();
 
     /// Provides a constant reference to the core timing instance.
-    const Timing::CoreTiming& CoreTiming() const;
+    [[nodiscard]] const Timing::CoreTiming& CoreTiming() const;
 
     /// Provides a reference to the interrupt manager instance.
-    Core::Hardware::InterruptManager& InterruptManager();
+    [[nodiscard]] Core::Hardware::InterruptManager& InterruptManager();
 
     /// Provides a constant reference to the interrupt manager instance.
-    const Core::Hardware::InterruptManager& InterruptManager() const;
+    [[nodiscard]] const Core::Hardware::InterruptManager& InterruptManager() const;
 
     /// Provides a reference to the kernel instance.
-    Kernel::KernelCore& Kernel();
+    [[nodiscard]] Kernel::KernelCore& Kernel();
 
     /// Provides a constant reference to the kernel instance.
-    const Kernel::KernelCore& Kernel() const;
+    [[nodiscard]] const Kernel::KernelCore& Kernel() const;
 
     /// Provides a reference to the internal PerfStats instance.
-    Core::PerfStats& GetPerfStats();
+    [[nodiscard]] Core::PerfStats& GetPerfStats();
 
     /// Provides a constant reference to the internal PerfStats instance.
-    const Core::PerfStats& GetPerfStats() const;
+    [[nodiscard]] const Core::PerfStats& GetPerfStats() const;
 
     /// Provides a reference to the frame limiter;
-    Core::FrameLimiter& FrameLimiter();
+    [[nodiscard]] Core::FrameLimiter& FrameLimiter();
 
     /// Provides a constant referent to the frame limiter
-    const Core::FrameLimiter& FrameLimiter() const;
+    [[nodiscard]] const Core::FrameLimiter& FrameLimiter() const;
 
     /// Gets the name of the current game
-    Loader::ResultStatus GetGameName(std::string& out) const;
+    [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
 
     void SetStatus(ResultStatus new_status, const char* details);
 
-    const std::string& GetStatusDetails() const;
+    [[nodiscard]] const std::string& GetStatusDetails() const;
 
-    Loader::AppLoader& GetAppLoader() const;
+    [[nodiscard]] Loader::AppLoader& GetAppLoader();
+    [[nodiscard]] const Loader::AppLoader& GetAppLoader() const;
 
-    Service::SM::ServiceManager& ServiceManager();
-    const Service::SM::ServiceManager& ServiceManager() const;
+    [[nodiscard]] Service::SM::ServiceManager& ServiceManager();
+    [[nodiscard]] const Service::SM::ServiceManager& ServiceManager() const;
 
     void SetFilesystem(FileSys::VirtualFilesystem vfs);
 
-    FileSys::VirtualFilesystem GetFilesystem() const;
+    [[nodiscard]] FileSys::VirtualFilesystem GetFilesystem() const;
 
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
                            const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
                            u64 main_region_size);
 
     void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
-
     void SetDefaultAppletFrontendSet();
 
-    Service::AM::Applets::AppletManager& GetAppletManager();
-
-    const Service::AM::Applets::AppletManager& GetAppletManager() const;
+    [[nodiscard]] Service::AM::Applets::AppletManager& GetAppletManager();
+    [[nodiscard]] const Service::AM::Applets::AppletManager& GetAppletManager() const;
 
     void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
 
-    FileSys::ContentProvider& GetContentProvider();
+    [[nodiscard]] FileSys::ContentProvider& GetContentProvider();
+    [[nodiscard]] const FileSys::ContentProvider& GetContentProvider() const;
 
-    const FileSys::ContentProvider& GetContentProvider() const;
-
-    Service::FileSystem::FileSystemController& GetFileSystemController();
-
-    const Service::FileSystem::FileSystemController& GetFileSystemController() const;
+    [[nodiscard]] Service::FileSystem::FileSystemController& GetFileSystemController();
+    [[nodiscard]] const Service::FileSystem::FileSystemController& GetFileSystemController() const;
 
     void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
                                  FileSys::ContentProvider* provider);
 
     void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
 
-    const Reporter& GetReporter() const;
+    [[nodiscard]] const Reporter& GetReporter() const;
 
-    Service::Glue::ARPManager& GetARPManager();
+    [[nodiscard]] Service::Glue::ARPManager& GetARPManager();
+    [[nodiscard]] const Service::Glue::ARPManager& GetARPManager() const;
 
-    const Service::Glue::ARPManager& GetARPManager() const;
+    [[nodiscard]] Service::APM::Controller& GetAPMController();
+    [[nodiscard]] const Service::APM::Controller& GetAPMController() const;
 
-    Service::APM::Controller& GetAPMController();
+    [[nodiscard]] Service::LM::Manager& GetLogManager();
+    [[nodiscard]] const Service::LM::Manager& GetLogManager() const;
 
-    const Service::APM::Controller& GetAPMController() const;
-
-    Service::LM::Manager& GetLogManager();
-
-    const Service::LM::Manager& GetLogManager() const;
-
-    Service::Time::TimeManager& GetTimeManager();
-
-    const Service::Time::TimeManager& GetTimeManager() const;
+    [[nodiscard]] Service::Time::TimeManager& GetTimeManager();
+    [[nodiscard]] const Service::Time::TimeManager& GetTimeManager() const;
 
     void SetExitLock(bool locked);
-
-    bool GetExitLock() const;
+    [[nodiscard]] bool GetExitLock() const;
 
     void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
-
-    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
+    [[nodiscard]] const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
 
     /// Register a host thread as an emulated CPU Core.
     void RegisterCoreThread(std::size_t id);
@@ -390,19 +376,28 @@ public:
     void ExitDynarmicProfile();
 
     /// Tells if system is running on multicore.
-    bool IsMulticore() const;
+    [[nodiscard]] bool IsMulticore() const;
+
+    /// Type used for the frontend to designate a callback for System to re-launch the application
+    /// using a specified program index.
+    using ExecuteProgramCallback = std::function<void(std::size_t)>;
+
+    /**
+     * Registers a callback from the frontend for System to re-launch the application using a
+     * specified program index.
+     * @param callback Callback from the frontend to relaunch the application.
+     */
+    void RegisterExecuteProgramCallback(ExecuteProgramCallback&& callback);
+
+    /**
+     * Instructs the frontend to re-launch the application using the specified program_index.
+     * @param program_index Specifies the index within the application of the program to launch.
+     */
+    void ExecuteProgram(std::size_t program_index);
 
 private:
     System();
 
-    /**
-     * Initialize the emulated system.
-     * @param emu_window Reference to the host-system window used for video output and keyboard
-     *                   input.
-     * @return ResultStatus code, indicating if the operation succeeded.
-     */
-    ResultStatus Init(Frontend::EmuWindow& emu_window);
-
     struct Impl;
     std::unique_ptr<Impl> impl;
 

src/core/core_timing.cpp

@@ -49,6 +49,7 @@ void CoreTiming::ThreadEntry(CoreTiming& instance) {
     Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
     instance.on_thread_init();
     instance.ThreadLoop();
+    MicroProfileOnThreadExit();
 }
 
 void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {

src/core/core_timing.h

@@ -27,8 +27,8 @@ using TimedCallback =
 
 /// Contains the characteristics of a particular event.
 struct EventType {
-    EventType(TimedCallback&& callback, std::string&& name)
-        : callback{std::move(callback)}, name{std::move(name)} {}
+    explicit EventType(TimedCallback&& callback_, std::string&& name_)
+        : callback{std::move(callback_)}, name{std::move(name_)} {}
 
     /// The event's callback function.
     TimedCallback callback;
@@ -67,8 +67,8 @@ public:
     void Shutdown();
 
     /// Sets if emulation is multicore or single core, must be set before Initialize
-    void SetMulticore(bool is_multicore) {
-        this->is_multicore = is_multicore;
+    void SetMulticore(bool is_multicore_) {
+        is_multicore = is_multicore_;
     }
 
     /// Check if it's using host timing.

src/core/cpu_manager.cpp

@@ -4,15 +4,15 @@
 
 #include "common/fiber.h"
 #include "common/microprofile.h"
+#include "common/scope_exit.h"
 #include "common/thread.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/cpu_manager.h"
-#include "core/gdbstub/gdbstub.h"
+#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
-#include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
 #include "video_core/gpu.h"
 
@@ -109,28 +109,26 @@ void* CpuManager::GetStartFuncParamater() {
 
 void CpuManager::MultiCoreRunGuestThread() {
     auto& kernel = system.Kernel();
-    {
-        auto& sched = kernel.CurrentScheduler();
-        sched.OnThreadStart();
-    }
+    kernel.CurrentScheduler()->OnThreadStart();
+    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
+    auto& host_context = thread->GetHostContext();
+    host_context->SetRewindPoint(GuestRewindFunction, this);
     MultiCoreRunGuestLoop();
 }
 
 void CpuManager::MultiCoreRunGuestLoop() {
     auto& kernel = system.Kernel();
-    auto* thread = kernel.CurrentScheduler().GetCurrentThread();
+
     while (true) {
         auto* physical_core = &kernel.CurrentPhysicalCore();
-        auto& arm_interface = thread->ArmInterface();
         system.EnterDynarmicProfile();
         while (!physical_core->IsInterrupted()) {
-            arm_interface.Run();
+            physical_core->Run();
             physical_core = &kernel.CurrentPhysicalCore();
         }
         system.ExitDynarmicProfile();
-        arm_interface.ClearExclusiveState();
-        auto& scheduler = kernel.CurrentScheduler();
-        scheduler.TryDoContextSwitch();
+        physical_core->ArmInterface().ClearExclusiveState();
+        kernel.CurrentScheduler()->RescheduleCurrentCore();
     }
 }
 
@@ -139,25 +137,21 @@ void CpuManager::MultiCoreRunIdleThread() {
     while (true) {
         auto& physical_core = kernel.CurrentPhysicalCore();
         physical_core.Idle();
-        auto& scheduler = kernel.CurrentScheduler();
-        scheduler.TryDoContextSwitch();
+        kernel.CurrentScheduler()->RescheduleCurrentCore();
     }
 }
 
 void CpuManager::MultiCoreRunSuspendThread() {
     auto& kernel = system.Kernel();
-    {
-        auto& sched = kernel.CurrentScheduler();
-        sched.OnThreadStart();
-    }
+    kernel.CurrentScheduler()->OnThreadStart();
     while (true) {
         auto core = kernel.GetCurrentHostThreadID();
-        auto& scheduler = kernel.CurrentScheduler();
+        auto& scheduler = *kernel.CurrentScheduler();
         Kernel::Thread* current_thread = scheduler.GetCurrentThread();
         Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[core].host_context);
         ASSERT(scheduler.ContextSwitchPending());
         ASSERT(core == kernel.GetCurrentHostThreadID());
-        scheduler.TryDoContextSwitch();
+        scheduler.RescheduleCurrentCore();
     }
 }
 
@@ -205,32 +199,31 @@ void CpuManager::MultiCorePause(bool paused) {
 
 void CpuManager::SingleCoreRunGuestThread() {
     auto& kernel = system.Kernel();
-    {
-        auto& sched = kernel.CurrentScheduler();
-        sched.OnThreadStart();
-    }
+    kernel.CurrentScheduler()->OnThreadStart();
+    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
+    auto& host_context = thread->GetHostContext();
+    host_context->SetRewindPoint(GuestRewindFunction, this);
     SingleCoreRunGuestLoop();
 }
 
 void CpuManager::SingleCoreRunGuestLoop() {
     auto& kernel = system.Kernel();
-    auto* thread = kernel.CurrentScheduler().GetCurrentThread();
+    auto* thread = kernel.CurrentScheduler()->GetCurrentThread();
     while (true) {
         auto* physical_core = &kernel.CurrentPhysicalCore();
-        auto& arm_interface = thread->ArmInterface();
         system.EnterDynarmicProfile();
         if (!physical_core->IsInterrupted()) {
-            arm_interface.Run();
+            physical_core->Run();
             physical_core = &kernel.CurrentPhysicalCore();
         }
         system.ExitDynarmicProfile();
         thread->SetPhantomMode(true);
         system.CoreTiming().Advance();
         thread->SetPhantomMode(false);
-        arm_interface.ClearExclusiveState();
+        physical_core->ArmInterface().ClearExclusiveState();
         PreemptSingleCore();
         auto& scheduler = kernel.Scheduler(current_core);
-        scheduler.TryDoContextSwitch();
+        scheduler.RescheduleCurrentCore();
     }
 }
 
@@ -242,51 +235,53 @@ void CpuManager::SingleCoreRunIdleThread() {
         system.CoreTiming().AddTicks(1000U);
         idle_count++;
         auto& scheduler = physical_core.Scheduler();
-        scheduler.TryDoContextSwitch();
+        scheduler.RescheduleCurrentCore();
     }
 }
 
 void CpuManager::SingleCoreRunSuspendThread() {
     auto& kernel = system.Kernel();
-    {
-        auto& sched = kernel.CurrentScheduler();
-        sched.OnThreadStart();
-    }
+    kernel.CurrentScheduler()->OnThreadStart();
     while (true) {
         auto core = kernel.GetCurrentHostThreadID();
-        auto& scheduler = kernel.CurrentScheduler();
+        auto& scheduler = *kernel.CurrentScheduler();
         Kernel::Thread* current_thread = scheduler.GetCurrentThread();
         Common::Fiber::YieldTo(current_thread->GetHostContext(), core_data[0].host_context);
         ASSERT(scheduler.ContextSwitchPending());
         ASSERT(core == kernel.GetCurrentHostThreadID());
-        scheduler.TryDoContextSwitch();
+        scheduler.RescheduleCurrentCore();
     }
 }
 
 void CpuManager::PreemptSingleCore(bool from_running_enviroment) {
-    std::size_t old_core = current_core;
-    auto& scheduler = system.Kernel().Scheduler(old_core);
-    Kernel::Thread* current_thread = scheduler.GetCurrentThread();
-    if (idle_count >= 4 || from_running_enviroment) {
-        if (!from_running_enviroment) {
-            system.CoreTiming().Idle();
+    {
+        auto& scheduler = system.Kernel().Scheduler(current_core);
+        Kernel::Thread* current_thread = scheduler.GetCurrentThread();
+        if (idle_count >= 4 || from_running_enviroment) {
+            if (!from_running_enviroment) {
+                system.CoreTiming().Idle();
+                idle_count = 0;
+            }
+            current_thread->SetPhantomMode(true);
+            system.CoreTiming().Advance();
+            current_thread->SetPhantomMode(false);
+        }
+        current_core.store((current_core + 1) % Core::Hardware::NUM_CPU_CORES);
+        system.CoreTiming().ResetTicks();
+        scheduler.Unload(scheduler.GetCurrentThread());
+
+        auto& next_scheduler = system.Kernel().Scheduler(current_core);
+        Common::Fiber::YieldTo(current_thread->GetHostContext(), next_scheduler.ControlContext());
+    }
+
+    // May have changed scheduler
+    {
+        auto& scheduler = system.Kernel().Scheduler(current_core);
+        scheduler.Reload(scheduler.GetCurrentThread());
+        auto* currrent_thread2 = scheduler.GetCurrentThread();
+        if (!currrent_thread2->IsIdleThread()) {
             idle_count = 0;
         }
-        current_thread->SetPhantomMode(true);
-        system.CoreTiming().Advance();
-        current_thread->SetPhantomMode(false);
-    }
-    current_core.store((current_core + 1) % Core::Hardware::NUM_CPU_CORES);
-    system.CoreTiming().ResetTicks();
-    scheduler.Unload();
-    auto& next_scheduler = system.Kernel().Scheduler(current_core);
-    Common::Fiber::YieldTo(current_thread->GetHostContext(), next_scheduler.ControlContext());
-    /// May have changed scheduler
-    auto& current_scheduler = system.Kernel().Scheduler(current_core);
-    current_scheduler.Reload();
-    auto* currrent_thread2 = current_scheduler.GetCurrentThread();
-    if (!currrent_thread2->IsIdleThread()) {
-        idle_count = 0;
     }
 }
 
@@ -343,6 +338,16 @@ void CpuManager::RunThread(std::size_t core) {
     data.initialized = true;
     const bool sc_sync = !is_async_gpu && !is_multicore;
     bool sc_sync_first_use = sc_sync;
+
+    // Cleanup
+    SCOPE_EXIT({
+        data.host_context->Exit();
+        data.enter_barrier.reset();
+        data.exit_barrier.reset();
+        data.initialized = false;
+        MicroProfileOnThreadExit();
+    });
+
     /// Running
     while (running_mode) {
         data.is_running = false;
@@ -351,8 +356,13 @@ void CpuManager::RunThread(std::size_t core) {
             system.GPU().ObtainContext();
             sc_sync_first_use = false;
         }
-        auto& scheduler = system.Kernel().CurrentScheduler();
-        Kernel::Thread* current_thread = scheduler.GetCurrentThread();
+
+        // Abort if emulation was killed before the session really starts
+        if (!system.IsPoweredOn()) {
+            return;
+        }
+
+        auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
         data.is_running = true;
         Common::Fiber::YieldTo(data.host_context, current_thread->GetHostContext());
         data.is_running = false;
@@ -360,13 +370,6 @@ void CpuManager::RunThread(std::size_t core) {
         data.exit_barrier->Wait();
         data.is_paused = false;
     }
-    /// Time to cleanup
-    data.host_context->Exit();
-    data.enter_barrier.reset();
-    data.exit_barrier.reset();
-    data.initialized = false;
-
-    MicroProfileOnThreadExit();
 }
 
 } // namespace Core

src/core/crypto/key_manager.cpp

@@ -143,6 +143,7 @@ u64 GetSignatureTypeDataSize(SignatureType type) {
         return 0x3C;
     }
     UNREACHABLE();
+    return 0;
 }
 
 u64 GetSignatureTypePaddingSize(SignatureType type) {
@@ -157,6 +158,7 @@ u64 GetSignatureTypePaddingSize(SignatureType type) {
         return 0x40;
     }
     UNREACHABLE();
+    return 0;
 }
 
 SignatureType Ticket::GetSignatureType() const {
@@ -169,8 +171,7 @@ SignatureType Ticket::GetSignatureType() const {
     if (const auto* ticket = std::get_if<ECDSATicket>(&data)) {
         return ticket->sig_type;
     }
-
-    UNREACHABLE();
+    throw std::bad_variant_access{};
 }
 
 TicketData& Ticket::GetData() {
@@ -183,8 +184,7 @@ TicketData& Ticket::GetData() {
     if (auto* ticket = std::get_if<ECDSATicket>(&data)) {
         return ticket->data;
     }
-
-    UNREACHABLE();
+    throw std::bad_variant_access{};
 }
 
 const TicketData& Ticket::GetData() const {
@@ -197,8 +197,7 @@ const TicketData& Ticket::GetData() const {
     if (const auto* ticket = std::get_if<ECDSATicket>(&data)) {
         return ticket->data;
     }
-
-    UNREACHABLE();
+    throw std::bad_variant_access{};
 }
 
 u64 Ticket::GetSize() const {

src/core/file_sys/card_image.cpp

@@ -29,7 +29,7 @@ constexpr std::array partition_names{
     "logo",
 };
 
-XCI::XCI(VirtualFile file_)
+XCI::XCI(VirtualFile file_, std::size_t program_index)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
       partitions(partition_names.size()),
       partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
@@ -62,7 +62,8 @@ XCI::XCI(VirtualFile file_)
     }
 
     secure_partition = std::make_shared<NSP>(
-        main_hfs.GetFile(partition_names[static_cast<std::size_t>(XCIPartition::Secure)]));
+        main_hfs.GetFile(partition_names[static_cast<std::size_t>(XCIPartition::Secure)]),
+        program_index);
 
     ncas = secure_partition->GetNCAsCollapsed();
     program =

src/core/file_sys/card_image.h

@@ -78,7 +78,7 @@ enum class XCIPartition : u8 { Update, Normal, Secure, Logo };
 
 class XCI : public ReadOnlyVfsDirectory {
 public:
-    explicit XCI(VirtualFile file);
+    explicit XCI(VirtualFile file, std::size_t program_index = 0);
     ~XCI() override;
 
     Loader::ResultStatus GetStatus() const;

src/core/file_sys/common_funcs.h

@@ -0,0 +1,56 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace FileSys {
+
+constexpr u64 AOC_TITLE_ID_MASK = 0x7FF;
+constexpr u64 AOC_TITLE_ID_OFFSET = 0x1000;
+constexpr u64 BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
+
+/**
+ * Gets the base title ID from a given title ID.
+ *
+ * @param title_id The title ID.
+ * @returns The base title ID.
+ */
+[[nodiscard]] constexpr u64 GetBaseTitleID(u64 title_id) {
+    return title_id & BASE_TITLE_ID_MASK;
+}
+
+/**
+ * Gets the base title ID with a program index offset from a given title ID.
+ *
+ * @param title_id The title ID.
+ * @param program_index The program index.
+ * @returns The base title ID with a program index offset.
+ */
+[[nodiscard]] constexpr u64 GetBaseTitleIDWithProgramIndex(u64 title_id, u64 program_index) {
+    return GetBaseTitleID(title_id) + program_index;
+}
+
+/**
+ * Gets the AOC (Add-On Content) base title ID from a given title ID.
+ *
+ * @param title_id The title ID.
+ * @returns The AOC base title ID.
+ */
+[[nodiscard]] constexpr u64 GetAOCBaseTitleID(u64 title_id) {
+    return GetBaseTitleID(title_id) + AOC_TITLE_ID_OFFSET;
+}
+
+/**
+ * Gets the AOC (Add-On Content) ID from a given AOC title ID.
+ *
+ * @param aoc_title_id The AOC title ID.
+ * @returns The AOC ID.
+ */
+[[nodiscard]] constexpr u64 GetAOCID(u64 aoc_title_id) {
+    return aoc_title_id & AOC_TITLE_ID_MASK;
+}
+
+} // namespace FileSys

src/core/file_sys/content_archive.cpp

@@ -43,17 +43,17 @@ static_assert(sizeof(IVFCLevel) == 0x18, "IVFCLevel has incorrect size.");
 struct IVFCHeader {
     u32_le magic;
     u32_le magic_number;
-    INSERT_UNION_PADDING_BYTES(8);
+    INSERT_PADDING_BYTES_NOINIT(8);
     std::array<IVFCLevel, 6> levels;
-    INSERT_UNION_PADDING_BYTES(64);
+    INSERT_PADDING_BYTES_NOINIT(64);
 };
 static_assert(sizeof(IVFCHeader) == 0xE0, "IVFCHeader has incorrect size.");
 
 struct NCASectionHeaderBlock {
-    INSERT_UNION_PADDING_BYTES(3);
+    INSERT_PADDING_BYTES_NOINIT(3);
     NCASectionFilesystemType filesystem_type;
     NCASectionCryptoType crypto_type;
-    INSERT_UNION_PADDING_BYTES(3);
+    INSERT_PADDING_BYTES_NOINIT(3);
 };
 static_assert(sizeof(NCASectionHeaderBlock) == 0x8, "NCASectionHeaderBlock has incorrect size.");
 
@@ -61,7 +61,7 @@ struct NCASectionRaw {
     NCASectionHeaderBlock header;
     std::array<u8, 0x138> block_data;
     std::array<u8, 0x8> section_ctr;
-    INSERT_UNION_PADDING_BYTES(0xB8);
+    INSERT_PADDING_BYTES_NOINIT(0xB8);
 };
 static_assert(sizeof(NCASectionRaw) == 0x200, "NCASectionRaw has incorrect size.");
 
@@ -69,19 +69,19 @@ struct PFS0Superblock {
     NCASectionHeaderBlock header_block;
     std::array<u8, 0x20> hash;
     u32_le size;
-    INSERT_UNION_PADDING_BYTES(4);
+    INSERT_PADDING_BYTES_NOINIT(4);
     u64_le hash_table_offset;
     u64_le hash_table_size;
     u64_le pfs0_header_offset;
     u64_le pfs0_size;
-    INSERT_UNION_PADDING_BYTES(0x1B0);
+    INSERT_PADDING_BYTES_NOINIT(0x1B0);
 };
 static_assert(sizeof(PFS0Superblock) == 0x200, "PFS0Superblock has incorrect size.");
 
 struct RomFSSuperblock {
     NCASectionHeaderBlock header_block;
     IVFCHeader ivfc;
-    INSERT_UNION_PADDING_BYTES(0x118);
+    INSERT_PADDING_BYTES_NOINIT(0x118);
 };
 static_assert(sizeof(RomFSSuperblock) == 0x200, "RomFSSuperblock has incorrect size.");
 
@@ -89,19 +89,19 @@ struct BKTRHeader {
     u64_le offset;
     u64_le size;
     u32_le magic;
-    INSERT_UNION_PADDING_BYTES(0x4);
+    INSERT_PADDING_BYTES_NOINIT(0x4);
     u32_le number_entries;
-    INSERT_UNION_PADDING_BYTES(0x4);
+    INSERT_PADDING_BYTES_NOINIT(0x4);
 };
 static_assert(sizeof(BKTRHeader) == 0x20, "BKTRHeader has incorrect size.");
 
 struct BKTRSuperblock {
     NCASectionHeaderBlock header_block;
     IVFCHeader ivfc;
-    INSERT_UNION_PADDING_BYTES(0x18);
+    INSERT_PADDING_BYTES_NOINIT(0x18);
     BKTRHeader relocation;
     BKTRHeader subsection;
-    INSERT_UNION_PADDING_BYTES(0xC0);
+    INSERT_PADDING_BYTES_NOINIT(0xC0);
 };
 static_assert(sizeof(BKTRSuperblock) == 0x200, "BKTRSuperblock has incorrect size.");
 
@@ -410,8 +410,9 @@ u8 NCA::GetCryptoRevision() const {
 std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type) const {
     const auto master_key_id = GetCryptoRevision();
 
-    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index))
-        return {};
+    if (!keys.HasKey(Core::Crypto::S128KeyType::KeyArea, master_key_id, header.key_index)) {
+        return std::nullopt;
+    }
 
     std::vector<u8> key_area(header.key_area.begin(), header.key_area.end());
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -420,15 +421,17 @@ std::optional<Core::Crypto::Key128> NCA::GetKeyAreaKey(NCASectionCryptoType type
     cipher.Transcode(key_area.data(), key_area.size(), key_area.data(), Core::Crypto::Op::Decrypt);
 
     Core::Crypto::Key128 out;
-    if (type == NCASectionCryptoType::XTS)
+    if (type == NCASectionCryptoType::XTS) {
         std::copy(key_area.begin(), key_area.begin() + 0x10, out.begin());
-    else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR)
+    } else if (type == NCASectionCryptoType::CTR || type == NCASectionCryptoType::BKTR) {
         std::copy(key_area.begin() + 0x20, key_area.begin() + 0x30, out.begin());
-    else
+    } else {
         LOG_CRITICAL(Crypto, "Called GetKeyAreaKey on invalid NCASectionCryptoType type={:02X}",
-                     static_cast<u8>(type));
+                     type);
+    }
+
     u128 out_128{};
-    memcpy(out_128.data(), out.data(), 16);
+    std::memcpy(out_128.data(), out.data(), sizeof(u128));
     LOG_TRACE(Crypto, "called with crypto_rev={:02X}, kak_index={:02X}, key={:016X}{:016X}",
               master_key_id, header.key_index, out_128[1], out_128[0]);
 
@@ -507,7 +510,7 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
         // TODO(DarkLordZach): Find a test case for XTS-encrypted NCAs
     default:
         LOG_ERROR(Crypto, "called with unhandled crypto type={:02X}",
-                  static_cast<u8>(s_header.raw.header.crypto_type));
+                  s_header.raw.header.crypto_type);
         return nullptr;
     }
 }
@@ -516,15 +519,17 @@ Loader::ResultStatus NCA::GetStatus() const {
     return status;
 }
 
-std::vector<std::shared_ptr<VfsFile>> NCA::GetFiles() const {
-    if (status != Loader::ResultStatus::Success)
+std::vector<VirtualFile> NCA::GetFiles() const {
+    if (status != Loader::ResultStatus::Success) {
         return {};
+    }
     return files;
 }
 
-std::vector<std::shared_ptr<VfsDirectory>> NCA::GetSubdirectories() const {
-    if (status != Loader::ResultStatus::Success)
+std::vector<VirtualDir> NCA::GetSubdirectories() const {
+    if (status != Loader::ResultStatus::Success) {
         return {};
+    }
     return dirs;
 }
 
@@ -532,7 +537,7 @@ std::string NCA::GetName() const {
     return file->GetName();
 }
 
-std::shared_ptr<VfsDirectory> NCA::GetParentDirectory() const {
+VirtualDir NCA::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 

src/core/file_sys/content_archive.h

@@ -82,7 +82,7 @@ struct NCAHeader {
 };
 static_assert(sizeof(NCAHeader) == 0x400, "NCAHeader has incorrect size.");
 
-inline bool IsDirectoryExeFS(const std::shared_ptr<VfsDirectory>& pfs) {
+inline bool IsDirectoryExeFS(const VirtualDir& pfs) {
     // According to switchbrew, an exefs must only contain these two files:
     return pfs->GetFile("main") != nullptr && pfs->GetFile("main.npdm") != nullptr;
 }
@@ -104,10 +104,10 @@ public:
 
     Loader::ResultStatus GetStatus() const;
 
-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;
     std::string GetName() const override;
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    VirtualDir GetParentDirectory() const override;
 
     NCAContentType GetType() const;
     u64 GetTitleId() const;

src/core/file_sys/nca_patch.cpp

@@ -51,8 +51,8 @@ std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockTyp
             low = mid + 1;
         }
     }
-
     UNREACHABLE_MSG("Offset could not be found in BKTR block.");
+    return {0, 0};
 }
 } // Anonymous namespace
 
@@ -191,7 +191,7 @@ bool BKTR::Resize(std::size_t new_size) {
     return false;
 }
 
-std::shared_ptr<VfsDirectory> BKTR::GetContainingDirectory() const {
+VirtualDir BKTR::GetContainingDirectory() const {
     return base_romfs->GetContainingDirectory();
 }
 

src/core/file_sys/nca_patch.h

@@ -106,7 +106,7 @@ public:
 
     bool Resize(std::size_t new_size) override;
 
-    std::shared_ptr<VfsDirectory> GetContainingDirectory() const override;
+    VirtualDir GetContainingDirectory() const override;
 
     bool IsWritable() const override;
 

src/core/file_sys/patch_manager.cpp

@@ -12,6 +12,7 @@
 #include "common/logging/log.h"
 #include "common/string_util.h"
 #include "core/core.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/ips_layer.h"
@@ -30,7 +31,6 @@ namespace FileSys {
 namespace {
 
 constexpr u32 SINGLE_BYTE_MODULUS = 0x100;
-constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
 
 constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
     "main",    "main.npdm", "rtld",    "sdk",     "subsdk0", "subsdk1", "subsdk2",
@@ -112,7 +112,10 @@ bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
 }
 } // Anonymous namespace
 
-PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
+PatchManager::PatchManager(u64 title_id_,
+                           const Service::FileSystem::FileSystemController& fs_controller_,
+                           const ContentProvider& content_provider_)
+    : title_id{title_id_}, fs_controller{fs_controller_}, content_provider{content_provider_} {}
 
 PatchManager::~PatchManager() = default;
 
@@ -128,34 +131,30 @@ VirtualDir PatchManager::PatchExeFS(VirtualDir exefs) const {
 
     if (Settings::values.dump_exefs) {
         LOG_INFO(Loader, "Dumping ExeFS for title_id={:016X}", title_id);
-        const auto dump_dir =
-            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
+        const auto dump_dir = fs_controller.GetModificationDumpRoot(title_id);
         if (dump_dir != nullptr) {
             const auto exefs_dir = GetOrCreateDirectoryRelative(dump_dir, "/exefs");
             VfsRawCopyD(exefs, exefs_dir);
         }
     }
 
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
-
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
         std::find(disabled.cbegin(), disabled.cend(), "Update") != disabled.cend();
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntry(update_tid, ContentRecordType::Program);
+    const auto update = content_provider.GetEntry(update_tid, ContentRecordType::Program);
 
     if (!update_disabled && update != nullptr && update->GetExeFS() != nullptr &&
         update->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
         LOG_INFO(Loader, "    ExeFS: Update ({}) applied successfully",
-                 FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                 FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
         exefs = update->GetExeFS();
     }
 
     // LayeredExeFS
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir != nullptr && load_dir->GetSize() > 0) {
         auto patch_dirs = load_dir->GetSubdirectories();
         std::sort(
@@ -241,8 +240,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     if (Settings::values.dump_nso) {
         LOG_INFO(Loader, "Dumping NSO for name={}, build_id={}, title_id={:016X}", name, build_id,
                  title_id);
-        const auto dump_dir =
-            Core::System::GetInstance().GetFileSystemController().GetModificationDumpRoot(title_id);
+        const auto dump_dir = fs_controller.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));
@@ -254,8 +252,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
 
     LOG_INFO(Loader, "Patching NSO for name={}, build_id={}", name, build_id);
 
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return nso;
@@ -298,8 +295,7 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
 
     LOG_INFO(Loader, "Querying NSO patch existence for build_id={}", build_id);
 
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return false;
@@ -313,8 +309,8 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
 }
 
 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
-    const Core::System& system, const BuildID& build_id_) const {
-    const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
+    const BuildID& build_id_) const {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
         return {};
@@ -347,9 +343,9 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
     return out;
 }
 
-static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type) {
-    const auto load_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType type,
+                           const Service::FileSystem::FileSystemController& fs_controller) {
+    const auto load_dir = fs_controller.GetModificationLoadRoot(title_id);
     if ((type != ContentRecordType::Program && type != ContentRecordType::Data) ||
         load_dir == nullptr || load_dir->GetSize() <= 0) {
         return;
@@ -411,19 +407,19 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     const auto log_string = fmt::format("Patching RomFS for title_id={:016X}, type={:02X}",
                                         title_id, static_cast<u8>(type));
 
-    if (type == ContentRecordType::Program || type == ContentRecordType::Data)
+    if (type == ContentRecordType::Program || type == ContentRecordType::Data) {
         LOG_INFO(Loader, "{}", log_string);
-    else
+    } else {
         LOG_DEBUG(Loader, "{}", log_string);
+    }
 
-    if (romfs == nullptr)
+    if (romfs == nullptr) {
         return romfs;
-
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
+    }
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    const auto update = installed.GetEntryRaw(update_tid, type);
+    const auto update = content_provider.GetEntryRaw(update_tid, type);
 
     const auto& disabled = Settings::values.disabled_addons[title_id];
     const auto update_disabled =
@@ -434,7 +430,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
         if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
             new_nca->GetRomFS() != nullptr) {
             LOG_INFO(Loader, "    RomFS: Update ({}) applied successfully",
-                     FormatTitleVersion(installed.GetEntryVersion(update_tid).value_or(0)));
+                     FormatTitleVersion(content_provider.GetEntryVersion(update_tid).value_or(0)));
             romfs = new_nca->GetRomFS();
         }
     } else if (!update_disabled && update_raw != nullptr) {
@@ -447,7 +443,7 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     }
 
     // LayeredFS
-    ApplyLayeredFS(romfs, title_id, type);
+    ApplyLayeredFS(romfs, title_id, type, fs_controller);
 
     return romfs;
 }
@@ -458,12 +454,11 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     }
 
     std::map<std::string, std::string, std::less<>> out;
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto& disabled = Settings::values.disabled_addons[title_id];
 
     // Game Updates
     const auto update_tid = GetUpdateTitleID(title_id);
-    PatchManager update{update_tid};
+    PatchManager update{update_tid, fs_controller, content_provider};
     const auto metadata = update.GetControlMetadata();
     const auto& nacp = metadata.first;
 
@@ -474,8 +469,8 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     if (nacp != nullptr) {
         out.insert_or_assign(update_label, nacp->GetVersionString());
     } else {
-        if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-            const auto meta_ver = installed.GetEntryVersion(update_tid);
+        if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
+            const auto meta_ver = content_provider.GetEntryVersion(update_tid);
             if (meta_ver.value_or(0) == 0) {
                 out.insert_or_assign(update_label, "");
             } else {
@@ -487,8 +482,7 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     }
 
     // General Mods (LayeredFS and IPS)
-    const auto mod_dir =
-        Core::System::GetInstance().GetFileSystemController().GetModificationLoadRoot(title_id);
+    const auto mod_dir = fs_controller.GetModificationLoadRoot(title_id);
     if (mod_dir != nullptr && mod_dir->GetSize() > 0) {
         for (const auto& mod : mod_dir->GetSubdirectories()) {
             std::string types;
@@ -532,13 +526,15 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
     }
 
     // DLC
-    const auto dlc_entries = installed.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
+    const auto dlc_entries =
+        content_provider.ListEntriesFilter(TitleType::AOC, ContentRecordType::Data);
     std::vector<ContentProviderEntry> 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) {
-                     return (entry.title_id & DLC_BASE_TITLE_ID_MASK) == title_id &&
-                            installed.GetEntry(entry)->GetStatus() == Loader::ResultStatus::Success;
+                 [this](const ContentProviderEntry& entry) {
+                     return GetBaseTitleID(entry.title_id) == title_id &&
+                            content_provider.GetEntry(entry)->GetStatus() ==
+                                Loader::ResultStatus::Success;
                  });
     if (!dlc_match.empty()) {
         // Ensure sorted so DLC IDs show in order.
@@ -559,19 +555,16 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
 }
 
 std::optional<u32> PatchManager::GetGameVersion() const {
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto update_tid = GetUpdateTitleID(title_id);
-    if (installed.HasEntry(update_tid, ContentRecordType::Program)) {
-        return installed.GetEntryVersion(update_tid);
+    if (content_provider.HasEntry(update_tid, ContentRecordType::Program)) {
+        return content_provider.GetEntryVersion(update_tid);
     }
 
-    return installed.GetEntryVersion(title_id);
+    return content_provider.GetEntryVersion(title_id);
 }
 
 PatchManager::Metadata PatchManager::GetControlMetadata() const {
-    const auto& installed = Core::System::GetInstance().GetContentProvider();
-
-    const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
+    const auto base_control_nca = content_provider.GetEntry(title_id, ContentRecordType::Control);
     if (base_control_nca == nullptr) {
         return {};
     }

src/core/file_sys/patch_manager.h

@@ -17,8 +17,13 @@ namespace Core {
 class System;
 }
 
+namespace Service::FileSystem {
+class FileSystemController;
+}
+
 namespace FileSys {
 
+class ContentProvider;
 class NCA;
 class NACP;
 
@@ -29,7 +34,9 @@ public:
     using Metadata = std::pair<std::unique_ptr<NACP>, VirtualFile>;
     using PatchVersionNames = std::map<std::string, std::string, std::less<>>;
 
-    explicit PatchManager(u64 title_id);
+    explicit PatchManager(u64 title_id_,
+                          const Service::FileSystem::FileSystemController& fs_controller_,
+                          const ContentProvider& content_provider_);
     ~PatchManager();
 
     [[nodiscard]] u64 GetTitleID() const;
@@ -50,7 +57,7 @@ public:
 
     // Creates a CheatList object with all
     [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const Core::System& system, const BuildID& build_id) const;
+        const BuildID& build_id) const;
 
     // Currently tracked RomFS patches:
     // - Game Updates
@@ -80,6 +87,8 @@ private:
                                                           const std::string& build_id) const;
 
     u64 title_id;
+    const Service::FileSystem::FileSystemController& fs_controller;
+    const ContentProvider& content_provider;
 };
 
 } // namespace FileSys

src/core/file_sys/registered_cache.cpp

@@ -105,7 +105,8 @@ ContentRecordType GetCRTypeFromNCAType(NCAContentType type) {
         // TODO(DarkLordZach): Peek at NCA contents to differentiate Manual and Legal.
         return ContentRecordType::HtmlDocument;
     default:
-        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", static_cast<u8>(type));
+        UNREACHABLE_MSG("Invalid NCAContentType={:02X}", type);
+        return ContentRecordType{};
     }
 }
 

src/core/file_sys/registered_cache.h

@@ -67,18 +67,18 @@ public:
     virtual void Refresh() = 0;
 
     virtual bool HasEntry(u64 title_id, ContentRecordType type) const = 0;
-    virtual bool HasEntry(ContentProviderEntry entry) const;
+    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;
+    VirtualFile GetEntryUnparsed(ContentProviderEntry entry) const;
 
     virtual VirtualFile GetEntryRaw(u64 title_id, ContentRecordType type) const = 0;
-    virtual VirtualFile GetEntryRaw(ContentProviderEntry entry) const;
+    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;
+    std::unique_ptr<NCA> GetEntry(ContentProviderEntry entry) const;
 
     virtual std::vector<ContentProviderEntry> ListEntries() const;
 

src/core/file_sys/romfs_factory.cpp

@@ -7,6 +7,7 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/file_sys/card_image.h"
+#include "core/file_sys/common_funcs.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -37,14 +38,37 @@ void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
 }
 
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_title_id) const {
-    if (!updatable)
+    if (!updatable) {
         return MakeResult<VirtualFile>(file);
+    }
 
-    const PatchManager patch_manager(current_process_title_id);
+    const PatchManager patch_manager{current_process_title_id, filesystem_controller,
+                                     content_provider};
     return MakeResult<VirtualFile>(
         patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
 
+ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFS(u64 title_id, ContentRecordType type) const {
+    auto nca = content_provider.GetEntry(title_id, type);
+
+    if (nca == nullptr) {
+        // TODO: Find the right error code to use here
+        return RESULT_UNKNOWN;
+    }
+
+    const PatchManager patch_manager{title_id, filesystem_controller, content_provider};
+
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(nca->GetRomFS(), nca->GetBaseIVFCOffset(), type));
+}
+
+ResultVal<VirtualFile> RomFSFactory::OpenPatchedRomFSWithProgramIndex(
+    u64 title_id, u8 program_index, ContentRecordType type) const {
+    const auto res_title_id = GetBaseTitleIDWithProgramIndex(title_id, program_index);
+
+    return OpenPatchedRomFS(res_title_id, type);
+}
+
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
                                           ContentRecordType type) const {
     const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);