Fix license headers

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

src/audio_core/renderer/sink/circular_buffer_sink_info.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -35,7 +38,7 @@ void CircularBufferSinkInfo::Update(BehaviorInfo::ErrorInfo& error_info, OutStat
     auto current_params{reinterpret_cast<CircularBufferInParameter*>(parameter.data())};
     auto current_state{reinterpret_cast<CircularBufferState*>(state.data())};
 
-    if (in_use == buffer_params->in_use && !buffer_unmapped) {
+    if (in_use == bool(buffer_params->in_use) && !buffer_unmapped) {
         error_info.error_code = ResultSuccess;
         error_info.address = CpuAddr(0);
         out_status.writeOffset = current_state->last_pos2;

src/audio_core/renderer/sink/sink_info_base.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
@@ -31,10 +31,10 @@ public:
     };
 
     struct DeviceInParameter {
-        /* 0x000 */ char name[0x100];
+        /* 0x000 */ u8 name[0x100];
         /* 0x100 */ u32 input_count;
         /* 0x104 */ std::array<s8, MaxChannels> inputs;
-        /* 0x10A */ char unk10A[0x1];
+        /* 0x10A */ u8 unk10A[0x1];
         /* 0x10B */ bool downmix_enabled;
         /* 0x10C */ std::array<f32, 4> downmix_coeff;
     };
@@ -43,7 +43,7 @@ public:
     struct DeviceState {
         /* 0x00 */ UpsamplerInfo* upsampler_info;
         /* 0x08 */ std::array<Common::FixedPoint<16, 16>, 4> downmix_coeff;
-        /* 0x18 */ char unk18[0x18];
+        /* 0x18 */ u8 unk18[0x18];
     };
     static_assert(sizeof(DeviceState) == 0x30, "DeviceState has the wrong size!");
 
@@ -55,8 +55,8 @@ public:
         /* 0x14 */ u32 previous_pos;
         /* 0x18 */ SampleFormat format;
         /* 0x1C */ std::array<s8, MaxChannels> inputs;
-        /* 0x22 */ bool in_use;
-        /* 0x23 */ char unk23[0x5];
+        /* 0x22 */ u8 in_use;
+        /* 0x23 */ u8 unk23[0x5];
     };
     static_assert(sizeof(CircularBufferInParameter) == 0x28,
                   "CircularBufferInParameter has the wrong size!");
@@ -65,16 +65,16 @@ public:
         /* 0x00 */ u32 last_pos2;
         /* 0x04 */ s32 current_pos;
         /* 0x08 */ u32 last_pos;
-        /* 0x0C */ char unk0C[0x4];
+        /* 0x0C */ u8 unk0C[0x4];
         /* 0x10 */ AddressInfo address_info;
     };
     static_assert(sizeof(CircularBufferState) == 0x30, "CircularBufferState has the wrong size!");
 
     struct InParameter {
         /* 0x000 */ Type type;
-        /* 0x001 */ bool in_use;
+        /* 0x001 */ u8 in_use;
         /* 0x004 */ u32 node_id;
-        /* 0x008 */ char unk08[0x18];
+        /* 0x008 */ u8 unk08[0x18];
         union {
             /* 0x020 */ DeviceInParameter device;
             /* 0x020 */ CircularBufferInParameter circular_buffer;
@@ -84,7 +84,7 @@ public:
 
     struct OutStatus {
         /* 0x00 */ u32 writeOffset;
-        /* 0x04 */ char unk04[0x1C];
+        /* 0x04 */ u8 unk04[0x1C];
     }; // size == 0x20
     static_assert(sizeof(OutStatus) == 0x20, "SinkInfoBase::OutStatus has the wrong size!");
 
@@ -162,19 +162,18 @@ public:
     u8* GetParameter();
 
 protected:
-    /// Type of this sink
-    Type type{Type::Invalid};
-    /// Is this sink in use?
-    bool in_use{};
-    /// Is this sink's buffer unmapped? Circular only
-    bool buffer_unmapped{};
-    /// Node id for this sink
-    u32 node_id{};
     /// State buffer for this sink
     std::array<u8, (std::max)(sizeof(DeviceState), sizeof(CircularBufferState))> state{};
     /// Parameter buffer for this sink
-    std::array<u8, (std::max)(sizeof(DeviceInParameter), sizeof(CircularBufferInParameter))>
-        parameter{};
+    std::array<u8, (std::max)(sizeof(DeviceInParameter), sizeof(CircularBufferInParameter))> parameter{};
+    /// Type of this sink
+    Type type{Type::Invalid};
+    /// Node id for this sink
+    u32 node_id{};
+    /// Is this sink in use?
+    bool in_use : 1 = false;
+    /// Is this sink's buffer unmapped? Circular only
+    bool buffer_unmapped : 1 = false;
 };
 
 } // namespace AudioCore::Renderer

