fx

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/core/hle/service/ns/application_manager_interface.cpp

@@ -137,7 +137,7 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {405, nullptr, "ListApplicationControlCacheEntryInfo"},
         {406, nullptr, "GetApplicationControlProperty"},
         {407, &IApplicationManagerInterface::ListApplicationTitle, "ListApplicationTitle"},
-        {408, &IApplicationManagerInterface::ListApplicationIcon, "ListApplicationIcon"},
+        {408, nullptr, "ListApplicationIcon"},
         {411, nullptr, "Unknown411"}, //19.0.0+
         {412, nullptr, "Unknown412"}, //19.0.0+
         {413, nullptr, "Unknown413"}, //19.0.0+
@@ -848,9 +848,4 @@ void IApplicationManagerInterface::ListApplicationTitle(HLERequestContext& ctx)
     IReadOnlyApplicationControlDataInterface(system).ListApplicationTitle(ctx);
 }
 
-void IApplicationManagerInterface::ListApplicationIcon(HLERequestContext& ctx) {
-    LOG_DEBUG(Service_NS, "called");
-    IReadOnlyApplicationControlDataInterface(system).ListApplicationIcon(ctx);
-}
-
 } // namespace Service::NS

src/core/hle/service/ns/application_manager_interface.h

@@ -75,7 +75,6 @@ public:
                                                              u64 application_id);
 
     void ListApplicationTitle(HLERequestContext& ctx);
-    void ListApplicationIcon(HLERequestContext& ctx);
 
 private:
     KernelHelpers::ServiceContext service_context;

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -14,16 +14,12 @@
 #include <stb_image_resize.h>
 #include <stb_image_write.h>
 
-#include "common/logging.h"
 #include "common/settings.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/kernel/k_transfer_memory.h"
-#include "core/hle/result.h"
 #include "core/hle/service/cmif_serialization.h"
