2026-09-18 06:06:10

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

src/common/error.cpp

@@ -17,33 +17,35 @@
 
 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),
-                               LPSTR(&err_str), 1, nullptr);
-    if (res) {
-        std::string ret(err_str);
-        LocalFree(err_str);
-        return ret;
+                               reinterpret_cast<LPSTR>(&err_str), 1, nullptr);
+    if (!res) {
+        return "(FormatMessageA failed to format error)";
     }
-    return "(FormatMessageA failed to format error)";
+    std::string ret(err_str);
+    LocalFree(err_str);
+    return ret;
 #else
     char err_str[255];
-    return HandleStrerrorR(strerror_r(e, err_str, sizeof(err_str)), err_str);
+#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.
 #endif // _WIN32
 }
 

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

@@ -29,7 +29,6 @@
 #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 {
@@ -73,16 +72,10 @@ 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());
-    }
-    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();
+
+    std::scoped_lock lk{applet_->lock};
+    applet_->is_completed = true;
+    applet_->state_changed_event.Signal(system.Kernel());
 }
 
 FrontendAppletSet::FrontendAppletSet() = default;

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

@@ -122,10 +122,7 @@ 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;
-        {
-            std::scoped_lock lk{caller_applet->lock};
-            caller_applet->child_applets.push_back(applet);
-        }
+        caller_applet->child_applets.push_back(applet);
         window_system.TrackApplet(applet, false);
         return std::make_shared<ILibraryAppletAccessor>(system, broker, applet);
     }
@@ -151,10 +148,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);
-    {
-        std::scoped_lock lk{caller_applet->lock};
-        caller_applet->child_applets.push_back(applet);
-    }
+    caller_applet->child_applets.push_back(applet);
+
+    window_system.TrackApplet(applet, false);
+
     return std::make_shared<ILibraryAppletAccessor>(system, storage, applet);
 }
 

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

@@ -23,66 +23,30 @@
 
 namespace Dynarmic::Backend::Arm64 {
 
-template<auto mfp, typename T>
-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* 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) {
+static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -95,7 +59,6 @@ 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);
@@ -138,7 +101,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
+static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -152,7 +115,6 @@ 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);
@@ -214,27 +176,14 @@ void A32AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-
-    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.read_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
+    prelude_info.wrapped_read_memory = EmitWrappedReadCallTrampoline<&A32::UserCallbacks::MemoryRead>(code, conf.callbacks);
     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_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.write_memory = EmitCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
+    prelude_info.wrapped_write_memory = EmitWrappedWriteCallTrampoline<&A32::UserCallbacks::MemoryWrite>(code, conf.callbacks);
     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

@@ -22,66 +22,30 @@
 
 namespace Dynarmic::Backend::Arm64 {
 
-template<auto mfp, typename T>
-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* 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) {
+static void* EmitWrappedReadCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -94,7 +58,6 @@ 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);
@@ -137,7 +100,7 @@ static void* EmitExclusiveReadCallTrampoline(oaknut::CodeGenerator& code, const
 }
 
 template<auto mfp, typename T>