src/common/error.cpp

@@ -17,35 +17,33 @@
 
 namespace Common {
 
+// glibc, mlibc, musl, and newlib all define their own variants of strerror_r
+// We don't need to use the preprocessor, we can just select depending on return type
+template<typename T> std::string HandleStrerrorR(T r, char *err_str);
+template<> std::string HandleStrerrorR(char* r, char *) { return std::string{r}; }
+template<> std::string HandleStrerrorR(const char* r, char *) { return std::string{r}; }
+template<> std::string HandleStrerrorR(int r, char *err_str) {
+    return std::string{r != 0
+        ? "(strerror_r failed to format error)"
+        : err_str};
+}
+
 std::string NativeErrorToString(int e) {
 #ifdef _WIN32
     LPSTR err_str;
-
     DWORD res = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER |
                                    FORMAT_MESSAGE_IGNORE_INSERTS,
                                nullptr, e, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
-    if (!res) {
-        return "(FormatMessageA failed to format error)";
+                               LPSTR(&err_str), 1, nullptr);
+    if (res) {
+        std::string ret(err_str);
+        LocalFree(err_str);
+        return ret;
     }
-    std::string ret(err_str);
-    LocalFree(err_str);
-    return ret;
+    return "(FormatMessageA failed to format error)";
 #else
     char err_str[255];
-#if defined(__ANDROID__) ||                                                                            \
-    (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600)))
-    // Thread safe (GNU-specific)
-    const char* str = strerror_r(e, err_str, sizeof(err_str));
-    return std::string(str);
-#else
-    // Thread safe (XSI-compliant)
-    int second_err = strerror_r(e, err_str, sizeof(err_str));
-    if (second_err != 0) {
-        return "(strerror_r failed to format error)";
-    }
-    return std::string(err_str);
-#endif // GLIBC etc.
+    return HandleStrerrorR(strerror_r(e, err_str, sizeof(err_str)), err_str);
 #endif // _WIN32
 }
 

src/core/core.cpp

@@ -428,8 +428,8 @@ struct System::Impl {
         core_timing.SyncPause(false);
         Network::CancelPendingSocketOperations();
         kernel.SuspendEmulation(true);
-        kernel.CloseServices();
         kernel.ShutdownCores();
+        kernel.CloseServices();
         services.reset();
         service_manager.reset();
         fs_controller.Reset();

src/core/file_sys/savedata_factory.cpp

@@ -9,7 +9,6 @@
 #include "common/logging.h"
 #include "common/uuid.h"
 #include "core/core.h"
-#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"
 
@@ -62,24 +61,17 @@ SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,
 
 SaveDataFactory::~SaveDataFactory() = default;
 
-std::string SaveDataFactory::GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const {
-    if (type == SaveDataType::Account || type == SaveDataType::Device) {
-        const auto requested_id = title_id != 0 ? title_id : program_id;
-        const auto parent_id = system.GetContentProvider().GetParentApplicationId(requested_id);
-        title_id = parent_id.value_or(requested_id);
-    }
-    return GetFullPath(program_id, dir, space, type, title_id, user_id, save_id);
-}
-
 VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
 
     return dir->CreateDirectoryRelative(save_directory);
 }
 
 VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
 
-    const auto save_directory = GetSaveDataPath(space, meta.type, meta.program_id, meta.user_id, meta.system_save_data_id);
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
@@ -162,7 +154,8 @@ std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future)
 
 SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
                                                u128 user_id) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->GetFile(GetSaveDataSizeFileName());
