MemoryUtil: platform-specific allocation tweaks

Author: warmenhoven

Source/Core/Common/Arm64Emitter.cpp

@@ -118,7 +118,7 @@ void ARM64XEmitter::Write32(u32 value)
     return;
   }
 
-  std::memcpy(m_code, &value, sizeof(u32));
+  std::memcpy(m_code + m_writable_region_diff, &value, sizeof(u32));
   m_code += sizeof(u32);
 }
 
@@ -730,7 +730,7 @@ void ARM64XEmitter::SetJumpTarget(FixupBranch const& branch)
     break;
   }
 
-  std::memcpy(branch.ptr, &inst, sizeof(inst));
+  std::memcpy(branch.ptr + m_writable_region_diff, &inst, sizeof(inst));
 }
 
 FixupBranch ARM64XEmitter::WriteFixupBranch()

Source/Core/Common/Arm64Emitter.h

@@ -618,6 +618,8 @@ class ARM64XEmitter
   // Writes that would reach this memory are refused and will set the m_write_failed flag instead.
   u8* m_code_end = nullptr;
 
+  ptrdiff_t m_writable_region_diff = 0;
+
   u8* m_lastCacheFlushEnd = nullptr;
 
   // Set to true when a write request happens that would write past m_code_end.
@@ -690,6 +692,9 @@ class ARM64XEmitter
   void FlushIcache();
   void FlushIcacheSection(u8* start, u8* end);
 
+  ptrdiff_t GetWritableRegionDiff() { return m_writable_region_diff; }
+  void SetWritableRegionDiff(ptrdiff_t diff) { m_writable_region_diff = diff; }
+
   // Should be checked after a block of code has been generated to see if the code has been
   // successfully written to memory. Do not call the generated code when this returns true!
   bool HasWriteFailed() const { return m_write_failed; }
@@ -1488,7 +1493,7 @@ class ARM64CodeBlock : public Common::CodeBlock<ARM64XEmitter>
 
     for (size_t i = 0; i < region_size; i += sizeof(u32))
     {
-      std::memcpy(region + i, &brk_0, sizeof(u32));
+      std::memcpy(region + writable_region_diff + i, &brk_0, sizeof(u32));
     }
   }
 };

Source/Core/Common/CodeBlock.h

@@ -32,6 +32,8 @@ class CodeBlock : public T
   size_t region_size = 0;
   // Original size of the region we allocated.
   size_t total_region_size = 0;
+  // Offset from executable region to writable region (0 when not dual-mapped).
+  ptrdiff_t writable_region_diff = 0;
 
   bool m_is_child = false;
   std::vector<CodeBlock*> m_children;
@@ -58,6 +60,13 @@ class CodeBlock : public T
     else
       region = static_cast<u8*>(Common::AllocateMemoryPages(total_region_size));
     T::SetCodePtr(region, region + size);
+
+#if defined(IPHONEOS) || (defined(__APPLE__) && defined(__aarch64__) && !TARGET_OS_IPHONE)
+    if constexpr (executable)
+      writable_region_diff = Common::AllocateWritableRegionAndGetDiff(region, size);
+#endif
+
+    T::SetWritableRegionDiff(writable_region_diff);
   }
 
   // Always clear code space with breakpoints, so that if someone accidentally executes
@@ -72,15 +81,27 @@ class CodeBlock : public T
   void FreeCodeSpace()
   {
     ASSERT(!m_is_child);
-    Common::FreeMemoryPages(region, total_region_size);
+#if defined(IPHONEOS) || (defined(__APPLE__) && defined(__aarch64__) && !TARGET_OS_IPHONE)
+    if constexpr (executable)
+    {
+      Common::FreeWritableRegion(region, total_region_size, writable_region_diff);
+      Common::FreeExecutableMemory(region, total_region_size);
+    }
+    else
+#endif
+    {
+      Common::FreeMemoryPages(region, total_region_size);
+    }
     region = nullptr;
     region_size = 0;
     total_region_size = 0;
+    writable_region_diff = 0;
     for (CodeBlock* child : m_children)
     {
       child->region = nullptr;
       child->region_size = 0;
       child->total_region_size = 0;
+      child->writable_region_diff = 0;
     }
   }
 
