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