-#include "core/hle/service/cmif_types.h"
-#include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/ns/ns_results.h"
@@ -79,26 +75,24 @@ void SanitizeJPEGImageSize(std::vector<u8>& image) {
 
 // IAsyncValue implementation for ListApplicationTitle
 // https://switchbrew.org/wiki/NS_services#ListApplicationTitle
-class IAsyncValue final : public ServiceFramework<IAsyncValue> {
+class IAsyncValueForListApplicationTitle final : public ServiceFramework<IAsyncValueForListApplicationTitle> {
 public:
-    explicit IAsyncValue(Core::System& system_, s32 offset, s32 size)
-        : ServiceFramework{system_, "IAsyncValue"}
-        , service_context{system_, "IAsyncValue"}
-        , data_offset{offset}
-        , data_size{size}
-    {
+    explicit IAsyncValueForListApplicationTitle(Core::System& system_, s32 offset, s32 size)
+        : ServiceFramework{system_, "IAsyncValue"}, service_context{system_, "IAsyncValue"},
+          data_offset{offset}, data_size{size} {
         static const FunctionInfo functions[] = {
-            {0, D<&IAsyncValue::GetSize>, "GetSize"},
-            {1, D<&IAsyncValue::Get>, "Get"},
-            {2, D<&IAsyncValue::Cancel>, "Cancel"},
-            {3, D<&IAsyncValue::GetErrorContext>, "GetErrorContext"},
+            {0, &IAsyncValueForListApplicationTitle::GetSize, "GetSize"},
+            {1, &IAsyncValueForListApplicationTitle::Get, "Get"},
+            {2, &IAsyncValueForListApplicationTitle::Cancel, "Cancel"},
+            {3, &IAsyncValueForListApplicationTitle::GetErrorContext, "GetErrorContext"},
         };
         RegisterHandlers(functions);
+
         completion_event = service_context.CreateEvent("IAsyncValue:Completion");
         completion_event->GetReadableEvent().Signal(system.Kernel());
     }
 
-    ~IAsyncValue() override {
+    ~IAsyncValueForListApplicationTitle() override {
         service_context.CloseEvent(completion_event);
     }
 
@@ -107,24 +101,35 @@ public:
     }
 
 private:
-    Result GetSize(Out<s64> out_data_size) {
+    void GetSize(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        *out_data_size = data_size;
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push<s64>(data_size);
     }
-    Result Get(OutBuffer<BufferAttr_HipcMapAlias> out_data_offset) {
+
+    void Get(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        std::memcpy(out_data_offset.data(), &data_offset, sizeof(s32));
-        R_SUCCEED();
+        std::vector<u8> buffer(sizeof(s32));
+        std::memcpy(buffer.data(), &data_offset, sizeof(s32));
+        ctx.WriteBuffer(buffer);
+
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
-    Result Cancel() {
+
+    void Cancel(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
-    Result GetErrorContext() {
+
+    void GetErrorContext(HLERequestContext& ctx) {
         LOG_DEBUG(Service_NS, "called");
-        R_SUCCEED();
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ResultSuccess);
     }
+
     KernelHelpers::ServiceContext service_context;
     Kernel::KEvent* completion_event{};
     s32 data_offset;
@@ -142,7 +147,6 @@ IReadOnlyApplicationControlDataInterface::IReadOnlyApplicationControlDataInterfa
         {3, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
         {4, nullptr, "SelectApplicationDesiredLanguage"},
         {5, D<&IReadOnlyApplicationControlDataInterface::GetApplicationControlData2>, "GetApplicationControlData"},
-        {10, &IReadOnlyApplicationControlDataInterface::ListApplicationIcon, "ListApplicationIcon"},
         {13, &IReadOnlyApplicationControlDataInterface::ListApplicationTitle, "ListApplicationTitle"},
         {19, D<&IReadOnlyApplicationControlDataInterface::GetApplicationControlData3>, "GetApplicationControlData"},
     };
@@ -159,7 +163,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
     LOG_INFO(Service_NS, "called with control_source={}, application_id={:016X}",
              application_control_source, application_id);
 
-    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(), system.GetContentProvider()};
+    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(),
+                                   system.GetContentProvider()};
     const auto control = pm.GetControlMetadata();
     const auto size = out_buffer.size();
 
@@ -167,7 +172,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
     const auto total_size = sizeof(FileSys::RawNACP) + icon_size;
 
     if (size < total_size) {
-        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min=0x4000)", size);
+        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min=0x4000)",
+                  size);
         R_THROW(ResultUnknown);
     }
 
@@ -175,7 +181,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData(
         const auto bytes = control.first->GetRawBytes();
         std::memcpy(out_buffer.data(), bytes.data(), bytes.size());
     } else {
-        LOG_WARNING(Service_NS, "missing NACP data for application_id={:016X}, defaulting to zero", application_id);
+        LOG_WARNING(Service_NS, "missing NACP data for application_id={:016X}, defaulting to zero",
+                    application_id);
         std::memset(out_buffer.data(), 0, sizeof(FileSys::RawNACP));
     }
 
@@ -200,12 +207,15 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationDesiredLanguage(
     // Convert to application language, get priority list
     const auto application_language = ConvertToApplicationLanguage(language_code);
     if (application_language == std::nullopt) {
-        LOG_ERROR(Service_NS, "Could not convert application language! language_code={}", language_code);
+        LOG_ERROR(Service_NS, "Could not convert application language! language_code={}",
+                  language_code);
         R_THROW(Service::NS::ResultApplicationLanguageNotFound);
     }
     const auto priority_list = GetApplicationLanguagePriorityList(*application_language);
     if (!priority_list) {
-        LOG_ERROR(Service_NS, "Could not find application language priorities! application_language={}", *application_language);
+        LOG_ERROR(Service_NS,
+                  "Could not find application language priorities! application_language={}",
+                  *application_language);
         R_THROW(Service::NS::ResultApplicationLanguageNotFound);
     }
 
@@ -249,7 +259,8 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData2(
     const auto nacp_size = sizeof(FileSys::RawNACP);
 
     if (size < nacp_size) {
-        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min={:08X})", size, nacp_size);
+        LOG_ERROR(Service_NS, "output buffer is too small! (actual={:016X}, expected_min={:08X})",
+                  size, nacp_size);
         R_THROW(ResultUnknown);
     }
 
@@ -300,83 +311,63 @@ Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData2(
     R_SUCCEED();
 }
 
-void IReadOnlyApplicationControlDataInterface::ListApplicationIcon(HLERequestContext& ctx) {
-    LOG_WARNING(Service_NS, "(stubbed)");
-
-    const auto app_ids_buffer = ctx.ReadBuffer();
-    const u64 app_count = app_ids_buffer.size() / sizeof(u64);
-    auto t_mem_obj = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(ctx.GetCopyHandle(0));
-    auto* t_mem = t_mem_obj.GetPointerUnsafe();
-
-    size_t out_length = 0;
-    if (t_mem != nullptr && app_count > 0) {
-        auto& memory = system.ApplicationMemory();
-        const auto t_mem_address = t_mem->GetSourceAddress();
-        // u64 - app count
-        memory.WriteBlock(t_mem_address + out_length, &app_count, sizeof(u64));
-        out_length += sizeof(u64);
-        // [list of u64] - size of icons
-        for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = app_ids_buffer[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            const auto control = pm.GetControlMetadata();
-            u64 full_size = control.second->GetSize();
-            memory.WriteBlock(t_mem_address + out_length, &full_size, sizeof(u64));
-            out_length += sizeof(u64);
-        }
-        // [list of raw icon data]
-        std::vector<u8> full_icon_data;
-        for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = app_ids_buffer[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
-            const auto control = pm.GetControlMetadata();
-            auto const full_size = control.second->GetSize();
-            if (full_size > 0) {
-                full_icon_data.resize(full_size);
-                control.second->Read(full_icon_data.data(), full_size, 0);
-                memory.WriteBlock(t_mem_address + out_length, full_icon_data.data(), full_size);
-                out_length += full_size;
-            }
-        }
-    }
-    auto async_value = std::make_shared<IAsyncValue>(system, 0, s32(out_length));
-    IPC::ResponseBuilder rb{ctx, 2, 1, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(ctx, async_value->ReadableEvent());
-    rb.PushIpcInterface(ctx, std::move(async_value));
-}
 
 void IReadOnlyApplicationControlDataInterface::ListApplicationTitle(HLERequestContext& ctx) {
+    /*
+    IPC::RequestParser rp{ctx};
+    auto control_source = rp.PopRaw<u8>();
+    rp.Skip(7, false);
+    auto transfer_memory_size = rp.Pop<u64>();
+    */
+
     const auto app_ids_buffer = ctx.ReadBuffer();
     const size_t app_count = app_ids_buffer.size() / sizeof(u64);
+
+    std::vector<u64> application_ids(app_count);
+    if (app_count > 0) {
+        std::memcpy(application_ids.data(), app_ids_buffer.data(), app_count * sizeof(u64));
+    }
+
     auto t_mem_obj = ctx.GetObjectFromHandle<Kernel::KTransferMemory>(ctx.GetCopyHandle(0));
     auto* t_mem = t_mem_obj.GetPointerUnsafe();
+
     constexpr size_t title_entry_size = sizeof(FileSys::LanguageEntry);
     const size_t total_data_size = app_count * title_entry_size;
+
     constexpr s32 data_offset = 0;
+
     if (t_mem != nullptr && app_count > 0) {
         auto& memory = system.ApplicationMemory();
         const auto t_mem_address = t_mem->GetSourceAddress();
+
         for (size_t i = 0; i < app_count; ++i) {
-            const u64 app_id = app_ids_buffer[i];
-            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(), system.GetContentProvider()};
+            const u64 app_id = application_ids[i];
+            const FileSys::PatchManager pm{app_id, system.GetFileSystemController(),
+                                           system.GetContentProvider()};
             const auto control = pm.GetControlMetadata();
+
             FileSys::LanguageEntry entry{};
             if (control.first != nullptr) {
                 entry = control.first->GetLanguageEntry();
             }
+
             const size_t offset = i * title_entry_size;
             memory.WriteBlock(t_mem_address + offset, &entry, title_entry_size);
         }
     }
-    auto async_value = std::make_shared<IAsyncValue>(system, data_offset, s32(total_data_size));
+
+    auto async_value = std::make_shared<IAsyncValueForListApplicationTitle>(
+        system, data_offset, static_cast<s32>(total_data_size));
+
     IPC::ResponseBuilder rb{ctx, 2, 1, 1};
     rb.Push(ResultSuccess);
     rb.PushCopyObjects(ctx, async_value->ReadableEvent());
     rb.PushIpcInterface(ctx, std::move(async_value));
 }
 
-Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData3(OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u32> out_flags_a, Out<u32> out_flags_b, Out<u32> out_actual_size, ApplicationControlSource application_control_source, u8 flag1, u8 flag2, u64 application_id) {
+Result IReadOnlyApplicationControlDataInterface::GetApplicationControlData3(
+   OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u32> out_flags_a, Out<u32> out_flags_b,
+   Out<u32> out_actual_size, ApplicationControlSource application_control_source, u8 flag1, u8 flag2, u64 application_id) {
     LOG_INFO(Service_NS, "called with control_source={}, flags=({:02X},{:02X}), application_id={:016X}",
              application_control_source, flag1, flag2, application_id);
 

src/core/hle/service/ns/read_only_application_control_data_interface.h

@@ -34,7 +34,6 @@ public:
         u8 flag1,
         u8 flag2,
         u64 application_id);
-    void ListApplicationIcon(HLERequestContext& ctx);
     void ListApplicationTitle(HLERequestContext& ctx);
     Result GetApplicationControlData3(
         OutBuffer<BufferAttr_HipcMapAlias> out_buffer,

src/core/hle/service/ns/read_only_application_record_interface.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
@@ -16,8 +16,10 @@ IReadOnlyApplicationRecordInterface::IReadOnlyApplicationRecordInterface(Core::S
     static const FunctionInfo functions[] = {
         {0, D<&IReadOnlyApplicationRecordInterface::HasApplicationRecord>, "HasApplicationRecord"},
         {1, nullptr, "NotifyApplicationFailure"},
-        {2, D<&IReadOnlyApplicationRecordInterface::IsDataCorruptedResult>, "IsDataCorruptedResult"},
-        {3, D<&IReadOnlyApplicationRecordInterface::ListApplicationRecord>, "ListApplicationRecord"},
+        {2, D<&IReadOnlyApplicationRecordInterface::IsDataCorruptedResult>,
+         "IsDataCorruptedResult"},
+        {3, D<&IReadOnlyApplicationRecordInterface::ListApplicationRecord>,
+         "ListApplicationRecord"},
     };
     // clang-format on
 

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_a32.cpp

@@ -34,7 +34,8 @@ oaknut::Label EmitA32Cond(oaknut::CodeGenerator& code, EmitContext&, IR::Cond co
     return pass;
 }
 
-void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
+void EmitA32LeafTerminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step);
+void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step);
 
 void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
     EmitRelocation(code, ctx, LinkTarget::ReturnToDispatcher);
@@ -125,31 +126,53 @@ void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Fa
 
 void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     oaknut::Label pass = EmitA32Cond(code, ctx, terminal.if_);
-    EmitA32Terminal(code, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA32LeafTerminal(code, ctx, terminal.else_, initial_location, is_single_step);
     code.l(pass);
-    EmitA32Terminal(code, ctx, terminal.then_, initial_location, is_single_step);
+    EmitA32LeafTerminal(code, ctx, terminal.then_, initial_location, is_single_step);
 }
 
 void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     oaknut::Label fail;
     code.LDRB(Wscratch0, SP, offsetof(StackLayout, check_bit));
     code.CBZ(Wscratch0, fail);
-    EmitA32Terminal(code, ctx, terminal.then_, initial_location, is_single_step);
+    EmitA32LeafTerminal(code, ctx, terminal.then_, initial_location, is_single_step);
     code.l(fail);
-    EmitA32Terminal(code, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA32LeafTerminal(code, ctx, terminal.else_, initial_location, is_single_step);
 }
 
 void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     oaknut::Label fail;
     code.LDAR(Wscratch0, Xhalt);
     code.CBNZ(Wscratch0, fail);
-    EmitA32Terminal(code, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA32LeafTerminal(code, ctx, terminal.else_, initial_location, is_single_step);
     code.l(fail);
     EmitRelocation(code, ctx, LinkTarget::ReturnToDispatcher);
 }
 
-void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    boost::apply_visitor([&](const auto& t) { EmitA32Terminal(code, ctx, t, initial_location, is_single_step); }, terminal);
+void EmitA32LeafTerminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    if (auto const x = std::get_if<IR::Term::ReturnToDispatch>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlock>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlockFast>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::PopRSBHint>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::FastDispatchHint>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    UNREACHABLE();
+}
+
+void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    if (auto const x = std::get_if<IR::Term::LeafTerminal>(&terminal))
+        return EmitA32LeafTerminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::If>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckBit>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckHalt>(&terminal))
+        return EmitA32Terminal(code, ctx, *x, initial_location, is_single_step);
+    UNREACHABLE();
 }
 
 void EmitA32Terminal(oaknut::CodeGenerator& code, EmitContext& ctx) {

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_a64.cpp

@@ -33,7 +33,8 @@ oaknut::Label EmitA64Cond(oaknut::CodeGenerator& code, EmitContext&, IR::Cond co
     return pass;
 }
 
-void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
+void EmitA64LeafTerminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step);
+void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step);
 
 void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
     EmitRelocation(code, ctx, LinkTarget::ReturnToDispatcher);
@@ -108,31 +109,53 @@ void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Fa
 
 void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     oaknut::Label pass = EmitA64Cond(code, ctx, terminal.if_);
-    EmitA64Terminal(code, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA64LeafTerminal(code, ctx, terminal.else_, initial_location, is_single_step);
     code.l(pass);
-    EmitA64Terminal(code, ctx, terminal.then_, initial_location, is_single_step);
+    EmitA64LeafTerminal(code, ctx, terminal.then_, initial_location, is_single_step);
 }
 
 void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     oaknut::Label fail;
     code.LDRB(Wscratch0, SP, offsetof(StackLayout, check_bit));
     code.CBZ(Wscratch0, fail);
-    EmitA64Terminal(code, ctx, terminal.then_, initial_location, is_single_step);
+    EmitA64LeafTerminal(code, ctx, terminal.then_, initial_location, is_single_step);
     code.l(fail);
-    EmitA64Terminal(code, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA64LeafTerminal(code, ctx, terminal.else_, initial_location, is_single_step);
 }
 
 void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     oaknut::Label fail;
     code.LDAR(Wscratch0, Xhalt);
     code.CBNZ(Wscratch0, fail);
-    EmitA64Terminal(code, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA64LeafTerminal(code, ctx, terminal.else_, initial_location, is_single_step);
     code.l(fail);
     EmitRelocation(code, ctx, LinkTarget::ReturnToDispatcher);
 }
 
-void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    boost::apply_visitor([&](const auto& t) { EmitA64Terminal(code, ctx, t, initial_location, is_single_step); }, terminal);
+void EmitA64LeafTerminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    if (auto const x = std::get_if<IR::Term::ReturnToDispatch>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlock>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlockFast>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::PopRSBHint>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::FastDispatchHint>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    UNREACHABLE();
+}
+
+void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx, IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    if (auto const x = std::get_if<IR::Term::LeafTerminal>(&terminal))
+        return EmitA64LeafTerminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::If>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckBit>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckHalt>(&terminal))
+        return EmitA64Terminal(code, ctx, *x, initial_location, is_single_step);
+    UNREACHABLE();
 }
 
 void EmitA64Terminal(oaknut::CodeGenerator& code, EmitContext& ctx) {

src/dynarmic/src/dynarmic/backend/riscv64/emit_riscv64_a32.cpp

@@ -112,6 +112,7 @@ void EmitA32Cond(biscuit::Assembler& as, EmitContext&, IR::Cond cond, biscuit::L
     }
 }
 
+void EmitA32LeafTerminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::LeafTerminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step);
 
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
@@ -170,18 +171,18 @@ void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::FastDis
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     biscuit::Label pass;
     EmitA32Cond(as, ctx, terminal.if_, &pass);