@@ -90,6 +111,7 @@ class CodeBlock : public T
     return ptr >= region && ptr < (region + total_region_size);
   }
   u8* GetRegionPtr() { return region; }
+  ptrdiff_t GetWritableRegionDiff() const { return writable_region_diff; }
   void WriteProtect(bool allow_execute)
   {
     Common::WriteProtectMemory(region, region_size, allow_execute);
@@ -127,6 +149,7 @@ class CodeBlock : public T
     child->region = child_region;
     child->region_size = child_size;
     child->total_region_size = child_size;
+    child->writable_region_diff = writable_region_diff;
     child->ResetCodePtr();
     m_children.emplace_back(child);
   }

Source/Core/Common/MemoryUtil.cpp

@@ -19,6 +19,9 @@
 #if defined(_M_ARM_64) && defined(__APPLE__)
 #include <pthread.h>
 #endif
+#if defined(__APPLE__) && defined(__aarch64__)
+#include <mach/mach.h>
+#endif
 #if defined __APPLE__ || defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__
 #include <sys/sysctl.h>
 #elif defined __HAIKU__
@@ -30,6 +33,30 @@
 
 #ifdef IPHONEOS
 #include "Common/JITMemoryTracker.h"
+#ifdef __LIBRETRO__
+#include <algorithm>
+#include <mutex>
+#include <vector>
+#include "DolphinLibretro/Common/Globals.h"
+static void* s_last_exec_rw = nullptr;
+static unsigned s_last_exec_mode = 0;
+// Regions the frontend allocated for us. Whether they are dual-mapped says
+// nothing about who owns them, so ownership is recorded rather than inferred.
+static std::mutex s_frontend_regions_mutex;
+static std::vector<void*> s_frontend_regions;
+#endif
+#endif
+
+#ifdef IPHONEOS
+namespace Common
+{
+static JitType g_jit_type = JitType::Legacy;
+
+void SetJitType(JitType type)
+{
+  g_jit_type = type;
+}
+}  // namespace Common
 #endif
 
 namespace Common
@@ -43,19 +70,43 @@ static JITMemoryTracker g_jit_memory_tracker;
 
 void* AllocateExecutableMemory(size_t size)
 {
+#if defined(IPHONEOS) && defined(__LIBRETRO__)
+  {
+    struct retro_exec_mem_alloc alloc = {};
+    alloc.version = 1;
+    alloc.size = size;
+    if (Libretro::environ_cb &&
+        Libretro::environ_cb(RETRO_ENVIRONMENT_EXEC_MEM_ALLOC, &alloc) &&
+        alloc.mode != RETRO_EXEC_MEM_MODE_UNAVAILABLE &&
+        alloc.rx != nullptr)
+    {
+      s_last_exec_rw = alloc.rw;
+      s_last_exec_mode = alloc.mode;
+      SetJitType(alloc.mode == RETRO_EXEC_MEM_MODE_DUAL_MAP ? JitType::LuckTXM :
+                                                              JitType::Legacy);
+      {
+        std::scoped_lock lk(s_frontend_regions_mutex);
+        s_frontend_regions.push_back(alloc.rx);
+      }
+      g_jit_memory_tracker.RegisterJITRegion(alloc.rx, size);
+      return alloc.rx;
+    }
+  }
+#endif
 #if defined(_WIN32)
   void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+#elif defined(__APPLE__) && defined(__aarch64__) && !defined(IPHONEOS)
+  // macOS ARM: mmap R-X for dual mapping (no MAP_JIT, which prevents vm_remap)
+  void* ptr = mmap(nullptr, size, PROT_READ | PROT_EXEC, MAP_ANON | MAP_PRIVATE, -1, 0);
+  if (ptr == MAP_FAILED)
+    ptr = nullptr;
 #else
   int map_flags = MAP_ANON | MAP_PRIVATE;
 #if defined(__APPLE__) && !defined(IPHONEOS)
   map_flags |= MAP_JIT;
 #endif
 
-  int map_prot = PROT_READ | PROT_EXEC;
-#ifndef IPHONEOS
-  // The default protection is r-x on non-iOS platforms.
-  map_prot |= PROT_WRITE;
-#endif
+  int map_prot = PROT_READ | PROT_WRITE | PROT_EXEC;
 
   void* ptr = mmap(nullptr, size, map_prot, map_flags, -1, 0);
   if (ptr == MAP_FAILED)
@@ -142,12 +193,14 @@ void JITPageWriteDisableExecuteEnable()
 #else
 void JITPageWriteEnableExecuteDisable(void* ptr)
 {
-  g_jit_memory_tracker.JITRegionWriteEnableExecuteDisable(ptr);
+  if (g_jit_type == JitType::Legacy)
+    g_jit_memory_tracker.JITRegionWriteEnableExecuteDisable(ptr);
 }
 
 void JITPageWriteDisableExecuteEnable(void* ptr)
 {
-  g_jit_memory_tracker.JITRegionWriteDisableExecuteEnable(ptr);
+  if (g_jit_type == JitType::Legacy)
+    g_jit_memory_tracker.JITRegionWriteDisableExecuteEnable(ptr);
 }
 #endif
 
@@ -317,4 +370,81 @@ size_t MemPhysical()
 #endif
 }
 
