contrib/llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

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