Vulkan: Fix regression caused by limiting render area to width/height of rendef targets.

kernel: reinitialize after dram layout change

.ci/scripts/transifex/docker.sh

@@ -3,15 +3,6 @@
 # SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
-# Setup RC file for tx
-cat << EOF > ~/.transifexrc
-[https://www.transifex.com]
-hostname = https://www.transifex.com
-username = api
-password = $TRANSIFEX_API_TOKEN
-EOF
-
-
 set -x
 
 echo -e "\e[1m\e[33mBuild tools information:\e[0m"
@@ -19,9 +10,6 @@ cmake --version
 gcc -v
 tx --version
 
-# vcpkg needs these: curl zip unzip tar, have tar
-apt-get install -y curl zip unzip
-
 mkdir build && cd build
 cmake .. -DENABLE_QT_TRANSLATION=ON -DGENERATE_QT_TRANSLATION=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_SDL2=OFF -DYUZU_TESTS=OFF -DYUZU_USE_BUNDLED_VCPKG=ON
 make translation

.ci/scripts/windows/docker.sh

@@ -10,13 +10,9 @@ set -e
 ccache -sv
 
 mkdir -p build && cd build
-export LDFLAGS="-fuse-ld=lld"
-# -femulated-tls required due to an incompatibility between GCC and Clang
-# TODO(lat9nq): If this is widespread, we probably need to add this to CMakeLists where appropriate
-export CXXFLAGS="-femulated-tls"
 cmake .. \
     -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_TOOLCHAIN_FILE="${PWD}/../CMakeModules/MinGWClangCross.cmake" \
+    -DCMAKE_TOOLCHAIN_FILE="${PWD}/../CMakeModules/MinGWCross.cmake" \
     -DDISPLAY_VERSION="$1" \
     -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
     -DENABLE_QT_TRANSLATION=ON \

.github/workflows/ci.yml

@@ -19,11 +19,11 @@ jobs:
       - uses: actions/checkout@v3
         with:
           submodules: recursive
-          fetch-depth: 0   
+          fetch-depth: 0
       - name: Update Translation
         run: ./.ci/scripts/transifex/docker.sh
         env:
-          TRANSIFEX_API_TOKEN: ${{ secrets.TRANSIFEX_API_TOKEN }}
+          TX_TOKEN: ${{ secrets.TRANSIFEX_API_TOKEN }}
 
   reuse:
     runs-on: ubuntu-latest

CMakeLists.txt

@@ -252,7 +252,7 @@ if(ENABLE_QT)
             endif()
 
             # Check for headers
-            Include(FindPkgConfig REQUIRED)
+            find_package(PkgConfig REQUIRED)
             pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
             if (NOT QT_DEP_GLU_FOUND)
                 message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
@@ -386,7 +386,7 @@ endif()
 
 # Ensure libusb is properly configured (based on dolphin libusb include)
 if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
-    include(FindPkgConfig)
+    find_package(PkgConfig)
     if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
         pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
     else()
@@ -410,7 +410,7 @@ set(FFmpeg_COMPONENTS
     swscale)
 
 if (UNIX AND NOT APPLE)
-    Include(FindPkgConfig REQUIRED)
+    find_package(PkgConfig REQUIRED)
     pkg_check_modules(LIBVA libva)
 endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
@@ -541,9 +541,9 @@ add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
 # Adjustments for MSVC + Ninja
 if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
     add_compile_options(
-        /wd4711 # function 'function' selected for automatic inline expansion
         /wd4464 # relative include path contains '..'
-        /wd4820 # 'identifier1': '4' bytes padding added after data member 'identifier2'
+        /wd4711 # function 'function' selected for automatic inline expansion
+        /wd4820 # 'bytes' bytes padding added after construct 'member_name'
     )
 endif()
 

dist/languages/.tx/config

@@ -1,7 +1,7 @@
 [main]
 host = https://www.transifex.com
 
-[yuzu.emulator]
+[o:yuzu-emulator:p:yuzu:r:emulator]
 file_filter = <lang>.ts
 source_file = en.ts
 source_lang = en

dist/languages/README.md

@@ -1 +1,3 @@
-This directory stores translation patches (TS files) for yuzu Qt frontend. This directory is linked with [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu), so you can update the translation by executing `tx pull -a`. If you want to contribute to the translation, please go the transifex link and submit your translation there. This directory on the main repo will be synchronized with transifex periodically. Do not directly open PRs on github to modify the translation.
+This directory stores translation patches (TS files) for yuzu Qt frontend. This directory is linked with [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu), so you can update the translation by executing `tx pull -t -a`. If you want to contribute to the translation, please go the transifex link and submit your translation there. This directory on the main repo will be synchronized with transifex periodically.
+
+Do not directly open PRs on github to modify the translation.

externals/ffmpeg/CMakeLists.txt

@@ -43,7 +43,7 @@ if (NOT WIN32)
             CACHE PATH "Paths to FFmpeg libraries" FORCE)
     endforeach()
 
-    Include(FindPkgConfig REQUIRED)
+    find_package(PkgConfig REQUIRED)
     pkg_check_modules(LIBVA libva)
     pkg_check_modules(CUDA cuda)
     pkg_check_modules(FFNVCODEC ffnvcodec)

externals/libusb/CMakeLists.txt

@@ -108,7 +108,7 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
     target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")
 
     if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-        Include(FindPkgConfig)
+        find_package(PkgConfig)
         pkg_check_modules(LIBUDEV REQUIRED libudev)
 
         if (LIBUDEV_FOUND)

src/CMakeLists.txt

@@ -58,13 +58,11 @@ if (MSVC)
 
         # Warnings
         /W3
-        /we4018 # 'expression': signed/unsigned mismatch
+        /WX
+
         /we4062 # Enumerator 'identifier' in a switch of enum 'enumeration' is not handled
-        /we4101 # 'identifier': unreferenced local variable
         /we4189 # 'identifier': local variable is initialized but not referenced
         /we4265 # 'class': class has virtual functions, but destructor is not virtual
-        /we4267 # 'var': conversion from 'size_t' to 'type', possible loss of data
-        /we4305 # 'context': truncation from 'type1' to 'type2'
         /we4388 # 'expression': signed/unsigned mismatch
         /we4389 # 'operator': signed/unsigned mismatch
         /we4456 # Declaration of 'identifier' hides previous local declaration
@@ -75,10 +73,13 @@ if (MSVC)
         /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
-        /we4715 # 'function': not all control paths return a value
-        /we4834 # Discarding return value of function with 'nodiscard' attribute
+        /we4826 # Conversion from 'type1' to 'type2' is sign-extended. This may cause unexpected runtime behavior.
         /we5038 # data member 'member1' will be initialized after data member 'member2'
+        /we5233 # explicit lambda capture 'identifier' is not used
         /we5245 # 'function': unreferenced function with internal linkage has been removed
+
+        /wd4100 # 'identifier': unreferenced formal parameter
+        /wd4324 # 'struct_name': structure was padded due to __declspec(align())
     )
 
     if (USE_CCACHE)
@@ -99,24 +100,18 @@ if (MSVC)
     set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
 else()
     add_compile_options(
-        -Wall
-        -Werror=array-bounds
-        -Werror=implicit-fallthrough
+        -Werror=all
+        -Werror=extra
         -Werror=missing-declarations
-        -Werror=missing-field-initializers
-        -Werror=reorder
         -Werror=shadow
-        -Werror=sign-compare
-        -Werror=switch
-        -Werror=uninitialized
-        -Werror=unused-function
-        -Werror=unused-result
-        -Werror=unused-variable
-        -Wextra
-        -Wmissing-declarations
+        -Werror=unused
+
         -Wno-attributes
         -Wno-invalid-offsetof
         -Wno-unused-parameter
+
+        $<$<CXX_COMPILER_ID:Clang>:-Wno-braced-scalar-init>
+        $<$<CXX_COMPILER_ID:Clang>:-Wno-unused-private-field>
     )
 
     if (ARCHITECTURE_x86_64)

src/audio_core/CMakeLists.txt

@@ -206,20 +206,11 @@ if (MSVC)
         /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
         /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
         /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /we4456 # Declaration of 'identifier' hides previous local declaration
-        /we4457 # Declaration of 'identifier' hides function parameter
-        /we4458 # Declaration of 'identifier' hides class member
-        /we4459 # Declaration of 'identifier' hides global declaration
+        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
     )
 else()
     target_compile_options(audio_core PRIVATE
         -Werror=conversion
-        -Werror=ignored-qualifiers
-        -Werror=shadow
-        -Werror=unused-variable
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
 
         -Wno-sign-conversion
     )

src/audio_core/in/audio_in_system.cpp

@@ -23,7 +23,7 @@ System::~System() {
 void System::Finalize() {
     Stop();
     session->Finalize();
-    buffer_event->GetWritableEvent().Signal();
+    buffer_event->Signal();
 }
 
 void System::StartSession() {
@@ -56,7 +56,7 @@ Result System::IsConfigValid(const std::string_view device_name,
     return ResultSuccess;
 }
 
-Result System::Initialize(std::string& device_name, const AudioInParameter& in_params,
+Result System::Initialize(std::string device_name, const AudioInParameter& in_params,
                           const u32 handle_, const u64 applet_resource_user_id_) {
     auto result{IsConfigValid(device_name, in_params)};
     if (result.IsError()) {
@@ -142,7 +142,7 @@ void System::ReleaseBuffers() {
 
     if (signal) {
         // Signal if any buffer was released, or if none are registered, we need more.
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
     }
 }
 
@@ -159,7 +159,7 @@ bool System::FlushAudioInBuffers() {
     buffers.FlushBuffers(buffers_released);
 
     if (buffers_released > 0) {
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
     }
     return true;
 }

src/audio_core/in/audio_in_system.h

@@ -97,7 +97,7 @@ public:
      * @param applet_resource_user_id - Unused.
      * @return Result code.
      */
-    Result Initialize(std::string& device_name, const AudioInParameter& in_params, u32 handle,
+    Result Initialize(std::string device_name, const AudioInParameter& in_params, u32 handle,
                       u64 applet_resource_user_id);
 
     /**

src/audio_core/out/audio_out_system.cpp

@@ -24,7 +24,7 @@ System::~System() {
 void System::Finalize() {
     Stop();
     session->Finalize();
-    buffer_event->GetWritableEvent().Signal();
+    buffer_event->Signal();
 }
 
 std::string_view System::GetDefaultOutputDeviceName() const {
@@ -49,8 +49,8 @@ Result System::IsConfigValid(std::string_view device_name,
     return Service::Audio::ERR_INVALID_CHANNEL_COUNT;
 }
 
-Result System::Initialize(std::string& device_name, const AudioOutParameter& in_params, u32 handle_,
-                          u64& applet_resource_user_id_) {
+Result System::Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle_,
+                          u64 applet_resource_user_id_) {
     auto result = IsConfigValid(device_name, in_params);
     if (result.IsError()) {
         return result;
@@ -141,7 +141,7 @@ void System::ReleaseBuffers() {
     bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
     if (signal) {
         // Signal if any buffer was released, or if none are registered, we need more.
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
     }
 }
 
@@ -158,7 +158,7 @@ bool System::FlushAudioOutBuffers() {
     buffers.FlushBuffers(buffers_released);
 
     if (buffers_released > 0) {
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
     }
     return true;
 }

src/audio_core/out/audio_out_system.h

@@ -88,8 +88,8 @@ public:
      * @param applet_resource_user_id - Unused.
      * @return Result code.
      */
-    Result Initialize(std::string& device_name, const AudioOutParameter& in_params, u32 handle,
-                      u64& applet_resource_user_id);
+    Result Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle,
+                      u64 applet_resource_user_id);
 
     /**
      * Start this system.

src/audio_core/renderer/behavior/info_updater.cpp

@@ -91,7 +91,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
             voice_info.Initialize();
 
             for (u32 channel = 0; channel < in_param.channel_count; channel++) {
-                std::memset(voice_states[channel], 0, sizeof(VoiceState));
+                *voice_states[channel] = {};
             }
         }
 

src/audio_core/renderer/command/effect/biquad_filter.cpp

@@ -94,7 +94,7 @@ void BiquadFilterCommand::Dump([[maybe_unused]] const ADSP::CommandListProcessor
 void BiquadFilterCommand::Process(const ADSP::CommandListProcessor& processor) {
     auto state_{reinterpret_cast<VoiceState::BiquadFilterState*>(state)};
     if (needs_init) {
-        std::memset(state_, 0, sizeof(VoiceState::BiquadFilterState));
+        *state_ = {};
     }
 
     auto input_buffer{

src/audio_core/renderer/command/effect/multi_tap_biquad_filter.cpp

@@ -30,7 +30,7 @@ void MultiTapBiquadFilterCommand::Process(const ADSP::CommandListProcessor& proc
     for (u32 i = 0; i < filter_tap_count; i++) {
         auto state{reinterpret_cast<VoiceState::BiquadFilterState*>(states[i])};
         if (needs_init[i]) {
-            std::memset(state, 0, sizeof(VoiceState::BiquadFilterState));
+            *state = {};
         }
 
         ApplyBiquadFilterFloat(output_buffer, input_buffer, biquads[i].b, biquads[i].a, *state,

src/audio_core/renderer/system.cpp

@@ -98,9 +98,8 @@ System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
     : core{core_}, adsp{core.AudioCore().GetADSP()}, adsp_rendered_event{adsp_rendered_event_} {}
 
 Result System::Initialize(const AudioRendererParameterInternal& params,
-                          Kernel::KTransferMemory* transfer_memory, const u64 transfer_memory_size,
-                          const u32 process_handle_, const u64 applet_resource_user_id_,
-                          const s32 session_id_) {
+                          Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
+                          u32 process_handle_, u64 applet_resource_user_id_, s32 session_id_) {
     if (!CheckValidRevision(params.revision)) {
         return Service::Audio::ERR_INVALID_REVISION;
     }
@@ -354,6 +353,8 @@ Result System::Initialize(const AudioRendererParameterInternal& params,
 
     render_time_limit_percent = 100;
     drop_voice = params.voice_drop_enabled && params.execution_mode == ExecutionMode::Auto;
+    drop_voice_param = 1.0f;
+    num_voices_dropped = 0;
 
     allocator.Align(0x40);
     command_workbuffer_size = allocator.GetRemainingSize();
@@ -534,7 +535,7 @@ Result System::Update(std::span<const u8> input, std::span<u8> performance, std:
         return result;
     }
 
-    adsp_rendered_event->GetWritableEvent().Clear();
+    adsp_rendered_event->Clear();
     num_times_updated++;
 
     const auto end_time{core.CoreTiming().GetClockTicks()};
@@ -547,7 +548,7 @@ u32 System::GetRenderingTimeLimit() const {
     return render_time_limit_percent;
 }
 
-void System::SetRenderingTimeLimit(const u32 limit) {
+void System::SetRenderingTimeLimit(u32 limit) {
     render_time_limit_percent = limit;
 }
 
@@ -625,7 +626,7 @@ void System::SendCommandToDsp() {
             reset_command_buffers = false;
             command_buffer_size = command_size;
             if (remaining_command_count == 0) {
-                adsp_rendered_event->GetWritableEvent().Signal();
+                adsp_rendered_event->Signal();
             }
         } else {
             adsp.ClearRemainCount(session_id);
@@ -635,7 +636,7 @@ void System::SendCommandToDsp() {
 }
 
 u64 System::GenerateCommand(std::span<u8> in_command_buffer,
-                            [[maybe_unused]] const u64 command_buffer_size_) {
+                            [[maybe_unused]] u64 command_buffer_size_) {
     PoolMapper::ClearUseState(memory_pool_workbuffer, memory_pool_count);
     const auto start_time{core.CoreTiming().GetClockTicks()};
 
@@ -693,7 +694,8 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
 
     voice_context.SortInfo();
 
-    const auto start_estimated_time{command_buffer.estimated_process_time};
+    const auto start_estimated_time{drop_voice_param *
+                                    static_cast<f32>(command_buffer.estimated_process_time)};
 
     command_generator.GenerateVoiceCommands();
     command_generator.GenerateSubMixCommands();
@@ -712,11 +714,16 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
             render_context.behavior->IsAudioRendererProcessingTimeLimit70PercentSupported();
             time_limit_percent = 70.0f;
         }
+
+        const auto end_estimated_time{drop_voice_param *
+                                      static_cast<f32>(command_buffer.estimated_process_time)};
+        const auto estimated_time{start_estimated_time - end_estimated_time};
+
         const auto time_limit{static_cast<u32>(
-            static_cast<f32>(start_estimated_time - command_buffer.estimated_process_time) +
-            (((time_limit_percent / 100.0f) * 2'880'000.0) *
-             (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
-        num_voices_dropped = DropVoices(command_buffer, start_estimated_time, time_limit);
+            estimated_time + (((time_limit_percent / 100.0f) * 2'880'000.0) *
+                              (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
+        num_voices_dropped =
+            DropVoices(command_buffer, static_cast<u32>(start_estimated_time), time_limit);
     }
 
     command_list_header->buffer_size = command_buffer.size;
@@ -737,24 +744,33 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
     return command_buffer.size;
 }
 
-u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_process_time,
-                       const u32 time_limit) {
+f32 System::GetVoiceDropParameter() const {
+    return drop_voice_param;
+}
+
+void System::SetVoiceDropParameter(f32 voice_drop_) {
+    drop_voice_param = voice_drop_;
+}
+
+u32 System::DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time, u32 time_limit) {
     u32 i{0};
     auto command_list{command_buffer.command_list.data() + sizeof(CommandListHeader)};
-    ICommand* cmd{};
+    ICommand* cmd{nullptr};
 
-    for (; i < command_buffer.count; i++) {
+    // Find a first valid voice to drop
+    while (i < command_buffer.count) {
         cmd = reinterpret_cast<ICommand*>(command_list);
-        if (cmd->type != CommandId::Performance &&
-            cmd->type != CommandId::DataSourcePcmInt16Version1 &&
-            cmd->type != CommandId::DataSourcePcmInt16Version2 &&
-            cmd->type != CommandId::DataSourcePcmFloatVersion1 &&
-            cmd->type != CommandId::DataSourcePcmFloatVersion2 &&
-            cmd->type != CommandId::DataSourceAdpcmVersion1 &&
-            cmd->type != CommandId::DataSourceAdpcmVersion2) {
+        if (cmd->type == CommandId::Performance ||
+            cmd->type == CommandId::DataSourcePcmInt16Version1 ||
+            cmd->type == CommandId::DataSourcePcmInt16Version2 ||
+            cmd->type == CommandId::DataSourcePcmFloatVersion1 ||
+            cmd->type == CommandId::DataSourcePcmFloatVersion2 ||
+            cmd->type == CommandId::DataSourceAdpcmVersion1 ||
+            cmd->type == CommandId::DataSourceAdpcmVersion2) {
             break;
         }
         command_list += cmd->size;
+        i++;
     }
 
     if (cmd == nullptr || command_buffer.count == 0 || i >= command_buffer.count) {
@@ -767,6 +783,7 @@ u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_proces
         const auto node_id_type{cmd->node_id >> 28};
         const auto node_id_base{cmd->node_id & 0xFFF};
 
+        // If the new estimated process time falls below the limit, we're done dropping.
         if (estimated_process_time <= time_limit) {
             break;
         }
@@ -775,6 +792,7 @@ u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_proces
             break;
         }
 
+        // Don't drop voices marked with the highest priority.
         auto& voice_info{voice_context.GetInfo(node_id_base)};
         if (voice_info.priority == HighestVoicePriority) {
             break;
@@ -783,18 +801,23 @@ u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_proces
         voices_dropped++;
         voice_info.voice_dropped = true;
 
-        if (i < command_buffer.count) {
-            while (cmd->node_id == node_id) {
-                if (cmd->type == CommandId::DepopPrepare) {
-                    cmd->enabled = true;
-                } else if (cmd->type == CommandId::Performance || !cmd->enabled) {
-                    cmd->enabled = false;
-                }
-                i++;
-                command_list += cmd->size;
-                cmd = reinterpret_cast<ICommand*>(command_list);
+        // First iteration should drop the voice, and then iterate through all of the commands tied
+        // to the voice. We don't need reverb on a voice which we've just removed, for example.
+        // Depops can't be removed otherwise we'll introduce audio popping, and we don't
+        // remove perf commands. Lower the estimated time for each command dropped.
+        while (i < command_buffer.count && cmd->node_id == node_id) {
+            if (cmd->type == CommandId::DepopPrepare) {
+                cmd->enabled = true;
+            } else if (cmd->enabled && cmd->type != CommandId::Performance) {
+                cmd->enabled = false;
+                estimated_process_time -= static_cast<u32>(
+                    drop_voice_param * static_cast<f32>(cmd->estimated_process_time));
             }
+            command_list += cmd->size;
+            cmd = reinterpret_cast<ICommand*>(command_list);
+            i++;
         }
+        i++;
     }
     return voices_dropped;
 }

src/audio_core/renderer/system.h

@@ -196,6 +196,20 @@ public:
      */
     u32 DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time, u32 time_limit);
 
+    /**
+     * Get the current voice drop parameter.
+     *
+     * @return The current voice drop.
+     */
+    f32 GetVoiceDropParameter() const;
+
+    /**
+     * Set the voice drop parameter.
+     *
+     * @param The new voice drop.
+     */
+    void SetVoiceDropParameter(f32 voice_drop);
+
 private:
     /// Core system
     Core::System& core;
@@ -301,6 +315,8 @@ private:
     u32 num_voices_dropped{};
     /// Tick that rendering started
     u64 render_start_tick{};
+    /// Parameter to control the threshold for dropping voices if the audio graph gets too large
+    f32 drop_voice_param{1.0f};
 };
 
 } // namespace AudioRenderer

src/audio_core/renderer/voice/voice_context.cpp

@@ -74,8 +74,8 @@ void VoiceContext::SortInfo() {
     }
 
     std::ranges::sort(sorted_voice_info, [](const VoiceInfo* a, const VoiceInfo* b) {
-        return a->priority != b->priority ? a->priority < b->priority
-                                          : a->sort_order < b->sort_order;
+        return a->priority != b->priority ? a->priority > b->priority
+                                          : a->sort_order > b->sort_order;
     });
 }
 

src/audio_core/sink/cubeb_sink.cpp

@@ -66,10 +66,10 @@ public:
         const auto latency_error = cubeb_get_min_latency(ctx, &params, &minimum_latency);
         if (latency_error != CUBEB_OK) {
             LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
-            minimum_latency = 256U;
+            minimum_latency = TargetSampleCount * 2;
         }
 
-        minimum_latency = std::max(minimum_latency, 256u);
+        minimum_latency = std::max(minimum_latency, TargetSampleCount * 2);
 
         LOG_INFO(Service_Audio,
                  "Opening cubeb stream {} type {} with: rate {} channels {} (system channels {}) "
@@ -326,4 +326,31 @@ std::vector<std::string> ListCubebSinkDevices(bool capture) {
     return device_list;
 }
 
+u32 GetCubebLatency() {
+    cubeb* ctx;
+
+    if (cubeb_init(&ctx, "yuzu Latency Getter", nullptr) != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+        // Return a large latency so we choose SDL instead.
+        return 10000u;
+    }
+
+    cubeb_stream_params params{};
+    params.rate = TargetSampleRate;
+    params.channels = 2;
+    params.format = CUBEB_SAMPLE_S16LE;
+    params.prefs = CUBEB_STREAM_PREF_NONE;
+    params.layout = CUBEB_LAYOUT_STEREO;
+
+    u32 latency{0};
+    const auto latency_error = cubeb_get_min_latency(ctx, &params, &latency);
+    if (latency_error != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
+        latency = TargetSampleCount * 2;
+    }
+    latency = std::max(latency, TargetSampleCount * 2);
+    cubeb_destroy(ctx);
+    return latency;
+}
+
 } // namespace AudioCore::Sink

src/audio_core/sink/cubeb_sink.h

@@ -96,4 +96,11 @@ private:
  */
 std::vector<std::string> ListCubebSinkDevices(bool capture);
 
+/**
+ * Get the reported latency for this sink.
+ *
+ * @return Minimum latency for this sink.
+ */
+u32 GetCubebLatency();
+
 } // namespace AudioCore::Sink

