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 *allocateSpace(intptr_t Size, unsigned Alignment) {
117 return Base->allocateSpace(Size, Alignment);
119 virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) {
120 return Base->allocateGlobal(Size, Alignment);
122 struct DeallocateFunctionBodyCall {
123 DeallocateFunctionBodyCall(const void *Body) : Body(Body) {}
126 std::vector<DeallocateFunctionBodyCall> deallocateFunctionBodyCalls;
127 virtual void deallocateFunctionBody(void *Body) {
128 deallocateFunctionBodyCalls.push_back(DeallocateFunctionBodyCall(Body));
129 Base->deallocateFunctionBody(Body);
131 struct DeallocateExceptionTableCall {
132 DeallocateExceptionTableCall(const void *ET) : ET(ET) {}
135 std::vector<DeallocateExceptionTableCall> deallocateExceptionTableCalls;
136 virtual void deallocateExceptionTable(void *ET) {
137 deallocateExceptionTableCalls.push_back(DeallocateExceptionTableCall(ET));
138 Base->deallocateExceptionTable(ET);
140 struct StartExceptionTableCall {
141 StartExceptionTableCall(uint8_t *Result, const Function *F,
142 uintptr_t ActualSize, uintptr_t ActualSizeResult)
143 : Result(Result), F(F), F_dump(DumpFunction(F)),
144 ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {}
148 uintptr_t ActualSize;
149 uintptr_t ActualSizeResult;
151 std::vector<StartExceptionTableCall> startExceptionTableCalls;
152 virtual uint8_t* startExceptionTable(const Function* F,
153 uintptr_t &ActualSize) {
154 uintptr_t InitialActualSize = ActualSize;
155 uint8_t *Result = Base->startExceptionTable(F, ActualSize);
156 startExceptionTableCalls.push_back(
157 StartExceptionTableCall(Result, F, InitialActualSize, ActualSize));
160 struct EndExceptionTableCall {
161 EndExceptionTableCall(const Function *F, uint8_t *TableStart,
162 uint8_t *TableEnd, uint8_t* FrameRegister)
163 : F(F), F_dump(DumpFunction(F)),
164 TableStart(TableStart), TableEnd(TableEnd),
165 FrameRegister(FrameRegister) {}
170 uint8_t *FrameRegister;
172 std::vector<EndExceptionTableCall> endExceptionTableCalls;
173 virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
174 uint8_t *TableEnd, uint8_t* FrameRegister) {
175 endExceptionTableCalls.push_back(
176 EndExceptionTableCall(F, TableStart, TableEnd, FrameRegister));
177 return Base->endExceptionTable(F, TableStart, TableEnd, FrameRegister);
181 bool LoadAssemblyInto(Module *M, const char *assembly) {
184 NULL != ParseAssemblyString(assembly, M, Error, M->getContext());
186 raw_string_ostream os(errMsg);
188 EXPECT_TRUE(success) << os.str();
192 class JITTest : public testing::Test {
194 virtual void SetUp() {
195 M = new Module("<main>", Context);
196 RJMM = new RecordingJITMemoryManager;
197 RJMM->setPoisonMemory(true);
199 TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT)
200 .setJITMemoryManager(RJMM)
201 .setErrorStr(&Error).create());
202 ASSERT_TRUE(TheJIT.get() != NULL) << Error;
205 void LoadAssembly(const char *assembly) {
206 LoadAssemblyInto(M, assembly);
210 Module *M; // Owned by ExecutionEngine.
211 RecordingJITMemoryManager *RJMM;
212 OwningPtr<ExecutionEngine> TheJIT;
215 // Regression test for a bug. The JIT used to allocate globals inside the same
216 // memory block used for the function, and when the function code was freed,
217 // the global was left in the same place. This test allocates a function
218 // that uses and global, deallocates it, and then makes sure that the global
219 // stays alive after that.
220 TEST(JIT, GlobalInFunction) {
222 Module *M = new Module("<main>", context);
224 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
225 // Tell the memory manager to poison freed memory so that accessing freed
226 // memory is more easily tested.
227 MemMgr->setPoisonMemory(true);
229 OwningPtr<ExecutionEngine> JIT(EngineBuilder(M)
230 .setEngineKind(EngineKind::JIT)
232 .setJITMemoryManager(MemMgr)
233 // The next line enables the fix:
234 .setAllocateGVsWithCode(false)
236 ASSERT_EQ(Error, "");
238 // Create a global variable.
239 Type *GTy = Type::getInt32Ty(context);
240 GlobalVariable *G = new GlobalVariable(
243 false, // Not constant.
244 GlobalValue::InternalLinkage,
245 Constant::getNullValue(GTy),
248 // Make a function that points to a global.
249 Function *F1 = makeReturnGlobal("F1", G, M);
251 // Get the pointer to the native code to force it to JIT the function and
252 // allocate space for the global.
254 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1));
256 // Since F1 was codegen'd, a pointer to G should be available.
257 int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
258 ASSERT_NE((int32_t*)NULL, GPtr);
261 // F1() should increment G.
265 // Make a second function identical to the first, referring to the same
267 Function *F2 = makeReturnGlobal("F2", G, M);
269 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F2));
271 // F2() should increment G.
276 JIT->freeMachineCodeForFunction(F1);
278 // F2() should *still* increment G.
283 int PlusOne(int arg) {
287 // ARM tests disabled pending fix for PR10783.
288 #if !defined(__arm__)
289 TEST_F(JITTest, FarCallToKnownFunction) {
290 // x86-64 can only make direct calls to functions within 32 bits of
291 // the current PC. To call anything farther away, we have to load
292 // the address into a register and call through the register. The
293 // current JIT does this by allocating a stub for any far call.
294 // There was a bug in which the JIT tried to emit a direct call when
295 // the target was already in the JIT's global mappings and lazy
296 // compilation was disabled.
298 Function *KnownFunction = Function::Create(
299 TypeBuilder<int(int), false>::get(Context),
300 GlobalValue::ExternalLinkage, "known", M);
301 TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne);
303 // int test() { return known(7); }
304 Function *TestFunction = Function::Create(
305 TypeBuilder<int(), false>::get(Context),
306 GlobalValue::ExternalLinkage, "test", M);
307 BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction);
308 IRBuilder<> Builder(Entry);
309 Value *result = Builder.CreateCall(
311 ConstantInt::get(TypeBuilder<int, false>::get(Context), 7));
312 Builder.CreateRet(result);
314 TheJIT->DisableLazyCompilation(true);
315 int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
316 (intptr_t)TheJIT->getPointerToFunction(TestFunction));
317 // This used to crash in trying to call PlusOne().
318 EXPECT_EQ(8, TestFunctionPtr());
321 // Test a function C which calls A and B which call each other.
322 TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) {
323 TheJIT->DisableLazyCompilation(true);
325 FunctionType *Func1Ty =
326 cast<FunctionType>(TypeBuilder<void(void), false>::get(Context));
327 std::vector<Type*> arg_types;
328 arg_types.push_back(Type::getInt1Ty(Context));
329 FunctionType *FuncTy = FunctionType::get(
330 Type::getVoidTy(Context), arg_types, false);
331 Function *Func1 = Function::Create(Func1Ty, Function::ExternalLinkage,
333 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
335 Function *Func3 = Function::Create(FuncTy, Function::InternalLinkage,
337 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
338 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
339 BasicBlock *True2 = BasicBlock::Create(Context, "cond_true", Func2);
340 BasicBlock *False2 = BasicBlock::Create(Context, "cond_false", Func2);
341 BasicBlock *Block3 = BasicBlock::Create(Context, "block3", Func3);
342 BasicBlock *True3 = BasicBlock::Create(Context, "cond_true", Func3);
343 BasicBlock *False3 = BasicBlock::Create(Context, "cond_false", Func3);
345 // Make Func1 call Func2(0) and Func3(0).
346 IRBuilder<> Builder(Block1);
347 Builder.CreateCall(Func2, ConstantInt::getTrue(Context));
348 Builder.CreateCall(Func3, ConstantInt::getTrue(Context));
349 Builder.CreateRetVoid();
351 // void Func2(bool b) { if (b) { Func3(false); return; } return; }
352 Builder.SetInsertPoint(Block2);
353 Builder.CreateCondBr(Func2->arg_begin(), True2, False2);
354 Builder.SetInsertPoint(True2);
355 Builder.CreateCall(Func3, ConstantInt::getFalse(Context));
356 Builder.CreateRetVoid();
357 Builder.SetInsertPoint(False2);
358 Builder.CreateRetVoid();
360 // void Func3(bool b) { if (b) { Func2(false); return; } return; }
361 Builder.SetInsertPoint(Block3);
362 Builder.CreateCondBr(Func3->arg_begin(), True3, False3);
363 Builder.SetInsertPoint(True3);
364 Builder.CreateCall(Func2, ConstantInt::getFalse(Context));
365 Builder.CreateRetVoid();
366 Builder.SetInsertPoint(False3);
367 Builder.CreateRetVoid();
369 // Compile the function to native code
371 reinterpret_cast<void(*)()>((intptr_t)TheJIT->getPointerToFunction(Func1));
376 // Regression test for PR5162. This used to trigger an AssertingVH inside the
377 // JIT's Function to stub mapping.
378 TEST_F(JITTest, NonLazyLeaksNoStubs) {
379 TheJIT->DisableLazyCompilation(true);
381 // Create two functions with a single basic block each.
382 FunctionType *FuncTy =
383 cast<FunctionType>(TypeBuilder<int(), false>::get(Context));
384 Function *Func1 = Function::Create(FuncTy, Function::ExternalLinkage,
386 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
388 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
389 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
391 // The first function calls the second and returns the result
392 IRBuilder<> Builder(Block1);
393 Value *Result = Builder.CreateCall(Func2);
394 Builder.CreateRet(Result);
396 // The second function just returns a constant
397 Builder.SetInsertPoint(Block2);
398 Builder.CreateRet(ConstantInt::get(TypeBuilder<int, false>::get(Context),42));
400 // Compile the function to native code
401 (void)TheJIT->getPointerToFunction(Func1);
403 // Free the JIT state for the functions
404 TheJIT->freeMachineCodeForFunction(Func1);
405 TheJIT->freeMachineCodeForFunction(Func2);
407 // Delete the first function (and show that is has no users)
408 EXPECT_EQ(Func1->getNumUses(), 0u);
409 Func1->eraseFromParent();
411 // Delete the second function (and show that it has no users - it had one,
412 // func1 but that's gone now)
413 EXPECT_EQ(Func2->getNumUses(), 0u);
414 Func2->eraseFromParent();
417 TEST_F(JITTest, ModuleDeletion) {
418 TheJIT->DisableLazyCompilation(false);
419 LoadAssembly("define void @main() { "
420 " call i32 @computeVal() "
424 "define internal i32 @computeVal() { "
427 Function *func = M->getFunction("main");
428 TheJIT->getPointerToFunction(func);
429 TheJIT->removeModule(M);
432 SmallPtrSet<const void*, 2> FunctionsDeallocated;
433 for (unsigned i = 0, e = RJMM->deallocateFunctionBodyCalls.size();
435 FunctionsDeallocated.insert(RJMM->deallocateFunctionBodyCalls[i].Body);
437 for (unsigned i = 0, e = RJMM->startFunctionBodyCalls.size(); i != e; ++i) {
438 EXPECT_TRUE(FunctionsDeallocated.count(
439 RJMM->startFunctionBodyCalls[i].Result))
440 << "Function leaked: \n" << RJMM->startFunctionBodyCalls[i].F_dump;
442 EXPECT_EQ(RJMM->startFunctionBodyCalls.size(),
443 RJMM->deallocateFunctionBodyCalls.size());
445 SmallPtrSet<const void*, 2> ExceptionTablesDeallocated;
446 unsigned NumTablesDeallocated = 0;
447 for (unsigned i = 0, e = RJMM->deallocateExceptionTableCalls.size();
449 ExceptionTablesDeallocated.insert(
450 RJMM->deallocateExceptionTableCalls[i].ET);
451 if (RJMM->deallocateExceptionTableCalls[i].ET != NULL) {
452 // If JITEmitDebugInfo is off, we'll "deallocate" NULL, which doesn't
453 // appear in startExceptionTableCalls.
454 NumTablesDeallocated++;
457 for (unsigned i = 0, e = RJMM->startExceptionTableCalls.size(); i != e; ++i) {
458 EXPECT_TRUE(ExceptionTablesDeallocated.count(
459 RJMM->startExceptionTableCalls[i].Result))
460 << "Function's exception table leaked: \n"
461 << RJMM->startExceptionTableCalls[i].F_dump;
463 EXPECT_EQ(RJMM->startExceptionTableCalls.size(),
464 NumTablesDeallocated);
466 #endif // !defined(__arm__)
468 // ARM and PPC still emit stubs for calls since the target may be too far away
469 // to call directly. This #if can probably be removed when
470 // http://llvm.org/PR5201 is fixed.
471 #if !defined(__arm__) && !defined(__powerpc__) && !defined(__ppc__)
472 typedef int (*FooPtr) ();
474 TEST_F(JITTest, NoStubs) {
475 LoadAssembly("define void @bar() {"
480 "define i32 @foo() {"
486 "define i32 @main() {"
488 "%0 = call i32 @foo()"
492 Function *foo = M->getFunction("foo");
493 uintptr_t tmp = (uintptr_t)(TheJIT->getPointerToFunction(foo));
494 FooPtr ptr = (FooPtr)(tmp);
498 // We should now allocate no more stubs, we have the code to foo
499 // and the existing stub for bar.
500 int stubsBefore = RJMM->stubsAllocated;
501 Function *func = M->getFunction("main");
502 TheJIT->getPointerToFunction(func);
504 Function *bar = M->getFunction("bar");
505 TheJIT->getPointerToFunction(bar);
507 ASSERT_EQ(stubsBefore, RJMM->stubsAllocated);
509 #endif // !ARM && !PPC
511 TEST_F(JITTest, FunctionPointersOutliveTheirCreator) {
512 TheJIT->DisableLazyCompilation(true);
513 LoadAssembly("define i8()* @get_foo_addr() { "
517 "define i8 @foo() { "
520 Function *F_get_foo_addr = M->getFunction("get_foo_addr");
522 typedef char(*fooT)();
523 fooT (*get_foo_addr)() = reinterpret_cast<fooT(*)()>(
524 (intptr_t)TheJIT->getPointerToFunction(F_get_foo_addr));
525 fooT foo_addr = get_foo_addr();
527 // Now free get_foo_addr. This should not free the machine code for foo or
528 // any call stub returned as foo's canonical address.
529 TheJIT->freeMachineCodeForFunction(F_get_foo_addr);
531 // Check by calling the reported address of foo.
532 EXPECT_EQ(42, foo_addr());
534 // The reported address should also be the same as the result of a subsequent
535 // getPointerToFunction(foo).
537 // Fails until PR5126 is fixed:
538 Function *F_foo = M->getFunction("foo");
539 fooT foo = reinterpret_cast<fooT>(
540 (intptr_t)TheJIT->getPointerToFunction(F_foo));
541 EXPECT_EQ((intptr_t)foo, (intptr_t)foo_addr);
545 // ARM doesn't have an implementation of replaceMachineCodeForFunction(), so
546 // recompileAndRelinkFunction doesn't work.
547 #if !defined(__arm__)
548 TEST_F(JITTest, FunctionIsRecompiledAndRelinked) {
549 Function *F = Function::Create(TypeBuilder<int(void), false>::get(Context),
550 GlobalValue::ExternalLinkage, "test", M);
551 BasicBlock *Entry = BasicBlock::Create(Context, "entry", F);
552 IRBuilder<> Builder(Entry);
553 Value *Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 1);
554 Builder.CreateRet(Val);
556 TheJIT->DisableLazyCompilation(true);
557 // Compile the function once, and make sure it works.
558 int (*OrigFPtr)() = reinterpret_cast<int(*)()>(
559 (intptr_t)TheJIT->recompileAndRelinkFunction(F));
560 EXPECT_EQ(1, OrigFPtr());
562 // Now change the function to return a different value.
563 Entry->eraseFromParent();
564 BasicBlock *NewEntry = BasicBlock::Create(Context, "new_entry", F);
565 Builder.SetInsertPoint(NewEntry);
566 Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 2);
567 Builder.CreateRet(Val);
568 // Recompile it, which should produce a new function pointer _and_ update the
570 int (*NewFPtr)() = reinterpret_cast<int(*)()>(
571 (intptr_t)TheJIT->recompileAndRelinkFunction(F));
573 EXPECT_EQ(2, NewFPtr())
574 << "The new pointer should call the new version of the function";
575 EXPECT_EQ(2, OrigFPtr())
576 << "The old pointer's target should now jump to the new version";
578 #endif // !defined(__arm__)
580 } // anonymous namespace
581 // This variable is intentionally defined differently in the statically-compiled
582 // program from the IR input to the JIT to assert that the JIT doesn't use its
584 extern "C" int32_t JITTest_AvailableExternallyGlobal;
585 int32_t JITTest_AvailableExternallyGlobal = 42;
588 TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) {
589 TheJIT->DisableLazyCompilation(true);
590 LoadAssembly("@JITTest_AvailableExternallyGlobal = "
591 " available_externally global i32 7 "
593 "define i32 @loader() { "
594 " %result = load i32* @JITTest_AvailableExternallyGlobal "
597 Function *loaderIR = M->getFunction("loader");
599 int32_t (*loader)() = reinterpret_cast<int32_t(*)()>(
600 (intptr_t)TheJIT->getPointerToFunction(loaderIR));
601 EXPECT_EQ(42, loader()) << "func should return 42 from the external global,"
602 << " not 7 from the IR version.";
605 } // anonymous namespace
606 // This function is intentionally defined differently in the statically-compiled
607 // program from the IR input to the JIT to assert that the JIT doesn't use its
609 extern "C" int32_t JITTest_AvailableExternallyFunction() {
614 // ARM tests disabled pending fix for PR10783.
615 #if !defined(__arm__)
616 TEST_F(JITTest, AvailableExternallyFunctionIsntCompiled) {
617 TheJIT->DisableLazyCompilation(true);
618 LoadAssembly("define available_externally i32 "
619 " @JITTest_AvailableExternallyFunction() { "
623 "define i32 @func() { "
624 " %result = tail call i32 "
625 " @JITTest_AvailableExternallyFunction() "
628 Function *funcIR = M->getFunction("func");
630 int32_t (*func)() = reinterpret_cast<int32_t(*)()>(
631 (intptr_t)TheJIT->getPointerToFunction(funcIR));
632 EXPECT_EQ(42, func()) << "func should return 42 from the static version,"
633 << " not 7 from the IR version.";
636 TEST_F(JITTest, EscapedLazyStubStillCallable) {
637 TheJIT->DisableLazyCompilation(false);
638 LoadAssembly("define internal i32 @stubbed() { "
642 "define i32()* @get_stub() { "
643 " ret i32()* @stubbed "
645 typedef int32_t(*StubTy)();
647 // Call get_stub() to get the address of @stubbed without actually JITting it.
648 Function *get_stubIR = M->getFunction("get_stub");
649 StubTy (*get_stub)() = reinterpret_cast<StubTy(*)()>(
650 (intptr_t)TheJIT->getPointerToFunction(get_stubIR));
651 StubTy stubbed = get_stub();
652 // Now get_stubIR is the only reference to stubbed's stub.
653 get_stubIR->eraseFromParent();
654 // Now there are no references inside the JIT, but we've got a pointer outside
655 // it. The stub should be callable and return the right value.
656 EXPECT_EQ(42, stubbed());
659 // Converts the LLVM assembly to bitcode and returns it in a std::string. An
660 // empty string indicates an error.
661 std::string AssembleToBitcode(LLVMContext &Context, const char *Assembly) {
662 Module TempModule("TempModule", Context);
663 if (!LoadAssemblyInto(&TempModule, Assembly)) {
668 raw_string_ostream OS(Result);
669 WriteBitcodeToFile(&TempModule, OS);
674 // Returns a newly-created ExecutionEngine that reads the bitcode in 'Bitcode'
675 // lazily. The associated Module (owned by the ExecutionEngine) is returned in
676 // M. Both will be NULL on an error. Bitcode must live at least as long as the
678 ExecutionEngine *getJITFromBitcode(
679 LLVMContext &Context, const std::string &Bitcode, Module *&M) {
680 // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires.
681 MemoryBuffer *BitcodeBuffer =
682 MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test");
684 M = getLazyBitcodeModule(BitcodeBuffer, Context, &errMsg);
686 ADD_FAILURE() << errMsg;
687 delete BitcodeBuffer;
690 ExecutionEngine *TheJIT = EngineBuilder(M)
691 .setEngineKind(EngineKind::JIT)
692 .setErrorStr(&errMsg)
694 if (TheJIT == NULL) {
695 ADD_FAILURE() << errMsg;
703 TEST(LazyLoadedJITTest, MaterializableAvailableExternallyFunctionIsntCompiled) {
705 const std::string Bitcode =
706 AssembleToBitcode(Context,
707 "define available_externally i32 "
708 " @JITTest_AvailableExternallyFunction() { "
712 "define i32 @func() { "
713 " %result = tail call i32 "
714 " @JITTest_AvailableExternallyFunction() "
717 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
719 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
720 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
721 TheJIT->DisableLazyCompilation(true);
723 Function *funcIR = M->getFunction("func");
724 Function *availableFunctionIR =
725 M->getFunction("JITTest_AvailableExternallyFunction");
727 // Double-check that the available_externally function is still unmaterialized
728 // when getPointerToFunction needs to find out if it's available_externally.
729 EXPECT_TRUE(availableFunctionIR->isMaterializable());
731 int32_t (*func)() = reinterpret_cast<int32_t(*)()>(
732 (intptr_t)TheJIT->getPointerToFunction(funcIR));
733 EXPECT_EQ(42, func()) << "func should return 42 from the static version,"
734 << " not 7 from the IR version.";
737 TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) {
739 const std::string Bitcode =
740 AssembleToBitcode(Context,
741 "define i32 @recur1(i32 %a) { "
742 " %zero = icmp eq i32 %a, 0 "
743 " br i1 %zero, label %done, label %notdone "
747 " %am1 = sub i32 %a, 1 "
748 " %result = call i32 @recur2(i32 %am1) "
752 "define i32 @recur2(i32 %b) { "
753 " %result = call i32 @recur1(i32 %b) "
756 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
758 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
759 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
760 TheJIT->DisableLazyCompilation(true);
762 Function *recur1IR = M->getFunction("recur1");
763 Function *recur2IR = M->getFunction("recur2");
764 EXPECT_TRUE(recur1IR->isMaterializable());
765 EXPECT_TRUE(recur2IR->isMaterializable());
767 int32_t (*recur1)(int32_t) = reinterpret_cast<int32_t(*)(int32_t)>(
768 (intptr_t)TheJIT->getPointerToFunction(recur1IR));
769 EXPECT_EQ(3, recur1(4));
771 #endif // !defined(__arm__)
773 // This code is copied from JITEventListenerTest, but it only runs once for all
774 // the tests in this directory. Everything seems fine, but that's strange
776 class JITEnvironment : public testing::Environment {
777 virtual void SetUp() {
778 // Required to create a JIT.
779 InitializeNativeTarget();
782 testing::Environment* const jit_env =
783 testing::AddGlobalTestEnvironment(new JITEnvironment);