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.

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

6 files changed, 186 insertions, 14 deletions

diff --git a/unittests/ExecutionEngine/MCJIT/SectionMemoryManager.h b/include/llvm/ExecutionEngine/SectionMemoryManager.h
index 7d5a5ff..ba4ba8d0 100644
--- a/unittests/ExecutionEngine/MCJIT/SectionMemoryManager.h
+++ b/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;
diff --git a/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt b/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt
index cbf7cf1..728303a 100644
--- a/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt
+++ b/lib/ExecutionEngine/RuntimeDyld/CMakeLists.txt
@@ -3,4 +3,5 @@ add_llvm_library(LLVMRuntimeDyld
   RuntimeDyld.cpp
   RuntimeDyldELF.cpp
   RuntimeDyldMachO.cpp
+  SectionMemoryManager.cpp
   )
diff --git a/unittests/ExecutionEngine/MCJIT/SectionMemoryManager.cpp b/lib/ExecutionEngine/RuntimeDyld/SectionMemoryManager.cpp
index e8aaa82..fa35acd 100644
--- a/unittests/ExecutionEngine/MCJIT/SectionMemoryManager.cpp
+++ b/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;
diff --git a/unittests/ExecutionEngine/MCJIT/CMakeLists.txt b/unittests/ExecutionEngine/MCJIT/CMakeLists.txt
index 3e9c5b6..c6b1f77 100644
--- a/unittests/ExecutionEngine/MCJIT/CMakeLists.txt
+++ b/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)
diff --git a/unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp b/unittests/ExecutionEngine/MCJIT/MCJITMemoryManagerTest.cpp
new file mode 100644
index 0000000..eeea9d7
--- /dev/null
+++ b/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

+

diff --git a/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h b/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
index 9b4a4ac..e34074b 100644
--- a/unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
+++ b/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.