2026-09-19 11:52:09

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

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/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/dynarmic/src/dynarmic/backend/arm64/a64_address_space.cpp

@@ -23,7 +23,7 @@
 namespace Dynarmic::Backend::Arm64 {
 
 template<auto mfp, typename T>
-static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize = 0) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -32,6 +32,9 @@ static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
 
     void* target = code.xptr<void*>();
     code.LDR(X0, l_this);
+    if (bitsize) {
+        code.MOV(X1, bitsize);
+    }
     code.LDR(Xscratch0, l_addr);
     code.BR(Xscratch0);
 
@@ -45,7 +48,7 @@ static void* EmitCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
+static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -58,6 +61,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 +104,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 +118,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 +347,30 @@ void A64AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-    prelude_info.read_memory = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.read_memory_8 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u8));
+    prelude_info.read_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u16));
+    prelude_info.read_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks, sizeof(u32));
+    prelude_info.read_memory_64 = EmitCallTrampoline<&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 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u8));
+    prelude_info.write_memory_16 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u16));
+    prelude_info.write_memory_32 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks, sizeof(u32));
+    prelude_info.write_memory_64 = EmitCallTrampoline<&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,40 +147,32 @@ 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);
@@ -202,39 +194,31 @@ 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);

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;