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///
31llvm::sys::MemoryBlock
32llvm::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
100bool 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
107bool 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
119bool 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
131bool 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
142bool 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}
152