vk_texture_cache: Add ABGR src format check for D24S8 conversions

The image view itself can be queried to see if it is being rescaled or not, removing the need to pass the upscale/down shift factors from the texture cache.

CMakeLists.txt

@@ -131,7 +131,7 @@ add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
     add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)
 
-    # boost still makes use of deprecated result_of.
+    # cubeb and boost still make use of deprecated result_of.
     add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
 else()
     set(CMAKE_CXX_STANDARD 20)
@@ -370,7 +370,7 @@ if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
         if ((MSVC_VERSION GREATER_EQUAL 1920 AND MSVC_VERSION LESS 1940) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.18")
+            set(SDL2_VER "SDL2-2.0.16")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
         endif()
@@ -390,7 +390,7 @@ if (ENABLE_SDL2)
     elseif (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
     else()
-        find_package(SDL2 2.0.18 REQUIRED)
+        find_package(SDL2 2.0.16 REQUIRED)
 
         # Some installations don't set SDL2_LIBRARIES
         if("${SDL2_LIBRARIES}" STREQUAL "")

README.md

@@ -17,7 +17,7 @@ It is written in C++ with portability in mind, and we actively maintain builds f
             alt="Azure Mainline CI Build Status">
     </a>
     <a href="https://discord.com/invite/u77vRWY">
-        <img src="https://img.shields.io/discord/398318088170242053?color=5865F2&label=yuzu&logo=discord&logoColor=white"
+        <img src="https://img.shields.io/discord/398318088170242053?color=%237289DA&label=yuzu&logo=discord&logoColor=white"
             alt="Discord">
     </a>
 </p>

externals/CMakeLists.txt

@@ -44,6 +44,10 @@ target_include_directories(mbedtls PUBLIC ./mbedtls/include)
 add_library(microprofile INTERFACE)
 target_include_directories(microprofile INTERFACE ./microprofile)
 
+# Unicorn
+add_library(unicorn-headers INTERFACE)
+target_include_directories(unicorn-headers INTERFACE ./unicorn/include)
+
 # libusb
 if (NOT LIBUSB_FOUND OR YUZU_USE_BUNDLED_LIBUSB)
     add_subdirectory(libusb)

externals/find-modules/FindUnicorn.cmake

@@ -0,0 +1,18 @@
+# Exports:
+#  LIBUNICORN_FOUND
+#  LIBUNICORN_INCLUDE_DIR
+#  LIBUNICORN_LIBRARY
+
+find_path(LIBUNICORN_INCLUDE_DIR
+          unicorn/unicorn.h
+          HINTS $ENV{UNICORNDIR}
+          PATH_SUFFIXES include)
+
+find_library(LIBUNICORN_LIBRARY
+             NAMES unicorn
+             HINTS $ENV{UNICORNDIR})
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(unicorn DEFAULT_MSG
+                                  LIBUNICORN_LIBRARY LIBUNICORN_INCLUDE_DIR)
+mark_as_advanced(LIBUNICORN_INCLUDE_DIR LIBUNICORN_LIBRARY)

src/CMakeLists.txt

@@ -24,7 +24,6 @@ if (MSVC)
     # /W3                 - Level 3 warnings
     # /MP                 - Multi-threaded compilation
     # /Zi                 - Output debugging information
-    # /Zm                 - Specifies the precompiled header memory allocation limit
     # /Zo                 - Enhanced debug info for optimized builds
     # /permissive-        - Enables stricter C++ standards conformance checks
     # /EHsc               - C++-only exception handling semantics
@@ -37,7 +36,6 @@ if (MSVC)
     add_compile_options(
         /MP
         /Zi
-        /Zm200
         /Zo
         /permissive-
         /EHsc

src/audio_core/delay_line.cpp

@@ -1,7 +1,3 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #include <cstring>
 #include "audio_core/delay_line.h"
 

src/audio_core/delay_line.h

@@ -1,7 +1,3 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #pragma once
 
 #include "common/common_types.h"

src/common/host_memory.cpp

@@ -1,7 +1,3 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #ifdef _WIN32
 
 #include <iterator>

src/common/input.h

@@ -227,7 +227,7 @@ struct CallbackStatus {
 
 // Triggered once every input change
 struct InputCallback {
-    std::function<void(const CallbackStatus&)> on_change;
+    std::function<void(CallbackStatus)> on_change;
 };
 
 /// An abstract class template for an input device (a button, an analog input, etc.).
@@ -236,10 +236,14 @@ public:
     virtual ~InputDevice() = default;
 
     // Request input device to update if necessary
-    virtual void SoftUpdate() {}
+    virtual void SoftUpdate() {
+        return;
+    }
 
     // Force input device to update data regardless of the current state
-    virtual void ForceUpdate() {}
+    virtual void ForceUpdate() {
+        return;
+    }
 
     // Sets the function to be triggered when input changes
     void SetCallback(InputCallback callback_) {
@@ -247,7 +251,7 @@ public:
     }
 
     // Triggers the function set in the callback
-    void TriggerOnChange(const CallbackStatus& status) {
+    void TriggerOnChange(CallbackStatus status) {
         if (callback.on_change) {
             callback.on_change(status);
         }
@@ -262,9 +266,11 @@ class OutputDevice {
 public:
     virtual ~OutputDevice() = default;
 
-    virtual void SetLED([[maybe_unused]] const LedStatus& led_status) {}
+    virtual void SetLED([[maybe_unused]] LedStatus led_status) {
+        return;
+    }
 
-    virtual VibrationError SetVibration([[maybe_unused]] const VibrationStatus& vibration_status) {
+    virtual VibrationError SetVibration([[maybe_unused]] VibrationStatus vibration_status) {
         return VibrationError::NotSupported;
     }
 

src/common/logging/filter.cpp

@@ -114,7 +114,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Service, NGCT)                                                                             \
     SUB(Service, NIFM)                                                                             \
     SUB(Service, NIM)                                                                              \
-    SUB(Service, NOTIF)                                                                            \
     SUB(Service, NPNS)                                                                             \
     SUB(Service, NS)                                                                               \
     SUB(Service, NVDRV)                                                                            \

src/common/logging/types.h

@@ -82,7 +82,6 @@ enum class Class : u8 {
     Service_NGCT,      ///< The NGCT (No Good Content for Terra) service
     Service_NIFM,      ///< The NIFM (Network interface) service
     Service_NIM,       ///< The NIM service
-    Service_NOTIF,     ///< The NOTIF (Notification) service
     Service_NPNS,      ///< The NPNS service
     Service_NS,        ///< The NS services
     Service_NVDRV,     ///< The NVDRV (Nvidia driver) service

src/common/x64/cpu_detect.cpp

@@ -71,6 +71,9 @@ static CPUCaps Detect() {
     else
         caps.manufacturer = Manufacturer::Unknown;
 
+    u32 family = {};
+    u32 model = {};
+
     __cpuid(cpu_id, 0x80000000);
 
     u32 max_ex_fn = cpu_id[0];
@@ -81,6 +84,15 @@ static CPUCaps Detect() {
     // Detect family and other miscellaneous features
     if (max_std_fn >= 1) {
         __cpuid(cpu_id, 0x00000001);
+        family = (cpu_id[0] >> 8) & 0xf;
+        model = (cpu_id[0] >> 4) & 0xf;
+        if (family == 0xf) {
+            family += (cpu_id[0] >> 20) & 0xff;
+        }
+        if (family >= 6) {
+            model += ((cpu_id[0] >> 16) & 0xf) << 4;
+        }
+
         if ((cpu_id[3] >> 25) & 1)
             caps.sse = true;
         if ((cpu_id[3] >> 26) & 1)

src/core/CMakeLists.txt

@@ -179,15 +179,12 @@ add_library(core STATIC
     hle/kernel/k_client_port.h
     hle/kernel/k_client_session.cpp
     hle/kernel/k_client_session.h
-    hle/kernel/k_code_memory.cpp
-    hle/kernel/k_code_memory.h
     hle/kernel/k_condition_variable.cpp
     hle/kernel/k_condition_variable.h
     hle/kernel/k_event.cpp
     hle/kernel/k_event.h
     hle/kernel/k_handle_table.cpp
     hle/kernel/k_handle_table.h
-    hle/kernel/k_light_condition_variable.cpp
     hle/kernel/k_light_condition_variable.h
     hle/kernel/k_light_lock.cpp
     hle/kernel/k_light_lock.h
@@ -240,7 +237,6 @@ add_library(core STATIC
     hle/kernel/k_system_control.h
     hle/kernel/k_thread.cpp
     hle/kernel/k_thread.h
-    hle/kernel/k_thread_queue.cpp
     hle/kernel/k_thread_queue.h
     hle/kernel/k_trace.h
     hle/kernel/k_transfer_memory.cpp
@@ -412,8 +408,6 @@ add_library(core STATIC
     hle/service/glue/glue.h
     hle/service/glue/glue_manager.cpp
     hle/service/glue/glue_manager.h
-    hle/service/glue/notif.cpp
-    hle/service/glue/notif.h
     hle/service/grc/grc.cpp
     hle/service/grc/grc.h
     hle/service/hid/hid.cpp

src/core/core.cpp

@@ -521,6 +521,12 @@ const ARM_Interface& System::CurrentArmInterface() const {
     return impl->kernel.CurrentPhysicalCore().ArmInterface();
 }
 
+std::size_t System::CurrentCoreIndex() const {
+    std::size_t core = impl->kernel.GetCurrentHostThreadID();
+    ASSERT(core < Core::Hardware::NUM_CPU_CORES);
+    return core;
+}
+
 Kernel::PhysicalCore& System::CurrentPhysicalCore() {
     return impl->kernel.CurrentPhysicalCore();
 }

src/core/core.h

@@ -208,6 +208,9 @@ public:
     /// Gets an ARM interface to the CPU core that is currently running
     [[nodiscard]] const ARM_Interface& CurrentArmInterface() const;
 
+    /// Gets the index of the currently running CPU core
+    [[nodiscard]] std::size_t CurrentCoreIndex() const;
+
     /// Gets the physical core for the CPU core that is currently running
     [[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore();
 

src/core/cpu_manager.cpp

@@ -117,18 +117,17 @@ void CpuManager::MultiCoreRunGuestLoop() {
             physical_core = &kernel.CurrentPhysicalCore();
         }
         system.ExitDynarmicProfile();
-        {
-            Kernel::KScopedDisableDispatch dd(kernel);
-            physical_core->ArmInterface().ClearExclusiveState();
-        }
+        physical_core->ArmInterface().ClearExclusiveState();
+        kernel.CurrentScheduler()->RescheduleCurrentCore();
     }
 }
 
 void CpuManager::MultiCoreRunIdleThread() {
     auto& kernel = system.Kernel();
     while (true) {
-        Kernel::KScopedDisableDispatch dd(kernel);
-        kernel.CurrentPhysicalCore().Idle();
+        auto& physical_core = kernel.CurrentPhysicalCore();
+        physical_core.Idle();
+        kernel.CurrentScheduler()->RescheduleCurrentCore();
     }
 }
 
@@ -136,12 +135,12 @@ void CpuManager::MultiCoreRunSuspendThread() {
     auto& kernel = system.Kernel();
     kernel.CurrentScheduler()->OnThreadStart();
     while (true) {
-        auto core = kernel.CurrentPhysicalCoreIndex();
+        auto core = kernel.GetCurrentHostThreadID();
         auto& scheduler = *kernel.CurrentScheduler();
         Kernel::KThread* current_thread = scheduler.GetCurrentThread();
         Common::Fiber::YieldTo(current_thread->GetHostContext(), *core_data[core].host_context);
         ASSERT(scheduler.ContextSwitchPending());
-        ASSERT(core == kernel.CurrentPhysicalCoreIndex());
+        ASSERT(core == kernel.GetCurrentHostThreadID());
         scheduler.RescheduleCurrentCore();
     }
 }
@@ -347,11 +346,15 @@ void CpuManager::RunThread(std::stop_token stop_token, std::size_t core) {
             sc_sync_first_use = false;
         }
 
-        // Emulation was stopped
-        if (stop_token.stop_requested()) {
+        // Abort if emulation was killed before the session really starts
+        if (!system.IsPoweredOn()) {
             return;
         }
 
+        if (stop_token.stop_requested()) {
+            break;
+        }
+
         auto current_thread = system.Kernel().CurrentScheduler()->GetCurrentThread();
         data.is_running = true;
         Common::Fiber::YieldTo(data.host_context, *current_thread->GetHostContext());

src/core/hid/emulated_console.cpp

@@ -66,10 +66,9 @@ void EmulatedConsole::ReloadInput() {
 
     motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
     if (motion_devices) {
-        motion_devices->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback) { SetMotion(callback); },
-        });
+        Common::Input::InputCallback motion_callback{
+            [this](Common::Input::CallbackStatus callback) { SetMotion(callback); }};
+        motion_devices->SetCallback(motion_callback);
     }
 
     // Unique index for identifying touch device source
@@ -79,12 +78,9 @@ void EmulatedConsole::ReloadInput() {
         if (!touch_device) {
             continue;
         }
-        touch_device->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetTouch(callback, index);
-                },
-        });
+        Common::Input::InputCallback touch_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }};
+        touch_device->SetCallback(touch_callback);
         index++;
     }
 }
@@ -131,7 +127,7 @@ void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
     ReloadInput();
 }
 
-void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
+void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
     std::lock_guard lock{mutex};
     auto& raw_status = console.motion_values.raw_status;
     auto& emulated = console.motion_values.emulated;
@@ -166,7 +162,8 @@ void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
     TriggerOnChange(ConsoleTriggerType::Motion);
 }
 
-void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index) {
+void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback,
+                               [[maybe_unused]] std::size_t index) {
     if (index >= console.touch_values.size()) {
         return;
     }

src/core/hid/emulated_console.h

@@ -155,14 +155,14 @@ private:
      * Updates the motion status of the console
      * @param callback A CallbackStatus containing gyro and accelerometer data
      */
-    void SetMotion(const Common::Input::CallbackStatus& callback);
+    void SetMotion(Common::Input::CallbackStatus callback);
 
     /**
      * Updates the touch status of the console
      * @param callback A CallbackStatus containing the touch position
      * @param index Finger ID to be updated
      */
-    void SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetTouch(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the console status

src/core/hid/emulated_controller.cpp

@@ -205,12 +205,11 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
-        button_devices[index]->SetCallback({
-            .on_change =
-                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
-                    SetButton(callback, index, uuid);
-                },
-        });
+        Common::Input::InputCallback button_callback{
+            [this, index, uuid](Common::Input::CallbackStatus callback) {
+                SetButton(callback, index, uuid);
+            }};
+        button_devices[index]->SetCallback(button_callback);
         button_devices[index]->ForceUpdate();
     }
 
@@ -219,12 +218,11 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
-        stick_devices[index]->SetCallback({
-            .on_change =
-                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
-                    SetStick(callback, index, uuid);
-                },
-        });
+        Common::Input::InputCallback stick_callback{
+            [this, index, uuid](Common::Input::CallbackStatus callback) {
+                SetStick(callback, index, uuid);
+            }};
+        stick_devices[index]->SetCallback(stick_callback);
         stick_devices[index]->ForceUpdate();
     }
 
@@ -233,12 +231,11 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
-        trigger_devices[index]->SetCallback({
-            .on_change =
-                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
-                    SetTrigger(callback, index, uuid);
-                },
-        });
+        Common::Input::InputCallback trigger_callback{
+            [this, index, uuid](Common::Input::CallbackStatus callback) {
+                SetTrigger(callback, index, uuid);
+            }};
+        trigger_devices[index]->SetCallback(trigger_callback);
         trigger_devices[index]->ForceUpdate();
     }
 
@@ -246,12 +243,9 @@ void EmulatedController::ReloadInput() {
         if (!battery_devices[index]) {
             continue;
         }
-        battery_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetBattery(callback, index);
-                },
-        });
+        Common::Input::InputCallback battery_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetBattery(callback, index); }};
+        battery_devices[index]->SetCallback(battery_callback);
         battery_devices[index]->ForceUpdate();
     }
 
@@ -259,12 +253,9 @@ void EmulatedController::ReloadInput() {
         if (!motion_devices[index]) {
             continue;
         }
-        motion_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetMotion(callback, index);
-                },
-        });
+        Common::Input::InputCallback motion_callback{
+            [this, index](Common::Input::CallbackStatus callback) { SetMotion(callback, index); }};
+        motion_devices[index]->SetCallback(motion_callback);
         motion_devices[index]->ForceUpdate();
     }
 
@@ -276,24 +267,22 @@ void EmulatedController::ReloadInput() {
         if (!tas_button_devices[index]) {
             continue;
         }
-        tas_button_devices[index]->SetCallback({
-            .on_change =
-                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
-                    SetButton(callback, index, tas_uuid);
-                },
-        });
+        Common::Input::InputCallback button_callback{
+            [this, index, tas_uuid](Common::Input::CallbackStatus callback) {
+                SetButton(callback, index, tas_uuid);
+            }};
+        tas_button_devices[index]->SetCallback(button_callback);
     }
 
     for (std::size_t index = 0; index < tas_stick_devices.size(); ++index) {
         if (!tas_stick_devices[index]) {
             continue;
         }
-        tas_stick_devices[index]->SetCallback({
-            .on_change =
-                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
-                    SetStick(callback, index, tas_uuid);
-                },
-        });
+        Common::Input::InputCallback stick_callback{
+            [this, index, tas_uuid](Common::Input::CallbackStatus callback) {
+                SetStick(callback, index, tas_uuid);
+            }};
+        tas_stick_devices[index]->SetCallback(stick_callback);
     }
 }
 
@@ -451,7 +440,7 @@ void EmulatedController::SetButtonParam(std::size_t index, Common::ParamPackage
     if (index >= button_params.size()) {
         return;
     }
-    button_params[index] = std::move(param);
+    button_params[index] = param;
     ReloadInput();
 }
 
@@ -459,7 +448,7 @@ void EmulatedController::SetStickParam(std::size_t index, Common::ParamPackage p
     if (index >= stick_params.size()) {
         return;
     }
-    stick_params[index] = std::move(param);
+    stick_params[index] = param;
     ReloadInput();
 }
 
@@ -467,11 +456,11 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
     if (index >= motion_params.size()) {
         return;
     }
-    motion_params[index] = std::move(param);
+    motion_params[index] = param;
     ReloadInput();
 }
 
-void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
+void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::size_t index,
                                    Common::UUID uuid) {
     if (index >= controller.button_values.size()) {
         return;
@@ -611,7 +600,7 @@ void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback
     TriggerOnChange(ControllerTriggerType::Button, true);
 }
 
-void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
+void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::size_t index,
                                   Common::UUID uuid) {
     if (index >= controller.stick_values.size()) {
         return;
@@ -661,8 +650,8 @@ void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback,
     TriggerOnChange(ControllerTriggerType::Stick, true);
 }
 
-void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
-                                    std::size_t index, Common::UUID uuid) {
+void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std::size_t index,
+                                    Common::UUID uuid) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
@@ -670,7 +659,7 @@ void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callbac
     const auto trigger_value = TransformToTrigger(callback);
 
     // Only read trigger values that have the same uuid or are pressed once
-    if (controller.trigger_values[index].uuid != uuid) {
+    if (controller.stick_values[index].uuid != uuid) {
         if (!trigger_value.pressed.value) {
             return;
         }
@@ -686,7 +675,7 @@ void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callbac
         return;
     }
 
-    const auto& trigger = controller.trigger_values[index];
+    const auto trigger = controller.trigger_values[index];
 
     switch (index) {
     case Settings::NativeTrigger::LTrigger:
@@ -703,8 +692,7 @@ void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callbac
     TriggerOnChange(ControllerTriggerType::Trigger, true);
 }
 
-void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback,
-                                   std::size_t index) {
+void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.motion_values.size()) {
         return;
     }
@@ -742,8 +730,7 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
     TriggerOnChange(ControllerTriggerType::Motion, true);
 }
 
-void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
-                                    std::size_t index) {
+void EmulatedController::SetBattery(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= controller.battery_values.size()) {
         return;
     }
@@ -1123,7 +1110,7 @@ void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npa
 
 int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) {
     std::lock_guard lock{mutex};
-    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
+    callback_list.insert_or_assign(last_callback_key, update_callback);
     return last_callback_key++;
 }
 

src/core/hid/emulated_controller.h

@@ -328,38 +328,35 @@ private:
      * @param callback A CallbackStatus containing the button status
      * @param index Button ID of the to be updated
      */
-    void SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
-                   Common::UUID uuid);
+    void SetButton(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
 
     /**
      * Updates the analog stick status of the controller
      * @param callback A CallbackStatus containing the analog stick status
      * @param index stick ID of the to be updated
      */
-    void SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
-                  Common::UUID uuid);
+    void SetStick(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
 
     /**
      * Updates the trigger status of the controller
      * @param callback A CallbackStatus containing the trigger status
      * @param index trigger ID of the to be updated
      */
-    void SetTrigger(const Common::Input::CallbackStatus& callback, std::size_t index,
-                    Common::UUID uuid);
+    void SetTrigger(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
 
     /**
      * Updates the motion status of the controller
      * @param callback A CallbackStatus containing gyro and accelerometer data
      * @param index motion ID of the to be updated
      */
-    void SetMotion(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetMotion(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the battery status of the controller
      * @param callback A CallbackStatus containing the battery status
      * @param index Button ID of the to be updated
      */
-    void SetBattery(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetBattery(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Triggers a callback that something has changed on the controller status

src/core/hid/emulated_devices.cpp

@@ -70,55 +70,50 @@ void EmulatedDevices::ReloadInput() {
         if (!mouse_button_devices[index]) {
             continue;
         }
-        mouse_button_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetMouseButton(callback, index);
-                },
-        });
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetMouseButton(callback, index);
+            }};
+        mouse_button_devices[index]->SetCallback(button_callback);
     }
 
     for (std::size_t index = 0; index < mouse_analog_devices.size(); ++index) {
         if (!mouse_analog_devices[index]) {
             continue;
         }
-        mouse_analog_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetMouseAnalog(callback, index);
-                },
-        });
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetMouseAnalog(callback, index);
+            }};
+        mouse_analog_devices[index]->SetCallback(button_callback);
     }
 
     if (mouse_stick_device) {
-        mouse_stick_device->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback) { SetMouseStick(callback); },
-        });
+        Common::Input::InputCallback button_callback{
+            [this](Common::Input::CallbackStatus callback) { SetMouseStick(callback); }};
+        mouse_stick_device->SetCallback(button_callback);
     }
 
     for (std::size_t index = 0; index < keyboard_devices.size(); ++index) {
         if (!keyboard_devices[index]) {
             continue;
         }
-        keyboard_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetKeyboardButton(callback, index);
-                },
-        });
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardButton(callback, index);
+            }};
+        keyboard_devices[index]->SetCallback(button_callback);
     }
 
     for (std::size_t index = 0; index < keyboard_modifier_devices.size(); ++index) {
         if (!keyboard_modifier_devices[index]) {
             continue;
         }
-        keyboard_modifier_devices[index]->SetCallback({
-            .on_change =
-                [this, index](const Common::Input::CallbackStatus& callback) {
-                    SetKeyboardModifier(callback, index);
-                },
-        });
+        Common::Input::InputCallback button_callback{
+            [this, index](Common::Input::CallbackStatus callback) {
+                SetKeyboardModifier(callback, index);
+            }};
+        keyboard_modifier_devices[index]->SetCallback(button_callback);
     }
 }
 
@@ -164,8 +159,7 @@ void EmulatedDevices::RestoreConfig() {
     ReloadFromSettings();
 }
 
-void EmulatedDevices::SetKeyboardButton(const Common::Input::CallbackStatus& callback,
-                                        std::size_t index) {
+void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.keyboard_values.size()) {
         return;
     }
@@ -222,7 +216,7 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     }
 }
 
