lib/Support/Windows/Memory.inc

   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
  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
  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
  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.
 158 void Memory::InvalidateInstructionCache(
 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;
 219   Memory::InvalidateInstructionCache(Addr, Size);
 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;
 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