1 //===- MCJITMemoryManagerTest.cpp - Unit tests for the JIT memory manager -===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
10 #include "gtest/gtest.h"
11
12 using namespace llvm;
13
14 namespace {
15
TEST(MCJITMemoryManagerTest,BasicAllocations)16 TEST(MCJITMemoryManagerTest, BasicAllocations) {
17 std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
18
19 uint8_t *code1 = MemMgr->allocateCodeSection(256, 0, 1, "");
20 uint8_t *data1 = MemMgr->allocateDataSection(256, 0, 2, "", true);
21 uint8_t *code2 = MemMgr->allocateCodeSection(256, 0, 3, "");
22 uint8_t *data2 = MemMgr->allocateDataSection(256, 0, 4, "", false);
23
24 EXPECT_NE((uint8_t*)nullptr, code1);
25 EXPECT_NE((uint8_t*)nullptr, code2);
26 EXPECT_NE((uint8_t*)nullptr, data1);
27 EXPECT_NE((uint8_t*)nullptr, data2);
28
29 // Initialize the data
30 for (unsigned i = 0; i < 256; ++i) {
31 code1[i] = 1;
32 code2[i] = 2;
33 data1[i] = 3;
34 data2[i] = 4;
35 }
36
37 // Verify the data (this is checking for overlaps in the addresses)
38 for (unsigned i = 0; i < 256; ++i) {
39 EXPECT_EQ(1, code1[i]);
40 EXPECT_EQ(2, code2[i]);
41 EXPECT_EQ(3, data1[i]);
42 EXPECT_EQ(4, data2[i]);
43 }
44
45 std::string Error;
46 EXPECT_FALSE(MemMgr->finalizeMemory(&Error));
47 }
48
TEST(MCJITMemoryManagerTest,LargeAllocations)49 TEST(MCJITMemoryManagerTest, LargeAllocations) {
50 std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
51
52 uint8_t *code1 = MemMgr->allocateCodeSection(0x100000, 0, 1, "");
53 uint8_t *data1 = MemMgr->allocateDataSection(0x100000, 0, 2, "", true);
54 uint8_t *code2 = MemMgr->allocateCodeSection(0x100000, 0, 3, "");
55 uint8_t *data2 = MemMgr->allocateDataSection(0x100000, 0, 4, "", false);
56
57 EXPECT_NE((uint8_t*)nullptr, code1);
58 EXPECT_NE((uint8_t*)nullptr, code2);
59 EXPECT_NE((uint8_t*)nullptr, data1);
60 EXPECT_NE((uint8_t*)nullptr, data2);
61
62 // Initialize the data
63 for (unsigned i = 0; i < 0x100000; ++i) {
64 code1[i] = 1;
65 code2[i] = 2;
66 data1[i] = 3;
67 data2[i] = 4;
68 }
69
70 // Verify the data (this is checking for overlaps in the addresses)
71 for (unsigned i = 0; i < 0x100000; ++i) {
72 EXPECT_EQ(1, code1[i]);
73 EXPECT_EQ(2, code2[i]);
74 EXPECT_EQ(3, data1[i]);
75 EXPECT_EQ(4, data2[i]);
76 }
77
78 std::string Error;
79 EXPECT_FALSE(MemMgr->finalizeMemory(&Error));
80 }
81
TEST(MCJITMemoryManagerTest,ManyAllocations)82 TEST(MCJITMemoryManagerTest, ManyAllocations) {
83 std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
84
85 uint8_t* code[10000];
86 uint8_t* data[10000];
87
88 for (unsigned i = 0; i < 10000; ++i) {
89 const bool isReadOnly = i % 2 == 0;
90
91 code[i] = MemMgr->allocateCodeSection(32, 0, 1, "");
92 data[i] = MemMgr->allocateDataSection(32, 0, 2, "", isReadOnly);
93
94 for (unsigned j = 0; j < 32; j++) {
95 code[i][j] = 1 + (i % 254);
96 data[i][j] = 2 + (i % 254);
97 }
98
99 EXPECT_NE((uint8_t *)nullptr, code[i]);
100 EXPECT_NE((uint8_t *)nullptr, data[i]);
101 }
102
103 // Verify the data (this is checking for overlaps in the addresses)
104 for (unsigned i = 0; i < 10000; ++i) {
105 for (unsigned j = 0; j < 32;j++ ) {
106 uint8_t ExpectedCode = 1 + (i % 254);
107 uint8_t ExpectedData = 2 + (i % 254);
108 EXPECT_EQ(ExpectedCode, code[i][j]);
109 EXPECT_EQ(ExpectedData, data[i][j]);
110 }
111 }
112
113 std::string Error;
114 EXPECT_FALSE(MemMgr->finalizeMemory(&Error));
115 }
116
TEST(MCJITMemoryManagerTest,ManyVariedAllocations)117 TEST(MCJITMemoryManagerTest, ManyVariedAllocations) {
118 std::unique_ptr<SectionMemoryManager> MemMgr(new SectionMemoryManager());
119
120 uint8_t* code[10000];
121 uint8_t* data[10000];
122
123 for (unsigned i = 0; i < 10000; ++i) {
124 uintptr_t CodeSize = i % 16 + 1;
125 uintptr_t DataSize = i % 8 + 1;
126
127 bool isReadOnly = i % 3 == 0;
128 unsigned Align = 8 << (i % 4);
129
130 code[i] = MemMgr->allocateCodeSection(CodeSize, Align, i, "");
131 data[i] = MemMgr->allocateDataSection(DataSize, Align, i + 10000, "",
132 isReadOnly);
133
134 for (unsigned j = 0; j < CodeSize; j++) {
135 code[i][j] = 1 + (i % 254);
136 }
137
138 for (unsigned j = 0; j < DataSize; j++) {
139 data[i][j] = 2 + (i % 254);
140 }
141
142 EXPECT_NE((uint8_t *)nullptr, code[i]);
143 EXPECT_NE((uint8_t *)nullptr, data[i]);
144
145 uintptr_t CodeAlign = Align ? (uintptr_t)code[i] % Align : 0;
146 uintptr_t DataAlign = Align ? (uintptr_t)data[i] % Align : 0;
147
148 EXPECT_EQ((uintptr_t)0, CodeAlign);
149 EXPECT_EQ((uintptr_t)0, DataAlign);
150 }
151
152 for (unsigned i = 0; i < 10000; ++i) {
153 uintptr_t CodeSize = i % 16 + 1;
154 uintptr_t DataSize = i % 8 + 1;
155
156 for (unsigned j = 0; j < CodeSize; j++) {
157 uint8_t ExpectedCode = 1 + (i % 254);
158 EXPECT_EQ(ExpectedCode, code[i][j]);
159 }
160
161 for (unsigned j = 0; j < DataSize; j++) {
162 uint8_t ExpectedData = 2 + (i % 254);
163 EXPECT_EQ(ExpectedData, data[i][j]);
164 }
165 }
166 }
167
168 } // Namespace
169
170