LLVM  6.0.0svn
Memory.inc
Go to the documentation of this file.
1 //===- Win32/Memory.cpp - Win32 Memory Implementation -----------*- 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 provides the Win32 specific implementation of various Memory
11 // management utilities
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/Support/DataTypes.h"
17 #include "llvm/Support/Process.h"
19 
20 // The Windows.h header must be the last one included.
21 #include "WindowsSupport.h"
22 
23 namespace {
24 
25 DWORD getWindowsProtectionFlags(unsigned Flags) {
26  switch (Flags) {
27  // Contrary to what you might expect, the Windows page protection flags
28  // are not a bitwise combination of RWX values
30  return PAGE_READONLY;
32  // Note: PAGE_WRITE is not supported by VirtualProtect
33  return PAGE_READWRITE;
35  return PAGE_READWRITE;
37  return PAGE_EXECUTE_READ;
41  return PAGE_EXECUTE_READWRITE;
43  return PAGE_EXECUTE;
44  default:
45  llvm_unreachable("Illegal memory protection flag specified!");
46  }
47  // Provide a default return value as required by some compilers.
48  return PAGE_NOACCESS;
49 }
50 
51 size_t getAllocationGranularity() {
52  SYSTEM_INFO Info;
53  ::GetSystemInfo(&Info);
54  if (Info.dwPageSize > Info.dwAllocationGranularity)
55  return Info.dwPageSize;
56  else
57  return Info.dwAllocationGranularity;
58 }
59 
60 } // namespace
61 
62 namespace llvm {
63 namespace sys {
64 
65 //===----------------------------------------------------------------------===//
66 //=== WARNING: Implementation here must contain only Win32 specific code
67 //=== and must not be UNIX code
68 //===----------------------------------------------------------------------===//
69 
70 MemoryBlock Memory::allocateMappedMemory(size_t NumBytes,
71  const MemoryBlock *const NearBlock,
72  unsigned Flags,
73  std::error_code &EC) {
74  EC = std::error_code();
75  if (NumBytes == 0)
76  return MemoryBlock();
77 
78  // While we'd be happy to allocate single pages, the Windows allocation
79  // granularity may be larger than a single page (in practice, it is 64K)
80  // so mapping less than that will create an unreachable fragment of memory.
81  // Avoid using one-time initialization of static locals here, since they
82  // aren't thread safe with MSVC.
83  static volatile size_t GranularityCached;
84  size_t Granularity = GranularityCached;
85  if (Granularity == 0) {
86  Granularity = getAllocationGranularity();
87  GranularityCached = Granularity;
88  }
89 
90  const size_t NumBlocks = (NumBytes+Granularity-1)/Granularity;
91 
92  uintptr_t Start = NearBlock ? reinterpret_cast<uintptr_t>(NearBlock->base()) +
93  NearBlock->size()
94  : 0;
95 
96  // If the requested address is not aligned to the allocation granularity,
97  // round up to get beyond NearBlock. VirtualAlloc would have rounded down.
98  if (Start && Start % Granularity != 0)
99  Start += Granularity - Start % Granularity;
100 
101  DWORD Protect = getWindowsProtectionFlags(Flags);
102 
103  void *PA = ::VirtualAlloc(reinterpret_cast<void*>(Start),
104  NumBlocks*Granularity,
105  MEM_RESERVE | MEM_COMMIT, Protect);
106  if (PA == NULL) {
107  if (NearBlock) {
108  // Try again without the NearBlock hint
109  return allocateMappedMemory(NumBytes, NULL, Flags, EC);
110  }
111  EC = mapWindowsError(::GetLastError());
112  return MemoryBlock();
113  }
114 
115  MemoryBlock Result;
116  Result.Address = PA;
117  Result.Size = NumBlocks*Granularity;
118 
119  if (Flags & MF_EXEC)
120  Memory::InvalidateInstructionCache(Result.Address, Result.Size);
121 
122  return Result;
123 }
124 
125  std::error_code Memory::releaseMappedMemory(MemoryBlock &M) {
126  if (M.Address == 0 || M.Size == 0)
127  return std::error_code();
128 
129  if (!VirtualFree(M.Address, 0, MEM_RELEASE))
130  return mapWindowsError(::GetLastError());
131 
132  M.Address = 0;
133  M.Size = 0;
134 
135  return std::error_code();
136 }
137 
138  std::error_code Memory::protectMappedMemory(const MemoryBlock &M,
139  unsigned Flags) {
140  if (M.Address == 0 || M.Size == 0)
141  return std::error_code();
142 
143  DWORD Protect = getWindowsProtectionFlags(Flags);
144 
145  DWORD OldFlags;
146  if (!VirtualProtect(M.Address, M.Size, Protect, &OldFlags))
147  return mapWindowsError(::GetLastError());
148 
149  if (Flags & MF_EXEC)
150  Memory::InvalidateInstructionCache(M.Address, M.Size);
151 
152  return std::error_code();
153 }
154 
155 /// InvalidateInstructionCache - Before the JIT can run a block of code
156 /// that has been emitted it must invalidate the instruction cache on some
157 /// platforms.
159  const void *Addr, size_t Len) {
160  FlushInstructionCache(GetCurrentProcess(), Addr, Len);
161 }
162 
163 
164 MemoryBlock Memory::AllocateRWX(size_t NumBytes,
165  const MemoryBlock *NearBlock,
166  std::string *ErrMsg) {
167  MemoryBlock MB;
168  std::error_code EC;
169  MB = allocateMappedMemory(NumBytes, NearBlock,
170  MF_READ|MF_WRITE|MF_EXEC, EC);
171  if (EC != std::error_code() && ErrMsg) {
172  MakeErrMsg(ErrMsg, EC.message());
173  }
174  return MB;
175 }
176 
177 bool Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
178  std::error_code EC = releaseMappedMemory(M);
179  if (EC == std::error_code())
180  return false;
181  MakeErrMsg(ErrMsg, EC.message());
182  return true;
183 }
184 
185 static DWORD getProtection(const void *addr) {
186  MEMORY_BASIC_INFORMATION info;
187  if (sizeof(info) == ::VirtualQuery(addr, &info, sizeof(info))) {
188  return info.Protect;
189  }
190  return 0;
191 }
192 
193 bool Memory::setWritable(MemoryBlock &M, std::string *ErrMsg) {
194  if (!setRangeWritable(M.Address, M.Size)) {
195  return MakeErrMsg(ErrMsg, "Cannot set memory to writeable");
196  }
197  return true;
198 }
199 
200 bool Memory::setExecutable(MemoryBlock &M, std::string *ErrMsg) {
201  if (!setRangeExecutable(M.Address, M.Size)) {
202  return MakeErrMsg(ErrMsg, "Cannot set memory to executable");
203  }
204  return true;
205 }
206 
207 bool Memory::setRangeWritable(const void *Addr, size_t Size) {
208  DWORD prot = getProtection(Addr);
209  if (!prot)
210  return false;
211 
212  if (prot == PAGE_EXECUTE || prot == PAGE_EXECUTE_READ) {
213  prot = PAGE_EXECUTE_READWRITE;
214  } else if (prot == PAGE_NOACCESS || prot == PAGE_READONLY) {
215  prot = PAGE_READWRITE;
216  }
217 
218  DWORD oldProt;
220  return ::VirtualProtect(const_cast<LPVOID>(Addr), Size, prot, &oldProt)
221  == TRUE;
222 }
223 
224 bool Memory::setRangeExecutable(const void *Addr, size_t Size) {
225  DWORD prot = getProtection(Addr);
226  if (!prot)
227  return false;
228 
229  if (prot == PAGE_NOACCESS) {
230  prot = PAGE_EXECUTE;
231  } else if (prot == PAGE_READONLY) {
232  prot = PAGE_EXECUTE_READ;
233  } else if (prot == PAGE_READWRITE) {
234  prot = PAGE_EXECUTE_READWRITE;
235  }
236 
237  DWORD oldProt;
239  return ::VirtualProtect(const_cast<LPVOID>(Addr), Size, prot, &oldProt)
240  == TRUE;
241 }
242 
243 } // namespace sys
244 } // namespace llvm
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
static bool setRangeWritable(const void *Addr, size_t Size)
setRangeWritable - Mark the page containing a range of addresses as writable.
static std::error_code releaseMappedMemory(MemoryBlock &Block)
This method releases a block of memory that was allocated with the allocateMappedMemory method...
static MemoryBlock allocateMappedMemory(size_t NumBytes, const MemoryBlock *const NearBlock, unsigned Flags, std::error_code &EC)
This method allocates a block of memory that is suitable for loading dynamically generated code (e...
static void InvalidateInstructionCache(const void *Addr, size_t Len)
InvalidateInstructionCache - Before the JIT can run a block of code that has been emitted it must inv...
static bool ReleaseRWX(MemoryBlock &block, std::string *ErrMsg=nullptr)
This method releases a block of Read/Write/Execute memory that was allocated with the AllocateRWX met...
std::error_code mapWindowsError(unsigned EV)
lazy value info
static bool setRangeExecutable(const void *Addr, size_t Size)
setRangeExecutable - Mark the page containing a range of addresses as executable. ...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static MemoryBlock AllocateRWX(size_t NumBytes, const MemoryBlock *NearBlock, std::string *ErrMsg=nullptr)
This method allocates a block of Read/Write/Execute memory that is suitable for executing dynamically...
bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix)
Provides a library for accessing information about this process and other processes on the operating ...
static bool setExecutable(MemoryBlock &M, std::string *ErrMsg=nullptr)
setExecutable - Before the JIT can run a block of code, it has to be given read and executable privil...
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
static bool setWritable(MemoryBlock &M, std::string *ErrMsg=nullptr)
setWritable - When adding to a block of code, the JIT may need to mark a block of code as RW since th...
static std::error_code protectMappedMemory(const MemoryBlock &Block, unsigned Flags)
This method sets the protection flags for a block of memory to the state specified by /p Flags...