JIT.cpp revision 195098
1//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===// 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// This tool implements a just-in-time compiler for LLVM, allowing direct 11// execution of LLVM bitcode in an efficient manner. 12// 13//===----------------------------------------------------------------------===// 14 15#include "JIT.h" 16#include "llvm/Constants.h" 17#include "llvm/DerivedTypes.h" 18#include "llvm/Function.h" 19#include "llvm/GlobalVariable.h" 20#include "llvm/Instructions.h" 21#include "llvm/ModuleProvider.h" 22#include "llvm/CodeGen/JITCodeEmitter.h" 23#include "llvm/CodeGen/MachineCodeInfo.h" 24#include "llvm/ExecutionEngine/GenericValue.h" 25#include "llvm/ExecutionEngine/JITEventListener.h" 26#include "llvm/Target/TargetData.h" 27#include "llvm/Target/TargetMachine.h" 28#include "llvm/Target/TargetJITInfo.h" 29#include "llvm/Support/Dwarf.h" 30#include "llvm/Support/MutexGuard.h" 31#include "llvm/System/DynamicLibrary.h" 32#include "llvm/Config/config.h" 33 34using namespace llvm; 35 36#ifdef __APPLE__ 37// Apple gcc defaults to -fuse-cxa-atexit (i.e. calls __cxa_atexit instead 38// of atexit). It passes the address of linker generated symbol __dso_handle 39// to the function. 40// This configuration change happened at version 5330. 41# include <AvailabilityMacros.h> 42# if defined(MAC_OS_X_VERSION_10_4) && \ 43 ((MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4) || \ 44 (MAC_OS_X_VERSION_MIN_REQUIRED == MAC_OS_X_VERSION_10_4 && \ 45 __APPLE_CC__ >= 5330)) 46# ifndef HAVE___DSO_HANDLE 47# define HAVE___DSO_HANDLE 1 48# endif 49# endif 50#endif 51 52#if HAVE___DSO_HANDLE 53extern void *__dso_handle __attribute__ ((__visibility__ ("hidden"))); 54#endif 55 56namespace { 57 58static struct RegisterJIT { 59 RegisterJIT() { JIT::Register(); } 60} JITRegistrator; 61 62} 63 64extern "C" void LLVMLinkInJIT() { 65} 66 67 68#if defined(__GNUC__) && !defined(__ARM__EABI__) 69 70// libgcc defines the __register_frame function to dynamically register new 71// dwarf frames for exception handling. This functionality is not portable 72// across compilers and is only provided by GCC. We use the __register_frame 73// function here so that code generated by the JIT cooperates with the unwinding 74// runtime of libgcc. When JITting with exception handling enable, LLVM 75// generates dwarf frames and registers it to libgcc with __register_frame. 76// 77// The __register_frame function works with Linux. 78// 79// Unfortunately, this functionality seems to be in libgcc after the unwinding 80// library of libgcc for darwin was written. The code for darwin overwrites the 81// value updated by __register_frame with a value fetched with "keymgr". 82// "keymgr" is an obsolete functionality, which should be rewritten some day. 83// In the meantime, since "keymgr" is on all libgccs shipped with apple-gcc, we 84// need a workaround in LLVM which uses the "keymgr" to dynamically modify the 85// values of an opaque key, used by libgcc to find dwarf tables. 86 87extern "C" void __register_frame(void*); 88 89#if defined(__APPLE__) && MAC_OS_X_VERSION_MAX_ALLOWED <= 1050 90# define USE_KEYMGR 1 91#else 92# define USE_KEYMGR 0 93#endif 94 95#if USE_KEYMGR 96 97namespace { 98 99// LibgccObject - This is the structure defined in libgcc. There is no #include 100// provided for this structure, so we also define it here. libgcc calls it 101// "struct object". The structure is undocumented in libgcc. 102struct LibgccObject { 103 void *unused1; 104 void *unused2; 105 void *unused3; 106 107 /// frame - Pointer to the exception table. 108 void *frame; 109 110 /// encoding - The encoding of the object? 111 union { 112 struct { 113 unsigned long sorted : 1; 114 unsigned long from_array : 1; 115 unsigned long mixed_encoding : 1; 116 unsigned long encoding : 8; 117 unsigned long count : 21; 118 } b; 119 size_t i; 120 } encoding; 121 122 /// fde_end - libgcc defines this field only if some macro is defined. We 123 /// include this field even if it may not there, to make libgcc happy. 124 char *fde_end; 125 126 /// next - At least we know it's a chained list! 127 struct LibgccObject *next; 128}; 129 130// "kemgr" stuff. Apparently, all frame tables are stored there. 131extern "C" void _keymgr_set_and_unlock_processwide_ptr(int, void *); 132extern "C" void *_keymgr_get_and_lock_processwide_ptr(int); 133#define KEYMGR_GCC3_DW2_OBJ_LIST 302 /* Dwarf2 object list */ 134 135/// LibgccObjectInfo - libgcc defines this struct as km_object_info. It 136/// probably contains all dwarf tables that are loaded. 137struct LibgccObjectInfo { 138 139 /// seenObjects - LibgccObjects already parsed by the unwinding runtime. 140 /// 141 struct LibgccObject* seenObjects; 142 143 /// unseenObjects - LibgccObjects not parsed yet by the unwinding runtime. 144 /// 145 struct LibgccObject* unseenObjects; 146 147 unsigned unused[2]; 148}; 149 150/// darwin_register_frame - Since __register_frame does not work with darwin's 151/// libgcc,we provide our own function, which "tricks" libgcc by modifying the 152/// "Dwarf2 object list" key. 153void DarwinRegisterFrame(void* FrameBegin) { 154 // Get the key. 155 LibgccObjectInfo* LOI = (struct LibgccObjectInfo*) 156 _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST); 157 assert(LOI && "This should be preallocated by the runtime"); 158 159 // Allocate a new LibgccObject to represent this frame. Deallocation of this 160 // object may be impossible: since darwin code in libgcc was written after 161 // the ability to dynamically register frames, things may crash if we 162 // deallocate it. 163 struct LibgccObject* ob = (struct LibgccObject*) 164 malloc(sizeof(struct LibgccObject)); 165 166 // Do like libgcc for the values of the field. 167 ob->unused1 = (void *)-1; 168 ob->unused2 = 0; 169 ob->unused3 = 0; 170 ob->frame = FrameBegin; 171 ob->encoding.i = 0; 172 ob->encoding.b.encoding = llvm::dwarf::DW_EH_PE_omit; 173 174 // Put the info on both places, as libgcc uses the first or the the second 175 // field. Note that we rely on having two pointers here. If fde_end was a 176 // char, things would get complicated. 177 ob->fde_end = (char*)LOI->unseenObjects; 178 ob->next = LOI->unseenObjects; 179 180 // Update the key's unseenObjects list. 181 LOI->unseenObjects = ob; 182 183 // Finally update the "key". Apparently, libgcc requires it. 184 _keymgr_set_and_unlock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST, 185 LOI); 186 187} 188 189} 190#endif // __APPLE__ 191#endif // __GNUC__ 192 193/// createJIT - This is the factory method for creating a JIT for the current 194/// machine, it does not fall back to the interpreter. This takes ownership 195/// of the module provider. 196ExecutionEngine *ExecutionEngine::createJIT(ModuleProvider *MP, 197 std::string *ErrorStr, 198 JITMemoryManager *JMM, 199 CodeGenOpt::Level OptLevel) { 200 ExecutionEngine *EE = JIT::createJIT(MP, ErrorStr, JMM, OptLevel); 201 if (!EE) return 0; 202 203 // Make sure we can resolve symbols in the program as well. The zero arg 204 // to the function tells DynamicLibrary to load the program, not a library. 205 sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr); 206 return EE; 207} 208 209JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji, 210 JITMemoryManager *JMM, CodeGenOpt::Level OptLevel) 211 : ExecutionEngine(MP), TM(tm), TJI(tji) { 212 setTargetData(TM.getTargetData()); 213 214 jitstate = new JITState(MP); 215 216 // Initialize JCE 217 JCE = createEmitter(*this, JMM); 218 219 // Add target data 220 MutexGuard locked(lock); 221 FunctionPassManager &PM = jitstate->getPM(locked); 222 PM.add(new TargetData(*TM.getTargetData())); 223 224 // Turn the machine code intermediate representation into bytes in memory that 225 // may be executed. 226 if (TM.addPassesToEmitMachineCode(PM, *JCE, OptLevel)) { 227 cerr << "Target does not support machine code emission!\n"; 228 abort(); 229 } 230 231 // Register routine for informing unwinding runtime about new EH frames 232#if defined(__GNUC__) && !defined(__ARM_EABI__) 233#if USE_KEYMGR 234 struct LibgccObjectInfo* LOI = (struct LibgccObjectInfo*) 235 _keymgr_get_and_lock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST); 236 237 // The key is created on demand, and libgcc creates it the first time an 238 // exception occurs. Since we need the key to register frames, we create 239 // it now. 240 if (!LOI) 241 LOI = (LibgccObjectInfo*)calloc(sizeof(struct LibgccObjectInfo), 1); 242 _keymgr_set_and_unlock_processwide_ptr(KEYMGR_GCC3_DW2_OBJ_LIST, LOI); 243 InstallExceptionTableRegister(DarwinRegisterFrame); 244#else 245 InstallExceptionTableRegister(__register_frame); 246#endif // __APPLE__ 247#endif // __GNUC__ 248 249 // Initialize passes. 250 PM.doInitialization(); 251} 252 253JIT::~JIT() { 254 delete jitstate; 255 delete JCE; 256 delete &TM; 257} 258 259/// addModuleProvider - Add a new ModuleProvider to the JIT. If we previously 260/// removed the last ModuleProvider, we need re-initialize jitstate with a valid 261/// ModuleProvider. 262void JIT::addModuleProvider(ModuleProvider *MP) { 263 MutexGuard locked(lock); 264 265 if (Modules.empty()) { 266 assert(!jitstate && "jitstate should be NULL if Modules vector is empty!"); 267 268 jitstate = new JITState(MP); 269 270 FunctionPassManager &PM = jitstate->getPM(locked); 271 PM.add(new TargetData(*TM.getTargetData())); 272 273 // Turn the machine code intermediate representation into bytes in memory 274 // that may be executed. 275 if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) { 276 cerr << "Target does not support machine code emission!\n"; 277 abort(); 278 } 279 280 // Initialize passes. 281 PM.doInitialization(); 282 } 283 284 ExecutionEngine::addModuleProvider(MP); 285} 286 287/// removeModuleProvider - If we are removing the last ModuleProvider, 288/// invalidate the jitstate since the PassManager it contains references a 289/// released ModuleProvider. 290Module *JIT::removeModuleProvider(ModuleProvider *MP, std::string *E) { 291 Module *result = ExecutionEngine::removeModuleProvider(MP, E); 292 293 MutexGuard locked(lock); 294 295 if (jitstate->getMP() == MP) { 296 delete jitstate; 297 jitstate = 0; 298 } 299 300 if (!jitstate && !Modules.empty()) { 301 jitstate = new JITState(Modules[0]); 302 303 FunctionPassManager &PM = jitstate->getPM(locked); 304 PM.add(new TargetData(*TM.getTargetData())); 305 306 // Turn the machine code intermediate representation into bytes in memory 307 // that may be executed. 308 if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) { 309 cerr << "Target does not support machine code emission!\n"; 310 abort(); 311 } 312 313 // Initialize passes. 314 PM.doInitialization(); 315 } 316 return result; 317} 318 319/// deleteModuleProvider - Remove a ModuleProvider from the list of modules, 320/// and deletes the ModuleProvider and owned Module. Avoids materializing 321/// the underlying module. 322void JIT::deleteModuleProvider(ModuleProvider *MP, std::string *E) { 323 ExecutionEngine::deleteModuleProvider(MP, E); 324 325 MutexGuard locked(lock); 326 327 if (jitstate->getMP() == MP) { 328 delete jitstate; 329 jitstate = 0; 330 } 331 332 if (!jitstate && !Modules.empty()) { 333 jitstate = new JITState(Modules[0]); 334 335 FunctionPassManager &PM = jitstate->getPM(locked); 336 PM.add(new TargetData(*TM.getTargetData())); 337 338 // Turn the machine code intermediate representation into bytes in memory 339 // that may be executed. 340 if (TM.addPassesToEmitMachineCode(PM, *JCE, CodeGenOpt::Default)) { 341 cerr << "Target does not support machine code emission!\n"; 342 abort(); 343 } 344 345 // Initialize passes. 346 PM.doInitialization(); 347 } 348} 349 350/// run - Start execution with the specified function and arguments. 351/// 352GenericValue JIT::runFunction(Function *F, 353 const std::vector<GenericValue> &ArgValues) { 354 assert(F && "Function *F was null at entry to run()"); 355 356 void *FPtr = getPointerToFunction(F); 357 assert(FPtr && "Pointer to fn's code was null after getPointerToFunction"); 358 const FunctionType *FTy = F->getFunctionType(); 359 const Type *RetTy = FTy->getReturnType(); 360 361 assert((FTy->getNumParams() == ArgValues.size() || 362 (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) && 363 "Wrong number of arguments passed into function!"); 364 assert(FTy->getNumParams() == ArgValues.size() && 365 "This doesn't support passing arguments through varargs (yet)!"); 366 367 // Handle some common cases first. These cases correspond to common `main' 368 // prototypes. 369 if (RetTy == Type::Int32Ty || RetTy == Type::VoidTy) { 370 switch (ArgValues.size()) { 371 case 3: 372 if (FTy->getParamType(0) == Type::Int32Ty && 373 isa<PointerType>(FTy->getParamType(1)) && 374 isa<PointerType>(FTy->getParamType(2))) { 375 int (*PF)(int, char **, const char **) = 376 (int(*)(int, char **, const char **))(intptr_t)FPtr; 377 378 // Call the function. 379 GenericValue rv; 380 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 381 (char **)GVTOP(ArgValues[1]), 382 (const char **)GVTOP(ArgValues[2]))); 383 return rv; 384 } 385 break; 386 case 2: 387 if (FTy->getParamType(0) == Type::Int32Ty && 388 isa<PointerType>(FTy->getParamType(1))) { 389 int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr; 390 391 // Call the function. 392 GenericValue rv; 393 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 394 (char **)GVTOP(ArgValues[1]))); 395 return rv; 396 } 397 break; 398 case 1: 399 if (FTy->getNumParams() == 1 && 400 FTy->getParamType(0) == Type::Int32Ty) { 401 GenericValue rv; 402 int (*PF)(int) = (int(*)(int))(intptr_t)FPtr; 403 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue())); 404 return rv; 405 } 406 break; 407 } 408 } 409 410 // Handle cases where no arguments are passed first. 411 if (ArgValues.empty()) { 412 GenericValue rv; 413 switch (RetTy->getTypeID()) { 414 default: assert(0 && "Unknown return type for function call!"); 415 case Type::IntegerTyID: { 416 unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth(); 417 if (BitWidth == 1) 418 rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)()); 419 else if (BitWidth <= 8) 420 rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)()); 421 else if (BitWidth <= 16) 422 rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)()); 423 else if (BitWidth <= 32) 424 rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)()); 425 else if (BitWidth <= 64) 426 rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)()); 427 else 428 assert(0 && "Integer types > 64 bits not supported"); 429 return rv; 430 } 431 case Type::VoidTyID: 432 rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)()); 433 return rv; 434 case Type::FloatTyID: 435 rv.FloatVal = ((float(*)())(intptr_t)FPtr)(); 436 return rv; 437 case Type::DoubleTyID: 438 rv.DoubleVal = ((double(*)())(intptr_t)FPtr)(); 439 return rv; 440 case Type::X86_FP80TyID: 441 case Type::FP128TyID: 442 case Type::PPC_FP128TyID: 443 assert(0 && "long double not supported yet"); 444 return rv; 445 case Type::PointerTyID: 446 return PTOGV(((void*(*)())(intptr_t)FPtr)()); 447 } 448 } 449 450 // Okay, this is not one of our quick and easy cases. Because we don't have a 451 // full FFI, we have to codegen a nullary stub function that just calls the 452 // function we are interested in, passing in constants for all of the 453 // arguments. Make this function and return. 454 455 // First, create the function. 456 FunctionType *STy=FunctionType::get(RetTy, std::vector<const Type*>(), false); 457 Function *Stub = Function::Create(STy, Function::InternalLinkage, "", 458 F->getParent()); 459 460 // Insert a basic block. 461 BasicBlock *StubBB = BasicBlock::Create("", Stub); 462 463 // Convert all of the GenericValue arguments over to constants. Note that we 464 // currently don't support varargs. 465 SmallVector<Value*, 8> Args; 466 for (unsigned i = 0, e = ArgValues.size(); i != e; ++i) { 467 Constant *C = 0; 468 const Type *ArgTy = FTy->getParamType(i); 469 const GenericValue &AV = ArgValues[i]; 470 switch (ArgTy->getTypeID()) { 471 default: assert(0 && "Unknown argument type for function call!"); 472 case Type::IntegerTyID: 473 C = ConstantInt::get(AV.IntVal); 474 break; 475 case Type::FloatTyID: 476 C = ConstantFP::get(APFloat(AV.FloatVal)); 477 break; 478 case Type::DoubleTyID: 479 C = ConstantFP::get(APFloat(AV.DoubleVal)); 480 break; 481 case Type::PPC_FP128TyID: 482 case Type::X86_FP80TyID: 483 case Type::FP128TyID: 484 C = ConstantFP::get(APFloat(AV.IntVal)); 485 break; 486 case Type::PointerTyID: 487 void *ArgPtr = GVTOP(AV); 488 if (sizeof(void*) == 4) 489 C = ConstantInt::get(Type::Int32Ty, (int)(intptr_t)ArgPtr); 490 else 491 C = ConstantInt::get(Type::Int64Ty, (intptr_t)ArgPtr); 492 C = ConstantExpr::getIntToPtr(C, ArgTy); // Cast the integer to pointer 493 break; 494 } 495 Args.push_back(C); 496 } 497 498 CallInst *TheCall = CallInst::Create(F, Args.begin(), Args.end(), 499 "", StubBB); 500 TheCall->setCallingConv(F->getCallingConv()); 501 TheCall->setTailCall(); 502 if (TheCall->getType() != Type::VoidTy) 503 ReturnInst::Create(TheCall, StubBB); // Return result of the call. 504 else 505 ReturnInst::Create(StubBB); // Just return void. 506 507 // Finally, return the value returned by our nullary stub function. 508 return runFunction(Stub, std::vector<GenericValue>()); 509} 510 511void JIT::RegisterJITEventListener(JITEventListener *L) { 512 if (L == NULL) 513 return; 514 MutexGuard locked(lock); 515 EventListeners.push_back(L); 516} 517void JIT::UnregisterJITEventListener(JITEventListener *L) { 518 if (L == NULL) 519 return; 520 MutexGuard locked(lock); 521 std::vector<JITEventListener*>::reverse_iterator I= 522 std::find(EventListeners.rbegin(), EventListeners.rend(), L); 523 if (I != EventListeners.rend()) { 524 std::swap(*I, EventListeners.back()); 525 EventListeners.pop_back(); 526 } 527} 528void JIT::NotifyFunctionEmitted( 529 const Function &F, 530 void *Code, size_t Size, 531 const JITEvent_EmittedFunctionDetails &Details) { 532 MutexGuard locked(lock); 533 for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) { 534 EventListeners[I]->NotifyFunctionEmitted(F, Code, Size, Details); 535 } 536} 537 538void JIT::NotifyFreeingMachineCode(const Function &F, void *OldPtr) { 539 MutexGuard locked(lock); 540 for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) { 541 EventListeners[I]->NotifyFreeingMachineCode(F, OldPtr); 542 } 543} 544 545/// runJITOnFunction - Run the FunctionPassManager full of 546/// just-in-time compilation passes on F, hopefully filling in 547/// GlobalAddress[F] with the address of F's machine code. 548/// 549void JIT::runJITOnFunction(Function *F, MachineCodeInfo *MCI) { 550 MutexGuard locked(lock); 551 552 class MCIListener : public JITEventListener { 553 MachineCodeInfo *const MCI; 554 public: 555 MCIListener(MachineCodeInfo *mci) : MCI(mci) {} 556 virtual void NotifyFunctionEmitted(const Function &, 557 void *Code, size_t Size, 558 const EmittedFunctionDetails &) { 559 MCI->setAddress(Code); 560 MCI->setSize(Size); 561 } 562 }; 563 MCIListener MCIL(MCI); 564 RegisterJITEventListener(&MCIL); 565 566 runJITOnFunctionUnlocked(F, locked); 567 568 UnregisterJITEventListener(&MCIL); 569} 570 571void JIT::runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked) { 572 static bool isAlreadyCodeGenerating = false; 573 assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!"); 574 575 // JIT the function 576 isAlreadyCodeGenerating = true; 577 jitstate->getPM(locked).run(*F); 578 isAlreadyCodeGenerating = false; 579 580 // If the function referred to another function that had not yet been 581 // read from bitcode, but we are jitting non-lazily, emit it now. 582 while (!jitstate->getPendingFunctions(locked).empty()) { 583 Function *PF = jitstate->getPendingFunctions(locked).back(); 584 jitstate->getPendingFunctions(locked).pop_back(); 585 586 // JIT the function 587 isAlreadyCodeGenerating = true; 588 jitstate->getPM(locked).run(*PF); 589 isAlreadyCodeGenerating = false; 590 591 // Now that the function has been jitted, ask the JITEmitter to rewrite 592 // the stub with real address of the function. 593 updateFunctionStub(PF); 594 } 595 596 // If the JIT is configured to emit info so that dlsym can be used to 597 // rewrite stubs to external globals, do so now. 598 if (areDlsymStubsEnabled() && isLazyCompilationDisabled()) 599 updateDlsymStubTable(); 600} 601 602/// getPointerToFunction - This method is used to get the address of the 603/// specified function, compiling it if neccesary. 604/// 605void *JIT::getPointerToFunction(Function *F) { 606 607 if (void *Addr = getPointerToGlobalIfAvailable(F)) 608 return Addr; // Check if function already code gen'd 609 610 MutexGuard locked(lock); 611 612 // Now that this thread owns the lock, check if another thread has already 613 // code gen'd the function. 614 if (void *Addr = getPointerToGlobalIfAvailable(F)) 615 return Addr; 616 617 // Make sure we read in the function if it exists in this Module. 618 if (F->hasNotBeenReadFromBitcode()) { 619 // Determine the module provider this function is provided by. 620 Module *M = F->getParent(); 621 ModuleProvider *MP = 0; 622 for (unsigned i = 0, e = Modules.size(); i != e; ++i) { 623 if (Modules[i]->getModule() == M) { 624 MP = Modules[i]; 625 break; 626 } 627 } 628 assert(MP && "Function isn't in a module we know about!"); 629 630 std::string ErrorMsg; 631 if (MP->materializeFunction(F, &ErrorMsg)) { 632 cerr << "Error reading function '" << F->getName() 633 << "' from bitcode file: " << ErrorMsg << "\n"; 634 abort(); 635 } 636 637 // Now retry to get the address. 638 if (void *Addr = getPointerToGlobalIfAvailable(F)) 639 return Addr; 640 } 641 642 if (F->isDeclaration()) { 643 bool AbortOnFailure = 644 !areDlsymStubsEnabled() && !F->hasExternalWeakLinkage(); 645 void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure); 646 addGlobalMapping(F, Addr); 647 return Addr; 648 } 649 650 runJITOnFunctionUnlocked(F, locked); 651 652 void *Addr = getPointerToGlobalIfAvailable(F); 653 assert(Addr && "Code generation didn't add function to GlobalAddress table!"); 654 return Addr; 655} 656 657/// getOrEmitGlobalVariable - Return the address of the specified global 658/// variable, possibly emitting it to memory if needed. This is used by the 659/// Emitter. 660void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) { 661 MutexGuard locked(lock); 662 663 void *Ptr = getPointerToGlobalIfAvailable(GV); 664 if (Ptr) return Ptr; 665 666 // If the global is external, just remember the address. 667 if (GV->isDeclaration()) { 668#if HAVE___DSO_HANDLE 669 if (GV->getName() == "__dso_handle") 670 return (void*)&__dso_handle; 671#endif 672 Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(GV->getName().c_str()); 673 if (Ptr == 0 && !areDlsymStubsEnabled()) { 674 cerr << "Could not resolve external global address: " 675 << GV->getName() << "\n"; 676 abort(); 677 } 678 addGlobalMapping(GV, Ptr); 679 } else { 680 // GlobalVariable's which are not "constant" will cause trouble in a server 681 // situation. It's returned in the same block of memory as code which may 682 // not be writable. 683 if (isGVCompilationDisabled() && !GV->isConstant()) { 684 cerr << "Compilation of non-internal GlobalValue is disabled!\n"; 685 abort(); 686 } 687 // If the global hasn't been emitted to memory yet, allocate space and 688 // emit it into memory. It goes in the same array as the generated 689 // code, jump tables, etc. 690 const Type *GlobalType = GV->getType()->getElementType(); 691 size_t S = getTargetData()->getTypeAllocSize(GlobalType); 692 size_t A = getTargetData()->getPreferredAlignment(GV); 693 if (GV->isThreadLocal()) { 694 MutexGuard locked(lock); 695 Ptr = TJI.allocateThreadLocalMemory(S); 696 } else if (TJI.allocateSeparateGVMemory()) { 697 if (A <= 8) { 698 Ptr = malloc(S); 699 } else { 700 // Allocate S+A bytes of memory, then use an aligned pointer within that 701 // space. 702 Ptr = malloc(S+A); 703 unsigned MisAligned = ((intptr_t)Ptr & (A-1)); 704 Ptr = (char*)Ptr + (MisAligned ? (A-MisAligned) : 0); 705 } 706 } else { 707 Ptr = JCE->allocateSpace(S, A); 708 } 709 addGlobalMapping(GV, Ptr); 710 EmitGlobalVariable(GV); 711 } 712 return Ptr; 713} 714 715/// recompileAndRelinkFunction - This method is used to force a function 716/// which has already been compiled, to be compiled again, possibly 717/// after it has been modified. Then the entry to the old copy is overwritten 718/// with a branch to the new copy. If there was no old copy, this acts 719/// just like JIT::getPointerToFunction(). 720/// 721void *JIT::recompileAndRelinkFunction(Function *F) { 722 void *OldAddr = getPointerToGlobalIfAvailable(F); 723 724 // If it's not already compiled there is no reason to patch it up. 725 if (OldAddr == 0) { return getPointerToFunction(F); } 726 727 // Delete the old function mapping. 728 addGlobalMapping(F, 0); 729 730 // Recodegen the function 731 runJITOnFunction(F); 732 733 // Update state, forward the old function to the new function. 734 void *Addr = getPointerToGlobalIfAvailable(F); 735 assert(Addr && "Code generation didn't add function to GlobalAddress table!"); 736 TJI.replaceMachineCodeForFunction(OldAddr, Addr); 737 return Addr; 738} 739 740/// getMemoryForGV - This method abstracts memory allocation of global 741/// variable so that the JIT can allocate thread local variables depending 742/// on the target. 743/// 744char* JIT::getMemoryForGV(const GlobalVariable* GV) { 745 const Type *ElTy = GV->getType()->getElementType(); 746 size_t GVSize = (size_t)getTargetData()->getTypeAllocSize(ElTy); 747 if (GV->isThreadLocal()) { 748 MutexGuard locked(lock); 749 return TJI.allocateThreadLocalMemory(GVSize); 750 } else { 751 return new char[GVSize]; 752 } 753} 754 755void JIT::addPendingFunction(Function *F) { 756 MutexGuard locked(lock); 757 jitstate->getPendingFunctions(locked).push_back(F); 758} 759 760 761JITEventListener::~JITEventListener() {} 762