Revert "video_core/codecs: refactor ffmpeg searching and handling in cmake"

video_core/codecs: refactor ffmpeg searching and handling in cmake

CMakeLists.txt

@@ -131,7 +131,7 @@ add_definitions(-DBOOST_ASIO_DISABLE_CONCEPTS)
 if (MSVC)
     add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/std:c++latest>)
 
-    # cubeb and boost still make use of deprecated result_of.
+    # boost still makes use of deprecated result_of.
     add_definitions(-D_HAS_DEPRECATED_RESULT_OF)
 else()
     set(CMAKE_CXX_STANDARD 20)

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=%237289DA&label=yuzu&logo=discord&logoColor=white"
+        <img src="https://img.shields.io/discord/398318088170242053?color=5865F2&label=yuzu&logo=discord&logoColor=white"
             alt="Discord">
     </a>
 </p>

externals/CMakeLists.txt

@@ -44,10 +44,6 @@ 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

@@ -1,18 +0,0 @@
-# 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,6 +24,7 @@ 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
@@ -36,6 +37,7 @@ if (MSVC)
     add_compile_options(
         /MP
         /Zi
+        /Zm200
         /Zo
         /permissive-
         /EHsc

src/common/input.h

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

src/common/logging/filter.cpp

@@ -114,6 +114,7 @@ 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,6 +82,7 @@ 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,9 +71,6 @@ static CPUCaps Detect() {
     else
         caps.manufacturer = Manufacturer::Unknown;
 
-    u32 family = {};
-    u32 model = {};
-
     __cpuid(cpu_id, 0x80000000);
 
     u32 max_ex_fn = cpu_id[0];
@@ -84,15 +81,6 @@ 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,6 +179,8 @@ 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
@@ -410,6 +412,8 @@ 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/hid/emulated_console.cpp

@@ -66,9 +66,10 @@ void EmulatedConsole::ReloadInput() {
 
     motion_devices = Common::Input::CreateDevice<Common::Input::InputDevice>(motion_params);
     if (motion_devices) {
-        Common::Input::InputCallback motion_callback{
-            [this](Common::Input::CallbackStatus callback) { SetMotion(callback); }};
-        motion_devices->SetCallback(motion_callback);
+        motion_devices->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetMotion(callback); },
+        });
     }
 
     // Unique index for identifying touch device source
@@ -78,9 +79,12 @@ void EmulatedConsole::ReloadInput() {
         if (!touch_device) {
             continue;
         }
-        Common::Input::InputCallback touch_callback{
-            [this, index](Common::Input::CallbackStatus callback) { SetTouch(callback, index); }};
-        touch_device->SetCallback(touch_callback);
+        touch_device->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetTouch(callback, index);
+                },
+        });
         index++;
     }
 }
@@ -127,7 +131,7 @@ void EmulatedConsole::SetMotionParam(Common::ParamPackage param) {
     ReloadInput();
 }
 
-void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
+void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
     std::lock_guard lock{mutex};
     auto& raw_status = console.motion_values.raw_status;
     auto& emulated = console.motion_values.emulated;
@@ -162,8 +166,7 @@ void EmulatedConsole::SetMotion(Common::Input::CallbackStatus callback) {
     TriggerOnChange(ConsoleTriggerType::Motion);
 }
 
-void EmulatedConsole::SetTouch(Common::Input::CallbackStatus callback,
-                               [[maybe_unused]] std::size_t index) {
+void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, 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(Common::Input::CallbackStatus callback);
+    void SetMotion(const 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(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetTouch(const 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,11 +205,12 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{button_params[index].Get("guid", "")};
-        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]->SetCallback({
+            .on_change =
+                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, uuid);
+                },
+        });
         button_devices[index]->ForceUpdate();
     }
 
@@ -218,11 +219,12 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{stick_params[index].Get("guid", "")};
-        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]->SetCallback({
+            .on_change =
+                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, uuid);
+                },
+        });
         stick_devices[index]->ForceUpdate();
     }
 
@@ -231,11 +233,12 @@ void EmulatedController::ReloadInput() {
             continue;
         }
         const auto uuid = Common::UUID{trigger_params[index].Get("guid", "")};
-        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]->SetCallback({
+            .on_change =
+                [this, index, uuid](const Common::Input::CallbackStatus& callback) {
+                    SetTrigger(callback, index, uuid);
+                },
+        });
         trigger_devices[index]->ForceUpdate();
     }
 
@@ -243,9 +246,12 @@ void EmulatedController::ReloadInput() {
         if (!battery_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback battery_callback{
-            [this, index](Common::Input::CallbackStatus callback) { SetBattery(callback, index); }};
-        battery_devices[index]->SetCallback(battery_callback);
+        battery_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetBattery(callback, index);
+                },
+        });
         battery_devices[index]->ForceUpdate();
     }
 
@@ -253,9 +259,12 @@ void EmulatedController::ReloadInput() {
         if (!motion_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback motion_callback{
-            [this, index](Common::Input::CallbackStatus callback) { SetMotion(callback, index); }};
-        motion_devices[index]->SetCallback(motion_callback);
+        motion_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetMotion(callback, index);
+                },
+        });
         motion_devices[index]->ForceUpdate();
     }
 
@@ -267,22 +276,24 @@ void EmulatedController::ReloadInput() {
         if (!tas_button_devices[index]) {
             continue;
         }
-        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);
+        tas_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, tas_uuid);
+                },
+        });
     }
 
     for (std::size_t index = 0; index < tas_stick_devices.size(); ++index) {
         if (!tas_stick_devices[index]) {
             continue;
         }
-        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);
+        tas_stick_devices[index]->SetCallback({
+            .on_change =
+                [this, index, tas_uuid](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, tas_uuid);
+                },
+        });
     }
 }
 
@@ -440,7 +451,7 @@ void EmulatedController::SetButtonParam(std::size_t index, Common::ParamPackage
     if (index >= button_params.size()) {
         return;
     }
-    button_params[index] = param;
+    button_params[index] = std::move(param);
     ReloadInput();
 }
 
@@ -448,7 +459,7 @@ void EmulatedController::SetStickParam(std::size_t index, Common::ParamPackage p
     if (index >= stick_params.size()) {
         return;
     }
-    stick_params[index] = param;
+    stick_params[index] = std::move(param);
     ReloadInput();
 }
 
@@ -456,11 +467,11 @@ void EmulatedController::SetMotionParam(std::size_t index, Common::ParamPackage
     if (index >= motion_params.size()) {
         return;
     }
-    motion_params[index] = param;
+    motion_params[index] = std::move(param);
     ReloadInput();
 }
 
