1 //===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // Implementation of the MC-JIT runtime dynamic linker. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/ExecutionEngine/RuntimeDyld.h" 14 #include "RuntimeDyldCOFF.h" 15 #include "RuntimeDyldELF.h" 16 #include "RuntimeDyldImpl.h" 17 #include "RuntimeDyldMachO.h" 18 #include "llvm/Object/COFF.h" 19 #include "llvm/Object/ELFObjectFile.h" 20 #include "llvm/Support/Alignment.h" 21 #include "llvm/Support/MSVCErrorWorkarounds.h" 22 #include "llvm/Support/ManagedStatic.h" 23 #include "llvm/Support/MathExtras.h" 24 #include <mutex> 25 26 #include <future> 27 28 using namespace llvm; 29 using namespace llvm::object; 30 31 #define DEBUG_TYPE "dyld" 32 33 namespace { 34 35 enum RuntimeDyldErrorCode { 36 GenericRTDyldError = 1 37 }; 38 39 // FIXME: This class is only here to support the transition to llvm::Error. It 40 // will be removed once this transition is complete. Clients should prefer to 41 // deal with the Error value directly, rather than converting to error_code. 42 class RuntimeDyldErrorCategory : public std::error_category { 43 public: 44 const char *name() const noexcept override { return "runtimedyld"; } 45 46 std::string message(int Condition) const override { 47 switch (static_cast<RuntimeDyldErrorCode>(Condition)) { 48 case GenericRTDyldError: return "Generic RuntimeDyld error"; 49 } 50 llvm_unreachable("Unrecognized RuntimeDyldErrorCode"); 51 } 52 }; 53 54 static ManagedStatic<RuntimeDyldErrorCategory> RTDyldErrorCategory; 55 56 } 57 58 char RuntimeDyldError::ID = 0; 59 60 void RuntimeDyldError::log(raw_ostream &OS) const { 61 OS << ErrMsg << "\n"; 62 } 63 64 std::error_code RuntimeDyldError::convertToErrorCode() const { 65 return std::error_code(GenericRTDyldError, *RTDyldErrorCategory); 66 } 67 68 // Empty out-of-line virtual destructor as the key function. 69 RuntimeDyldImpl::~RuntimeDyldImpl() {} 70 71 // Pin LoadedObjectInfo's vtables to this file. 72 void RuntimeDyld::LoadedObjectInfo::anchor() {} 73 74 namespace llvm { 75 76 void RuntimeDyldImpl::registerEHFrames() {} 77 78 void RuntimeDyldImpl::deregisterEHFrames() { 79 MemMgr.deregisterEHFrames(); 80 } 81 82 #ifndef NDEBUG 83 static void dumpSectionMemory(const SectionEntry &S, StringRef State) { 84 dbgs() << "----- Contents of section " << S.getName() << " " << State 85 << " -----"; 86 87 if (S.getAddress() == nullptr) { 88 dbgs() << "\n <section not emitted>\n"; 89 return; 90 } 91 92 const unsigned ColsPerRow = 16; 93 94 uint8_t *DataAddr = S.getAddress(); 95 uint64_t LoadAddr = S.getLoadAddress(); 96 97 unsigned StartPadding = LoadAddr & (ColsPerRow - 1); 98 unsigned BytesRemaining = S.getSize(); 99 100 if (StartPadding) { 101 dbgs() << "\n" << format("0x%016" PRIx64, 102 LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":"; 103 while (StartPadding--) 104 dbgs() << " "; 105 } 106 107 while (BytesRemaining > 0) { 108 if ((LoadAddr & (ColsPerRow - 1)) == 0) 109 dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":"; 110 111 dbgs() << " " << format("%02x", *DataAddr); 112 113 ++DataAddr; 114 ++LoadAddr; 115 --BytesRemaining; 116 } 117 118 dbgs() << "\n"; 119 } 120 #endif 121 122 // Resolve the relocations for all symbols we currently know about. 123 void RuntimeDyldImpl::resolveRelocations() { 124 std::lock_guard<sys::Mutex> locked(lock); 125 126 // Print out the sections prior to relocation. 127 LLVM_DEBUG({ 128 for (SectionEntry &S : Sections) 129 dumpSectionMemory(S, "before relocations"); 130 }); 131 132 // First, resolve relocations associated with external symbols. 133 if (auto Err = resolveExternalSymbols()) { 134 HasError = true; 135 ErrorStr = toString(std::move(Err)); 136 } 137 138 resolveLocalRelocations(); 139 140 // Print out sections after relocation. 141 LLVM_DEBUG({ 142 for (SectionEntry &S : Sections) 143 dumpSectionMemory(S, "after relocations"); 144 }); 145 } 146 147 void RuntimeDyldImpl::resolveLocalRelocations() { 148 // Iterate over all outstanding relocations 149 for (const auto &Rel : Relocations) { 150 // The Section here (Sections[i]) refers to the section in which the 151 // symbol for the relocation is located. The SectionID in the relocation 152 // entry provides the section to which the relocation will be applied. 153 unsigned Idx = Rel.first; 154 uint64_t Addr = getSectionLoadAddress(Idx); 155 LLVM_DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t" 156 << format("%p", (uintptr_t)Addr) << "\n"); 157 resolveRelocationList(Rel.second, Addr); 158 } 159 Relocations.clear(); 160 } 161 162 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress, 163 uint64_t TargetAddress) { 164 std::lock_guard<sys::Mutex> locked(lock); 165 for (unsigned i = 0, e = Sections.size(); i != e; ++i) { 166 if (Sections[i].getAddress() == LocalAddress) { 167 reassignSectionAddress(i, TargetAddress); 168 return; 169 } 170 } 171 llvm_unreachable("Attempting to remap address of unknown section!"); 172 } 173 174 static Error getOffset(const SymbolRef &Sym, SectionRef Sec, 175 uint64_t &Result) { 176 Expected<uint64_t> AddressOrErr = Sym.getAddress(); 177 if (!AddressOrErr) 178 return AddressOrErr.takeError(); 179 Result = *AddressOrErr - Sec.getAddress(); 180 return Error::success(); 181 } 182 183 Expected<RuntimeDyldImpl::ObjSectionToIDMap> 184 RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) { 185 std::lock_guard<sys::Mutex> locked(lock); 186 187 // Save information about our target 188 Arch = (Triple::ArchType)Obj.getArch(); 189 IsTargetLittleEndian = Obj.isLittleEndian(); 190 setMipsABI(Obj); 191 192 // Compute the memory size required to load all sections to be loaded 193 // and pass this information to the memory manager 194 if (MemMgr.needsToReserveAllocationSpace()) { 195 uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0; 196 uint32_t CodeAlign = 1, RODataAlign = 1, RWDataAlign = 1; 197 if (auto Err = computeTotalAllocSize(Obj, 198 CodeSize, CodeAlign, 199 RODataSize, RODataAlign, 200 RWDataSize, RWDataAlign)) 201 return std::move(Err); 202 MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign, 203 RWDataSize, RWDataAlign); 204 } 205 206 // Used sections from the object file 207 ObjSectionToIDMap LocalSections; 208 209 // Common symbols requiring allocation, with their sizes and alignments 210 CommonSymbolList CommonSymbolsToAllocate; 211 212 uint64_t CommonSize = 0; 213 uint32_t CommonAlign = 0; 214 215 // First, collect all weak and common symbols. We need to know if stronger 216 // definitions occur elsewhere. 217 JITSymbolResolver::LookupSet ResponsibilitySet; 218 { 219 JITSymbolResolver::LookupSet Symbols; 220 for (auto &Sym : Obj.symbols()) { 221 Expected<uint32_t> FlagsOrErr = Sym.getFlags(); 222 if (!FlagsOrErr) 223 // TODO: Test this error. 224 return FlagsOrErr.takeError(); 225 if ((*FlagsOrErr & SymbolRef::SF_Common) || 226 (*FlagsOrErr & SymbolRef::SF_Weak)) { 227 // Get symbol name. 228 if (auto NameOrErr = Sym.getName()) 229 Symbols.insert(*NameOrErr); 230 else 231 return NameOrErr.takeError(); 232 } 233 } 234 235 if (auto ResultOrErr = Resolver.getResponsibilitySet(Symbols)) 236 ResponsibilitySet = std::move(*ResultOrErr); 237 else 238 return ResultOrErr.takeError(); 239 } 240 241 // Parse symbols 242 LLVM_DEBUG(dbgs() << "Parse symbols:\n"); 243 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E; 244 ++I) { 245 Expected<uint32_t> FlagsOrErr = I->getFlags(); 246 if (!FlagsOrErr) 247 // TODO: Test this error. 248 return FlagsOrErr.takeError(); 249 250 // Skip undefined symbols. 251 if (*FlagsOrErr & SymbolRef::SF_Undefined) 252 continue; 253 254 // Get the symbol type. 255 object::SymbolRef::Type SymType; 256 if (auto SymTypeOrErr = I->getType()) 257 SymType = *SymTypeOrErr; 258 else 259 return SymTypeOrErr.takeError(); 260 261 // Get symbol name. 262 StringRef Name; 263 if (auto NameOrErr = I->getName()) 264 Name = *NameOrErr; 265 else 266 return NameOrErr.takeError(); 267 268 // Compute JIT symbol flags. 269 auto JITSymFlags = getJITSymbolFlags(*I); 270 if (!JITSymFlags) 271 return JITSymFlags.takeError(); 272 273 // If this is a weak definition, check to see if there's a strong one. 274 // If there is, skip this symbol (we won't be providing it: the strong 275 // definition will). If there's no strong definition, make this definition 276 // strong. 277 if (JITSymFlags->isWeak() || JITSymFlags->isCommon()) { 278 // First check whether there's already a definition in this instance. 279 if (GlobalSymbolTable.count(Name)) 280 continue; 281 282 // If we're not responsible for this symbol, skip it. 283 if (!ResponsibilitySet.count(Name)) 284 continue; 285 286 // Otherwise update the flags on the symbol to make this definition 287 // strong. 288 if (JITSymFlags->isWeak()) 289 *JITSymFlags &= ~JITSymbolFlags::Weak; 290 if (JITSymFlags->isCommon()) { 291 *JITSymFlags &= ~JITSymbolFlags::Common; 292 uint32_t Align = I->getAlignment(); 293 uint64_t Size = I->getCommonSize(); 294 if (!CommonAlign) 295 CommonAlign = Align; 296 CommonSize = alignTo(CommonSize, Align) + Size; 297 CommonSymbolsToAllocate.push_back(*I); 298 } 299 } 300 301 if (*FlagsOrErr & SymbolRef::SF_Absolute && 302 SymType != object::SymbolRef::ST_File) { 303 uint64_t Addr = 0; 304 if (auto AddrOrErr = I->getAddress()) 305 Addr = *AddrOrErr; 306 else 307 return AddrOrErr.takeError(); 308 309 unsigned SectionID = AbsoluteSymbolSection; 310 311 LLVM_DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name 312 << " SID: " << SectionID 313 << " Offset: " << format("%p", (uintptr_t)Addr) 314 << " flags: " << *FlagsOrErr << "\n"); 315 if (!Name.empty()) // Skip absolute symbol relocations. 316 GlobalSymbolTable[Name] = 317 SymbolTableEntry(SectionID, Addr, *JITSymFlags); 318 } else if (SymType == object::SymbolRef::ST_Function || 319 SymType == object::SymbolRef::ST_Data || 320 SymType == object::SymbolRef::ST_Unknown || 321 SymType == object::SymbolRef::ST_Other) { 322 323 section_iterator SI = Obj.section_end(); 324 if (auto SIOrErr = I->getSection()) 325 SI = *SIOrErr; 326 else 327 return SIOrErr.takeError(); 328 329 if (SI == Obj.section_end()) 330 continue; 331 332 // Get symbol offset. 333 uint64_t SectOffset; 334 if (auto Err = getOffset(*I, *SI, SectOffset)) 335 return std::move(Err); 336 337 bool IsCode = SI->isText(); 338 unsigned SectionID; 339 if (auto SectionIDOrErr = 340 findOrEmitSection(Obj, *SI, IsCode, LocalSections)) 341 SectionID = *SectionIDOrErr; 342 else 343 return SectionIDOrErr.takeError(); 344 345 LLVM_DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name 346 << " SID: " << SectionID 347 << " Offset: " << format("%p", (uintptr_t)SectOffset) 348 << " flags: " << *FlagsOrErr << "\n"); 349 if (!Name.empty()) // Skip absolute symbol relocations 350 GlobalSymbolTable[Name] = 351 SymbolTableEntry(SectionID, SectOffset, *JITSymFlags); 352 } 353 } 354 355 // Allocate common symbols 356 if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize, 357 CommonAlign)) 358 return std::move(Err); 359 360 // Parse and process relocations 361 LLVM_DEBUG(dbgs() << "Parse relocations:\n"); 362 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 363 SI != SE; ++SI) { 364 StubMap Stubs; 365 366 Expected<section_iterator> RelSecOrErr = SI->getRelocatedSection(); 367 if (!RelSecOrErr) 368 return RelSecOrErr.takeError(); 369 370 section_iterator RelocatedSection = *RelSecOrErr; 371 if (RelocatedSection == SE) 372 continue; 373 374 relocation_iterator I = SI->relocation_begin(); 375 relocation_iterator E = SI->relocation_end(); 376 377 if (I == E && !ProcessAllSections) 378 continue; 379 380 bool IsCode = RelocatedSection->isText(); 381 unsigned SectionID = 0; 382 if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode, 383 LocalSections)) 384 SectionID = *SectionIDOrErr; 385 else 386 return SectionIDOrErr.takeError(); 387 388 LLVM_DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n"); 389 390 for (; I != E;) 391 if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs)) 392 I = *IOrErr; 393 else 394 return IOrErr.takeError(); 395 396 // If there is a NotifyStubEmitted callback set, call it to register any 397 // stubs created for this section. 398 if (NotifyStubEmitted) { 399 StringRef FileName = Obj.getFileName(); 400 StringRef SectionName = Sections[SectionID].getName(); 401 for (auto &KV : Stubs) { 402 403 auto &VR = KV.first; 404 uint64_t StubAddr = KV.second; 405 406 // If this is a named stub, just call NotifyStubEmitted. 407 if (VR.SymbolName) { 408 NotifyStubEmitted(FileName, SectionName, VR.SymbolName, SectionID, 409 StubAddr); 410 continue; 411 } 412 413 // Otherwise we will have to try a reverse lookup on the globla symbol table. 414 for (auto &GSTMapEntry : GlobalSymbolTable) { 415 StringRef SymbolName = GSTMapEntry.first(); 416 auto &GSTEntry = GSTMapEntry.second; 417 if (GSTEntry.getSectionID() == VR.SectionID && 418 GSTEntry.getOffset() == VR.Offset) { 419 NotifyStubEmitted(FileName, SectionName, SymbolName, SectionID, 420 StubAddr); 421 break; 422 } 423 } 424 } 425 } 426 } 427 428 // Process remaining sections 429 if (ProcessAllSections) { 430 LLVM_DEBUG(dbgs() << "Process remaining sections:\n"); 431 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 432 SI != SE; ++SI) { 433 434 /* Ignore already loaded sections */ 435 if (LocalSections.find(*SI) != LocalSections.end()) 436 continue; 437 438 bool IsCode = SI->isText(); 439 if (auto SectionIDOrErr = 440 findOrEmitSection(Obj, *SI, IsCode, LocalSections)) 441 LLVM_DEBUG(dbgs() << "\tSectionID: " << (*SectionIDOrErr) << "\n"); 442 else 443 return SectionIDOrErr.takeError(); 444 } 445 } 446 447 // Give the subclasses a chance to tie-up any loose ends. 448 if (auto Err = finalizeLoad(Obj, LocalSections)) 449 return std::move(Err); 450 451 // for (auto E : LocalSections) 452 // llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n"; 453 454 return LocalSections; 455 } 456 457 // A helper method for computeTotalAllocSize. 458 // Computes the memory size required to allocate sections with the given sizes, 459 // assuming that all sections are allocated with the given alignment 460 static uint64_t 461 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes, 462 uint64_t Alignment) { 463 uint64_t TotalSize = 0; 464 for (uint64_t SectionSize : SectionSizes) { 465 uint64_t AlignedSize = 466 (SectionSize + Alignment - 1) / Alignment * Alignment; 467 TotalSize += AlignedSize; 468 } 469 return TotalSize; 470 } 471 472 static bool isRequiredForExecution(const SectionRef Section) { 473 const ObjectFile *Obj = Section.getObject(); 474 if (isa<object::ELFObjectFileBase>(Obj)) 475 return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC; 476 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) { 477 const coff_section *CoffSection = COFFObj->getCOFFSection(Section); 478 // Avoid loading zero-sized COFF sections. 479 // In PE files, VirtualSize gives the section size, and SizeOfRawData 480 // may be zero for sections with content. In Obj files, SizeOfRawData 481 // gives the section size, and VirtualSize is always zero. Hence 482 // the need to check for both cases below. 483 bool HasContent = 484 (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0); 485 bool IsDiscardable = 486 CoffSection->Characteristics & 487 (COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_LNK_INFO); 488 return HasContent && !IsDiscardable; 489 } 490 491 assert(isa<MachOObjectFile>(Obj)); 492 return true; 493 } 494 495 static bool isReadOnlyData(const SectionRef Section) { 496 const ObjectFile *Obj = Section.getObject(); 497 if (isa<object::ELFObjectFileBase>(Obj)) 498 return !(ELFSectionRef(Section).getFlags() & 499 (ELF::SHF_WRITE | ELF::SHF_EXECINSTR)); 500 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) 501 return ((COFFObj->getCOFFSection(Section)->Characteristics & 502 (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA 503 | COFF::IMAGE_SCN_MEM_READ 504 | COFF::IMAGE_SCN_MEM_WRITE)) 505 == 506 (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA 507 | COFF::IMAGE_SCN_MEM_READ)); 508 509 assert(isa<MachOObjectFile>(Obj)); 510 return false; 511 } 512 513 static bool isZeroInit(const SectionRef Section) { 514 const ObjectFile *Obj = Section.getObject(); 515 if (isa<object::ELFObjectFileBase>(Obj)) 516 return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS; 517 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) 518 return COFFObj->getCOFFSection(Section)->Characteristics & 519 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; 520 521 auto *MachO = cast<MachOObjectFile>(Obj); 522 unsigned SectionType = MachO->getSectionType(Section); 523 return SectionType == MachO::S_ZEROFILL || 524 SectionType == MachO::S_GB_ZEROFILL; 525 } 526 527 static bool isTLS(const SectionRef Section) { 528 const ObjectFile *Obj = Section.getObject(); 529 if (isa<object::ELFObjectFileBase>(Obj)) 530 return ELFSectionRef(Section).getFlags() & ELF::SHF_TLS; 531 return false; 532 } 533 534 // Compute an upper bound of the memory size that is required to load all 535 // sections 536 Error RuntimeDyldImpl::computeTotalAllocSize(const ObjectFile &Obj, 537 uint64_t &CodeSize, 538 uint32_t &CodeAlign, 539 uint64_t &RODataSize, 540 uint32_t &RODataAlign, 541 uint64_t &RWDataSize, 542 uint32_t &RWDataAlign) { 543 // Compute the size of all sections required for execution 544 std::vector<uint64_t> CodeSectionSizes; 545 std::vector<uint64_t> ROSectionSizes; 546 std::vector<uint64_t> RWSectionSizes; 547 548 // Collect sizes of all sections to be loaded; 549 // also determine the max alignment of all sections 550 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 551 SI != SE; ++SI) { 552 const SectionRef &Section = *SI; 553 554 bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections; 555 556 // Consider only the sections that are required to be loaded for execution 557 if (IsRequired) { 558 uint64_t DataSize = Section.getSize(); 559 uint64_t Alignment64 = Section.getAlignment(); 560 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL; 561 bool IsCode = Section.isText(); 562 bool IsReadOnly = isReadOnlyData(Section); 563 bool IsTLS = isTLS(Section); 564 565 Expected<StringRef> NameOrErr = Section.getName(); 566 if (!NameOrErr) 567 return NameOrErr.takeError(); 568 StringRef Name = *NameOrErr; 569 570 uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section); 571 572 uint64_t PaddingSize = 0; 573 if (Name == ".eh_frame") 574 PaddingSize += 4; 575 if (StubBufSize != 0) 576 PaddingSize += getStubAlignment() - 1; 577 578 uint64_t SectionSize = DataSize + PaddingSize + StubBufSize; 579 580 // The .eh_frame section (at least on Linux) needs an extra four bytes 581 // padded 582 // with zeroes added at the end. For MachO objects, this section has a 583 // slightly different name, so this won't have any effect for MachO 584 // objects. 585 if (Name == ".eh_frame") 586 SectionSize += 4; 587 588 if (!SectionSize) 589 SectionSize = 1; 590 591 if (IsCode) { 592 CodeAlign = std::max(CodeAlign, Alignment); 593 CodeSectionSizes.push_back(SectionSize); 594 } else if (IsReadOnly) { 595 RODataAlign = std::max(RODataAlign, Alignment); 596 ROSectionSizes.push_back(SectionSize); 597 } else if (!IsTLS) { 598 RWDataAlign = std::max(RWDataAlign, Alignment); 599 RWSectionSizes.push_back(SectionSize); 600 } 601 } 602 } 603 604 // Compute Global Offset Table size. If it is not zero we 605 // also update alignment, which is equal to a size of a 606 // single GOT entry. 607 if (unsigned GotSize = computeGOTSize(Obj)) { 608 RWSectionSizes.push_back(GotSize); 609 RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize()); 610 } 611 612 // Compute the size of all common symbols 613 uint64_t CommonSize = 0; 614 uint32_t CommonAlign = 1; 615 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E; 616 ++I) { 617 Expected<uint32_t> FlagsOrErr = I->getFlags(); 618 if (!FlagsOrErr) 619 // TODO: Test this error. 620 return FlagsOrErr.takeError(); 621 if (*FlagsOrErr & SymbolRef::SF_Common) { 622 // Add the common symbols to a list. We'll allocate them all below. 623 uint64_t Size = I->getCommonSize(); 624 uint32_t Align = I->getAlignment(); 625 // If this is the first common symbol, use its alignment as the alignment 626 // for the common symbols section. 627 if (CommonSize == 0) 628 CommonAlign = Align; 629 CommonSize = alignTo(CommonSize, Align) + Size; 630 } 631 } 632 if (CommonSize != 0) { 633 RWSectionSizes.push_back(CommonSize); 634 RWDataAlign = std::max(RWDataAlign, CommonAlign); 635 } 636 637 // Compute the required allocation space for each different type of sections 638 // (code, read-only data, read-write data) assuming that all sections are 639 // allocated with the max alignment. Note that we cannot compute with the 640 // individual alignments of the sections, because then the required size 641 // depends on the order, in which the sections are allocated. 642 CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign); 643 RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign); 644 RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign); 645 646 return Error::success(); 647 } 648 649 // compute GOT size 650 unsigned RuntimeDyldImpl::computeGOTSize(const ObjectFile &Obj) { 651 size_t GotEntrySize = getGOTEntrySize(); 652 if (!GotEntrySize) 653 return 0; 654 655 size_t GotSize = 0; 656 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 657 SI != SE; ++SI) { 658 659 for (const RelocationRef &Reloc : SI->relocations()) 660 if (relocationNeedsGot(Reloc)) 661 GotSize += GotEntrySize; 662 } 663 664 return GotSize; 665 } 666 667 // compute stub buffer size for the given section 668 unsigned RuntimeDyldImpl::computeSectionStubBufSize(const ObjectFile &Obj, 669 const SectionRef &Section) { 670 if (!MemMgr.allowStubAllocation()) { 671 return 0; 672 } 673 674 unsigned StubSize = getMaxStubSize(); 675 if (StubSize == 0) { 676 return 0; 677 } 678 // FIXME: this is an inefficient way to handle this. We should computed the 679 // necessary section allocation size in loadObject by walking all the sections 680 // once. 681 unsigned StubBufSize = 0; 682 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 683 SI != SE; ++SI) { 684 685 Expected<section_iterator> RelSecOrErr = SI->getRelocatedSection(); 686 if (!RelSecOrErr) 687 report_fatal_error(Twine(toString(RelSecOrErr.takeError()))); 688 689 section_iterator RelSecI = *RelSecOrErr; 690 if (!(RelSecI == Section)) 691 continue; 692 693 for (const RelocationRef &Reloc : SI->relocations()) 694 if (relocationNeedsStub(Reloc)) 695 StubBufSize += StubSize; 696 } 697 698 // Get section data size and alignment 699 uint64_t DataSize = Section.getSize(); 700 uint64_t Alignment64 = Section.getAlignment(); 701 702 // Add stubbuf size alignment 703 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL; 704 unsigned StubAlignment = getStubAlignment(); 705 unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment); 706 if (StubAlignment > EndAlignment) 707 StubBufSize += StubAlignment - EndAlignment; 708 return StubBufSize; 709 } 710 711 uint64_t RuntimeDyldImpl::readBytesUnaligned(uint8_t *Src, 712 unsigned Size) const { 713 uint64_t Result = 0; 714 if (IsTargetLittleEndian) { 715 Src += Size - 1; 716 while (Size--) 717 Result = (Result << 8) | *Src--; 718 } else 719 while (Size--) 720 Result = (Result << 8) | *Src++; 721 722 return Result; 723 } 724 725 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst, 726 unsigned Size) const { 727 if (IsTargetLittleEndian) { 728 while (Size--) { 729 *Dst++ = Value & 0xFF; 730 Value >>= 8; 731 } 732 } else { 733 Dst += Size - 1; 734 while (Size--) { 735 *Dst-- = Value & 0xFF; 736 Value >>= 8; 737 } 738 } 739 } 740 741 Expected<JITSymbolFlags> 742 RuntimeDyldImpl::getJITSymbolFlags(const SymbolRef &SR) { 743 return JITSymbolFlags::fromObjectSymbol(SR); 744 } 745 746 Error RuntimeDyldImpl::emitCommonSymbols(const ObjectFile &Obj, 747 CommonSymbolList &SymbolsToAllocate, 748 uint64_t CommonSize, 749 uint32_t CommonAlign) { 750 if (SymbolsToAllocate.empty()) 751 return Error::success(); 752 753 // Allocate memory for the section 754 unsigned SectionID = Sections.size(); 755 uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID, 756 "<common symbols>", false); 757 if (!Addr) 758 report_fatal_error("Unable to allocate memory for common symbols!"); 759 uint64_t Offset = 0; 760 Sections.push_back( 761 SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0)); 762 memset(Addr, 0, CommonSize); 763 764 LLVM_DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID 765 << " new addr: " << format("%p", Addr) 766 << " DataSize: " << CommonSize << "\n"); 767 768 // Assign the address of each symbol 769 for (auto &Sym : SymbolsToAllocate) { 770 uint32_t Alignment = Sym.getAlignment(); 771 uint64_t Size = Sym.getCommonSize(); 772 StringRef Name; 773 if (auto NameOrErr = Sym.getName()) 774 Name = *NameOrErr; 775 else 776 return NameOrErr.takeError(); 777 if (Alignment) { 778 // This symbol has an alignment requirement. 779 uint64_t AlignOffset = 780 offsetToAlignment((uint64_t)Addr, Align(Alignment)); 781 Addr += AlignOffset; 782 Offset += AlignOffset; 783 } 784 auto JITSymFlags = getJITSymbolFlags(Sym); 785 786 if (!JITSymFlags) 787 return JITSymFlags.takeError(); 788 789 LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address " 790 << format("%p", Addr) << "\n"); 791 if (!Name.empty()) // Skip absolute symbol relocations. 792 GlobalSymbolTable[Name] = 793 SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags)); 794 Offset += Size; 795 Addr += Size; 796 } 797 798 return Error::success(); 799 } 800 801 Expected<unsigned> 802 RuntimeDyldImpl::emitSection(const ObjectFile &Obj, 803 const SectionRef &Section, 804 bool IsCode) { 805 StringRef data; 806 uint64_t Alignment64 = Section.getAlignment(); 807 808 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL; 809 unsigned PaddingSize = 0; 810 unsigned StubBufSize = 0; 811 bool IsRequired = isRequiredForExecution(Section); 812 bool IsVirtual = Section.isVirtual(); 813 bool IsZeroInit = isZeroInit(Section); 814 bool IsReadOnly = isReadOnlyData(Section); 815 bool IsTLS = isTLS(Section); 816 uint64_t DataSize = Section.getSize(); 817 818 // An alignment of 0 (at least with ELF) is identical to an alignment of 1, 819 // while being more "polite". Other formats do not support 0-aligned sections 820 // anyway, so we should guarantee that the alignment is always at least 1. 821 Alignment = std::max(1u, Alignment); 822 823 Expected<StringRef> NameOrErr = Section.getName(); 824 if (!NameOrErr) 825 return NameOrErr.takeError(); 826 StringRef Name = *NameOrErr; 827 828 StubBufSize = computeSectionStubBufSize(Obj, Section); 829 830 // The .eh_frame section (at least on Linux) needs an extra four bytes padded 831 // with zeroes added at the end. For MachO objects, this section has a 832 // slightly different name, so this won't have any effect for MachO objects. 833 if (Name == ".eh_frame") 834 PaddingSize = 4; 835 836 uintptr_t Allocate; 837 unsigned SectionID = Sections.size(); 838 uint8_t *Addr; 839 uint64_t LoadAddress = 0; 840 const char *pData = nullptr; 841 842 // If this section contains any bits (i.e. isn't a virtual or bss section), 843 // grab a reference to them. 844 if (!IsVirtual && !IsZeroInit) { 845 // In either case, set the location of the unrelocated section in memory, 846 // since we still process relocations for it even if we're not applying them. 847 if (Expected<StringRef> E = Section.getContents()) 848 data = *E; 849 else 850 return E.takeError(); 851 pData = data.data(); 852 } 853 854 // If there are any stubs then the section alignment needs to be at least as 855 // high as stub alignment or padding calculations may by incorrect when the 856 // section is remapped. 857 if (StubBufSize != 0) { 858 Alignment = std::max(Alignment, getStubAlignment()); 859 PaddingSize += getStubAlignment() - 1; 860 } 861 862 // Some sections, such as debug info, don't need to be loaded for execution. 863 // Process those only if explicitly requested. 864 if (IsRequired || ProcessAllSections) { 865 Allocate = DataSize + PaddingSize + StubBufSize; 866 if (!Allocate) 867 Allocate = 1; 868 if (IsTLS) { 869 auto TLSSection = 870 MemMgr.allocateTLSSection(Allocate, Alignment, SectionID, Name); 871 Addr = TLSSection.InitializationImage; 872 LoadAddress = TLSSection.Offset; 873 } else if (IsCode) { 874 Addr = MemMgr.allocateCodeSection(Allocate, Alignment, SectionID, Name); 875 } else { 876 Addr = MemMgr.allocateDataSection(Allocate, Alignment, SectionID, Name, 877 IsReadOnly); 878 } 879 if (!Addr) 880 report_fatal_error("Unable to allocate section memory!"); 881 882 // Zero-initialize or copy the data from the image 883 if (IsZeroInit || IsVirtual) 884 memset(Addr, 0, DataSize); 885 else 886 memcpy(Addr, pData, DataSize); 887 888 // Fill in any extra bytes we allocated for padding 889 if (PaddingSize != 0) { 890 memset(Addr + DataSize, 0, PaddingSize); 891 // Update the DataSize variable to include padding. 892 DataSize += PaddingSize; 893 894 // Align DataSize to stub alignment if we have any stubs (PaddingSize will 895 // have been increased above to account for this). 896 if (StubBufSize > 0) 897 DataSize &= -(uint64_t)getStubAlignment(); 898 } 899 900 LLVM_DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " 901 << Name << " obj addr: " << format("%p", pData) 902 << " new addr: " << format("%p", Addr) << " DataSize: " 903 << DataSize << " StubBufSize: " << StubBufSize 904 << " Allocate: " << Allocate << "\n"); 905 } else { 906 // Even if we didn't load the section, we need to record an entry for it 907 // to handle later processing (and by 'handle' I mean don't do anything 908 // with these sections). 909 Allocate = 0; 910 Addr = nullptr; 911 LLVM_DEBUG( 912 dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name 913 << " obj addr: " << format("%p", data.data()) << " new addr: 0" 914 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize 915 << " Allocate: " << Allocate << "\n"); 916 } 917 918 Sections.push_back( 919 SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData)); 920 921 // The load address of a TLS section is not equal to the address of its 922 // initialization image 923 if (IsTLS) 924 Sections.back().setLoadAddress(LoadAddress); 925 // Debug info sections are linked as if their load address was zero 926 if (!IsRequired) 927 Sections.back().setLoadAddress(0); 928 929 return SectionID; 930 } 931 932 Expected<unsigned> 933 RuntimeDyldImpl::findOrEmitSection(const ObjectFile &Obj, 934 const SectionRef &Section, 935 bool IsCode, 936 ObjSectionToIDMap &LocalSections) { 937 938 unsigned SectionID = 0; 939 ObjSectionToIDMap::iterator i = LocalSections.find(Section); 940 if (i != LocalSections.end()) 941 SectionID = i->second; 942 else { 943 if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode)) 944 SectionID = *SectionIDOrErr; 945 else 946 return SectionIDOrErr.takeError(); 947 LocalSections[Section] = SectionID; 948 } 949 return SectionID; 950 } 951 952 void RuntimeDyldImpl::addRelocationForSection(const RelocationEntry &RE, 953 unsigned SectionID) { 954 Relocations[SectionID].push_back(RE); 955 } 956 957 void RuntimeDyldImpl::addRelocationForSymbol(const RelocationEntry &RE, 958 StringRef SymbolName) { 959 // Relocation by symbol. If the symbol is found in the global symbol table, 960 // create an appropriate section relocation. Otherwise, add it to 961 // ExternalSymbolRelocations. 962 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName); 963 if (Loc == GlobalSymbolTable.end()) { 964 ExternalSymbolRelocations[SymbolName].push_back(RE); 965 } else { 966 assert(!SymbolName.empty() && 967 "Empty symbol should not be in GlobalSymbolTable"); 968 // Copy the RE since we want to modify its addend. 969 RelocationEntry RECopy = RE; 970 const auto &SymInfo = Loc->second; 971 RECopy.Addend += SymInfo.getOffset(); 972 Relocations[SymInfo.getSectionID()].push_back(RECopy); 973 } 974 } 975 976 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr, 977 unsigned AbiVariant) { 978 if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be || 979 Arch == Triple::aarch64_32) { 980 // This stub has to be able to access the full address space, 981 // since symbol lookup won't necessarily find a handy, in-range, 982 // PLT stub for functions which could be anywhere. 983 // Stub can use ip0 (== x16) to calculate address 984 writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr> 985 writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr> 986 writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr> 987 writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr> 988 writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0 989 990 return Addr; 991 } else if (Arch == Triple::arm || Arch == Triple::armeb) { 992 // TODO: There is only ARM far stub now. We should add the Thumb stub, 993 // and stubs for branches Thumb - ARM and ARM - Thumb. 994 writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4] 995 return Addr + 4; 996 } else if (IsMipsO32ABI || IsMipsN32ABI) { 997 // 0: 3c190000 lui t9,%hi(addr). 998 // 4: 27390000 addiu t9,t9,%lo(addr). 999 // 8: 03200008 jr t9. 1000 // c: 00000000 nop. 1001 const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000; 1002 const unsigned NopInstr = 0x0; 1003 unsigned JrT9Instr = 0x03200008; 1004 if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 || 1005 (AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6) 1006 JrT9Instr = 0x03200009; 1007 1008 writeBytesUnaligned(LuiT9Instr, Addr, 4); 1009 writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4); 1010 writeBytesUnaligned(JrT9Instr, Addr + 8, 4); 1011 writeBytesUnaligned(NopInstr, Addr + 12, 4); 1012 return Addr; 1013 } else if (IsMipsN64ABI) { 1014 // 0: 3c190000 lui t9,%highest(addr). 1015 // 4: 67390000 daddiu t9,t9,%higher(addr). 1016 // 8: 0019CC38 dsll t9,t9,16. 1017 // c: 67390000 daddiu t9,t9,%hi(addr). 1018 // 10: 0019CC38 dsll t9,t9,16. 1019 // 14: 67390000 daddiu t9,t9,%lo(addr). 1020 // 18: 03200008 jr t9. 1021 // 1c: 00000000 nop. 1022 const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000, 1023 DsllT9Instr = 0x19CC38; 1024 const unsigned NopInstr = 0x0; 1025 unsigned JrT9Instr = 0x03200008; 1026 if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6) 1027 JrT9Instr = 0x03200009; 1028 1029 writeBytesUnaligned(LuiT9Instr, Addr, 4); 1030 writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4); 1031 writeBytesUnaligned(DsllT9Instr, Addr + 8, 4); 1032 writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4); 1033 writeBytesUnaligned(DsllT9Instr, Addr + 16, 4); 1034 writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4); 1035 writeBytesUnaligned(JrT9Instr, Addr + 24, 4); 1036 writeBytesUnaligned(NopInstr, Addr + 28, 4); 1037 return Addr; 1038 } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) { 1039 // Depending on which version of the ELF ABI is in use, we need to 1040 // generate one of two variants of the stub. They both start with 1041 // the same sequence to load the target address into r12. 1042 writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr) 1043 writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr) 1044 writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32 1045 writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr) 1046 writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr) 1047 if (AbiVariant == 2) { 1048 // PowerPC64 stub ELFv2 ABI: The address points to the function itself. 1049 // The address is already in r12 as required by the ABI. Branch to it. 1050 writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1) 1051 writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12 1052 writeInt32BE(Addr+28, 0x4E800420); // bctr 1053 } else { 1054 // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor. 1055 // Load the function address on r11 and sets it to control register. Also 1056 // loads the function TOC in r2 and environment pointer to r11. 1057 writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1) 1058 writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12) 1059 writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12) 1060 writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11 1061 writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2) 1062 writeInt32BE(Addr+40, 0x4E800420); // bctr 1063 } 1064 return Addr; 1065 } else if (Arch == Triple::systemz) { 1066 writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8 1067 writeInt16BE(Addr+2, 0x0000); 1068 writeInt16BE(Addr+4, 0x0004); 1069 writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1 1070 // 8-byte address stored at Addr + 8 1071 return Addr; 1072 } else if (Arch == Triple::x86_64) { 1073 *Addr = 0xFF; // jmp 1074 *(Addr+1) = 0x25; // rip 1075 // 32-bit PC-relative address of the GOT entry will be stored at Addr+2 1076 } else if (Arch == Triple::x86) { 1077 *Addr = 0xE9; // 32-bit pc-relative jump. 1078 } 1079 return Addr; 1080 } 1081 1082 // Assign an address to a symbol name and resolve all the relocations 1083 // associated with it. 1084 void RuntimeDyldImpl::reassignSectionAddress(unsigned SectionID, 1085 uint64_t Addr) { 1086 // The address to use for relocation resolution is not 1087 // the address of the local section buffer. We must be doing 1088 // a remote execution environment of some sort. Relocations can't 1089 // be applied until all the sections have been moved. The client must 1090 // trigger this with a call to MCJIT::finalize() or 1091 // RuntimeDyld::resolveRelocations(). 1092 // 1093 // Addr is a uint64_t because we can't assume the pointer width 1094 // of the target is the same as that of the host. Just use a generic 1095 // "big enough" type. 1096 LLVM_DEBUG( 1097 dbgs() << "Reassigning address for section " << SectionID << " (" 1098 << Sections[SectionID].getName() << "): " 1099 << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress()) 1100 << " -> " << format("0x%016" PRIx64, Addr) << "\n"); 1101 Sections[SectionID].setLoadAddress(Addr); 1102 } 1103 1104 void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs, 1105 uint64_t Value) { 1106 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) { 1107 const RelocationEntry &RE = Relocs[i]; 1108 // Ignore relocations for sections that were not loaded 1109 if (RE.SectionID != AbsoluteSymbolSection && 1110 Sections[RE.SectionID].getAddress() == nullptr) 1111 continue; 1112 resolveRelocation(RE, Value); 1113 } 1114 } 1115 1116 void RuntimeDyldImpl::applyExternalSymbolRelocations( 1117 const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) { 1118 for (auto &RelocKV : ExternalSymbolRelocations) { 1119 StringRef Name = RelocKV.first(); 1120 RelocationList &Relocs = RelocKV.second; 1121 if (Name.size() == 0) { 1122 // This is an absolute symbol, use an address of zero. 1123 LLVM_DEBUG(dbgs() << "Resolving absolute relocations." 1124 << "\n"); 1125 resolveRelocationList(Relocs, 0); 1126 } else { 1127 uint64_t Addr = 0; 1128 JITSymbolFlags Flags; 1129 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name); 1130 if (Loc == GlobalSymbolTable.end()) { 1131 auto RRI = ExternalSymbolMap.find(Name); 1132 assert(RRI != ExternalSymbolMap.end() && "No result for symbol"); 1133 Addr = RRI->second.getAddress(); 1134 Flags = RRI->second.getFlags(); 1135 } else { 1136 // We found the symbol in our global table. It was probably in a 1137 // Module that we loaded previously. 1138 const auto &SymInfo = Loc->second; 1139 Addr = getSectionLoadAddress(SymInfo.getSectionID()) + 1140 SymInfo.getOffset(); 1141 Flags = SymInfo.getFlags(); 1142 } 1143 1144 // FIXME: Implement error handling that doesn't kill the host program! 1145 if (!Addr && !Resolver.allowsZeroSymbols()) 1146 report_fatal_error(Twine("Program used external function '") + Name + 1147 "' which could not be resolved!"); 1148 1149 // If Resolver returned UINT64_MAX, the client wants to handle this symbol 1150 // manually and we shouldn't resolve its relocations. 1151 if (Addr != UINT64_MAX) { 1152 1153 // Tweak the address based on the symbol flags if necessary. 1154 // For example, this is used by RuntimeDyldMachOARM to toggle the low bit 1155 // if the target symbol is Thumb. 1156 Addr = modifyAddressBasedOnFlags(Addr, Flags); 1157 1158 LLVM_DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t" 1159 << format("0x%lx", Addr) << "\n"); 1160 resolveRelocationList(Relocs, Addr); 1161 } 1162 } 1163 } 1164 ExternalSymbolRelocations.clear(); 1165 } 1166 1167 Error RuntimeDyldImpl::resolveExternalSymbols() { 1168 StringMap<JITEvaluatedSymbol> ExternalSymbolMap; 1169 1170 // Resolution can trigger emission of more symbols, so iterate until 1171 // we've resolved *everything*. 1172 { 1173 JITSymbolResolver::LookupSet ResolvedSymbols; 1174 1175 while (true) { 1176 JITSymbolResolver::LookupSet NewSymbols; 1177 1178 for (auto &RelocKV : ExternalSymbolRelocations) { 1179 StringRef Name = RelocKV.first(); 1180 if (!Name.empty() && !GlobalSymbolTable.count(Name) && 1181 !ResolvedSymbols.count(Name)) 1182 NewSymbols.insert(Name); 1183 } 1184 1185 if (NewSymbols.empty()) 1186 break; 1187 1188 #ifdef _MSC_VER 1189 using ExpectedLookupResult = 1190 MSVCPExpected<JITSymbolResolver::LookupResult>; 1191 #else 1192 using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>; 1193 #endif 1194 1195 auto NewSymbolsP = std::make_shared<std::promise<ExpectedLookupResult>>(); 1196 auto NewSymbolsF = NewSymbolsP->get_future(); 1197 Resolver.lookup(NewSymbols, 1198 [=](Expected<JITSymbolResolver::LookupResult> Result) { 1199 NewSymbolsP->set_value(std::move(Result)); 1200 }); 1201 1202 auto NewResolverResults = NewSymbolsF.get(); 1203 1204 if (!NewResolverResults) 1205 return NewResolverResults.takeError(); 1206 1207 assert(NewResolverResults->size() == NewSymbols.size() && 1208 "Should have errored on unresolved symbols"); 1209 1210 for (auto &RRKV : *NewResolverResults) { 1211 assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?"); 1212 ExternalSymbolMap.insert(RRKV); 1213 ResolvedSymbols.insert(RRKV.first); 1214 } 1215 } 1216 } 1217 1218 applyExternalSymbolRelocations(ExternalSymbolMap); 1219 1220 return Error::success(); 1221 } 1222 1223 void RuntimeDyldImpl::finalizeAsync( 1224 std::unique_ptr<RuntimeDyldImpl> This, 1225 unique_function<void(object::OwningBinary<object::ObjectFile>, 1226 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>, Error)> 1227 OnEmitted, 1228 object::OwningBinary<object::ObjectFile> O, 1229 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> Info) { 1230 1231 auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This)); 1232 auto PostResolveContinuation = 1233 [SharedThis, OnEmitted = std::move(OnEmitted), O = std::move(O), 1234 Info = std::move(Info)]( 1235 Expected<JITSymbolResolver::LookupResult> Result) mutable { 1236 if (!Result) { 1237 OnEmitted(std::move(O), std::move(Info), Result.takeError()); 1238 return; 1239 } 1240 1241 /// Copy the result into a StringMap, where the keys are held by value. 1242 StringMap<JITEvaluatedSymbol> Resolved; 1243 for (auto &KV : *Result) 1244 Resolved[KV.first] = KV.second; 1245 1246 SharedThis->applyExternalSymbolRelocations(Resolved); 1247 SharedThis->resolveLocalRelocations(); 1248 SharedThis->registerEHFrames(); 1249 std::string ErrMsg; 1250 if (SharedThis->MemMgr.finalizeMemory(&ErrMsg)) 1251 OnEmitted(std::move(O), std::move(Info), 1252 make_error<StringError>(std::move(ErrMsg), 1253 inconvertibleErrorCode())); 1254 else 1255 OnEmitted(std::move(O), std::move(Info), Error::success()); 1256 }; 1257 1258 JITSymbolResolver::LookupSet Symbols; 1259 1260 for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) { 1261 StringRef Name = RelocKV.first(); 1262 if (Name.empty()) // Skip absolute symbol relocations. 1263 continue; 1264 assert(!SharedThis->GlobalSymbolTable.count(Name) && 1265 "Name already processed. RuntimeDyld instances can not be re-used " 1266 "when finalizing with finalizeAsync."); 1267 Symbols.insert(Name); 1268 } 1269 1270 if (!Symbols.empty()) { 1271 SharedThis->Resolver.lookup(Symbols, std::move(PostResolveContinuation)); 1272 } else 1273 PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>()); 1274 } 1275 1276 //===----------------------------------------------------------------------===// 1277 // RuntimeDyld class implementation 1278 1279 uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress( 1280 const object::SectionRef &Sec) const { 1281 1282 auto I = ObjSecToIDMap.find(Sec); 1283 if (I != ObjSecToIDMap.end()) 1284 return RTDyld.Sections[I->second].getLoadAddress(); 1285 1286 return 0; 1287 } 1288 1289 RuntimeDyld::MemoryManager::TLSSection 1290 RuntimeDyld::MemoryManager::allocateTLSSection(uintptr_t Size, 1291 unsigned Alignment, 1292 unsigned SectionID, 1293 StringRef SectionName) { 1294 report_fatal_error("allocation of TLS not implemented"); 1295 } 1296 1297 void RuntimeDyld::MemoryManager::anchor() {} 1298 void JITSymbolResolver::anchor() {} 1299 void LegacyJITSymbolResolver::anchor() {} 1300 1301 RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr, 1302 JITSymbolResolver &Resolver) 1303 : MemMgr(MemMgr), Resolver(Resolver) { 1304 // FIXME: There's a potential issue lurking here if a single instance of 1305 // RuntimeDyld is used to load multiple objects. The current implementation 1306 // associates a single memory manager with a RuntimeDyld instance. Even 1307 // though the public class spawns a new 'impl' instance for each load, 1308 // they share a single memory manager. This can become a problem when page 1309 // permissions are applied. 1310 Dyld = nullptr; 1311 ProcessAllSections = false; 1312 } 1313 1314 RuntimeDyld::~RuntimeDyld() {} 1315 1316 static std::unique_ptr<RuntimeDyldCOFF> 1317 createRuntimeDyldCOFF( 1318 Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, 1319 JITSymbolResolver &Resolver, bool ProcessAllSections, 1320 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) { 1321 std::unique_ptr<RuntimeDyldCOFF> Dyld = 1322 RuntimeDyldCOFF::create(Arch, MM, Resolver); 1323 Dyld->setProcessAllSections(ProcessAllSections); 1324 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted)); 1325 return Dyld; 1326 } 1327 1328 static std::unique_ptr<RuntimeDyldELF> 1329 createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, 1330 JITSymbolResolver &Resolver, bool ProcessAllSections, 1331 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) { 1332 std::unique_ptr<RuntimeDyldELF> Dyld = 1333 RuntimeDyldELF::create(Arch, MM, Resolver); 1334 Dyld->setProcessAllSections(ProcessAllSections); 1335 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted)); 1336 return Dyld; 1337 } 1338 1339 static std::unique_ptr<RuntimeDyldMachO> 1340 createRuntimeDyldMachO( 1341 Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, 1342 JITSymbolResolver &Resolver, 1343 bool ProcessAllSections, 1344 RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) { 1345 std::unique_ptr<RuntimeDyldMachO> Dyld = 1346 RuntimeDyldMachO::create(Arch, MM, Resolver); 1347 Dyld->setProcessAllSections(ProcessAllSections); 1348 Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted)); 1349 return Dyld; 1350 } 1351 1352 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> 1353 RuntimeDyld::loadObject(const ObjectFile &Obj) { 1354 if (!Dyld) { 1355 if (Obj.isELF()) 1356 Dyld = 1357 createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()), 1358 MemMgr, Resolver, ProcessAllSections, 1359 std::move(NotifyStubEmitted)); 1360 else if (Obj.isMachO()) 1361 Dyld = createRuntimeDyldMachO( 1362 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver, 1363 ProcessAllSections, std::move(NotifyStubEmitted)); 1364 else if (Obj.isCOFF()) 1365 Dyld = createRuntimeDyldCOFF( 1366 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver, 1367 ProcessAllSections, std::move(NotifyStubEmitted)); 1368 else 1369 report_fatal_error("Incompatible object format!"); 1370 } 1371 1372 if (!Dyld->isCompatibleFile(Obj)) 1373 report_fatal_error("Incompatible object format!"); 1374 1375 auto LoadedObjInfo = Dyld->loadObject(Obj); 1376 MemMgr.notifyObjectLoaded(*this, Obj); 1377 return LoadedObjInfo; 1378 } 1379 1380 void *RuntimeDyld::getSymbolLocalAddress(StringRef Name) const { 1381 if (!Dyld) 1382 return nullptr; 1383 return Dyld->getSymbolLocalAddress(Name); 1384 } 1385 1386 unsigned RuntimeDyld::getSymbolSectionID(StringRef Name) const { 1387 assert(Dyld && "No RuntimeDyld instance attached"); 1388 return Dyld->getSymbolSectionID(Name); 1389 } 1390 1391 JITEvaluatedSymbol RuntimeDyld::getSymbol(StringRef Name) const { 1392 if (!Dyld) 1393 return nullptr; 1394 return Dyld->getSymbol(Name); 1395 } 1396 1397 std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const { 1398 if (!Dyld) 1399 return std::map<StringRef, JITEvaluatedSymbol>(); 1400 return Dyld->getSymbolTable(); 1401 } 1402 1403 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); } 1404 1405 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) { 1406 Dyld->reassignSectionAddress(SectionID, Addr); 1407 } 1408 1409 void RuntimeDyld::mapSectionAddress(const void *LocalAddress, 1410 uint64_t TargetAddress) { 1411 Dyld->mapSectionAddress(LocalAddress, TargetAddress); 1412 } 1413 1414 bool RuntimeDyld::hasError() { return Dyld->hasError(); } 1415 1416 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); } 1417 1418 void RuntimeDyld::finalizeWithMemoryManagerLocking() { 1419 bool MemoryFinalizationLocked = MemMgr.FinalizationLocked; 1420 MemMgr.FinalizationLocked = true; 1421 resolveRelocations(); 1422 registerEHFrames(); 1423 if (!MemoryFinalizationLocked) { 1424 MemMgr.finalizeMemory(); 1425 MemMgr.FinalizationLocked = false; 1426 } 1427 } 1428 1429 StringRef RuntimeDyld::getSectionContent(unsigned SectionID) const { 1430 assert(Dyld && "No Dyld instance attached"); 1431 return Dyld->getSectionContent(SectionID); 1432 } 1433 1434 uint64_t RuntimeDyld::getSectionLoadAddress(unsigned SectionID) const { 1435 assert(Dyld && "No Dyld instance attached"); 1436 return Dyld->getSectionLoadAddress(SectionID); 1437 } 1438 1439 void RuntimeDyld::registerEHFrames() { 1440 if (Dyld) 1441 Dyld->registerEHFrames(); 1442 } 1443 1444 void RuntimeDyld::deregisterEHFrames() { 1445 if (Dyld) 1446 Dyld->deregisterEHFrames(); 1447 } 1448 // FIXME: Kill this with fire once we have a new JIT linker: this is only here 1449 // so that we can re-use RuntimeDyld's implementation without twisting the 1450 // interface any further for ORC's purposes. 1451 void jitLinkForORC( 1452 object::OwningBinary<object::ObjectFile> O, 1453 RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver, 1454 bool ProcessAllSections, 1455 unique_function<Error(const object::ObjectFile &Obj, 1456 RuntimeDyld::LoadedObjectInfo &LoadedObj, 1457 std::map<StringRef, JITEvaluatedSymbol>)> 1458 OnLoaded, 1459 unique_function<void(object::OwningBinary<object::ObjectFile>, 1460 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>, Error)> 1461 OnEmitted) { 1462 1463 RuntimeDyld RTDyld(MemMgr, Resolver); 1464 RTDyld.setProcessAllSections(ProcessAllSections); 1465 1466 auto Info = RTDyld.loadObject(*O.getBinary()); 1467 1468 if (RTDyld.hasError()) { 1469 OnEmitted(std::move(O), std::move(Info), 1470 make_error<StringError>(RTDyld.getErrorString(), 1471 inconvertibleErrorCode())); 1472 return; 1473 } 1474 1475 if (auto Err = OnLoaded(*O.getBinary(), *Info, RTDyld.getSymbolTable())) 1476 OnEmitted(std::move(O), std::move(Info), std::move(Err)); 1477 1478 RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted), 1479 std::move(O), std::move(Info)); 1480 } 1481 1482 } // end namespace llvm 1483