-    EmitA32Terminal(as, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA32LeafTerminal(as, ctx, terminal.else_, initial_location, is_single_step);
     as.Bind(&pass);
-    EmitA32Terminal(as, ctx, terminal.then_, initial_location, is_single_step);
+    EmitA32LeafTerminal(as, ctx, terminal.then_, initial_location, is_single_step);
 }
 
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     biscuit::Label fail;
     as.LBU(Xscratch0, offsetof(StackLayout, check_bit), Xstate);
     as.BEQZ(Xscratch0, &fail);
-    EmitA32Terminal(as, ctx, terminal.then_, initial_location, is_single_step);
+    EmitA32LeafTerminal(as, ctx, terminal.then_, initial_location, is_single_step);
     as.Bind(&fail);
-    EmitA32Terminal(as, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA32LeafTerminal(as, ctx, terminal.else_, initial_location, is_single_step);
 }
 
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
@@ -189,13 +190,35 @@ void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::CheckHa
     as.LWU(Xscratch0, 0, Xhalt);
     as.FENCE(biscuit::FenceOrder::RW, biscuit::FenceOrder::RW);
     as.BNEZ(Xscratch0, &fail);
-    EmitA32Terminal(as, ctx, terminal.else_, initial_location, is_single_step);
+    EmitA32LeafTerminal(as, ctx, terminal.else_, initial_location, is_single_step);
     as.Bind(&fail);
     EmitRelocation(as, ctx, LinkTarget::ReturnFromRunCode);
 }
 
