From 33189e787b98c79bd03be466ec19dfb2f65eb65f Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Mon, 13 Sep 2004 22:38:11 +0000 Subject: [PATCH] Simplify the sys::Memory interface per Chris' request. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16318 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/System/Memory.h | 54 +++++++++++++++----------- lib/ExecutionEngine/JIT/JITEmitter.cpp | 4 +- lib/System/AIX/Memory.cpp | 17 ++++---- lib/System/Cygwin/Memory.cpp | 15 +++---- lib/System/Darwin/Memory.cpp | 17 ++++---- lib/System/FreeBSD/Memory.cpp | 16 ++++---- lib/System/Interix/Memory.cpp | 17 ++++---- lib/System/Linux/Memory.cpp | 17 ++++---- lib/System/SunOS/Memory.cpp | 17 ++++---- lib/System/Win32/Memory.cpp | 17 ++++---- lib/System/Win32/Memory.inc | 17 ++++---- 11 files changed, 114 insertions(+), 94 deletions(-) diff --git a/include/llvm/System/Memory.h b/include/llvm/System/Memory.h index 5b3c884cd78..3b319cb3baf 100644 --- a/include/llvm/System/Memory.h +++ b/include/llvm/System/Memory.h @@ -11,38 +11,48 @@ // //===----------------------------------------------------------------------===// -#ifndef LLVM_SYSTEM_PATH_H -#define LLVM_SYSTEM_PATH_H - -#include +#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); } + /// 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); - /// @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(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 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); /// @} }; } diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp index 3ce5765cf49..a0e7a946092 100644 --- a/lib/ExecutionEngine/JIT/JITEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp @@ -38,7 +38,7 @@ namespace { /// 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; @@ -53,7 +53,7 @@ namespace { JITMemoryManager::JITMemoryManager() { // Allocate a 16M block of memory... - sys::Memory::AllocateRWX(MemBlock,(16 << 20)); + MemBlock = sys::Memory::AllocateRWX((16 << 20)); MemBase = reinterpret_cast(MemBlock.base()); FunctionBase = MemBase + 512*1024; // Use 512k for stubs diff --git a/lib/System/AIX/Memory.cpp b/lib/System/AIX/Memory.cpp index 6ba57de40a6..dc8f2d1c475 100644 --- a/lib/System/AIX/Memory.cpp +++ b/lib/System/AIX/Memory.cpp @@ -26,8 +26,8 @@ using namespace sys; //=== 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; @@ -37,14 +37,15 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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); } } diff --git a/lib/System/Cygwin/Memory.cpp b/lib/System/Cygwin/Memory.cpp index 58e660c2083..2392e71e0db 100644 --- a/lib/System/Cygwin/Memory.cpp +++ b/lib/System/Cygwin/Memory.cpp @@ -26,8 +26,8 @@ using namespace sys; //=== 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; @@ -37,14 +37,15 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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); } } diff --git a/lib/System/Darwin/Memory.cpp b/lib/System/Darwin/Memory.cpp index a6a88835ad9..974d1dbe104 100644 --- a/lib/System/Darwin/Memory.cpp +++ b/lib/System/Darwin/Memory.cpp @@ -30,8 +30,8 @@ using namespace sys; /// 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; @@ -43,14 +43,15 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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; diff --git a/lib/System/FreeBSD/Memory.cpp b/lib/System/FreeBSD/Memory.cpp index eeb22e910bf..4ab1a5dcc15 100644 --- a/lib/System/FreeBSD/Memory.cpp +++ b/lib/System/FreeBSD/Memory.cpp @@ -25,8 +25,8 @@ using namespace sys; //=== 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; @@ -36,14 +36,16 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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); } } diff --git a/lib/System/Interix/Memory.cpp b/lib/System/Interix/Memory.cpp index b79f8b62680..94e58939328 100644 --- a/lib/System/Interix/Memory.cpp +++ b/lib/System/Interix/Memory.cpp @@ -25,8 +25,8 @@ using namespace sys; //=== 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; @@ -36,14 +36,15 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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); } } diff --git a/lib/System/Linux/Memory.cpp b/lib/System/Linux/Memory.cpp index 1bc6fd98bb4..1a55ad8a196 100644 --- a/lib/System/Linux/Memory.cpp +++ b/lib/System/Linux/Memory.cpp @@ -30,8 +30,8 @@ using namespace sys; /// 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; @@ -43,14 +43,15 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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; diff --git a/lib/System/SunOS/Memory.cpp b/lib/System/SunOS/Memory.cpp index d6d871aa715..8c6a44d2773 100644 --- a/lib/System/SunOS/Memory.cpp +++ b/lib/System/SunOS/Memory.cpp @@ -26,8 +26,8 @@ using namespace sys; //=== 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; @@ -37,14 +37,15 @@ void* Memory::AllocateRWX(Memory& M, unsigned NumBytes) { 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); } } diff --git a/lib/System/Win32/Memory.cpp b/lib/System/Win32/Memory.cpp index 8a9ae05f374..946e50cd6fc 100644 --- a/lib/System/Win32/Memory.cpp +++ b/lib/System/Win32/Memory.cpp @@ -22,8 +22,8 @@ using namespace sys; //=== 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; @@ -33,12 +33,13 @@ void* Memory::AllocateRWX(Memory&M, unsigned NumBytes) { 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); } diff --git a/lib/System/Win32/Memory.inc b/lib/System/Win32/Memory.inc index 8a9ae05f374..946e50cd6fc 100644 --- a/lib/System/Win32/Memory.inc +++ b/lib/System/Win32/Memory.inc @@ -22,8 +22,8 @@ using namespace sys; //=== 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; @@ -33,12 +33,13 @@ void* Memory::AllocateRWX(Memory&M, unsigned NumBytes) { 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); }