LLVM API Documentation

Unix/Memory.inc

Go to the documentation of this file.
00001 //===- Unix/Memory.cpp - Generic UNIX System Configuration ------*- C++ -*-===//
00002 // 
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 // 
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file defines some functions for various memory management utilities.
00011 //
00012 //===----------------------------------------------------------------------===//
00013 
00014 #include "Unix.h"
00015 #include "llvm/Support/DataTypes.h"
00016 #include "llvm/System/Process.h"
00017 
00018 #ifdef HAVE_SYS_MMAN_H
00019 #include <sys/mman.h>
00020 #endif
00021 
00022 #ifdef __APPLE__
00023 #include <mach/mach.h>
00024 #endif
00025 
00026 /// AllocateRWX - Allocate a slab of memory with read/write/execute
00027 /// permissions.  This is typically used for JIT applications where we want
00028 /// to emit code to the memory then jump to it.  Getting this type of memory
00029 /// is very OS specific.
00030 ///
00031 llvm::sys::MemoryBlock 
00032 llvm::sys::Memory::AllocateRWX(size_t NumBytes, const MemoryBlock* NearBlock,
00033                                std::string *ErrMsg) {
00034   if (NumBytes == 0) return MemoryBlock();
00035 
00036   size_t pageSize = Process::GetPageSize();
00037   size_t NumPages = (NumBytes+pageSize-1)/pageSize;
00038 
00039   int fd = -1;
00040 #ifdef NEED_DEV_ZERO_FOR_MMAP
00041   static int zero_fd = open("/dev/zero", O_RDWR);
00042   if (zero_fd == -1) {
00043     MakeErrMsg(ErrMsg, "Can't open /dev/zero device");
00044     return MemoryBlock();
00045   }
00046   fd = zero_fd;
00047 #endif
00048 
00049   int flags = MAP_PRIVATE |
00050 #ifdef HAVE_MMAP_ANONYMOUS
00051   MAP_ANONYMOUS
00052 #else
00053   MAP_ANON
00054 #endif
00055   ;
00056 
00057   void* start = NearBlock ? (unsigned char*)NearBlock->base() + 
00058                             NearBlock->size() : 0;
00059 
00060 #if defined(__APPLE__) && defined(__arm__)
00061   void *pa = ::mmap(start, pageSize*NumPages, PROT_READ|PROT_EXEC,
00062                     flags, fd, 0);
00063 #else
00064   void *pa = ::mmap(start, pageSize*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC,
00065                     flags, fd, 0);
00066 #endif
00067   if (pa == MAP_FAILED) {
00068     if (NearBlock) //Try again without a near hint
00069       return AllocateRWX(NumBytes, 0);
00070 
00071     MakeErrMsg(ErrMsg, "Can't allocate RWX Memory");
00072     return MemoryBlock();
00073   }
00074 
00075 #if defined(__APPLE__) && defined(__arm__)
00076   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)pa,
00077                                 (vm_size_t)(pageSize*NumPages), 0,
00078                                 VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
00079   if (KERN_SUCCESS != kr) {
00080     MakeErrMsg(ErrMsg, "vm_protect max RX failed");
00081     return sys::MemoryBlock();
00082   }
00083 
00084   kr = vm_protect(mach_task_self(), (vm_address_t)pa,
00085                   (vm_size_t)(pageSize*NumPages), 0,
00086                   VM_PROT_READ | VM_PROT_WRITE);
00087   if (KERN_SUCCESS != kr) {
00088     MakeErrMsg(ErrMsg, "vm_protect RW failed");
00089     return sys::MemoryBlock();
00090   }
00091 #endif
00092 
00093   MemoryBlock result;
00094   result.Address = pa;
00095   result.Size = NumPages*pageSize;
00096 
00097   return result;
00098 }
00099 
00100 bool llvm::sys::Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
00101   if (M.Address == 0 || M.Size == 0) return false;
00102   if (0 != ::munmap(M.Address, M.Size))
00103     return MakeErrMsg(ErrMsg, "Can't release RWX Memory");
00104   return false;
00105 }
00106 
00107 bool llvm::sys::Memory::setWritable (MemoryBlock &M, std::string *ErrMsg) {
00108 #if defined(__APPLE__) && defined(__arm__)
00109   if (M.Address == 0 || M.Size == 0) return false;
00110   sys::Memory::InvalidateInstructionCache(M.Address, M.Size);
00111   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)M.Address,
00112     (vm_size_t)M.Size, 0, VM_PROT_READ | VM_PROT_WRITE);
00113   return KERN_SUCCESS == kr;
00114 #else
00115   return true;
00116 #endif
00117 }
00118 
00119 bool llvm::sys::Memory::setExecutable (MemoryBlock &M, std::string *ErrMsg) {
00120 #if defined(__APPLE__) && defined(__arm__)
00121   if (M.Address == 0 || M.Size == 0) return false;
00122   sys::Memory::InvalidateInstructionCache(M.Address, M.Size);
00123   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)M.Address,
00124     (vm_size_t)M.Size, 0, VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
00125   return KERN_SUCCESS == kr;
00126 #else
00127   return false;
00128 #endif
00129 }
00130 
00131 bool llvm::sys::Memory::setRangeWritable(const void *Addr, size_t Size) {
00132 #if defined(__APPLE__) && defined(__arm__)
00133   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)Addr,
00134                                 (vm_size_t)Size, 0,
00135                                 VM_PROT_READ | VM_PROT_WRITE);
00136   return KERN_SUCCESS == kr;
00137 #else
00138   return true;
00139 #endif
00140 }
00141 
00142 bool llvm::sys::Memory::setRangeExecutable(const void *Addr, size_t Size) {
00143 #if defined(__APPLE__) && defined(__arm__)
00144   kern_return_t kr = vm_protect(mach_task_self(), (vm_address_t)Addr,
00145                                 (vm_size_t)Size, 0,
00146                                 VM_PROT_READ | VM_PROT_EXECUTE | VM_PROT_COPY);
00147   return KERN_SUCCESS == kr;
00148 #else
00149   return true;
00150 #endif
00151 }