[MCJIT] Add a FindGlobalVariableNamed utility
[oota-llvm.git] / unittests / ExecutionEngine / MCJIT / MCJITMultipleModuleTest.cpp
1 //===- MCJITMultipeModuleTest.cpp - Unit tests for the MCJIT---------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This test suite verifies MCJIT for handling multiple modules in a single
11 // ExecutionEngine by building multiple modules, making function calls across
12 // modules, accessing global variables, etc.
13 //===----------------------------------------------------------------------===//
14
15 #include "llvm/ExecutionEngine/MCJIT.h"
16 #include "MCJITTestBase.h"
17 #include "gtest/gtest.h"
18
19 using namespace llvm;
20
21 namespace {
22
23 class MCJITMultipleModuleTest : public testing::Test, public MCJITTestBase {};
24
25 // FIXME: ExecutionEngine has no support empty modules
26 /*
27 TEST_F(MCJITMultipleModuleTest, multiple_empty_modules) {
28   SKIP_UNSUPPORTED_PLATFORM;
29
30   createJIT(M.take());
31   // JIT-compile
32   EXPECT_NE(0, TheJIT->getObjectImage())
33     << "Unable to generate executable loaded object image";
34
35   TheJIT->addModule(createEmptyModule("<other module>"));
36   TheJIT->addModule(createEmptyModule("<other other module>"));
37
38   // JIT again
39   EXPECT_NE(0, TheJIT->getObjectImage())
40     << "Unable to generate executable loaded object image";
41 }
42 */
43
44 // Helper Function to test add operation
45 void checkAdd(uint64_t ptr) {
46   ASSERT_TRUE(ptr != 0) << "Unable to get pointer to function.";
47   int (*AddPtr)(int, int) = (int (*)(int, int))ptr;
48   EXPECT_EQ(0, AddPtr(0, 0));
49   EXPECT_EQ(1, AddPtr(1, 0));
50   EXPECT_EQ(3, AddPtr(1, 2));
51   EXPECT_EQ(-5, AddPtr(-2, -3));
52   EXPECT_EQ(30, AddPtr(10, 20));
53   EXPECT_EQ(-30, AddPtr(-10, -20));
54   EXPECT_EQ(-40, AddPtr(-10, -30));
55 }
56
57 void checkAccumulate(uint64_t ptr) {
58   ASSERT_TRUE(ptr != 0) << "Unable to get pointer to function.";
59   int32_t (*FPtr)(int32_t) = (int32_t (*)(int32_t))(intptr_t)ptr;
60   EXPECT_EQ(0, FPtr(0));
61   EXPECT_EQ(1, FPtr(1));
62   EXPECT_EQ(3, FPtr(2));
63   EXPECT_EQ(6, FPtr(3));
64   EXPECT_EQ(10, FPtr(4));
65   EXPECT_EQ(15, FPtr(5));
66 }
67
68 // FIXME: ExecutionEngine has no support empty modules
69 /*
70 TEST_F(MCJITMultipleModuleTest, multiple_empty_modules) {
71   SKIP_UNSUPPORTED_PLATFORM;
72
73   createJIT(M.take());
74   // JIT-compile
75   EXPECT_NE(0, TheJIT->getObjectImage())
76     << "Unable to generate executable loaded object image";
77
78   TheJIT->addModule(createEmptyModule("<other module>"));
79   TheJIT->addModule(createEmptyModule("<other other module>"));
80
81   // JIT again
82   EXPECT_NE(0, TheJIT->getObjectImage())
83     << "Unable to generate executable loaded object image";
84 }
85 */
86
87 // Module A { Function FA },
88 // Module B { Function FB },
89 // execute FA then FB
90 TEST_F(MCJITMultipleModuleTest, two_module_case) {
91   SKIP_UNSUPPORTED_PLATFORM;
92
93   std::unique_ptr<Module> A, B;
94   Function *FA, *FB;
95   createTwoModuleCase(A, FA, B, FB);
96
97   createJIT(std::move(A));
98   TheJIT->addModule(std::move(B));
99
100   uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
101   checkAdd(ptr);
102
103   ptr = TheJIT->getFunctionAddress(FB->getName().str());
104   checkAdd(ptr);
105 }
106
107 // Module A { Function FA },
108 // Module B { Function FB },
109 // execute FB then FA
110 TEST_F(MCJITMultipleModuleTest, two_module_reverse_case) {
111   SKIP_UNSUPPORTED_PLATFORM;
112
113   std::unique_ptr<Module> A, B;
114   Function *FA, *FB;
115   createTwoModuleCase(A, FA, B, FB);
116
117   createJIT(std::move(A));
118   TheJIT->addModule(std::move(B));
119
120   uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
121   TheJIT->finalizeObject();
122   checkAdd(ptr);
123
124   ptr = TheJIT->getFunctionAddress(FA->getName().str());
125   checkAdd(ptr);
126 }
127
128 // Module A { Function FA },
129 // Module B { Extern FA, Function FB which calls FA },
130 // execute FB then FA
131 TEST_F(MCJITMultipleModuleTest, two_module_extern_reverse_case) {
132   SKIP_UNSUPPORTED_PLATFORM;
133
134   std::unique_ptr<Module> A, B;
135   Function *FA, *FB;
136   createTwoModuleExternCase(A, FA, B, FB);
137
138   createJIT(std::move(A));
139   TheJIT->addModule(std::move(B));
140
141   uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
142   TheJIT->finalizeObject();
143   checkAdd(ptr);
144
145   ptr = TheJIT->getFunctionAddress(FA->getName().str());
146   checkAdd(ptr);
147 }
148
149 // Module A { Function FA },
150 // Module B { Extern FA, Function FB which calls FA },
151 // execute FA then FB
152 TEST_F(MCJITMultipleModuleTest, two_module_extern_case) {
153   SKIP_UNSUPPORTED_PLATFORM;
154
155   std::unique_ptr<Module> A, B;
156   Function *FA, *FB;
157   createTwoModuleExternCase(A, FA, B, FB);
158
159   createJIT(std::move(A));
160   TheJIT->addModule(std::move(B));
161
162   uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
163   checkAdd(ptr);
164
165   ptr = TheJIT->getFunctionAddress(FB->getName().str());
166   checkAdd(ptr);
167 }
168
169 // Module A { Function FA1, Function FA2 which calls FA1 },
170 // Module B { Extern FA1, Function FB which calls FA1 },
171 // execute FB then FA2
172 TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case) {
173   SKIP_UNSUPPORTED_PLATFORM;
174
175   std::unique_ptr<Module> A, B;
176   Function *FA1, *FA2, *FB;
177   createTwoModuleExternCase(A, FA1, B, FB);
178   FA2 = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(A.get(), FA1);
179
180   createJIT(std::move(A));
181   TheJIT->addModule(std::move(B));
182
183   uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
184   TheJIT->finalizeObject();
185   checkAdd(ptr);
186
187   ptr = TheJIT->getFunctionAddress(FA2->getName().str());
188   checkAdd(ptr);
189 }
190
191 // TODO:
192 // Module A { Extern Global GVB, Global Variable GVA, Function FA loads GVB },
193 // Module B { Extern Global GVA, Global Variable GVB, Function FB loads GVA },
194
195
196 // Module A { Global Variable GVA, Function FA loads GVA },
197 // Module B { Global Variable GVB, Internal Global GVC, Function FB loads GVB },
198 // execute FB then FA, also check that the global variables are properly accesible
199 // through the ExecutionEngine APIs
200 TEST_F(MCJITMultipleModuleTest, two_module_global_variables_case) {
201   SKIP_UNSUPPORTED_PLATFORM;
202
203   std::unique_ptr<Module> A, B;
204   Function *FA, *FB;
205   GlobalVariable *GVA, *GVB, *GVC;
206   A.reset(createEmptyModule("A"));
207   B.reset(createEmptyModule("B"));
208
209   int32_t initialNum = 7;
210   GVA = insertGlobalInt32(A.get(), "GVA", initialNum);
211   GVB = insertGlobalInt32(B.get(), "GVB", initialNum);
212   FA = startFunction<int32_t(void)>(A.get(), "FA");
213   endFunctionWithRet(FA, Builder.CreateLoad(GVA));
214   FB = startFunction<int32_t(void)>(B.get(), "FB");
215   endFunctionWithRet(FB, Builder.CreateLoad(GVB));
216
217   GVC = insertGlobalInt32(B.get(), "GVC", initialNum);
218   GVC->setLinkage(GlobalValue::InternalLinkage);
219
220   createJIT(std::move(A));
221   TheJIT->addModule(std::move(B));
222
223   EXPECT_EQ(GVA, TheJIT->FindGlobalVariableNamed("GVA"));
224   EXPECT_EQ(GVB, TheJIT->FindGlobalVariableNamed("GVB"));
225   EXPECT_EQ(GVC, TheJIT->FindGlobalVariableNamed("GVC",true));
226   EXPECT_EQ(NULL, TheJIT->FindGlobalVariableNamed("GVC"));
227
228   uint64_t FBPtr = TheJIT->getFunctionAddress(FB->getName().str());
229   TheJIT->finalizeObject();
230   EXPECT_TRUE(0 != FBPtr);
231   int32_t(*FuncPtr)(void) = (int32_t(*)(void))FBPtr;
232   EXPECT_EQ(initialNum, FuncPtr())
233     << "Invalid value for global returned from JITted function in module B";
234
235   uint64_t FAPtr = TheJIT->getFunctionAddress(FA->getName().str());
236   EXPECT_TRUE(0 != FAPtr);
237   FuncPtr = (int32_t(*)(void))FAPtr;
238   EXPECT_EQ(initialNum, FuncPtr())
239     << "Invalid value for global returned from JITted function in module A";
240 }
241
242 // Module A { Function FA },
243 // Module B { Extern FA, Function FB which calls FA },
244 // Module C { Extern FA, Function FC which calls FA },
245 // execute FC, FB, FA
246 TEST_F(MCJITMultipleModuleTest, three_module_case) {
247   SKIP_UNSUPPORTED_PLATFORM;
248
249   std::unique_ptr<Module> A, B, C;
250   Function *FA, *FB, *FC;
251   createThreeModuleCase(A, FA, B, FB, C, FC);
252
253   createJIT(std::move(A));
254   TheJIT->addModule(std::move(B));
255   TheJIT->addModule(std::move(C));
256
257   uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
258   checkAdd(ptr);
259
260   ptr = TheJIT->getFunctionAddress(FB->getName().str());
261   checkAdd(ptr);
262
263   ptr = TheJIT->getFunctionAddress(FA->getName().str());
264   checkAdd(ptr);
265 }
266
267 // Module A { Function FA },
268 // Module B { Extern FA, Function FB which calls FA },
269 // Module C { Extern FA, Function FC which calls FA },
270 // execute FA, FB, FC
271 TEST_F(MCJITMultipleModuleTest, three_module_case_reverse_order) {
272   SKIP_UNSUPPORTED_PLATFORM;
273
274   std::unique_ptr<Module> A, B, C;
275   Function *FA, *FB, *FC;
276   createThreeModuleCase(A, FA, B, FB, C, FC);
277
278   createJIT(std::move(A));
279   TheJIT->addModule(std::move(B));
280   TheJIT->addModule(std::move(C));
281
282   uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
283   checkAdd(ptr);
284
285   ptr = TheJIT->getFunctionAddress(FB->getName().str());
286   checkAdd(ptr);
287
288   ptr = TheJIT->getFunctionAddress(FC->getName().str());
289   checkAdd(ptr);
290 }
291
292 // Module A { Function FA },
293 // Module B { Extern FA, Function FB which calls FA },
294 // Module C { Extern FB, Function FC which calls FB },
295 // execute FC, FB, FA
296 TEST_F(MCJITMultipleModuleTest, three_module_chain_case) {
297   SKIP_UNSUPPORTED_PLATFORM;
298
299   std::unique_ptr<Module> A, B, C;
300   Function *FA, *FB, *FC;
301   createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
302
303   createJIT(std::move(A));
304   TheJIT->addModule(std::move(B));
305   TheJIT->addModule(std::move(C));
306
307   uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
308   checkAdd(ptr);
309
310   ptr = TheJIT->getFunctionAddress(FB->getName().str());
311   checkAdd(ptr);
312
313   ptr = TheJIT->getFunctionAddress(FA->getName().str());
314   checkAdd(ptr);
315 }
316
317 // Module A { Function FA },
318 // Module B { Extern FA, Function FB which calls FA },
319 // Module C { Extern FB, Function FC which calls FB },
320 // execute FA, FB, FC
321 TEST_F(MCJITMultipleModuleTest, three_modules_chain_case_reverse_order) {
322   SKIP_UNSUPPORTED_PLATFORM;
323
324   std::unique_ptr<Module> A, B, C;
325   Function *FA, *FB, *FC;
326   createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
327
328   createJIT(std::move(A));
329   TheJIT->addModule(std::move(B));
330   TheJIT->addModule(std::move(C));
331
332   uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
333   checkAdd(ptr);
334
335   ptr = TheJIT->getFunctionAddress(FB->getName().str());
336   checkAdd(ptr);
337
338   ptr = TheJIT->getFunctionAddress(FC->getName().str());
339   checkAdd(ptr);
340 }
341
342 // Module A { Extern FB, Function FA which calls FB1 },
343 // Module B { Extern FA, Function FB1, Function FB2 which calls FA },
344 // execute FA, then FB1
345 // FIXME: this test case is not supported by MCJIT
346 TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case) {
347   SKIP_UNSUPPORTED_PLATFORM;
348
349   std::unique_ptr<Module> A, B;
350   Function *FA, *FB1, *FB2;
351   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
352
353   createJIT(std::move(A));
354   TheJIT->addModule(std::move(B));
355
356   uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
357   checkAccumulate(ptr);
358
359   ptr = TheJIT->getFunctionAddress(FB1->getName().str());
360   checkAccumulate(ptr);
361 }
362
363 // Module A { Extern FB, Function FA which calls FB1 },
364 // Module B { Extern FA, Function FB1, Function FB2 which calls FA },
365 // execute FB1 then FA
366 // FIXME: this test case is not supported by MCJIT
367 TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case_reverse_order) {
368   SKIP_UNSUPPORTED_PLATFORM;
369
370   std::unique_ptr<Module> A, B;
371   Function *FA, *FB1, *FB2;
372   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
373
374   createJIT(std::move(A));
375   TheJIT->addModule(std::move(B));
376
377   uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
378   checkAccumulate(ptr);
379
380   ptr = TheJIT->getFunctionAddress(FA->getName().str());
381   checkAccumulate(ptr);
382 }
383
384 // Module A { Extern FB1, Function FA which calls FB1 },
385 // Module B { Extern FA, Function FB1, Function FB2 which calls FA },
386 // execute FB1 then FB2
387 // FIXME: this test case is not supported by MCJIT
388 TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case3) {
389   SKIP_UNSUPPORTED_PLATFORM;
390
391   std::unique_ptr<Module> A, B;
392   Function *FA, *FB1, *FB2;
393   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
394
395   createJIT(std::move(A));
396   TheJIT->addModule(std::move(B));
397
398   uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
399   checkAccumulate(ptr);
400
401   ptr = TheJIT->getFunctionAddress(FB2->getName().str());
402   checkAccumulate(ptr);
403 }
404
405 // Test that FindFunctionNamed finds the definition of
406 // a function in the correct module. We check two functions
407 // in two different modules, to make sure that for at least
408 // one of them MCJIT had to ignore the extern declaration.
409 TEST_F(MCJITMultipleModuleTest, FindFunctionNamed_test) {
410   SKIP_UNSUPPORTED_PLATFORM;
411
412   std::unique_ptr<Module> A, B;
413   Function *FA, *FB1, *FB2;
414   createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
415
416   createJIT(std::move(A));
417   TheJIT->addModule(std::move(B));
418
419   EXPECT_EQ(FA, TheJIT->FindFunctionNamed(FA->getName().data()));
420   EXPECT_EQ(FB1, TheJIT->FindFunctionNamed(FB1->getName().data()));
421 }
422
423 }