+void EmitA32LeafTerminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::LeafTerminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+    if (auto const x = std::get_if<IR::Term::ReturnToDispatch>(&terminal))
+        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlock>(&terminal))
+        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlockFast>(&terminal))
+        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::PopRSBHint>(&terminal))
+        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::FastDispatchHint>(&terminal))
+        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+    UNREACHABLE();
+}
+
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx, IR::Term::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
-    boost::apply_visitor([&](const auto& t) { EmitA32Terminal(as, ctx, t, initial_location, is_single_step); }, terminal);
+    if (auto const x = std::get_if<IR::Term::LeafTerminal>(&terminal))
+        return EmitA32LeafTerminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::If>(&terminal))
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckBit>(&terminal))
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckHalt>(&terminal))
+        return EmitA32Terminal(as, ctx, *x, initial_location, is_single_step);
+    UNREACHABLE();
 }
 
 void EmitA32Terminal(biscuit::Assembler& as, EmitContext& ctx) {

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.cpp

@@ -175,7 +175,7 @@ finish_this_inst:
     if (conf.enable_cycle_counting)
         EmitAddCycles(block.CycleCount());
     code.mov(rbp, code.qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, abi_base_pointer)]);
-    EmitTerminal(block.GetTerminal(), ctx.Location().SetSingleStepping(false), ctx.IsSingleStep());
+    EmitTerminal(block.terminal, ctx.Location().SetSingleStepping(false), ctx.IsSingleStep());
     code.int3();
 
     for (auto& deferred_emit : ctx.deferred_emits)
@@ -219,7 +219,7 @@ void A32EmitX64::EmitCondPrelude(const A32EmitContext& ctx) {
     if (conf.enable_cycle_counting) {
         EmitAddCycles(ctx.block.ConditionFailedCycleCount());
     }
-    EmitTerminal(IR::Term::LinkBlock{ctx.block.ConditionFailedLocation()}, ctx.Location().SetSingleStepping(false), ctx.IsSingleStep());
+    EmitLeafTerminal(IR::Term::LinkBlock{ctx.block.ConditionFailedLocation()}, ctx.Location().SetSingleStepping(false), ctx.IsSingleStep());
     code.L(pass);
 }
 
