Moving SectionMemoryManager into RuntimeDyld and adding unit tests for it.

The SectionMemoryManager now supports (and requires) applying section-specific page permissions.  Clients using this memory manager must call either MCJIT::finalizeObject() or SectionMemoryManager::applyPermissions() before executing JITed code.

See r168718 for changes from the previous implementation.

llvm-svn: 168721

include/llvm/ExecutionEngine/SectionMemoryManager.h

@@ -22,14 +22,14 @@
 
 namespace llvm {
 
-/// This is a simple memory manager which implements the methods called by 
+/// This is a simple memory manager which implements the methods called by
 /// the RuntimeDyld class to allocate memory for section-based loading of
 /// objects, usually those generated by the MCJIT execution engine.
-/// 
-/// This memory manager allocates all section memory as read-write.  The 
+///
+/// This memory manager allocates all section memory as read-write.  The
 /// RuntimeDyld will copy JITed section memory into these allocated blocks
 /// and perform any necessary linking and relocations.
-/// 
+///
 /// Any client using this memory manager MUST ensure that section-specific
 /// page permissions have been applied before attempting to execute functions
 /// in the JITed object.  Permissions can be applied either by calling
@@ -45,7 +45,7 @@ public:
 
   /// \brief Allocates a memory block of (at least) the given size suitable for
   /// executable code.
-  /// 
+  ///
   /// The value of \p Alignment must be a power of two.  If \p Alignment is zero
   /// a default alignment of 16 will be used.
   virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
@@ -53,7 +53,7 @@ public:
 
   /// \brief Allocates a memory block of (at least) the given size suitable for
   /// executable code.
-  /// 
+  ///
   /// The value of \p Alignment must be a power of two.  If \p Alignment is zero
   /// a default alignment of 16 will be used.
   virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
@@ -86,7 +86,7 @@ public:
   /// Some platforms with separate data cache and instruction cache require
   /// explicit cache flush, otherwise JIT code manipulations (like resolved
   /// relocations) will get to the data cache but not to the instruction cache.
-  /// 
+  ///
   /// This method is not called by RuntimeDyld or MCJIT during the load
   /// process.  Clients may call this function when needed.  See the lli
   /// tool for example use.
@@ -136,7 +136,7 @@ public:
     llvm_unreachable("Unexpected call!");
     return 0;
   }
