configure_input: Use unique pointers for player_controllers array

Ignore ARM for core count

CMakeLists.txt

@@ -133,13 +133,13 @@ if (NOT ENABLE_GENERIC)
     if (MSVC)
         detect_architecture("_M_AMD64" x86_64)
         detect_architecture("_M_IX86" x86)
-        detect_architecture("_M_ARM" ARM)
-        detect_architecture("_M_ARM64" ARM64)
+        detect_architecture("_M_ARM" arm)
+        detect_architecture("_M_ARM64" arm64)
     else()
         detect_architecture("__x86_64__" x86_64)
         detect_architecture("__i386__" x86)
-        detect_architecture("__arm__" ARM)
-        detect_architecture("__aarch64__" ARM64)
+        detect_architecture("__arm__" arm)
+        detect_architecture("__aarch64__" arm64)
     endif()
 endif()
 
@@ -218,11 +218,11 @@ if(ENABLE_QT)
     set(QT_VERSION 5.15)
 
     # Check for system Qt on Linux, fallback to bundled Qt
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    if (UNIX AND NOT APPLE)
         if (NOT YUZU_USE_BUNDLED_QT)
             find_package(Qt5 ${QT_VERSION} COMPONENTS Widgets DBus Multimedia)
         endif()
-        if (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT)
+        if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux" AND (NOT Qt5_FOUND OR YUZU_USE_BUNDLED_QT))
             # Check for dependencies, then enable bundled Qt download
 
             # Check that the system GLIBCXX version is compatible
@@ -323,7 +323,7 @@ if(ENABLE_QT)
 
         set(YUZU_QT_NO_CMAKE_SYSTEM_PATH "NO_CMAKE_SYSTEM_PATH")
     endif()
-    if ((${CMAKE_SYSTEM_NAME} STREQUAL "Linux") AND YUZU_USE_BUNDLED_QT)
+    if (UNIX AND NOT APPLE AND YUZU_USE_BUNDLED_QT)
         find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia DBus ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
     else()
         find_package(Qt5 ${QT_VERSION} REQUIRED COMPONENTS Widgets Concurrent Multimedia ${QT_PREFIX_HINT} ${YUZU_QT_NO_CMAKE_SYSTEM_PATH})
@@ -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()
 

externals/CMakeLists.txt

@@ -7,15 +7,14 @@ include(DownloadExternals)
 
 # xbyak
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    add_library(xbyak INTERFACE)
-    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/xbyak/xbyak DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    target_include_directories(xbyak SYSTEM INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/xbyak/include)
-    target_compile_definitions(xbyak INTERFACE XBYAK_NO_OP_NAMES)
+    add_subdirectory(xbyak)
 endif()
 
 # Dynarmic
-if (ARCHITECTURE_x86_64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
+    if (ARCHITECTURE_arm64)
+       set(DYNARMIC_FRONTENDS "A32")
+    endif()
     set(DYNARMIC_NO_BUNDLED_FMT ON)
     set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
     add_subdirectory(dynarmic)

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,27 +206,18 @@ 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
     )
 endif()
 
 target_link_libraries(audio_core PUBLIC common core)
-if (ARCHITECTURE_x86_64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
     target_link_libraries(audio_core PRIVATE dynarmic)
 endif()
 

src/audio_core/in/audio_in_system.cpp

@@ -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()) {

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

@@ -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;

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();
@@ -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;
 }
 
@@ -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/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()

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/common_funcs.h

@@ -31,8 +31,10 @@
 
 #ifndef _MSC_VER
 
-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64)
 #define Crash() __asm__ __volatile__("int $3")
+#elif defined(ARCHITECTURE_arm64)
+#define Crash() __asm__ __volatile__("brk #0")
 #else
 #define Crash() exit(1)
 #endif

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

@@ -12,6 +12,8 @@
 #include <ostream>
 #include <type_traits>
 
+#include <common/concepts.h>
+
 namespace Common {
 
 template <size_t I, size_t F>
@@ -50,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>;
 };
 
@@ -61,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>;
 };
 
@@ -72,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>;
 };
 
@@ -83,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>;
 };
 
@@ -101,7 +103,7 @@ struct divide_by_zero : std::exception {};
 template <size_t I, size_t F>
 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;
@@ -121,7 +123,7 @@ constexpr FixedPoint<I, F> divide(
 template <size_t I, size_t F>
 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;
 
@@ -191,7 +193,7 @@ constexpr FixedPoint<I, F> divide(
 template <size_t I, size_t F>
 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;
@@ -210,7 +212,7 @@ constexpr FixedPoint<I, F> multiply(
 template <size_t I, size_t F>
 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;
 
@@ -265,15 +267,16 @@ 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>
@@ -301,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
@@ -338,11 +319,11 @@ 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_);
     }
 
@@ -411,15 +392,13 @@ public: // binary math operators, effects underlying bit pattern since these
         return *this;
     }
 
-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
+    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>
+    template <IsIntegral Integer>
     constexpr FixedPoint& operator<<=(Integer n) {
         data_ <<= n;
         return *this;
@@ -430,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_;
     }
 
@@ -473,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:
-    constexpr 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>
-constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type operator+(
+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());
@@ -501,10 +480,10 @@ constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2,
 }
 
 template <size_t I1, size_t I2, size_t F>
-constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type operator-(
+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());
@@ -512,10 +491,10 @@ constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2,
 }
 
 template <size_t I1, size_t I2, size_t F>
-constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type operator*(
+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());
@@ -523,10 +502,10 @@ constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2,
 }
 
 template <size_t I1, size_t I2, size_t F>
-constexpr typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type operator/(
+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());
@@ -561,54 +540,46 @@ constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> 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>
+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>
+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>
+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>
+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>
+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>
+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>
+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>
+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;
@@ -616,78 +587,64 @@ constexpr FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
 }
 
 // shift operators
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
+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>
+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;
 }

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/host_memory.cpp

@@ -359,6 +359,12 @@ public:
             }
         });
 
+        long page_size = sysconf(_SC_PAGESIZE);
+        if (page_size != 0x1000) {
+            LOG_CRITICAL(HW_Memory, "page size {:#x} is incompatible with 4K paging", page_size);
+            throw std::bad_alloc{};
+        }
+
         // Backing memory initialization
 #if defined(__FreeBSD__) && __FreeBSD__ < 13
         // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30

src/common/input.h