-static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_, size_t bitsize) {
+static void* EmitWrappedWriteCallTrampoline(oaknut::CodeGenerator& code, T* this_) {
     using namespace oaknut::util;
 
     const auto info = Devirtualize<mfp>(this_);
@@ -151,7 +114,6 @@ 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);
@@ -380,30 +342,18 @@ void A64AddressSpace::EmitPrelude() {
 
     UnprotectCodeMemory();
 
-    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 = EmitCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
     prelude_info.read_memory_128 = EmitRead128CallTrampoline(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 = EmitWrappedReadCallTrampoline<&A64::UserCallbacks::MemoryRead>(code, conf.callbacks);
     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_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 = EmitCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
     prelude_info.write_memory_128 = EmitWrite128CallTrampoline(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 = EmitWrappedWriteCallTrampoline<&A64::UserCallbacks::MemoryWrite>(code, conf.callbacks);
     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,37 +147,44 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
             break;
         // { this, vaddr, size }
         case LinkTarget::ReadMemory8:
-            c.BL(prelude_info.read_memory_8);
+            c.LDR(X2, 1);
+            c.BL(prelude_info.read_memory);
             break;
         case LinkTarget::ReadMemory16:
-            c.BL(prelude_info.read_memory_16);
+            c.LDR(X2, 2);
+            c.BL(prelude_info.read_memory);
             break;
         case LinkTarget::ReadMemory32:
-            c.BL(prelude_info.read_memory_32);
+            c.LDR(X2, 4);
+            c.BL(prelude_info.read_memory);
             break;
         case LinkTarget::ReadMemory64:
-            c.BL(prelude_info.read_memory_64);
+            c.LDR(X2, 8);
+            c.BL(prelude_info.read_memory);
             break;
         case LinkTarget::ReadMemory128:
             c.BL(prelude_info.read_memory_128);
             break;
         // { this, vaddr, size }
         case LinkTarget::WrappedReadMemory8:
-            c.BL(prelude_info.wrapped_read_memory_8);
+            c.LDR(X2, 1);
+            c.BL(prelude_info.wrapped_read_memory);
             break;
         case LinkTarget::WrappedReadMemory16:
-            c.BL(prelude_info.wrapped_read_memory_16);
+            c.LDR(X2, 2);
+            c.BL(prelude_info.wrapped_read_memory);
             break;
         case LinkTarget::WrappedReadMemory32:
-            c.BL(prelude_info.wrapped_read_memory_32);
+            c.LDR(X2, 4);
+            c.BL(prelude_info.wrapped_read_memory);
             break;
         case LinkTarget::WrappedReadMemory64:
-            c.BL(prelude_info.wrapped_read_memory_64);
+            c.LDR(X2, 8);
+            c.BL(prelude_info.wrapped_read_memory);
             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;
@@ -195,37 +202,43 @@ void AddressSpace::Link(EmittedBlockInfo& block_info) {
             break;
         // { this, vaddr, value, size }
         case LinkTarget::WriteMemory8:
-            c.BL(prelude_info.write_memory_8);
+            c.LDR(X3, 1);
+            c.BL(prelude_info.write_memory);
             break;
         case LinkTarget::WriteMemory16:
-            c.BL(prelude_info.write_memory_16);
+            c.LDR(X3, 2);
+            c.BL(prelude_info.write_memory);
             break;
         case LinkTarget::WriteMemory32:
-            c.BL(prelude_info.write_memory_32);
+            c.LDR(X3, 4);
+            c.BL(prelude_info.write_memory);
             break;
         case LinkTarget::WriteMemory64:
-            c.BL(prelude_info.write_memory_64);
+            c.LDR(X3, 8);
+            c.BL(prelude_info.write_memory);
             break;
         case LinkTarget::WriteMemory128:
             c.BL(prelude_info.write_memory_128);
             break;
-        //
         case LinkTarget::WrappedWriteMemory8:
-            c.BL(prelude_info.wrapped_write_memory_8);
+            c.LDR(X3, 1);
+            c.BL(prelude_info.wrapped_write_memory);
             break;
         case LinkTarget::WrappedWriteMemory16:
-            c.BL(prelude_info.wrapped_write_memory_16);
+            c.LDR(X3, 2);
+            c.BL(prelude_info.wrapped_write_memory);
             break;
         case LinkTarget::WrappedWriteMemory32:
-            c.BL(prelude_info.wrapped_write_memory_32);
+            c.LDR(X3, 4);
+            c.BL(prelude_info.wrapped_write_memory);
             break;
         case LinkTarget::WrappedWriteMemory64:
-            c.BL(prelude_info.wrapped_write_memory_64);
+            c.LDR(X3, 8);
+            c.BL(prelude_info.wrapped_write_memory);
             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,30 +93,18 @@ protected:
         void* return_to_dispatcher;
         void* return_from_run_code;
 
-        void* read_memory_8;
-        void* read_memory_16;
-        void* read_memory_32;
-        void* read_memory_64;
+        void* read_memory;
         void* read_memory_128;
-        void* wrapped_read_memory_8;
-        void* wrapped_read_memory_16;
-        void* wrapped_read_memory_32;
-        void* wrapped_read_memory_64;
+        void* wrapped_read_memory;
         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_8;
-        void* write_memory_16;
-        void* write_memory_32;
-        void* write_memory_64;
+        void* write_memory;
         void* write_memory_128;
-        void* wrapped_write_memory_8;
-        void* wrapped_write_memory_16;
-        void* wrapped_write_memory_32;
-        void* wrapped_write_memory_64;
+        void* wrapped_write_memory;
         void* wrapped_write_memory_128;
         void* exclusive_write_memory_8;
         void* exclusive_write_memory_16;

src/dynarmic/src/dynarmic/backend/x64/a32_emit_x64_memory.cpp

@@ -11,8 +11,7 @@
 #include <tuple>
 #include <utility>
 
-#include <fmt/format.h>
-#include <fmt/ostream.h>
+#include "common/logging.h"
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include "dynarmic/backend/x64/xbyak.h"
 

src/dynarmic/src/dynarmic/backend/x64/a64_emit_x64_memory.cpp

@@ -11,8 +11,7 @@
 #include <tuple>
 #include <utility>
 
-#include <fmt/format.h>
-#include <fmt/ostream.h>
+#include "common/logging.h"
 #include "dynarmic/mcl/integer_of_size.hpp"
 #include "dynarmic/backend/x64/xbyak.h"
 

src/dynarmic/src/dynarmic/backend/x64/emit_x64_memory.cpp.inc

@@ -14,10 +14,6 @@
 #define AxxJitState CONCATENATE_TOKENS(Axx, JitState)
 #define AxxUserConfig Axx::UserConfig
 
-namespace {
-using Vector = std::array<u64, 2>;
-}
-
 std::optional<AxxEmitX64::DoNotFastmemMarker> AxxEmitX64::ShouldFastmem(AxxEmitContext& ctx, IR::Inst* inst) const {
     if (!conf.fastmem_pointer || !exception_handler.SupportsFastmem()) {
         return std::nullopt;
@@ -31,22 +27,19 @@ std::optional<AxxEmitX64::DoNotFastmemMarker> AxxEmitX64::ShouldFastmem(AxxEmitC
 }
 
 FakeCall AxxEmitX64::FastmemCallback(u64 rip_) {
-    const auto iter = fastmem_patch_info.find(rip_);
-    if (iter != fastmem_patch_info.end()) {
+    if (auto const it = fastmem_patch_info.find(rip_); it != fastmem_patch_info.end()) {
         FakeCall result{
-            .call_rip = iter->second.callback,
-            .ret_rip = iter->second.resume_rip,
+            .call_rip = it->second.callback,
+            .ret_rip = it->second.resume_rip,
         };
-        if (iter->second.recompile) {
-            const auto marker = iter->second.marker;
+        if (it->second.recompile) {
+            const auto marker = it->second.marker;
             do_not_fastmem.insert(marker);
             InvalidateBasicBlocks({std::get<0>(marker)});
         }
         return result;
     }
-    fmt::print("dynarmic: Segfault happened within JITted code at rip = {:016x}\n"
-        "Segfault wasn't at a fastmem patch location!\n", rip_);
-    UNREACHABLE(); //("iter != fastmem_patch_info.end()");
+    UNREACHABLE_MSG("SIGSEGV @ JIT, rip={:#016x}", rip_); //("iter != fastmem_patch_info.end()");
 }
 
 template<std::size_t bitsize, auto callback>
@@ -83,22 +76,17 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
 
     const Xbyak::Reg64 vaddr = ctx.reg_alloc.UseGpr(code, args[1]);
     const int value_idx = bitsize == 128 ? ctx.reg_alloc.ScratchXmm(code).getIdx() : ctx.reg_alloc.ScratchGpr(code).getIdx();
-
     const auto wrapped_fn = read_fallbacks[std::make_tuple(ordered, bitsize, vaddr.getIdx(), value_idx)];
 
     SharedLabel abort = ctx.GenSharedLabel(), end = ctx.GenSharedLabel();
-
     if (fastmem_marker) {
         // Use fastmem
         bool require_abort_handling = false;
         const auto src_ptr = EmitFastmemVAddr(code, ctx, *abort, vaddr, require_abort_handling);
-
         const auto location = EmitReadMemoryMov<bitsize>(code, value_idx, src_ptr, ordered);
-
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
             code.L(*abort);
             code.call(wrapped_fn);
-
             fastmem_patch_info.emplace(
                 std::bit_cast<u64>(location),
                 FastmemPatchInfo{
@@ -107,25 +95,23 @@ void AxxEmitX64::EmitMemoryRead(AxxEmitContext& ctx, IR::Inst* inst) {
                     *fastmem_marker,
                     conf.recompile_on_fastmem_failure,
                 });
-
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else {
+    } else if (conf.page_table) {
         // Use page table
-        ASSERT(conf.page_table);
         const auto src_ptr = EmitVAddrLookup(code, ctx, bitsize, *abort, vaddr);
         EmitReadMemoryMov<bitsize>(code, value_idx, src_ptr, ordered);
-
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
             code.L(*abort);
             code.call(wrapped_fn);
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
+    } else {
+        UNREACHABLE();
     }
     code.L(*end);
-
     if constexpr (bitsize == 128) {
         ctx.reg_alloc.DefineValue(code, inst, Xbyak::Xmm{value_idx});
     } else {
@@ -168,18 +154,16 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
 
     const Xbyak::Reg64 vaddr = ctx.reg_alloc.UseGpr(code, args[1]);
     const int value_idx = bitsize == 128
-                            ? ctx.reg_alloc.UseXmm(code, args[2]).getIdx()
-                            : (ordered ? ctx.reg_alloc.UseScratchGpr(code, args[2]).getIdx() : ctx.reg_alloc.UseGpr(code, args[2]).getIdx());
+        ? ctx.reg_alloc.UseXmm(code, args[2]).getIdx()
+        : (ordered ? ctx.reg_alloc.UseScratchGpr(code, args[2]).getIdx() : ctx.reg_alloc.UseGpr(code, args[2]).getIdx());
 
     const auto wrapped_fn = write_fallbacks[std::make_tuple(ordered, bitsize, vaddr.getIdx(), value_idx)];
 
     SharedLabel abort = ctx.GenSharedLabel(), end = ctx.GenSharedLabel();
-
     if (fastmem_marker) {
         // Use fastmem
         bool require_abort_handling = false;
         const auto dest_ptr = EmitFastmemVAddr(code, ctx, *abort, vaddr, require_abort_handling);
-
         const auto location = EmitWriteMemoryMov<bitsize>(code, dest_ptr, value_idx, ordered);
 
         ctx.deferred_emits.emplace_back([=, this, &ctx] {
@@ -198,9 +182,8 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
-    } else {
+    } else if (conf.page_table) {
         // Use page table
-        ASSERT(conf.page_table);
         const auto dest_ptr = EmitVAddrLookup(code, ctx, bitsize, *abort, vaddr);
         EmitWriteMemoryMov<bitsize>(code, dest_ptr, value_idx, ordered);
 
@@ -210,6 +193,8 @@ void AxxEmitX64::EmitMemoryWrite(AxxEmitContext& ctx, IR::Inst* inst) {
             EmitCheckMemoryAbort(ctx, inst, end);
             code.jmp(*end, code.T_NEAR);
         });
+    } else {
+        UNREACHABLE();
     }
     code.L(*end);
 }
@@ -249,8 +234,8 @@ void AxxEmitX64::EmitExclusiveReadMemory(AxxEmitContext& ctx, IR::Inst* inst) {
         if (ordered) {
             code.mfence();
         }
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& ret) {
-            ret = conf.global_monitor->ReadAndMark<Vector>(conf.processor_id, vaddr, [&]() -> Vector {
+        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, u128& ret) {
+            ret = conf.global_monitor->ReadAndMark<u128>(conf.processor_id, vaddr, [&]() -> u128 {
                 return (conf.callbacks->*callback)(vaddr);
             });
         });
@@ -301,8 +286,8 @@ void AxxEmitX64::EmitExclusiveWriteMemory(AxxEmitContext& ctx, IR::Inst* inst) {
         ctx.reg_alloc.AllocStackSpace(code, 16 + ABI_SHADOW_SPACE);
         code.lea(code.ABI_PARAM3, ptr[rsp + ABI_SHADOW_SPACE]);
         code.movaps(xword[code.ABI_PARAM3], xmm1);
-        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, Vector& value) -> u32 {
-            return conf.global_monitor->DoExclusiveOperation<Vector>(conf.processor_id, vaddr, [&](Vector expected) -> bool {
+        code.CallLambda([](AxxUserConfig& conf, Axx::VAddr vaddr, u128& value) -> u32 {
+            return conf.global_monitor->DoExclusiveOperation<u128>(conf.processor_id, vaddr, [&](u128 expected) -> bool {
                 return (conf.callbacks->*callback)(vaddr, value, expected);
             }) ? 0 : 1;
         });

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

@@ -135,10 +135,16 @@ template<>
     if (unused_top_bits == 0) {
         code.mov(tmp, vaddr);
         code.shr(tmp, int(page_table_const_bits));
+        if (ctx.conf.page_table_log2_stride > 3) {
+            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+            code.mov(page, qword[r14 + tmp.cvt64()]);
+        } else {
+            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        }
     } else if (ctx.conf.silently_mirror_page_table) {
         if (valid_page_index_bits >= 32) {
             if (code.HasHostFeature(HostFeature::BMI2)) {
-                const Xbyak::Reg64 bit_count = ctx.reg_alloc.ScratchGpr(code);
+                auto const bit_count = ctx.reg_alloc.ScratchGpr(code);
                 code.mov(bit_count, unused_top_bits);
                 code.bzhi(tmp, vaddr, bit_count);
                 code.shr(tmp, int(page_table_const_bits));
@@ -153,19 +159,31 @@ template<>
             code.shr(tmp, int(page_table_const_bits));
             code.and_(tmp, u32((1 << valid_page_index_bits) - 1));
         }
+        if (ctx.conf.page_table_log2_stride > 3) {
+            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+            code.mov(page, qword[r14 + tmp.cvt64()]);
+        } else {
+            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        }
     } else {
+        // Common VA sizes: 39 - 12 => 27, 42 - 12 => 30
+        // Check if bits outside of VA space are non-zero
         ASSERT(valid_page_index_bits < 32);
         code.mov(tmp, vaddr);
+        if (ctx.conf.check_halt_on_memory_access) {
+            auto const tmp2 = ctx.reg_alloc.ScratchGpr(code);
+            code.mov(tmp2, u64(-(1ull << valid_page_index_bits) << page_table_const_bits));
+            code.test(tmp, tmp2);
+            code.jnz(abort, code.T_NEAR);
+            ctx.reg_alloc.Release(tmp2);
+        }
         code.shr(tmp, int(page_table_const_bits));
-        code.test(tmp, u32(-(1 << valid_page_index_bits)));
-        code.jnz(abort, code.T_NEAR);
-    }
-
-    if (ctx.conf.page_table_log2_stride > 3) {
-        code.shl(tmp, int(ctx.conf.page_table_log2_stride));
-        code.mov(page, qword[r14 + tmp.cvt64()]);
-    } else {
-        code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        if (ctx.conf.page_table_log2_stride > 3) {
+            code.shl(tmp, int(ctx.conf.page_table_log2_stride));
+            code.mov(page, qword[r14 + tmp.cvt64()]);
+        } else {
+            code.mov(page, qword[r14 + tmp.cvt64() * int(1 << ctx.conf.page_table_log2_stride)]);
+        }
     }
 
     // check for marked bit, use as unmapped if marked
@@ -193,7 +211,7 @@ template<>
         return page + vaddr;
     }
     code.mov(tmp, vaddr);
-    code.and_(tmp, static_cast<u32>(page_table_const_mask));
+    code.and_(tmp, u32(page_table_const_mask));
     return page + tmp;
 }
 

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

@@ -39,8 +39,16 @@ Block::iterator Block::PrependNewInst(iterator insertion_point, Opcode opcode, s
     // just pool it!!! - reason why there is an inline buffer is because many small blocks are created
     // with few instructions due to subpar optimisations on other passes... plus branch-heavy code will
     // hugely benefit from the coherency of faster allocations...
-    inlined_inst.emplace_back(opcode);
-    auto* inst = &inlined_inst[inlined_inst.size() - 1];
+    IR::Inst* inst;
+    if (inlined_inst.size() < inlined_inst.max_size()) {
+        inlined_inst.emplace_back(opcode);
+        inst = &inlined_inst[inlined_inst.size() - 1];
+    } else {
+        if (pooled_inst.empty() || pooled_inst.back().size() == pooled_inst.back().max_size())
+            pooled_inst.emplace_back();
+        pooled_inst.back().emplace_back(opcode);
+        inst = &pooled_inst.back()[pooled_inst.back().size() - 1];
+    }
     DEBUG_ASSERT(args.size() == inst->NumArgs());
     std::for_each(args.begin(), args.end(), [&inst, index = size_t(0)](const auto& arg) mutable {
         inst->SetArg(index, arg);
@@ -53,6 +61,7 @@ void Block::Reset(LocationDescriptor location_) noexcept {
     mcl::intrusive_list<IR::Inst> tmp = {};
     instructions.swap(tmp);
     inlined_inst.clear();
+    pooled_inst.clear();
     cond_failed.reset();
     location = location_;
     end_location = location_;

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

@@ -142,9 +142,11 @@ public:
     }
 
     /// "Hot cache" for small blocks so we don't call global allocator
-    boost::container::static_vector<Inst, 65536> inlined_inst = {};
+    boost::container::static_vector<Inst, 30> inlined_inst;
     /// List of instructions in this block.
     instruction_list_type instructions;
+    /// "Long/far" memory pool
+    boost::container::stable_vector<boost::container::static_vector<Inst, 32>> pooled_inst;
     /// Block to execute next if `cond` did not pass.
     std::optional<LocationDescriptor> cond_failed = {};
     /// Description of the starting location of this block
@@ -160,7 +162,7 @@ public:
     /// Number of cycles this block takes to execute.
     size_t cycle_count = 0;
 };
-//static_assert(sizeof(Block) == 4096);
+static_assert(sizeof(Block) == 4096);
 
 /// Returns a string representation of the contents of block. Intended for debugging.
 std::string DumpBlock(const IR::Block& block) noexcept;