//
//===----------------------------------------------------------------------===//
-#ifndef LLVM_SYSTEM_PATH_H
-#define LLVM_SYSTEM_PATH_H
-
-#include <string>
+#ifndef LLVM_SYSTEM_MEMORY_H
+#define LLVM_SYSTEM_MEMORY_H
namespace llvm {
namespace sys {
- /// This class provides an abstraction for various memory handling functions
+ /// This class encapsulates the notion of a memory block which has an address
+ /// and a size. It is used by the Memory class (a friend) as the result of
+ /// various memory allocation operations.
+ /// @see Memory
+ /// @brief Memory block abstraction.
+ class MemoryBlock {
+ public:
+ void* base() const { return Address; }
+ unsigned size() const { return Size; }
+ private:
+ void * Address; ///< Address of first byte of memory area
+ unsigned Size; ///< Size, in bytes of the memory area
+ friend class Memory;
+ };
+
+ /// This class provides various memory handling functions that manipulate
+ /// MemoryBlock instances.
/// @since 1.4
- /// @brief An abstraction for operating system paths.
+ /// @brief An abstraction for memory operations.
class Memory {
/// @name Functions
/// @{
public:
- Memory() { Address = 0; AllocSize = 0; }
- ~Memory() { ReleaseRWX(*this); }
-
- /// @throws std::string if an error occurred
- static void* AllocateRWX(Memory& block, unsigned NumBytes);
-
- /// @throws std::string if an error occurred
- static void ReleaseRWX(Memory& block);
-
- char* base() const { return reinterpret_cast<char*>(Address); }
- unsigned size() const { return AllocSize; }
- /// @}
- /// @name Data
- /// @{
- private:
- void * Address; // Address of first byte of memory area
- unsigned AllocSize; // Size, in bytes of the memory area
+ /// This method allocates a block of Read/Write/Execute memory that is
+ /// suitable for executing dynamically generated code (e.g. JIT). An
+ /// attempt to allocate \p NumBytes bytes of virtual memory is made.
+ /// @throws std::string if an error occurred.
+ /// @brief Allocate Read/Write/Execute memory.
+ static MemoryBlock AllocateRWX(unsigned NumBytes);
+
+ /// This method releases a block of Read/Write/Execute memory that was
+ /// allocated with the AllocateRWX method. It should not be used to release
+ /// any memory block allocated any other way.
+ /// @throws std::string if an error occurred.
+ /// @brief Release Read/Write/Execute memory.
+ static void ReleaseRWX(MemoryBlock& block);
/// @}
};
}
/// are emitting is. This never bothers to release the memory, because when
/// we are ready to destroy the JIT, the program exits.
class JITMemoryManager {
- sys::Memory MemBlock; // Virtual memory block allocated RWX
+ sys::MemoryBlock MemBlock; // Virtual memory block allocated RWX
unsigned char *MemBase; // Base of block of memory, start of stub mem
unsigned char *FunctionBase; // Start of the function body area
unsigned char *CurStubPtr, *CurFunctionPtr;
JITMemoryManager::JITMemoryManager() {
// Allocate a 16M block of memory...
- sys::Memory::AllocateRWX(MemBlock,(16 << 20));
+ MemBlock = sys::Memory::AllocateRWX((16 << 20));
MemBase = reinterpret_cast<unsigned char*>(MemBlock.base());
FunctionBase = MemBase + 512*1024; // Use 512k for stubs
//=== and must not be generic UNIX code (see ../Unix/Memory.cpp)
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
if (pa == (void*)-1) {
throw std::string("Can't allocate RWX Memory: ") + strerror(errno);
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+ MemoryBlock result;
+ result.Address = pa;
+ result.Size = NumPages*pageSize;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
throw std::string("Can't release RWX Memory: ") + strerror(errno);
}
}
//=== and must not be generic UNIX code (see ../Unix/Memory.cpp)
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
if (pa == (void*)-1) {
throw std::string("Can't allocate RWX Memory: ") + strerror(errno);
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+ MemoryBlock result;
+ result.Address = pa;
+ result.Size = NumPages*pageSize;
+ return result;
}
void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
throw std::string("Can't release RWX Memory: ") + strerror(errno);
}
}
/// to emit code to the memory then jump to it. Getting this type of memory
/// is very OS specific.
///
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
strerror_r(errno, msg, MAXPATHLEN-1);
throw std::string("Can't allocate RWX Memory: ") + msg;
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+ MemoryBlock result;
+ result.Address = pa;
+ result.Size = NumPages*pageSize;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
char msg[MAXPATHLEN];
strerror_r(errno, msg, MAXPATHLEN-1);
throw std::string("Can't release RWX Memory: ") + msg;
//=== and must not be generic UNIX code (see ../Unix/Memory.cpp)
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
if (pa == (void*)-1) {
throw std::string("Can't allocate RWX Memory: ") + strerror(errno);
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+
+ MemoryBlock result;
+ result.Address = pa;
+ result.Size = NumPages*pageSize;
+ return result;
}
void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
throw std::string("Can't release RWX Memory: ") + strerror(errno);
}
}
//=== and must not be generic UNIX code (see ../Unix/Memory.cpp)
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
if (pa == (void*)-1) {
throw std::string("Can't allocate RWX Memory: ") + strerror(errno);
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+ MemoryBlock result;
+ result.Address = pa;
+ result.Size = NumPages*pageSize;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
throw std::string("Can't release RWX Memory: ") + strerror(errno);
}
}
/// to emit code to the memory then jump to it. Getting this type of memory
/// is very OS specific.
///
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
strerror_r(errno, msg, MAXPATHLEN-1);
throw std::string("Can't allocate RWX Memory: ") + msg;
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+ MemoryBlock result;
+ result.Address = pa;
+ result.Size = NumPages*pageSize;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
char msg[MAXPATHLEN];
strerror_r(errno, msg, MAXPATHLEN-1);
throw std::string("Can't release RWX Memory: ") + msg;
//=== and must not be generic UNIX code (see ../Unix/Memory.cpp)
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
static const long pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
if (pa == (void*)-1) {
throw std::string("Can't allocate RWX Memory: ") + strerror(errno);
}
- M.Address = pa;
- M.AllocSize = NumPages*pageSize;
- return pa;
+ MemoryBlock result;
+ result.Address = pa;
+ result.AllocSize = NumPages*pageSize;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 || M.AllocSize == 0) return;
- if (0 != munmap(M.Address, M.AllocSize)) {
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ if (0 != munmap(M.Address, M.Size)) {
throw std::string("Can't release RWX Memory: ") + strerror(errno);
}
}
//=== WARNING: Implementation here must contain only Win32 specific code.
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory&M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
unsigned pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
throw std::string("Couldn't allocate ") + utostr(NumBytes) +
" bytes of executable memory!";
}
- M.Address = P;
- M.AllocSize = NumBytes;
- return P;
+ MemoryBlock result;
+ result.Address = P;
+ result.Size = NumBytes;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 ) return;
- VirtualFree(M.Address, M.AllocSize, MEM_DECOMMIT, PAGE_NOACCESS);
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ VirtualFree(M.Address, M.Size, MEM_DECOMMIT, PAGE_NOACCESS);
}
//=== WARNING: Implementation here must contain only Win32 specific code.
//===----------------------------------------------------------------------===//
-void* Memory::AllocateRWX(Memory&M, unsigned NumBytes) {
- if (NumBytes == 0) return 0;
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes) {
+ if (NumBytes == 0) return MemoryBlock();
unsigned pageSize = Process::GetPageSize();
unsigned NumPages = (NumBytes+pageSize-1)/pageSize;
throw std::string("Couldn't allocate ") + utostr(NumBytes) +
" bytes of executable memory!";
}
- M.Address = P;
- M.AllocSize = NumBytes;
- return P;
+ MemoryBlock result;
+ result.Address = P;
+ result.Size = NumBytes;
+ return result;
}
-void Memory::ReleaseRWX(Memory& M) {
- if (M.Address == 0 ) return;
- VirtualFree(M.Address, M.AllocSize, MEM_DECOMMIT, PAGE_NOACCESS);
+void Memory::ReleaseRWX(MemoryBlock& M) {
+ if (M.Address == 0 || M.Size == 0) return;
+ VirtualFree(M.Address, M.Size, MEM_DECOMMIT, PAGE_NOACCESS);
}