1 //===- JITTest.cpp - Unit tests for the JIT -------------------------------===// 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 #include "llvm/BasicBlock.h" 11 #include "llvm/Constant.h" 12 #include "llvm/Constants.h" 13 #include "llvm/DerivedTypes.h" 14 #include "llvm/Function.h" 15 #include "llvm/GlobalValue.h" 16 #include "llvm/GlobalVariable.h" 17 #include "llvm/IRBuilder.h" 18 #include "llvm/LLVMContext.h" 19 #include "llvm/Module.h" 20 #include "llvm/Type.h" 21 #include "llvm/TypeBuilder.h" 22 #include "llvm/ADT/OwningPtr.h" 23 #include "llvm/ADT/SmallPtrSet.h" 24 #include "llvm/Assembly/Parser.h" 25 #include "llvm/Bitcode/ReaderWriter.h" 26 #include "llvm/ExecutionEngine/JIT.h" 27 #include "llvm/ExecutionEngine/JITMemoryManager.h" 28 #include "llvm/Support/MemoryBuffer.h" 29 #include "llvm/Support/SourceMgr.h" 30 #include "llvm/Support/TargetSelect.h" 31 32 #include "gtest/gtest.h" 33 #include <vector> 34 35 using namespace llvm; 36 37 namespace { 38 39 Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) { 40 std::vector<Type*> params; 41 FunctionType *FTy = FunctionType::get(G->getType()->getElementType(), 42 params, false); 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); 51 return F; 52 } 53 54 std::string DumpFunction(const Function *F) { 55 std::string Result; 56 raw_string_ostream(Result) << "" << *F; 57 return Result; 58 } 59 60 class RecordingJITMemoryManager : public JITMemoryManager { 61 const OwningPtr<JITMemoryManager> Base; 62 public: 63 RecordingJITMemoryManager() 64 : Base(JITMemoryManager::CreateDefaultMemManager()) { 65 stubsAllocated = 0; 66 } 67 virtual void *getPointerToNamedFunction(const std::string &Name, 68 bool AbortOnFailure = true) { 69 return Base->getPointerToNamedFunction(Name, AbortOnFailure); 70 } 71 72 virtual void setMemoryWritable() { Base->setMemoryWritable(); } 73 virtual void setMemoryExecutable() { Base->setMemoryExecutable(); } 74 virtual void setPoisonMemory(bool poison) { Base->setPoisonMemory(poison); } 75 virtual void AllocateGOT() { Base->AllocateGOT(); } 76 virtual uint8_t *getGOTBase() const { return Base->getGOTBase(); } 77 struct StartFunctionBodyCall { 78 StartFunctionBodyCall(uint8_t *Result, const Function *F, 79 uintptr_t ActualSize, uintptr_t ActualSizeResult) 80 : Result(Result), F(F), F_dump(DumpFunction(F)), 81 ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {} 82 uint8_t *Result; 83 const Function *F; 84 std::string F_dump; 85 uintptr_t ActualSize; 86 uintptr_t ActualSizeResult; 87 }; 88 std::vector<StartFunctionBodyCall> startFunctionBodyCalls; 89 virtual uint8_t *startFunctionBody(const Function *F, 90 uintptr_t &ActualSize) { 91 uintptr_t InitialActualSize = ActualSize; 92 uint8_t *Result = Base->startFunctionBody(F, ActualSize); 93 startFunctionBodyCalls.push_back( 94 StartFunctionBodyCall(Result, F, InitialActualSize, ActualSize)); 95 return Result; 96 } 97 int stubsAllocated; 98 virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize, 99 unsigned Alignment) { 100 stubsAllocated++; 101 return Base->allocateStub(F, StubSize, Alignment); 102 } 103 struct EndFunctionBodyCall { 104 EndFunctionBodyCall(const Function *F, uint8_t *FunctionStart, 105 uint8_t *FunctionEnd) 106 : F(F), F_dump(DumpFunction(F)), 107 FunctionStart(FunctionStart), FunctionEnd(FunctionEnd) {} 108 const Function *F; 109 std::string F_dump; 110 uint8_t *FunctionStart; 111 uint8_t *FunctionEnd; 112 }; 113 std::vector<EndFunctionBodyCall> endFunctionBodyCalls; 114 virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart, 115 uint8_t *FunctionEnd) { 116 endFunctionBodyCalls.push_back( 117 EndFunctionBodyCall(F, FunctionStart, FunctionEnd)); 118 Base->endFunctionBody(F, FunctionStart, FunctionEnd); 119 } 120 virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment, 121 unsigned SectionID) { 122 return Base->allocateDataSection(Size, Alignment, SectionID); 123 } 124 virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment, 125 unsigned SectionID) { 126 return Base->allocateCodeSection(Size, Alignment, SectionID); 127 } 128 virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) { 129 return Base->allocateSpace(Size, Alignment); 130 } 131 virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) { 132 return Base->allocateGlobal(Size, Alignment); 133 } 134 struct DeallocateFunctionBodyCall { 135 DeallocateFunctionBodyCall(const void *Body) : Body(Body) {} 136 const void *Body; 137 }; 138 std::vector<DeallocateFunctionBodyCall> deallocateFunctionBodyCalls; 139 virtual void deallocateFunctionBody(void *Body) { 140 deallocateFunctionBodyCalls.push_back(DeallocateFunctionBodyCall(Body)); 141 Base->deallocateFunctionBody(Body); 142 } 143 struct DeallocateExceptionTableCall { 144 DeallocateExceptionTableCall(const void *ET) : ET(ET) {} 145 const void *ET; 146 }; 147 std::vector<DeallocateExceptionTableCall> deallocateExceptionTableCalls; 148 virtual void deallocateExceptionTable(void *ET) { 149 deallocateExceptionTableCalls.push_back(DeallocateExceptionTableCall(ET)); 150 Base->deallocateExceptionTable(ET); 151 } 152 struct StartExceptionTableCall { 153 StartExceptionTableCall(uint8_t *Result, const Function *F, 154 uintptr_t ActualSize, uintptr_t ActualSizeResult) 155 : Result(Result), F(F), F_dump(DumpFunction(F)), 156 ActualSize(ActualSize), ActualSizeResult(ActualSizeResult) {} 157 uint8_t *Result; 158 const Function *F; 159 std::string F_dump; 160 uintptr_t ActualSize; 161 uintptr_t ActualSizeResult; 162 }; 163 std::vector<StartExceptionTableCall> startExceptionTableCalls; 164 virtual uint8_t* startExceptionTable(const Function* F, 165 uintptr_t &ActualSize) { 166 uintptr_t InitialActualSize = ActualSize; 167 uint8_t *Result = Base->startExceptionTable(F, ActualSize); 168 startExceptionTableCalls.push_back( 169 StartExceptionTableCall(Result, F, InitialActualSize, ActualSize)); 170 return Result; 171 } 172 struct EndExceptionTableCall { 173 EndExceptionTableCall(const Function *F, uint8_t *TableStart, 174 uint8_t *TableEnd, uint8_t* FrameRegister) 175 : F(F), F_dump(DumpFunction(F)), 176 TableStart(TableStart), TableEnd(TableEnd), 177 FrameRegister(FrameRegister) {} 178 const Function *F; 179 std::string F_dump; 180 uint8_t *TableStart; 181 uint8_t *TableEnd; 182 uint8_t *FrameRegister; 183 }; 184 std::vector<EndExceptionTableCall> endExceptionTableCalls; 185 virtual void endExceptionTable(const Function *F, uint8_t *TableStart, 186 uint8_t *TableEnd, uint8_t* FrameRegister) { 187 endExceptionTableCalls.push_back( 188 EndExceptionTableCall(F, TableStart, TableEnd, FrameRegister)); 189 return Base->endExceptionTable(F, TableStart, TableEnd, FrameRegister); 190 } 191 }; 192 193 bool LoadAssemblyInto(Module *M, const char *assembly) { 194 SMDiagnostic Error; 195 bool success = 196 NULL != ParseAssemblyString(assembly, M, Error, M->getContext()); 197 std::string errMsg; 198 raw_string_ostream os(errMsg); 199 Error.print("", os); 200 EXPECT_TRUE(success) << os.str(); 201 return success; 202 } 203 204 class JITTest : public testing::Test { 205 protected: 206 virtual void SetUp() { 207 M = new Module("<main>", Context); 208 RJMM = new RecordingJITMemoryManager; 209 RJMM->setPoisonMemory(true); 210 std::string Error; 211 TheJIT.reset(EngineBuilder(M).setEngineKind(EngineKind::JIT) 212 .setJITMemoryManager(RJMM) 213 .setErrorStr(&Error).create()); 214 ASSERT_TRUE(TheJIT.get() != NULL) << Error; 215 } 216 217 void LoadAssembly(const char *assembly) { 218 LoadAssemblyInto(M, assembly); 219 } 220 221 LLVMContext Context; 222 Module *M; // Owned by ExecutionEngine. 223 RecordingJITMemoryManager *RJMM; 224 OwningPtr<ExecutionEngine> TheJIT; 225 }; 226 227 // Regression test for a bug. The JIT used to allocate globals inside the same 228 // memory block used for the function, and when the function code was freed, 229 // the global was left in the same place. This test allocates a function 230 // that uses and global, deallocates it, and then makes sure that the global 231 // stays alive after that. 232 TEST(JIT, GlobalInFunction) { 233 LLVMContext context; 234 Module *M = new Module("<main>", context); 235 236 JITMemoryManager *MemMgr = JITMemoryManager::CreateDefaultMemManager(); 237 // Tell the memory manager to poison freed memory so that accessing freed 238 // memory is more easily tested. 239 MemMgr->setPoisonMemory(true); 240 std::string Error; 241 OwningPtr<ExecutionEngine> JIT(EngineBuilder(M) 242 .setEngineKind(EngineKind::JIT) 243 .setErrorStr(&Error) 244 .setJITMemoryManager(MemMgr) 245 // The next line enables the fix: 246 .setAllocateGVsWithCode(false) 247 .create()); 248 ASSERT_EQ(Error, ""); 249 250 // Create a global variable. 251 Type *GTy = Type::getInt32Ty(context); 252 GlobalVariable *G = new GlobalVariable( 253 *M, 254 GTy, 255 false, // Not constant. 256 GlobalValue::InternalLinkage, 257 Constant::getNullValue(GTy), 258 "myglobal"); 259 260 // Make a function that points to a global. 261 Function *F1 = makeReturnGlobal("F1", G, M); 262 263 // Get the pointer to the native code to force it to JIT the function and 264 // allocate space for the global. 265 void (*F1Ptr)() = 266 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F1)); 267 268 // Since F1 was codegen'd, a pointer to G should be available. 269 int32_t *GPtr = (int32_t*)JIT->getPointerToGlobalIfAvailable(G); 270 ASSERT_NE((int32_t*)NULL, GPtr); 271 EXPECT_EQ(0, *GPtr); 272 273 // F1() should increment G. 274 F1Ptr(); 275 EXPECT_EQ(1, *GPtr); 276 277 // Make a second function identical to the first, referring to the same 278 // global. 279 Function *F2 = makeReturnGlobal("F2", G, M); 280 void (*F2Ptr)() = 281 reinterpret_cast<void(*)()>((intptr_t)JIT->getPointerToFunction(F2)); 282 283 // F2() should increment G. 284 F2Ptr(); 285 EXPECT_EQ(2, *GPtr); 286 287 // Deallocate F1. 288 JIT->freeMachineCodeForFunction(F1); 289 290 // F2() should *still* increment G. 291 F2Ptr(); 292 EXPECT_EQ(3, *GPtr); 293 } 294 295 int PlusOne(int arg) { 296 return arg + 1; 297 } 298 299 // ARM tests disabled pending fix for PR10783. 300 #if !defined(__arm__) 301 TEST_F(JITTest, FarCallToKnownFunction) { 302 // x86-64 can only make direct calls to functions within 32 bits of 303 // the current PC. To call anything farther away, we have to load 304 // the address into a register and call through the register. The 305 // current JIT does this by allocating a stub for any far call. 306 // There was a bug in which the JIT tried to emit a direct call when 307 // the target was already in the JIT's global mappings and lazy 308 // compilation was disabled. 309 310 Function *KnownFunction = Function::Create( 311 TypeBuilder<int(int), false>::get(Context), 312 GlobalValue::ExternalLinkage, "known", M); 313 TheJIT->addGlobalMapping(KnownFunction, (void*)(intptr_t)PlusOne); 314 315 // int test() { return known(7); } 316 Function *TestFunction = Function::Create( 317 TypeBuilder<int(), false>::get(Context), 318 GlobalValue::ExternalLinkage, "test", M); 319 BasicBlock *Entry = BasicBlock::Create(Context, "entry", TestFunction); 320 IRBuilder<> Builder(Entry); 321 Value *result = Builder.CreateCall( 322 KnownFunction, 323 ConstantInt::get(TypeBuilder<int, false>::get(Context), 7)); 324 Builder.CreateRet(result); 325 326 TheJIT->DisableLazyCompilation(true); 327 int (*TestFunctionPtr)() = reinterpret_cast<int(*)()>( 328 (intptr_t)TheJIT->getPointerToFunction(TestFunction)); 329 // This used to crash in trying to call PlusOne(). 330 EXPECT_EQ(8, TestFunctionPtr()); 331 } 332 333 // Test a function C which calls A and B which call each other. 334 TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) { 335 TheJIT->DisableLazyCompilation(true); 336 337 FunctionType *Func1Ty = 338 cast<FunctionType>(TypeBuilder<void(void), false>::get(Context)); 339 std::vector<Type*> arg_types; 340 arg_types.push_back(Type::getInt1Ty(Context)); 341 FunctionType *FuncTy = FunctionType::get( 342 Type::getVoidTy(Context), arg_types, false); 343 Function *Func1 = Function::Create(Func1Ty, Function::ExternalLinkage, 344 "func1", M); 345 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage, 346 "func2", M); 347 Function *Func3 = Function::Create(FuncTy, Function::InternalLinkage, 348 "func3", M); 349 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1); 350 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2); 351 BasicBlock *True2 = BasicBlock::Create(Context, "cond_true", Func2); 352 BasicBlock *False2 = BasicBlock::Create(Context, "cond_false", Func2); 353 BasicBlock *Block3 = BasicBlock::Create(Context, "block3", Func3); 354 BasicBlock *True3 = BasicBlock::Create(Context, "cond_true", Func3); 355 BasicBlock *False3 = BasicBlock::Create(Context, "cond_false", Func3); 356 357 // Make Func1 call Func2(0) and Func3(0). 358 IRBuilder<> Builder(Block1); 359 Builder.CreateCall(Func2, ConstantInt::getTrue(Context)); 360 Builder.CreateCall(Func3, ConstantInt::getTrue(Context)); 361 Builder.CreateRetVoid(); 362 363 // void Func2(bool b) { if (b) { Func3(false); return; } return; } 364 Builder.SetInsertPoint(Block2); 365 Builder.CreateCondBr(Func2->arg_begin(), True2, False2); 366 Builder.SetInsertPoint(True2); 367 Builder.CreateCall(Func3, ConstantInt::getFalse(Context)); 368 Builder.CreateRetVoid(); 369 Builder.SetInsertPoint(False2); 370 Builder.CreateRetVoid(); 371 372 // void Func3(bool b) { if (b) { Func2(false); return; } return; } 373 Builder.SetInsertPoint(Block3); 374 Builder.CreateCondBr(Func3->arg_begin(), True3, False3); 375 Builder.SetInsertPoint(True3); 376 Builder.CreateCall(Func2, ConstantInt::getFalse(Context)); 377 Builder.CreateRetVoid(); 378 Builder.SetInsertPoint(False3); 379 Builder.CreateRetVoid(); 380 381 // Compile the function to native code 382 void (*F1Ptr)() = 383 reinterpret_cast<void(*)()>((intptr_t)TheJIT->getPointerToFunction(Func1)); 384 385 F1Ptr(); 386 } 387 388 // Regression test for PR5162. This used to trigger an AssertingVH inside the 389 // JIT's Function to stub mapping. 390 TEST_F(JITTest, NonLazyLeaksNoStubs) { 391 TheJIT->DisableLazyCompilation(true); 392 393 // Create two functions with a single basic block each. 394 FunctionType *FuncTy = 395 cast<FunctionType>(TypeBuilder<int(), false>::get(Context)); 396 Function *Func1 = Function::Create(FuncTy, Function::ExternalLinkage, 397 "func1", M); 398 Function *Func2 = Function::Create(FuncTy, Function::InternalLinkage, 399 "func2", M); 400 BasicBlock *Block1 = BasicBlock::Create(Context, "block1", Func1); 401 BasicBlock *Block2 = BasicBlock::Create(Context, "block2", Func2); 402 403 // The first function calls the second and returns the result 404 IRBuilder<> Builder(Block1); 405 Value *Result = Builder.CreateCall(Func2); 406 Builder.CreateRet(Result); 407 408 // The second function just returns a constant 409 Builder.SetInsertPoint(Block2); 410 Builder.CreateRet(ConstantInt::get(TypeBuilder<int, false>::get(Context),42)); 411 412 // Compile the function to native code 413 (void)TheJIT->getPointerToFunction(Func1); 414 415 // Free the JIT state for the functions 416 TheJIT->freeMachineCodeForFunction(Func1); 417 TheJIT->freeMachineCodeForFunction(Func2); 418 419 // Delete the first function (and show that is has no users) 420 EXPECT_EQ(Func1->getNumUses(), 0u); 421 Func1->eraseFromParent(); 422 423 // Delete the second function (and show that it has no users - it had one, 424 // func1 but that's gone now) 425 EXPECT_EQ(Func2->getNumUses(), 0u); 426 Func2->eraseFromParent(); 427 } 428 429 TEST_F(JITTest, ModuleDeletion) { 430 TheJIT->DisableLazyCompilation(false); 431 LoadAssembly("define void @main() { " 432 " call i32 @computeVal() " 433 " ret void " 434 "} " 435 " " 436 "define internal i32 @computeVal() { " 437 " ret i32 0 " 438 "} "); 439 Function *func = M->getFunction("main"); 440 TheJIT->getPointerToFunction(func); 441 TheJIT->removeModule(M); 442 delete M; 443 444 SmallPtrSet<const void*, 2> FunctionsDeallocated; 445 for (unsigned i = 0, e = RJMM->deallocateFunctionBodyCalls.size(); 446 i != e; ++i) { 447 FunctionsDeallocated.insert(RJMM->deallocateFunctionBodyCalls[i].Body); 448 } 449 for (unsigned i = 0, e = RJMM->startFunctionBodyCalls.size(); i != e; ++i) { 450 EXPECT_TRUE(FunctionsDeallocated.count( 451 RJMM->startFunctionBodyCalls[i].Result)) 452 << "Function leaked: \n" << RJMM->startFunctionBodyCalls[i].F_dump; 453 } 454 EXPECT_EQ(RJMM->startFunctionBodyCalls.size(), 455 RJMM->deallocateFunctionBodyCalls.size()); 456 457 SmallPtrSet<const void*, 2> ExceptionTablesDeallocated; 458 unsigned NumTablesDeallocated = 0; 459 for (unsigned i = 0, e = RJMM->deallocateExceptionTableCalls.size(); 460 i != e; ++i) { 461 ExceptionTablesDeallocated.insert( 462 RJMM->deallocateExceptionTableCalls[i].ET); 463 if (RJMM->deallocateExceptionTableCalls[i].ET != NULL) { 464 // If JITEmitDebugInfo is off, we'll "deallocate" NULL, which doesn't 465 // appear in startExceptionTableCalls. 466 NumTablesDeallocated++; 467 } 468 } 469 for (unsigned i = 0, e = RJMM->startExceptionTableCalls.size(); i != e; ++i) { 470 EXPECT_TRUE(ExceptionTablesDeallocated.count( 471 RJMM->startExceptionTableCalls[i].Result)) 472 << "Function's exception table leaked: \n" 473 << RJMM->startExceptionTableCalls[i].F_dump; 474 } 475 EXPECT_EQ(RJMM->startExceptionTableCalls.size(), 476 NumTablesDeallocated); 477 } 478 #endif // !defined(__arm__) 479 480 // ARM, MIPS and PPC still emit stubs for calls since the target may be 481 // too far away to call directly. This #if can probably be removed when 482 // http://llvm.org/PR5201 is fixed. 483 #if !defined(__arm__) && !defined(__mips__) && \ 484 !defined(__powerpc__) && !defined(__ppc__) 485 typedef int (*FooPtr) (); 486 487 TEST_F(JITTest, NoStubs) { 488 LoadAssembly("define void @bar() {" 489 "entry: " 490 "ret void" 491 "}" 492 " " 493 "define i32 @foo() {" 494 "entry:" 495 "call void @bar()" 496 "ret i32 undef" 497 "}" 498 " " 499 "define i32 @main() {" 500 "entry:" 501 "%0 = call i32 @foo()" 502 "call void @bar()" 503 "ret i32 undef" 504 "}"); 505 Function *foo = M->getFunction("foo"); 506 uintptr_t tmp = (uintptr_t)(TheJIT->getPointerToFunction(foo)); 507 FooPtr ptr = (FooPtr)(tmp); 508 509 (ptr)(); 510 511 // We should now allocate no more stubs, we have the code to foo 512 // and the existing stub for bar. 513 int stubsBefore = RJMM->stubsAllocated; 514 Function *func = M->getFunction("main"); 515 TheJIT->getPointerToFunction(func); 516 517 Function *bar = M->getFunction("bar"); 518 TheJIT->getPointerToFunction(bar); 519 520 ASSERT_EQ(stubsBefore, RJMM->stubsAllocated); 521 } 522 #endif // !ARM && !PPC 523 524 TEST_F(JITTest, FunctionPointersOutliveTheirCreator) { 525 TheJIT->DisableLazyCompilation(true); 526 LoadAssembly("define i8()* @get_foo_addr() { " 527 " ret i8()* @foo " 528 "} " 529 " " 530 "define i8 @foo() { " 531 " ret i8 42 " 532 "} "); 533 Function *F_get_foo_addr = M->getFunction("get_foo_addr"); 534 535 typedef char(*fooT)(); 536 fooT (*get_foo_addr)() = reinterpret_cast<fooT(*)()>( 537 (intptr_t)TheJIT->getPointerToFunction(F_get_foo_addr)); 538 fooT foo_addr = get_foo_addr(); 539 540 // Now free get_foo_addr. This should not free the machine code for foo or 541 // any call stub returned as foo's canonical address. 542 TheJIT->freeMachineCodeForFunction(F_get_foo_addr); 543 544 // Check by calling the reported address of foo. 545 EXPECT_EQ(42, foo_addr()); 546 547 // The reported address should also be the same as the result of a subsequent 548 // getPointerToFunction(foo). 549 #if 0 550 // Fails until PR5126 is fixed: 551 Function *F_foo = M->getFunction("foo"); 552 fooT foo = reinterpret_cast<fooT>( 553 (intptr_t)TheJIT->getPointerToFunction(F_foo)); 554 EXPECT_EQ((intptr_t)foo, (intptr_t)foo_addr); 555 #endif 556 } 557 558 // ARM does not have an implementation 559 // of replaceMachineCodeForFunction(), so recompileAndRelinkFunction 560 // doesn't work. 561 #if !defined(__arm__) 562 TEST_F(JITTest, FunctionIsRecompiledAndRelinked) { 563 Function *F = Function::Create(TypeBuilder<int(void), false>::get(Context), 564 GlobalValue::ExternalLinkage, "test", M); 565 BasicBlock *Entry = BasicBlock::Create(Context, "entry", F); 566 IRBuilder<> Builder(Entry); 567 Value *Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 1); 568 Builder.CreateRet(Val); 569 570 TheJIT->DisableLazyCompilation(true); 571 // Compile the function once, and make sure it works. 572 int (*OrigFPtr)() = reinterpret_cast<int(*)()>( 573 (intptr_t)TheJIT->recompileAndRelinkFunction(F)); 574 EXPECT_EQ(1, OrigFPtr()); 575 576 // Now change the function to return a different value. 577 Entry->eraseFromParent(); 578 BasicBlock *NewEntry = BasicBlock::Create(Context, "new_entry", F); 579 Builder.SetInsertPoint(NewEntry); 580 Val = ConstantInt::get(TypeBuilder<int, false>::get(Context), 2); 581 Builder.CreateRet(Val); 582 // Recompile it, which should produce a new function pointer _and_ update the 583 // old one. 584 int (*NewFPtr)() = reinterpret_cast<int(*)()>( 585 (intptr_t)TheJIT->recompileAndRelinkFunction(F)); 586 587 EXPECT_EQ(2, NewFPtr()) 588 << "The new pointer should call the new version of the function"; 589 EXPECT_EQ(2, OrigFPtr()) 590 << "The old pointer's target should now jump to the new version"; 591 } 592 #endif // !defined(__arm__) 593 594 } // anonymous namespace 595 // This variable is intentionally defined differently in the statically-compiled 596 // program from the IR input to the JIT to assert that the JIT doesn't use its 597 // definition. 598 extern "C" int32_t JITTest_AvailableExternallyGlobal; 599 int32_t JITTest_AvailableExternallyGlobal = 42; 600 namespace { 601 602 TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) { 603 TheJIT->DisableLazyCompilation(true); 604 LoadAssembly("@JITTest_AvailableExternallyGlobal = " 605 " available_externally global i32 7 " 606 " " 607 "define i32 @loader() { " 608 " %result = load i32* @JITTest_AvailableExternallyGlobal " 609 " ret i32 %result " 610 "} "); 611 Function *loaderIR = M->getFunction("loader"); 612 613 int32_t (*loader)() = reinterpret_cast<int32_t(*)()>( 614 (intptr_t)TheJIT->getPointerToFunction(loaderIR)); 615 EXPECT_EQ(42, loader()) << "func should return 42 from the external global," 616 << " not 7 from the IR version."; 617 } 618 619 } // anonymous namespace 620 // This function is intentionally defined differently in the statically-compiled 621 // program from the IR input to the JIT to assert that the JIT doesn't use its 622 // definition. 623 extern "C" int32_t JITTest_AvailableExternallyFunction() { 624 return 42; 625 } 626 namespace { 627 628 // ARM tests disabled pending fix for PR10783. 629 #if !defined(__arm__) 630 TEST_F(JITTest, AvailableExternallyFunctionIsntCompiled) { 631 TheJIT->DisableLazyCompilation(true); 632 LoadAssembly("define available_externally i32 " 633 " @JITTest_AvailableExternallyFunction() { " 634 " ret i32 7 " 635 "} " 636 " " 637 "define i32 @func() { " 638 " %result = tail call i32 " 639 " @JITTest_AvailableExternallyFunction() " 640 " ret i32 %result " 641 "} "); 642 Function *funcIR = M->getFunction("func"); 643 644 int32_t (*func)() = reinterpret_cast<int32_t(*)()>( 645 (intptr_t)TheJIT->getPointerToFunction(funcIR)); 646 EXPECT_EQ(42, func()) << "func should return 42 from the static version," 647 << " not 7 from the IR version."; 648 } 649 650 TEST_F(JITTest, EscapedLazyStubStillCallable) { 651 TheJIT->DisableLazyCompilation(false); 652 LoadAssembly("define internal i32 @stubbed() { " 653 " ret i32 42 " 654 "} " 655 " " 656 "define i32()* @get_stub() { " 657 " ret i32()* @stubbed " 658 "} "); 659 typedef int32_t(*StubTy)(); 660 661 // Call get_stub() to get the address of @stubbed without actually JITting it. 662 Function *get_stubIR = M->getFunction("get_stub"); 663 StubTy (*get_stub)() = reinterpret_cast<StubTy(*)()>( 664 (intptr_t)TheJIT->getPointerToFunction(get_stubIR)); 665 StubTy stubbed = get_stub(); 666 // Now get_stubIR is the only reference to stubbed's stub. 667 get_stubIR->eraseFromParent(); 668 // Now there are no references inside the JIT, but we've got a pointer outside 669 // it. The stub should be callable and return the right value. 670 EXPECT_EQ(42, stubbed()); 671 } 672 673 // Converts the LLVM assembly to bitcode and returns it in a std::string. An 674 // empty string indicates an error. 675 std::string AssembleToBitcode(LLVMContext &Context, const char *Assembly) { 676 Module TempModule("TempModule", Context); 677 if (!LoadAssemblyInto(&TempModule, Assembly)) { 678 return ""; 679 } 680 681 std::string Result; 682 raw_string_ostream OS(Result); 683 WriteBitcodeToFile(&TempModule, OS); 684 OS.flush(); 685 return Result; 686 } 687 688 // Returns a newly-created ExecutionEngine that reads the bitcode in 'Bitcode' 689 // lazily. The associated Module (owned by the ExecutionEngine) is returned in 690 // M. Both will be NULL on an error. Bitcode must live at least as long as the 691 // ExecutionEngine. 692 ExecutionEngine *getJITFromBitcode( 693 LLVMContext &Context, const std::string &Bitcode, Module *&M) { 694 // c_str() is null-terminated like MemoryBuffer::getMemBuffer requires. 695 MemoryBuffer *BitcodeBuffer = 696 MemoryBuffer::getMemBuffer(Bitcode, "Bitcode for test"); 697 std::string errMsg; 698 M = getLazyBitcodeModule(BitcodeBuffer, Context, &errMsg); 699 if (M == NULL) { 700 ADD_FAILURE() << errMsg; 701 delete BitcodeBuffer; 702 return NULL; 703 } 704 ExecutionEngine *TheJIT = EngineBuilder(M) 705 .setEngineKind(EngineKind::JIT) 706 .setErrorStr(&errMsg) 707 .create(); 708 if (TheJIT == NULL) { 709 ADD_FAILURE() << errMsg; 710 delete M; 711 M = NULL; 712 return NULL; 713 } 714 return TheJIT; 715 } 716 717 TEST(LazyLoadedJITTest, MaterializableAvailableExternallyFunctionIsntCompiled) { 718 LLVMContext Context; 719 const std::string Bitcode = 720 AssembleToBitcode(Context, 721 "define available_externally i32 " 722 " @JITTest_AvailableExternallyFunction() { " 723 " ret i32 7 " 724 "} " 725 " " 726 "define i32 @func() { " 727 " %result = tail call i32 " 728 " @JITTest_AvailableExternallyFunction() " 729 " ret i32 %result " 730 "} "); 731 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed"; 732 Module *M; 733 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M)); 734 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT."; 735 TheJIT->DisableLazyCompilation(true); 736 737 Function *funcIR = M->getFunction("func"); 738 Function *availableFunctionIR = 739 M->getFunction("JITTest_AvailableExternallyFunction"); 740 741 // Double-check that the available_externally function is still unmaterialized 742 // when getPointerToFunction needs to find out if it's available_externally. 743 EXPECT_TRUE(availableFunctionIR->isMaterializable()); 744 745 int32_t (*func)() = reinterpret_cast<int32_t(*)()>( 746 (intptr_t)TheJIT->getPointerToFunction(funcIR)); 747 EXPECT_EQ(42, func()) << "func should return 42 from the static version," 748 << " not 7 from the IR version."; 749 } 750 751 TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) { 752 LLVMContext Context; 753 const std::string Bitcode = 754 AssembleToBitcode(Context, 755 "define i32 @recur1(i32 %a) { " 756 " %zero = icmp eq i32 %a, 0 " 757 " br i1 %zero, label %done, label %notdone " 758 "done: " 759 " ret i32 3 " 760 "notdone: " 761 " %am1 = sub i32 %a, 1 " 762 " %result = call i32 @recur2(i32 %am1) " 763 " ret i32 %result " 764 "} " 765 " " 766 "define i32 @recur2(i32 %b) { " 767 " %result = call i32 @recur1(i32 %b) " 768 " ret i32 %result " 769 "} "); 770 ASSERT_FALSE(Bitcode.empty()) << "Assembling failed"; 771 Module *M; 772 OwningPtr<ExecutionEngine> TheJIT(getJITFromBitcode(Context, Bitcode, M)); 773 ASSERT_TRUE(TheJIT.get()) << "Failed to create JIT."; 774 TheJIT->DisableLazyCompilation(true); 775 776 Function *recur1IR = M->getFunction("recur1"); 777 Function *recur2IR = M->getFunction("recur2"); 778 EXPECT_TRUE(recur1IR->isMaterializable()); 779 EXPECT_TRUE(recur2IR->isMaterializable()); 780 781 int32_t (*recur1)(int32_t) = reinterpret_cast<int32_t(*)(int32_t)>( 782 (intptr_t)TheJIT->getPointerToFunction(recur1IR)); 783 EXPECT_EQ(3, recur1(4)); 784 } 785 #endif // !defined(__arm__) 786 787 // This code is copied from JITEventListenerTest, but it only runs once for all 788 // the tests in this directory. Everything seems fine, but that's strange 789 // behavior. 790 class JITEnvironment : public testing::Environment { 791 virtual void SetUp() { 792 // Required to create a JIT. 793 InitializeNativeTarget(); 794 } 795 }; 796 testing::Environment* const jit_env = 797 testing::AddGlobalTestEnvironment(new JITEnvironment); 798 799 } 800