1 //===- MCJITMemoryManagerTest.cpp - Unit tests for the JIT memory manager -===//
\r
3 // The LLVM Compiler Infrastructure
\r
5 // This file is distributed under the University of Illinois Open Source
\r
6 // License. See LICENSE.TXT for details.
\r
8 //===----------------------------------------------------------------------===//
\r
10 #include "gtest/gtest.h"
\r
11 #include "llvm/ADT/OwningPtr.h"
\r
12 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
\r
13 #include "llvm/ExecutionEngine/JIT.h"
\r
15 using namespace llvm;
\r
19 TEST(MCJITMemoryManagerTest, BasicAllocations) {
\r
20 OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
\r
22 uint8_t *code1 = MemMgr->allocateCodeSection(256, 0, 1);
\r
23 uint8_t *data1 = MemMgr->allocateDataSection(256, 0, 2, true);
\r
24 uint8_t *code2 = MemMgr->allocateCodeSection(256, 0, 3);
\r
25 uint8_t *data2 = MemMgr->allocateDataSection(256, 0, 4, false);
\r
27 EXPECT_NE((uint8_t*)0, code1);
\r
28 EXPECT_NE((uint8_t*)0, code2);
\r
29 EXPECT_NE((uint8_t*)0, data1);
\r
30 EXPECT_NE((uint8_t*)0, data2);
\r
32 // Initialize the data
\r
33 for (unsigned i = 0; i < 256; ++i) {
\r
40 // Verify the data (this is checking for overlaps in the addresses)
\r
41 for (unsigned i = 0; i < 256; ++i) {
\r
42 EXPECT_EQ(1, code1[i]);
\r
43 EXPECT_EQ(2, code2[i]);
\r
44 EXPECT_EQ(3, data1[i]);
\r
45 EXPECT_EQ(4, data2[i]);
\r
49 EXPECT_FALSE(MemMgr->applyPermissions(&Error));
\r
52 TEST(MCJITMemoryManagerTest, LargeAllocations) {
\r
53 OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
\r
55 uint8_t *code1 = MemMgr->allocateCodeSection(0x100000, 0, 1);
\r
56 uint8_t *data1 = MemMgr->allocateDataSection(0x100000, 0, 2, true);
\r
57 uint8_t *code2 = MemMgr->allocateCodeSection(0x100000, 0, 3);
\r
58 uint8_t *data2 = MemMgr->allocateDataSection(0x100000, 0, 4, false);
\r
60 EXPECT_NE((uint8_t*)0, code1);
\r
61 EXPECT_NE((uint8_t*)0, code2);
\r
62 EXPECT_NE((uint8_t*)0, data1);
\r
63 EXPECT_NE((uint8_t*)0, data2);
\r
65 // Initialize the data
\r
66 for (unsigned i = 0; i < 0x100000; ++i) {
\r
73 // Verify the data (this is checking for overlaps in the addresses)
\r
74 for (unsigned i = 0; i < 0x100000; ++i) {
\r
75 EXPECT_EQ(1, code1[i]);
\r
76 EXPECT_EQ(2, code2[i]);
\r
77 EXPECT_EQ(3, data1[i]);
\r
78 EXPECT_EQ(4, data2[i]);
\r
82 EXPECT_FALSE(MemMgr->applyPermissions(&Error));
\r
85 TEST(MCJITMemoryManagerTest, ManyAllocations) {
\r
86 OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
\r
88 uint8_t* code[10000];
\r
89 uint8_t* data[10000];
\r
91 for (unsigned i = 0; i < 10000; ++i) {
\r
92 const bool isReadOnly = i % 2 == 0;
\r
94 code[i] = MemMgr->allocateCodeSection(32, 0, 1);
\r
95 data[i] = MemMgr->allocateDataSection(32, 0, 2, isReadOnly);
\r
97 for (unsigned j = 0; j < 32; j++) {
\r
98 code[i][j] = 1 + (i % 254);
\r
99 data[i][j] = 2 + (i % 254);
\r
102 EXPECT_NE((uint8_t *)0, code[i]);
\r
103 EXPECT_NE((uint8_t *)0, data[i]);
\r
106 // Verify the data (this is checking for overlaps in the addresses)
\r
107 for (unsigned i = 0; i < 10000; ++i) {
\r
108 for (unsigned j = 0; j < 32;j++ ) {
\r
109 uint8_t ExpectedCode = 1 + (i % 254);
\r
110 uint8_t ExpectedData = 2 + (i % 254);
\r
111 EXPECT_EQ(ExpectedCode, code[i][j]);
\r
112 EXPECT_EQ(ExpectedData, data[i][j]);
\r
117 EXPECT_FALSE(MemMgr->applyPermissions(&Error));
\r
120 TEST(MCJITMemoryManagerTest, ManyVariedAllocations) {
\r
121 OwningPtr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
\r
123 uint8_t* code[10000];
\r
124 uint8_t* data[10000];
\r
126 for (unsigned i = 0; i < 10000; ++i) {
\r
127 uintptr_t CodeSize = i % 16 + 1;
\r
128 uintptr_t DataSize = i % 8 + 1;
\r
130 bool isReadOnly = i % 3 == 0;
\r
131 unsigned Align = 8 << (i % 4);
\r
133 code[i] = MemMgr->allocateCodeSection(CodeSize, Align, i);
\r
134 data[i] = MemMgr->allocateDataSection(DataSize, Align, i + 10000,
\r
137 for (unsigned j = 0; j < CodeSize; j++) {
\r
138 code[i][j] = 1 + (i % 254);
\r
141 for (unsigned j = 0; j < DataSize; j++) {
\r
142 data[i][j] = 2 + (i % 254);
\r
145 EXPECT_NE((uint8_t *)0, code[i]);
\r
146 EXPECT_NE((uint8_t *)0, data[i]);
\r
148 uintptr_t CodeAlign = Align ? (uintptr_t)code[i] % Align : 0;
\r
149 uintptr_t DataAlign = Align ? (uintptr_t)data[i] % Align : 0;
\r
151 EXPECT_EQ((uintptr_t)0, CodeAlign);
\r
152 EXPECT_EQ((uintptr_t)0, DataAlign);
\r
155 for (unsigned i = 0; i < 10000; ++i) {
\r
156 uintptr_t CodeSize = i % 16 + 1;
\r
157 uintptr_t DataSize = i % 8 + 1;
\r
159 for (unsigned j = 0; j < CodeSize; j++) {
\r
160 uint8_t ExpectedCode = 1 + (i % 254);
\r
161 EXPECT_EQ(ExpectedCode, code[i][j]);
\r
164 for (unsigned j = 0; j < DataSize; j++) {
\r
165 uint8_t ExpectedData = 2 + (i % 254);
\r
166 EXPECT_EQ(ExpectedData, data[i][j]);
\r