-void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::size_t index,
+void EmulatedController::SetButton(const Common::Input::CallbackStatus& callback, std::size_t index,
                                    Common::UUID uuid) {
     if (index >= controller.button_values.size()) {
         return;
@@ -600,7 +611,7 @@ void EmulatedController::SetButton(Common::Input::CallbackStatus callback, std::
     TriggerOnChange(ControllerTriggerType::Button, true);
 }
 
-void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::size_t index,
+void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback, std::size_t index,
                                   Common::UUID uuid) {
     if (index >= controller.stick_values.size()) {
         return;
@@ -650,8 +661,8 @@ void EmulatedController::SetStick(Common::Input::CallbackStatus callback, std::s
     TriggerOnChange(ControllerTriggerType::Stick, true);
 }
 
-void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std::size_t index,
-                                    Common::UUID uuid) {
+void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callback,
+                                    std::size_t index, Common::UUID uuid) {
     if (index >= controller.trigger_values.size()) {
         return;
     }
@@ -659,7 +670,7 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
     const auto trigger_value = TransformToTrigger(callback);
 
     // Only read trigger values that have the same uuid or are pressed once
-    if (controller.stick_values[index].uuid != uuid) {
+    if (controller.trigger_values[index].uuid != uuid) {
         if (!trigger_value.pressed.value) {
             return;
         }
@@ -675,7 +686,7 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
         return;
     }
 
-    const auto trigger = controller.trigger_values[index];
+    const auto& trigger = controller.trigger_values[index];
 
     switch (index) {
     case Settings::NativeTrigger::LTrigger:
@@ -692,7 +703,8 @@ void EmulatedController::SetTrigger(Common::Input::CallbackStatus callback, std:
     TriggerOnChange(ControllerTriggerType::Trigger, true);
 }
 
-void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback,
+                                   std::size_t index) {
     if (index >= controller.motion_values.size()) {
         return;
     }
@@ -730,7 +742,8 @@ void EmulatedController::SetMotion(Common::Input::CallbackStatus callback, std::
     TriggerOnChange(ControllerTriggerType::Motion, true);
 }
 
-void EmulatedController::SetBattery(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callback,
+                                    std::size_t index) {
     if (index >= controller.battery_values.size()) {
         return;
     }
@@ -1110,7 +1123,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, update_callback);
+    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 

src/core/hid/emulated_controller.h

@@ -328,35 +328,38 @@ private:
      * @param callback A CallbackStatus containing the button status
      * @param index Button ID of the to be updated
      */
-    void SetButton(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+    void SetButton(const 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(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+    void SetStick(const 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(Common::Input::CallbackStatus callback, std::size_t index, Common::UUID uuid);
+    void SetTrigger(const 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(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetMotion(const 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(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetBattery(const 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,50 +70,55 @@ void EmulatedDevices::ReloadInput() {
         if (!mouse_button_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetMouseButton(callback, index);
-            }};
-        mouse_button_devices[index]->SetCallback(button_callback);
+        mouse_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetMouseButton(callback, index);
+                },
+        });
     }
 
     for (std::size_t index = 0; index < mouse_analog_devices.size(); ++index) {
         if (!mouse_analog_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetMouseAnalog(callback, index);
-            }};
-        mouse_analog_devices[index]->SetCallback(button_callback);
+        mouse_analog_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetMouseAnalog(callback, index);
+                },
+        });
     }
 
     if (mouse_stick_device) {
-        Common::Input::InputCallback button_callback{
-            [this](Common::Input::CallbackStatus callback) { SetMouseStick(callback); }};
-        mouse_stick_device->SetCallback(button_callback);
+        mouse_stick_device->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback) { SetMouseStick(callback); },
+        });
     }
 
     for (std::size_t index = 0; index < keyboard_devices.size(); ++index) {
         if (!keyboard_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetKeyboardButton(callback, index);
-            }};
-        keyboard_devices[index]->SetCallback(button_callback);
+        keyboard_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetKeyboardButton(callback, index);
+                },
+        });
     }
 
     for (std::size_t index = 0; index < keyboard_modifier_devices.size(); ++index) {
         if (!keyboard_modifier_devices[index]) {
             continue;
         }
-        Common::Input::InputCallback button_callback{
-            [this, index](Common::Input::CallbackStatus callback) {
-                SetKeyboardModifier(callback, index);
-            }};
-        keyboard_modifier_devices[index]->SetCallback(button_callback);
+        keyboard_modifier_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetKeyboardModifier(callback, index);
+                },
+        });
     }
 }
 
@@ -159,7 +164,8 @@ void EmulatedDevices::RestoreConfig() {
     ReloadFromSettings();
 }
 
-void EmulatedDevices::SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetKeyboardButton(const Common::Input::CallbackStatus& callback,
+                                        std::size_t index) {
     if (index >= device_status.keyboard_values.size()) {
         return;
     }
@@ -216,7 +222,7 @@ void EmulatedDevices::UpdateKey(std::size_t key_index, bool status) {
     }
 }
 
