1 //===-- MCJIT.cpp - MC-based 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 #include "MCJIT.h" 11 #include "llvm/ExecutionEngine/GenericValue.h" 12 #include "llvm/ExecutionEngine/JITEventListener.h" 13 #include "llvm/ExecutionEngine/JITMemoryManager.h" 14 #include "llvm/ExecutionEngine/MCJIT.h" 15 #include "llvm/ExecutionEngine/ObjectBuffer.h" 16 #include "llvm/ExecutionEngine/ObjectImage.h" 17 #include "llvm/ExecutionEngine/SectionMemoryManager.h" 18 #include "llvm/IR/DataLayout.h" 19 #include "llvm/IR/DerivedTypes.h" 20 #include "llvm/IR/Function.h" 21 #include "llvm/IR/Mangler.h" 22 #include "llvm/IR/Module.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/Object/Archive.h" 25 #include "llvm/PassManager.h" 26 #include "llvm/Support/DynamicLibrary.h" 27 #include "llvm/Support/ErrorHandling.h" 28 #include "llvm/Support/MemoryBuffer.h" 29 #include "llvm/Support/MutexGuard.h" 30 #include "llvm/Target/TargetLowering.h" 31 32 using namespace llvm; 33 34 namespace { 35 36 static struct RegisterJIT { 37 RegisterJIT() { MCJIT::Register(); } 38 } JITRegistrator; 39 40 } 41 42 extern "C" void LLVMLinkInMCJIT() { 43 } 44 45 ExecutionEngine *MCJIT::createJIT(Module *M, 46 std::string *ErrorStr, 47 RTDyldMemoryManager *MemMgr, 48 bool GVsWithCode, 49 TargetMachine *TM) { 50 // Try to register the program as a source of symbols to resolve against. 51 // 52 // FIXME: Don't do this here. 53 sys::DynamicLibrary::LoadLibraryPermanently(nullptr, nullptr); 54 55 return new MCJIT(M, TM, MemMgr ? MemMgr : new SectionMemoryManager(), 56 GVsWithCode); 57 } 58 59 MCJIT::MCJIT(Module *m, TargetMachine *tm, RTDyldMemoryManager *MM, 60 bool AllocateGVsWithCode) 61 : ExecutionEngine(m), TM(tm), Ctx(nullptr), MemMgr(this, MM), Dyld(&MemMgr), 62 ObjCache(nullptr) { 63 64 OwnedModules.addModule(m); 65 setDataLayout(TM->getDataLayout()); 66 } 67 68 MCJIT::~MCJIT() { 69 MutexGuard locked(lock); 70 // FIXME: We are managing our modules, so we do not want the base class 71 // ExecutionEngine to manage them as well. To avoid double destruction 72 // of the first (and only) module added in ExecutionEngine constructor 73 // we remove it from EE and will destruct it ourselves. 74 // 75 // It may make sense to move our module manager (based on SmallStPtr) back 76 // into EE if the JIT and Interpreter can live with it. 77 // If so, additional functions: addModule, removeModule, FindFunctionNamed, 78 // runStaticConstructorsDestructors could be moved back to EE as well. 79 // 80 Modules.clear(); 81 Dyld.deregisterEHFrames(); 82 83 LoadedObjectList::iterator it, end; 84 for (it = LoadedObjects.begin(), end = LoadedObjects.end(); it != end; ++it) { 85 ObjectImage *Obj = *it; 86 if (Obj) { 87 NotifyFreeingObject(*Obj); 88 delete Obj; 89 } 90 } 91 LoadedObjects.clear(); 92 93 94 SmallVector<object::Archive *, 2>::iterator ArIt, ArEnd; 95 for (ArIt = Archives.begin(), ArEnd = Archives.end(); ArIt != ArEnd; ++ArIt) { 96 object::Archive *A = *ArIt; 97 delete A; 98 } 99 Archives.clear(); 100 101 delete TM; 102 } 103 104 void MCJIT::addModule(Module *M) { 105 MutexGuard locked(lock); 106 OwnedModules.addModule(M); 107 } 108 109 bool MCJIT::removeModule(Module *M) { 110 MutexGuard locked(lock); 111 return OwnedModules.removeModule(M); 112 } 113 114 115 116 void MCJIT::addObjectFile(std::unique_ptr<object::ObjectFile> Obj) { 117 ObjectImage *LoadedObject = Dyld.loadObject(std::move(Obj)); 118 if (!LoadedObject || Dyld.hasError()) 119 report_fatal_error(Dyld.getErrorString()); 120 121 LoadedObjects.push_back(LoadedObject); 122 123 NotifyObjectEmitted(*LoadedObject); 124 } 125 126 void MCJIT::addArchive(object::Archive *A) { 127 Archives.push_back(A); 128 } 129 130 131 void MCJIT::setObjectCache(ObjectCache* NewCache) { 132 MutexGuard locked(lock); 133 ObjCache = NewCache; 134 } 135 136 ObjectBufferStream* MCJIT::emitObject(Module *M) { 137 MutexGuard locked(lock); 138 139 // This must be a module which has already been added but not loaded to this 140 // MCJIT instance, since these conditions are tested by our caller, 141 // generateCodeForModule. 142 143 PassManager PM; 144 145 M->setDataLayout(TM->getDataLayout()); 146 PM.add(new DataLayoutPass(M)); 147 148 // The RuntimeDyld will take ownership of this shortly 149 std::unique_ptr<ObjectBufferStream> CompiledObject(new ObjectBufferStream()); 150 151 // Turn the machine code intermediate representation into bytes in memory 152 // that may be executed. 153 if (TM->addPassesToEmitMC(PM, Ctx, CompiledObject->getOStream(), 154 !getVerifyModules())) { 155 report_fatal_error("Target does not support MC emission!"); 156 } 157 158 // Initialize passes. 159 PM.run(*M); 160 // Flush the output buffer to get the generated code into memory 161 CompiledObject->flush(); 162 163 // If we have an object cache, tell it about the new object. 164 // Note that we're using the compiled image, not the loaded image (as below). 165 if (ObjCache) { 166 // MemoryBuffer is a thin wrapper around the actual memory, so it's OK 167 // to create a temporary object here and delete it after the call. 168 std::unique_ptr<MemoryBuffer> MB(CompiledObject->getMemBuffer()); 169 ObjCache->notifyObjectCompiled(M, MB.get()); 170 } 171 172 return CompiledObject.release(); 173 } 174 175 void MCJIT::generateCodeForModule(Module *M) { 176 // Get a thread lock to make sure we aren't trying to load multiple times 177 MutexGuard locked(lock); 178 179 // This must be a module which has already been added to this MCJIT instance. 180 assert(OwnedModules.ownsModule(M) && 181 "MCJIT::generateCodeForModule: Unknown module."); 182 183 // Re-compilation is not supported 184 if (OwnedModules.hasModuleBeenLoaded(M)) 185 return; 186 187 std::unique_ptr<ObjectBuffer> ObjectToLoad; 188 // Try to load the pre-compiled object from cache if possible 189 if (ObjCache) { 190 std::unique_ptr<MemoryBuffer> PreCompiledObject(ObjCache->getObject(M)); 191 if (PreCompiledObject.get()) 192 ObjectToLoad.reset(new ObjectBuffer(PreCompiledObject.release())); 193 } 194 195 // If the cache did not contain a suitable object, compile the object 196 if (!ObjectToLoad) { 197 ObjectToLoad.reset(emitObject(M)); 198 assert(ObjectToLoad.get() && "Compilation did not produce an object."); 199 } 200 201 // Load the object into the dynamic linker. 202 // MCJIT now owns the ObjectImage pointer (via its LoadedObjects list). 203 ObjectImage *LoadedObject = Dyld.loadObject(ObjectToLoad.release()); 204 LoadedObjects.push_back(LoadedObject); 205 if (!LoadedObject) 206 report_fatal_error(Dyld.getErrorString()); 207 208 // FIXME: Make this optional, maybe even move it to a JIT event listener 209 LoadedObject->registerWithDebugger(); 210 211 NotifyObjectEmitted(*LoadedObject); 212 213 OwnedModules.markModuleAsLoaded(M); 214 } 215 216 void MCJIT::finalizeLoadedModules() { 217 MutexGuard locked(lock); 218 219 // Resolve any outstanding relocations. 220 Dyld.resolveRelocations(); 221 222 OwnedModules.markAllLoadedModulesAsFinalized(); 223 224 // Register EH frame data for any module we own which has been loaded 225 Dyld.registerEHFrames(); 226 227 // Set page permissions. 228 MemMgr.finalizeMemory(); 229 } 230 231 // FIXME: Rename this. 232 void MCJIT::finalizeObject() { 233 MutexGuard locked(lock); 234 235 for (ModulePtrSet::iterator I = OwnedModules.begin_added(), 236 E = OwnedModules.end_added(); 237 I != E; ++I) { 238 Module *M = *I; 239 generateCodeForModule(M); 240 } 241 242 finalizeLoadedModules(); 243 } 244 245 void MCJIT::finalizeModule(Module *M) { 246 MutexGuard locked(lock); 247 248 // This must be a module which has already been added to this MCJIT instance. 249 assert(OwnedModules.ownsModule(M) && "MCJIT::finalizeModule: Unknown module."); 250 251 // If the module hasn't been compiled, just do that. 252 if (!OwnedModules.hasModuleBeenLoaded(M)) 253 generateCodeForModule(M); 254 255 finalizeLoadedModules(); 256 } 257 258 void *MCJIT::getPointerToBasicBlock(BasicBlock *BB) { 259 report_fatal_error("not yet implemented"); 260 } 261 262 uint64_t MCJIT::getExistingSymbolAddress(const std::string &Name) { 263 Mangler Mang(TM->getDataLayout()); 264 SmallString<128> FullName; 265 Mang.getNameWithPrefix(FullName, Name); 266 return Dyld.getSymbolLoadAddress(FullName); 267 } 268 269 Module *MCJIT::findModuleForSymbol(const std::string &Name, 270 bool CheckFunctionsOnly) { 271 MutexGuard locked(lock); 272 273 // If it hasn't already been generated, see if it's in one of our modules. 274 for (ModulePtrSet::iterator I = OwnedModules.begin_added(), 275 E = OwnedModules.end_added(); 276 I != E; ++I) { 277 Module *M = *I; 278 Function *F = M->getFunction(Name); 279 if (F && !F->isDeclaration()) 280 return M; 281 if (!CheckFunctionsOnly) { 282 GlobalVariable *G = M->getGlobalVariable(Name); 283 if (G && !G->isDeclaration()) 284 return M; 285 // FIXME: Do we need to worry about global aliases? 286 } 287 } 288 // We didn't find the symbol in any of our modules. 289 return nullptr; 290 } 291 292 uint64_t MCJIT::getSymbolAddress(const std::string &Name, 293 bool CheckFunctionsOnly) 294 { 295 MutexGuard locked(lock); 296 297 // First, check to see if we already have this symbol. 298 uint64_t Addr = getExistingSymbolAddress(Name); 299 if (Addr) 300 return Addr; 301 302 SmallVector<object::Archive*, 2>::iterator I, E; 303 for (I = Archives.begin(), E = Archives.end(); I != E; ++I) { 304 object::Archive *A = *I; 305 // Look for our symbols in each Archive 306 object::Archive::child_iterator ChildIt = A->findSym(Name); 307 if (ChildIt != A->child_end()) { 308 // FIXME: Support nested archives? 309 ErrorOr<std::unique_ptr<object::Binary>> ChildBinOrErr = 310 ChildIt->getAsBinary(); 311 if (ChildBinOrErr.getError()) 312 continue; 313 std::unique_ptr<object::Binary> ChildBin = std::move(ChildBinOrErr.get()); 314 if (ChildBin->isObject()) { 315 std::unique_ptr<object::ObjectFile> OF( 316 static_cast<object::ObjectFile *>(ChildBin.release())); 317 // This causes the object file to be loaded. 318 addObjectFile(std::move(OF)); 319 // The address should be here now. 320 Addr = getExistingSymbolAddress(Name); 321 if (Addr) 322 return Addr; 323 } 324 } 325 } 326 327 // If it hasn't already been generated, see if it's in one of our modules. 328 Module *M = findModuleForSymbol(Name, CheckFunctionsOnly); 329 if (!M) 330 return 0; 331 332 generateCodeForModule(M); 333 334 // Check the RuntimeDyld table again, it should be there now. 335 return getExistingSymbolAddress(Name); 336 } 337 338 uint64_t MCJIT::getGlobalValueAddress(const std::string &Name) { 339 MutexGuard locked(lock); 340 uint64_t Result = getSymbolAddress(Name, false); 341 if (Result != 0) 342 finalizeLoadedModules(); 343 return Result; 344 } 345 346 uint64_t MCJIT::getFunctionAddress(const std::string &Name) { 347 MutexGuard locked(lock); 348 uint64_t Result = getSymbolAddress(Name, true); 349 if (Result != 0) 350 finalizeLoadedModules(); 351 return Result; 352 } 353 354 // Deprecated. Use getFunctionAddress instead. 355 void *MCJIT::getPointerToFunction(Function *F) { 356 MutexGuard locked(lock); 357 358 if (F->isDeclaration() || F->hasAvailableExternallyLinkage()) { 359 bool AbortOnFailure = !F->hasExternalWeakLinkage(); 360 void *Addr = getPointerToNamedFunction(F->getName(), AbortOnFailure); 361 addGlobalMapping(F, Addr); 362 return Addr; 363 } 364 365 Module *M = F->getParent(); 366 bool HasBeenAddedButNotLoaded = OwnedModules.hasModuleBeenAddedButNotLoaded(M); 367 368 // Make sure the relevant module has been compiled and loaded. 369 if (HasBeenAddedButNotLoaded) 370 generateCodeForModule(M); 371 else if (!OwnedModules.hasModuleBeenLoaded(M)) 372 // If this function doesn't belong to one of our modules, we're done. 373 return nullptr; 374 375 // FIXME: Should the Dyld be retaining module information? Probably not. 376 // 377 // This is the accessor for the target address, so make sure to check the 378 // load address of the symbol, not the local address. 379 Mangler Mang(TM->getDataLayout()); 380 SmallString<128> Name; 381 TM->getNameWithPrefix(Name, F, Mang); 382 return (void*)Dyld.getSymbolLoadAddress(Name); 383 } 384 385 void *MCJIT::recompileAndRelinkFunction(Function *F) { 386 report_fatal_error("not yet implemented"); 387 } 388 389 void MCJIT::freeMachineCodeForFunction(Function *F) { 390 report_fatal_error("not yet implemented"); 391 } 392 393 void MCJIT::runStaticConstructorsDestructorsInModulePtrSet( 394 bool isDtors, ModulePtrSet::iterator I, ModulePtrSet::iterator E) { 395 for (; I != E; ++I) { 396 ExecutionEngine::runStaticConstructorsDestructors(*I, isDtors); 397 } 398 } 399 400 void MCJIT::runStaticConstructorsDestructors(bool isDtors) { 401 // Execute global ctors/dtors for each module in the program. 402 runStaticConstructorsDestructorsInModulePtrSet( 403 isDtors, OwnedModules.begin_added(), OwnedModules.end_added()); 404 runStaticConstructorsDestructorsInModulePtrSet( 405 isDtors, OwnedModules.begin_loaded(), OwnedModules.end_loaded()); 406 runStaticConstructorsDestructorsInModulePtrSet( 407 isDtors, OwnedModules.begin_finalized(), OwnedModules.end_finalized()); 408 } 409 410 Function *MCJIT::FindFunctionNamedInModulePtrSet(const char *FnName, 411 ModulePtrSet::iterator I, 412 ModulePtrSet::iterator E) { 413 for (; I != E; ++I) { 414 if (Function *F = (*I)->getFunction(FnName)) 415 return F; 416 } 417 return nullptr; 418 } 419 420 Function *MCJIT::FindFunctionNamed(const char *FnName) { 421 Function *F = FindFunctionNamedInModulePtrSet( 422 FnName, OwnedModules.begin_added(), OwnedModules.end_added()); 423 if (!F) 424 F = FindFunctionNamedInModulePtrSet(FnName, OwnedModules.begin_loaded(), 425 OwnedModules.end_loaded()); 426 if (!F) 427 F = FindFunctionNamedInModulePtrSet(FnName, OwnedModules.begin_finalized(), 428 OwnedModules.end_finalized()); 429 return F; 430 } 431 432 GenericValue MCJIT::runFunction(Function *F, 433 const std::vector<GenericValue> &ArgValues) { 434 assert(F && "Function *F was null at entry to run()"); 435 436 void *FPtr = getPointerToFunction(F); 437 assert(FPtr && "Pointer to fn's code was null after getPointerToFunction"); 438 FunctionType *FTy = F->getFunctionType(); 439 Type *RetTy = FTy->getReturnType(); 440 441 assert((FTy->getNumParams() == ArgValues.size() || 442 (FTy->isVarArg() && FTy->getNumParams() <= ArgValues.size())) && 443 "Wrong number of arguments passed into function!"); 444 assert(FTy->getNumParams() == ArgValues.size() && 445 "This doesn't support passing arguments through varargs (yet)!"); 446 447 // Handle some common cases first. These cases correspond to common `main' 448 // prototypes. 449 if (RetTy->isIntegerTy(32) || RetTy->isVoidTy()) { 450 switch (ArgValues.size()) { 451 case 3: 452 if (FTy->getParamType(0)->isIntegerTy(32) && 453 FTy->getParamType(1)->isPointerTy() && 454 FTy->getParamType(2)->isPointerTy()) { 455 int (*PF)(int, char **, const char **) = 456 (int(*)(int, char **, const char **))(intptr_t)FPtr; 457 458 // Call the function. 459 GenericValue rv; 460 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 461 (char **)GVTOP(ArgValues[1]), 462 (const char **)GVTOP(ArgValues[2]))); 463 return rv; 464 } 465 break; 466 case 2: 467 if (FTy->getParamType(0)->isIntegerTy(32) && 468 FTy->getParamType(1)->isPointerTy()) { 469 int (*PF)(int, char **) = (int(*)(int, char **))(intptr_t)FPtr; 470 471 // Call the function. 472 GenericValue rv; 473 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(), 474 (char **)GVTOP(ArgValues[1]))); 475 return rv; 476 } 477 break; 478 case 1: 479 if (FTy->getNumParams() == 1 && 480 FTy->getParamType(0)->isIntegerTy(32)) { 481 GenericValue rv; 482 int (*PF)(int) = (int(*)(int))(intptr_t)FPtr; 483 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue())); 484 return rv; 485 } 486 break; 487 } 488 } 489 490 // Handle cases where no arguments are passed first. 491 if (ArgValues.empty()) { 492 GenericValue rv; 493 switch (RetTy->getTypeID()) { 494 default: llvm_unreachable("Unknown return type for function call!"); 495 case Type::IntegerTyID: { 496 unsigned BitWidth = cast<IntegerType>(RetTy)->getBitWidth(); 497 if (BitWidth == 1) 498 rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)()); 499 else if (BitWidth <= 8) 500 rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)()); 501 else if (BitWidth <= 16) 502 rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)()); 503 else if (BitWidth <= 32) 504 rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)()); 505 else if (BitWidth <= 64) 506 rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)()); 507 else 508 llvm_unreachable("Integer types > 64 bits not supported"); 509 return rv; 510 } 511 case Type::VoidTyID: 512 rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)()); 513 return rv; 514 case Type::FloatTyID: 515 rv.FloatVal = ((float(*)())(intptr_t)FPtr)(); 516 return rv; 517 case Type::DoubleTyID: 518 rv.DoubleVal = ((double(*)())(intptr_t)FPtr)(); 519 return rv; 520 case Type::X86_FP80TyID: 521 case Type::FP128TyID: 522 case Type::PPC_FP128TyID: 523 llvm_unreachable("long double not supported yet"); 524 case Type::PointerTyID: 525 return PTOGV(((void*(*)())(intptr_t)FPtr)()); 526 } 527 } 528 529 llvm_unreachable("Full-featured argument passing not supported yet!"); 530 } 531 532 void *MCJIT::getPointerToNamedFunction(const std::string &Name, 533 bool AbortOnFailure) { 534 if (!isSymbolSearchingDisabled()) { 535 void *ptr = MemMgr.getPointerToNamedFunction(Name, false); 536 if (ptr) 537 return ptr; 538 } 539 540 /// If a LazyFunctionCreator is installed, use it to get/create the function. 541 if (LazyFunctionCreator) 542 if (void *RP = LazyFunctionCreator(Name)) 543 return RP; 544 545 if (AbortOnFailure) { 546 report_fatal_error("Program used external function '"+Name+ 547 "' which could not be resolved!"); 548 } 549 return nullptr; 550 } 551 552 void MCJIT::RegisterJITEventListener(JITEventListener *L) { 553 if (!L) 554 return; 555 MutexGuard locked(lock); 556 EventListeners.push_back(L); 557 } 558 void MCJIT::UnregisterJITEventListener(JITEventListener *L) { 559 if (!L) 560 return; 561 MutexGuard locked(lock); 562 SmallVector<JITEventListener*, 2>::reverse_iterator I= 563 std::find(EventListeners.rbegin(), EventListeners.rend(), L); 564 if (I != EventListeners.rend()) { 565 std::swap(*I, EventListeners.back()); 566 EventListeners.pop_back(); 567 } 568 } 569 void MCJIT::NotifyObjectEmitted(const ObjectImage& Obj) { 570 MutexGuard locked(lock); 571 MemMgr.notifyObjectLoaded(this, &Obj); 572 for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) { 573 EventListeners[I]->NotifyObjectEmitted(Obj); 574 } 575 } 576 void MCJIT::NotifyFreeingObject(const ObjectImage& Obj) { 577 MutexGuard locked(lock); 578 for (unsigned I = 0, S = EventListeners.size(); I < S; ++I) { 579 EventListeners[I]->NotifyFreeingObject(Obj); 580 } 581 } 582 583 uint64_t LinkingMemoryManager::getSymbolAddress(const std::string &Name) { 584 uint64_t Result = ParentEngine->getSymbolAddress(Name, false); 585 // If the symbols wasn't found and it begins with an underscore, try again 586 // without the underscore. 587 if (!Result && Name[0] == '_') 588 Result = ParentEngine->getSymbolAddress(Name.substr(1), false); 589 if (Result) 590 return Result; 591 return ClientMM->getSymbolAddress(Name); 592 } 593