• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
16#include "llvm/Support/ErrorHandling.h"
17#include "llvm/Support/Process.h"
18#include "llvm/Support/WindowsError.h"
19
20// The Windows.h header must be the last one included.
21#include "WindowsSupport.h"
22
23namespace {
24
25DWORD 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
29  case llvm::sys::Memory::MF_READ:
30    return PAGE_READONLY;
31  case llvm::sys::Memory::MF_WRITE:
32    // Note: PAGE_WRITE is not supported by VirtualProtect
33    return PAGE_READWRITE;
34  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_WRITE:
35    return PAGE_READWRITE;
36  case llvm::sys::Memory::MF_READ|llvm::sys::Memory::MF_EXEC:
37    return PAGE_EXECUTE_READ;
38  case llvm::sys::Memory::MF_READ |
39         llvm::sys::Memory::MF_WRITE |
40         llvm::sys::Memory::MF_EXEC:
41    return PAGE_EXECUTE_READWRITE;
42  case llvm::sys::Memory::MF_EXEC:
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
51size_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
62namespace llvm {
63namespace sys {
64
65//===----------------------------------------------------------------------===//
66//=== WARNING: Implementation here must contain only Win32 specific code
67//===          and must not be UNIX code
68//===----------------------------------------------------------------------===//
69
70MemoryBlock 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.
158void Memory::InvalidateInstructionCache(
159    const void *Addr, size_t Len) {
160  FlushInstructionCache(GetCurrentProcess(), Addr, Len);
161}
162
163
164MemoryBlock 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
177bool 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
185static 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
193bool 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
200bool 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
207bool 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;
219  Memory::InvalidateInstructionCache(Addr, Size);
220  return ::VirtualProtect(const_cast<LPVOID>(Addr), Size, prot, &oldProt)
221            == TRUE;
222}
223
224bool 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;
238  Memory::InvalidateInstructionCache(Addr, Size);
239  return ::VirtualProtect(const_cast<LPVOID>(Addr), Size, prot, &oldProt)
240            == TRUE;
241}
242
243} // namespace sys
244} // namespace llvm
245