1 //===- JITTest.cpp - Unit tests for the JIT -------------------------------===//
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 "gtest/gtest.h"
11 #include "llvm/ADT/OwningPtr.h"
12 #include "llvm/ADT/SmallPtrSet.h"
13 #include "llvm/Assembly/Parser.h"
14 #include "llvm/BasicBlock.h"
15 #include "llvm/Bitcode/ReaderWriter.h"
16 #include "llvm/Constant.h"
17 #include "llvm/Constants.h"
18 #include "llvm/DerivedTypes.h"
19 #include "llvm/ExecutionEngine/JIT.h"
20 #include "llvm/ExecutionEngine/JITMemoryManager.h"
21 #include "llvm/Function.h"
22 #include "llvm/GlobalValue.h"
23 #include "llvm/GlobalVariable.h"
24 #include "llvm/LLVMContext.h"
25 #include "llvm/Module.h"
26 #include "llvm/Support/IRBuilder.h"
27 #include "llvm/Support/MemoryBuffer.h"
28 #include "llvm/Support/SourceMgr.h"
29 #include "llvm/Support/TypeBuilder.h"
30 #include "llvm/Support/TargetSelect.h"
31 #include "llvm/Type.h"
39 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
40 std::vector<Type*> params;
41 FunctionType *FTy = FunctionType::get(G->getType()->getElementType(),
43 Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
44 BasicBlock *Entry = BasicBlock::Create(M->getContext(), "entry", F);
45 IRBuilder<> builder(Entry);
46 Value *Load = builder.CreateLoad(G);
47 Type *GTy = G->getType()->getElementType();
48 Value *Add = builder.CreateAdd(Load, ConstantInt::get(GTy, 1LL));
49 builder.CreateStore(Add, G);
50 builder.CreateRet(Add);
54 std::string DumpFunction(const Function *F) {
56 raw_string_ostream(Result) << "" << *F;
60 class RecordingJITMemoryManager : public JITMemoryManager {
61 const OwningPtr<JITMemoryManager> Base;
63 RecordingJITMemoryManager()
64 : Base(JITMemoryManager::CreateDefaultMemManager()) {
68 virtual void setMemoryWritable() { Base->setMemoryWritable(); }
69 virtual void setMemoryExecutable() { Base->setMemoryExecutable(); }
70 virtual void setPoisonMemory(bool poison) { Base->setPoisonMemory(poison); }
71 virtual void AllocateGOT() { Base->AllocateGOT(); }
72 virtual uint8_t *getGOTBase() const { return Base->getGOTBase(); }
73 struct StartFunctionBodyCall {
74 StartFunctionBodyCall(uint8_t *Result, const Function *F,
75 uintptr_t ActualSize, uintptr_t ActualSizeResult)
76 : Result(Result), F(F), F_dump(DumpFunction(F)),
77 ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {}
82 uintptr_t ActualSizeResult;
84 std::vector<StartFunctionBodyCall> startFunctionBodyCalls;
85 virtual uint8_t *startFunctionBody(const Function *F,
86 uintptr_t &ActualSize) {
87 uintptr_t InitialActualSize = ActualSize;
88 uint8_t *Result = Base->startFunctionBody(F, ActualSize);
89 startFunctionBodyCalls.push_back(
90 StartFunctionBodyCall(Result, F, InitialActualSize, ActualSize));
94 virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
97 return Base->allocateStub(F, StubSize, Alignment);
99 struct EndFunctionBodyCall {
100 EndFunctionBodyCall(const Function *F, uint8_t *FunctionStart,
101 uint8_t *FunctionEnd)
102 : F(F), F_dump(DumpFunction(F)),
103 FunctionStart(FunctionStart), FunctionEnd(FunctionEnd) {}
106 uint8_t *FunctionStart;
107 uint8_t *FunctionEnd;
109 std::vector<EndFunctionBodyCall> endFunctionBodyCalls;
110 virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
111 uint8_t *FunctionEnd) {
112 endFunctionBodyCalls.push_back(
113 EndFunctionBodyCall(F, FunctionStart, FunctionEnd));
114 Base->endFunctionBody(F, FunctionStart, FunctionEnd);
116 virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
117 unsigned SectionID) {
118 return Base->allocateDataSection(Size, Alignment, SectionID);
120 virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
121 unsigned SectionID) {
122 return Base->allocateCodeSection(Size, Alignment, SectionID);
124 virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) {
125 return Base->allocateSpace(Size, Alignment);
127 virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) {
128 return Base->allocateGlobal(Size, Alignment);
130 struct DeallocateFunctionBodyCall {
131 DeallocateFunctionBodyCall(const void *Body) : Body(Body) {}
134 std::vector<DeallocateFunctionBodyCall> deallocateFunctionBodyCalls;
135 virtual void deallocateFunctionBody(void *Body) {
136 deallocateFunctionBodyCalls.push_back(DeallocateFunctionBodyCall(Body));
137 Base->deallocateFunctionBody(Body);
139 struct DeallocateExceptionTableCall {
140 DeallocateExceptionTableCall(const void *ET) : ET(ET) {}
143 std::vector<DeallocateExceptionTableCall> deallocateExceptionTableCalls;
144 virtual void deallocateExceptionTable(void *ET) {
145 deallocateExceptionTableCalls.push_back(DeallocateExceptionTableCall(ET));
146 Base->deallocateExceptionTable(ET);
148 struct StartExceptionTableCall {
149 StartExceptionTableCall(uint8_t *Result, const Function *F,
150 uintptr_t ActualSize, uintptr_t ActualSizeResult)
151 : Result(Result), F(F), F_dump(DumpFunction(F)),
152 ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {}
156 uintptr_t ActualSize;
157 uintptr_t ActualSizeResult;
159 std::vector<StartExceptionTableCall> startExceptionTableCalls;
160 virtual uint8_t* startExceptionTable(const Function* F,
161 uintptr_t &ActualSize) {
162 uintptr_t InitialActualSize = ActualSize;
163 uint8_t *Result = Base->startExceptionTable(F, ActualSize);
164 startExceptionTableCalls.push_back(
165 StartExceptionTableCall(Result, F, InitialActualSize, ActualSize));
168 struct EndExceptionTableCall {
169 EndExceptionTableCall(const Function *F, uint8_t *TableStart,
170 uint8_t *TableEnd, uint8_t* FrameRegister)
171 : F(F), F_dump(DumpFunction(F)),
172 TableStart(TableStart), TableEnd(TableEnd),
173 FrameRegister(FrameRegister) {}
178 uint8_t *FrameRegister;
180 std::vector<EndExceptionTableCall> endExceptionTableCalls;
181 virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
182 uint8_t *TableEnd, uint8_t* FrameRegister) {
183 endExceptionTableCalls.push_back(
184 EndExceptionTableCall(F, TableStart, TableEnd, FrameRegister));
185 return Base->endExceptionTable(F, TableStart, TableEnd, FrameRegister);
189 bool LoadAssemblyInto(Module *M, const char *assembly) {
192 NULL != ParseAssemblyString(assembly, M, Error, M->getContext());
194 raw_string_ostream os(errMsg);
196 EXPECT_TRUE(success) << os.str();
200 class JITTest : public testing::Test {
202 virtual void SetUp() {
203 M = new Module("<main>", Context);
204 RJMM = new RecordingJITMemoryManager;
205 RJMM->setPoisonMemory(true);
207 TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT)
208 .setJITMemoryManager(RJMM)
209 .setErrorStr(&Error).create());
210 ASSERT_TRUE(TheJIT.get() != NULL) << Error;
213 void LoadAssembly(const char *assembly) {
214 LoadAssemblyInto(M, assembly);
218 Module *M; // Owned by ExecutionEngine.
219 RecordingJITMemoryManager *RJMM;
220 OwningPtr<ExecutionEngine> TheJIT;
223 // Regression test for a bug. The JIT used to allocate globals inside the same
224 // memory block used for the function, and when the function code was freed,
225 // the global was left in the same place. This test allocates a function
226 // that uses and global, deallocates it, and then makes sure that the global
227 // stays alive after that.
228 TEST(JIT, GlobalInFunction) {
230 Module *M = new Module("<main>", context);
232 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
233 // Tell the memory manager to poison freed memory so that accessing freed
234 // memory is more easily tested.
235 MemMgr->setPoisonMemory(true);
237 OwningPtr<ExecutionEngine> JIT(EngineBuilder(M)
238 .setEngineKind(EngineKind::JIT)
240 .setJITMemoryManager(MemMgr)
241 // The next line enables the fix:
242 .setAllocateGVsWithCode(false)
244 ASSERT_EQ(Error, "");
246 // Create a global variable.
247 Type *GTy = Type::getInt32Ty(context);
248 GlobalVariable *G = new GlobalVariable(
251 false, // Not constant.
252 GlobalValue::InternalLinkage,
253 Constant::getNullValue(GTy),
256 // Make a function that points to a global.
257 Function *F1 = makeReturnGlobal("F1", G, M);
259 // Get the pointer to the native code to force it to JIT the function and
260 // allocate space for the global.
262 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1));
264 // Since F1 was codegen'd, a pointer to G should be available.
265 int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
266 ASSERT_NE((int32_t*)NULL, GPtr);
269 // F1() should increment G.
273 // Make a second function identical to the first, referring to the same
275 Function *F2 = makeReturnGlobal("F2", G, M);
277 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F2));
279 // F2() should increment G.
284 JIT->freeMachineCodeForFunction(F1);
286 // F2() should *still* increment G.
291 int PlusOne(int arg) {
295 // ARM tests disabled pending fix for PR10783.
296 #if !defined(__arm__)
297 TEST_F(JITTest, FarCallToKnownFunction) {
298 // x86-64 can only make direct calls to functions within 32 bits of
299 // the current PC. To call anything farther away, we have to load
300 // the address into a register and call through the register. The
301 // current JIT does this by allocating a stub for any far call.
302 // There was a bug in which the JIT tried to emit a direct call when
303 // the target was already in the JIT's global mappings and lazy
304 // compilation was disabled.
306 Function *KnownFunction = Function::Create(
307 TypeBuilder<int(int), false>::get(Context),
308 GlobalValue::ExternalLinkage, "known", M);
309 TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne);
311 // int test() { return known(7); }
312 Function *TestFunction = Function::Create(
313 TypeBuilder<int(), false>::get(Context),
314 GlobalValue::ExternalLinkage, "test", M);
315 BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction);
316 IRBuilder<> Builder(Entry);
317 Value *result = Builder.CreateCall(
319 ConstantInt::get(TypeBuilder<int, false>::get(Context), 7));
320 Builder.CreateRet(result);
322 TheJIT->DisableLazyCompilation(true);
323 int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
324 (intptr_t)TheJIT->getPointerToFunction(TestFunction));
325 // This used to crash in trying to call PlusOne().
326 EXPECT_EQ(8, TestFunctionPtr());
329 // Test a function C which calls A and B which call each other.
330 TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) {
331 TheJIT->DisableLazyCompilation(true);
333 FunctionType *Func1Ty =
334 cast<FunctionType>(TypeBuilder<void(void), false>::get(Context));
335 std::vector<Type*> arg_types;
336 arg_types.push_back(Type::getInt1Ty(Context));
337 FunctionType *FuncTy = FunctionType::get(
338 Type::getVoidTy(Context), arg_types, false);
339 Function *Func1 = Function::Create(Func1Ty, Function::ExternalLinkage,
341 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
343 Function *Func3 = Function::Create(FuncTy, Function::InternalLinkage,
345 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
346 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
347 BasicBlock *True2 = BasicBlock::Create(Context, "cond_true", Func2);
348 BasicBlock *False2 = BasicBlock::Create(Context, "cond_false", Func2);
349 BasicBlock *Block3 = BasicBlock::Create(Context, "block3", Func3);
350 BasicBlock *True3 = BasicBlock::Create(Context, "cond_true", Func3);
351 BasicBlock *False3 = BasicBlock::Create(Context, "cond_false", Func3);
353 // Make Func1 call Func2(0) and Func3(0).
354 IRBuilder<> Builder(Block1);
355 Builder.CreateCall(Func2, ConstantInt::getTrue(Context));
356 Builder.CreateCall(Func3, ConstantInt::getTrue(Context));
357 Builder.CreateRetVoid();
359 // void Func2(bool b) { if (b) { Func3(false); return; } return; }
360 Builder.SetInsertPoint(Block2);
361 Builder.CreateCondBr(Func2->arg_begin(), True2, False2);
362 Builder.SetInsertPoint(True2);
363 Builder.CreateCall(Func3, ConstantInt::getFalse(Context));
364 Builder.CreateRetVoid();
365 Builder.SetInsertPoint(False2);
366 Builder.CreateRetVoid();
368 // void Func3(bool b) { if (b) { Func2(false); return; } return; }
369 Builder.SetInsertPoint(Block3);
370 Builder.CreateCondBr(Func3->arg_begin(), True3, False3);
371 Builder.SetInsertPoint(True3);
372 Builder.CreateCall(Func2, ConstantInt::getFalse(Context));
373 Builder.CreateRetVoid();
374 Builder.SetInsertPoint(False3);
375 Builder.CreateRetVoid();
377 // Compile the function to native code
379 reinterpret_cast<void(*)()>((intptr_t)TheJIT->getPointerToFunction(Func1));
384 // Regression test for PR5162. This used to trigger an AssertingVH inside the
385 // JIT's Function to stub mapping.
386 TEST_F(JITTest, NonLazyLeaksNoStubs) {
387 TheJIT->DisableLazyCompilation(true);
389 // Create two functions with a single basic block each.
390 FunctionType *FuncTy =
391 cast<FunctionType>(TypeBuilder<int(), false>::get(Context));
392 Function *Func1 = Function::Create(FuncTy, Function::ExternalLinkage,
394 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
396 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
397 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
399 // The first function calls the second and returns the result
400 IRBuilder<> Builder(Block1);
401 Value *Result = Builder.CreateCall(Func2);
402 Builder.CreateRet(Result);
404 // The second function just returns a constant
405 Builder.SetInsertPoint(Block2);
406 Builder.CreateRet(ConstantInt::get(TypeBuilder<int, false>::get(Context),42));
408 // Compile the function to native code
409 (void)TheJIT->getPointerToFunction(Func1);
411 // Free the JIT state for the functions
412 TheJIT->freeMachineCodeForFunction(Func1);
413 TheJIT->freeMachineCodeForFunction(Func2);
415 // Delete the first function (and show that is has no users)
416 EXPECT_EQ(Func1->getNumUses(), 0u);
417 Func1->eraseFromParent();
419 // Delete the second function (and show that it has no users - it had one,
420 // func1 but that's gone now)
421 EXPECT_EQ(Func2->getNumUses(), 0u);
422 Func2->eraseFromParent();
425 TEST_F(JITTest, ModuleDeletion) {
426 TheJIT->DisableLazyCompilation(false);
427 LoadAssembly("define void @main() { "
428 " call i32 @computeVal() "
432 "define internal i32 @computeVal() { "
435 Function *func = M->getFunction("main");
436 TheJIT->getPointerToFunction(func);
437 TheJIT->removeModule(M);
440 SmallPtrSet<const void*, 2> FunctionsDeallocated;
441 for (unsigned i = 0, e = RJMM->deallocateFunctionBodyCalls.size();
443 FunctionsDeallocated.insert(RJMM->deallocateFunctionBodyCalls[i].Body);
445 for (unsigned i = 0, e = RJMM->startFunctionBodyCalls.size(); i != e; ++i) {
446 EXPECT_TRUE(FunctionsDeallocated.count(
447 RJMM->startFunctionBodyCalls[i].Result))
448 << "Function leaked: \n" << RJMM->startFunctionBodyCalls[i].F_dump;
450 EXPECT_EQ(RJMM->startFunctionBodyCalls.size(),
451 RJMM->deallocateFunctionBodyCalls.size());
453 SmallPtrSet<const void*, 2> ExceptionTablesDeallocated;
454 unsigned NumTablesDeallocated = 0;
455 for (unsigned i = 0, e = RJMM->deallocateExceptionTableCalls.size();
457 ExceptionTablesDeallocated.insert(
458 RJMM->deallocateExceptionTableCalls[i].ET);
459 if (RJMM->deallocateExceptionTableCalls[i].ET != NULL) {
460 // If JITEmitDebugInfo is off, we'll "deallocate" NULL, which doesn't
461 // appear in startExceptionTableCalls.
462 NumTablesDeallocated++;
465 for (unsigned i = 0, e = RJMM->startExceptionTableCalls.size(); i != e; ++i) {
466 EXPECT_TRUE(ExceptionTablesDeallocated.count(
467 RJMM->startExceptionTableCalls[i].Result))
468 << "Function's exception table leaked: \n"
469 << RJMM->startExceptionTableCalls[i].F_dump;
471 EXPECT_EQ(RJMM->startExceptionTableCalls.size(),
472 NumTablesDeallocated);
474 #endif // !defined(__arm__)
476 // ARM and PPC still emit stubs for calls since the target may be too far away
477 // to call directly. This #if can probably be removed when
478 // http://llvm.org/PR5201 is fixed.
479 #if !defined(__arm__) && !defined(__powerpc__) && !defined(__ppc__)
480 typedef int (*FooPtr) ();
482 TEST_F(JITTest, NoStubs) {
483 LoadAssembly("define void @bar() {"
488 "define i32 @foo() {"
494 "define i32 @main() {"
496 "%0 = call i32 @foo()"
500 Function *foo = M->getFunction("foo");
501 uintptr_t tmp = (uintptr_t)(TheJIT->getPointerToFunction(foo));
502 FooPtr ptr = (FooPtr)(tmp);
506 // We should now allocate no more stubs, we have the code to foo
507 // and the existing stub for bar.
508 int stubsBefore = RJMM->stubsAllocated;
509 Function *func = M->getFunction("main");
510 TheJIT->getPointerToFunction(func);
512 Function *bar = M->getFunction("bar");
513 TheJIT->getPointerToFunction(bar);
515 ASSERT_EQ(stubsBefore, RJMM->stubsAllocated);
517 #endif // !ARM && !PPC
519 TEST_F(JITTest, FunctionPointersOutliveTheirCreator) {
520 TheJIT->DisableLazyCompilation(true);
521 LoadAssembly("define i8()* @get_foo_addr() { "
525 "define i8 @foo() { "
528 Function *F_get_foo_addr = M->getFunction("get_foo_addr");
530 typedef char(*fooT)();
531 fooT (*get_foo_addr)() = reinterpret_cast<fooT(*)()>(
532 (intptr_t)TheJIT->getPointerToFunction(F_get_foo_addr));
533 fooT foo_addr = get_foo_addr();
535 // Now free get_foo_addr. This should not free the machine code for foo or
536 // any call stub returned as foo's canonical address.
537 TheJIT->freeMachineCodeForFunction(F_get_foo_addr);
539 // Check by calling the reported address of foo.
540 EXPECT_EQ(42, foo_addr());
542 // The reported address should also be the same as the result of a subsequent
543 // getPointerToFunction(foo).
545 // Fails until PR5126 is fixed:
546 Function *F_foo = M->getFunction("foo");
547 fooT foo = reinterpret_cast<fooT>(
548 (intptr_t)TheJIT->getPointerToFunction(F_foo));
549 EXPECT_EQ((intptr_t)foo, (intptr_t)foo_addr);
553 // ARM doesn't have an implementation of replaceMachineCodeForFunction(), so
554 // recompileAndRelinkFunction doesn't work.
555 #if !defined(__arm__)
556 TEST_F(JITTest, FunctionIsRecompiledAndRelinked) {
557 Function *F = Function::Create(TypeBuilder<int(void), false>::get(Context),
558 GlobalValue::ExternalLinkage, "test", M);
559 BasicBlock *Entry = BasicBlock::Create(Context, "entry", F);
560 IRBuilder<> Builder(Entry);
561 Value *Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 1);
562 Builder.CreateRet(Val);
564 TheJIT->DisableLazyCompilation(true);
565 // Compile the function once, and make sure it works.
566 int (*OrigFPtr)() = reinterpret_cast<int(*)()>(
567 (intptr_t)TheJIT->recompileAndRelinkFunction(F));
568 EXPECT_EQ(1, OrigFPtr());
570 // Now change the function to return a different value.
571 Entry->eraseFromParent();
572 BasicBlock *NewEntry = BasicBlock::Create(Context, "new_entry", F);
573 Builder.SetInsertPoint(NewEntry);
574 Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 2);
575 Builder.CreateRet(Val);
576 // Recompile it, which should produce a new function pointer _and_ update the
578 int (*NewFPtr)() = reinterpret_cast<int(*)()>(
579 (intptr_t)TheJIT->recompileAndRelinkFunction(F));
581 EXPECT_EQ(2, NewFPtr())
582 << "The new pointer should call the new version of the function";
583 EXPECT_EQ(2, OrigFPtr())
584 << "The old pointer's target should now jump to the new version";
586 #endif // !defined(__arm__)
588 } // anonymous namespace
589 // This variable is intentionally defined differently in the statically-compiled
590 // program from the IR input to the JIT to assert that the JIT doesn't use its
592 extern "C" int32_t JITTest_AvailableExternallyGlobal;
593 int32_t JITTest_AvailableExternallyGlobal = 42;
596 TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) {
597 TheJIT->DisableLazyCompilation(true);
598 LoadAssembly("@JITTest_AvailableExternallyGlobal = "
599 " available_externally global i32 7 "
601 "define i32 @loader() { "
602 " %result = load i32* @JITTest_AvailableExternallyGlobal "
605 Function *loaderIR = M->getFunction("loader");
607 int32_t (*loader)() = reinterpret_cast<int32_t(*)()>(
608 (intptr_t)TheJIT->getPointerToFunction(loaderIR));
609 EXPECT_EQ(42, loader()) << "func should return 42 from the external global,"
610 << " not 7 from the IR version.";
613 } // anonymous namespace
614 // This function is intentionally defined differently in the statically-compiled
615 // program from the IR input to the JIT to assert that the JIT doesn't use its
617 extern "C" int32_t JITTest_AvailableExternallyFunction() {
622 // ARM tests disabled pending fix for PR10783.
623 #if !defined(__arm__)
624 TEST_F(JITTest, AvailableExternallyFunctionIsntCompiled) {
625 TheJIT->DisableLazyCompilation(true);
626 LoadAssembly("define available_externally i32 "
627 " @JITTest_AvailableExternallyFunction() { "
631 "define i32 @func() { "
632 " %result = tail call i32 "
633 " @JITTest_AvailableExternallyFunction() "
636 Function *funcIR = M->getFunction("func");
638 int32_t (*func)() = reinterpret_cast<int32_t(*)()>(
639 (intptr_t)TheJIT->getPointerToFunction(funcIR));
640 EXPECT_EQ(42, func()) << "func should return 42 from the static version,"
641 << " not 7 from the IR version.";
644 TEST_F(JITTest, EscapedLazyStubStillCallable) {
645 TheJIT->DisableLazyCompilation(false);
646 LoadAssembly("define internal i32 @stubbed() { "
650 "define i32()* @get_stub() { "
651 " ret i32()* @stubbed "
653 typedef int32_t(*StubTy)();
655 // Call get_stub() to get the address of @stubbed without actually JITting it.
656 Function *get_stubIR = M->getFunction("get_stub");
657 StubTy (*get_stub)() = reinterpret_cast<StubTy(*)()>(
658 (intptr_t)TheJIT->getPointerToFunction(get_stubIR));
659 StubTy stubbed = get_stub();
660 // Now get_stubIR is the only reference to stubbed's stub.
661 get_stubIR->eraseFromParent();
662 // Now there are no references inside the JIT, but we've got a pointer outside
663 // it. The stub should be callable and return the right value.
664 EXPECT_EQ(42, stubbed());
667 // Converts the LLVM assembly to bitcode and returns it in a std::string. An
668 // empty string indicates an error.
669 std::string AssembleToBitcode(LLVMContext &Context, const char *Assembly) {
670 Module TempModule("TempModule", Context);
671 if (!LoadAssemblyInto(&TempModule, Assembly)) {
676 raw_string_ostream OS(Result);
677 WriteBitcodeToFile(&TempModule, OS);
682 // Returns a newly-created ExecutionEngine that reads the bitcode in 'Bitcode'
683 // lazily. The associated Module (owned by the ExecutionEngine) is returned in
684 // M. Both will be NULL on an error. Bitcode must live at least as long as the
686 ExecutionEngine *getJITFromBitcode(
687 LLVMContext &Context, const std::string &Bitcode, Module *&M) {
688 // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires.
689 MemoryBuffer *BitcodeBuffer =
690 MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test");
692 M = getLazyBitcodeModule(BitcodeBuffer, Context, &errMsg);
694 ADD_FAILURE() << errMsg;
695 delete BitcodeBuffer;
698 ExecutionEngine *TheJIT = EngineBuilder(M)
699 .setEngineKind(EngineKind::JIT)
700 .setErrorStr(&errMsg)
702 if (TheJIT == NULL) {
703 ADD_FAILURE() << errMsg;
711 TEST(LazyLoadedJITTest, MaterializableAvailableExternallyFunctionIsntCompiled) {
713 const std::string Bitcode =
714 AssembleToBitcode(Context,
715 "define available_externally i32 "
716 " @JITTest_AvailableExternallyFunction() { "
720 "define i32 @func() { "
721 " %result = tail call i32 "
722 " @JITTest_AvailableExternallyFunction() "
725 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
727 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
728 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
729 TheJIT->DisableLazyCompilation(true);
731 Function *funcIR = M->getFunction("func");
732 Function *availableFunctionIR =
733 M->getFunction("JITTest_AvailableExternallyFunction");
735 // Double-check that the available_externally function is still unmaterialized
736 // when getPointerToFunction needs to find out if it's available_externally.
737 EXPECT_TRUE(availableFunctionIR->isMaterializable());
739 int32_t (*func)() = reinterpret_cast<int32_t(*)()>(
740 (intptr_t)TheJIT->getPointerToFunction(funcIR));
741 EXPECT_EQ(42, func()) << "func should return 42 from the static version,"
742 << " not 7 from the IR version.";
745 TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) {
747 const std::string Bitcode =
748 AssembleToBitcode(Context,
749 "define i32 @recur1(i32 %a) { "
750 " %zero = icmp eq i32 %a, 0 "
751 " br i1 %zero, label %done, label %notdone "
755 " %am1 = sub i32 %a, 1 "
756 " %result = call i32 @recur2(i32 %am1) "
760 "define i32 @recur2(i32 %b) { "
761 " %result = call i32 @recur1(i32 %b) "
764 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
766 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
767 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
768 TheJIT->DisableLazyCompilation(true);
770 Function *recur1IR = M->getFunction("recur1");
771 Function *recur2IR = M->getFunction("recur2");
772 EXPECT_TRUE(recur1IR->isMaterializable());
773 EXPECT_TRUE(recur2IR->isMaterializable());
775 int32_t (*recur1)(int32_t) = reinterpret_cast<int32_t(*)(int32_t)>(
776 (intptr_t)TheJIT->getPointerToFunction(recur1IR));
777 EXPECT_EQ(3, recur1(4));
779 #endif // !defined(__arm__)
781 // This code is copied from JITEventListenerTest, but it only runs once for all
782 // the tests in this directory. Everything seems fine, but that's strange
784 class JITEnvironment : public testing::Environment {
785 virtual void SetUp() {
786 // Required to create a JIT.
787 InitializeNativeTarget();
790 testing::Environment* const jit_env =
791 testing::AddGlobalTestEnvironment(new JITEnvironment);