@@ -180,7 +173,8 @@ SaveDataSize SaveDataFactory::ReadSaveDataSize(SaveDataType type, u64 title_id,
 
 void SaveDataFactory::WriteSaveDataSize(SaveDataType type, u64 title_id, u128 user_id,
                                         SaveDataSize new_value) const {
-    const auto path = GetSaveDataPath(SaveDataSpaceId::User, type, title_id, user_id, 0);
+    const auto path =
+        GetFullPath(program_id, dir, SaveDataSpaceId::User, type, title_id, user_id, 0);
     const auto relative_dir = GetOrCreateDirectoryRelative(dir, path);
 
     const auto size_file = relative_dir->CreateFile(GetSaveDataSizeFileName());

src/core/file_sys/savedata_factory.h

@@ -50,7 +50,6 @@ public:
     void SetAutoCreate(bool state);
 
 private:
-    std::string GetSaveDataPath(SaveDataSpaceId space, SaveDataType type, u64 title_id, u128 user_id, u64 save_id) const;
     Core::System& system;
     ProgramId program_id;
     VirtualDir dir;

src/core/hle/kernel/global_scheduler_context.cpp

@@ -72,11 +72,9 @@ void GlobalSchedulerContext::UnregisterDummyThreadForWakeup(KThread* thread) noe
 
 void GlobalSchedulerContext::WakeupWaitingDummyThreads(KernelCore& kernel) noexcept {
     ASSERT(this->IsLocked());
-    if (m_woken_dummy_threads.size() > 0) {
-        for (auto* thread : m_woken_dummy_threads)
-            thread->DummyThreadEndWait(kernel);
-        m_woken_dummy_threads.clear();
-    }
+    for (auto* thread : m_woken_dummy_threads)
+        thread->DummyThreadEndWait(kernel);
+    m_woken_dummy_threads.clear();
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_thread.cpp

@@ -1236,14 +1236,10 @@ namespace Kernel {
         KScopedSchedulerLock sl{kernel};
 
         // Determine if this is the first termination request.
-        const bool first_request = [&]() -> bool {
-            // Perform an atomic compare-and-swap from false to true.
-            bool expected = false;
-            return m_termination_requested.compare_exchange_strong(expected, true);
-        }();
-
+        // Perform an atomic compare-and-swap from false to true.
+        bool expected = false;
         // If this is the first request, start termination procedure.
-        if (first_request) {
+        if (m_termination_requested.compare_exchange_strong(expected, true)) {
             // If the thread is in initialized state, just change state to terminated.
             if (this->GetState() == ThreadState::Initialized) {
                 m_thread_state = ThreadState::Terminated;

src/core/hle/kernel/kernel.cpp

@@ -967,12 +967,16 @@ Kernel::KHardwareTimer& KernelCore::HardwareTimer() {
     return *impl->hardware_timer;
 }
 
-KAutoObjectWithListContainer& KernelCore::ObjectListContainer() {
-    return *impl->global_object_list_container;
+KAutoObjectWithListContainer* KernelCore::ObjectListContainer() {
+    if (!impl->global_object_list_container)
+        return nullptr;
+    return std::addressof(*impl->global_object_list_container);
 }
 
-const KAutoObjectWithListContainer& KernelCore::ObjectListContainer() const {
-    return *impl->global_object_list_container;
+const KAutoObjectWithListContainer* KernelCore::ObjectListContainer() const {
+    if (!impl->global_object_list_container)
+        return nullptr;
+    return std::addressof(*impl->global_object_list_container);
 }
 
 void KernelCore::PrepareReschedule(std::size_t id) {
@@ -1001,16 +1005,10 @@ void KernelCore::UnregisterInUseObject(KAutoObject* object) {
 
 void KernelCore::RunServer(std::unique_ptr<Service::ServerManager>&& server_manager) {
     auto* manager = server_manager.get();
-
-    {
+    if (!impl->is_shutting_down) {
         std::scoped_lock lk{impl->server_lock};
-        if (impl->is_shutting_down) {
-            return;
-        }
-
         impl->server_managers.emplace_back(std::move(server_manager));
     }
-
     manager->LoopProcess();
 }
 

src/core/hle/kernel/kernel.h

@@ -175,9 +175,8 @@ public:
     /// Stops execution of 'id' core, in order to reschedule a new thread.
     void PrepareReschedule(std::size_t id);
 
-    KAutoObjectWithListContainer& ObjectListContainer();
-
-    const KAutoObjectWithListContainer& ObjectListContainer() const;
+    KAutoObjectWithListContainer* ObjectListContainer();
+    const KAutoObjectWithListContainer* ObjectListContainer() const;
 
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.

src/core/hle/kernel/slab_helpers.h

@@ -151,7 +151,8 @@ public:
         const bool is_initialized = this->IsInitialized();
         uintptr_t arg = 0;
         if (is_initialized) {
-            kernel.ObjectListContainer().Unregister(this);
+            if (auto const olc = kernel.ObjectListContainer(); olc)
+                olc->Unregister(this);
             arg = this->GetPostDestroyArgument();
             this->Finalize(kernel);
         }
@@ -175,7 +176,7 @@ public:
 public:
     static void InitializeSlabHeap(KernelCore& kernel, void* memory, size_t memory_size) {
         kernel.SlabHeap<Derived>().Initialize(memory, memory_size);
-        kernel.ObjectListContainer().Initialize();
+        kernel.ObjectListContainer()->Initialize();
     }
 
     static Derived* Create(KernelCore& kernel) {
@@ -186,7 +187,7 @@ public:
     }
 
     static void Register(KernelCore& kernel, Derived* obj) {
-        return kernel.ObjectListContainer().Register(obj);
+        return kernel.ObjectListContainer()->Register(obj);
     }
 
     static size_t GetObjectSize(KernelCore& kernel) {

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

@@ -29,6 +29,7 @@
 #include "core/hle/service/am/frontend/applet_web_browser.h"
 #include "core/hle/service/am/frontend/applets.h"
 #include "core/hle/service/am/service/storage.h"
+#include "core/hle/service/am/window_system.h"
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::AM::Frontend {
@@ -72,10 +73,16 @@ void FrontendApplet::PushInteractiveOutData(std::shared_ptr<IStorage> storage) {
 
 void FrontendApplet::Exit() {
     auto applet_ = applet.lock();
-
-    std::scoped_lock lk{applet_->lock};
-    applet_->is_completed = true;
-    applet_->state_changed_event.Signal(system.Kernel());
+    {
+        std::scoped_lock lk{applet_->lock};
+        applet_->is_completed = true;
+        applet_->state_changed_event.Signal(system.Kernel());
+    }
+    if (auto caller_applet = applet_->caller_applet.lock()) {
+        std::scoped_lock lk{caller_applet->lock};
+        std::erase(caller_applet->child_applets, applet_);
+    }
+    if (auto* window_system = system.GetAppletManager().GetWindowSystem()) window_system->RequestUpdate();
 }
 
 FrontendAppletSet::FrontendAppletSet() = default;

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

@@ -122,7 +122,10 @@ std::shared_ptr<ILibraryAppletAccessor> CreateGuestApplet(Core::System& system,
         auto broker = std::make_shared<AppletDataBroker>(system);
         applet->caller_applet = caller_applet;
         applet->caller_applet_broker = broker;
-        caller_applet->child_applets.push_back(applet);
+        {
+            std::scoped_lock lk{caller_applet->lock};
+            caller_applet->child_applets.push_back(applet);
+        }
         window_system.TrackApplet(applet, false);
         return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
     }
@@ -148,10 +151,10 @@ std::shared_ptr<ILibraryAppletAccessor> CreateFrontendApplet(Core::System& syste
     applet->caller_applet = caller_applet;
     applet->caller_applet_broker = storage;
     applet->frontend = system.GetFrontendAppletHolder().GetApplet(applet, applet_id, mode);
-    caller_applet->child_applets.push_back(applet);
-
-    window_system.TrackApplet(applet, false);
-
+    {
+        std::scoped_lock lk{caller_applet->lock};
+        caller_applet->child_applets.push_back(applet);
+    }
     return std::make_shared<ILibraryAppletAccessor>(system, storage, applet);
 }
 

src/core/memory/dmnt_cheat_vm.cpp

@@ -1,6 +1,15 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+// gcc14 bug
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
 #include "common/assert.h"
 #include "common/scope_exit.h"
 #include "core/memory/dmnt_cheat_types.h"
@@ -223,7 +232,10 @@ DmntCheatVm::Callbacks::~Callbacks() = default;
 bool DmntCheatVm::DecodeNextOpcode(CheatVmOpcode& out) {
     // If we've ever seen a decode failure, return false.
     bool valid = decode_success;
-    CheatVmOpcode opcode = {};
+    CheatVmOpcode opcode = {
+        .begin_conditional_block = false,
+        .opcode = {}
+    };
     SCOPE_EXIT {
         decode_success &= valid;
         if (valid) {
@@ -1266,3 +1278,8 @@ void DmntCheatVm::Execute(const CheatProcessMetadata& metadata) {
 }
 
 } // namespace Core::Memory
+
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif

src/core/memory/dmnt_cheat_vm.h

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
@@ -254,14 +254,16 @@ struct UnrecognizedInstruction {
 
 struct CheatVmOpcode {
     bool begin_conditional_block{};
-    std::variant<StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
-                 LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
-                 PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
-                 PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
-                 BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
-                 SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
-                 ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction>
-        opcode{};
+    std::variant<
+        std::monostate,
+        StoreStaticOpcode, BeginConditionalOpcode, EndConditionalOpcode, ControlLoopOpcode,
+        LoadRegisterStaticOpcode, LoadRegisterMemoryOpcode, StoreStaticToAddressOpcode,
+        PerformArithmeticStaticOpcode, BeginKeypressConditionalOpcode,
+        PerformArithmeticRegisterOpcode, StoreRegisterToAddressOpcode,
+        BeginRegisterConditionalOpcode, SaveRestoreRegisterOpcode,
+        SaveRestoreRegisterMaskOpcode, ReadWriteStaticRegisterOpcode, PauseProcessOpcode,
+        ResumeProcessOpcode, DebugLogOpcode, UnrecognizedInstruction
+    > opcode{};
 };
 
 class DmntCheatVm {

src/dynarmic/src/dynarmic/backend/arm64/a32_address_space.cpp

@@ -24,29 +24,65 @@
 namespace Dynarmic::Backend::Arm64 {
 
 template<auto mfp, typename T>
-static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitCallReadTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
-
     const auto info = Devirtualize<mfp>(this_);
-
     oaknut::Label l_addr, l_this;
-
     void* target = code.xptr<void*>();
+    // params = { this, vaddr, bitsize }
     code.LDR(X0, l_this);
+    // X1 = vaddr
+    code.MOV(X2, bitsize);
     code.LDR(Xscratch0, l_addr);
     code.BR(Xscratch0);
-
     code.align(8);
     code.l(l_this);
     code.dx(info.this_ptr);
     code.l(l_addr);
     code.dx(info.fn_ptr);
-
     return target;
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitCallWriteTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
+    using namespace oaknut::util;
+    const auto info = Devirtualize<mfp>(this_);
+    oaknut::Label l_addr, l_this;
+    void* target = code.xptr<void*>();
+    // params = { this, vaddr, value, bitsize }
+    code.LDR(X0, l_this);
+    // X1 = vaddr
+    // X2 = value
+    code.MOV(X3, bitsize);
+    code.LDR(Xscratch0, l_addr);
+    code.BR(Xscratch0);
+    code.align(8);
+    code.l(l_this);
+    code.dx(info.this_ptr);
+    code.l(l_addr);
+    code.dx(info.fn_ptr);
+    return target;
+}
+
+template<auto mfp, typename T>
+static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+    using namespace oaknut::util;
+    const auto info = Devirtualize<mfp>(this_);
+    oaknut::Label l_addr, l_this;
+    void* target = code.xptr<void*>();
+    code.LDR(X0, l_this);
+    code.LDR(Xscratch0, l_addr);
+    code.BR(Xscratch0);
+    code.align(8);
+    code.l(l_this);
+    code.dx(info.this_ptr);
+    code.l(l_addr);
+    code.dx(info.fn_ptr);
+    return target;
+}
+
+template<auto mfp, typename T>
+static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -59,6 +95,7 @@ static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_
     ABI_PushRegisters(code, save_regs, 0);
     code.LDR(X0, l_this);
     code.MOV(X1, Xscratch0);
+    code.MOV(X2, bitsize);
     code.LDR(Xscratch0, l_addr);
     code.BLR(Xscratch0);
     code.MOV(Xscratch0, X0);
@@ -101,7 +138,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -115,6 +152,7 @@ static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this
     code.LDR(X0, l_this);
     code.MOV(X1, Xscratch0);
     code.MOV(X2, Xscratch1);
+    code.MOV(X3, bitsize);
     code.LDR(Xscratch0, l_addr);
     code.BLR(Xscratch0);
     ABI_PopRegisters(code, save_regs, 0);
@@ -176,14 +214,27 @@ void A32AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-    prelude_info.read_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
-    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
+
+    prelude_info.read_memory_8 = EmitCallReadTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u8));
+    prelude_info.read_memory_16 = EmitCallReadTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u16));
+    prelude_info.read_memory_32 = EmitCallReadTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u32));
+    prelude_info.read_memory_64 = EmitCallReadTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u64));
+    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u8));
+    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u16));
+    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u32));
+    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u64));
     prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u8>(code, conf);
     prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u16>(code, conf);
     prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u32>(code, conf);
     prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A32::UserCallbacks::MemoryRead, u64>(code, conf);
-    prelude_info.write_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
-    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.write_memory_8 = EmitCallWriteTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u8));
+    prelude_info.write_memory_16 = EmitCallWriteTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u16));
+    prelude_info.write_memory_32 = EmitCallWriteTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u32));
+    prelude_info.write_memory_64 = EmitCallWriteTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u64));
+    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u8));
+    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u16));
+    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u32));
+    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u64));
     prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
     prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);
     prelude_info.exclusive_write_memory_32 = EmitExclusiveWriteCallTrampoline<&A32::UserCallbacks::MemoryWriteExclusive32, u32>(code, conf);