+#if defined(__APPLE__) && defined(__aarch64__)
+ptrdiff_t AllocateWritableRegionAndGetDiff(void* rx_ptr, size_t size)
+{
+#if defined(IPHONEOS) && defined(__LIBRETRO__)
+  if (s_last_exec_rw && s_last_exec_mode == RETRO_EXEC_MEM_MODE_DUAL_MAP)
+  {
+    ptrdiff_t diff = static_cast<u8*>(s_last_exec_rw) - static_cast<u8*>(rx_ptr);
+    s_last_exec_rw = nullptr;
+    return diff;
+  }
+  return 0;
+#endif
+  vm_address_t rw_region = 0;
+  vm_prot_t cur_protection = 0;
+  vm_prot_t max_protection = 0;
+
+  kern_return_t retval =
+      vm_remap(mach_task_self(), &rw_region, size, 0, true, mach_task_self(),
+               (vm_address_t)rx_ptr, false, &cur_protection, &max_protection,
+               VM_INHERIT_DEFAULT);
+  if (retval != KERN_SUCCESS)
+  {
+    PanicAlertFmt("AllocateWritableRegionAndGetDiff failed! vm_remap returned {0:#x}", retval);
+    return 0;
+  }
+
+  u8* rw_ptr = reinterpret_cast<u8*>(rw_region);
+  if (mprotect(rw_ptr, size, PROT_READ | PROT_WRITE) != 0)
+  {
+    PanicAlertFmt("AllocateWritableRegionAndGetDiff failed! mprotect returned {}",
+                  LastStrerrorString());
+    return 0;
+  }
+
+  return rw_ptr - static_cast<u8*>(rx_ptr);
+}
+
+void FreeWritableRegion(void* rx_ptr, size_t size, ptrdiff_t diff)
+{
+#if defined(IPHONEOS) && defined(__LIBRETRO__)
+  // Frontend owns the writable region; nothing to do here.
+  // FreeExecutableMemory will tell the frontend to free everything.
+#else
+  if (diff == 0)
+    return;
+  u8* rw_ptr = static_cast<u8*>(rx_ptr) + diff;
+  vm_deallocate(mach_task_self(), reinterpret_cast<vm_address_t>(rw_ptr), size);
+#endif
+}
+
+void FreeExecutableMemory(void* ptr, size_t size)
+{
+  if (!ptr)
+    return;
+#ifdef IPHONEOS
+  g_jit_memory_tracker.UnregisterJITRegion(ptr);
+#endif
+#if defined(IPHONEOS) && defined(__LIBRETRO__)
+  {
+    std::scoped_lock lk(s_frontend_regions_mutex);
+    auto it = std::find(s_frontend_regions.begin(), s_frontend_regions.end(), ptr);
+    if (it != s_frontend_regions.end())
+    {
+      s_frontend_regions.erase(it);
+      struct retro_exec_mem_free f = {};
+      f.rx = ptr;
+      if (Libretro::environ_cb)
+        Libretro::environ_cb(RETRO_ENVIRONMENT_EXEC_MEM_FREE, &f);
+      return;
+    }
+  }
+#endif
+  munmap(ptr, size);
+}
+#endif
+
+
 }  // namespace Common

Source/Core/Common/MemoryUtil.h

