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

@@ -11,38 +11,48 @@
 //
 //===----------------------------------------------------------------------===//
 
-#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); }
+      /// 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<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 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);
     /// @}
   };
 }

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<unsigned char*>(MemBlock.base());
   FunctionBase = MemBase + 512*1024; // Use 512k for stubs
 

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);
   }
 }

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);
   }
 }

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;

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);
   }
 }

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);
   }
 }

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;

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);
   }
 }

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);
 }

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);
 }