lib/Support/Unix/Memory.inc

   1 //===- Unix/Memory.cpp - Generic UNIX System Configuration ------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines some functions for various memory management utilities.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Unix.h"
  15 #include "llvm/Support/DataTypes.h"
  16 #include "llvm/Support/Process.h"
  17
  18 #ifdef HAVE_SYS_MMAN_H
  19 #include <sys/mman.h>
  20 #endif
  21
  22 #ifdef __APPLE__
  23 #include <mach/mach.h>
  24 #endif
  25
  26 /// AllocateRWX - Allocate a slab of memory with read/write/execute
  27 /// permissions.  This is typically used for JIT applications where we want
  28 /// to emit code to the memory then jump to it.  Getting this type of memory
  29 /// is very OS specific.
  30 ///
  31 llvm::sys::MemoryBlock
  32 llvm::sys::Memory::AllocateRWX(size_t NumBytes, const MemoryBlock* NearBlock,
  33                                std::string *ErrMsg) {
  34   if (NumBytes == 0) return MemoryBlock();
  35
  36   size_t pageSize = Process::GetPageSize();
  37   size_t NumPages = (NumBytes+pageSize-1)/pageSize;
  38
  39   int fd = -1;
  40 #ifdef NEED_DEV_ZERO_FOR_MMAP
  41   static int zero_fd = open("/dev/zero", O_RDWR);
  42   if (zero_fd == -1) {
  43     MakeErrMsg(ErrMsg, "Can't open /dev/zero device");
  44     return MemoryBlock();
  45   }
  46   fd = zero_fd;
  47 #endif
  48
  49   int flags = MAP_PRIVATE |
  50 #ifdef HAVE_MMAP_ANONYMOUS
  51   MAP_ANONYMOUS
  52 #else
  53   MAP_ANON
  54 #endif
  55   ;
  56
  57   void* start = NearBlock ? (unsigned char*)NearBlock->base() +
  58                             NearBlock->size() : 0;
  59
  60 #if defined(__APPLE__) && defined(__arm__)
  61   void *pa = ::mmap(start, pageSize*NumPages, PROT_READ|PROT_EXEC,
  62                     flags, fd, 0);
  63 #else
  64   void *pa = ::mmap(start, pageSize*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC,
  65                     flags, fd, 0);
  66 #endif
  67   if (pa == MAP_FAILED) {
  68     if (NearBlock) //Try again without a near hint
  69       return AllocateRWX(NumBytes, 0);
  70
  71     MakeErrMsg(ErrMsg, "Can't allocate RWX Memory");
  72     return MemoryBlock();
  73   }
  74
  75 #if defined(__APPLE__) && defined(__arm__)
  76   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)pa,
  77                                 (vm_size_t)(pageSize*NumPages), 0,
  78                                 VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
  79   if (KERN_SUCCESS != kr) {
  80     MakeErrMsg(ErrMsg, "vm_protect max RX failed");
  81     return sys::MemoryBlock();
  82   }
  83
  84   kr = vm_protect(mach_task_self(), (vm_address_t)pa,
  85                   (vm_size_t)(pageSize*NumPages), 0,
  86                   VM_PROT_READ | VM_PROT_WRITE);
  87   if (KERN_SUCCESS != kr) {
  88     MakeErrMsg(ErrMsg, "vm_protect RW failed");
  89     return sys::MemoryBlock();
  90   }
  91 #endif
  92
  93   MemoryBlock result;
  94   result.Address = pa;
  95   result.Size = NumPages*pageSize;
  96
  97   return result;
  98 }
  99
 100 bool llvm::sys::Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
 101   if (M.Address == 0 || M.Size == 0) return false;
 102   if (0 != ::munmap(M.Address, M.Size))
 103     return MakeErrMsg(ErrMsg, "Can't release RWX Memory");
 104   return false;
 105 }
 106
 107 bool llvm::sys::Memory::setWritable (MemoryBlock &M, std::string *ErrMsg) {
 108 #if defined(__APPLE__) && defined(__arm__)
 109   if (M.Address == 0 || M.Size == 0) return false;
 110   sys::Memory::InvalidateInstructionCache(M.Address, M.Size);
 111   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)M.Address,
 112     (vm_size_t)M.Size, 0, VM_PROT_READ | VM_PROT_WRITE);
 113   return KERN_SUCCESS == kr;
 114 #else
 115   return true;
 116 #endif
 117 }
 118
 119 bool llvm::sys::Memory::setExecutable (MemoryBlock &M, std::string *ErrMsg) {
 120 #if defined(__APPLE__) && defined(__arm__)
 121   if (M.Address == 0 || M.Size == 0) return false;
 122   sys::Memory::InvalidateInstructionCache(M.Address, M.Size);
 123   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)M.Address,
 124     (vm_size_t)M.Size, 0, VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
 125   return KERN_SUCCESS == kr;
 126 #else
 127   return true;
 128 #endif
 129 }
 130
 131 bool llvm::sys::Memory::setRangeWritable(const void *Addr, size_t Size) {
 132 #if defined(__APPLE__) && defined(__arm__)
 133   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)Addr,
 134                                 (vm_size_t)Size, 0,
 135                                 VM_PROT_READ | VM_PROT_WRITE);
 136   return KERN_SUCCESS == kr;
 137 #else
 138   return true;
 139 #endif
 140 }
 141
 142 bool llvm::sys::Memory::setRangeExecutable(const void *Addr, size_t Size) {
 143 #if defined(__APPLE__) && defined(__arm__)
 144   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)Addr,
 145                                 (vm_size_t)Size, 0,
 146                                 VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
 147   return KERN_SUCCESS == kr;
 148 #else
 149   return true;
 150 #endif
 151 }