@@ -8,10 +8,33 @@
 
 #include "Common/CommonTypes.h"
 
+#ifdef __APPLE__
+#include <TargetConditionals.h>
+#endif
+
 namespace Common
 {
 void* AllocateExecutableMemory(size_t size);
 
+#ifdef IPHONEOS
+// Which of the executable-memory strategies is in use. Dual-mapped modes write
+// through an alias, so the W^X toggling below must not run for them.
+enum class JitType
+{
+  Legacy,
+  LuckNoTXM,
+  LuckTXM
+};
+
+void SetJitType(JitType type);
+#endif
+
+#if defined(IPHONEOS) || (defined(__APPLE__) && defined(__aarch64__) && !TARGET_OS_IPHONE)
+ptrdiff_t AllocateWritableRegionAndGetDiff(void* rx_ptr, size_t size);
+void FreeWritableRegion(void* rx_ptr, size_t size, ptrdiff_t diff);
+void FreeExecutableMemory(void* ptr, size_t size);
+#endif
+
 // These two functions control the executable/writable state of the W^X memory
 // allocations. More detailed documentation about them is in the .cpp file.
 // In general where applicable the ScopedJITPageWriteAndNoExecute wrapper

Source/Core/Common/x64Emitter.h

@@ -398,6 +398,9 @@ class XEmitter
   const u8* GetCodeEnd() const { return m_code_end; }
   u8* GetWritableCodeEnd() { return m_code_end; }
 
+  ptrdiff_t GetWritableRegionDiff() { return 0; }
+  void SetWritableRegionDiff(ptrdiff_t diff) {}
+
   void LockFlags() { flags_locked = true; }
   void UnlockFlags() { flags_locked = false; }
 

Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreterEmitter.h

@@ -84,6 +84,9 @@ class CachedInterpreterEmitter
     m_write_failed = false;
   }
 
+  ptrdiff_t GetWritableRegionDiff() { return 0; }
+  void SetWritableRegionDiff(ptrdiff_t diff) {}
+
   static s32 PoisonCallback(PowerPC::PowerPCState& ppc_state, const void* operands);
   static s32 PoisonCallback(std::ostream& stream, const void* operands);
 

Source/Core/Core/PowerPC/JitArm64/JitArm64Cache.cpp

@@ -87,6 +87,10 @@ void JitArm64BlockCache::WriteLinkBlock(const JitBlock::LinkData& source, const
   u8* location = source.exitPtrs;
   ARM64XEmitter emit(location, location + BLOCK_LINK_SIZE);
 
+  auto& jit = static_cast<JitArm64&>(m_jit);
+  auto& jit_emitter = static_cast<Arm64Gen::ARM64XEmitter&>(jit);
+  emit.SetWritableRegionDiff(jit_emitter.GetWritableRegionDiff());
+
   WriteLinkBlock(emit, source, dest);
   emit.FlushIcache();
 }
@@ -95,6 +99,11 @@ void JitArm64BlockCache::WriteDestroyBlock(const JitBlock& block)
 {
   // Only clear the entry point as we might still be within this block.
   ARM64XEmitter emit(block.normalEntry, block.normalEntry + 4);
+
+  auto& jit = static_cast<JitArm64&>(m_jit);
+  auto& jit_emitter = static_cast<Arm64Gen::ARM64XEmitter&>(jit);
+  emit.SetWritableRegionDiff(jit_emitter.GetWritableRegionDiff());
+
   const Common::ScopedJITPageWriteAndNoExecute enable_jit_page_writes(block.normalEntry);
   emit.BRK(0x123);
   emit.FlushIcache();

Source/Core/Core/PowerPC/JitArm64/JitArm64_BackPatch.cpp

@@ -346,6 +346,8 @@ bool JitArm64::HandleFastmemFault(SContext* ctx)
   const Common::ScopedJITPageWriteAndNoExecute enable_jit_page_writes(GetRegionPtr());
   ARM64XEmitter emitter(const_cast<u8*>(fastmem_area_start), const_cast<u8*>(fastmem_area_end));
 
+  emitter.SetWritableRegionDiff(GetWritableRegionDiff());
+
   emitter.BL(slow_handler_iter->second.slow_access_code);
 
   while (emitter.GetCodePtr() < fastmem_area_end)