@@ -1155,11 +1155,12 @@ void A32EmitX64::EmitSetUpperLocationDescriptor(IR::LocationDescriptor new_locat
 }
 
 namespace {
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
     e.code.ReturnFromRunCode();
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::LinkBlock terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::LinkBlock terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     e.EmitSetUpperLocationDescriptor(terminal.next, initial_location);
     if (!e.conf.HasOptimization(OptimizationFlag::BlockLinking) || is_single_step) {
         e.code.mov(MJitStateReg(A32::Reg::PC), A32::LocationDescriptor{terminal.next}.PC());
@@ -1186,9 +1187,10 @@ void EmitTerminalImpl(A32EmitX64& e, IR::Term::LinkBlock terminal, IR::LocationD
         e.PushRSBHelper(rax, rbx, terminal.next);
         e.code.ForceReturnFromRunCode();
     }
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::LinkBlockFast terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::LinkBlockFast terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     e.EmitSetUpperLocationDescriptor(terminal.next, initial_location);
     if (!e.conf.HasOptimization(OptimizationFlag::BlockLinking) || is_single_step) {
         e.code.mov(MJitStateReg(A32::Reg::PC), A32::LocationDescriptor{terminal.next}.PC());
@@ -1201,55 +1203,78 @@ void EmitTerminalImpl(A32EmitX64& e, IR::Term::LinkBlockFast terminal, IR::Locat
             e.EmitPatchJmp(terminal.next);
         }
     }
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::PopRSBHint, IR::LocationDescriptor, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::PopRSBHint, IR::LocationDescriptor, bool is_single_step) {
     if (!e.conf.HasOptimization(OptimizationFlag::ReturnStackBuffer) || is_single_step) {
         e.code.ReturnFromRunCode();
     } else {
         e.code.jmp(e.terminal_handler_pop_rsb_hint);
     }
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::FastDispatchHint, IR::LocationDescriptor, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::FastDispatchHint, IR::LocationDescriptor, bool is_single_step) {
     if (!e.conf.HasOptimization(OptimizationFlag::FastDispatch) || is_single_step) {
         e.code.ReturnFromRunCode();
     } else {
         e.code.jmp(e.terminal_handler_fast_dispatch_hint);
     }
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     Xbyak::Label pass = e.EmitCond(terminal.if_);
-    e.EmitTerminal(terminal.else_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.else_, initial_location, is_single_step);
     e.code.L(pass);
-    e.EmitTerminal(terminal.then_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.then_, initial_location, is_single_step);
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     Xbyak::Label fail;
     e.code.cmp(e.code.byte[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, check_bit)], u8(0));
     e.code.jz(fail);
-    e.EmitTerminal(terminal.then_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.then_, initial_location, is_single_step);
     e.code.L(fail);
-    e.EmitTerminal(terminal.else_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.else_, initial_location, is_single_step);
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64& e, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A32EmitX64& e, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     e.code.cmp(dword[e.code.ABI_JIT_PTR + offsetof(A32JitState, halt_reason)], 0);
     e.code.jne(e.code.GetForceReturnFromRunCodeAddress());
-    e.EmitTerminal(terminal.else_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.else_, initial_location, is_single_step);
+    return true;
 }
 
