1 //===- MultiJITTest.cpp - Unit tests for instantiating multiple JITs ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/ExecutionEngine/JIT.h"
11 #include "llvm/AsmParser/Parser.h"
12 #include "llvm/ExecutionEngine/GenericValue.h"
13 #include "llvm/IR/LLVMContext.h"
14 #include "llvm/IR/Module.h"
15 #include "llvm/Support/SourceMgr.h"
16 #include "gtest/gtest.h"
23 // ARM, PowerPC and SystemZ tests disabled pending fix for PR10783.
24 #if !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__) \
25 && !defined(__aarch64__)
27 bool LoadAssemblyInto(Module *M, const char *assembly) {
30 nullptr != ParseAssemblyString(assembly, M, Error, M->getContext());
32 raw_string_ostream os(errMsg);
34 EXPECT_TRUE(success) << os.str();
38 void createModule1(LLVMContext &Context1, Module *&M1, Function *&FooF1) {
39 M1 = new Module("test1", Context1);
41 "define i32 @add1(i32 %ArgX1) { "
43 " %addresult = add i32 1, %ArgX1 "
44 " ret i32 %addresult "
47 "define i32 @foo1() { "
49 " %add1 = call i32 @add1(i32 10) "
52 FooF1 = M1->getFunction("foo1");
55 void createModule2(LLVMContext &Context2, Module *&M2, Function *&FooF2) {
56 M2 = new Module("test2", Context2);
58 "define i32 @add2(i32 %ArgX2) { "
60 " %addresult = add i32 2, %ArgX2 "
61 " ret i32 %addresult "
64 "define i32 @foo2() { "
66 " %add2 = call i32 @add2(i32 10) "
69 FooF2 = M2->getFunction("foo2");
72 TEST(MultiJitTest, EagerMode) {
75 Function *FooF1 = nullptr;
76 createModule1(Context1, M1, FooF1);
80 Function *FooF2 = nullptr;
81 createModule2(Context2, M2, FooF2);
83 // Now we create the JIT in eager mode
84 std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(M1).create());
85 EE1->DisableLazyCompilation(true);
86 std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(M2).create());
87 EE2->DisableLazyCompilation(true);
89 // Call the `foo' function with no arguments:
90 std::vector<GenericValue> noargs;
91 GenericValue gv1 = EE1->runFunction(FooF1, noargs);
92 GenericValue gv2 = EE2->runFunction(FooF2, noargs);
94 // Import result of execution:
95 EXPECT_EQ(gv1.IntVal, 11);
96 EXPECT_EQ(gv2.IntVal, 12);
98 EE1->freeMachineCodeForFunction(FooF1);
99 EE2->freeMachineCodeForFunction(FooF2);
102 TEST(MultiJitTest, LazyMode) {
103 LLVMContext Context1;
104 Module *M1 = nullptr;
105 Function *FooF1 = nullptr;
106 createModule1(Context1, M1, FooF1);
108 LLVMContext Context2;
109 Module *M2 = nullptr;
110 Function *FooF2 = nullptr;
111 createModule2(Context2, M2, FooF2);
113 // Now we create the JIT in lazy mode
114 std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(M1).create());
115 EE1->DisableLazyCompilation(false);
116 std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(M2).create());
117 EE2->DisableLazyCompilation(false);
119 // Call the `foo' function with no arguments:
120 std::vector<GenericValue> noargs;
121 GenericValue gv1 = EE1->runFunction(FooF1, noargs);
122 GenericValue gv2 = EE2->runFunction(FooF2, noargs);
124 // Import result of execution:
125 EXPECT_EQ(gv1.IntVal, 11);
126 EXPECT_EQ(gv2.IntVal, 12);
128 EE1->freeMachineCodeForFunction(FooF1);
129 EE2->freeMachineCodeForFunction(FooF2);
133 extern void *getPointerToNamedFunction(const char *Name);
136 TEST(MultiJitTest, JitPool) {
137 LLVMContext Context1;
138 Module *M1 = nullptr;
139 Function *FooF1 = nullptr;
140 createModule1(Context1, M1, FooF1);
142 LLVMContext Context2;
143 Module *M2 = nullptr;
144 Function *FooF2 = nullptr;
145 createModule2(Context2, M2, FooF2);
147 // Now we create two JITs
148 std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(M1).create());
149 std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(M2).create());
151 Function *F1 = EE1->FindFunctionNamed("foo1");
152 void *foo1 = EE1->getPointerToFunction(F1);
154 Function *F2 = EE2->FindFunctionNamed("foo2");
155 void *foo2 = EE2->getPointerToFunction(F2);
158 EXPECT_EQ(getPointerToNamedFunction("foo1"), foo1);
161 EXPECT_EQ(getPointerToNamedFunction("foo2"), foo2);
165 sa = (intptr_t)getPointerToNamedFunction("getPointerToNamedFunction");
166 EXPECT_TRUE(sa != 0);
167 intptr_t fa = (intptr_t)&getPointerToNamedFunction;
168 EXPECT_TRUE(fa != 0);
170 // getPointerToNamedFunction might be indirect jump on Win32 --enable-shared.
171 // FF 25 <disp32>: jmp *(pointer to IAT)
172 if (sa != fa && memcmp((char *)fa, "\xFF\x25", 2) == 0) {
173 fa = *(intptr_t *)(fa + 2); // Address to IAT
174 EXPECT_TRUE(fa != 0);
175 fa = *(intptr_t *)fa; // Bound value of IAT
177 #elif defined(__x86_64__)
178 // getPointerToNamedFunction might be indirect jump
179 // on Win32 x64 --enable-shared.
180 // FF 25 <pcrel32>: jmp *(RIP + pointer to IAT)
181 if (sa != fa && memcmp((char *)fa, "\xFF\x25", 2) == 0) {
182 fa += *(int32_t *)(fa + 2) + 6; // Address to IAT(RIP)
183 fa = *(intptr_t *)fa; // Bound value of IAT
186 EXPECT_TRUE(sa == fa);
188 #endif // !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__)
190 } // anonymous namespace