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 "llvm/ExecutionEngine/JIT.h"
11 #include "llvm/ADT/OwningPtr.h"
12 #include "llvm/ADT/SmallPtrSet.h"
13 #include "llvm/Assembly/Parser.h"
14 #include "llvm/Bitcode/ReaderWriter.h"
15 #include "llvm/ExecutionEngine/JITMemoryManager.h"
16 #include "llvm/IR/BasicBlock.h"
17 #include "llvm/IR/Constant.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/GlobalValue.h"
22 #include "llvm/IR/GlobalVariable.h"
23 #include "llvm/IR/IRBuilder.h"
24 #include "llvm/IR/LLVMContext.h"
25 #include "llvm/IR/Module.h"
26 #include "llvm/IR/Type.h"
27 #include "llvm/IR/TypeBuilder.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/SourceMgr.h"
30 #include "llvm/Support/TargetSelect.h"
31 #include "gtest/gtest.h"
36 // This variable is intentionally defined differently in the statically-compiled
37 // program from the IR input to the JIT to assert that the JIT doesn't use its
38 // definition. Note that this variable must be defined even on platforms where
39 // JIT tests are disabled as it is referenced from the .def file.
40 extern "C" int32_t JITTest_AvailableExternallyGlobal;
41 int32_t JITTest_AvailableExternallyGlobal LLVM_ATTRIBUTE_USED = 42;
43 // This function is intentionally defined differently in the statically-compiled
44 // program from the IR input to the JIT to assert that the JIT doesn't use its
45 // definition. Note that this function must be defined even on platforms where
46 // JIT tests are disabled as it is referenced from the .def file.
47 extern "C" int32_t JITTest_AvailableExternallyFunction() LLVM_ATTRIBUTE_USED;
48 extern "C" int32_t JITTest_AvailableExternallyFunction() {
54 // Tests on ARM, PowerPC and SystemZ disabled as we're running the old jit
55 #if !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__)
57 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
58 std::vector<Type*> params;
59 FunctionType *FTy = FunctionType::get(G->getType()->getElementType(),
61 Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
62 BasicBlock *Entry = BasicBlock::Create(M->getContext(), "entry", F);
63 IRBuilder<> builder(Entry);
64 Value *Load = builder.CreateLoad(G);
65 Type *GTy = G->getType()->getElementType();
66 Value *Add = builder.CreateAdd(Load, ConstantInt::get(GTy, 1LL));
67 builder.CreateStore(Add, G);
68 builder.CreateRet(Add);
72 std::string DumpFunction(const Function *F) {
74 raw_string_ostream(Result) << "" << *F;
78 class RecordingJITMemoryManager : public JITMemoryManager {
79 const OwningPtr<JITMemoryManager> Base;
81 RecordingJITMemoryManager()
82 : Base(JITMemoryManager::CreateDefaultMemManager()) {
85 virtual void *getPointerToNamedFunction(const std::string &Name,
86 bool AbortOnFailure = true) {
87 return Base->getPointerToNamedFunction(Name, AbortOnFailure);
90 virtual void setMemoryWritable() { Base->setMemoryWritable(); }
91 virtual void setMemoryExecutable() { Base->setMemoryExecutable(); }
92 virtual void setPoisonMemory(bool poison) { Base->setPoisonMemory(poison); }
93 virtual void AllocateGOT() { Base->AllocateGOT(); }
94 virtual uint8_t *getGOTBase() const { return Base->getGOTBase(); }
95 struct StartFunctionBodyCall {
96 StartFunctionBodyCall(uint8_t *Result, const Function *F,
97 uintptr_t ActualSize, uintptr_t ActualSizeResult)
98 : Result(Result), F(F), F_dump(DumpFunction(F)),
99 ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {}
103 uintptr_t ActualSize;
104 uintptr_t ActualSizeResult;
106 std::vector<StartFunctionBodyCall> startFunctionBodyCalls;
107 virtual uint8_t *startFunctionBody(const Function *F,
108 uintptr_t &ActualSize) {
109 uintptr_t InitialActualSize = ActualSize;
110 uint8_t *Result = Base->startFunctionBody(F, ActualSize);
111 startFunctionBodyCalls.push_back(
112 StartFunctionBodyCall(Result, F, InitialActualSize, ActualSize));
116 virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
117 unsigned Alignment) {
119 return Base->allocateStub(F, StubSize, Alignment);
121 struct EndFunctionBodyCall {
122 EndFunctionBodyCall(const Function *F, uint8_t *FunctionStart,
123 uint8_t *FunctionEnd)
124 : F(F), F_dump(DumpFunction(F)),
125 FunctionStart(FunctionStart), FunctionEnd(FunctionEnd) {}
128 uint8_t *FunctionStart;
129 uint8_t *FunctionEnd;
131 std::vector<EndFunctionBodyCall> endFunctionBodyCalls;
132 virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
133 uint8_t *FunctionEnd) {
134 endFunctionBodyCalls.push_back(
135 EndFunctionBodyCall(F, FunctionStart, FunctionEnd));
136 Base->endFunctionBody(F, FunctionStart, FunctionEnd);
138 virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
139 unsigned SectionID, bool IsReadOnly) {
140 return Base->allocateDataSection(Size, Alignment, SectionID, IsReadOnly);
142 virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
143 unsigned SectionID) {
144 return Base->allocateCodeSection(Size, Alignment, SectionID);
146 virtual bool finalizeMemory(std::string *ErrMsg) { return false; }
147 virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) {
148 return Base->allocateSpace(Size, Alignment);
150 virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) {
151 return Base->allocateGlobal(Size, Alignment);
153 struct DeallocateFunctionBodyCall {
154 DeallocateFunctionBodyCall(const void *Body) : Body(Body) {}
157 std::vector<DeallocateFunctionBodyCall> deallocateFunctionBodyCalls;
158 virtual void deallocateFunctionBody(void *Body) {
159 deallocateFunctionBodyCalls.push_back(DeallocateFunctionBodyCall(Body));
160 Base->deallocateFunctionBody(Body);
164 bool LoadAssemblyInto(Module *M, const char *assembly) {
167 NULL != ParseAssemblyString(assembly, M, Error, M->getContext());
169 raw_string_ostream os(errMsg);
171 EXPECT_TRUE(success) << os.str();
175 class JITTest : public testing::Test {
177 virtual RecordingJITMemoryManager *createMemoryManager() {
178 return new RecordingJITMemoryManager;
181 virtual void SetUp() {
182 M = new Module("<main>", Context);
183 RJMM = createMemoryManager();
184 RJMM->setPoisonMemory(true);
186 TargetOptions Options;
187 TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT)
188 .setJITMemoryManager(RJMM)
190 .setTargetOptions(Options).create());
191 ASSERT_TRUE(TheJIT.get() != NULL) << Error;
194 void LoadAssembly(const char *assembly) {
195 LoadAssemblyInto(M, assembly);
199 Module *M; // Owned by ExecutionEngine.
200 RecordingJITMemoryManager *RJMM;
201 OwningPtr<ExecutionEngine> TheJIT;
204 // Regression test for a bug. The JIT used to allocate globals inside the same
205 // memory block used for the function, and when the function code was freed,
206 // the global was left in the same place. This test allocates a function
207 // that uses and global, deallocates it, and then makes sure that the global
208 // stays alive after that.
209 TEST(JIT, GlobalInFunction) {
211 Module *M = new Module("<main>", context);
213 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager();
214 // Tell the memory manager to poison freed memory so that accessing freed
215 // memory is more easily tested.
216 MemMgr->setPoisonMemory(true);
218 OwningPtr<ExecutionEngine> JIT(EngineBuilder(M)
219 .setEngineKind(EngineKind::JIT)
221 .setJITMemoryManager(MemMgr)
222 // The next line enables the fix:
223 .setAllocateGVsWithCode(false)
225 ASSERT_EQ(Error, "");
227 // Create a global variable.
228 Type *GTy = Type::getInt32Ty(context);
229 GlobalVariable *G = new GlobalVariable(
232 false, // Not constant.
233 GlobalValue::InternalLinkage,
234 Constant::getNullValue(GTy),
237 // Make a function that points to a global.
238 Function *F1 = makeReturnGlobal("F1", G, M);
240 // Get the pointer to the native code to force it to JIT the function and
241 // allocate space for the global.
243 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1));
245 // Since F1 was codegen'd, a pointer to G should be available.
246 int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G);
247 ASSERT_NE((int32_t*)NULL, GPtr);
250 // F1() should increment G.
254 // Make a second function identical to the first, referring to the same
256 Function *F2 = makeReturnGlobal("F2", G, M);
258 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F2));
260 // F2() should increment G.
265 JIT->freeMachineCodeForFunction(F1);
267 // F2() should *still* increment G.
272 int PlusOne(int arg) {
276 TEST_F(JITTest, FarCallToKnownFunction) {
277 // x86-64 can only make direct calls to functions within 32 bits of
278 // the current PC. To call anything farther away, we have to load
279 // the address into a register and call through the register. The
280 // current JIT does this by allocating a stub for any far call.
281 // There was a bug in which the JIT tried to emit a direct call when
282 // the target was already in the JIT's global mappings and lazy
283 // compilation was disabled.
285 Function *KnownFunction = Function::Create(
286 TypeBuilder<int(int), false>::get(Context),
287 GlobalValue::ExternalLinkage, "known", M);
288 TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne);
290 // int test() { return known(7); }
291 Function *TestFunction = Function::Create(
292 TypeBuilder<int(), false>::get(Context),
293 GlobalValue::ExternalLinkage, "test", M);
294 BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction);
295 IRBuilder<> Builder(Entry);
296 Value *result = Builder.CreateCall(
298 ConstantInt::get(TypeBuilder<int, false>::get(Context), 7));
299 Builder.CreateRet(result);
301 TheJIT->DisableLazyCompilation(true);
302 int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>(
303 (intptr_t)TheJIT->getPointerToFunction(TestFunction));
304 // This used to crash in trying to call PlusOne().
305 EXPECT_EQ(8, TestFunctionPtr());
308 // Test a function C which calls A and B which call each other.
309 TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) {
310 TheJIT->DisableLazyCompilation(true);
312 FunctionType *Func1Ty =
313 cast<FunctionType>(TypeBuilder<void(void), false>::get(Context));
314 std::vector<Type*> arg_types;
315 arg_types.push_back(Type::getInt1Ty(Context));
316 FunctionType *FuncTy = FunctionType::get(
317 Type::getVoidTy(Context), arg_types, false);
318 Function *Func1 = Function::Create(Func1Ty, Function::ExternalLinkage,
320 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
322 Function *Func3 = Function::Create(FuncTy, Function::InternalLinkage,
324 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
325 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
326 BasicBlock *True2 = BasicBlock::Create(Context, "cond_true", Func2);
327 BasicBlock *False2 = BasicBlock::Create(Context, "cond_false", Func2);
328 BasicBlock *Block3 = BasicBlock::Create(Context, "block3", Func3);
329 BasicBlock *True3 = BasicBlock::Create(Context, "cond_true", Func3);
330 BasicBlock *False3 = BasicBlock::Create(Context, "cond_false", Func3);
332 // Make Func1 call Func2(0) and Func3(0).
333 IRBuilder<> Builder(Block1);
334 Builder.CreateCall(Func2, ConstantInt::getTrue(Context));
335 Builder.CreateCall(Func3, ConstantInt::getTrue(Context));
336 Builder.CreateRetVoid();
338 // void Func2(bool b) { if (b) { Func3(false); return; } return; }
339 Builder.SetInsertPoint(Block2);
340 Builder.CreateCondBr(Func2->arg_begin(), True2, False2);
341 Builder.SetInsertPoint(True2);
342 Builder.CreateCall(Func3, ConstantInt::getFalse(Context));
343 Builder.CreateRetVoid();
344 Builder.SetInsertPoint(False2);
345 Builder.CreateRetVoid();
347 // void Func3(bool b) { if (b) { Func2(false); return; } return; }
348 Builder.SetInsertPoint(Block3);
349 Builder.CreateCondBr(Func3->arg_begin(), True3, False3);
350 Builder.SetInsertPoint(True3);
351 Builder.CreateCall(Func2, ConstantInt::getFalse(Context));
352 Builder.CreateRetVoid();
353 Builder.SetInsertPoint(False3);
354 Builder.CreateRetVoid();
356 // Compile the function to native code
358 reinterpret_cast<void(*)()>((intptr_t)TheJIT->getPointerToFunction(Func1));
363 // Regression test for PR5162. This used to trigger an AssertingVH inside the
364 // JIT's Function to stub mapping.
365 TEST_F(JITTest, NonLazyLeaksNoStubs) {
366 TheJIT->DisableLazyCompilation(true);
368 // Create two functions with a single basic block each.
369 FunctionType *FuncTy =
370 cast<FunctionType>(TypeBuilder<int(), false>::get(Context));
371 Function *Func1 = Function::Create(FuncTy, Function::ExternalLinkage,
373 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage,
375 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1);
376 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2);
378 // The first function calls the second and returns the result
379 IRBuilder<> Builder(Block1);
380 Value *Result = Builder.CreateCall(Func2);
381 Builder.CreateRet(Result);
383 // The second function just returns a constant
384 Builder.SetInsertPoint(Block2);
385 Builder.CreateRet(ConstantInt::get(TypeBuilder<int, false>::get(Context),42));
387 // Compile the function to native code
388 (void)TheJIT->getPointerToFunction(Func1);
390 // Free the JIT state for the functions
391 TheJIT->freeMachineCodeForFunction(Func1);
392 TheJIT->freeMachineCodeForFunction(Func2);
394 // Delete the first function (and show that is has no users)
395 EXPECT_EQ(Func1->getNumUses(), 0u);
396 Func1->eraseFromParent();
398 // Delete the second function (and show that it has no users - it had one,
399 // func1 but that's gone now)
400 EXPECT_EQ(Func2->getNumUses(), 0u);
401 Func2->eraseFromParent();
404 TEST_F(JITTest, ModuleDeletion) {
405 TheJIT->DisableLazyCompilation(false);
406 LoadAssembly("define void @main() { "
407 " call i32 @computeVal() "
411 "define internal i32 @computeVal() { "
414 Function *func = M->getFunction("main");
415 TheJIT->getPointerToFunction(func);
416 TheJIT->removeModule(M);
419 SmallPtrSet<const void*, 2> FunctionsDeallocated;
420 for (unsigned i = 0, e = RJMM->deallocateFunctionBodyCalls.size();
422 FunctionsDeallocated.insert(RJMM->deallocateFunctionBodyCalls[i].Body);
424 for (unsigned i = 0, e = RJMM->startFunctionBodyCalls.size(); i != e; ++i) {
425 EXPECT_TRUE(FunctionsDeallocated.count(
426 RJMM->startFunctionBodyCalls[i].Result))
427 << "Function leaked: \n" << RJMM->startFunctionBodyCalls[i].F_dump;
429 EXPECT_EQ(RJMM->startFunctionBodyCalls.size(),
430 RJMM->deallocateFunctionBodyCalls.size());
433 // ARM, MIPS and PPC still emit stubs for calls since the target may be
434 // too far away to call directly. This #if can probably be removed when
435 // http://llvm.org/PR5201 is fixed.
436 #if !defined(__arm__) && !defined(__mips__) && \
437 !defined(__powerpc__) && !defined(__ppc__)
438 typedef int (*FooPtr) ();
440 TEST_F(JITTest, NoStubs) {
441 LoadAssembly("define void @bar() {"
446 "define i32 @foo() {"
452 "define i32 @main() {"
454 "%0 = call i32 @foo()"
458 Function *foo = M->getFunction("foo");
459 uintptr_t tmp = (uintptr_t)(TheJIT->getPointerToFunction(foo));
460 FooPtr ptr = (FooPtr)(tmp);
464 // We should now allocate no more stubs, we have the code to foo
465 // and the existing stub for bar.
466 int stubsBefore = RJMM->stubsAllocated;
467 Function *func = M->getFunction("main");
468 TheJIT->getPointerToFunction(func);
470 Function *bar = M->getFunction("bar");
471 TheJIT->getPointerToFunction(bar);
473 ASSERT_EQ(stubsBefore, RJMM->stubsAllocated);
475 #endif // !ARM && !PPC
477 TEST_F(JITTest, FunctionPointersOutliveTheirCreator) {
478 TheJIT->DisableLazyCompilation(true);
479 LoadAssembly("define i8()* @get_foo_addr() { "
483 "define i8 @foo() { "
486 Function *F_get_foo_addr = M->getFunction("get_foo_addr");
488 typedef char(*fooT)();
489 fooT (*get_foo_addr)() = reinterpret_cast<fooT(*)()>(
490 (intptr_t)TheJIT->getPointerToFunction(F_get_foo_addr));
491 fooT foo_addr = get_foo_addr();
493 // Now free get_foo_addr. This should not free the machine code for foo or
494 // any call stub returned as foo's canonical address.
495 TheJIT->freeMachineCodeForFunction(F_get_foo_addr);
497 // Check by calling the reported address of foo.
498 EXPECT_EQ(42, foo_addr());
500 // The reported address should also be the same as the result of a subsequent
501 // getPointerToFunction(foo).
503 // Fails until PR5126 is fixed:
504 Function *F_foo = M->getFunction("foo");
505 fooT foo = reinterpret_cast<fooT>(
506 (intptr_t)TheJIT->getPointerToFunction(F_foo));
507 EXPECT_EQ((intptr_t)foo, (intptr_t)foo_addr);
511 // ARM does not have an implementation of replaceMachineCodeForFunction(),
512 // so recompileAndRelinkFunction doesn't work.
513 #if !defined(__arm__)
514 TEST_F(JITTest, FunctionIsRecompiledAndRelinked) {
515 Function *F = Function::Create(TypeBuilder<int(void), false>::get(Context),
516 GlobalValue::ExternalLinkage, "test", M);
517 BasicBlock *Entry = BasicBlock::Create(Context, "entry", F);
518 IRBuilder<> Builder(Entry);
519 Value *Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 1);
520 Builder.CreateRet(Val);
522 TheJIT->DisableLazyCompilation(true);
523 // Compile the function once, and make sure it works.
524 int (*OrigFPtr)() = reinterpret_cast<int(*)()>(
525 (intptr_t)TheJIT->recompileAndRelinkFunction(F));
526 EXPECT_EQ(1, OrigFPtr());
528 // Now change the function to return a different value.
529 Entry->eraseFromParent();
530 BasicBlock *NewEntry = BasicBlock::Create(Context, "new_entry", F);
531 Builder.SetInsertPoint(NewEntry);
532 Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 2);
533 Builder.CreateRet(Val);
534 // Recompile it, which should produce a new function pointer _and_ update the
536 int (*NewFPtr)() = reinterpret_cast<int(*)()>(
537 (intptr_t)TheJIT->recompileAndRelinkFunction(F));
539 EXPECT_EQ(2, NewFPtr())
540 << "The new pointer should call the new version of the function";
541 EXPECT_EQ(2, OrigFPtr())
542 << "The old pointer's target should now jump to the new version";
544 #endif // !defined(__arm__)
546 TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) {
547 TheJIT->DisableLazyCompilation(true);
548 LoadAssembly("@JITTest_AvailableExternallyGlobal = "
549 " available_externally global i32 7 "
551 "define i32 @loader() { "
552 " %result = load i32* @JITTest_AvailableExternallyGlobal "
555 Function *loaderIR = M->getFunction("loader");
557 int32_t (*loader)() = reinterpret_cast<int32_t(*)()>(
558 (intptr_t)TheJIT->getPointerToFunction(loaderIR));
559 EXPECT_EQ(42, loader()) << "func should return 42 from the external global,"
560 << " not 7 from the IR version.";
563 TEST_F(JITTest, AvailableExternallyFunctionIsntCompiled) {
564 TheJIT->DisableLazyCompilation(true);
565 LoadAssembly("define available_externally i32 "
566 " @JITTest_AvailableExternallyFunction() { "
570 "define i32 @func() { "
571 " %result = tail call i32 "
572 " @JITTest_AvailableExternallyFunction() "
575 Function *funcIR = M->getFunction("func");
577 int32_t (*func)() = reinterpret_cast<int32_t(*)()>(
578 (intptr_t)TheJIT->getPointerToFunction(funcIR));
579 EXPECT_EQ(42, func()) << "func should return 42 from the static version,"
580 << " not 7 from the IR version.";
583 TEST_F(JITTest, EscapedLazyStubStillCallable) {
584 TheJIT->DisableLazyCompilation(false);
585 LoadAssembly("define internal i32 @stubbed() { "
589 "define i32()* @get_stub() { "
590 " ret i32()* @stubbed "
592 typedef int32_t(*StubTy)();
594 // Call get_stub() to get the address of @stubbed without actually JITting it.
595 Function *get_stubIR = M->getFunction("get_stub");
596 StubTy (*get_stub)() = reinterpret_cast<StubTy(*)()>(
597 (intptr_t)TheJIT->getPointerToFunction(get_stubIR));
598 StubTy stubbed = get_stub();
599 // Now get_stubIR is the only reference to stubbed's stub.
600 get_stubIR->eraseFromParent();
601 // Now there are no references inside the JIT, but we've got a pointer outside
602 // it. The stub should be callable and return the right value.
603 EXPECT_EQ(42, stubbed());
606 // Converts the LLVM assembly to bitcode and returns it in a std::string. An
607 // empty string indicates an error.
608 std::string AssembleToBitcode(LLVMContext &Context, const char *Assembly) {
609 Module TempModule("TempModule", Context);
610 if (!LoadAssemblyInto(&TempModule, Assembly)) {
615 raw_string_ostream OS(Result);
616 WriteBitcodeToFile(&TempModule, OS);
621 // Returns a newly-created ExecutionEngine that reads the bitcode in 'Bitcode'
622 // lazily. The associated Module (owned by the ExecutionEngine) is returned in
623 // M. Both will be NULL on an error. Bitcode must live at least as long as the
625 ExecutionEngine *getJITFromBitcode(
626 LLVMContext &Context, const std::string &Bitcode, Module *&M) {
627 // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires.
628 MemoryBuffer *BitcodeBuffer =
629 MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test");
631 M = getLazyBitcodeModule(BitcodeBuffer, Context, &errMsg);
633 ADD_FAILURE() << errMsg;
634 delete BitcodeBuffer;
637 ExecutionEngine *TheJIT = EngineBuilder(M)
638 .setEngineKind(EngineKind::JIT)
639 .setErrorStr(&errMsg)
641 if (TheJIT == NULL) {
642 ADD_FAILURE() << errMsg;
650 TEST(LazyLoadedJITTest, MaterializableAvailableExternallyFunctionIsntCompiled) {
652 const std::string Bitcode =
653 AssembleToBitcode(Context,
654 "define available_externally i32 "
655 " @JITTest_AvailableExternallyFunction() { "
659 "define i32 @func() { "
660 " %result = tail call i32 "
661 " @JITTest_AvailableExternallyFunction() "
664 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
666 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
667 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
668 TheJIT->DisableLazyCompilation(true);
670 Function *funcIR = M->getFunction("func");
671 Function *availableFunctionIR =
672 M->getFunction("JITTest_AvailableExternallyFunction");
674 // Double-check that the available_externally function is still unmaterialized
675 // when getPointerToFunction needs to find out if it's available_externally.
676 EXPECT_TRUE(availableFunctionIR->isMaterializable());
678 int32_t (*func)() = reinterpret_cast<int32_t(*)()>(
679 (intptr_t)TheJIT->getPointerToFunction(funcIR));
680 EXPECT_EQ(42, func()) << "func should return 42 from the static version,"
681 << " not 7 from the IR version.";
684 TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) {
686 const std::string Bitcode =
687 AssembleToBitcode(Context,
688 "define i32 @recur1(i32 %a) { "
689 " %zero = icmp eq i32 %a, 0 "
690 " br i1 %zero, label %done, label %notdone "
694 " %am1 = sub i32 %a, 1 "
695 " %result = call i32 @recur2(i32 %am1) "
699 "define i32 @recur2(i32 %b) { "
700 " %result = call i32 @recur1(i32 %b) "
703 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed";
705 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M));
706 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT.";
707 TheJIT->DisableLazyCompilation(true);
709 Function *recur1IR = M->getFunction("recur1");
710 Function *recur2IR = M->getFunction("recur2");
711 EXPECT_TRUE(recur1IR->isMaterializable());
712 EXPECT_TRUE(recur2IR->isMaterializable());
714 int32_t (*recur1)(int32_t) = reinterpret_cast<int32_t(*)(int32_t)>(
715 (intptr_t)TheJIT->getPointerToFunction(recur1IR));
716 EXPECT_EQ(3, recur1(4));
718 #endif // !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__)
720 // This code is copied from JITEventListenerTest, but it only runs once for all
721 // the tests in this directory. Everything seems fine, but that's strange
723 class JITEnvironment : public testing::Environment {
724 virtual void SetUp() {
725 // Required to create a JIT.
726 InitializeNativeTarget();
729 testing::Environment* const jit_env =
730 testing::AddGlobalTestEnvironment(new JITEnvironment);