src/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cpp

@@ -23,29 +23,65 @@
 namespace Dynarmic::Backend::Arm64 {
 
 template<auto mfp, typename T>
-static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitCallReadTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
-
     const auto info = Devirtualize<mfp>(this_);
-
     oaknut::Label l_addr, l_this;
-
     void* target = code.xptr<void*>();
+    // params = { this, vaddr, bitsize }
     code.LDR(X0, l_this);
+    // X1 = vaddr
+    code.MOV(X2, bitsize);
     code.LDR(Xscratch0, l_addr);
     code.BR(Xscratch0);
-
     code.align(8);
     code.l(l_this);
     code.dx(info.this_ptr);
     code.l(l_addr);
     code.dx(info.fn_ptr);
-
     return target;
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitCallWriteTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
+    using namespace oaknut::util;
+    const auto info = Devirtualize<mfp>(this_);
+    oaknut::Label l_addr, l_this;
+    void* target = code.xptr<void*>();
+    // params = { this, vaddr, value, bitsize }
+    code.LDR(X0, l_this);
+    // X1 = vaddr
+    // X2 = value
+    code.MOV(X3, bitsize);
+    code.LDR(Xscratch0, l_addr);
+    code.BR(Xscratch0);
+    code.align(8);
+    code.l(l_this);
+    code.dx(info.this_ptr);
+    code.l(l_addr);
+    code.dx(info.fn_ptr);
+    return target;
+}
+
+template<auto mfp, typename T>
+static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+    using namespace oaknut::util;
+    const auto info = Devirtualize<mfp>(this_);
+    oaknut::Label l_addr, l_this;
+    void* target = code.xptr<void*>();
+    code.LDR(X0, l_this);
+    code.LDR(Xscratch0, l_addr);
+    code.BR(Xscratch0);
+    code.align(8);
+    code.l(l_this);
+    code.dx(info.this_ptr);
+    code.l(l_addr);
+    code.dx(info.fn_ptr);
+    return target;
+}
+
+template<auto mfp, typename T>
+static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -58,6 +94,7 @@ static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_
     ABI_PushRegisters(code, save_regs, 0);
     code.LDR(X0, l_this);
     code.MOV(X1, Xscratch0);
