1 //===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===// 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 // Implementation of the MC-JIT runtime dynamic linker. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/ExecutionEngine/RuntimeDyld.h" 15 #include "RuntimeDyldCheckerImpl.h" 16 #include "RuntimeDyldCOFF.h" 17 #include "RuntimeDyldELF.h" 18 #include "RuntimeDyldImpl.h" 19 #include "RuntimeDyldMachO.h" 20 #include "llvm/Object/ELFObjectFile.h" 21 #include "llvm/Object/COFF.h" 22 #include "llvm/Support/MathExtras.h" 23 #include "llvm/Support/MutexGuard.h" 24 25 using namespace llvm; 26 using namespace llvm::object; 27 28 #define DEBUG_TYPE "dyld" 29 30 // Empty out-of-line virtual destructor as the key function. 31 RuntimeDyldImpl::~RuntimeDyldImpl() {} 32 33 // Pin LoadedObjectInfo's vtables to this file. 34 void RuntimeDyld::LoadedObjectInfo::anchor() {} 35 36 namespace llvm { 37 38 void RuntimeDyldImpl::registerEHFrames() {} 39 40 void RuntimeDyldImpl::deregisterEHFrames() {} 41 42 #ifndef NDEBUG 43 static void dumpSectionMemory(const SectionEntry &S, StringRef State) { 44 dbgs() << "----- Contents of section " << S.Name << " " << State << " -----"; 45 46 if (S.Address == nullptr) { 47 dbgs() << "\n <section not emitted>\n"; 48 return; 49 } 50 51 const unsigned ColsPerRow = 16; 52 53 uint8_t *DataAddr = S.Address; 54 uint64_t LoadAddr = S.LoadAddress; 55 56 unsigned StartPadding = LoadAddr & (ColsPerRow - 1); 57 unsigned BytesRemaining = S.Size; 58 59 if (StartPadding) { 60 dbgs() << "\n" << format("0x%016" PRIx64, 61 LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":"; 62 while (StartPadding--) 63 dbgs() << " "; 64 } 65 66 while (BytesRemaining > 0) { 67 if ((LoadAddr & (ColsPerRow - 1)) == 0) 68 dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":"; 69 70 dbgs() << " " << format("%02x", *DataAddr); 71 72 ++DataAddr; 73 ++LoadAddr; 74 --BytesRemaining; 75 } 76 77 dbgs() << "\n"; 78 } 79 #endif 80 81 // Resolve the relocations for all symbols we currently know about. 82 void RuntimeDyldImpl::resolveRelocations() { 83 MutexGuard locked(lock); 84 85 // First, resolve relocations associated with external symbols. 86 resolveExternalSymbols(); 87 88 // Just iterate over the sections we have and resolve all the relocations 89 // in them. Gross overkill, but it gets the job done. 90 for (int i = 0, e = Sections.size(); i != e; ++i) { 91 // The Section here (Sections[i]) refers to the section in which the 92 // symbol for the relocation is located. The SectionID in the relocation 93 // entry provides the section to which the relocation will be applied. 94 uint64_t Addr = Sections[i].LoadAddress; 95 DEBUG(dbgs() << "Resolving relocations Section #" << i << "\t" 96 << format("%p", (uintptr_t)Addr) << "\n"); 97 DEBUG(dumpSectionMemory(Sections[i], "before relocations")); 98 resolveRelocationList(Relocations[i], Addr); 99 DEBUG(dumpSectionMemory(Sections[i], "after relocations")); 100 Relocations.erase(i); 101 } 102 } 103 104 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress, 105 uint64_t TargetAddress) { 106 MutexGuard locked(lock); 107 for (unsigned i = 0, e = Sections.size(); i != e; ++i) { 108 if (Sections[i].Address == LocalAddress) { 109 reassignSectionAddress(i, TargetAddress); 110 return; 111 } 112 } 113 llvm_unreachable("Attempting to remap address of unknown section!"); 114 } 115 116 static std::error_code getOffset(const SymbolRef &Sym, uint64_t &Result) { 117 uint64_t Address; 118 if (std::error_code EC = Sym.getAddress(Address)) 119 return EC; 120 121 if (Address == UnknownAddressOrSize) { 122 Result = UnknownAddressOrSize; 123 return object_error::success; 124 } 125 126 const ObjectFile *Obj = Sym.getObject(); 127 section_iterator SecI(Obj->section_begin()); 128 if (std::error_code EC = Sym.getSection(SecI)) 129 return EC; 130 131 if (SecI == Obj->section_end()) { 132 Result = UnknownAddressOrSize; 133 return object_error::success; 134 } 135 136 uint64_t SectionAddress = SecI->getAddress(); 137 Result = Address - SectionAddress; 138 return object_error::success; 139 } 140 141 std::pair<unsigned, unsigned> 142 RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) { 143 MutexGuard locked(lock); 144 145 // Grab the first Section ID. We'll use this later to construct the underlying 146 // range for the returned LoadedObjectInfo. 147 unsigned SectionsAddedBeginIdx = Sections.size(); 148 149 // Save information about our target 150 Arch = (Triple::ArchType)Obj.getArch(); 151 IsTargetLittleEndian = Obj.isLittleEndian(); 152 153 // Compute the memory size required to load all sections to be loaded 154 // and pass this information to the memory manager 155 if (MemMgr.needsToReserveAllocationSpace()) { 156 uint64_t CodeSize = 0, DataSizeRO = 0, DataSizeRW = 0; 157 computeTotalAllocSize(Obj, CodeSize, DataSizeRO, DataSizeRW); 158 MemMgr.reserveAllocationSpace(CodeSize, DataSizeRO, DataSizeRW); 159 } 160 161 // Used sections from the object file 162 ObjSectionToIDMap LocalSections; 163 164 // Common symbols requiring allocation, with their sizes and alignments 165 CommonSymbolList CommonSymbols; 166 167 // Parse symbols 168 DEBUG(dbgs() << "Parse symbols:\n"); 169 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E; 170 ++I) { 171 uint32_t Flags = I->getFlags(); 172 173 bool IsCommon = Flags & SymbolRef::SF_Common; 174 if (IsCommon) 175 CommonSymbols.push_back(*I); 176 else { 177 object::SymbolRef::Type SymType; 178 Check(I->getType(SymType)); 179 180 if (SymType == object::SymbolRef::ST_Function || 181 SymType == object::SymbolRef::ST_Data || 182 SymType == object::SymbolRef::ST_Unknown) { 183 184 StringRef Name; 185 uint64_t SectOffset; 186 Check(I->getName(Name)); 187 Check(getOffset(*I, SectOffset)); 188 section_iterator SI = Obj.section_end(); 189 Check(I->getSection(SI)); 190 if (SI == Obj.section_end()) 191 continue; 192 StringRef SectionData; 193 Check(SI->getContents(SectionData)); 194 bool IsCode = SI->isText(); 195 unsigned SectionID = 196 findOrEmitSection(Obj, *SI, IsCode, LocalSections); 197 DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name 198 << " SID: " << SectionID << " Offset: " 199 << format("%p", (uintptr_t)SectOffset) 200 << " flags: " << Flags << "\n"); 201 JITSymbolFlags RTDyldSymFlags = JITSymbolFlags::None; 202 if (Flags & SymbolRef::SF_Weak) 203 RTDyldSymFlags |= JITSymbolFlags::Weak; 204 if (Flags & SymbolRef::SF_Exported) 205 RTDyldSymFlags |= JITSymbolFlags::Exported; 206 GlobalSymbolTable[Name] = 207 SymbolTableEntry(SectionID, SectOffset, RTDyldSymFlags); 208 } 209 } 210 } 211 212 // Allocate common symbols 213 emitCommonSymbols(Obj, CommonSymbols); 214 215 // Parse and process relocations 216 DEBUG(dbgs() << "Parse relocations:\n"); 217 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 218 SI != SE; ++SI) { 219 unsigned SectionID = 0; 220 StubMap Stubs; 221 section_iterator RelocatedSection = SI->getRelocatedSection(); 222 223 if (RelocatedSection == SE) 224 continue; 225 226 relocation_iterator I = SI->relocation_begin(); 227 relocation_iterator E = SI->relocation_end(); 228 229 if (I == E && !ProcessAllSections) 230 continue; 231 232 bool IsCode = RelocatedSection->isText(); 233 SectionID = 234 findOrEmitSection(Obj, *RelocatedSection, IsCode, LocalSections); 235 DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n"); 236 237 for (; I != E;) 238 I = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs); 239 240 // If there is an attached checker, notify it about the stubs for this 241 // section so that they can be verified. 242 if (Checker) 243 Checker->registerStubMap(Obj.getFileName(), SectionID, Stubs); 244 } 245 246 // Give the subclasses a chance to tie-up any loose ends. 247 finalizeLoad(Obj, LocalSections); 248 249 unsigned SectionsAddedEndIdx = Sections.size(); 250 251 return std::make_pair(SectionsAddedBeginIdx, SectionsAddedEndIdx); 252 } 253 254 // A helper method for computeTotalAllocSize. 255 // Computes the memory size required to allocate sections with the given sizes, 256 // assuming that all sections are allocated with the given alignment 257 static uint64_t 258 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes, 259 uint64_t Alignment) { 260 uint64_t TotalSize = 0; 261 for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) { 262 uint64_t AlignedSize = 263 (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment; 264 TotalSize += AlignedSize; 265 } 266 return TotalSize; 267 } 268 269 static bool isRequiredForExecution(const SectionRef &Section) { 270 const ObjectFile *Obj = Section.getObject(); 271 if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj)) 272 return ELFObj->getSectionFlags(Section) & ELF::SHF_ALLOC; 273 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) { 274 const coff_section *CoffSection = COFFObj->getCOFFSection(Section); 275 // Avoid loading zero-sized COFF sections. 276 // In PE files, VirtualSize gives the section size, and SizeOfRawData 277 // may be zero for sections with content. In Obj files, SizeOfRawData 278 // gives the section size, and VirtualSize is always zero. Hence 279 // the need to check for both cases below. 280 bool HasContent = (CoffSection->VirtualSize > 0) 281 || (CoffSection->SizeOfRawData > 0); 282 bool IsDiscardable = CoffSection->Characteristics & 283 (COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_LNK_INFO); 284 return HasContent && !IsDiscardable; 285 } 286 287 assert(isa<MachOObjectFile>(Obj)); 288 return true; 289 } 290 291 static bool isReadOnlyData(const SectionRef &Section) { 292 const ObjectFile *Obj = Section.getObject(); 293 if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj)) 294 return !(ELFObj->getSectionFlags(Section) & 295 (ELF::SHF_WRITE | ELF::SHF_EXECINSTR)); 296 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) 297 return ((COFFObj->getCOFFSection(Section)->Characteristics & 298 (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA 299 | COFF::IMAGE_SCN_MEM_READ 300 | COFF::IMAGE_SCN_MEM_WRITE)) 301 == 302 (COFF::IMAGE_SCN_CNT_INITIALIZED_DATA 303 | COFF::IMAGE_SCN_MEM_READ)); 304 305 assert(isa<MachOObjectFile>(Obj)); 306 return false; 307 } 308 309 static bool isZeroInit(const SectionRef &Section) { 310 const ObjectFile *Obj = Section.getObject(); 311 if (auto *ELFObj = dyn_cast<object::ELFObjectFileBase>(Obj)) 312 return ELFObj->getSectionType(Section) == ELF::SHT_NOBITS; 313 if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) 314 return COFFObj->getCOFFSection(Section)->Characteristics & 315 COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA; 316 317 auto *MachO = cast<MachOObjectFile>(Obj); 318 unsigned SectionType = MachO->getSectionType(Section); 319 return SectionType == MachO::S_ZEROFILL || 320 SectionType == MachO::S_GB_ZEROFILL; 321 } 322 323 // Compute an upper bound of the memory size that is required to load all 324 // sections 325 void RuntimeDyldImpl::computeTotalAllocSize(const ObjectFile &Obj, 326 uint64_t &CodeSize, 327 uint64_t &DataSizeRO, 328 uint64_t &DataSizeRW) { 329 // Compute the size of all sections required for execution 330 std::vector<uint64_t> CodeSectionSizes; 331 std::vector<uint64_t> ROSectionSizes; 332 std::vector<uint64_t> RWSectionSizes; 333 uint64_t MaxAlignment = sizeof(void *); 334 335 // Collect sizes of all sections to be loaded; 336 // also determine the max alignment of all sections 337 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 338 SI != SE; ++SI) { 339 const SectionRef &Section = *SI; 340 341 bool IsRequired = isRequiredForExecution(Section); 342 343 // Consider only the sections that are required to be loaded for execution 344 if (IsRequired) { 345 StringRef Name; 346 uint64_t DataSize = Section.getSize(); 347 uint64_t Alignment64 = Section.getAlignment(); 348 bool IsCode = Section.isText(); 349 bool IsReadOnly = isReadOnlyData(Section); 350 Check(Section.getName(Name)); 351 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL; 352 353 uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section); 354 uint64_t SectionSize = DataSize + StubBufSize; 355 356 // The .eh_frame section (at least on Linux) needs an extra four bytes 357 // padded 358 // with zeroes added at the end. For MachO objects, this section has a 359 // slightly different name, so this won't have any effect for MachO 360 // objects. 361 if (Name == ".eh_frame") 362 SectionSize += 4; 363 364 if (!SectionSize) 365 SectionSize = 1; 366 367 if (IsCode) { 368 CodeSectionSizes.push_back(SectionSize); 369 } else if (IsReadOnly) { 370 ROSectionSizes.push_back(SectionSize); 371 } else { 372 RWSectionSizes.push_back(SectionSize); 373 } 374 375 // update the max alignment 376 if (Alignment > MaxAlignment) { 377 MaxAlignment = Alignment; 378 } 379 } 380 } 381 382 // Compute the size of all common symbols 383 uint64_t CommonSize = 0; 384 for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E; 385 ++I) { 386 uint32_t Flags = I->getFlags(); 387 if (Flags & SymbolRef::SF_Common) { 388 // Add the common symbols to a list. We'll allocate them all below. 389 uint64_t Size = 0; 390 Check(I->getSize(Size)); 391 CommonSize += Size; 392 } 393 } 394 if (CommonSize != 0) { 395 RWSectionSizes.push_back(CommonSize); 396 } 397 398 // Compute the required allocation space for each different type of sections 399 // (code, read-only data, read-write data) assuming that all sections are 400 // allocated with the max alignment. Note that we cannot compute with the 401 // individual alignments of the sections, because then the required size 402 // depends on the order, in which the sections are allocated. 403 CodeSize = computeAllocationSizeForSections(CodeSectionSizes, MaxAlignment); 404 DataSizeRO = computeAllocationSizeForSections(ROSectionSizes, MaxAlignment); 405 DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment); 406 } 407 408 // compute stub buffer size for the given section 409 unsigned RuntimeDyldImpl::computeSectionStubBufSize(const ObjectFile &Obj, 410 const SectionRef &Section) { 411 unsigned StubSize = getMaxStubSize(); 412 if (StubSize == 0) { 413 return 0; 414 } 415 // FIXME: this is an inefficient way to handle this. We should computed the 416 // necessary section allocation size in loadObject by walking all the sections 417 // once. 418 unsigned StubBufSize = 0; 419 for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end(); 420 SI != SE; ++SI) { 421 section_iterator RelSecI = SI->getRelocatedSection(); 422 if (!(RelSecI == Section)) 423 continue; 424 425 for (const RelocationRef &Reloc : SI->relocations()) { 426 (void)Reloc; 427 StubBufSize += StubSize; 428 } 429 } 430 431 // Get section data size and alignment 432 uint64_t DataSize = Section.getSize(); 433 uint64_t Alignment64 = Section.getAlignment(); 434 435 // Add stubbuf size alignment 436 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL; 437 unsigned StubAlignment = getStubAlignment(); 438 unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment); 439 if (StubAlignment > EndAlignment) 440 StubBufSize += StubAlignment - EndAlignment; 441 return StubBufSize; 442 } 443 444 uint64_t RuntimeDyldImpl::readBytesUnaligned(uint8_t *Src, 445 unsigned Size) const { 446 uint64_t Result = 0; 447 if (IsTargetLittleEndian) { 448 Src += Size - 1; 449 while (Size--) 450 Result = (Result << 8) | *Src--; 451 } else 452 while (Size--) 453 Result = (Result << 8) | *Src++; 454 455 return Result; 456 } 457 458 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst, 459 unsigned Size) const { 460 if (IsTargetLittleEndian) { 461 while (Size--) { 462 *Dst++ = Value & 0xFF; 463 Value >>= 8; 464 } 465 } else { 466 Dst += Size - 1; 467 while (Size--) { 468 *Dst-- = Value & 0xFF; 469 Value >>= 8; 470 } 471 } 472 } 473 474 void RuntimeDyldImpl::emitCommonSymbols(const ObjectFile &Obj, 475 CommonSymbolList &CommonSymbols) { 476 if (CommonSymbols.empty()) 477 return; 478 479 uint64_t CommonSize = 0; 480 CommonSymbolList SymbolsToAllocate; 481 482 DEBUG(dbgs() << "Processing common symbols...\n"); 483 484 for (const auto &Sym : CommonSymbols) { 485 StringRef Name; 486 Check(Sym.getName(Name)); 487 488 // Skip common symbols already elsewhere. 489 if (GlobalSymbolTable.count(Name) || 490 Resolver.findSymbolInLogicalDylib(Name)) { 491 DEBUG(dbgs() << "\tSkipping already emitted common symbol '" << Name 492 << "'\n"); 493 continue; 494 } 495 496 uint32_t Align = 0; 497 uint64_t Size = 0; 498 Check(Sym.getAlignment(Align)); 499 Check(Sym.getSize(Size)); 500 501 CommonSize += Align + Size; 502 SymbolsToAllocate.push_back(Sym); 503 } 504 505 // Allocate memory for the section 506 unsigned SectionID = Sections.size(); 507 uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, sizeof(void *), 508 SectionID, StringRef(), false); 509 if (!Addr) 510 report_fatal_error("Unable to allocate memory for common symbols!"); 511 uint64_t Offset = 0; 512 Sections.push_back(SectionEntry("<common symbols>", Addr, CommonSize, 0)); 513 memset(Addr, 0, CommonSize); 514 515 DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID << " new addr: " 516 << format("%p", Addr) << " DataSize: " << CommonSize << "\n"); 517 518 // Assign the address of each symbol 519 for (auto &Sym : SymbolsToAllocate) { 520 uint32_t Align; 521 uint64_t Size; 522 StringRef Name; 523 Check(Sym.getAlignment(Align)); 524 Check(Sym.getSize(Size)); 525 Check(Sym.getName(Name)); 526 if (Align) { 527 // This symbol has an alignment requirement. 528 uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align); 529 Addr += AlignOffset; 530 Offset += AlignOffset; 531 } 532 uint32_t Flags = Sym.getFlags(); 533 JITSymbolFlags RTDyldSymFlags = JITSymbolFlags::None; 534 if (Flags & SymbolRef::SF_Weak) 535 RTDyldSymFlags |= JITSymbolFlags::Weak; 536 if (Flags & SymbolRef::SF_Exported) 537 RTDyldSymFlags |= JITSymbolFlags::Exported; 538 DEBUG(dbgs() << "Allocating common symbol " << Name << " address " 539 << format("%p", Addr) << "\n"); 540 GlobalSymbolTable[Name] = 541 SymbolTableEntry(SectionID, Offset, RTDyldSymFlags); 542 Offset += Size; 543 Addr += Size; 544 } 545 } 546 547 unsigned RuntimeDyldImpl::emitSection(const ObjectFile &Obj, 548 const SectionRef &Section, bool IsCode) { 549 550 StringRef data; 551 uint64_t Alignment64 = Section.getAlignment(); 552 553 unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL; 554 unsigned PaddingSize = 0; 555 unsigned StubBufSize = 0; 556 StringRef Name; 557 bool IsRequired = isRequiredForExecution(Section); 558 bool IsVirtual = Section.isVirtual(); 559 bool IsZeroInit = isZeroInit(Section); 560 bool IsReadOnly = isReadOnlyData(Section); 561 uint64_t DataSize = Section.getSize(); 562 Check(Section.getName(Name)); 563 564 StubBufSize = computeSectionStubBufSize(Obj, Section); 565 566 // The .eh_frame section (at least on Linux) needs an extra four bytes padded 567 // with zeroes added at the end. For MachO objects, this section has a 568 // slightly different name, so this won't have any effect for MachO objects. 569 if (Name == ".eh_frame") 570 PaddingSize = 4; 571 572 uintptr_t Allocate; 573 unsigned SectionID = Sections.size(); 574 uint8_t *Addr; 575 const char *pData = nullptr; 576 577 // Some sections, such as debug info, don't need to be loaded for execution. 578 // Leave those where they are. 579 if (IsRequired) { 580 Check(Section.getContents(data)); 581 Allocate = DataSize + PaddingSize + StubBufSize; 582 if (!Allocate) 583 Allocate = 1; 584 Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID, 585 Name) 586 : MemMgr.allocateDataSection(Allocate, Alignment, SectionID, 587 Name, IsReadOnly); 588 if (!Addr) 589 report_fatal_error("Unable to allocate section memory!"); 590 591 // Virtual sections have no data in the object image, so leave pData = 0 592 if (!IsVirtual) 593 pData = data.data(); 594 595 // Zero-initialize or copy the data from the image 596 if (IsZeroInit || IsVirtual) 597 memset(Addr, 0, DataSize); 598 else 599 memcpy(Addr, pData, DataSize); 600 601 // Fill in any extra bytes we allocated for padding 602 if (PaddingSize != 0) { 603 memset(Addr + DataSize, 0, PaddingSize); 604 // Update the DataSize variable so that the stub offset is set correctly. 605 DataSize += PaddingSize; 606 } 607 608 DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name 609 << " obj addr: " << format("%p", pData) 610 << " new addr: " << format("%p", Addr) 611 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize 612 << " Allocate: " << Allocate << "\n"); 613 } else { 614 // Even if we didn't load the section, we need to record an entry for it 615 // to handle later processing (and by 'handle' I mean don't do anything 616 // with these sections). 617 Allocate = 0; 618 Addr = nullptr; 619 DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name 620 << " obj addr: " << format("%p", data.data()) << " new addr: 0" 621 << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize 622 << " Allocate: " << Allocate << "\n"); 623 } 624 625 Sections.push_back(SectionEntry(Name, Addr, DataSize, (uintptr_t)pData)); 626 627 if (Checker) 628 Checker->registerSection(Obj.getFileName(), SectionID); 629 630 return SectionID; 631 } 632 633 unsigned RuntimeDyldImpl::findOrEmitSection(const ObjectFile &Obj, 634 const SectionRef &Section, 635 bool IsCode, 636 ObjSectionToIDMap &LocalSections) { 637 638 unsigned SectionID = 0; 639 ObjSectionToIDMap::iterator i = LocalSections.find(Section); 640 if (i != LocalSections.end()) 641 SectionID = i->second; 642 else { 643 SectionID = emitSection(Obj, Section, IsCode); 644 LocalSections[Section] = SectionID; 645 } 646 return SectionID; 647 } 648 649 void RuntimeDyldImpl::addRelocationForSection(const RelocationEntry &RE, 650 unsigned SectionID) { 651 Relocations[SectionID].push_back(RE); 652 } 653 654 void RuntimeDyldImpl::addRelocationForSymbol(const RelocationEntry &RE, 655 StringRef SymbolName) { 656 // Relocation by symbol. If the symbol is found in the global symbol table, 657 // create an appropriate section relocation. Otherwise, add it to 658 // ExternalSymbolRelocations. 659 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName); 660 if (Loc == GlobalSymbolTable.end()) { 661 ExternalSymbolRelocations[SymbolName].push_back(RE); 662 } else { 663 // Copy the RE since we want to modify its addend. 664 RelocationEntry RECopy = RE; 665 const auto &SymInfo = Loc->second; 666 RECopy.Addend += SymInfo.getOffset(); 667 Relocations[SymInfo.getSectionID()].push_back(RECopy); 668 } 669 } 670 671 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr, 672 unsigned AbiVariant) { 673 if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be) { 674 // This stub has to be able to access the full address space, 675 // since symbol lookup won't necessarily find a handy, in-range, 676 // PLT stub for functions which could be anywhere. 677 // Stub can use ip0 (== x16) to calculate address 678 writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr> 679 writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr> 680 writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr> 681 writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr> 682 writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0 683 684 return Addr; 685 } else if (Arch == Triple::arm || Arch == Triple::armeb) { 686 // TODO: There is only ARM far stub now. We should add the Thumb stub, 687 // and stubs for branches Thumb - ARM and ARM - Thumb. 688 writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc,<label> 689 return Addr + 4; 690 } else if (Arch == Triple::mipsel || Arch == Triple::mips) { 691 // 0: 3c190000 lui t9,%hi(addr). 692 // 4: 27390000 addiu t9,t9,%lo(addr). 693 // 8: 03200008 jr t9. 694 // c: 00000000 nop. 695 const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000; 696 const unsigned JrT9Instr = 0x03200008, NopInstr = 0x0; 697 698 writeBytesUnaligned(LuiT9Instr, Addr, 4); 699 writeBytesUnaligned(AdduiT9Instr, Addr+4, 4); 700 writeBytesUnaligned(JrT9Instr, Addr+8, 4); 701 writeBytesUnaligned(NopInstr, Addr+12, 4); 702 return Addr; 703 } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) { 704 // Depending on which version of the ELF ABI is in use, we need to 705 // generate one of two variants of the stub. They both start with 706 // the same sequence to load the target address into r12. 707 writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr) 708 writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr) 709 writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32 710 writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr) 711 writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr) 712 if (AbiVariant == 2) { 713 // PowerPC64 stub ELFv2 ABI: The address points to the function itself. 714 // The address is already in r12 as required by the ABI. Branch to it. 715 writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1) 716 writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12 717 writeInt32BE(Addr+28, 0x4E800420); // bctr 718 } else { 719 // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor. 720 // Load the function address on r11 and sets it to control register. Also 721 // loads the function TOC in r2 and environment pointer to r11. 722 writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1) 723 writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12) 724 writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12) 725 writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11 726 writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2) 727 writeInt32BE(Addr+40, 0x4E800420); // bctr 728 } 729 return Addr; 730 } else if (Arch == Triple::systemz) { 731 writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8 732 writeInt16BE(Addr+2, 0x0000); 733 writeInt16BE(Addr+4, 0x0004); 734 writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1 735 // 8-byte address stored at Addr + 8 736 return Addr; 737 } else if (Arch == Triple::x86_64) { 738 *Addr = 0xFF; // jmp 739 *(Addr+1) = 0x25; // rip 740 // 32-bit PC-relative address of the GOT entry will be stored at Addr+2 741 } else if (Arch == Triple::x86) { 742 *Addr = 0xE9; // 32-bit pc-relative jump. 743 } 744 return Addr; 745 } 746 747 // Assign an address to a symbol name and resolve all the relocations 748 // associated with it. 749 void RuntimeDyldImpl::reassignSectionAddress(unsigned SectionID, 750 uint64_t Addr) { 751 // The address to use for relocation resolution is not 752 // the address of the local section buffer. We must be doing 753 // a remote execution environment of some sort. Relocations can't 754 // be applied until all the sections have been moved. The client must 755 // trigger this with a call to MCJIT::finalize() or 756 // RuntimeDyld::resolveRelocations(). 757 // 758 // Addr is a uint64_t because we can't assume the pointer width 759 // of the target is the same as that of the host. Just use a generic 760 // "big enough" type. 761 DEBUG(dbgs() << "Reassigning address for section " 762 << SectionID << " (" << Sections[SectionID].Name << "): " 763 << format("0x%016" PRIx64, Sections[SectionID].LoadAddress) << " -> " 764 << format("0x%016" PRIx64, Addr) << "\n"); 765 Sections[SectionID].LoadAddress = Addr; 766 } 767 768 void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs, 769 uint64_t Value) { 770 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) { 771 const RelocationEntry &RE = Relocs[i]; 772 // Ignore relocations for sections that were not loaded 773 if (Sections[RE.SectionID].Address == nullptr) 774 continue; 775 resolveRelocation(RE, Value); 776 } 777 } 778 779 void RuntimeDyldImpl::resolveExternalSymbols() { 780 while (!ExternalSymbolRelocations.empty()) { 781 StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin(); 782 783 StringRef Name = i->first(); 784 if (Name.size() == 0) { 785 // This is an absolute symbol, use an address of zero. 786 DEBUG(dbgs() << "Resolving absolute relocations." 787 << "\n"); 788 RelocationList &Relocs = i->second; 789 resolveRelocationList(Relocs, 0); 790 } else { 791 uint64_t Addr = 0; 792 RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name); 793 if (Loc == GlobalSymbolTable.end()) { 794 // This is an external symbol, try to get its address from the symbol 795 // resolver. 796 Addr = Resolver.findSymbol(Name.data()).getAddress(); 797 // The call to getSymbolAddress may have caused additional modules to 798 // be loaded, which may have added new entries to the 799 // ExternalSymbolRelocations map. Consquently, we need to update our 800 // iterator. This is also why retrieval of the relocation list 801 // associated with this symbol is deferred until below this point. 802 // New entries may have been added to the relocation list. 803 i = ExternalSymbolRelocations.find(Name); 804 } else { 805 // We found the symbol in our global table. It was probably in a 806 // Module that we loaded previously. 807 const auto &SymInfo = Loc->second; 808 Addr = getSectionLoadAddress(SymInfo.getSectionID()) + 809 SymInfo.getOffset(); 810 } 811 812 // FIXME: Implement error handling that doesn't kill the host program! 813 if (!Addr) 814 report_fatal_error("Program used external function '" + Name + 815 "' which could not be resolved!"); 816 817 DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t" 818 << format("0x%lx", Addr) << "\n"); 819 // This list may have been updated when we called getSymbolAddress, so 820 // don't change this code to get the list earlier. 821 RelocationList &Relocs = i->second; 822 resolveRelocationList(Relocs, Addr); 823 } 824 825 ExternalSymbolRelocations.erase(i); 826 } 827 } 828 829 //===----------------------------------------------------------------------===// 830 // RuntimeDyld class implementation 831 832 uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress( 833 StringRef SectionName) const { 834 for (unsigned I = BeginIdx; I != EndIdx; ++I) 835 if (RTDyld.Sections[I].Name == SectionName) 836 return RTDyld.Sections[I].LoadAddress; 837 838 return 0; 839 } 840 841 void RuntimeDyld::MemoryManager::anchor() {} 842 void RuntimeDyld::SymbolResolver::anchor() {} 843 844 RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr, 845 RuntimeDyld::SymbolResolver &Resolver) 846 : MemMgr(MemMgr), Resolver(Resolver) { 847 // FIXME: There's a potential issue lurking here if a single instance of 848 // RuntimeDyld is used to load multiple objects. The current implementation 849 // associates a single memory manager with a RuntimeDyld instance. Even 850 // though the public class spawns a new 'impl' instance for each load, 851 // they share a single memory manager. This can become a problem when page 852 // permissions are applied. 853 Dyld = nullptr; 854 ProcessAllSections = false; 855 Checker = nullptr; 856 } 857 858 RuntimeDyld::~RuntimeDyld() {} 859 860 static std::unique_ptr<RuntimeDyldCOFF> 861 createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, 862 RuntimeDyld::SymbolResolver &Resolver, 863 bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker) { 864 std::unique_ptr<RuntimeDyldCOFF> Dyld = 865 RuntimeDyldCOFF::create(Arch, MM, Resolver); 866 Dyld->setProcessAllSections(ProcessAllSections); 867 Dyld->setRuntimeDyldChecker(Checker); 868 return Dyld; 869 } 870 871 static std::unique_ptr<RuntimeDyldELF> 872 createRuntimeDyldELF(RuntimeDyld::MemoryManager &MM, 873 RuntimeDyld::SymbolResolver &Resolver, 874 bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker) { 875 std::unique_ptr<RuntimeDyldELF> Dyld(new RuntimeDyldELF(MM, Resolver)); 876 Dyld->setProcessAllSections(ProcessAllSections); 877 Dyld->setRuntimeDyldChecker(Checker); 878 return Dyld; 879 } 880 881 static std::unique_ptr<RuntimeDyldMachO> 882 createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, 883 RuntimeDyld::SymbolResolver &Resolver, 884 bool ProcessAllSections, 885 RuntimeDyldCheckerImpl *Checker) { 886 std::unique_ptr<RuntimeDyldMachO> Dyld = 887 RuntimeDyldMachO::create(Arch, MM, Resolver); 888 Dyld->setProcessAllSections(ProcessAllSections); 889 Dyld->setRuntimeDyldChecker(Checker); 890 return Dyld; 891 } 892 893 std::unique_ptr<RuntimeDyld::LoadedObjectInfo> 894 RuntimeDyld::loadObject(const ObjectFile &Obj) { 895 if (!Dyld) { 896 if (Obj.isELF()) 897 Dyld = createRuntimeDyldELF(MemMgr, Resolver, ProcessAllSections, Checker); 898 else if (Obj.isMachO()) 899 Dyld = createRuntimeDyldMachO( 900 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver, 901 ProcessAllSections, Checker); 902 else if (Obj.isCOFF()) 903 Dyld = createRuntimeDyldCOFF( 904 static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver, 905 ProcessAllSections, Checker); 906 else 907 report_fatal_error("Incompatible object format!"); 908 } 909 910 if (!Dyld->isCompatibleFile(Obj)) 911 report_fatal_error("Incompatible object format!"); 912 913 return Dyld->loadObject(Obj); 914 } 915 916 void *RuntimeDyld::getSymbolLocalAddress(StringRef Name) const { 917 if (!Dyld) 918 return nullptr; 919 return Dyld->getSymbolLocalAddress(Name); 920 } 921 922 RuntimeDyld::SymbolInfo RuntimeDyld::getSymbol(StringRef Name) const { 923 if (!Dyld) 924 return nullptr; 925 return Dyld->getSymbol(Name); 926 } 927 928 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); } 929 930 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) { 931 Dyld->reassignSectionAddress(SectionID, Addr); 932 } 933 934 void RuntimeDyld::mapSectionAddress(const void *LocalAddress, 935 uint64_t TargetAddress) { 936 Dyld->mapSectionAddress(LocalAddress, TargetAddress); 937 } 938 939 bool RuntimeDyld::hasError() { return Dyld->hasError(); } 940 941 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); } 942 943 void RuntimeDyld::registerEHFrames() { 944 if (Dyld) 945 Dyld->registerEHFrames(); 946 } 947 948 void RuntimeDyld::deregisterEHFrames() { 949 if (Dyld) 950 Dyld->deregisterEHFrames(); 951 } 952 953 } // end namespace llvm 954