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