+    code.MOV(X2, bitsize);
     code.LDR(Xscratch0, l_addr);
     code.BLR(Xscratch0);
     code.MOV(Xscratch0, X0);
@@ -100,7 +137,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -114,6 +151,7 @@ static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this
     code.LDR(X0, l_this);
     code.MOV(X1, Xscratch0);
     code.MOV(X2, Xscratch1);
+    code.MOV(X3, bitsize);
     code.LDR(Xscratch0, l_addr);
     code.BLR(Xscratch0);
     ABI_PopRegisters(code, save_regs, 0);
@@ -342,18 +380,30 @@ void A64AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-    prelude_info.read_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.read_memory_8 = EmitCallReadTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u8));
+    prelude_info.read_memory_16 = EmitCallReadTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u16));
+    prelude_info.read_memory_32 = EmitCallReadTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u32));
+    prelude_info.read_memory_64 = EmitCallReadTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u64));
     prelude_info.read_memory_128 = EmitRead128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory_8 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u8));
+    prelude_info.wrapped_read_memory_16 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u16));
+    prelude_info.wrapped_read_memory_32 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u32));
+    prelude_info.wrapped_read_memory_64 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u64));
     prelude_info.wrapped_read_memory_128 = EmitWrappedRead128CallTrampoline(code, conf.callbacks);
     prelude_info.exclusive_read_memory_8 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u8>(code, conf);
     prelude_info.exclusive_read_memory_16 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u16>(code, conf);
     prelude_info.exclusive_read_memory_32 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u32>(code, conf);
     prelude_info.exclusive_read_memory_64 = EmitExclusiveReadCallTrampoline<&A64::UserCallbacks::MemoryRead, u64>(code, conf);
     prelude_info.exclusive_read_memory_128 = EmitExclusiveRead128CallTrampoline(code, conf);
