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 
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 
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 
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 
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