-void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback,
+void EmulatedDevices::SetKeyboardModifier(const Common::Input::CallbackStatus& callback,
                                           std::size_t index) {
     if (index >= device_status.keyboard_moddifier_values.size()) {
         return;
@@ -286,7 +292,8 @@ void EmulatedDevices::SetKeyboardModifier(Common::Input::CallbackStatus callback
     TriggerOnChange(DeviceTriggerType::KeyboardModdifier);
 }
 
-void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetMouseButton(const Common::Input::CallbackStatus& callback,
+                                     std::size_t index) {
     if (index >= device_status.mouse_button_values.size()) {
         return;
     }
@@ -347,7 +354,8 @@ void EmulatedDevices::SetMouseButton(Common::Input::CallbackStatus callback, std
     TriggerOnChange(DeviceTriggerType::Mouse);
 }
 
-void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std::size_t index) {
+void EmulatedDevices::SetMouseAnalog(const Common::Input::CallbackStatus& callback,
+                                     std::size_t index) {
     if (index >= device_status.mouse_analog_values.size()) {
         return;
     }
@@ -374,7 +382,7 @@ void EmulatedDevices::SetMouseAnalog(Common::Input::CallbackStatus callback, std
     TriggerOnChange(DeviceTriggerType::Mouse);
 }
 
-void EmulatedDevices::SetMouseStick(Common::Input::CallbackStatus callback) {
+void EmulatedDevices::SetMouseStick(const Common::Input::CallbackStatus& callback) {
     std::lock_guard lock{mutex};
     const auto touch_value = TransformToTouch(callback);
 
@@ -435,7 +443,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, update_callback);
+    callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 

src/core/hid/emulated_devices.h

@@ -156,35 +156,34 @@ private:
      * @param callback A CallbackStatus containing the key status
      * @param index key ID to be updated
      */
-    void SetKeyboardButton(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardButton(const 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(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetKeyboardModifier(const 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(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetMouseButton(const 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(Common::Input::CallbackStatus callback, std::size_t index);
+    void SetMouseAnalog(const 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(Common::Input::CallbackStatus callback);
+    void SetMouseStick(const Common::Input::CallbackStatus& callback);
 
     /**
      * Triggers a callback that something has changed on the device status

src/core/hid/hid_core.cpp

@@ -145,6 +145,16 @@ 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,6 +45,9 @@ 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,6 +9,7 @@
 #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"
@@ -32,6 +33,7 @@ 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_class_token.cpp

@@ -6,6 +6,7 @@
 #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"
@@ -48,7 +49,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.
 
@@ -79,7 +80,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

@@ -0,0 +1,146 @@
+// 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

@@ -0,0 +1,66 @@
+// 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_memory_block.h

@@ -131,6 +131,26 @@ 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,6 +27,10 @@ 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,6 +368,33 @@ 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()};
@@ -942,6 +969,60 @@ 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);
 
@@ -1231,4 +1312,42 @@ 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,6 +33,8 @@ 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);
@@ -55,6 +57,8 @@ 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;
@@ -115,6 +119,10 @@ 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_thread_queue.cpp

@@ -2,8 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#pragma once
-
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/time_manager.h"

src/core/hle/kernel/kernel.h

@@ -53,6 +53,7 @@ class KSharedMemoryInfo;
 class KThread;
 class KTransferMemory;
 class KWritableEvent;
+class KCodeMemory;
 class PhysicalCore;
 class ServiceThread;
 class Synchronization;
@@ -331,6 +332,8 @@ 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;
         }
     }
 
@@ -382,6 +385,7 @@ 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/svc.cpp

@@ -18,6 +18,7 @@
 #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"
@@ -1202,6 +1203,22 @@ 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,
@@ -1311,6 +1328,195 @@ 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) {
@@ -2605,8 +2811,8 @@ static const FunctionDef SVC_Table_64[] = {
     {0x48, nullptr, "MapPhysicalMemoryUnsafe"},
     {0x49, nullptr, "UnmapPhysicalMemoryUnsafe"},
     {0x4A, nullptr, "SetUnsafeLimit"},
-    {0x4B, nullptr, "CreateCodeMemory"},
-    {0x4C, nullptr, "ControlCodeMemory"},
+    {0x4B, SvcWrap64<CreateCodeMemory>, "CreateCodeMemory"},
+    {0x4C, SvcWrap64<ControlCodeMemory>, "ControlCodeMemory"},
     {0x4D, nullptr, "SleepSystem"},
     {0x4E, nullptr, "ReadWriteRegister"},
     {0x4F, nullptr, "SetProcessActivity"},
@@ -2646,8 +2852,8 @@ static const FunctionDef SVC_Table_64[] = {
     {0x71, nullptr, "ManageNamedPort"},
     {0x72, nullptr, "ConnectToPort"},
     {0x73, SvcWrap64<SetProcessMemoryPermission>, "SetProcessMemoryPermission"},
-    {0x74, nullptr, "MapProcessMemory"},
-    {0x75, nullptr, "UnmapProcessMemory"},
+    {0x74, SvcWrap64<MapProcessMemory>, "MapProcessMemory"},
+    {0x75, SvcWrap64<UnmapProcessMemory>, "UnmapProcessMemory"},
     {0x76, SvcWrap64<QueryProcessMemory>, "QueryProcessMemory"},
     {0x77, SvcWrap64<MapProcessCodeMemory>, "MapProcessCodeMemory"},
     {0x78, SvcWrap64<UnmapProcessCodeMemory>, "UnmapProcessCodeMemory"},

src/core/hle/kernel/svc_wrap.h

@@ -73,6 +73,23 @@ 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;
@@ -301,6 +318,16 @@ 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/service/glue/glue.cpp

@@ -8,6 +8,7 @@
 #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 {
 
@@ -24,6 +25,9 @@ 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

@@ -0,0 +1,44 @@
+// 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

@@ -0,0 +1,25 @@
+// 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.is_connected) {
+        if (!controller.device->IsConnected()) {
             return;
         }
         auto& shared_memory = controller.shared_memory_entry;
@@ -150,7 +150,6 @@ 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:
@@ -166,21 +165,30 @@ void Controller_NPad::InitNewlyAddedController(Core::HID::NpadIdType npad_id) {
         break;
     case Core::HID::NpadStyleIndex::JoyconDual:
         shared_memory.style_tag.joycon_dual.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);
+        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.system_properties.is_vertical.Assign(1);
         shared_memory.assignment_mode = NpadJoyAssignmentMode::Dual;
-        shared_memory.applet_footer.type = AppletFooterUiType::JoyDual;
+        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;
+        }
         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:
@@ -188,7 +196,6 @@ 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:
@@ -200,7 +207,6 @@ 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);
@@ -443,11 +449,15 @@ 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);
-            pad_state.connection_status.is_left_connected.Assign(1);
-            pad_state.connection_status.is_right_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);
+            }
 
-            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);
@@ -687,7 +697,7 @@ Controller_NPad::NpadCommunicationMode Controller_NPad::GetNpadCommunicationMode
     return communication_mode;
 }
 
-void Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id,
+void Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type,
                                   NpadJoyAssignmentMode assignment_mode) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
@@ -698,6 +708,62 @@ void Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id,
     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,
@@ -907,6 +973,7 @@ 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;
@@ -923,9 +990,10 @@ 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);
@@ -1022,19 +1090,70 @@ void Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
                   npad_id_2);
         return;
     }
-    auto& controller_1 = GetControllerFromNpadIdType(npad_id_1).device;
-    auto& controller_2 = GetControllerFromNpadIdType(npad_id_2).device;
+    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;
 
     // If the controllers at both npad indices form a pair of left and right joycons, merge them.
     // Otherwise, do nothing.
-    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)) {
+    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) {
         // 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,7 +113,8 @@ public:
     void SetNpadCommunicationMode(NpadCommunicationMode communication_mode_);
     NpadCommunicationMode GetNpadCommunicationMode() const;
 
-    void SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyAssignmentMode assignment_mode);
+    void SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type,
+                     NpadJoyAssignmentMode assignment_mode);
 
     bool VibrateControllerAtIndex(Core::HID::NpadIdType npad_id, std::size_t device_index,
                                   const Core::HID::VibrationValue& vibration_value);
@@ -464,7 +465,10 @@ private:
         std::array<VibrationData, 2> vibration{};
         bool unintended_home_button_input_protection{};
         bool is_connected{};
-        Core::HID::NpadStyleIndex npad_type{Core::HID::NpadStyleIndex::None};
+
+        // Dual joycons can have only one side connected
+        bool is_dual_left_connected{true};
+        bool is_dual_right_connected{true};
 
         // Motion parameters
         bool sixaxis_at_rest{true};

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

@@ -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::NpadJoyAssignmentMode::Single);
+        .SetNpadMode(parameters.npad_id, Controller_NPad::NpadJoyDeviceType::Left,
+                     Controller_NPad::NpadJoyAssignmentMode::Single);
 
-    LOG_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}",
-                parameters.npad_id, parameters.applet_resource_user_id);
+    LOG_INFO(Service_HID, "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;
-        u64 npad_joy_device_type;
+        Controller_NPad::NpadJoyDeviceType 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, Controller_NPad::NpadJoyAssignmentMode::Single);
+        .SetNpadMode(parameters.npad_id, parameters.npad_joy_device_type,
+                     Controller_NPad::NpadJoyAssignmentMode::Single);
 
-    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);
+    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);
 
     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_WARNING(Service_HID, "(STUBBED) called, npad_id={}, applet_resource_user_id={}",
-                parameters.npad_id, parameters.applet_resource_user_id);
+    LOG_INFO(Service_HID, "called, npad_id={}, applet_resource_user_id={}", parameters.npad_id,
+             parameters.applet_resource_user_id);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);

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

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

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

@@ -24,6 +24,9 @@ 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,7 +59,8 @@ NvResult nvhost_nvdec_common::SetNVMAPfd(const std::vector<u8>& input) {
     return NvResult::Success;
 }
 
-NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u8>& output) {
+NvResult nvhost_nvdec_common::Submit(DeviceFD fd, 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);
@@ -93,7 +94,7 @@ NvResult nvhost_nvdec_common::Submit(const std::vector<u8>& input, std::vector<u
         Tegra::ChCommandHeaderList cmdlist(cmd_buffer.word_count);
         system.Memory().ReadBlock(object->addr + cmd_buffer.offset, cmdlist.data(),
                                   cmdlist.size() * sizeof(u32));
-        gpu.PushCommandBuffer(cmdlist);
+        gpu.PushCommandBuffer(fd_to_id[fd], 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,13 +104,14 @@ protected:
 
     /// Ioctl command implementations
     NvResult SetNVMAPfd(const std::vector<u8>& input);
-    NvResult Submit(const std::vector<u8>& input, std::vector<u8>& output);
+    NvResult Submit(DeviceFD fd, 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,7 +21,10 @@ NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& i
     case 0x0:
         switch (command.cmd) {
         case 0x1:
-            return Submit(input, output);
+            if (!fd_to_id.contains(fd)) {
+                fd_to_id[fd] = next_id++;
+            }
+            return Submit(fd, input, output);
         case 0x2:
             return GetSyncpoint(input, output);
         case 0x3:
@@ -65,7 +68,10 @@ 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) {
-    system.GPU().ClearCdmaInstance();
+    const auto iter = fd_to_id.find(fd);
+    if (iter != fd_to_id.end()) {
+        system.GPU().ClearCdmaInstance(iter->second);
+    }
 }
 
 } // namespace Service::Nvidia::Devices

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

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

src/input_common/drivers/gc_adapter.cpp

@@ -69,7 +69,7 @@ private:
     libusb_device_handle* handle{};
 };
 
-GCAdapter::GCAdapter(const std::string& input_engine_) : InputEngine(input_engine_) {
+GCAdapter::GCAdapter(std::string input_engine_) : InputEngine(std::move(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 InputCommon::InputEngine {
+class GCAdapter : public InputEngine {
 public:
-    explicit GCAdapter(const std::string& input_engine_);
-    ~GCAdapter();
+    explicit GCAdapter(std::string input_engine_);
+    ~GCAdapter() override;
 
     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(const std::string& input_engine_) : InputEngine(input_engine_) {
+Keyboard::Keyboard(std::string input_engine_) : InputEngine(std::move(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 InputCommon::InputEngine {
+class Keyboard final : public InputEngine {
 public:
-    explicit Keyboard(const std::string& input_engine_);
+    explicit Keyboard(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(const std::string& input_engine_) : InputEngine(input_engine_) {
+Mouse::Mouse(std::string input_engine_) : InputEngine(std::move(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 InputCommon::InputEngine {
+class Mouse final : public InputEngine {
 public:
-    explicit Mouse(const std::string& input_engine_);
+    explicit Mouse(std::string input_engine_);
 
     /**
      * Signals that mouse has moved.

src/input_common/drivers/sdl_driver.cpp

@@ -88,7 +88,7 @@ public:
         return true;
     }
 
-    BasicMotion GetMotion() {
+    const BasicMotion& GetMotion() const {
         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(const std::string& input_engine_) : InputEngine(input_engine_) {
+SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(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,10 +403,11 @@ SDLDriver::SDLDriver(const std::string& input_engine_) : InputEngine(input_engin
 
     // Use hidapi driver for joycons. This will allow joycons to be detected as a GameController and
     // not a generic one
-    SDL_SetHint("SDL_JOYSTICK_HIDAPI_JOY_CONS", "1");
+    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS, "1");
 
-    // Turn off Pro controller home led
-    SDL_SetHint("SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED", "0");
+    // 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");
 
     // 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;
@@ -491,8 +492,9 @@ 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) {
@@ -526,6 +528,7 @@ Common::Input::VibrationError SDLDriver::SetRumble(const PadIdentifier& identifi
 
     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>;
 
-namespace InputCommon {
-
-class SDLJoystick;
-
-class SDLDriver : public InputCommon::InputEngine {
+class SDLDriver : public InputEngine {
 public:
     /// Initializes and registers SDL device factories
-    SDLDriver(const std::string& input_engine_);
+    explicit SDLDriver(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,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include <cstring>
-#include <regex>
 #include <fmt/format.h>
 
 #include "common/fs/file.h"
@@ -15,7 +14,7 @@
 
 namespace InputCommon::TasInput {
 
-enum TasAxes : u8 {
+enum class Tas::TasAxis : u8 {
     StickX,
     StickY,
     SubstickX,
@@ -47,7 +46,7 @@ constexpr std::array<std::pair<std::string_view, TasButton>, 20> text_to_tas_but
     {"KEY_ZR", TasButton::TRIGGER_ZR},
 };
 
-Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engine_) {
+Tas::Tas(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
     for (size_t player_index = 0; player_index < PLAYER_NUMBER; player_index++) {
         PadIdentifier identifier{
             .guid = Common::UUID{},
@@ -66,7 +65,7 @@ Tas::Tas(const std::string& input_engine_) : InputCommon::InputEngine(input_engi
 
 Tas::~Tas() {
     Stop();
-};
+}
 
 void Tas::LoadTasFiles() {
     script_length = 0;
@@ -79,43 +78,43 @@ void Tas::LoadTasFiles() {
 }
 
 void Tas::LoadTasFile(size_t player_index, size_t file_index) {
-    if (!commands[player_index].empty()) {
-        commands[player_index].clear();
-    }
+    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::stringstream command_line(file);
+    std::istringstream 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::stringstream linestream(line);
-        std::string segment;
-        std::vector<std::string> seglist;
-
-        while (std::getline(linestream, segment, ' ')) {
-            seglist.push_back(segment);
+        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));
+            }
         }
 
-        if (seglist.size() < 4) {
+        if (seg_list.size() < 4) {
             continue;
         }
 
-        while (frame_no < std::stoi(seglist.at(0))) {
-            commands[player_index].push_back({});
+        const auto num_frames = std::stoi(seg_list[0]);
+        while (frame_no < num_frames) {
+            commands[player_index].emplace_back();
             frame_no++;
         }
 
         TASCommand command = {
-            .buttons = ReadCommandButtons(seglist.at(1)),
-            .l_axis = ReadCommandAxis(seglist.at(2)),
-            .r_axis = ReadCommandAxis(seglist.at(3)),
+            .buttons = ReadCommandButtons(seg_list[1]),
+            .l_axis = ReadCommandAxis(seg_list[2]),
+            .r_axis = ReadCommandAxis(seg_list[3]),
         };
         commands[player_index].push_back(command);
         frame_no++;
@@ -123,16 +122,17 @@ 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 file_name) {
+void Tas::WriteTasFile(std::u8string_view 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 bytes_written = Common::FS::WriteStringToFile(
-        Common::FS::GetYuzuPath(Common::FS::YuzuPath::TASDir) / file_name,
-        Common::FS::FileType::TextFile, output_text);
+
+    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);
     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);
             }
-            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);
+            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);
         }
     } else {
         is_running = Settings::values.tas_loop.GetValue();
@@ -224,27 +224,28 @@ void Tas::ClearInput() {
 }
 
 TasAnalog Tas::ReadCommandAxis(const std::string& line) const {
-    std::stringstream linestream(line);
-    std::string segment;
-    std::vector<std::string> seglist;
-
-    while (std::getline(linestream, segment, ';')) {
-        seglist.push_back(segment);
+    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));
+        }
     }
 
-    const float x = std::stof(seglist.at(0)) / 32767.0f;
-    const float y = std::stof(seglist.at(1)) / 32767.0f;
+    const float x = std::stof(seg_list.at(0)) / 32767.0f;
+    const float y = std::stof(seg_list.at(1)) / 32767.0f;
 
     return {x, y};
 }
 
-u64 Tas::ReadCommandButtons(const std::string& data) const {
-    std::stringstream button_text(data);
-    std::string line;
+u64 Tas::ReadCommandButtons(const std::string& line) const {
+    std::istringstream button_text(line);
+    std::string button_line;
     u64 buttons = 0;
-    while (std::getline(button_text, line, ';')) {
-        for (auto [text, tas_button] : text_to_tas_button) {
-            if (text == line) {
+    while (std::getline(button_text, button_line, ';')) {
+        for (const auto& [text, tas_button] : text_to_tas_button) {
+            if (text == button_line) {
                 buttons |= static_cast<u64>(tas_button);
                 break;
             }
@@ -254,8 +255,8 @@ u64 Tas::ReadCommandButtons(const std::string& data) const {
 }
 
 std::string Tas::WriteCommandButtons(u64 buttons) const {
-    std::string returns = "";
-    for (auto [text_button, tas_button] : text_to_tas_button) {
+    std::string returns;
+    for (const auto& [text_button, tas_button] : text_to_tas_button) {
         if ((buttons & static_cast<u64>(tas_button)) != 0) {
             returns += fmt::format("{};", text_button);
         }
@@ -267,6 +268,10 @@ 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 InputCommon::InputEngine {
+class Tas final : public InputEngine {
 public:
-    explicit Tas(const std::string& input_engine_);
-    ~Tas();
+    explicit Tas(std::string input_engine_);
+    ~Tas() override;
 
     /**
      * 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 excecution and swaps controllers profiles
+    // Sets the flag to start or stop the TAS command execution 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 begining in the next update
+    // Sets the flag to reload the file and start from the beginning in the next update
     void Reset();
 
     /**
      * Sets the flag to enable or disable recording of inputs
-     * @return Returns true if the current recording status is enabled
+     * @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
-     * @return Tuple of
+     * @returns A Tuple of
      * TasState indicating the current state out of Running ;
      * Current playback progress ;
      * Total length of script file currently loaded or being recorded
@@ -128,6 +128,8 @@ public:
     std::tuple<TasState, size_t, size_t> GetStatus() const;
 
 private:
+    enum class TasAxis : u8;
+
     struct TASCommand {
         u64 buttons{};
         TasAnalog l_axis{};
@@ -137,29 +139,31 @@ 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 file_name);
+    void WriteTasFile(std::u8string_view 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"
-     * @return 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"
+     * @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..."
-     * @return 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..."
+     * @returns A u64 with each bit representing the status of a button
      */
     u64 ReadCommandButtons(const std::string& line) const;
 
@@ -170,17 +174,20 @@ private:
 
     /**
      * Converts an u64 containing the button status into the text equivalent
-     * @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
+     * @param buttons Bitfield with the status of the buttons
+     * @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 data: value of the axis
-     * @return A string with the value of the axis to be written to the file
+     * @param analog Value of the axis
+     * @returns A string with the value of the axis to be written to the file
      */
-    std::string WriteCommandAxis(TasAnalog data) const;
+    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);
 
     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(const std::string& input_engine_) : InputEngine(input_engine_) {
+TouchScreen::TouchScreen(std::string input_engine_) : InputEngine(std::move(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 InputCommon::InputEngine {
+class TouchScreen final : public InputEngine {
 public:
-    explicit TouchScreen(const std::string& input_engine_);
+    explicit TouchScreen(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(const std::string& input_engine_) : InputEngine(input_engine_) {
+UDPClient::UDPClient(std::string input_engine_) : InputEngine(std::move(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 InputCommon::InputEngine {
+class UDPClient final : public InputEngine {
 public:
-    explicit UDPClient(const std::string& input_engine_);
-    ~UDPClient();
+    explicit UDPClient(std::string input_engine_);
+    ~UDPClient() override;
 
     void ReloadSockets();
 

src/input_common/helpers/stick_from_buttons.cpp

@@ -19,23 +19,36 @@ 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_) {
-        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);
+        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_);
+                },
+        });
         last_x_axis_value = 0.0f;
         last_y_axis_value = 0.0f;
     }
@@ -133,27 +146,27 @@ public:
         }
     }
 
-    void UpdateUpButtonStatus(Common::Input::CallbackStatus button_callback) {
+    void UpdateUpButtonStatus(const Common::Input::CallbackStatus& button_callback) {
         up_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateDownButtonStatus(Common::Input::CallbackStatus button_callback) {
+    void UpdateDownButtonStatus(const Common::Input::CallbackStatus& button_callback) {
         down_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateLeftButtonStatus(Common::Input::CallbackStatus button_callback) {
+    void UpdateLeftButtonStatus(const Common::Input::CallbackStatus& button_callback) {
         left_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateRightButtonStatus(Common::Input::CallbackStatus button_callback) {
+    void UpdateRightButtonStatus(const Common::Input::CallbackStatus& button_callback) {
         right_status = button_callback.button_status.value;
         UpdateStatus();
     }
 
-    void UpdateModButtonStatus(Common::Input::CallbackStatus button_callback) {
+    void UpdateModButtonStatus(const Common::Input::CallbackStatus& button_callback) {
         modifier_status = button_callback.button_status.value;
         UpdateStatus();
     }
@@ -265,18 +278,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,10 +14,13 @@ 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(button_up_callback);
+        button->SetCallback({
+            .on_change =
+                [this](const Common::Input::CallbackStatus& callback_) {
+                    UpdateButtonStatus(callback_);
+                },
+        });
         button->ForceUpdate();
     }
 
@@ -47,7 +50,7 @@ public:
         return status;
     }
 
-    void UpdateButtonStatus(Common::Input::CallbackStatus button_callback) {
+    void UpdateButtonStatus(const 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,41 +10,31 @@ namespace InputCommon {
 
 void InputEngine::PreSetController(const PadIdentifier& identifier) {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
-        controller_list.insert_or_assign(identifier, ControllerData{});
-    }
+    controller_list.try_emplace(identifier);
 }
 
 void InputEngine::PreSetButton(const PadIdentifier& identifier, int button) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.buttons.contains(button)) {
-        controller.buttons.insert_or_assign(button, false);
-    }
+    controller.buttons.try_emplace(button, false);
 }
 
 void InputEngine::PreSetHatButton(const PadIdentifier& identifier, int button) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.hat_buttons.contains(button)) {
-        controller.hat_buttons.insert_or_assign(button, u8{0});
-    }
+    controller.hat_buttons.try_emplace(button, u8{0});
 }
 
 void InputEngine::PreSetAxis(const PadIdentifier& identifier, int axis) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.axes.contains(axis)) {
-        controller.axes.insert_or_assign(axis, 0.0f);
-    }
+    controller.axes.try_emplace(axis, 0.0f);
 }
 
 void InputEngine::PreSetMotion(const PadIdentifier& identifier, int motion) {
     std::lock_guard lock{mutex};
     ControllerData& controller = controller_list.at(identifier);
-    if (!controller.motions.contains(motion)) {
-        controller.motions.insert_or_assign(motion, BasicMotion{});
-    }
+    controller.motions.try_emplace(motion);
 }
 
 void InputEngine::SetButton(const PadIdentifier& identifier, int button, bool value) {
@@ -91,7 +81,7 @@ void InputEngine::SetBattery(const PadIdentifier& identifier, BatteryLevel value
     TriggerOnBatteryChange(identifier, value);
 }
 
-void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMotion value) {
+void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value) {
     {
         std::lock_guard lock{mutex};
         ControllerData& controller = controller_list.at(identifier);
@@ -104,85 +94,93 @@ void InputEngine::SetMotion(const PadIdentifier& identifier, int motion, BasicMo
 
 bool InputEngine::GetButton(const PadIdentifier& identifier, int button) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return false;
     }
-    ControllerData controller = controller_list.at(identifier);
-    if (!controller.buttons.contains(button)) {
+    const ControllerData& controller = controller_iter->second;
+    const auto button_iter = controller.buttons.find(button);
+    if (button_iter == controller.buttons.cend()) {
         LOG_ERROR(Input, "Invalid button {}", button);
         return false;
     }
-    return controller.buttons.at(button);
+    return button_iter->second;
 }
 
 bool InputEngine::GetHatButton(const PadIdentifier& identifier, int button, u8 direction) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return false;
     }
-    ControllerData controller = controller_list.at(identifier);
-    if (!controller.hat_buttons.contains(button)) {
+    const ControllerData& controller = controller_iter->second;
+    const auto hat_iter = controller.hat_buttons.find(button);
+    if (hat_iter == controller.hat_buttons.cend()) {
         LOG_ERROR(Input, "Invalid hat button {}", button);
         return false;
     }
-    return (controller.hat_buttons.at(button) & direction) != 0;
+    return (hat_iter->second & direction) != 0;
 }
 
 f32 InputEngine::GetAxis(const PadIdentifier& identifier, int axis) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return 0.0f;
     }
-    ControllerData controller = controller_list.at(identifier);
-    if (!controller.axes.contains(axis)) {
+    const ControllerData& controller = controller_iter->second;
+    const auto axis_iter = controller.axes.find(axis);
+    if (axis_iter == controller.axes.cend()) {
         LOG_ERROR(Input, "Invalid axis {}", axis);
         return 0.0f;
     }
-    return controller.axes.at(axis);
+    return axis_iter->second;
 }
 
 BatteryLevel InputEngine::GetBattery(const PadIdentifier& identifier) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return BatteryLevel::Charging;
     }
-    ControllerData controller = controller_list.at(identifier);
+    const ControllerData& controller = controller_iter->second;
     return controller.battery;
 }
 
 BasicMotion InputEngine::GetMotion(const PadIdentifier& identifier, int motion) const {
     std::lock_guard lock{mutex};
-    if (!controller_list.contains(identifier)) {
+    const auto controller_iter = controller_list.find(identifier);
+    if (controller_iter == controller_list.cend()) {
         LOG_ERROR(Input, "Invalid identifier guid={}, pad={}, port={}", identifier.guid.Format(),
                   identifier.pad, identifier.port);
         return {};
     }
-    ControllerData controller = controller_list.at(identifier);
+    const ControllerData& controller = controller_iter->second;
     return controller.motions.at(motion);
 }
 
 void InputEngine::ResetButtonState() {
-    for (std::pair<PadIdentifier, ControllerData> controller : controller_list) {
-        for (std::pair<int, bool> button : controller.second.buttons) {
+    for (const auto& controller : controller_list) {
+        for (const auto& button : controller.second.buttons) {
             SetButton(controller.first, button.first, false);
         }
-        for (std::pair<int, bool> button : controller.second.hat_buttons) {
+        for (const auto& button : controller.second.hat_buttons) {
             SetHatButton(controller.first, button.first, false);
         }
     }
 }
 
 void InputEngine::ResetAnalogState() {
-    for (std::pair<PadIdentifier, ControllerData> controller : controller_list) {
-        for (std::pair<int, float> axis : controller.second.axes) {
+    for (const auto& controller : controller_list) {
+        for (const auto& axis : controller.second.axes) {
             SetAxis(controller.first, axis.first, 0.0);
         }
     }
@@ -190,7 +188,7 @@ void InputEngine::ResetAnalogState() {
 
 void InputEngine::TriggerOnButtonChange(const PadIdentifier& identifier, int button, bool value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Button, button)) {
             continue;
@@ -218,7 +216,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 std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::HatButton, button)) {
             continue;
@@ -247,7 +245,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 std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Analog, axis)) {
             continue;
@@ -274,7 +272,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 std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Battery, 0)) {
             continue;
@@ -286,9 +284,9 @@ void InputEngine::TriggerOnBatteryChange(const PadIdentifier& identifier,
 }
 
 void InputEngine::TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
-                                        BasicMotion value) {
+                                        const BasicMotion& value) {
     std::lock_guard lock{mutex_callback};
-    for (const std::pair<int, InputIdentifier> poller_pair : callback_list) {
+    for (const auto& poller_pair : callback_list) {
         const InputIdentifier& poller = poller_pair.second;
         if (!IsInputIdentifierEqual(poller, identifier, EngineInputType::Motion, motion)) {
             continue;
@@ -342,7 +340,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, input_identifier);
+    callback_list.insert_or_assign(last_callback_key, std::move(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 microsecons
+// Basic motion data containing data from the sensors and a timestamp in microseconds
 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,9 +102,7 @@ struct InputIdentifier {
 
 class InputEngine {
 public:
-    explicit InputEngine(const std::string& input_engine_) : input_engine(input_engine_) {
-        callback_list.clear();
-    }
+    explicit InputEngine(std::string input_engine_) : input_engine{std::move(input_engine_)} {}
 
     virtual ~InputEngine() = default;
 
@@ -116,14 +114,12 @@ public:
 
     // Sets a led pattern for a controller
     virtual void SetLeds([[maybe_unused]] const PadIdentifier& identifier,
-                         [[maybe_unused]] const Common::Input::LedStatus led_status) {
-        return;
-    }
+                         [[maybe_unused]] const Common::Input::LedStatus& led_status) {}
 
     // 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;
     }
 
@@ -140,36 +136,36 @@ public:
     /// Used for automapping features
     virtual std::vector<Common::ParamPackage> GetInputDevices() const {
         return {};
-    };
+    }
 
     /// Retrieves the button mappings for the given device
-    virtual InputCommon::ButtonMapping GetButtonMappingForDevice(
+    virtual ButtonMapping GetButtonMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    };
+    }
 
     /// Retrieves the analog mappings for the given device
-    virtual InputCommon::AnalogMapping GetAnalogMappingForDevice(
+    virtual AnalogMapping GetAnalogMappingForDevice(
         [[maybe_unused]] const Common::ParamPackage& params) {
         return {};
-    };
+    }
 
     /// Retrieves the motion mappings for the given device
-    virtual InputCommon::MotionMapping GetMotionMappingForDevice(
+    virtual 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);
@@ -194,7 +190,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, BasicMotion value);
+    void SetMotion(const PadIdentifier& identifier, int motion, const BasicMotion& value);
 
     virtual std::string GetHatButtonName([[maybe_unused]] u8 direction_value) const {
         return "Unknown";
@@ -206,14 +202,15 @@ 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 button, f32 value);
+    void TriggerOnAxisChange(const PadIdentifier& identifier, int axis, f32 value);
     void TriggerOnBatteryChange(const PadIdentifier& identifier, BatteryLevel value);
-    void TriggerOnMotionChange(const PadIdentifier& identifier, int motion, BasicMotion value);
+    void TriggerOnMotionChange(const PadIdentifier& identifier, int motion,
+                               const 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 varables to beggin the mapping process
-     * @param "type": type of input desired to be returned
+     * Resets all variables to begin 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": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A 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 requeriments it will push an element to the input_queue
+     * If provided data satisfies the requirements 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": An struct containing all the information needed to create a proper
+     * @param data A struct containing all the information needed to create a proper
      * ParamPackage
      */
     void RegisterButton(const MappingData& data);
 
     /**
-     * If provided data satisfies the requeriments it will push an element to the input_queue
+     * If provided data satisfies the requirements 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": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A struct containing all the information needed to create a proper
+     *             ParamPackage
      */
     void RegisterStick(const MappingData& data);
 
     /**
-     * If provided data satisfies the requeriments it will push an element to the input_queue
+     * If provided data satisfies the requirements 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": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A 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": An struct containing all the information needed to create a proper
-     * ParamPackage
+     * @param data A struct containing all the information needed to create a proper
+     *             ParamPackage
      */
     bool IsDriverValid(const MappingData& data) const;
 

src/input_common/input_poller.cpp

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

src/input_common/input_poller.h

@@ -13,9 +13,6 @@ 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:
@@ -24,10 +21,10 @@ public:
     /**
      * Creates an output device from the parameters given.
      * @param params contains parameters for creating the device:
-     * @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
+     *               - "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
      */
     std::unique_ptr<Common::Input::OutputDevice> Create(
         const Common::ParamPackage& params) override;
@@ -36,6 +33,9 @@ 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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     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:
-     * @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
+     *               - "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
      */
     std::unique_ptr<Common::Input::InputDevice> CreateMotionDevice(Common::ParamPackage params);
 

src/shader_recompiler/CMakeLists.txt

@@ -1,7 +1,5 @@
 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
@@ -22,10 +20,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
@@ -47,10 +45,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
@@ -72,6 +70,8 @@ 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

src/shader_recompiler/backend/glasm/emit_glasm.cpp

@@ -9,9 +9,9 @@
 #include "common/div_ceil.h"
 #include "common/settings.h"
 #include "shader_recompiler/backend/bindings.h"
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/profile.h"

src/shader_recompiler/backend/glasm/emit_glasm_barriers.cpp

@@ -0,0 +1,22 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
+
+namespace Shader::Backend::GLASM {
+
+void EmitBarrier(EmitContext& ctx) {
+    ctx.Add("BAR;");
+}
+
+void EmitWorkgroupMemoryBarrier(EmitContext& ctx) {
+    ctx.Add("MEMBAR.CTA;");
+}
+
+void EmitDeviceMemoryBarrier(EmitContext& ctx) {
+    ctx.Add("MEMBAR;");
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_bitwise_conversion.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLASM {

src/shader_recompiler/backend/glasm/emit_glasm_composite.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLASM {

src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/profile.h"
 #include "shader_recompiler/shader_info.h"
@@ -335,6 +335,35 @@ void EmitSetFragDepth(EmitContext& ctx, ScalarF32 value) {
     ctx.Add("MOV.F result.depth.z,{};", value);
 }
 
+void EmitWorkgroupId(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {},invocation.groupid;", inst);
+}
+
+void EmitLocalInvocationId(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {},invocation.localid;", inst);
+}
+
+void EmitInvocationId(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,primitive_invocation.x;", inst);
+}
+
+void EmitSampleId(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,fragment.sampleid.x;", inst);
+}
+
+void EmitIsHelperInvocation(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,fragment.helperthread.x;", inst);
+}
+
+void EmitYDirection(EmitContext& ctx, IR::Inst& inst) {
+    ctx.uses_y_direction = true;
+    ctx.Add("MOV.F {}.x,y_direction[0].w;", inst);
+}
+
+void EmitResolutionDownFactor(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.F {}.x,scaling[0].z;", inst);
+}
+
 void EmitLoadLocal(EmitContext& ctx, IR::Inst& inst, ScalarU32 word_offset) {
     ctx.Add("MOV.U {},lmem[{}].x;", inst, word_offset);
 }

src/shader_recompiler/backend/glasm/emit_glasm_control_flow.cpp

@@ -0,0 +1,18 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
+
+namespace Shader::Backend::GLASM {
+
+void EmitJoin(EmitContext&) {
+    throw NotImplementedException("Join shouldn't be emitted");
+}
+
+void EmitDemoteToHelperInvocation(EmitContext& ctx) {
+    ctx.Add("KIL TR.x;");
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_convert.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/modifiers.h"
 #include "shader_recompiler/frontend/ir/value.h"
 

src/shader_recompiler/backend/glasm/emit_glasm_floating_point.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/modifiers.h"
 #include "shader_recompiler/frontend/ir/value.h"
 

src/shader_recompiler/backend/glasm/emit_glasm_image.cpp

@@ -4,8 +4,8 @@
 
 #include <utility>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/modifiers.h"
 #include "shader_recompiler/frontend/ir/value.h"
 

src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLASM {

src/shader_recompiler/backend/glasm/emit_glasm_logical.cpp

@@ -0,0 +1,26 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
+
+namespace Shader::Backend::GLASM {
+
+void EmitLogicalOr(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("OR.S {},{},{};", inst, a, b);
+}
+
+void EmitLogicalAnd(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("AND.S {},{},{};", inst, a, b);
+}
+
+void EmitLogicalXor(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
+    ctx.Add("XOR.S {},{},{};", inst, a, b);
+}
+
+void EmitLogicalNot(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
+    ctx.Add("SEQ.S {},{},0;", inst, value);
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_memory.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/runtime_info.h"

src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
@@ -17,110 +17,6 @@ namespace Shader::Backend::GLASM {
 
 #define NotImplemented() throw NotImplementedException("GLASM instruction {}", __LINE__)
 
-static void DefinePhi(EmitContext& ctx, IR::Inst& phi) {
-    switch (phi.Type()) {
-    case IR::Type::U1:
-    case IR::Type::U32:
-    case IR::Type::F32:
-        ctx.reg_alloc.Define(phi);
-        break;
-    case IR::Type::U64:
-    case IR::Type::F64:
-        ctx.reg_alloc.LongDefine(phi);
-        break;
-    default:
-        throw NotImplementedException("Phi node type {}", phi.Type());
-    }
-}
-
-void EmitPhi(EmitContext& ctx, IR::Inst& phi) {
-    const size_t num_args{phi.NumArgs()};
-    for (size_t i = 0; i < num_args; ++i) {
-        ctx.reg_alloc.Consume(phi.Arg(i));
-    }
-    if (!phi.Definition<Id>().is_valid) {
-        // The phi node wasn't forward defined
-        DefinePhi(ctx, phi);
-    }
-}
-
-void EmitVoid(EmitContext&) {}
-
-void EmitReference(EmitContext& ctx, const IR::Value& value) {
-    ctx.reg_alloc.Consume(value);
-}
-
-void EmitPhiMove(EmitContext& ctx, const IR::Value& phi_value, const IR::Value& value) {
-    IR::Inst& phi{RegAlloc::AliasInst(*phi_value.Inst())};
-    if (!phi.Definition<Id>().is_valid) {
-        // The phi node wasn't forward defined
-        DefinePhi(ctx, phi);
-    }
-    const Register phi_reg{ctx.reg_alloc.Consume(IR::Value{&phi})};
-    const Value eval_value{ctx.reg_alloc.Consume(value)};
-
-    if (phi_reg == eval_value) {
-        return;
-    }
-    switch (phi.Flags<IR::Type>()) {
-    case IR::Type::U1:
-    case IR::Type::U32:
-    case IR::Type::F32:
-        ctx.Add("MOV.S {}.x,{};", phi_reg, ScalarS32{eval_value});
-        break;
-    case IR::Type::U64:
-    case IR::Type::F64:
-        ctx.Add("MOV.U64 {}.x,{};", phi_reg, ScalarRegister{eval_value});
-        break;
-    default:
-        throw NotImplementedException("Phi node type {}", phi.Type());
-    }
-}
-
-void EmitJoin(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitDemoteToHelperInvocation(EmitContext& ctx) {
-    ctx.Add("KIL TR.x;");
-}
-
-void EmitBarrier(EmitContext& ctx) {
-    ctx.Add("BAR;");
-}
-
-void EmitWorkgroupMemoryBarrier(EmitContext& ctx) {
-    ctx.Add("MEMBAR.CTA;");
-}
-
-void EmitDeviceMemoryBarrier(EmitContext& ctx) {
-    ctx.Add("MEMBAR;");
-}
-
-void EmitPrologue(EmitContext& ctx) {
-    // TODO
-}
-
-void EmitEpilogue(EmitContext& ctx) {
-    // TODO
-}
-
-void EmitEmitVertex(EmitContext& ctx, ScalarS32 stream) {
-    if (stream.type == Type::U32 && stream.imm_u32 == 0) {
-        ctx.Add("EMIT;");
-    } else {
-        ctx.Add("EMITS {};", stream);
-    }
-}
-
-void EmitEndPrimitive(EmitContext& ctx, const IR::Value& stream) {
-    if (!stream.IsImmediate()) {
-        LOG_WARNING(Shader_GLASM, "Stream is not immediate");
-    }
-    ctx.reg_alloc.Consume(stream);
-    ctx.Add("ENDPRIM;");
-}
-
 void EmitGetRegister(EmitContext& ctx) {
     NotImplemented();
 }
@@ -185,55 +81,6 @@ void EmitSetOFlag(EmitContext& ctx) {
     NotImplemented();
 }
 
-void EmitWorkgroupId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {},invocation.groupid;", inst);
-}
-
-void EmitLocalInvocationId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {},invocation.localid;", inst);
-}
-
-void EmitInvocationId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,primitive_invocation.x;", inst);
-}
-
-void EmitSampleId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,fragment.sampleid.x;", inst);
-}
-
-void EmitIsHelperInvocation(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,fragment.helperthread.x;", inst);
-}
-
-void EmitYDirection(EmitContext& ctx, IR::Inst& inst) {
-    ctx.uses_y_direction = true;
-    ctx.Add("MOV.F {}.x,y_direction[0].w;", inst);
-}
-
-void EmitResolutionDownFactor(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.F {}.x,scaling[0].z;", inst);
-}
-
-void EmitUndefU1(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU8(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU16(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU32(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU64(EmitContext& ctx, IR::Inst& inst) {
-    ctx.LongAdd("MOV.S64 {}.x,0;", inst);
-}
-
 void EmitGetZeroFromOp(EmitContext& ctx) {
     NotImplemented();
 }
@@ -258,20 +105,4 @@ void EmitGetInBoundsFromOp(EmitContext& ctx) {
     NotImplemented();
 }
 
-void EmitLogicalOr(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("OR.S {},{},{};", inst, a, b);
-}
-
-void EmitLogicalAnd(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("AND.S {},{},{};", inst, a, b);
-}
-
-void EmitLogicalXor(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("XOR.S {},{},{};", inst, a, b);
-}
-
-void EmitLogicalNot(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("SEQ.S {},{},0;", inst, value);
-}
-
 } // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_select.cpp

@@ -3,8 +3,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLASM {

src/shader_recompiler/backend/glasm/emit_glasm_shared_memory.cpp

@@ -3,8 +3,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLASM {

src/shader_recompiler/backend/glasm/emit_glasm_special.cpp

@@ -0,0 +1,95 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
+#include "shader_recompiler/frontend/ir/value.h"
+
+namespace Shader::Backend::GLASM {
+
+static void DefinePhi(EmitContext& ctx, IR::Inst& phi) {
+    switch (phi.Type()) {
+    case IR::Type::U1:
+    case IR::Type::U32:
+    case IR::Type::F32:
+        ctx.reg_alloc.Define(phi);
+        break;
+    case IR::Type::U64:
+    case IR::Type::F64:
+        ctx.reg_alloc.LongDefine(phi);
+        break;
+    default:
+        throw NotImplementedException("Phi node type {}", phi.Type());
+    }
+}
+
+void EmitPhi(EmitContext& ctx, IR::Inst& phi) {
+    const size_t num_args{phi.NumArgs()};
+    for (size_t i = 0; i < num_args; ++i) {
+        ctx.reg_alloc.Consume(phi.Arg(i));
+    }
+    if (!phi.Definition<Id>().is_valid) {
+        // The phi node wasn't forward defined
+        DefinePhi(ctx, phi);
+    }
+}
+
+void EmitVoid(EmitContext&) {}
+
+void EmitReference(EmitContext& ctx, const IR::Value& value) {
+    ctx.reg_alloc.Consume(value);
+}
+
+void EmitPhiMove(EmitContext& ctx, const IR::Value& phi_value, const IR::Value& value) {
+    IR::Inst& phi{RegAlloc::AliasInst(*phi_value.Inst())};
+    if (!phi.Definition<Id>().is_valid) {
+        // The phi node wasn't forward defined
+        DefinePhi(ctx, phi);
+    }
+    const Register phi_reg{ctx.reg_alloc.Consume(IR::Value{&phi})};
+    const Value eval_value{ctx.reg_alloc.Consume(value)};
+
+    if (phi_reg == eval_value) {
+        return;
+    }
+    switch (phi.Flags<IR::Type>()) {
+    case IR::Type::U1:
+    case IR::Type::U32:
+    case IR::Type::F32:
+        ctx.Add("MOV.S {}.x,{};", phi_reg, ScalarS32{eval_value});
+        break;
+    case IR::Type::U64:
+    case IR::Type::F64:
+        ctx.Add("MOV.U64 {}.x,{};", phi_reg, ScalarRegister{eval_value});
+        break;
+    default:
+        throw NotImplementedException("Phi node type {}", phi.Type());
+    }
+}
+
+void EmitPrologue(EmitContext&) {
+    // TODO
+}
+
+void EmitEpilogue(EmitContext&) {
+    // TODO
+}
+
+void EmitEmitVertex(EmitContext& ctx, ScalarS32 stream) {
+    if (stream.type == Type::U32 && stream.imm_u32 == 0) {
+        ctx.Add("EMIT;");
+    } else {
+        ctx.Add("EMITS {};", stream);
+    }
+}
+
+void EmitEndPrimitive(EmitContext& ctx, const IR::Value& stream) {
+    if (!stream.IsImmediate()) {
+        LOG_WARNING(Shader_GLASM, "Stream is not immediate");
+    }
+    ctx.reg_alloc.Consume(stream);
+    ctx.Add("ENDPRIM;");
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_undefined.cpp

@@ -0,0 +1,30 @@
+// Copyright 2021 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
+
+namespace Shader::Backend::GLASM {
+
+void EmitUndefU1(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,0;", inst);
+}
+
+void EmitUndefU8(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,0;", inst);
+}
+
+void EmitUndefU16(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,0;", inst);
+}
+
+void EmitUndefU32(EmitContext& ctx, IR::Inst& inst) {
+    ctx.Add("MOV.S {}.x,0;", inst);
+}
+
+void EmitUndefU64(EmitContext& ctx, IR::Inst& inst) {
+    ctx.LongAdd("MOV.S64 {}.x,0;", inst);
+}
+
+} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_warp.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/profile.h"
 

src/shader_recompiler/backend/glasm/glasm_emit_context.cpp

@@ -5,8 +5,8 @@
 #include <string_view>
 
 #include "shader_recompiler/backend/bindings.h"
-#include "shader_recompiler/backend/glasm/emit_context.h"
 #include "shader_recompiler/backend/glasm/emit_glasm.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/profile.h"
 #include "shader_recompiler/runtime_info.h"

src/shader_recompiler/backend/glasm/reg_alloc.cpp

@@ -6,7 +6,7 @@
 
 #include <fmt/format.h>
 
-#include "shader_recompiler/backend/glasm/emit_context.h"
+#include "shader_recompiler/backend/glasm/glasm_emit_context.h"
 #include "shader_recompiler/backend/glasm/reg_alloc.h"
 #include "shader_recompiler/exception.h"
 #include "shader_recompiler/frontend/ir/value.h"

src/shader_recompiler/backend/glsl/emit_glsl.cpp

@@ -9,9 +9,9 @@
 
 #include "common/div_ceil.h"
 #include "common/settings.h"
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_atomic.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_barriers.cpp

@@ -2,8 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_bitwise_conversion.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_composite.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/profile.h"
 #include "shader_recompiler/runtime_info.h"

src/shader_recompiler/backend/glsl/emit_glsl_control_flow.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/exception.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_convert.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_floating_point.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/modifiers.h"
 #include "shader_recompiler/frontend/ir/value.h"
 

src/shader_recompiler/backend/glsl/emit_glsl_image.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/modifiers.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/profile.h"

src/shader_recompiler/backend/glsl/emit_glsl_integer.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_logical.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 namespace Shader::Backend::GLSL {

src/shader_recompiler/backend/glsl/emit_glsl_memory.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/profile.h"
 

src/shader_recompiler/backend/glsl/emit_glsl_not_implemented.cpp

@@ -4,8 +4,8 @@
 
 #include <string_view>
 
-#include "shader_recompiler/backend/glsl/emit_context.h"
 #include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
+#include "shader_recompiler/backend/glsl/glsl_emit_context.h"
 #include "shader_recompiler/frontend/ir/value.h"
 
 #ifdef _MSC_VER