Change AllocateRWX/DeallocateRWX to not throw an exception.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@29058 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/System/Memory.h

@@ -14,6 +14,8 @@
 #ifndef LLVM_SYSTEM_MEMORY_H
 #define LLVM_SYSTEM_MEMORY_H
 
+#include <string>
+
 namespace llvm {
 namespace sys {
 
@@ -24,10 +26,10 @@ namespace sys {
   /// @brief Memory block abstraction.
   class MemoryBlock {
   public:
-    void* base() const { return Address; }
+    void *base() const { return Address; }
     unsigned size() const { return Size; }
   private:
-    void * Address;   ///< Address of first byte of memory area
+    void *Address;    ///< Address of first byte of memory area
     unsigned Size;    ///< Size, in bytes of the memory area
     friend class Memory;
   };
@@ -45,21 +47,27 @@ namespace sys {
       /// attempt to allocate \p NumBytes bytes of virtual memory is made.
       /// \p NearBlock may point to an existing allocation in which case
       /// an attempt is made to allocate more memory near the existing block.
-      /// @throws std::string if an error occurred.
+      ///
+      /// On success, this returns a non-null memory block, otherwise it returns
+      /// a null memory block and fills in *ErrMsg.
+      /// 
       /// @brief Allocate Read/Write/Execute memory.
-      static MemoryBlock AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock);
+      static MemoryBlock AllocateRWX(unsigned NumBytes,
+                                     const MemoryBlock *NearBlock,
+                                     std::string *ErrMsg = 0);
 
       /// 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.
+      ///
+      /// On success, this returns false, otherwise it returns true and fills
+      /// in *ErrMsg.
       /// @throws std::string if an error occurred.
       /// @brief Release Read/Write/Execute memory.
-      static void ReleaseRWX(MemoryBlock& block);
+      static bool ReleaseRWX(MemoryBlock &block, std::string *ErrMsg = 0);
-
     /// @}
   };
 }
 }
 
-
 #endif

lib/System/Unix/Memory.inc

@@ -18,14 +18,14 @@
 #include <sys/mman.h>
 #endif
 
-namespace llvm {
-
 /// AllocateRWXMemory - Allocate a slab of memory with read/write/execute
 /// permissions.  This is typically used for JIT applications where we want
 /// to emit code to the memory then jump to it.  Getting this type of memory
 /// is very OS specific.
 ///
-MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock) {
+llvm::sys::MemoryBlock 
+llvm::sys::Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock,
+                               std::string *ErrMsg) {
   if (NumBytes == 0) return MemoryBlock();
 
   long pageSize = Process::GetPageSize();
@@ -35,7 +35,8 @@ MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock)
 #ifdef NEED_DEV_ZERO_FOR_MMAP
   static int zero_fd = open("/dev/zero", O_RDWR);
   if (zero_fd == -1) {
-    ThrowErrno("Can't open /dev/zero device");
+    GetErrno("Can't open /dev/zero device", ErrMsg);
+    return MemoryBlock();
   }
   fd = zero_fd;
 #endif
@@ -48,15 +49,17 @@ MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock)
 #endif
   ;
 
-  void* start = NearBlock ? (unsigned char*) NearBlock->base() + NearBlock->size() : 0;
+  void* start = NearBlock ? (unsigned char*)NearBlock->base() + 
+                            NearBlock->size() : 0;
 
   void *pa = ::mmap(start, pageSize*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC,
                     flags, fd, 0);
   if (pa == MAP_FAILED) {
     if (NearBlock) //Try again without a near hint
       return AllocateRWX(NumBytes, 0);
-    else
+
-      ThrowErrno("Can't allocate RWX Memory");
+    GetErrno("Can't allocate RWX Memory", ErrMsg);
+    return MemoryBlock();
   }
   MemoryBlock result;
   result.Address = pa;
@@ -64,12 +67,10 @@ MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock)
   return result;
 }
 
-void Memory::ReleaseRWX(MemoryBlock& M) {
+bool llvm::sys::Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
-  if (M.Address == 0 || M.Size == 0) return;
+  if (M.Address == 0 || M.Size == 0) return false;
-  if (0 != ::munmap(M.Address, M.Size)) {
+  if (0 != ::munmap(M.Address, M.Size))
-    ThrowErrno("Can't release RWX Memory");
+    return GetErrno("Can't release RWX Memory", ErrMsg);
-  }
+  return false;
-}
-
 }
 

lib/System/Unix/Unix.h

@@ -66,6 +66,35 @@
 # define WIFEXITED(stat_val) (((stat_val) & 255) == 0)
 #endif
 
+inline bool GetErrno(const std::string &prefix, std::string *ErrDest,
+                     int errnum = -1) {
+  char buffer[MAXPATHLEN];
+  
+  if (ErrDest == 0) return true;
+  
+  buffer[0] = 0;
+  if (errnum == -1)
+    errnum = errno;
+#ifdef HAVE_STRERROR_R
+  // strerror_r is thread-safe.
+  if (errnum)
+    strerror_r(errnum, buffer, MAXPATHLEN-1);
+#elif HAVE_STRERROR
+  // Copy the thread un-safe result of strerror into
+  // the buffer as fast as possible to minimize impact
+  // of collision of strerror in multiple threads.
+  if (errnum)
+    strncpy(buffer, strerror(errnum), MAXPATHLEN-1);
+  buffer[MAXPATHLEN-1] = 0;
+#else
+  // Strange that this system doesn't even have strerror
+  // but, oh well, just use a generic message
+  sprintf(buffer, "Error #%d", errnum);
+#endif
+  *ErrDest = prefix + ": " + buffer;
+  return true;
+}
+
 inline void ThrowErrno(const std::string& prefix, int errnum = -1) {
   char buffer[MAXPATHLEN];
   buffer[0] = 0;

lib/System/Win32/Memory.inc

@@ -23,7 +23,9 @@ using namespace sys;
 //===          and must not be UNIX code
 //===----------------------------------------------------------------------===//
 
-MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock) {
+MemoryBlock Memory::AllocateRWX(unsigned NumBytes,
+                                const MemoryBlock *NearBlock,
+                                std::string *ErrMsg) {
   if (NumBytes == 0) return MemoryBlock();
 
   static const long pageSize = Process::GetPageSize();
@@ -34,7 +36,8 @@ MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock)
   void *pa = VirtualAlloc(NULL, NumPages*pageSize, MEM_COMMIT,
                   PAGE_EXECUTE_READWRITE);
   if (pa == NULL) {
-    ThrowError("Can't allocate RWX Memory: ");
+    GetError("Can't allocate RWX Memory: ", ErrMsg);
+    return MemoryBlock();
   }
 
   MemoryBlock result;
@@ -43,11 +46,10 @@ MemoryBlock Memory::AllocateRWX(unsigned NumBytes, const MemoryBlock* NearBlock)
   return result;
 }
 
-void Memory::ReleaseRWX(MemoryBlock& M) {
+bool Memory::ReleaseRWX(MemoryBlock &M, std::string *ErrMsg) {
   if (M.Address == 0 || M.Size == 0) return;
-  if (!VirtualFree(M.Address, 0, MEM_RELEASE)) {
+  if (!VirtualFree(M.Address, 0, MEM_RELEASE))
-    ThrowError("Can't release RWX Memory: ");
+    return GetError("Can't release RWX Memory: ", ErrMsg);
-  }
 }
 
 }