MemoryUtil: Use mach vm functions on iOS

Source/Core/Common/MemoryUtil.cpp

@@ -15,11 +15,17 @@
 #ifdef _WIN32
 #include <windows.h>
 #include "Common/StringUtil.h"
+
 #else
 #include <stdio.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #if defined __APPLE__ || defined __FreeBSD__ || defined __OpenBSD__
+#ifdef IPHONEOS
+#include <mach/mach.h>
+#include <mach/vm_map.h>
+#include <mach/vm_param.h>
+#endif
 #include <sys/sysctl.h>
 #elif defined __HAIKU__
 #include <OS.h>
@@ -37,6 +43,25 @@ void* AllocateExecutableMemory(size_t size)
 {
 #if defined(_WIN32)
   void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
+#elif defined(IPHONEOS)
+  void* ptr = nullptr;
+  vm_address_t vm_ptr;
+  kern_return_t retval = vm_allocate(mach_task_self(), &vm_ptr, size, VM_FLAGS_ANYWHERE);
+
+  if (retval == KERN_SUCCESS)
+  {
+    vm_prot_t protection = VM_PROT_READ | VM_PROT_WRITE;
+#ifdef _M_X86_64
+    protection |= VM_PROT_EXECUTE;
+#endif
+
+    retval = vm_protect(mach_task_self(), vm_ptr, size, false, protection);
+
+    if (retval == KERN_SUCCESS)
+    {
+      ptr = (void*)vm_ptr;
+    }
+  }
 #else
   void* ptr =
       mmap(nullptr, size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANON | MAP_PRIVATE, -1, 0);
@@ -55,6 +80,19 @@ void* AllocateMemoryPages(size_t size)
 {
 #ifdef _WIN32
   void* ptr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
+#elif defined(IPHONEOS)
+  vm_address_t vm_ptr;
+  kern_return_t retval = vm_allocate(mach_task_self(), &vm_ptr, size, VM_FLAGS_ANYWHERE);
+
+  void* ptr;
+  if (retval == KERN_SUCCESS)
+  {
+    ptr = (void*)vm_ptr;
+  }
+  else
+  {
+    ptr = nullptr;
+  }
 #else
   void* ptr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
 
@@ -91,6 +129,10 @@ void FreeMemoryPages(void* ptr, size_t size)
 #ifdef _WIN32
     if (!VirtualFree(ptr, 0, MEM_RELEASE))
       PanicAlert("FreeMemoryPages failed!\nVirtualFree: %s", GetLastErrorString().c_str());
+#elif defined(IPHONEOS)
+    kern_return_t retval = vm_deallocate(mach_task_self(), (vm_address_t)ptr, size);
+    if (retval != KERN_SUCCESS)
+      PanicAlert("FreeMemoryPages failed!\nvm_deallocate: 0x%x", retval);
 #else
     if (munmap(ptr, size) != 0)
       PanicAlert("FreeMemoryPages failed!\nmunmap: %s", LastStrerrorString().c_str());
@@ -116,6 +158,10 @@ void ReadProtectMemory(void* ptr, size_t size)
   DWORD oldValue;
   if (!VirtualProtect(ptr, size, PAGE_NOACCESS, &oldValue))
     PanicAlert("ReadProtectMemory failed!\nVirtualProtect: %s", GetLastErrorString().c_str());
+#elif defined(IPHONEOS)
+  kern_return_t retval = vm_protect(mach_task_self(), (vm_address_t)ptr, size, false, VM_PROT_NONE);
+  if (retval != KERN_SUCCESS)
+    PanicAlert("ReadProtectMemory failed!\nvm_protect: 0x%x", retval);
 #else
   if (mprotect(ptr, size, PROT_NONE) != 0)
     PanicAlert("ReadProtectMemory failed!\nmprotect: %s", LastStrerrorString().c_str());
@@ -128,6 +174,10 @@ void WriteProtectMemory(void* ptr, size_t size, bool allowExecute)
   DWORD oldValue;
   if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READ : PAGE_READONLY, &oldValue))
     PanicAlert("WriteProtectMemory failed!\nVirtualProtect: %s", GetLastErrorString().c_str());
+#elif defined(IPHONEOS)
+  kern_return_t retval = vm_protect(mach_task_self(), (vm_address_t)ptr, size, false, allowExecute ? (VM_PROT_READ | VM_PROT_EXECUTE) : VM_PROT_READ);
+  if (retval != KERN_SUCCESS)
+    PanicAlert("WriteProtectMemory failed!\nvm_protect: 0x%x", retval);
 #else
   if (mprotect(ptr, size, allowExecute ? (PROT_READ | PROT_EXEC) : PROT_READ) != 0)
     PanicAlert("WriteProtectMemory failed!\nmprotect: %s", LastStrerrorString().c_str());
@@ -140,6 +190,22 @@ void UnWriteProtectMemory(void* ptr, size_t size, bool allowExecute)
   DWORD oldValue;
   if (!VirtualProtect(ptr, size, allowExecute ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE, &oldValue))
     PanicAlert("UnWriteProtectMemory failed!\nVirtualProtect: %s", GetLastErrorString().c_str());
+#elif defined(IPHONEOS)
+  vm_prot_t protection = VM_PROT_READ | VM_PROT_WRITE;
+  if (allowExecute)
+  {
+#ifdef _M_X86_64
+    protection |= VM_PROT_EXECUTE;
+#else
+    WARN_LOG(COMMON, "UnWriteProtectMemory: Cannot have memory be simultaneously executable and writable on iOS");
+#endif
+  }
+
+  kern_return_t retval = vm_protect(mach_task_self(), (vm_address_t)ptr, size, false, protection);
+  if (retval != KERN_SUCCESS)
+  {
+    PanicAlert("UnWriteProtectMemory failed!\nvm_protect: 0x%x", retval);
+  }
 #else
   if (mprotect(ptr, size,
                allowExecute ? (PROT_READ | PROT_WRITE | PROT_EXEC) : PROT_WRITE | PROT_READ) != 0)