//===- Win32/Memory.cpp - Win32 Memory Implementation -----------*- C++ -*-===// | |
// | |
// The LLVM Compiler Infrastructure | |
// | |
// This file is distributed under the University of Illinois Open Source | |
// License. See LICENSE.TXT for details. | |
// | |
//===----------------------------------------------------------------------===// | |
// | |
// This file provides the Win32 specific implementation of various Memory | |
// management utilities | |
// | |
//===----------------------------------------------------------------------===// | |
#include "Windows.h" | |
#include "llvm/Support/DataTypes.h" | |
#include "llvm/Support/Process.h" | |
namespace llvm { | |
using namespace sys; | |
//===----------------------------------------------------------------------===// | |
//=== WARNING: Implementation here must contain only Win32 specific code | |
//=== and must not be UNIX code | |
//===----------------------------------------------------------------------===// | |
MemoryBlock Memory::AllocateRWX(size_t NumBytes, | |
const MemoryBlock *NearBlock, | |
std::string *ErrMsg) { | |
if (NumBytes == 0) return MemoryBlock(); | |
static const size_t pageSize = Process::GetPageSize(); | |
size_t NumPages = (NumBytes+pageSize-1)/pageSize; | |
PVOID start = NearBlock ? static_cast<unsigned char *>(NearBlock->base()) + | |
NearBlock->size() : NULL; | |
void *pa = VirtualAlloc(start, NumPages*pageSize, MEM_RESERVE | MEM_COMMIT, | |
PAGE_EXECUTE_READWRITE); | |
if (pa == NULL) { | |
if (NearBlock) { | |
// Try again without the NearBlock hint | |
return AllocateRWX(NumBytes, NULL, ErrMsg); | |
} | |
MakeErrMsg(ErrMsg, "Can't allocate RWX Memory: "); | |
return MemoryBlock(); | |
} | |
MemoryBlock result; | |
result.Address = pa; | |
result.Size = NumPages*pageSize; | |
return result; | |
} | |
bool Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) { | |
if (M.Address == 0 || M.Size == 0) return false; | |
if (!VirtualFree(M.Address, 0, MEM_RELEASE)) | |
return MakeErrMsg(ErrMsg, "Can't release RWX Memory: "); | |
return false; | |
} | |
static DWORD getProtection(const void *addr) { | |
MEMORY_BASIC_INFORMATION info; | |
if (sizeof(info) == ::VirtualQuery(addr, &info, sizeof(info))) { | |
return info.Protect; | |
} | |
return 0; | |
} | |
bool Memory::setWritable(MemoryBlock &M, std::string *ErrMsg) { | |
if (!setRangeWritable(M.Address, M.Size)) { | |
return MakeErrMsg(ErrMsg, "Cannot set memory to writeable: "); | |
} | |
return true; | |
} | |
bool Memory::setExecutable(MemoryBlock &M, std::string *ErrMsg) { | |
if (!setRangeExecutable(M.Address, M.Size)) { | |
return MakeErrMsg(ErrMsg, "Cannot set memory to executable: "); | |
} | |
return true; | |
} | |
bool Memory::setRangeWritable(const void *Addr, size_t Size) { | |
DWORD prot = getProtection(Addr); | |
if (!prot) | |
return false; | |
if (prot == PAGE_EXECUTE || prot == PAGE_EXECUTE_READ) { | |
prot = PAGE_EXECUTE_READWRITE; | |
} else if (prot == PAGE_NOACCESS || prot == PAGE_READONLY) { | |
prot = PAGE_READWRITE; | |
} | |
DWORD oldProt; | |
sys::Memory::InvalidateInstructionCache(Addr, Size); | |
return ::VirtualProtect(const_cast<LPVOID>(Addr), Size, prot, &oldProt) | |
== TRUE; | |
} | |
bool Memory::setRangeExecutable(const void *Addr, size_t Size) { | |
DWORD prot = getProtection(Addr); | |
if (!prot) | |
return false; | |
if (prot == PAGE_NOACCESS) { | |
prot = PAGE_EXECUTE; | |
} else if (prot == PAGE_READONLY) { | |
prot = PAGE_EXECUTE_READ; | |
} else if (prot == PAGE_READWRITE) { | |
prot = PAGE_EXECUTE_READWRITE; | |
} | |
DWORD oldProt; | |
sys::Memory::InvalidateInstructionCache(Addr, Size); | |
return ::VirtualProtect(const_cast<LPVOID>(Addr), Size, prot, &oldProt) | |
== TRUE; | |
} | |
} |