-  virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
+  virtual uint8_t *allocateStub(const GlobalValue *F, unsigned StubSize,
                                 unsigned Alignment) {
     llvm_unreachable("Unexpected call!");
     return 0;

lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt

@@ -3,4 +3,5 @@ add_llvm_library(LLVMRuntimeDyld
   RuntimeDyld.cpp
   RuntimeDyldELF.cpp
   RuntimeDyldMachO.cpp
+  SectionMemoryManager.cpp
   )

lib/ExecutionEngine/RuntimeDyld/SectionMemoryManager.cpp

@@ -13,9 +13,9 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Config/config.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/MathExtras.h"
-#include "SectionMemoryManager.h"
 
 #ifdef __linux__
   // These includes used by SectionMemoryManager::getPointerToNamedFunction()
@@ -77,7 +77,7 @@ uint8_t *SectionMemoryManager::allocateSection(MemoryGroup &MemGroup,
   //
   // FIXME: It would be useful to define a default allocation size (or add
   // it as a constructor parameter) to minimize the number of allocations.
-  // 
+  //
   // FIXME: Initialize the Near member for each memory group to avoid
   // interleaving.
   error_code ec;

unittests/ExecutionEngine/MCJIT/CMakeLists.txt

@@ -2,14 +2,14 @@ set(LLVM_LINK_COMPONENTS
   asmparser
   bitreader
   bitwriter
-  mcjit
   jit
+  mcjit
   nativecodegen
   )
 
 set(MCJITTestsSources
   MCJITTest.cpp
-  SectionMemoryManager.cpp
+  MCJITMemoryManagerTest.cpp
   )
 
 if(MSVC)

unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp

@@ -0,0 +1,172 @@
+//===- MCJITMemoryManagerTest.cpp - Unit tests for the JIT memory manager -===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/ExecutionEngine/JIT.h"
+
+using namespace llvm;
+
+namespace {
+
+TEST(MCJITMemoryManagerTest, BasicAllocations) {
+  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+
+  uint8_t *code1 = MemMgr->allocateCodeSection(256, 0, 1);
+  uint8_t *data1 = MemMgr->allocateDataSection(256, 0, 2, true);
+  uint8_t *code2 = MemMgr->allocateCodeSection(256, 0, 3);
+  uint8_t *data2 = MemMgr->allocateDataSection(256, 0, 4, false);
+
+  EXPECT_NE((uint8_t*)0, code1);
+  EXPECT_NE((uint8_t*)0, code2);
+  EXPECT_NE((uint8_t*)0, data1);
+  EXPECT_NE((uint8_t*)0, data2);
+
+  // Initialize the data
+  for (unsigned i = 0; i < 256; ++i) {
+    code1[i] = 1;
+    code2[i] = 2;
+    data1[i] = 3;
+    data2[i] = 4;
+  }
+
+  // Verify the data (this is checking for overlaps in the addresses)
+  for (unsigned i = 0; i < 256; ++i) {
+    EXPECT_EQ(1, code1[i]);
+    EXPECT_EQ(2, code2[i]);
+    EXPECT_EQ(3, data1[i]);
+    EXPECT_EQ(4, data2[i]);
+  }
+
+  std::string Error;
+  EXPECT_FALSE(MemMgr->applyPermissions(&Error));
+}
+
+TEST(MCJITMemoryManagerTest, LargeAllocations) {
+  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+
+  uint8_t *code1 = MemMgr->allocateCodeSection(0x100000, 0, 1);
+  uint8_t *data1 = MemMgr->allocateDataSection(0x100000, 0, 2, true);
+  uint8_t *code2 = MemMgr->allocateCodeSection(0x100000, 0, 3);
+  uint8_t *data2 = MemMgr->allocateDataSection(0x100000, 0, 4, false);
+
+  EXPECT_NE((uint8_t*)0, code1);
+  EXPECT_NE((uint8_t*)0, code2);
+  EXPECT_NE((uint8_t*)0, data1);
+  EXPECT_NE((uint8_t*)0, data2);
+
+  // Initialize the data
+  for (unsigned i = 0; i < 0x100000; ++i) {
+    code1[i] = 1;
+    code2[i] = 2;
+    data1[i] = 3;
+    data2[i] = 4;
+  }
+
+  // Verify the data (this is checking for overlaps in the addresses)
+  for (unsigned i = 0; i < 0x100000; ++i) {
+    EXPECT_EQ(1, code1[i]);
+    EXPECT_EQ(2, code2[i]);
+    EXPECT_EQ(3, data1[i]);
+    EXPECT_EQ(4, data2[i]);
+  }
+
+  std::string Error;
+  EXPECT_FALSE(MemMgr->applyPermissions(&Error));
+}
+
+TEST(MCJITMemoryManagerTest, ManyAllocations) {
+  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+
+  uint8_t* code[10000];
+  uint8_t* data[10000];
+
+  for (unsigned i = 0; i < 10000; ++i) {
+    const bool isReadOnly = i % 2 == 0;
+
+    code[i] = MemMgr->allocateCodeSection(32, 0, 1);
+    data[i] = MemMgr->allocateDataSection(32, 0, 2, isReadOnly);
+
+    for (unsigned j = 0; j < 32; j++) {
+      code[i][j] = 1 + (i % 254);
+      data[i][j] = 2 + (i % 254);
+    }
+
+    EXPECT_NE((uint8_t *)0, code[i]);
+    EXPECT_NE((uint8_t *)0, data[i]);
+  }
+
+  // Verify the data (this is checking for overlaps in the addresses)
+  for (unsigned i = 0; i < 10000; ++i) {
+    for (unsigned j = 0; j < 32;j++ ) {
+      uint8_t ExpectedCode = 1 + (i % 254);
+      uint8_t ExpectedData = 2 + (i % 254);
+      EXPECT_EQ(ExpectedCode, code[i][j]);
+      EXPECT_EQ(ExpectedData, data[i][j]);
+    }
+  }
+
+  std::string Error;
+  EXPECT_FALSE(MemMgr->applyPermissions(&Error));
+}
+
+TEST(MCJITMemoryManagerTest, ManyVariedAllocations) {
+  OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
+
+  uint8_t* code[10000];
+  uint8_t* data[10000];
+
+  for (unsigned i = 0; i < 10000; ++i) {
+    uintptr_t CodeSize = i % 16 + 1;
+    uintptr_t DataSize = i % 8 + 1;
+
+    bool isReadOnly = i % 3 == 0;
+    unsigned Align = 8 << (i % 4);
+
+    code[i] = MemMgr->allocateCodeSection(CodeSize, Align, i);
+    data[i] = MemMgr->allocateDataSection(DataSize, Align, i + 10000,
+                                          isReadOnly);
+
+    for (unsigned j = 0; j < CodeSize; j++) {
+      code[i][j] = 1 + (i % 254);
+    }
+
+    for (unsigned j = 0; j < DataSize; j++) {
+      data[i][j] = 2 + (i % 254);
+    }
+
+    EXPECT_NE((uint8_t *)0, code[i]);
+    EXPECT_NE((uint8_t *)0, data[i]);
+
+    uintptr_t CodeAlign = Align ? (uintptr_t)code[i] % Align : 0;
+    uintptr_t DataAlign = Align ? (uintptr_t)data[i] % Align : 0;
+
+    EXPECT_EQ((uintptr_t)0, CodeAlign);
+    EXPECT_EQ((uintptr_t)0, DataAlign);
+  }
+
+  for (unsigned i = 0; i < 10000; ++i) {
+    uintptr_t CodeSize = i % 16 + 1;
+    uintptr_t DataSize = i % 8 + 1;
+
+    for (unsigned j = 0; j < CodeSize; j++) {
+      uint8_t ExpectedCode = 1 + (i % 254);
+      EXPECT_EQ(ExpectedCode, code[i][j]);
+    }
+
+    for (unsigned j = 0; j < DataSize; j++) {
+      uint8_t ExpectedData = 2 + (i % 254);
+      EXPECT_EQ(ExpectedData, data[i][j]); 
+    }
+  }
+}
+
+} // Namespace
+

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

@@ -21,6 +21,7 @@
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Config/config.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/Function.h"
 #include "llvm/IRBuilder.h"
 #include "llvm/LLVMContext.h"
@@ -30,8 +31,6 @@
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/TypeBuilder.h"
 
-#include "SectionMemoryManager.h"
-
 // Used to skip tests on unsupported architectures and operating systems.
 // To skip a test, add this macro at the top of a test-case in a suite that
 // inherits from MCJITTestBase. See MCJITTest.cpp for examples.