src/audio_core/sink/sdl2_sink.cpp

@@ -47,11 +47,7 @@ public:
         spec.freq = TargetSampleRate;
         spec.channels = static_cast<u8>(device_channels);
         spec.format = AUDIO_S16SYS;
-        if (type == StreamType::Render) {
-            spec.samples = TargetSampleCount;
-        } else {
-            spec.samples = 1024;
-        }
+        spec.samples = TargetSampleCount * 2;
         spec.callback = &SDLSinkStream::DataCallback;
         spec.userdata = this;
 
@@ -234,10 +230,16 @@ std::vector<std::string> ListSDLSinkDevices(bool capture) {
 
     const int device_count = SDL_GetNumAudioDevices(capture);
     for (int i = 0; i < device_count; ++i) {
-        device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
+        if (const char* name = SDL_GetAudioDeviceName(i, capture)) {
+            device_list.emplace_back(name);
+        }
     }
 
     return device_list;
 }
 
+u32 GetSDLLatency() {
+    return TargetSampleCount * 2;
+}
+
 } // namespace AudioCore::Sink

src/audio_core/sink/sdl2_sink.h

@@ -87,4 +87,11 @@ private:
  */
 std::vector<std::string> ListSDLSinkDevices(bool capture);
 
+/**
+ * Get the reported latency for this sink.
+ *
+ * @return Minimum latency for this sink.
+ */
+u32 GetSDLLatency();
+
 } // namespace AudioCore::Sink

src/audio_core/sink/sink_details.cpp

@@ -21,58 +21,80 @@ namespace {
 struct SinkDetails {
     using FactoryFn = std::unique_ptr<Sink> (*)(std::string_view);
     using ListDevicesFn = std::vector<std::string> (*)(bool);
+    using LatencyFn = u32 (*)();
 
     /// Name for this sink.
-    const char* id;
+    std::string_view id;
     /// A method to call to construct an instance of this type of sink.
     FactoryFn factory;
     /// A method to call to list available devices.
     ListDevicesFn list_devices;
+    /// Method to get the latency of this backend.
+    LatencyFn latency;
 };
 
 // sink_details is ordered in terms of desirability, with the best choice at the top.
 constexpr SinkDetails sink_details[] = {
 #ifdef HAVE_CUBEB
-    SinkDetails{"cubeb",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<CubebSink>(device_id);
-                },
-                &ListCubebSinkDevices},
+    SinkDetails{
+        "cubeb",
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<CubebSink>(device_id);
+        },
+        &ListCubebSinkDevices,
+        &GetCubebLatency,
+    },
 #endif
 #ifdef HAVE_SDL2