-void EmulatedDevices::SetKeyboardModifier(const Common::Input::CallbackStatus& callback,
+void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback,
                                           std::size_t index) {
     if (index >= device_status.keyboard_moddifier_values.size()) {
         return;
@@ -292,8 +286,7 @@ void EmulatedDevices::SetKeyboardModifier(const Common::Input::CallbackStatus& c
     TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
 }
 
-void EmulatedDevices::SetMouseButton(const Common::Input::CallbackStatus& callback,
-                                     std::size_t index) {
+void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.mouse_button_values.size()) {
         return;
     }
@@ -354,8 +347,7 @@ void EmulatedDevices::SetMouseButton(const Common::Input::CallbackStatus& callba
     TriggerOnChange(DeviceTriggerType::Mouse);
 }
 
-void EmulatedDevices::SetMouseAnalog(const Common::Input::CallbackStatus& callback,
-                                     std::size_t index) {
+void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index) {
     if (index >= device_status.mouse_analog_values.size()) {
         return;
     }
@@ -382,7 +374,7 @@ void EmulatedDevices::SetMouseAnalog(const Common::Input::CallbackStatus& callba
     TriggerOnChange(DeviceTriggerType::Mouse);
 }
 
-void EmulatedDevices::SetMouseStick(const Common::Input::CallbackStatus& callback) {
+void EmulatedDevices::SetMouseStick(Common::Input::CallbackStatus callback) {
     std::lock_guard lock{mutex};
     const auto touch_value = TransformToTouch(callback);
 
@@ -443,7 +435,7 @@ void EmulatedDevices::TriggerOnChange(DeviceTriggerType type) {
 
 int EmulatedDevices::SetCallback(InterfaceUpdateCallback update_callback) {
     std::lock_guard lock{mutex};
-    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
+    callback_list.insert_or_assign(last_callback_key, update_callback);
     return last_callback_key++;
 }
 

src/core/hid/emulated_devices.h

@@ -156,34 +156,35 @@ private:
      * @param callback A CallbackStatus containing the key status
      * @param index key ID to be updated
      */
-    void SetKeyboardButton(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the keyboard status of the keyboard device
      * @param callback A CallbackStatus containing the modifier key status
      * @param index modifier key ID to be updated
      */
-    void SetKeyboardModifier(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetKeyboardModifier(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the mouse button status of the mouse device
      * @param callback A CallbackStatus containing the button status
      * @param index Button ID to be updated
      */
-    void SetMouseButton(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the mouse wheel status of the mouse device
      * @param callback A CallbackStatus containing the wheel status
      * @param index wheel ID to be updated
      */
-    void SetMouseAnalog(const Common::Input::CallbackStatus& callback, std::size_t index);
+    void SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index);
 
     /**
      * Updates the mouse position status of the mouse device
      * @param callback A CallbackStatus containing the position status
+     * @param index stick ID to be updated
      */
-    void SetMouseStick(const Common::Input::CallbackStatus& callback);
+    void SetMouseStick(Common::Input::CallbackStatus callback);
 
     /**
      * Triggers a callback that something has changed on the device status

src/core/hid/hid_core.cpp

@@ -145,16 +145,6 @@ NpadIdType HIDCore::GetFirstNpadId() const {
     return NpadIdType::Player1;
 }
 
-NpadIdType HIDCore::GetFirstDisconnectedNpadId() const {
-    for (std::size_t player_index = 0; player_index < available_controllers; ++player_index) {
-        const auto* const controller = GetEmulatedControllerByIndex(player_index);
-        if (!controller->IsConnected()) {
-            return controller->GetNpadIdType();
-        }
-    }
-    return NpadIdType::Player1;
-}
-
 void HIDCore::EnableAllControllerConfiguration() {
     player_1->EnableConfiguration();
     player_2->EnableConfiguration();

src/core/hid/hid_core.h

@@ -45,9 +45,6 @@ public:
     /// Returns the first connected npad id
     NpadIdType GetFirstNpadId() const;
 
-    /// Returns the first disconnected npad id
-    NpadIdType GetFirstDisconnectedNpadId() const;
-
     /// Sets all emulated controllers into configuring mode.
     void EnableAllControllerConfiguration();
 

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

@@ -9,7 +9,6 @@
 #include "core/core.h"
 #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_event.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
@@ -33,7 +32,6 @@ namespace Kernel::Init {
     HANDLER(KPort, (SLAB_COUNT(KPort)), ##__VA_ARGS__)                                             \
     HANDLER(KSharedMemory, (SLAB_COUNT(KSharedMemory)), ##__VA_ARGS__)                             \
     HANDLER(KTransferMemory, (SLAB_COUNT(KTransferMemory)), ##__VA_ARGS__)                         \
-    HANDLER(KCodeMemory, (SLAB_COUNT(KCodeMemory)), ##__VA_ARGS__)                                 \
     HANDLER(KSession, (SLAB_COUNT(KSession)), ##__VA_ARGS__)                                       \
     HANDLER(KResourceLimit, (SLAB_COUNT(KResourceLimit)), ##__VA_ARGS__)
 

src/core/hle/kernel/k_address_arbiter.cpp

@@ -8,7 +8,6 @@
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
 #include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/time_manager.h"
@@ -29,7 +28,7 @@ bool ReadFromUser(Core::System& system, s32* out, VAddr address) {
 
 bool DecrementIfLessThan(Core::System& system, s32* out, VAddr address, s32 value) {
     auto& monitor = system.Monitor();
-    const auto current_core = system.Kernel().CurrentPhysicalCoreIndex();
+    const auto current_core = system.CurrentCoreIndex();
 
     // TODO(bunnei): We should disable interrupts here via KScopedInterruptDisable.
     // TODO(bunnei): We should call CanAccessAtomic(..) here.
@@ -59,7 +58,7 @@ bool DecrementIfLessThan(Core::System& system, s32* out, VAddr address, s32 valu
 
 bool UpdateIfEqual(Core::System& system, s32* out, VAddr address, s32 value, s32 new_value) {
     auto& monitor = system.Monitor();
-    const auto current_core = system.Kernel().CurrentPhysicalCoreIndex();
+    const auto current_core = system.CurrentCoreIndex();
 
     // TODO(bunnei): We should disable interrupts here via KScopedInterruptDisable.
     // TODO(bunnei): We should call CanAccessAtomic(..) here.
@@ -86,27 +85,6 @@ bool UpdateIfEqual(Core::System& system, s32* out, VAddr address, s32 value, s32
     return true;
 }
 
-class ThreadQueueImplForKAddressArbiter final : public KThreadQueue {
-public:
-    explicit ThreadQueueImplForKAddressArbiter(KernelCore& kernel_, KAddressArbiter::ThreadTree* t)
-        : KThreadQueue(kernel_), m_tree(t) {}
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // If the thread is waiting on an address arbiter, remove it from the tree.
-        if (waiting_thread->IsWaitingForAddressArbiter()) {
-            m_tree->erase(m_tree->iterator_to(*waiting_thread));
-            waiting_thread->ClearAddressArbiter();
-        }
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-
-private:
-    KAddressArbiter::ThreadTree* m_tree;
-};
-
 } // namespace
 
 ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
@@ -118,14 +96,14 @@ ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
         auto it = thread_tree.nfind_light({addr, -1});
         while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
                (it->GetAddressArbiterKey() == addr)) {
-            // End the thread's wait.
             KThread* target_thread = std::addressof(*it);
-            target_thread->EndWait(ResultSuccess);
+            target_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             ASSERT(target_thread->IsWaitingForAddressArbiter());
-            target_thread->ClearAddressArbiter();
+            target_thread->Wakeup();
 
             it = thread_tree.erase(it);
+            target_thread->ClearAddressArbiter();
             ++num_waiters;
         }
     }
@@ -151,14 +129,14 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32
         auto it = thread_tree.nfind_light({addr, -1});
         while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
                (it->GetAddressArbiterKey() == addr)) {
-            // End the thread's wait.
             KThread* target_thread = std::addressof(*it);
-            target_thread->EndWait(ResultSuccess);
+            target_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             ASSERT(target_thread->IsWaitingForAddressArbiter());
-            target_thread->ClearAddressArbiter();
+            target_thread->Wakeup();
 
             it = thread_tree.erase(it);
+            target_thread->ClearAddressArbiter();
             ++num_waiters;
         }
     }
@@ -219,14 +197,14 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
 
         while ((it != thread_tree.end()) && (count <= 0 || num_waiters < count) &&
                (it->GetAddressArbiterKey() == addr)) {
-            // End the thread's wait.
             KThread* target_thread = std::addressof(*it);
-            target_thread->EndWait(ResultSuccess);
+            target_thread->SetSyncedObject(nullptr, ResultSuccess);
 
             ASSERT(target_thread->IsWaitingForAddressArbiter());
-            target_thread->ClearAddressArbiter();
+            target_thread->Wakeup();
 
             it = thread_tree.erase(it);
+            target_thread->ClearAddressArbiter();
             ++num_waiters;
         }
     }
@@ -236,7 +214,6 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
 ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout) {
     // Prepare to wait.
     KThread* cur_thread = kernel.CurrentScheduler()->GetCurrentThread();
-    ThreadQueueImplForKAddressArbiter wait_queue(kernel, std::addressof(thread_tree));
 
     {
         KScopedSchedulerLockAndSleep slp{kernel, cur_thread, timeout};
@@ -247,6 +224,9 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
             return ResultTerminationRequested;
         }
 
+        // Set the synced object.
+        cur_thread->SetSyncedObject(nullptr, ResultTimedOut);
+
         // Read the value from userspace.
         s32 user_value{};
         bool succeeded{};
@@ -276,20 +256,31 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
         // Set the arbiter.
         cur_thread->SetAddressArbiter(&thread_tree, addr);
         thread_tree.insert(*cur_thread);
-
-        // Wait for the thread to finish.
-        cur_thread->BeginWait(std::addressof(wait_queue));
+        cur_thread->SetState(ThreadState::Waiting);
         cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Arbitration);
     }
 
+    // Cancel the timer wait.
+    kernel.TimeManager().UnscheduleTimeEvent(cur_thread);
+
+    // Remove from the address arbiter.
+    {
+        KScopedSchedulerLock sl(kernel);
+
+        if (cur_thread->IsWaitingForAddressArbiter()) {
+            thread_tree.erase(thread_tree.iterator_to(*cur_thread));
+            cur_thread->ClearAddressArbiter();
+        }
+    }
+
     // Get the result.
-    return cur_thread->GetWaitResult();
+    KSynchronizationObject* dummy{};
+    return cur_thread->GetWaitResult(&dummy);
 }
 
 ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
     // Prepare to wait.
     KThread* cur_thread = kernel.CurrentScheduler()->GetCurrentThread();
-    ThreadQueueImplForKAddressArbiter wait_queue(kernel, std::addressof(thread_tree));
 
     {
         KScopedSchedulerLockAndSleep slp{kernel, cur_thread, timeout};
@@ -300,6 +291,9 @@ ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
             return ResultTerminationRequested;
         }
 
+        // Set the synced object.
+        cur_thread->SetSyncedObject(nullptr, ResultTimedOut);
+
         // Read the value from userspace.
         s32 user_value{};
         if (!ReadFromUser(system, &user_value, addr)) {
@@ -322,14 +316,26 @@ ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
         // Set the arbiter.
         cur_thread->SetAddressArbiter(&thread_tree, addr);
         thread_tree.insert(*cur_thread);
-
-        // Wait for the thread to finish.
-        cur_thread->BeginWait(std::addressof(wait_queue));
+        cur_thread->SetState(ThreadState::Waiting);
         cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Arbitration);
     }
 
+    // Cancel the timer wait.
+    kernel.TimeManager().UnscheduleTimeEvent(cur_thread);
+
+    // Remove from the address arbiter.
+    {
+        KScopedSchedulerLock sl(kernel);
+
+        if (cur_thread->IsWaitingForAddressArbiter()) {
+            thread_tree.erase(thread_tree.iterator_to(*cur_thread));
+            cur_thread->ClearAddressArbiter();
+        }
+    }
+
     // Get the result.
-    return cur_thread->GetWaitResult();
+    KSynchronizationObject* dummy{};
+    return cur_thread->GetWaitResult(&dummy);
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_auto_object.h

@@ -170,10 +170,6 @@ public:
         }
     }
 
-    const std::string& GetName() const {
-        return name;
-    }
-
 private:
     void RegisterWithKernel();
     void UnregisterWithKernel();

src/core/hle/kernel/k_class_token.cpp

@@ -6,7 +6,6 @@
 #include "core/hle/kernel/k_class_token.h"
 #include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_client_session.h"
-#include "core/hle/kernel/k_code_memory.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_port.h"
 #include "core/hle/kernel/k_process.h"
@@ -49,7 +48,7 @@ static_assert(ClassToken<KWritableEvent> == 0b10001001'00000000);
 static_assert(ClassToken<KTransferMemory> == 0b10010001'00000000);
 // static_assert(ClassToken<KDeviceAddressSpace> == 0b01100001'00000000);
 // static_assert(ClassToken<KSessionRequest> == 0b10100001'00000000);
-static_assert(ClassToken<KCodeMemory> == 0b11000001'00000000);
+// static_assert(ClassToken<KCodeMemory> == 0b11000001'00000000);
 
 // Ensure that the token hierarchy is correct.
 
@@ -80,7 +79,7 @@ static_assert(ClassToken<KWritableEvent> == ((0b10001001 << 8) | ClassToken<KAut
 static_assert(ClassToken<KTransferMemory> == ((0b10010001 << 8) | ClassToken<KAutoObject>));
 // static_assert(ClassToken<KDeviceAddressSpace> == ((0b01100001 << 8) | ClassToken<KAutoObject>));
 // static_assert(ClassToken<KSessionRequest> == ((0b10100001 << 8) | ClassToken<KAutoObject>));
-static_assert(ClassToken<KCodeMemory> == ((0b11000001 << 8) | ClassToken<KAutoObject>));
+// static_assert(ClassToken<KCodeMemory> == ((0b11000001 << 8) | ClassToken<KAutoObject>));
 
 // Ensure that the token hierarchy reflects the class hierarchy.
 

src/core/hle/kernel/k_code_memory.cpp

@@ -1,146 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/common_types.h"
-#include "core/device_memory.h"
-#include "core/hle/kernel/k_auto_object.h"
-#include "core/hle/kernel/k_code_memory.h"
-#include "core/hle/kernel/k_light_lock.h"
-#include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_page_linked_list.h"
-#include "core/hle/kernel/k_page_table.h"
-#include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/slab_helpers.h"
-#include "core/hle/kernel/svc_types.h"
-#include "core/hle/result.h"
-
-namespace Kernel {
-
-KCodeMemory::KCodeMemory(KernelCore& kernel_)
-    : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_lock(kernel_) {}
-
-ResultCode KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {
-    // Set members.
-    m_owner = kernel.CurrentProcess();
-
-    // Get the owner page table.
-    auto& page_table = m_owner->PageTable();
-
-    // Construct the page group.
-    KMemoryInfo kBlockInfo = page_table.QueryInfo(addr);
-    m_page_group = KPageLinkedList(kBlockInfo.GetAddress(), kBlockInfo.GetNumPages());
-
-    // Lock the memory.
-    R_TRY(page_table.LockForCodeMemory(addr, size))
-
-    // Clear the memory.
-    for (const auto& block : m_page_group.Nodes()) {
-        std::memset(device_memory.GetPointer(block.GetAddress()), 0xFF, block.GetSize());
-    }
-
-    // Set remaining tracking members.
-    m_address = addr;
-    m_is_initialized = true;
-    m_is_owner_mapped = false;
-    m_is_mapped = false;
-
-    // We succeeded.
-    return ResultSuccess;
-}
-
-void KCodeMemory::Finalize() {
-    // Unlock.
-    if (!m_is_mapped && !m_is_owner_mapped) {
-        const size_t size = m_page_group.GetNumPages() * PageSize;
-        m_owner->PageTable().UnlockForCodeMemory(m_address, size);
-    }
-}
-
-ResultCode KCodeMemory::Map(VAddr address, size_t size) {
-    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
-
-    // Lock ourselves.
-    KScopedLightLock lk(m_lock);
-
-    // Ensure we're not already mapped.
-    R_UNLESS(!m_is_mapped, ResultInvalidState);
-
-    // Map the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().MapPages(
-        address, m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));
-
-    // Mark ourselves as mapped.
-    m_is_mapped = true;
-
-    return ResultSuccess;
-}
-
-ResultCode KCodeMemory::Unmap(VAddr address, size_t size) {
-    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
-
-    // Lock ourselves.
-    KScopedLightLock lk(m_lock);
-
-    // Unmap the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPages(address, m_page_group,
-                                                          KMemoryState::CodeOut));
-
-    // Mark ourselves as unmapped.
-    m_is_mapped = false;
-
-    return ResultSuccess;
-}
-
-ResultCode KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
-    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
-
-    // Lock ourselves.
-    KScopedLightLock lk(m_lock);
-
-    // Ensure we're not already mapped.
-    R_UNLESS(!m_is_owner_mapped, ResultInvalidState);
-
-    // Convert the memory permission.
-    KMemoryPermission k_perm{};
-    switch (perm) {
-    case Svc::MemoryPermission::Read:
-        k_perm = KMemoryPermission::UserRead;
-        break;
-    case Svc::MemoryPermission::ReadExecute:
-        k_perm = KMemoryPermission::UserReadExecute;
-        break;
-    default:
-        break;
-    }
-
-    // Map the memory.
-    R_TRY(
-        m_owner->PageTable().MapPages(address, m_page_group, KMemoryState::GeneratedCode, k_perm));
-
-    // Mark ourselves as mapped.
-    m_is_owner_mapped = true;
-
-    return ResultSuccess;
-}
-
-ResultCode KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
-    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
-
-    // Lock ourselves.
-    KScopedLightLock lk(m_lock);
-
-    // Unmap the memory.
-    R_TRY(m_owner->PageTable().UnmapPages(address, m_page_group, KMemoryState::GeneratedCode));
-
-    // Mark ourselves as unmapped.
-    m_is_owner_mapped = false;
-
-    return ResultSuccess;
-}
-
-} // namespace Kernel

src/core/hle/kernel/k_code_memory.h

@@ -1,66 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "core/device_memory.h"
-#include "core/hle/kernel/k_auto_object.h"
-#include "core/hle/kernel/k_light_lock.h"
-#include "core/hle/kernel/k_page_linked_list.h"
-#include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/slab_helpers.h"
-#include "core/hle/kernel/svc_types.h"
-#include "core/hle/result.h"
-
-namespace Kernel {
-
-enum class CodeMemoryOperation : u32 {
-    Map = 0,
-    MapToOwner = 1,
-    Unmap = 2,
-    UnmapFromOwner = 3,
-};
-
-class KCodeMemory final
-    : public KAutoObjectWithSlabHeapAndContainer<KCodeMemory, KAutoObjectWithList> {
-    KERNEL_AUTOOBJECT_TRAITS(KCodeMemory, KAutoObject);
-
-public:
-    explicit KCodeMemory(KernelCore& kernel_);
-
-    ResultCode Initialize(Core::DeviceMemory& device_memory, VAddr address, size_t size);
-    void Finalize();
-
-    ResultCode Map(VAddr address, size_t size);
-    ResultCode Unmap(VAddr address, size_t size);
-    ResultCode MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm);
-    ResultCode UnmapFromOwner(VAddr address, size_t size);
-
-    bool IsInitialized() const {
-        return m_is_initialized;
-    }
-    static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
-
-    KProcess* GetOwner() const {
-        return m_owner;
-    }
-    VAddr GetSourceAddress() const {
-        return m_address;
-    }
-    size_t GetSize() const {
-        return m_is_initialized ? m_page_group.GetNumPages() * PageSize : 0;
-    }
-
-private:
-    KPageLinkedList m_page_group{};
-    KProcess* m_owner{};
-    VAddr m_address{};
-    KLightLock m_lock;
-    bool m_is_initialized{};
-    bool m_is_owner_mapped{};
-    bool m_is_mapped{};
-};
-
-} // namespace Kernel

src/core/hle/kernel/k_condition_variable.cpp

@@ -11,7 +11,6 @@
 #include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
 #include "core/hle/kernel/k_synchronization_object.h"
 #include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_common.h"
 #include "core/hle/kernel/svc_results.h"
@@ -34,7 +33,7 @@ bool WriteToUser(Core::System& system, VAddr address, const u32* p) {
 bool UpdateLockAtomic(Core::System& system, u32* out, VAddr address, u32 if_zero,
                       u32 new_orr_mask) {
     auto& monitor = system.Monitor();
-    const auto current_core = system.Kernel().CurrentPhysicalCoreIndex();
+    const auto current_core = system.CurrentCoreIndex();
 
     // Load the value from the address.
     const auto expected = monitor.ExclusiveRead32(current_core, address);
@@ -58,48 +57,6 @@ bool UpdateLockAtomic(Core::System& system, u32* out, VAddr address, u32 if_zero
     return true;
 }
 
-class ThreadQueueImplForKConditionVariableWaitForAddress final : public KThreadQueue {
-public:
-    explicit ThreadQueueImplForKConditionVariableWaitForAddress(KernelCore& kernel_)
-        : KThreadQueue(kernel_) {}
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // Remove the thread as a waiter from its owner.
-        waiting_thread->GetLockOwner()->RemoveWaiter(waiting_thread);
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-};
-
-class ThreadQueueImplForKConditionVariableWaitConditionVariable final : public KThreadQueue {
-private:
-    KConditionVariable::ThreadTree* m_tree;
-
-public:
-    explicit ThreadQueueImplForKConditionVariableWaitConditionVariable(
-        KernelCore& kernel_, KConditionVariable::ThreadTree* t)
-        : KThreadQueue(kernel_), m_tree(t) {}
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // Remove the thread as a waiter from its owner.
-        if (KThread* owner = waiting_thread->GetLockOwner(); owner != nullptr) {
-            owner->RemoveWaiter(waiting_thread);
-        }
-
-        // If the thread is waiting on a condvar, remove it from the tree.
-        if (waiting_thread->IsWaitingForConditionVariable()) {
-            m_tree->erase(m_tree->iterator_to(*waiting_thread));
-            waiting_thread->ClearConditionVariable();
-        }
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-};
-
 } // namespace
 
 KConditionVariable::KConditionVariable(Core::System& system_)
@@ -121,77 +78,84 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
 
         // Determine the next tag.
         u32 next_value{};
-        if (next_owner_thread != nullptr) {
+        if (next_owner_thread) {
             next_value = next_owner_thread->GetAddressKeyValue();
             if (num_waiters > 1) {
                 next_value |= Svc::HandleWaitMask;
             }
 
-            // Write the value to userspace.
-            ResultCode result{ResultSuccess};
-            if (WriteToUser(system, addr, std::addressof(next_value))) [[likely]] {
-                result = ResultSuccess;
-            } else {
-                result = ResultInvalidCurrentMemory;
+            next_owner_thread->SetSyncedObject(nullptr, ResultSuccess);
+            next_owner_thread->Wakeup();
+        }
+
+        // Write the value to userspace.
+        if (!WriteToUser(system, addr, std::addressof(next_value))) {
+            if (next_owner_thread) {
+                next_owner_thread->SetSyncedObject(nullptr, ResultInvalidCurrentMemory);
             }
 
-            // Signal the next owner thread.
-            next_owner_thread->EndWait(result);
-            return result;
-        } else {
-            // Just write the value to userspace.
-            R_UNLESS(WriteToUser(system, addr, std::addressof(next_value)),
-                     ResultInvalidCurrentMemory);
-
-            return ResultSuccess;
+            return ResultInvalidCurrentMemory;
         }
     }
+
+    return ResultSuccess;
 }
 
 ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 value) {
     KThread* cur_thread = kernel.CurrentScheduler()->GetCurrentThread();
-    ThreadQueueImplForKConditionVariableWaitForAddress wait_queue(kernel);
 
     // Wait for the address.
-    KThread* owner_thread{};
     {
-        KScopedSchedulerLock sl(kernel);
+        KScopedAutoObject<KThread> owner_thread;
+        ASSERT(owner_thread.IsNull());
+        {
+            KScopedSchedulerLock sl(kernel);
+            cur_thread->SetSyncedObject(nullptr, ResultSuccess);
 
-        // Check if the thread should terminate.
-        R_UNLESS(!cur_thread->IsTerminationRequested(), ResultTerminationRequested);
+            // Check if the thread should terminate.
+            R_UNLESS(!cur_thread->IsTerminationRequested(), ResultTerminationRequested);
 
-        // Read the tag from userspace.
-        u32 test_tag{};
-        R_UNLESS(ReadFromUser(system, std::addressof(test_tag), addr), ResultInvalidCurrentMemory);
+            {
+                // Read the tag from userspace.
+                u32 test_tag{};
+                R_UNLESS(ReadFromUser(system, std::addressof(test_tag), addr),
+                         ResultInvalidCurrentMemory);
 
-        // If the tag isn't the handle (with wait mask), we're done.
-        R_SUCCEED_IF(test_tag != (handle | Svc::HandleWaitMask));
+                // If the tag isn't the handle (with wait mask), we're done.
+                R_UNLESS(test_tag == (handle | Svc::HandleWaitMask), ResultSuccess);
 
-        // Get the lock owner thread.
-        owner_thread = kernel.CurrentProcess()
-                           ->GetHandleTable()
-                           .GetObjectWithoutPseudoHandle<KThread>(handle)
-                           .ReleasePointerUnsafe();
-        R_UNLESS(owner_thread != nullptr, ResultInvalidHandle);
+                // Get the lock owner thread.
+                owner_thread =
+                    kernel.CurrentProcess()->GetHandleTable().GetObjectWithoutPseudoHandle<KThread>(
+                        handle);
+                R_UNLESS(owner_thread.IsNotNull(), ResultInvalidHandle);
 
-        // Update the lock.
-        cur_thread->SetAddressKey(addr, value);
-        owner_thread->AddWaiter(cur_thread);
-
-        // Begin waiting.
-        cur_thread->BeginWait(std::addressof(wait_queue));
-        cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::ConditionVar);
-        cur_thread->SetMutexWaitAddressForDebugging(addr);
+                // Update the lock.
+                cur_thread->SetAddressKey(addr, value);
+                owner_thread->AddWaiter(cur_thread);
+                cur_thread->SetState(ThreadState::Waiting);
+                cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::ConditionVar);
+                cur_thread->SetMutexWaitAddressForDebugging(addr);
+            }
+        }
+        ASSERT(owner_thread.IsNotNull());
     }
 
-    // Close our reference to the owner thread, now that the wait is over.
-    owner_thread->Close();
+    // Remove the thread as a waiter from the lock owner.
+    {
+        KScopedSchedulerLock sl(kernel);
+        KThread* owner_thread = cur_thread->GetLockOwner();
+        if (owner_thread != nullptr) {
+            owner_thread->RemoveWaiter(cur_thread);
+        }
+    }
 
     // Get the wait result.
-    return cur_thread->GetWaitResult();
+    KSynchronizationObject* dummy{};
+    return cur_thread->GetWaitResult(std::addressof(dummy));
 }
 
-void KConditionVariable::SignalImpl(KThread* thread) {
+KThread* KConditionVariable::SignalImpl(KThread* thread) {
     // Check pre-conditions.
     ASSERT(kernel.GlobalSchedulerContext().IsLocked());
 
@@ -205,16 +169,18 @@ void KConditionVariable::SignalImpl(KThread* thread) {
         // TODO(bunnei): We should disable interrupts here via KScopedInterruptDisable.
         // TODO(bunnei): We should call CanAccessAtomic(..) here.
         can_access = true;
-        if (can_access) [[likely]] {
+        if (can_access) {
             UpdateLockAtomic(system, std::addressof(prev_tag), address, own_tag,
                              Svc::HandleWaitMask);
         }
     }
 
-    if (can_access) [[likely]] {
+    KThread* thread_to_close = nullptr;
+    if (can_access) {
         if (prev_tag == Svc::InvalidHandle) {
             // If nobody held the lock previously, we're all good.
-            thread->EndWait(ResultSuccess);
+            thread->SetSyncedObject(nullptr, ResultSuccess);
+            thread->Wakeup();
         } else {
             // Get the previous owner.
             KThread* owner_thread = kernel.CurrentProcess()
@@ -223,22 +189,33 @@ void KConditionVariable::SignalImpl(KThread* thread) {
                                             static_cast<Handle>(prev_tag & ~Svc::HandleWaitMask))
                                         .ReleasePointerUnsafe();
 
-            if (owner_thread) [[likely]] {
+            if (owner_thread) {
                 // Add the thread as a waiter on the owner.
                 owner_thread->AddWaiter(thread);
-                owner_thread->Close();
+                thread_to_close = owner_thread;
             } else {
                 // The lock was tagged with a thread that doesn't exist.
-                thread->EndWait(ResultInvalidState);
+                thread->SetSyncedObject(nullptr, ResultInvalidState);
+                thread->Wakeup();
             }
         }
     } else {
         // If the address wasn't accessible, note so.
-        thread->EndWait(ResultInvalidCurrentMemory);
+        thread->SetSyncedObject(nullptr, ResultInvalidCurrentMemory);
+        thread->Wakeup();
     }
+
+    return thread_to_close;
 }
 
 void KConditionVariable::Signal(u64 cv_key, s32 count) {
+    // Prepare for signaling.
+    constexpr int MaxThreads = 16;
+
+    KLinkedList<KThread> thread_list{kernel};
+    std::array<KThread*, MaxThreads> thread_array;
+    s32 num_to_close{};
+
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -249,7 +226,14 @@ void KConditionVariable::Signal(u64 cv_key, s32 count) {
                (it->GetConditionVariableKey() == cv_key)) {
             KThread* target_thread = std::addressof(*it);
 
-            this->SignalImpl(target_thread);
+            if (KThread* thread = SignalImpl(target_thread); thread != nullptr) {
+                if (num_to_close < MaxThreads) {
+                    thread_array[num_to_close++] = thread;
+                } else {
+                    thread_list.push_back(*thread);
+                }
+            }
+
             it = thread_tree.erase(it);
             target_thread->ClearConditionVariable();
             ++num_waiters;
@@ -261,16 +245,27 @@ void KConditionVariable::Signal(u64 cv_key, s32 count) {
             WriteToUser(system, cv_key, std::addressof(has_waiter_flag));
         }
     }
+
+    // Close threads in the array.
+    for (auto i = 0; i < num_to_close; ++i) {
+        thread_array[i]->Close();
+    }
+
+    // Close threads in the list.
+    for (auto it = thread_list.begin(); it != thread_list.end(); it = thread_list.erase(it)) {
+        (*it).Close();
+    }
 }
 
 ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout) {
     // Prepare to wait.
-    KThread* cur_thread = GetCurrentThreadPointer(kernel);
-    ThreadQueueImplForKConditionVariableWaitConditionVariable wait_queue(
-        kernel, std::addressof(thread_tree));
+    KThread* cur_thread = kernel.CurrentScheduler()->GetCurrentThread();
 
     {
-        KScopedSchedulerLockAndSleep slp(kernel, cur_thread, timeout);
+        KScopedSchedulerLockAndSleep slp{kernel, cur_thread, timeout};
+
+        // Set the synced object.
+        cur_thread->SetSyncedObject(nullptr, ResultTimedOut);
 
         // Check that the thread isn't terminating.
         if (cur_thread->IsTerminationRequested()) {
@@ -295,7 +290,8 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
                 }
 
                 // Wake up the next owner.
-                next_owner_thread->EndWait(ResultSuccess);
+                next_owner_thread->SetSyncedObject(nullptr, ResultSuccess);
+                next_owner_thread->Wakeup();
             }
 
             // Write to the cv key.
@@ -312,21 +308,40 @@ ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout)
             }
         }
 
-        // If timeout is zero, time out.
-        R_UNLESS(timeout != 0, ResultTimedOut);
-
         // Update condition variable tracking.
-        cur_thread->SetConditionVariable(std::addressof(thread_tree), addr, key, value);
-        thread_tree.insert(*cur_thread);
+        {
+            cur_thread->SetConditionVariable(std::addressof(thread_tree), addr, key, value);
+            thread_tree.insert(*cur_thread);
+        }
 
-        // Begin waiting.
-        cur_thread->BeginWait(std::addressof(wait_queue));
-        cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::ConditionVar);
-        cur_thread->SetMutexWaitAddressForDebugging(addr);
+        // If the timeout is non-zero, set the thread as waiting.
+        if (timeout != 0) {
+            cur_thread->SetState(ThreadState::Waiting);
+            cur_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::ConditionVar);
+            cur_thread->SetMutexWaitAddressForDebugging(addr);
+        }
     }
 
-    // Get the wait result.
-    return cur_thread->GetWaitResult();
+    // Cancel the timer wait.
+    kernel.TimeManager().UnscheduleTimeEvent(cur_thread);
+
+    // Remove from the condition variable.
+    {
+        KScopedSchedulerLock sl(kernel);
+
+        if (KThread* owner = cur_thread->GetLockOwner(); owner != nullptr) {
+            owner->RemoveWaiter(cur_thread);
+        }
+
+        if (cur_thread->IsWaitingForConditionVariable()) {
+            thread_tree.erase(thread_tree.iterator_to(*cur_thread));
+            cur_thread->ClearConditionVariable();
+        }
+    }
+
+    // Get the result.
+    KSynchronizationObject* dummy{};
+    return cur_thread->GetWaitResult(std::addressof(dummy));
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_condition_variable.h

@@ -34,7 +34,7 @@ public:
     [[nodiscard]] ResultCode Wait(VAddr addr, u64 key, u32 value, s64 timeout);
 
 private:
-    void SignalImpl(KThread* thread);
+    [[nodiscard]] KThread* SignalImpl(KThread* thread);
 
     ThreadTree thread_tree;
 

src/core/hle/kernel/k_handle_table.cpp

@@ -13,7 +13,6 @@ ResultCode KHandleTable::Finalize() {
     // Get the table and clear our record of it.
     u16 saved_table_size = 0;
     {
-        KScopedDisableDispatch dd(kernel);
         KScopedSpinLock lk(m_lock);
 
         std::swap(m_table_size, saved_table_size);
@@ -44,7 +43,6 @@ bool KHandleTable::Remove(Handle handle) {
     // Find the object and free the entry.
     KAutoObject* obj = nullptr;
     {
-        KScopedDisableDispatch dd(kernel);
         KScopedSpinLock lk(m_lock);
 
         if (this->IsValidHandle(handle)) {
@@ -64,7 +62,6 @@ bool KHandleTable::Remove(Handle handle) {
 }
 
 ResultCode KHandleTable::Add(Handle* out_handle, KAutoObject* obj, u16 type) {
-    KScopedDisableDispatch dd(kernel);
     KScopedSpinLock lk(m_lock);
 
     // Never exceed our capacity.
@@ -87,7 +84,6 @@ ResultCode KHandleTable::Add(Handle* out_handle, KAutoObject* obj, u16 type) {
 }
 
 ResultCode KHandleTable::Reserve(Handle* out_handle) {
-    KScopedDisableDispatch dd(kernel);
     KScopedSpinLock lk(m_lock);
 
     // Never exceed our capacity.
@@ -98,7 +94,6 @@ ResultCode KHandleTable::Reserve(Handle* out_handle) {
 }
 
 void KHandleTable::Unreserve(Handle handle) {
-    KScopedDisableDispatch dd(kernel);
     KScopedSpinLock lk(m_lock);
 
     // Unpack the handle.
@@ -117,7 +112,6 @@ void KHandleTable::Unreserve(Handle handle) {
 }
 
 void KHandleTable::Register(Handle handle, KAutoObject* obj, u16 type) {
-    KScopedDisableDispatch dd(kernel);
     KScopedSpinLock lk(m_lock);
 
     // Unpack the handle.

src/core/hle/kernel/k_handle_table.h

@@ -68,7 +68,6 @@ public:
     template <typename T = KAutoObject>
     KScopedAutoObject<T> GetObjectWithoutPseudoHandle(Handle handle) const {
         // Lock and look up in table.
-        KScopedDisableDispatch dd(kernel);
         KScopedSpinLock lk(m_lock);
 
         if constexpr (std::is_same_v<T, KAutoObject>) {
@@ -123,7 +122,6 @@ public:
         size_t num_opened;
         {
             // Lock the table.
-            KScopedDisableDispatch dd(kernel);
             KScopedSpinLock lk(m_lock);
             for (num_opened = 0; num_opened < num_handles; num_opened++) {
                 // Get the current handle.

src/core/hle/kernel/k_light_condition_variable.cpp

@@ -1,80 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/kernel/k_light_condition_variable.h"
-#include "core/hle/kernel/k_scheduler.h"
-#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
-#include "core/hle/kernel/k_thread_queue.h"
-#include "core/hle/kernel/svc_results.h"
-
-namespace Kernel {
-
-namespace {
-
-class ThreadQueueImplForKLightConditionVariable final : public KThreadQueue {
-public:
-    ThreadQueueImplForKLightConditionVariable(KernelCore& kernel_, KThread::WaiterList* wl,
-                                              bool term)
-        : KThreadQueue(kernel_), m_wait_list(wl), m_allow_terminating_thread(term) {}
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // Only process waits if we're allowed to.
-        if (ResultTerminationRequested == wait_result && m_allow_terminating_thread) {
-            return;
-        }
-
-        // Remove the thread from the waiting thread from the light condition variable.
-        m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread));
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-
-private:
-    KThread::WaiterList* m_wait_list;
-    bool m_allow_terminating_thread;
-};
-
-} // namespace
-
-void KLightConditionVariable::Wait(KLightLock* lock, s64 timeout, bool allow_terminating_thread) {
-    // Create thread queue.
-    KThread* owner = GetCurrentThreadPointer(kernel);
-
-    ThreadQueueImplForKLightConditionVariable wait_queue(kernel, std::addressof(wait_list),
-                                                         allow_terminating_thread);
-
-    // Sleep the thread.
-    {
-        KScopedSchedulerLockAndSleep lk(kernel, owner, timeout);
-
-        if (!allow_terminating_thread && owner->IsTerminationRequested()) {
-            lk.CancelSleep();
-            return;
-        }
-
-        lock->Unlock();
-
-        // Add the thread to the queue.
-        wait_list.push_back(*owner);
-
-        // Begin waiting.
-        owner->BeginWait(std::addressof(wait_queue));
-    }
-
-    // Re-acquire the lock.
-    lock->Lock();
-}
-
-void KLightConditionVariable::Broadcast() {
-    KScopedSchedulerLock lk(kernel);
-
-    // Signal all threads.
-    for (auto it = wait_list.begin(); it != wait_list.end(); it = wait_list.erase(it)) {
-        it->EndWait(ResultSuccess);
-    }
-}
-
-} // namespace Kernel

src/core/hle/kernel/k_light_condition_variable.h

@@ -2,24 +2,72 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+// This file references various implementation details from Atmosphere, an open-source firmware for
+// the Nintendo Switch. Copyright 2018-2020 Atmosphere-NX.
+
 #pragma once
 
 #include "common/common_types.h"
-#include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
+#include "core/hle/kernel/time_manager.h"
 
 namespace Kernel {
-
 class KernelCore;
-class KLightLock;
 
 class KLightConditionVariable {
 public:
     explicit KLightConditionVariable(KernelCore& kernel_) : kernel{kernel_} {}
 
-    void Wait(KLightLock* lock, s64 timeout = -1, bool allow_terminating_thread = true);
-    void Broadcast();
+    void Wait(KLightLock* lock, s64 timeout = -1, bool allow_terminating_thread = true) {
+        WaitImpl(lock, timeout, allow_terminating_thread);
+    }
+
+    void Broadcast() {
+        KScopedSchedulerLock lk{kernel};
+
+        // Signal all threads.
+        for (auto& thread : wait_list) {
+            thread.SetState(ThreadState::Runnable);
+        }
+    }
 
 private:
+    void WaitImpl(KLightLock* lock, s64 timeout, bool allow_terminating_thread) {
+        KThread* owner = GetCurrentThreadPointer(kernel);
+
+        // Sleep the thread.
+        {
+            KScopedSchedulerLockAndSleep lk{kernel, owner, timeout};
+
+            if (!allow_terminating_thread && owner->IsTerminationRequested()) {
+                lk.CancelSleep();
+                return;
+            }
+
+            lock->Unlock();
+
+            // Set the thread as waiting.
+            GetCurrentThread(kernel).SetState(ThreadState::Waiting);
+
+            // Add the thread to the queue.
+            wait_list.push_back(GetCurrentThread(kernel));
+        }
+
+        // Remove the thread from the wait list.
+        {
+            KScopedSchedulerLock sl{kernel};
+
+            wait_list.erase(wait_list.iterator_to(GetCurrentThread(kernel)));
+        }
+
+        // Cancel the task that the sleep setup.
+        kernel.TimeManager().UnscheduleTimeEvent(owner);
+
+        // Re-acquire the lock.
+        lock->Lock();
+    }
+
     KernelCore& kernel;
     KThread::WaiterList wait_list{};
 };

src/core/hle/kernel/k_light_lock.cpp

@@ -5,59 +5,44 @@
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
 
-namespace {
-
-class ThreadQueueImplForKLightLock final : public KThreadQueue {
-public:
-    explicit ThreadQueueImplForKLightLock(KernelCore& kernel_) : KThreadQueue(kernel_) {}
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // Remove the thread as a waiter from its owner.
-        if (KThread* owner = waiting_thread->GetLockOwner(); owner != nullptr) {
-            owner->RemoveWaiter(waiting_thread);
-        }
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-};
-
-} // namespace
-
 void KLightLock::Lock() {
     const uintptr_t cur_thread = reinterpret_cast<uintptr_t>(GetCurrentThreadPointer(kernel));
+    const uintptr_t cur_thread_tag = (cur_thread | 1);
 
     while (true) {
         uintptr_t old_tag = tag.load(std::memory_order_relaxed);
 
-        while (!tag.compare_exchange_weak(old_tag, (old_tag == 0) ? cur_thread : (old_tag | 1),
+        while (!tag.compare_exchange_weak(old_tag, (old_tag == 0) ? cur_thread : old_tag | 1,
                                           std::memory_order_acquire)) {
+            if ((old_tag | 1) == cur_thread_tag) {
+                return;
+            }
         }
 
-        if (old_tag == 0 || this->LockSlowPath(old_tag | 1, cur_thread)) {
+        if ((old_tag == 0) || ((old_tag | 1) == cur_thread_tag)) {
             break;
         }
+
+        LockSlowPath(old_tag | 1, cur_thread);
     }
 }
 
 void KLightLock::Unlock() {
     const uintptr_t cur_thread = reinterpret_cast<uintptr_t>(GetCurrentThreadPointer(kernel));
-
     uintptr_t expected = cur_thread;
-    if (!tag.compare_exchange_strong(expected, 0, std::memory_order_release)) {
-        this->UnlockSlowPath(cur_thread);
-    }
+    do {
+        if (expected != cur_thread) {
+            return UnlockSlowPath(cur_thread);
+        }
+    } while (!tag.compare_exchange_weak(expected, 0, std::memory_order_release));
 }
 
-bool KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
+void KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
     KThread* cur_thread = reinterpret_cast<KThread*>(_cur_thread);
-    ThreadQueueImplForKLightLock wait_queue(kernel);
 
     // Pend the current thread waiting on the owner thread.
     {
@@ -65,7 +50,7 @@ bool KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
 
         // Ensure we actually have locking to do.
         if (tag.load(std::memory_order_relaxed) != _owner) {
-            return false;
+            return;
         }
 
         // Add the current thread as a waiter on the owner.
@@ -73,15 +58,22 @@ bool KLightLock::LockSlowPath(uintptr_t _owner, uintptr_t _cur_thread) {
         cur_thread->SetAddressKey(reinterpret_cast<uintptr_t>(std::addressof(tag)));
         owner_thread->AddWaiter(cur_thread);
 
-        // Begin waiting to hold the lock.
-        cur_thread->BeginWait(std::addressof(wait_queue));
+        // Set thread states.
+        cur_thread->SetState(ThreadState::Waiting);
 
         if (owner_thread->IsSuspended()) {
             owner_thread->ContinueIfHasKernelWaiters();
         }
     }
 
-    return true;
+    // We're no longer waiting on the lock owner.
+    {
+        KScopedSchedulerLock sl{kernel};
+
+        if (KThread* owner_thread = cur_thread->GetLockOwner(); owner_thread != nullptr) {
+            owner_thread->RemoveWaiter(cur_thread);
+        }
+    }
 }
 
 void KLightLock::UnlockSlowPath(uintptr_t _cur_thread) {
@@ -89,20 +81,22 @@ void KLightLock::UnlockSlowPath(uintptr_t _cur_thread) {
 
     // Unlock.
     {
-        KScopedSchedulerLock sl(kernel);
+        KScopedSchedulerLock sl{kernel};
 
         // Get the next owner.
-        s32 num_waiters;
+        s32 num_waiters = 0;
         KThread* next_owner = owner_thread->RemoveWaiterByKey(
             std::addressof(num_waiters), reinterpret_cast<uintptr_t>(std::addressof(tag)));
 
         // Pass the lock to the next owner.
         uintptr_t next_tag = 0;
         if (next_owner != nullptr) {
-            next_tag =
-                reinterpret_cast<uintptr_t>(next_owner) | static_cast<uintptr_t>(num_waiters > 1);
+            next_tag = reinterpret_cast<uintptr_t>(next_owner);
+            if (num_waiters > 1) {
+                next_tag |= 0x1;
+            }
 
-            next_owner->EndWait(ResultSuccess);
+            next_owner->SetState(ThreadState::Runnable);
 
             if (next_owner->IsSuspended()) {
                 next_owner->ContinueIfHasKernelWaiters();
@@ -116,7 +110,7 @@ void KLightLock::UnlockSlowPath(uintptr_t _cur_thread) {
         }
 
         // Write the new tag value.
-        tag.store(next_tag, std::memory_order_release);
+        tag.store(next_tag);
     }
 }
 

src/core/hle/kernel/k_light_lock.h

@@ -20,7 +20,7 @@ public:
 
     void Unlock();
 
-    bool LockSlowPath(uintptr_t owner, uintptr_t cur_thread);
+    void LockSlowPath(uintptr_t owner, uintptr_t cur_thread);
 
     void UnlockSlowPath(uintptr_t cur_thread);
 

src/core/hle/kernel/k_memory_block.h

@@ -131,26 +131,6 @@ enum class KMemoryPermission : u8 {
 
     UserMask = static_cast<u8>(Svc::MemoryPermission::Read | Svc::MemoryPermission::Write |
                                Svc::MemoryPermission::Execute),
-
-    KernelShift = 3,
-
-    KernelRead = Read << KernelShift,
-    KernelWrite = Write << KernelShift,
-    KernelExecute = Execute << KernelShift,
-
-    NotMapped = (1 << (2 * KernelShift)),
-
-    KernelReadWrite = KernelRead | KernelWrite,
-    KernelReadExecute = KernelRead | KernelExecute,
-
-    UserRead = Read | KernelRead,
-    UserWrite = Write | KernelWrite,
-    UserExecute = Execute,
-
-    UserReadWrite = UserRead | UserWrite,
-    UserReadExecute = UserRead | UserExecute,
-
-    IpcLockChangeMask = NotMapped | UserReadWrite
 };
 DECLARE_ENUM_FLAG_OPERATORS(KMemoryPermission);
 

src/core/hle/kernel/k_page_linked_list.h

@@ -27,10 +27,6 @@ public:
             return num_pages;
         }
 
-        constexpr std::size_t GetSize() const {
-            return GetNumPages() * PageSize;
-        }
-
     private:
         u64 addr{};
         std::size_t num_pages{};

src/core/hle/kernel/k_page_table.cpp

@@ -368,33 +368,6 @@ ResultCode KPageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, st
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapProcessMemory(VAddr dst_addr, std::size_t size,
-                                          KPageTable& src_page_table, VAddr src_addr) {
-    std::lock_guard lock{page_table_lock};
-
-    const std::size_t num_pages{size / PageSize};
-
-    // Check that the memory is mapped in the destination process.
-    size_t num_allocator_blocks;
-    R_TRY(CheckMemoryState(&num_allocator_blocks, dst_addr, size, KMemoryState::All,
-                           KMemoryState::SharedCode, KMemoryPermission::UserReadWrite,
-                           KMemoryPermission::UserReadWrite, KMemoryAttribute::All,
-                           KMemoryAttribute::None));
-
-    // Check that the memory is mapped in the source process.
-    R_TRY(src_page_table.CheckMemoryState(src_addr, size, KMemoryState::FlagCanMapProcess,
-                                          KMemoryState::FlagCanMapProcess, KMemoryPermission::None,
-                                          KMemoryPermission::None, KMemoryAttribute::All,
-                                          KMemoryAttribute::None));
-
-    CASCADE_CODE(Operate(dst_addr, num_pages, KMemoryPermission::None, OperationType::Unmap));
-
-    // Apply the memory block update.
-    block_manager->Update(dst_addr, num_pages, KMemoryState::Free, KMemoryPermission::None,
-                          KMemoryAttribute::None);
-
-    return ResultSuccess;
-}
 void KPageTable::MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end) {
     auto node{page_linked_list.Nodes().begin()};
     PAddr map_addr{node->GetAddress()};
@@ -969,60 +942,6 @@ ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
     return ResultSuccess;
 }
 
-ResultCode KPageTable::LockForCodeMemory(VAddr addr, std::size_t size) {
-    std::lock_guard lock{page_table_lock};
-
-    KMemoryPermission new_perm = KMemoryPermission::NotMapped | KMemoryPermission::KernelReadWrite;
-
-    KMemoryPermission old_perm{};
-
-    if (const ResultCode result{CheckMemoryState(
-            nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
-            KMemoryState::FlagCanCodeMemory, KMemoryPermission::Mask,
-            KMemoryPermission::UserReadWrite, KMemoryAttribute::All, KMemoryAttribute::None)};
-        result.IsError()) {
-        return result;
-    }
-
-    new_perm = (new_perm != KMemoryPermission::None) ? new_perm : old_perm;
-
-    block_manager->UpdateLock(
-        addr, size / PageSize,
-        [](KMemoryBlockManager::iterator block, KMemoryPermission permission) {
-            block->ShareToDevice(permission);
-        },
-        new_perm);
-
-    return ResultSuccess;
-}
-
-ResultCode KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size) {
-    std::lock_guard lock{page_table_lock};
-
-    KMemoryPermission new_perm = KMemoryPermission::UserReadWrite;
-
-    KMemoryPermission old_perm{};
-
-    if (const ResultCode result{CheckMemoryState(
-            nullptr, &old_perm, nullptr, addr, size, KMemoryState::FlagCanCodeMemory,
-            KMemoryState::FlagCanCodeMemory, KMemoryPermission::None, KMemoryPermission::None,
-            KMemoryAttribute::All, KMemoryAttribute::Locked)};
-        result.IsError()) {
-        return result;
-    }
-
-    new_perm = (new_perm != KMemoryPermission::None) ? new_perm : old_perm;
-
-    block_manager->UpdateLock(
-        addr, size / PageSize,
-        [](KMemoryBlockManager::iterator block, KMemoryPermission permission) {
-            block->UnshareToDevice(permission);
-        },
-        new_perm);
-
-    return ResultSuccess;
-}
-
 ResultCode KPageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
     block_manager = std::make_unique<KMemoryBlockManager>(start, end);
 
@@ -1312,42 +1231,4 @@ ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermissi
     return ResultSuccess;
 }
 
-ResultCode KPageTable::CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size,
-                                        KMemoryState state_mask, KMemoryState state,
-                                        KMemoryPermission perm_mask, KMemoryPermission perm,
-                                        KMemoryAttribute attr_mask, KMemoryAttribute attr) const {
-    // Get information about the first block.
-    const VAddr last_addr = addr + size - 1;
-    KMemoryBlockManager::const_iterator it{block_manager->FindIterator(addr)};
-    KMemoryInfo info = it->GetMemoryInfo();
-
-    // If the start address isn't aligned, we need a block.
-    const size_t blocks_for_start_align =
-        (Common::AlignDown(addr, PageSize) != info.GetAddress()) ? 1 : 0;
-
-    while (true) {
-        // Validate against the provided masks.
-        R_TRY(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
-
-        // Break once we're done.
-        if (last_addr <= info.GetLastAddress()) {
-            break;
-        }
-
-        // Advance our iterator.
-        it++;
-        info = it->GetMemoryInfo();
-    }
-
-    // If the end address isn't aligned, we need a block.
-    const size_t blocks_for_end_align =
-        (Common::AlignUp(addr + size, PageSize) != info.GetEndAddress()) ? 1 : 0;
-
-    if (out_blocks_needed != nullptr) {
-        *out_blocks_needed = blocks_for_start_align + blocks_for_end_align;
-    }
-
-    return ResultSuccess;
-}
-
 } // namespace Kernel

src/core/hle/kernel/k_page_table.h

@@ -33,8 +33,6 @@ public:
                               KMemoryPermission perm);
     ResultCode MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
     ResultCode UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode UnmapProcessMemory(VAddr dst_addr, std::size_t size, KPageTable& src_page_table,
-                                  VAddr src_addr);
     ResultCode MapPhysicalMemory(VAddr addr, std::size_t size);
     ResultCode UnmapPhysicalMemory(VAddr addr, std::size_t size);
     ResultCode UnmapMemory(VAddr addr, std::size_t size);
@@ -57,8 +55,6 @@ public:
                                           KMemoryPermission perm, PAddr map_addr = 0);
     ResultCode LockForDeviceAddressSpace(VAddr addr, std::size_t size);
     ResultCode UnlockForDeviceAddressSpace(VAddr addr, std::size_t size);
-    ResultCode LockForCodeMemory(VAddr addr, std::size_t size);
-    ResultCode UnlockForCodeMemory(VAddr addr, std::size_t size);
 
     Common::PageTable& PageTableImpl() {
         return page_table_impl;
@@ -119,10 +115,6 @@ private:
         return CheckMemoryState(nullptr, nullptr, nullptr, addr, size, state_mask, state, perm_mask,
                                 perm, attr_mask, attr, ignore_attr);
     }
-    ResultCode CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size,
-                                KMemoryState state_mask, KMemoryState state,
-                                KMemoryPermission perm_mask, KMemoryPermission perm,
-                                KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
 
     std::recursive_mutex page_table_lock;
     std::unique_ptr<KMemoryBlockManager> block_manager;

src/core/hle/kernel/k_process.cpp

@@ -60,7 +60,6 @@ void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority
     thread->GetContext64().cpu_registers[0] = 0;
     thread->GetContext32().cpu_registers[1] = thread_handle;
     thread->GetContext64().cpu_registers[1] = thread_handle;
-    thread->DisableDispatch();
 
     auto& kernel = system.Kernel();
     // Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
@@ -228,15 +227,12 @@ void KProcess::PinCurrentThread() {
     const s32 core_id = GetCurrentCoreId(kernel);
     KThread* cur_thread = GetCurrentThreadPointer(kernel);
 
-    // If the thread isn't terminated, pin it.
-    if (!cur_thread->IsTerminationRequested()) {
-        // Pin it.
-        PinThread(core_id, cur_thread);
-        cur_thread->Pin();
+    // Pin it.
+    PinThread(core_id, cur_thread);
+    cur_thread->Pin();
 
-        // An update is needed.
-        KScheduler::SetSchedulerUpdateNeeded(kernel);
-    }
+    // An update is needed.
+    KScheduler::SetSchedulerUpdateNeeded(kernel);
 }
 
 void KProcess::UnpinCurrentThread() {
@@ -254,20 +250,6 @@ void KProcess::UnpinCurrentThread() {
     KScheduler::SetSchedulerUpdateNeeded(kernel);
 }
 
-void KProcess::UnpinThread(KThread* thread) {
-    ASSERT(kernel.GlobalSchedulerContext().IsLocked());
-
-    // Get the thread's core id.
-    const auto core_id = thread->GetActiveCore();
-
-    // Unpin it.
-    UnpinThread(core_id, thread);
-    thread->Unpin();
-
-    // An update is needed.
-    KScheduler::SetSchedulerUpdateNeeded(kernel);
-}
-
 ResultCode KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr address,
                                      [[maybe_unused]] size_t size) {
     // Lock ourselves, to prevent concurrent access.

src/core/hle/kernel/k_process.h

@@ -347,7 +347,6 @@ public:
 
     void PinCurrentThread();
     void UnpinCurrentThread();
-    void UnpinThread(KThread* thread);
 
     KLightLock& GetStateLock() {
         return state_lock;

src/core/hle/kernel/k_scheduler.cpp

@@ -240,8 +240,8 @@ void KScheduler::OnThreadPriorityChanged(KernelCore& kernel, KThread* thread, s3
 
     // If the thread is runnable, we want to change its priority in the queue.
     if (thread->GetRawState() == ThreadState::Runnable) {
-        GetPriorityQueue(kernel).ChangePriority(old_priority,
-                                                thread == kernel.GetCurrentEmuThread(), thread);
+        GetPriorityQueue(kernel).ChangePriority(
+            old_priority, thread == kernel.CurrentScheduler()->GetCurrentThread(), thread);
         IncrementScheduledCount(thread);
         SetSchedulerUpdateNeeded(kernel);
     }
@@ -360,7 +360,7 @@ void KScheduler::RotateScheduledQueue(s32 cpu_core_id, s32 priority) {
 }
 
 bool KScheduler::CanSchedule(KernelCore& kernel) {
-    return kernel.GetCurrentEmuThread()->GetDisableDispatchCount() <= 1;
+    return kernel.CurrentScheduler()->GetCurrentThread()->GetDisableDispatchCount() <= 1;
 }
 
 bool KScheduler::IsSchedulerUpdateNeeded(const KernelCore& kernel) {
@@ -376,30 +376,20 @@ void KScheduler::ClearSchedulerUpdateNeeded(KernelCore& kernel) {
 }
 
 void KScheduler::DisableScheduling(KernelCore& kernel) {
-    // If we are shutting down the kernel, none of this is relevant anymore.
-    if (kernel.IsShuttingDown()) {
-        return;
+    if (auto* scheduler = kernel.CurrentScheduler(); scheduler) {
+        ASSERT(scheduler->GetCurrentThread()->GetDisableDispatchCount() >= 0);
+        scheduler->GetCurrentThread()->DisableDispatch();
     }
-
-    ASSERT(GetCurrentThreadPointer(kernel)->GetDisableDispatchCount() >= 0);
-    GetCurrentThreadPointer(kernel)->DisableDispatch();
 }
 
 void KScheduler::EnableScheduling(KernelCore& kernel, u64 cores_needing_scheduling) {
-    // If we are shutting down the kernel, none of this is relevant anymore.
-    if (kernel.IsShuttingDown()) {
-        return;
-    }
-
-    auto* current_thread = GetCurrentThreadPointer(kernel);
-
-    ASSERT(current_thread->GetDisableDispatchCount() >= 1);
-
-    if (current_thread->GetDisableDispatchCount() > 1) {
-        current_thread->EnableDispatch();
-    } else {
-        RescheduleCores(kernel, cores_needing_scheduling);
+    if (auto* scheduler = kernel.CurrentScheduler(); scheduler) {
+        ASSERT(scheduler->GetCurrentThread()->GetDisableDispatchCount() >= 1);
+        if (scheduler->GetCurrentThread()->GetDisableDispatchCount() >= 1) {
+            scheduler->GetCurrentThread()->EnableDispatch();
+        }
     }
+    RescheduleCores(kernel, cores_needing_scheduling);
 }
 
 u64 KScheduler::UpdateHighestPriorityThreads(KernelCore& kernel) {
@@ -627,17 +617,13 @@ KScheduler::KScheduler(Core::System& system_, s32 core_id_) : system{system_}, c
     state.highest_priority_thread = nullptr;
 }
 
-void KScheduler::Finalize() {
+KScheduler::~KScheduler() {
     if (idle_thread) {
         idle_thread->Close();
         idle_thread = nullptr;
     }
 }
 
-KScheduler::~KScheduler() {
-    ASSERT(!idle_thread);
-}
-
 KThread* KScheduler::GetCurrentThread() const {
     if (auto result = current_thread.load(); result) {
         return result;
@@ -656,12 +642,10 @@ void KScheduler::RescheduleCurrentCore() {
     if (phys_core.IsInterrupted()) {
         phys_core.ClearInterrupt();
     }
-
     guard.Lock();
     if (state.needs_scheduling.load()) {
         Schedule();
     } else {
-        GetCurrentThread()->EnableDispatch();
         guard.Unlock();
     }
 }
@@ -671,33 +655,26 @@ void KScheduler::OnThreadStart() {
 }
 
 void KScheduler::Unload(KThread* thread) {
-    ASSERT(thread);
-
     LOG_TRACE(Kernel, "core {}, unload thread {}", core_id, thread ? thread->GetName() : "nullptr");
 
-    if (thread->IsCallingSvc()) {
-        thread->ClearIsCallingSvc();
+    if (thread) {
+        if (thread->IsCallingSvc()) {
+            thread->ClearIsCallingSvc();
+        }
+        if (!thread->IsTerminationRequested()) {
+            prev_thread = thread;
+
+            Core::ARM_Interface& cpu_core = system.ArmInterface(core_id);
+            cpu_core.SaveContext(thread->GetContext32());
+            cpu_core.SaveContext(thread->GetContext64());
+            // Save the TPIDR_EL0 system register in case it was modified.
+            thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
+            cpu_core.ClearExclusiveState();
+        } else {
+            prev_thread = nullptr;
+        }
+        thread->context_guard.Unlock();
     }
-
-    auto& physical_core = system.Kernel().PhysicalCore(core_id);
-    if (!physical_core.IsInitialized()) {
-        return;
-    }
-
-    Core::ARM_Interface& cpu_core = physical_core.ArmInterface();
-    cpu_core.SaveContext(thread->GetContext32());
-    cpu_core.SaveContext(thread->GetContext64());
-    // Save the TPIDR_EL0 system register in case it was modified.
-    thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
-    cpu_core.ClearExclusiveState();
-
-    if (!thread->IsTerminationRequested() && thread->GetActiveCore() == core_id) {
-        prev_thread = thread;
-    } else {
-        prev_thread = nullptr;
-    }
-
-    thread->context_guard.Unlock();
 }
 
 void KScheduler::Reload(KThread* thread) {
@@ -706,6 +683,11 @@ void KScheduler::Reload(KThread* thread) {
     if (thread) {
         ASSERT_MSG(thread->GetState() == ThreadState::Runnable, "Thread must be runnable.");
 
+        auto* const thread_owner_process = thread->GetOwnerProcess();
+        if (thread_owner_process != nullptr) {
+            system.Kernel().MakeCurrentProcess(thread_owner_process);
+        }
+
         Core::ARM_Interface& cpu_core = system.ArmInterface(core_id);
         cpu_core.LoadContext(thread->GetContext32());
         cpu_core.LoadContext(thread->GetContext64());
@@ -723,7 +705,7 @@ void KScheduler::SwitchContextStep2() {
 }
 
 void KScheduler::ScheduleImpl() {
-    KThread* previous_thread = GetCurrentThread();
+    KThread* previous_thread = current_thread.load();
     KThread* next_thread = state.highest_priority_thread;
 
     state.needs_scheduling = false;
@@ -735,15 +717,10 @@ void KScheduler::ScheduleImpl() {
 
     // If we're not actually switching thread, there's nothing to do.
     if (next_thread == current_thread.load()) {
-        previous_thread->EnableDispatch();
         guard.Unlock();
         return;
     }
 
-    if (next_thread->GetCurrentCore() != core_id) {
-        next_thread->SetCurrentCore(core_id);
-    }
-
     current_thread.store(next_thread);
 
     KProcess* const previous_process = system.Kernel().CurrentProcess();
@@ -754,7 +731,11 @@ void KScheduler::ScheduleImpl() {
     Unload(previous_thread);
 
     std::shared_ptr<Common::Fiber>* old_context;
-    old_context = &previous_thread->GetHostContext();
+    if (previous_thread != nullptr) {
+        old_context = &previous_thread->GetHostContext();
+    } else {
+        old_context = &idle_thread->GetHostContext();
+    }
     guard.Unlock();
 
     Common::Fiber::YieldTo(*old_context, *switch_fiber);

src/core/hle/kernel/k_scheduler.h

@@ -33,8 +33,6 @@ public:
     explicit KScheduler(Core::System& system_, s32 core_id_);
     ~KScheduler();
 
-    void Finalize();
-
     /// Reschedules to the next available thread (call after current thread is suspended)
     void RescheduleCurrentCore();
 

src/core/hle/kernel/k_scheduler_lock.h

@@ -23,11 +23,6 @@ public:
     }
 
     void Lock() {
-        // If we are shutting down the kernel, none of this is relevant anymore.
-        if (kernel.IsShuttingDown()) {
-            return;
-        }
-
         if (IsLockedByCurrentThread()) {
             // If we already own the lock, we can just increment the count.
             ASSERT(lock_count > 0);
@@ -48,11 +43,6 @@ public:
     }
 
     void Unlock() {
-        // If we are shutting down the kernel, none of this is relevant anymore.
-        if (kernel.IsShuttingDown()) {
-            return;
-        }
-
         ASSERT(IsLockedByCurrentThread());
         ASSERT(lock_count > 0);
 

src/core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h

@@ -8,7 +8,6 @@
 #pragma once
 
 #include "common/common_types.h"
-#include "core/hle/kernel/global_scheduler_context.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/time_manager.h"

src/core/hle/kernel/k_server_session.cpp

@@ -175,7 +175,8 @@ ResultCode KServerSession::CompleteSyncRequest(HLERequestContext& context) {
     {
         KScopedSchedulerLock lock(kernel);
         if (!context.IsThreadWaiting()) {
-            context.GetThread().EndWait(result);
+            context.GetThread().Wakeup();
+            context.GetThread().SetSyncedObject(nullptr, result);
         }
     }
 

src/core/hle/kernel/k_synchronization_object.cpp

@@ -8,66 +8,11 @@
 #include "core/hle/kernel/k_scoped_scheduler_lock_and_sleep.h"
 #include "core/hle/kernel/k_synchronization_object.h"
 #include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 
 namespace Kernel {
 
-namespace {
-
-class ThreadQueueImplForKSynchronizationObjectWait final : public KThreadQueueWithoutEndWait {
-public:
-    ThreadQueueImplForKSynchronizationObjectWait(KernelCore& kernel_, KSynchronizationObject** o,
-                                                 KSynchronizationObject::ThreadListNode* n, s32 c)
-        : KThreadQueueWithoutEndWait(kernel_), m_objects(o), m_nodes(n), m_count(c) {}
-
-    void NotifyAvailable(KThread* waiting_thread, KSynchronizationObject* signaled_object,
-                         ResultCode wait_result) override {
-        // Determine the sync index, and unlink all nodes.
-        s32 sync_index = -1;
-        for (auto i = 0; i < m_count; ++i) {
-            // Check if this is the signaled object.
-            if (m_objects[i] == signaled_object && sync_index == -1) {
-                sync_index = i;
-            }
-
-            // Unlink the current node from the current object.
-            m_objects[i]->UnlinkNode(std::addressof(m_nodes[i]));
-        }
-
-        // Set the waiting thread's sync index.
-        waiting_thread->SetSyncedIndex(sync_index);
-
-        // Set the waiting thread as not cancellable.
-        waiting_thread->ClearCancellable();
-
-        // Invoke the base end wait handler.
-        KThreadQueue::EndWait(waiting_thread, wait_result);
-    }
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // Remove all nodes from our list.
-        for (auto i = 0; i < m_count; ++i) {
-            m_objects[i]->UnlinkNode(std::addressof(m_nodes[i]));
-        }
-
-        // Set the waiting thread as not cancellable.
-        waiting_thread->ClearCancellable();
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-
-private:
-    KSynchronizationObject** m_objects;
-    KSynchronizationObject::ThreadListNode* m_nodes;
-    s32 m_count;
-};
-
-} // namespace
-
 void KSynchronizationObject::Finalize() {
     this->OnFinalizeSynchronizationObject();
     KAutoObject::Finalize();
@@ -80,19 +25,11 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,
     std::vector<ThreadListNode> thread_nodes(num_objects);
 
     // Prepare for wait.
-    KThread* thread = GetCurrentThreadPointer(kernel_ctx);
-    ThreadQueueImplForKSynchronizationObjectWait wait_queue(kernel_ctx, objects,
-                                                            thread_nodes.data(), num_objects);
+    KThread* thread = kernel_ctx.CurrentScheduler()->GetCurrentThread();
 
     {
         // Setup the scheduling lock and sleep.
-        KScopedSchedulerLockAndSleep slp(kernel_ctx, thread, timeout);
-
-        // Check if the thread should terminate.
-        if (thread->IsTerminationRequested()) {
-            slp.CancelSleep();
-            return ResultTerminationRequested;
-        }
+        KScopedSchedulerLockAndSleep slp{kernel_ctx, thread, timeout};
 
         // Check if any of the objects are already signaled.
         for (auto i = 0; i < num_objects; ++i) {
@@ -111,6 +48,12 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,
             return ResultTimedOut;
         }
 
+        // Check if the thread should terminate.
+        if (thread->IsTerminationRequested()) {
+            slp.CancelSleep();
+            return ResultTerminationRequested;
+        }
+
         // Check if waiting was canceled.
         if (thread->IsWaitCancelled()) {
             slp.CancelSleep();
@@ -123,25 +66,73 @@ ResultCode KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,
             thread_nodes[i].thread = thread;
             thread_nodes[i].next = nullptr;
 
-            objects[i]->LinkNode(std::addressof(thread_nodes[i]));
+            if (objects[i]->thread_list_tail == nullptr) {
+                objects[i]->thread_list_head = std::addressof(thread_nodes[i]);
+            } else {
+                objects[i]->thread_list_tail->next = std::addressof(thread_nodes[i]);
+            }
+
+            objects[i]->thread_list_tail = std::addressof(thread_nodes[i]);
         }
 
-        // Mark the thread as cancellable.
+        // For debugging only
+        thread->SetWaitObjectsForDebugging({objects, static_cast<std::size_t>(num_objects)});
+
+        // Mark the thread as waiting.
         thread->SetCancellable();
-
-        // Clear the thread's synced index.
-        thread->SetSyncedIndex(-1);
-
-        // Wait for an object to be signaled.
-        thread->BeginWait(std::addressof(wait_queue));
+        thread->SetSyncedObject(nullptr, ResultTimedOut);
+        thread->SetState(ThreadState::Waiting);
         thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Synchronization);
     }
 
-    // Set the output index.
-    *out_index = thread->GetSyncedIndex();
+    // The lock/sleep is done, so we should be able to get our result.
+
+    // Thread is no longer cancellable.
+    thread->ClearCancellable();
+
+    // For debugging only
+    thread->SetWaitObjectsForDebugging({});
+
+    // Cancel the timer as needed.
+    kernel_ctx.TimeManager().UnscheduleTimeEvent(thread);
 
     // Get the wait result.
-    return thread->GetWaitResult();
+    ResultCode wait_result{ResultSuccess};
+    s32 sync_index = -1;
+    {
+        KScopedSchedulerLock lock(kernel_ctx);
+        KSynchronizationObject* synced_obj;
+        wait_result = thread->GetWaitResult(std::addressof(synced_obj));
+
+        for (auto i = 0; i < num_objects; ++i) {
+            // Unlink the object from the list.
+            ThreadListNode* prev_ptr =
+                reinterpret_cast<ThreadListNode*>(std::addressof(objects[i]->thread_list_head));
+            ThreadListNode* prev_val = nullptr;
+            ThreadListNode *prev, *tail_prev;
+
+            do {
+                prev = prev_ptr;
+                prev_ptr = prev_ptr->next;
+                tail_prev = prev_val;
+                prev_val = prev_ptr;
+            } while (prev_ptr != std::addressof(thread_nodes[i]));
+
+            if (objects[i]->thread_list_tail == std::addressof(thread_nodes[i])) {
+                objects[i]->thread_list_tail = tail_prev;
+            }
+
+            prev->next = thread_nodes[i].next;
+
+            if (objects[i] == synced_obj) {
+                sync_index = i;
+            }
+        }
+    }
+
+    // Set output.
+    *out_index = sync_index;
+    return wait_result;
 }
 
 KSynchronizationObject::KSynchronizationObject(KernelCore& kernel_)
@@ -150,7 +141,7 @@ KSynchronizationObject::KSynchronizationObject(KernelCore& kernel_)
 KSynchronizationObject::~KSynchronizationObject() = default;
 
 void KSynchronizationObject::NotifyAvailable(ResultCode result) {
-    KScopedSchedulerLock sl(kernel);
+    KScopedSchedulerLock lock(kernel);
 
     // If we're not signaled, we've nothing to notify.
     if (!this->IsSignaled()) {
@@ -159,7 +150,11 @@ void KSynchronizationObject::NotifyAvailable(ResultCode result) {
 
     // Iterate over each thread.
     for (auto* cur_node = thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {
-        cur_node->thread->NotifyAvailable(this, result);
+        KThread* thread = cur_node->thread;
+        if (thread->GetState() == ThreadState::Waiting) {
+            thread->SetSyncedObject(this, result);
+            thread->SetState(ThreadState::Runnable);
+        }
     }
 }
 

src/core/hle/kernel/k_synchronization_object.h

@@ -35,38 +35,6 @@ public:
 
     [[nodiscard]] std::vector<KThread*> GetWaitingThreadsForDebugging() const;
 
-    void LinkNode(ThreadListNode* node_) {
-        // Link the node to the list.
-        if (thread_list_tail == nullptr) {
-            thread_list_head = node_;
-        } else {
-            thread_list_tail->next = node_;
-        }
-
-        thread_list_tail = node_;
-    }
-
-    void UnlinkNode(ThreadListNode* node_) {
-        // Unlink the node from the list.
-        ThreadListNode* prev_ptr =
-            reinterpret_cast<ThreadListNode*>(std::addressof(thread_list_head));
-        ThreadListNode* prev_val = nullptr;
-        ThreadListNode *prev, *tail_prev;
-
-        do {
-            prev = prev_ptr;
-            prev_ptr = prev_ptr->next;
-            tail_prev = prev_val;
-            prev_val = prev_ptr;
-        } while (prev_ptr != node_);
-
-        if (thread_list_tail == node_) {
-            thread_list_tail = tail_prev;
-        }
-
-        prev->next = node_->next;
-    }
-
 protected:
     explicit KSynchronizationObject(KernelCore& kernel);
     ~KSynchronizationObject() override;

src/core/hle/kernel/k_thread.cpp

@@ -13,9 +13,6 @@
 #include "common/common_types.h"
 #include "common/fiber.h"
 #include "common/logging/log.h"
-#include "common/scope_exit.h"
-#include "common/settings.h"
-#include "common/thread_queue_list.h"
 #include "core/core.h"
 #include "core/cpu_manager.h"
 #include "core/hardware_properties.h"
@@ -59,34 +56,6 @@ static void ResetThreadContext64(Core::ARM_Interface::ThreadContext64& context,
 
 namespace Kernel {
 
-namespace {
-
-class ThreadQueueImplForKThreadSleep final : public KThreadQueueWithoutEndWait {
-public:
-    explicit ThreadQueueImplForKThreadSleep(KernelCore& kernel_)
-        : KThreadQueueWithoutEndWait(kernel_) {}
-};
-
-class ThreadQueueImplForKThreadSetProperty final : public KThreadQueue {
-public:
-    explicit ThreadQueueImplForKThreadSetProperty(KernelCore& kernel_, KThread::WaiterList* wl)
-        : KThreadQueue(kernel_), m_wait_list(wl) {}
-
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
-        // Remove the thread from the wait list.
-        m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread));
-
-        // Invoke the base cancel wait handler.
-        KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
-    }
-
-private:
-    KThread::WaiterList* m_wait_list;
-};
-
-} // namespace
-
 KThread::KThread(KernelCore& kernel_)
     : KAutoObjectWithSlabHeapAndContainer{kernel_}, activity_pause_lock{kernel_} {}
 KThread::~KThread() = default;
@@ -113,8 +82,6 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
         [[fallthrough]];
     case ThreadType::HighPriority:
         [[fallthrough]];
-    case ThreadType::Dummy:
-        [[fallthrough]];
     case ThreadType::User:
         ASSERT(((owner == nullptr) ||
                 (owner->GetCoreMask() | (1ULL << virt_core)) == owner->GetCoreMask()));
@@ -160,8 +127,11 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
     priority = prio;
     base_priority = prio;
 
+    // Set sync object and waiting lock to null.
+    synced_object = nullptr;
+
     // Initialize sleeping queue.
-    wait_queue = nullptr;
+    sleeping_queue = nullptr;
 
     // Set suspend flags.
     suspend_request_flags = 0;
@@ -214,7 +184,7 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
     // Setup the stack parameters.
     StackParameters& sp = GetStackParameters();
     sp.cur_thread = this;
-    sp.disable_count = 0;
+    sp.disable_count = 1;
     SetInExceptionHandler();
 
     // Set thread ID.
@@ -241,16 +211,15 @@ ResultCode KThread::InitializeThread(KThread* thread, KThreadFunction func, uint
     // Initialize the thread.
     R_TRY(thread->Initialize(func, arg, user_stack_top, prio, core, owner, type));
 
-    // Initialize emulation parameters.
+    // Initialize host context.
     thread->host_context =
         std::make_shared<Common::Fiber>(std::move(init_func), init_func_parameter);
-    thread->is_single_core = !Settings::values.use_multi_core.GetValue();
 
     return ResultSuccess;
 }
 
 ResultCode KThread::InitializeDummyThread(KThread* thread) {
-    return thread->Initialize({}, {}, {}, DefaultThreadPriority, 3, {}, ThreadType::Dummy);
+    return thread->Initialize({}, {}, {}, DefaultThreadPriority, 3, {}, ThreadType::Main);
 }
 
 ResultCode KThread::InitializeIdleThread(Core::System& system, KThread* thread, s32 virt_core) {
@@ -304,14 +273,11 @@ void KThread::Finalize() {
 
         auto it = waiter_list.begin();
         while (it != waiter_list.end()) {
-            // Clear the lock owner
+            // The thread shouldn't be a kernel waiter.
             it->SetLockOwner(nullptr);
-
-            // Erase the waiter from our list.
+            it->SetSyncedObject(nullptr, ResultInvalidState);
+            it->Wakeup();
             it = waiter_list.erase(it);
-
-            // Cancel the thread's wait.
-            it->CancelWait(ResultInvalidState, true);
         }
     }
 
@@ -328,12 +294,15 @@ bool KThread::IsSignaled() const {
     return signaled;
 }
 
-void KThread::OnTimer() {
-    ASSERT(kernel.GlobalSchedulerContext().IsLocked());
+void KThread::Wakeup() {
+    KScopedSchedulerLock sl{kernel};
 
-    // If we're waiting, cancel the wait.
     if (GetState() == ThreadState::Waiting) {
-        wait_queue->CancelWait(this, ResultTimedOut, false);
+        if (sleeping_queue != nullptr) {
+            sleeping_queue->WakeupThread(this);
+        } else {
+            SetState(ThreadState::Runnable);
+        }
     }
 }
 
@@ -358,7 +327,7 @@ void KThread::StartTermination() {
 
     // Signal.
     signaled = true;
-    KSynchronizationObject::NotifyAvailable();
+    NotifyAvailable();
 
     // Clear previous thread in KScheduler.
     KScheduler::ClearPreviousThread(kernel, this);
@@ -506,32 +475,30 @@ ResultCode KThread::GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_m
     return ResultSuccess;
 }
 
-ResultCode KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
+ResultCode KThread::SetCoreMask(s32 cpu_core_id, u64 v_affinity_mask) {
     ASSERT(parent != nullptr);
     ASSERT(v_affinity_mask != 0);
-    KScopedLightLock lk(activity_pause_lock);
+    KScopedLightLock lk{activity_pause_lock};
 
     // Set the core mask.
     u64 p_affinity_mask = 0;
     {
-        KScopedSchedulerLock sl(kernel);
+        KScopedSchedulerLock sl{kernel};
         ASSERT(num_core_migration_disables >= 0);
 
-        // If we're updating, set our ideal virtual core.
-        if (core_id_ != Svc::IdealCoreNoUpdate) {
-            virtual_ideal_core_id = core_id_;
-        } else {
-            // Preserve our ideal core id.
-            core_id_ = virtual_ideal_core_id;
-            R_UNLESS(((1ULL << core_id_) & v_affinity_mask) != 0, ResultInvalidCombination);
+        // If the core id is no-update magic, preserve the ideal core id.
+        if (cpu_core_id == Svc::IdealCoreNoUpdate) {
+            cpu_core_id = virtual_ideal_core_id;
+            R_UNLESS(((1ULL << cpu_core_id) & v_affinity_mask) != 0, ResultInvalidCombination);
         }
 
-        // Set our affinity mask.
+        // Set the virtual core/affinity mask.
+        virtual_ideal_core_id = cpu_core_id;
         virtual_affinity_mask = v_affinity_mask;
 
         // Translate the virtual core to a physical core.
-        if (core_id_ >= 0) {
-            core_id_ = Core::Hardware::VirtualToPhysicalCoreMap[core_id_];
+        if (cpu_core_id >= 0) {
+            cpu_core_id = Core::Hardware::VirtualToPhysicalCoreMap[cpu_core_id];
         }
 
         // Translate the virtual affinity mask to a physical one.
@@ -546,7 +513,7 @@ ResultCode KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
             const KAffinityMask old_mask = physical_affinity_mask;
 
             // Set our new ideals.
-            physical_ideal_core_id = core_id_;
+            physical_ideal_core_id = cpu_core_id;
             physical_affinity_mask.SetAffinityMask(p_affinity_mask);
 
             if (physical_affinity_mask.GetAffinityMask() != old_mask.GetAffinityMask()) {
@@ -564,18 +531,18 @@ ResultCode KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
             }
         } else {
             // Otherwise, we edit the original affinity for restoration later.
-            original_physical_ideal_core_id = core_id_;
+            original_physical_ideal_core_id = cpu_core_id;
             original_physical_affinity_mask.SetAffinityMask(p_affinity_mask);
         }
     }
 
     // Update the pinned waiter list.
-    ThreadQueueImplForKThreadSetProperty wait_queue_(kernel, std::addressof(pinned_waiter_list));
     {
         bool retry_update{};
+        bool thread_is_pinned{};
         do {
             // Lock the scheduler.
-            KScopedSchedulerLock sl(kernel);
+            KScopedSchedulerLock sl{kernel};
 
             // Don't do any further management if our termination has been requested.
             R_SUCCEED_IF(IsTerminationRequested());
@@ -603,9 +570,12 @@ ResultCode KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
                     R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
                              ResultTerminationRequested);
 
+                    // Note that the thread was pinned.
+                    thread_is_pinned = true;
+
                     // Wait until the thread isn't pinned any more.
                     pinned_waiter_list.push_back(GetCurrentThread(kernel));
-                    GetCurrentThread(kernel).BeginWait(std::addressof(wait_queue_));
+                    GetCurrentThread(kernel).SetState(ThreadState::Waiting);
                 } else {
                     // If the thread isn't pinned, release the scheduler lock and retry until it's
                     // not current.
@@ -613,6 +583,16 @@ ResultCode KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
                 }
             }
         } while (retry_update);
+
+        // If the thread was pinned, it no longer is, and we should remove the current thread from
+        // our waiter list.
+        if (thread_is_pinned) {
+            // Lock the scheduler.
+            KScopedSchedulerLock sl{kernel};
+
+            // Remove from the list.
+            pinned_waiter_list.erase(pinned_waiter_list.iterator_to(GetCurrentThread(kernel)));
+        }
     }
 
     return ResultSuccess;
@@ -661,9 +641,15 @@ void KThread::WaitCancel() {
     KScopedSchedulerLock sl{kernel};
 
     // Check if we're waiting and cancellable.
-    if (this->GetState() == ThreadState::Waiting && cancellable) {
-        wait_cancelled = false;
-        wait_queue->CancelWait(this, ResultCancelled, true);
+    if (GetState() == ThreadState::Waiting && cancellable) {
+        if (sleeping_queue != nullptr) {
+            sleeping_queue->WakeupThread(this);
+            wait_cancelled = true;
+        } else {
+            SetSyncedObject(nullptr, ResultCancelled);
+            SetState(ThreadState::Runnable);
+            wait_cancelled = false;
+        }
     } else {
         // Otherwise, note that we cancelled a wait.
         wait_cancelled = true;
@@ -714,59 +700,60 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
     // Set the activity.
     {
         // Lock the scheduler.
-        KScopedSchedulerLock sl(kernel);
+        KScopedSchedulerLock sl{kernel};
 
         // Verify our state.
-        const auto cur_state = this->GetState();
+        const auto cur_state = GetState();
         R_UNLESS((cur_state == ThreadState::Waiting || cur_state == ThreadState::Runnable),
                  ResultInvalidState);
 
         // Either pause or resume.
         if (activity == Svc::ThreadActivity::Paused) {
             // Verify that we're not suspended.
-            R_UNLESS(!this->IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
+            R_UNLESS(!IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
 
             // Suspend.
-            this->RequestSuspend(SuspendType::Thread);
+            RequestSuspend(SuspendType::Thread);
         } else {
             ASSERT(activity == Svc::ThreadActivity::Runnable);
 
             // Verify that we're suspended.
-            R_UNLESS(this->IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
+            R_UNLESS(IsSuspendRequested(SuspendType::Thread), ResultInvalidState);
 
             // Resume.
-            this->Resume(SuspendType::Thread);
+            Resume(SuspendType::Thread);
         }
     }
 
     // If the thread is now paused, update the pinned waiter list.
     if (activity == Svc::ThreadActivity::Paused) {
-        ThreadQueueImplForKThreadSetProperty wait_queue_(kernel,
-                                                         std::addressof(pinned_waiter_list));
-
-        bool thread_is_current;
+        bool thread_is_pinned{};
+        bool thread_is_current{};
         do {
             // Lock the scheduler.
-            KScopedSchedulerLock sl(kernel);
+            KScopedSchedulerLock sl{kernel};
 
             // Don't do any further management if our termination has been requested.
-            R_SUCCEED_IF(this->IsTerminationRequested());
-
-            // By default, treat the thread as not current.
-            thread_is_current = false;
+            R_SUCCEED_IF(IsTerminationRequested());
 
             // Check whether the thread is pinned.
-            if (this->GetStackParameters().is_pinned) {
+            if (GetStackParameters().is_pinned) {
                 // Verify that the current thread isn't terminating.
                 R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),
                          ResultTerminationRequested);
 
+                // Note that the thread was pinned and not current.
+                thread_is_pinned = true;
+                thread_is_current = false;
+
                 // Wait until the thread isn't pinned any more.
                 pinned_waiter_list.push_back(GetCurrentThread(kernel));
-                GetCurrentThread(kernel).BeginWait(std::addressof(wait_queue_));
+                GetCurrentThread(kernel).SetState(ThreadState::Waiting);
             } else {
                 // Check if the thread is currently running.
                 // If it is, we'll need to retry.
+                thread_is_current = false;
+
                 for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) {
                     if (kernel.Scheduler(i).GetCurrentThread() == this) {
                         thread_is_current = true;
@@ -775,6 +762,16 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
                 }
             }
         } while (thread_is_current);
+
+        // If the thread was pinned, it no longer is, and we should remove the current thread from
+        // our waiter list.
+        if (thread_is_pinned) {
+            // Lock the scheduler.
+            KScopedSchedulerLock sl{kernel};
+
+            // Remove from the list.
+            pinned_waiter_list.erase(pinned_waiter_list.iterator_to(GetCurrentThread(kernel)));
+        }
     }
 
     return ResultSuccess;
@@ -969,9 +966,6 @@ ResultCode KThread::Run() {
 
         // Set our state and finish.
         SetState(ThreadState::Runnable);
-
-        DisableDispatch();
-
         return ResultSuccess;
     }
 }
@@ -1002,63 +996,29 @@ ResultCode KThread::Sleep(s64 timeout) {
     ASSERT(this == GetCurrentThreadPointer(kernel));
     ASSERT(timeout > 0);
 
-    ThreadQueueImplForKThreadSleep wait_queue_(kernel);
     {
         // Setup the scheduling lock and sleep.
-        KScopedSchedulerLockAndSleep slp(kernel, this, timeout);
+        KScopedSchedulerLockAndSleep slp{kernel, this, timeout};
 
         // Check if the thread should terminate.
-        if (this->IsTerminationRequested()) {
+        if (IsTerminationRequested()) {
             slp.CancelSleep();
             return ResultTerminationRequested;
         }
 
-        // Wait for the sleep to end.
-        this->BeginWait(std::addressof(wait_queue_));
+        // Mark the thread as waiting.
+        SetState(ThreadState::Waiting);
         SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::Sleep);
     }
 
+    // The lock/sleep is done.
+
+    // Cancel the timer.
+    kernel.TimeManager().UnscheduleTimeEvent(this);
+
     return ResultSuccess;
 }
 
-void KThread::BeginWait(KThreadQueue* queue) {
-    // Set our state as waiting.
-    SetState(ThreadState::Waiting);
-
-    // Set our wait queue.
-    wait_queue = queue;
-}
-
-void KThread::NotifyAvailable(KSynchronizationObject* signaled_object, ResultCode wait_result_) {
-    // Lock the scheduler.
-    KScopedSchedulerLock sl(kernel);
-
-    // If we're waiting, notify our queue that we're available.
-    if (GetState() == ThreadState::Waiting) {
-        wait_queue->NotifyAvailable(this, signaled_object, wait_result_);
-    }
-}
-
-void KThread::EndWait(ResultCode wait_result_) {
-    // Lock the scheduler.
-    KScopedSchedulerLock sl(kernel);
-
-    // If we're waiting, notify our queue that we're available.
-    if (GetState() == ThreadState::Waiting) {
-        wait_queue->EndWait(this, wait_result_);
-    }
-}
-
-void KThread::CancelWait(ResultCode wait_result_, bool cancel_timer_task) {
-    // Lock the scheduler.
-    KScopedSchedulerLock sl(kernel);
-
-    // If we're waiting, notify our queue that we're available.
-    if (GetState() == ThreadState::Waiting) {
-        wait_queue->CancelWait(this, wait_result_, cancel_timer_task);
-    }
-}
-
 void KThread::SetState(ThreadState state) {
     KScopedSchedulerLock sl{kernel};
 
@@ -1090,26 +1050,4 @@ s32 GetCurrentCoreId(KernelCore& kernel) {
     return GetCurrentThread(kernel).GetCurrentCore();
 }
 
-KScopedDisableDispatch::~KScopedDisableDispatch() {
-    // If we are shutting down the kernel, none of this is relevant anymore.
-    if (kernel.IsShuttingDown()) {
-        return;
-    }
-
-    // Skip the reschedule if single-core, as dispatch tracking is disabled here.
-    if (!Settings::values.use_multi_core.GetValue()) {
-        return;
-    }
-
-    if (GetCurrentThread(kernel).GetDisableDispatchCount() <= 1) {
-        auto scheduler = kernel.CurrentScheduler();
-
-        if (scheduler) {
-            scheduler->RescheduleCurrentCore();
-        }
-    } else {
-        GetCurrentThread(kernel).EnableDispatch();
-    }
-}
-
 } // namespace Kernel

src/core/hle/kernel/k_thread.h

@@ -48,7 +48,6 @@ enum class ThreadType : u32 {
     Kernel = 1,
     HighPriority = 2,
     User = 3,
-    Dummy = 100, // Special thread type for emulation purposes only
 };
 DECLARE_ENUM_FLAG_OPERATORS(ThreadType);
 
@@ -162,6 +161,8 @@ public:
         }
     }
 
+    void Wakeup();
+
     void SetBasePriority(s32 value);
 
     [[nodiscard]] ResultCode Run();
@@ -196,19 +197,13 @@ public:
 
     void Suspend();
 
-    constexpr void SetSyncedIndex(s32 index) {
-        synced_index = index;
-    }
-
-    [[nodiscard]] constexpr s32 GetSyncedIndex() const {
-        return synced_index;
-    }
-
-    constexpr void SetWaitResult(ResultCode wait_res) {
+    void SetSyncedObject(KSynchronizationObject* obj, ResultCode wait_res) {
+        synced_object = obj;
         wait_result = wait_res;
     }
 
-    [[nodiscard]] constexpr ResultCode GetWaitResult() const {
+    [[nodiscard]] ResultCode GetWaitResult(KSynchronizationObject** out) const {
+        *out = synced_object;
         return wait_result;
     }
 
@@ -379,8 +374,6 @@ public:
 
     [[nodiscard]] bool IsSignaled() const override;
 
-    void OnTimer();
-
     static void PostDestroy(uintptr_t arg);
 
     [[nodiscard]] static ResultCode InitializeDummyThread(KThread* thread);
@@ -453,39 +446,20 @@ public:
         return per_core_priority_queue_entry[core];
     }
 
-    [[nodiscard]] bool IsKernelThread() const {
-        return GetActiveCore() == 3;
-    }
-
-    [[nodiscard]] bool IsDispatchTrackingDisabled() const {
-        return is_single_core || IsKernelThread();
+    void SetSleepingQueue(KThreadQueue* q) {
+        sleeping_queue = q;
     }
 
     [[nodiscard]] s32 GetDisableDispatchCount() const {
-        if (IsDispatchTrackingDisabled()) {
-            // TODO(bunnei): Until kernel threads are emulated, we cannot enable/disable dispatch.
-            return 1;
-        }
-
         return this->GetStackParameters().disable_count;
     }
 
     void DisableDispatch() {
-        if (IsDispatchTrackingDisabled()) {
-            // TODO(bunnei): Until kernel threads are emulated, we cannot enable/disable dispatch.
-            return;
-        }
-
         ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() >= 0);
         this->GetStackParameters().disable_count++;
     }
 
     void EnableDispatch() {
-        if (IsDispatchTrackingDisabled()) {
-            // TODO(bunnei): Until kernel threads are emulated, we cannot enable/disable dispatch.
-            return;
-        }
-
         ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() > 0);
         this->GetStackParameters().disable_count--;
     }
@@ -599,15 +573,6 @@ public:
         address_key_value = val;
     }
 
-    void ClearWaitQueue() {
-        wait_queue = nullptr;
-    }
-
-    void BeginWait(KThreadQueue* queue);
-    void NotifyAvailable(KSynchronizationObject* signaled_object, ResultCode wait_result_);
-    void EndWait(ResultCode wait_result_);
-    void CancelWait(ResultCode wait_result_, bool cancel_timer_task);
-
     [[nodiscard]] bool HasWaiters() const {
         return !waiter_list.empty();
     }
@@ -702,6 +667,7 @@ private:
     KAffinityMask physical_affinity_mask{};
     u64 thread_id{};
     std::atomic<s64> cpu_time{};
+    KSynchronizationObject* synced_object{};
     VAddr address_key{};
     KProcess* parent{};
     VAddr kernel_stack_top{};
@@ -711,14 +677,13 @@ private:
     s64 schedule_count{};
     s64 last_scheduled_tick{};
     std::array<QueueEntry, Core::Hardware::NUM_CPU_CORES> per_core_priority_queue_entry{};
-    KThreadQueue* wait_queue{};
+    KThreadQueue* sleeping_queue{};
     WaiterList waiter_list{};
     WaiterList pinned_waiter_list{};
     KThread* lock_owner{};
     u32 address_key_value{};
     u32 suspend_request_flags{};
     u32 suspend_allowed_flags{};
-    s32 synced_index{};
     ResultCode wait_result{ResultSuccess};
     s32 base_priority{};
     s32 physical_ideal_core_id{};
@@ -743,7 +708,6 @@ private:
 
     // For emulation
     std::shared_ptr<Common::Fiber> host_context{};
-    bool is_single_core{};
 
     // For debugging
     std::vector<KSynchronizationObject*> wait_objects_for_debugging;
@@ -788,20 +752,4 @@ public:
     }
 };
 
-class KScopedDisableDispatch {
-public:
-    [[nodiscard]] explicit KScopedDisableDispatch(KernelCore& kernel_) : kernel{kernel_} {
-        // If we are shutting down the kernel, none of this is relevant anymore.
-        if (kernel.IsShuttingDown()) {
-            return;
-        }
-        GetCurrentThread(kernel).DisableDispatch();
-    }
-
-    ~KScopedDisableDispatch();
-
-private:
-    KernelCore& kernel;
-};
-
 } // namespace Kernel

src/core/hle/kernel/k_thread_queue.cpp

@@ -1,49 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/kernel/k_thread_queue.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/time_manager.h"
-
-namespace Kernel {
-
-void KThreadQueue::NotifyAvailable([[maybe_unused]] KThread* waiting_thread,
-                                   [[maybe_unused]] KSynchronizationObject* signaled_object,
-                                   [[maybe_unused]] ResultCode wait_result) {}
-
-void KThreadQueue::EndWait(KThread* waiting_thread, ResultCode wait_result) {
-    // Set the thread's wait result.
-    waiting_thread->SetWaitResult(wait_result);
-
-    // Set the thread as runnable.
-    waiting_thread->SetState(ThreadState::Runnable);
-
-    // Clear the thread's wait queue.
-    waiting_thread->ClearWaitQueue();
-
-    // Cancel the thread task.
-    kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
-}
-
-void KThreadQueue::CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                              bool cancel_timer_task) {
-    // Set the thread's wait result.
-    waiting_thread->SetWaitResult(wait_result);
-
-    // Set the thread as runnable.
-    waiting_thread->SetState(ThreadState::Runnable);
-
-    // Clear the thread's wait queue.
-    waiting_thread->ClearWaitQueue();
-
-    // Cancel the thread task.
-    if (cancel_timer_task) {
-        kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
-    }
-}
-
-void KThreadQueueWithoutEndWait::EndWait([[maybe_unused]] KThread* waiting_thread,
-                                         [[maybe_unused]] ResultCode wait_result) {}
-
-} // namespace Kernel

src/core/hle/kernel/k_thread_queue.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_thread.h"
 
 namespace Kernel {
@@ -12,24 +11,71 @@ namespace Kernel {
 class KThreadQueue {
 public:
     explicit KThreadQueue(KernelCore& kernel_) : kernel{kernel_} {}
-    virtual ~KThreadQueue() = default;
 
-    virtual void NotifyAvailable(KThread* waiting_thread, KSynchronizationObject* signaled_object,
-                                 ResultCode wait_result);
-    virtual void EndWait(KThread* waiting_thread, ResultCode wait_result);
-    virtual void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                            bool cancel_timer_task);
+    bool IsEmpty() const {
+        return wait_list.empty();
+    }
+
+    KThread::WaiterList::iterator begin() {
+        return wait_list.begin();
+    }
+    KThread::WaiterList::iterator end() {
+        return wait_list.end();
+    }
+
+    bool SleepThread(KThread* t) {
+        KScopedSchedulerLock sl{kernel};
+
+        // If the thread needs terminating, don't enqueue it.
+        if (t->IsTerminationRequested()) {
+            return false;
+        }
+
+        // Set the thread's queue and mark it as waiting.
+        t->SetSleepingQueue(this);
+        t->SetState(ThreadState::Waiting);
+
+        // Add the thread to the queue.
+        wait_list.push_back(*t);
+
+        return true;
+    }
+
+    void WakeupThread(KThread* t) {
+        KScopedSchedulerLock sl{kernel};
+
+        // Remove the thread from the queue.
+        wait_list.erase(wait_list.iterator_to(*t));
+
+        // Mark the thread as no longer sleeping.
+        t->SetState(ThreadState::Runnable);
+        t->SetSleepingQueue(nullptr);
+    }
+
+    KThread* WakeupFrontThread() {
+        KScopedSchedulerLock sl{kernel};
+
+        if (wait_list.empty()) {
+            return nullptr;
+        } else {
+            // Remove the thread from the queue.
+            auto it = wait_list.begin();
+            KThread* thread = std::addressof(*it);
+            wait_list.erase(it);
+
+            ASSERT(thread->GetState() == ThreadState::Waiting);
+
+            // Mark the thread as no longer sleeping.
+            thread->SetState(ThreadState::Runnable);
+            thread->SetSleepingQueue(nullptr);
+
+            return thread;
+        }
+    }
 
 private:
     KernelCore& kernel;
     KThread::WaiterList wait_list{};
 };
 
-class KThreadQueueWithoutEndWait : public KThreadQueue {
-public:
-    explicit KThreadQueueWithoutEndWait(KernelCore& kernel_) : KThreadQueue(kernel_) {}
-
-    void EndWait(KThread* waiting_thread, ResultCode wait_result) override final;
-};
-
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -14,7 +14,6 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/microprofile.h"
-#include "common/scope_exit.h"
 #include "common/thread.h"
 #include "common/thread_worker.h"
 #include "core/arm/arm_interface.h"
@@ -84,16 +83,12 @@ struct KernelCore::Impl {
     }
 
     void InitializeCores() {
-        for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            cores[core_id].Initialize(current_process->Is64BitProcess());
-            system.Memory().SetCurrentPageTable(*current_process, core_id);
+        for (auto& core : cores) {
+            core.Initialize(current_process->Is64BitProcess());
         }
     }
 
     void Shutdown() {
-        is_shutting_down.store(true, std::memory_order_relaxed);
-        SCOPE_EXIT({ is_shutting_down.store(false, std::memory_order_relaxed); });
-
         process_list.clear();
 
         // Close all open server ports.
@@ -128,6 +123,15 @@ struct KernelCore::Impl {
         next_user_process_id = KProcess::ProcessIDMin;
         next_thread_id = 1;
 
+        for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
+            if (suspend_threads[core_id]) {
+                suspend_threads[core_id]->Close();
+                suspend_threads[core_id] = nullptr;
+            }
+
+            schedulers[core_id].reset();
+        }
+
         cores.clear();
 
         global_handle_table->Finalize();
@@ -155,16 +159,6 @@ struct KernelCore::Impl {
         CleanupObject(time_shared_mem);
         CleanupObject(system_resource_limit);
 
-        for (u32 core_id = 0; core_id < Core::Hardware::NUM_CPU_CORES; core_id++) {
-            if (suspend_threads[core_id]) {
-                suspend_threads[core_id]->Close();
-                suspend_threads[core_id] = nullptr;
-            }
-
-            schedulers[core_id]->Finalize();
-            schedulers[core_id].reset();
-        }
-
         // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others
         next_host_thread_id = Core::Hardware::NUM_CPU_CORES;
 
@@ -251,11 +245,13 @@ struct KernelCore::Impl {
                     KScopedSchedulerLock lock(kernel);
                     global_scheduler_context->PreemptThreads();
                 }
-                const auto time_interval = std::chrono::nanoseconds{std::chrono::milliseconds(10)};
+                const auto time_interval = std::chrono::nanoseconds{
+                    Core::Timing::msToCycles(std::chrono::milliseconds(10))};
                 system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
             });
 
-        const auto time_interval = std::chrono::nanoseconds{std::chrono::milliseconds(10)};
+        const auto time_interval =
+            std::chrono::nanoseconds{Core::Timing::msToCycles(std::chrono::milliseconds(10))};
         system.CoreTiming().ScheduleEvent(time_interval, preemption_event);
     }
 
@@ -271,6 +267,14 @@ struct KernelCore::Impl {
 
     void MakeCurrentProcess(KProcess* process) {
         current_process = process;
+        if (process == nullptr) {
+            return;
+        }
+
+        const u32 core_id = GetCurrentHostThreadID();
+        if (core_id < Core::Hardware::NUM_CPU_CORES) {
+            system.Memory().SetCurrentPageTable(*process, core_id);
+        }
     }
 
     static inline thread_local u32 host_thread_id = UINT32_MAX;
@@ -340,16 +344,7 @@ struct KernelCore::Impl {
         is_phantom_mode_for_singlecore = value;
     }
 
-    bool IsShuttingDown() const {
-        return is_shutting_down.load(std::memory_order_relaxed);
-    }
-
     KThread* GetCurrentEmuThread() {
-        // If we are shutting down the kernel, none of this is relevant anymore.
-        if (IsShuttingDown()) {
-            return {};
-        }
-
         const auto thread_id = GetCurrentHostThreadID();
         if (thread_id >= Core::Hardware::NUM_CPU_CORES) {
             return GetHostDummyThread();
@@ -765,7 +760,6 @@ struct KernelCore::Impl {
     std::vector<std::unique_ptr<KThread>> dummy_threads;
 
     bool is_multicore{};
-    std::atomic_bool is_shutting_down{};
     bool is_phantom_mode_for_singlecore{};
     u32 single_core_thread_id{};
 
@@ -851,20 +845,16 @@ const Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) const {
     return impl->cores[id];
 }
 
-size_t KernelCore::CurrentPhysicalCoreIndex() const {
-    const u32 core_id = impl->GetCurrentHostThreadID();
-    if (core_id >= Core::Hardware::NUM_CPU_CORES) {
-        return Core::Hardware::NUM_CPU_CORES - 1;
-    }
-    return core_id;
-}
-
 Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() {
-    return impl->cores[CurrentPhysicalCoreIndex()];
+    u32 core_id = impl->GetCurrentHostThreadID();
+    ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
+    return impl->cores[core_id];
 }
 
 const Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() const {
-    return impl->cores[CurrentPhysicalCoreIndex()];
+    u32 core_id = impl->GetCurrentHostThreadID();
+    ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
+    return impl->cores[core_id];
 }
 
 Kernel::KScheduler* KernelCore::CurrentScheduler() {
@@ -1067,9 +1057,6 @@ void KernelCore::Suspend(bool in_suspention) {
             impl->suspend_threads[core_id]->SetState(state);
             impl->suspend_threads[core_id]->SetWaitReasonForDebugging(
                 ThreadWaitReasonForDebugging::Suspended);
-            if (!should_suspend) {
-                impl->suspend_threads[core_id]->DisableDispatch();
-            }
         }
     }
 }
@@ -1078,21 +1065,19 @@ bool KernelCore::IsMulticore() const {
     return impl->is_multicore;
 }
 
-bool KernelCore::IsShuttingDown() const {
-    return impl->IsShuttingDown();
-}
-
 void KernelCore::ExceptionalExit() {
     exception_exited = true;
     Suspend(true);
 }
 
 void KernelCore::EnterSVCProfile() {
-    impl->svc_ticks[CurrentPhysicalCoreIndex()] = MicroProfileEnter(MICROPROFILE_TOKEN(Kernel_SVC));
+    std::size_t core = impl->GetCurrentHostThreadID();
+    impl->svc_ticks[core] = MicroProfileEnter(MICROPROFILE_TOKEN(Kernel_SVC));
 }
 
 void KernelCore::ExitSVCProfile() {
-    MicroProfileLeave(MICROPROFILE_TOKEN(Kernel_SVC), impl->svc_ticks[CurrentPhysicalCoreIndex()]);
+    std::size_t core = impl->GetCurrentHostThreadID();
+    MicroProfileLeave(MICROPROFILE_TOKEN(Kernel_SVC), impl->svc_ticks[core]);
 }
 
 std::weak_ptr<Kernel::ServiceThread> KernelCore::CreateServiceThread(const std::string& name) {

src/core/hle/kernel/kernel.h

@@ -53,7 +53,6 @@ class KSharedMemoryInfo;
 class KThread;
 class KTransferMemory;
 class KWritableEvent;
-class KCodeMemory;
 class PhysicalCore;
 class ServiceThread;
 class Synchronization;
@@ -149,9 +148,6 @@ public:
     /// Gets the an instance of the respective physical CPU core.
     const Kernel::PhysicalCore& PhysicalCore(std::size_t id) const;
 
-    /// Gets the current physical core index for the running host thread.
-    std::size_t CurrentPhysicalCoreIndex() const;
-
     /// Gets the sole instance of the Scheduler at the current running core.
     Kernel::KScheduler* CurrentScheduler();
 
@@ -275,8 +271,6 @@ public:
 
     bool IsMulticore() const;
 
-    bool IsShuttingDown() const;
-
     void EnterSVCProfile();
 
     void ExitSVCProfile();
@@ -332,8 +326,6 @@ public:
             return slab_heap_container->transfer_memory;
         } else if constexpr (std::is_same_v<T, KWritableEvent>) {
             return slab_heap_container->writeable_event;
-        } else if constexpr (std::is_same_v<T, KCodeMemory>) {
-            return slab_heap_container->code_memory;
         }
     }
 
@@ -385,7 +377,6 @@ private:
         KSlabHeap<KThread> thread;
         KSlabHeap<KTransferMemory> transfer_memory;
         KSlabHeap<KWritableEvent> writeable_event;
-        KSlabHeap<KCodeMemory> code_memory;
     };
 
     std::unique_ptr<SlabHeapContainer> slab_heap_container;

src/core/hle/kernel/service_thread.cpp

@@ -25,27 +25,24 @@ public:
     void QueueSyncRequest(KSession& session, std::shared_ptr<HLERequestContext>&& context);
 
 private:
-    std::vector<std::jthread> threads;
+    std::vector<std::thread> threads;
     std::queue<std::function<void()>> requests;
     std::mutex queue_mutex;
-    std::condition_variable_any condition;
+    std::condition_variable condition;
     const std::string service_name;
+    bool stop{};
 };
 
 ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads, const std::string& name)
     : service_name{name} {
-    for (std::size_t i = 0; i < num_threads; ++i) {
-        threads.emplace_back([this, &kernel](std::stop_token stop_token) {
+    for (std::size_t i = 0; i < num_threads; ++i)
+        threads.emplace_back([this, &kernel] {
             Common::SetCurrentThreadName(std::string{"yuzu:HleService:" + service_name}.c_str());
 
             // Wait for first request before trying to acquire a render context
             {
                 std::unique_lock lock{queue_mutex};
-                condition.wait(lock, stop_token, [this] { return !requests.empty(); });
-            }
-
-            if (stop_token.stop_requested()) {
-                return;
+                condition.wait(lock, [this] { return stop || !requests.empty(); });
             }
 
             kernel.RegisterHostThread();
@@ -55,16 +52,10 @@ ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads, const std
 
                 {
                     std::unique_lock lock{queue_mutex};
-                    condition.wait(lock, stop_token, [this] { return !requests.empty(); });
-
-                    if (stop_token.stop_requested()) {
+                    condition.wait(lock, [this] { return stop || !requests.empty(); });
+                    if (stop || requests.empty()) {
                         return;
                     }
-
-                    if (requests.empty()) {
-                        continue;
-                    }
-
                     task = std::move(requests.front());
                     requests.pop();
                 }
@@ -72,7 +63,6 @@ ServiceThread::Impl::Impl(KernelCore& kernel, std::size_t num_threads, const std
                 task();
             }
         });
-    }
 }
 
 void ServiceThread::Impl::QueueSyncRequest(KSession& session,
@@ -98,9 +88,12 @@ void ServiceThread::Impl::QueueSyncRequest(KSession& session,
 }
 
 ServiceThread::Impl::~Impl() {
+    {
+        std::unique_lock lock{queue_mutex};
+        stop = true;
+    }
     condition.notify_all();
-    for (auto& thread : threads) {
-        thread.request_stop();
+    for (std::thread& thread : threads) {
         thread.join();
     }
 }

src/core/hle/kernel/svc.cpp

@@ -18,7 +18,6 @@
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_client_session.h"
-#include "core/hle/kernel/k_code_memory.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/kernel/k_handle_table.h"
 #include "core/hle/kernel/k_memory_block.h"
@@ -32,7 +31,6 @@
 #include "core/hle/kernel/k_shared_memory.h"
 #include "core/hle/kernel/k_synchronization_object.h"
 #include "core/hle/kernel/k_thread.h"
-#include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/k_transfer_memory.h"
 #include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
@@ -309,29 +307,26 @@ static ResultCode ConnectToNamedPort32(Core::System& system, Handle* out_handle,
 
 /// Makes a blocking IPC call to an OS service.
 static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
+
     auto& kernel = system.Kernel();
 
-    // Create the wait queue.
-    KThreadQueue wait_queue(kernel);
-
-    // Get the client session from its handle.
-    KScopedAutoObject session =
-        kernel.CurrentProcess()->GetHandleTable().GetObject<KClientSession>(handle);
-    R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
-
-    LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
-
     auto thread = kernel.CurrentScheduler()->GetCurrentThread();
     {
         KScopedSchedulerLock lock(kernel);
+        thread->SetState(ThreadState::Waiting);
+        thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);
 
-        // This is a synchronous request, so we should wait for our request to complete.
-        GetCurrentThread(kernel).BeginWait(std::addressof(wait_queue));
-        GetCurrentThread(kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);
-        session->SendSyncRequest(&GetCurrentThread(kernel), system.Memory(), system.CoreTiming());
+        {
+            KScopedAutoObject session =
+                kernel.CurrentProcess()->GetHandleTable().GetObject<KClientSession>(handle);
+            R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
+            LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}({})", handle, session->GetName());
+            session->SendSyncRequest(thread, system.Memory(), system.CoreTiming());
+        }
     }
 
-    return thread->GetWaitResult();
+    KSynchronizationObject* dummy{};
+    return thread->GetWaitResult(std::addressof(dummy));
 }
 
 static ResultCode SendSyncRequest32(Core::System& system, Handle handle) {
@@ -878,7 +873,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
             const u64 thread_ticks = current_thread->GetCpuTime();
 
             out_ticks = thread_ticks + (core_timing.GetCPUTicks() - prev_ctx_ticks);
-        } else if (same_thread && info_sub_id == system.Kernel().CurrentPhysicalCoreIndex()) {
+        } else if (same_thread && info_sub_id == system.CurrentCoreIndex()) {
             out_ticks = core_timing.GetCPUTicks() - prev_ctx_ticks;
         }
 
@@ -892,8 +887,7 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
             return ResultInvalidHandle;
         }
 
-        if (info_sub_id != 0xFFFFFFFFFFFFFFFF &&
-            info_sub_id != system.Kernel().CurrentPhysicalCoreIndex()) {
+        if (info_sub_id != 0xFFFFFFFFFFFFFFFF && info_sub_id != system.CurrentCoreIndex()) {
             LOG_ERROR(Kernel_SVC, "Core is not the current core, got {}", info_sub_id);
             return ResultInvalidCombination;
         }
@@ -1203,22 +1197,6 @@ constexpr bool IsValidProcessMemoryPermission(Svc::MemoryPermission perm) {
     }
 }
 
-constexpr bool IsValidMapCodeMemoryPermission(Svc::MemoryPermission perm) {
-    return perm == Svc::MemoryPermission::ReadWrite;
-}
-
-constexpr bool IsValidMapToOwnerCodeMemoryPermission(Svc::MemoryPermission perm) {
-    return perm == Svc::MemoryPermission::Read || perm == Svc::MemoryPermission::ReadExecute;
-}
-
-constexpr bool IsValidUnmapCodeMemoryPermission(Svc::MemoryPermission perm) {
-    return perm == Svc::MemoryPermission::None;
-}
-
-constexpr bool IsValidUnmapFromOwnerCodeMemoryPermission(Svc::MemoryPermission perm) {
-    return perm == Svc::MemoryPermission::None;
-}
-
 } // Anonymous namespace
 
 static ResultCode MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
@@ -1328,195 +1306,6 @@ static ResultCode SetProcessMemoryPermission(Core::System& system, Handle proces
     return page_table.SetProcessMemoryPermission(address, size, ConvertToKMemoryPermission(perm));
 }
 
-static ResultCode MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
-                                   VAddr src_address, u64 size) {
-    LOG_TRACE(Kernel_SVC,
-              "called, dst_address=0x{:X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
-              dst_address, process_handle, src_address, size);
-
-    // Validate the address/size.
-    R_UNLESS(Common::IsAligned(dst_address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(src_address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
-    R_UNLESS(size > 0, ResultInvalidSize);
-    R_UNLESS((dst_address < dst_address + size), ResultInvalidCurrentMemory);
-    R_UNLESS((src_address < src_address + size), ResultInvalidCurrentMemory);
-
-    // Get the processes.
-    KProcess* dst_process = system.CurrentProcess();
-    KScopedAutoObject src_process =
-        dst_process->GetHandleTable().GetObjectWithoutPseudoHandle<KProcess>(process_handle);
-    R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);
-
-    // Get the page tables.
-    auto& dst_pt = dst_process->PageTable();
-    auto& src_pt = src_process->PageTable();
-
-    // Validate that the mapping is in range.
-    R_UNLESS(src_pt.Contains(src_address, size), ResultInvalidCurrentMemory);
-    R_UNLESS(dst_pt.CanContain(dst_address, size, KMemoryState::SharedCode),
-             ResultInvalidMemoryRegion);
-
-    // Create a new page group.
-    KMemoryInfo kBlockInfo = dst_pt.QueryInfo(dst_address);
-    KPageLinkedList pg(kBlockInfo.GetAddress(), kBlockInfo.GetNumPages());
-
-    // Map the group.
-    R_TRY(dst_pt.MapPages(dst_address, pg, KMemoryState::SharedCode,
-                          KMemoryPermission::UserReadWrite));
-
-    return ResultSuccess;
-}
-
-static ResultCode UnmapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
-                                     VAddr src_address, u64 size) {
-    LOG_TRACE(Kernel_SVC,
-              "called, dst_address=0x{:X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
-              dst_address, process_handle, src_address, size);
-
-    // Validate the address/size.
-    R_UNLESS(Common::IsAligned(dst_address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(src_address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
-    R_UNLESS(size > 0, ResultInvalidSize);
-    R_UNLESS((dst_address < dst_address + size), ResultInvalidCurrentMemory);
-    R_UNLESS((src_address < src_address + size), ResultInvalidCurrentMemory);
-
-    // Get the processes.
-    KProcess* dst_process = system.CurrentProcess();
-    KScopedAutoObject src_process =
-        dst_process->GetHandleTable().GetObjectWithoutPseudoHandle<KProcess>(process_handle);
-    R_UNLESS(src_process.IsNotNull(), ResultInvalidHandle);
-
-    // Get the page tables.
-    auto& dst_pt = dst_process->PageTable();
-    auto& src_pt = src_process->PageTable();
-
-    // Validate that the mapping is in range.
-    R_UNLESS(src_pt.Contains(src_address, size), ResultInvalidCurrentMemory);
-    R_UNLESS(dst_pt.CanContain(dst_address, size, KMemoryState::SharedCode),
-             ResultInvalidMemoryRegion);
-
-    // Unmap the memory.
-    R_TRY(dst_pt.UnmapProcessMemory(dst_address, size, src_pt, src_address));
-
-    return ResultSuccess;
-}
-
-static ResultCode CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t size) {
-    LOG_TRACE(Kernel_SVC, "called, handle_out=0x{:X}, address=0x{:X}, size=0x{:X}",
-              static_cast<void*>(out), address, size);
-    // Get kernel instance.
-    auto& kernel = system.Kernel();
-
-    // Validate address / size.
-    R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
-    R_UNLESS(size > 0, ResultInvalidSize);
-    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
-
-    // Create the code memory.
-
-    KCodeMemory* code_mem = KCodeMemory::Create(kernel);
-    R_UNLESS(code_mem != nullptr, ResultOutOfResource);
-
-    // Verify that the region is in range.
-    R_UNLESS(system.CurrentProcess()->PageTable().Contains(address, size),
-             ResultInvalidCurrentMemory);
-
-    // Initialize the code memory.
-    R_TRY(code_mem->Initialize(system.DeviceMemory(), address, size));
-
-    // Register the code memory.
-    KCodeMemory::Register(kernel, code_mem);
-
-    // Add the code memory to the handle table.
-    R_TRY(system.CurrentProcess()->GetHandleTable().Add(out, code_mem));
-
-    code_mem->Close();
-
-    return ResultSuccess;
-}
-
-static ResultCode ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 operation,
-                                    VAddr address, size_t size, Svc::MemoryPermission perm) {
-
-    LOG_TRACE(Kernel_SVC,
-              "called, code_memory_handle=0x{:X}, operation=0x{:X}, address=0x{:X}, size=0x{:X}, "
-              "permission=0x{:X}",
-              code_memory_handle, operation, address, size, perm);
-
-    // Validate the address / size.
-    R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
-    R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
-    R_UNLESS(size > 0, ResultInvalidSize);
-    R_UNLESS((address < address + size), ResultInvalidCurrentMemory);
-
-    // Get the code memory from its handle.
-    KScopedAutoObject code_mem =
-        system.CurrentProcess()->GetHandleTable().GetObject<KCodeMemory>(code_memory_handle);
-    R_UNLESS(code_mem.IsNotNull(), ResultInvalidHandle);
-
-    // NOTE: Here, Atmosphere extends the SVC to allow code memory operations on one's own process.
-    // This enables homebrew usage of these SVCs for JIT.
-
-    // Perform the operation.
-    switch (static_cast<CodeMemoryOperation>(operation)) {
-    case CodeMemoryOperation::Map: {
-        // Check that the region is in range.
-        R_UNLESS(
-            system.CurrentProcess()->PageTable().CanContain(address, size, KMemoryState::CodeOut),
-            ResultInvalidMemoryRegion);
-
-        // Check the memory permission.
-        R_UNLESS(IsValidMapCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
-
-        // Map the memory.
-        R_TRY(code_mem->Map(address, size));
-    } break;
-    case CodeMemoryOperation::Unmap: {
-        // Check that the region is in range.
-        R_UNLESS(
-            system.CurrentProcess()->PageTable().CanContain(address, size, KMemoryState::CodeOut),
-            ResultInvalidMemoryRegion);
-
-        // Check the memory permission.
-        R_UNLESS(IsValidUnmapCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
-
-        // Unmap the memory.
-        R_TRY(code_mem->Unmap(address, size));
-    } break;
-    case CodeMemoryOperation::MapToOwner: {
-        // Check that the region is in range.
-        R_UNLESS(code_mem->GetOwner()->PageTable().CanContain(address, size,
-                                                              KMemoryState::GeneratedCode),
-                 ResultInvalidMemoryRegion);
-
-        // Check the memory permission.
-        R_UNLESS(IsValidMapToOwnerCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
-
-        // Map the memory to its owner.
-        R_TRY(code_mem->MapToOwner(address, size, perm));
-    } break;
-    case CodeMemoryOperation::UnmapFromOwner: {
-        // Check that the region is in range.
-        R_UNLESS(code_mem->GetOwner()->PageTable().CanContain(address, size,
-                                                              KMemoryState::GeneratedCode),
-                 ResultInvalidMemoryRegion);
-
-        // Check the memory permission.
-        R_UNLESS(IsValidUnmapFromOwnerCodeMemoryPermission(perm), ResultInvalidNewMemoryPermission);
-
-        // Unmap the memory from its owner.
-        R_TRY(code_mem->UnmapFromOwner(address, size));
-    } break;
-    default:
-        return ResultInvalidEnumValue;
-    }
-
-    return ResultSuccess;
-}
-
 static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_address,
                                      VAddr page_info_address, Handle process_handle,
                                      VAddr address) {
@@ -2811,8 +2600,8 @@ static const FunctionDef SVC_Table_64[] = {
     {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
     {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"},
     {0x4A, nullptr, "SetUnsafeLimit"},
-    {0x4B, SvcWrap64<CreateCodeMemory>, "CreateCodeMemory"},
-    {0x4C, SvcWrap64<ControlCodeMemory>, "ControlCodeMemory"},
+    {0x4B, nullptr, "CreateCodeMemory"},
+    {0x4C, nullptr, "ControlCodeMemory"},
     {0x4D, nullptr, "SleepSystem"},
     {0x4E, nullptr, "ReadWriteRegister"},
     {0x4F, nullptr, "SetProcessActivity"},
@@ -2852,8 +2641,8 @@ static const FunctionDef SVC_Table_64[] = {
     {0x71, nullptr, "ManageNamedPort"},
     {0x72, nullptr, "ConnectToPort"},
     {0x73, SvcWrap64<SetProcessMemoryPermission>, "SetProcessMemoryPermission"},
-    {0x74, SvcWrap64<MapProcessMemory>, "MapProcessMemory"},
-    {0x75, SvcWrap64<UnmapProcessMemory>, "UnmapProcessMemory"},
+    {0x74, nullptr, "MapProcessMemory"},
+    {0x75, nullptr, "UnmapProcessMemory"},
     {0x76, SvcWrap64<QueryProcessMemory>, "QueryProcessMemory"},
     {0x77, SvcWrap64<MapProcessCodeMemory>, "MapProcessCodeMemory"},
     {0x78, SvcWrap64<UnmapProcessCodeMemory>, "UnmapProcessCodeMemory"},

src/core/hle/kernel/svc_wrap.h

@@ -73,23 +73,6 @@ void SvcWrap64(Core::System& system) {
                            .raw);
 }
 
-// Used by MapProcessMemory and UnmapProcessMemory
-template <ResultCode func(Core::System&, u64, u32, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
-                            Param(system, 2), Param(system, 3))
-                           .raw);
-}
-
-// Used by ControlCodeMemory
-template <ResultCode func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
-void SvcWrap64(Core::System& system) {
-    FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)),
-                            static_cast<u32>(Param(system, 1)), Param(system, 2), Param(system, 3),
-                            static_cast<Svc::MemoryPermission>(Param(system, 4)))
-                           .raw);
-}
-
 template <ResultCode func(Core::System&, u32*)>
 void SvcWrap64(Core::System& system) {
     u32 param = 0;
@@ -318,16 +301,6 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-// Used by CreateCodeMemory
-template <ResultCode func(Core::System&, Handle*, u64, u64)>
-void SvcWrap64(Core::System& system) {
-    u32 param_1 = 0;
-    const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2)).raw;
-
-    system.CurrentArmInterface().SetReg(1, param_1);
-    FuncReturn(system, retval);
-}
-
 template <ResultCode func(Core::System&, Handle*, u64, u32, u32)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;

src/core/hle/kernel/time_manager.cpp

@@ -5,7 +5,6 @@
 #include "common/assert.h"
 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/time_manager.h"
 
@@ -16,10 +15,7 @@ TimeManager::TimeManager(Core::System& system_) : system{system_} {
         Core::Timing::CreateEvent("Kernel::TimeManagerCallback",
                                   [this](std::uintptr_t thread_handle, std::chrono::nanoseconds) {
                                       KThread* thread = reinterpret_cast<KThread*>(thread_handle);
-                                      {
-                                          KScopedSchedulerLock sl(system.Kernel());
-                                          thread->OnTimer();
-                                      }
+                                      thread->Wakeup();
                                   });
 }
 

src/core/hle/service/glue/glue.cpp

@@ -8,7 +8,6 @@
 #include "core/hle/service/glue/bgtc.h"
 #include "core/hle/service/glue/ectx.h"
 #include "core/hle/service/glue/glue.h"
-#include "core/hle/service/glue/notif.h"
 
 namespace Service::Glue {
 
@@ -25,9 +24,6 @@ void InstallInterfaces(Core::System& system) {
 
     // Error Context
     std::make_shared<ECTX_AW>(system)->InstallAsService(system.ServiceManager());
-
-    // Notification Services for application
-    std::make_shared<NOTIF_A>(system)->InstallAsService(system.ServiceManager());
 }
 
 } // namespace Service::Glue

src/core/hle/service/glue/notif.cpp

@@ -1,44 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/glue/notif.h"
-
-namespace Service::Glue {
-
-NOTIF_A::NOTIF_A(Core::System& system_) : ServiceFramework{system_, "notif:a"} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {500, nullptr, "RegisterAlarmSetting"},
-        {510, nullptr, "UpdateAlarmSetting"},
-        {520, &NOTIF_A::ListAlarmSettings, "ListAlarmSettings"},
-        {530, nullptr, "LoadApplicationParameter"},
-        {540, nullptr, "DeleteAlarmSetting"},
-        {1000, &NOTIF_A::Initialize, "Initialize"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-NOTIF_A::~NOTIF_A() = default;
-
-void NOTIF_A::ListAlarmSettings(Kernel::HLERequestContext& ctx) {
-    // Returns an array of AlarmSetting
-    constexpr s32 alarm_count = 0;
-
-    LOG_WARNING(Service_NOTIF, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push(alarm_count);
-}
-
-void NOTIF_A::Initialize(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_NOTIF, "(STUBBED) called");
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-} // namespace Service::Glue

src/core/hle/service/glue/notif.h

@@ -1,25 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Glue {
-
-class NOTIF_A final : public ServiceFramework<NOTIF_A> {
-public:
-    explicit NOTIF_A(Core::System& system_);
-    ~NOTIF_A() override;
-
-private:
-    void ListAlarmSettings(Kernel::HLERequestContext& ctx);
-    void Initialize(Kernel::HLERequestContext& ctx);
-};
-
-} // namespace Service::Glue

src/core/hle/service/hid/controllers/npad.cpp

@@ -110,7 +110,7 @@ void Controller_NPad::ControllerUpdate(Core::HID::ControllerTriggerType type,
         UpdateControllerAt(npad_type, npad_id, is_connected);
         break;
     case Core::HID::ControllerTriggerType::Battery: {
-        if (!controller.device->IsConnected()) {
+        if (!controller.is_connected) {
             return;
         }
         auto& shared_memory = controller.shared_memory_entry;
@@ -150,6 +150,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         shared_memory.system_properties.is_vertical.Assign(1);
         shared_memory.system_properties.use_plus.Assign(1);
         shared_memory.system_properties.use_minus.Assign(1);
+        shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
         shared_memory.applet_footer.type = AppletFooterUiType::SwitchProController;
         break;
     case Core::HID::NpadStyleIndex::Handheld:
@@ -165,30 +166,21 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         break;
     case Core::HID::NpadStyleIndex::JoyconDual:
         shared_memory.style_tag.joycon_dual.Assign(1);
-        if (controller.is_dual_left_connected) {
-            shared_memory.device_type.joycon_left.Assign(1);
-            shared_memory.system_properties.use_minus.Assign(1);
-        }
-        if (controller.is_dual_right_connected) {
-            shared_memory.device_type.joycon_right.Assign(1);
-            shared_memory.system_properties.use_plus.Assign(1);
-        }
-        shared_memory.system_properties.use_directional_buttons.Assign(1);
+        shared_memory.device_type.joycon_left.Assign(1);
+        shared_memory.device_type.joycon_right.Assign(1);
         shared_memory.system_properties.is_vertical.Assign(1);
+        shared_memory.system_properties.use_plus.Assign(1);
+        shared_memory.system_properties.use_minus.Assign(1);
+        shared_memory.system_properties.use_directional_buttons.Assign(1);
         shared_memory.assignment_mode = NpadJoyAssignmentMode::Dual;
-        if (controller.is_dual_left_connected && controller.is_dual_right_connected) {
-            shared_memory.applet_footer.type = AppletFooterUiType::JoyDual;
-        } else if (controller.is_dual_left_connected) {
-            shared_memory.applet_footer.type = AppletFooterUiType::JoyDualLeftOnly;
-        } else {
-            shared_memory.applet_footer.type = AppletFooterUiType::JoyDualRightOnly;
-        }
+        shared_memory.applet_footer.type = AppletFooterUiType::JoyDual;
         break;
     case Core::HID::NpadStyleIndex::JoyconLeft:
         shared_memory.style_tag.joycon_left.Assign(1);
         shared_memory.device_type.joycon_left.Assign(1);
         shared_memory.system_properties.is_horizontal.Assign(1);
         shared_memory.system_properties.use_minus.Assign(1);
+        shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
         shared_memory.applet_footer.type = AppletFooterUiType::JoyLeftHorizontal;
         break;
     case Core::HID::NpadStyleIndex::JoyconRight:
@@ -196,6 +188,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         shared_memory.device_type.joycon_right.Assign(1);
         shared_memory.system_properties.is_horizontal.Assign(1);
         shared_memory.system_properties.use_plus.Assign(1);
+        shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
         shared_memory.applet_footer.type = AppletFooterUiType::JoyRightHorizontal;
         break;
     case Core::HID::NpadStyleIndex::GameCube:
@@ -207,6 +200,7 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
     case Core::HID::NpadStyleIndex::Pokeball:
         shared_memory.style_tag.palma.Assign(1);
         shared_memory.device_type.palma.Assign(1);
+        shared_memory.assignment_mode = NpadJoyAssignmentMode::Single;
         break;
     case Core::HID::NpadStyleIndex::NES:
         shared_memory.style_tag.lark.Assign(1);
@@ -449,15 +443,11 @@ void Controller_NPad::OnUpdate(const Core::Timing::CoreTiming& core_timing, u8*
         case Core::HID::NpadStyleIndex::JoyconDual:
             pad_state.connection_status.raw = 0;
             pad_state.connection_status.is_connected.Assign(1);
-            if (controller.is_dual_left_connected) {
-                pad_state.connection_status.is_left_connected.Assign(1);
-                libnx_state.connection_status.is_left_connected.Assign(1);
-            }
-            if (controller.is_dual_right_connected) {
-                pad_state.connection_status.is_right_connected.Assign(1);
-                libnx_state.connection_status.is_right_connected.Assign(1);
-            }
+            pad_state.connection_status.is_left_connected.Assign(1);
+            pad_state.connection_status.is_right_connected.Assign(1);
 
+            libnx_state.connection_status.is_left_connected.Assign(1);
+            libnx_state.connection_status.is_right_connected.Assign(1);
             pad_state.sampling_number =
                 npad.joy_dual_lifo.ReadCurrentEntry().state.sampling_number + 1;
             npad.joy_dual_lifo.WriteNextEntry(pad_state);
@@ -697,7 +687,7 @@ Controller_NPad::NpadCommunicationMode Controller_NPad::GetNpadCommunicationMode
     return communication_mode;
 }
 
-void Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type,
+void Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id,
                                   NpadJoyAssignmentMode assignment_mode) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
@@ -708,62 +698,6 @@ void Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceTy
     if (controller.shared_memory_entry.assignment_mode != assignment_mode) {
         controller.shared_memory_entry.assignment_mode = assignment_mode;
     }
-
-    if (!controller.device->IsConnected()) {
-        return;
-    }
-
-    if (assignment_mode == NpadJoyAssignmentMode::Dual) {
-        if (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft) {
-            DisconnectNpad(npad_id);
-            controller.is_dual_left_connected = true;
-            controller.is_dual_right_connected = false;
-            UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
-            return;
-        }
-        if (controller.device->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight) {
-            DisconnectNpad(npad_id);
-            controller.is_dual_left_connected = false;
-            controller.is_dual_right_connected = true;
-            UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconDual, npad_id, true);
-            return;
-        }
-        return;
-    }
-
-    // This is for NpadJoyAssignmentMode::Single
-
-    // Only JoyconDual get affected by this function
-    if (controller.device->GetNpadStyleIndex() != Core::HID::NpadStyleIndex::JoyconDual) {
-        return;
-    }
-
-    if (controller.is_dual_left_connected && !controller.is_dual_right_connected) {
-        DisconnectNpad(npad_id);
-        UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
-        return;
-    }
-    if (!controller.is_dual_left_connected && controller.is_dual_right_connected) {
-        DisconnectNpad(npad_id);
-        UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
-        return;
-    }
-
-    // We have two controllers connected to the same npad_id we need to split them
-    const auto npad_id_2 = hid_core.GetFirstDisconnectedNpadId();
-    auto& controller_2 = GetControllerFromNpadIdType(npad_id_2);
-    DisconnectNpad(npad_id);
-    if (npad_device_type == NpadJoyDeviceType::Left) {
-        UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconLeft, npad_id, true);
-        controller_2.is_dual_left_connected = false;
-        controller_2.is_dual_right_connected = true;
-        UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconDual, npad_id_2, true);
-    } else {
-        UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconRight, npad_id, true);
-        controller_2.is_dual_left_connected = true;
-        controller_2.is_dual_right_connected = false;
-        UpdateControllerAt(Core::HID::NpadStyleIndex::JoyconDual, npad_id_2, true);
-    }
 }
 
 bool Controller_NPad::VibrateControllerAtIndex(Core::HID::NpadIdType npad_id,
@@ -973,7 +907,6 @@ void Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     }
 
     auto& shared_memory_entry = controller.shared_memory_entry;
-    // Don't reset shared_memory_entry.assignment_mode this value is persistent
     shared_memory_entry.style_tag.raw = Core::HID::NpadStyleSet::None; // Zero out
     shared_memory_entry.device_type.raw = 0;
     shared_memory_entry.system_properties.raw = 0;
@@ -990,10 +923,9 @@ void Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
         .left = {},
         .right = {},
     };
+    shared_memory_entry.assignment_mode = NpadJoyAssignmentMode::Dual;
     shared_memory_entry.applet_footer.type = AppletFooterUiType::None;
 
-    controller.is_dual_left_connected = true;
-    controller.is_dual_right_connected = true;
     controller.is_connected = false;
     controller.device->Disconnect();
     SignalStyleSetChangedEvent(npad_id);
@@ -1090,70 +1022,19 @@ void Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
                   npad_id_2);
         return;
     }
-    auto& controller_1 = GetControllerFromNpadIdType(npad_id_1);
-    auto& controller_2 = GetControllerFromNpadIdType(npad_id_2);
-    const auto controller_style_1 = controller_1.device->GetNpadStyleIndex();
-    const auto controller_style_2 = controller_2.device->GetNpadStyleIndex();
-    bool merge_controllers = false;
+    auto& controller_1 = GetControllerFromNpadIdType(npad_id_1).device;
+    auto& controller_2 = GetControllerFromNpadIdType(npad_id_2).device;
 
     // If the controllers at both npad indices form a pair of left and right joycons, merge them.
     // Otherwise, do nothing.
-    if (controller_style_1 == Core::HID::NpadStyleIndex::JoyconLeft &&
-        controller_style_2 == Core::HID::NpadStyleIndex::JoyconRight) {
-        merge_controllers = true;
-    }
-    if (controller_style_2 == Core::HID::NpadStyleIndex::JoyconLeft &&
-        controller_style_1 == Core::HID::NpadStyleIndex::JoyconRight) {
-        merge_controllers = true;
-    }
-    if (controller_style_1 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_style_2 == Core::HID::NpadStyleIndex::JoyconRight &&
-        controller_1.is_dual_left_connected && !controller_1.is_dual_right_connected) {
-        merge_controllers = true;
-    }
-    if (controller_style_1 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_style_2 == Core::HID::NpadStyleIndex::JoyconLeft &&
-        !controller_1.is_dual_left_connected && controller_1.is_dual_right_connected) {
-        merge_controllers = true;
-    }
-    if (controller_style_2 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_style_1 == Core::HID::NpadStyleIndex::JoyconRight &&
-        controller_2.is_dual_left_connected && !controller_2.is_dual_right_connected) {
-        merge_controllers = true;
-    }
-    if (controller_style_2 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_style_1 == Core::HID::NpadStyleIndex::JoyconLeft &&
-        !controller_2.is_dual_left_connected && controller_2.is_dual_right_connected) {
-        merge_controllers = true;
-    }
-    if (controller_style_1 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_style_2 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_1.is_dual_left_connected && !controller_1.is_dual_right_connected &&
-        !controller_2.is_dual_left_connected && controller_2.is_dual_right_connected) {
-        merge_controllers = true;
-    }
-    if (controller_style_1 == Core::HID::NpadStyleIndex::JoyconDual &&
-        controller_style_2 == Core::HID::NpadStyleIndex::JoyconDual &&
-        !controller_1.is_dual_left_connected && controller_1.is_dual_right_connected &&
-        controller_2.is_dual_left_connected && !controller_2.is_dual_right_connected) {
-        merge_controllers = true;
-    }
-
-    if (merge_controllers) {
+    if ((controller_1->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft &&
+         controller_2->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight) ||
+        (controller_2->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconLeft &&
+         controller_1->GetNpadStyleIndex() == Core::HID::NpadStyleIndex::JoyconRight)) {
         // Disconnect the joycon at the second id and connect the dual joycon at the first index.
         DisconnectNpad(npad_id_2);
-        controller_1.is_dual_left_connected = true;
-        controller_1.is_dual_right_connected = true;
         AddNewControllerAt(Core::HID::NpadStyleIndex::JoyconDual, npad_id_1);
-        return;
     }
-    LOG_WARNING(Service_HID,
-                "Controllers can't be merged npad_id_1:{}, npad_id_2:{}, type_1:{}, type_2:{}, "
-                "dual_1(left/right):{}/{}, dual_2(left/right):{}/{}",
-                npad_id_1, npad_id_2, controller_1.device->GetNpadStyleIndex(),
-                controller_2.device->GetNpadStyleIndex(), controller_1.is_dual_left_connected,
-                controller_1.is_dual_right_connected, controller_2.is_dual_left_connected,
-                controller_2.is_dual_right_connected);
 }
 
 void Controller_NPad::StartLRAssignmentMode() {

src/core/hle/service/hid/controllers/npad.h

@@ -113,8 +113,7 @@ public:
     void SetNpadCommunicationMode(NpadCommunicationMode communication_mode_);
     NpadCommunicationMode GetNpadCommunicationMode() const;
 
-    void SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type,
-                     NpadJoyAssignmentMode assignment_mode);
+    void SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyAssignmentMode assignment_mode);
 
     bool VibrateControllerAtIndex(Core::HID::NpadIdType npad_id, std::size_t device_index,
                                   const Core::HID::VibrationValue& vibration_value);
@@ -465,10 +464,7 @@ private:
         std::array<VibrationData, 2> vibration{};
         bool unintended_home_button_input_protection{};
         bool is_connected{};
-
-        // Dual joycons can have only one side connected
-        bool is_dual_left_connected{true};
-        bool is_dual_right_connected{true};
+        Core::HID::NpadStyleIndex npad_type{Core::HID::NpadStyleIndex::None};
 
         // Motion parameters
         bool sixaxis_at_rest{true};

src/core/hle/service/hid/hid.cpp

@@ -293,8 +293,8 @@ Hid::Hid(Core::System& system_)
         {132, &Hid::EnableUnintendedHomeButtonInputProtection, "EnableUnintendedHomeButtonInputProtection"},
         {133, nullptr, "SetNpadJoyAssignmentModeSingleWithDestination"},
         {134, &Hid::SetNpadAnalogStickUseCenterClamp, "SetNpadAnalogStickUseCenterClamp"},
-        {135, &Hid::SetNpadCaptureButtonAssignment, "SetNpadCaptureButtonAssignment"},
-        {136, &Hid::ClearNpadCaptureButtonAssignment, "ClearNpadCaptureButtonAssignment"},
+        {135, nullptr, "SetNpadCaptureButtonAssignment"},
+        {136, nullptr, "ClearNpadCaptureButtonAssignment"},
         {200, &Hid::GetVibrationDeviceInfo, "GetVibrationDeviceInfo"},
         {201, &Hid::SendVibrationValue, "SendVibrationValue"},
         {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
@@ -975,35 +975,35 @@ void Hid::SetNpadJoyAssignmentModeSingleByDefault(Kernel::HLERequestContext& ctx
     const auto parameters{rp.PopRaw<Parameters>()};
 
     applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetNpadMode(parameters.npad_id, Controller_NPad::NpadJoyDeviceType::Left,
-                     Controller_NPad::NpadJoyAssignmentMode::Single);
+        .SetNpadMode(parameters.npad_id, Controller_NPad::NpadJoyAssignmentMode::Single);
 
-    LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", parameters.npad_id,
-             parameters.applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}",
+                parameters.npad_id, parameters.applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
 }
 
 void Hid::SetNpadJoyAssignmentModeSingle(Kernel::HLERequestContext& ctx) {
+    // TODO: Check the differences between this and SetNpadJoyAssignmentModeSingleByDefault
     IPC::RequestParser rp{ctx};
     struct Parameters {
         Core::HID::NpadIdType npad_id;
         INSERT_PADDING_WORDS_NOINIT(1);
         u64 applet_resource_user_id;
-        Controller_NPad::NpadJoyDeviceType npad_joy_device_type;
+        u64 npad_joy_device_type;
     };
     static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size.");
 
     const auto parameters{rp.PopRaw<Parameters>()};
 
     applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetNpadMode(parameters.npad_id, parameters.npad_joy_device_type,
-                     Controller_NPad::NpadJoyAssignmentMode::Single);
+        .SetNpadMode(parameters.npad_id, Controller_NPad::NpadJoyAssignmentMode::Single);
 
-    LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}",
-             parameters.npad_id, parameters.applet_resource_user_id,
-             parameters.npad_joy_device_type);
+    LOG_WARNING(Service_HID,
+                "(STUBBED) called, npad_id={}, applet_resource_user_id={}, npad_joy_device_type={}",
+                parameters.npad_id, parameters.applet_resource_user_id,
+                parameters.npad_joy_device_type);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
@@ -1021,10 +1021,10 @@ void Hid::SetNpadJoyAssignmentModeDual(Kernel::HLERequestContext& ctx) {
     const auto parameters{rp.PopRaw<Parameters>()};
 
     applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetNpadMode(parameters.npad_id, {}, Controller_NPad::NpadJoyAssignmentMode::Dual);
+        .SetNpadMode(parameters.npad_id, Controller_NPad::NpadJoyAssignmentMode::Dual);
 
-    LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", parameters.npad_id,
-             parameters.applet_resource_user_id);
+    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}",
+                parameters.npad_id, parameters.applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);
@@ -1186,37 +1186,6 @@ void Hid::SetNpadAnalogStickUseCenterClamp(Kernel::HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
-void Hid::SetNpadCaptureButtonAssignment(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    struct Parameters {
-        Core::HID::NpadStyleSet npad_styleset;
-        INSERT_PADDING_WORDS_NOINIT(1);
-        u64 applet_resource_user_id;
-        Core::HID::NpadButton button;
-    };
-    static_assert(sizeof(Parameters) == 0x18, "Parameters has incorrect size.");
-
-    const auto parameters{rp.PopRaw<Parameters>()};
-
-    LOG_WARNING(Service_HID,
-                "(STUBBED) called, npad_styleset={}, applet_resource_user_id={}, button={}",
-                parameters.npad_styleset, parameters.applet_resource_user_id, parameters.button);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void Hid::ClearNpadCaptureButtonAssignment(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_WARNING(Service_HID, "(STUBBED) called, applet_resource_user_id={}",
-                applet_resource_user_id);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
 void Hid::GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     const auto vibration_device_handle{rp.PopRaw<Core::HID::VibrationDeviceHandle>()};

src/core/hle/service/hid/hid.h

@@ -136,8 +136,6 @@ private:
     void IsUnintendedHomeButtonInputProtectionEnabled(Kernel::HLERequestContext& ctx);
     void EnableUnintendedHomeButtonInputProtection(Kernel::HLERequestContext& ctx);
     void SetNpadAnalogStickUseCenterClamp(Kernel::HLERequestContext& ctx);
-    void SetNpadCaptureButtonAssignment(Kernel::HLERequestContext& ctx);
-    void ClearNpadCaptureButtonAssignment(Kernel::HLERequestContext& ctx);
     void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx);
     void SendVibrationValue(Kernel::HLERequestContext& ctx);
     void GetActualVibrationValue(Kernel::HLERequestContext& ctx);

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -20,12 +20,8 @@ NvResult nvhost_nvdec::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>&
     switch (command.group) {
     case 0x0:
         switch (command.cmd) {
-        case 0x1: {
-            if (!fd_to_id.contains(fd)) {
-                fd_to_id[fd] = next_id++;
-            }
-            return Submit(fd, input, output);
-        }
+        case 0x1:
+            return Submit(input, output);
         case 0x2:
             return GetSyncpoint(input, output);
         case 0x3:
@@ -70,10 +66,7 @@ void nvhost_nvdec::OnOpen(DeviceFD fd) {}
 
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
-    const auto iter = fd_to_id.find(fd);
-    if (iter != fd_to_id.end()) {
-        system.GPU().ClearCdmaInstance(iter->second);
-    }
+    system.GPU().ClearCdmaInstance();
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec.h

@@ -24,9 +24,6 @@ public:
 
     void OnOpen(DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
-
-private:
-    u32 next_id{};
 };
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -59,8 +59,7 @@ NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::Submit(DeviceFD fd, const std::vector<u8>& input,
-                                     std::vector<u8>& output) {
+NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
     IoctlSubmit params{};
     std::memcpy(&params, input.data(), sizeof(IoctlSubmit));
     LOG_DEBUG(Service_NVDRV, "called NVDEC Submit, cmd_buffer_count={}", params.cmd_buffer_count);
@@ -94,7 +93,7 @@ NvResult nvhost_nvdec_common::Submit(DeviceFD fd, const std::vector<u8>& input,
         Tegra::ChCommandHeaderList cmdlist(cmd_buffer.word_count);
         system.Memory().ReadBlock(object->addr + cmd_buffer.offset, cmdlist.data(),
                                   cmdlist.size() * sizeof(u32));
-        gpu.PushCommandBuffer(fd_to_id[fd], cmdlist);
+        gpu.PushCommandBuffer(cmdlist);
     }
     std::memcpy(output.data(), &params, sizeof(IoctlSubmit));
     // Some games expect command_buffers to be written back

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -104,14 +104,13 @@ protected:
 
     /// Ioctl command implementations
     NvResult SetNVMAPfd(const std::vector<u8>& input);
-    NvResult Submit(DeviceFD fd, const std::vector<u8>& input, std::vector<u8>& output);
+    NvResult Submit(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult GetSyncpoint(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult GetWaitbase(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult MapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output);
 
-    std::unordered_map<DeviceFD, u32> fd_to_id{};
     s32_le nvmap_fd{};
     u32_le submit_timeout{};
     std::shared_ptr<nvmap> nvmap_dev;

src/core/hle/service/nvdrv/devices/nvhost_vic.cpp

@@ -21,10 +21,7 @@ NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& i
     case 0x0:
         switch (command.cmd) {
         case 0x1:
-            if (!fd_to_id.contains(fd)) {
-                fd_to_id[fd] = next_id++;
-            }
-            return Submit(fd, input, output);
+            return Submit(input, output);
         case 0x2:
             return GetSyncpoint(input, output);
         case 0x3:
@@ -68,10 +65,7 @@ NvResult nvhost_vic::Ioctl3(DeviceFD fd, Ioctl command, const std::vector<u8>& i
 void nvhost_vic::OnOpen(DeviceFD fd) {}
 
 void nvhost_vic::OnClose(DeviceFD fd) {
-    const auto iter = fd_to_id.find(fd);
-    if (iter != fd_to_id.end()) {
-        system.GPU().ClearCdmaInstance(iter->second);
-    }
+    system.GPU().ClearCdmaInstance();
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_vic.h

@@ -23,8 +23,5 @@ public:
 
     void OnOpen(DeviceFD fd) override;
     void OnClose(DeviceFD fd) override;
-
-private:
-    u32 next_id{};
 };
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/nvdata.h

@@ -1,7 +1,3 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
 #pragma once
 
 #include <array>

src/core/loader/deconstructed_rom_directory.cpp

@@ -125,9 +125,8 @@ AppLoader_DeconstructedRomDirectory::LoadResult AppLoader_DeconstructedRomDirect
     }
     metadata.Print();
 
-    const auto static_modules = {"rtld",    "main",    "subsdk0", "subsdk1", "subsdk2",
-                                 "subsdk3", "subsdk4", "subsdk5", "subsdk6", "subsdk7",
-                                 "subsdk8", "subsdk9", "sdk"};
+    const auto static_modules = {"rtld",    "main",    "subsdk0", "subsdk1", "subsdk2", "subsdk3",
+                                 "subsdk4", "subsdk5", "subsdk6", "subsdk7", "sdk"};
 
     // Use the NSO module loader to figure out the code layout
     std::size_t code_size{};

src/input_common/drivers/gc_adapter.cpp

@@ -69,7 +69,7 @@ private:
     libusb_device_handle* handle{};
 };
 
-GCAdapter::GCAdapter(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+GCAdapter::GCAdapter(const std::string& input_engine_) : InputEngine(input_engine_) {
     if (usb_adapter_handle) {
         return;
     }
@@ -325,8 +325,8 @@ bool GCAdapter::GetGCEndpoint(libusb_device* device) {
     return true;
 }
 
-Common::Input::VibrationError GCAdapter::SetRumble(
-    const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
+Common::Input::VibrationError GCAdapter::SetRumble(const PadIdentifier& identifier,
+                                                   const Common::Input::VibrationStatus vibration) {
     const auto mean_amplitude = (vibration.low_amplitude + vibration.high_amplitude) * 0.5f;
     const auto processed_amplitude =
         static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);

src/input_common/drivers/gc_adapter.h

@@ -22,13 +22,13 @@ namespace InputCommon {
 class LibUSBContext;
 class LibUSBDeviceHandle;
 
-class GCAdapter : public InputEngine {
+class GCAdapter : public InputCommon::InputEngine {
 public:
-    explicit GCAdapter(std::string input_engine_);
-    ~GCAdapter() override;
+    explicit GCAdapter(const std::string& input_engine_);
+    ~GCAdapter();
 
     Common::Input::VibrationError SetRumble(
-        const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) override;
+        const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
 
     /// Used for automapping features
     std::vector<Common::ParamPackage> GetInputDevices() const override;

src/input_common/drivers/keyboard.cpp

@@ -24,7 +24,7 @@ constexpr PadIdentifier keyboard_modifier_identifier = {
     .pad = 1,
 };
 
-Keyboard::Keyboard(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+Keyboard::Keyboard(const std::string& input_engine_) : InputEngine(input_engine_) {
     // Keyboard is broken into 3 diferent sets:
     // key: Unfiltered intended for controllers.
     // keyboard_key: Allows only Settings::NativeKeyboard::Keys intended for keyboard emulation.

src/input_common/drivers/keyboard.h

@@ -12,9 +12,9 @@ namespace InputCommon {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class Keyboard final : public InputEngine {
+class Keyboard final : public InputCommon::InputEngine {
 public:
-    explicit Keyboard(std::string input_engine_);
+    explicit Keyboard(const std::string& input_engine_);
 
     /**
      * Sets the status of all buttons bound with the key to pressed

src/input_common/drivers/mouse.cpp

@@ -24,7 +24,7 @@ constexpr PadIdentifier identifier = {
     .pad = 0,
 };
 
-Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+Mouse::Mouse(const std::string& input_engine_) : InputEngine(input_engine_) {
     PreSetController(identifier);
     PreSetAxis(identifier, mouse_axis_x);
     PreSetAxis(identifier, mouse_axis_y);

src/input_common/drivers/mouse.h

@@ -27,9 +27,9 @@ enum class MouseButton {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class Mouse final : public InputEngine {
+class Mouse final : public InputCommon::InputEngine {
 public:
-    explicit Mouse(std::string input_engine_);
+    explicit Mouse(const std::string& input_engine_);
 
     /**
      * Signals that mouse has moved.

src/input_common/drivers/sdl_driver.cpp

@@ -88,7 +88,7 @@ public:
         return true;
     }
 
-    const BasicMotion& GetMotion() const {
+    BasicMotion GetMotion() {
         return motion;
     }
 
@@ -367,7 +367,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
             if (joystick->UpdateMotion(event.csensor)) {
                 const PadIdentifier identifier = joystick->GetPadIdentifier();
                 SetMotion(identifier, 0, joystick->GetMotion());
-            }
+            };
         }
         break;
     }
@@ -387,7 +387,7 @@ void SDLDriver::CloseJoysticks() {
     joystick_map.clear();
 }
 
-SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+SDLDriver::SDLDriver(const std::string& input_engine_) : InputEngine(input_engine_) {
     if (!Settings::values.enable_raw_input) {
         // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
         SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
@@ -403,11 +403,10 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
 
     // Use hidapi driver for joycons. This will allow joycons to be detected as a GameController and
     // not a generic one
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
+    SDL_SetHint("SDL_JOYSTICK_HIDAPI_JOY_CONS", "1");
 
-    // Disable hidapi driver for xbox. Already default on Windows, this causes conflict with native
-    // driver on Linux.
-    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX, "0");
+    // Turn off Pro controller home led
+    SDL_SetHint("SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED", "0");
 
     // If the frontend is going to manage the event loop, then we don't start one here
     start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0;
@@ -492,9 +491,8 @@ std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
     }
     return devices;
 }
-
-Common::Input::VibrationError SDLDriver::SetRumble(
-    const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) {
+Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifier,
+                                                   const Common::Input::VibrationStatus vibration) {
     const auto joystick =
         GetSDLJoystickByGUID(identifier.guid.Format(), static_cast<int>(identifier.port));
     const auto process_amplitude_exp = [](f32 amplitude, f32 factor) {
@@ -528,7 +526,6 @@ Common::Input::VibrationError SDLDriver::SetRumble(
 
     return Common::Input::VibrationError::None;
 }
-
 Common::ParamPackage SDLDriver::BuildAnalogParamPackageForButton(int port, std::string guid,
                                                                  s32 axis, float value) const {
     Common::ParamPackage params{};

src/input_common/drivers/sdl_driver.h

@@ -19,19 +19,19 @@ using SDL_GameController = struct _SDL_GameController;
 using SDL_Joystick = struct _SDL_Joystick;
 using SDL_JoystickID = s32;
 
-namespace InputCommon {
-
-class SDLJoystick;
-
 using ButtonBindings =
     std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerButton>, 17>;
 using ZButtonBindings =
     std::array<std::pair<Settings::NativeButton::Values, SDL_GameControllerAxis>, 2>;
 
-class SDLDriver : public InputEngine {
+namespace InputCommon {
+
+class SDLJoystick;
+
+class SDLDriver : public InputCommon::InputEngine {
 public:
     /// Initializes and registers SDL device factories
-    explicit SDLDriver(std::string input_engine_);
+    SDLDriver(const std::string& input_engine_);
 
     /// Unregisters SDL device factories and shut them down.
     ~SDLDriver() override;
@@ -59,7 +59,7 @@ public:
     u8 GetHatButtonId(const std::string& direction_name) const override;
 
     Common::Input::VibrationError SetRumble(
-        const PadIdentifier& identifier, const Common::Input::VibrationStatus& vibration) override;
+        const PadIdentifier& identifier, const Common::Input::VibrationStatus vibration) override;
 
 private:
     void InitJoystick(int joystick_index);

src/input_common/drivers/tas_input.cpp

@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
+#include <regex>
 #include <fmt/format.h>
 
 #include "common/fs/file.h"
@@ -14,7 +15,7 @@
 
 namespace InputCommon::TasInput {
 
-enum class Tas::TasAxis : u8 {
+enum TasAxes : u8 {
     StickX,
     StickY,
     SubstickX,
@@ -46,7 +47,7 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_but
     {"KEY_ZR", TasButton::TRIGGER_ZR},
 };
 
-Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engine_) {
     for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) {
         PadIdentifier identifier{
             .guid = Common::UUID{},
@@ -65,7 +66,7 @@ Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
 
 Tas::~Tas() {
     Stop();
-}
+};
 
 void Tas::LoadTasFiles() {
     script_length = 0;
@@ -78,43 +79,43 @@ void Tas::LoadTasFiles() {
 }
 
 void Tas::LoadTasFile(size_t player_index, size_t file_index) {
-    commands[player_index].clear();
-
+    if (!commands[player_index].empty()) {
+        commands[player_index].clear();
+    }
     std::string file = Common::FS::ReadStringFromFile(
         Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) /
             fmt::format("script{}-{}.txt", file_index, player_index + 1),
         Common::FS::FileType::BinaryFile);
-    std::istringstream command_line(file);
+    std::stringstream command_line(file);
     std::string line;
     int frame_no = 0;
     while (std::getline(command_line, line, '\n')) {
         if (line.empty()) {
             continue;
         }
+        std::smatch m;
 
-        std::vector<std::string> seg_list;
-        {
-            std::istringstream line_stream(line);
-            std::string segment;
-            while (std::getline(line_stream, segment, ' ')) {
-                seg_list.push_back(std::move(segment));
-            }
+        std::stringstream linestream(line);
+        std::string segment;
+        std::vector<std::string> seglist;
+
+        while (std::getline(linestream, segment, ' ')) {
+            seglist.push_back(segment);
         }
 
-        if (seg_list.size() < 4) {
+        if (seglist.size() < 4) {
             continue;
         }
 
-        const auto num_frames = std::stoi(seg_list[0]);
-        while (frame_no < num_frames) {
-            commands[player_index].emplace_back();
+        while (frame_no < std::stoi(seglist.at(0))) {
+            commands[player_index].push_back({});
             frame_no++;
         }
 
         TASCommand command = {
-            .buttons = ReadCommandButtons(seg_list[1]),
-            .l_axis = ReadCommandAxis(seg_list[2]),
-            .r_axis = ReadCommandAxis(seg_list[3]),
+            .buttons = ReadCommandButtons(seglist.at(1)),
+            .l_axis = ReadCommandAxis(seglist.at(2)),
+            .r_axis = ReadCommandAxis(seglist.at(3)),
         };
         commands[player_index].push_back(command);
         frame_no++;
@@ -122,17 +123,16 @@ void Tas::LoadTasFile(size_t player_index, size_t file_index) {
     LOG_INFO(Input, "TAS file loaded! {} frames", frame_no);
 }
 
-void Tas::WriteTasFile(std::u8string_view file_name) {
+void Tas::WriteTasFile(std::u8string file_name) {
     std::string output_text;
     for (size_t frame = 0; frame < record_commands.size(); frame++) {
         const TASCommand& line = record_commands[frame];
         output_text += fmt::format("{} {} {} {}\n", frame, WriteCommandButtons(line.buttons),
                                    WriteCommandAxis(line.l_axis), WriteCommandAxis(line.r_axis));
     }
-
-    const auto tas_file_name = Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name;
-    const auto bytes_written =
-        Common::FS::WriteStringToFile(tas_file_name, Common::FS::FileType::TextFile, output_text);
+    const auto bytes_written = Common::FS::WriteStringToFile(
+        Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name,
+        Common::FS::FileType::TextFile, output_text);
     if (bytes_written == output_text.size()) {
         LOG_INFO(Input, "TAS file written to file!");
     } else {
@@ -205,10 +205,10 @@ void Tas::UpdateThread() {
                 const int button = static_cast<int>(i);
                 SetButton(identifier, button, button_status);
             }
-            SetTasAxis(identifier, TasAxis::StickX, command.l_axis.x);
-            SetTasAxis(identifier, TasAxis::StickY, command.l_axis.y);
-            SetTasAxis(identifier, TasAxis::SubstickX, command.r_axis.x);
-            SetTasAxis(identifier, TasAxis::SubstickY, command.r_axis.y);
+            SetAxis(identifier, TasAxes::StickX, command.l_axis.x);
+            SetAxis(identifier, TasAxes::StickY, command.l_axis.y);
+            SetAxis(identifier, TasAxes::SubstickX, command.r_axis.x);
+            SetAxis(identifier, TasAxes::SubstickY, command.r_axis.y);
         }
     } else {
         is_running = Settings::values.tas_loop.GetValue();
@@ -224,28 +224,27 @@ void Tas::ClearInput() {
 }
 
 TasAnalog Tas::ReadCommandAxis(const std::string& line) const {
-    std::vector<std::string> seg_list;
-    {
-        std::istringstream line_stream(line);
-        std::string segment;
-        while (std::getline(line_stream, segment, ';')) {
-            seg_list.push_back(std::move(segment));
-        }
+    std::stringstream linestream(line);
+    std::string segment;
+    std::vector<std::string> seglist;
+
+    while (std::getline(linestream, segment, ';')) {
+        seglist.push_back(segment);
     }
 
-    const float x = std::stof(seg_list.at(0)) / 32767.0f;
-    const float y = std::stof(seg_list.at(1)) / 32767.0f;
+    const float x = std::stof(seglist.at(0)) / 32767.0f;
+    const float y = std::stof(seglist.at(1)) / 32767.0f;
 
     return {x, y};
 }
 
-u64 Tas::ReadCommandButtons(const std::string& line) const {
-    std::istringstream button_text(line);
-    std::string button_line;
+u64 Tas::ReadCommandButtons(const std::string& data) const {
+    std::stringstream button_text(data);
+    std::string line;
     u64 buttons = 0;
-    while (std::getline(button_text, button_line, ';')) {
-        for (const auto& [text, tas_button] : text_to_tas_button) {
-            if (text == button_line) {
+    while (std::getline(button_text, line, ';')) {
+        for (auto [text, tas_button] : text_to_tas_button) {
+            if (text == line) {
                 buttons |= static_cast<u64>(tas_button);
                 break;
             }
@@ -255,8 +254,8 @@ u64 Tas::ReadCommandButtons(const std::string& line) const {
 }
 
 std::string Tas::WriteCommandButtons(u64 buttons) const {
-    std::string returns;
-    for (const auto& [text_button, tas_button] : text_to_tas_button) {
+    std::string returns = "";
+    for (auto [text_button, tas_button] : text_to_tas_button) {
         if ((buttons & static_cast<u64>(tas_button)) != 0) {
             returns += fmt::format("{};", text_button);
         }
@@ -268,10 +267,6 @@ std::string Tas::WriteCommandAxis(TasAnalog analog) const {
     return fmt::format("{};{}", analog.x * 32767, analog.y * 32767);
 }
 
-void Tas::SetTasAxis(const PadIdentifier& identifier, TasAxis axis, f32 value) {
-    SetAxis(identifier, static_cast<int>(axis), value);
-}
-
 void Tas::StartStop() {
     if (!Settings::values.tas_enable) {
         return;

src/input_common/drivers/tas_input.h

@@ -5,11 +5,11 @@
 #pragma once
 
 #include <array>
-#include <string>
-#include <vector>
 
 #include "common/common_types.h"
+#include "common/settings_input.h"
 #include "input_common/input_engine.h"
+#include "input_common/main.h"
 
 /*
 To play back TAS scripts on Yuzu, select the folder with scripts in the configuration menu below
@@ -81,46 +81,46 @@ enum class TasState {
     Stopped,
 };
 
-class Tas final : public InputEngine {
+class Tas final : public InputCommon::InputEngine {
 public:
-    explicit Tas(std::string input_engine_);
-    ~Tas() override;
+    explicit Tas(const std::string& input_engine_);
+    ~Tas();
 
     /**
      * Changes the input status that will be stored in each frame
-     * @param buttons    Bitfield with the status of the buttons
-     * @param left_axis  Value of the left axis
-     * @param right_axis Value of the right axis
+     * @param buttons: bitfield with the status of the buttons
+     * @param left_axis: value of the left axis
+     * @param right_axis: value of the right axis
      */
     void RecordInput(u64 buttons, TasAnalog left_axis, TasAnalog right_axis);
 
     // Main loop that records or executes input
     void UpdateThread();
 
-    // Sets the flag to start or stop the TAS command execution and swaps controllers profiles
+    //  Sets the flag to start or stop the TAS command excecution and swaps controllers profiles
     void StartStop();
 
-    // Stop the TAS and reverts any controller profile
+    //  Stop the TAS and reverts any controller profile
     void Stop();
 
-    // Sets the flag to reload the file and start from the beginning in the next update
+    // Sets the flag to reload the file and start from the begining in the next update
     void Reset();
 
     /**
      * Sets the flag to enable or disable recording of inputs
-     * @returns true if the current recording status is enabled
+     * @return Returns true if the current recording status is enabled
      */
     bool Record();
 
     /**
      * Saves contents of record_commands on a file
-     * @param overwrite_file Indicates if player 1 should be overwritten
+     * @param overwrite_file: Indicates if player 1 should be overwritten
      */
     void SaveRecording(bool overwrite_file);
 
     /**
      * Returns the current status values of TAS playback/recording
-     * @returns A Tuple of
+     * @return Tuple of
      * TasState indicating the current state out of Running ;
      * Current playback progress ;
      * Total length of script file currently loaded or being recorded
@@ -128,8 +128,6 @@ public:
     std::tuple<TasState, size_t, size_t> GetStatus() const;
 
 private:
-    enum class TasAxis : u8;
-
     struct TASCommand {
         u64 buttons{};
         TasAnalog l_axis{};
@@ -139,31 +137,29 @@ private:
     /// Loads TAS files from all players
     void LoadTasFiles();
 
-    /**
-     * Loads TAS file from the specified player
-     * @param player_index Player number to save the script
-     * @param file_index   Script number of the file
+    /** Loads TAS file from the specified player
+     * @param player_index: player number to save the script
+     * @param file_index: script number of the file
      */
     void LoadTasFile(size_t player_index, size_t file_index);
 
-    /**
-     * Writes a TAS file from the recorded commands
-     * @param file_name Name of the file to be written
+    /** Writes a TAS file from the recorded commands
+     * @param file_name: name of the file to be written
      */
-    void WriteTasFile(std::u8string_view file_name);
+    void WriteTasFile(std::u8string file_name);
 
     /**
      * Parses a string containing the axis values. X and Y have a range from -32767 to 32767
-     * @param line String containing axis values with the following format "x;y"
-     * @returns A TAS analog object with axis values with range from -1.0 to 1.0
+     * @param line: string containing axis values with the following format "x;y"
+     * @return Returns a TAS analog object with axis values with range from -1.0 to 1.0
      */
     TasAnalog ReadCommandAxis(const std::string& line) const;
 
     /**
      * Parses a string containing the button values. Each button is represented by it's text format
      * specified in text_to_tas_button array
-     * @param line string containing button name with the following format "a;b;c;d..."
-     * @returns A u64 with each bit representing the status of a button
+     * @param line: string containing button name with the following format "a;b;c;d..."
+     * @return Returns a u64 with each bit representing the status of a button
      */
     u64 ReadCommandButtons(const std::string& line) const;
 
@@ -174,20 +170,17 @@ private:
 
     /**
      * Converts an u64 containing the button status into the text equivalent
-     * @param buttons Bitfield with the status of the buttons
-     * @returns A string with the name of the buttons to be written to the file
+     * @param buttons: bitfield with the status of the buttons
+     * @return Returns a string with the name of the buttons to be written to the file
      */
     std::string WriteCommandButtons(u64 buttons) const;
 
     /**
      * Converts an TAS analog object containing the axis status into the text equivalent
-     * @param analog Value of the axis
-     * @returns A string with the value of the axis to be written to the file
+     * @param data: value of the axis
+     * @return A string with the value of the axis to be written to the file
      */
-    std::string WriteCommandAxis(TasAnalog analog) const;
-
-    /// Sets an axis for a particular pad to the given value.
-    void SetTasAxis(const PadIdentifier& identifier, TasAxis axis, f32 value);
+    std::string WriteCommandAxis(TasAnalog data) const;
 
     size_t script_length{0};
     bool is_recording{false};

src/input_common/drivers/touch_screen.cpp

@@ -13,7 +13,7 @@ constexpr PadIdentifier identifier = {
     .pad = 0,
 };
 
-TouchScreen::TouchScreen(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+TouchScreen::TouchScreen(const std::string& input_engine_) : InputEngine(input_engine_) {
     PreSetController(identifier);
 }
 

src/input_common/drivers/touch_screen.h

@@ -12,9 +12,9 @@ namespace InputCommon {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class TouchScreen final : public InputEngine {
+class TouchScreen final : public InputCommon::InputEngine {
 public:
-    explicit TouchScreen(std::string input_engine_);
+    explicit TouchScreen(const std::string& input_engine_);
 
     /**
      * Signals that mouse has moved.

src/input_common/drivers/udp_client.cpp

@@ -136,7 +136,7 @@ static void SocketLoop(Socket* socket) {
     socket->Loop();
 }
 
-UDPClient::UDPClient(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+UDPClient::UDPClient(const std::string& input_engine_) : InputEngine(input_engine_) {
     LOG_INFO(Input, "Udp Initialization started");
     ReloadSockets();
 }

src/input_common/drivers/udp_client.h

@@ -49,10 +49,10 @@ struct DeviceStatus {
  * A button device factory representing a keyboard. It receives keyboard events and forward them
  * to all button devices it created.
  */
-class UDPClient final : public InputEngine {
+class UDPClient final : public InputCommon::InputEngine {
 public:
-    explicit UDPClient(std::string input_engine_);
-    ~UDPClient() override;
+    explicit UDPClient(const std::string& input_engine_);
+    ~UDPClient();
 
     void ReloadSockets();
 

src/input_common/helpers/stick_from_buttons.cpp

@@ -19,36 +19,23 @@ public:
         : up(std::move(up_)), down(std::move(down_)), left(std::move(left_)),
           right(std::move(right_)), modifier(std::move(modifier_)), modifier_scale(modifier_scale_),
           modifier_angle(modifier_angle_) {
-        up->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback_) {
-                    UpdateUpButtonStatus(callback_);
-                },
-        });
-        down->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback_) {
-                    UpdateDownButtonStatus(callback_);
-                },
-        });
-        left->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback_) {
-                    UpdateLeftButtonStatus(callback_);
-                },
-        });
-        right->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback_) {
-                    UpdateRightButtonStatus(callback_);
-                },
-        });
-        modifier->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback_) {
-                    UpdateModButtonStatus(callback_);
-                },
-        });
+        Common::Input::InputCallback button_up_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateUpButtonStatus(callback_); }};
+        Common::Input::InputCallback button_down_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateDownButtonStatus(callback_); }};
+        Common::Input::InputCallback button_left_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateLeftButtonStatus(callback_); }};
+        Common::Input::InputCallback button_right_callback{
+            [this](Common::Input::CallbackStatus callback_) {
+                UpdateRightButtonStatus(callback_);
+            }};
+        Common::Input::InputCallback button_modifier_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateModButtonStatus(callback_); }};
+        up->SetCallback(button_up_callback);
+        down->SetCallback(button_down_callback);
+        left->SetCallback(button_left_callback);
+        right->SetCallback(button_right_callback);
+        modifier->SetCallback(button_modifier_callback);
         last_x_axis_value = 0.0f;
         last_y_axis_value = 0.0f;
     }
