Delete renderer_vulkan.cpp

externals/microprofile/microprofileui.h

@@ -845,6 +845,8 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
     MicroProfile& S = *MicroProfileGet();
     MP_DEBUG_DUMP_RANGE();
     int nY = nBaseY - UI.nOffsetY;
+    int64_t nNumBoxes = 0;
+    int64_t nNumLines = 0;
 
     uint32_t nFrameNext = (S.nFrameCurrent+1) % MICROPROFILE_MAX_FRAME_HISTORY;
     MicroProfileFrameState* pFrameCurrent = &S.Frames[S.nFrameCurrent];
@@ -1147,6 +1149,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                 }
                             }
 #endif
+                            ++nNumBoxes;
                         }
                         else
                         {
@@ -1162,6 +1165,7 @@ inline void MicroProfileDrawDetailedBars(uint32_t nWidth, uint32_t nHeight, int
                                 }
                                 nLinesDrawn[nStackPos] = nLineX;
                                 MicroProfileDrawLineVertical(nLineX, fYStart + 0.5f, fYEnd + 0.5f, nColor|UI.nOpacityForeground);
+                                ++nNumLines;
                             }
                         }
                         nStackPos--;

src/audio_core/renderer/performance/performance_manager.cpp

@@ -26,7 +26,6 @@ void PerformanceManager::CreateImpl(const size_t version) {
         impl = std::make_unique<
             PerformanceManagerImpl<PerformanceVersion::Version1, PerformanceFrameHeaderVersion1,
                                    PerformanceEntryVersion1, PerformanceDetailVersion1>>();
-        break;
     }
 }
 

src/common/CMakeLists.txt

@@ -34,8 +34,6 @@ add_library(common STATIC
     bit_util.h
     cityhash.cpp
     cityhash.h
-    cache_management.cpp
-    cache_management.h
     common_funcs.h
     common_types.h
     concepts.h

src/common/atomic_helpers.h

@@ -156,7 +156,6 @@ AE_FORCEINLINE void compiler_fence(memory_order order) AE_NO_TSAN {
         break;
     default:
         assert(false);
-        break;
     }
 }
 

src/common/cache_management.cpp

@@ -1,60 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cstring>
-
-#include "alignment.h"
-#include "cache_management.h"
-#include "common_types.h"
-
-namespace Common {
-
-#if defined(ARCHITECTURE_x86_64)
-
-// Most cache operations are no-ops on x86
-
-void DataCacheLineCleanByVAToPoU(void* start, size_t size) {}
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size) {}
-void DataCacheLineCleanByVAToPoC(void* start, size_t size) {}
-void DataCacheZeroByVA(void* start, size_t size) {
-    std::memset(start, 0, size);
-}
-
-#elif defined(ARCHITECTURE_arm64)
-
-// BS/DminLine is log2(cache size in words), we want size in bytes
-#define EXTRACT_DMINLINE(ctr_el0) (1 << ((((ctr_el0) >> 16) & 0xf) + 2))
-#define EXTRACT_BS(dczid_el0) (1 << (((dczid_el0)&0xf) + 2))
-
-#define DEFINE_DC_OP(op_name, function_name)                                                       \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t ctr_el0;                                                                            \
-        asm volatile("mrs %[ctr_el0], ctr_el0\n\t" : [ctr_el0] "=r"(ctr_el0));                     \
-        size_t cacheline_size = EXTRACT_DMINLINE(ctr_el0);                                         \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-#define DEFINE_DC_OP_DCZID(op_name, function_name)                                                 \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t dczid_el0;                                                                          \
-        asm volatile("mrs %[dczid_el0], dczid_el0\n\t" : [dczid_el0] "=r"(dczid_el0));             \
-        size_t cacheline_size = EXTRACT_BS(dczid_el0);                                             \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-DEFINE_DC_OP(cvau, DataCacheLineCleanByVAToPoU);
-DEFINE_DC_OP(civac, DataCacheLineCleanAndInvalidateByVAToPoC);
-DEFINE_DC_OP(cvac, DataCacheLineCleanByVAToPoC);
-DEFINE_DC_OP_DCZID(zva, DataCacheZeroByVA);
-
-#endif
-
-} // namespace Common

src/common/cache_management.h

@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "stdlib.h"
-
-namespace Common {
-
-// Data cache instructions enabled at EL0 by SCTLR_EL1.UCI.
-// VA = virtual address
-// PoC = point of coherency
-// PoU = point of unification
-
-// dc cvau
-void DataCacheLineCleanByVAToPoU(void* start, size_t size);
-
-// dc civac
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size);
-
-// dc cvac
-void DataCacheLineCleanByVAToPoC(void* start, size_t size);
-
-// dc zva
-void DataCacheZeroByVA(void* start, size_t size);
-
-} // namespace Common

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -348,6 +348,7 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (Settings::values.cpu_accuracy.GetValue() == Settings::CPUAccuracy::Auto) {
             config.unsafe_optimizations = true;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
+            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
             config.fastmem_address_space_bits = 64;
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
         }

src/core/hid/emulated_console.cpp