-    prelude_info.write_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.write_memory_8 = EmitCallWriteTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u8));
+    prelude_info.write_memory_16 = EmitCallWriteTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u16));
+    prelude_info.write_memory_32 = EmitCallWriteTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u32));
+    prelude_info.write_memory_64 = EmitCallWriteTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u64));
     prelude_info.write_memory_128 = EmitWrite128CallTrampoline(code, conf.callbacks);
-    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory_8 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u8));
+    prelude_info.wrapped_write_memory_16 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u16));
+    prelude_info.wrapped_write_memory_32 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u32));
+    prelude_info.wrapped_write_memory_64 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u64));
     prelude_info.wrapped_write_memory_128 = EmitWrappedWrite128CallTrampoline(code, conf.callbacks);
     prelude_info.exclusive_write_memory_8 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive8, u8>(code, conf);
     prelude_info.exclusive_write_memory_16 = EmitExclusiveWriteCallTrampoline<&A64::UserCallbacks::MemoryWriteExclusive16, u16>(code, conf);

src/dynarmic/src/dynarmic/backend/arm64/address_space.cpp

@@ -147,44 +147,37 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
             break;
         // { this, vaddr, size }
         case LinkTarget::ReadMemory8:
-            c.LDR(X2, 1);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_8);
             break;
         case LinkTarget::ReadMemory16:
-            c.LDR(X2, 2);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_16);
             break;
         case LinkTarget::ReadMemory32:
