LLVM API Documentation
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 }