applets: Move from am to hle directory and rename namespace

CMakeModules/GenerateSCMRev.cmake

@@ -82,8 +82,6 @@ set(HASH_FILES
     "${VIDEO_CORE}/shader/decode/shift.cpp"
     "${VIDEO_CORE}/shader/decode/video.cpp"
     "${VIDEO_CORE}/shader/decode/xmad.cpp"
-    "${VIDEO_CORE}/shader/control_flow.cpp"
-    "${VIDEO_CORE}/shader/control_flow.h"
     "${VIDEO_CORE}/shader/decode.cpp"
     "${VIDEO_CORE}/shader/node.h"
     "${VIDEO_CORE}/shader/node_helper.cpp"

src/audio_core/audio_renderer.cpp

@@ -217,15 +217,13 @@ std::vector<s16> AudioRenderer::VoiceState::DequeueSamples(std::size_t sample_co
     if (offset == samples.size()) {
         offset = 0;
 
-        if (!wave_buffer.is_looping && wave_buffer.buffer_sz) {
+        if (!wave_buffer.is_looping) {
             SetWaveIndex(wave_index + 1);
         }
 
-        if (wave_buffer.buffer_sz) {
-            out_status.wave_buffer_consumed++;
-        }
+        out_status.wave_buffer_consumed++;
 
-        if (wave_buffer.end_of_stream || wave_buffer.buffer_sz == 0) {
+        if (wave_buffer.end_of_stream) {
             info.play_state = PlayState::Paused;
         }
     }

src/common/CMakeLists.txt

@@ -56,8 +56,6 @@ add_custom_command(OUTPUT scm_rev.cpp
       "${VIDEO_CORE}/shader/decode/shift.cpp"
       "${VIDEO_CORE}/shader/decode/video.cpp"
       "${VIDEO_CORE}/shader/decode/xmad.cpp"
-      "${VIDEO_CORE}/shader/control_flow.cpp"
-      "${VIDEO_CORE}/shader/control_flow.h"
       "${VIDEO_CORE}/shader/decode.cpp"
       "${VIDEO_CORE}/shader/node.h"
       "${VIDEO_CORE}/shader/node_helper.cpp"

src/core/CMakeLists.txt

@@ -111,6 +111,18 @@ add_library(core STATIC
     frontend/scope_acquire_window_context.h
     gdbstub/gdbstub.cpp
     gdbstub/gdbstub.h
+    hle/applet/applet.cpp
+    hle/applet/applet.h
+    hle/applet/error.cpp
+    hle/applet/error.h
+    hle/applet/general_backend.cpp
+    hle/applet/general_backend.h
+    hle/applet/profile_select.cpp
+    hle/applet/profile_select.h
+    hle/applet/software_keyboard.cpp
+    hle/applet/software_keyboard.h
+    hle/applet/web_browser.cpp
+    hle/applet/web_browser.h
     hle/ipc.h
     hle/ipc_helpers.h
     hle/kernel/address_arbiter.cpp
@@ -184,18 +196,6 @@ add_library(core STATIC
     hle/service/am/applet_ae.h
     hle/service/am/applet_oe.cpp
     hle/service/am/applet_oe.h
-    hle/service/am/applets/applets.cpp
-    hle/service/am/applets/applets.h
-    hle/service/am/applets/error.cpp
-    hle/service/am/applets/error.h
-    hle/service/am/applets/general_backend.cpp
-    hle/service/am/applets/general_backend.h
-    hle/service/am/applets/profile_select.cpp
-    hle/service/am/applets/profile_select.h
-    hle/service/am/applets/software_keyboard.cpp
-    hle/service/am/applets/software_keyboard.h
-    hle/service/am/applets/web_browser.cpp
-    hle/service/am/applets/web_browser.h
     hle/service/am/idle.cpp
     hle/service/am/idle.h
     hle/service/am/omm.cpp
@@ -208,8 +208,6 @@ add_library(core STATIC
     hle/service/aoc/aoc_u.h
     hle/service/apm/apm.cpp
     hle/service/apm/apm.h
-    hle/service/apm/controller.cpp
-    hle/service/apm/controller.h
     hle/service/apm/interface.cpp
     hle/service/apm/interface.h
     hle/service/audio/audctl.cpp
@@ -295,7 +293,6 @@ add_library(core STATIC
     hle/service/hid/irs.h
     hle/service/hid/xcd.cpp
     hle/service/hid/xcd.h
-    hle/service/hid/errors.h
     hle/service/hid/controllers/controller_base.cpp
     hle/service/hid/controllers/controller_base.h
     hle/service/hid/controllers/debug_pad.cpp

src/core/core.cpp

@@ -19,13 +19,12 @@
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
 #include "core/gdbstub/gdbstub.h"
+#include "core/hle/applet/applet.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
-#include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/apm/controller.h"
 #include "core/hle/service/glue/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
@@ -144,7 +143,7 @@ struct System::Impl {
         telemetry_session = std::make_unique<Core::TelemetrySession>();
         service_manager = std::make_shared<Service::SM::ServiceManager>();
 
-        Service::Init(service_manager, system);
+        Service::Init(service_manager, system, *virtual_filesystem);
         GDBStub::Init();
 
         renderer = VideoCore::CreateRenderer(emu_window, system);
@@ -305,10 +304,7 @@ struct System::Impl {
     std::unique_ptr<Tools::Freezer> memory_freezer;
 
     /// Frontend applets
-    Service::AM::Applets::AppletManager applet_manager;
-
-    /// APM (Performance) services
-    Service::APM::Controller apm_controller{core_timing};
+    HLE::Applet::AppletManager applet_manager;
 
     /// Glue services
     Service::Glue::ARPManager arp_manager;
@@ -523,7 +519,7 @@ std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
-void System::SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set) {
+void System::SetAppletFrontendSet(HLE::Applet::AppletFrontendSet&& set) {
     impl->applet_manager.SetAppletFrontendSet(std::move(set));
 }
 
@@ -531,11 +527,11 @@ void System::SetDefaultAppletFrontendSet() {
     impl->applet_manager.SetDefaultAppletFrontendSet();
 }
 
-Service::AM::Applets::AppletManager& System::GetAppletManager() {
+HLE::Applet::AppletManager& System::GetAppletManager() {
     return impl->applet_manager;
 }
 
-const Service::AM::Applets::AppletManager& System::GetAppletManager() const {
+const HLE::Applet::AppletManager& System::GetAppletManager() const {
     return impl->applet_manager;
 }
 
@@ -572,14 +568,6 @@ const Service::Glue::ARPManager& System::GetARPManager() const {
     return impl->arp_manager;
 }
 
-Service::APM::Controller& System::GetAPMController() {
-    return impl->apm_controller;
-}
-
-const Service::APM::Controller& System::GetAPMController() const {
-    return impl->apm_controller;
-}
-
 System::ResultStatus System::Init(Frontend::EmuWindow& emu_window) {
     return impl->Init(*this, emu_window);
 }

src/core/core.h

@@ -25,6 +25,11 @@ enum class ContentProviderUnionSlot;
 class VfsFilesystem;
 } // namespace FileSys
 
+namespace HLE::Applet {
+struct AppletFrontendSet;
+class AppletManager;
+} // namespace HLE::Applet
+
 namespace Kernel {
 class KernelCore;
 class Process;
@@ -38,15 +43,6 @@ enum class ResultStatus : u16;
 
 namespace Service {
 
-namespace AM::Applets {
-struct AppletFrontendSet;
-class AppletManager;
-} // namespace AM::Applets
-
-namespace APM {
-class Controller;
-}
-
 namespace Glue {
 class ARPManager;
 }
@@ -275,13 +271,13 @@ public:
     void RegisterCheatList(const std::vector<FileSys::CheatList>& list, const std::string& build_id,
                            VAddr code_region_start, VAddr code_region_end);
 
-    void SetAppletFrontendSet(Service::AM::Applets::AppletFrontendSet&& set);
+    void SetAppletFrontendSet(HLE::Applet::AppletFrontendSet&& set);
 
     void SetDefaultAppletFrontendSet();
 
-    Service::AM::Applets::AppletManager& GetAppletManager();
+    HLE::Applet::AppletManager& GetAppletManager();
 
-    const Service::AM::Applets::AppletManager& GetAppletManager() const;
+    const HLE::Applet::AppletManager& GetAppletManager() const;
 
     void SetContentProvider(std::unique_ptr<FileSys::ContentProviderUnion> provider);
 
@@ -300,10 +296,6 @@ public:
 
     const Service::Glue::ARPManager& GetARPManager() const;
 
-    Service::APM::Controller& GetAPMController();
-
-    const Service::APM::Controller& GetAPMController() const;
-
 private:
     System();
 

src/core/hle/applet/applet.cpp

@@ -10,18 +10,18 @@
 #include "core/frontend/applets/profile_select.h"
 #include "core/frontend/applets/software_keyboard.h"
 #include "core/frontend/applets/web_browser.h"
+#include "core/hle/applet/applet.h"
+#include "core/hle/applet/error.h"
+#include "core/hle/applet/general_backend.h"
+#include "core/hle/applet/profile_select.h"
+#include "core/hle/applet/software_keyboard.h"
+#include "core/hle/applet/web_browser.h"
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/server_session.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/am/applets/error.h"
-#include "core/hle/service/am/applets/general_backend.h"
-#include "core/hle/service/am/applets/profile_select.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
-#include "core/hle/service/am/applets/web_browser.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 AppletDataBroker::AppletDataBroker() {
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -51,7 +51,7 @@ AppletDataBroker::RawChannelData AppletDataBroker::PeekDataToAppletForDebug() co
     return {std::move(out_normal), std::move(out_interactive)};
 }
 
-std::unique_ptr<IStorage> AppletDataBroker::PopNormalDataToGame() {
+std::unique_ptr<Service::AM::IStorage> AppletDataBroker::PopNormalDataToGame() {
     if (out_channel.empty())
         return nullptr;
 
@@ -60,7 +60,7 @@ std::unique_ptr<IStorage> AppletDataBroker::PopNormalDataToGame() {
     return out;
 }
 
-std::unique_ptr<IStorage> AppletDataBroker::PopNormalDataToApplet() {
+std::unique_ptr<Service::AM::IStorage> AppletDataBroker::PopNormalDataToApplet() {
     if (in_channel.empty())
         return nullptr;
 
@@ -69,7 +69,7 @@ std::unique_ptr<IStorage> AppletDataBroker::PopNormalDataToApplet() {
     return out;
 }
 
-std::unique_ptr<IStorage> AppletDataBroker::PopInteractiveDataToGame() {
+std::unique_ptr<Service::AM::IStorage> AppletDataBroker::PopInteractiveDataToGame() {
     if (out_interactive_channel.empty())
         return nullptr;
 
@@ -78,7 +78,7 @@ std::unique_ptr<IStorage> AppletDataBroker::PopInteractiveDataToGame() {
     return out;
 }
 
-std::unique_ptr<IStorage> AppletDataBroker::PopInteractiveDataToApplet() {
+std::unique_ptr<Service::AM::IStorage> AppletDataBroker::PopInteractiveDataToApplet() {
     if (in_interactive_channel.empty())
         return nullptr;
 
@@ -87,21 +87,21 @@ std::unique_ptr<IStorage> AppletDataBroker::PopInteractiveDataToApplet() {
     return out;
 }
 
-void AppletDataBroker::PushNormalDataFromGame(IStorage storage) {
-    in_channel.push_back(std::make_unique<IStorage>(storage));
+void AppletDataBroker::PushNormalDataFromGame(Service::AM::IStorage storage) {
+    in_channel.push_back(std::make_unique<Service::AM::IStorage>(storage));
 }
 
-void AppletDataBroker::PushNormalDataFromApplet(IStorage storage) {
-    out_channel.push_back(std::make_unique<IStorage>(storage));
+void AppletDataBroker::PushNormalDataFromApplet(Service::AM::IStorage storage) {
+    out_channel.push_back(std::make_unique<Service::AM::IStorage>(storage));
     pop_out_data_event.writable->Signal();
 }
 
-void AppletDataBroker::PushInteractiveDataFromGame(IStorage storage) {
-    in_interactive_channel.push_back(std::make_unique<IStorage>(storage));
+void AppletDataBroker::PushInteractiveDataFromGame(Service::AM::IStorage storage) {
+    in_interactive_channel.push_back(std::make_unique<Service::AM::IStorage>(storage));
 }
 
-void AppletDataBroker::PushInteractiveDataFromApplet(IStorage storage) {
-    out_interactive_channel.push_back(std::make_unique<IStorage>(storage));
+void AppletDataBroker::PushInteractiveDataFromApplet(Service::AM::IStorage storage) {
+    out_interactive_channel.push_back(std::make_unique<Service::AM::IStorage>(storage));
     pop_interactive_out_data_event.writable->Signal();
 }
 
@@ -241,4 +241,4 @@ std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id, u64 current_proces
     }
 }
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/applet.h

@@ -25,8 +25,9 @@ class WebBrowserApplet;
 namespace Service::AM {
 
 class IStorage;
+}
 
-namespace Applets {
+namespace HLE::Applet {
 
 enum class AppletId : u32 {
     OverlayDisplay = 0x02,
@@ -64,17 +65,17 @@ public:
     // Retrieves but does not pop the data sent to applet.
     RawChannelData PeekDataToAppletForDebug() const;
 
-    std::unique_ptr<IStorage> PopNormalDataToGame();
-    std::unique_ptr<IStorage> PopNormalDataToApplet();
+    std::unique_ptr<Service::AM::IStorage> PopNormalDataToGame();
+    std::unique_ptr<Service::AM::IStorage> PopNormalDataToApplet();
 
-    std::unique_ptr<IStorage> PopInteractiveDataToGame();
-    std::unique_ptr<IStorage> PopInteractiveDataToApplet();
+    std::unique_ptr<Service::AM::IStorage> PopInteractiveDataToGame();
+    std::unique_ptr<Service::AM::IStorage> PopInteractiveDataToApplet();
 
-    void PushNormalDataFromGame(IStorage storage);
-    void PushNormalDataFromApplet(IStorage storage);
+    void PushNormalDataFromGame(Service::AM::IStorage storage);
+    void PushNormalDataFromApplet(Service::AM::IStorage storage);
 
-    void PushInteractiveDataFromGame(IStorage storage);
-    void PushInteractiveDataFromApplet(IStorage storage);
+    void PushInteractiveDataFromGame(Service::AM::IStorage storage);
+    void PushInteractiveDataFromApplet(Service::AM::IStorage storage);
 
     void SignalStateChanged() const;
 
@@ -86,16 +87,16 @@ private:
     // Queues are named from applet's perspective
 
     // PopNormalDataToApplet and PushNormalDataFromGame
-    std::deque<std::unique_ptr<IStorage>> in_channel;
+    std::deque<std::unique_ptr<Service::AM::IStorage>> in_channel;
 
     // PopNormalDataToGame and PushNormalDataFromApplet
-    std::deque<std::unique_ptr<IStorage>> out_channel;
+    std::deque<std::unique_ptr<Service::AM::IStorage>> out_channel;
 
     // PopInteractiveDataToApplet and PushInteractiveDataFromGame
-    std::deque<std::unique_ptr<IStorage>> in_interactive_channel;
+    std::deque<std::unique_ptr<Service::AM::IStorage>> in_interactive_channel;
 
     // PopInteractiveDataToGame and PushInteractiveDataFromApplet
-    std::deque<std::unique_ptr<IStorage>> out_interactive_channel;
+    std::deque<std::unique_ptr<Service::AM::IStorage>> out_interactive_channel;
 
     Kernel::EventPair state_changed_event;
 
@@ -193,5 +194,4 @@ private:
     AppletFrontendSet frontend;
 };
 
-} // namespace Applets
-} // namespace Service::AM
+} // namespace HLE::Applet

src/core/hle/applet/error.cpp

@@ -9,12 +9,12 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/error.h"
+#include "core/hle/applet/error.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/error.h"
 #include "core/reporter.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 #pragma pack(push, 4)
 struct ShowError {
@@ -184,8 +184,8 @@ void Error::Execute() {
 
 void Error::DisplayCompleted() {
     complete = true;
-    broker.PushNormalDataFromApplet(IStorage{{}});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{{}});
     broker.SignalStateChanged();
 }
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/error.h

@@ -4,10 +4,10 @@
 
 #pragma once
 
+#include "core/hle/applet/applet.h"
 #include "core/hle/result.h"
-#include "core/hle/service/am/applets/applets.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 enum class ErrorAppletMode : u8 {
     ShowError = 0,
@@ -44,4 +44,4 @@ private:
     bool complete = false;
 };
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/general_backend.cpp

@@ -9,18 +9,18 @@
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/frontend/applets/general_frontend.h"
+#include "core/hle/applet/general_backend.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/general_backend.h"
 #include "core/reporter.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 constexpr ResultCode ERROR_INVALID_PIN{ErrorModule::PCTL, 221};
 
 static void LogCurrentStorage(AppletDataBroker& broker, std::string_view prefix) {
-    std::unique_ptr<IStorage> storage = broker.PopNormalDataToApplet();
+    std::unique_ptr<Service::AM::IStorage> storage = broker.PopNormalDataToApplet();
     for (; storage != nullptr; storage = broker.PopNormalDataToApplet()) {
         const auto data = storage->GetData();
         LOG_INFO(Service_AM,
@@ -147,7 +147,7 @@ void Auth::AuthFinished(bool successful) {
     std::vector<u8> out(sizeof(Return));
     std::memcpy(out.data(), &return_, sizeof(Return));
 
-    broker.PushNormalDataFromApplet(IStorage{out});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{out});
     broker.SignalStateChanged();
 }
 
@@ -196,7 +196,7 @@ void PhotoViewer::Execute() {
 }
 
 void PhotoViewer::ViewFinished() {
-    broker.PushNormalDataFromApplet(IStorage{{}});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{{}});
     broker.SignalStateChanged();
 }
 
@@ -231,8 +231,8 @@ void StubApplet::ExecuteInteractive() {
     LOG_WARNING(Service_AM, "called (STUBBED)");
     LogCurrentStorage(broker, "ExecuteInteractive");
 
-    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
-    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{std::vector<u8>(0x1000)});
+    broker.PushInteractiveDataFromApplet(Service::AM::IStorage{std::vector<u8>(0x1000)});
     broker.SignalStateChanged();
 }
 
@@ -240,9 +240,9 @@ void StubApplet::Execute() {
     LOG_WARNING(Service_AM, "called (STUBBED)");
     LogCurrentStorage(broker, "Execute");
 
-    broker.PushNormalDataFromApplet(IStorage{std::vector<u8>(0x1000)});
-    broker.PushInteractiveDataFromApplet(IStorage{std::vector<u8>(0x1000)});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{std::vector<u8>(0x1000)});
+    broker.PushInteractiveDataFromApplet(Service::AM::IStorage{std::vector<u8>(0x1000)});
     broker.SignalStateChanged();
 }
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/general_backend.h

@@ -4,9 +4,9 @@
 
 #pragma once
 
-#include "core/hle/service/am/applets/applets.h"
+#include "core/hle/applet/applet.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 enum class AuthAppletType : u32 {
     ShowParentalAuthentication,
@@ -78,4 +78,4 @@ private:
     AppletId id;
 };
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/profile_select.cpp

@@ -8,10 +8,10 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/profile_select.h"
+#include "core/hle/applet/profile_select.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/profile_select.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 constexpr ResultCode ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};
 
@@ -49,7 +49,7 @@ void ProfileSelect::ExecuteInteractive() {
 
 void ProfileSelect::Execute() {
     if (complete) {
-        broker.PushNormalDataFromApplet(IStorage{final_data});
+        broker.PushNormalDataFromApplet(Service::AM::IStorage{final_data});
         return;
     }
 
@@ -70,8 +70,8 @@ void ProfileSelect::SelectionComplete(std::optional<Common::UUID> uuid) {
 
     final_data = std::vector<u8>(sizeof(UserSelectionOutput));
     std::memcpy(final_data.data(), &output, final_data.size());
-    broker.PushNormalDataFromApplet(IStorage{final_data});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{final_data});
     broker.SignalStateChanged();
 }
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/profile_select.h

@@ -8,10 +8,10 @@
 
 #include "common/common_funcs.h"
 #include "common/uuid.h"
+#include "core/hle/applet/applet.h"
 #include "core/hle/result.h"
-#include "core/hle/service/am/applets/applets.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 struct UserSelectionConfig {
     // TODO(DarkLordZach): RE this structure
@@ -50,4 +50,4 @@ private:
     std::vector<u8> final_data;
 };
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/software_keyboard.cpp

@@ -7,11 +7,11 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/software_keyboard.h"
+#include "core/hle/applet/software_keyboard.h"
 #include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 constexpr std::size_t SWKBD_OUTPUT_BUFFER_SIZE = 0x7D8;
 constexpr std::size_t SWKBD_OUTPUT_INTERACTIVE_BUFFER_SIZE = 0x7D4;
@@ -101,7 +101,7 @@ void SoftwareKeyboard::ExecuteInteractive() {
 
 void SoftwareKeyboard::Execute() {
     if (complete) {
-        broker.PushNormalDataFromApplet(IStorage{final_data});
+        broker.PushNormalDataFromApplet(Service::AM::IStorage{final_data});
         return;
     }
 
@@ -143,16 +143,16 @@ void SoftwareKeyboard::WriteText(std::optional<std::u16string> text) {
         final_data = output_main;
 
         if (complete) {
-            broker.PushNormalDataFromApplet(IStorage{output_main});
+            broker.PushNormalDataFromApplet(Service::AM::IStorage{output_main});
             broker.SignalStateChanged();
         } else {
-            broker.PushInteractiveDataFromApplet(IStorage{output_sub});
+            broker.PushInteractiveDataFromApplet(Service::AM::IStorage{output_sub});
         }
     } else {
         output_main[0] = 1;
         complete = true;
-        broker.PushNormalDataFromApplet(IStorage{output_main});
+        broker.PushNormalDataFromApplet(Service::AM::IStorage{output_main});
         broker.SignalStateChanged();
     }
 }
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/software_keyboard.h

@@ -11,12 +11,12 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/hle/applet/applet.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/applets.h"
 
 union ResultCode;
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 enum class KeysetDisable : u32 {
     Space = 0x02,
@@ -76,4 +76,4 @@ private:
     std::vector<u8> final_data;
 };
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/web_browser.cpp

@@ -23,12 +23,12 @@
 #include "core/file_sys/vfs_types.h"
 #include "core/frontend/applets/general_frontend.h"
 #include "core/frontend/applets/web_browser.h"
+#include "core/hle/applet/web_browser.h"
 #include "core/hle/kernel/process.h"
-#include "core/hle/service/am/applets/web_browser.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/loader.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 enum class WebArgTLVType : u16 {
     InitialURL = 0x1,
@@ -283,7 +283,7 @@ void WebBrowser::Finalize() {
     std::vector<u8> data(sizeof(WebCommonReturnValue));
     std::memcpy(data.data(), &out, sizeof(WebCommonReturnValue));
 
-    broker.PushNormalDataFromApplet(IStorage{data});
+    broker.PushNormalDataFromApplet(Service::AM::IStorage{data});
     broker.SignalStateChanged();
 
     if (!temporary_dir.empty() && FileUtil::IsDirectory(temporary_dir)) {
@@ -547,4 +547,4 @@ void WebBrowser::ExecuteOffline() {
     frontend.OpenPageLocal(filename, [this] { UnpackRomFS(); }, [this] { Finalize(); });
 }
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

src/core/hle/applet/web_browser.h

@@ -6,10 +6,11 @@
 
 #include <map>
 #include "core/file_sys/vfs_types.h"
+#include "core/hle/applet/applet.h"
+#include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
-#include "core/hle/service/am/applets/applets.h"
 
-namespace Service::AM::Applets {
+namespace HLE::Applet {
 
 enum class ShimKind : u32;
 enum class ShopWebTarget;
@@ -76,4 +77,4 @@ private:
     std::string shop_extra_parameter;
 };
 
-} // namespace Service::AM::Applets
+} // namespace HLE::Applet

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

@@ -11,6 +11,10 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/savedata_factory.h"
+#include "core/hle/applet/applet.h"
+#include "core/hle/applet/profile_select.h"
+#include "core/hle/applet/software_keyboard.h"
+#include "core/hle/applet/web_browser.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
@@ -21,16 +25,11 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_ae.h"
 #include "core/hle/service/am/applet_oe.h"
-#include "core/hle/service/am/applets/applets.h"
-#include "core/hle/service/am/applets/profile_select.h"
-#include "core/hle/service/am/applets/software_keyboard.h"
-#include "core/hle/service/am/applets/web_browser.h"
 #include "core/hle/service/am/idle.h"
 #include "core/hle/service/am/omm.h"
 #include "core/hle/service/am/spsm.h"
 #include "core/hle/service/am/tcap.h"
-#include "core/hle/service/apm/controller.h"
-#include "core/hle/service/apm/interface.h"
+#include "core/hle/service/apm/apm.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -521,9 +520,8 @@ void AppletMessageQueue::OperationModeChanged() {
     on_operation_mode_changed.writable->Signal();
 }
 
-ICommonStateGetter::ICommonStateGetter(Core::System& system,
-                                       std::shared_ptr<AppletMessageQueue> msg_queue)
-    : ServiceFramework("ICommonStateGetter"), system(system), msg_queue(std::move(msg_queue)) {
+ICommonStateGetter::ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue)
+    : ServiceFramework("ICommonStateGetter"), msg_queue(std::move(msg_queue)) {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &ICommonStateGetter::GetEventHandle, "GetEventHandle"},
@@ -556,7 +554,7 @@ ICommonStateGetter::ICommonStateGetter(Core::System& system,
         {63, nullptr, "GetHdcpAuthenticationStateChangeEvent"},
         {64, nullptr, "SetTvPowerStateMatchingMode"},
         {65, nullptr, "GetApplicationIdByContentActionName"},
-        {66, &ICommonStateGetter::SetCpuBoostMode, "SetCpuBoostMode"},
+        {66, nullptr, "SetCpuBoostMode"},
         {80, nullptr, "PerformSystemButtonPressingIfInFocus"},
         {90, nullptr, "SetPerformanceConfigurationChangedNotification"},
         {91, nullptr, "GetCurrentPerformanceConfiguration"},
@@ -637,16 +635,6 @@ void ICommonStateGetter::GetDefaultDisplayResolution(Kernel::HLERequestContext&
     }
 }
 
-void ICommonStateGetter::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called, forwarding to APM:SYS");
-
-    const auto& sm = system.ServiceManager();
-    const auto apm_sys = sm.GetService<APM::APM_Sys>("apm:sys");
-    ASSERT(apm_sys != nullptr);
-
-    apm_sys->SetCpuBoostMode(ctx);
-}
-
 IStorage::IStorage(std::vector<u8> buffer)
     : ServiceFramework("IStorage"), buffer(std::move(buffer)) {
     // clang-format off
@@ -675,16 +663,18 @@ void ICommonStateGetter::GetOperationMode(Kernel::HLERequestContext& ctx) {
 }
 
 void ICommonStateGetter::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_AM, "called");
+    const bool use_docked_mode{Settings::values.use_docked_mode};
+    LOG_DEBUG(Service_AM, "called, use_docked_mode={}", use_docked_mode);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(system.GetAPMController().GetCurrentPerformanceMode());
+    rb.Push(static_cast<u32>(use_docked_mode ? APM::PerformanceMode::Docked
+                                             : APM::PerformanceMode::Handheld));
 }
 
 class ILibraryAppletAccessor final : public ServiceFramework<ILibraryAppletAccessor> {
 public:
-    explicit ILibraryAppletAccessor(std::shared_ptr<Applets::Applet> applet)
+    explicit ILibraryAppletAccessor(std::shared_ptr<HLE::Applet::Applet> applet)
         : ServiceFramework("ILibraryAppletAccessor"), applet(std::move(applet)) {
         // clang-format off
         static const FunctionInfo functions[] = {
@@ -826,7 +816,7 @@ private:
         rb.PushCopyObjects(applet->GetBroker().GetInteractiveDataEvent());
     }
 
-    std::shared_ptr<Applets::Applet> applet;
+    std::shared_ptr<HLE::Applet::Applet> applet;
 };
 
 void IStorage::Open(Kernel::HLERequestContext& ctx) {
@@ -927,7 +917,7 @@ ILibraryAppletCreator::~ILibraryAppletCreator() = default;
 
 void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
-    const auto applet_id = rp.PopRaw<Applets::AppletId>();
+    const auto applet_id = rp.PopRaw<HLE::Applet::AppletId>();
     const auto applet_mode = rp.PopRaw<u32>();
 
     LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",

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

@@ -146,8 +146,7 @@ private:
 
 class ICommonStateGetter final : public ServiceFramework<ICommonStateGetter> {
 public:
-    explicit ICommonStateGetter(Core::System& system,
-                                std::shared_ptr<AppletMessageQueue> msg_queue);
+    explicit ICommonStateGetter(std::shared_ptr<AppletMessageQueue> msg_queue);
     ~ICommonStateGetter() override;
 
 private:
@@ -169,9 +168,7 @@ private:
     void GetPerformanceMode(Kernel::HLERequestContext& ctx);
     void GetBootMode(Kernel::HLERequestContext& ctx);
     void GetDefaultDisplayResolution(Kernel::HLERequestContext& ctx);
-    void SetCpuBoostMode(Kernel::HLERequestContext& ctx);
 
-    Core::System& system;
     std::shared_ptr<AppletMessageQueue> msg_queue;
 };
 

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

@@ -42,7 +42,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {
@@ -146,7 +146,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
     }
 
     void GetSelfController(Kernel::HLERequestContext& ctx) {

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

@@ -80,7 +80,7 @@ private:
 
         IPC::ResponseBuilder rb{ctx, 2, 0, 1};
         rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ICommonStateGetter>(system, msg_queue);
+        rb.PushIpcInterface<ICommonStateGetter>(msg_queue);
     }
 
     void GetLibraryAppletCreator(Kernel::HLERequestContext& ctx) {

src/core/hle/service/apm/apm.cpp

@@ -2,6 +2,7 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/apm/interface.h"
@@ -11,15 +12,11 @@ namespace Service::APM {
 Module::Module() = default;
 Module::~Module() = default;
 
-void InstallInterfaces(Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager) {
     auto module_ = std::make_shared<Module>();
-    std::make_shared<APM>(module_, system.GetAPMController(), "apm")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<APM>(module_, system.GetAPMController(), "apm:p")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<APM>(module_, system.GetAPMController(), "apm:am")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<APM_Sys>(system.GetAPMController())->InstallAsService(system.ServiceManager());
+    std::make_shared<APM>(module_, "apm")->InstallAsService(service_manager);
+    std::make_shared<APM>(module_, "apm:p")->InstallAsService(service_manager);
+    std::make_shared<APM_Sys>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/apm.h

@@ -8,6 +8,11 @@
 
 namespace Service::APM {
 
+enum class PerformanceMode : u8 {
+    Handheld = 0,
+    Docked = 1,
+};
+
 class Module final {
 public:
     Module();
@@ -15,6 +20,6 @@ public:
 };
 
 /// Registers all AM services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager);
 
 } // namespace Service::APM

src/core/hle/service/apm/controller.cpp

@@ -1,68 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/logging/log.h"
-#include "core/core_timing.h"
-#include "core/hle/service/apm/controller.h"
-#include "core/settings.h"
-
-namespace Service::APM {
-
-constexpr PerformanceConfiguration DEFAULT_PERFORMANCE_CONFIGURATION =
-    PerformanceConfiguration::Config7;
-
-Controller::Controller(Core::Timing::CoreTiming& core_timing)
-    : core_timing(core_timing), configs{
-                                    {PerformanceMode::Handheld, DEFAULT_PERFORMANCE_CONFIGURATION},
-                                    {PerformanceMode::Docked, DEFAULT_PERFORMANCE_CONFIGURATION},
-                                } {}
-
-Controller::~Controller() = default;
-
-void Controller::SetPerformanceConfiguration(PerformanceMode mode,
-                                             PerformanceConfiguration config) {
-    static const std::map<PerformanceConfiguration, u32> PCONFIG_TO_SPEED_MAP{
-        {PerformanceConfiguration::Config1, 1020},  {PerformanceConfiguration::Config2, 1020},
-        {PerformanceConfiguration::Config3, 1224},  {PerformanceConfiguration::Config4, 1020},
-        {PerformanceConfiguration::Config5, 1020},  {PerformanceConfiguration::Config6, 1224},
-        {PerformanceConfiguration::Config7, 1020},  {PerformanceConfiguration::Config8, 1020},
-        {PerformanceConfiguration::Config9, 1020},  {PerformanceConfiguration::Config10, 1020},
-        {PerformanceConfiguration::Config11, 1020}, {PerformanceConfiguration::Config12, 1020},
-        {PerformanceConfiguration::Config13, 1785}, {PerformanceConfiguration::Config14, 1785},
-        {PerformanceConfiguration::Config15, 1020}, {PerformanceConfiguration::Config16, 1020},
-    };
-
-    SetClockSpeed(PCONFIG_TO_SPEED_MAP.find(config)->second);
-    configs.insert_or_assign(mode, config);
-}
-
-void Controller::SetFromCpuBoostMode(CpuBoostMode mode) {
-    constexpr std::array<PerformanceConfiguration, 3> BOOST_MODE_TO_CONFIG_MAP{{
-        PerformanceConfiguration::Config7,
-        PerformanceConfiguration::Config13,
-        PerformanceConfiguration::Config15,
-    }};
-
-    SetPerformanceConfiguration(PerformanceMode::Docked,
-                                BOOST_MODE_TO_CONFIG_MAP.at(static_cast<u32>(mode)));
-}
-
-PerformanceMode Controller::GetCurrentPerformanceMode() {
-    return Settings::values.use_docked_mode ? PerformanceMode::Docked : PerformanceMode::Handheld;
-}
-
-PerformanceConfiguration Controller::GetCurrentPerformanceConfiguration(PerformanceMode mode) {
-    if (configs.find(mode) == configs.end()) {
-        configs.insert_or_assign(mode, DEFAULT_PERFORMANCE_CONFIGURATION);
-    }
-
-    return configs[mode];
-}
-
-void Controller::SetClockSpeed(u32 mhz) {
-    LOG_INFO(Service_APM, "called, mhz={:08X}", mhz);
-    // TODO(DarkLordZach): Actually signal core_timing to change clock speed.
-}
-
-} // namespace Service::APM

src/core/hle/service/apm/controller.h

@@ -1,70 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <map>
-#include "common/common_types.h"
-
-namespace Core::Timing {
-class CoreTiming;
-}
-
-namespace Service::APM {
-
-enum class PerformanceConfiguration : u32 {
-    Config1 = 0x00010000,
-    Config2 = 0x00010001,
-    Config3 = 0x00010002,
-    Config4 = 0x00020000,
-    Config5 = 0x00020001,
-    Config6 = 0x00020002,
-    Config7 = 0x00020003,
-    Config8 = 0x00020004,
-    Config9 = 0x00020005,
-    Config10 = 0x00020006,
-    Config11 = 0x92220007,
-    Config12 = 0x92220008,
-    Config13 = 0x92220009,
-    Config14 = 0x9222000A,
-    Config15 = 0x9222000B,
-    Config16 = 0x9222000C,
-};
-
-enum class CpuBoostMode : u32 {
-    Disabled = 0,
-    Full = 1,    // CPU + GPU -> Config 13, 14, 15, or 16
-    Partial = 2, // GPU Only -> Config 15 or 16
-};
-
-enum class PerformanceMode : u8 {
-    Handheld = 0,
-    Docked = 1,
-};
-
-// Class to manage the state and change of the emulated system performance.
-// Specifically, this deals with PerformanceMode, which corresponds to the system being docked or
-// undocked, and PerformanceConfig which specifies the exact CPU, GPU, and Memory clocks to operate
-// at. Additionally, this manages 'Boost Mode', which allows games to temporarily overclock the
-// system during times of high load -- this simply maps to different PerformanceConfigs to use.
-class Controller {
-public:
-    Controller(Core::Timing::CoreTiming& core_timing);
-    ~Controller();
-
-    void SetPerformanceConfiguration(PerformanceMode mode, PerformanceConfiguration config);
-    void SetFromCpuBoostMode(CpuBoostMode mode);
-
-    PerformanceMode GetCurrentPerformanceMode();
-    PerformanceConfiguration GetCurrentPerformanceConfiguration(PerformanceMode mode);
-
-private:
-    void SetClockSpeed(u32 mhz);
-
-    std::map<PerformanceMode, PerformanceConfiguration> configs;
-
-    Core::Timing::CoreTiming& core_timing;
-};
-
-} // namespace Service::APM

src/core/hle/service/apm/interface.cpp

@@ -5,32 +5,43 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/apm/apm.h"
-#include "core/hle/service/apm/controller.h"
 #include "core/hle/service/apm/interface.h"
 
 namespace Service::APM {
 
 class ISession final : public ServiceFramework<ISession> {
 public:
-    ISession(Controller& controller) : ServiceFramework("ISession"), controller(controller) {
+    ISession() : ServiceFramework("ISession") {
         static const FunctionInfo functions[] = {
             {0, &ISession::SetPerformanceConfiguration, "SetPerformanceConfiguration"},
             {1, &ISession::GetPerformanceConfiguration, "GetPerformanceConfiguration"},
-            {2, nullptr, "SetCpuOverclockEnabled"},
         };
         RegisterHandlers(functions);
     }
 
 private:
+    enum class PerformanceConfiguration : u32 {
+        Config1 = 0x00010000,
+        Config2 = 0x00010001,
+        Config3 = 0x00010002,
+        Config4 = 0x00020000,
+        Config5 = 0x00020001,
+        Config6 = 0x00020002,
+        Config7 = 0x00020003,
+        Config8 = 0x00020004,
+        Config9 = 0x00020005,
+        Config10 = 0x00020006,
+        Config11 = 0x92220007,
+        Config12 = 0x92220008,
+    };
+
     void SetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
-        const auto mode = rp.PopEnum<PerformanceMode>();
-        const auto config = rp.PopEnum<PerformanceConfiguration>();
-        LOG_DEBUG(Service_APM, "called mode={} config={}", static_cast<u32>(mode),
-                  static_cast<u32>(config));
-
-        controller.SetPerformanceConfiguration(mode, config);
+        auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
+        u32 config = rp.Pop<u32>();
+        LOG_WARNING(Service_APM, "(STUBBED) called mode={} config={}", static_cast<u32>(mode),
+                    config);
 
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(RESULT_SUCCESS);
@@ -39,23 +50,20 @@ private:
     void GetPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
 
-        const auto mode = rp.PopEnum<PerformanceMode>();
-        LOG_DEBUG(Service_APM, "called mode={}", static_cast<u32>(mode));
+        auto mode = static_cast<PerformanceMode>(rp.Pop<u32>());
+        LOG_WARNING(Service_APM, "(STUBBED) called mode={}", static_cast<u32>(mode));
 
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(RESULT_SUCCESS);
-        rb.PushEnum(controller.GetCurrentPerformanceConfiguration(mode));
+        rb.Push<u32>(static_cast<u32>(PerformanceConfiguration::Config1));
     }
-
-    Controller& controller;
 };
 
-APM::APM(std::shared_ptr<Module> apm, Controller& controller, const char* name)
-    : ServiceFramework(name), apm(std::move(apm)), controller(controller) {
+APM::APM(std::shared_ptr<Module> apm, const char* name)
+    : ServiceFramework(name), apm(std::move(apm)) {
     static const FunctionInfo functions[] = {
         {0, &APM::OpenSession, "OpenSession"},
-        {1, &APM::GetPerformanceMode, "GetPerformanceMode"},
-        {6, nullptr, "IsCpuOverclockEnabled"},
+        {1, nullptr, "GetPerformanceMode"},
     };
     RegisterHandlers(functions);
 }
@@ -67,17 +75,10 @@ void APM::OpenSession(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISession>(controller);
+    rb.PushIpcInterface<ISession>();
 }
 
-void APM::GetPerformanceMode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_APM, "called");
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.PushEnum(controller.GetCurrentPerformanceMode());
-}
-
-APM_Sys::APM_Sys(Controller& controller) : ServiceFramework{"apm:sys"}, controller(controller) {
+APM_Sys::APM_Sys() : ServiceFramework{"apm:sys"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "RequestPerformanceMode"},
@@ -86,8 +87,8 @@ APM_Sys::APM_Sys(Controller& controller) : ServiceFramework{"apm:sys"}, controll
         {3, nullptr, "GetLastThrottlingState"},
         {4, nullptr, "ClearLastThrottlingState"},
         {5, nullptr, "LoadAndApplySettings"},
-        {6, &APM_Sys::SetCpuBoostMode, "SetCpuBoostMode"},
-        {7, &APM_Sys::GetCurrentPerformanceConfiguration, "GetCurrentPerformanceConfiguration"},
+        {6, nullptr, "SetCpuBoostMode"},
+        {7, nullptr, "GetCurrentPerformanceConfiguration"},
     };
     // clang-format on
 
@@ -101,28 +102,7 @@ void APM_Sys::GetPerformanceEvent(Kernel::HLERequestContext& ctx) {
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<ISession>(controller);
-}
-
-void APM_Sys::SetCpuBoostMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto mode = rp.PopEnum<CpuBoostMode>();
-
-    LOG_DEBUG(Service_APM, "called, mode={:08X}", static_cast<u32>(mode));
-
-    controller.SetFromCpuBoostMode(mode);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void APM_Sys::GetCurrentPerformanceConfiguration(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_APM, "called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(
-        controller.GetCurrentPerformanceConfiguration(controller.GetCurrentPerformanceMode()));
+    rb.PushIpcInterface<ISession>();
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/interface.h

@@ -8,34 +8,24 @@
 
 namespace Service::APM {
 
-class Controller;
-class Module;
-
 class APM final : public ServiceFramework<APM> {
 public:
-    explicit APM(std::shared_ptr<Module> apm, Controller& controller, const char* name);
+    explicit APM(std::shared_ptr<Module> apm, const char* name);
     ~APM() override;
 
 private:
     void OpenSession(Kernel::HLERequestContext& ctx);
-    void GetPerformanceMode(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<Module> apm;
-    Controller& controller;
 };
 
 class APM_Sys final : public ServiceFramework<APM_Sys> {
 public:
-    explicit APM_Sys(Controller& controller);
+    explicit APM_Sys();
     ~APM_Sys() override;
 
-    void SetCpuBoostMode(Kernel::HLERequestContext& ctx);
-
 private:
     void GetPerformanceEvent(Kernel::HLERequestContext& ctx);
-    void GetCurrentPerformanceConfiguration(Kernel::HLERequestContext& ctx);
-
-    Controller& controller;
 };
 
 } // namespace Service::APM

src/core/hle/service/filesystem/filesystem.cpp

@@ -472,12 +472,12 @@ void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite) {
     }
 }
 
-void InstallInterfaces(Core::System& system) {
+void InstallInterfaces(SM::ServiceManager& service_manager, FileSys::VfsFilesystem& vfs) {
     romfs_factory = nullptr;
-    CreateFactories(*system.GetFilesystem(), false);
-    std::make_shared<FSP_LDR>()->InstallAsService(system.ServiceManager());
-    std::make_shared<FSP_PR>()->InstallAsService(system.ServiceManager());
-    std::make_shared<FSP_SRV>(system.GetReporter())->InstallAsService(system.ServiceManager());
+    CreateFactories(vfs, false);
+    std::make_shared<FSP_LDR>()->InstallAsService(service_manager);
+    std::make_shared<FSP_PR>()->InstallAsService(service_manager);
+    std::make_shared<FSP_SRV>()->InstallAsService(service_manager);
 }
 
 } // namespace Service::FileSystem

src/core/hle/service/filesystem/filesystem.h

@@ -65,7 +65,7 @@ FileSys::VirtualDir GetModificationDumpRoot(u64 title_id);
 // above is called.
 void CreateFactories(FileSys::VfsFilesystem& vfs, bool overwrite = true);
 
-void InstallInterfaces(Core::System& system);
+void InstallInterfaces(SM::ServiceManager& service_manager, FileSys::VfsFilesystem& vfs);
 
 // A class that wraps a VfsDirectory with methods that return ResultVal and ResultCode instead of
 // pointers and booleans. This makes using a VfsDirectory with switch services much easier and

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -26,7 +26,6 @@
 #include "core/hle/kernel/process.h"
 #include "core/hle/service/filesystem/filesystem.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
-#include "core/reporter.h"
 
 namespace Service::FileSystem {
 
@@ -614,7 +613,7 @@ private:
     u64 next_entry_index = 0;
 };
 
-FSP_SRV::FSP_SRV(const Core::Reporter& reporter) : ServiceFramework("fsp-srv"), reporter(reporter) {
+FSP_SRV::FSP_SRV() : ServiceFramework("fsp-srv") {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, nullptr, "OpenFileSystem"},
@@ -711,14 +710,14 @@ FSP_SRV::FSP_SRV(const Core::Reporter& reporter) : ServiceFramework("fsp-srv"),
         {1001, nullptr, "SetSaveDataSize"},
         {1002, nullptr, "SetSaveDataRootPath"},
         {1003, nullptr, "DisableAutoSaveDataCreation"},
-        {1004, &FSP_SRV::SetGlobalAccessLogMode, "SetGlobalAccessLogMode"},
+        {1004, nullptr, "SetGlobalAccessLogMode"},
         {1005, &FSP_SRV::GetGlobalAccessLogMode, "GetGlobalAccessLogMode"},
-        {1006, &FSP_SRV::OutputAccessLogToSdCard, "OutputAccessLogToSdCard"},
+        {1006, nullptr, "OutputAccessLogToSdCard"},
         {1007, nullptr, "RegisterUpdatePartition"},
         {1008, nullptr, "OpenRegisteredUpdatePartition"},
         {1009, nullptr, "GetAndClearMemoryReportInfo"},
         {1010, nullptr, "SetDataStorageRedirectTarget"},
-        {1011, &FSP_SRV::GetAccessLogVersionInfo, "GetAccessLogVersionInfo"},
+        {1011, nullptr, "OutputAccessLogToSdCard2"},
         {1100, nullptr, "OverrideSaveDataTransferTokenSignVerificationKey"},
         {1110, nullptr, "CorruptSaveDataFileSystemBySaveDataSpaceId2"},
         {1200, nullptr, "OpenMultiCommitManager"},
@@ -815,22 +814,21 @@ void FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext&
     rb.PushIpcInterface<ISaveDataInfoReader>(std::make_shared<ISaveDataInfoReader>(space));
 }
 
-void FSP_SRV::SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    log_mode = rp.PopEnum<LogMode>();
-
-    LOG_DEBUG(Service_FS, "called, log_mode={:08X}", static_cast<u32>(log_mode));
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
 void FSP_SRV::GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_FS, "called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
 
+    enum class LogMode : u32 {
+        Off,
+        Log,
+        RedirectToSdCard,
+        LogToSdCard = Log | RedirectToSdCard,
+    };
+
+    // Given we always want to receive logging information,
+    // we always specify logging as enabled.
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(log_mode);
+    rb.PushEnum(LogMode::Log);
 }
 
 void FSP_SRV::OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx) {
@@ -904,26 +902,4 @@ void FSP_SRV::OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ct
     rb.Push(FileSys::ERROR_ENTITY_NOT_FOUND);
 }
 
-void FSP_SRV::OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx) {
-    const auto raw = ctx.ReadBuffer();
-    auto log = Common::StringFromFixedZeroTerminatedBuffer(
-        reinterpret_cast<const char*>(raw.data()), raw.size());
-
-    LOG_DEBUG(Service_FS, "called, log='{}'", log);
-
-    reporter.SaveFilesystemAccessReport(log_mode, std::move(log));
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void FSP_SRV::GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_FS, "called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushEnum(AccessLogVersion::Latest);
-    rb.Push(access_log_program_index);
-}
-
 } // namespace Service::FileSystem

src/core/hle/service/filesystem/fsp_srv.h

@@ -7,32 +7,15 @@
 #include <memory>
 #include "core/hle/service/service.h"
 
-namespace Core {
-class Reporter;
-}
-
 namespace FileSys {
 class FileSystemBackend;
 }
 
 namespace Service::FileSystem {
 
-enum class AccessLogVersion : u32 {
-    V7_0_0 = 2,
-
-    Latest = V7_0_0,
-};
-
-enum class LogMode : u32 {
-    Off,
-    Log,
-    RedirectToSdCard,
-    LogToSdCard = Log | RedirectToSdCard,
-};
-
 class FSP_SRV final : public ServiceFramework<FSP_SRV> {
 public:
-    explicit FSP_SRV(const Core::Reporter& reporter);
+    explicit FSP_SRV();
     ~FSP_SRV() override;
 
 private:
@@ -43,20 +26,13 @@ private:
     void OpenSaveDataFileSystem(Kernel::HLERequestContext& ctx);
     void OpenReadOnlySaveDataFileSystem(Kernel::HLERequestContext& ctx);
     void OpenSaveDataInfoReaderBySaveDataSpaceId(Kernel::HLERequestContext& ctx);
-    void SetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void GetGlobalAccessLogMode(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
     void OpenDataStorageByDataId(Kernel::HLERequestContext& ctx);
     void OpenPatchDataStorageByCurrentProcess(Kernel::HLERequestContext& ctx);
-    void OutputAccessLogToSdCard(Kernel::HLERequestContext& ctx);
-    void GetAccessLogVersionInfo(Kernel::HLERequestContext& ctx);
 
     FileSys::VirtualFile romfs;
     u64 current_process_id = 0;
-    u32 access_log_program_index = 0;
-    LogMode log_mode = LogMode::LogToSdCard;
-
-    const Core::Reporter& reporter;
 };
 
 } // namespace Service::FileSystem

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

@@ -548,37 +548,6 @@ void Controller_NPad::DisconnectNPad(u32 npad_id) {
     connected_controllers[NPadIdToIndex(npad_id)].is_connected = false;
 }
 
-void Controller_NPad::StartLRAssignmentMode() {
-    // Nothing internally is used for lr assignment mode. Since we have the ability to set the
-    // controller types from boot, it doesn't really matter about showing a selection screen
-    is_in_lr_assignment_mode = true;
-}
-
-void Controller_NPad::StopLRAssignmentMode() {
-    is_in_lr_assignment_mode = false;
-}
-
-bool Controller_NPad::SwapNpadAssignment(u32 npad_id_1, u32 npad_id_2) {
-    if (npad_id_1 == NPAD_HANDHELD || npad_id_2 == NPAD_HANDHELD || npad_id_1 == NPAD_UNKNOWN ||
-        npad_id_2 == NPAD_UNKNOWN) {
-        return true;
-    }
-    const auto npad_index_1 = NPadIdToIndex(npad_id_1);
-    const auto npad_index_2 = NPadIdToIndex(npad_id_2);
-
-    if (!IsControllerSupported(connected_controllers[npad_index_1].type) ||
-        !IsControllerSupported(connected_controllers[npad_index_2].type)) {
-        return false;
-    }
-
-    std::swap(connected_controllers[npad_index_1].type, connected_controllers[npad_index_2].type);
-
-    InitNewlyAddedControler(npad_index_1);
-    InitNewlyAddedControler(npad_index_2);
-
-    return true;
-}
-
 bool Controller_NPad::IsControllerSupported(NPadControllerType controller) {
     if (controller == NPadControllerType::Handheld) {
         // Handheld is not even a supported type, lets stop here

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

@@ -124,10 +124,6 @@ public:
     void ConnectAllDisconnectedControllers();
     void ClearAllControllers();
 
-    void StartLRAssignmentMode();
-    void StopLRAssignmentMode();
-    bool SwapNpadAssignment(u32 npad_id_1, u32 npad_id_2);
-
     // Logical OR for all buttons presses on all controllers
     // Specifically for cheat engine and other features.
     u32 GetAndResetPressState();
@@ -325,6 +321,5 @@ private:
     void RequestPadStateUpdate(u32 npad_id);
     std::array<ControllerPad, 10> npad_pad_states{};
     bool IsControllerSupported(NPadControllerType controller);
-    bool is_in_lr_assignment_mode{false};
 };
 } // namespace Service::HID

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

@@ -1,13 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::HID {
-
-constexpr ResultCode ERR_NPAD_NOT_CONNECTED{ErrorModule::HID, 710};
-
-} // namespace Service::HID

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

@@ -16,7 +16,6 @@
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/shared_memory.h"
 #include "core/hle/kernel/writable_event.h"
-#include "core/hle/service/hid/errors.h"
 #include "core/hle/service/hid/hid.h"
 #include "core/hle/service/hid/irs.h"
 #include "core/hle/service/hid/xcd.h"
@@ -203,11 +202,11 @@ Hid::Hid() : ServiceFramework("hid") {
         {123, nullptr, "SetNpadJoyAssignmentModeSingleByDefault"},
         {124, &Hid::SetNpadJoyAssignmentModeDual, "SetNpadJoyAssignmentModeDual"},
         {125, &Hid::MergeSingleJoyAsDualJoy, "MergeSingleJoyAsDualJoy"},
-        {126, &Hid::StartLrAssignmentMode, "StartLrAssignmentMode"},
-        {127, &Hid::StopLrAssignmentMode, "StopLrAssignmentMode"},
+        {126, nullptr, "StartLrAssignmentMode"},
+        {127, nullptr, "StopLrAssignmentMode"},
         {128, &Hid::SetNpadHandheldActivationMode, "SetNpadHandheldActivationMode"},
         {129, nullptr, "GetNpadHandheldActivationMode"},
-        {130, &Hid::SwapNpadAssignment, "SwapNpadAssignment"},
+        {130, nullptr, "SwapNpadAssignment"},
         {131, nullptr, "IsUnintendedHomeButtonInputProtectionEnabled"},
         {132, nullptr, "EnableUnintendedHomeButtonInputProtection"},
         {133, nullptr, "SetNpadJoyAssignmentModeSingleWithDestination"},
@@ -734,49 +733,6 @@ void Hid::SetPalmaBoostMode(Kernel::HLERequestContext& ctx) {
     rb.Push(RESULT_SUCCESS);
 }
 
-void Hid::StartLrAssignmentMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-    controller.StartLRAssignmentMode();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::StopLrAssignmentMode(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
-    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-    controller.StopLRAssignmentMode();
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::SwapNpadAssignment(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto npad_1{rp.Pop<u32>()};
-    const auto npad_2{rp.Pop<u32>()};
-    const auto applet_resource_user_id{rp.Pop<u64>()};
-
-    LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}, npad_1={}, npad_2={}",
-              applet_resource_user_id, npad_1, npad_2);
-
-    auto& controller = applet_resource->GetController<Controller_NPad>(HidController::NPad);
-    IPC::ResponseBuilder rb{ctx, 2};
-    if (controller.SwapNpadAssignment(npad_1, npad_2)) {
-        rb.Push(RESULT_SUCCESS);
-    } else {
-        LOG_ERROR(Service_HID, "Npads are not connected!");
-        rb.Push(ERR_NPAD_NOT_CONNECTED);
-    }
-}
-
 class HidDbg final : public ServiceFramework<HidDbg> {
 public:
     explicit HidDbg() : ServiceFramework{"hid:dbg"} {

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

@@ -119,9 +119,6 @@ private:
     void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
     void SetIsPalmaAllConnectable(Kernel::HLERequestContext& ctx);
     void SetPalmaBoostMode(Kernel::HLERequestContext& ctx);
-    void StartLrAssignmentMode(Kernel::HLERequestContext& ctx);
-    void StopLrAssignmentMode(Kernel::HLERequestContext& ctx);
-    void SwapNpadAssignment(Kernel::HLERequestContext& ctx);
 
     std::shared_ptr<IAppletResource> applet_resource;
 };

src/core/hle/service/service.cpp

@@ -195,7 +195,8 @@ ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::HLERequestContext& co
 // Module interface
 
 /// Initialize ServiceManager
-void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
+void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system,
+          FileSys::VfsFilesystem& vfs) {
     // 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.CoreTiming());
@@ -205,7 +206,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     Account::InstallInterfaces(system);
     AM::InstallInterfaces(*sm, nv_flinger, system);
     AOC::InstallInterfaces(*sm);
-    APM::InstallInterfaces(system);
+    APM::InstallInterfaces(*sm);
     Audio::InstallInterfaces(*sm);
     BCAT::InstallInterfaces(*sm);
     BPC::InstallInterfaces(*sm);
@@ -217,7 +218,7 @@ void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system) {
     EUPLD::InstallInterfaces(*sm);
     Fatal::InstallInterfaces(*sm);
     FGM::InstallInterfaces(*sm);
-    FileSystem::InstallInterfaces(system);
+    FileSystem::InstallInterfaces(*sm, vfs);
     Friend::InstallInterfaces(*sm);
     Glue::InstallInterfaces(system);
     GRC::InstallInterfaces(*sm);

src/core/hle/service/service.h

@@ -182,7 +182,8 @@ private:
 };
 
 /// Initialize ServiceManager
-void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system);
+void Init(std::shared_ptr<SM::ServiceManager>& sm, Core::System& system,
+          FileSys::VfsFilesystem& vfs);
 
 /// Shutdown ServiceManager
 void Shutdown();

src/core/reporter.cpp

@@ -350,24 +350,6 @@ void Reporter::SaveErrorReport(u64 title_id, ResultCode result,
     SaveToFile(std::move(out), GetPath("error_report", title_id, timestamp));
 }
 
-void Reporter::SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
-                                          std::string log_message) const {
-    if (!IsReportingEnabled())
-        return;
-
-    const auto timestamp = GetTimestamp();
-    const auto title_id = system.CurrentProcess()->GetTitleID();
-    json out;
-
-    out["yuzu_version"] = GetYuzuVersionData();
-    out["report_common"] = GetReportCommonData(title_id, RESULT_SUCCESS, timestamp);
-
-    out["log_mode"] = fmt::format("{:08X}", static_cast<u32>(log_mode));
-    out["log_message"] = std::move(log_message);
-
-    SaveToFile(std::move(out), GetPath("filesystem_access_report", title_id, timestamp));
-}
-
 void Reporter::SaveUserReport() const {
     if (!IsReportingEnabled()) {
         return;

src/core/reporter.h

@@ -16,10 +16,6 @@ namespace Kernel {
 class HLERequestContext;
 } // namespace Kernel
 
-namespace Service::FileSystem {
-enum class LogMode : u32;
-}
-
 namespace Core {
 
 class System;
@@ -53,9 +49,6 @@ public:
                          std::optional<std::string> custom_text_main = {},
                          std::optional<std::string> custom_text_detail = {}) const;
 
-    void SaveFilesystemAccessReport(Service::FileSystem::LogMode log_mode,
-                                    std::string log_message) const;
-
     void SaveUserReport() const;
 
 private:

src/video_core/CMakeLists.txt

@@ -103,8 +103,6 @@ add_library(video_core STATIC
     shader/decode/video.cpp
     shader/decode/xmad.cpp
     shader/decode/other.cpp
-    shader/control_flow.cpp
-    shader/control_flow.h
     shader/decode.cpp
     shader/node_helper.cpp
     shader/node_helper.h

src/video_core/engines/shader_bytecode.h

@@ -1367,20 +1367,6 @@ union Instruction {
         }
     } bra;
 
-    union {
-        BitField<20, 24, u64> target;
-        BitField<5, 1, u64> constant_buffer;
-
-        s32 GetBranchExtend() const {
-            // Sign extend the branch target offset
-            u32 mask = 1U << (24 - 1);
-            u32 value = static_cast<u32>(target);
-            // The branch offset is relative to the next instruction and is stored in bytes, so
-            // divide it by the size of an instruction and add 1 to it.
-            return static_cast<s32>((value ^ mask) - mask) / sizeof(Instruction) + 1;
-        }
-    } brx;
-
     union {
         BitField<39, 1, u64> emit; // EmitVertex
         BitField<40, 1, u64> cut;  // EndPrimitive
@@ -1478,7 +1464,6 @@ public:
         BFE_IMM,
         BFI_IMM_R,
         BRA,
-        BRX,
         PBK,
         LD_A,
         LD_L,
@@ -1753,7 +1738,6 @@ private:
             INST("111000101001----", Id::SSY, Type::Flow, "SSY"),
             INST("111000101010----", Id::PBK, Type::Flow, "PBK"),
             INST("111000100100----", Id::BRA, Type::Flow, "BRA"),
-            INST("111000100101----", Id::BRX, Type::Flow, "BRX"),
             INST("1111000011111---", Id::SYNC, Type::Flow, "SYNC"),
             INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
             INST("111000110000----", Id::EXIT, Type::Flow, "EXIT"),

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -129,11 +129,9 @@ std::size_t CalculateProgramSize(const GLShader::ProgramCode& program) {
 
 /// Hashes one (or two) program streams
 u64 GetUniqueIdentifier(Maxwell::ShaderProgram program_type, const ProgramCode& code,
-                        const ProgramCode& code_b, std::size_t size_a = 0, std::size_t size_b = 0) {
-    if (size_a == 0) {
-        size_a = CalculateProgramSize(code);
-    }
-    u64 unique_identifier = Common::CityHash64(reinterpret_cast<const char*>(code.data()), size_a);
+                        const ProgramCode& code_b) {
+    u64 unique_identifier =
+        Common::CityHash64(reinterpret_cast<const char*>(code.data()), CalculateProgramSize(code));
     if (program_type != Maxwell::ShaderProgram::VertexA) {
         return unique_identifier;
     }
@@ -142,11 +140,8 @@ u64 GetUniqueIdentifier(Maxwell::ShaderProgram program_type, const ProgramCode&
     std::size_t seed = 0;
     boost::hash_combine(seed, unique_identifier);
 
-    if (size_b == 0) {
-        size_b = CalculateProgramSize(code_b);
-    }
-    const u64 identifier_b =
-        Common::CityHash64(reinterpret_cast<const char*>(code_b.data()), size_b);
+    const u64 identifier_b = Common::CityHash64(reinterpret_cast<const char*>(code_b.data()),
+                                                CalculateProgramSize(code_b));
     boost::hash_combine(seed, identifier_b);
     return static_cast<u64>(seed);
 }
@@ -155,17 +150,14 @@ u64 GetUniqueIdentifier(Maxwell::ShaderProgram program_type, const ProgramCode&
 GLShader::ProgramResult CreateProgram(const Device& device, Maxwell::ShaderProgram program_type,
                                       ProgramCode program_code, ProgramCode program_code_b) {
     GLShader::ShaderSetup setup(program_code);
-    setup.program.size_a = CalculateProgramSize(program_code);
-    setup.program.size_b = 0;
     if (program_type == Maxwell::ShaderProgram::VertexA) {
         // VertexB is always enabled, so when VertexA is enabled, we have two vertex shaders.
         // Conventional HW does not support this, so we combine VertexA and VertexB into one
         // stage here.
         setup.SetProgramB(program_code_b);
-        setup.program.size_b = CalculateProgramSize(program_code_b);
     }
-    setup.program.unique_identifier = GetUniqueIdentifier(
-        program_type, program_code, program_code_b, setup.program.size_a, setup.program.size_b);
+    setup.program.unique_identifier =
+        GetUniqueIdentifier(program_type, program_code, program_code_b);
 
     switch (program_type) {
     case Maxwell::ShaderProgram::VertexA:

src/video_core/renderer_opengl/gl_shader_decompiler.cpp

@@ -191,12 +191,10 @@ public:
 
         // TODO(Subv): Figure out the actual depth of the flow stack, for now it seems
         // unlikely that shaders will use 20 nested SSYs and PBKs.
-        if (!ir.IsFlowStackDisabled()) {
-            constexpr u32 FLOW_STACK_SIZE = 20;
-            for (const auto stack : std::array{MetaStackClass::Ssy, MetaStackClass::Pbk}) {
-                code.AddLine("uint {}[{}];", FlowStackName(stack), FLOW_STACK_SIZE);
-                code.AddLine("uint {} = 0u;", FlowStackTopName(stack));
-            }
+        constexpr u32 FLOW_STACK_SIZE = 20;
+        for (const auto stack : std::array{MetaStackClass::Ssy, MetaStackClass::Pbk}) {
+            code.AddLine("uint {}[{}];", FlowStackName(stack), FLOW_STACK_SIZE);
+            code.AddLine("uint {} = 0u;", FlowStackTopName(stack));
         }
 
         code.AddLine("while (true) {{");
@@ -1557,14 +1555,6 @@ private:
         return {};
     }
 
-    std::string BranchIndirect(Operation operation) {
-        const std::string op_a = VisitOperand(operation, 0, Type::Uint);
-
-        code.AddLine("jmp_to = {};", op_a);
-        code.AddLine("break;");
-        return {};
-    }
-
     std::string PushFlowStack(Operation operation) {
         const auto stack = std::get<MetaStackClass>(operation.GetMeta());
         const auto target = std::get_if<ImmediateNode>(&*operation[0]);
@@ -1799,7 +1789,6 @@ private:
         &GLSLDecompiler::ImageStore,
 
         &GLSLDecompiler::Branch,
-        &GLSLDecompiler::BranchIndirect,
         &GLSLDecompiler::PushFlowStack,
         &GLSLDecompiler::PopFlowStack,
         &GLSLDecompiler::Exit,

src/video_core/renderer_opengl/gl_shader_gen.cpp

@@ -29,14 +29,14 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform vs_config {
 };
 
 )";
-    const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET, setup.program.size_a);
+    const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
     ProgramResult program =
         Decompile(device, program_ir, Maxwell3D::Regs::ShaderStage::Vertex, "vertex");
 
     out += program.first;
 
     if (setup.IsDualProgram()) {
-        const ShaderIR program_ir_b(setup.program.code_b, PROGRAM_OFFSET, setup.program.size_b);
+        const ShaderIR program_ir_b(setup.program.code_b, PROGRAM_OFFSET);
         ProgramResult program_b =
             Decompile(device, program_ir_b, Maxwell3D::Regs::ShaderStage::Vertex, "vertex_b");
 
@@ -80,7 +80,7 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform gs_config {
 };
 
 )";
-    const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET, setup.program.size_a);
+    const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
     ProgramResult program =
         Decompile(device, program_ir, Maxwell3D::Regs::ShaderStage::Geometry, "geometry");
     out += program.first;
@@ -115,7 +115,7 @@ layout (std140, binding = EMULATION_UBO_BINDING) uniform fs_config {
 };
 
 )";
-    const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET, setup.program.size_a);
+    const ShaderIR program_ir(setup.program.code, PROGRAM_OFFSET);
     ProgramResult program =
         Decompile(device, program_ir, Maxwell3D::Regs::ShaderStage::Fragment, "fragment");
 

src/video_core/renderer_opengl/gl_shader_gen.h

@@ -27,8 +27,6 @@ struct ShaderSetup {
         ProgramCode code;
         ProgramCode code_b; // Used for dual vertex shaders
         u64 unique_identifier;
-        std::size_t size_a;
-        std::size_t size_b;
     } program;
 
     /// Used in scenarios where we have a dual vertex shaders

src/video_core/renderer_vulkan/vk_shader_decompiler.cpp

@@ -949,14 +949,6 @@ private:
         return {};
     }
 
-    Id BranchIndirect(Operation operation) {
-        const Id op_a = VisitOperand<Type::Uint>(operation, 0);
-
-        Emit(OpStore(jmp_to, op_a));
-        BranchingOp([&]() { Emit(OpBranch(continue_label)); });
-        return {};
-    }
-
     Id PushFlowStack(Operation operation) {
         const auto target = std::get_if<ImmediateNode>(&*operation[0]);
         ASSERT(target);
@@ -1342,7 +1334,6 @@ private:
         &SPIRVDecompiler::ImageStore,
 
         &SPIRVDecompiler::Branch,
-        &SPIRVDecompiler::BranchIndirect,
         &SPIRVDecompiler::PushFlowStack,
         &SPIRVDecompiler::PopFlowStack,
         &SPIRVDecompiler::Exit,

src/video_core/shader/control_flow.cpp

@@ -1,476 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <list>
-#include <map>
-#include <stack>
-#include <unordered_map>
-#include <unordered_set>
-#include <vector>
-
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "video_core/shader/control_flow.h"
-#include "video_core/shader/shader_ir.h"
-
-namespace VideoCommon::Shader {
-
-using Tegra::Shader::Instruction;
-using Tegra::Shader::OpCode;
-
-constexpr s32 unassigned_branch = -2;
-
-struct Query {
-    u32 address{};
-    std::stack<u32> ssy_stack{};
-    std::stack<u32> pbk_stack{};
-};
-
-struct BlockStack {
-    BlockStack() = default;
-    BlockStack(const BlockStack& b) = default;
-    BlockStack(const Query& q) : ssy_stack{q.ssy_stack}, pbk_stack{q.pbk_stack} {}
-    std::stack<u32> ssy_stack{};
-    std::stack<u32> pbk_stack{};
-};
-
-struct BlockBranchInfo {
-    Condition condition{};
-    s32 address{exit_branch};
-    bool kill{};
-    bool is_sync{};
-    bool is_brk{};
-    bool ignore{};
-};
-
-struct BlockInfo {
-    u32 start{};
-    u32 end{};
-    bool visited{};
-    BlockBranchInfo branch{};
-
-    bool IsInside(const u32 address) const {
-        return start <= address && address <= end;
-    }
-};
-
-struct CFGRebuildState {
-    explicit CFGRebuildState(const ProgramCode& program_code, const std::size_t program_size,
-                             const u32 start)
-        : program_code{program_code}, program_size{program_size}, start{start} {}
-
-    u32 start{};
-    std::vector<BlockInfo> block_info{};
-    std::list<u32> inspect_queries{};
-    std::list<Query> queries{};
-    std::unordered_map<u32, u32> registered{};
-    std::unordered_set<u32> labels{};
-    std::map<u32, u32> ssy_labels{};
-    std::map<u32, u32> pbk_labels{};
-    std::unordered_map<u32, BlockStack> stacks{};
-    const ProgramCode& program_code;
-    const std::size_t program_size;
-};
-
-enum class BlockCollision : u32 { None, Found, Inside };
-
-std::pair<BlockCollision, u32> TryGetBlock(CFGRebuildState& state, u32 address) {
-    const auto& blocks = state.block_info;
-    for (u32 index = 0; index < blocks.size(); index++) {
-        if (blocks[index].start == address) {
-            return {BlockCollision::Found, index};
-        }
-        if (blocks[index].IsInside(address)) {
-            return {BlockCollision::Inside, index};
-        }
-    }
-    return {BlockCollision::None, -1};
-}
-
-struct ParseInfo {
-    BlockBranchInfo branch_info{};
-    u32 end_address{};
-};
-
-BlockInfo& CreateBlockInfo(CFGRebuildState& state, u32 start, u32 end) {
-    auto& it = state.block_info.emplace_back();
-    it.start = start;
-    it.end = end;
-    const u32 index = static_cast<u32>(state.block_info.size() - 1);
-    state.registered.insert({start, index});
-    return it;
-}
-
-Pred GetPredicate(u32 index, bool negated) {
-    return static_cast<Pred>(index + (negated ? 8 : 0));
-}
-
-/**
- * Returns whether the instruction at the specified offset is a 'sched' instruction.
- * Sched instructions always appear before a sequence of 3 instructions.
- */
-constexpr bool IsSchedInstruction(u32 offset, u32 main_offset) {
-    constexpr u32 SchedPeriod = 4;
-    u32 absolute_offset = offset - main_offset;
-
-    return (absolute_offset % SchedPeriod) == 0;
-}
-
-enum class ParseResult : u32 {
-    ControlCaught,
-    BlockEnd,
-    AbnormalFlow,
-};
-
-std::pair<ParseResult, ParseInfo> ParseCode(CFGRebuildState& state, u32 address) {
-    u32 offset = static_cast<u32>(address);
-    const u32 end_address = static_cast<u32>(state.program_size / sizeof(Instruction));
-    ParseInfo parse_info{};
-
-    const auto insert_label = [](CFGRebuildState& state, u32 address) {
-        const auto pair = state.labels.emplace(address);
-        if (pair.second) {
-            state.inspect_queries.push_back(address);
-        }
-    };
-
-    while (true) {
-        if (offset >= end_address) {
-            // ASSERT_OR_EXECUTE can't be used, as it ignores the break
-            ASSERT_MSG(false, "Shader passed the current limit!");
-            parse_info.branch_info.address = exit_branch;
-            parse_info.branch_info.ignore = false;
-            break;
-        }
-        if (state.registered.count(offset) != 0) {
-            parse_info.branch_info.address = offset;
-            parse_info.branch_info.ignore = true;
-            break;
-        }
-        if (IsSchedInstruction(offset, state.start)) {
-            offset++;
-            continue;
-        }
-        const Instruction instr = {state.program_code[offset]};
-        const auto opcode = OpCode::Decode(instr);
-        if (!opcode || opcode->get().GetType() != OpCode::Type::Flow) {
-            offset++;
-            continue;
-        }
-
-        switch (opcode->get().GetId()) {
-        case OpCode::Id::EXIT: {
-            const auto pred_index = static_cast<u32>(instr.pred.pred_index);
-            parse_info.branch_info.condition.predicate =
-                GetPredicate(pred_index, instr.negate_pred != 0);
-            if (parse_info.branch_info.condition.predicate == Pred::NeverExecute) {
-                offset++;
-                continue;
-            }
-            const ConditionCode cc = instr.flow_condition_code;
-            parse_info.branch_info.condition.cc = cc;
-            if (cc == ConditionCode::F) {
-                offset++;
-                continue;
-            }
-            parse_info.branch_info.address = exit_branch;
-            parse_info.branch_info.kill = false;
-            parse_info.branch_info.is_sync = false;
-            parse_info.branch_info.is_brk = false;
-            parse_info.branch_info.ignore = false;
-            parse_info.end_address = offset;
-
-            return {ParseResult::ControlCaught, parse_info};
-        }
-        case OpCode::Id::BRA: {
-            if (instr.bra.constant_buffer != 0) {
-                return {ParseResult::AbnormalFlow, parse_info};
-            }
-            const auto pred_index = static_cast<u32>(instr.pred.pred_index);
-            parse_info.branch_info.condition.predicate =
-                GetPredicate(pred_index, instr.negate_pred != 0);
-            if (parse_info.branch_info.condition.predicate == Pred::NeverExecute) {
-                offset++;
-                continue;
-            }
-            const ConditionCode cc = instr.flow_condition_code;
-            parse_info.branch_info.condition.cc = cc;
-            if (cc == ConditionCode::F) {
-                offset++;
-                continue;
-            }
-            const u32 branch_offset = offset + instr.bra.GetBranchTarget();
-            if (branch_offset == 0) {
-                parse_info.branch_info.address = exit_branch;
-            } else {
-                parse_info.branch_info.address = branch_offset;
-            }
-            insert_label(state, branch_offset);
-            parse_info.branch_info.kill = false;
-            parse_info.branch_info.is_sync = false;
-            parse_info.branch_info.is_brk = false;
-            parse_info.branch_info.ignore = false;
-            parse_info.end_address = offset;
-
-            return {ParseResult::ControlCaught, parse_info};
-        }
-        case OpCode::Id::SYNC: {
-            const auto pred_index = static_cast<u32>(instr.pred.pred_index);
-            parse_info.branch_info.condition.predicate =
-                GetPredicate(pred_index, instr.negate_pred != 0);
-            if (parse_info.branch_info.condition.predicate == Pred::NeverExecute) {
-                offset++;
-                continue;
-            }
-            const ConditionCode cc = instr.flow_condition_code;
-            parse_info.branch_info.condition.cc = cc;
-            if (cc == ConditionCode::F) {
-                offset++;
-                continue;
-            }
-            parse_info.branch_info.address = unassigned_branch;
-            parse_info.branch_info.kill = false;
-            parse_info.branch_info.is_sync = true;
-            parse_info.branch_info.is_brk = false;
-            parse_info.branch_info.ignore = false;
-            parse_info.end_address = offset;
-
-            return {ParseResult::ControlCaught, parse_info};
-        }
-        case OpCode::Id::BRK: {
-            const auto pred_index = static_cast<u32>(instr.pred.pred_index);
-            parse_info.branch_info.condition.predicate =
-                GetPredicate(pred_index, instr.negate_pred != 0);
-            if (parse_info.branch_info.condition.predicate == Pred::NeverExecute) {
-                offset++;
-                continue;
-            }
-            const ConditionCode cc = instr.flow_condition_code;
-            parse_info.branch_info.condition.cc = cc;
-            if (cc == ConditionCode::F) {
-                offset++;
-                continue;
-            }
-            parse_info.branch_info.address = unassigned_branch;
-            parse_info.branch_info.kill = false;
-            parse_info.branch_info.is_sync = false;
-            parse_info.branch_info.is_brk = true;
-            parse_info.branch_info.ignore = false;
-            parse_info.end_address = offset;
-
-            return {ParseResult::ControlCaught, parse_info};
-        }
-        case OpCode::Id::KIL: {
-            const auto pred_index = static_cast<u32>(instr.pred.pred_index);
-            parse_info.branch_info.condition.predicate =
-                GetPredicate(pred_index, instr.negate_pred != 0);
-            if (parse_info.branch_info.condition.predicate == Pred::NeverExecute) {
-                offset++;
-                continue;
-            }
-            const ConditionCode cc = instr.flow_condition_code;
-            parse_info.branch_info.condition.cc = cc;
-            if (cc == ConditionCode::F) {
-                offset++;
-                continue;
-            }
-            parse_info.branch_info.address = exit_branch;
-            parse_info.branch_info.kill = true;
-            parse_info.branch_info.is_sync = false;
-            parse_info.branch_info.is_brk = false;
-            parse_info.branch_info.ignore = false;
-            parse_info.end_address = offset;
-
-            return {ParseResult::ControlCaught, parse_info};
-        }
-        case OpCode::Id::SSY: {
-            const u32 target = offset + instr.bra.GetBranchTarget();
-            insert_label(state, target);
-            state.ssy_labels.emplace(offset, target);
-            break;
-        }
-        case OpCode::Id::PBK: {
-            const u32 target = offset + instr.bra.GetBranchTarget();
-            insert_label(state, target);
-            state.pbk_labels.emplace(offset, target);
-            break;
-        }
-        case OpCode::Id::BRX: {
-            return {ParseResult::AbnormalFlow, parse_info};
-        }
-        default:
-            break;
-        }
-
-        offset++;
-    }
-    parse_info.branch_info.kill = false;
-    parse_info.branch_info.is_sync = false;
-    parse_info.branch_info.is_brk = false;
-    parse_info.end_address = offset - 1;
-    return {ParseResult::BlockEnd, parse_info};
-}
-
-bool TryInspectAddress(CFGRebuildState& state) {
-    if (state.inspect_queries.empty()) {
-        return false;
-    }
-
-    const u32 address = state.inspect_queries.front();
-    state.inspect_queries.pop_front();
-    const auto [result, block_index] = TryGetBlock(state, address);
-    switch (result) {
-    case BlockCollision::Found: {
-        return true;
-    }
-    case BlockCollision::Inside: {
-        // This case is the tricky one:
-        // We need to Split the block in 2 sepparate blocks
-        const u32 end = state.block_info[block_index].end;
-        BlockInfo& new_block = CreateBlockInfo(state, address, end);
-        BlockInfo& current_block = state.block_info[block_index];
-        current_block.end = address - 1;
-        new_block.branch = current_block.branch;
-        BlockBranchInfo forward_branch{};
-        forward_branch.address = address;
-        forward_branch.ignore = true;
-        current_block.branch = forward_branch;
-        return true;
-    }
-    default:
-        break;
-    }
-    const auto [parse_result, parse_info] = ParseCode(state, address);
-    if (parse_result == ParseResult::AbnormalFlow) {
-        // if it's AbnormalFlow, we end it as false, ending the CFG reconstruction
-        return false;
-    }
-
-    BlockInfo& block_info = CreateBlockInfo(state, address, parse_info.end_address);
-    block_info.branch = parse_info.branch_info;
-    if (parse_info.branch_info.condition.IsUnconditional()) {
-        return true;
-    }
-
-    const u32 fallthrough_address = parse_info.end_address + 1;
-    state.inspect_queries.push_front(fallthrough_address);
-    return true;
-}
-
-bool TryQuery(CFGRebuildState& state) {
-    const auto gather_labels = [](std::stack<u32>& cc, std::map<u32, u32>& labels,
-                                  BlockInfo& block) {
-        auto gather_start = labels.lower_bound(block.start);
-        const auto gather_end = labels.upper_bound(block.end);
-        while (gather_start != gather_end) {
-            cc.push(gather_start->second);
-            gather_start++;
-        }
-    };
-    if (state.queries.empty()) {
-        return false;
-    }
-    Query& q = state.queries.front();
-    const u32 block_index = state.registered[q.address];
-    BlockInfo& block = state.block_info[block_index];
-    // If the block is visted, check if the stacks match, else gather the ssy/pbk
-    // labels into the current stack and look if the branch at the end of the block
-    // consumes a label. Schedule new queries accordingly
-    if (block.visited) {
-        BlockStack& stack = state.stacks[q.address];
-        const bool all_okay = (stack.ssy_stack.size() == 0 || q.ssy_stack == stack.ssy_stack) &&
-                              (stack.pbk_stack.size() == 0 || q.pbk_stack == stack.pbk_stack);
-        state.queries.pop_front();
-        return all_okay;
-    }
-    block.visited = true;
-    state.stacks[q.address] = BlockStack{q};
-    Query q2(q);
-    state.queries.pop_front();
-    gather_labels(q2.ssy_stack, state.ssy_labels, block);
-    gather_labels(q2.pbk_stack, state.pbk_labels, block);
-    if (!block.branch.condition.IsUnconditional()) {
-        q2.address = block.end + 1;
-        state.queries.push_back(q2);
-    }
-    Query conditional_query{q2};
-    if (block.branch.is_sync) {
-        if (block.branch.address == unassigned_branch) {
-            block.branch.address = conditional_query.ssy_stack.top();
-        }
-        conditional_query.ssy_stack.pop();
-    }
-    if (block.branch.is_brk) {
-        if (block.branch.address == unassigned_branch) {
-            block.branch.address = conditional_query.pbk_stack.top();
-        }
-        conditional_query.pbk_stack.pop();
-    }
-    conditional_query.address = block.branch.address;
-    state.queries.push_back(conditional_query);
-    return true;
-}
-
-std::optional<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code, u32 program_size,
-                                              u32 start_address) {
-    CFGRebuildState state{program_code, program_size, start_address};
-    // Inspect Code and generate blocks
-    state.labels.clear();
-    state.labels.emplace(start_address);
-    state.inspect_queries.push_back(state.start);
-    while (!state.inspect_queries.empty()) {
-        if (!TryInspectAddress(state)) {
-            return {};
-        }
-    }
-    // Decompile Stacks
-    Query start_query{};
-    start_query.address = state.start;
-    state.queries.push_back(start_query);
-    bool decompiled = true;
-    while (!state.queries.empty()) {
-        if (!TryQuery(state)) {
-            decompiled = false;
-            break;
-        }
-    }
-    // Sort and organize results
-    std::sort(state.block_info.begin(), state.block_info.end(),
-              [](const BlockInfo& a, const BlockInfo& b) -> bool { return a.start < b.start; });
-    ShaderCharacteristics result_out{};
-    result_out.decompilable = decompiled;
-    result_out.start = start_address;
-    result_out.end = start_address;
-    for (auto& block : state.block_info) {
-        ShaderBlock new_block{};
-        new_block.start = block.start;
-        new_block.end = block.end;
-        new_block.ignore_branch = block.branch.ignore;
-        if (!new_block.ignore_branch) {
-            new_block.branch.cond = block.branch.condition;
-            new_block.branch.kills = block.branch.kill;
-            new_block.branch.address = block.branch.address;
-        }
-        result_out.end = std::max(result_out.end, block.end);
-        result_out.blocks.push_back(new_block);
-    }
-    if (result_out.decompilable) {
-        result_out.labels = std::move(state.labels);
-        return {result_out};
-    }
-    // If it's not decompilable, merge the unlabelled blocks together
-    auto back = result_out.blocks.begin();
-    auto next = std::next(back);
-    while (next != result_out.blocks.end()) {
-        if (state.labels.count(next->start) == 0 && next->start == back->end + 1) {
-            back->end = next->end;
-            next = result_out.blocks.erase(next);
-            continue;
-        }
-        back = next;
-        next++;
-    }
-    return {result_out};
-}
-} // namespace VideoCommon::Shader

src/video_core/shader/control_flow.h

@@ -1,63 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <cstring>
-#include <list>
-#include <optional>
-#include <unordered_set>
-
-#include "video_core/engines/shader_bytecode.h"
-#include "video_core/shader/shader_ir.h"
-
-namespace VideoCommon::Shader {
-
-using Tegra::Shader::ConditionCode;
-using Tegra::Shader::Pred;
-
-constexpr s32 exit_branch = -1;
-
-struct Condition {
-    Pred predicate{Pred::UnusedIndex};
-    ConditionCode cc{ConditionCode::T};
-
-    bool IsUnconditional() const {
-        return predicate == Pred::UnusedIndex && cc == ConditionCode::T;
-    }
-    bool operator==(const Condition& other) const {
-        return std::tie(predicate, cc) == std::tie(other.predicate, other.cc);
-    }
-};
-
-struct ShaderBlock {
-    u32 start{};
-    u32 end{};
-    bool ignore_branch{};
-    struct Branch {
-        Condition cond{};
-        bool kills{};
-        s32 address{};
-        bool operator==(const Branch& b) const {
-            return std::tie(cond, kills, address) == std::tie(b.cond, b.kills, b.address);
-        }
-    } branch{};
-    bool operator==(const ShaderBlock& sb) const {
-        return std::tie(start, end, ignore_branch, branch) ==
-               std::tie(sb.start, sb.end, sb.ignore_branch, sb.branch);
-    }
-};
-
-struct ShaderCharacteristics {
-    std::list<ShaderBlock> blocks{};
-    bool decompilable{};
-    u32 start{};
-    u32 end{};
-    std::unordered_set<u32> labels{};
-};
-
-std::optional<ShaderCharacteristics> ScanFlow(const ProgramCode& program_code, u32 program_size,
-                                              u32 start_address);
-
-} // namespace VideoCommon::Shader

src/video_core/shader/decode.cpp

@@ -11,7 +11,6 @@
 #include "common/common_types.h"
 #include "video_core/engines/shader_bytecode.h"
 #include "video_core/engines/shader_header.h"
-#include "video_core/shader/control_flow.h"
 #include "video_core/shader/node_helper.h"
 #include "video_core/shader/shader_ir.h"
 
@@ -22,6 +21,20 @@ using Tegra::Shader::OpCode;
 
 namespace {
 
+/// Merges exit method of two parallel branches.
+constexpr ExitMethod ParallelExit(ExitMethod a, ExitMethod b) {
+    if (a == ExitMethod::Undetermined) {
+        return b;
+    }
+    if (b == ExitMethod::Undetermined) {
+        return a;
+    }
+    if (a == b) {
+        return a;
+    }
+    return ExitMethod::Conditional;
+}
+
 /**
  * Returns whether the instruction at the specified offset is a 'sched' instruction.
  * Sched instructions always appear before a sequence of 3 instructions.
@@ -38,104 +51,85 @@ constexpr bool IsSchedInstruction(u32 offset, u32 main_offset) {
 void ShaderIR::Decode() {
     std::memcpy(&header, program_code.data(), sizeof(Tegra::Shader::Header));
 
-    disable_flow_stack = false;
-    const auto info = ScanFlow(program_code, program_size, main_offset);
-    if (info) {
-        const auto& shader_info = *info;
-        coverage_begin = shader_info.start;
-        coverage_end = shader_info.end;
-        if (shader_info.decompilable) {
-            disable_flow_stack = true;
-            const auto insert_block = ([this](NodeBlock& nodes, u32 label) {
-                if (label == exit_branch) {
-                    return;
-                }
-                basic_blocks.insert({label, nodes});
-            });
-            const auto& blocks = shader_info.blocks;
-            NodeBlock current_block;
-            u32 current_label = exit_branch;
-            for (auto& block : blocks) {
-                if (shader_info.labels.count(block.start) != 0) {
-                    insert_block(current_block, current_label);
-                    current_block.clear();
-                    current_label = block.start;
-                }
-                if (!block.ignore_branch) {
-                    DecodeRangeInner(current_block, block.start, block.end);
-                    InsertControlFlow(current_block, block);
-                } else {
-                    DecodeRangeInner(current_block, block.start, block.end + 1);
-                }
-            }
-            insert_block(current_block, current_label);
-            return;
-        }
-        LOG_WARNING(HW_GPU, "Flow Stack Removing Failed! Falling back to old method");
-        // we can't decompile it, fallback to standard method
-        for (const auto& block : shader_info.blocks) {
-            basic_blocks.insert({block.start, DecodeRange(block.start, block.end + 1)});
-        }
+    std::set<u32> labels;
+    const ExitMethod exit_method = Scan(main_offset, MAX_PROGRAM_LENGTH, labels);
+    if (exit_method != ExitMethod::AlwaysEnd) {
+        UNREACHABLE_MSG("Program does not always end");
+    }
+
+    if (labels.empty()) {
+        basic_blocks.insert({main_offset, DecodeRange(main_offset, MAX_PROGRAM_LENGTH)});
         return;
     }
-    LOG_WARNING(HW_GPU, "Flow Analysis Failed! Falling back to brute force compiling");
 
-    // Now we need to deal with an undecompilable shader. We need to brute force
-    // a shader that captures every position.
-    coverage_begin = main_offset;
-    const u32 shader_end = static_cast<u32>(program_size / sizeof(u64));
-    coverage_end = shader_end;
-    for (u32 label = main_offset; label < shader_end; label++) {
-        basic_blocks.insert({label, DecodeRange(label, label + 1)});
+    labels.insert(main_offset);
+
+    for (const u32 label : labels) {
+        const auto next_it = labels.lower_bound(label + 1);
+        const u32 next_label = next_it == labels.end() ? MAX_PROGRAM_LENGTH : *next_it;
+
+        basic_blocks.insert({label, DecodeRange(label, next_label)});
     }
 }
 
+ExitMethod ShaderIR::Scan(u32 begin, u32 end, std::set<u32>& labels) {
+    const auto [iter, inserted] =
+        exit_method_map.emplace(std::make_pair(begin, end), ExitMethod::Undetermined);
+    ExitMethod& exit_method = iter->second;
+    if (!inserted)
+        return exit_method;
+
+    for (u32 offset = begin; offset != end && offset != MAX_PROGRAM_LENGTH; ++offset) {
+        coverage_begin = std::min(coverage_begin, offset);
+        coverage_end = std::max(coverage_end, offset + 1);
+
+        const Instruction instr = {program_code[offset]};
+        const auto opcode = OpCode::Decode(instr);
+        if (!opcode)
+            continue;
+        switch (opcode->get().GetId()) {
+        case OpCode::Id::EXIT: {
+            // The EXIT instruction can be predicated, which means that the shader can conditionally
+            // end on this instruction. We have to consider the case where the condition is not met
+            // and check the exit method of that other basic block.
+            using Tegra::Shader::Pred;
+            if (instr.pred.pred_index == static_cast<u64>(Pred::UnusedIndex)) {
+                return exit_method = ExitMethod::AlwaysEnd;
+            } else {
+                const ExitMethod not_met = Scan(offset + 1, end, labels);
+                return exit_method = ParallelExit(ExitMethod::AlwaysEnd, not_met);
+            }
+        }
+        case OpCode::Id::BRA: {
+            const u32 target = offset + instr.bra.GetBranchTarget();
+            labels.insert(target);
+            const ExitMethod no_jmp = Scan(offset + 1, end, labels);
+            const ExitMethod jmp = Scan(target, end, labels);
+            return exit_method = ParallelExit(no_jmp, jmp);
+        }
+        case OpCode::Id::SSY:
+        case OpCode::Id::PBK: {
+            // The SSY and PBK use a similar encoding as the BRA instruction.
+            UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
+                                 "Constant buffer branching is not supported");
+            const u32 target = offset + instr.bra.GetBranchTarget();
+            labels.insert(target);
+            // Continue scanning for an exit method.
+            break;
+        }
+        default:
+            break;
+        }
+    }
+    return exit_method = ExitMethod::AlwaysReturn;
+}
+
 NodeBlock ShaderIR::DecodeRange(u32 begin, u32 end) {
     NodeBlock basic_block;
-    DecodeRangeInner(basic_block, begin, end);
-    return basic_block;
-}
-
-void ShaderIR::DecodeRangeInner(NodeBlock& bb, u32 begin, u32 end) {
     for (u32 pc = begin; pc < (begin > end ? MAX_PROGRAM_LENGTH : end);) {
-        pc = DecodeInstr(bb, pc);
+        pc = DecodeInstr(basic_block, pc);
     }
-}
-
-void ShaderIR::InsertControlFlow(NodeBlock& bb, const ShaderBlock& block) {
-    const auto apply_conditions = ([&](const Condition& cond, Node n) -> Node {
-        Node result = n;
-        if (cond.cc != ConditionCode::T) {
-            result = Conditional(GetConditionCode(cond.cc), {result});
-        }
-        if (cond.predicate != Pred::UnusedIndex) {
-            u32 pred = static_cast<u32>(cond.predicate);
-            const bool is_neg = pred > 7;
-            if (is_neg) {
-                pred -= 8;
-            }
-            result = Conditional(GetPredicate(pred, is_neg), {result});
-        }
-        return result;
-    });
-    if (block.branch.address < 0) {
-        if (block.branch.kills) {
-            Node n = Operation(OperationCode::Discard);
-            n = apply_conditions(block.branch.cond, n);
-            bb.push_back(n);
-            global_code.push_back(n);
-            return;
-        }
-        Node n = Operation(OperationCode::Exit);
-        n = apply_conditions(block.branch.cond, n);
-        bb.push_back(n);
-        global_code.push_back(n);
-        return;
-    }
-    Node n = Operation(OperationCode::Branch, Immediate(block.branch.address));
-    n = apply_conditions(block.branch.cond, n);
-    bb.push_back(n);
-    global_code.push_back(n);
+    return basic_block;
 }
 
 u32 ShaderIR::DecodeInstr(NodeBlock& bb, u32 pc) {
@@ -146,18 +140,15 @@ u32 ShaderIR::DecodeInstr(NodeBlock& bb, u32 pc) {
 
     const Instruction instr = {program_code[pc]};
     const auto opcode = OpCode::Decode(instr);
-    const u32 nv_address = ConvertAddressToNvidiaSpace(pc);
 
     // Decoding failure
     if (!opcode) {
         UNIMPLEMENTED_MSG("Unhandled instruction: {0:x}", instr.value);
-        bb.push_back(Comment(fmt::format("{:05x} Unimplemented Shader instruction (0x{:016x})",
-                                         nv_address, instr.value)));
         return pc + 1;
     }
 
-    bb.push_back(Comment(
-        fmt::format("{:05x} {} (0x{:016x})", nv_address, opcode->get().GetName(), instr.value)));
+    bb.push_back(
+        Comment(fmt::format("{}: {} (0x{:016x})", pc, opcode->get().GetName(), instr.value)));
 
     using Tegra::Shader::Pred;
     UNIMPLEMENTED_IF_MSG(instr.pred.full_pred == Pred::NeverExecute,

src/video_core/shader/decode/other.cpp

@@ -91,46 +91,11 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         break;
     }
     case OpCode::Id::BRA: {
-        Node branch;
-        if (instr.bra.constant_buffer == 0) {
-            const u32 target = pc + instr.bra.GetBranchTarget();
-            branch = Operation(OperationCode::Branch, Immediate(target));
-        } else {
-            const u32 target = pc + 1;
-            const Node op_a = GetConstBuffer(instr.cbuf36.index, instr.cbuf36.GetOffset());
-            const Node convert = SignedOperation(OperationCode::IArithmeticShiftRight, true,
-                                                 PRECISE, op_a, Immediate(3));
-            const Node operand =
-                Operation(OperationCode::IAdd, PRECISE, convert, Immediate(target));
-            branch = Operation(OperationCode::BranchIndirect, convert);
-        }
+        UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
+                             "BRA with constant buffers are not implemented");
 
-        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
-        if (cc != Tegra::Shader::ConditionCode::T) {
-            bb.push_back(Conditional(GetConditionCode(cc), {branch}));
-        } else {
-            bb.push_back(branch);
-        }
-        break;
-    }
-    case OpCode::Id::BRX: {
-        Node operand;
-        if (instr.brx.constant_buffer != 0) {
-            const s32 target = pc + 1;
-            const Node index = GetRegister(instr.gpr8);
-            const Node op_a =
-                GetConstBufferIndirect(instr.cbuf36.index, instr.cbuf36.GetOffset() + 0, index);
-            const Node convert = SignedOperation(OperationCode::IArithmeticShiftRight, true,
-                                                 PRECISE, op_a, Immediate(3));
-            operand = Operation(OperationCode::IAdd, PRECISE, convert, Immediate(target));
-        } else {
-            const s32 target = pc + instr.brx.GetBranchExtend();
-            const Node op_a = GetRegister(instr.gpr8);
-            const Node convert = SignedOperation(OperationCode::IArithmeticShiftRight, true,
-                                                 PRECISE, op_a, Immediate(3));
-            operand = Operation(OperationCode::IAdd, PRECISE, convert, Immediate(target));
-        }
-        const Node branch = Operation(OperationCode::BranchIndirect, operand);
+        const u32 target = pc + instr.bra.GetBranchTarget();
+        const Node branch = Operation(OperationCode::Branch, Immediate(target));
 
         const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
         if (cc != Tegra::Shader::ConditionCode::T) {
@@ -144,10 +109,6 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
                              "Constant buffer flow is not supported");
 
-        if (disable_flow_stack) {
-            break;
-        }
-
         // The SSY opcode tells the GPU where to re-converge divergent execution paths with SYNC.
         const u32 target = pc + instr.bra.GetBranchTarget();
         bb.push_back(
@@ -158,10 +119,6 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         UNIMPLEMENTED_IF_MSG(instr.bra.constant_buffer != 0,
                              "Constant buffer PBK is not supported");
 
-        if (disable_flow_stack) {
-            break;
-        }
-
         // PBK pushes to a stack the address where BRK will jump to.
         const u32 target = pc + instr.bra.GetBranchTarget();
         bb.push_back(
@@ -173,10 +130,6 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "SYNC condition code used: {}",
                              static_cast<u32>(cc));
 
-        if (disable_flow_stack) {
-            break;
-        }
-
         // The SYNC opcode jumps to the address previously set by the SSY opcode
         bb.push_back(Operation(OperationCode::PopFlowStack, MetaStackClass::Ssy));
         break;
@@ -185,9 +138,6 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
         const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
         UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "BRK condition code used: {}",
                              static_cast<u32>(cc));
-        if (disable_flow_stack) {
-            break;
-        }
 
         // The BRK opcode jumps to the address previously set by the PBK opcode
         bb.push_back(Operation(OperationCode::PopFlowStack, MetaStackClass::Pbk));

src/video_core/shader/node.h

@@ -148,12 +148,11 @@ enum class OperationCode {
 
     ImageStore, /// (MetaImage, float[N] coords) -> void
 
-    Branch,         /// (uint branch_target) -> void
-    BranchIndirect, /// (uint branch_target) -> void
-    PushFlowStack,  /// (uint branch_target) -> void
-    PopFlowStack,   /// () -> void
-    Exit,           /// () -> void
-    Discard,        /// () -> void
+    Branch,        /// (uint branch_target) -> void
+    PushFlowStack, /// (uint branch_target) -> void
+    PopFlowStack,  /// () -> void
+    Exit,          /// () -> void
+    Discard,       /// () -> void
 
     EmitVertex,   /// () -> void
     EndPrimitive, /// () -> void

src/video_core/shader/shader_ir.cpp

@@ -22,8 +22,8 @@ using Tegra::Shader::PredCondition;
 using Tegra::Shader::PredOperation;
 using Tegra::Shader::Register;
 
-ShaderIR::ShaderIR(const ProgramCode& program_code, u32 main_offset, const std::size_t size)
-    : program_code{program_code}, main_offset{main_offset}, program_size{size} {
+ShaderIR::ShaderIR(const ProgramCode& program_code, u32 main_offset)
+    : program_code{program_code}, main_offset{main_offset} {
     Decode();
 }
 

src/video_core/shader/shader_ir.h

@@ -22,12 +22,18 @@
 
 namespace VideoCommon::Shader {
 
-struct ShaderBlock;
-
 using ProgramCode = std::vector<u64>;
 
 constexpr u32 MAX_PROGRAM_LENGTH = 0x1000;
 
+/// Describes the behaviour of code path of a given entry point and a return point.
+enum class ExitMethod {
+    Undetermined, ///< Internal value. Only occur when analyzing JMP loop.
+    AlwaysReturn, ///< All code paths reach the return point.
+    Conditional,  ///< Code path reaches the return point or an END instruction conditionally.
+    AlwaysEnd,    ///< All code paths reach a END instruction.
+};
+
 class ConstBuffer {
 public:
     explicit ConstBuffer(u32 max_offset, bool is_indirect)
@@ -67,7 +73,7 @@ struct GlobalMemoryUsage {
 
 class ShaderIR final {
 public:
-    explicit ShaderIR(const ProgramCode& program_code, u32 main_offset, std::size_t size);
+    explicit ShaderIR(const ProgramCode& program_code, u32 main_offset);
     ~ShaderIR();
 
     const std::map<u32, NodeBlock>& GetBasicBlocks() const {
@@ -123,20 +129,12 @@ public:
         return header;
     }
 
-    bool IsFlowStackDisabled() const {
-        return disable_flow_stack;
-    }
-
-    u32 ConvertAddressToNvidiaSpace(const u32 address) const {
-        return (address - main_offset) * sizeof(Tegra::Shader::Instruction);
-    }
-
 private:
     void Decode();
 
+    ExitMethod Scan(u32 begin, u32 end, std::set<u32>& labels);
+
     NodeBlock DecodeRange(u32 begin, u32 end);
-    void DecodeRangeInner(NodeBlock& bb, u32 begin, u32 end);
-    void InsertControlFlow(NodeBlock& bb, const ShaderBlock& block);
 
     /**
      * Decodes a single instruction from Tegra to IR.
@@ -328,11 +326,10 @@ private:
 
     const ProgramCode& program_code;
     const u32 main_offset;
-    const std::size_t program_size;
-    bool disable_flow_stack{};
 
     u32 coverage_begin{};
     u32 coverage_end{};
+    std::map<std::pair<u32, u32>, ExitMethod> exit_method_map;
 
     std::map<u32, NodeBlock> basic_blocks;
     NodeBlock global_code;

src/yuzu/main.cpp

@@ -18,8 +18,8 @@
 #include "core/file_sys/vfs_real.h"
 #include "core/frontend/applets/general_frontend.h"
 #include "core/frontend/scope_acquire_window_context.h"
+#include "core/hle/applet/applet.h"
 #include "core/hle/service/acc/profile_manager.h"
-#include "core/hle/service/am/applets/applets.h"
 #include "core/hle/service/hid/controllers/npad.h"
 #include "core/hle/service/hid/hid.h"