-            c.LDR(X2, 4);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_32);
             break;
         case LinkTarget::ReadMemory64:
-            c.LDR(X2, 8);
-            c.BL(prelude_info.read_memory);
+            c.BL(prelude_info.read_memory_64);
             break;
         case LinkTarget::ReadMemory128:
             c.BL(prelude_info.read_memory_128);
             break;
         // { this, vaddr, size }
         case LinkTarget::WrappedReadMemory8:
-            c.LDR(X2, 1);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_8);
             break;
         case LinkTarget::WrappedReadMemory16:
-            c.LDR(X2, 2);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_16);
             break;
         case LinkTarget::WrappedReadMemory32:
-            c.LDR(X2, 4);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_32);
             break;
         case LinkTarget::WrappedReadMemory64:
-            c.LDR(X2, 8);
-            c.BL(prelude_info.wrapped_read_memory);
+            c.BL(prelude_info.wrapped_read_memory_64);
             break;
         case LinkTarget::WrappedReadMemory128:
             c.BL(prelude_info.wrapped_read_memory_128);
             break;
+        //
         case LinkTarget::ExclusiveReadMemory8:
             c.BL(prelude_info.exclusive_read_memory_8);
             break;
@@ -202,43 +195,37 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
             break;
         // { this, vaddr, value, size }
         case LinkTarget::WriteMemory8:
-            c.LDR(X3, 1);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_8);
             break;
         case LinkTarget::WriteMemory16:
-            c.LDR(X3, 2);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_16);
             break;
         case LinkTarget::WriteMemory32:
-            c.LDR(X3, 4);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_32);
             break;
         case LinkTarget::WriteMemory64:
-            c.LDR(X3, 8);
-            c.BL(prelude_info.write_memory);
+            c.BL(prelude_info.write_memory_64);
             break;
         case LinkTarget::WriteMemory128:
             c.BL(prelude_info.write_memory_128);
             break;
+        //
         case LinkTarget::WrappedWriteMemory8:
-            c.LDR(X3, 1);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_8);
             break;
         case LinkTarget::WrappedWriteMemory16:
-            c.LDR(X3, 2);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_16);
             break;
         case LinkTarget::WrappedWriteMemory32:
-            c.LDR(X3, 4);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_32);
             break;
         case LinkTarget::WrappedWriteMemory64:
-            c.LDR(X3, 8);
-            c.BL(prelude_info.wrapped_write_memory);
+            c.BL(prelude_info.wrapped_write_memory_64);
             break;
         case LinkTarget::WrappedWriteMemory128:
             c.BL(prelude_info.wrapped_write_memory_128);
             break;
+        //
         case LinkTarget::ExclusiveWriteMemory8:
             c.BL(prelude_info.exclusive_write_memory_8);
             break;

src/dynarmic/src/dynarmic/backend/arm64/address_space.h

@@ -93,18 +93,30 @@ protected:
         void* return_to_dispatcher;
         void* return_from_run_code;
 
-        void* read_memory;
+        void* read_memory_8;
+        void* read_memory_16;
+        void* read_memory_32;
+        void* read_memory_64;
         void* read_memory_128;
-        void* wrapped_read_memory;
+        void* wrapped_read_memory_8;
+        void* wrapped_read_memory_16;
+        void* wrapped_read_memory_32;
+        void* wrapped_read_memory_64;
         void* wrapped_read_memory_128;
         void* exclusive_read_memory_8;
         void* exclusive_read_memory_16;
         void* exclusive_read_memory_32;
         void* exclusive_read_memory_64;
         void* exclusive_read_memory_128;
-        void* write_memory;
+        void* write_memory_8;
+        void* write_memory_16;
+        void* write_memory_32;
+        void* write_memory_64;
         void* write_memory_128;
-        void* wrapped_write_memory;
+        void* wrapped_write_memory_8;
+        void* wrapped_write_memory_16;
+        void* wrapped_write_memory_32;
+        void* wrapped_write_memory_64;
         void* wrapped_write_memory_128;
         void* exclusive_write_memory_8;
         void* exclusive_write_memory_16;

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.h