@@ -19,26 +19,27 @@ void EmulatedConsole::ReloadFromSettings() {
 }
 
 void EmulatedConsole::SetTouchParams() {
+    // TODO(german77): Support any number of fingers
     std::size_t index = 0;
 
-    // We can't use mouse as touch if native mouse is enabled
+    // Hardcode mouse, touchscreen and cemuhook parameters
     if (!Settings::values.mouse_enabled) {
+        // We can't use mouse as touch if native mouse is enabled
         touch_params[index++] = Common::ParamPackage{"engine:mouse,axis_x:10,axis_y:11,button:0"};
     }
 
     touch_params[index++] =
-        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536"};
+        Common::ParamPackage{"engine:touch,axis_x:0,axis_y:1,button:0,touch_id:0"};
     touch_params[index++] =
-        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072"};
-
-    for (int i = 0; i < static_cast<int>(MaxActiveTouchInputs); i++) {
-        Common::ParamPackage touchscreen_param{};
-        touchscreen_param.Set("engine", "touch");
-        touchscreen_param.Set("axis_x", i * 2);
-        touchscreen_param.Set("axis_y", (i * 2) + 1);
-        touchscreen_param.Set("button", i);
-        touch_params[index++] = touchscreen_param;
-    }
+        Common::ParamPackage{"engine:touch,axis_x:2,axis_y:3,button:1,touch_id:1"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:touch,axis_x:4,axis_y:5,button:2,touch_id:2"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:touch,axis_x:6,axis_y:7,button:3,touch_id:3"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:17,axis_y:18,button:65536,touch_id:0"};
+    touch_params[index++] =
+        Common::ParamPackage{"engine:cemuhookudp,axis_x:19,axis_y:20,button:131072,touch_id:1"};
 
     const auto button_index =
         static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
@@ -46,7 +47,7 @@ void EmulatedConsole::SetTouchParams() {
 
     // Map the rest of the fingers from touch from button configuration
     for (const auto& config_entry : touch_buttons) {
-        if (index >= MaxTouchDevices) {
+        if (index >= touch_params.size()) {
             continue;
         }
         Common::ParamPackage params{config_entry};
@@ -59,6 +60,7 @@ void EmulatedConsole::SetTouchParams() {
         touch_button_params.Set("button", params.Serialize());
         touch_button_params.Set("x", x);
         touch_button_params.Set("y", y);
+        touch_button_params.Set("touch_id", static_cast<int>(index));
         touch_params[index] = touch_button_params;
         index++;
     }
@@ -176,38 +178,12 @@ void EmulatedConsole::SetMotion(const Common::Input::CallbackStatus& callback) {
 }
 
 void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index) {
-    if (index >= MaxTouchDevices) {
+    if (index >= console.touch_values.size()) {
         return;
     }
     std::unique_lock lock{mutex};
 
-    const auto touch_input = TransformToTouch(callback);
-    auto touch_index = GetIndexFromFingerId(index);
-    bool is_new_input = false;
-
-    if (!touch_index.has_value() && touch_input.pressed.value) {
-        touch_index = GetNextFreeIndex();
-        is_new_input = true;
-    }
-
-    // No free entries or invalid state. Ignore input
-    if (!touch_index.has_value()) {
-        return;
-    }
-
-    auto& touch_value = console.touch_values[touch_index.value()];
-
-    if (is_new_input) {
-        touch_value.pressed.value = true;
-        touch_value.id = static_cast<u32>(index);
-    }
-
-    touch_value.x = touch_input.x;
-    touch_value.y = touch_input.y;
-
-    if (!touch_input.pressed.value) {
-        touch_value.pressed.value = false;
-    }
+    console.touch_values[index] = TransformToTouch(callback);
 
     if (is_configuring) {
         lock.unlock();
@@ -215,15 +191,11 @@ void EmulatedConsole::SetTouch(const Common::Input::CallbackStatus& callback, st
         return;
     }
 
-    // Touch outside allowed range. Ignore input
-    if (touch_index.value() >= MaxActiveTouchInputs) {
-        return;
-    }
-
-    console.touch_state[touch_index.value()] = {
-        .position = {touch_value.x.value, touch_value.y.value},
-        .id = static_cast<u32>(touch_index.value()),
-        .pressed = touch_input.pressed.value,
+    // TODO(german77): Remap touch id in sequential order
+    console.touch_state[index] = {
+        .position = {console.touch_values[index].x.value, console.touch_values[index].y.value},
+        .id = static_cast<u32>(console.touch_values[index].id),
+        .pressed = console.touch_values[index].pressed.value,
     };
 
     lock.unlock();
@@ -250,28 +222,6 @@ TouchFingerState EmulatedConsole::GetTouch() const {
     return console.touch_state;
 }
 
-std::optional<std::size_t> EmulatedConsole::GetIndexFromFingerId(std::size_t finger_id) const {
-    for (std::size_t index = 0; index < MaxTouchDevices; ++index) {
-        const auto& finger = console.touch_values[index];
-        if (!finger.pressed.value) {
-            continue;
-        }
-        if (finger.id == static_cast<int>(finger_id)) {
-            return index;
-        }
-    }
-    return std::nullopt;
-}
-
-std::optional<std::size_t> EmulatedConsole::GetNextFreeIndex() const {
-    for (std::size_t index = 0; index < MaxTouchDevices; ++index) {
-        if (!console.touch_values[index].pressed.value) {
-            return index;
-        }
-    }
-    return std::nullopt;
-}
-
 void EmulatedConsole::TriggerOnChange(ConsoleTriggerType type) {
     std::scoped_lock lock{callback_mutex};
     for (const auto& poller_pair : callback_list) {

src/core/hid/emulated_console.h

@@ -7,7 +7,6 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <optional>
 #include <unordered_map>
 
 #include "common/common_funcs.h"
@@ -21,8 +20,6 @@
 #include "core/hid/motion_input.h"
 
 namespace Core::HID {
-static constexpr std::size_t MaxTouchDevices = 32;
-static constexpr std::size_t MaxActiveTouchInputs = 16;
 
 struct ConsoleMotionInfo {
     Common::Input::MotionStatus raw_status{};
@@ -30,13 +27,13 @@ struct ConsoleMotionInfo {
 };
 
 using ConsoleMotionDevices = std::unique_ptr<Common::Input::InputDevice>;
-using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, MaxTouchDevices>;
+using TouchDevices = std::array<std::unique_ptr<Common::Input::InputDevice>, 16>;
 
 using ConsoleMotionParams = Common::ParamPackage;
-using TouchParams = std::array<Common::ParamPackage, MaxTouchDevices>;
+using TouchParams = std::array<Common::ParamPackage, 16>;
 
 using ConsoleMotionValues = ConsoleMotionInfo;
-using TouchValues = std::array<Common::Input::TouchStatus, MaxTouchDevices>;
+using TouchValues = std::array<Common::Input::TouchStatus, 16>;
 
 struct TouchFinger {
     u64 last_touch{};
@@ -58,7 +55,7 @@ struct ConsoleMotion {
     bool is_at_rest{};
 };
 
-using TouchFingerState = std::array<TouchFinger, MaxActiveTouchInputs>;
+using TouchFingerState = std::array<TouchFinger, 16>;
 
 struct ConsoleStatus {
     // Data from input_common
@@ -169,10 +166,6 @@ private:
      */
     void SetTouch(const Common::Input::CallbackStatus& callback, std::size_t index);
 
-    std::optional<std::size_t> GetIndexFromFingerId(std::size_t finger_id) const;
-
-    std::optional<std::size_t> GetNextFreeIndex() const;
-
     /**
      * Triggers a callback that something has changed on the console status
      * @param type Input type of the event to trigger

src/core/hid/input_converter.cpp

@@ -200,6 +200,9 @@ Common::Input::TouchStatus TransformToTouch(const Common::Input::CallbackStatus&
     x = std::clamp(x, 0.0f, 1.0f);
     y = std::clamp(y, 0.0f, 1.0f);
 
+    // Limit id to maximum number of fingers
+    status.id = std::clamp(status.id, 0, 16);
+
     if (status.pressed.inverted) {
         status.pressed.value = !status.pressed.value;
     }

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

@@ -243,7 +243,6 @@ void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {
             // If we somehow get an invalid type, abort.
         default:
             ASSERT_MSG(false, "Unknown slab type: {}", slab_types[i]);
-            break;
         }
 
         // If we've hit the end of a gap, free it.

src/core/hle/kernel/k_page_table.cpp

@@ -2301,7 +2301,6 @@ Result KPageTable::SetProcessMemoryPermission(VAddr addr, size_t size,
             break;
         default:
             ASSERT(false);
-            break;
         }
     }
 
@@ -2804,7 +2803,6 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, const KPageGroup& page_
             break;
         default:
             ASSERT(false);
-            break;
         }
 
         addr += size;
@@ -2840,7 +2838,6 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, KMemoryPermission perm,
         break;
     default:
         ASSERT(false);
-        break;
     }
     R_SUCCEED();
 }

src/core/hle/kernel/k_process.cpp

@@ -395,7 +395,6 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
 
     default:
         ASSERT(false);
-        break;
     }
 
     // Create TLS region

src/core/hle/kernel/svc.cpp

@@ -2701,24 +2701,14 @@ static Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr ou
     return ResultSuccess;
 }
 
-static Result FlushProcessDataCache32(Core::System& system, Handle process_handle, u64 address,
-                                      u64 size) {
-    // Validate address/size.
-    R_UNLESS(size > 0, ResultInvalidSize);
-    R_UNLESS(address == static_cast<uintptr_t>(address), ResultInvalidCurrentMemory);
-    R_UNLESS(size == static_cast<size_t>(size), ResultInvalidCurrentMemory);
-
-    // Get the process from its handle.
-    KScopedAutoObject process =
-        system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KProcess>(process_handle);
-    R_UNLESS(process.IsNotNull(), ResultInvalidHandle);
-
-    // Verify the region is within range.
-    auto& page_table = process->PageTable();
-    R_UNLESS(page_table.Contains(address, size), ResultInvalidCurrentMemory);
-
-    // Perform the operation.
-    R_RETURN(system.Memory().FlushDataCache(*process, address, size));
+static Result FlushProcessDataCache32([[maybe_unused]] Core::System& system,
+                                      [[maybe_unused]] Handle handle, [[maybe_unused]] u32 address,
+                                      [[maybe_unused]] u32 size) {
+    // Note(Blinkhawk): For emulation purposes of the data cache this is mostly a no-op,
+    // as all emulation is done in the same cache level in host architecture, thus data cache
+    // does not need flushing.
+    LOG_DEBUG(Kernel_SVC, "called");
+    return ResultSuccess;
 }
 
 namespace {

src/core/hle/kernel/svc_wrap.h

@@ -722,12 +722,4 @@ void SvcWrap32(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-// Used by Invalidate/Store/FlushProcessDataCache32
-template <Result func(Core::System&, Handle, u64, u64)>
-void SvcWrap32(Core::System& system) {
-    const u64 address = (Param(system, 3) << 32) | Param(system, 2);
-    const u64 size = (Param(system, 4) << 32) | Param(system, 1);
-    FuncReturn32(system, func(system, Param32(system, 0), address, size).raw);
-}
-
 } // namespace Kernel

src/core/hle/service/am/applets/applet_error.cpp

@@ -144,7 +144,6 @@ void Error::Initialize() {
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented LibAppletError mode={:02X}!", mode);
-        break;
     }
 }
 

src/core/hle/service/am/applets/applet_general_backend.cpp

@@ -129,7 +129,6 @@ void Auth::Execute() {
     }
     default:
         unimplemented_log();
-        break;
     }
 }
 
@@ -193,7 +192,6 @@ void PhotoViewer::Execute() {
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented PhotoViewer applet mode={:02X}!", mode);
-        break;
     }
 }
 

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

@@ -36,9 +36,8 @@ namespace Service::HID {
 
 // Updating period for each HID device.
 // Period time is obtained by measuring the number of samples in a second on HW using a homebrew
-// Correct npad_update_ns is 4ms this is overclocked to lower input lag
-constexpr auto npad_update_ns = std::chrono::nanoseconds{1 * 1000 * 1000};    // (1ms, 1000Hz)
-constexpr auto default_update_ns = std::chrono::nanoseconds{4 * 1000 * 1000}; // (4ms, 1000Hz)
+// Correct pad_update_ns is 4ms this is overclocked to lower input lag
+constexpr auto pad_update_ns = std::chrono::nanoseconds{1 * 1000 * 1000}; // (1ms, 1000Hz)
 constexpr auto mouse_keyboard_update_ns = std::chrono::nanoseconds{8 * 1000 * 1000}; // (8ms, 125Hz)
 constexpr auto motion_update_ns = std::chrono::nanoseconds{5 * 1000 * 1000};         // (5ms, 200Hz)
 
@@ -76,16 +75,8 @@ IAppletResource::IAppletResource(Core::System& system_,
     GetController<Controller_Stubbed>(HidController::UniquePad).SetCommonHeaderOffset(0x5A00);
 
     // Register update callbacks
-    npad_update_event = Core::Timing::CreateEvent(
+    pad_update_event = Core::Timing::CreateEvent(
         "HID::UpdatePadCallback",
-        [this](std::uintptr_t user_data, s64 time,
-               std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
-            const auto guard = LockService();
-            UpdateNpad(user_data, ns_late);
-            return std::nullopt;
-        });
-    default_update_event = Core::Timing::CreateEvent(
-        "HID::UpdateDefaultCallback",
         [this](std::uintptr_t user_data, s64 time,
                std::chrono::nanoseconds ns_late) -> std::optional<std::chrono::nanoseconds> {
             const auto guard = LockService();
@@ -109,9 +100,7 @@ IAppletResource::IAppletResource(Core::System& system_,
             return std::nullopt;
         });
 
-    system.CoreTiming().ScheduleLoopingEvent(npad_update_ns, npad_update_ns, npad_update_event);
-    system.CoreTiming().ScheduleLoopingEvent(default_update_ns, default_update_ns,
-                                             default_update_event);
+    system.CoreTiming().ScheduleLoopingEvent(pad_update_ns, pad_update_ns, pad_update_event);
     system.CoreTiming().ScheduleLoopingEvent(mouse_keyboard_update_ns, mouse_keyboard_update_ns,
                                              mouse_keyboard_update_event);
     system.CoreTiming().ScheduleLoopingEvent(motion_update_ns, motion_update_ns,
@@ -129,8 +118,7 @@ void IAppletResource::DeactivateController(HidController controller) {
 }
 
 IAppletResource::~IAppletResource() {
-    system.CoreTiming().UnscheduleEvent(npad_update_event, 0);
-    system.CoreTiming().UnscheduleEvent(default_update_event, 0);
+    system.CoreTiming().UnscheduleEvent(pad_update_event, 0);
     system.CoreTiming().UnscheduleEvent(mouse_keyboard_update_event, 0);
     system.CoreTiming().UnscheduleEvent(motion_update_event, 0);
 }
@@ -156,20 +144,10 @@ void IAppletResource::UpdateControllers(std::uintptr_t user_data,
         if (controller == controllers[static_cast<size_t>(HidController::Mouse)]) {
             continue;
         }
-        // Npad has it's own update event
-        if (controller == controllers[static_cast<size_t>(HidController::NPad)]) {
-            continue;
-        }
         controller->OnUpdate(core_timing);
     }
 }
 
-void IAppletResource::UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late) {
-    auto& core_timing = system.CoreTiming();
-
-    controllers[static_cast<size_t>(HidController::NPad)]->OnUpdate(core_timing);
-}
-
 void IAppletResource::UpdateMouseKeyboard(std::uintptr_t user_data,
                                           std::chrono::nanoseconds ns_late) {
     auto& core_timing = system.CoreTiming();

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

@@ -71,14 +71,12 @@ private:
 
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
     void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
-    void UpdateNpad(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMouseKeyboard(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
 
     KernelHelpers::ServiceContext& service_context;
 
-    std::shared_ptr<Core::Timing::EventType> npad_update_event;
-    std::shared_ptr<Core::Timing::EventType> default_update_event;
+    std::shared_ptr<Core::Timing::EventType> pad_update_event;
     std::shared_ptr<Core::Timing::EventType> mouse_keyboard_update_event;
     std::shared_ptr<Core::Timing::EventType> motion_update_event;
 

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

@@ -300,10 +300,11 @@ Kernel::KEvent* nvhost_ctrl_gpu::QueryEvent(u32 event_id) {
         return error_notifier_event;
     case 2:
         return unknown_event;
-    default:
+    default: {
         LOG_CRITICAL(Service_NVDRV, "Unknown Ctrl GPU Event {}", event_id);
-        return nullptr;
     }
+    }
+    return nullptr;
 }
 
 } // namespace Service::Nvidia::Devices

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

@@ -364,10 +364,11 @@ Kernel::KEvent* nvhost_gpu::QueryEvent(u32 event_id) {
         return sm_exception_breakpoint_pause_report_event;
     case 3:
         return error_notifier_event;
-    default:
+    default: {
         LOG_CRITICAL(Service_NVDRV, "Unknown Ctrl GPU Event {}", event_id);
-        return nullptr;
     }
+    }
+    return nullptr;
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvflinger/buffer_queue_core.cpp

@@ -23,17 +23,15 @@ void BufferQueueCore::NotifyShutdown() {
 }
 
 void BufferQueueCore::SignalDequeueCondition() {
-    dequeue_possible.store(true);
     dequeue_condition.notify_all();
 }
 
-bool BufferQueueCore::WaitForDequeueCondition(std::unique_lock<std::mutex>& lk) {
+bool BufferQueueCore::WaitForDequeueCondition() {
     if (is_shutting_down) {
         return false;
     }
 
-    dequeue_condition.wait(lk, [&] { return dequeue_possible.load(); });
-    dequeue_possible.store(false);
+    dequeue_condition.wait(mutex);
 
     return true;
 }

src/core/hle/service/nvflinger/buffer_queue_core.h

@@ -38,7 +38,7 @@ public:
 
 private:
     void SignalDequeueCondition();
-    bool WaitForDequeueCondition(std::unique_lock<std::mutex>& lk);
+    bool WaitForDequeueCondition();
 
     s32 GetMinUndequeuedBufferCountLocked(bool async) const;
     s32 GetMinMaxBufferCountLocked(bool async) const;
@@ -60,8 +60,7 @@ private:
     BufferQueueDefs::SlotsType slots{};
     std::vector<BufferItem> queue;
     s32 override_max_buffer_count{};
-    std::condition_variable dequeue_condition;
-    std::atomic<bool> dequeue_possible{};
+    mutable std::condition_variable_any dequeue_condition;
     const bool use_async_buffer{}; // This is always disabled on HOS
     bool dequeue_buffer_cannot_block{};
     PixelFormat default_buffer_format{PixelFormat::Rgba8888};

src/core/hle/service/nvflinger/buffer_queue_producer.cpp

@@ -121,8 +121,8 @@ Status BufferQueueProducer::SetBufferCount(s32 buffer_count) {
     return Status::NoError;
 }
 
-Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, Status* return_flags,
-                                                      std::unique_lock<std::mutex>& lk) const {
+Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found,
+                                                      Status* return_flags) const {
     bool try_again = true;
 
     while (try_again) {
@@ -214,7 +214,7 @@ Status BufferQueueProducer::WaitForFreeSlotThenRelock(bool async, s32* found, St
                 return Status::WouldBlock;
             }
 
-            if (!core->WaitForDequeueCondition(lk)) {
+            if (!core->WaitForDequeueCondition()) {
                 // We are no longer running
                 return Status::NoError;
             }
@@ -237,7 +237,7 @@ Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool
     Status return_flags = Status::NoError;
     bool attached_by_consumer = false;
     {
-        std::unique_lock lock{core->mutex};
+        std::scoped_lock lock{core->mutex};
         core->WaitWhileAllocatingLocked();
 
         if (format == PixelFormat::NoFormat) {
@@ -248,7 +248,7 @@ Status BufferQueueProducer::DequeueBuffer(s32* out_slot, Fence* out_fence, bool
         usage |= core->consumer_usage_bit;
 
         s32 found{};
-        Status status = WaitForFreeSlotThenRelock(async, &found, &return_flags, lock);
+        Status status = WaitForFreeSlotThenRelock(async, &found, &return_flags);
         if (status != Status::NoError) {
             return status;
         }
@@ -400,13 +400,13 @@ Status BufferQueueProducer::AttachBuffer(s32* out_slot,
         return Status::BadValue;
     }
 
-    std::unique_lock lock{core->mutex};
+    std::scoped_lock lock{core->mutex};
     core->WaitWhileAllocatingLocked();
 
     Status return_flags = Status::NoError;
     s32 found{};
 
-    const auto status = WaitForFreeSlotThenRelock(false, &found, &return_flags, lock);
+    const auto status = WaitForFreeSlotThenRelock(false, &found, &return_flags);
     if (status != Status::NoError) {
         return status;
     }

src/core/hle/service/nvflinger/buffer_queue_producer.h

@@ -70,8 +70,7 @@ public:
 private:
     BufferQueueProducer(const BufferQueueProducer&) = delete;
 
-    Status WaitForFreeSlotThenRelock(bool async, s32* found, Status* return_flags,
-                                     std::unique_lock<std::mutex>& lk) const;
+    Status WaitForFreeSlotThenRelock(bool async, s32* found, Status* return_flags) const;
 
     Kernel::KEvent* buffer_wait_event{};
     Service::KernelHelpers::ServiceContext& service_context;

src/core/hle/service/service.cpp

@@ -228,7 +228,6 @@ Result ServiceFrameworkBase::HandleSyncRequest(Kernel::KServerSession& session,
         }
 
         UNIMPLEMENTED_MSG("command_type={}", ctx.GetCommandType());
-        break;
     }
 
     // If emulation was shutdown, we are closing service threads, do not write the response back to

src/core/hle/service/time/time_zone_manager.cpp

@@ -280,7 +280,6 @@ static constexpr int TransitionTime(int year, Rule rule, int offset) {
     }
     default:
         ASSERT(false);
-        break;
     }
     return value + rule.transition_time + offset;
 }

src/core/memory.cpp

@@ -6,7 +6,6 @@
 
 #include "common/assert.h"
 #include "common/atomic_ops.h"
-#include "common/cache_management.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
@@ -330,55 +329,6 @@ struct Memory::Impl {
             });
     }
 
-    template <typename Callback>
-    Result PerformCacheOperation(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size,
-                                 Callback&& cb) {
-        class InvalidMemoryException : public std::exception {};
-
-        try {
-            WalkBlock(
-                process, dest_addr, size,
-                [&](const std::size_t block_size, const VAddr current_vaddr) {
-                    LOG_ERROR(HW_Memory, "Unmapped cache maintenance @ {:#018X}", current_vaddr);
-                    throw InvalidMemoryException();
-                },
-                [&](const std::size_t block_size, u8* const host_ptr) { cb(block_size, host_ptr); },
-                [&](const VAddr current_vaddr, const std::size_t block_size, u8* const host_ptr) {
-                    system.GPU().FlushRegion(current_vaddr, block_size);
-                    cb(block_size, host_ptr);
-                },
-                [](const std::size_t block_size) {});
-        } catch (InvalidMemoryException&) {
-            return Kernel::ResultInvalidCurrentMemory;
-        }
-
-        return ResultSuccess;
-    }
-
-    Result InvalidateDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
-        auto perform = [&](const std::size_t block_size, u8* const host_ptr) {
-            // Do nothing; this operation (dc ivac) cannot be supported
-            // from EL0
-        };
-        return PerformCacheOperation(process, dest_addr, size, perform);
-    }
-
-    Result StoreDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
-        auto perform = [&](const std::size_t block_size, u8* const host_ptr) {
-            // dc cvac: Store to point of coherency
-            Common::DataCacheLineCleanByVAToPoC(host_ptr, block_size);
-        };
-        return PerformCacheOperation(process, dest_addr, size, perform);
-    }
-
-    Result FlushDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
-        auto perform = [&](const std::size_t block_size, u8* const host_ptr) {
-            // dc civac: Store to point of coherency, and invalidate from cache
-            Common::DataCacheLineCleanAndInvalidateByVAToPoC(host_ptr, block_size);
-        };
-        return PerformCacheOperation(process, dest_addr, size, perform);
-    }
-
     void MarkRegionDebug(VAddr vaddr, u64 size, bool debug) {
         if (vaddr == 0) {
             return;
@@ -836,21 +786,6 @@ void Memory::ZeroBlock(const Kernel::KProcess& process, VAddr dest_addr, const s
     impl->ZeroBlock(process, dest_addr, size);
 }
 
-Result Memory::InvalidateDataCache(const Kernel::KProcess& process, VAddr dest_addr,
-                                   const std::size_t size) {
-    return impl->InvalidateDataCache(process, dest_addr, size);
-}
-
-Result Memory::StoreDataCache(const Kernel::KProcess& process, VAddr dest_addr,
-                              const std::size_t size) {
-    return impl->StoreDataCache(process, dest_addr, size);
-}
-
-Result Memory::FlushDataCache(const Kernel::KProcess& process, VAddr dest_addr,
-                              const std::size_t size) {
-    return impl->FlushDataCache(process, dest_addr, size);
-}
-
 void Memory::RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
     impl->RasterizerMarkRegionCached(vaddr, size, cached);
 }

src/core/memory.h

@@ -7,7 +7,6 @@
 #include <memory>
 #include <string>
 #include "common/common_types.h"
-#include "core/hle/result.h"
 
 namespace Common {
 struct PageTable;
@@ -450,39 +449,6 @@ public:
      */
     void ZeroBlock(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size);
 
-    /**
-     * Invalidates a range of bytes within the current process' address space at the specified
-     * virtual address.
-     *
-     * @param process   The process that will have data invalidated within its address space.
-     * @param dest_addr The destination virtual address to invalidate the data from.
-     * @param size      The size of the range to invalidate, in bytes.
-     *
-     */
-    Result InvalidateDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size);
-
-    /**
-     * Stores a range of bytes within the current process' address space at the specified
-     * virtual address.
-     *
-     * @param process   The process that will have data stored within its address space.
-     * @param dest_addr The destination virtual address to store the data from.
-     * @param size      The size of the range to store, in bytes.
-     *
-     */
-    Result StoreDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size);
-
-    /**
-     * Flushes a range of bytes within the current process' address space at the specified
-     * virtual address.
-     *
-     * @param process   The process that will have data flushed within its address space.
-     * @param dest_addr The destination virtual address to flush the data from.
-     * @param size      The size of the range to flush, in bytes.
-     *
-     */
-    Result FlushDataCache(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size);
-
     /**
      * Marks each page within the specified address range as cached or uncached.
      *

src/input_common/helpers/touch_from_buttons.cpp

@@ -10,8 +10,8 @@ namespace InputCommon {
 class TouchFromButtonDevice final : public Common::Input::InputDevice {
 public:
     using Button = std::unique_ptr<Common::Input::InputDevice>;
-    TouchFromButtonDevice(Button button_, float x_, float y_)
-        : button(std::move(button_)), x(x_), y(y_) {
+    TouchFromButtonDevice(Button button_, int touch_id_, float x_, float y_)
+        : button(std::move(button_)), touch_id(touch_id_), x(x_), y(y_) {
         last_button_value = false;
         button->SetCallback({
             .on_change =
@@ -34,6 +34,7 @@ public:
             .pressed = button_status,
             .x = {},
             .y = {},
+            .id = touch_id,
         };
         status.x.properties = properties;
         status.y.properties = properties;
@@ -61,6 +62,7 @@ public:
 private:
     Button button;
     bool last_button_value;
+    const int touch_id;
     const float x;
     const float y;
     const Common::Input::AnalogProperties properties{0.0f, 1.0f, 0.5f, 0.0f, false};
@@ -71,9 +73,10 @@ std::unique_ptr<Common::Input::InputDevice> TouchFromButton::Create(
     const std::string null_engine = Common::ParamPackage{{"engine", "null"}}.Serialize();
     auto button = Common::Input::CreateDeviceFromString<Common::Input::InputDevice>(
         params.Get("button", null_engine));
+    const auto touch_id = params.Get("touch_id", 0);
     const float x = params.Get("x", 0.0f) / 1280.0f;
     const float y = params.Get("y", 0.0f) / 720.0f;
-    return std::make_unique<TouchFromButtonDevice>(std::move(button), x, y);
+    return std::make_unique<TouchFromButtonDevice>(std::move(button), touch_id, x, y);
 }
 
 } // namespace InputCommon

src/input_common/input_poller.cpp

@@ -229,12 +229,13 @@ private:
 
 class InputFromTouch final : public Common::Input::InputDevice {
 public:
-    explicit InputFromTouch(PadIdentifier identifier_, int button_, bool toggle_, bool inverted_,
-                            int axis_x_, int axis_y_, Common::Input::AnalogProperties properties_x_,
+    explicit InputFromTouch(PadIdentifier identifier_, int touch_id_, int button_, bool toggle_,
+                            bool inverted_, int axis_x_, int axis_y_,
+                            Common::Input::AnalogProperties properties_x_,
                             Common::Input::AnalogProperties properties_y_,
                             InputEngine* input_engine_)
-        : identifier(identifier_), button(button_), toggle(toggle_), inverted(inverted_),
-          axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
+        : identifier(identifier_), touch_id(touch_id_), button(button_), toggle(toggle_),
+          inverted(inverted_), axis_x(axis_x_), axis_y(axis_y_), properties_x(properties_x_),
           properties_y(properties_y_), input_engine(input_engine_) {
         UpdateCallback engine_callback{[this]() { OnChange(); }};
         const InputIdentifier button_input_identifier{
@@ -270,7 +271,8 @@ public:
     }
 
     Common::Input::TouchStatus GetStatus() const {
-        Common::Input::TouchStatus status{};
+        Common::Input::TouchStatus status;
+        status.id = touch_id;
         status.pressed = {
             .value = input_engine->GetButton(identifier, button),
             .inverted = inverted,
@@ -305,6 +307,7 @@ public:
 
 private:
     const PadIdentifier identifier;
+    const int touch_id;
     const int button;
     const bool toggle;
     const bool inverted;
@@ -916,6 +919,7 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTriggerDevice(
 
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
     const Common::ParamPackage& params) {
+    const auto touch_id = params.Get("touch_id", 0);
     const auto deadzone = std::clamp(params.Get("deadzone", 0.0f), 0.0f, 1.0f);
     const auto range = std::clamp(params.Get("range", 1.0f), 0.25f, 1.50f);
     const auto threshold = std::clamp(params.Get("threshold", 0.5f), 0.0f, 1.0f);
@@ -950,8 +954,8 @@ std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateTouchDevice(
     input_engine->PreSetAxis(identifier, axis_x);
     input_engine->PreSetAxis(identifier, axis_y);
     input_engine->PreSetButton(identifier, button);
-    return std::make_unique<InputFromTouch>(identifier, button, toggle, inverted, axis_x, axis_y,
-                                            properties_x, properties_y, input_engine.get());
+    return std::make_unique<InputFromTouch>(identifier, touch_id, button, toggle, inverted, axis_x,
+                                            axis_y, properties_x, properties_y, input_engine.get());
 }
 
 std::unique_ptr<Common::Input::InputDevice> InputFactory::CreateBatteryDevice(

src/shader_recompiler/backend/glasm/emit_glasm.cpp

@@ -320,7 +320,6 @@ void SetupOptions(const IR::Program& program, const Profile& profile,
     }
     if (stage == Stage::Fragment) {
         header += "OPTION ARB_draw_buffers;";
-        header += "OPTION ARB_fragment_layer_viewport;";
     }
 }
 

src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp

@@ -104,9 +104,6 @@ void EmitGetAttribute(EmitContext& ctx, IR::Inst& inst, IR::Attribute attr, Scal
     case IR::Attribute::PrimitiveId:
         ctx.Add("MOV.F {}.x,primitive.id;", inst);
         break;
-    case IR::Attribute::Layer:
-        ctx.Add("MOV.F {}.x,fragment.layer;", inst);
-        break;
     case IR::Attribute::PositionX:
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:

src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp

@@ -205,9 +205,6 @@ void EmitGetAttribute(EmitContext& ctx, IR::Inst& inst, IR::Attribute attr,
     case IR::Attribute::PrimitiveId:
         ctx.AddF32("{}=itof(gl_PrimitiveID);", inst);
         break;
-    case IR::Attribute::Layer:
-        ctx.AddF32("{}=itof(gl_Layer);", inst);
-        break;
     case IR::Attribute::PositionX:
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:

src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp

@@ -315,8 +315,6 @@ Id EmitGetAttribute(EmitContext& ctx, IR::Attribute attr, Id vertex) {
     switch (attr) {
     case IR::Attribute::PrimitiveId:
         return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.primitive_id));
-    case IR::Attribute::Layer:
-        return ctx.OpBitcast(ctx.F32[1], ctx.OpLoad(ctx.U32[1], ctx.layer));
     case IR::Attribute::PositionX:
     case IR::Attribute::PositionY:
     case IR::Attribute::PositionZ:

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -1359,11 +1359,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     if (loads[IR::Attribute::PrimitiveId]) {
         primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
     }
-    if (loads[IR::Attribute::Layer]) {
-        AddCapability(spv::Capability::Geometry);
-        layer = DefineInput(*this, U32[1], false, spv::BuiltIn::Layer);
-        Decorate(layer, spv::Decoration::Flat);
-    }
     if (loads.AnyComponent(IR::Attribute::PositionX)) {
         const bool is_fragment{stage != Stage::Fragment};
         const spv::BuiltIn built_in{is_fragment ? spv::BuiltIn::Position : spv::BuiltIn::FragCoord};

src/video_core/engines/maxwell_3d.cpp

@@ -232,7 +232,7 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         use_topology_override = true;
         return;
     case MAXWELL3D_REG_INDEX(clear_surface):
-        return ProcessClearBuffers(1);
+        return ProcessClearBuffers();
     case MAXWELL3D_REG_INDEX(report_semaphore.query):
         return ProcessQueryGet();
     case MAXWELL3D_REG_INDEX(render_enable.mode):
@@ -596,8 +596,8 @@ u32 Maxwell3D::GetRegisterValue(u32 method) const {
     return regs.reg_array[method];
 }
 
-void Maxwell3D::ProcessClearBuffers(u32 layer_count) {
-    rasterizer->Clear(layer_count);
+void Maxwell3D::ProcessClearBuffers() {
+    rasterizer->Clear();
 }
 
 void Maxwell3D::ProcessDraw(u32 instance_count) {

src/video_core/engines/maxwell_3d.h

@@ -3086,9 +3086,6 @@ public:
 
     std::vector<u8> inline_index_draw_indexes;
 
-    /// Handles a write to the CLEAR_BUFFERS register.
-    void ProcessClearBuffers(u32 layer_count);
-
 private:
     void InitializeRegisterDefaults();
 
@@ -3123,6 +3120,9 @@ private:
     /// Handles firmware blob 4
     void ProcessFirmwareCall4();
 
+    /// Handles a write to the CLEAR_BUFFERS register.
+    void ProcessClearBuffers();
+
     /// Handles a write to the QUERY_GET register.
     void ProcessQueryGet();
 

src/video_core/engines/maxwell_dma.cpp

@@ -314,7 +314,6 @@ void MaxwellDMA::ReleaseSemaphore() {
     }
     default:
         ASSERT_MSG(false, "Unknown semaphore type: {}", static_cast<u32>(type.Value()));
-        break;
     }
 }
 

src/video_core/engines/puller.cpp

@@ -50,7 +50,6 @@ void Puller::ProcessBindMethod(const MethodCall& method_call) {
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine {:04X}", engine_id);
-        break;
     }
 }
 
@@ -66,7 +65,6 @@ void Puller::ProcessFenceActionMethod() {
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented operation {}", regs.fence_action.op.Value());
-        break;
     }
 }
 
@@ -230,7 +228,6 @@ void Puller::CallEngineMethod(const MethodCall& method_call) {
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
-        break;
     }
 }
 
@@ -257,7 +254,6 @@ void Puller::CallEngineMultiMethod(u32 method, u32 subchannel, const u32* base_s
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented engine");
-        break;
     }
 }
 

src/video_core/macro/macro_hle.cpp

@@ -126,25 +126,11 @@ void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     }
 }
 
-// Multi-layer Clear
-void HLE_EAD26C3E2109B06B(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
-    ASSERT(parameters.size() == 1);
-
-    const Engines::Maxwell3D::Regs::ClearSurface clear_params{parameters[0]};
-    const u32 rt_index = clear_params.RT;
-    const u32 num_layers = maxwell3d.regs.rt[rt_index].depth;
-    ASSERT(clear_params.layer == 0);
-
-    maxwell3d.regs.clear_surface.raw = clear_params.raw;
-    maxwell3d.ProcessClearBuffers(num_layers);
-}
-
-constexpr std::array<std::pair<u64, HLEFunction>, 5> hle_funcs{{
+constexpr std::array<std::pair<u64, HLEFunction>, 4> hle_funcs{{
     {0x771BB18C62444DA0, &HLE_771BB18C62444DA0},
     {0x0D61FC9FAAC9FCAD, &HLE_0D61FC9FAAC9FCAD},
     {0x0217920100488FF7, &HLE_0217920100488FF7},
     {0x3F5E74B9C9A50164, &HLE_3F5E74B9C9A50164},
-    {0xEAD26C3E2109B06B, &HLE_EAD26C3E2109B06B},
 }};
 
 class HLEMacroImpl final : public CachedMacro {

src/video_core/macro/macro_interpreter.cpp

@@ -201,7 +201,6 @@ bool MacroInterpreterImpl::Step(bool is_delay_slot) {
     }
     default:
         UNIMPLEMENTED_MSG("Unimplemented macro operation {}", opcode.operation.Value());
-        break;
     }
 
     // An instruction with the Exit flag will not actually
@@ -298,7 +297,6 @@ void MacroInterpreterImpl::ProcessResult(Macro::ResultOperation operation, u32 r
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented result operation {}", operation);
-        break;
     }
 }
 

src/video_core/macro/macro_jit_x64.cpp

@@ -652,7 +652,6 @@ void MacroJITx64Impl::Compile_ProcessResult(Macro::ResultOperation operation, u3
         break;
     default:
         UNIMPLEMENTED_MSG("Unimplemented macro operation {}", operation);
-        break;
     }
 }
 

src/video_core/rasterizer_interface.h

@@ -43,7 +43,7 @@ public:
     virtual void Draw(bool is_indexed, u32 instance_count) = 0;
 
     /// Clear the current framebuffer
-    virtual void Clear(u32 layer_count) = 0;
+    virtual void Clear() = 0;
 
     /// Dispatches a compute shader invocation
     virtual void DispatchCompute() = 0;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -136,7 +136,7 @@ void RasterizerOpenGL::LoadDiskResources(u64 title_id, std::stop_token stop_load
     shader_cache.LoadDiskResources(title_id, stop_loading, callback);
 }
 
-void RasterizerOpenGL::Clear(u32 layer_count) {
+void RasterizerOpenGL::Clear() {
     MICROPROFILE_SCOPE(OpenGL_Clears);
     if (!maxwell3d->ShouldExecute()) {
         return;

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -69,7 +69,7 @@ public:
     ~RasterizerOpenGL() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;
-    void Clear(u32 layer_count) override;
+    void Clear() override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
     void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;

src/video_core/renderer_opengl/gl_texture_cache.cpp

@@ -891,7 +891,6 @@ void Image::CopyBufferToImage(const VideoCommon::BufferImageCopy& copy, size_t b
         break;
     default:
         ASSERT(false);
-        break;
     }
 }
 
@@ -928,7 +927,6 @@ void Image::CopyImageToBuffer(const VideoCommon::BufferImageCopy& copy, size_t b
         break;
     default:
         ASSERT(false);
-        break;
     }
     // Compressed formats don't have a pixel format or type
     const bool is_compressed = gl_format == GL_NONE;

src/video_core/renderer_opengl/renderer_opengl.cpp

@@ -340,7 +340,6 @@ void RendererOpenGL::ConfigureFramebufferTexture(TextureInfo& texture,
         texture.gl_type = GL_UNSIGNED_INT_8_8_8_8_REV;
         // UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
         //                   static_cast<u32>(framebuffer.pixel_format));
-        break;
     }
 
     texture.resource.Release();

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -1,345 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <algorithm>
-#include <array>
-#include <cstring>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include <fmt/format.h>
-
-#include "common/logging/log.h"
-#include "common/scope_exit.h"
-#include "common/settings.h"
-#include "common/telemetry.h"
-#include "core/core_timing.h"
-#include "core/frontend/emu_window.h"
-#include "core/telemetry_session.h"
-#include "video_core/gpu.h"
-#include "video_core/renderer_vulkan/renderer_vulkan.h"
-#include "video_core/renderer_vulkan/vk_blit_screen.h"
-#include "video_core/renderer_vulkan/vk_rasterizer.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
-#include "video_core/renderer_vulkan/vk_state_tracker.h"
-#include "video_core/renderer_vulkan/vk_swapchain.h"
-#include "video_core/vulkan_common/vulkan_debug_callback.h"
-#include "video_core/vulkan_common/vulkan_device.h"
-#include "video_core/vulkan_common/vulkan_instance.h"
-#include "video_core/vulkan_common/vulkan_library.h"
-#include "video_core/vulkan_common/vulkan_memory_allocator.h"
-#include "video_core/vulkan_common/vulkan_surface.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
-namespace Vulkan {
-namespace {
-std::string GetReadableVersion(u32 version) {
-    return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version),
-                       VK_VERSION_PATCH(version));
-}
-
-std::string GetDriverVersion(const Device& device) {
-    // Extracted from
-    // https://github.com/SaschaWillems/vulkan.gpuinfo.org/blob/5dddea46ea1120b0df14eef8f15ff8e318e35462/functions.php#L308-L314
-    const u32 version = device.GetDriverVersion();
-
-    if (device.GetDriverID() == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR) {
-        const u32 major = (version >> 22) & 0x3ff;
-        const u32 minor = (version >> 14) & 0x0ff;
-        const u32 secondary = (version >> 6) & 0x0ff;
-        const u32 tertiary = version & 0x003f;
-        return fmt::format("{}.{}.{}.{}", major, minor, secondary, tertiary);
-    }
-    if (device.GetDriverID() == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR) {
-        const u32 major = version >> 14;
-        const u32 minor = version & 0x3fff;
-        return fmt::format("{}.{}", major, minor);
-    }
-    return GetReadableVersion(version);
-}
-
-std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_extensions) {
-    std::sort(std::begin(available_extensions), std::end(available_extensions));
-
-    static constexpr std::size_t AverageExtensionSize = 64;
-    std::string separated_extensions;
-    separated_extensions.reserve(available_extensions.size() * AverageExtensionSize);
-
-    const auto end = std::end(available_extensions);
-    for (auto extension = std::begin(available_extensions); extension != end; ++extension) {
-        if (const bool is_last = extension + 1 == end; is_last) {
-            separated_extensions += *extension;
-        } else {
-            separated_extensions += fmt::format("{},", *extension);
-        }
-    }
-    return separated_extensions;
-}
-
-Device CreateDevice(const vk::Instance& instance, const vk::InstanceDispatch& dld,
-                    VkSurfaceKHR surface) {
-    const std::vector<VkPhysicalDevice> devices = instance.EnumeratePhysicalDevices();
-    const s32 device_index = Settings::values.vulkan_device.GetValue();
-    if (device_index < 0 || device_index >= static_cast<s32>(devices.size())) {
-        LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index);
-        throw vk::Exception(VK_ERROR_INITIALIZATION_FAILED);
-    }
-    const vk::PhysicalDevice physical_device(devices[device_index], dld);
-    return Device(*instance, physical_device, surface, dld);
-}
-} // Anonymous namespace
-
-RendererVulkan::RendererVulkan(Core::TelemetrySession& telemetry_session_,
-                               Core::Frontend::EmuWindow& emu_window,
-                               Core::Memory::Memory& cpu_memory_, Tegra::GPU& gpu_,
-                               std::unique_ptr<Core::Frontend::GraphicsContext> context_) try
-    : RendererBase(emu_window, std::move(context_)), telemetry_session(telemetry_session_),
-      cpu_memory(cpu_memory_), gpu(gpu_), library(OpenLibrary()),
-      instance(CreateInstance(library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type,
-                              true, Settings::values.renderer_debug.GetValue())),
-      debug_callback(Settings::values.renderer_debug ? CreateDebugCallback(instance) : nullptr),
-      surface(CreateSurface(instance, render_window)),
-      device(CreateDevice(instance, dld, *surface)), memory_allocator(device, false),
-      state_tracker(), scheduler(device, state_tracker),
-      swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width,
-                render_window.GetFramebufferLayout().height, false),
-      blit_screen(cpu_memory, render_window, device, memory_allocator, swapchain, scheduler,
-                  screen_info),
-      rasterizer(render_window, gpu, cpu_memory, screen_info, device, memory_allocator,
-                 state_tracker, scheduler) {
-    Report();
-} catch (const vk::Exception& exception) {
-    LOG_ERROR(Render_Vulkan, "Vulkan initialization failed with error: {}", exception.what());
-    throw std::runtime_error{fmt::format("Vulkan initialization error {}", exception.what())};
-}
-
-RendererVulkan::~RendererVulkan() {
-    void(device.GetLogical().WaitIdle());
-}
-
-void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-    if (!framebuffer) {
-        return;
-    }
-    SCOPE_EXIT({ render_window.OnFrameDisplayed(); });
-    if (!render_window.IsShown()) {
-        return;
-    }
-    // Update screen info if the framebuffer size has changed.
-    if (screen_info.width != framebuffer->width || screen_info.height != framebuffer->height) {
-        screen_info.width = framebuffer->width;
-        screen_info.height = framebuffer->height;
-    }
-    const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
-    const bool use_accelerated =
-        rasterizer.AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
-    const bool is_srgb = use_accelerated && screen_info.is_srgb;
-    RenderScreenshot(*framebuffer, use_accelerated);
-
-    bool has_been_recreated = false;
-    const auto recreate_swapchain = [&] {
-        if (!has_been_recreated) {
-            has_been_recreated = true;
-            scheduler.Finish();
-        }
-        const Layout::FramebufferLayout layout = render_window.GetFramebufferLayout();
-        swapchain.Create(layout.width, layout.height, is_srgb);
-    };
-    if (swapchain.NeedsRecreation(is_srgb)) {
-        recreate_swapchain();
-    }
-    bool is_outdated;
-    do {
-        swapchain.AcquireNextImage();
-        is_outdated = swapchain.IsOutDated();
-        if (is_outdated) {
-            recreate_swapchain();
-        }
-    } while (is_outdated);
-    if (has_been_recreated) {
-        blit_screen.Recreate();
-    }
-    const VkSemaphore render_semaphore = blit_screen.DrawToSwapchain(*framebuffer, use_accelerated);
-    const VkSemaphore present_semaphore = swapchain.CurrentPresentSemaphore();
-    scheduler.Flush(render_semaphore, present_semaphore);
-    scheduler.WaitWorker();
-    swapchain.Present(render_semaphore);
-
-    gpu.RendererFrameEndNotify();
-    rasterizer.TickFrame();
-}
-
-void RendererVulkan::Report() const {
-    const std::string vendor_name{device.GetVendorName()};
-    const std::string model_name{device.GetModelName()};
-    const std::string driver_version = GetDriverVersion(device);
-    const std::string driver_name = fmt::format("{} {}", vendor_name, driver_version);
-
-    const std::string api_version = GetReadableVersion(device.ApiVersion());
-
-    const std::string extensions = BuildCommaSeparatedExtensions(device.GetAvailableExtensions());
-
-    LOG_INFO(Render_Vulkan, "Driver: {}", driver_name);
-    LOG_INFO(Render_Vulkan, "Device: {}", model_name);
-    LOG_INFO(Render_Vulkan, "Vulkan: {}", api_version);
-
-    static constexpr auto field = Common::Telemetry::FieldType::UserSystem;
-    telemetry_session.AddField(field, "GPU_Vendor", vendor_name);
-    telemetry_session.AddField(field, "GPU_Model", model_name);
-    telemetry_session.AddField(field, "GPU_Vulkan_Driver", driver_name);
-    telemetry_session.AddField(field, "GPU_Vulkan_Version", api_version);
-    telemetry_session.AddField(field, "GPU_Vulkan_Extensions", extensions);
-}
-
-void Vulkan::RendererVulkan::RenderScreenshot(const Tegra::FramebufferConfig& framebuffer,
-                                              bool use_accelerated) {
-    if (!renderer_settings.screenshot_requested) {
-        return;
-    }
-    const Layout::FramebufferLayout layout{renderer_settings.screenshot_framebuffer_layout};
-    vk::Image staging_image = device.GetLogical().CreateImage(VkImageCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
-        .imageType = VK_IMAGE_TYPE_2D,
-        .format = VK_FORMAT_B8G8R8A8_UNORM,
-        .extent =
-            {
-                .width = layout.width,
-                .height = layout.height,
-                .depth = 1,
-            },
-        .mipLevels = 1,
-        .arrayLayers = 1,
-        .samples = VK_SAMPLE_COUNT_1_BIT,
-        .tiling = VK_IMAGE_TILING_OPTIMAL,
-        .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
-                 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-        .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
-    });
-    const auto image_commit = memory_allocator.Commit(staging_image, MemoryUsage::DeviceLocal);
-
-    const vk::ImageView dst_view = device.GetLogical().CreateImageView(VkImageViewCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .image = *staging_image,
-        .viewType = VK_IMAGE_VIEW_TYPE_2D,
-        .format = screen_info.is_srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM,
-        .components{
-            .r = VK_COMPONENT_SWIZZLE_IDENTITY,
-            .g = VK_COMPONENT_SWIZZLE_IDENTITY,
-            .b = VK_COMPONENT_SWIZZLE_IDENTITY,
-            .a = VK_COMPONENT_SWIZZLE_IDENTITY,
-        },
-        .subresourceRange{
-            .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-            .baseMipLevel = 0,
-            .levelCount = 1,
-            .baseArrayLayer = 0,
-            .layerCount = VK_REMAINING_ARRAY_LAYERS,
-        },
-    });
-    const VkExtent2D render_area{.width = layout.width, .height = layout.height};
-    const vk::Framebuffer screenshot_fb = blit_screen.CreateFramebuffer(*dst_view, render_area);
-    // Since we're not rendering to the screen, ignore the render semaphore.
-    void(blit_screen.Draw(framebuffer, *screenshot_fb, layout, render_area, use_accelerated));
-
-    const auto buffer_size = static_cast<VkDeviceSize>(layout.width * layout.height * 4);
-    const VkBufferCreateInfo dst_buffer_info{
-        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .size = buffer_size,
-        .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-        .queueFamilyIndexCount = 0,
-        .pQueueFamilyIndices = nullptr,
-    };
-    const vk::Buffer dst_buffer = device.GetLogical().CreateBuffer(dst_buffer_info);
-    MemoryCommit dst_buffer_memory = memory_allocator.Commit(dst_buffer, MemoryUsage::Download);
-
-    scheduler.RequestOutsideRenderPassOperationContext();
-    scheduler.Record([&](vk::CommandBuffer cmdbuf) {
-        const VkImageMemoryBarrier read_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
-            .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = *staging_image,
-            .subresourceRange{
-                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        const VkImageMemoryBarrier image_write_barrier{
-            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = 0,
-            .dstAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
-            .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
-            .newLayout = VK_IMAGE_LAYOUT_GENERAL,
-            .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
-            .image = *staging_image,
-            .subresourceRange{
-                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                .baseMipLevel = 0,
-                .levelCount = VK_REMAINING_MIP_LEVELS,
-                .baseArrayLayer = 0,
-                .layerCount = VK_REMAINING_ARRAY_LAYERS,
-            },
-        };
-        static constexpr VkMemoryBarrier memory_write_barrier{
-            .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
-            .pNext = nullptr,
-            .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
-            .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
-        };
-        const VkBufferImageCopy copy{
-            .bufferOffset = 0,
-            .bufferRowLength = 0,
-            .bufferImageHeight = 0,
-            .imageSubresource{
-                .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-                .mipLevel = 0,
-                .baseArrayLayer = 0,
-                .layerCount = 1,
-            },
-            .imageOffset{.x = 0, .y = 0, .z = 0},
-            .imageExtent{
-                .width = layout.width,
-                .height = layout.height,
-                .depth = 1,
-            },
-        };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, read_barrier);
-        cmdbuf.CopyImageToBuffer(*staging_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, *dst_buffer,
-                                 copy);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, memory_write_barrier, nullptr, image_write_barrier);
-    });
-    // Ensure the copy is fully completed before saving the screenshot
-    scheduler.Finish();
-
-    // Copy backing image data to the QImage screenshot buffer
-    const auto dst_memory_map = dst_buffer_memory.Map();
-    std::memcpy(renderer_settings.screenshot_bits, dst_memory_map.data(), dst_memory_map.size());
-    renderer_settings.screenshot_complete_callback(false);
-    renderer_settings.screenshot_requested = false;
-}
-
-} // namespace Vulkan

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -213,7 +213,7 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     EndTransformFeedback();
 }
 
-void RasterizerVulkan::Clear(u32 layer_count) {
+void RasterizerVulkan::Clear() {
     MICROPROFILE_SCOPE(Vulkan_Clearing);
 
     if (!maxwell3d->ShouldExecute()) {
@@ -256,7 +256,7 @@ void RasterizerVulkan::Clear(u32 layer_count) {
         .rect = regs.clear_control.use_scissor ? GetScissorState(regs, 0, up_scale, down_shift)
                                                : default_scissor,
         .baseArrayLayer = regs.clear_surface.layer,
-        .layerCount = layer_count,
+        .layerCount = 1,
     };
     if (clear_rect.rect.extent.width == 0 || clear_rect.rect.extent.height == 0) {
         return;

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -65,7 +65,7 @@ public:
     ~RasterizerVulkan() override;
 
     void Draw(bool is_indexed, u32 instance_count) override;
-    void Clear(u32 layer_count) override;
+    void Clear() override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
     void Query(GPUVAddr gpu_addr, VideoCore::QueryType type, std::optional<u64> timestamp) override;

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -221,7 +221,6 @@ void Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_s
             [[fallthrough]];
         default:
             vk::Check(result);
-            break;
         }
     });
     chunk->MarkSubmit();

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -108,7 +108,6 @@ constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
             break;
         default:
             ASSERT_MSG(false, "Invalid surface type");
-            break;
         }
     }
     if (info.storage) {

src/video_core/textures/decoders.cpp

@@ -170,7 +170,6 @@ void Swizzle(std::span<u8> output, std::span<const u8> input, u32 bytes_per_pixe
 #undef BPP_CASE
     default:
         ASSERT_MSG(false, "Invalid bytes_per_pixel={}", bytes_per_pixel);
-        break;
     }
 }
 
@@ -218,7 +217,6 @@ void SwizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes_p
 #undef BPP_CASE
     default:
         ASSERT_MSG(false, "Invalid bytes_per_pixel={}", bytes_per_pixel);
-        break;
     }
 }
 
@@ -242,7 +240,6 @@ void UnswizzleSubrect(std::span<u8> output, std::span<const u8> input, u32 bytes
 #undef BPP_CASE
     default:
         ASSERT_MSG(false, "Invalid bytes_per_pixel={}", bytes_per_pixel);
-        break;
     }
 }
 

src/yuzu/compatdb.cpp

@@ -126,7 +126,6 @@ void CompatDB::Submit() {
         break;
     default:
         LOG_ERROR(Frontend, "Unexpected page: {}", currentId());
-        break;
     }
 }
 

src/yuzu/configuration/configure_input_player.cpp

@@ -736,6 +736,9 @@ ConfigureInputPlayer::ConfigureInputPlayer(QWidget* parent, std::size_t player_i
         emulated_controller->SetNpadStyleIndex(type);
     });
 
+    connect(ui->comboDevices, qOverload<int>(&QComboBox::activated), this,
+            &ConfigureInputPlayer::UpdateMappingWithDefaults);
+
     ui->comboDevices->setCurrentIndex(-1);
 
     ui->buttonRefreshDevices->setIcon(QIcon::fromTheme(QStringLiteral("view-refresh")));

src/yuzu/main.cpp

@@ -1956,7 +1956,6 @@ void GMainWindow::OnGameListOpenFolder(u64 program_id, GameListOpenTarget target
     }
     default:
         UNIMPLEMENTED();
-        break;
     }
 
     const QString qpath = QString::fromStdString(Common::FS::PathToUTF8String(path));
@@ -3200,7 +3199,6 @@ void GMainWindow::OnToggleGpuAccuracy() {
     case Settings::GPUAccuracy::Extreme:
     default: {
         Settings::values.gpu_accuracy.SetValue(Settings::GPUAccuracy::High);
-        break;
     }
     }
 
@@ -3533,7 +3531,6 @@ void GMainWindow::UpdateGPUAccuracyButton() {
     default: {
         gpu_accuracy_button->setText(tr("GPU ERROR"));
         gpu_accuracy_button->setChecked(true);
-        break;
     }
     }
 }

src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp

@@ -84,7 +84,6 @@ EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(InputCommon::InputSubsystem* input_subsyste
     default:
         LOG_CRITICAL(Frontend, "Window manager subsystem not implemented");
         std::exit(EXIT_FAILURE);
-        break;
     }
 
     OnResize();

src/yuzu_cmd/yuzu.cpp

@@ -351,7 +351,6 @@ int main(int argc, char** argv) {
                          "additional help.\n\nError Code: {:04X}-{:04X}\nError Description: {}",
                          loader_id, error_id, static_cast<Loader::ResultStatus>(error_id));
         }
-        break;
     }
 
     system.TelemetrySession().AddField(Common::Telemetry::FieldType::App, "Frontend", "SDL");