-void EmitTerminalImpl(A32EmitX64&, IR::Term::Invalid, IR::LocationDescriptor, bool) {
+}
+
+bool A32EmitX64::EmitLeafTerminal(IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept {
+    if (auto const x = std::get_if<IR::Term::ReturnToDispatch>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlock>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlockFast>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::PopRSBHint>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::FastDispatchHint>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
     UNREACHABLE();
 }
-}
 
-void A32EmitX64::EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept {
-    boost::apply_visitor([this, initial_location, is_single_step](auto x) {
-        EmitTerminalImpl(*this, x, initial_location, is_single_step);
-    }, terminal);
+bool A32EmitX64::EmitTerminal(IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept {
+    if (auto const e = std::get_if<IR::Term::LeafTerminal>(&terminal))
+        return EmitLeafTerminal(*e, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::If>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckBit>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckHalt>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    UNREACHABLE();
 }
 
 void A32EmitX64::EmitPatchJg(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr) {

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64.h

@@ -112,7 +112,8 @@ public:
 
     // Terminal instruction emitters
     void EmitSetUpperLocationDescriptor(IR::LocationDescriptor new_location, IR::LocationDescriptor old_location);
-    void EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept override;
+    bool EmitLeafTerminal(IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept override;
+    bool EmitTerminal(IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept override;
 
     // Patching
     void Unpatch(const IR::LocationDescriptor& target_desc) override;

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.cpp

@@ -12,6 +12,7 @@
 #include <fmt/ostream.h>
 #include "common/assert.h"
 #include "common/common_types.h"
+#include "dynarmic/ir/terminal.h"
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include <boost/container/static_vector.hpp>
 
@@ -147,7 +148,7 @@ finish_this_inst:
     if (conf.enable_cycle_counting)
         EmitAddCycles(block.CycleCount());
     code.mov(rbp, code.qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, abi_base_pointer)]);
-    EmitTerminal(block.GetTerminal(), ctx.Location().SetSingleStepping(false), ctx.IsSingleStep());
+    EmitTerminal(block.terminal, ctx.Location().SetSingleStepping(false), ctx.IsSingleStep());
     code.int3();
     for (auto& deferred_emit : ctx.deferred_emits)
         deferred_emit();
@@ -617,11 +618,12 @@ std::string A64EmitX64::LocationDescriptorToFriendlyName(const IR::LocationDescr
 }
 
 namespace {
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::ReturnToDispatch, IR::LocationDescriptor, bool) {
     e.code.ReturnFromRunCode();
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::LinkBlock terminal, IR::LocationDescriptor, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::LinkBlock terminal, IR::LocationDescriptor, bool is_single_step) {
     // Used for patches and linking
     if (e.conf.HasOptimization(OptimizationFlag::BlockLinking) && !is_single_step) {
         if (e.conf.enable_cycle_counting) {
@@ -649,9 +651,10 @@ void EmitTerminalImpl(A64EmitX64& e, IR::Term::LinkBlock terminal, IR::LocationD
         e.code.mov(qword[e.code.ABI_JIT_PTR + offsetof(A64JitState, pc)], rax);
         e.code.ReturnFromRunCode();
     }
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::LinkBlockFast terminal, IR::LocationDescriptor, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::LinkBlockFast terminal, IR::LocationDescriptor, bool is_single_step) {
     if (e.conf.HasOptimization(OptimizationFlag::BlockLinking) && !is_single_step) {
         e.patch_information[terminal.next].jmp.push_back(e.code.getCurr());
         if (auto next_bb = e.GetBasicBlock(terminal.next)) {
@@ -664,63 +667,86 @@ void EmitTerminalImpl(A64EmitX64& e, IR::Term::LinkBlockFast terminal, IR::Locat
         e.code.mov(qword[e.code.ABI_JIT_PTR + offsetof(A64JitState, pc)], rax);
         e.code.ReturnFromRunCode();
     }
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::PopRSBHint, IR::LocationDescriptor, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::PopRSBHint, IR::LocationDescriptor, bool is_single_step) {
     if (e.conf.HasOptimization(OptimizationFlag::ReturnStackBuffer) && !is_single_step) {
         e.code.jmp(e.terminal_handler_pop_rsb_hint);
     } else {
         e.code.ReturnFromRunCode();
     }
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::FastDispatchHint, IR::LocationDescriptor, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::FastDispatchHint, IR::LocationDescriptor, bool is_single_step) {
     if (!e.conf.HasOptimization(OptimizationFlag::FastDispatch) || is_single_step) {
         e.code.ReturnFromRunCode();
     } else {
         e.code.jmp(e.terminal_handler_fast_dispatch_hint);
     }
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::If terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     switch (terminal.if_) {
     case IR::Cond::AL:
     case IR::Cond::NV:
-        e.EmitTerminal(terminal.then_, initial_location, is_single_step);
+        e.EmitLeafTerminal(terminal.then_, initial_location, is_single_step);
         break;
     default:
         Xbyak::Label pass = e.EmitCond(terminal.if_);
-        e.EmitTerminal(terminal.else_, initial_location, is_single_step);
+        e.EmitLeafTerminal(terminal.else_, initial_location, is_single_step);
         e.code.L(pass);
-        e.EmitTerminal(terminal.then_, initial_location, is_single_step);
+        e.EmitLeafTerminal(terminal.then_, initial_location, is_single_step);
         break;
     }
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::CheckBit terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     Xbyak::Label fail;
     e.code.cmp(e.code.byte[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, check_bit)], u8(0));
     e.code.jz(fail);
-    e.EmitTerminal(terminal.then_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.then_, initial_location, is_single_step);
     e.code.L(fail);
-    e.EmitTerminal(terminal.else_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.else_, initial_location, is_single_step);
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64& e, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
+bool EmitTerminalImpl(A64EmitX64& e, IR::Term::CheckHalt terminal, IR::LocationDescriptor initial_location, bool is_single_step) {
     e.code.cmp(dword[e.code.ABI_JIT_PTR + offsetof(A64JitState, halt_reason)], 0);
     e.code.jne(e.code.GetForceReturnFromRunCodeAddress());
-    e.EmitTerminal(terminal.else_, initial_location, is_single_step);
+    e.EmitLeafTerminal(terminal.else_, initial_location, is_single_step);
+    return true;
 }
 
-void EmitTerminalImpl(A64EmitX64&, IR::Term::Invalid, IR::LocationDescriptor, bool) {
+}
+
+bool A64EmitX64::EmitLeafTerminal(IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept {
+    if (auto const x = std::get_if<IR::Term::ReturnToDispatch>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlock>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::LinkBlockFast>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::PopRSBHint>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::FastDispatchHint>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
     UNREACHABLE();
 }
-}
 
-void A64EmitX64::EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept {
-    boost::apply_visitor([this, initial_location, is_single_step](auto x) {
-        EmitTerminalImpl(*this, x, initial_location, is_single_step);
-    }, terminal);
+bool A64EmitX64::EmitTerminal(IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept {
+    if (auto const x = std::get_if<IR::Term::LeafTerminal>(&terminal))
+        return EmitLeafTerminal(*x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::If>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckBit>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    if (auto const x = std::get_if<IR::Term::CheckHalt>(&terminal))
+        return EmitTerminalImpl(*this, *x, initial_location, is_single_step);
+    UNREACHABLE();
 }
 
 void A64EmitX64::EmitPatchJg(const IR::LocationDescriptor& target_desc, CodePtr target_code_ptr) {

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64.h

@@ -107,7 +107,8 @@ public:
     void EmitExclusiveWriteMemoryInline(A64EmitContext& ctx, IR::Inst* inst);
 
     // Terminal instruction emitters
-    void EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept override;
+    bool EmitLeafTerminal(IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept override;
+    bool EmitTerminal(IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept override;
 
     // Patching
     void Unpatch(const IR::LocationDescriptor& target_desc) override;

src/dynarmic/src/dynarmic/backend/x64/emit_x64.h

@@ -111,7 +111,8 @@ public:
 #ifndef NDEBUG
     void EmitVerboseDebuggingOutput(RegAlloc& reg_alloc);
 #endif
-    virtual void EmitTerminal(IR::Terminal terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept = 0;
+    virtual bool EmitLeafTerminal(IR::Term::LeafTerminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept = 0;
+    virtual bool EmitTerminal(IR::Term::Terminal const& terminal, IR::LocationDescriptor initial_location, bool is_single_step) noexcept = 0;
 
     // Patching
     struct PatchInformation {

src/dynarmic/src/dynarmic/ir/basic_block.cpp

@@ -66,43 +66,44 @@ void Block::Reset(LocationDescriptor location_) noexcept {
     location = location_;
     end_location = location_;
     cond = Cond::AL;
-    terminal = Term::Invalid{};
+    terminal = std::monostate{};
     cond_failed_cycle_count = 0;
     cycle_count = 0;
     ASSERT(instructions.size() == 0);
 }
 
-static std::string TerminalToString(const Terminal& terminal_variant) noexcept {
-    struct : boost::static_visitor<std::string> {
-        std::string operator()(const Term::Invalid&) const {
-            return "<invalid terminal>";
-        }
-        std::string operator()(const Term::ReturnToDispatch&) const {
-            return "ReturnToDispatch{}";
-        }
-        std::string operator()(const Term::LinkBlock& terminal) const {
-            return fmt::format("LinkBlock{{{}}}", terminal.next);
-        }
-        std::string operator()(const Term::LinkBlockFast& terminal) const {
-            return fmt::format("LinkBlockFast{{{}}}", terminal.next);
-        }
-        std::string operator()(const Term::PopRSBHint&) const {
-            return "PopRSBHint{}";
-        }
-        std::string operator()(const Term::FastDispatchHint&) const {
-            return "FastDispatchHint{}";
-        }
-        std::string operator()(const Term::If& terminal) const {
-            return fmt::format("If{{{}, {}, {}}}", A64::CondToString(terminal.if_), TerminalToString(terminal.then_), TerminalToString(terminal.else_));
-        }
-        std::string operator()(const Term::CheckBit& terminal) const {
-            return fmt::format("CheckBit{{{}, {}}}", TerminalToString(terminal.then_), TerminalToString(terminal.else_));
-        }
-        std::string operator()(const Term::CheckHalt& terminal) const {
-            return fmt::format("CheckHalt{{{}}}", TerminalToString(terminal.else_));
-        }
-    } visitor;
-    return boost::apply_visitor(visitor, terminal_variant);
+static std::string TerminalToString(const Term::Terminal& terminal_variant) noexcept {
+    // struct : boost::static_visitor<std::string> {
+    //     std::string operator()(const std::monostate&) const {
+    //         return "<invalid>";
+    //     }
+    //     std::string operator()(const Term::ReturnToDispatch&) const {
+    //         return "ReturnToDispatch{}";
+    //     }
+    //     std::string operator()(const Term::LinkBlock& terminal) const {
+    //         return fmt::format("LinkBlock{{{}}}", terminal.next);
+    //     }
+    //     std::string operator()(const Term::LinkBlockFast& terminal) const {
+    //         return fmt::format("LinkBlockFast{{{}}}", terminal.next);
+    //     }
+    //     std::string operator()(const Term::PopRSBHint&) const {
+    //         return "PopRSBHint{}";
+    //     }
+    //     std::string operator()(const Term::FastDispatchHint&) const {
+    //         return "FastDispatchHint{}";
+    //     }
+    //     std::string operator()(const Term::If& terminal) const {
+    //         return fmt::format("If{{{}, {}, {}}}", A64::CondToString(terminal.if_), TerminalToString(terminal.then_), TerminalToString(terminal.else_));
+    //     }
+    //     std::string operator()(const Term::CheckBit& terminal) const {
+    //         return fmt::format("CheckBit{{{}, {}}}", TerminalToString(terminal.then_), TerminalToString(terminal.else_));
+    //     }
+    //     std::string operator()(const Term::CheckHalt& terminal) const {
+    //         return fmt::format("CheckHalt{{{}}}", TerminalToString(terminal.else_));
+    //     }
+    // } visitor;
+    // return boost::apply_visitor(visitor, terminal_variant);
+    return "";
 }
 
 std::string DumpBlock(const IR::Block& block) noexcept {

src/dynarmic/src/dynarmic/ir/basic_block.h

@@ -114,22 +114,22 @@ public:
     }
 
     /// Gets the terminal instruction for this basic block.
-    inline Terminal GetTerminal() const noexcept {
+    inline Term::Terminal GetTerminal() const noexcept {
         return terminal;
     }
     /// Sets the terminal instruction for this basic block.
-    inline void SetTerminal(Terminal term) noexcept {
+    inline void SetTerminal(Term::Terminal term) noexcept {
         ASSERT(!HasTerminal() && "Terminal has already been set.");
         terminal = std::move(term);
     }
     /// Replaces the terminal instruction for this basic block.
-    inline void ReplaceTerminal(Terminal term) noexcept {
+    inline void ReplaceTerminal(Term::Terminal term) noexcept {
         ASSERT(HasTerminal() && "Terminal has not been set.");
         terminal = std::move(term);
     }
     /// Determines whether or not this basic block has a terminal instruction.
     inline bool HasTerminal() const noexcept {
-        return terminal.which() != 0;
+        return !std::holds_alternative<std::monostate>(terminal);
     }
 
     /// Gets a mutable reference to the cycle count for this basic block.
@@ -156,7 +156,7 @@ public:
     /// Conditional to pass in order to execute this block
     Cond cond = Cond::AL;
     /// Terminal instruction of this block.
-    Terminal terminal = Term::Invalid{};
+    Term::Terminal terminal = std::monostate{};
     /// Number of cycles this block takes to execute if the conditional fails.
     size_t cond_failed_cycle_count = 0;
     /// Number of cycles this block takes to execute.

src/dynarmic/src/dynarmic/ir/ir_emitter.h

@@ -2943,7 +2943,7 @@ public:
         Inst(Opcode::CallHostFunction, Imm64(std::bit_cast<u64>(fn)), arg1, arg2, arg3);
     }
 
-    void SetTerm(const Terminal& terminal) {
+    void SetTerm(const Term::Terminal& terminal) {
         block.SetTerminal(terminal);
     }
 

src/dynarmic/src/dynarmic/ir/terminal.h

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <boost/variant.hpp>
+#include <variant>
 #include "common/common_types.h"
 
 #include "dynarmic/ir/cond.h"
@@ -17,106 +17,89 @@
 namespace Dynarmic::IR {
 namespace Term {
 
-struct Invalid {};
-
-/**
- * This terminal instruction returns control to the dispatcher.
- * The dispatcher will use the current cpu state to determine what comes next.
- */
+/// This terminal instruction returns control to the dispatcher.
+/// The dispatcher will use the current cpu state to determine what comes next.
 struct ReturnToDispatch {};
 
-/**
- * This terminal instruction jumps to the basic block described by `next` if we have enough
- * cycles remaining. If we do not have enough cycles remaining, we return to the
- * dispatcher, which will return control to the host.
- */
+/// This terminal instruction jumps to the basic block described by `next` if we have enough
+/// cycles remaining. If we do not have enough cycles remaining, we return to the
+/// dispatcher, which will return control to the host.
 struct LinkBlock {
-    explicit LinkBlock(const LocationDescriptor& next_)
-            : next(next_) {}
+    explicit LinkBlock(const LocationDescriptor& next_) : next(next_) {}
     LocationDescriptor next;  ///< Location descriptor for next block.
 };
 
-/**
- * This terminal instruction jumps to the basic block described by `next` unconditionally.
- * This is an optimization and MUST only be emitted when this is guaranteed not to result
- * in hanging, even in the face of other optimizations. (In practice, this means that only
- * forward jumps to short-ish blocks would use this instruction.)
- * A backend that doesn't support this optimization may choose to implement this exactly
- * as LinkBlock.
- */
+/// This terminal instruction jumps to the basic block described by `next` unconditionally.
+/// This is an optimization and MUST only be emitted when this is guaranteed not to result
+/// in hanging, even in the face of other optimizations. (In practice, this means that only
+/// forward jumps to short-ish blocks would use this instruction.)
+/// A backend that doesn't support this optimization may choose to implement this exactly
+/// as LinkBlock.
 struct LinkBlockFast {
-    explicit LinkBlockFast(const LocationDescriptor& next_)
-            : next(next_) {}
+    explicit LinkBlockFast(const LocationDescriptor& next_) : next(next_) {}
     LocationDescriptor next;  ///< Location descriptor for next block.
 };
 
-/**
- * This terminal instruction checks the top of the Return Stack Buffer against the current
- * location descriptor. If RSB lookup fails, control is returned to the dispatcher.
- * This is an optimization for faster function calls. A backend that doesn't support
- * this optimization or doesn't have a RSB may choose to implement this exactly as
- * ReturnToDispatch.
- */
+/// This terminal instruction checks the top of the Return Stack Buffer against the current
+/// location descriptor. If RSB lookup fails, control is returned to the dispatcher.
+/// This is an optimization for faster function calls. A backend that doesn't support
+/// this optimization or doesn't have a RSB may choose to implement this exactly as
+/// ReturnToDispatch.
 struct PopRSBHint {};
 
-/**
- * This terminal instruction performs a lookup of the current location descriptor in the
- * fast dispatch lookup table. A backend that doesn't support this optimization may choose
- * to implement this exactly as ReturnToDispatch.
- */
+/// This terminal instruction performs a lookup of the current location descriptor in the
+/// fast dispatch lookup table. A backend that doesn't support this optimization may choose
+/// to implement this exactly as ReturnToDispatch.
 struct FastDispatchHint {};
 
 struct If;
 struct CheckBit;
 struct CheckHalt;
-/// A Terminal is the terminal instruction in a MicroBlock.
-using Terminal = boost::variant<
-    Invalid,
+
+/// Non recursive kind of terminal
+using LeafTerminal = std::variant<
+    std::monostate,
     ReturnToDispatch,
     LinkBlock,
     LinkBlockFast,
     PopRSBHint,
-    FastDispatchHint,
-    boost::recursive_wrapper<If>,
-    boost::recursive_wrapper<CheckBit>,
-    boost::recursive_wrapper<CheckHalt>>;
+    FastDispatchHint
+>;
 
-/**
- * This terminal instruction conditionally executes one terminal or another depending
- * on the run-time state of the ARM flags.
- */
+/// A Terminal is the terminal instruction in a MicroBlock.
+using Terminal = std::variant<
+    std::monostate,
+    LeafTerminal,
+    If,
+    CheckBit,
+    CheckHalt
+>;
+
+/// This terminal instruction conditionally executes one terminal or another depending
+/// on the run-time state of the ARM flags.
 struct If {
-    If(Cond if_, Terminal then_, Terminal else_)
-            : if_(if_), then_(std::move(then_)), else_(std::move(else_)) {}
+    explicit If(Cond if_, LeafTerminal then_, LeafTerminal else_) : if_(if_), then_(std::move(then_)), else_(std::move(else_)) {}
     Cond if_;
-    Terminal then_;
-    Terminal else_;
+    LeafTerminal then_;
+    LeafTerminal else_;
 };
 
-/**
- * This terminal instruction conditionally executes one terminal or another depending
- * on the run-time state of the check bit.
- * then_ is executed if the check bit is non-zero, otherwise else_ is executed.
- */
+/// This terminal instruction conditionally executes one terminal or another depending
+/// on the run-time state of the check bit.
+/// then_ is executed if the check bit is non-zero, otherwise else_ is executed.
 struct CheckBit {
-    CheckBit(Terminal then_, Terminal else_)
-            : then_(std::move(then_)), else_(std::move(else_)) {}
-    Terminal then_;
-    Terminal else_;
+    explicit CheckBit(LeafTerminal then_, LeafTerminal else_) : then_(std::move(then_)), else_(std::move(else_)) {}
+    LeafTerminal then_;
+    LeafTerminal else_;
 };
 
-/**
- * This terminal instruction checks if a halt was requested. If it wasn't, else_ is
- * executed.
- */
+/// This terminal instruction checks if a halt was requested. If it wasn't, else_ is
+/// executed.
 struct CheckHalt {
-    explicit CheckHalt(Terminal else_)
-            : else_(std::move(else_)) {}
-    Terminal else_;
+    explicit CheckHalt(LeafTerminal else_) : else_(std::move(else_)) {}
+    LeafTerminal else_;
 };
 
 }  // namespace Term
 
-using Term::Terminal;
-
 }  // namespace Dynarmic::IR

src/dynarmic/tests/A32/fuzz_arm.cpp

@@ -43,32 +43,20 @@ namespace {
 using namespace Dynarmic;
 
 template<typename Fn>
-bool AnyLocationDescriptorForTerminalHas(IR::Terminal terminal, Fn fn) {
-    return boost::apply_visitor([&](auto t) -> bool {
-        using T = std::decay_t<decltype(t)>;
-        if constexpr (std::is_same_v<T, IR::Term::Invalid>) {
-            return false;
-        } else if constexpr (std::is_same_v<T, IR::Term::ReturnToDispatch>) {
-            return false;
-        } else if constexpr (std::is_same_v<T, IR::Term::LinkBlock>) {
-            return fn(t.next);
-        } else if constexpr (std::is_same_v<T, IR::Term::LinkBlockFast>) {
-            return fn(t.next);
-        } else if constexpr (std::is_same_v<T, IR::Term::PopRSBHint>) {
-            return false;
-        } else if constexpr (std::is_same_v<T, IR::Term::FastDispatchHint>) {
-            return false;
-        } else if constexpr (std::is_same_v<T, IR::Term::If>) {
-            return AnyLocationDescriptorForTerminalHas(t.then_, fn) || AnyLocationDescriptorForTerminalHas(t.else_, fn);
-        } else if constexpr (std::is_same_v<T, IR::Term::CheckBit>) {
-            return AnyLocationDescriptorForTerminalHas(t.then_, fn) || AnyLocationDescriptorForTerminalHas(t.else_, fn);
-        } else if constexpr (std::is_same_v<T, IR::Term::CheckHalt>) {
-            return AnyLocationDescriptorForTerminalHas(t.else_, fn);
-        } else {
-            ASSERT(false && "Invalid terminal type");
-            return false;
-        }
-    }, terminal);
+bool AnyLocationDescriptorForTerminalHas(IR::Term::Terminal terminal, Fn fn) {
+    if (auto const e = std::get_if<IR::Term::LeafTerminal>(&terminal)) {
+        if (auto const x = std::get_if<IR::Term::LinkBlock>(e))
+            return fn(x->next);
+        if (auto const x = std::get_if<IR::Term::LinkBlockFast>(e))
+            return fn(x->next);
+    }
+    if (auto const x = std::get_if<IR::Term::If>(&terminal))
+        return AnyLocationDescriptorForTerminalHas(x->then_, fn) || AnyLocationDescriptorForTerminalHas(x->else_, fn);
+    if (auto const x = std::get_if<IR::Term::CheckBit>(&terminal))
+        return AnyLocationDescriptorForTerminalHas(x->then_, fn) || AnyLocationDescriptorForTerminalHas(x->else_, fn);
+    if (auto const x = std::get_if<IR::Term::CheckHalt>(&terminal))
+        return AnyLocationDescriptorForTerminalHas(x->else_, fn);
+    return false;
 }
 
 bool ShouldTestInst(u32 instruction, u32 pc, bool is_thumb, bool is_last_inst, A32::ITState it_state = {}) {