@@ -100,7 +100,6 @@ enum class CameraError {
 enum class VibrationAmplificationType {
     Linear,
     Exponential,
-    Test,
 };
 
 // Analog properties for calibration
@@ -325,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.cpp

@@ -151,6 +151,7 @@ void UpdateRescalingInfo() {
         ASSERT(false);
         info.up_scale = 1;
         info.down_shift = 0;
+        break;
     }
     info.up_factor = static_cast<f32>(info.up_scale) / (1U << info.down_shift);
     info.down_factor = static_cast<f32>(1U << info.down_shift) / info.up_scale;

src/common/x64/cpu_detect.cpp

@@ -4,14 +4,27 @@
 
 #include <array>
 #include <cstring>
+#include <fstream>
 #include <iterator>
+#include <optional>
 #include <string_view>
+#include <thread>
+#include <vector>
 #include "common/bit_util.h"
 #include "common/common_types.h"
+#include "common/logging/log.h"
 #include "common/x64/cpu_detect.h"
 
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
 #ifdef _MSC_VER
 #include <intrin.h>
+
+static inline u64 xgetbv(u32 index) {
+    return _xgetbv(index);
+}
 #else
 
 #if defined(__DragonFly__) || defined(__FreeBSD__)
@@ -39,12 +52,11 @@ static inline void __cpuid(int info[4], u32 function_id) {
 }
 
 #define _XCR_XFEATURE_ENABLED_MASK 0
-static inline u64 _xgetbv(u32 index) {
+static inline u64 xgetbv(u32 index) {
     u32 eax, edx;
     __asm__ __volatile__("xgetbv" : "=a"(eax), "=d"(edx) : "c"(index));
     return ((u64)edx << 32) | eax;
 }
-
 #endif // _MSC_VER
 
 namespace Common {
@@ -107,7 +119,7 @@ static CPUCaps Detect() {
         //  - Is the XSAVE bit set in CPUID?
         //  - XGETBV result has the XCR bit set.
         if (Common::Bit<28>(cpu_id[2]) && Common::Bit<27>(cpu_id[2])) {
-            if ((_xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
+            if ((xgetbv(_XCR_XFEATURE_ENABLED_MASK) & 0x6) == 0x6) {
                 caps.avx = true;
                 if (Common::Bit<12>(cpu_id[2]))
                     caps.fma = true;
@@ -192,4 +204,45 @@ const CPUCaps& GetCPUCaps() {
     return caps;
 }
 
+std::optional<int> GetProcessorCount() {
+#if defined(_WIN32)
+    // Get the buffer length.
+    DWORD length = 0;
+    GetLogicalProcessorInformation(nullptr, &length);
+    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
+        LOG_ERROR(Frontend, "Failed to query core count.");
+        return std::nullopt;
+    }
+    std::vector<SYSTEM_LOGICAL_PROCESSOR_INFORMATION> buffer(
+        length / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION));
+    // Now query the core count.
+    if (!GetLogicalProcessorInformation(buffer.data(), &length)) {
+        LOG_ERROR(Frontend, "Failed to query core count.");
+        return std::nullopt;
+    }
+    return static_cast<int>(
+        std::count_if(buffer.cbegin(), buffer.cend(), [](const auto& proc_info) {
+            return proc_info.Relationship == RelationProcessorCore;
+        }));
+#elif defined(__unix__)
+    const int thread_count = std::thread::hardware_concurrency();
+    std::ifstream smt("/sys/devices/system/cpu/smt/active");
+    char state = '0';
+    if (smt) {
+        smt.read(&state, sizeof(state));
+    }
+    switch (state) {
+    case '0':
+        return thread_count;
+    case '1':
+        return thread_count / 2;
+    default:
+        return std::nullopt;
+    }
+#else
+    // Shame on you
+    return std::nullopt;
+#endif
+}
+
 } // namespace Common

src/common/x64/cpu_detect.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <optional>
 #include <string_view>
 #include "common/common_types.h"
 
@@ -74,4 +75,7 @@ struct CPUCaps {
  */
 const CPUCaps& GetCPUCaps();
 
+/// Detects CPU core count
+std::optional<int> GetProcessorCount();
+
 } // namespace Common

src/core/CMakeLists.txt

@@ -190,11 +190,13 @@ 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_debug.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_event_info.h
     hle/kernel/k_handle_table.cpp
     hle/kernel/k_handle_table.h
     hle/kernel/k_interrupt_manager.cpp
@@ -222,6 +224,8 @@ add_library(core STATIC
     hle/kernel/k_page_group.h
     hle/kernel/k_page_table.cpp
     hle/kernel/k_page_table.h
+    hle/kernel/k_page_table_manager.h
+    hle/kernel/k_page_table_slab_heap.h
     hle/kernel/k_port.cpp
     hle/kernel/k_port.h
     hle/kernel/k_priority_queue.h
@@ -243,6 +247,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
@@ -252,6 +258,8 @@ add_library(core STATIC
     hle/kernel/k_synchronization_object.cpp
     hle/kernel/k_synchronization_object.h
     hle/kernel/k_system_control.h
+    hle/kernel/k_system_resource.cpp
+    hle/kernel/k_system_resource.h
     hle/kernel/k_thread.cpp
     hle/kernel/k_thread.h
     hle/kernel/k_thread_local_page.cpp
@@ -489,10 +497,6 @@ add_library(core STATIC
     hle/service/hid/irsensor/processor_base.h
     hle/service/hid/irsensor/tera_plugin_processor.cpp
     hle/service/hid/irsensor/tera_plugin_processor.h
-    hle/service/jit/jit_context.cpp
-    hle/service/jit/jit_context.h
-    hle/service/jit/jit.cpp
-    hle/service/jit/jit.h
     hle/service/lbl/lbl.cpp
     hle/service/lbl/lbl.h
     hle/service/ldn/lan_discovery.cpp
@@ -772,19 +776,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()
 
@@ -801,14 +801,18 @@ if (ENABLE_WEB_SERVICE)
     target_link_libraries(core PRIVATE web_service)
 endif()
 
-if (ARCHITECTURE_x86_64)
+if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
     target_sources(core PRIVATE
-        arm/dynarmic/arm_dynarmic_32.cpp
-        arm/dynarmic/arm_dynarmic_32.h
         arm/dynarmic/arm_dynarmic_64.cpp
         arm/dynarmic/arm_dynarmic_64.h
+        arm/dynarmic/arm_dynarmic_32.cpp
+        arm/dynarmic/arm_dynarmic_32.h
         arm/dynarmic/arm_dynarmic_cp15.cpp
         arm/dynarmic/arm_dynarmic_cp15.h
+        hle/service/jit/jit_context.cpp
+        hle/service/jit/jit_context.h
+        hle/service/jit/jit.cpp
+        hle/service/jit/jit.h
     )
     target_link_libraries(core PRIVATE dynarmic)
 endif()

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -301,6 +301,11 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         }
     }
 
+#ifdef ARCHITECTURE_arm64
+    // TODO: remove when fixed in dynarmic
+    config.optimizations &= ~Dynarmic::OptimizationFlag::BlockLinking;
+#endif
+
     return std::make_unique<Dynarmic::A32::Jit>(config);
 }
 
@@ -450,7 +455,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

@@ -517,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/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -52,12 +52,16 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
         case 4:
             // CP15_DATA_SYNC_BARRIER
             return Callback{
-                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
-#ifdef _MSC_VER
+                [](void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#if defined(_MSC_VER) && defined(ARCHITECTURE_x86_64)
                     _mm_mfence();
                     _mm_lfence();
-#else
+#elif defined(ARCHITECTURE_x86_64)
                     asm volatile("mfence\n\tlfence\n\t" : : : "memory");
+#elif defined(ARCHITECTURE_arm64)
+                    asm volatile("dsb sy\n\t" : : : "memory");
+#else
+#error Unsupported architecture
 #endif
                     return 0;
                 },
@@ -66,11 +70,15 @@ CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1
         case 5:
             // CP15_DATA_MEMORY_BARRIER
             return Callback{
-                [](Dynarmic::A32::Jit*, void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
-#ifdef _MSC_VER
+                [](void*, std::uint32_t, std::uint32_t) -> std::uint64_t {
+#if defined(_MSC_VER) && defined(ARCHITECTURE_x86_64)
                     _mm_mfence();
-#else
+#elif defined(ARCHITECTURE_x86_64)
                     asm volatile("mfence\n\t" : : : "memory");
+#elif defined(ARCHITECTURE_arm64)
+                    asm volatile("dmb sy\n\t" : : : "memory");
+#else
+#error Unsupported architecture
 #endif
                     return 0;
                 },
@@ -115,7 +123,7 @@ CallbackOrAccessOneWord DynarmicCP15::CompileGetOneWord(bool two, unsigned opc1,
 CallbackOrAccessTwoWords DynarmicCP15::CompileGetTwoWords(bool two, unsigned opc, CoprocReg CRm) {
     if (!two && opc == 0 && CRm == CoprocReg::C14) {
         // CNTPCT
-        const auto callback = [](Dynarmic::A32::Jit*, void* arg, u32, u32) -> u64 {
+        const auto callback = [](void* arg, u32, u32) -> u64 {
             const auto& parent_arg = *static_cast<ARM_Dynarmic_32*>(arg);
             return parent_arg.system.CoreTiming().GetClockTicks();
         };

src/core/arm/exclusive_monitor.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #endif
 #include "core/arm/exclusive_monitor.h"
@@ -13,7 +13,7 @@ ExclusiveMonitor::~ExclusiveMonitor() = default;
 
 std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
                                                              std::size_t num_cores) {
-#ifdef ARCHITECTURE_x86_64
+#if defined(ARCHITECTURE_x86_64) || defined(ARCHITECTURE_arm64)
     return std::make_unique<Core::DynarmicExclusiveMonitor>(memory, num_cores);
 #else
     // TODO(merry): Passthrough exclusive monitor

src/core/core.cpp

@@ -137,6 +137,7 @@ struct System::Impl {
         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(); });
@@ -166,13 +167,18 @@ struct System::Impl {
     }
 
     void ReinitializeIfNecessary(System& system) {
-        if (is_multicore == Settings::values.use_multi_core.GetValue()) {
+        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);
     }
@@ -384,6 +390,7 @@ struct System::Impl {
         kernel.ShutdownCores();
         cpu_manager.Shutdown();
         debugger.reset();
+        services->KillNVNFlinger();
         kernel.CloseServices();
         services.reset();
         service_manager.reset();
@@ -520,6 +527,7 @@ struct System::Impl {
 
     bool is_multicore{};
     bool is_async_gpu{};
+    bool extended_memory_layout{};
 
     ExecuteProgramCallback execute_program_callback;
     ExitCallback exit_callback;

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/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/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.GetManager()->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.GetManager()->IsDomain()) {
             raw_data_size +=
                 static_cast<u32>(sizeof(DomainMessageHeader) / sizeof(u32) + num_domain_objects);
             ctx.write_size += num_domain_objects;
@@ -125,7 +125,7 @@ public:
         if (!ctx.IsTipc()) {
             AlignWithPadding();
 
-            if (ctx.Session()->IsDomain() && ctx.HasDomainMessageHeader()) {
+            if (ctx.GetManager()->IsDomain() && ctx.HasDomainMessageHeader()) {
                 IPC::DomainMessageHeader domain_header{};
                 domain_header.num_objects = num_domain_objects;
                 PushRaw(domain_header);
@@ -145,18 +145,18 @@ public:
 
     template <class T>
     void PushIpcInterface(std::shared_ptr<T> iface) {
-        if (context->Session()->IsDomain()) {
+        if (context->GetManager()->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
             kernel.CurrentProcess()->GetResourceLimit()->Reserve(
-                Kernel::LimitableResource::Sessions, 1);
+                Kernel::LimitableResource::SessionCountMax, 1);
 
             auto* session = Kernel::KSession::Create(kernel);
-            session->Initialize(nullptr, iface->GetServiceName(),
-                                std::make_shared<Kernel::SessionRequestManager>(kernel));
+            session->Initialize(nullptr, iface->GetServiceName());
+            iface->RegisterSession(&session->GetServerSession(),
+                                   std::make_shared<Kernel::SessionRequestManager>(kernel));
 
             context->AddMoveObject(&session->GetClientSession());
-            iface->ClientConnected(&session->GetServerSession());
         }
     }
 
@@ -386,7 +386,7 @@ public:
 
     template <class T>
     std::weak_ptr<T> PopIpcInterface() {
-        ASSERT(context->Session()->IsDomain());
+        ASSERT(context->GetManager()->IsDomain());
         ASSERT(context->GetDomainMessageHeader().input_object_count > 0);
         return context->GetDomainHandler<T>(Pop<u32>() - 1);
     }
@@ -405,7 +405,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
@@ -416,7 +416,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/board/nintendo/nx/k_system_control.h

@@ -8,6 +8,10 @@
 namespace Kernel::Board::Nintendo::Nx {
 
 class KSystemControl {
+public:
+    // This can be overridden as needed.
+    static constexpr size_t SecureAppletMemorySize = 4 * 1024 * 1024; // 4_MB
+
 public:
     class Init {
     public:

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

@@ -16,27 +16,39 @@
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/k_server_port.h"
 #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 {
 
 SessionRequestHandler::SessionRequestHandler(KernelCore& kernel_, const char* service_name_,
                                              ServiceThreadType thread_type)
-    : kernel{kernel_} {
-    if (thread_type == ServiceThreadType::CreateNew) {
-        service_thread = kernel.CreateServiceThread(service_name_);
-    } else {
-        service_thread = kernel.GetDefaultServiceThread();
-    }
-}
+    : kernel{kernel_}, service_thread{thread_type == ServiceThreadType::CreateNew
+                                          ? kernel.CreateServiceThread(service_name_)
+                                          : kernel.GetDefaultServiceThread()} {}
 
 SessionRequestHandler::~SessionRequestHandler() {
     kernel.ReleaseServiceThread(service_thread);
 }
 
+void SessionRequestHandler::AcceptSession(KServerPort* server_port) {
+    auto* server_session = server_port->AcceptSession();
+    ASSERT(server_session != nullptr);
+
+    RegisterSession(server_session, std::make_shared<SessionRequestManager>(kernel));
+}
+
+void SessionRequestHandler::RegisterSession(KServerSession* server_session,
+                                            std::shared_ptr<SessionRequestManager> manager) {
+    manager->SetSessionHandler(shared_from_this());
+    service_thread.RegisterServerSession(server_session, manager);
+    server_session->Close();
+}
+
 SessionRequestManager::SessionRequestManager(KernelCore& kernel_) : kernel{kernel_} {}
 
 SessionRequestManager::~SessionRequestManager() = default;
@@ -56,15 +68,77 @@ bool SessionRequestManager::HasSessionRequestHandler(const HLERequestContext& co
     }
 }
 
-void SessionRequestHandler::ClientConnected(KServerSession* session) {
-    session->ClientConnected(shared_from_this());
+Result SessionRequestManager::CompleteSyncRequest(KServerSession* server_session,
+                                                  HLERequestContext& context) {
+    Result result = ResultSuccess;
 
-    // Ensure our server session is tracked globally.
-    kernel.RegisterServerObject(session);
+    // 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;
 }
 
-void SessionRequestHandler::ClientDisconnected(KServerSession* session) {
-    session->ClientDisconnected();
+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
+    ASSERT(context.GetManager().get() == this);
+
+    // 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;
 }
 
 HLERequestContext::HLERequestContext(KernelCore& kernel_, Core::Memory::Memory& memory_,
@@ -126,7 +200,7 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
         // Padding to align to 16 bytes
         rp.AlignWithPadding();
 
-        if (Session()->IsDomain() &&
+        if (GetManager()->IsDomain() &&
             ((command_header->type == IPC::CommandType::Request ||
               command_header->type == IPC::CommandType::RequestWithContext) ||
              !incoming)) {
@@ -135,7 +209,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 (GetManager()->IsDomain()) {
                     LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
                 }
             }
@@ -228,12 +302,11 @@ 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 (GetManager()->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) {
+            GetManager()->AppendDomainHandler(std::move(object));
+            cmd_buf[current_offset++] = static_cast<u32_le>(GetManager()->DomainHandlerCount());
         }
     }
 

src/core/hle/kernel/hle_ipc.h

@@ -45,11 +45,13 @@ class KAutoObject;
 class KernelCore;
 class KEvent;
 class KHandleTable;
+class KServerPort;
 class KProcess;
 class KServerSession;
 class KThread;
 class KReadableEvent;
 class KSession;
+class SessionRequestManager;
 class ServiceThread;
 
 enum class ThreadWakeupReason;
@@ -76,27 +78,17 @@ public:
     virtual Result HandleSyncRequest(Kernel::KServerSession& session,
                                      Kernel::HLERequestContext& context) = 0;
 
-    /**
-     * Signals that a client has just connected to this HLE handler and keeps the
-     * associated ServerSession alive for the duration of the connection.
-     * @param server_session Owning pointer to the ServerSession associated with the connection.
-     */
-    void ClientConnected(KServerSession* session);
+    void AcceptSession(KServerPort* server_port);
+    void RegisterSession(KServerSession* server_session,
+                         std::shared_ptr<SessionRequestManager> manager);
 
-    /**
-     * Signals that a client has just disconnected from this HLE handler and releases the
-     * associated ServerSession.
-     * @param server_session ServerSession associated with the connection.
-     */
-    void ClientDisconnected(KServerSession* session);
-
-    std::weak_ptr<ServiceThread> GetServiceThread() const {
+    ServiceThread& GetServiceThread() const {
         return service_thread;
     }
 
 protected:
     KernelCore& kernel;
-    std::weak_ptr<ServiceThread> service_thread;
+    ServiceThread& service_thread;
 };
 
 using SessionRequestHandlerWeakPtr = std::weak_ptr<SessionRequestHandler>;
@@ -121,6 +113,10 @@ public:
         is_domain = true;
     }
 
+    void ConvertToDomainOnRequestEnd() {
+        convert_to_domain = true;
+    }
+
     std::size_t DomainHandlerCount() const {
         return domain_handlers.size();
     }
@@ -158,13 +154,17 @@ public:
         session_handler = std::move(handler);
     }
 
-    std::weak_ptr<ServiceThread> GetServiceThread() const {
+    ServiceThread& GetServiceThread() const {
         return session_handler->GetServiceThread();
     }
 
     bool HasSessionRequestHandler(const HLERequestContext& context) const;
 
+    Result HandleDomainSyncRequest(KServerSession* server_session, HLERequestContext& context);
+    Result CompleteSyncRequest(KServerSession* server_session, HLERequestContext& context);
+
 private:
+    bool convert_to_domain{};
     bool is_domain{};
     SessionRequestHandlerPtr session_handler;
     std::vector<SessionRequestHandlerPtr> domain_handlers;
@@ -295,7 +295,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");
@@ -341,11 +341,11 @@ public:
 
     template <typename T>
     std::shared_ptr<T> GetDomainHandler(std::size_t index) const {
-        return std::static_pointer_cast<T>(manager.lock()->DomainHandler(index).lock());
+        return std::static_pointer_cast<T>(GetManager()->DomainHandler(index).lock());
     }
 
     void SetSessionRequestManager(std::weak_ptr<SessionRequestManager> manager_) {
-        manager = std::move(manager_);
+        manager = manager_;
     }
 
     std::string Description() const;
@@ -354,6 +354,10 @@ public:
         return *thread;
     }
 
+    std::shared_ptr<SessionRequestManager> GetManager() const {
+        return manager.lock();
+    }
+
 private:
     friend class IPC::ResponseBuilder;
 
@@ -387,7 +391,7 @@ private:
     u32 handles_offset{};
     u32 domain_offset{};
 
-    std::weak_ptr<SessionRequestManager> manager;
+    std::weak_ptr<SessionRequestManager> manager{};
 
     KernelCore& kernel;
     Core::Memory::Memory& memory;

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

@@ -10,7 +10,9 @@
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/init/init_slab_setup.h"
 #include "core/hle/kernel/k_code_memory.h"
+#include "core/hle/kernel/k_debug.h"
 #include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_event_info.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_page_buffer.h"
@@ -18,9 +20,11 @@
 #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"
+#include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_thread_local_page.h"
 #include "core/hle/kernel/k_transfer_memory.h"
@@ -34,6 +38,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__)                         \
@@ -42,7 +47,10 @@ namespace Kernel::Init {
     HANDLER(KThreadLocalPage,                                                                      \
             (SLAB_COUNT(KProcess) + (SLAB_COUNT(KProcess) + SLAB_COUNT(KThread)) / 8),             \
             ##__VA_ARGS__)                                                                         \
-    HANDLER(KResourceLimit, (SLAB_COUNT(KResourceLimit)), ##__VA_ARGS__)
+    HANDLER(KResourceLimit, (SLAB_COUNT(KResourceLimit)), ##__VA_ARGS__)                           \
+    HANDLER(KEventInfo, (SLAB_COUNT(KThread) + SLAB_COUNT(KDebug)), ##__VA_ARGS__)                 \
+    HANDLER(KDebug, (SLAB_COUNT(KDebug)), ##__VA_ARGS__)                                           \
+    HANDLER(KSecureSystemResource, (SLAB_COUNT(KProcess)), ##__VA_ARGS__)
 
 namespace {
 
@@ -71,8 +79,20 @@ constexpr size_t SlabCountKResourceLimit = 5;
 constexpr size_t SlabCountKDebug = Core::Hardware::NUM_CPU_CORES;
 constexpr size_t SlabCountKIoPool = 1;
 constexpr size_t SlabCountKIoRegion = 6;
+constexpr size_t SlabcountKSessionRequestMappings = 40;
 
-constexpr size_t SlabCountExtraKThread = 160;
+constexpr size_t SlabCountExtraKThread = (1024 + 256 + 256) - SlabCountKThread;
+
+namespace test {
+
+static_assert(KernelPageBufferHeapSize ==
+              2 * PageSize + (SlabCountKProcess + SlabCountKThread +
+                              (SlabCountKProcess + SlabCountKThread) / 8) *
+                                 PageSize);
+static_assert(KernelPageBufferAdditionalSize ==
+              (SlabCountExtraKThread + (SlabCountExtraKThread / 8)) * PageSize);
+
+} // namespace test
 
 /// Helper function to translate from the slab virtual address to the reserved location in physical
 /// memory.
@@ -107,7 +127,7 @@ VAddr InitializeSlabHeap(Core::System& system, KMemoryLayout& memory_layout, VAd
 }
 
 size_t CalculateSlabHeapGapSize() {
-    constexpr size_t KernelSlabHeapGapSize = 2_MiB - 296_KiB;
+    constexpr size_t KernelSlabHeapGapSize = 2_MiB - 320_KiB;
     static_assert(KernelSlabHeapGapSize <= KernelSlabHeapGapsSizeMax);
     return KernelSlabHeapGapSize;
 }
@@ -132,6 +152,7 @@ KSlabResourceCounts KSlabResourceCounts::CreateDefault() {
         .num_KDebug = SlabCountKDebug,
         .num_KIoPool = SlabCountKIoPool,
         .num_KIoRegion = SlabCountKIoRegion,
+        .num_KSessionRequestMappings = SlabcountKSessionRequestMappings,
     };
 }
 
@@ -162,29 +183,6 @@ size_t CalculateTotalSlabHeapSize(const KernelCore& kernel) {
     return size;
 }
 
-void InitializeKPageBufferSlabHeap(Core::System& system) {
-    auto& kernel = system.Kernel();
-
-    const auto& counts = kernel.SlabResourceCounts();
-    const size_t num_pages =
-        counts.num_KProcess + counts.num_KThread + (counts.num_KProcess + counts.num_KThread) / 8;
-    const size_t slab_size = num_pages * PageSize;
-
-    // Reserve memory from the system resource limit.
-    ASSERT(kernel.GetSystemResourceLimit()->Reserve(LimitableResource::PhysicalMemory, slab_size));
-
-    // Allocate memory for the slab.
-    constexpr auto AllocateOption = KMemoryManager::EncodeOption(
-        KMemoryManager::Pool::System, KMemoryManager::Direction::FromFront);
-    const PAddr slab_address =
-        kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, AllocateOption);
-    ASSERT(slab_address != 0);
-
-    // Initialize the slabheap.
-    KPageBuffer::InitializeSlabHeap(kernel, system.DeviceMemory().GetPointer<void>(slab_address),
-                                    slab_size);
-}
-
 void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {
     auto& kernel = system.Kernel();
 
@@ -256,3 +254,30 @@ void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {
 }
 
 } // namespace Kernel::Init
+
+namespace Kernel {
+
+void KPageBufferSlabHeap::Initialize(Core::System& system) {
+    auto& kernel = system.Kernel();
+    const auto& counts = kernel.SlabResourceCounts();
+    const size_t num_pages =
+        counts.num_KProcess + counts.num_KThread + (counts.num_KProcess + counts.num_KThread) / 8;
+    const size_t slab_size = num_pages * PageSize;
+
+    // Reserve memory from the system resource limit.
+    ASSERT(
+        kernel.GetSystemResourceLimit()->Reserve(LimitableResource::PhysicalMemoryMax, slab_size));
+
+    // Allocate memory for the slab.
+    constexpr auto AllocateOption = KMemoryManager::EncodeOption(
+        KMemoryManager::Pool::System, KMemoryManager::Direction::FromFront);
+    const PAddr slab_address =
+        kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, AllocateOption);
+    ASSERT(slab_address != 0);
+
+    // Initialize the slabheap.
+    KPageBuffer::InitializeSlabHeap(kernel, system.DeviceMemory().GetPointer<void>(slab_address),
+                                    slab_size);
+}
+
+} // namespace Kernel

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

@@ -33,11 +33,11 @@ struct KSlabResourceCounts {
     size_t num_KDebug;
     size_t num_KIoPool;
     size_t num_KIoRegion;
+    size_t num_KSessionRequestMappings;
 };
 
 void InitializeSlabResourceCounts(KernelCore& kernel);
 size_t CalculateTotalSlabHeapSize(const KernelCore& kernel);
-void InitializeKPageBufferSlabHeap(Core::System& system);
 void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout);
 
 } // namespace Kernel::Init

src/core/hle/kernel/k_class_token.cpp

@@ -16,6 +16,7 @@
 #include "core/hle/kernel/k_session.h"
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 
@@ -119,4 +120,6 @@ static_assert(std::is_final_v<KTransferMemory> && std::is_base_of_v<KAutoObject,
 // static_assert(std::is_final_v<KCodeMemory> &&
 //              std::is_base_of_v<KAutoObject, KCodeMemory>);
 
+static_assert(std::is_base_of_v<KAutoObject, KSystemResource>);
+
 } // namespace Kernel

src/core/hle/kernel/k_class_token.h

@@ -10,6 +10,8 @@ namespace Kernel {
 
 class KAutoObject;
 
+class KSystemResource;
+
 class KClassTokenGenerator {
 public:
     using TokenBaseType = u16;
@@ -58,7 +60,7 @@ private:
         if constexpr (std::is_same<T, KAutoObject>::value) {
             static_assert(T::ObjectType == ObjectType::KAutoObject);
             return 0;
-        } else if constexpr (!std::is_final<T>::value) {
+        } else if constexpr (!std::is_final<T>::value && !std::same_as<T, KSystemResource>) {
             static_assert(ObjectType::BaseClassesStart <= T::ObjectType &&
                           T::ObjectType < ObjectType::BaseClassesEnd);
             constexpr auto ClassIndex = static_cast<TokenBaseType>(T::ObjectType) -
@@ -108,6 +110,8 @@ public:
         KSessionRequest,
         KCodeMemory,
 
+        KSystemResource,
+
         // NOTE: True order for these has not been determined yet.
         KAlpha,
         KBeta,

src/core/hle/kernel/k_client_port.cpp

@@ -58,11 +58,10 @@ bool KClientPort::IsSignaled() const {
     return num_sessions < max_sessions;
 }
 
-Result KClientPort::CreateSession(KClientSession** out,
-                                  std::shared_ptr<SessionRequestManager> session_manager) {
+Result KClientPort::CreateSession(KClientSession** out) {
     // Reserve a new session from the resource limit.
     KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
-                                                   LimitableResource::Sessions);
+                                                   LimitableResource::SessionCountMax);
     R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
 
     // Update the session counts.
@@ -104,7 +103,7 @@ Result KClientPort::CreateSession(KClientSession** out,
     }
 
     // Initialize the session.
-    session->Initialize(this, parent->GetName(), session_manager);
+    session->Initialize(this, parent->GetName());
 
     // Commit the session reservation.
     session_reservation.Commit();

src/core/hle/kernel/k_client_port.h

@@ -52,8 +52,7 @@ public:
     void Destroy() override;
     bool IsSignaled() const override;
 
-    Result CreateSession(KClientSession** out,
-                         std::shared_ptr<SessionRequestManager> session_manager = nullptr);
+    Result CreateSession(KClientSession** out);
 
 private:
     std::atomic<s32> num_sessions{};

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;
@@ -22,8 +25,16 @@ void KClientSession::Destroy() {
 void KClientSession::OnServerClosed() {}
 
 Result KClientSession::SendSyncRequest() {
-    // Signal the server session that new data is available
-    return parent->GetServerSession().OnRequest();
+    // 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_debug.h

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_auto_object.h"
+#include "core/hle/kernel/slab_helpers.h"
+
+namespace Kernel {
+
+class KDebug final : public KAutoObjectWithSlabHeapAndContainer<KDebug, KAutoObjectWithList> {
+    KERNEL_AUTOOBJECT_TRAITS(KDebug, KAutoObject);
+
+public:
+    explicit KDebug(KernelCore& kernel_) : KAutoObjectWithSlabHeapAndContainer{kernel_} {}
+
+    static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_dynamic_page_manager.h

@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <vector>
+
 #include "common/alignment.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/k_page_bitmap.h"
@@ -33,28 +35,36 @@ public:
         return reinterpret_cast<T*>(m_backing_memory.data() + (addr - m_address));
     }
 
-    Result Initialize(VAddr addr, size_t sz) {
+    Result Initialize(VAddr memory, size_t size, size_t align) {
         // We need to have positive size.
-        R_UNLESS(sz > 0, ResultOutOfMemory);
-        m_backing_memory.resize(sz);
+        R_UNLESS(size > 0, ResultOutOfMemory);
+        m_backing_memory.resize(size);
 
-        // Calculate management overhead.
-        const size_t management_size =
-            KPageBitmap::CalculateManagementOverheadSize(sz / sizeof(PageBuffer));
-        const size_t allocatable_size = sz - management_size;
+        // Set addresses.
+        m_address = memory;
+        m_aligned_address = Common::AlignDown(memory, align);
+
+        // Calculate extents.
+        const size_t managed_size = m_address + size - m_aligned_address;
+        const size_t overhead_size = Common::AlignUp(
+            KPageBitmap::CalculateManagementOverheadSize(managed_size / sizeof(PageBuffer)),
+            sizeof(PageBuffer));
+        R_UNLESS(overhead_size < size, ResultOutOfMemory);
 
         // 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);
+        m_size = Common::AlignDown(size - overhead_size, sizeof(PageBuffer));
+        m_count = m_size / sizeof(PageBuffer);
 
         // Clear the management region.
-        u64* management_ptr = GetPointer<u64>(m_address + allocatable_size);
-        std::memset(management_ptr, 0, management_size);
+        u64* management_ptr = GetPointer<u64>(m_address + size - overhead_size);
+        std::memset(management_ptr, 0, overhead_size);
 
         // Initialize the bitmap.
-        m_page_bitmap.Initialize(management_ptr, m_count);
+        const size_t allocatable_region_size =
+            (m_address + size - overhead_size) - m_aligned_address;
+        ASSERT(allocatable_region_size >= sizeof(PageBuffer));
+
+        m_page_bitmap.Initialize(management_ptr, allocatable_region_size / sizeof(PageBuffer));
 
         // Free the pages to the bitmap.
         for (size_t i = 0; i < m_count; i++) {
@@ -62,7 +72,8 @@ public:
             std::memset(GetPointer<PageBuffer>(m_address) + i, 0, PageSize);
 
             // Set the bit for the free page.
-            m_page_bitmap.SetBit(i);
+            m_page_bitmap.SetBit((m_address + (i * sizeof(PageBuffer)) - m_aligned_address) /
+                                 sizeof(PageBuffer));
         }
 
         R_SUCCEED();
@@ -101,7 +112,28 @@ public:
         m_page_bitmap.ClearBit(offset);
         m_peak = std::max(m_peak, (++m_used));
 
-        return GetPointer<PageBuffer>(m_address) + offset;
+        return GetPointer<PageBuffer>(m_aligned_address) + offset;
+    }
+
+    PageBuffer* Allocate(size_t count) {
+        // 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.FindFreeRange(count);
+        if (soffset < 0) [[likely]] {
+            return nullptr;
+        }
+
+        const size_t offset = static_cast<size_t>(soffset);
+
+        // Update our tracking.
+        m_page_bitmap.ClearRange(offset, count);
+        m_used += count;
+        m_peak = std::max(m_peak, m_used);
+
+        return GetPointer<PageBuffer>(m_aligned_address) + offset;
     }
 
     void Free(PageBuffer* pb) {
@@ -113,7 +145,7 @@ public:
         KScopedSpinLock lk(m_lock);
 
         // Set the bit for the free page.
-        size_t offset = (reinterpret_cast<uintptr_t>(pb) - m_address) / sizeof(PageBuffer);
+        size_t offset = (reinterpret_cast<uintptr_t>(pb) - m_aligned_address) / sizeof(PageBuffer);
         m_page_bitmap.SetBit(offset);
 
         // Decrement our used count.
@@ -127,6 +159,7 @@ private:
     size_t m_peak{};
     size_t m_count{};
     VAddr m_address{};
+    VAddr m_aligned_address{};
     size_t m_size{};
 
     // TODO(bunnei): Back by host memory until we emulate kernel virtual address space.

src/core/hle/kernel/k_dynamic_resource_manager.h

@@ -6,6 +6,7 @@
 #include "common/common_funcs.h"
 #include "core/hle/kernel/k_dynamic_slab_heap.h"
 #include "core/hle/kernel/k_memory_block.h"
+#include "core/hle/kernel/k_page_group.h"
 
 namespace Kernel {
 
@@ -51,8 +52,10 @@ private:
     DynamicSlabType* m_slab_heap{};
 };
 
+class KBlockInfoManager : public KDynamicResourceManager<KBlockInfo> {};
 class KMemoryBlockSlabManager : public KDynamicResourceManager<KMemoryBlock> {};
 
+using KBlockInfoSlabHeap = typename KBlockInfoManager::DynamicSlabType;
 using KMemoryBlockSlabHeap = typename KMemoryBlockSlabManager::DynamicSlabType;
 
 } // namespace Kernel

src/core/hle/kernel/k_event.cpp

@@ -20,8 +20,12 @@ void KEvent::Initialize(KProcess* owner) {
     m_readable_event.Initialize(this);
 
     // Set our owner process.
-    m_owner = owner;
-    m_owner->Open();
+    // HACK: this should never be nullptr, but service threads don't have a
+    // proper parent process yet.
+    if (owner != nullptr) {
+        m_owner = owner;
+        m_owner->Open();
+    }
 
     // Mark initialized.
     m_initialized = true;
@@ -50,8 +54,11 @@ Result KEvent::Clear() {
 void KEvent::PostDestroy(uintptr_t arg) {
     // Release the event count resource the owner process holds.
     KProcess* owner = reinterpret_cast<KProcess*>(arg);
-    owner->GetResourceLimit()->Release(LimitableResource::Events, 1);
-    owner->Close();
+
+    if (owner != nullptr) {
+        owner->GetResourceLimit()->Release(LimitableResource::EventCountMax, 1);
+        owner->Close();
+    }
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_event_info.h

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include <boost/intrusive/list.hpp>
+
+#include "core/hle/kernel/slab_helpers.h"
+#include "core/hle/kernel/svc_types.h"
+
+namespace Kernel {
+
+class KEventInfo : public KSlabAllocated<KEventInfo>, public boost::intrusive::list_base_hook<> {
+public:
+    struct InfoCreateThread {
+        u32 thread_id{};
+        uintptr_t tls_address{};
+    };
+
+    struct InfoExitProcess {
+        Svc::ProcessExitReason reason{};
+    };
+
+    struct InfoExitThread {
+        Svc::ThreadExitReason reason{};
+    };
+
+    struct InfoException {
+        Svc::DebugException exception_type{};
+        s32 exception_data_count{};
+        uintptr_t exception_address{};
+        std::array<uintptr_t, 4> exception_data{};
+    };
+
+    struct InfoSystemCall {
+        s64 tick{};
+        s32 id{};
+    };
+
+public:
+    KEventInfo() = default;
+    ~KEventInfo() = default;
+
+public:
+    Svc::DebugEvent event{};
+    u32 thread_id{};
+    u32 flags{};
+    bool is_attached{};
+    bool continue_flag{};
+    bool ignore_continue{};
+    bool close_once{};
+    union {
+        InfoCreateThread create_thread;
+        InfoExitProcess exit_process;
+        InfoExitThread exit_thread;
+        InfoException exception;
+        InfoSystemCall system_call;
+    } info{};
+    KThread* debug_thread{};
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_handle_table.cpp

@@ -5,14 +5,11 @@
 
 namespace Kernel {
 
-KHandleTable::KHandleTable(KernelCore& kernel_) : kernel{kernel_} {}
-KHandleTable::~KHandleTable() = default;
-
 Result KHandleTable::Finalize() {
     // Get the table and clear our record of it.
     u16 saved_table_size = 0;
     {
-        KScopedDisableDispatch dd(kernel);
+        KScopedDisableDispatch dd{m_kernel};
         KScopedSpinLock lk(m_lock);
 
         std::swap(m_table_size, saved_table_size);
@@ -25,28 +22,28 @@ Result KHandleTable::Finalize() {
         }
     }
 
-    return ResultSuccess;
+    R_SUCCEED();
 }
 
 bool KHandleTable::Remove(Handle handle) {
     // Don't allow removal of a pseudo-handle.
-    if (Svc::IsPseudoHandle(handle)) {
+    if (Svc::IsPseudoHandle(handle)) [[unlikely]] {
         return false;
     }
 
     // Handles must not have reserved bits set.
     const auto handle_pack = HandlePack(handle);
-    if (handle_pack.reserved != 0) {
+    if (handle_pack.reserved != 0) [[unlikely]] {
         return false;
     }
 
     // Find the object and free the entry.
     KAutoObject* obj = nullptr;
     {
-        KScopedDisableDispatch dd(kernel);
+        KScopedDisableDispatch dd{m_kernel};
         KScopedSpinLock lk(m_lock);
 
-        if (this->IsValidHandle(handle)) {
+        if (this->IsValidHandle(handle)) [[likely]] {
             const auto index = handle_pack.index;
 
             obj = m_objects[index];
@@ -57,13 +54,13 @@ bool KHandleTable::Remove(Handle handle) {
     }
 
     // Close the object.
-    kernel.UnregisterInUseObject(obj);
+    m_kernel.UnregisterInUseObject(obj);
     obj->Close();
     return true;
 }
 
 Result KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
-    KScopedDisableDispatch dd(kernel);
+    KScopedDisableDispatch dd{m_kernel};
     KScopedSpinLock lk(m_lock);
 
     // Never exceed our capacity.
@@ -82,22 +79,22 @@ Result KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
         *out_handle = EncodeHandle(static_cast<u16>(index), linear_id);
     }
 
-    return ResultSuccess;
+    R_SUCCEED();
 }
 
 Result KHandleTable::Reserve(Handle* out_handle) {
-    KScopedDisableDispatch dd(kernel);
+    KScopedDisableDispatch dd{m_kernel};
     KScopedSpinLock lk(m_lock);
 
     // Never exceed our capacity.
     R_UNLESS(m_count < m_table_size, ResultOutOfHandles);
 
     *out_handle = EncodeHandle(static_cast<u16>(this->AllocateEntry()), this->AllocateLinearId());
-    return ResultSuccess;
+    R_SUCCEED();
 }
 
 void KHandleTable::Unreserve(Handle handle) {
-    KScopedDisableDispatch dd(kernel);
+    KScopedDisableDispatch dd{m_kernel};
     KScopedSpinLock lk(m_lock);
 
     // Unpack the handle.
@@ -108,7 +105,7 @@ void KHandleTable::Unreserve(Handle handle) {
     ASSERT(reserved == 0);
     ASSERT(linear_id != 0);
 
-    if (index < m_table_size) {
+    if (index < m_table_size) [[likely]] {
         // NOTE: This code does not check the linear id.
         ASSERT(m_objects[index] == nullptr);
         this->FreeEntry(index);
@@ -116,7 +113,7 @@ void KHandleTable::Unreserve(Handle handle) {
 }
 
 void KHandleTable::Register(Handle handle, KAutoObject* obj) {
-    KScopedDisableDispatch dd(kernel);
+    KScopedDisableDispatch dd{m_kernel};
     KScopedSpinLock lk(m_lock);
 
     // Unpack the handle.
@@ -127,7 +124,7 @@ void KHandleTable::Register(Handle handle, KAutoObject* obj) {
     ASSERT(reserved == 0);
     ASSERT(linear_id != 0);
 
-    if (index < m_table_size) {
+    if (index < m_table_size) [[likely]] {
         // Set the entry.
         ASSERT(m_objects[index] == nullptr);
 

src/core/hle/kernel/k_handle_table.h

@@ -21,33 +21,38 @@ namespace Kernel {
 class KernelCore;
 
 class KHandleTable {
-public:
     YUZU_NON_COPYABLE(KHandleTable);
     YUZU_NON_MOVEABLE(KHandleTable);
 
+public:
     static constexpr size_t MaxTableSize = 1024;
 
-    explicit KHandleTable(KernelCore& kernel_);
-    ~KHandleTable();
+public:
+    explicit KHandleTable(KernelCore& kernel) : m_kernel(kernel) {}
 
     Result Initialize(s32 size) {
+        // Check that the table size is valid.
         R_UNLESS(size <= static_cast<s32>(MaxTableSize), ResultOutOfMemory);
 
+        // Lock.
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk(m_lock);
+
         // Initialize all fields.
         m_max_count = 0;
-        m_table_size = static_cast<u16>((size <= 0) ? MaxTableSize : size);
+        m_table_size = static_cast<s16>((size <= 0) ? MaxTableSize : size);
         m_next_linear_id = MinLinearId;
         m_count = 0;
         m_free_head_index = -1;
 
         // Free all entries.
-        for (s16 i = 0; i < static_cast<s16>(m_table_size); ++i) {
+        for (s32 i = 0; i < static_cast<s32>(m_table_size); ++i) {
             m_objects[i] = nullptr;
-            m_entry_infos[i].next_free_index = i - 1;
+            m_entry_infos[i].next_free_index = static_cast<s16>(i - 1);
             m_free_head_index = i;
         }
 
-        return ResultSuccess;
+        R_SUCCEED();
     }
 
     size_t GetTableSize() const {
@@ -66,13 +71,13 @@ public:
     template <typename T = KAutoObject>
     KScopedAutoObject<T> GetObjectWithoutPseudoHandle(Handle handle) const {
         // Lock and look up in table.
-        KScopedDisableDispatch dd(kernel);
+        KScopedDisableDispatch dd{m_kernel};
         KScopedSpinLock lk(m_lock);
 
         if constexpr (std::is_same_v<T, KAutoObject>) {
             return this->GetObjectImpl(handle);
         } else {
-            if (auto* obj = this->GetObjectImpl(handle); obj != nullptr) {
+            if (auto* obj = this->GetObjectImpl(handle); obj != nullptr) [[likely]] {
                 return obj->DynamicCast<T*>();
             } else {
                 return nullptr;
@@ -85,13 +90,13 @@ public:
         // Handle pseudo-handles.
         if constexpr (std::derived_from<KProcess, T>) {
             if (handle == Svc::PseudoHandle::CurrentProcess) {
-                auto* const cur_process = kernel.CurrentProcess();
+                auto* const cur_process = m_kernel.CurrentProcess();
                 ASSERT(cur_process != nullptr);
                 return cur_process;
             }
         } else if constexpr (std::derived_from<KThread, T>) {
             if (handle == Svc::PseudoHandle::CurrentThread) {
-                auto* const cur_thread = GetCurrentThreadPointer(kernel);
+                auto* const cur_thread = GetCurrentThreadPointer(m_kernel);
                 ASSERT(cur_thread != nullptr);
                 return cur_thread;
             }
@@ -100,6 +105,37 @@ public:
         return this->template GetObjectWithoutPseudoHandle<T>(handle);
     }
 
+    KScopedAutoObject<KAutoObject> GetObjectForIpcWithoutPseudoHandle(Handle handle) const {
+        // Lock and look up in table.
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk(m_lock);
+
+        return this->GetObjectImpl(handle);
+    }
+
+    KScopedAutoObject<KAutoObject> GetObjectForIpc(Handle handle, KThread* cur_thread) const {
+        // Handle pseudo-handles.
+        ASSERT(cur_thread != nullptr);
+        if (handle == Svc::PseudoHandle::CurrentProcess) {
+            auto* const cur_process =
+                static_cast<KAutoObject*>(static_cast<void*>(cur_thread->GetOwnerProcess()));
+            ASSERT(cur_process != nullptr);
+            return cur_process;
+        }
+        if (handle == Svc::PseudoHandle::CurrentThread) {
+            return static_cast<KAutoObject*>(cur_thread);
+        }
+
+        return GetObjectForIpcWithoutPseudoHandle(handle);
+    }
+
+    KScopedAutoObject<KAutoObject> GetObjectByIndex(Handle* out_handle, size_t index) const {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk(m_lock);
+
+        return this->GetObjectByIndexImpl(out_handle, index);
+    }
+
     Result Reserve(Handle* out_handle);
     void Unreserve(Handle handle);
 
@@ -112,7 +148,7 @@ public:
         size_t num_opened;
         {
             // Lock the table.
-            KScopedDisableDispatch dd(kernel);
+            KScopedDisableDispatch dd{m_kernel};
             KScopedSpinLock lk(m_lock);
             for (num_opened = 0; num_opened < num_handles; num_opened++) {
                 // Get the current handle.
@@ -120,13 +156,13 @@ public:
 
                 // Get the object for the current handle.
                 KAutoObject* cur_object = this->GetObjectImpl(cur_handle);
-                if (cur_object == nullptr) {
+                if (cur_object == nullptr) [[unlikely]] {
                     break;
                 }
 
                 // Cast the current object to the desired type.
                 T* cur_t = cur_object->DynamicCast<T*>();
-                if (cur_t == nullptr) {
+                if (cur_t == nullptr) [[unlikely]] {
                     break;
                 }
 
@@ -137,7 +173,7 @@ public:
         }
 
         // If we converted every object, succeed.
-        if (num_opened == num_handles) {
+        if (num_opened == num_handles) [[likely]] {
             return true;
         }
 
@@ -191,21 +227,21 @@ private:
         ASSERT(reserved == 0);
 
         // Validate our indexing information.
-        if (raw_value == 0) {
+        if (raw_value == 0) [[unlikely]] {
             return false;
         }
-        if (linear_id == 0) {
+        if (linear_id == 0) [[unlikely]] {
             return false;
         }
-        if (index >= m_table_size) {
+        if (index >= m_table_size) [[unlikely]] {
             return false;
         }
 
         // Check that there's an object, and our serial id is correct.
-        if (m_objects[index] == nullptr) {
+        if (m_objects[index] == nullptr) [[unlikely]] {
             return false;
         }
-        if (m_entry_infos[index].GetLinearId() != linear_id) {
+        if (m_entry_infos[index].GetLinearId() != linear_id) [[unlikely]] {
             return false;
         }
 
@@ -215,11 +251,11 @@ private:
     KAutoObject* GetObjectImpl(Handle handle) const {
         // Handles must not have reserved bits set.
         const auto handle_pack = HandlePack(handle);
-        if (handle_pack.reserved != 0) {
+        if (handle_pack.reserved != 0) [[unlikely]] {
             return nullptr;
         }
 
-        if (this->IsValidHandle(handle)) {
+        if (this->IsValidHandle(handle)) [[likely]] {
             return m_objects[handle_pack.index];
         } else {
             return nullptr;
@@ -227,9 +263,8 @@ private:
     }
 
     KAutoObject* GetObjectByIndexImpl(Handle* out_handle, size_t index) const {
-
         // Index must be in bounds.
-        if (index >= m_table_size) {
+        if (index >= m_table_size) [[unlikely]] {
             return nullptr;
         }
 
@@ -244,18 +279,15 @@ private:
 
 private:
     union HandlePack {
-        HandlePack() = default;
-        HandlePack(Handle handle) : raw{static_cast<u32>(handle)} {}
+        constexpr HandlePack() = default;
+        constexpr HandlePack(Handle handle) : raw{static_cast<u32>(handle)} {}
 
-        u32 raw;
+        u32 raw{};
         BitField<0, 15, u32> index;
         BitField<15, 15, u32> linear_id;
         BitField<30, 2, u32> reserved;
     };
 
-    static constexpr u16 MinLinearId = 1;
-    static constexpr u16 MaxLinearId = 0x7FFF;
-
     static constexpr Handle EncodeHandle(u16 index, u16 linear_id) {
         HandlePack handle{};
         handle.index.Assign(index);
@@ -264,6 +296,10 @@ private:
         return handle.raw;
     }
 
+private:
+    static constexpr u16 MinLinearId = 1;
+    static constexpr u16 MaxLinearId = 0x7FFF;
+
     union EntryInfo {
         u16 linear_id;
         s16 next_free_index;
@@ -271,21 +307,21 @@ private:
         constexpr u16 GetLinearId() const {
             return linear_id;
         }
-        constexpr s16 GetNextFreeIndex() const {
+        constexpr s32 GetNextFreeIndex() const {
             return next_free_index;
         }
     };
 
 private:
+    KernelCore& m_kernel;
     std::array<EntryInfo, MaxTableSize> m_entry_infos{};
     std::array<KAutoObject*, MaxTableSize> m_objects{};
-    s32 m_free_head_index{-1};
+    mutable KSpinLock m_lock;
+    s32 m_free_head_index{};
     u16 m_table_size{};
     u16 m_max_count{};
-    u16 m_next_linear_id{MinLinearId};
+    u16 m_next_linear_id{};
     u16 m_count{};
-    mutable KSpinLock m_lock;
-    KernelCore& kernel;
 };
 
 } // 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

@@ -35,26 +35,32 @@ enum class KMemoryState : u32 {
     FlagCanMapProcess = (1 << 23),
     FlagCanChangeAttribute = (1 << 24),
     FlagCanCodeMemory = (1 << 25),
+    FlagLinearMapped = (1 << 26),
 
     FlagsData = FlagCanReprotect | FlagCanUseIpc | FlagCanUseNonDeviceIpc | FlagCanUseNonSecureIpc |
                 FlagMapped | FlagCanAlias | FlagCanTransfer | FlagCanQueryPhysical |
                 FlagCanDeviceMap | FlagCanAlignedDeviceMap | FlagCanIpcUserBuffer |
-                FlagReferenceCounted | FlagCanChangeAttribute,
+                FlagReferenceCounted | FlagCanChangeAttribute | FlagLinearMapped,
 
     FlagsCode = FlagCanDebug | FlagCanUseIpc | FlagCanUseNonDeviceIpc | FlagCanUseNonSecureIpc |
                 FlagMapped | FlagCode | FlagCanQueryPhysical | FlagCanDeviceMap |
-                FlagCanAlignedDeviceMap | FlagReferenceCounted,
+                FlagCanAlignedDeviceMap | FlagReferenceCounted | FlagLinearMapped,
 
-    FlagsMisc = FlagMapped | FlagReferenceCounted | FlagCanQueryPhysical | FlagCanDeviceMap,
+    FlagsMisc = FlagMapped | FlagReferenceCounted | FlagCanQueryPhysical | FlagCanDeviceMap |
+                FlagLinearMapped,
 
     Free = static_cast<u32>(Svc::MemoryState::Free),
-    Io = static_cast<u32>(Svc::MemoryState::Io) | FlagMapped,
+    Io = static_cast<u32>(Svc::MemoryState::Io) | FlagMapped | FlagCanDeviceMap |
+         FlagCanAlignedDeviceMap,
     Static = static_cast<u32>(Svc::MemoryState::Static) | FlagMapped | FlagCanQueryPhysical,
     Code = static_cast<u32>(Svc::MemoryState::Code) | FlagsCode | FlagCanMapProcess,
     CodeData = static_cast<u32>(Svc::MemoryState::CodeData) | FlagsData | FlagCanMapProcess |
                FlagCanCodeMemory,
-    Shared = static_cast<u32>(Svc::MemoryState::Shared) | FlagMapped | FlagReferenceCounted,
     Normal = static_cast<u32>(Svc::MemoryState::Normal) | FlagsData | FlagCanCodeMemory,
+    Shared = static_cast<u32>(Svc::MemoryState::Shared) | FlagMapped | FlagReferenceCounted |
+             FlagLinearMapped,
+
+    // Alias was removed after 1.0.0.
 
     AliasCode = static_cast<u32>(Svc::MemoryState::AliasCode) | FlagsCode | FlagCanMapProcess |
                 FlagCanCodeAlias,
@@ -67,18 +73,18 @@ enum class KMemoryState : u32 {
     Stack = static_cast<u32>(Svc::MemoryState::Stack) | FlagsMisc | FlagCanAlignedDeviceMap |
             FlagCanUseIpc | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 
-    ThreadLocal =
-        static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagMapped | FlagReferenceCounted,
+    ThreadLocal = static_cast<u32>(Svc::MemoryState::ThreadLocal) | FlagMapped | FlagLinearMapped,
 
-    Transfered = static_cast<u32>(Svc::MemoryState::Transferred) | FlagsMisc |
+    Transfered = static_cast<u32>(Svc::MemoryState::Transfered) | FlagsMisc |
                  FlagCanAlignedDeviceMap | FlagCanChangeAttribute | FlagCanUseIpc |
                  FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 
-    SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransferred) | FlagsMisc |
+    SharedTransfered = static_cast<u32>(Svc::MemoryState::SharedTransfered) | FlagsMisc |
                        FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 
     SharedCode = static_cast<u32>(Svc::MemoryState::SharedCode) | FlagMapped |
-                 FlagReferenceCounted | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
+                 FlagReferenceCounted | FlagLinearMapped | FlagCanUseNonSecureIpc |
+                 FlagCanUseNonDeviceIpc,
 
     Inaccessible = static_cast<u32>(Svc::MemoryState::Inaccessible),
 
@@ -91,69 +97,69 @@ enum class KMemoryState : u32 {
     Kernel = static_cast<u32>(Svc::MemoryState::Kernel) | FlagMapped,
 
     GeneratedCode = static_cast<u32>(Svc::MemoryState::GeneratedCode) | FlagMapped |
-                    FlagReferenceCounted | FlagCanDebug,
-    CodeOut = static_cast<u32>(Svc::MemoryState::CodeOut) | FlagMapped | FlagReferenceCounted,
+                    FlagReferenceCounted | FlagCanDebug | FlagLinearMapped,
+    CodeOut = static_cast<u32>(Svc::MemoryState::CodeOut) | FlagMapped | FlagReferenceCounted |
+              FlagLinearMapped,
 
     Coverage = static_cast<u32>(Svc::MemoryState::Coverage) | FlagMapped,
+
+    Insecure = static_cast<u32>(Svc::MemoryState::Insecure) | FlagMapped | FlagReferenceCounted |
+               FlagLinearMapped | FlagCanChangeAttribute | FlagCanDeviceMap |
+               FlagCanAlignedDeviceMap | FlagCanUseNonSecureIpc | FlagCanUseNonDeviceIpc,
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryState);
 
 static_assert(static_cast<u32>(KMemoryState::Free) == 0x00000000);
-static_assert(static_cast<u32>(KMemoryState::Io) == 0x00002001);
+static_assert(static_cast<u32>(KMemoryState::Io) == 0x00182001);
 static_assert(static_cast<u32>(KMemoryState::Static) == 0x00042002);
-static_assert(static_cast<u32>(KMemoryState::Code) == 0x00DC7E03);
-static_assert(static_cast<u32>(KMemoryState::CodeData) == 0x03FEBD04);
-static_assert(static_cast<u32>(KMemoryState::Normal) == 0x037EBD05);
-static_assert(static_cast<u32>(KMemoryState::Shared) == 0x00402006);
-static_assert(static_cast<u32>(KMemoryState::AliasCode) == 0x00DD7E08);
-static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x03FFBD09);
-static_assert(static_cast<u32>(KMemoryState::Ipc) == 0x005C3C0A);
-static_assert(static_cast<u32>(KMemoryState::Stack) == 0x005C3C0B);
-static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0040200C);
-static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x015C3C0D);
-static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x005C380E);
-static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0040380F);
+static_assert(static_cast<u32>(KMemoryState::Code) == 0x04DC7E03);
+static_assert(static_cast<u32>(KMemoryState::CodeData) == 0x07FEBD04);
+static_assert(static_cast<u32>(KMemoryState::Normal) == 0x077EBD05);
+static_assert(static_cast<u32>(KMemoryState::Shared) == 0x04402006);
+
+static_assert(static_cast<u32>(KMemoryState::AliasCode) == 0x04DD7E08);
+static_assert(static_cast<u32>(KMemoryState::AliasCodeData) == 0x07FFBD09);
+static_assert(static_cast<u32>(KMemoryState::Ipc) == 0x045C3C0A);
+static_assert(static_cast<u32>(KMemoryState::Stack) == 0x045C3C0B);
+static_assert(static_cast<u32>(KMemoryState::ThreadLocal) == 0x0400200C);
+static_assert(static_cast<u32>(KMemoryState::Transfered) == 0x055C3C0D);
+static_assert(static_cast<u32>(KMemoryState::SharedTransfered) == 0x045C380E);
+static_assert(static_cast<u32>(KMemoryState::SharedCode) == 0x0440380F);
 static_assert(static_cast<u32>(KMemoryState::Inaccessible) == 0x00000010);
-static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x005C3811);
-static_assert(static_cast<u32>(KMemoryState::NonDeviceIpc) == 0x004C2812);
+static_assert(static_cast<u32>(KMemoryState::NonSecureIpc) == 0x045C3811);
+static_assert(static_cast<u32>(KMemoryState::NonDeviceIpc) == 0x044C2812);
 static_assert(static_cast<u32>(KMemoryState::Kernel) == 0x00002013);
-static_assert(static_cast<u32>(KMemoryState::GeneratedCode) == 0x00402214);
-static_assert(static_cast<u32>(KMemoryState::CodeOut) == 0x00402015);
+static_assert(static_cast<u32>(KMemoryState::GeneratedCode) == 0x04402214);
+static_assert(static_cast<u32>(KMemoryState::CodeOut) == 0x04402015);
 static_assert(static_cast<u32>(KMemoryState::Coverage) == 0x00002016);
+static_assert(static_cast<u32>(KMemoryState::Insecure) == 0x05583817);
 
 enum class KMemoryPermission : u8 {
     None = 0,
     All = static_cast<u8>(~None),
 
-    Read = 1 << 0,
-    Write = 1 << 1,
-    Execute = 1 << 2,
-
-    ReadAndWrite = Read | Write,
-    ReadAndExecute = Read | Execute,
-
-    UserMask = static_cast<u8>(Svc::MemoryPermission::Read | Svc::MemoryPermission::Write |
-                               Svc::MemoryPermission::Execute),
-
     KernelShift = 3,
 
-    KernelRead = Read << KernelShift,
-    KernelWrite = Write << KernelShift,
-    KernelExecute = Execute << KernelShift,
+    KernelRead = static_cast<u8>(Svc::MemoryPermission::Read) << KernelShift,
+    KernelWrite = static_cast<u8>(Svc::MemoryPermission::Write) << KernelShift,
+    KernelExecute = static_cast<u8>(Svc::MemoryPermission::Execute) << KernelShift,
 
     NotMapped = (1 << (2 * KernelShift)),
 
     KernelReadWrite = KernelRead | KernelWrite,
     KernelReadExecute = KernelRead | KernelExecute,
 
-    UserRead = Read | KernelRead,
-    UserWrite = Write | KernelWrite,
-    UserExecute = Execute,
+    UserRead = static_cast<u8>(Svc::MemoryPermission::Read) | KernelRead,
+    UserWrite = static_cast<u8>(Svc::MemoryPermission::Write) | KernelWrite,
+    UserExecute = static_cast<u8>(Svc::MemoryPermission::Execute),
 
     UserReadWrite = UserRead | UserWrite,
     UserReadExecute = UserRead | UserExecute,
 
-    IpcLockChangeMask = NotMapped | UserReadWrite
+    UserMask = static_cast<u8>(Svc::MemoryPermission::Read | Svc::MemoryPermission::Write |
+                               Svc::MemoryPermission::Execute),
+
+    IpcLockChangeMask = NotMapped | UserReadWrite,
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryPermission);
 
@@ -210,13 +216,15 @@ struct KMemoryInfo {
 
     constexpr Svc::MemoryInfo GetSvcMemoryInfo() const {
         return {
-            .addr = m_address,
+            .base_address = 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,
+            .attribute =
+                static_cast<Svc::MemoryAttribute>(m_attribute & KMemoryAttribute::UserMask),
+            .permission =
+                static_cast<Svc::MemoryPermission>(m_permission & KMemoryPermission::UserMask),
+            .ipc_count = m_ipc_lock_count,
+            .device_count = m_device_use_count,
             .padding = {},
         };
     }
@@ -468,6 +476,7 @@ public:
 
     constexpr void UpdateDeviceDisableMergeStateForShareLeft(
         [[maybe_unused]] KMemoryPermission new_perm, bool left, [[maybe_unused]] bool right) {
+        // New permission/right aren't used.
         if (left) {
             m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
                 m_disable_merge_attribute | KMemoryBlockDisableMergeAttribute::DeviceLeft);
@@ -478,6 +487,7 @@ public:
 
     constexpr void UpdateDeviceDisableMergeStateForShareRight(
         [[maybe_unused]] KMemoryPermission new_perm, [[maybe_unused]] bool left, bool right) {
+        // New permission/left aren't used.
         if (right) {
             m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(
                 m_disable_merge_attribute | KMemoryBlockDisableMergeAttribute::DeviceRight);
@@ -494,6 +504,8 @@ public:
 
     constexpr void ShareToDevice([[maybe_unused]] KMemoryPermission new_perm, bool left,
                                  bool right) {
+        // New permission isn't used.
+
         // We must either be shared or have a zero lock count.
         ASSERT((m_attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared ||
                m_device_use_count == 0);
@@ -509,6 +521,7 @@ public:
 
     constexpr void UpdateDeviceDisableMergeStateForUnshareLeft(
         [[maybe_unused]] KMemoryPermission new_perm, bool left, [[maybe_unused]] bool right) {
+        // New permission/right aren't used.
 
         if (left) {
             if (!m_device_disable_merge_left_count) {
@@ -528,6 +541,8 @@ public:
 
     constexpr void UpdateDeviceDisableMergeStateForUnshareRight(
         [[maybe_unused]] KMemoryPermission new_perm, [[maybe_unused]] bool left, bool right) {
+        // New permission/left aren't used.
+
         if (right) {
             const u16 old_device_disable_merge_right_count = m_device_disable_merge_right_count--;
             ASSERT(old_device_disable_merge_right_count > 0);
@@ -546,6 +561,8 @@ public:
 
     constexpr void UnshareToDevice([[maybe_unused]] KMemoryPermission new_perm, bool left,
                                    bool right) {
+        // New permission isn't used.
+
         // We must be shared.
         ASSERT((m_attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared);
 
@@ -563,6 +580,7 @@ public:
 
     constexpr void UnshareToDeviceRight([[maybe_unused]] KMemoryPermission new_perm, bool left,
                                         bool right) {
+        // New permission isn't used.
 
         // We must be shared.
         ASSERT((m_attribute & KMemoryAttribute::DeviceShared) == KMemoryAttribute::DeviceShared);
@@ -613,6 +631,8 @@ public:
 
     constexpr void UnlockForIpc([[maybe_unused]] KMemoryPermission new_perm, bool left,
                                 [[maybe_unused]] bool right) {
+        // New permission isn't used.
+
         // We must be locked.
         ASSERT((m_attribute & KMemoryAttribute::IpcLocked) == KMemoryAttribute::IpcLocked);
 

src/core/hle/kernel/k_memory_layout.cpp

@@ -153,13 +153,9 @@ void KMemoryLayout::InitializeLinearMemoryRegionTrees(PAddr aligned_linear_phys_
     }
 }
 
-size_t KMemoryLayout::GetResourceRegionSizeForInit() {
-    // Calculate resource region size based on whether we allow extra threads.
-    const bool use_extra_resources = KSystemControl::Init::ShouldIncreaseThreadResourceLimit();
-    size_t resource_region_size =
-        KernelResourceSize + (use_extra_resources ? KernelSlabHeapAdditionalSize : 0);
-
-    return resource_region_size;
+size_t KMemoryLayout::GetResourceRegionSizeForInit(bool use_extra_resource) {
+    return KernelResourceSize + KSystemControl::SecureAppletMemorySize +
+           (use_extra_resource ? KernelSlabHeapAdditionalSize + KernelPageBufferAdditionalSize : 0);
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_memory_layout.h

@@ -60,10 +60,12 @@ constexpr std::size_t KernelSlabHeapGapsSizeMax = 2_MiB - 64_KiB;
 constexpr std::size_t KernelSlabHeapSize = KernelSlabHeapDataSize + KernelSlabHeapGapsSizeMax;
 
 // NOTE: This is calculated from KThread slab counts, assuming KThread size <= 0x860.
-constexpr std::size_t KernelSlabHeapAdditionalSize = 0x68000;
+constexpr size_t KernelPageBufferHeapSize = 0x3E0000;
+constexpr size_t KernelSlabHeapAdditionalSize = 0x148000;
+constexpr size_t KernelPageBufferAdditionalSize = 0x33C000;
 
-constexpr std::size_t KernelResourceSize =
-    KernelPageTableHeapSize + KernelInitialPageHeapSize + KernelSlabHeapSize;
+constexpr std::size_t KernelResourceSize = KernelPageTableHeapSize + KernelInitialPageHeapSize +
+                                           KernelSlabHeapSize + KernelPageBufferHeapSize;
 
 constexpr bool IsKernelAddressKey(VAddr key) {
     return KernelVirtualAddressSpaceBase <= key && key <= KernelVirtualAddressSpaceLast;
@@ -168,6 +170,11 @@ public:
             KMemoryRegionType_VirtualDramKernelTraceBuffer));
     }
 
+    const KMemoryRegion& GetSecureAppletMemoryRegion() {
+        return Dereference(GetVirtualMemoryRegionTree().FindByType(
+            KMemoryRegionType_VirtualDramKernelSecureAppletMemory));
+    }
+
     const KMemoryRegion& GetVirtualLinearRegion(VAddr address) const {
         return Dereference(FindVirtualLinear(address));
     }
@@ -229,7 +236,7 @@ public:
 
     void InitializeLinearMemoryRegionTrees(PAddr aligned_linear_phys_start,
                                            VAddr linear_virtual_start);
-    static size_t GetResourceRegionSizeForInit();
+    static size_t GetResourceRegionSizeForInit(bool use_extra_resource);
 
     auto GetKernelRegionExtents() const {
         return GetVirtualMemoryRegionTree().GetDerivedRegionExtents(KMemoryRegionType_Kernel);
@@ -279,6 +286,10 @@ public:
         return GetPhysicalMemoryRegionTree().GetDerivedRegionExtents(
             KMemoryRegionType_DramKernelSlab);
     }
+    auto GetKernelSecureAppletMemoryRegionPhysicalExtents() {
+        return GetPhysicalMemoryRegionTree().GetDerivedRegionExtents(
+            KMemoryRegionType_DramKernelSecureAppletMemory);
+    }
     auto GetKernelPageTableHeapRegionPhysicalExtents() const {
         return GetPhysicalMemoryRegionTree().GetDerivedRegionExtents(
             KMemoryRegionType_DramKernelPtHeap);

src/core/hle/kernel/k_memory_manager.cpp

@@ -29,43 +29,44 @@ constexpr KMemoryManager::Pool GetPoolFromMemoryRegionType(u32 type) {
     } else if ((type | KMemoryRegionType_DramSystemNonSecurePool) == type) {
         return KMemoryManager::Pool::SystemNonSecure;
     } else {
-        ASSERT_MSG(false, "InvalidMemoryRegionType for conversion to Pool");
-        return {};
+        UNREACHABLE_MSG("InvalidMemoryRegionType for conversion to Pool");
     }
 }
 
 } // namespace
 
-KMemoryManager::KMemoryManager(Core::System& system_)
-    : system{system_}, pool_locks{
-                           KLightLock{system_.Kernel()},
-                           KLightLock{system_.Kernel()},
-                           KLightLock{system_.Kernel()},
-                           KLightLock{system_.Kernel()},
-                       } {}
+KMemoryManager::KMemoryManager(Core::System& system)
+    : m_system{system}, m_memory_layout{system.Kernel().MemoryLayout()},
+      m_pool_locks{
+          KLightLock{system.Kernel()},
+          KLightLock{system.Kernel()},
+          KLightLock{system.Kernel()},
+          KLightLock{system.Kernel()},
+      } {}
 
 void KMemoryManager::Initialize(VAddr management_region, size_t management_region_size) {
 
     // Clear the management region to zero.
     const VAddr management_region_end = management_region + management_region_size;
+    // std::memset(GetVoidPointer(management_region), 0, management_region_size);
 
     // Reset our manager count.
-    num_managers = 0;
+    m_num_managers = 0;
 
     // Traverse the virtual memory layout tree, initializing each manager as appropriate.
-    while (num_managers != MaxManagerCount) {
+    while (m_num_managers != MaxManagerCount) {
         // Locate the region that should initialize the current manager.
         PAddr region_address = 0;
         size_t region_size = 0;
         Pool region_pool = Pool::Count;
-        for (const auto& it : system.Kernel().MemoryLayout().GetPhysicalMemoryRegionTree()) {
+        for (const auto& it : m_system.Kernel().MemoryLayout().GetPhysicalMemoryRegionTree()) {
             // We only care about regions that we need to create managers for.
             if (!it.IsDerivedFrom(KMemoryRegionType_DramUserPool)) {
                 continue;
             }
 
             // We want to initialize the managers in order.
-            if (it.GetAttributes() != num_managers) {
+            if (it.GetAttributes() != m_num_managers) {
                 continue;
             }
 
@@ -97,8 +98,8 @@ void KMemoryManager::Initialize(VAddr management_region, size_t management_regio
         }
 
         // Initialize a new manager for the region.
-        Impl* manager = std::addressof(managers[num_managers++]);
-        ASSERT(num_managers <= managers.size());
+        Impl* manager = std::addressof(m_managers[m_num_managers++]);
+        ASSERT(m_num_managers <= m_managers.size());
 
         const size_t cur_size = manager->Initialize(region_address, region_size, management_region,
                                                     management_region_end, region_pool);
@@ -107,13 +108,13 @@ void KMemoryManager::Initialize(VAddr management_region, size_t management_regio
 
         // Insert the manager into the pool list.
         const auto region_pool_index = static_cast<u32>(region_pool);
-        if (pool_managers_tail[region_pool_index] == nullptr) {
-            pool_managers_head[region_pool_index] = manager;
+        if (m_pool_managers_tail[region_pool_index] == nullptr) {
+            m_pool_managers_head[region_pool_index] = manager;
         } else {
-            pool_managers_tail[region_pool_index]->SetNext(manager);
-            manager->SetPrev(pool_managers_tail[region_pool_index]);
+            m_pool_managers_tail[region_pool_index]->SetNext(manager);
+            manager->SetPrev(m_pool_managers_tail[region_pool_index]);
         }
-        pool_managers_tail[region_pool_index] = manager;
+        m_pool_managers_tail[region_pool_index] = manager;
     }
 
     // Free each region to its corresponding heap.
@@ -121,11 +122,10 @@ void KMemoryManager::Initialize(VAddr management_region, size_t management_regio
     const PAddr ini_start = GetInitialProcessBinaryPhysicalAddress();
     const PAddr ini_end = ini_start + InitialProcessBinarySizeMax;
     const PAddr ini_last = ini_end - 1;
-    for (const auto& it : system.Kernel().MemoryLayout().GetPhysicalMemoryRegionTree()) {
+    for (const auto& it : m_system.Kernel().MemoryLayout().GetPhysicalMemoryRegionTree()) {
         if (it.IsDerivedFrom(KMemoryRegionType_DramUserPool)) {
             // Get the manager for the region.
-            auto index = it.GetAttributes();
-            auto& manager = managers[index];
+            auto& manager = m_managers[it.GetAttributes()];
 
             const PAddr cur_start = it.GetAddress();
             const PAddr cur_last = it.GetLastAddress();
@@ -162,11 +162,19 @@ void KMemoryManager::Initialize(VAddr management_region, size_t management_regio
     }
 
     // Update the used size for all managers.
-    for (size_t i = 0; i < num_managers; ++i) {
-        managers[i].SetInitialUsedHeapSize(reserved_sizes[i]);
+    for (size_t i = 0; i < m_num_managers; ++i) {
+        m_managers[i].SetInitialUsedHeapSize(reserved_sizes[i]);
     }
 }
 
+Result KMemoryManager::InitializeOptimizedMemory(u64 process_id, Pool pool) {
+    UNREACHABLE();
+}
+
+void KMemoryManager::FinalizeOptimizedMemory(u64 process_id, Pool pool) {
+    UNREACHABLE();
+}
+
 PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option) {
     // Early return if we're allocating no pages.
     if (num_pages == 0) {
@@ -175,7 +183,7 @@ PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_p
 
     // Lock the pool that we're allocating from.
     const auto [pool, dir] = DecodeOption(option);
-    KScopedLightLock lk(pool_locks[static_cast<std::size_t>(pool)]);
+    KScopedLightLock lk(m_pool_locks[static_cast<std::size_t>(pool)]);
 
     // Choose a heap based on our page size request.
     const s32 heap_index = KPageHeap::GetAlignedBlockIndex(num_pages, align_pages);
@@ -185,7 +193,7 @@ PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_p
     PAddr allocated_block = 0;
     for (chosen_manager = this->GetFirstManager(pool, dir); chosen_manager != nullptr;
          chosen_manager = this->GetNextManager(chosen_manager, dir)) {
-        allocated_block = chosen_manager->AllocateBlock(heap_index, true);
+        allocated_block = chosen_manager->AllocateAligned(heap_index, num_pages, align_pages);
         if (allocated_block != 0) {
             break;
         }
@@ -196,10 +204,9 @@ PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_p
         return 0;
     }
 
-    // If we allocated more than we need, free some.
-    const size_t allocated_pages = KPageHeap::GetBlockNumPages(heap_index);
-    if (allocated_pages > num_pages) {
-        chosen_manager->Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages);
+    // Maintain the optimized memory bitmap, if we should.
+    if (m_has_optimized_process[static_cast<size_t>(pool)]) {
+        UNIMPLEMENTED();
     }
 
     // Open the first reference to the pages.
@@ -209,20 +216,21 @@ PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_p
 }
 
 Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages, Pool pool,
-                                             Direction dir, bool random) {
+                                             Direction dir, bool unoptimized, bool random) {
     // Choose a heap based on our page size request.
     const s32 heap_index = KPageHeap::GetBlockIndex(num_pages);
     R_UNLESS(0 <= heap_index, ResultOutOfMemory);
 
     // Ensure that we don't leave anything un-freed.
-    auto group_guard = SCOPE_GUARD({
+    ON_RESULT_FAILURE {
         for (const auto& it : out->Nodes()) {
-            auto& manager = this->GetManager(system.Kernel().MemoryLayout(), it.GetAddress());
-            const size_t num_pages_to_free =
+            auto& manager = this->GetManager(it.GetAddress());
+            const size_t node_num_pages =
                 std::min(it.GetNumPages(), (manager.GetEndAddress() - it.GetAddress()) / PageSize);
-            manager.Free(it.GetAddress(), num_pages_to_free);
+            manager.Free(it.GetAddress(), node_num_pages);
         }
-    });
+        out->Finalize();
+    };
 
     // Keep allocating until we've allocated all our pages.
     for (s32 index = heap_index; index >= 0 && num_pages > 0; index--) {
@@ -236,12 +244,17 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages,
                     break;
                 }
 
-                // Safely add it to our group.
-                {
-                    auto block_guard =
-                        SCOPE_GUARD({ cur_manager->Free(allocated_block, pages_per_alloc); });
-                    R_TRY(out->AddBlock(allocated_block, pages_per_alloc));
-                    block_guard.Cancel();
+                // Ensure we don't leak the block if we fail.
+                ON_RESULT_FAILURE_2 {
+                    cur_manager->Free(allocated_block, pages_per_alloc);
+                };
+
+                // Add the block to our group.
+                R_TRY(out->AddBlock(allocated_block, pages_per_alloc));
+
+                // Maintain the optimized memory bitmap, if we should.
+                if (unoptimized) {
+                    UNIMPLEMENTED();
                 }
 
                 num_pages -= pages_per_alloc;
@@ -253,8 +266,7 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages,
     R_UNLESS(num_pages == 0, ResultOutOfMemory);
 
     // We succeeded!
-    group_guard.Cancel();
-    return ResultSuccess;
+    R_SUCCEED();
 }
 
 Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option) {
@@ -266,10 +278,11 @@ Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 op
 
     // Lock the pool that we're allocating from.
     const auto [pool, dir] = DecodeOption(option);
-    KScopedLightLock lk(pool_locks[static_cast<size_t>(pool)]);
+    KScopedLightLock lk(m_pool_locks[static_cast<size_t>(pool)]);
 
     // Allocate the page group.
-    R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, false));
+    R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir,
+                                      m_has_optimized_process[static_cast<size_t>(pool)], true));
 
     // Open the first reference to the pages.
     for (const auto& block : out->Nodes()) {
@@ -277,7 +290,7 @@ Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 op
         size_t remaining_pages = block.GetNumPages();
         while (remaining_pages > 0) {
             // Get the manager for the current address.
-            auto& manager = this->GetManager(system.Kernel().MemoryLayout(), cur_address);
+            auto& manager = this->GetManager(cur_address);
 
             // Process part or all of the block.
             const size_t cur_pages =
@@ -290,11 +303,11 @@ Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 op
         }
     }
 
-    return ResultSuccess;
+    R_SUCCEED();
 }
 
-Result KMemoryManager::AllocateAndOpenForProcess(KPageGroup* out, size_t num_pages, u32 option,
-                                                 u64 process_id, u8 fill_pattern) {
+Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32 option,
+                                          u64 process_id, u8 fill_pattern) {
     ASSERT(out != nullptr);
     ASSERT(out->GetNumPages() == 0);
 
@@ -302,83 +315,89 @@ Result KMemoryManager::AllocateAndOpenForProcess(KPageGroup* out, size_t num_pag
     const auto [pool, dir] = DecodeOption(option);
 
     // Allocate the memory.
+    bool optimized;
     {
         // Lock the pool that we're allocating from.
-        KScopedLightLock lk(pool_locks[static_cast<size_t>(pool)]);
+        KScopedLightLock lk(m_pool_locks[static_cast<size_t>(pool)]);
+
+        // Check if we have an optimized process.
+        const bool has_optimized = m_has_optimized_process[static_cast<size_t>(pool)];
+        const bool is_optimized = m_optimized_process_ids[static_cast<size_t>(pool)] == process_id;
 
         // Allocate the page group.
-        R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, false));
+        R_TRY(this->AllocatePageGroupImpl(out, num_pages, pool, dir, has_optimized && !is_optimized,
+                                          false));
 
-        // Open the first reference to the pages.
+        // Set whether we should optimize.
+        optimized = has_optimized && is_optimized;
+    }
+
+    // Perform optimized memory tracking, if we should.
+    if (optimized) {
+        // Iterate over the allocated blocks.
         for (const auto& block : out->Nodes()) {
-            PAddr cur_address = block.GetAddress();
-            size_t remaining_pages = block.GetNumPages();
-            while (remaining_pages > 0) {
-                // Get the manager for the current address.
-                auto& manager = this->GetManager(system.Kernel().MemoryLayout(), cur_address);
+            // Get the block extents.
+            const PAddr block_address = block.GetAddress();
+            const size_t block_pages = block.GetNumPages();
 
-                // Process part or all of the block.
-                const size_t cur_pages =
-                    std::min(remaining_pages, manager.GetPageOffsetToEnd(cur_address));
-                manager.OpenFirst(cur_address, cur_pages);
+            // If it has no pages, we don't need to do anything.
+            if (block_pages == 0) {
+                continue;
+            }
 
-                // Advance.
-                cur_address += cur_pages * PageSize;
-                remaining_pages -= cur_pages;
+            // Fill all the pages that we need to fill.
+            bool any_new = false;
+            {
+                PAddr cur_address = block_address;
+                size_t remaining_pages = block_pages;
+                while (remaining_pages > 0) {
+                    // Get the manager for the current address.
+                    auto& manager = this->GetManager(cur_address);
+
+                    // Process part or all of the block.
+                    const size_t cur_pages =
+                        std::min(remaining_pages, manager.GetPageOffsetToEnd(cur_address));
+                    any_new =
+                        manager.ProcessOptimizedAllocation(cur_address, cur_pages, fill_pattern);
+
+                    // Advance.
+                    cur_address += cur_pages * PageSize;
+                    remaining_pages -= cur_pages;
+                }
+            }
+
+            // If there are new pages, update tracking for the allocation.
+            if (any_new) {
+                // Update tracking for the allocation.
+                PAddr cur_address = block_address;
+                size_t remaining_pages = block_pages;
+                while (remaining_pages > 0) {
+                    // Get the manager for the current address.
+                    auto& manager = this->GetManager(cur_address);
+
+                    // Lock the pool for the manager.
+                    KScopedLightLock lk(m_pool_locks[static_cast<size_t>(manager.GetPool())]);
+
+                    // Track some or all of the current pages.
+                    const size_t cur_pages =
+                        std::min(remaining_pages, manager.GetPageOffsetToEnd(cur_address));
+                    manager.TrackOptimizedAllocation(cur_address, cur_pages);
+
+                    // Advance.
+                    cur_address += cur_pages * PageSize;
+                    remaining_pages -= cur_pages;
+                }
             }
         }
-    }
-
-    // Set all the allocated memory.
-    for (const auto& block : out->Nodes()) {
-        std::memset(system.DeviceMemory().GetPointer<void>(block.GetAddress()), fill_pattern,
-                    block.GetSize());
-    }
-
-    return ResultSuccess;
-}
-
-void KMemoryManager::Open(PAddr address, size_t num_pages) {
-    // Repeatedly open references until we've done so for all pages.
-    while (num_pages) {
-        auto& manager = this->GetManager(system.Kernel().MemoryLayout(), address);
-        const size_t cur_pages = std::min(num_pages, manager.GetPageOffsetToEnd(address));
-
-        {
-            KScopedLightLock lk(pool_locks[static_cast<size_t>(manager.GetPool())]);
-            manager.Open(address, cur_pages);
+    } else {
+        // Set all the allocated memory.
+        for (const auto& block : out->Nodes()) {
+            std::memset(m_system.DeviceMemory().GetPointer<void>(block.GetAddress()), fill_pattern,
+                        block.GetSize());
         }
-
-        num_pages -= cur_pages;
-        address += cur_pages * PageSize;
     }
-}
 
-void KMemoryManager::Close(PAddr address, size_t num_pages) {
-    // Repeatedly close references until we've done so for all pages.
-    while (num_pages) {
-        auto& manager = this->GetManager(system.Kernel().MemoryLayout(), address);
-        const size_t cur_pages = std::min(num_pages, manager.GetPageOffsetToEnd(address));
-
-        {
-            KScopedLightLock lk(pool_locks[static_cast<size_t>(manager.GetPool())]);
-            manager.Close(address, cur_pages);
-        }
-
-        num_pages -= cur_pages;
-        address += cur_pages * PageSize;
-    }
-}
-
-void KMemoryManager::Close(const KPageGroup& pg) {
-    for (const auto& node : pg.Nodes()) {
-        Close(node.GetAddress(), node.GetNumPages());
-    }
-}
-void KMemoryManager::Open(const KPageGroup& pg) {
-    for (const auto& node : pg.Nodes()) {
-        Open(node.GetAddress(), node.GetNumPages());
-    }
+    R_SUCCEED();
 }
 
 size_t KMemoryManager::Impl::Initialize(PAddr address, size_t size, VAddr management,
@@ -394,18 +413,31 @@ size_t KMemoryManager::Impl::Initialize(PAddr address, size_t size, VAddr manage
     ASSERT(Common::IsAligned(total_management_size, PageSize));
 
     // Setup region.
-    pool = p;
-    management_region = management;
-    page_reference_counts.resize(
+    m_pool = p;
+    m_management_region = management;
+    m_page_reference_counts.resize(
         Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize() / PageSize);
-    ASSERT(Common::IsAligned(management_region, PageSize));
+    ASSERT(Common::IsAligned(m_management_region, PageSize));
 
     // Initialize the manager's KPageHeap.
-    heap.Initialize(address, size, management + manager_size, page_heap_size);
+    m_heap.Initialize(address, size, management + manager_size, page_heap_size);
 
     return total_management_size;
 }
 
+void KMemoryManager::Impl::TrackUnoptimizedAllocation(PAddr block, size_t num_pages) {
+    UNREACHABLE();
+}
+
+void KMemoryManager::Impl::TrackOptimizedAllocation(PAddr block, size_t num_pages) {
+    UNREACHABLE();
+}
+
+bool KMemoryManager::Impl::ProcessOptimizedAllocation(PAddr block, size_t num_pages,
+                                                      u8 fill_pattern) {
+    UNREACHABLE();
+}
+
 size_t KMemoryManager::Impl::CalculateManagementOverheadSize(size_t region_size) {
     const size_t ref_count_size = (region_size / PageSize) * sizeof(u16);
     const size_t optimize_map_size =

src/core/hle/kernel/k_memory_manager.h

@@ -21,11 +21,8 @@ namespace Kernel {
 
 class KPageGroup;
 
-class KMemoryManager final {
+class KMemoryManager {
 public:
-    YUZU_NON_COPYABLE(KMemoryManager);
-    YUZU_NON_MOVEABLE(KMemoryManager);
-
     enum class Pool : u32 {
         Application = 0,
         Applet = 1,
@@ -45,16 +42,85 @@ public:
     enum class Direction : u32 {
         FromFront = 0,
         FromBack = 1,
-
         Shift = 0,
         Mask = (0xF << Shift),
     };
 
-    explicit KMemoryManager(Core::System& system_);
+    static constexpr size_t MaxManagerCount = 10;
+
+    explicit KMemoryManager(Core::System& system);
 
     void Initialize(VAddr management_region, size_t management_region_size);
 
-    constexpr size_t GetSize(Pool pool) const {
+    Result InitializeOptimizedMemory(u64 process_id, Pool pool);
+    void FinalizeOptimizedMemory(u64 process_id, Pool pool);
+
+    PAddr AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option);
+    Result AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option);
+    Result AllocateForProcess(KPageGroup* out, size_t num_pages, u32 option, u64 process_id,
+                              u8 fill_pattern);
+
+    Pool GetPool(PAddr address) const {
+        return this->GetManager(address).GetPool();
+    }
+
+    void Open(PAddr address, size_t num_pages) {
+        // Repeatedly open references until we've done so for all pages.
+        while (num_pages) {
+            auto& manager = this->GetManager(address);
+            const size_t cur_pages = std::min(num_pages, manager.GetPageOffsetToEnd(address));
+
+            {
+                KScopedLightLock lk(m_pool_locks[static_cast<size_t>(manager.GetPool())]);
+                manager.Open(address, cur_pages);
+            }
+
+            num_pages -= cur_pages;
+            address += cur_pages * PageSize;
+        }
+    }
+
+    void OpenFirst(PAddr address, size_t num_pages) {
+        // Repeatedly open references until we've done so for all pages.
+        while (num_pages) {
+            auto& manager = this->GetManager(address);
+            const size_t cur_pages = std::min(num_pages, manager.GetPageOffsetToEnd(address));
+
+            {
+                KScopedLightLock lk(m_pool_locks[static_cast<size_t>(manager.GetPool())]);
+                manager.OpenFirst(address, cur_pages);
+            }
+
+            num_pages -= cur_pages;
+            address += cur_pages * PageSize;
+        }
+    }
+
+    void Close(PAddr address, size_t num_pages) {
+        // Repeatedly close references until we've done so for all pages.
+        while (num_pages) {
+            auto& manager = this->GetManager(address);
+            const size_t cur_pages = std::min(num_pages, manager.GetPageOffsetToEnd(address));
+
+            {
+                KScopedLightLock lk(m_pool_locks[static_cast<size_t>(manager.GetPool())]);
+                manager.Close(address, cur_pages);
+            }
+
+            num_pages -= cur_pages;
+            address += cur_pages * PageSize;
+        }
+    }
+
+    size_t GetSize() {
+        size_t total = 0;
+        for (size_t i = 0; i < m_num_managers; i++) {
+            total += m_managers[i].GetSize();
+        }
+        return total;
+    }
+
+    size_t GetSize(Pool pool) {
         constexpr Direction GetSizeDirection = Direction::FromFront;
         size_t total = 0;
         for (auto* manager = this->GetFirstManager(pool, GetSizeDirection); manager != nullptr;
@@ -64,18 +130,36 @@ public:
         return total;
     }
 
-    PAddr AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option);
-    Result AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option);
-    Result AllocateAndOpenForProcess(KPageGroup* out, size_t num_pages, u32 option, u64 process_id,
-                                     u8 fill_pattern);
+    size_t GetFreeSize() {
+        size_t total = 0;
+        for (size_t i = 0; i < m_num_managers; i++) {
+            KScopedLightLock lk(m_pool_locks[static_cast<size_t>(m_managers[i].GetPool())]);
+            total += m_managers[i].GetFreeSize();
+        }
+        return total;
+    }
 
-    static constexpr size_t MaxManagerCount = 10;
+    size_t GetFreeSize(Pool pool) {
+        KScopedLightLock lk(m_pool_locks[static_cast<size_t>(pool)]);
 
-    void Close(PAddr address, size_t num_pages);
-    void Close(const KPageGroup& pg);
+        constexpr Direction GetSizeDirection = Direction::FromFront;
+        size_t total = 0;
+        for (auto* manager = this->GetFirstManager(pool, GetSizeDirection); manager != nullptr;
+             manager = this->GetNextManager(manager, GetSizeDirection)) {
+            total += manager->GetFreeSize();
+        }
+        return total;
+    }
 
-    void Open(PAddr address, size_t num_pages);
-    void Open(const KPageGroup& pg);
+    void DumpFreeList(Pool pool) {
+        KScopedLightLock lk(m_pool_locks[static_cast<size_t>(pool)]);
+
+        constexpr Direction DumpDirection = Direction::FromFront;
+        for (auto* manager = this->GetFirstManager(pool, DumpDirection); manager != nullptr;
+             manager = this->GetNextManager(manager, DumpDirection)) {
+            manager->DumpFreeList();
+        }
+    }
 
 public:
     static size_t CalculateManagementOverheadSize(size_t region_size) {
@@ -88,14 +172,13 @@ public:
     }
 
     static constexpr Pool GetPool(u32 option) {
-        return static_cast<Pool>((static_cast<u32>(option) & static_cast<u32>(Pool::Mask)) >>
+        return static_cast<Pool>((option & static_cast<u32>(Pool::Mask)) >>
                                  static_cast<u32>(Pool::Shift));
     }
 
     static constexpr Direction GetDirection(u32 option) {
-        return static_cast<Direction>(
-            (static_cast<u32>(option) & static_cast<u32>(Direction::Mask)) >>
-            static_cast<u32>(Direction::Shift));
+        return static_cast<Direction>((option & static_cast<u32>(Direction::Mask)) >>
+                                      static_cast<u32>(Direction::Shift));
     }
 
     static constexpr std::tuple<Pool, Direction> DecodeOption(u32 option) {
@@ -103,74 +186,88 @@ public:
     }
 
 private:
-    class Impl final {
+    class Impl {
     public:
-        YUZU_NON_COPYABLE(Impl);
-        YUZU_NON_MOVEABLE(Impl);
+        static size_t CalculateManagementOverheadSize(size_t region_size);
 
+        static constexpr size_t CalculateOptimizedProcessOverheadSize(size_t region_size) {
+            return (Common::AlignUp((region_size / PageSize), Common::BitSize<u64>()) /
+                    Common::BitSize<u64>()) *
+                   sizeof(u64);
+        }
+
+    public:
         Impl() = default;
-        ~Impl() = default;
 
         size_t Initialize(PAddr address, size_t size, VAddr management, VAddr management_end,
                           Pool p);
 
-        VAddr AllocateBlock(s32 index, bool random) {
-            return heap.AllocateBlock(index, random);
+        PAddr AllocateBlock(s32 index, bool random) {
+            return m_heap.AllocateBlock(index, random);
         }
-
-        void Free(VAddr addr, size_t num_pages) {
-            heap.Free(addr, num_pages);
+        PAddr AllocateAligned(s32 index, size_t num_pages, size_t align_pages) {
+            return m_heap.AllocateAligned(index, num_pages, align_pages);
+        }
+        void Free(PAddr addr, size_t num_pages) {
+            m_heap.Free(addr, num_pages);
         }
 
         void SetInitialUsedHeapSize(size_t reserved_size) {
-            heap.SetInitialUsedSize(reserved_size);
+            m_heap.SetInitialUsedSize(reserved_size);
         }
 
+        void InitializeOptimizedMemory() {
+            UNIMPLEMENTED();
+        }
+
+        void TrackUnoptimizedAllocation(PAddr block, size_t num_pages);
+        void TrackOptimizedAllocation(PAddr block, size_t num_pages);
+
+        bool ProcessOptimizedAllocation(PAddr block, size_t num_pages, u8 fill_pattern);
+
         constexpr Pool GetPool() const {
-            return pool;
+            return m_pool;
         }
-
         constexpr size_t GetSize() const {
-            return heap.GetSize();
+            return m_heap.GetSize();
+        }
+        constexpr PAddr GetEndAddress() const {
+            return m_heap.GetEndAddress();
         }
 
-        constexpr VAddr GetAddress() const {
-            return heap.GetAddress();
+        size_t GetFreeSize() const {
+            return m_heap.GetFreeSize();
         }
 
-        constexpr VAddr GetEndAddress() const {
-            return heap.GetEndAddress();
+        void DumpFreeList() const {
+            UNIMPLEMENTED();
         }
 
         constexpr size_t GetPageOffset(PAddr address) const {
-            return heap.GetPageOffset(address);
+            return m_heap.GetPageOffset(address);
         }
-
         constexpr size_t GetPageOffsetToEnd(PAddr address) const {
-            return heap.GetPageOffsetToEnd(address);
+            return m_heap.GetPageOffsetToEnd(address);
         }
 
         constexpr void SetNext(Impl* n) {
-            next = n;
+            m_next = n;
         }
-
         constexpr void SetPrev(Impl* n) {
-            prev = n;
+            m_prev = n;
         }
-
         constexpr Impl* GetNext() const {
-            return next;
+            return m_next;
         }
-
         constexpr Impl* GetPrev() const {
-            return prev;
+            return m_prev;
         }
 
         void OpenFirst(PAddr address, size_t num_pages) {
             size_t index = this->GetPageOffset(address);
             const size_t end = index + num_pages;
             while (index < end) {
-                const RefCount ref_count = (++page_reference_counts[index]);
+                const RefCount ref_count = (++m_page_reference_counts[index]);
                 ASSERT(ref_count == 1);
 
                 index++;
@@ -181,7 +278,7 @@ private:
             size_t index = this->GetPageOffset(address);
             const size_t end = index + num_pages;
             while (index < end) {
-                const RefCount ref_count = (++page_reference_counts[index]);
+                const RefCount ref_count = (++m_page_reference_counts[index]);
                 ASSERT(ref_count > 1);
 
                 index++;
@@ -195,8 +292,8 @@ private:
             size_t free_start = 0;
             size_t free_count = 0;
             while (index < end) {
-                ASSERT(page_reference_counts[index] > 0);
-                const RefCount ref_count = (--page_reference_counts[index]);
+                ASSERT(m_page_reference_counts[index] > 0);
+                const RefCount ref_count = (--m_page_reference_counts[index]);
 
                 // Keep track of how many zero refcounts we see in a row, to minimize calls to free.
                 if (ref_count == 0) {
@@ -208,7 +305,7 @@ private:
                     }
                 } else {
                     if (free_count > 0) {
-                        this->Free(heap.GetAddress() + free_start * PageSize, free_count);
+                        this->Free(m_heap.GetAddress() + free_start * PageSize, free_count);
                         free_count = 0;
                     }
                 }
@@ -217,44 +314,36 @@ private:
             }
 
             if (free_count > 0) {
-                this->Free(heap.GetAddress() + free_start * PageSize, free_count);
+                this->Free(m_heap.GetAddress() + free_start * PageSize, free_count);
             }
         }
 
-        static size_t CalculateManagementOverheadSize(size_t region_size);
-
-        static constexpr size_t CalculateOptimizedProcessOverheadSize(size_t region_size) {
-            return (Common::AlignUp((region_size / PageSize), Common::BitSize<u64>()) /
-                    Common::BitSize<u64>()) *
-                   sizeof(u64);
-        }
-
     private:
         using RefCount = u16;
 
-        KPageHeap heap;
-        std::vector<RefCount> page_reference_counts;
-        VAddr management_region{};
-        Pool pool{};
-        Impl* next{};
-        Impl* prev{};
+        KPageHeap m_heap;
+        std::vector<RefCount> m_page_reference_counts;
+        VAddr m_management_region{};
+        Pool m_pool{};
+        Impl* m_next{};
+        Impl* m_prev{};
     };
 
 private:
-    Impl& GetManager(const KMemoryLayout& memory_layout, PAddr address) {
-        return managers[memory_layout.GetPhysicalLinearRegion(address).GetAttributes()];
+    Impl& GetManager(PAddr address) {
+        return m_managers[m_memory_layout.GetPhysicalLinearRegion(address).GetAttributes()];
     }
 
-    const Impl& GetManager(const KMemoryLayout& memory_layout, PAddr address) const {
-        return managers[memory_layout.GetPhysicalLinearRegion(address).GetAttributes()];
+    const Impl& GetManager(PAddr address) const {
+        return m_managers[m_memory_layout.GetPhysicalLinearRegion(address).GetAttributes()];
     }
 
-    constexpr Impl* GetFirstManager(Pool pool, Direction dir) const {
-        return dir == Direction::FromBack ? pool_managers_tail[static_cast<size_t>(pool)]
-                                          : pool_managers_head[static_cast<size_t>(pool)];
+    constexpr Impl* GetFirstManager(Pool pool, Direction dir) {
+        return dir == Direction::FromBack ? m_pool_managers_tail[static_cast<size_t>(pool)]
+                                          : m_pool_managers_head[static_cast<size_t>(pool)];
     }
 
-    constexpr Impl* GetNextManager(Impl* cur, Direction dir) const {
+    constexpr Impl* GetNextManager(Impl* cur, Direction dir) {
         if (dir == Direction::FromBack) {
             return cur->GetPrev();
         } else {
@@ -263,15 +352,21 @@ private:
     }
 
     Result AllocatePageGroupImpl(KPageGroup* out, size_t num_pages, Pool pool, Direction dir,
-                                 bool random);
+                                 bool unoptimized, bool random);
 
 private:
-    Core::System& system;
-    std::array<KLightLock, static_cast<size_t>(Pool::Count)> pool_locks;
-    std::array<Impl*, MaxManagerCount> pool_managers_head{};
-    std::array<Impl*, MaxManagerCount> pool_managers_tail{};
-    std::array<Impl, MaxManagerCount> managers;
-    size_t num_managers{};
+    template <typename T>
+    using PoolArray = std::array<T, static_cast<size_t>(Pool::Count)>;
+
+    Core::System& m_system;
+    const KMemoryLayout& m_memory_layout;
+    PoolArray<KLightLock> m_pool_locks;
+    std::array<Impl*, MaxManagerCount> m_pool_managers_head{};
+    std::array<Impl*, MaxManagerCount> m_pool_managers_tail{};
+    std::array<Impl, MaxManagerCount> m_managers;
+    size_t m_num_managers{};
+    PoolArray<u64> m_optimized_process_ids{};
+    PoolArray<bool> m_has_optimized_process{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_memory_region_type.h

@@ -142,32 +142,38 @@ private:
 
 } // namespace impl
 
-constexpr auto KMemoryRegionType_None = impl::KMemoryRegionTypeValue();
-constexpr auto KMemoryRegionType_Kernel = KMemoryRegionType_None.DeriveInitial(0, 2);
-constexpr auto KMemoryRegionType_Dram = KMemoryRegionType_None.DeriveInitial(1, 2);
+constexpr inline auto KMemoryRegionType_None = impl::KMemoryRegionTypeValue();
+
+constexpr inline auto KMemoryRegionType_Kernel = KMemoryRegionType_None.DeriveInitial(0, 2);
+constexpr inline auto KMemoryRegionType_Dram = KMemoryRegionType_None.DeriveInitial(1, 2);
 static_assert(KMemoryRegionType_Kernel.GetValue() == 0x1);
 static_assert(KMemoryRegionType_Dram.GetValue() == 0x2);
 
-constexpr auto KMemoryRegionType_DramKernelBase =
+// constexpr inline auto KMemoryRegionType_CoreLocalRegion =
+// KMemoryRegionType_None.DeriveInitial(2).Finalize();
+// static_assert(KMemoryRegionType_CoreLocalRegion.GetValue() == 0x4);
+
+constexpr inline auto KMemoryRegionType_DramKernelBase =
     KMemoryRegionType_Dram.DeriveSparse(0, 3, 0)
         .SetAttribute(KMemoryRegionAttr_NoUserMap)
         .SetAttribute(KMemoryRegionAttr_CarveoutProtected);
-constexpr auto KMemoryRegionType_DramReservedBase = KMemoryRegionType_Dram.DeriveSparse(0, 3, 1);
-constexpr auto KMemoryRegionType_DramHeapBase =
+constexpr inline auto KMemoryRegionType_DramReservedBase =
+    KMemoryRegionType_Dram.DeriveSparse(0, 3, 1);
+constexpr inline auto KMemoryRegionType_DramHeapBase =
     KMemoryRegionType_Dram.DeriveSparse(0, 3, 2).SetAttribute(KMemoryRegionAttr_LinearMapped);
 static_assert(KMemoryRegionType_DramKernelBase.GetValue() ==
               (0xE | KMemoryRegionAttr_CarveoutProtected | KMemoryRegionAttr_NoUserMap));
 static_assert(KMemoryRegionType_DramReservedBase.GetValue() == (0x16));
 static_assert(KMemoryRegionType_DramHeapBase.GetValue() == (0x26 | KMemoryRegionAttr_LinearMapped));
 
-constexpr auto KMemoryRegionType_DramKernelCode =
+constexpr inline auto KMemoryRegionType_DramKernelCode =
     KMemoryRegionType_DramKernelBase.DeriveSparse(0, 4, 0);
-constexpr auto KMemoryRegionType_DramKernelSlab =
+constexpr inline auto KMemoryRegionType_DramKernelSlab =
     KMemoryRegionType_DramKernelBase.DeriveSparse(0, 4, 1);
-constexpr auto KMemoryRegionType_DramKernelPtHeap =
+constexpr inline auto KMemoryRegionType_DramKernelPtHeap =
     KMemoryRegionType_DramKernelBase.DeriveSparse(0, 4, 2).SetAttribute(
         KMemoryRegionAttr_LinearMapped);
-constexpr auto KMemoryRegionType_DramKernelInitPt =
+constexpr inline auto KMemoryRegionType_DramKernelInitPt =
     KMemoryRegionType_DramKernelBase.DeriveSparse(0, 4, 3).SetAttribute(
         KMemoryRegionAttr_LinearMapped);
 static_assert(KMemoryRegionType_DramKernelCode.GetValue() ==
@@ -181,32 +187,40 @@ static_assert(KMemoryRegionType_DramKernelInitPt.GetValue() ==
               (0x44E | KMemoryRegionAttr_CarveoutProtected | KMemoryRegionAttr_NoUserMap |
                KMemoryRegionAttr_LinearMapped));
 
-constexpr auto KMemoryRegionType_DramReservedEarly =
+constexpr inline auto KMemoryRegionType_DramKernelSecureAppletMemory =
+    KMemoryRegionType_DramKernelBase.DeriveSparse(1, 3, 0).SetAttribute(
+        KMemoryRegionAttr_LinearMapped);
+static_assert(KMemoryRegionType_DramKernelSecureAppletMemory.GetValue() ==
+              (0x18E | KMemoryRegionAttr_CarveoutProtected | KMemoryRegionAttr_NoUserMap |
+               KMemoryRegionAttr_LinearMapped));
+
+constexpr inline auto KMemoryRegionType_DramReservedEarly =
     KMemoryRegionType_DramReservedBase.DeriveAttribute(KMemoryRegionAttr_NoUserMap);
 static_assert(KMemoryRegionType_DramReservedEarly.GetValue() ==
               (0x16 | KMemoryRegionAttr_NoUserMap));
 
-constexpr auto KMemoryRegionType_KernelTraceBuffer =
+constexpr inline auto KMemoryRegionType_KernelTraceBuffer =
     KMemoryRegionType_DramReservedBase.DeriveSparse(0, 3, 0)
         .SetAttribute(KMemoryRegionAttr_LinearMapped)
         .SetAttribute(KMemoryRegionAttr_UserReadOnly);
-constexpr auto KMemoryRegionType_OnMemoryBootImage =
+constexpr inline auto KMemoryRegionType_OnMemoryBootImage =
     KMemoryRegionType_DramReservedBase.DeriveSparse(0, 3, 1);
-constexpr auto KMemoryRegionType_DTB = KMemoryRegionType_DramReservedBase.DeriveSparse(0, 3, 2);
+constexpr inline auto KMemoryRegionType_DTB =
+    KMemoryRegionType_DramReservedBase.DeriveSparse(0, 3, 2);
 static_assert(KMemoryRegionType_KernelTraceBuffer.GetValue() ==
               (0xD6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_UserReadOnly));
 static_assert(KMemoryRegionType_OnMemoryBootImage.GetValue() == 0x156);
 static_assert(KMemoryRegionType_DTB.GetValue() == 0x256);
 
-constexpr auto KMemoryRegionType_DramPoolPartition =
+constexpr inline auto KMemoryRegionType_DramPoolPartition =
     KMemoryRegionType_DramHeapBase.DeriveAttribute(KMemoryRegionAttr_NoUserMap);
 static_assert(KMemoryRegionType_DramPoolPartition.GetValue() ==
               (0x26 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
 
-constexpr auto KMemoryRegionType_DramPoolManagement =
+constexpr inline auto KMemoryRegionType_DramPoolManagement =
     KMemoryRegionType_DramPoolPartition.DeriveTransition(0, 2).DeriveTransition().SetAttribute(
         KMemoryRegionAttr_CarveoutProtected);
-constexpr auto KMemoryRegionType_DramUserPool =
+constexpr inline auto KMemoryRegionType_DramUserPool =
     KMemoryRegionType_DramPoolPartition.DeriveTransition(1, 2).DeriveTransition();
 static_assert(KMemoryRegionType_DramPoolManagement.GetValue() ==
               (0x166 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap |
@@ -214,11 +228,13 @@ static_assert(KMemoryRegionType_DramPoolManagement.GetValue() ==
 static_assert(KMemoryRegionType_DramUserPool.GetValue() ==
               (0x1A6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
 
-constexpr auto KMemoryRegionType_DramApplicationPool = KMemoryRegionType_DramUserPool.Derive(4, 0);
-constexpr auto KMemoryRegionType_DramAppletPool = KMemoryRegionType_DramUserPool.Derive(4, 1);
-constexpr auto KMemoryRegionType_DramSystemNonSecurePool =
+constexpr inline auto KMemoryRegionType_DramApplicationPool =
+    KMemoryRegionType_DramUserPool.Derive(4, 0);
+constexpr inline auto KMemoryRegionType_DramAppletPool =
+    KMemoryRegionType_DramUserPool.Derive(4, 1);
+constexpr inline auto KMemoryRegionType_DramSystemNonSecurePool =
     KMemoryRegionType_DramUserPool.Derive(4, 2);
-constexpr auto KMemoryRegionType_DramSystemPool =
+constexpr inline auto KMemoryRegionType_DramSystemPool =
     KMemoryRegionType_DramUserPool.Derive(4, 3).SetAttribute(KMemoryRegionAttr_CarveoutProtected);
 static_assert(KMemoryRegionType_DramApplicationPool.GetValue() ==
               (0x7A6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap));
@@ -230,50 +246,55 @@ static_assert(KMemoryRegionType_DramSystemPool.GetValue() ==
               (0x13A6 | KMemoryRegionAttr_LinearMapped | KMemoryRegionAttr_NoUserMap |
                KMemoryRegionAttr_CarveoutProtected));
 
-constexpr auto KMemoryRegionType_VirtualDramHeapBase = KMemoryRegionType_Dram.DeriveSparse(1, 3, 0);
-constexpr auto KMemoryRegionType_VirtualDramKernelPtHeap =
+constexpr inline auto KMemoryRegionType_VirtualDramHeapBase =
+    KMemoryRegionType_Dram.DeriveSparse(1, 3, 0);
+constexpr inline auto KMemoryRegionType_VirtualDramKernelPtHeap =
     KMemoryRegionType_Dram.DeriveSparse(1, 3, 1);
-constexpr auto KMemoryRegionType_VirtualDramKernelTraceBuffer =
+constexpr inline auto KMemoryRegionType_VirtualDramKernelTraceBuffer =
     KMemoryRegionType_Dram.DeriveSparse(1, 3, 2);
 static_assert(KMemoryRegionType_VirtualDramHeapBase.GetValue() == 0x1A);
 static_assert(KMemoryRegionType_VirtualDramKernelPtHeap.GetValue() == 0x2A);
 static_assert(KMemoryRegionType_VirtualDramKernelTraceBuffer.GetValue() == 0x4A);
 
 // UNUSED: .DeriveSparse(2, 2, 0);
-constexpr auto KMemoryRegionType_VirtualDramUnknownDebug =
+constexpr inline auto KMemoryRegionType_VirtualDramUnknownDebug =
     KMemoryRegionType_Dram.DeriveSparse(2, 2, 1);
 static_assert(KMemoryRegionType_VirtualDramUnknownDebug.GetValue() == (0x52));
 
-constexpr auto KMemoryRegionType_VirtualDramKernelInitPt =
+constexpr inline auto KMemoryRegionType_VirtualDramKernelSecureAppletMemory =
+    KMemoryRegionType_Dram.DeriveSparse(3, 1, 0);
+static_assert(KMemoryRegionType_VirtualDramKernelSecureAppletMemory.GetValue() == (0x62));
+
+constexpr inline auto KMemoryRegionType_VirtualDramKernelInitPt =
     KMemoryRegionType_VirtualDramHeapBase.Derive(3, 0);
-constexpr auto KMemoryRegionType_VirtualDramPoolManagement =
+constexpr inline auto KMemoryRegionType_VirtualDramPoolManagement =
     KMemoryRegionType_VirtualDramHeapBase.Derive(3, 1);
-constexpr auto KMemoryRegionType_VirtualDramUserPool =
+constexpr inline auto KMemoryRegionType_VirtualDramUserPool =
     KMemoryRegionType_VirtualDramHeapBase.Derive(3, 2);
 static_assert(KMemoryRegionType_VirtualDramKernelInitPt.GetValue() == 0x19A);
 static_assert(KMemoryRegionType_VirtualDramPoolManagement.GetValue() == 0x29A);
 static_assert(KMemoryRegionType_VirtualDramUserPool.GetValue() == 0x31A);
 
-// NOTE: For unknown reason, the pools are derived out-of-order here. It's worth eventually trying
-// to understand why Nintendo made this choice.
+// NOTE: For unknown reason, the pools are derived out-of-order here.
+// It's worth eventually trying to understand why Nintendo made this choice.
 // UNUSED: .Derive(6, 0);
 // UNUSED: .Derive(6, 1);
-constexpr auto KMemoryRegionType_VirtualDramAppletPool =
+constexpr inline auto KMemoryRegionType_VirtualDramAppletPool =
     KMemoryRegionType_VirtualDramUserPool.Derive(6, 2);
-constexpr auto KMemoryRegionType_VirtualDramApplicationPool =
+constexpr inline auto KMemoryRegionType_VirtualDramApplicationPool =
     KMemoryRegionType_VirtualDramUserPool.Derive(6, 3);
-constexpr auto KMemoryRegionType_VirtualDramSystemNonSecurePool =
+constexpr inline auto KMemoryRegionType_VirtualDramSystemNonSecurePool =
     KMemoryRegionType_VirtualDramUserPool.Derive(6, 4);
-constexpr auto KMemoryRegionType_VirtualDramSystemPool =
+constexpr inline auto KMemoryRegionType_VirtualDramSystemPool =
     KMemoryRegionType_VirtualDramUserPool.Derive(6, 5);
 static_assert(KMemoryRegionType_VirtualDramAppletPool.GetValue() == 0x1B1A);
 static_assert(KMemoryRegionType_VirtualDramApplicationPool.GetValue() == 0x271A);
 static_assert(KMemoryRegionType_VirtualDramSystemNonSecurePool.GetValue() == 0x2B1A);
 static_assert(KMemoryRegionType_VirtualDramSystemPool.GetValue() == 0x331A);
 
-constexpr auto KMemoryRegionType_ArchDeviceBase =
+constexpr inline auto KMemoryRegionType_ArchDeviceBase =
     KMemoryRegionType_Kernel.DeriveTransition(0, 1).SetSparseOnly();
-constexpr auto KMemoryRegionType_BoardDeviceBase =
+constexpr inline auto KMemoryRegionType_BoardDeviceBase =
     KMemoryRegionType_Kernel.DeriveTransition(0, 2).SetDenseOnly();
 static_assert(KMemoryRegionType_ArchDeviceBase.GetValue() == 0x5);
 static_assert(KMemoryRegionType_BoardDeviceBase.GetValue() == 0x5);
@@ -284,7 +305,7 @@ static_assert(KMemoryRegionType_BoardDeviceBase.GetValue() == 0x5);
 #error "Unimplemented"
 #else
 // Default to no architecture devices.
-constexpr auto NumArchitectureDeviceRegions = 0;
+constexpr inline auto NumArchitectureDeviceRegions = 0;
 #endif
 static_assert(NumArchitectureDeviceRegions >= 0);
 
@@ -292,34 +313,35 @@ static_assert(NumArchitectureDeviceRegions >= 0);
 #include "core/hle/kernel/board/nintendo/nx/k_memory_region_device_types.inc"
 #else
 // Default to no board devices.
-constexpr auto NumBoardDeviceRegions = 0;
+constexpr inline auto NumBoardDeviceRegions = 0;
 #endif
 static_assert(NumBoardDeviceRegions >= 0);
 
-constexpr auto KMemoryRegionType_KernelCode = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 0);
-constexpr auto KMemoryRegionType_KernelStack = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 1);
-constexpr auto KMemoryRegionType_KernelMisc = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 2);
-constexpr auto KMemoryRegionType_KernelSlab = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 3);
+constexpr inline auto KMemoryRegionType_KernelCode = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 0);
+constexpr inline auto KMemoryRegionType_KernelStack =
+    KMemoryRegionType_Kernel.DeriveSparse(1, 4, 1);
+constexpr inline auto KMemoryRegionType_KernelMisc = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 2);
+constexpr inline auto KMemoryRegionType_KernelSlab = KMemoryRegionType_Kernel.DeriveSparse(1, 4, 3);
 static_assert(KMemoryRegionType_KernelCode.GetValue() == 0x19);
 static_assert(KMemoryRegionType_KernelStack.GetValue() == 0x29);
 static_assert(KMemoryRegionType_KernelMisc.GetValue() == 0x49);
 static_assert(KMemoryRegionType_KernelSlab.GetValue() == 0x89);
 
-constexpr auto KMemoryRegionType_KernelMiscDerivedBase =
+constexpr inline auto KMemoryRegionType_KernelMiscDerivedBase =
     KMemoryRegionType_KernelMisc.DeriveTransition();
 static_assert(KMemoryRegionType_KernelMiscDerivedBase.GetValue() == 0x149);
 
 // UNUSED: .Derive(7, 0);
-constexpr auto KMemoryRegionType_KernelMiscMainStack =
+constexpr inline auto KMemoryRegionType_KernelMiscMainStack =
     KMemoryRegionType_KernelMiscDerivedBase.Derive(7, 1);
-constexpr auto KMemoryRegionType_KernelMiscMappedDevice =
+constexpr inline auto KMemoryRegionType_KernelMiscMappedDevice =
     KMemoryRegionType_KernelMiscDerivedBase.Derive(7, 2);
-constexpr auto KMemoryRegionType_KernelMiscExceptionStack =
+constexpr inline auto KMemoryRegionType_KernelMiscExceptionStack =
     KMemoryRegionType_KernelMiscDerivedBase.Derive(7, 3);
-constexpr auto KMemoryRegionType_KernelMiscUnknownDebug =
+constexpr inline auto KMemoryRegionType_KernelMiscUnknownDebug =
     KMemoryRegionType_KernelMiscDerivedBase.Derive(7, 4);
 // UNUSED: .Derive(7, 5);
-constexpr auto KMemoryRegionType_KernelMiscIdleStack =
+constexpr inline auto KMemoryRegionType_KernelMiscIdleStack =
     KMemoryRegionType_KernelMiscDerivedBase.Derive(7, 6);
 static_assert(KMemoryRegionType_KernelMiscMainStack.GetValue() == 0xB49);
 static_assert(KMemoryRegionType_KernelMiscMappedDevice.GetValue() == 0xD49);
@@ -327,7 +349,8 @@ static_assert(KMemoryRegionType_KernelMiscExceptionStack.GetValue() == 0x1349);
 static_assert(KMemoryRegionType_KernelMiscUnknownDebug.GetValue() == 0x1549);
 static_assert(KMemoryRegionType_KernelMiscIdleStack.GetValue() == 0x2349);
 
-constexpr auto KMemoryRegionType_KernelTemp = KMemoryRegionType_Kernel.Advance(2).Derive(2, 0);
+constexpr inline auto KMemoryRegionType_KernelTemp =
+    KMemoryRegionType_Kernel.Advance(2).Derive(2, 0);
 static_assert(KMemoryRegionType_KernelTemp.GetValue() == 0x31);
 
 constexpr KMemoryRegionType GetTypeForVirtualLinearMapping(u32 type_id) {
@@ -335,6 +358,8 @@ constexpr KMemoryRegionType GetTypeForVirtualLinearMapping(u32 type_id) {
         return KMemoryRegionType_VirtualDramKernelTraceBuffer;
     } else if (KMemoryRegionType_DramKernelPtHeap.IsAncestorOf(type_id)) {
         return KMemoryRegionType_VirtualDramKernelPtHeap;
+    } else if (KMemoryRegionType_DramKernelSecureAppletMemory.IsAncestorOf(type_id)) {
+        return KMemoryRegionType_VirtualDramKernelSecureAppletMemory;
     } else if ((type_id | KMemoryRegionAttr_ShouldKernelMap) == type_id) {
         return KMemoryRegionType_VirtualDramUnknownDebug;
     } else {

src/core/hle/kernel/k_page_bitmap.h

@@ -16,107 +16,126 @@
 namespace Kernel {
 
 class KPageBitmap {
-private:
+public:
     class RandomBitGenerator {
-    private:
-        Common::TinyMT rng{};
-        u32 entropy{};
-        u32 bits_available{};
-
-    private:
-        void RefreshEntropy() {
-            entropy = rng.GenerateRandomU32();
-            bits_available = static_cast<u32>(Common::BitSize<decltype(entropy)>());
-        }
-
-        bool GenerateRandomBit() {
-            if (bits_available == 0) {
-                this->RefreshEntropy();
-            }
-
-            const bool rnd_bit = (entropy & 1) != 0;
-            entropy >>= 1;
-            --bits_available;
-            return rnd_bit;
-        }
-
     public:
         RandomBitGenerator() {
-            rng.Initialize(static_cast<u32>(KSystemControl::GenerateRandomU64()));
+            m_rng.Initialize(static_cast<u32>(KSystemControl::GenerateRandomU64()));
         }
 
-        std::size_t SelectRandomBit(u64 bitmap) {
+        u64 SelectRandomBit(u64 bitmap) {
             u64 selected = 0;
 
-            u64 cur_num_bits = Common::BitSize<decltype(bitmap)>() / 2;
-            u64 cur_mask = (1ULL << cur_num_bits) - 1;
+            for (size_t cur_num_bits = Common::BitSize<decltype(bitmap)>() / 2; cur_num_bits != 0;
+                 cur_num_bits /= 2) {
+                const u64 high = (bitmap >> cur_num_bits);
+                const u64 low = (bitmap & (~(UINT64_C(0xFFFFFFFFFFFFFFFF) << cur_num_bits)));
 
-            while (cur_num_bits) {
-                const u64 low = (bitmap >> 0) & cur_mask;
-                const u64 high = (bitmap >> cur_num_bits) & cur_mask;
-
-                bool choose_low;
-                if (high == 0) {
-                    // If only low val is set, choose low.
-                    choose_low = true;
-                } else if (low == 0) {
-                    // If only high val is set, choose high.
-                    choose_low = false;
-                } else {
-                    // If both are set, choose random.
-                    choose_low = this->GenerateRandomBit();
-                }
-
-                // If we chose low, proceed with low.
-                if (choose_low) {
-                    bitmap = low;
-                    selected += 0;
-                } else {
+                // Choose high if we have high and (don't have low or select high randomly).
+                if (high && (low == 0 || this->GenerateRandomBit())) {
                     bitmap = high;
                     selected += cur_num_bits;
+                } else {
+                    bitmap = low;
+                    selected += 0;
                 }
-
-                // Proceed.
-                cur_num_bits /= 2;
-                cur_mask >>= cur_num_bits;
             }
 
             return selected;
         }
+
+        u64 GenerateRandom(u64 max) {
+            // Determine the number of bits we need.
+            const u64 bits_needed = 1 + (Common::BitSize<decltype(max)>() - std::countl_zero(max));
+
+            // Generate a random value of the desired bitwidth.
+            const u64 rnd = this->GenerateRandomBits(static_cast<u32>(bits_needed));
+
+            // Adjust the value to be in range.
+            return rnd - ((rnd / max) * max);
+        }
+
+    private:
+        void RefreshEntropy() {
+            m_entropy = m_rng.GenerateRandomU32();
+            m_bits_available = static_cast<u32>(Common::BitSize<decltype(m_entropy)>());
+        }
+
+        bool GenerateRandomBit() {
+            if (m_bits_available == 0) {
+                this->RefreshEntropy();
+            }
+
+            const bool rnd_bit = (m_entropy & 1) != 0;
+            m_entropy >>= 1;
+            --m_bits_available;
+            return rnd_bit;
+        }
+
+        u64 GenerateRandomBits(u32 num_bits) {
+            u64 result = 0;
+
+            // Iteratively add random bits to our result.
+            while (num_bits > 0) {
+                // Ensure we have random bits to take from.
+                if (m_bits_available == 0) {
+                    this->RefreshEntropy();
+                }
+
+                // Determine how many bits to take this round.
+                const auto cur_bits = std::min(num_bits, m_bits_available);
+
+                // Generate mask for our current bits.
+                const u64 mask = (static_cast<u64>(1) << cur_bits) - 1;
+
+                // Add bits to output from our entropy.
+                result <<= cur_bits;
+                result |= (m_entropy & mask);
+
+                // Remove bits from our entropy.
+                m_entropy >>= cur_bits;
+                m_bits_available -= cur_bits;
+
+                // Advance.
+                num_bits -= cur_bits;
+            }
+
+            return result;
+        }
+
+    private:
+        Common::TinyMT m_rng;
+        u32 m_entropy{};
+        u32 m_bits_available{};
     };
 
 public:
-    static constexpr std::size_t MaxDepth = 4;
-
-private:
-    std::array<u64*, MaxDepth> bit_storages{};
-    RandomBitGenerator rng{};
-    std::size_t num_bits{};
-    std::size_t used_depths{};
+    static constexpr size_t MaxDepth = 4;
 
 public:
     KPageBitmap() = default;
 
-    constexpr std::size_t GetNumBits() const {
-        return num_bits;
+    constexpr size_t GetNumBits() const {
+        return m_num_bits;
     }
     constexpr s32 GetHighestDepthIndex() const {
-        return static_cast<s32>(used_depths) - 1;
+        return static_cast<s32>(m_used_depths) - 1;
     }
 
-    u64* Initialize(u64* storage, std::size_t size) {
+    u64* Initialize(u64* storage, size_t size) {
         // Initially, everything is un-set.
-        num_bits = 0;
+        m_num_bits = 0;
 
         // Calculate the needed bitmap depth.
-        used_depths = static_cast<std::size_t>(GetRequiredDepth(size));
-        ASSERT(used_depths <= MaxDepth);
+        m_used_depths = static_cast<size_t>(GetRequiredDepth(size));
+        ASSERT(m_used_depths <= MaxDepth);
 
         // Set the bitmap pointers.
         for (s32 depth = this->GetHighestDepthIndex(); depth >= 0; depth--) {
-            bit_storages[depth] = storage;
+            m_bit_storages[depth] = storage;
             size = Common::AlignUp(size, Common::BitSize<u64>()) / Common::BitSize<u64>();
             storage += size;
+            m_end_storages[depth] = storage;
         }
 
         return storage;
@@ -128,19 +147,19 @@ public:
 
         if (random) {
             do {
-                const u64 v = bit_storages[depth][offset];
+                const u64 v = m_bit_storages[depth][offset];
                 if (v == 0) {
                     // If depth is bigger than zero, then a previous level indicated a block was
                     // free.
                     ASSERT(depth == 0);
                     return -1;
                 }
-                offset = offset * Common::BitSize<u64>() + rng.SelectRandomBit(v);
+                offset = offset * Common::BitSize<u64>() + m_rng.SelectRandomBit(v);
                 ++depth;
-            } while (depth < static_cast<s32>(used_depths));
+            } while (depth < static_cast<s32>(m_used_depths));
         } else {
             do {
-                const u64 v = bit_storages[depth][offset];
+                const u64 v = m_bit_storages[depth][offset];
                 if (v == 0) {
                     // If depth is bigger than zero, then a previous level indicated a block was
                     // free.
@@ -149,28 +168,69 @@ public:
                 }
                 offset = offset * Common::BitSize<u64>() + std::countr_zero(v);
                 ++depth;
-            } while (depth < static_cast<s32>(used_depths));
+            } while (depth < static_cast<s32>(m_used_depths));
         }
 
         return static_cast<s64>(offset);
     }
 
-    void SetBit(std::size_t offset) {
+    s64 FindFreeRange(size_t count) {
+        // Check that it is possible to find a range.
+        const u64* const storage_start = m_bit_storages[m_used_depths - 1];
+        const u64* const storage_end = m_end_storages[m_used_depths - 1];
+
+        // If we don't have a storage to iterate (or want more blocks than fit in a single storage),
+        // we can't find a free range.
+        if (!(storage_start < storage_end && count <= Common::BitSize<u64>())) {
+            return -1;
+        }
+
+        // Walk the storages to select a random free range.
+        const size_t options_per_storage = std::max<size_t>(Common::BitSize<u64>() / count, 1);
+        const size_t num_entries = std::max<size_t>(storage_end - storage_start, 1);
+
+        const u64 free_mask = (static_cast<u64>(1) << count) - 1;
+
+        size_t num_valid_options = 0;
+        s64 chosen_offset = -1;
+        for (size_t storage_index = 0; storage_index < num_entries; ++storage_index) {
+            u64 storage = storage_start[storage_index];
+            for (size_t option = 0; option < options_per_storage; ++option) {
+                if ((storage & free_mask) == free_mask) {
+                    // We've found a new valid option.
+                    ++num_valid_options;
+
+                    // Select the Kth valid option with probability 1/K. This leads to an overall
+                    // uniform distribution.
+                    if (num_valid_options == 1 || m_rng.GenerateRandom(num_valid_options) == 0) {
+                        // This is our first option, so select it.
+                        chosen_offset = storage_index * Common::BitSize<u64>() + option * count;
+                    }
+                }
+                storage >>= count;
+            }
+        }
+
+        // Return the random offset we chose.*/
+        return chosen_offset;
+    }
+
+    void SetBit(size_t offset) {
         this->SetBit(this->GetHighestDepthIndex(), offset);
-        num_bits++;
+        m_num_bits++;
     }
 
-    void ClearBit(std::size_t offset) {
+    void ClearBit(size_t offset) {
         this->ClearBit(this->GetHighestDepthIndex(), offset);
-        num_bits--;
+        m_num_bits--;
     }
 
-    bool ClearRange(std::size_t offset, std::size_t count) {
+    bool ClearRange(size_t offset, size_t count) {
         s32 depth = this->GetHighestDepthIndex();
-        u64* bits = bit_storages[depth];
-        std::size_t bit_ind = offset / Common::BitSize<u64>();
-        if (count < Common::BitSize<u64>()) {
-            const std::size_t shift = offset % Common::BitSize<u64>();
+        u64* bits = m_bit_storages[depth];
+        size_t bit_ind = offset / Common::BitSize<u64>();
+        if (count < Common::BitSize<u64>()) [[likely]] {
+            const size_t shift = offset % Common::BitSize<u64>();
             ASSERT(shift + count <= Common::BitSize<u64>());
             // Check that all the bits are set.
             const u64 mask = ((u64(1) << count) - 1) << shift;
@@ -189,8 +249,8 @@ public:
             ASSERT(offset % Common::BitSize<u64>() == 0);
             ASSERT(count % Common::BitSize<u64>() == 0);
             // Check that all the bits are set.
-            std::size_t remaining = count;
-            std::size_t i = 0;
+            size_t remaining = count;
+            size_t i = 0;
             do {
                 if (bits[bit_ind + i++] != ~u64(0)) {
                     return false;
@@ -209,18 +269,18 @@ public:
             } while (remaining > 0);
         }
 
-        num_bits -= count;
+        m_num_bits -= count;
         return true;
     }
 
 private:
-    void SetBit(s32 depth, std::size_t offset) {
+    void SetBit(s32 depth, size_t offset) {
         while (depth >= 0) {
-            std::size_t ind = offset / Common::BitSize<u64>();
-            std::size_t which = offset % Common::BitSize<u64>();
+            size_t ind = offset / Common::BitSize<u64>();
+            size_t which = offset % Common::BitSize<u64>();
             const u64 mask = u64(1) << which;
 
-            u64* bit = std::addressof(bit_storages[depth][ind]);
+            u64* bit = std::addressof(m_bit_storages[depth][ind]);
             u64 v = *bit;
             ASSERT((v & mask) == 0);
             *bit = v | mask;
@@ -232,13 +292,13 @@ private:
         }
     }
 
-    void ClearBit(s32 depth, std::size_t offset) {
+    void ClearBit(s32 depth, size_t offset) {
         while (depth >= 0) {
-            std::size_t ind = offset / Common::BitSize<u64>();
-            std::size_t which = offset % Common::BitSize<u64>();
+            size_t ind = offset / Common::BitSize<u64>();
+            size_t which = offset % Common::BitSize<u64>();
             const u64 mask = u64(1) << which;
 
-            u64* bit = std::addressof(bit_storages[depth][ind]);
+            u64* bit = std::addressof(m_bit_storages[depth][ind]);
             u64 v = *bit;
             ASSERT((v & mask) != 0);
             v &= ~mask;
@@ -252,7 +312,7 @@ private:
     }
 
 private:
-    static constexpr s32 GetRequiredDepth(std::size_t region_size) {
+    static constexpr s32 GetRequiredDepth(size_t region_size) {
         s32 depth = 0;
         while (true) {
             region_size /= Common::BitSize<u64>();
@@ -264,8 +324,8 @@ private:
     }
 
 public:
-    static constexpr std::size_t CalculateManagementOverheadSize(std::size_t region_size) {
-        std::size_t overhead_bits = 0;
+    static constexpr size_t CalculateManagementOverheadSize(size_t region_size) {
+        size_t overhead_bits = 0;
         for (s32 depth = GetRequiredDepth(region_size) - 1; depth >= 0; depth--) {
             region_size =
                 Common::AlignUp(region_size, Common::BitSize<u64>()) / Common::BitSize<u64>();
@@ -273,6 +333,13 @@ public:
         }
         return overhead_bits * sizeof(u64);
     }
+
+private:
+    std::array<u64*, MaxDepth> m_bit_storages{};
+    std::array<u64*, MaxDepth> m_end_storages{};
+    RandomBitGenerator m_rng;
+    size_t m_num_bits{};
+    size_t m_used_depths{};
 };
 
 } // namespace Kernel

src/core/hle/kernel/k_page_buffer.h

@@ -11,8 +11,19 @@
 
 namespace Kernel {
 
+class KernelCore;
+
+class KPageBufferSlabHeap : protected impl::KSlabHeapImpl {
+public:
+    static constexpr size_t BufferSize = PageSize;
+
+public:
+    void Initialize(Core::System& system);
+};
+
 class KPageBuffer final : public KSlabAllocated<KPageBuffer> {
 public:
+    explicit KPageBuffer(KernelCore&) {}
     KPageBuffer() = default;
 
     static KPageBuffer* FromPhysicalAddress(Core::System& system, PAddr phys_addr);
@@ -20,8 +31,6 @@ public:
 private:
     [[maybe_unused]] alignas(PageSize) std::array<u8, PageSize> m_buffer{};
 };
-
-static_assert(sizeof(KPageBuffer) == PageSize);
-static_assert(alignof(KPageBuffer) == PageSize);
+static_assert(sizeof(KPageBuffer) == KPageBufferSlabHeap::BufferSize);
 
 } // namespace Kernel

src/core/hle/kernel/k_page_group.h

@@ -5,6 +5,7 @@
 
 #include <list>
 
+#include "common/alignment.h"
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/hle/kernel/memory_types.h"
@@ -12,6 +13,89 @@
 
 namespace Kernel {
 
+class KPageGroup;
+
+class KBlockInfo {
+private:
+    friend class KPageGroup;
+
+public:
+    constexpr KBlockInfo() = default;
+
+    constexpr void Initialize(PAddr addr, size_t np) {
+        ASSERT(Common::IsAligned(addr, PageSize));
+        ASSERT(static_cast<u32>(np) == np);
+
+        m_page_index = static_cast<u32>(addr) / PageSize;
+        m_num_pages = static_cast<u32>(np);
+    }
+
+    constexpr PAddr GetAddress() const {
+        return m_page_index * PageSize;
+    }
+    constexpr size_t GetNumPages() const {
+        return m_num_pages;
+    }
+    constexpr size_t GetSize() const {
+        return this->GetNumPages() * PageSize;
+    }
+    constexpr PAddr GetEndAddress() const {
+        return (m_page_index + m_num_pages) * PageSize;
+    }
+    constexpr PAddr GetLastAddress() const {
+        return this->GetEndAddress() - 1;
+    }
+
+    constexpr KBlockInfo* GetNext() const {
+        return m_next;
+    }
+
+    constexpr bool IsEquivalentTo(const KBlockInfo& rhs) const {
+        return m_page_index == rhs.m_page_index && m_num_pages == rhs.m_num_pages;
+    }
+
+    constexpr bool operator==(const KBlockInfo& rhs) const {
+        return this->IsEquivalentTo(rhs);
+    }
+
+    constexpr bool operator!=(const KBlockInfo& rhs) const {
+        return !(*this == rhs);
+    }
+
+    constexpr bool IsStrictlyBefore(PAddr addr) const {
+        const PAddr end = this->GetEndAddress();
+
+        if (m_page_index != 0 && end == 0) {
+            return false;
+        }
+
+        return end < addr;
+    }
+
+    constexpr bool operator<(PAddr addr) const {
+        return this->IsStrictlyBefore(addr);
+    }
+
+    constexpr bool TryConcatenate(PAddr addr, size_t np) {
+        if (addr != 0 && addr == this->GetEndAddress()) {
+            m_num_pages += static_cast<u32>(np);
+            return true;
+        }
+        return false;
+    }
+
+private:
+    constexpr void SetNext(KBlockInfo* next) {
+        m_next = next;
+    }
+
+private:
+    KBlockInfo* m_next{};
+    u32 m_page_index{};
+    u32 m_num_pages{};
+};
+static_assert(sizeof(KBlockInfo) <= 0x10);
+
 class KPageGroup final {
 public:
     class Node final {
@@ -92,6 +176,8 @@ public:
         return nodes.empty();
     }
 
+    void Finalize() {}
+
 private:
     std::list<Node> nodes;
 };

src/core/hle/kernel/k_page_heap.cpp

@@ -44,11 +44,11 @@ size_t KPageHeap::GetNumFreePages() const {
     return num_free;
 }
 
-PAddr KPageHeap::AllocateBlock(s32 index, bool random) {
+PAddr KPageHeap::AllocateByLinearSearch(s32 index) {
     const size_t needed_size = m_blocks[index].GetSize();
 
     for (s32 i = index; i < static_cast<s32>(m_num_blocks); i++) {
-        if (const PAddr addr = m_blocks[i].PopBlock(random); addr != 0) {
+        if (const PAddr addr = m_blocks[i].PopBlock(false); addr != 0) {
             if (const size_t allocated_size = m_blocks[i].GetSize(); allocated_size > needed_size) {
                 this->Free(addr + needed_size, (allocated_size - needed_size) / PageSize);
             }
@@ -59,6 +59,88 @@ PAddr KPageHeap::AllocateBlock(s32 index, bool random) {
     return 0;
 }
 
+PAddr KPageHeap::AllocateByRandom(s32 index, size_t num_pages, size_t align_pages) {
+    // Get the size and required alignment.
+    const size_t needed_size = num_pages * PageSize;
+    const size_t align_size = align_pages * PageSize;
+
+    // Determine meta-alignment of our desired alignment size.
+    const size_t align_shift = std::countr_zero(align_size);
+
+    // Decide on a block to allocate from.
+    constexpr size_t MinimumPossibleAlignmentsForRandomAllocation = 4;
+    {
+        // By default, we'll want to look at all blocks larger than our current one.
+        s32 max_blocks = static_cast<s32>(m_num_blocks);
+
+        // Determine the maximum block we should try to allocate from.
+        size_t possible_alignments = 0;
+        for (s32 i = index; i < max_blocks; ++i) {
+            // Add the possible alignments from blocks at the current size.
+            possible_alignments += (1 + ((m_blocks[i].GetSize() - needed_size) >> align_shift)) *
+                                   m_blocks[i].GetNumFreeBlocks();
+
+            // If there are enough possible alignments, we don't need to look at larger blocks.
+            if (possible_alignments >= MinimumPossibleAlignmentsForRandomAllocation) {
+                max_blocks = i + 1;
+                break;
+            }
+        }
+
+        // If we have any possible alignments which require a larger block, we need to pick one.
+        if (possible_alignments > 0 && index + 1 < max_blocks) {
+            // Select a random alignment from the possibilities.
+            const size_t rnd = m_rng.GenerateRandom(possible_alignments);
+
+            // Determine which block corresponds to the random alignment we chose.
+            possible_alignments = 0;
+            for (s32 i = index; i < max_blocks; ++i) {
+                // Add the possible alignments from blocks at the current size.
+                possible_alignments +=
+                    (1 + ((m_blocks[i].GetSize() - needed_size) >> align_shift)) *
+                    m_blocks[i].GetNumFreeBlocks();
+
+                // If the current block gets us to our random choice, use the current block.
+                if (rnd < possible_alignments) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+    }
+
+    // Pop a block from the index we selected.
+    if (PAddr addr = m_blocks[index].PopBlock(true); addr != 0) {
+        // Determine how much size we have left over.
+        if (const size_t leftover_size = m_blocks[index].GetSize() - needed_size;
+            leftover_size > 0) {
+            // Determine how many valid alignments we can have.
+            const size_t possible_alignments = 1 + (leftover_size >> align_shift);
+
+            // Select a random valid alignment.
+            const size_t random_offset = m_rng.GenerateRandom(possible_alignments) << align_shift;
+
+            // Free memory before the random offset.
+            if (random_offset != 0) {
+                this->Free(addr, random_offset / PageSize);
+            }
+
+            // Advance our block by the random offset.
+            addr += random_offset;
+
+            // Free memory after our allocated block.
+            if (random_offset != leftover_size) {
+                this->Free(addr + needed_size, (leftover_size - random_offset) / PageSize);
+            }
+        }
+
+        // Return the block we allocated.
+        return addr;
+    }
+
+    return 0;
+}
+
 void KPageHeap::FreeBlock(PAddr block, s32 index) {
     do {
         block = m_blocks[index++].PushBlock(block);

src/core/hle/kernel/k_page_heap.h

@@ -14,13 +14,9 @@
 
 namespace Kernel {
 
-class KPageHeap final {
+class KPageHeap {
 public:
-    YUZU_NON_COPYABLE(KPageHeap);
-    YUZU_NON_MOVEABLE(KPageHeap);
-
     KPageHeap() = default;
-    ~KPageHeap() = default;
 
     constexpr PAddr GetAddress() const {
         return m_heap_address;
@@ -57,7 +53,20 @@ public:
         m_initial_used_size = m_heap_size - free_size - reserved_size;
     }
 
-    PAddr AllocateBlock(s32 index, bool random);
+    PAddr AllocateBlock(s32 index, bool random) {
+        if (random) {
+            const size_t block_pages = m_blocks[index].GetNumPages();
+            return this->AllocateByRandom(index, block_pages, block_pages);
+        } else {
+            return this->AllocateByLinearSearch(index);
+        }
+    }
+
+    PAddr AllocateAligned(s32 index, size_t num_pages, size_t align_pages) {
+        // TODO: linear search support?
+        return this->AllocateByRandom(index, num_pages, align_pages);
+    }
+
     void Free(PAddr addr, size_t num_pages);
 
     static size_t CalculateManagementOverheadSize(size_t region_size) {
@@ -68,7 +77,7 @@ public:
     static constexpr s32 GetAlignedBlockIndex(size_t num_pages, size_t align_pages) {
         const size_t target_pages = std::max(num_pages, align_pages);
         for (size_t i = 0; i < NumMemoryBlockPageShifts; i++) {
-            if (target_pages <= (size_t(1) << MemoryBlockPageShifts[i]) / PageSize) {
+            if (target_pages <= (static_cast<size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
                 return static_cast<s32>(i);
             }
         }
@@ -77,7 +86,7 @@ public:
 
     static constexpr s32 GetBlockIndex(size_t num_pages) {
         for (s32 i = static_cast<s32>(NumMemoryBlockPageShifts) - 1; i >= 0; i--) {
-            if (num_pages >= (size_t(1) << MemoryBlockPageShifts[i]) / PageSize) {
+            if (num_pages >= (static_cast<size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
                 return i;
             }
         }
@@ -85,7 +94,7 @@ public:
     }
 
     static constexpr size_t GetBlockSize(size_t index) {
-        return size_t(1) << MemoryBlockPageShifts[index];
+        return static_cast<size_t>(1) << MemoryBlockPageShifts[index];
     }
 
     static constexpr size_t GetBlockNumPages(size_t index) {
@@ -93,13 +102,9 @@ public:
     }
 
 private:
-    class Block final {
+    class Block {
     public:
-        YUZU_NON_COPYABLE(Block);
-        YUZU_NON_MOVEABLE(Block);
-
         Block() = default;
-        ~Block() = default;
 
         constexpr size_t GetShift() const {
             return m_block_shift;
@@ -201,6 +206,9 @@ private:
     };
 
 private:
+    PAddr AllocateByLinearSearch(s32 index);
+    PAddr AllocateByRandom(s32 index, size_t num_pages, size_t align_pages);
+
     static size_t CalculateManagementOverheadSize(size_t region_size, const size_t* block_shifts,
                                                   size_t num_block_shifts);
 
@@ -209,7 +217,8 @@ private:
     size_t m_heap_size{};
     size_t m_initial_used_size{};
     size_t m_num_blocks{};
-    std::array<Block, NumMemoryBlockPageShifts> m_blocks{};
+    std::array<Block, NumMemoryBlockPageShifts> m_blocks;
+    KPageBitmap::RandomBitGenerator m_rng;
     std::vector<u64> m_management_data;
 };