@@ -146,27 +133,27 @@ public:
         }
     }
 
-    void UpdateUpButtonStatus(const Common::Input::CallbackStatus& button_callback) {
+    void UpdateUpButtonStatus(Common::Input::CallbackStatus button_callback) {
         up_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateDownButtonStatus(const Common::Input::CallbackStatus& button_callback) {
+    void UpdateDownButtonStatus(Common::Input::CallbackStatus button_callback) {
         down_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateLeftButtonStatus(const Common::Input::CallbackStatus& button_callback) {
+    void UpdateLeftButtonStatus(Common::Input::CallbackStatus button_callback) {
         left_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateRightButtonStatus(const Common::Input::CallbackStatus& button_callback) {
+    void UpdateRightButtonStatus(Common::Input::CallbackStatus button_callback) {
         right_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateModButtonStatus(const Common::Input::CallbackStatus& button_callback) {
+    void UpdateModButtonStatus(Common::Input::CallbackStatus button_callback) {
         modifier_status = button_callback.button_status.value;
         UpdateStatus();
     }
@@ -278,18 +265,18 @@ private:
     Button left;
     Button right;
     Button modifier;
-    float modifier_scale{};
-    float modifier_angle{};
+    float modifier_scale;
+    float modifier_angle;
     float angle{};
     float goal_angle{};
     float amplitude{};
-    bool up_status{};
-    bool down_status{};
-    bool left_status{};
-    bool right_status{};
-    bool modifier_status{};
-    float last_x_axis_value{};
-    float last_y_axis_value{};
+    bool up_status;
+    bool down_status;
+    bool left_status;
+    bool right_status;
+    bool modifier_status;
+    float last_x_axis_value;
+    float last_y_axis_value;
     const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
     std::chrono::time_point<std::chrono::steady_clock> last_update;
 };

src/input_common/helpers/touch_from_buttons.cpp

@@ -14,13 +14,10 @@ public:
     using Button = std::unique_ptr<Common::Input::InputDevice>;
     TouchFromButtonDevice(Button button_, int touch_id_, float x_, float y_)
         : button(std::move(button_)), touch_id(touch_id_), x(x_), y(y_) {
+        Common::Input::InputCallback button_up_callback{
+            [this](Common::Input::CallbackStatus callback_) { UpdateButtonStatus(callback_); }};
         last_button_value = false;
-        button->SetCallback({
-            .on_change =
-                [this](const Common::Input::CallbackStatus& callback_) {
-                    UpdateButtonStatus(callback_);
-                },
-        });
+        button->SetCallback(button_up_callback);
         button->ForceUpdate();
     }
 
@@ -50,7 +47,7 @@ public:
         return status;
     }
 
-    void UpdateButtonStatus(const Common::Input::CallbackStatus& button_callback) {
+    void UpdateButtonStatus(Common::Input::CallbackStatus button_callback) {
         const Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Touch,
             .touch_status = GetStatus(button_callback.button_status.value),

src/input_common/input_engine.cpp

@@ -10,31 +10,41 @@ namespace InputCommon {
 
 void InputEngine::PreSetController(const PadIdentifier& identifier) {
     std::lock_guard lock{mutex};
-    controller_list.try_emplace(identifier);
+    if (!controller_list.contains(identifier)) {
+        controller_list.insert_or_assign(identifier, ControllerData{});
+    }
 }
 
 void InputEngine::PreSetButton(const PadIdentifier& identifier, int button) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    controller.buttons.try_emplace(button, false);
+    if (!controller.buttons.contains(button)) {
+        controller.buttons.insert_or_assign(button, false);
+    }
 }
 
 void InputEngine::PreSetHatButton(const PadIdentifier& identifier, int button) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    controller.hat_buttons.try_emplace(button, u8{0});
+    if (!controller.hat_buttons.contains(button)) {
+        controller.hat_buttons.insert_or_assign(button, u8{0});
+    }
 }
 
 void InputEngine::PreSetAxis(const PadIdentifier& identifier, int axis) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    controller.axes.try_emplace(axis, 0.0f);
+    if (!controller.axes.contains(axis)) {
+        controller.axes.insert_or_assign(axis, 0.0f);
+    }
 }
 
 void InputEngine::PreSetMotion(const PadIdentifier& identifier, int motion) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    controller.motions.try_emplace(motion);
+    if (!controller.motions.contains(motion)) {
+        controller.motions.insert_or_assign(motion, BasicMotion{});
+    }
 }
 
 void InputEngine::SetButton(const PadIdentifier& identifier, int button, bool value) {
@@ -81,7 +91,7 @@ void InputEngine::SetBattery(const PadIdentifier& identifier, BatteryLevel value
     TriggerOnBatteryChange(identifier, value);
 }
 
-void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value) {
+void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value) {
     {
         std::lock_guard lock{mutex};
         ControllerData& controller = controller_list.at(identifier);
@@ -94,93 +104,85 @@ void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const B
 
 bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
     std::lock_guard lock{mutex};
-    const auto controller_iter = controller_list.find(identifier);
-    if (controller_iter == controller_list.cend()) {
+    if (!controller_list.contains(identifier)) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return false;
     }
-    const ControllerData& controller = controller_iter->second;
-    const auto button_iter = controller.buttons.find(button);
-    if (button_iter == controller.buttons.cend()) {
+    ControllerData controller = controller_list.at(identifier);
+    if (!controller.buttons.contains(button)) {
         LOG_ERROR(Input, "Invalid button {}", button);
         return false;
     }
-    return button_iter->second;
+    return controller.buttons.at(button);
 }
 
 bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const {
     std::lock_guard lock{mutex};
-    const auto controller_iter = controller_list.find(identifier);
-    if (controller_iter == controller_list.cend()) {
+    if (!controller_list.contains(identifier)) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return false;
     }
-    const ControllerData& controller = controller_iter->second;
-    const auto hat_iter = controller.hat_buttons.find(button);
-    if (hat_iter == controller.hat_buttons.cend()) {
+    ControllerData controller = controller_list.at(identifier);
+    if (!controller.hat_buttons.contains(button)) {
         LOG_ERROR(Input, "Invalid hat button {}", button);
         return false;
     }
-    return (hat_iter->second & direction) != 0;
+    return (controller.hat_buttons.at(button) & direction) != 0;
 }
 
 f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
     std::lock_guard lock{mutex};
-    const auto controller_iter = controller_list.find(identifier);
-    if (controller_iter == controller_list.cend()) {
+    if (!controller_list.contains(identifier)) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return 0.0f;
     }
-    const ControllerData& controller = controller_iter->second;
-    const auto axis_iter = controller.axes.find(axis);
-    if (axis_iter == controller.axes.cend()) {
+    ControllerData controller = controller_list.at(identifier);
+    if (!controller.axes.contains(axis)) {
         LOG_ERROR(Input, "Invalid axis {}", axis);
         return 0.0f;
     }
-    return axis_iter->second;
+    return controller.axes.at(axis);
 }
 
 BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
     std::lock_guard lock{mutex};
-    const auto controller_iter = controller_list.find(identifier);
-    if (controller_iter == controller_list.cend()) {
+    if (!controller_list.contains(identifier)) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return BatteryLevel::Charging;
     }
-    const ControllerData& controller = controller_iter->second;
+    ControllerData controller = controller_list.at(identifier);
     return controller.battery;
 }
 
 BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion) const {
     std::lock_guard lock{mutex};
-    const auto controller_iter = controller_list.find(identifier);
-    if (controller_iter == controller_list.cend()) {
+    if (!controller_list.contains(identifier)) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return {};
     }
-    const ControllerData& controller = controller_iter->second;
+    ControllerData controller = controller_list.at(identifier);
     return controller.motions.at(motion);
 }
 
 void InputEngine::ResetButtonState() {
-    for (const auto& controller : controller_list) {
-        for (const auto& button : controller.second.buttons) {
+    for (std::pair<PadIdentifier, ControllerData> controller : controller_list) {
+        for (std::pair<int, bool> button : controller.second.buttons) {
             SetButton(controller.first, button.first, false);
         }
-        for (const auto& button : controller.second.hat_buttons) {
+        for (std::pair<int, bool> button : controller.second.hat_buttons) {
             SetHatButton(controller.first, button.first, false);
         }
     }
 }
 
 void InputEngine::ResetAnalogState() {
-    for (const auto& controller : controller_list) {
-        for (const auto& axis : controller.second.axes) {
+    for (std::pair<PadIdentifier, ControllerData> controller : controller_list) {
+        for (std::pair<int, float> axis : controller.second.axes) {
             SetAxis(controller.first, axis.first, 0.0);
         }
     }
@@ -188,7 +190,7 @@ void InputEngine::ResetAnalogState() {
 
 void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value) {
     std::lock_guard lock{mutex_callback};
-    for (const auto& poller_pair : callback_list) {
+    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Button, button)) {
             continue;
@@ -216,7 +218,7 @@ void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int but
 
 void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value) {
     std::lock_guard lock{mutex_callback};
-    for (const auto& poller_pair : callback_list) {
+    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::HatButton, button)) {
             continue;
@@ -245,7 +247,7 @@ void InputEngine::TriggerOnHatButtonChange(const PadIdentifier& identifier, int
 
 void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value) {
     std::lock_guard lock{mutex_callback};
-    for (const auto& poller_pair : callback_list) {
+    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Analog, axis)) {
             continue;
@@ -272,7 +274,7 @@ void InputEngine::TriggerOnAxisChange(const PadIdentifier& identifier, int axis,
 void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
                                          [[maybe_unused]] BatteryLevel value) {
     std::lock_guard lock{mutex_callback};
-    for (const auto& poller_pair : callback_list) {
+    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Battery, 0)) {
             continue;
@@ -284,9 +286,9 @@ void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
 }
 
 void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
-                                        const BasicMotion& value) {
+                                        BasicMotion value) {
     std::lock_guard lock{mutex_callback};
-    for (const auto& poller_pair : callback_list) {
+    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Motion, motion)) {
             continue;
@@ -340,7 +342,7 @@ const std::string& InputEngine::GetEngineName() const {
 
 int InputEngine::SetCallback(InputIdentifier input_identifier) {
     std::lock_guard lock{mutex_callback};
-    callback_list.insert_or_assign(last_callback_key, std::move(input_identifier));
+    callback_list.insert_or_assign(last_callback_key, input_identifier);
     return last_callback_key++;
 }
 

src/input_common/input_engine.h

@@ -23,15 +23,15 @@ struct PadIdentifier {
     friend constexpr bool operator==(const PadIdentifier&, const PadIdentifier&) = default;
 };
 
-// Basic motion data containing data from the sensors and a timestamp in microseconds
+// Basic motion data containing data from the sensors and a timestamp in microsecons
 struct BasicMotion {
-    float gyro_x{};
-    float gyro_y{};
-    float gyro_z{};
-    float accel_x{};
-    float accel_y{};
-    float accel_z{};
-    u64 delta_timestamp{};
+    float gyro_x;
+    float gyro_y;
+    float gyro_z;
+    float accel_x;
+    float accel_y;
+    float accel_z;
+    u64 delta_timestamp;
 };
 
 // Stages of a battery charge
@@ -102,7 +102,9 @@ struct InputIdentifier {
 
 class InputEngine {
 public:
-    explicit InputEngine(std::string input_engine_) : input_engine{std::move(input_engine_)} {}
+    explicit InputEngine(const std::string& input_engine_) : input_engine(input_engine_) {
+        callback_list.clear();
+    }
 
     virtual ~InputEngine() = default;
 
@@ -114,12 +116,14 @@ public:
 
     // Sets a led pattern for a controller
     virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
-                         [[maybe_unused]] const Common::Input::LedStatus& led_status) {}
+                         [[maybe_unused]] const Common::Input::LedStatus led_status) {
+        return;
+    }
 
     // Sets rumble to a controller
     virtual Common::Input::VibrationError SetRumble(
         [[maybe_unused]] const PadIdentifier& identifier,
-        [[maybe_unused]] const Common::Input::VibrationStatus& vibration) {
+        [[maybe_unused]] const Common::Input::VibrationStatus vibration) {
         return Common::Input::VibrationError::NotSupported;
     }
 
@@ -136,36 +140,36 @@ public:
     /// Used for automapping features
     virtual std::vector<Common::ParamPackage> GetInputDevices() const {
         return {};
-    }
+    };
 
     /// Retrieves the button mappings for the given device
-    virtual ButtonMapping GetButtonMappingForDevice(
+    virtual InputCommon::ButtonMapping GetButtonMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    }
+    };
 
     /// Retrieves the analog mappings for the given device
-    virtual AnalogMapping GetAnalogMappingForDevice(
+    virtual InputCommon::AnalogMapping GetAnalogMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    }
+    };
 
     /// Retrieves the motion mappings for the given device
-    virtual MotionMapping GetMotionMappingForDevice(
+    virtual InputCommon::MotionMapping GetMotionMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    }
+    };
 
     /// Retrieves the name of the given input.
     virtual Common::Input::ButtonNames GetUIName(
         [[maybe_unused]] const Common::ParamPackage& params) const {
         return Common::Input::ButtonNames::Engine;
-    }
+    };
 
     /// Retrieves the index number of the given hat button direction
     virtual u8 GetHatButtonId([[maybe_unused]] const std::string& direction_name) const {
         return 0;
-    }
+    };
 
     void PreSetController(const PadIdentifier& identifier);
     void PreSetButton(const PadIdentifier& identifier, int button);
@@ -190,7 +194,7 @@ protected:
     void SetHatButton(const PadIdentifier& identifier, int button, u8 value);
     void SetAxis(const PadIdentifier& identifier, int axis, f32 value);
     void SetBattery(const PadIdentifier& identifier, BatteryLevel value);
-    void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
+    void SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value);
 
     virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
         return "Unknown";
@@ -202,15 +206,14 @@ private:
         std::unordered_map<int, u8> hat_buttons;
         std::unordered_map<int, float> axes;
         std::unordered_map<int, BasicMotion> motions;
-        BatteryLevel battery{};
+        BatteryLevel battery;
     };
 
     void TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value);
     void TriggerOnHatButtonChange(const PadIdentifier& identifier, int button, u8 value);
-    void TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value);
+    void TriggerOnAxisChange(const PadIdentifier& identifier, int button, f32 value);
     void TriggerOnBatteryChange(const PadIdentifier& identifier, BatteryLevel value);
-    void TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
-                               const BasicMotion& value);
+    void TriggerOnMotionChange(const PadIdentifier& identifier, int motion, BasicMotion value);
 
     bool IsInputIdentifierEqual(const InputIdentifier& input_identifier,
                                 const PadIdentifier& identifier, EngineInputType type,

src/input_common/input_mapping.h

@@ -14,8 +14,8 @@ public:
     MappingFactory();
 
     /**
-     * Resets all variables to begin the mapping process
-     * @param type type of input desired to be returned
+     * Resets all varables to beggin the mapping process
+     * @param "type": type of input desired to be returned
      */
     void BeginMapping(Polling::InputType type);
 
@@ -24,8 +24,8 @@ public:
 
     /**
      * Registers mapping input data from the driver
-     * @param data A struct containing all the information needed to create a proper
-     *             ParamPackage
+     * @param "data": An struct containing all the information needed to create a proper
+     * ParamPackage
      */
     void RegisterInput(const MappingData& data);
 
@@ -34,42 +34,42 @@ public:
 
 private:
     /**
-     * If provided data satisfies the requirements it will push an element to the input_queue
+     * If provided data satisfies the requeriments it will push an element to the input_queue
      * Supported input:
      *     - Button: Creates a basic button ParamPackage
      *     - HatButton: Creates a basic hat button ParamPackage
      *     - Analog: Creates a basic analog ParamPackage
-     * @param data A struct containing all the information needed to create a proper
+     * @param "data": An struct containing all the information needed to create a proper
      * ParamPackage
      */
     void RegisterButton(const MappingData& data);
 
     /**
-     * If provided data satisfies the requirements it will push an element to the input_queue
+     * If provided data satisfies the requeriments it will push an element to the input_queue
      * Supported input:
      *     - Button, HatButton: Pass the data to RegisterButton
      *     - Analog: Stores the first axis and on the second axis creates a basic stick ParamPackage
-     * @param data A struct containing all the information needed to create a proper
-     *             ParamPackage
+     * @param "data": An struct containing all the information needed to create a proper
+     * ParamPackage
      */
     void RegisterStick(const MappingData& data);
 
     /**
-     * If provided data satisfies the requirements it will push an element to the input_queue
+     * If provided data satisfies the requeriments it will push an element to the input_queue
      * Supported input:
      *     - Button, HatButton: Pass the data to RegisterButton
      *     - Analog: Stores the first two axis and on the third axis creates a basic Motion
      * ParamPackage
      *     - Motion: Creates a basic Motion ParamPackage
-     * @param data A struct containing all the information needed to create a proper
-     *             ParamPackage
+     * @param "data": An struct containing all the information needed to create a proper
+     * ParamPackage
      */
     void RegisterMotion(const MappingData& data);
 
     /**
      * Returns true if driver can be mapped
-     * @param data A struct containing all the information needed to create a proper
-     *             ParamPackage
+     * @param "data": An struct containing all the information needed to create a proper
+     * ParamPackage
      */
     bool IsDriverValid(const MappingData& data) const;
 

src/input_common/input_poller.cpp

@@ -12,7 +12,8 @@ namespace InputCommon {
 
 class DummyInput final : public Common::Input::InputDevice {
 public:
-    explicit DummyInput() = default;
+    explicit DummyInput() {}
+    ~DummyInput() {}
 };
 
 class InputFromButton final : public Common::Input::InputDevice {
@@ -32,7 +33,7 @@ public:
         callback_key = input_engine->SetCallback(input_identifier);
     }
 
-    ~InputFromButton() override {
+    ~InputFromButton() {
         input_engine->DeleteCallback(callback_key);
     }
 
@@ -44,7 +45,7 @@ public:
         };
     }
 
-    void ForceUpdate() override {
+    void ForceUpdate() {
         const Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Button,
             .button_status = GetStatus(),
@@ -93,7 +94,7 @@ public:
         callback_key = input_engine->SetCallback(input_identifier);
     }
 
-    ~InputFromHatButton() override {
+    ~InputFromHatButton() {
         input_engine->DeleteCallback(callback_key);
     }
 
@@ -105,7 +106,7 @@ public:
         };
     }
 
-    void ForceUpdate() override {
+    void ForceUpdate() {
         const Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Button,
             .button_status = GetStatus(),
@@ -166,7 +167,7 @@ public:
         callback_key_y = input_engine->SetCallback(y_input_identifier);
     }
 
-    ~InputFromStick() override {
+    ~InputFromStick() {
         input_engine->DeleteCallback(callback_key_x);
         input_engine->DeleteCallback(callback_key_y);
     }
@@ -189,7 +190,7 @@ public:
         return status;
     }
 
-    void ForceUpdate() override {
+    void ForceUpdate() {
         const Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Stick,
             .stick_status = GetStatus(),
@@ -265,7 +266,7 @@ public:
         callback_key_y = input_engine->SetCallback(y_input_identifier);
     }
 
-    ~InputFromTouch() override {
+    ~InputFromTouch() {
         input_engine->DeleteCallback(callback_key_button);
         input_engine->DeleteCallback(callback_key_x);
         input_engine->DeleteCallback(callback_key_y);
@@ -351,7 +352,7 @@ public:
         axis_callback_key = input_engine->SetCallback(axis_input_identifier);
     }
 
-    ~InputFromTrigger() override {
+    ~InputFromTrigger() {
         input_engine->DeleteCallback(callback_key_button);
         input_engine->DeleteCallback(axis_callback_key);
     }
@@ -418,7 +419,7 @@ public:
         callback_key = input_engine->SetCallback(input_identifier);
     }
 
-    ~InputFromAnalog() override {
+    ~InputFromAnalog() {
         input_engine->DeleteCallback(callback_key);
     }
 
@@ -465,7 +466,7 @@ public:
         callback_key = input_engine->SetCallback(input_identifier);
     }
 
-    ~InputFromBattery() override {
+    ~InputFromBattery() {
         input_engine->DeleteCallback(callback_key);
     }
 
@@ -473,7 +474,7 @@ public:
         return static_cast<Common::Input::BatteryLevel>(input_engine->GetBattery(identifier));
     }
 
-    void ForceUpdate() override {
+    void ForceUpdate() {
         const Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Battery,
             .battery_status = GetStatus(),
@@ -517,7 +518,7 @@ public:
         callback_key = input_engine->SetCallback(input_identifier);
     }
 
-    ~InputFromMotion() override {
+    ~InputFromMotion() {
         input_engine->DeleteCallback(callback_key);
     }
 
@@ -592,7 +593,7 @@ public:
         callback_key_z = input_engine->SetCallback(z_input_identifier);
     }
 
-    ~InputFromAxisMotion() override {
+    ~InputFromAxisMotion() {
         input_engine->DeleteCallback(callback_key_x);
         input_engine->DeleteCallback(callback_key_y);
         input_engine->DeleteCallback(callback_key_z);
@@ -617,7 +618,7 @@ public:
         return status;
     }
 
-    void ForceUpdate() override {
+    void ForceUpdate() {
         const Common::Input::CallbackStatus status{
             .type = Common::Input::InputType::Motion,
             .motion_status = GetStatus(),
@@ -667,16 +668,16 @@ public:
     explicit OutputFromIdentifier(PadIdentifier identifier_, InputEngine* input_engine_)
         : identifier(identifier_), input_engine(input_engine_) {}
 
-    void SetLED(const Common::Input::LedStatus& led_status) override {
+    virtual void SetLED(Common::Input::LedStatus led_status) {
         input_engine->SetLeds(identifier, led_status);
     }
 
-    Common::Input::VibrationError SetVibration(
-        const Common::Input::VibrationStatus& vibration_status) override {
+    virtual Common::Input::VibrationError SetVibration(
+        Common::Input::VibrationStatus vibration_status) {
         return input_engine->SetRumble(identifier, vibration_status);
     }
 
-    Common::Input::PollingError SetPollingMode(Common::Input::PollingMode polling_mode) override {
+    virtual Common::Input::PollingError SetPollingMode(Common::Input::PollingMode polling_mode) {
         return input_engine->SetPollingMode(identifier, polling_mode);
     }
 

src/input_common/input_poller.h

@@ -13,6 +13,9 @@ class Factory;
 
 namespace InputCommon {
 class InputEngine;
+/**
+ * An Input factory. It receives input events and forward them to all input devices it created.
+ */
 
 class OutputFactory final : public Common::Input::Factory<Common::Input::OutputDevice> {
 public:
@@ -21,10 +24,10 @@ public:
     /**
      * Creates an output device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "guid" text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique output device with the parameters specified
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique ouput device with the parameters specified
      */
     std::unique_ptr<Common::Input::OutputDevice> Create(
         const Common::ParamPackage& params) override;
@@ -33,9 +36,6 @@ private:
     std::shared_ptr<InputEngine> input_engine;
 };
 
-/**
- * An Input factory. It receives input events and forward them to all input devices it created.
- */
 class InputFactory final : public Common::Input::Factory<Common::Input::InputDevice> {
 public:
     explicit InputFactory(std::shared_ptr<InputEngine> input_engine_);
@@ -54,16 +54,16 @@ public:
      * - battery: Contains "battery"
      * - output: Contains "output"
      * @param params contains parameters for creating the device:
-     *               - "code": the code of the keyboard key to bind with the input
-     *               - "button": same as "code" but for controller buttons
-     *               - "hat": similar as "button" but it's a group of hat buttons from SDL
-     *               - "axis": the axis number of the axis to bind with the input
-     *               - "motion": the motion number of the motion to bind with the input
-     *               - "axis_x": same as axis but specifying horizontal direction
-     *               - "axis_y": same as axis but specifying vertical direction
-     *               - "axis_z": same as axis but specifying forward direction
-     *               - "battery": Only used as a placeholder to set the input type
-     * @returns a unique input device with the parameters specified
+     * @param    - "code": the code of the keyboard key to bind with the input
+     * @param    - "button": same as "code" but for controller buttons
+     * @param    - "hat": similar as "button" but it's a group of hat buttons from SDL
+     * @param    - "axis": the axis number of the axis to bind with the input
+     * @param    - "motion": the motion number of the motion to bind with the input
+     * @param    - "axis_x": same as axis but specifing horizontal direction
+     * @param    - "axis_y": same as axis but specifing vertical direction
+     * @param    - "axis_z": same as axis but specifing forward direction
+     * @param    - "battery": Only used as a placeholder to set the input type
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> Create(const Common::ParamPackage& params) override;
 
@@ -71,14 +71,14 @@ private:
     /**
      * Creates a button device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "code": the code of the keyboard key to bind with the input
-     *               - "button": same as "code" but for controller buttons
-     *               - "toggle": press once to enable, press again to disable
-     *               - "inverted": inverts the output of the button
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "code": the code of the keyboard key to bind with the input
+     * @param    - "button": same as "code" but for controller buttons
+     * @param    - "toggle": press once to enable, press again to disable
+     * @param    - "inverted": inverts the output of the button
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateButtonDevice(
         const Common::ParamPackage& params);
@@ -86,14 +86,14 @@ private:
     /**
      * Creates a hat button device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "button": the controller hat id to bind with the input
-     *               - "direction": the direction id to be detected
-     *               - "toggle": press once to enable, press again to disable
-     *               - "inverted": inverts the output of the button
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "button": the controller hat id to bind with the input
+     * @param    - "direction": the direction id to be detected
+     * @param    - "toggle": press once to enable, press again to disable
+     * @param    - "inverted": inverts the output of the button
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateHatButtonDevice(
         const Common::ParamPackage& params);
@@ -101,19 +101,19 @@ private:
     /**
      * Creates a stick device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "axis_x": the controller horizontal axis id to bind with the input
-     *               - "axis_y": the controller vertical axis id to bind with the input
-     *               - "deadzone": the minimum required value to be detected
-     *               - "range": the maximum value required to reach 100%
-     *               - "threshold": the minimum required value to considered pressed
-     *               - "offset_x": the amount of offset in the x axis
-     *               - "offset_y": the amount of offset in the y axis
-     *               - "invert_x": inverts the sign of the horizontal axis
-     *               - "invert_y": inverts the sign of the vertical axis
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "axis_x": the controller horizontal axis id to bind with the input
+     * @param    - "axis_y": the controller vertical axis id to bind with the input
+     * @param    - "deadzone": the mimimum required value to be detected
+     * @param    - "range": the maximum value required to reach 100%
+     * @param    - "threshold": the mimimum required value to considered pressed
+     * @param    - "offset_x": the amount of offset in the x axis
+     * @param    - "offset_y": the amount of offset in the y axis
+     * @param    - "invert_x": inverts the sign of the horizontal axis
+     * @param    - "invert_y": inverts the sign of the vertical axis
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateStickDevice(
         const Common::ParamPackage& params);
@@ -121,16 +121,16 @@ private:
     /**
      * Creates an analog device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "axis": the controller axis id to bind with the input
-     *               - "deadzone": the minimum required value to be detected
-     *               - "range": the maximum value required to reach 100%
-     *               - "threshold": the minimum required value to considered pressed
-     *               - "offset": the amount of offset in the axis
-     *               - "invert": inverts the sign of the axis
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "axis": the controller axis id to bind with the input
+     * @param    - "deadzone": the mimimum required value to be detected
+     * @param    - "range": the maximum value required to reach 100%
+     * @param    - "threshold": the mimimum required value to considered pressed
+     * @param    - "offset": the amount of offset in the axis
+     * @param    - "invert": inverts the sign of the axis
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateAnalogDevice(
         const Common::ParamPackage& params);
@@ -138,20 +138,20 @@ private:
     /**
      * Creates a trigger device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "button": the controller hat id to bind with the input
-     *               - "direction": the direction id to be detected
-     *               - "toggle": press once to enable, press again to disable
-     *               - "inverted": inverts the output of the button
-     *               - "axis": the controller axis id to bind with the input
-     *               - "deadzone": the minimum required value to be detected
-     *               - "range": the maximum value required to reach 100%
-     *               - "threshold": the minimum required value to considered pressed
-     *               - "offset": the amount of offset in the axis
-     *               - "invert": inverts the sign of the axis
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "button": the controller hat id to bind with the input
+     * @param    - "direction": the direction id to be detected
+     * @param    - "toggle": press once to enable, press again to disable
+     * @param    - "inverted": inverts the output of the button
+     * @param    - "axis": the controller axis id to bind with the input
+     * @param    - "deadzone": the mimimum required value to be detected
+     * @param    - "range": the maximum value required to reach 100%
+     * @param    - "threshold": the mimimum required value to considered pressed
+     * @param    - "offset": the amount of offset in the axis
+     * @param    - "invert": inverts the sign of the axis
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateTriggerDevice(
         const Common::ParamPackage& params);
@@ -159,23 +159,23 @@ private:
     /**
      * Creates a touch device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "button": the controller hat id to bind with the input
-     *               - "direction": the direction id to be detected
-     *               - "toggle": press once to enable, press again to disable
-     *               - "inverted": inverts the output of the button
-     *               - "axis_x": the controller horizontal axis id to bind with the input
-     *               - "axis_y": the controller vertical axis id to bind with the input
-     *               - "deadzone": the minimum required value to be detected
-     *               - "range": the maximum value required to reach 100%
-     *               - "threshold": the minimum required value to considered pressed
-     *               - "offset_x": the amount of offset in the x axis
-     *               - "offset_y": the amount of offset in the y axis
-     *               - "invert_x": inverts the sign of the horizontal axis
-     *               - "invert_y": inverts the sign of the vertical axis
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "button": the controller hat id to bind with the input
+     * @param    - "direction": the direction id to be detected
+     * @param    - "toggle": press once to enable, press again to disable
+     * @param    - "inverted": inverts the output of the button
+     * @param    - "axis_x": the controller horizontal axis id to bind with the input
+     * @param    - "axis_y": the controller vertical axis id to bind with the input
+     * @param    - "deadzone": the mimimum required value to be detected
+     * @param    - "range": the maximum value required to reach 100%
+     * @param    - "threshold": the mimimum required value to considered pressed
+     * @param    - "offset_x": the amount of offset in the x axis
+     * @param    - "offset_y": the amount of offset in the y axis
+     * @param    - "invert_x": inverts the sign of the horizontal axis
+     * @param    - "invert_y": inverts the sign of the vertical axis
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateTouchDevice(
         const Common::ParamPackage& params);
@@ -183,10 +183,10 @@ private:
     /**
      * Creates a battery device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateBatteryDevice(
         const Common::ParamPackage& params);
@@ -194,21 +194,21 @@ private:
     /**
      * Creates a motion device from the parameters given.
      * @param params contains parameters for creating the device:
-     *               - "axis_x": the controller horizontal axis id to bind with the input
-     *               - "axis_y": the controller vertical axis id to bind with the input
-     *               - "axis_z": the controller forward axis id to bind with the input
-     *               - "deadzone": the minimum required value to be detected
-     *               - "range": the maximum value required to reach 100%
-     *               - "offset_x": the amount of offset in the x axis
-     *               - "offset_y": the amount of offset in the y axis
-     *               - "offset_z": the amount of offset in the z axis
-     *               - "invert_x": inverts the sign of the horizontal axis
-     *               - "invert_y": inverts the sign of the vertical axis
-     *               - "invert_z": inverts the sign of the forward axis
-     *               - "guid": text string for identifying controllers
-     *               - "port": port of the connected device
-     *               - "pad": slot of the connected controller
-     * @returns a unique input device with the parameters specified
+     * @param    - "axis_x": the controller horizontal axis id to bind with the input
+     * @param    - "axis_y": the controller vertical axis id to bind with the input
+     * @param    - "axis_z": the controller fordward axis id to bind with the input
+     * @param    - "deadzone": the mimimum required value to be detected
+     * @param    - "range": the maximum value required to reach 100%
+     * @param    - "offset_x": the amount of offset in the x axis
+     * @param    - "offset_y": the amount of offset in the y axis
+     * @param    - "offset_z": the amount of offset in the z axis
+     * @param    - "invert_x": inverts the sign of the horizontal axis
+     * @param    - "invert_y": inverts the sign of the vertical axis
+     * @param    - "invert_z": inverts the sign of the fordward axis
+     * @param    - "guid": text string for identifing controllers
+     * @param    - "port": port of the connected device
+     * @param    - "pad": slot of the connected controller
+     * @return an unique input device with the parameters specified
      */
     std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
 

src/shader_recompiler/CMakeLists.txt

@@ -1,5 +1,7 @@
 add_library(shader_recompiler STATIC
     backend/bindings.h
+    backend/glasm/emit_context.cpp
+    backend/glasm/emit_context.h
     backend/glasm/emit_glasm.cpp
     backend/glasm/emit_glasm.h
     backend/glasm/emit_glasm_barriers.cpp
@@ -20,10 +22,10 @@ add_library(shader_recompiler STATIC
     backend/glasm/emit_glasm_special.cpp
     backend/glasm/emit_glasm_undefined.cpp
     backend/glasm/emit_glasm_warp.cpp
-    backend/glasm/glasm_emit_context.cpp
-    backend/glasm/glasm_emit_context.h
     backend/glasm/reg_alloc.cpp
     backend/glasm/reg_alloc.h
+    backend/glsl/emit_context.cpp
+    backend/glsl/emit_context.h
     backend/glsl/emit_glsl.cpp
     backend/glsl/emit_glsl.h
     backend/glsl/emit_glsl_atomic.cpp
@@ -45,10 +47,10 @@ add_library(shader_recompiler STATIC
     backend/glsl/emit_glsl_special.cpp
     backend/glsl/emit_glsl_undefined.cpp
     backend/glsl/emit_glsl_warp.cpp
-    backend/glsl/glsl_emit_context.cpp
-    backend/glsl/glsl_emit_context.h
     backend/glsl/var_alloc.cpp
     backend/glsl/var_alloc.h
+    backend/spirv/emit_context.cpp
+    backend/spirv/emit_context.h
     backend/spirv/emit_spirv.cpp
     backend/spirv/emit_spirv.h
     backend/spirv/emit_spirv_atomic.cpp
@@ -70,8 +72,6 @@ add_library(shader_recompiler STATIC
     backend/spirv/emit_spirv_special.cpp
     backend/spirv/emit_spirv_undefined.cpp
     backend/spirv/emit_spirv_warp.cpp
-    backend/spirv/spirv_emit_context.cpp
-    backend/spirv/spirv_emit_context.h
     environment.h
     exception.h
     frontend/ir/abstract_syntax_list.h