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/ADT/SmallPtrSet.h" 17#include "llvm/CodeGen/JITCodeEmitter.h" 18#include "llvm/CodeGen/MachineCodeInfo.h" 19#include "llvm/Config/config.h" 20#include "llvm/ExecutionEngine/GenericValue.h" 21#include "llvm/ExecutionEngine/JITEventListener.h" 22#include "llvm/ExecutionEngine/JITMemoryManager.h" 23#include "llvm/IR/Constants.h" 24#include "llvm/IR/DataLayout.h" 25#include "llvm/IR/DerivedTypes.h" 26#include "llvm/IR/Function.h" 27#include "llvm/IR/GlobalVariable.h" 28#include "llvm/IR/Instructions.h" 29#include "llvm/Support/Dwarf.h" 30#include "llvm/Support/DynamicLibrary.h" 31#include "llvm/Support/ErrorHandling.h" 32#include "llvm/Support/ManagedStatic.h" 33#include "llvm/Support/MutexGuard.h" 34#include "llvm/Target/TargetJITInfo.h" 35#include "llvm/Target/TargetMachine.h" 36 37using namespace llvm; 38 39#ifdef __APPLE__ 40// Apple gcc defaults to -fuse-cxa-atexit (i.e. calls __cxa_atexit instead 41// of atexit). It passes the address of linker generated symbol __dso_handle 42// to the function. 43// This configuration change happened at version 5330. 44# include <AvailabilityMacros.h> 45# if defined(MAC_OS_X_VERSION_10_4) && \ 46 ((MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4) || \ 47 (MAC_OS_X_VERSION_MIN_REQUIRED == MAC_OS_X_VERSION_10_4 && \ 48 __APPLE_CC__ >= 5330)) 49# ifndef HAVE___DSO_HANDLE 50# define HAVE___DSO_HANDLE 1 51# endif 52# endif 53#endif 54 55#if HAVE___DSO_HANDLE 56extern void *__dso_handle __attribute__ ((__visibility__ ("hidden"))); 57#endif 58 59namespace { 60 61static struct RegisterJIT { 62 RegisterJIT() { JIT::Register(); } 63} JITRegistrator; 64 65} 66 67extern "C" void LLVMLinkInJIT() { 68} 69 70/// createJIT - This is the factory method for creating a JIT for the current 71/// machine, it does not fall back to the interpreter. This takes ownership 72/// of the module. 73ExecutionEngine *JIT::createJIT(Module *M, 74 std::string *ErrorStr, 75 JITMemoryManager *JMM, 76 bool GVsWithCode, 77 TargetMachine *TM) { 78 // Try to register the program as a source of symbols to resolve against. 79 // 80 // FIXME: Don't do this here. 81 sys::DynamicLibrary::LoadLibraryPermanently(0, NULL); 82 83 // If the target supports JIT code generation, create the JIT. 84 if (TargetJITInfo *TJ = TM->getJITInfo()) { 85 return new JIT(M, *TM, *TJ, JMM, GVsWithCode); 86 } else { 87 if (ErrorStr) 88 *ErrorStr = "target does not support JIT code generation"; 89 return 0; 90 } 91} 92 93namespace { 94/// This class supports the global getPointerToNamedFunction(), which allows 95/// bugpoint or gdb users to search for a function by name without any context. 96class JitPool { 97 SmallPtrSet<JIT*, 1> JITs; // Optimize for process containing just 1 JIT. 98 mutable sys::Mutex Lock; 99public: 100 void Add(JIT *jit) { 101 MutexGuard guard(Lock); 102 JITs.insert(jit); 103 } 104 void Remove(JIT *jit) { 105 MutexGuard guard(Lock); 106 JITs.erase(jit); 107 } 108 void *getPointerToNamedFunction(const char *Name) const { 109 MutexGuard guard(Lock); 110 assert(JITs.size() != 0 && "No Jit registered"); 111 //search function in every instance of JIT 112 for (SmallPtrSet<JIT*, 1>::const_iterator Jit = JITs.begin(), 113 end = JITs.end(); 114 Jit != end; ++Jit) { 115 if (Function *F = (*Jit)->FindFunctionNamed(Name)) 116 return (*Jit)->getPointerToFunction(F); 117 } 118 // The function is not available : fallback on the first created (will 119 // search in symbol of the current program/library) 120 return (*JITs.begin())->getPointerToNamedFunction(Name); 121 } 122}; 123ManagedStatic<JitPool> AllJits; 124} 125extern "C" { 126 // getPointerToNamedFunction - This function is used as a global wrapper to 127 // JIT::getPointerToNamedFunction for the purpose of resolving symbols when 128 // bugpoint is debugging the JIT. In that scenario, we are loading an .so and 129 // need to resolve function(s) that are being mis-codegenerated, so we need to 130 // resolve their addresses at runtime, and this is the way to do it. 131 void *getPointerToNamedFunction(const char *Name) { 132 return AllJits->getPointerToNamedFunction(Name); 133 } 134} 135 136JIT::JIT(Module *M, TargetMachine &tm, TargetJITInfo &tji, 137 JITMemoryManager *jmm, bool GVsWithCode) 138 : ExecutionEngine(M), TM(tm), TJI(tji), 139 JMM(jmm ? jmm : JITMemoryManager::CreateDefaultMemManager()), 140 AllocateGVsWithCode(GVsWithCode), isAlreadyCodeGenerating(false) { 141 setDataLayout(TM.getDataLayout()); 142 143 jitstate = new JITState(M); 144 145 // Initialize JCE 146 JCE = createEmitter(*this, JMM, TM); 147 148 // Register in global list of all JITs. 149 AllJits->Add(this); 150 151 // Add target data 152 MutexGuard locked(lock); 153 FunctionPassManager &PM = jitstate->getPM(locked); 154 PM.add(new DataLayout(*TM.getDataLayout())); 155 156 // Turn the machine code intermediate representation into bytes in memory that 157 // may be executed. 158 if (TM.addPassesToEmitMachineCode(PM, *JCE)) { 159 report_fatal_error("Target does not support machine code emission!"); 160 } 161 162 // Initialize passes. 163 PM.doInitialization(); 164} 165 166JIT::~JIT() { 167 // Cleanup. 168 AllJits->Remove(this); 169 delete jitstate; 170 delete JCE; 171 // JMM is a ownership of JCE, so we no need delete JMM here. 172 delete &TM; 173} 174 175/// addModule - Add a new Module to the JIT. If we previously removed the last 176/// Module, we need re-initialize jitstate with a valid Module. 177void JIT::addModule(Module *M) { 178 MutexGuard locked(lock); 179 180 if (Modules.empty()) { 181 assert(!jitstate && "jitstate should be NULL if Modules vector is empty!"); 182 183 jitstate = new JITState(M); 184 185 FunctionPassManager &PM = jitstate->getPM(locked); 186 PM.add(new DataLayout(*TM.getDataLayout())); 187 188 // Turn the machine code intermediate representation into bytes in memory 189 // that may be executed. 190 if (TM.addPassesToEmitMachineCode(PM, *JCE)) { 191 report_fatal_error("Target does not support machine code emission!"); 192 } 193 194 // Initialize passes. 195 PM.doInitialization(); 196 } 197 198 ExecutionEngine::addModule(M); 199} 200 201/// removeModule - If we are removing the last Module, invalidate the jitstate 202/// since the PassManager it contains references a released Module. 203bool JIT::removeModule(Module *M) { 204 bool result = ExecutionEngine::removeModule(M); 205 206 MutexGuard locked(lock); 207 208 if (jitstate && jitstate->getModule() == M) { 209 delete jitstate; 210 jitstate = 0; 211 } 212 213 if (!jitstate && !Modules.empty()) { 214 jitstate = new JITState(Modules[0]); 215 216 FunctionPassManager &PM = jitstate->getPM(locked); 217 PM.add(new DataLayout(*TM.getDataLayout())); 218 219 // Turn the machine code intermediate representation into bytes in memory 220 // that may be executed. 221 if (TM.addPassesToEmitMachineCode(PM, *JCE)) { 222 report_fatal_error("Target does not support machine code emission!"); 223 } 224 225 // Initialize passes. 226 PM.doInitialization(); 227 } 228 return result; 229} 230 231/// run - Start execution with the specified function and arguments. 232/// 233GenericValue JIT::runFunction(Function *F, 234 const std::vector<GenericValue> &ArgValues) { 235 assert(F && "Function *F was null at entry to run()"); 236 237 void *FPtr = getPointerToFunction(F); 238 assert(FPtr && "Pointer to fn's code was null after getPointerToFunction"); 239 FunctionType *FTy = F->getFunctionType(); 240 Type *RetTy = FTy->getReturnType(); 241 242 assert((FTy->getNumParams() == ArgValues.size() || 243 (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) && 244 "Wrong number of arguments passed into function!"); 245 assert(FTy->getNumParams() == ArgValues.size() && 246 "This doesn't support passing arguments through varargs (yet)!"); 247 248 // Handle some common cases first. These cases correspond to common `main' 249 // prototypes. 250 if (RetTy->isIntegerTy(32) || RetTy->isVoidTy()) { 251 switch (ArgValues.size()) { 252 case 3: 253 if (FTy->getParamType(0)->isIntegerTy(32) && 254 FTy->getParamType(1)->isPointerTy() && 255 FTy->getParamType(2)->isPointerTy()) { 256 int (*PF)(int, char **, const char **) = 257 (int(*)(int, char **, const char **))(intptr_t)FPtr; 258 259 // Call the function. 260 GenericValue rv; 261 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 262 (char **)GVTOP(ArgValues[1]), 263 (const char **)GVTOP(ArgValues[2]))); 264 return rv; 265 } 266 break; 267 case 2: 268 if (FTy->getParamType(0)->isIntegerTy(32) && 269 FTy->getParamType(1)->isPointerTy()) { 270 int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr; 271 272 // Call the function. 273 GenericValue rv; 274 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 275 (char **)GVTOP(ArgValues[1]))); 276 return rv; 277 } 278 break; 279 case 1: 280 if (FTy->getParamType(0)->isIntegerTy(32)) { 281 GenericValue rv; 282 int (*PF)(int) = (int(*)(int))(intptr_t)FPtr; 283 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue())); 284 return rv; 285 } 286 if (FTy->getParamType(0)->isPointerTy()) { 287 GenericValue rv; 288 int (*PF)(char *) = (int(*)(char *))(intptr_t)FPtr; 289 rv.IntVal = APInt(32, PF((char*)GVTOP(ArgValues[0]))); 290 return rv; 291 } 292 break; 293 } 294 } 295 296 // Handle cases where no arguments are passed first. 297 if (ArgValues.empty()) { 298 GenericValue rv; 299 switch (RetTy->getTypeID()) { 300 default: llvm_unreachable("Unknown return type for function call!"); 301 case Type::IntegerTyID: { 302 unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth(); 303 if (BitWidth == 1) 304 rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)()); 305 else if (BitWidth <= 8) 306 rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)()); 307 else if (BitWidth <= 16) 308 rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)()); 309 else if (BitWidth <= 32) 310 rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)()); 311 else if (BitWidth <= 64) 312 rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)()); 313 else 314 llvm_unreachable("Integer types > 64 bits not supported"); 315 return rv; 316 } 317 case Type::VoidTyID: 318 rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)()); 319 return rv; 320 case Type::FloatTyID: 321 rv.FloatVal = ((float(*)())(intptr_t)FPtr)(); 322 return rv; 323 case Type::DoubleTyID: 324 rv.DoubleVal = ((double(*)())(intptr_t)FPtr)(); 325 return rv; 326 case Type::X86_FP80TyID: 327 case Type::FP128TyID: 328 case Type::PPC_FP128TyID: 329 llvm_unreachable("long double not supported yet"); 330 case Type::PointerTyID: 331 return PTOGV(((void*(*)())(intptr_t)FPtr)()); 332 } 333 } 334 335 // Okay, this is not one of our quick and easy cases. Because we don't have a 336 // full FFI, we have to codegen a nullary stub function that just calls the 337 // function we are interested in, passing in constants for all of the 338 // arguments. Make this function and return. 339 340 // First, create the function. 341 FunctionType *STy=FunctionType::get(RetTy, false); 342 Function *Stub = Function::Create(STy, Function::InternalLinkage, "", 343 F->getParent()); 344 345 // Insert a basic block. 346 BasicBlock *StubBB = BasicBlock::Create(F->getContext(), "", Stub); 347 348 // Convert all of the GenericValue arguments over to constants. Note that we 349 // currently don't support varargs. 350 SmallVector<Value*, 8> Args; 351 for (unsigned i = 0, e = ArgValues.size(); i != e; ++i) { 352 Constant *C = 0; 353 Type *ArgTy = FTy->getParamType(i); 354 const GenericValue &AV = ArgValues[i]; 355 switch (ArgTy->getTypeID()) { 356 default: llvm_unreachable("Unknown argument type for function call!"); 357 case Type::IntegerTyID: 358 C = ConstantInt::get(F->getContext(), AV.IntVal); 359 break; 360 case Type::FloatTyID: 361 C = ConstantFP::get(F->getContext(), APFloat(AV.FloatVal)); 362 break; 363 case Type::DoubleTyID: 364 C = ConstantFP::get(F->getContext(), APFloat(AV.DoubleVal)); 365 break; 366 case Type::PPC_FP128TyID: 367 case Type::X86_FP80TyID: 368 case Type::FP128TyID: 369 C = ConstantFP::get(F->getContext(), APFloat(ArgTy->getFltSemantics(), 370 AV.IntVal)); 371 break; 372 case Type::PointerTyID: 373 void *ArgPtr = GVTOP(AV); 374 if (sizeof(void*) == 4) 375 C = ConstantInt::get(Type::getInt32Ty(F->getContext()), 376 (int)(intptr_t)ArgPtr); 377 else 378 C = ConstantInt::get(Type::getInt64Ty(F->getContext()), 379 (intptr_t)ArgPtr); 380 // Cast the integer to pointer 381 C = ConstantExpr::getIntToPtr(C, ArgTy); 382 break; 383 } 384 Args.push_back(C); 385 } 386 387 CallInst *TheCall = CallInst::Create(F, Args, "", StubBB); 388 TheCall->setCallingConv(F->getCallingConv()); 389 TheCall->setTailCall(); 390 if (!TheCall->getType()->isVoidTy()) 391 // Return result of the call. 392 ReturnInst::Create(F->getContext(), TheCall, StubBB); 393 else 394 ReturnInst::Create(F->getContext(), StubBB); // Just return void. 395 396 // Finally, call our nullary stub function. 397 GenericValue Result = runFunction(Stub, std::vector<GenericValue>()); 398 // Erase it, since no other function can have a reference to it. 399 Stub->eraseFromParent(); 400 // And return the result. 401 return Result; 402} 403 404void JIT::RegisterJITEventListener(JITEventListener *L) { 405 if (L == NULL) 406 return; 407 MutexGuard locked(lock); 408 EventListeners.push_back(L); 409} 410void JIT::UnregisterJITEventListener(JITEventListener *L) { 411 if (L == NULL) 412 return; 413 MutexGuard locked(lock); 414 std::vector<JITEventListener*>::reverse_iterator I= 415 std::find(EventListeners.rbegin(), EventListeners.rend(), L); 416 if (I != EventListeners.rend()) { 417 std::swap(*I, EventListeners.back()); 418 EventListeners.pop_back(); 419 } 420} 421void JIT::NotifyFunctionEmitted( 422 const Function &F, 423 void *Code, size_t Size, 424 const JITEvent_EmittedFunctionDetails &Details) { 425 MutexGuard locked(lock); 426 for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) { 427 EventListeners[I]->NotifyFunctionEmitted(F, Code, Size, Details); 428 } 429} 430 431void JIT::NotifyFreeingMachineCode(void *OldPtr) { 432 MutexGuard locked(lock); 433 for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) { 434 EventListeners[I]->NotifyFreeingMachineCode(OldPtr); 435 } 436} 437 438/// runJITOnFunction - Run the FunctionPassManager full of 439/// just-in-time compilation passes on F, hopefully filling in 440/// GlobalAddress[F] with the address of F's machine code. 441/// 442void JIT::runJITOnFunction(Function *F, MachineCodeInfo *MCI) { 443 MutexGuard locked(lock); 444 445 class MCIListener : public JITEventListener { 446 MachineCodeInfo *const MCI; 447 public: 448 MCIListener(MachineCodeInfo *mci) : MCI(mci) {} 449 virtual void NotifyFunctionEmitted(const Function &, 450 void *Code, size_t Size, 451 const EmittedFunctionDetails &) { 452 MCI->setAddress(Code); 453 MCI->setSize(Size); 454 } 455 }; 456 MCIListener MCIL(MCI); 457 if (MCI) 458 RegisterJITEventListener(&MCIL); 459 460 runJITOnFunctionUnlocked(F, locked); 461 462 if (MCI) 463 UnregisterJITEventListener(&MCIL); 464} 465 466void JIT::runJITOnFunctionUnlocked(Function *F, const MutexGuard &locked) { 467 assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!"); 468 469 jitTheFunction(F, locked); 470 471 // If the function referred to another function that had not yet been 472 // read from bitcode, and we are jitting non-lazily, emit it now. 473 while (!jitstate->getPendingFunctions(locked).empty()) { 474 Function *PF = jitstate->getPendingFunctions(locked).back(); 475 jitstate->getPendingFunctions(locked).pop_back(); 476 477 assert(!PF->hasAvailableExternallyLinkage() && 478 "Externally-defined function should not be in pending list."); 479 480 jitTheFunction(PF, locked); 481 482 // Now that the function has been jitted, ask the JITEmitter to rewrite 483 // the stub with real address of the function. 484 updateFunctionStub(PF); 485 } 486} 487 488void JIT::jitTheFunction(Function *F, const MutexGuard &locked) { 489 isAlreadyCodeGenerating = true; 490 jitstate->getPM(locked).run(*F); 491 isAlreadyCodeGenerating = false; 492 493 // clear basic block addresses after this function is done 494 getBasicBlockAddressMap(locked).clear(); 495} 496 497/// getPointerToFunction - This method is used to get the address of the 498/// specified function, compiling it if necessary. 499/// 500void *JIT::getPointerToFunction(Function *F) { 501 502 if (void *Addr = getPointerToGlobalIfAvailable(F)) 503 return Addr; // Check if function already code gen'd 504 505 MutexGuard locked(lock); 506 507 // Now that this thread owns the lock, make sure we read in the function if it 508 // exists in this Module. 509 std::string ErrorMsg; 510 if (F->Materialize(&ErrorMsg)) { 511 report_fatal_error("Error reading function '" + F->getName()+ 512 "' from bitcode file: " + ErrorMsg); 513 } 514 515 // ... and check if another thread has already code gen'd the function. 516 if (void *Addr = getPointerToGlobalIfAvailable(F)) 517 return Addr; 518 519 if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) { 520 bool AbortOnFailure = !F->hasExternalWeakLinkage(); 521 void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure); 522 addGlobalMapping(F, Addr); 523 return Addr; 524 } 525 526 runJITOnFunctionUnlocked(F, locked); 527 528 void *Addr = getPointerToGlobalIfAvailable(F); 529 assert(Addr && "Code generation didn't add function to GlobalAddress table!"); 530 return Addr; 531} 532 533void JIT::addPointerToBasicBlock(const BasicBlock *BB, void *Addr) { 534 MutexGuard locked(lock); 535 536 BasicBlockAddressMapTy::iterator I = 537 getBasicBlockAddressMap(locked).find(BB); 538 if (I == getBasicBlockAddressMap(locked).end()) { 539 getBasicBlockAddressMap(locked)[BB] = Addr; 540 } else { 541 // ignore repeats: some BBs can be split into few MBBs? 542 } 543} 544 545void JIT::clearPointerToBasicBlock(const BasicBlock *BB) { 546 MutexGuard locked(lock); 547 getBasicBlockAddressMap(locked).erase(BB); 548} 549 550void *JIT::getPointerToBasicBlock(BasicBlock *BB) { 551 // make sure it's function is compiled by JIT 552 (void)getPointerToFunction(BB->getParent()); 553 554 // resolve basic block address 555 MutexGuard locked(lock); 556 557 BasicBlockAddressMapTy::iterator I = 558 getBasicBlockAddressMap(locked).find(BB); 559 if (I != getBasicBlockAddressMap(locked).end()) { 560 return I->second; 561 } else { 562 llvm_unreachable("JIT does not have BB address for address-of-label, was" 563 " it eliminated by optimizer?"); 564 } 565} 566 567void *JIT::getPointerToNamedFunction(const std::string &Name, 568 bool AbortOnFailure){ 569 if (!isSymbolSearchingDisabled()) { 570 void *ptr = JMM->getPointerToNamedFunction(Name, false); 571 if (ptr) 572 return ptr; 573 } 574 575 /// If a LazyFunctionCreator is installed, use it to get/create the function. 576 if (LazyFunctionCreator) 577 if (void *RP = LazyFunctionCreator(Name)) 578 return RP; 579 580 if (AbortOnFailure) { 581 report_fatal_error("Program used external function '"+Name+ 582 "' which could not be resolved!"); 583 } 584 return 0; 585} 586 587 588/// getOrEmitGlobalVariable - Return the address of the specified global 589/// variable, possibly emitting it to memory if needed. This is used by the 590/// Emitter. 591void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) { 592 MutexGuard locked(lock); 593 594 void *Ptr = getPointerToGlobalIfAvailable(GV); 595 if (Ptr) return Ptr; 596 597 // If the global is external, just remember the address. 598 if (GV->isDeclaration() || GV->hasAvailableExternallyLinkage()) { 599#if HAVE___DSO_HANDLE 600 if (GV->getName() == "__dso_handle") 601 return (void*)&__dso_handle; 602#endif 603 Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(GV->getName()); 604 if (Ptr == 0) { 605 report_fatal_error("Could not resolve external global address: " 606 +GV->getName()); 607 } 608 addGlobalMapping(GV, Ptr); 609 } else { 610 // If the global hasn't been emitted to memory yet, allocate space and 611 // emit it into memory. 612 Ptr = getMemoryForGV(GV); 613 addGlobalMapping(GV, Ptr); 614 EmitGlobalVariable(GV); // Initialize the variable. 615 } 616 return Ptr; 617} 618 619/// recompileAndRelinkFunction - This method is used to force a function 620/// which has already been compiled, to be compiled again, possibly 621/// after it has been modified. Then the entry to the old copy is overwritten 622/// with a branch to the new copy. If there was no old copy, this acts 623/// just like JIT::getPointerToFunction(). 624/// 625void *JIT::recompileAndRelinkFunction(Function *F) { 626 void *OldAddr = getPointerToGlobalIfAvailable(F); 627 628 // If it's not already compiled there is no reason to patch it up. 629 if (OldAddr == 0) { return getPointerToFunction(F); } 630 631 // Delete the old function mapping. 632 addGlobalMapping(F, 0); 633 634 // Recodegen the function 635 runJITOnFunction(F); 636 637 // Update state, forward the old function to the new function. 638 void *Addr = getPointerToGlobalIfAvailable(F); 639 assert(Addr && "Code generation didn't add function to GlobalAddress table!"); 640 TJI.replaceMachineCodeForFunction(OldAddr, Addr); 641 return Addr; 642} 643 644/// getMemoryForGV - This method abstracts memory allocation of global 645/// variable so that the JIT can allocate thread local variables depending 646/// on the target. 647/// 648char* JIT::getMemoryForGV(const GlobalVariable* GV) { 649 char *Ptr; 650 651 // GlobalVariable's which are not "constant" will cause trouble in a server 652 // situation. It's returned in the same block of memory as code which may 653 // not be writable. 654 if (isGVCompilationDisabled() && !GV->isConstant()) { 655 report_fatal_error("Compilation of non-internal GlobalValue is disabled!"); 656 } 657 658 // Some applications require globals and code to live together, so they may 659 // be allocated into the same buffer, but in general globals are allocated 660 // through the memory manager which puts them near the code but not in the 661 // same buffer. 662 Type *GlobalType = GV->getType()->getElementType(); 663 size_t S = getDataLayout()->getTypeAllocSize(GlobalType); 664 size_t A = getDataLayout()->getPreferredAlignment(GV); 665 if (GV->isThreadLocal()) { 666 MutexGuard locked(lock); 667 Ptr = TJI.allocateThreadLocalMemory(S); 668 } else if (TJI.allocateSeparateGVMemory()) { 669 if (A <= 8) { 670 Ptr = (char*)malloc(S); 671 } else { 672 // Allocate S+A bytes of memory, then use an aligned pointer within that 673 // space. 674 Ptr = (char*)malloc(S+A); 675 unsigned MisAligned = ((intptr_t)Ptr & (A-1)); 676 Ptr = Ptr + (MisAligned ? (A-MisAligned) : 0); 677 } 678 } else if (AllocateGVsWithCode) { 679 Ptr = (char*)JCE->allocateSpace(S, A); 680 } else { 681 Ptr = (char*)JCE->allocateGlobal(S, A); 682 } 683 return Ptr; 684} 685 686void JIT::addPendingFunction(Function *F) { 687 MutexGuard locked(lock); 688 jitstate->getPendingFunctions(locked).push_back(F); 689} 690 691 692JITEventListener::~JITEventListener() {} 693