@@ -170,13 +170,19 @@ template<>
 
     // check for marked bit, use as unmapped if marked
     if (ctx.conf.page_table_marked_bit) {
-        code.bt(page, *ctx.conf.page_table_marked_bit);
-        code.jc(abort, code.T_NEAR);
+        auto const marked_bit = *ctx.conf.page_table_marked_bit;
+        if (s64(s32(1 << marked_bit)) == s64(1 << marked_bit)) {
+            code.test(page, s32(1 << marked_bit));
+            code.jnz(abort, code.T_NEAR);
+        } else {
+            code.bt(page, marked_bit);
+            code.jc(abort, code.T_NEAR);
+        }
     }
     // mask away attributes
     if (ctx.conf.page_table_pointer_mask == 0) {
         code.test(page, page);
-    } else if (std::in_range<s32>(ctx.conf.page_table_pointer_mask)) {
+    } else if (s64(s32(ctx.conf.page_table_pointer_mask)) == s64(ctx.conf.page_table_pointer_mask)) {
         code.and_(page, ctx.conf.page_table_pointer_mask);
     } else {
         code.mov(tmp, ctx.conf.page_table_pointer_mask);

src/hid_core/resources/abstracted_pad/abstract_button_handler.cpp

@@ -79,8 +79,10 @@ void NpadAbstractButtonHandler::UpdateAllButtonLifo() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-        UpdateButtonLifo(npad_entry, data->aruid);
+        if (auto const shfmt = data->shared_memory_format; shfmt) {
+            auto& npad_entry = shfmt->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+            UpdateButtonLifo(npad_entry, data->aruid);
+        }
     }
 }
 
@@ -88,19 +90,19 @@ void NpadAbstractButtonHandler::UpdateCoreBatteryState() {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
     for (std::size_t i = 0; i < AruidIndexMax; i++) {
         auto* data = applet_resource_holder->applet_resource->GetAruidDataByIndex(i);
-        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-        UpdateButtonLifo(npad_entry, data->aruid);
+        if (auto const shfmt = data->shared_memory_format; shfmt) {
+            auto& npad_entry = shfmt->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+            UpdateButtonLifo(npad_entry, data->aruid);
+        }
     }
 }
 
 void NpadAbstractButtonHandler::UpdateButtonState(u64 aruid) {
     Core::HID::NpadIdType npad_id = properties_handler->GetNpadId();
-    auto* data = applet_resource_holder->applet_resource->GetAruidData(aruid);
-    if (data == nullptr) {
-        return;
+    if (auto data = applet_resource_holder->applet_resource->GetAruidData(aruid); data) {
+        auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
+        UpdateButtonLifo(npad_entry, aruid);
     }
-    auto& npad_entry = data->shared_memory_format->npad.npad_entry[NpadIdTypeToIndex(npad_id)];
-    UpdateButtonLifo(npad_entry, aruid);
 }
 
 Result NpadAbstractButtonHandler::SetHomeProtection(bool is_enabled, u64 aruid) {

src/shader_recompiler/backend/spirv/emit_spirv.cpp

@@ -496,31 +496,30 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
 }
 
 void PatchPhiNodes(IR::Program& program, EmitContext& ctx) {
-            // Flatten all leading PHIs from each block into a vector
-            std::vector<IR::Inst*> phi_instructions;
-            for (IR::Block* block : program.blocks) {
-                for (auto it = block->begin(); it != block->end(); ++it) {
-                    if (it->GetOpcode() != IR::Opcode::Phi)
-                        break;
-                    phi_instructions.push_back(&*it);
-                }
-            }
-
-            if (phi_instructions.empty()) {
-                return; // nothing to patch
-            }
-
-            // Start "before" first PHI; advance on phi_arg == 0
-            size_t phi_index = static_cast<size_t>(-1);
-
-            ctx.PatchDeferredPhi([&](size_t phi_arg, Id parent) -> std::pair<Id, Id> {
-                if (phi_arg == 0) {
-                    ++phi_index;
-                }
-                IR::Inst* phi = phi_instructions[phi_index];
-                return { ctx.Def(phi->Arg(phi_arg)), parent };
-            });
+    // Flatten all leading PHIs from each block into a vector
+    std::vector<IR::Inst*> phi_instructions;
+    for (IR::Block* block : program.blocks) {
+        for (auto it = block->begin(); it != block->end(); ++it) {
+            if (it->GetOpcode() != IR::Opcode::Phi)
+                break;
+            phi_instructions.push_back(&*it);
         }
+    }
+
+    if (phi_instructions.empty()) {
+        return; // nothing to patch
+    }
+
+    // Start "before" first PHI; advance on phi_arg == 0
+    size_t phi_index = size_t(-1);
+    ctx.PatchDeferredPhi([&ctx, &phi_index, phi_insts = std::move(phi_instructions)](size_t phi_arg, Id parent) -> std::pair<Id, Id> {
+        if (phi_arg == 0) {
+            ++phi_index;
+        }
+        IR::Inst* phi = phi_insts[phi_index];
+        return { ctx.Def(phi->Arg(phi_arg)), parent };
+    });
+}
 } // Anonymous namespace
 
 std::vector<u32> EmitSPIRV(const Profile& profile, const RuntimeInfo& runtime_info, IR::Program& program, Bindings& bindings) {