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