-    SinkDetails{"sdl2",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<SDLSink>(device_id);
-                },
-                &ListSDLSinkDevices},
+    SinkDetails{
+        "sdl2",
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<SDLSink>(device_id);
+        },
+        &ListSDLSinkDevices,
+        &GetSDLLatency,
+    },
 #endif
     SinkDetails{"null",
                 [](std::string_view device_id) -> std::unique_ptr<Sink> {
                     return std::make_unique<NullSink>(device_id);
                 },
-                [](bool capture) { return std::vector<std::string>{"null"}; }},
+                [](bool capture) { return std::vector<std::string>{"null"}; }, []() { return 0u; }},
 };
 
 const SinkDetails& GetOutputSinkDetails(std::string_view sink_id) {
-    auto iter =
-        std::find_if(std::begin(sink_details), std::end(sink_details),
-                     [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
+    const auto find_backend{[](std::string_view id) {
+        return std::find_if(std::begin(sink_details), std::end(sink_details),
+                            [&id](const auto& sink_detail) { return sink_detail.id == id; });
+    }};
 
-    if (sink_id == "auto" || iter == std::end(sink_details)) {
-        if (sink_id != "auto") {
-            LOG_ERROR(Audio, "Invalid sink_id {}", sink_id);
+    auto iter = find_backend(sink_id);
+
+    if (sink_id == "auto") {
+        // Auto-select a backend. Prefer CubeB, but it may report a large minimum latency which
+        // causes audio issues, in that case go with SDL.
+#if defined(HAVE_CUBEB) && defined(HAVE_SDL2)
+        iter = find_backend("cubeb");
+        if (iter->latency() > TargetSampleCount * 3) {
+            iter = find_backend("sdl2");
         }
-        // Auto-select.
-        // sink_details is ordered in terms of desirability, with the best choice at the front.
+#else
         iter = std::begin(sink_details);
+#endif
+        LOG_INFO(Service_Audio, "Auto-selecting the {} backend", iter->id);
+    }
+
+    if (iter == std::end(sink_details)) {
+        LOG_ERROR(Audio, "Invalid sink_id {}", sink_id);
+        iter = find_backend("null");
     }
 
     return *iter;
 }
 } // Anonymous namespace
 
-std::vector<const char*> GetSinkIDs() {
-    std::vector<const char*> sink_ids(std::size(sink_details));
+std::vector<std::string_view> GetSinkIDs() {
+    std::vector<std::string_view> sink_ids(std::size(sink_details));
 
     std::transform(std::begin(sink_details), std::end(sink_details), std::begin(sink_ids),
                    [](const auto& sink) { return sink.id; });

src/audio_core/sink/sink_details.h

@@ -19,7 +19,7 @@ class Sink;
  *
  * @return Vector of available sink names.
  */
-std::vector<const char*> GetSinkIDs();
+std::vector<std::string_view> GetSinkIDs();
 
 /**
  * Gets the list of devices for a particular sink identified by the given ID.

src/common/CMakeLists.txt

@@ -156,12 +156,13 @@ if (MSVC)
   )
   target_compile_options(common PRIVATE
     /W4
-    /WX
+
+    /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+    /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+    /we4800 # Implicit conversion from 'type' to bool. Possible information loss
   )
 else()
   target_compile_options(common PRIVATE
-    -Werror
-
     $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
   )
 endif()
@@ -169,7 +170,11 @@ endif()
 create_target_directory_groups(common)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
-target_link_libraries(common PRIVATE lz4::lz4)
+if (TARGET lz4::lz4)
+  target_link_libraries(common PRIVATE lz4::lz4)
+else()
+  target_link_libraries(common PRIVATE LZ4::lz4_shared)
+endif()
 if (TARGET zstd::zstd)
   target_link_libraries(common PRIVATE zstd::zstd)
 else()

src/common/bit_field.h

@@ -141,10 +141,6 @@ public:
     constexpr BitField(BitField&&) noexcept = default;
     constexpr BitField& operator=(BitField&&) noexcept = default;
 
-    [[nodiscard]] constexpr operator T() const {
-        return Value();
-    }
-
     constexpr void Assign(const T& value) {
 #ifdef _MSC_VER
         storage = static_cast<StorageType>((storage & ~mask) | FormatValue(value));
@@ -162,6 +158,17 @@ public:
         return ExtractValue(storage);
     }
 
+    template <typename ConvertedToType>
+    [[nodiscard]] constexpr ConvertedToType As() const {
+        static_assert(!std::is_same_v<T, ConvertedToType>,
+                      "Unnecessary cast. Use Value() instead.");
+        return static_cast<ConvertedToType>(Value());
+    }
+
+    [[nodiscard]] constexpr operator T() const {
+        return Value();
+    }
+
     [[nodiscard]] constexpr explicit operator bool() const {
         return Value() != 0;
     }

src/common/bounded_threadsafe_queue.h

@@ -21,11 +21,6 @@ constexpr size_t hardware_interference_size = std::hardware_destructive_interfer
 constexpr size_t hardware_interference_size = 64;
 #endif
 
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4324)
-#endif
-
 template <typename T, size_t capacity = 0x400>
 class MPSCQueue {
 public:
@@ -160,8 +155,4 @@ private:
     static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
 };
 
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 } // namespace Common

src/common/concepts.h

@@ -3,24 +3,14 @@
 
 #pragma once
 
+#include <iterator>
 #include <type_traits>
 
 namespace Common {
 
-// Check if type is like an STL container
+// Check if type satisfies the ContiguousContainer named requirement.
 template <typename T>
-concept IsSTLContainer = requires(T t) {
-    typename T::value_type;
-    typename T::iterator;
-    typename T::const_iterator;
-    // TODO(ogniK): Replace below is std::same_as<void> when MSVC supports it.
-    t.begin();
-    t.end();
-    t.cbegin();
-    t.cend();
-    t.data();
-    t.size();
-};
+concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;
 
 // TODO: Replace with std::derived_from when the <concepts> header
 //       is available on all supported platforms.
@@ -34,4 +24,12 @@ concept DerivedFrom = requires {
 template <typename From, typename To>
 concept ConvertibleTo = std::is_convertible_v<From, To>;
 
+// No equivalents in the stdlib
+
+template <typename T>
+concept IsArithmetic = std::is_arithmetic_v<T>;
+
+template <typename T>
+concept IsIntegral = std::is_integral_v<T>;
+
 } // namespace Common

src/common/fixed_point.h

@@ -4,14 +4,7 @@
 // From: https://github.com/eteran/cpp-utilities/blob/master/fixed/include/cpp-utilities/fixed.h
 // See also: http://stackoverflow.com/questions/79677/whats-the-best-way-to-do-fixed-point-math
 
-#ifndef FIXED_H_
-#define FIXED_H_
-
-#if __cplusplus >= 201402L
-#define CONSTEXPR14 constexpr
-#else
-#define CONSTEXPR14
-#endif
+#pragma once
 
 #include <cstddef> // for size_t
 #include <cstdint>
@@ -19,6 +12,8 @@
 #include <ostream>
 #include <type_traits>
 
+#include <common/concepts.h>
+
 namespace Common {
 
 template <size_t I, size_t F>
@@ -57,8 +52,8 @@ struct type_from_size<64> {
     static constexpr size_t size = 64;
 
     using value_type = int64_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<128>;
 };
 
@@ -68,8 +63,8 @@ struct type_from_size<32> {
     static constexpr size_t size = 32;
 
     using value_type = int32_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<64>;
 };
 
@@ -79,8 +74,8 @@ struct type_from_size<16> {
     static constexpr size_t size = 16;
 
     using value_type = int16_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<32>;
 };
 
@@ -90,8 +85,8 @@ struct type_from_size<8> {
     static constexpr size_t size = 8;
 
     using value_type = int8_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
     using next_size = type_from_size<16>;
 };
 
@@ -106,9 +101,9 @@ constexpr B next_to_base(N rhs) {
 struct divide_by_zero : std::exception {};
 
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> divide(
+constexpr FixedPoint<I, F> divide(
     FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using next_type = typename FixedPoint<I, F>::next_type;
     using base_type = typename FixedPoint<I, F>::base_type;
@@ -126,9 +121,9 @@ CONSTEXPR14 FixedPoint<I, F> divide(
 }
 
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> divide(
+constexpr FixedPoint<I, F> divide(
     FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using unsigned_type = typename FixedPoint<I, F>::unsigned_type;
 
@@ -196,9 +191,9 @@ CONSTEXPR14 FixedPoint<I, F> divide(
 
 // this is the usual implementation of multiplication
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> multiply(
+constexpr FixedPoint<I, F> multiply(
     FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using next_type = typename FixedPoint<I, F>::next_type;
     using base_type = typename FixedPoint<I, F>::base_type;
@@ -215,9 +210,9 @@ CONSTEXPR14 FixedPoint<I, F> multiply(
 // it is slightly slower, but is more robust since it doesn't
 // require and upgraded type
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> multiply(
+constexpr FixedPoint<I, F> multiply(
     FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {
 
     using base_type = typename FixedPoint<I, F>::base_type;
 
@@ -272,19 +267,20 @@ public:
     static constexpr base_type one = base_type(1) << fractional_bits;
 
 public: // constructors
-    FixedPoint() = default;
-    FixedPoint(const FixedPoint&) = default;
-    FixedPoint(FixedPoint&&) = default;
-    FixedPoint& operator=(const FixedPoint&) = default;
+    constexpr FixedPoint() = default;
 
-    template <class Number>
-    constexpr FixedPoint(
-        Number n, typename std::enable_if<std::is_arithmetic<Number>::value>::type* = nullptr)
-        : data_(static_cast<base_type>(n * one)) {}
+    constexpr FixedPoint(const FixedPoint&) = default;
+    constexpr FixedPoint& operator=(const FixedPoint&) = default;
+
+    constexpr FixedPoint(FixedPoint&&) noexcept = default;
+    constexpr FixedPoint& operator=(FixedPoint&&) noexcept = default;
+
+    template <IsArithmetic Number>
+    constexpr FixedPoint(Number n) : data_(static_cast<base_type>(n * one)) {}
 
 public: // conversion
     template <size_t I2, size_t F2>
-    CONSTEXPR14 explicit FixedPoint(FixedPoint<I2, F2> other) {
+    constexpr explicit FixedPoint(FixedPoint<I2, F2> other) {
         static_assert(I2 <= I && F2 <= F, "Scaling conversion can only upgrade types");
         using T = FixedPoint<I2, F2>;
 
@@ -308,36 +304,14 @@ public:
     }
 
 public: // comparison operators
-    constexpr bool operator==(FixedPoint rhs) const {
-        return data_ == rhs.data_;
-    }
-
-    constexpr bool operator!=(FixedPoint rhs) const {
-        return data_ != rhs.data_;
-    }
-
-    constexpr bool operator<(FixedPoint rhs) const {
-        return data_ < rhs.data_;
-    }
-
-    constexpr bool operator>(FixedPoint rhs) const {
-        return data_ > rhs.data_;
-    }
-
-    constexpr bool operator<=(FixedPoint rhs) const {
-        return data_ <= rhs.data_;
-    }
-
-    constexpr bool operator>=(FixedPoint rhs) const {
-        return data_ >= rhs.data_;
-    }
+    friend constexpr auto operator<=>(FixedPoint lhs, FixedPoint rhs) = default;
 
 public: // unary operators
-    constexpr bool operator!() const {
+    [[nodiscard]] constexpr bool operator!() const {
         return !data_;
     }
 
-    constexpr FixedPoint operator~() const {
+    [[nodiscard]] constexpr FixedPoint operator~() const {
         // NOTE(eteran): this will often appear to "just negate" the value
         // that is not an error, it is because -x == (~x+1)
         // and that "+1" is adding an infinitesimally small fraction to the
@@ -345,89 +319,87 @@ public: // unary operators
         return FixedPoint::from_base(~data_);
     }
 
-    constexpr FixedPoint operator-() const {
+    [[nodiscard]] constexpr FixedPoint operator-() const {
         return FixedPoint::from_base(-data_);
     }
 
-    constexpr FixedPoint operator+() const {
+    [[nodiscard]] constexpr FixedPoint operator+() const {
         return FixedPoint::from_base(+data_);
     }
 
-    CONSTEXPR14 FixedPoint& operator++() {
+    constexpr FixedPoint& operator++() {
         data_ += one;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator--() {
+    constexpr FixedPoint& operator--() {
         data_ -= one;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint operator++(int) {
+    constexpr FixedPoint operator++(int) {
         FixedPoint tmp(*this);
         data_ += one;
         return tmp;
     }
 
-    CONSTEXPR14 FixedPoint operator--(int) {
+    constexpr FixedPoint operator--(int) {
         FixedPoint tmp(*this);
         data_ -= one;
         return tmp;
     }
 
 public: // basic math operators
-    CONSTEXPR14 FixedPoint& operator+=(FixedPoint n) {
+    constexpr FixedPoint& operator+=(FixedPoint n) {
         data_ += n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator-=(FixedPoint n) {
+    constexpr FixedPoint& operator-=(FixedPoint n) {
         data_ -= n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator*=(FixedPoint n) {
+    constexpr FixedPoint& operator*=(FixedPoint n) {
         return assign(detail::multiply(*this, n));
     }
 
-    CONSTEXPR14 FixedPoint& operator/=(FixedPoint n) {
+    constexpr FixedPoint& operator/=(FixedPoint n) {
         FixedPoint temp;
         return assign(detail::divide(*this, n, temp));
     }
 
 private:
-    CONSTEXPR14 FixedPoint& assign(FixedPoint rhs) {
+    constexpr FixedPoint& assign(FixedPoint rhs) {
         data_ = rhs.data_;
         return *this;
     }
 
 public: // binary math operators, effects underlying bit pattern since these
         // don't really typically make sense for non-integer values
-    CONSTEXPR14 FixedPoint& operator&=(FixedPoint n) {
+    constexpr FixedPoint& operator&=(FixedPoint n) {
         data_ &= n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator|=(FixedPoint n) {
+    constexpr FixedPoint& operator|=(FixedPoint n) {
         data_ |= n.data_;
         return *this;
     }
 
-    CONSTEXPR14 FixedPoint& operator^=(FixedPoint n) {
+    constexpr FixedPoint& operator^=(FixedPoint n) {
         data_ ^= n.data_;
         return *this;
     }
 
-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-    CONSTEXPR14 FixedPoint& operator>>=(Integer n) {
+    template <IsIntegral Integer>
+    constexpr FixedPoint& operator>>=(Integer n) {
         data_ >>= n;
         return *this;
     }
 
-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-    CONSTEXPR14 FixedPoint& operator<<=(Integer n) {
+    template <IsIntegral Integer>
+    constexpr FixedPoint& operator<<=(Integer n) {
         data_ <<= n;
         return *this;
     }
@@ -437,42 +409,42 @@ public: // conversion to basic types
         data_ += (data_ & fractional_mask) >> 1;
     }
 
-    constexpr int to_int() {
+    [[nodiscard]] constexpr int to_int() {
         round_up();
         return static_cast<int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr unsigned int to_uint() const {
+    [[nodiscard]] constexpr unsigned int to_uint() {
         round_up();
         return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr int64_t to_long() {
+    [[nodiscard]] constexpr int64_t to_long() {
         round_up();
         return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr int to_int_floor() const {
+    [[nodiscard]] constexpr int to_int_floor() const {
         return static_cast<int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr int64_t to_long_floor() {
+    [[nodiscard]] constexpr int64_t to_long_floor() const {
         return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr unsigned int to_uint_floor() const {
+    [[nodiscard]] constexpr unsigned int to_uint_floor() const {
         return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
     }
 
-    constexpr float to_float() const {
+    [[nodiscard]] constexpr float to_float() const {
         return static_cast<float>(data_) / FixedPoint::one;
     }
 
-    constexpr double to_double() const {
+    [[nodiscard]] constexpr double to_double() const {
         return static_cast<double>(data_) / FixedPoint::one;
     }
 
-    constexpr base_type to_raw() const {
+    [[nodiscard]] constexpr base_type to_raw() const {
         return data_;
     }
 
@@ -480,27 +452,27 @@ public: // conversion to basic types
         data_ &= fractional_mask;
     }
 
-    constexpr base_type get_frac() const {
+    [[nodiscard]] constexpr base_type get_frac() const {
         return data_ & fractional_mask;
     }
 
 public:
-    CONSTEXPR14 void swap(FixedPoint& rhs) {
+    constexpr void swap(FixedPoint& rhs) noexcept {
         using std::swap;
         swap(data_, rhs.data_);
     }
 
 public:
-    base_type data_;
+    base_type data_{};
 };
 
 // if we have the same fractional portion, but differing integer portions, we trivially upgrade the
 // smaller type
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator+(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -508,10 +480,10 @@ operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }
 
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator-(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -519,10 +491,10 @@ operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }
 
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator*(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -530,10 +502,10 @@ operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }
 
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator/(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator/(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 
-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;
 
     const T l = T::from_base(lhs.to_raw());
     const T r = T::from_base(rhs.to_raw());
@@ -548,159 +520,133 @@ std::ostream& operator<<(std::ostream& os, FixedPoint<I, F> f) {
 
 // basic math operators
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs += rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs -= rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs *= rhs;
     return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
     lhs /= rhs;
     return lhs;
 }
 
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
     lhs += FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
     lhs -= FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
     lhs *= FixedPoint<I, F>(rhs);
     return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
     lhs /= FixedPoint<I, F>(rhs);
     return lhs;
 }
 
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp += rhs;
     return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp -= rhs;
     return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp *= rhs;
     return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
     FixedPoint<I, F> tmp(lhs);
     tmp /= rhs;
     return tmp;
 }
 
 // shift operators
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, IsIntegral Integer>
+constexpr FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
     lhs <<= rhs;
     return lhs;
 }
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, IsIntegral Integer>
+constexpr FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
     lhs >>= rhs;
     return lhs;
 }
 
 // comparison operators
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>(FixedPoint<I, F> lhs, Number rhs) {
     return lhs > FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<(FixedPoint<I, F> lhs, Number rhs) {
     return lhs < FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs >= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs <= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator==(FixedPoint<I, F> lhs, Number rhs) {
     return lhs == FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator!=(FixedPoint<I, F> lhs, Number rhs) {
     return lhs != FixedPoint<I, F>(rhs);
 }
 
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) > rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) < rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) >= rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) <= rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator==(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) == rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator!=(Number lhs, FixedPoint<I, F> rhs) {
     return FixedPoint<I, F>(lhs) != rhs;
 }
 
 } // namespace Common
-
-#undef CONSTEXPR14
-
-#endif

src/common/fs/file.h

@@ -209,8 +209,8 @@ public:
 
     /**
      * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
-     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
-     * ReadObject and T must be a trivially copyable object.
+     * If T is not a contiguous container as defined by the concept IsContiguousContainer, this
+     * calls ReadObject and T must be a trivially copyable object.
      *
      * See ReadSpan for more details if T is a contiguous container.
      * See ReadObject for more details if T is a trivially copyable object.
@@ -223,7 +223,7 @@ public:
      */
     template <typename T>
     [[nodiscard]] size_t Read(T& data) const {
-        if constexpr (IsSTLContainer<T>) {
+        if constexpr (IsContiguousContainer<T>) {
             using ContiguousType = typename T::value_type;
             static_assert(std::is_trivially_copyable_v<ContiguousType>,
                           "Data type must be trivially copyable.");
@@ -235,8 +235,8 @@ public:
 
     /**
      * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
-     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
-     * WriteObject and T must be a trivially copyable object.
+     * If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this
+     * calls WriteObject and T must be a trivially copyable object.
      *
      * See WriteSpan for more details if T is a contiguous container.
      * See WriteObject for more details if T is a trivially copyable object.
@@ -249,7 +249,7 @@ public:
      */
     template <typename T>
     [[nodiscard]] size_t Write(const T& data) const {
-        if constexpr (IsSTLContainer<T>) {
+        if constexpr (IsContiguousContainer<T>) {
             using ContiguousType = typename T::value_type;
             static_assert(std::is_trivially_copyable_v<ContiguousType>,
                           "Data type must be trivially copyable.");

src/common/input.h

@@ -100,7 +100,6 @@ enum class CameraError {
 enum class VibrationAmplificationType {
     Linear,
     Exponential,
-    Test,
 };
 
 // Analog properties for calibration
@@ -277,8 +276,9 @@ struct CallbackStatus {
     BodyColorStatus color_status{};
     BatteryStatus battery_status{};
     VibrationStatus vibration_status{};
-    CameraStatus camera_status{};
-    NfcStatus nfc_status{};
+    CameraFormat camera_status{CameraFormat::None};
+    NfcState nfc_status{NfcState::Unknown};
+    std::vector<u8> raw_data{};
 };
 
 // Triggered once every input change
@@ -324,6 +324,10 @@ public:
         return VibrationError::NotSupported;
     }
 
+    virtual bool IsVibrationEnabled() {
+        return false;
+    }
+
     virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
         return PollingError::NotSupported;
     }

src/common/settings.h

@@ -431,7 +431,7 @@ struct Values {
         FullscreenMode::Exclusive,
 #endif
         FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    SwitchableSetting<int, true> aspect_ratio{0, 0, 3, "aspect_ratio"};
+    SwitchableSetting<int, true> aspect_ratio{0, 0, 4, "aspect_ratio"};
     SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
     SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
     SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"};

src/core/CMakeLists.txt

@@ -190,6 +190,9 @@ add_library(core STATIC
     hle/kernel/k_code_memory.h
     hle/kernel/k_condition_variable.cpp
     hle/kernel/k_condition_variable.h
+    hle/kernel/k_dynamic_page_manager.h
+    hle/kernel/k_dynamic_resource_manager.h
+    hle/kernel/k_dynamic_slab_heap.h
     hle/kernel/k_event.cpp
     hle/kernel/k_event.h
     hle/kernel/k_handle_table.cpp
@@ -240,6 +243,8 @@ add_library(core STATIC
     hle/kernel/k_server_session.h
     hle/kernel/k_session.cpp
     hle/kernel/k_session.h
+    hle/kernel/k_session_request.cpp
+    hle/kernel/k_session_request.h
     hle/kernel/k_shared_memory.cpp
     hle/kernel/k_shared_memory.h
     hle/kernel/k_shared_memory_info.h
@@ -261,8 +266,6 @@ add_library(core STATIC
     hle/kernel/k_worker_task.h
     hle/kernel/k_worker_task_manager.cpp
     hle/kernel/k_worker_task_manager.h
-    hle/kernel/k_writable_event.cpp
-    hle/kernel/k_writable_event.h
     hle/kernel/kernel.cpp
     hle/kernel/kernel.h
     hle/kernel/memory_types.h
@@ -771,19 +774,15 @@ if (MSVC)
         /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
         /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
         /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
     )
 else()
     target_compile_options(core PRIVATE
         -Werror=conversion
-        -Werror=ignored-qualifiers
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-
-        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
 
         -Wno-sign-conversion
+
+        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
     )
 endif()
 

src/core/arm/arm_interface.cpp

@@ -134,6 +134,14 @@ void ARM_Interface::Run() {
         }
         system.ExitDynarmicProfile();
 
+        // If the thread is scheduled for termination, exit the thread.
+        if (current_thread->HasDpc()) {
+            if (current_thread->IsTerminationRequested()) {
+                current_thread->Exit();
+                UNREACHABLE();
+            }
+        }
+
         // Notify the debugger and go to sleep if a breakpoint was hit,
         // or if the thread is unable to continue for any reason.
         if (Has(hr, breakpoint) || Has(hr, no_execute)) {

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -450,7 +450,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace(Core::S
     // Frame records are two words long:
     // fp+0 : pointer to previous frame record
     // fp+4 : value of lr for frame
-    while (true) {
+    for (size_t i = 0; i < 256; i++) {
         out.push_back({"", 0, lr, 0, ""});
         if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 8)) {
             break;

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -111,6 +111,7 @@ public:
         LOG_ERROR(Core_ARM,
                   "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                   num_instructions, memory.Read32(pc));
+        ReturnException(pc, ARM_Interface::no_execute);
     }
 
     void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
@@ -516,7 +517,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::S
     // Frame records are two words long:
     // fp+0 : pointer to previous frame record
     // fp+8 : value of lr for frame
-    while (true) {
+    for (size_t i = 0; i < 256; i++) {
         out.push_back({"", 0, lr, 0, ""});
         if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) {
             break;

src/core/core.cpp

@@ -133,6 +133,56 @@ struct System::Impl {
         : kernel{system}, fs_controller{system}, memory{system}, hid_core{}, room_network{},
           cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
 
+    void Initialize(System& system) {
+        device_memory = std::make_unique<Core::DeviceMemory>();
+
+        is_multicore = Settings::values.use_multi_core.GetValue();
+        extended_memory_layout = Settings::values.use_extended_memory_layout.GetValue();
+
+        core_timing.SetMulticore(is_multicore);
+        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
+
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+        Settings::values.custom_rtc_differential =
+            Settings::values.custom_rtc.value_or(current_time) - current_time;
+
+        // Create a default fs if one doesn't already exist.
+        if (virtual_filesystem == nullptr) {
+            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
+        }
+        if (content_provider == nullptr) {
+            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
+        }
+
+        // Create default implementations of applets if one is not provided.
+        applet_manager.SetDefaultAppletsIfMissing();
+
+        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
+
+        kernel.SetMulticore(is_multicore);
+        cpu_manager.SetMulticore(is_multicore);
+        cpu_manager.SetAsyncGpu(is_async_gpu);
+    }
+
+    void ReinitializeIfNecessary(System& system) {
+        const bool must_reinitialize =
+            is_multicore != Settings::values.use_multi_core.GetValue() ||
+            extended_memory_layout != Settings::values.use_extended_memory_layout.GetValue();
+
+        if (!must_reinitialize) {
+            return;
+        }
+
+        LOG_DEBUG(Kernel, "Re-initializing");
+
+        is_multicore = Settings::values.use_multi_core.GetValue();
+        extended_memory_layout = Settings::values.use_extended_memory_layout.GetValue();
+
+        Initialize(system);
+    }
+
     SystemResultStatus Run() {
         std::unique_lock<std::mutex> lk(suspend_guard);
         status = SystemResultStatus::Success;
@@ -178,37 +228,14 @@ struct System::Impl {
         debugger = std::make_unique<Debugger>(system, port);
     }
 
-    SystemResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
+    SystemResultStatus SetupForMainProcess(System& system, Frontend::EmuWindow& emu_window) {
         LOG_DEBUG(Core, "initialized OK");
 
-        device_memory = std::make_unique<Core::DeviceMemory>();
-
-        is_multicore = Settings::values.use_multi_core.GetValue();
-        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
-
-        kernel.SetMulticore(is_multicore);
-        cpu_manager.SetMulticore(is_multicore);
-        cpu_manager.SetAsyncGpu(is_async_gpu);
-        core_timing.SetMulticore(is_multicore);
+        // Setting changes may require a full system reinitialization (e.g., disabling multicore).
+        ReinitializeIfNecessary(system);
 
         kernel.Initialize();
         cpu_manager.Initialize();
-        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
-
-        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
-        Settings::values.custom_rtc_differential =
-            Settings::values.custom_rtc.value_or(current_time) - current_time;
-
-        // Create a default fs if one doesn't already exist.
-        if (virtual_filesystem == nullptr)
-            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-        if (content_provider == nullptr)
-            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
-
-        /// Create default implementations of applets if one is not provided.
-        applet_manager.SetDefaultAppletsIfMissing();
 
         /// Reset all glue registrations
         arp_manager.ResetAll();
@@ -253,11 +280,11 @@ struct System::Impl {
             return SystemResultStatus::ErrorGetLoader;
         }
 
-        SystemResultStatus init_result{Init(system, emu_window)};
+        SystemResultStatus init_result{SetupForMainProcess(system, emu_window)};
         if (init_result != SystemResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                          static_cast<int>(init_result));
-            Shutdown();
+            ShutdownMainProcess();
             return init_result;
         }
 
@@ -276,7 +303,7 @@ struct System::Impl {
         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 {})!", load_result);
-            Shutdown();
+            ShutdownMainProcess();
 
             return static_cast<SystemResultStatus>(
                 static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
@@ -335,7 +362,7 @@ struct System::Impl {
         return status;
     }
 
-    void Shutdown() {
+    void ShutdownMainProcess() {
         SetShuttingDown(true);
 
         // Log last frame performance stats if game was loded
@@ -363,13 +390,14 @@ struct System::Impl {
         kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
+        services->KillNVNFlinger();
         kernel.CloseServices();
         services.reset();
         service_manager.reset();
         cheat_engine.reset();
         telemetry_session.reset();
         time_manager.Shutdown();
-        core_timing.Shutdown();
+        core_timing.ClearPendingEvents();
         app_loader.reset();
         audio_core.reset();
         gpu_core.reset();
@@ -377,7 +405,6 @@ struct System::Impl {
         perf_stats.reset();
         kernel.Shutdown();
         memory.Reset();
-        applet_manager.ClearAll();
 
         if (auto room_member = room_network.GetRoomMember().lock()) {
             Network::GameInfo game_info{};
@@ -500,6 +527,7 @@ struct System::Impl {
 
     bool is_multicore{};
     bool is_async_gpu{};
+    bool extended_memory_layout{};
 
     ExecuteProgramCallback execute_program_callback;
     ExitCallback exit_callback;
@@ -520,6 +548,10 @@ const CpuManager& System::GetCpuManager() const {
     return impl->cpu_manager;
 }
 
+void System::Initialize() {
+    impl->Initialize(*this);
+}
+
 SystemResultStatus System::Run() {
     return impl->Run();
 }
@@ -540,8 +572,8 @@ void System::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
     impl->kernel.InvalidateCpuInstructionCacheRange(addr, size);
 }
 
-void System::Shutdown() {
-    impl->Shutdown();
+void System::ShutdownMainProcess() {
+    impl->ShutdownMainProcess();
 }
 
 bool System::IsShuttingDown() const {

src/core/core.h

@@ -142,6 +142,12 @@ public:
     System(System&&) = delete;
     System& operator=(System&&) = delete;
 
+    /**
+     * Initializes the system
+     * This function will initialize core functionaility used for system emulation
+     */
+    void Initialize();
+
     /**
      * Run the OS and Application
      * This function will start emulation and run the relevant devices
@@ -166,8 +172,8 @@ public:
 
     void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
 
-    /// Shutdown the emulated system.
-    void Shutdown();
+    /// Shutdown the main emulated process.
+    void ShutdownMainProcess();
 
     /// Check if the core is shutting down.
     [[nodiscard]] bool IsShuttingDown() const;

src/core/core_timing.cpp

@@ -40,7 +40,9 @@ struct CoreTiming::Event {
 CoreTiming::CoreTiming()
     : clock{Common::CreateBestMatchingClock(Hardware::BASE_CLOCK_RATE, Hardware::CNTFREQ)} {}
 
-CoreTiming::~CoreTiming() = default;
+CoreTiming::~CoreTiming() {
+    Reset();
+}
 
 void CoreTiming::ThreadEntry(CoreTiming& instance) {
     constexpr char name[] = "HostTiming";
@@ -53,6 +55,7 @@ void CoreTiming::ThreadEntry(CoreTiming& instance) {
 }
 
 void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
+    Reset();
     on_thread_init = std::move(on_thread_init_);
     event_fifo_id = 0;
     shutting_down = false;
@@ -65,17 +68,8 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
     }
 }
 
-void CoreTiming::Shutdown() {
-    paused = true;
-    shutting_down = true;
-    pause_event.Set();
-    event.Set();
-    if (timer_thread) {
-        timer_thread->join();
-    }
-    ClearPendingEvents();
-    timer_thread.reset();
-    has_started = false;
+void CoreTiming::ClearPendingEvents() {
+    event_queue.clear();
 }
 
 void CoreTiming::Pause(bool is_paused) {
@@ -196,10 +190,6 @@ u64 CoreTiming::GetClockTicks() const {
     return CpuCyclesToClockCycles(ticks);
 }
 
-void CoreTiming::ClearPendingEvents() {
-    event_queue.clear();
-}
-
 void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
     std::scoped_lock lock{basic_lock};
 
@@ -270,6 +260,7 @@ void CoreTiming::ThreadLoop() {
                 // There are more events left in the queue, wait until the next event.
                 const auto wait_time = *next_time - GetGlobalTimeNs().count();
                 if (wait_time > 0) {
+#ifdef _WIN32
                     // Assume a timer resolution of 1ms.
                     static constexpr s64 TimerResolutionNS = 1000000;
 
@@ -287,6 +278,9 @@ void CoreTiming::ThreadLoop() {
                     if (event.IsSet()) {
                         event.Reset();
                     }
+#else
+                    event.WaitFor(std::chrono::nanoseconds(wait_time));
+#endif
                 }
             } else {
                 // Queue is empty, wait until another event is scheduled and signals us to continue.
@@ -303,6 +297,18 @@ void CoreTiming::ThreadLoop() {
     }
 }
 
+void CoreTiming::Reset() {
+    paused = true;
+    shutting_down = true;
+    pause_event.Set();
+    event.Set();
+    if (timer_thread) {
+        timer_thread->join();
+    }
+    timer_thread.reset();
+    has_started = false;
+}
+
 std::chrono::nanoseconds CoreTiming::GetGlobalTimeNs() const {
     if (is_multicore) {
         return clock->GetTimeNS();

src/core/core_timing.h

@@ -61,19 +61,14 @@ public:
     /// required to end slice - 1 and start slice 0 before the first cycle of code is executed.
     void Initialize(std::function<void()>&& on_thread_init_);
 
-    /// Tears down all timing related functionality.
-    void Shutdown();
+    /// Clear all pending events. This should ONLY be done on exit.
+    void ClearPendingEvents();
 
     /// Sets if emulation is multicore or single core, must be set before Initialize
     void SetMulticore(bool is_multicore_) {
         is_multicore = is_multicore_;
     }
 
-    /// Check if it's using host timing.
-    bool IsHostTiming() const {
-        return is_multicore;
-    }
-
     /// Pauses/Unpauses the execution of the timer thread.
     void Pause(bool is_paused);
 
@@ -136,12 +131,11 @@ public:
 private:
     struct Event;
 
-    /// Clear all pending events. This should ONLY be done on exit.
-    void ClearPendingEvents();
-
     static void ThreadEntry(CoreTiming& instance);
     void ThreadLoop();
 
+    void Reset();
+
     std::unique_ptr<Common::WallClock> clock;
 
     s64 global_timer = 0;

src/core/device_memory.h

@@ -31,12 +31,14 @@ public:
                DramMemoryMap::Base;
     }
 
-    u8* GetPointer(PAddr addr) {
-        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
+    template <typename T>
+    T* GetPointer(PAddr addr) {
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (addr - DramMemoryMap::Base));
     }
 
-    const u8* GetPointer(PAddr addr) const {
-        return buffer.BackingBasePointer() + (addr - DramMemoryMap::Base);
+    template <typename T>
+    const T* GetPointer(PAddr addr) const {
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (addr - DramMemoryMap::Base));
     }
 
     Common::HostMemory buffer;

src/core/file_sys/card_image.cpp

@@ -232,8 +232,8 @@ const std::vector<std::shared_ptr<NCA>>& XCI::GetNCAs() const {
 
 std::shared_ptr<NCA> XCI::GetNCAByType(NCAContentType type) const {
     const auto program_id = secure_partition->GetProgramTitleID();
-    const auto iter = std::find_if(
-        ncas.begin(), ncas.end(), [this, type, program_id](const std::shared_ptr<NCA>& nca) {
+    const auto iter =
+        std::find_if(ncas.begin(), ncas.end(), [type, program_id](const std::shared_ptr<NCA>& nca) {
             return nca->GetType() == type && nca->GetTitleId() == program_id;
         });
     return iter == ncas.end() ? nullptr : *iter;

src/core/file_sys/control_metadata.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/settings.h"
 #include "common/string_util.h"
 #include "common/swap.h"
 #include "core/file_sys/control_metadata.h"
@@ -37,6 +38,27 @@ std::string LanguageEntry::GetDeveloperName() const {
                                                        developer_name.size());
 }
 
+constexpr std::array<Language, 18> language_to_codes = {{
+    Language::Japanese,
+    Language::AmericanEnglish,
+    Language::French,
+    Language::German,
+    Language::Italian,
+    Language::Spanish,
+    Language::Chinese,
+    Language::Korean,
+    Language::Dutch,
+    Language::Portuguese,
+    Language::Russian,
+    Language::Taiwanese,
+    Language::BritishEnglish,
+    Language::CanadianFrench,
+    Language::LatinAmericanSpanish,
+    Language::Chinese,
+    Language::Taiwanese,
+    Language::BrazilianPortuguese,
+}};
+
 NACP::NACP() = default;
 
 NACP::NACP(VirtualFile file) {
@@ -45,9 +67,13 @@ NACP::NACP(VirtualFile file) {
 
 NACP::~NACP() = default;
 
-const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
-    if (language != Language::Default) {
-        return raw.language_entries.at(static_cast<u8>(language));
+const LanguageEntry& NACP::GetLanguageEntry() const {
+    Language language = language_to_codes[Settings::values.language_index.GetValue()];
+
+    {
+        const auto& language_entry = raw.language_entries.at(static_cast<u8>(language));
+        if (!language_entry.GetApplicationName().empty())
+            return language_entry;
     }
 
     for (const auto& language_entry : raw.language_entries) {
@@ -55,16 +81,15 @@ const LanguageEntry& NACP::GetLanguageEntry(Language language) const {
             return language_entry;
     }
 
-    // Fallback to English
-    return GetLanguageEntry(Language::AmericanEnglish);
+    return raw.language_entries.at(static_cast<u8>(Language::AmericanEnglish));
 }
 
-std::string NACP::GetApplicationName(Language language) const {
-    return GetLanguageEntry(language).GetApplicationName();
+std::string NACP::GetApplicationName() const {
+    return GetLanguageEntry().GetApplicationName();
 }
 
-std::string NACP::GetDeveloperName(Language language) const {
-    return GetLanguageEntry(language).GetDeveloperName();
+std::string NACP::GetDeveloperName() const {
+    return GetLanguageEntry().GetDeveloperName();
 }
 
 u64 NACP::GetTitleId() const {

src/core/file_sys/control_metadata.h

@@ -101,9 +101,9 @@ public:
     explicit NACP(VirtualFile file);
     ~NACP();
 
-    const LanguageEntry& GetLanguageEntry(Language language = Language::Default) const;
-    std::string GetApplicationName(Language language = Language::Default) const;
-    std::string GetDeveloperName(Language language = Language::Default) const;
+    const LanguageEntry& GetLanguageEntry() const;
+    std::string GetApplicationName() const;
+    std::string GetDeveloperName() const;
     u64 GetTitleId() const;
     u64 GetDLCBaseTitleId() const;
     std::string GetVersionString() const;

src/core/file_sys/program_metadata.cpp

@@ -127,7 +127,7 @@ void ProgramMetadata::LoadManual(bool is_64_bit, ProgramAddressSpaceType address
 }
 
 bool ProgramMetadata::Is64BitProgram() const {
-    return npdm_header.has_64_bit_instructions;
+    return npdm_header.has_64_bit_instructions.As<bool>();
 }
 
 ProgramAddressSpaceType ProgramMetadata::GetAddressSpaceType() const {

src/core/file_sys/savedata_factory.cpp

@@ -5,6 +5,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "common/uuid.h"
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs.h"
@@ -59,6 +60,36 @@ bool ShouldSaveDataBeAutomaticallyCreated(SaveDataSpaceId space, const SaveDataA
             attr.title_id == 0 && attr.save_id == 0);
 }
 
+std::string GetFutureSaveDataPath(SaveDataSpaceId space_id, SaveDataType type, u64 title_id,
+                                  u128 user_id) {
+    // Only detect nand user saves.
+    const auto space_id_path = [space_id]() -> std::string_view {
+        switch (space_id) {
+        case SaveDataSpaceId::NandUser:
+            return "/user/save";
+        default:
+            return "";
+        }
+    }();
+
+    if (space_id_path.empty()) {
+        return "";
+    }
+
+    Common::UUID uuid;
+    std::memcpy(uuid.uuid.data(), user_id.data(), sizeof(Common::UUID));
+
+    // Only detect account/device saves from the future location.
+    switch (type) {
+    case SaveDataType::SaveData:
+        return fmt::format("{}/account/{}/{:016X}/1", space_id_path, uuid.RawString(), title_id);
+    case SaveDataType::DeviceSaveData:
+        return fmt::format("{}/device/{:016X}/1", space_id_path, title_id);
+    default:
+        return "";
+    }
+}
+
 } // Anonymous namespace
 
 std::string SaveDataAttribute::DebugInfo() const {
@@ -82,7 +113,7 @@ ResultVal<VirtualDir> SaveDataFactory::Create(SaveDataSpaceId space,
     PrintSaveDataAttributeWarnings(meta);
 
     const auto save_directory =
-        GetFullPath(system, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+        GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
     auto out = dir->CreateDirectoryRelative(save_directory);
 
@@ -99,7 +130,7 @@ ResultVal<VirtualDir> SaveDataFactory::Open(SaveDataSpaceId space,
                                             const SaveDataAttribute& meta) const {
 
     const auto save_directory =
-        GetFullPath(system, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
+        GetFullPath(system, dir, space, meta.type, meta.title_id, meta.user_id, meta.save_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
@@ -134,9 +165,9 @@ std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
     }
 }
 
-std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId space,
-                                         SaveDataType type, u64 title_id, u128 user_id,
-                                         u64 save_id) {
+std::string SaveDataFactory::GetFullPath(Core::System& system, VirtualDir dir,
+                                         SaveDataSpaceId space, SaveDataType type, u64 title_id,
+                                         u128 user_id, u64 save_id) {
     // According to switchbrew, if a save is of type SaveData and the title id field is 0, it should
     // be interpreted as the title id of the current process.
     if (type == SaveDataType::SaveData || type == SaveDataType::DeviceSaveData) {
@@ -145,6 +176,17 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId s
         }
     }
 
+    // For compat with a future impl.
+    if (std::string future_path =
+            GetFutureSaveDataPath(space, type, title_id & ~(0xFFULL), user_id);
+        !future_path.empty()) {
+        // Check if this location exists, and prefer it over the old.
+        if (const auto future_dir = dir->GetDirectoryRelative(future_path); future_dir != nullptr) {
+            LOG_INFO(Service_FS, "Using save at new location: {}", future_path);
+            return future_path;
+        }
+    }
+
     std::string out = GetSaveDataSpaceIdPath(space);
 
     switch (type) {
@@ -167,7 +209,8 @@ std::string SaveDataFactory::GetFullPath(Core::System& system, SaveDataSpaceId s
 
 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                                u128 user_id) const {
-    const auto path = GetFullPath(system, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(system, dir, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->GetFile(SAVE_DATA_SIZE_FILENAME);
@@ -185,7 +228,8 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 
 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                         SaveDataSize new_value) const {
-    const auto path = GetFullPath(system, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(system, dir, SaveDataSpaceId::NandUser, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->CreateFile(SAVE_DATA_SIZE_FILENAME);

src/core/file_sys/savedata_factory.h

@@ -95,8 +95,8 @@ public:
     VirtualDir GetSaveDataSpaceDirectory(SaveDataSpaceId space) const;
 
     static std::string GetSaveDataSpaceIdPath(SaveDataSpaceId space);
-    static std::string GetFullPath(Core::System& system, SaveDataSpaceId space, SaveDataType type,
-                                   u64 title_id, u128 user_id, u64 save_id);
+    static std::string GetFullPath(Core::System& system, VirtualDir dir, SaveDataSpaceId space,
+                                   SaveDataType type, u64 title_id, u128 user_id, u64 save_id);
 
     SaveDataSize ReadSaveDataSize(SaveDataType type, u64 title_id, u128 user_id) const;
     void WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,

src/core/frontend/framebuffer_layout.cpp

@@ -67,6 +67,8 @@ float EmulationAspectRatio(AspectRatio aspect, float window_aspect_ratio) {
         return 3.0f / 4.0f;
     case AspectRatio::R21_9:
         return 9.0f / 21.0f;
+    case AspectRatio::R16_10:
+        return 10.0f / 16.0f;
     case AspectRatio::StretchToWindow:
         return window_aspect_ratio;
     default:

src/core/frontend/framebuffer_layout.h

@@ -27,6 +27,7 @@ enum class AspectRatio {
     Default,
     R4_3,
     R21_9,
+    R16_10,
     StretchToWindow,
 };
 

src/core/hid/emulated_controller.cpp

@@ -970,14 +970,7 @@ bool EmulatedController::SetVibration(std::size_t device_index, VibrationValue v
            Common::Input::VibrationError::None;
 }
 
-bool EmulatedController::TestVibration(std::size_t device_index) {
-    if (device_index >= output_devices.size()) {
-        return false;
-    }
-    if (!output_devices[device_index]) {
-        return false;
-    }
-
+bool EmulatedController::IsVibrationEnabled(std::size_t device_index) {
     const auto player_index = NpadIdTypeToIndex(npad_id_type);
     const auto& player = Settings::values.players.GetValue()[player_index];
 
@@ -985,31 +978,15 @@ bool EmulatedController::TestVibration(std::size_t device_index) {
         return false;
     }
 
-    const Common::Input::VibrationStatus test_vibration = {
-        .low_amplitude = 0.001f,
-        .low_frequency = DEFAULT_VIBRATION_VALUE.low_frequency,
-        .high_amplitude = 0.001f,
-        .high_frequency = DEFAULT_VIBRATION_VALUE.high_frequency,
-        .type = Common::Input::VibrationAmplificationType::Test,
-    };
+    if (device_index >= output_devices.size()) {
+        return false;
+    }
 
-    const Common::Input::VibrationStatus zero_vibration = {
-        .low_amplitude = DEFAULT_VIBRATION_VALUE.low_amplitude,
-        .low_frequency = DEFAULT_VIBRATION_VALUE.low_frequency,
-        .high_amplitude = DEFAULT_VIBRATION_VALUE.high_amplitude,
-        .high_frequency = DEFAULT_VIBRATION_VALUE.high_frequency,
-        .type = Common::Input::VibrationAmplificationType::Test,
-    };
+    if (!output_devices[device_index]) {
+        return false;
+    }
 
-    // Send a slight vibration to test for rumble support
-    output_devices[device_index]->SetVibration(test_vibration);
-
-    // Wait for about 15ms to ensure the controller is ready for the stop command
-    std::this_thread::sleep_for(std::chrono::milliseconds(15));
-
-    // Stop any vibration and return the result
-    return output_devices[device_index]->SetVibration(zero_vibration) ==
-           Common::Input::VibrationError::None;
+    return output_devices[device_index]->IsVibrationEnabled();
 }
 
 bool EmulatedController::SetPollingMode(Common::Input::PollingMode polling_mode) {
@@ -1048,6 +1025,7 @@ bool EmulatedController::HasNfc() const {
     case NpadStyleIndex::JoyconRight:
     case NpadStyleIndex::JoyconDual:
     case NpadStyleIndex::ProController:
+    case NpadStyleIndex::Handheld:
         break;
     default:
         return false;
@@ -1158,27 +1136,27 @@ bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
     const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
     switch (type) {
     case NpadStyleIndex::ProController:
-        return supported_style_tag.fullkey;
+        return supported_style_tag.fullkey.As<bool>();
     case NpadStyleIndex::Handheld:
-        return supported_style_tag.handheld;
+        return supported_style_tag.handheld.As<bool>();
     case NpadStyleIndex::JoyconDual:
-        return supported_style_tag.joycon_dual;
+        return supported_style_tag.joycon_dual.As<bool>();
     case NpadStyleIndex::JoyconLeft:
-        return supported_style_tag.joycon_left;
+        return supported_style_tag.joycon_left.As<bool>();
     case NpadStyleIndex::JoyconRight:
-        return supported_style_tag.joycon_right;
+        return supported_style_tag.joycon_right.As<bool>();
     case NpadStyleIndex::GameCube:
-        return supported_style_tag.gamecube;
+        return supported_style_tag.gamecube.As<bool>();
     case NpadStyleIndex::Pokeball:
-        return supported_style_tag.palma;
+        return supported_style_tag.palma.As<bool>();
     case NpadStyleIndex::NES:
-        return supported_style_tag.lark;
+        return supported_style_tag.lark.As<bool>();
     case NpadStyleIndex::SNES:
-        return supported_style_tag.lucia;
+        return supported_style_tag.lucia.As<bool>();
     case NpadStyleIndex::N64:
-        return supported_style_tag.lagoon;
+        return supported_style_tag.lagoon.As<bool>();
     case NpadStyleIndex::SegaGenesis:
-        return supported_style_tag.lager;
+        return supported_style_tag.lager.As<bool>();
     default:
         return false;
     }
@@ -1234,12 +1212,6 @@ bool EmulatedController::IsConnected(bool get_temporary_value) const {
     return is_connected;
 }
 
-bool EmulatedController::IsVibrationEnabled() const {
-    const auto player_index = NpadIdTypeToIndex(npad_id_type);
-    const auto& player = Settings::values.players.GetValue()[player_index];
-    return player.vibration_enabled;
-}
-
 NpadIdType EmulatedController::GetNpadIdType() const {
     std::scoped_lock lock{mutex};
     return npad_id_type;

src/core/hid/emulated_controller.h

@@ -206,9 +206,6 @@ public:
      */
     bool IsConnected(bool get_temporary_value = false) const;
 
-    /// Returns true if vibration is enabled
-    bool IsVibrationEnabled() const;
-
     /// Removes all callbacks created from input devices
     void UnloadInput();
 
@@ -339,7 +336,7 @@ public:
      * Sends a small vibration to the output device
      * @return true if SetVibration was successfull
      */
-    bool TestVibration(std::size_t device_index);
+    bool IsVibrationEnabled(std::size_t device_index);
 
     /**
      * Sets the desired data to be polled from a controller

src/core/hid/input_converter.cpp

@@ -277,7 +277,10 @@ Common::Input::CameraStatus TransformToCamera(const Common::Input::CallbackStatu
     Common::Input::CameraStatus camera{};
     switch (callback.type) {
     case Common::Input::InputType::IrSensor:
-        camera = callback.camera_status;
+        camera = {
+            .format = callback.camera_status,
+            .data = callback.raw_data,
+        };
         break;
     default:
         LOG_ERROR(Input, "Conversion from type {} to camera not implemented", callback.type);
@@ -291,7 +294,10 @@ Common::Input::NfcStatus TransformToNfc(const Common::Input::CallbackStatus& cal
     Common::Input::NfcStatus nfc{};
     switch (callback.type) {
     case Common::Input::InputType::Nfc:
-        return callback.nfc_status;
+        nfc = {
+            .state = callback.nfc_status,
+            .data = callback.raw_data,
+        };
         break;
     default:
         LOG_ERROR(Input, "Conversion from type {} to NFC not implemented", callback.type);

src/core/hid/irs_types.h

@@ -14,7 +14,7 @@ enum class CameraAmbientNoiseLevel : u32 {
     Low,
     Medium,
     High,
-    Unkown3, // This level can't be reached
+    Unknown3, // This level can't be reached
 };
 
 // This is nn::irsensor::CameraLightTarget
@@ -75,9 +75,9 @@ enum class IrCameraStatus : u32 {
 enum class IrCameraInternalStatus : u32 {
     Stopped,
     FirmwareUpdateNeeded,
-    Unkown2,
-    Unkown3,
-    Unkown4,
+    Unknown2,
+    Unknown3,
+    Unknown4,
     FirmwareVersionRequested,
     FirmwareVersionIsInvalid,
     Ready,
@@ -121,20 +121,20 @@ enum class IrSensorFunctionLevel : u8 {
 
 // This is nn::irsensor::MomentProcessorPreprocess
 enum class MomentProcessorPreprocess : u32 {
-    Unkown0,
-    Unkown1,
+    Unknown0,
+    Unknown1,
 };
 
 // This is nn::irsensor::PackedMomentProcessorPreprocess
 enum class PackedMomentProcessorPreprocess : u8 {
-    Unkown0,
-    Unkown1,
+    Unknown0,
+    Unknown1,
 };
 
 // This is nn::irsensor::PointingStatus
 enum class PointingStatus : u32 {
-    Unkown0,
-    Unkown1,
+    Unknown0,
+    Unknown1,
 };
 
 struct IrsRect {

src/core/hle/ipc_helpers.h

@@ -86,13 +86,13 @@ public:
         u32 num_domain_objects{};
         const bool always_move_handles{
             (static_cast<u32>(flags) & static_cast<u32>(Flags::AlwaysMoveHandles)) != 0};
-        if (!ctx.Session()->IsDomain() || always_move_handles) {
+        if (!ctx.Session()->GetSessionRequestManager()->IsDomain() || always_move_handles) {
             num_handles_to_move = num_objects_to_move;
         } else {
             num_domain_objects = num_objects_to_move;
         }
 
-        if (ctx.Session()->IsDomain()) {
+        if (ctx.Session()->GetSessionRequestManager()->IsDomain()) {
             raw_data_size +=
                 static_cast<u32>(sizeof(DomainMessageHeader) / sizeof(u32) + num_domain_objects);
             ctx.write_size += num_domain_objects;
@@ -125,7 +125,8 @@ public:
         if (!ctx.IsTipc()) {
             AlignWithPadding();
 
-            if (ctx.Session()->IsDomain() && ctx.HasDomainMessageHeader()) {
+            if (ctx.Session()->GetSessionRequestManager()->IsDomain() &&
+                ctx.HasDomainMessageHeader()) {
                 IPC::DomainMessageHeader domain_header{};
                 domain_header.num_objects = num_domain_objects;
                 PushRaw(domain_header);
@@ -145,14 +146,15 @@ public:
 
     template <class T>
     void PushIpcInterface(std::shared_ptr<T> iface) {
-        if (context->Session()->IsDomain()) {
+        if (context->Session()->GetSessionRequestManager()->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
             kernel.CurrentProcess()->GetResourceLimit()->Reserve(
                 Kernel::LimitableResource::Sessions, 1);
 
             auto* session = Kernel::KSession::Create(kernel);
-            session->Initialize(nullptr, iface->GetServiceName());
+            session->Initialize(nullptr, iface->GetServiceName(),
+                                std::make_shared<Kernel::SessionRequestManager>(kernel));
 
             context->AddMoveObject(&session->GetClientSession());
             iface->ClientConnected(&session->GetServerSession());
@@ -385,7 +387,7 @@ public:
 
     template <class T>
     std::weak_ptr<T> PopIpcInterface() {
-        ASSERT(context->Session()->IsDomain());
+        ASSERT(context->Session()->GetSessionRequestManager()->IsDomain());
         ASSERT(context->GetDomainMessageHeader().input_object_count > 0);
         return context->GetDomainHandler<T>(Pop<u32>() - 1);
     }
@@ -404,7 +406,7 @@ inline s32 RequestParser::Pop() {
 }
 
 // Ignore the -Wclass-memaccess warning on memcpy for non-trivially default constructible objects.
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wclass-memaccess"
 #endif
@@ -415,7 +417,7 @@ void RequestParser::PopRaw(T& value) {
     std::memcpy(&value, cmdbuf + index, sizeof(T));
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
-#if defined(__GNUC__)
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
 #pragma GCC diagnostic pop
 #endif
 

src/core/hle/kernel/global_scheduler_context.cpp

@@ -49,4 +49,26 @@ bool GlobalSchedulerContext::IsLocked() const {
     return scheduler_lock.IsLockedByCurrentThread();
 }
 
+void GlobalSchedulerContext::RegisterDummyThreadForWakeup(KThread* thread) {
+    ASSERT(IsLocked());
+
+    woken_dummy_threads.insert(thread);
+}
+
+void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) {
+    ASSERT(IsLocked());
+
+    woken_dummy_threads.erase(thread);
+}
+
+void GlobalSchedulerContext::WakeupWaitingDummyThreads() {
+    ASSERT(IsLocked());
+
+    for (auto* thread : woken_dummy_threads) {
+        thread->DummyThreadEndWait();
+    }
+
+    woken_dummy_threads.clear();
+}
+
 } // namespace Kernel

src/core/hle/kernel/global_scheduler_context.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <atomic>
+#include <set>
 #include <vector>
 
 #include "common/common_types.h"
@@ -58,6 +59,10 @@ public:
     /// Returns true if the global scheduler lock is acquired
     bool IsLocked() const;
 
+    void UnregisterDummyThreadForWakeup(KThread* thread);
+    void RegisterDummyThreadForWakeup(KThread* thread);
+    void WakeupWaitingDummyThreads();
+
     [[nodiscard]] LockType& SchedulerLock() {
         return scheduler_lock;
     }
@@ -76,6 +81,9 @@ private:
     KSchedulerPriorityQueue priority_queue;
     LockType scheduler_lock;
 
+    /// Lists dummy threads pending wakeup on lock release
+    std::set<KThread*> woken_dummy_threads;
+
     /// Lists all thread ids that aren't deleted/etc.
     std::vector<KThread*> thread_list;
     std::mutex global_list_guard;

src/core/hle/kernel/hle_ipc.cpp

@@ -19,6 +19,7 @@
 #include "core/hle/kernel/k_server_session.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/service_thread.h"
 #include "core/memory.h"
 
 namespace Kernel {
@@ -56,16 +57,103 @@ bool SessionRequestManager::HasSessionRequestHandler(const HLERequestContext& co
     }
 }
 
+Result SessionRequestManager::CompleteSyncRequest(KServerSession* server_session,
+                                                  HLERequestContext& context) {
+    Result result = ResultSuccess;
+
+    // If the session has been converted to a domain, handle the domain request
+    if (this->HasSessionRequestHandler(context)) {
+        if (IsDomain() && context.HasDomainMessageHeader()) {
+            result = HandleDomainSyncRequest(server_session, context);
+            // If there is no domain header, the regular session handler is used
+        } else if (this->HasSessionHandler()) {
+            // If this manager has an associated HLE handler, forward the request to it.
+            result = this->SessionHandler().HandleSyncRequest(*server_session, context);
+        }
+    } else {
+        ASSERT_MSG(false, "Session handler is invalid, stubbing response!");
+        IPC::ResponseBuilder rb(context, 2);
+        rb.Push(ResultSuccess);
+    }
+
+    if (convert_to_domain) {
+        ASSERT_MSG(!IsDomain(), "ServerSession is already a domain instance.");
+        this->ConvertToDomain();
+        convert_to_domain = false;
+    }
+
+    return result;
+}
+
+Result SessionRequestManager::HandleDomainSyncRequest(KServerSession* server_session,
+                                                      HLERequestContext& context) {
+    if (!context.HasDomainMessageHeader()) {
+        return ResultSuccess;
+    }
+
+    // Set domain handlers in HLE context, used for domain objects (IPC interfaces) as inputs
+    context.SetSessionRequestManager(server_session->GetSessionRequestManager());
+
+    // If there is a DomainMessageHeader, then this is CommandType "Request"
+    const auto& domain_message_header = context.GetDomainMessageHeader();
+    const u32 object_id{domain_message_header.object_id};
+    switch (domain_message_header.command) {
+    case IPC::DomainMessageHeader::CommandType::SendMessage:
+        if (object_id > this->DomainHandlerCount()) {
+            LOG_CRITICAL(IPC,
+                         "object_id {} is too big! This probably means a recent service call "
+                         "needed to return a new interface!",
+                         object_id);
+            ASSERT(false);
+            return ResultSuccess; // Ignore error if asserts are off
+        }
+        if (auto strong_ptr = this->DomainHandler(object_id - 1).lock()) {
+            return strong_ptr->HandleSyncRequest(*server_session, context);
+        } else {
+            ASSERT(false);
+            return ResultSuccess;
+        }
+
+    case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
+        LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x{:08X}", object_id);
+
+        this->CloseDomainHandler(object_id - 1);
+
+        IPC::ResponseBuilder rb{context, 2};
+        rb.Push(ResultSuccess);
+        return ResultSuccess;
+    }
+    }
+
+    LOG_CRITICAL(IPC, "Unknown domain command={}", domain_message_header.command.Value());
+    ASSERT(false);
+    return ResultSuccess;
+}
+
+Result SessionRequestManager::QueueSyncRequest(KSession* parent,
+                                               std::shared_ptr<HLERequestContext>&& context) {
+    // Ensure we have a session request handler
+    if (this->HasSessionRequestHandler(*context)) {
+        if (auto strong_ptr = this->GetServiceThread().lock()) {
+            strong_ptr->QueueSyncRequest(*parent, std::move(context));
+        } else {
+            ASSERT_MSG(false, "strong_ptr is nullptr!");
+        }
+    } else {
+        ASSERT_MSG(false, "handler is invalid!");
+    }
+
+    return ResultSuccess;
+}
+
 void SessionRequestHandler::ClientConnected(KServerSession* session) {
-    session->ClientConnected(shared_from_this());
+    session->GetSessionRequestManager()->SetSessionHandler(shared_from_this());
 
     // Ensure our server session is tracked globally.
     kernel.RegisterServerObject(session);
 }
 
-void SessionRequestHandler::ClientDisconnected(KServerSession* session) {
-    session->ClientDisconnected();
-}
+void SessionRequestHandler::ClientDisconnected(KServerSession* session) {}
 
 HLERequestContext::HLERequestContext(KernelCore& kernel_, Core::Memory::Memory& memory_,
                                      KServerSession* server_session_, KThread* thread_)
@@ -126,7 +214,7 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
         // Padding to align to 16 bytes
         rp.AlignWithPadding();
 
-        if (Session()->IsDomain() &&
+        if (Session()->GetSessionRequestManager()->IsDomain() &&
             ((command_header->type == IPC::CommandType::Request ||
               command_header->type == IPC::CommandType::RequestWithContext) ||
              !incoming)) {
@@ -135,7 +223,7 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
             if (incoming || domain_message_header) {
                 domain_message_header = rp.PopRaw<IPC::DomainMessageHeader>();
             } else {
-                if (Session()->IsDomain()) {
+                if (Session()->GetSessionRequestManager()->IsDomain()) {
                     LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
                 }
             }
@@ -228,12 +316,12 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_threa
     // Write the domain objects to the command buffer, these go after the raw untranslated data.
     // TODO(Subv): This completely ignores C buffers.
 
-    if (Session()->IsDomain()) {
+    if (server_session->GetSessionRequestManager()->IsDomain()) {
         current_offset = domain_offset - static_cast<u32>(outgoing_domain_objects.size());
-        for (const auto& object : outgoing_domain_objects) {
-            server_session->AppendDomainHandler(object);
-            cmd_buf[current_offset++] =
-                static_cast<u32_le>(server_session->NumDomainRequestHandlers());
+        for (auto& object : outgoing_domain_objects) {
+            server_session->GetSessionRequestManager()->AppendDomainHandler(std::move(object));
+            cmd_buf[current_offset++] = static_cast<u32_le>(
+                server_session->GetSessionRequestManager()->DomainHandlerCount());
         }
     }
 

src/core/hle/kernel/hle_ipc.h

@@ -43,13 +43,13 @@ class Domain;
 class HLERequestContext;
 class KAutoObject;
 class KernelCore;
+class KEvent;
 class KHandleTable;
 class KProcess;
 class KServerSession;
 class KThread;
 class KReadableEvent;
 class KSession;
-class KWritableEvent;
 class ServiceThread;
 
 enum class ThreadWakeupReason;
@@ -121,6 +121,10 @@ public:
         is_domain = true;
     }
 
+    void ConvertToDomainOnRequestEnd() {
+        convert_to_domain = true;
+    }
+
     std::size_t DomainHandlerCount() const {
         return domain_handlers.size();
     }
@@ -164,7 +168,12 @@ public:
 
     bool HasSessionRequestHandler(const HLERequestContext& context) const;
 
+    Result HandleDomainSyncRequest(KServerSession* server_session, HLERequestContext& context);
+    Result CompleteSyncRequest(KServerSession* server_session, HLERequestContext& context);
+    Result QueueSyncRequest(KSession* parent, std::shared_ptr<HLERequestContext>&& context);
+
 private:
+    bool convert_to_domain{};
     bool is_domain{};
     SessionRequestHandlerPtr session_handler;
     std::vector<SessionRequestHandlerPtr> domain_handlers;
@@ -295,7 +304,7 @@ public:
      */
     template <typename T, typename = std::enable_if_t<!std::is_pointer_v<T>>>
     std::size_t WriteBuffer(const T& data, std::size_t buffer_index = 0) const {
-        if constexpr (Common::IsSTLContainer<T>) {
+        if constexpr (Common::IsContiguousContainer<T>) {
             using ContiguousType = typename T::value_type;
             static_assert(std::is_trivially_copyable_v<ContiguousType>,
                           "Container to WriteBuffer must contain trivially copyable objects");

src/core/hle/kernel/init/init_slab_setup.cpp

@@ -18,6 +18,7 @@
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_session.h"
+#include "core/hle/kernel/k_session_request.h"
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/k_shared_memory_info.h"
 #include "core/hle/kernel/k_system_control.h"
@@ -34,6 +35,7 @@ namespace Kernel::Init {
     HANDLER(KThread, (SLAB_COUNT(KThread)), ##__VA_ARGS__)                                         \
     HANDLER(KEvent, (SLAB_COUNT(KEvent)), ##__VA_ARGS__)                                           \
     HANDLER(KPort, (SLAB_COUNT(KPort)), ##__VA_ARGS__)                                             \
+    HANDLER(KSessionRequest, (SLAB_COUNT(KSession) * 2), ##__VA_ARGS__)                            \
     HANDLER(KSharedMemory, (SLAB_COUNT(KSharedMemory)), ##__VA_ARGS__)                             \
     HANDLER(KSharedMemoryInfo, (SLAB_COUNT(KSharedMemory) * 8), ##__VA_ARGS__)                     \
     HANDLER(KTransferMemory, (SLAB_COUNT(KTransferMemory)), ##__VA_ARGS__)                         \
@@ -94,8 +96,8 @@ VAddr InitializeSlabHeap(Core::System& system, KMemoryLayout& memory_layout, VAd
     // TODO(bunnei): Fix this once we support the kernel virtual memory layout.
 
     if (size > 0) {
-        void* backing_kernel_memory{
-            system.DeviceMemory().GetPointer(TranslateSlabAddrToPhysical(memory_layout, start))};
+        void* backing_kernel_memory{system.DeviceMemory().GetPointer<void>(
+            TranslateSlabAddrToPhysical(memory_layout, start))};
 
         const KMemoryRegion* region = memory_layout.FindVirtual(start + size - 1);
         ASSERT(region != nullptr);
@@ -181,7 +183,7 @@ void InitializeKPageBufferSlabHeap(Core::System& system) {
     ASSERT(slab_address != 0);
 
     // Initialize the slabheap.
-    KPageBuffer::InitializeSlabHeap(kernel, system.DeviceMemory().GetPointer(slab_address),
+    KPageBuffer::InitializeSlabHeap(kernel, system.DeviceMemory().GetPointer<void>(slab_address),
                                     slab_size);
 }
 

src/core/hle/kernel/k_class_token.cpp

@@ -18,7 +18,6 @@
 #include "core/hle/kernel/k_synchronization_object.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_transfer_memory.h"
-#include "core/hle/kernel/k_writable_event.h"
 
 namespace Kernel {
 
@@ -42,13 +41,12 @@ static_assert(ClassToken<KPort> == 0b10000101'00000000);
 static_assert(ClassToken<KSession> == 0b00011001'00000000);
 static_assert(ClassToken<KSharedMemory> == 0b00101001'00000000);
 static_assert(ClassToken<KEvent> == 0b01001001'00000000);
-static_assert(ClassToken<KWritableEvent> == 0b10001001'00000000);
 // static_assert(ClassToken<KLightClientSession> == 0b00110001'00000000);
 // static_assert(ClassToken<KLightServerSession> == 0b01010001'00000000);
-static_assert(ClassToken<KTransferMemory> == 0b10010001'00000000);
+static_assert(ClassToken<KTransferMemory> == 0b01010001'00000000);
 // static_assert(ClassToken<KDeviceAddressSpace> == 0b01100001'00000000);
 // static_assert(ClassToken<KSessionRequest> == 0b10100001'00000000);
-static_assert(ClassToken<KCodeMemory> == 0b11000001'00000000);
+static_assert(ClassToken<KCodeMemory> == 0b10100001'00000000);
 
 // Ensure that the token hierarchy is correct.
 
@@ -73,13 +71,12 @@ static_assert(ClassToken<KPort> == ((0b10000101 << 8) | ClassToken<KAutoObject>)
 static_assert(ClassToken<KSession> == ((0b00011001 << 8) | ClassToken<KAutoObject>));
 static_assert(ClassToken<KSharedMemory> == ((0b00101001 << 8) | ClassToken<KAutoObject>));
 static_assert(ClassToken<KEvent> == ((0b01001001 << 8) | ClassToken<KAutoObject>));
-static_assert(ClassToken<KWritableEvent> == ((0b10001001 << 8) | ClassToken<KAutoObject>));
 // static_assert(ClassToken<KLightClientSession> == ((0b00110001 << 8) | ClassToken<KAutoObject>));
 // static_assert(ClassToken<KLightServerSession> == ((0b01010001 << 8) | ClassToken<KAutoObject>));
-static_assert(ClassToken<KTransferMemory> == ((0b10010001 << 8) | ClassToken<KAutoObject>));
+static_assert(ClassToken<KTransferMemory> == ((0b01010001 << 8) | ClassToken<KAutoObject>));
 // static_assert(ClassToken<KDeviceAddressSpace> == ((0b01100001 << 8) | ClassToken<KAutoObject>));
 // static_assert(ClassToken<KSessionRequest> == ((0b10100001 << 8) | ClassToken<KAutoObject>));
-static_assert(ClassToken<KCodeMemory> == ((0b11000001 << 8) | ClassToken<KAutoObject>));
+static_assert(ClassToken<KCodeMemory> == ((0b10100001 << 8) | ClassToken<KAutoObject>));
 
 // Ensure that the token hierarchy reflects the class hierarchy.
 
@@ -110,7 +107,6 @@ static_assert(std::is_final_v<KPort> && std::is_base_of_v<KAutoObject, KPort>);
 static_assert(std::is_final_v<KSession> && std::is_base_of_v<KAutoObject, KSession>);
 static_assert(std::is_final_v<KSharedMemory> && std::is_base_of_v<KAutoObject, KSharedMemory>);
 static_assert(std::is_final_v<KEvent> && std::is_base_of_v<KAutoObject, KEvent>);
-static_assert(std::is_final_v<KWritableEvent> && std::is_base_of_v<KAutoObject, KWritableEvent>);
 // static_assert(std::is_final_v<KLightClientSession> &&
 //              std::is_base_of_v<KAutoObject, KLightClientSession>);
 // static_assert(std::is_final_v<KLightServerSession> &&

src/core/hle/kernel/k_class_token.h

@@ -101,7 +101,6 @@ public:
         KSession,
         KSharedMemory,
         KEvent,
-        KWritableEvent,
         KLightClientSession,
         KLightServerSession,
         KTransferMemory,

src/core/hle/kernel/k_client_session.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "common/scope_exit.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/kernel/k_client_session.h"
 #include "core/hle/kernel/k_server_session.h"
@@ -10,6 +11,8 @@
 
 namespace Kernel {
 
+static constexpr u32 MessageBufferSize = 0x100;
+
 KClientSession::KClientSession(KernelCore& kernel_)
     : KAutoObjectWithSlabHeapAndContainer{kernel_} {}
 KClientSession::~KClientSession() = default;
@@ -21,10 +24,17 @@ void KClientSession::Destroy() {
 
 void KClientSession::OnServerClosed() {}
 
-Result KClientSession::SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                                       Core::Timing::CoreTiming& core_timing) {
-    // Signal the server session that new data is available
-    return parent->GetServerSession().HandleSyncRequest(thread, memory, core_timing);
+Result KClientSession::SendSyncRequest() {
+    // Create a session request.
+    KSessionRequest* request = KSessionRequest::Create(kernel);
+    R_UNLESS(request != nullptr, ResultOutOfResource);
+    SCOPE_EXIT({ request->Close(); });
+
+    // Initialize the request.
+    request->Initialize(nullptr, GetCurrentThread(kernel).GetTLSAddress(), MessageBufferSize);
+
+    // Send the request.
+    return parent->GetServerSession().OnRequest(request);
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_client_session.h

@@ -46,8 +46,7 @@ public:
         return parent;
     }
 
-    Result SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                           Core::Timing::CoreTiming& core_timing);
+    Result SendSyncRequest();
 
     void OnServerClosed();
 

src/core/hle/kernel/k_code_memory.cpp

@@ -34,7 +34,7 @@ Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, si
 
     // Clear the memory.
     for (const auto& block : m_page_group.Nodes()) {
-        std::memset(device_memory.GetPointer(block.GetAddress()), 0xFF, block.GetSize());
+        std::memset(device_memory.GetPointer<void>(block.GetAddress()), 0xFF, block.GetSize());
     }
 
     // Set remaining tracking members.

src/core/hle/kernel/k_dynamic_page_manager.h

@@ -0,0 +1,136 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/alignment.h"
+#include "common/common_types.h"
+#include "core/hle/kernel/k_page_bitmap.h"
+#include "core/hle/kernel/k_spin_lock.h"
+#include "core/hle/kernel/memory_types.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+
+class KDynamicPageManager {
+public:
+    class PageBuffer {
+    private:
+        u8 m_buffer[PageSize];
+    };
+    static_assert(sizeof(PageBuffer) == PageSize);
+
+public:
+    KDynamicPageManager() = default;
+
+    template <typename T>
+    T* GetPointer(VAddr addr) {
+        return reinterpret_cast<T*>(m_backing_memory.data() + (addr - m_address));
+    }
+
+    template <typename T>
+    const T* GetPointer(VAddr addr) const {
+        return reinterpret_cast<T*>(m_backing_memory.data() + (addr - m_address));
+    }
+
+    Result Initialize(VAddr addr, size_t sz) {
+        // We need to have positive size.
+        R_UNLESS(sz > 0, ResultOutOfMemory);
+        m_backing_memory.resize(sz);
+
+        // Calculate management overhead.
+        const size_t management_size =
+            KPageBitmap::CalculateManagementOverheadSize(sz / sizeof(PageBuffer));
+        const size_t allocatable_size = sz - management_size;
+
+        // Set tracking fields.
+        m_address = addr;
+        m_size = Common::AlignDown(allocatable_size, sizeof(PageBuffer));
+        m_count = allocatable_size / sizeof(PageBuffer);
+        R_UNLESS(m_count > 0, ResultOutOfMemory);
+
+        // Clear the management region.
+        u64* management_ptr = GetPointer<u64>(m_address + allocatable_size);
+        std::memset(management_ptr, 0, management_size);
+
+        // Initialize the bitmap.
+        m_page_bitmap.Initialize(management_ptr, m_count);
+
+        // Free the pages to the bitmap.
+        for (size_t i = 0; i < m_count; i++) {
+            // Ensure the freed page is all-zero.
+            std::memset(GetPointer<PageBuffer>(m_address) + i, 0, PageSize);
+
+            // Set the bit for the free page.
+            m_page_bitmap.SetBit(i);
+        }
+
+        R_SUCCEED();
+    }
+
+    VAddr GetAddress() const {
+        return m_address;
+    }
+    size_t GetSize() const {
+        return m_size;
+    }
+    size_t GetUsed() const {
+        return m_used;
+    }
+    size_t GetPeak() const {
+        return m_peak;
+    }
+    size_t GetCount() const {
+        return m_count;
+    }
+
+    PageBuffer* Allocate() {
+        // Take the lock.
+        // TODO(bunnei): We should disable interrupts here via KScopedInterruptDisable.
+        KScopedSpinLock lk(m_lock);
+
+        // Find a random free block.
+        s64 soffset = m_page_bitmap.FindFreeBlock(true);
+        if (soffset < 0) [[unlikely]] {
+            return nullptr;
+        }
+
+        const size_t offset = static_cast<size_t>(soffset);
+
+        // Update our tracking.
+        m_page_bitmap.ClearBit(offset);
+        m_peak = std::max(m_peak, (++m_used));
+
+        return GetPointer<PageBuffer>(m_address) + offset;
+    }
+
+    void Free(PageBuffer* pb) {
+        // Ensure all pages in the heap are zero.
+        std::memset(pb, 0, PageSize);
+
+        // Take the lock.
+        // TODO(bunnei): We should disable interrupts here via KScopedInterruptDisable.
+        KScopedSpinLock lk(m_lock);
+
+        // Set the bit for the free page.
+        size_t offset = (reinterpret_cast<uintptr_t>(pb) - m_address) / sizeof(PageBuffer);
+        m_page_bitmap.SetBit(offset);
+
+        // Decrement our used count.
+        --m_used;
+    }
+
+private:
+    KSpinLock m_lock;
+    KPageBitmap m_page_bitmap;
+    size_t m_used{};
+    size_t m_peak{};
+    size_t m_count{};
+    VAddr m_address{};
+    size_t m_size{};
+
+    // TODO(bunnei): Back by host memory until we emulate kernel virtual address space.
+    std::vector<u8> m_backing_memory;
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_dynamic_resource_manager.h

@@ -0,0 +1,58 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "core/hle/kernel/k_dynamic_slab_heap.h"
+#include "core/hle/kernel/k_memory_block.h"
+
+namespace Kernel {
+
+template <typename T, bool ClearNode = false>
+class KDynamicResourceManager {
+    YUZU_NON_COPYABLE(KDynamicResourceManager);
+    YUZU_NON_MOVEABLE(KDynamicResourceManager);
+
+public:
+    using DynamicSlabType = KDynamicSlabHeap<T, ClearNode>;
+
+public:
+    constexpr KDynamicResourceManager() = default;
+
+    constexpr size_t GetSize() const {
+        return m_slab_heap->GetSize();
+    }
+    constexpr size_t GetUsed() const {
+        return m_slab_heap->GetUsed();
+    }
+    constexpr size_t GetPeak() const {
+        return m_slab_heap->GetPeak();
+    }
+    constexpr size_t GetCount() const {
+        return m_slab_heap->GetCount();
+    }
+
+    void Initialize(KDynamicPageManager* page_allocator, DynamicSlabType* slab_heap) {
+        m_page_allocator = page_allocator;
+        m_slab_heap = slab_heap;
+    }
+
+    T* Allocate() const {
+        return m_slab_heap->Allocate(m_page_allocator);
+    }
+
+    void Free(T* t) const {
+        m_slab_heap->Free(t);
+    }
+
+private:
+    KDynamicPageManager* m_page_allocator{};
+    DynamicSlabType* m_slab_heap{};
+};
+
+class KMemoryBlockSlabManager : public KDynamicResourceManager<KMemoryBlock> {};
+
+using KMemoryBlockSlabHeap = typename KMemoryBlockSlabManager::DynamicSlabType;
+
+} // namespace Kernel

src/core/hle/kernel/k_dynamic_slab_heap.h

@@ -0,0 +1,122 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <atomic>
+
+#include "common/common_funcs.h"
+#include "core/hle/kernel/k_dynamic_page_manager.h"
+#include "core/hle/kernel/k_slab_heap.h"
+
+namespace Kernel {
+
+template <typename T, bool ClearNode = false>
+class KDynamicSlabHeap : protected impl::KSlabHeapImpl {
+    YUZU_NON_COPYABLE(KDynamicSlabHeap);
+    YUZU_NON_MOVEABLE(KDynamicSlabHeap);
+
+public:
+    constexpr KDynamicSlabHeap() = default;
+
+    constexpr VAddr GetAddress() const {
+        return m_address;
+    }
+    constexpr size_t GetSize() const {
+        return m_size;
+    }
+    constexpr size_t GetUsed() const {
+        return m_used.load();
+    }
+    constexpr size_t GetPeak() const {
+        return m_peak.load();
+    }
+    constexpr size_t GetCount() const {
+        return m_count.load();
+    }
+
+    constexpr bool IsInRange(VAddr addr) const {
+        return this->GetAddress() <= addr && addr <= this->GetAddress() + this->GetSize() - 1;
+    }
+
+    void Initialize(KDynamicPageManager* page_allocator, size_t num_objects) {
+        ASSERT(page_allocator != nullptr);
+
+        // Initialize members.
+        m_address = page_allocator->GetAddress();
+        m_size = page_allocator->GetSize();
+
+        // Initialize the base allocator.
+        KSlabHeapImpl::Initialize();
+
+        // Allocate until we have the correct number of objects.
+        while (m_count.load() < num_objects) {
+            auto* allocated = reinterpret_cast<T*>(page_allocator->Allocate());
+            ASSERT(allocated != nullptr);
+
+            for (size_t i = 0; i < sizeof(PageBuffer) / sizeof(T); i++) {
+                KSlabHeapImpl::Free(allocated + i);
+            }
+
+            m_count += sizeof(PageBuffer) / sizeof(T);
+        }
+    }
+
+    T* Allocate(KDynamicPageManager* page_allocator) {
+        T* allocated = static_cast<T*>(KSlabHeapImpl::Allocate());
+
+        // If we successfully allocated and we should clear the node, do so.
+        if constexpr (ClearNode) {
+            if (allocated != nullptr) [[likely]] {
+                reinterpret_cast<KSlabHeapImpl::Node*>(allocated)->next = nullptr;
+            }
+        }
+
+        // If we fail to allocate, try to get a new page from our next allocator.
+        if (allocated == nullptr) [[unlikely]] {
+            if (page_allocator != nullptr) {
+                allocated = reinterpret_cast<T*>(page_allocator->Allocate());
+                if (allocated != nullptr) {
+                    // If we succeeded in getting a page, free the rest to our slab.
+                    for (size_t i = 1; i < sizeof(PageBuffer) / sizeof(T); i++) {
+                        KSlabHeapImpl::Free(allocated + i);
+                    }
+                    m_count += sizeof(PageBuffer) / sizeof(T);
+                }
+            }
+        }
+
+        if (allocated != nullptr) [[likely]] {
+            // Construct the object.
+            std::construct_at(allocated);
+
+            // Update our tracking.
+            const size_t used = ++m_used;
+            size_t peak = m_peak.load();
+            while (peak < used) {
+                if (m_peak.compare_exchange_weak(peak, used, std::memory_order_relaxed)) {
+                    break;
+                }
+            }
+        }
+
+        return allocated;
+    }
+
+    void Free(T* t) {
+        KSlabHeapImpl::Free(t);
+        --m_used;
+    }
+
+private:
+    using PageBuffer = KDynamicPageManager::PageBuffer;
+
+private:
+    std::atomic<size_t> m_used{};
+    std::atomic<size_t> m_peak{};
+    std::atomic<size_t> m_count{};
+    VAddr m_address{};
+    size_t m_size{};
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_event.cpp

@@ -8,39 +8,45 @@
 namespace Kernel {
 
 KEvent::KEvent(KernelCore& kernel_)
-    : KAutoObjectWithSlabHeapAndContainer{kernel_}, readable_event{kernel_}, writable_event{
-                                                                                 kernel_} {}
+    : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_readable_event{kernel_} {}
 
 KEvent::~KEvent() = default;
 
-void KEvent::Initialize(std::string&& name_, KProcess* owner_) {
-    // Increment reference count.
-    // Because reference count is one on creation, this will result
-    // in a reference count of two. Thus, when both readable and
-    // writable events are closed this object will be destroyed.
-    Open();
+void KEvent::Initialize(KProcess* owner) {
+    // Create our readable event.
+    KAutoObject::Create(std::addressof(m_readable_event));
 
-    // Create our sub events.
-    KAutoObject::Create(std::addressof(readable_event));
-    KAutoObject::Create(std::addressof(writable_event));
-
-    // Initialize our sub sessions.
-    readable_event.Initialize(this, name_ + ":Readable");
-    writable_event.Initialize(this, name_ + ":Writable");
+    // Initialize our readable event.
+    m_readable_event.Initialize(this);
 
     // Set our owner process.
-    owner = owner_;
-    owner->Open();
+    m_owner = owner;
+    m_owner->Open();
 
     // Mark initialized.
-    name = std::move(name_);
-    initialized = true;
+    m_initialized = true;
 }
 
 void KEvent::Finalize() {
     KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObjectWithList>::Finalize();
 }
 
+Result KEvent::Signal() {
+    KScopedSchedulerLock sl{kernel};
+
+    R_SUCCEED_IF(m_readable_event_destroyed);
+
+    return m_readable_event.Signal();
+}
+
+Result KEvent::Clear() {
+    KScopedSchedulerLock sl{kernel};
+
+    R_SUCCEED_IF(m_readable_event_destroyed);
+
+    return m_readable_event.Clear();
+}
+
 void KEvent::PostDestroy(uintptr_t arg) {
     // Release the event count resource the owner process holds.
     KProcess* owner = reinterpret_cast<KProcess*>(arg);

src/core/hle/kernel/k_event.h

@@ -4,14 +4,12 @@
 #pragma once
 
 #include "core/hle/kernel/k_readable_event.h"
-#include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/slab_helpers.h"
 
 namespace Kernel {
 
 class KernelCore;
 class KReadableEvent;
-class KWritableEvent;
 class KProcess;
 
 class KEvent final : public KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObjectWithList> {
@@ -21,37 +19,40 @@ public:
     explicit KEvent(KernelCore& kernel_);
     ~KEvent() override;
 
-    void Initialize(std::string&& name, KProcess* owner_);
+    void Initialize(KProcess* owner);
 
     void Finalize() override;
 
     bool IsInitialized() const override {
-        return initialized;
+        return m_initialized;
     }
 
     uintptr_t GetPostDestroyArgument() const override {
-        return reinterpret_cast<uintptr_t>(owner);
+        return reinterpret_cast<uintptr_t>(m_owner);
     }
 
     KProcess* GetOwner() const override {
-        return owner;
+        return m_owner;
     }
 
     KReadableEvent& GetReadableEvent() {
-        return readable_event;
-    }
-
-    KWritableEvent& GetWritableEvent() {
-        return writable_event;
+        return m_readable_event;
     }
 
     static void PostDestroy(uintptr_t arg);
 
+    Result Signal();
+    Result Clear();
+
+    void OnReadableEventDestroyed() {
+        m_readable_event_destroyed = true;
+    }
+
 private:
-    KReadableEvent readable_event;
-    KWritableEvent writable_event;
-    KProcess* owner{};
-    bool initialized{};
+    KReadableEvent m_readable_event;
+    KProcess* m_owner{};
+    bool m_initialized{};
+    bool m_readable_event_destroyed{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_interrupt_manager.cpp

@@ -11,29 +11,34 @@
 namespace Kernel::KInterruptManager {
 
 void HandleInterrupt(KernelCore& kernel, s32 core_id) {
-    auto* process = kernel.CurrentProcess();
-    if (!process) {
-        return;
-    }
-
     // Acknowledge the interrupt.
     kernel.PhysicalCore(core_id).ClearInterrupt();
 
     auto& current_thread = GetCurrentThread(kernel);
 
-    // If the user disable count is set, we may need to pin the current thread.
-    if (current_thread.GetUserDisableCount() && !process->GetPinnedThread(core_id)) {
-        KScopedSchedulerLock sl{kernel};
+    if (auto* process = kernel.CurrentProcess(); process) {
+        // If the user disable count is set, we may need to pin the current thread.
+        if (current_thread.GetUserDisableCount() && !process->GetPinnedThread(core_id)) {
+            KScopedSchedulerLock sl{kernel};
 
-        // Pin the current thread.
-        process->PinCurrentThread(core_id);
+            // Pin the current thread.
+            process->PinCurrentThread(core_id);
 
-        // Set the interrupt flag for the thread.
-        GetCurrentThread(kernel).SetInterruptFlag();
+            // Set the interrupt flag for the thread.
+            GetCurrentThread(kernel).SetInterruptFlag();
+        }
     }
 
     // Request interrupt scheduling.
     kernel.CurrentScheduler()->RequestScheduleOnInterrupt();
 }
 
+void SendInterProcessorInterrupt(KernelCore& kernel, u64 core_mask) {
+    for (std::size_t core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; ++core_id) {
+        if (core_mask & (1ULL << core_id)) {
+            kernel.PhysicalCore(core_id).Interrupt();
+        }
+    }
+}
+
 } // namespace Kernel::KInterruptManager

src/core/hle/kernel/k_interrupt_manager.h

@@ -11,6 +11,8 @@ class KernelCore;
 
 namespace KInterruptManager {
 void HandleInterrupt(KernelCore& kernel, s32 core_id);
-}
+void SendInterProcessorInterrupt(KernelCore& kernel, u64 core_mask);
+
+} // namespace KInterruptManager
 
 } // namespace Kernel

src/core/hle/kernel/k_linked_list.h

@@ -16,6 +16,7 @@ class KLinkedListNode : public boost::intrusive::list_base_hook<>,
                         public KSlabAllocated<KLinkedListNode> {
 
 public:
+    explicit KLinkedListNode(KernelCore&) {}
     KLinkedListNode() = default;
 
     void Initialize(void* it) {

src/core/hle/kernel/k_memory_block.h

@@ -6,6 +6,7 @@
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "common/intrusive_red_black_tree.h"
 #include "core/hle/kernel/memory_types.h"
 #include "core/hle/kernel/svc_types.h"
 
@@ -168,9 +169,8 @@ constexpr KMemoryPermission ConvertToKMemoryPermission(Svc::MemoryPermission per
 
 enum class KMemoryAttribute : u8 {
     None = 0x00,
-    Mask = 0x7F,
-    All = Mask,
-    DontCareMask = 0x80,
+    All = 0xFF,
+    UserMask = All,
 
     Locked = static_cast<u8>(Svc::MemoryAttribute::Locked),
     IpcLocked = static_cast<u8>(Svc::MemoryAttribute::IpcLocked),
@@ -178,76 +178,112 @@ enum class KMemoryAttribute : u8 {
     Uncached = static_cast<u8>(Svc::MemoryAttribute::Uncached),
 
     SetMask = Uncached,
-
-    IpcAndDeviceMapped = IpcLocked | DeviceShared,
-    LockedAndIpcLocked = Locked | IpcLocked,
-    DeviceSharedAndUncached = DeviceShared | Uncached
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryAttribute);
 
-static_assert((static_cast<u8>(KMemoryAttribute::Mask) &
-               static_cast<u8>(KMemoryAttribute::DontCareMask)) == 0);
+enum class KMemoryBlockDisableMergeAttribute : u8 {
+    None = 0,
+    Normal = (1u << 0),
+    DeviceLeft = (1u << 1),
+    IpcLeft = (1u << 2),
+    Locked = (1u << 3),
+    DeviceRight = (1u << 4),
+
+    AllLeft = Normal | DeviceLeft | IpcLeft | Locked,
+    AllRight = DeviceRight,
+};
+DECLARE_ENUM_FLAG_OPERATORS(KMemoryBlockDisableMergeAttribute);
 
 struct KMemoryInfo {
-    VAddr addr{};
-    std::size_t size{};
-    KMemoryState state{};
-    KMemoryPermission perm{};
-    KMemoryAttribute attribute{};
-    KMemoryPermission original_perm{};
-    u16 ipc_lock_count{};
-    u16 device_use_count{};
+    uintptr_t m_address;
+    size_t m_size;
+    KMemoryState m_state;
+    u16 m_device_disable_merge_left_count;
+    u16 m_device_disable_merge_right_count;
+    u16 m_ipc_lock_count;
+    u16 m_device_use_count;
+    u16 m_ipc_disable_merge_count;
+    KMemoryPermission m_permission;
+    KMemoryAttribute m_attribute;
+    KMemoryPermission m_original_permission;
+    KMemoryBlockDisableMergeAttribute m_disable_merge_attribute;
 
     constexpr Svc::MemoryInfo GetSvcMemoryInfo() const {
         return {
-            addr,
-            size,
-            static_cast<Svc::MemoryState>(state & KMemoryState::Mask),
-            static_cast<Svc::MemoryAttribute>(attribute & KMemoryAttribute::Mask),
-            static_cast<Svc::MemoryPermission>(perm & KMemoryPermission::UserMask),
-            ipc_lock_count,
-            device_use_count,
+            .addr = m_address,
+            .size = m_size,
+            .state = static_cast<Svc::MemoryState>(m_state & KMemoryState::Mask),
+            .attr = static_cast<Svc::MemoryAttribute>(m_attribute & KMemoryAttribute::UserMask),
+            .perm = static_cast<Svc::MemoryPermission>(m_permission & KMemoryPermission::UserMask),
+            .ipc_refcount = m_ipc_lock_count,
+            .device_refcount = m_device_use_count,
+            .padding = {},
         };
     }
 
-    constexpr VAddr GetAddress() const {
-        return addr;
+    constexpr uintptr_t GetAddress() const {
+        return m_address;
     }
-    constexpr std::size_t GetSize() const {
-        return size;
+
+    constexpr size_t GetSize() const {
+        return m_size;
     }
-    constexpr std::size_t GetNumPages() const {
-        return GetSize() / PageSize;
+
+    constexpr size_t GetNumPages() const {
+        return this->GetSize() / PageSize;
     }
-    constexpr VAddr GetEndAddress() const {
-        return GetAddress() + GetSize();
+
+    constexpr uintptr_t GetEndAddress() const {
+        return this->GetAddress() + this->GetSize();
     }
-    constexpr VAddr GetLastAddress() const {
-        return GetEndAddress() - 1;
+
+    constexpr uintptr_t GetLastAddress() const {
+        return this->GetEndAddress() - 1;
     }
+
+    constexpr u16 GetIpcLockCount() const {
+        return m_ipc_lock_count;
+    }
+
+    constexpr u16 GetIpcDisableMergeCount() const {
+        return m_ipc_disable_merge_count;
+    }
+
     constexpr KMemoryState GetState() const {
-        return state;
-    }
-    constexpr KMemoryAttribute GetAttribute() const {
-        return attribute;
+        return m_state;
     }
+
     constexpr KMemoryPermission GetPermission() const {
-        return perm;
+        return m_permission;
+    }
+
+    constexpr KMemoryPermission GetOriginalPermission() const {
+        return m_original_permission;
+    }
+
+    constexpr KMemoryAttribute GetAttribute() const {
+        return m_attribute;
+    }
+
+    constexpr KMemoryBlockDisableMergeAttribute GetDisableMergeAttribute() const {
+        return m_disable_merge_attribute;
     }
 };
 
-class KMemoryBlock final {
-    friend class KMemoryBlockManager;
-
+class KMemoryBlock : public Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock> {
 private:
-    VAddr addr{};
-    std::size_t num_pages{};
-    KMemoryState state{KMemoryState::None};
-    u16 ipc_lock_count{};
-    u16 device_use_count{};
-    KMemoryPermission perm{KMemoryPermission::None};
-    KMemoryPermission original_perm{KMemoryPermission::None};
-    KMemoryAttribute attribute{KMemoryAttribute::None};
+    u16 m_device_disable_merge_left_count;
+    u16 m_device_disable_merge_right_count;
+    VAddr m_address;
+    size_t m_num_pages;
+    KMemoryState m_memory_state;
+    u16 m_ipc_lock_count;
+    u16 m_device_use_count;
+    u16 m_ipc_disable_merge_count;
+    KMemoryPermission m_permission;
+    KMemoryPermission m_original_permission;
+    KMemoryAttribute m_attribute;
+    KMemoryBlockDisableMergeAttribute m_disable_merge_attribute;
 
 public:
     static constexpr int Compare(const KMemoryBlock& lhs, const KMemoryBlock& rhs) {
@@ -261,113 +297,349 @@ public:
     }
 
 public:
-    constexpr KMemoryBlock() = default;
-    constexpr KMemoryBlock(VAddr addr_, std::size_t num_pages_, KMemoryState state_,
-                           KMemoryPermission perm_, KMemoryAttribute attribute_)
-        : addr{addr_}, num_pages(num_pages_), state{state_}, perm{perm_}, attribute{attribute_} {}
-
     constexpr VAddr GetAddress() const {
-        return addr;
+        return m_address;
     }
 
-    constexpr std::size_t GetNumPages() const {
-        return num_pages;
+    constexpr size_t GetNumPages() const {
+        return m_num_pages;
     }
 
-    constexpr std::size_t GetSize() const {
-        return GetNumPages() * PageSize;
+    constexpr size_t GetSize() const {
+        return this->GetNumPages() * PageSize;
     }
 
     constexpr VAddr GetEndAddress() const {
-        return GetAddress() + GetSize();
+        return this->GetAddress() + this->GetSize();
     }
 
     constexpr VAddr GetLastAddress() const {
-        return GetEndAddress() - 1;
+        return this->GetEndAddress() - 1;
+    }
+
+    constexpr u16 GetIpcLockCount() const {
+        return m_ipc_lock_count;
+    }
+
+    constexpr u16 GetIpcDisableMergeCount() const {
+        return m_ipc_disable_merge_count;
+    }
+
+    constexpr KMemoryPermission GetPermission() const {
+        return m_permission;
+    }
+
+    constexpr KMemoryPermission GetOriginalPermission() const {
+        return m_original_permission;
+    }
+
+    constexpr KMemoryAttribute GetAttribute() const {
+        return m_attribute;
     }
 
     constexpr KMemoryInfo GetMemoryInfo() const {
         return {
-            GetAddress(), GetSize(),     state,          perm,
-            attribute,    original_perm, ipc_lock_count, device_use_count,
+            .m_address = this->GetAddress(),
+            .m_size = this->GetSize(),
+            .m_state = m_memory_state,
+            .m_device_disable_merge_left_count = m_device_disable_merge_left_count,
+            .m_device_disable_merge_right_count = m_device_disable_merge_right_count,
+            .m_ipc_lock_count = m_ipc_lock_count,
+            .m_device_use_count = m_device_use_count,
+            .m_ipc_disable_merge_count = m_ipc_disable_merge_count,
+            .m_permission = m_permission,
+            .m_attribute = m_attribute,
+            .m_original_permission = m_original_permission,
+            .m_disable_merge_attribute = m_disable_merge_attribute,
         };
     }
 
-    void ShareToDevice(KMemoryPermission /*new_perm*/) {
-        ASSERT((attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared ||
-               device_use_count == 0);
-        attribute |= KMemoryAttribute::DeviceShared;
-        const u16 new_use_count{++device_use_count};
-        ASSERT(new_use_count > 0);
+public:
+    explicit KMemoryBlock() = default;
+
+    constexpr KMemoryBlock(VAddr addr, size_t np, KMemoryState ms, KMemoryPermission p,
+                           KMemoryAttribute attr)
+        : Common::IntrusiveRedBlackTreeBaseNode<KMemoryBlock>(),
+          m_device_disable_merge_left_count(), m_device_disable_merge_right_count(),
+          m_address(addr), m_num_pages(np), m_memory_state(ms), m_ipc_lock_count(0),
+          m_device_use_count(0), m_ipc_disable_merge_count(), m_permission(p),
+          m_original_permission(KMemoryPermission::None), m_attribute(attr),
+          m_disable_merge_attribute() {}
+
+    constexpr void Initialize(VAddr addr, size_t np, KMemoryState ms, KMemoryPermission p,
+                              KMemoryAttribute attr) {
+        m_device_disable_merge_left_count = 0;
+        m_device_disable_merge_right_count = 0;
+        m_address = addr;
+        m_num_pages = np;
+        m_memory_state = ms;
+        m_ipc_lock_count = 0;
+        m_device_use_count = 0;
+        m_permission = p;
+        m_original_permission = KMemoryPermission::None;
+        m_attribute = attr;
+        m_disable_merge_attribute = KMemoryBlockDisableMergeAttribute::None;
     }
 
-    void UnshareToDevice(KMemoryPermission /*new_perm*/) {
-        ASSERT((attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared);
-        const u16 prev_use_count{device_use_count--};
-        ASSERT(prev_use_count > 0);
-        if (prev_use_count == 1) {
-            attribute &= ~KMemoryAttribute::DeviceShared;
-        }
-    }
-
-private:
     constexpr bool HasProperties(KMemoryState s, KMemoryPermission p, KMemoryAttribute a) const {
-        constexpr KMemoryAttribute AttributeIgnoreMask{KMemoryAttribute::DontCareMask |
-                                                       KMemoryAttribute::IpcLocked |
-                                                       KMemoryAttribute::DeviceShared};
-        return state == s && perm == p &&
-               (attribute | AttributeIgnoreMask) == (a | AttributeIgnoreMask);
+        constexpr auto AttributeIgnoreMask =
+            KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared;
+        return m_memory_state == s && m_permission == p &&
+               (m_attribute | AttributeIgnoreMask) == (a | AttributeIgnoreMask);
     }
 
     constexpr bool HasSameProperties(const KMemoryBlock& rhs) const {
-        return state == rhs.state && perm == rhs.perm && original_perm == rhs.original_perm &&
-               attribute == rhs.attribute && ipc_lock_count == rhs.ipc_lock_count &&
-               device_use_count == rhs.device_use_count;
+        return m_memory_state == rhs.m_memory_state && m_permission == rhs.m_permission &&
+               m_original_permission == rhs.m_original_permission &&
+               m_attribute == rhs.m_attribute && m_ipc_lock_count == rhs.m_ipc_lock_count &&
+               m_device_use_count == rhs.m_device_use_count;
     }
 
-    constexpr bool Contains(VAddr start) const {
-        return GetAddress() <= start && start <= GetEndAddress();
+    constexpr bool CanMergeWith(const KMemoryBlock& rhs) const {
+        return this->HasSameProperties(rhs) &&
+               (m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute::AllRight) ==
+                   KMemoryBlockDisableMergeAttribute::None &&
+               (rhs.m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute::AllLeft) ==
+                   KMemoryBlockDisableMergeAttribute::None;
     }
 
-    constexpr void Add(std::size_t count) {
-        ASSERT(count > 0);
-        ASSERT(GetAddress() + count * PageSize - 1 < GetEndAddress() + count * PageSize - 1);
-
-        num_pages += count;
+    constexpr bool Contains(VAddr addr) const {
+        return this->GetAddress() <= addr && addr <= this->GetEndAddress();
     }
 
-    constexpr void Update(KMemoryState new_state, KMemoryPermission new_perm,
-                          KMemoryAttribute new_attribute) {
-        ASSERT(original_perm == KMemoryPermission::None);
-        ASSERT((attribute & KMemoryAttribute::IpcLocked) == KMemoryAttribute::None);
+    constexpr void Add(const KMemoryBlock& added_block) {
+        ASSERT(added_block.GetNumPages() > 0);
+        ASSERT(this->GetAddress() + added_block.GetSize() - 1 <
+               this->GetEndAddress() + added_block.GetSize() - 1);
 
-        state = new_state;
-        perm = new_perm;
-
-        attribute = static_cast<KMemoryAttribute>(
-            new_attribute |
-            (attribute & (KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared)));
+        m_num_pages += added_block.GetNumPages();
+        m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+            m_disable_merge_attribute | added_block.m_disable_merge_attribute);
+        m_device_disable_merge_right_count = added_block.m_device_disable_merge_right_count;
     }
 
-    constexpr KMemoryBlock Split(VAddr split_addr) {
-        ASSERT(GetAddress() < split_addr);
-        ASSERT(Contains(split_addr));
-        ASSERT(Common::IsAligned(split_addr, PageSize));
+    constexpr void Update(KMemoryState s, KMemoryPermission p, KMemoryAttribute a,
+                          bool set_disable_merge_attr, u8 set_mask, u8 clear_mask) {
+        ASSERT(m_original_permission == KMemoryPermission::None);
+        ASSERT((m_attribute & KMemoryAttribute::IpcLocked) == KMemoryAttribute::None);
 
-        KMemoryBlock block;
-        block.addr = addr;
-        block.num_pages = (split_addr - GetAddress()) / PageSize;
-        block.state = state;
-        block.ipc_lock_count = ipc_lock_count;
-        block.device_use_count = device_use_count;
-        block.perm = perm;
-        block.original_perm = original_perm;
-        block.attribute = attribute;
+        m_memory_state = s;
+        m_permission = p;
+        m_attribute = static_cast<KMemoryAttribute>(
+            a | (m_attribute & (KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared)));
 
-        addr = split_addr;
-        num_pages -= block.num_pages;
+        if (set_disable_merge_attr && set_mask != 0) {
+            m_disable_merge_attribute = m_disable_merge_attribute |
+                                        static_cast<KMemoryBlockDisableMergeAttribute>(set_mask);
+        }
+        if (clear_mask != 0) {
+            m_disable_merge_attribute = m_disable_merge_attribute &
+                                        static_cast<KMemoryBlockDisableMergeAttribute>(~clear_mask);
+        }
+    }
 
-        return block;
+    constexpr void Split(KMemoryBlock* block, VAddr addr) {
+        ASSERT(this->GetAddress() < addr);
+        ASSERT(this->Contains(addr));
+        ASSERT(Common::IsAligned(addr, PageSize));
+
+        block->m_address = m_address;
+        block->m_num_pages = (addr - this->GetAddress()) / PageSize;
+        block->m_memory_state = m_memory_state;
+        block->m_ipc_lock_count = m_ipc_lock_count;
+        block->m_device_use_count = m_device_use_count;
+        block->m_permission = m_permission;
+        block->m_original_permission = m_original_permission;
+        block->m_attribute = m_attribute;
+        block->m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+            m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute::AllLeft);
+        block->m_ipc_disable_merge_count = m_ipc_disable_merge_count;
+        block->m_device_disable_merge_left_count = m_device_disable_merge_left_count;
+        block->m_device_disable_merge_right_count = 0;
+
+        m_address = addr;
+        m_num_pages -= block->m_num_pages;
+
+        m_ipc_disable_merge_count = 0;
+        m_device_disable_merge_left_count = 0;
+        m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+            m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute::AllRight);
+    }
+
+    constexpr void UpdateDeviceDisableMergeStateForShareLeft(
+        [[maybe_unused]] KMemoryPermission new_perm, bool left, [[maybe_unused]] bool right) {
+        if (left) {
+            m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+                m_disable_merge_attribute | KMemoryBlockDisableMergeAttribute::DeviceLeft);
+            const u16 new_device_disable_merge_left_count = ++m_device_disable_merge_left_count;
+            ASSERT(new_device_disable_merge_left_count > 0);
+        }
+    }
+
+    constexpr void UpdateDeviceDisableMergeStateForShareRight(
+        [[maybe_unused]] KMemoryPermission new_perm, [[maybe_unused]] bool left, bool right) {
+        if (right) {
+            m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+                m_disable_merge_attribute | KMemoryBlockDisableMergeAttribute::DeviceRight);
+            const u16 new_device_disable_merge_right_count = ++m_device_disable_merge_right_count;
+            ASSERT(new_device_disable_merge_right_count > 0);
+        }
+    }
+
+    constexpr void UpdateDeviceDisableMergeStateForShare(KMemoryPermission new_perm, bool left,
+                                                         bool right) {
+        this->UpdateDeviceDisableMergeStateForShareLeft(new_perm, left, right);
+        this->UpdateDeviceDisableMergeStateForShareRight(new_perm, left, right);
+    }
+
+    constexpr void ShareToDevice([[maybe_unused]] KMemoryPermission new_perm, bool left,
+                                 bool right) {
+        // We must either be shared or have a zero lock count.
+        ASSERT((m_attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared ||
+               m_device_use_count == 0);
+
+        // Share.
+        const u16 new_count = ++m_device_use_count;
+        ASSERT(new_count > 0);
+
+        m_attribute = static_cast<KMemoryAttribute>(m_attribute | KMemoryAttribute::DeviceShared);
+
+        this->UpdateDeviceDisableMergeStateForShare(new_perm, left, right);
+    }
+
+    constexpr void UpdateDeviceDisableMergeStateForUnshareLeft(
+        [[maybe_unused]] KMemoryPermission new_perm, bool left, [[maybe_unused]] bool right) {
+
+        if (left) {
+            if (!m_device_disable_merge_left_count) {
+                return;
+            }
+            --m_device_disable_merge_left_count;
+        }
+
+        m_device_disable_merge_left_count =
+            std::min(m_device_disable_merge_left_count, m_device_use_count);
+
+        if (m_device_disable_merge_left_count == 0) {
+            m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+                m_disable_merge_attribute & ~KMemoryBlockDisableMergeAttribute::DeviceLeft);
+        }
+    }
+
+    constexpr void UpdateDeviceDisableMergeStateForUnshareRight(
+        [[maybe_unused]] KMemoryPermission new_perm, [[maybe_unused]] bool left, bool right) {
+        if (right) {
+            const u16 old_device_disable_merge_right_count = m_device_disable_merge_right_count--;
+            ASSERT(old_device_disable_merge_right_count > 0);
+            if (old_device_disable_merge_right_count == 1) {
+                m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+                    m_disable_merge_attribute & ~KMemoryBlockDisableMergeAttribute::DeviceRight);
+            }
+        }
+    }
+
+    constexpr void UpdateDeviceDisableMergeStateForUnshare(KMemoryPermission new_perm, bool left,
+                                                           bool right) {
+        this->UpdateDeviceDisableMergeStateForUnshareLeft(new_perm, left, right);
+        this->UpdateDeviceDisableMergeStateForUnshareRight(new_perm, left, right);
+    }
+
+    constexpr void UnshareToDevice([[maybe_unused]] KMemoryPermission new_perm, bool left,
+                                   bool right) {
+        // We must be shared.
+        ASSERT((m_attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared);
+
+        // Unhare.
+        const u16 old_count = m_device_use_count--;
+        ASSERT(old_count > 0);
+
+        if (old_count == 1) {
+            m_attribute =
+                static_cast<KMemoryAttribute>(m_attribute & ~KMemoryAttribute::DeviceShared);
+        }
+
+        this->UpdateDeviceDisableMergeStateForUnshare(new_perm, left, right);
+    }
+
+    constexpr void UnshareToDeviceRight([[maybe_unused]] KMemoryPermission new_perm, bool left,
+                                        bool right) {
+
+        // We must be shared.
+        ASSERT((m_attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared);
+
+        // Unhare.
+        const u16 old_count = m_device_use_count--;
+        ASSERT(old_count > 0);
+
+        if (old_count == 1) {
+            m_attribute =
+                static_cast<KMemoryAttribute>(m_attribute & ~KMemoryAttribute::DeviceShared);
+        }
+
+        this->UpdateDeviceDisableMergeStateForUnshareRight(new_perm, left, right);
+    }
+
+    constexpr void LockForIpc(KMemoryPermission new_perm, bool left, [[maybe_unused]] bool right) {
+        // We must either be locked or have a zero lock count.
+        ASSERT((m_attribute & KMemoryAttribute::IpcLocked) == KMemoryAttribute::IpcLocked ||
+               m_ipc_lock_count == 0);
+
+        // Lock.
+        const u16 new_lock_count = ++m_ipc_lock_count;
+        ASSERT(new_lock_count > 0);
+
+        // If this is our first lock, update our permissions.
+        if (new_lock_count == 1) {
+            ASSERT(m_original_permission == KMemoryPermission::None);
+            ASSERT((m_permission | new_perm | KMemoryPermission::NotMapped) ==
+                   (m_permission | KMemoryPermission::NotMapped));
+            ASSERT((m_permission & KMemoryPermission::UserExecute) !=
+                       KMemoryPermission::UserExecute ||
+                   (new_perm == KMemoryPermission::UserRead));
+            m_original_permission = m_permission;
+            m_permission = static_cast<KMemoryPermission>(
+                (new_perm & KMemoryPermission::IpcLockChangeMask) |
+                (m_original_permission & ~KMemoryPermission::IpcLockChangeMask));
+        }
+        m_attribute = static_cast<KMemoryAttribute>(m_attribute | KMemoryAttribute::IpcLocked);
+
+        if (left) {
+            m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+                m_disable_merge_attribute | KMemoryBlockDisableMergeAttribute::IpcLeft);
+            const u16 new_ipc_disable_merge_count = ++m_ipc_disable_merge_count;
+            ASSERT(new_ipc_disable_merge_count > 0);
+        }
+    }
+
+    constexpr void UnlockForIpc([[maybe_unused]] KMemoryPermission new_perm, bool left,
+                                [[maybe_unused]] bool right) {
+        // We must be locked.
+        ASSERT((m_attribute & KMemoryAttribute::IpcLocked) == KMemoryAttribute::IpcLocked);
+
+        // Unlock.
+        const u16 old_lock_count = m_ipc_lock_count--;
+        ASSERT(old_lock_count > 0);
+
+        // If this is our last unlock, update our permissions.
+        if (old_lock_count == 1) {
+            ASSERT(m_original_permission != KMemoryPermission::None);
+            m_permission = m_original_permission;
+            m_original_permission = KMemoryPermission::None;
+            m_attribute = static_cast<KMemoryAttribute>(m_attribute & ~KMemoryAttribute::IpcLocked);
+        }
+
+        if (left) {
+            const u16 old_ipc_disable_merge_count = m_ipc_disable_merge_count--;
+            ASSERT(old_ipc_disable_merge_count > 0);
+            if (old_ipc_disable_merge_count == 1) {
+                m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
+                    m_disable_merge_attribute & ~KMemoryBlockDisableMergeAttribute::IpcLeft);
+            }
+        }
+    }
+
+    constexpr KMemoryBlockDisableMergeAttribute GetDisableMergeAttribute() const {
+        return m_disable_merge_attribute;
     }
 };
 static_assert(std::is_trivially_destructible<KMemoryBlock>::value);