core: cpu_manager: Fix shutdown crash when closing before emulation starts.

* hle: services: Fix a crash with improper NVFlinger lifetime management.

- This crash would happen when attempting to shutdown yuzu early on in boot.

src/core/core.cpp

@@ -187,7 +187,7 @@ struct System::Impl {
 
         service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
 
-        Service::Init(service_manager, system);
+        services = std::make_unique<Service::Services>(service_manager, system);
         GDBStub::DeferStart();
 
         interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
@@ -296,7 +296,7 @@ struct System::Impl {
 
         // Shutdown emulation session
         GDBStub::Shutdown();
-        Service::Shutdown();
+        services.reset();
         service_manager.reset();
         cheat_engine.reset();
         telemetry_session.reset();
@@ -306,8 +306,8 @@ struct System::Impl {
         cpu_manager.Shutdown();
 
         // Shutdown kernel and core timing
-        kernel.Shutdown();
         core_timing.Shutdown();
+        kernel.Shutdown();
 
         // Close app loader
         app_loader.reset();
@@ -398,6 +398,9 @@ struct System::Impl {
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
 
+    /// Services
+    std::unique_ptr<Service::Services> services;
+
     /// Telemetry session for this emulation session
     std::unique_ptr<Core::TelemetrySession> telemetry_session;
 
@@ -444,6 +447,10 @@ void System::InvalidateCpuInstructionCaches() {
     impl->kernel.InvalidateAllInstructionCaches();
 }
 
+void System::Shutdown() {
+    impl->Shutdown();
+}
+
 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
     return impl->Load(*this, emu_window, filepath);
 }
@@ -632,7 +639,11 @@ const std::string& System::GetStatusDetails() const {
     return impl->status_details;
 }
 
-Loader::AppLoader& System::GetAppLoader() const {
+Loader::AppLoader& System::GetAppLoader() {
+    return *impl->app_loader;
+}
+
+const Loader::AppLoader& System::GetAppLoader() const {
     return *impl->app_loader;
 }
 
@@ -748,14 +759,6 @@ const System::CurrentBuildProcessID& System::GetCurrentProcessBuildID() const {
     return impl->build_id;
 }
 
-System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
-    return impl->Init(*this, emu_window);
-}
-
-void System::Shutdown() {
-    impl->Shutdown();
-}
-
 Service::SM::ServiceManager& System::ServiceManager() {
     return *impl->service_manager;
 }

src/core/core.h

@@ -144,19 +144,19 @@ public:
      * Run the OS and Application
      * This function will start emulation and run the relevant devices
      */
-    ResultStatus Run();
+    [[nodiscard]] ResultStatus Run();
 
     /**
      * Pause the OS and Application
      * This function will pause emulation and stop the relevant devices
      */
-    ResultStatus Pause();
+    [[nodiscard]] ResultStatus Pause();
 
     /**
      * Step the CPU one instruction
      * @return Result status, indicating whether or not the operation succeeded.
      */
-    ResultStatus SingleStep();
+    [[nodiscard]] ResultStatus SingleStep();
 
     /**
      * Invalidate the CPU instruction caches
@@ -175,20 +175,20 @@ public:
      * @param filepath String path to the executable application to load on the host file system.
      * @returns ResultStatus code, indicating if the operation succeeded.
      */
-    ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath);
+    [[nodiscard]] ResultStatus Load(Frontend::EmuWindow& emu_window, const std::string& filepath);
 
     /**
      * Indicates if the emulated system is powered on (all subsystems initialized and able to run an
      * application).
      * @returns True if the emulated system is powered on, otherwise false.
      */
-    bool IsPoweredOn() const;
+    [[nodiscard]] bool IsPoweredOn() const;
 
     /// Gets a reference to the telemetry session for this emulation session.
-    Core::TelemetrySession& TelemetrySession();
+    [[nodiscard]] Core::TelemetrySession& TelemetrySession();
 
     /// Gets a reference to the telemetry session for this emulation session.
-    const Core::TelemetrySession& TelemetrySession() const;
+    [[nodiscard]] const Core::TelemetrySession& TelemetrySession() const;
 
     /// Prepare the core emulation for a reschedule
     void PrepareReschedule();
@@ -197,185 +197,178 @@ public:
     void PrepareReschedule(u32 core_index);
 
     /// Gets and resets core performance statistics
-    PerfStatsResults GetAndResetPerfStats();
+    [[nodiscard]] PerfStatsResults GetAndResetPerfStats();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    ARM_Interface& CurrentArmInterface();
+    [[nodiscard]] ARM_Interface& CurrentArmInterface();
 
     /// Gets an ARM interface to the CPU core that is currently running
-    const ARM_Interface& CurrentArmInterface() const;
+    [[nodiscard]] const ARM_Interface& CurrentArmInterface() const;
 
     /// Gets the index of the currently running CPU core
-    std::size_t CurrentCoreIndex() const;
+    [[nodiscard]] std::size_t CurrentCoreIndex() const;
 
     /// Gets the scheduler for the CPU core that is currently running
-    Kernel::Scheduler& CurrentScheduler();
+    [[nodiscard]] Kernel::Scheduler& CurrentScheduler();
 
     /// Gets the scheduler for the CPU core that is currently running
-    const Kernel::Scheduler& CurrentScheduler() const;
+    [[nodiscard]] const Kernel::Scheduler& CurrentScheduler() const;
 
     /// Gets the physical core for the CPU core that is currently running
-    Kernel::PhysicalCore& CurrentPhysicalCore();
+    [[nodiscard]] Kernel::PhysicalCore& CurrentPhysicalCore();
 
     /// Gets the physical core for the CPU core that is currently running
-    const Kernel::PhysicalCore& CurrentPhysicalCore() const;
+    [[nodiscard]] const Kernel::PhysicalCore& CurrentPhysicalCore() const;
 
     /// Gets a reference to an ARM interface for the CPU core with the specified index
-    ARM_Interface& ArmInterface(std::size_t core_index);
+    [[nodiscard]] ARM_Interface& ArmInterface(std::size_t core_index);
 
     /// Gets a const reference to an ARM interface from the CPU core with the specified index
-    const ARM_Interface& ArmInterface(std::size_t core_index) const;
+    [[nodiscard]] const ARM_Interface& ArmInterface(std::size_t core_index) const;
 
-    CpuManager& GetCpuManager();
+    /// Gets a reference to the underlying CPU manager.
+    [[nodiscard]] CpuManager& GetCpuManager();
 
-    const CpuManager& GetCpuManager() const;
+    /// Gets a const reference to the underlying CPU manager
+    [[nodiscard]] const CpuManager& GetCpuManager() const;
 
     /// Gets a reference to the exclusive monitor
-    ExclusiveMonitor& Monitor();
+    [[nodiscard]] ExclusiveMonitor& Monitor();
 
     /// Gets a constant reference to the exclusive monitor
-    const ExclusiveMonitor& Monitor() const;
+    [[nodiscard]] const ExclusiveMonitor& Monitor() const;
 
     /// Gets a mutable reference to the system memory instance.
-    Core::Memory::Memory& Memory();
+    [[nodiscard]] Core::Memory::Memory& Memory();
 
     /// Gets a constant reference to the system memory instance.
-    const Core::Memory::Memory& Memory() const;
+    [[nodiscard]] const Core::Memory::Memory& Memory() const;
 
     /// Gets a mutable reference to the GPU interface
-    Tegra::GPU& GPU();
+    [[nodiscard]] Tegra::GPU& GPU();
 
     /// Gets an immutable reference to the GPU interface.
-    const Tegra::GPU& GPU() const;
+    [[nodiscard]] const Tegra::GPU& GPU() const;
 
     /// Gets a mutable reference to the renderer.
-    VideoCore::RendererBase& Renderer();
+    [[nodiscard]] VideoCore::RendererBase& Renderer();
 
     /// Gets an immutable reference to the renderer.
-    const VideoCore::RendererBase& Renderer() const;
+    [[nodiscard]] const VideoCore::RendererBase& Renderer() const;
 
     /// Gets the scheduler for the CPU core with the specified index
-    Kernel::Scheduler& Scheduler(std::size_t core_index);
+    [[nodiscard]] Kernel::Scheduler& Scheduler(std::size_t core_index);
 
     /// Gets the scheduler for the CPU core with the specified index
-    const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
+    [[nodiscard]] const Kernel::Scheduler& Scheduler(std::size_t core_index) const;
 
     /// Gets the global scheduler
-    Kernel::GlobalScheduler& GlobalScheduler();
+    [[nodiscard]] Kernel::GlobalScheduler& GlobalScheduler();
 
     /// Gets the global scheduler
-    const Kernel::GlobalScheduler& GlobalScheduler() const;
+    [[nodiscard]] const Kernel::GlobalScheduler& GlobalScheduler() const;
 
     /// Gets the manager for the guest device memory
-    Core::DeviceMemory& DeviceMemory();
+    [[nodiscard]] Core::DeviceMemory& DeviceMemory();
 
     /// Gets the manager for the guest device memory
-    const Core::DeviceMemory& DeviceMemory() const;
+    [[nodiscard]] const Core::DeviceMemory& DeviceMemory() const;
 
     /// Provides a pointer to the current process
-    Kernel::Process* CurrentProcess();
+    [[nodiscard]] Kernel::Process* CurrentProcess();
 
     /// Provides a constant pointer to the current process.
-    const Kernel::Process* CurrentProcess() const;
+    [[nodiscard]] const Kernel::Process* CurrentProcess() const;
 
     /// Provides a reference to the core timing instance.
-    Timing::CoreTiming& CoreTiming();
+    [[nodiscard]] Timing::CoreTiming& CoreTiming();
 
     /// Provides a constant reference to the core timing instance.
-    const Timing::CoreTiming& CoreTiming() const;
+    [[nodiscard]] const Timing::CoreTiming& CoreTiming() const;
 
     /// Provides a reference to the interrupt manager instance.
-    Core::Hardware::InterruptManager& InterruptManager();
+    [[nodiscard]] Core::Hardware::InterruptManager& InterruptManager();
 
     /// Provides a constant reference to the interrupt manager instance.
-    const Core::Hardware::InterruptManager& InterruptManager() const;
+    [[nodiscard]] const Core::Hardware::InterruptManager& InterruptManager() const;
 
     /// Provides a reference to the kernel instance.
-    Kernel::KernelCore& Kernel();
+    [[nodiscard]] Kernel::KernelCore& Kernel();
 
     /// Provides a constant reference to the kernel instance.
-    const Kernel::KernelCore& Kernel() const;
+    [[nodiscard]] const Kernel::KernelCore& Kernel() const;
 
     /// Provides a reference to the internal PerfStats instance.
-    Core::PerfStats& GetPerfStats();
+    [[nodiscard]] Core::PerfStats& GetPerfStats();
 
     /// Provides a constant reference to the internal PerfStats instance.
-    const Core::PerfStats& GetPerfStats() const;
+    [[nodiscard]] const Core::PerfStats& GetPerfStats() const;
 
     /// Provides a reference to the frame limiter;
-    Core::FrameLimiter& FrameLimiter();
+    [[nodiscard]] Core::FrameLimiter& FrameLimiter();
 
     /// Provides a constant referent to the frame limiter
-    const Core::FrameLimiter& FrameLimiter() const;
+    [[nodiscard]] const Core::FrameLimiter& FrameLimiter() const;
 
     /// Gets the name of the current game
-    Loader::ResultStatus GetGameName(std::string& out) const;
+    [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;
 
     void SetStatus(ResultStatus new_status, const char* details);
 
-    const std::string& GetStatusDetails() const;
+    [[nodiscard]] const std::string& GetStatusDetails() const;
 
-    Loader::AppLoader& GetAppLoader() const;
+    [[nodiscard]] Loader::AppLoader& GetAppLoader();
+    [[nodiscard]] const Loader::AppLoader& GetAppLoader() const;
 
-    Service::SM::ServiceManager& ServiceManager();
-    const Service::SM::ServiceManager& ServiceManager() const;
+    [[nodiscard]] Service::SM::ServiceManager& ServiceManager();
+    [[nodiscard]] const Service::SM::ServiceManager& ServiceManager() const;
 
     void SetFilesystem(FileSys::VirtualFilesystem vfs);
 
-    FileSys::VirtualFilesystem GetFilesystem() const;
+    [[nodiscard]] FileSys::VirtualFilesystem GetFilesystem() const;
 
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
                            const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
                            u64 main_region_size);
 
     void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
-
     void SetDefaultAppletFrontendSet();
 
-    Service::AM::Applets::AppletManager& GetAppletManager();
-
-    const Service::AM::Applets::AppletManager& GetAppletManager() const;
+    [[nodiscard]] Service::AM::Applets::AppletManager& GetAppletManager();
+    [[nodiscard]] const Service::AM::Applets::AppletManager& GetAppletManager() const;
 
     void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
 
-    FileSys::ContentProvider& GetContentProvider();
+    [[nodiscard]] FileSys::ContentProvider& GetContentProvider();
+    [[nodiscard]] const FileSys::ContentProvider& GetContentProvider() const;
 
-    const FileSys::ContentProvider& GetContentProvider() const;
-
-    Service::FileSystem::FileSystemController& GetFileSystemController();
-
-    const Service::FileSystem::FileSystemController& GetFileSystemController() const;
+    [[nodiscard]] Service::FileSystem::FileSystemController& GetFileSystemController();
+    [[nodiscard]] const Service::FileSystem::FileSystemController& GetFileSystemController() const;
 
     void RegisterContentProvider(FileSys::ContentProviderUnionSlot slot,
                                  FileSys::ContentProvider* provider);
 
     void ClearContentProvider(FileSys::ContentProviderUnionSlot slot);
 
-    const Reporter& GetReporter() const;
+    [[nodiscard]] const Reporter& GetReporter() const;
 
-    Service::Glue::ARPManager& GetARPManager();
+    [[nodiscard]] Service::Glue::ARPManager& GetARPManager();
+    [[nodiscard]] const Service::Glue::ARPManager& GetARPManager() const;
 
-    const Service::Glue::ARPManager& GetARPManager() const;
+    [[nodiscard]] Service::APM::Controller& GetAPMController();
+    [[nodiscard]] const Service::APM::Controller& GetAPMController() const;
 
-    Service::APM::Controller& GetAPMController();
+    [[nodiscard]] Service::LM::Manager& GetLogManager();
+    [[nodiscard]] const Service::LM::Manager& GetLogManager() const;
 
-    const Service::APM::Controller& GetAPMController() const;
-
-    Service::LM::Manager& GetLogManager();
-
-    const Service::LM::Manager& GetLogManager() const;
-
-    Service::Time::TimeManager& GetTimeManager();
-
-    const Service::Time::TimeManager& GetTimeManager() const;
+    [[nodiscard]] Service::Time::TimeManager& GetTimeManager();
+    [[nodiscard]] const Service::Time::TimeManager& GetTimeManager() const;
 
     void SetExitLock(bool locked);
-
-    bool GetExitLock() const;
+    [[nodiscard]] bool GetExitLock() const;
 
     void SetCurrentProcessBuildID(const CurrentBuildProcessID& id);
-
-    const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
+    [[nodiscard]] const CurrentBuildProcessID& GetCurrentProcessBuildID() const;
 
     /// Register a host thread as an emulated CPU Core.
     void RegisterCoreThread(std::size_t id);
@@ -390,19 +383,11 @@ public:
     void ExitDynarmicProfile();
 
     /// Tells if system is running on multicore.
-    bool IsMulticore() const;
+    [[nodiscard]] bool IsMulticore() const;
 
 private:
     System();
 
-    /**
-     * Initialize the emulated system.
-     * @param emu_window Reference to the host-system window used for video output and keyboard
-     *                   input.
-     * @return ResultStatus code, indicating if the operation succeeded.
-     */
-    ResultStatus Init(Frontend::EmuWindow& emu_window);
-
     struct Impl;
     std::unique_ptr<Impl> impl;
 

src/core/cpu_manager.cpp

@@ -4,6 +4,7 @@
 
 #include "common/fiber.h"
 #include "common/microprofile.h"
+#include "common/scope_exit.h"
 #include "common/thread.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
@@ -343,6 +344,16 @@ void CpuManager::RunThread(std::size_t core) {
     data.initialized = true;
     const bool sc_sync = !is_async_gpu && !is_multicore;
     bool sc_sync_first_use = sc_sync;
+
+    // Cleanup
+    SCOPE_EXIT({
+        data.host_context->Exit();
+        data.enter_barrier.reset();
+        data.exit_barrier.reset();
+        data.initialized = false;
+        MicroProfileOnThreadExit();
+    });
+
     /// Running
     while (running_mode) {
         data.is_running = false;
@@ -351,6 +362,12 @@ void CpuManager::RunThread(std::size_t core) {
             system.GPU().ObtainContext();
             sc_sync_first_use = false;
         }
+
+        // Abort if emulation was killed before the session really starts
+        if (!system.IsPoweredOn()) {
+            return;
+        }
+
         auto& scheduler = system.Kernel().CurrentScheduler();
         Kernel::Thread* current_thread = scheduler.GetCurrentThread();
         data.is_running = true;
@@ -360,13 +377,6 @@ void CpuManager::RunThread(std::size_t core) {
         data.exit_barrier->Wait();
         data.is_paused = false;
     }
-    /// Time to cleanup
-    data.host_context->Exit();
-    data.enter_barrier.reset();
-    data.exit_barrier.reset();
-    data.initialized = false;
-
-    MicroProfileOnThreadExit();
 }
 
 } // namespace Core

src/core/frontend/input.h

@@ -30,10 +30,12 @@ public:
     virtual StatusType GetStatus() const {
         return {};
     }
-    virtual bool GetAnalogDirectionStatus(AnalogDirection direction) const {
+    virtual bool GetAnalogDirectionStatus([[maybe_unused]] AnalogDirection direction) const {
         return {};
     }
-    virtual bool SetRumblePlay(f32 amp_low, f32 freq_low, f32 amp_high, f32 freq_high) const {
+    virtual bool SetRumblePlay([[maybe_unused]] f32 amp_low, [[maybe_unused]] f32 freq_low,
+                               [[maybe_unused]] f32 amp_high,
+                               [[maybe_unused]] f32 freq_high) const {
         return {};
     }
 };

src/core/hle/kernel/svc.cpp

@@ -681,7 +681,7 @@ static void Break32(Core::System& system, u32 reason, u32 info1, u32 info2) {
 }
 
 /// Used to output a message on a debug hardware unit - does nothing on a retail unit
-static void OutputDebugString([[maybe_unused]] Core::System& system, VAddr address, u64 len) {
+static void OutputDebugString(Core::System& system, VAddr address, u64 len) {
     if (len == 0) {
         return;
     }

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

@@ -246,9 +246,8 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {
 
 IDebugFunctions::~IDebugFunctions() = default;
 
-ISelfController::ISelfController(Core::System& system,
-                                 std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
-    : ServiceFramework("ISelfController"), system(system), nvflinger(std::move(nvflinger)) {
+ISelfController::ISelfController(Core::System& system, NVFlinger::NVFlinger& nvflinger)
+    : ServiceFramework("ISelfController"), system(system), nvflinger(nvflinger) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ISelfController::Exit, "Exit"},
@@ -458,8 +457,8 @@ void ISelfController::CreateManagedDisplayLayer(Kernel::HLERequestContext& ctx)
 
     // TODO(Subv): Find out how AM determines the display to use, for now just
     // create the layer in the Default display.
-    const auto display_id = nvflinger->OpenDisplay("Default");
-    const auto layer_id = nvflinger->CreateLayer(*display_id);
+    const auto display_id = nvflinger.OpenDisplay("Default");
+    const auto layer_id = nvflinger.CreateLayer(*display_id);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
@@ -476,8 +475,8 @@ void ISelfController::CreateManagedDisplaySeparableLayer(Kernel::HLERequestConte
     // Outputting 1 layer id instead of the expected 2 has not been observed to cause any adverse
     // side effects.
     // TODO: Support multiple layers
-    const auto display_id = nvflinger->OpenDisplay("Default");
-    const auto layer_id = nvflinger->CreateLayer(*display_id);
+    const auto display_id = nvflinger.OpenDisplay("Default");
+    const auto layer_id = nvflinger.CreateLayer(*display_id);
 
     IPC::ResponseBuilder rb{ctx, 4};
     rb.Push(RESULT_SUCCESS);
@@ -1586,8 +1585,8 @@ void IApplicationFunctions::GetFriendInvitationStorageChannelEvent(Kernel::HLERe
     rb.PushCopyObjects(friend_invitation_storage_channel_event.readable);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager,
-                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
+                       Core::System& system) {
     auto message_queue = std::make_shared<AppletMessageQueue>(system.Kernel());
     // Needed on game boot
     message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);

src/core/hle/service/am/am.h

@@ -121,8 +121,7 @@ public:
 
 class ISelfController final : public ServiceFramework<ISelfController> {
 public:
-    explicit ISelfController(Core::System& system_,
-                             std::shared_ptr<NVFlinger::NVFlinger> nvflinger_);
+    explicit ISelfController(Core::System& system_, NVFlinger::NVFlinger& nvflinger_);
     ~ISelfController() override;
 
 private:
@@ -156,7 +155,7 @@ private:
     };
 
     Core::System& system;
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    NVFlinger::NVFlinger& nvflinger;
     Kernel::EventPair launchable_event;
     Kernel::EventPair accumulated_suspended_tick_changed_event;
 
@@ -332,7 +331,7 @@ public:
 };
 
 /// Registers all AM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager,
-                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
+                       Core::System& system);
 
 } // namespace Service::AM

src/core/hle/service/am/applet_ae.cpp

@@ -13,10 +13,10 @@ namespace Service::AM {
 
 class ILibraryAppletProxy final : public ServiceFramework<ILibraryAppletProxy> {
 public:
-    explicit ILibraryAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+    explicit ILibraryAppletProxy(NVFlinger::NVFlinger& nvflinger,
                                  std::shared_ptr<AppletMessageQueue> msg_queue,
                                  Core::System& system)
-        : ServiceFramework("ILibraryAppletProxy"), nvflinger(std::move(nvflinger)),
+        : ServiceFramework("ILibraryAppletProxy"), nvflinger(nvflinger),
           msg_queue(std::move(msg_queue)), system(system) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -109,16 +109,16 @@ private:
         rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    NVFlinger::NVFlinger& nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };
 
 class ISystemAppletProxy final : public ServiceFramework<ISystemAppletProxy> {
 public:
-    explicit ISystemAppletProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+    explicit ISystemAppletProxy(NVFlinger::NVFlinger& nvflinger,
                                 std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
-        : ServiceFramework("ISystemAppletProxy"), nvflinger(std::move(nvflinger)),
+        : ServiceFramework("ISystemAppletProxy"), nvflinger(nvflinger),
           msg_queue(std::move(msg_queue)), system(system) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -220,7 +220,8 @@ private:
         rb.Push(RESULT_SUCCESS);
         rb.PushIpcInterface<IApplicationCreator>();
     }
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+
+    NVFlinger::NVFlinger& nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };
@@ -249,10 +250,10 @@ void AppletAE::OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<ILibraryAppletProxy>(nvflinger, msg_queue, system);
 }
 
-AppletAE::AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
-                   std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
-    : ServiceFramework("appletAE"), nvflinger(std::move(nvflinger)),
-      msg_queue(std::move(msg_queue)), system(system) {
+AppletAE::AppletAE(NVFlinger::NVFlinger& nvflinger, std::shared_ptr<AppletMessageQueue> msg_queue,
+                   Core::System& system)
+    : ServiceFramework("appletAE"), nvflinger(nvflinger), msg_queue(std::move(msg_queue)),
+      system(system) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {100, &AppletAE::OpenSystemAppletProxy, "OpenSystemAppletProxy"},

src/core/hle/service/am/applet_ae.h

@@ -23,7 +23,7 @@ class AppletMessageQueue;
 
 class AppletAE final : public ServiceFramework<AppletAE> {
 public:
-    explicit AppletAE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+    explicit AppletAE(NVFlinger::NVFlinger& nvflinger,
                       std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system);
     ~AppletAE() override;
 
@@ -34,7 +34,7 @@ private:
     void OpenLibraryAppletProxy(Kernel::HLERequestContext& ctx);
     void OpenLibraryAppletProxyOld(Kernel::HLERequestContext& ctx);
 
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    NVFlinger::NVFlinger& nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };

src/core/hle/service/am/applet_oe.cpp

@@ -12,9 +12,9 @@ namespace Service::AM {
 
 class IApplicationProxy final : public ServiceFramework<IApplicationProxy> {
 public:
-    explicit IApplicationProxy(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+    explicit IApplicationProxy(NVFlinger::NVFlinger& nvflinger,
                                std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
-        : ServiceFramework("IApplicationProxy"), nvflinger(std::move(nvflinger)),
+        : ServiceFramework("IApplicationProxy"), nvflinger(nvflinger),
           msg_queue(std::move(msg_queue)), system(system) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -98,7 +98,7 @@ private:
         rb.PushIpcInterface<IApplicationFunctions>(system);
     }
 
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    NVFlinger::NVFlinger& nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };
@@ -111,10 +111,10 @@ void AppletOE::OpenApplicationProxy(Kernel::HLERequestContext& ctx) {
     rb.PushIpcInterface<IApplicationProxy>(nvflinger, msg_queue, system);
 }
 
-AppletOE::AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
-                   std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system)
-    : ServiceFramework("appletOE"), nvflinger(std::move(nvflinger)),
-      msg_queue(std::move(msg_queue)), system(system) {
+AppletOE::AppletOE(NVFlinger::NVFlinger& nvflinger, std::shared_ptr<AppletMessageQueue> msg_queue,
+                   Core::System& system)
+    : ServiceFramework("appletOE"), nvflinger(nvflinger), msg_queue(std::move(msg_queue)),
+      system(system) {
     static const FunctionInfo functions[] = {
         {0, &AppletOE::OpenApplicationProxy, "OpenApplicationProxy"},
     };

src/core/hle/service/am/applet_oe.h

@@ -23,7 +23,7 @@ class AppletMessageQueue;
 
 class AppletOE final : public ServiceFramework<AppletOE> {
 public:
-    explicit AppletOE(std::shared_ptr<NVFlinger::NVFlinger> nvflinger,
+    explicit AppletOE(NVFlinger::NVFlinger& nvflinger,
                       std::shared_ptr<AppletMessageQueue> msg_queue, Core::System& system);
     ~AppletOE() override;
 
@@ -32,7 +32,7 @@ public:
 private:
     void OpenApplicationProxy(Kernel::HLERequestContext& ctx);
 
-    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
+    NVFlinger::NVFlinger& nvflinger;
     std::shared_ptr<AppletMessageQueue> msg_queue;
     Core::System& system;
 };

src/core/hle/service/service.cpp

@@ -188,17 +188,19 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
     return RESULT_SUCCESS;
 }
 
-/// Initialize ServiceManager
-void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
+/// Initialize Services
+Services::Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system)
+    : nv_flinger{std::make_unique<NVFlinger::NVFlinger>(system)} {
+
     // NVFlinger needs to be accessed by several services like Vi and AppletOE so we instantiate it
     // here and pass it into the respective InstallInterfaces functions.
-    auto nv_flinger = std::make_shared<NVFlinger::NVFlinger>(system);
+
     system.GetFileSystemController().CreateFactories(*system.GetFilesystem(), false);
 
     SM::ServiceManager::InstallInterfaces(sm, system.Kernel());
 
     Account::InstallInterfaces(system);
-    AM::InstallInterfaces(*sm, nv_flinger, system);
+    AM::InstallInterfaces(*sm, *nv_flinger, system);
     AOC::InstallInterfaces(*sm, system);
     APM::InstallInterfaces(system);
     Audio::InstallInterfaces(*sm, system);
@@ -246,14 +248,10 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     SSL::InstallInterfaces(*sm);
     Time::InstallInterfaces(system);
     USB::InstallInterfaces(*sm);
-    VI::InstallInterfaces(*sm, nv_flinger);
+    VI::InstallInterfaces(*sm, *nv_flinger);
     WLAN::InstallInterfaces(*sm);
-
-    LOG_DEBUG(Service, "initialized OK");
 }
 
-/// Shutdown ServiceManager
-void Shutdown() {
-    LOG_DEBUG(Service, "shutdown OK");
-}
+Services::~Services() = default;
+
 } // namespace Service

src/core/hle/service/service.h

@@ -29,7 +29,11 @@ namespace Service {
 
 namespace FileSystem {
 class FileSystemController;
-} // namespace FileSystem
+}
+
+namespace NVFlinger {
+class NVFlinger;
+}
 
 namespace SM {
 class ServiceManager;
@@ -181,10 +185,17 @@ private:
     }
 };
 
-/// Initialize ServiceManager
-void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system);
+/**
+ * The purpose of this class is to own any objects that need to be shared across the other service
+ * implementations. Will be torn down when the global system instance is shutdown.
+ */
+class Services final {
+public:
+    explicit Services(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system);
+    ~Services();
 
-/// Shutdown ServiceManager
-void Shutdown();
+private:
+    std::unique_ptr<NVFlinger::NVFlinger> nv_flinger;
+};
 
 } // namespace Service

src/core/hle/service/vi/vi.cpp

@@ -492,8 +492,8 @@ private:
 
 class IHOSBinderDriver final : public ServiceFramework<IHOSBinderDriver> {
 public:
-    explicit IHOSBinderDriver(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-        : ServiceFramework("IHOSBinderDriver"), nv_flinger(std::move(nv_flinger)) {
+    explicit IHOSBinderDriver(NVFlinger::NVFlinger& nv_flinger)
+        : ServiceFramework("IHOSBinderDriver"), nv_flinger(nv_flinger) {
         static const FunctionInfo functions[] = {
             {0, &IHOSBinderDriver::TransactParcel, "TransactParcel"},
             {1, &IHOSBinderDriver::AdjustRefcount, "AdjustRefcount"},
@@ -530,8 +530,8 @@ private:
         LOG_DEBUG(Service_VI, "called. id=0x{:08X} transaction={:X}, flags=0x{:08X}", id,
                   static_cast<u32>(transaction), flags);
 
-        const auto guard = nv_flinger->Lock();
-        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
+        const auto guard = nv_flinger.Lock();
+        auto& buffer_queue = nv_flinger.FindBufferQueue(id);
 
         switch (transaction) {
         case TransactionId::Connect: {
@@ -570,8 +570,8 @@ private:
                     [=, this](std::shared_ptr<Kernel::Thread> thread,
                               Kernel::HLERequestContext& ctx, Kernel::ThreadWakeupReason reason) {
                         // Repeat TransactParcel DequeueBuffer when a buffer is available
-                        const auto guard = nv_flinger->Lock();
-                        auto& buffer_queue = nv_flinger->FindBufferQueue(id);
+                        const auto guard = nv_flinger.Lock();
+                        auto& buffer_queue = nv_flinger.FindBufferQueue(id);
                         auto result = buffer_queue.DequeueBuffer(width, height);
                         ASSERT_MSG(result != std::nullopt, "Could not dequeue buffer.");
 
@@ -676,7 +676,7 @@ private:
 
         LOG_WARNING(Service_VI, "(STUBBED) called id={}, unknown={:08X}", id, unknown);
 
-        const auto& buffer_queue = nv_flinger->FindBufferQueue(id);
+        const auto& buffer_queue = nv_flinger.FindBufferQueue(id);
 
         // TODO(Subv): Find out what this actually is.
         IPC::ResponseBuilder rb{ctx, 2, 1};
@@ -684,8 +684,8 @@ private:
         rb.PushCopyObjects(buffer_queue.GetBufferWaitEvent());
     }
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
-}; // namespace VI
+    NVFlinger::NVFlinger& nv_flinger;
+};
 
 class ISystemDisplayService final : public ServiceFramework<ISystemDisplayService> {
 public:
@@ -790,8 +790,8 @@ private:
 
 class IManagerDisplayService final : public ServiceFramework<IManagerDisplayService> {
 public:
-    explicit IManagerDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-        : ServiceFramework("IManagerDisplayService"), nv_flinger(std::move(nv_flinger)) {
+    explicit IManagerDisplayService(NVFlinger::NVFlinger& nv_flinger)
+        : ServiceFramework("IManagerDisplayService"), nv_flinger(nv_flinger) {
         // clang-format off
         static const FunctionInfo functions[] = {
             {200, nullptr, "AllocateProcessHeapBlock"},
@@ -893,7 +893,7 @@ private:
                     "(STUBBED) called. unknown=0x{:08X}, display=0x{:016X}, aruid=0x{:016X}",
                     unknown, display, aruid);
 
-        const auto layer_id = nv_flinger->CreateLayer(display);
+        const auto layer_id = nv_flinger.CreateLayer(display);
         if (!layer_id) {
             LOG_ERROR(Service_VI, "Layer not found! display=0x{:016X}", display);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -930,12 +930,12 @@ private:
         rb.Push(RESULT_SUCCESS);
     }
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+    NVFlinger::NVFlinger& nv_flinger;
 };
 
 class IApplicationDisplayService final : public ServiceFramework<IApplicationDisplayService> {
 public:
-    explicit IApplicationDisplayService(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    explicit IApplicationDisplayService(NVFlinger::NVFlinger& nv_flinger);
 
 private:
     enum class ConvertedScaleMode : u64 {
@@ -1010,7 +1010,7 @@ private:
 
         ASSERT_MSG(name == "Default", "Non-default displays aren't supported yet");
 
-        const auto display_id = nv_flinger->OpenDisplay(name);
+        const auto display_id = nv_flinger.OpenDisplay(name);
         if (!display_id) {
             LOG_ERROR(Service_VI, "Display not found! display_name={}", name);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1110,7 +1110,7 @@ private:
 
         LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}, aruid=0x{:016X}", layer_id, aruid);
 
-        const auto display_id = nv_flinger->OpenDisplay(display_name);
+        const auto display_id = nv_flinger.OpenDisplay(display_name);
         if (!display_id) {
             LOG_ERROR(Service_VI, "Layer not found! layer_id={}", layer_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1118,7 +1118,7 @@ private:
             return;
         }
 
-        const auto buffer_queue_id = nv_flinger->FindBufferQueueId(*display_id, layer_id);
+        const auto buffer_queue_id = nv_flinger.FindBufferQueueId(*display_id, layer_id);
         if (!buffer_queue_id) {
             LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", *display_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1138,7 +1138,7 @@ private:
 
         LOG_DEBUG(Service_VI, "called. layer_id=0x{:016X}", layer_id);
 
-        nv_flinger->CloseLayer(layer_id);
+        nv_flinger.CloseLayer(layer_id);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -1154,7 +1154,7 @@ private:
 
         // TODO(Subv): What's the difference between a Stray and a Managed layer?
 
-        const auto layer_id = nv_flinger->CreateLayer(display_id);
+        const auto layer_id = nv_flinger.CreateLayer(display_id);
         if (!layer_id) {
             LOG_ERROR(Service_VI, "Layer not found! layer_id={}", *layer_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1162,7 +1162,7 @@ private:
             return;
         }
 
-        const auto buffer_queue_id = nv_flinger->FindBufferQueueId(display_id, *layer_id);
+        const auto buffer_queue_id = nv_flinger.FindBufferQueueId(display_id, *layer_id);
         if (!buffer_queue_id) {
             LOG_ERROR(Service_VI, "Buffer queue id not found! display_id={}", display_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1193,7 +1193,7 @@ private:
 
         LOG_WARNING(Service_VI, "(STUBBED) called. display_id=0x{:016X}", display_id);
 
-        const auto vsync_event = nv_flinger->FindVsyncEvent(display_id);
+        const auto vsync_event = nv_flinger.FindVsyncEvent(display_id);
         if (!vsync_event) {
             LOG_ERROR(Service_VI, "Vsync event was not found for display_id={}", display_id);
             IPC::ResponseBuilder rb{ctx, 2};
@@ -1258,12 +1258,11 @@ private:
         }
     }
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+    NVFlinger::NVFlinger& nv_flinger;
 };
 
-IApplicationDisplayService::IApplicationDisplayService(
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework("IApplicationDisplayService"), nv_flinger(std::move(nv_flinger)) {
+IApplicationDisplayService::IApplicationDisplayService(NVFlinger::NVFlinger& nv_flinger)
+    : ServiceFramework("IApplicationDisplayService"), nv_flinger(nv_flinger) {
     static const FunctionInfo functions[] = {
         {100, &IApplicationDisplayService::GetRelayService, "GetRelayService"},
         {101, &IApplicationDisplayService::GetSystemDisplayService, "GetSystemDisplayService"},
@@ -1304,8 +1303,7 @@ static bool IsValidServiceAccess(Permission permission, Policy policy) {
     return false;
 }
 
-void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
-                                   std::shared_ptr<NVFlinger::NVFlinger> nv_flinger,
+void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, NVFlinger::NVFlinger& nv_flinger,
                                    Permission permission) {
     IPC::RequestParser rp{ctx};
     const auto policy = rp.PopEnum<Policy>();
@@ -1319,11 +1317,10 @@ void detail::GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IApplicationDisplayService>(std::move(nv_flinger));
+    rb.PushIpcInterface<IApplicationDisplayService>(nv_flinger);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager,
-                       std::shared_ptr<NVFlinger::NVFlinger> nv_flinger) {
+void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nv_flinger) {
     std::make_shared<VI_M>(nv_flinger)->InstallAsService(service_manager);
     std::make_shared<VI_S>(nv_flinger)->InstallAsService(service_manager);
     std::make_shared<VI_U>(nv_flinger)->InstallAsService(service_manager);

src/core/hle/service/vi/vi.h

@@ -43,12 +43,11 @@ enum class Policy {
 };
 
 namespace detail {
-void GetDisplayServiceImpl(Kernel::HLERequestContext& ctx,
-                           std::shared_ptr<NVFlinger::NVFlinger> nv_flinger, Permission permission);
+void GetDisplayServiceImpl(Kernel::HLERequestContext& ctx, NVFlinger::NVFlinger& nv_flinger,
+                           Permission permission);
 } // namespace detail
 
 /// Registers all VI services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager,
-                       std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nv_flinger);
 
 } // namespace Service::VI

src/core/hle/service/vi/vi_m.cpp

@@ -8,8 +8,7 @@
 
 namespace Service::VI {
 
-VI_M::VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework{"vi:m"}, nv_flinger{std::move(nv_flinger)} {
+VI_M::VI_M(NVFlinger::NVFlinger& nv_flinger) : ServiceFramework{"vi:m"}, nv_flinger{nv_flinger} {
     static const FunctionInfo functions[] = {
         {2, &VI_M::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_m.h

@@ -18,13 +18,13 @@ namespace Service::VI {
 
 class VI_M final : public ServiceFramework<VI_M> {
 public:
-    explicit VI_M(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    explicit VI_M(NVFlinger::NVFlinger& nv_flinger);
     ~VI_M() override;
 
 private:
     void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+    NVFlinger::NVFlinger& nv_flinger;
 };
 
 } // namespace Service::VI

src/core/hle/service/vi/vi_s.cpp

@@ -8,8 +8,7 @@
 
 namespace Service::VI {
 
-VI_S::VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework{"vi:s"}, nv_flinger{std::move(nv_flinger)} {
+VI_S::VI_S(NVFlinger::NVFlinger& nv_flinger) : ServiceFramework{"vi:s"}, nv_flinger{nv_flinger} {
     static const FunctionInfo functions[] = {
         {1, &VI_S::GetDisplayService, "GetDisplayService"},
         {3, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_s.h

@@ -18,13 +18,13 @@ namespace Service::VI {
 
 class VI_S final : public ServiceFramework<VI_S> {
 public:
-    explicit VI_S(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    explicit VI_S(NVFlinger::NVFlinger& nv_flinger);
     ~VI_S() override;
 
 private:
     void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+    NVFlinger::NVFlinger& nv_flinger;
 };
 
 } // namespace Service::VI

src/core/hle/service/vi/vi_u.cpp

@@ -8,8 +8,7 @@
 
 namespace Service::VI {
 
-VI_U::VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger)
-    : ServiceFramework{"vi:u"}, nv_flinger{std::move(nv_flinger)} {
+VI_U::VI_U(NVFlinger::NVFlinger& nv_flinger) : ServiceFramework{"vi:u"}, nv_flinger{nv_flinger} {
     static const FunctionInfo functions[] = {
         {0, &VI_U::GetDisplayService, "GetDisplayService"},
         {1, nullptr, "GetDisplayServiceWithProxyNameExchange"},

src/core/hle/service/vi/vi_u.h

@@ -18,13 +18,13 @@ namespace Service::VI {
 
 class VI_U final : public ServiceFramework<VI_U> {
 public:
-    explicit VI_U(std::shared_ptr<NVFlinger::NVFlinger> nv_flinger);
+    explicit VI_U(NVFlinger::NVFlinger& nv_flinger);
     ~VI_U() override;
 
 private:
     void GetDisplayService(Kernel::HLERequestContext& ctx);
 
-    std::shared_ptr<NVFlinger::NVFlinger> nv_flinger;
+    NVFlinger::NVFlinger& nv_flinger;
 };
 
 } // namespace Service::VI

src/input_common/CMakeLists.txt

@@ -31,6 +31,9 @@ add_library(input_common STATIC
 
 if (MSVC)
     target_compile_options(input_common PRIVATE
+        /W4
+        /WX
+
         # 'expression' : signed/unsigned mismatch
         /we4018
         # 'argument' : conversion from 'type1' to 'type2', possible loss of data (floating-point)
@@ -46,6 +49,7 @@ if (MSVC)
     )
 else()
     target_compile_options(input_common PRIVATE
+        -Werror
         -Werror=conversion
         -Werror=ignored-qualifiers
         -Werror=implicit-fallthrough

src/input_common/gcadapter/gc_poller.cpp

@@ -96,7 +96,6 @@ std::unique_ptr<Input::ButtonDevice> GCButtonFactory::Create(const Common::Param
                                               adapter.get());
     }
 
-    UNREACHABLE();
     return nullptr;
 }
 
@@ -300,7 +299,8 @@ public:
         return gcadapter->RumblePlay(port, 0);
     }
 
-    bool SetRumblePlay(f32 amp_low, f32 freq_low, f32 amp_high, f32 freq_high) const override {
+    bool SetRumblePlay(f32 amp_low, [[maybe_unused]] f32 freq_low, f32 amp_high,
+                       [[maybe_unused]] f32 freq_high) const override {
         const auto mean_amplitude = (amp_low + amp_high) * 0.5f;
         const auto processed_amplitude =
             static_cast<u8>((mean_amplitude + std::pow(mean_amplitude, 0.3f)) * 0.5f * 0x8);

src/input_common/sdl/sdl.h

@@ -23,7 +23,7 @@ public:
     /// Unregisters SDL device factories and shut them down.
     virtual ~State() = default;
 
-    virtual Pollers GetPollers(Polling::DeviceType type) {
+    virtual Pollers GetPollers(Polling::DeviceType) {
         return {};
     }
 

src/input_common/sdl/sdl_impl.cpp

@@ -400,7 +400,8 @@ public:
         return joystick->RumblePlay(0, 0);
     }
 
-    bool SetRumblePlay(f32 amp_low, f32 freq_low, f32 amp_high, f32 freq_high) const override {
+    bool SetRumblePlay(f32 amp_low, [[maybe_unused]] f32 freq_low, f32 amp_high,
+                       [[maybe_unused]] f32 freq_high) const override {
         const auto process_amplitude = [](f32 amplitude) {
             return static_cast<u16>((amplitude + std::pow(amplitude, 0.3f)) * 0.5f * 0xFFFF);
         };
@@ -864,6 +865,8 @@ Common::ParamPackage SDLEventToMotionParamPackage(SDLState& state, const SDL_Eve
 Common::ParamPackage BuildParamPackageForBinding(int port, const std::string& guid,
                                                  const SDL_GameControllerButtonBind& binding) {
     switch (binding.bindType) {
+    case SDL_CONTROLLER_BINDTYPE_NONE:
+        break;
     case SDL_CONTROLLER_BINDTYPE_AXIS:
         return BuildAnalogParamPackageForButton(port, guid, binding.value.axis);
     case SDL_CONTROLLER_BINDTYPE_BUTTON:
@@ -984,7 +987,7 @@ class SDLPoller : public InputCommon::Polling::DevicePoller {
 public:
     explicit SDLPoller(SDLState& state_) : state(state_) {}
 
-    void Start(const std::string& device_id) override {
+    void Start([[maybe_unused]] const std::string& device_id) override {
         state.event_queue.Clear();
         state.polling = true;
     }

src/input_common/touch_from_button.cpp

@@ -44,8 +44,7 @@ private:
     std::vector<std::tuple<std::unique_ptr<Input::ButtonDevice>, int, int>> map;
 };
 
-std::unique_ptr<Input::TouchDevice> TouchFromButtonFactory::Create(
-    const Common::ParamPackage& params) {
+std::unique_ptr<Input::TouchDevice> TouchFromButtonFactory::Create(const Common::ParamPackage&) {
     return std::make_unique<TouchFromButtonDevice>();
 }
 

src/input_common/udp/client.cpp

@@ -63,7 +63,7 @@ public:
     }
 
 private:
-    void HandleReceive(const boost::system::error_code& error, std::size_t bytes_transferred) {
+    void HandleReceive(const boost::system::error_code&, std::size_t bytes_transferred) {
         if (auto type = Response::Validate(receive_buffer.data(), bytes_transferred)) {
             switch (*type) {
             case Type::Version: {
@@ -90,7 +90,7 @@ private:
         StartReceive();
     }
 
-    void HandleSend(const boost::system::error_code& error) {
+    void HandleSend(const boost::system::error_code&) {
         boost::system::error_code _ignored{};
         // Send a request for getting port info for the pad
         const Request::PortInfo port_info{1, {static_cast<u8>(pad_index), 0, 0, 0}};
@@ -189,11 +189,11 @@ void Client::ReloadSocket(const std::string& host, u16 port, std::size_t pad_ind
     StartCommunication(client, host, port, pad_index, client_id);
 }
 
-void Client::OnVersion(Response::Version data) {
+void Client::OnVersion([[maybe_unused]] Response::Version data) {
     LOG_TRACE(Input, "Version packet received: {}", data.version);
 }
 
-void Client::OnPortInfo(Response::PortInfo data) {
+void Client::OnPortInfo([[maybe_unused]] Response::PortInfo data) {
     LOG_TRACE(Input, "PortInfo packet received: {}", data.model);
 }
 
@@ -369,7 +369,7 @@ CalibrationConfigurationJob::CalibrationConfigurationJob(
         u16 max_y{};
 
         Status current_status{Status::Initialized};
-        SocketCallback callback{[](Response::Version version) {}, [](Response::PortInfo info) {},
+        SocketCallback callback{[](Response::Version) {}, [](Response::PortInfo) {},
                                 [&](Response::PadData data) {
                                     if (current_status == Status::Initialized) {
                                         // Receiving data means the communication is ready now

src/input_common/udp/protocol.h

@@ -7,7 +7,16 @@
 #include <array>
 #include <optional>
 #include <type_traits>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4701)
+#endif
 #include <boost/crc.hpp>
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
 #include "common/bit_field.h"
 #include "common/swap.h"
 
@@ -93,7 +102,7 @@ static_assert(std::is_trivially_copyable_v<PadData>,
 
 /**
  * Creates a message with the proper header data that can be sent to the server.
- * @param T data Request body to send
+ * @param data Request body to send
  * @param client_id ID of the udp client (usually not checked on the server)
  */
 template <typename T>

src/video_core/shader/decode/image.cpp

@@ -212,10 +212,10 @@ u32 GetComponentSize(TextureFormat format, std::size_t component) {
         return 0;
     case TextureFormat::R8G24:
         if (component == 0) {
-            return 8;
+            return 24;
         }
         if (component == 1) {
-            return 24;
+            return 8;
         }
         return 0;
     case TextureFormat::R8G8:

src/yuzu_cmd/yuzu.cpp

@@ -240,11 +240,11 @@ int main(int argc, char** argv) {
         system.CurrentProcess()->GetTitleID(), false,
         [](VideoCore::LoadCallbackStage, size_t value, size_t total) {});
 
-    system.Run();
+    void(system.Run());
     while (emu_window->IsOpen()) {
         std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
-    system.Pause();
+    void(system.Pause());
     system.Shutdown();
 
     detached_tasks.WaitForAllTasks();

src/yuzu_tester/yuzu.cpp

@@ -256,11 +256,11 @@ int main(int argc, char** argv) {
 
     system.GPU().Start();
 
-    system.Run();
+    void(system.Run());
     while (!finished) {
         std::this_thread::sleep_for(std::chrono::milliseconds(1));
     }
-    system.Pause();
+    void(system.Pause());
 
     detached_tasks.WaitForAllTasks();
     return return_value;