LCOV - code coverage report
Current view: top level - lib/ExecutionEngine/RuntimeDyld - RuntimeDyld.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 445 504 88.3 %
Date: 2018-10-20 13:21:21 Functions: 40 53 75.5 %
Legend: Lines: hit not hit

          Line data    Source code
       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           0 : class RuntimeDyldErrorCategory : public std::error_category {
      44             : public:
      45           0 :   const char *name() const noexcept override { return "runtimedyld"; }
      46             : 
      47           0 :   std::string message(int Condition) const override {
      48           0 :     switch (static_cast<RuntimeDyldErrorCode>(Condition)) {
      49           0 :       case GenericRTDyldError: return "Generic RuntimeDyld error";
      50             :     }
      51           0 :     llvm_unreachable("Unrecognized RuntimeDyldErrorCode");
      52             :   }
      53             : };
      54             : 
      55             : static ManagedStatic<RuntimeDyldErrorCategory> RTDyldErrorCategory;
      56             : 
      57             : }
      58             : 
      59             : char RuntimeDyldError::ID = 0;
      60             : 
      61           0 : void RuntimeDyldError::log(raw_ostream &OS) const {
      62           0 :   OS << ErrMsg << "\n";
      63           0 : }
      64             : 
      65           0 : std::error_code RuntimeDyldError::convertToErrorCode() const {
      66           0 :   return std::error_code(GenericRTDyldError, *RTDyldErrorCategory);
      67             : }
      68             : 
      69             : // Empty out-of-line virtual destructor as the key function.
      70         684 : RuntimeDyldImpl::~RuntimeDyldImpl() {}
      71             : 
      72             : // Pin LoadedObjectInfo's vtables to this file.
      73           0 : void RuntimeDyld::LoadedObjectInfo::anchor() {}
      74             : 
      75             : namespace llvm {
      76             : 
      77           0 : void RuntimeDyldImpl::registerEHFrames() {}
      78             : 
      79          46 : void RuntimeDyldImpl::deregisterEHFrames() {
      80          46 :   MemMgr.deregisterEHFrames();
      81          46 : }
      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         446 : 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         892 :   if (auto Err = resolveExternalSymbols()) {
     133           0 :     HasError = true;
     134           0 :     ErrorStr = toString(std::move(Err));
     135             :   }
     136             : 
     137         446 :   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         446 : }
     143             : 
     144         477 : void RuntimeDyldImpl::resolveLocalRelocations() {
     145             :   // Iterate over all outstanding relocations
     146         973 :   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         496 :     int Idx = it->first;
     151         496 :     uint64_t Addr = Sections[Idx].getLoadAddress();
     152             :     LLVM_DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
     153             :                       << format("%p", (uintptr_t)Addr) << "\n");
     154         496 :     resolveRelocationList(it->second, Addr);
     155             :   }
     156             :   Relocations.clear();
     157         477 : }
     158             : 
     159         218 : void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
     160             :                                         uint64_t TargetAddress) {
     161             :   MutexGuard locked(lock);
     162         577 :   for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
     163        1154 :     if (Sections[i].getAddress() == LocalAddress) {
     164         218 :       reassignSectionAddress(i, TargetAddress);
     165         218 :       return;
     166             :     }
     167             :   }
     168           0 :   llvm_unreachable("Attempting to remap address of unknown section!");
     169             : }
     170             : 
     171         825 : static Error getOffset(const SymbolRef &Sym, SectionRef Sec,
     172             :                        uint64_t &Result) {
     173             :   Expected<uint64_t> AddressOrErr = Sym.getAddress();
     174         825 :   if (!AddressOrErr)
     175             :     return AddressOrErr.takeError();
     176         825 :   Result = *AddressOrErr - Sec.getAddress();
     177             :   return Error::success();
     178             : }
     179             : 
     180             : Expected<RuntimeDyldImpl::ObjSectionToIDMap>
     181         350 : RuntimeDyldImpl::loadObjectImpl(const object::ObjectFile &Obj) {
     182             :   MutexGuard locked(lock);
     183             : 
     184             :   // Save information about our target
     185         350 :   Arch = (Triple::ArchType)Obj.getArch();
     186         350 :   IsTargetLittleEndian = Obj.isLittleEndian();
     187         350 :   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         350 :   if (MemMgr.needsToReserveAllocationSpace()) {
     192          31 :     uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0;
     193          31 :     uint32_t CodeAlign = 1, RODataAlign = 1, RWDataAlign = 1;
     194          31 :     if (auto Err = computeTotalAllocSize(Obj,
     195             :                                          CodeSize, CodeAlign,
     196             :                                          RODataSize, RODataAlign,
     197          31 :                                          RWDataSize, RWDataAlign))
     198             :       return std::move(Err);
     199          62 :     MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
     200          31 :                                   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        2551 :     for (auto &Sym : Obj.symbols()) {
     218        2201 :       uint32_t Flags = Sym.getFlags();
     219        2201 :       if ((Flags & SymbolRef::SF_Common) || (Flags & SymbolRef::SF_Weak)) {
     220             :         // Get symbol name.
     221          98 :         if (auto NameOrErr = Sym.getName())
     222             :           Symbols.insert(*NameOrErr);
     223             :         else
     224             :           return NameOrErr.takeError();
     225             :       }
     226             :     }
     227             : 
     228         700 :     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        2551 :   for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
     237             :        ++I) {
     238        2201 :     uint32_t Flags = I->getFlags();
     239             : 
     240             :     // Skip undefined symbols.
     241        2201 :     if (Flags & SymbolRef::SF_Undefined)
     242         653 :       continue;
     243             : 
     244             :     // Get the symbol type.
     245             :     object::SymbolRef::Type SymType;
     246        1637 :     if (auto SymTypeOrErr = I->getType())
     247        1637 :       SymType = *SymTypeOrErr;
     248             :     else
     249             :       return SymTypeOrErr.takeError();
     250             : 
     251             :     // Get symbol name.
     252        1637 :     StringRef Name;
     253        1637 :     if (auto NameOrErr = I->getName())
     254        1637 :       Name = *NameOrErr;
     255             :     else
     256             :       return NameOrErr.takeError();
     257             : 
     258             :     // Compute JIT symbol flags.
     259        1637 :     auto JITSymFlags = getJITSymbolFlags(*I);
     260        1637 :     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        3274 :     if (JITSymFlags->isWeak() || JITSymFlags->isCommon()) {
     268             :       // First check whether there's already a definition in this instance.
     269         195 :       if (GlobalSymbolTable.count(Name))
     270           1 :         continue;
     271             : 
     272             :       // If we're not responsible for this symbol, skip it.
     273             :       if (!ResponsibilitySet.count(Name))
     274           3 :         continue;
     275             : 
     276             :       // Otherwise update the flags on the symbol to make this definition
     277             :       // strong.
     278         188 :       if (JITSymFlags->isWeak())
     279             :         *JITSymFlags &= ~JITSymbolFlags::Weak;
     280         188 :       if (JITSymFlags->isCommon()) {
     281             :         *JITSymFlags &= ~JITSymbolFlags::Common;
     282             :         uint32_t Align = I->getAlignment();
     283             :         uint64_t Size = I->getCommonSize();
     284          85 :         if (!CommonAlign)
     285             :           CommonAlign = Align;
     286          85 :         CommonSize = alignTo(CommonSize, Align) + Size;
     287          85 :         CommonSymbolsToAllocate.push_back(*I);
     288             :       }
     289             :     }
     290             : 
     291        1633 :     if (Flags & SymbolRef::SF_Absolute &&
     292             :         SymType != object::SymbolRef::ST_File) {
     293             :       uint64_t Addr = 0;
     294           1 :       if (auto AddrOrErr = I->getAddress())
     295           1 :         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           1 :       GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, *JITSymFlags);
     306        3264 :     } else if (SymType == object::SymbolRef::ST_Function ||
     307        1632 :                SymType == object::SymbolRef::ST_Data ||
     308        1758 :                SymType == object::SymbolRef::ST_Unknown ||
     309         879 :                SymType == object::SymbolRef::ST_Other) {
     310             : 
     311         910 :       section_iterator SI = Obj.section_end();
     312         910 :       if (auto SIOrErr = I->getSection())
     313         910 :         SI = *SIOrErr;
     314             :       else
     315             :         return SIOrErr.takeError();
     316             : 
     317         910 :       if (SI == Obj.section_end())
     318          85 :         continue;
     319             : 
     320             :       // Get symbol offset.
     321             :       uint64_t SectOffset;
     322        1650 :       if (auto Err = getOffset(*I, *SI, SectOffset))
     323             :         return std::move(Err);
     324             : 
     325         825 :       bool IsCode = SI->isText();
     326             :       unsigned SectionID;
     327         825 :       if (auto SectionIDOrErr =
     328         825 :               findOrEmitSection(Obj, *SI, IsCode, LocalSections))
     329         825 :         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         825 :       GlobalSymbolTable[Name] =
     338         825 :           SymbolTableEntry(SectionID, SectOffset, *JITSymFlags);
     339             :     }
     340             :   }
     341             : 
     342             :   // Allocate common symbols
     343         350 :   if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
     344         350 :                                    CommonAlign))
     345             :     return std::move(Err);
     346             : 
     347             :   // Parse and process relocations
     348             :   LLVM_DEBUG(dbgs() << "Parse relocations:\n");
     349         350 :   for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
     350        3184 :        SI != SE; ++SI) {
     351             :     StubMap Stubs;
     352        2834 :     section_iterator RelocatedSection = SI->getRelocatedSection();
     353             : 
     354        2834 :     if (RelocatedSection == SE)
     355             :       continue;
     356             : 
     357         613 :     relocation_iterator I = SI->relocation_begin();
     358         613 :     relocation_iterator E = SI->relocation_end();
     359             : 
     360         613 :     if (I == E && !ProcessAllSections)
     361             :       continue;
     362             : 
     363         583 :     bool IsCode = RelocatedSection->isText();
     364             :     unsigned SectionID = 0;
     365         583 :     if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode,
     366         583 :                                                 LocalSections))
     367         583 :       SectionID = *SectionIDOrErr;
     368             :     else
     369             :       return SectionIDOrErr.takeError();
     370             : 
     371             :     LLVM_DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
     372             : 
     373        1917 :     for (; I != E;)
     374        1334 :       if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs))
     375        1334 :         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         583 :     if (Checker)
     382         118 :       Checker->registerStubMap(Obj.getFileName(), SectionID, Stubs);
     383             :   }
     384             : 
     385             :   // Give the subclasses a chance to tie-up any loose ends.
     386         700 :   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         160 :   for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
     403             :     uint64_t AlignedSize =
     404          67 :         (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
     405          67 :     TotalSize += AlignedSize;
     406             :   }
     407             :   return TotalSize;
     408             : }
     409             : 
     410        1044 : static bool isRequiredForExecution(const SectionRef Section) {
     411        1044 :   const ObjectFile *Obj = Section.getObject();
     412        1044 :   if (isa<object::ELFObjectFileBase>(Obj))
     413         987 :     return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
     414             :   if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
     415          17 :     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          17 :         (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
     423             :     bool IsDiscardable =
     424          17 :         CoffSection->Characteristics &
     425             :         (COFF::IMAGE_SCN_MEM_DISCARDABLE | COFF::IMAGE_SCN_LNK_INFO);
     426          17 :     return HasContent && !IsDiscardable;
     427             :   }
     428             : 
     429             :   assert(isa<MachOObjectFile>(Obj));
     430             :   return true;
     431             : }
     432             : 
     433         880 : static bool isReadOnlyData(const SectionRef Section) {
     434         880 :   const ObjectFile *Obj = Section.getObject();
     435         880 :   if (isa<object::ELFObjectFileBase>(Obj))
     436        1646 :     return !(ELFSectionRef(Section).getFlags() &
     437         823 :              (ELF::SHF_WRITE | ELF::SHF_EXECINSTR));
     438             :   if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
     439          17 :     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          17 :              | COFF::IMAGE_SCN_MEM_READ));
     446             : 
     447             :   assert(isa<MachOObjectFile>(Obj));
     448             :   return false;
     449             : }
     450             : 
     451         821 : static bool isZeroInit(const SectionRef Section) {
     452         821 :   const ObjectFile *Obj = Section.getObject();
     453         821 :   if (isa<object::ELFObjectFileBase>(Obj))
     454         764 :     return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
     455             :   if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
     456          17 :     return COFFObj->getCOFFSection(Section)->Characteristics &
     457          17 :             COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA;
     458             : 
     459             :   auto *MachO = cast<MachOObjectFile>(Obj);
     460          40 :   unsigned SectionType = MachO->getSectionType(Section);
     461          40 :   return SectionType == MachO::S_ZEROFILL ||
     462          40 :          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          31 : 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          31 :   for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
     482         254 :        SI != SE; ++SI) {
     483             :     const SectionRef &Section = *SI;
     484             : 
     485         223 :     bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections;
     486             : 
     487             :     // Consider only the sections that are required to be loaded for execution
     488             :     if (IsRequired) {
     489          59 :       uint64_t DataSize = Section.getSize();
     490          59 :       uint64_t Alignment64 = Section.getAlignment();
     491          59 :       unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
     492          59 :       bool IsCode = Section.isText();
     493          59 :       bool IsReadOnly = isReadOnlyData(Section);
     494             : 
     495          59 :       StringRef Name;
     496          59 :       if (auto EC = Section.getName(Name))
     497           0 :         return errorCodeToError(EC);
     498             : 
     499          59 :       uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
     500          59 :       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           5 :         SectionSize += 4;
     509             : 
     510          59 :       if (!SectionSize)
     511           0 :         SectionSize = 1;
     512             : 
     513          59 :       if (IsCode) {
     514          31 :         CodeAlign = std::max(CodeAlign, Alignment);
     515          31 :         CodeSectionSizes.push_back(SectionSize);
     516          28 :       } else if (IsReadOnly) {
     517          17 :         RODataAlign = std::max(RODataAlign, Alignment);
     518          17 :         ROSectionSizes.push_back(SectionSize);
     519             :       } else {
     520          11 :         RWDataAlign = std::max(RWDataAlign, Alignment);
     521          11 :         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          31 :   if (unsigned GotSize = computeGOTSize(Obj)) {
     530           4 :     RWSectionSizes.push_back(GotSize);
     531           6 :     RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
     532             :   }
     533             : 
     534             :   // Compute the size of all common symbols
     535          31 :   uint64_t CommonSize = 0;
     536          31 :   uint32_t CommonAlign = 1;
     537         205 :   for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
     538             :        ++I) {
     539         174 :     uint32_t Flags = I->getFlags();
     540         174 :     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           8 :       if (CommonSize == 0)
     547           4 :         CommonAlign = Align;
     548          16 :       CommonSize = alignTo(CommonSize, Align) + Size;
     549             :     }
     550             :   }
     551          31 :   if (CommonSize != 0) {
     552           4 :     RWSectionSizes.push_back(CommonSize);
     553           4 :     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          31 :   CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
     562          31 :   RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
     563          62 :   RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
     564             : 
     565             :   return Error::success();
     566             : }
     567             : 
     568             : // compute GOT size
     569          31 : unsigned RuntimeDyldImpl::computeGOTSize(const ObjectFile &Obj) {
     570          31 :   size_t GotEntrySize = getGOTEntrySize();
     571          31 :   if (!GotEntrySize)
     572             :     return 0;
     573             : 
     574             :   size_t GotSize = 0;
     575          31 :   for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
     576         254 :        SI != SE; ++SI) {
     577             : 
     578         321 :     for (const RelocationRef &Reloc : SI->relocations())
     579          98 :       if (relocationNeedsGot(Reloc))
     580           6 :         GotSize += GotEntrySize;
     581             :   }
     582             : 
     583          31 :   return GotSize;
     584             : }
     585             : 
     586             : // compute stub buffer size for the given section
     587         880 : unsigned RuntimeDyldImpl::computeSectionStubBufSize(const ObjectFile &Obj,
     588             :                                                     const SectionRef &Section) {
     589         880 :   unsigned StubSize = getMaxStubSize();
     590         880 :   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         871 :   for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
     598        8830 :        SI != SE; ++SI) {
     599        7959 :     section_iterator RelSecI = SI->getRelocatedSection();
     600       15918 :     if (!(RelSecI == Section))
     601        7338 :       continue;
     602             : 
     603        2054 :     for (const RelocationRef &Reloc : SI->relocations())
     604        1433 :       if (relocationNeedsStub(Reloc))
     605         421 :         StubBufSize += StubSize;
     606             :   }
     607             : 
     608             :   // Get section data size and alignment
     609         871 :   uint64_t DataSize = Section.getSize();
     610         871 :   uint64_t Alignment64 = Section.getAlignment();
     611             : 
     612             :   // Add stubbuf size alignment
     613         871 :   unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
     614         871 :   unsigned StubAlignment = getStubAlignment();
     615         871 :   unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
     616         871 :   if (StubAlignment > EndAlignment)
     617           4 :     StubBufSize += StubAlignment - EndAlignment;
     618             :   return StubBufSize;
     619             : }
     620             : 
     621         393 : uint64_t RuntimeDyldImpl::readBytesUnaligned(uint8_t *Src,
     622             :                                              unsigned Size) const {
     623             :   uint64_t Result = 0;
     624         393 :   if (IsTargetLittleEndian) {
     625         282 :     Src += Size - 1;
     626        1600 :     while (Size--)
     627        1318 :       Result = (Result << 8) | *Src--;
     628             :   } else
     629         587 :     while (Size--)
     630         476 :       Result = (Result << 8) | *Src++;
     631             : 
     632         393 :   return Result;
     633             : }
     634             : 
     635         259 : void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
     636             :                                           unsigned Size) const {
     637         259 :   if (IsTargetLittleEndian) {
     638        1012 :     while (Size--) {
     639         836 :       *Dst++ = Value & 0xFF;
     640         836 :       Value >>= 8;
     641             :     }
     642             :   } else {
     643          83 :     Dst += Size - 1;
     644         439 :     while (Size--) {
     645         356 :       *Dst-- = Value & 0xFF;
     646         356 :       Value >>= 8;
     647             :     }
     648             :   }
     649         259 : }
     650             : 
     651             : Expected<JITSymbolFlags>
     652        1722 : RuntimeDyldImpl::getJITSymbolFlags(const SymbolRef &SR) {
     653        1722 :   return JITSymbolFlags::fromObjectSymbol(SR);
     654             : }
     655             : 
     656         350 : Error RuntimeDyldImpl::emitCommonSymbols(const ObjectFile &Obj,
     657             :                                          CommonSymbolList &SymbolsToAllocate,
     658             :                                          uint64_t CommonSize,
     659             :                                          uint32_t CommonAlign) {
     660         350 :   if (SymbolsToAllocate.empty())
     661             :     return Error::success();
     662             : 
     663             :   // Allocate memory for the section
     664          25 :   unsigned SectionID = Sections.size();
     665          25 :   uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
     666          25 :                                              "<common symbols>", false);
     667          25 :   if (!Addr)
     668           0 :     report_fatal_error("Unable to allocate memory for common symbols!");
     669             :   uint64_t Offset = 0;
     670          25 :   Sections.push_back(
     671          25 :       SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
     672          25 :   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         110 :   for (auto &Sym : SymbolsToAllocate) {
     680             :     uint32_t Align = Sym.getAlignment();
     681             :     uint64_t Size = Sym.getCommonSize();
     682             :     StringRef Name;
     683          85 :     if (auto NameOrErr = Sym.getName())
     684          85 :       Name = *NameOrErr;
     685             :     else
     686             :       return NameOrErr.takeError();
     687          85 :     if (Align) {
     688             :       // This symbol has an alignment requirement.
     689          85 :       uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
     690          85 :       Addr += AlignOffset;
     691          85 :       Offset += AlignOffset;
     692             :     }
     693          85 :     auto JITSymFlags = getJITSymbolFlags(Sym);
     694             : 
     695          85 :     if (!JITSymFlags)
     696             :       return JITSymFlags.takeError();
     697             : 
     698             :     LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
     699             :                       << format("%p", Addr) << "\n");
     700          85 :     GlobalSymbolTable[Name] =
     701             :         SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
     702          85 :     Offset += Size;
     703          85 :     Addr += Size;
     704             :   }
     705             : 
     706          25 :   if (Checker)
     707          10 :     Checker->registerSection(Obj.getFileName(), SectionID);
     708             : 
     709             :   return Error::success();
     710             : }
     711             : 
     712             : Expected<unsigned>
     713         821 : RuntimeDyldImpl::emitSection(const ObjectFile &Obj,
     714             :                              const SectionRef &Section,
     715             :                              bool IsCode) {
     716         821 :   StringRef data;
     717         821 :   uint64_t Alignment64 = Section.getAlignment();
     718             : 
     719         821 :   unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
     720             :   unsigned PaddingSize = 0;
     721             :   unsigned StubBufSize = 0;
     722         821 :   bool IsRequired = isRequiredForExecution(Section);
     723         821 :   bool IsVirtual = Section.isVirtual();
     724         821 :   bool IsZeroInit = isZeroInit(Section);
     725         821 :   bool IsReadOnly = isReadOnlyData(Section);
     726         821 :   uint64_t DataSize = Section.getSize();
     727             : 
     728         821 :   StringRef Name;
     729         821 :   if (auto EC = Section.getName(Name))
     730           0 :     return errorCodeToError(EC);
     731             : 
     732         821 :   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         821 :   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         821 :   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         796 :     if (auto EC = Section.getContents(data))
     751           0 :       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         821 :   if (IsCode) {
     759         347 :     Alignment = std::max(Alignment, getStubAlignment());
     760         347 :     if (StubBufSize > 0)
     761          43 :       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         821 :   if (IsRequired || ProcessAllSections) {
     767         803 :     Allocate = DataSize + PaddingSize + StubBufSize;
     768         803 :     if (!Allocate)
     769             :       Allocate = 1;
     770         803 :     Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
     771         347 :                                                Name)
     772         912 :                   : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
     773         456 :                                                Name, IsReadOnly);
     774         803 :     if (!Addr)
     775           0 :       report_fatal_error("Unable to allocate section memory!");
     776             : 
     777             :     // Zero-initialize or copy the data from the image
     778         803 :     if (IsZeroInit || IsVirtual)
     779          25 :       memset(Addr, 0, DataSize);
     780             :     else
     781         778 :       memcpy(Addr, pData, DataSize);
     782             : 
     783             :     // Fill in any extra bytes we allocated for padding
     784         803 :     if (PaddingSize != 0) {
     785         256 :       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         256 :       if (StubBufSize > 0)
     792          19 :         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         821 :   Sections.push_back(
     814         821 :       SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
     815             : 
     816             :   // Debug info sections are linked as if their load address was zero
     817         821 :   if (!IsRequired)
     818             :     Sections.back().setLoadAddress(0);
     819             : 
     820         821 :   if (Checker)
     821         152 :     Checker->registerSection(Obj.getFileName(), SectionID);
     822             : 
     823             :   return SectionID;
     824             : }
     825             : 
     826             : Expected<unsigned>
     827        2190 : 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        2190 :   if (i != LocalSections.end())
     835        1369 :     SectionID = i->second;
     836             :   else {
     837         821 :     if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
     838         821 :       SectionID = *SectionIDOrErr;
     839             :     else
     840             :       return SectionIDOrErr.takeError();
     841         821 :     LocalSections[Section] = SectionID;
     842             :   }
     843             :   return SectionID;
     844             : }
     845             : 
     846        1099 : void RuntimeDyldImpl::addRelocationForSection(const RelocationEntry &RE,
     847             :                                               unsigned SectionID) {
     848        1099 :   Relocations[SectionID].push_back(RE);
     849        1099 : }
     850             : 
     851         296 : 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         296 :   RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
     857         592 :   if (Loc == GlobalSymbolTable.end()) {
     858         293 :     ExternalSymbolRelocations[SymbolName].push_back(RE);
     859             :   } else {
     860             :     // Copy the RE since we want to modify its addend.
     861           3 :     RelocationEntry RECopy = RE;
     862             :     const auto &SymInfo = Loc->second;
     863           3 :     RECopy.Addend += SymInfo.getOffset();
     864           3 :     Relocations[SymInfo.getSectionID()].push_back(RECopy);
     865             :   }
     866         296 : }
     867             : 
     868          21 : uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
     869             :                                              unsigned AbiVariant) {
     870          21 :   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           0 :     writeBytesUnaligned(0xd2e00010, Addr,    4); // movz ip0, #:abs_g3:<addr>
     876           0 :     writeBytesUnaligned(0xf2c00010, Addr+4,  4); // movk ip0, #:abs_g2_nc:<addr>
     877           0 :     writeBytesUnaligned(0xf2a00010, Addr+8,  4); // movk ip0, #:abs_g1_nc:<addr>
     878           0 :     writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
     879           0 :     writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
     880             : 
     881           0 :     return Addr;
     882          21 :   } 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           0 :     writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
     886           0 :     return Addr + 4;
     887          21 :   } 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           4 :     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           4 :     writeBytesUnaligned(LuiT9Instr, Addr, 4);
     900           4 :     writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
     901           4 :     writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
     902           4 :     writeBytesUnaligned(NopInstr, Addr + 12, 4);
     903           4 :     return Addr;
     904          17 :   } 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           2 :     if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
     918             :       JrT9Instr = 0x03200009;
     919             : 
     920           2 :     writeBytesUnaligned(LuiT9Instr, Addr, 4);
     921           2 :     writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
     922           2 :     writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
     923           2 :     writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
     924           2 :     writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
     925           2 :     writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
     926           2 :     writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
     927           2 :     writeBytesUnaligned(NopInstr, Addr + 28, 4);
     928           2 :     return Addr;
     929          15 :   } 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           3 :     writeInt32BE(Addr,    0x3D800000); // lis   r12, highest(addr)
     934           3 :     writeInt32BE(Addr+4,  0x618C0000); // ori   r12, higher(addr)
     935           3 :     writeInt32BE(Addr+8,  0x798C07C6); // sldi  r12, r12, 32
     936           3 :     writeInt32BE(Addr+12, 0x658C0000); // oris  r12, r12, h(addr)
     937           3 :     writeInt32BE(Addr+16, 0x618C0000); // ori   r12, r12, l(addr)
     938           3 :     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           3 :       writeInt32BE(Addr+20, 0xF8410018); // std   r2,  24(r1)
     942           3 :       writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
     943           3 :       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           0 :       writeInt32BE(Addr+20, 0xF8410028); // std   r2,  40(r1)
     949           0 :       writeInt32BE(Addr+24, 0xE96C0000); // ld    r11, 0(r12)
     950           0 :       writeInt32BE(Addr+28, 0xE84C0008); // ld    r2,  0(r12)
     951           0 :       writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
     952           0 :       writeInt32BE(Addr+36, 0xE96C0010); // ld    r11, 16(r2)
     953           0 :       writeInt32BE(Addr+40, 0x4E800420); // bctr
     954             :     }
     955           3 :     return Addr;
     956          12 :   } 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           0 :     return Addr;
     963          12 :   } else if (Arch == Triple::x86_64) {
     964          11 :     *Addr      = 0xFF; // jmp
     965          11 :     *(Addr+1)  = 0x25; // rip
     966             :     // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
     967           1 :   } else if (Arch == Triple::x86) {
     968           1 :     *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         218 : 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         218 :   Sections[SectionID].setLoadAddress(Addr);
     993         218 : }
     994             : 
     995         690 : void RuntimeDyldImpl::resolveRelocationList(const RelocationList &Relocs,
     996             :                                             uint64_t Value) {
     997        2081 :   for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
     998        1391 :     const RelocationEntry &RE = Relocs[i];
     999             :     // Ignore relocations for sections that were not loaded
    1000        2782 :     if (Sections[RE.SectionID].getAddress() == nullptr)
    1001             :       continue;
    1002        1201 :     resolveRelocation(RE, Value);
    1003             :   }
    1004         690 : }
    1005             : 
    1006         477 : void RuntimeDyldImpl::applyExternalSymbolRelocations(
    1007             :     const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
    1008         675 :   while (!ExternalSymbolRelocations.empty()) {
    1009             : 
    1010         198 :     StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
    1011             : 
    1012         198 :     StringRef Name = i->first();
    1013         198 :     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           0 :       RelocationList &Relocs = i->second;
    1018           0 :       resolveRelocationList(Relocs, 0);
    1019             :     } else {
    1020             :       uint64_t Addr = 0;
    1021         198 :       JITSymbolFlags Flags;
    1022         198 :       RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
    1023         396 :       if (Loc == GlobalSymbolTable.end()) {
    1024         159 :         auto RRI = ExternalSymbolMap.find(Name);
    1025             :         assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
    1026         159 :         Addr = RRI->second.getAddress();
    1027         159 :         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         159 :         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          39 :         Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
    1040          39 :                SymInfo.getOffset();
    1041          39 :         Flags = SymInfo.getFlags();
    1042             :       }
    1043             : 
    1044             :       // FIXME: Implement error handling that doesn't kill the host program!
    1045         198 :       if (!Addr)
    1046           0 :         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         198 :       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         194 :         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         194 :         RelocationList &Relocs = i->second;
    1063         194 :         resolveRelocationList(Relocs, Addr);
    1064             :       }
    1065             :     }
    1066             : 
    1067             :     ExternalSymbolRelocations.erase(i);
    1068             :   }
    1069         477 : }
    1070             : 
    1071         446 : Error RuntimeDyldImpl::resolveExternalSymbols() {
    1072         446 :   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        1375 :       for (auto &RelocKV : ExternalSymbolRelocations) {
    1083         321 :         StringRef Name = RelocKV.first();
    1084         642 :         if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
    1085             :             !ResolvedSymbols.count(Name))
    1086             :           NewSymbols.insert(Name);
    1087             :       }
    1088             : 
    1089         527 :       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         162 :       Resolver.lookup(NewSymbols,
    1102           0 :                       [=](Expected<JITSymbolResolver::LookupResult> Result) {
    1103          81 :                         NewSymbolsP->set_value(std::move(Result));
    1104          81 :                       });
    1105             : 
    1106         162 :       auto NewResolverResults = NewSymbolsF.get();
    1107             : 
    1108          81 :       if (!NewResolverResults)
    1109           0 :         return NewResolverResults.takeError();
    1110             : 
    1111             :       assert(NewResolverResults->size() == NewSymbols.size() &&
    1112             :              "Should have errored on unresolved symbols");
    1113             : 
    1114         226 :       for (auto &RRKV : *NewResolverResults) {
    1115             :         assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
    1116         145 :         ExternalSymbolMap.insert(RRKV);
    1117         145 :         ResolvedSymbols.insert(RRKV.first);
    1118             :       }
    1119             :     }
    1120             :   }
    1121             : 
    1122         446 :   applyExternalSymbolRelocations(ExternalSymbolMap);
    1123             : 
    1124             :   return Error::success();
    1125             : }
    1126             : 
    1127          31 : 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           0 :       [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          31 :       };
    1159             : 
    1160             :   JITSymbolResolver::LookupSet Symbols;
    1161             : 
    1162          88 :   for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
    1163          26 :     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          31 :   if (!Symbols.empty()) {
    1172          42 :     SharedThis->Resolver.lookup(Symbols, PostResolveContinuation);
    1173             :   } else
    1174          17 :     PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>());
    1175          31 : }
    1176             : 
    1177             : //===----------------------------------------------------------------------===//
    1178             : // RuntimeDyld class implementation
    1179             : 
    1180        1102 : uint64_t RuntimeDyld::LoadedObjectInfo::getSectionLoadAddress(
    1181             :                                           const object::SectionRef &Sec) const {
    1182             : 
    1183             :   auto I = ObjSecToIDMap.find(Sec);
    1184        1102 :   if (I != ObjSecToIDMap.end())
    1185         780 :     return RTDyld.Sections[I->second].getLoadAddress();
    1186             : 
    1187             :   return 0;
    1188             : }
    1189             : 
    1190           0 : void RuntimeDyld::MemoryManager::anchor() {}
    1191           0 : void JITSymbolResolver::anchor() {}
    1192           0 : void LegacyJITSymbolResolver::anchor() {}
    1193             : 
    1194         306 : RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
    1195         306 :                          JITSymbolResolver &Resolver)
    1196         306 :     : 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         306 :   ProcessAllSections = false;
    1205         306 :   Checker = nullptr;
    1206         306 : }
    1207             : 
    1208         234 : 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           4 :     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         284 :       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          11 :     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         350 : RuntimeDyld::loadObject(const ObjectFile &Obj) {
    1246         350 :   if (!Dyld) {
    1247         598 :     if (Obj.isELF())
    1248             :       Dyld =
    1249         284 :           createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
    1250         284 :                                MemMgr, Resolver, ProcessAllSections, Checker);
    1251          15 :     else if (Obj.isMachO())
    1252          11 :       Dyld = createRuntimeDyldMachO(
    1253          11 :                static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
    1254          11 :                ProcessAllSections, Checker);
    1255           4 :     else if (Obj.isCOFF())
    1256           4 :       Dyld = createRuntimeDyldCOFF(
    1257           4 :                static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
    1258           4 :                ProcessAllSections, Checker);
    1259             :     else
    1260           0 :       report_fatal_error("Incompatible object format!");
    1261             :   }
    1262             : 
    1263         350 :   if (!Dyld->isCompatibleFile(Obj))
    1264           0 :     report_fatal_error("Incompatible object format!");
    1265             : 
    1266         350 :   auto LoadedObjInfo = Dyld->loadObject(Obj);
    1267         350 :   MemMgr.notifyObjectLoaded(*this, Obj);
    1268         350 :   return LoadedObjInfo;
    1269             : }
    1270             : 
    1271           0 : void *RuntimeDyld::getSymbolLocalAddress(StringRef Name) const {
    1272           0 :   if (!Dyld)
    1273             :     return nullptr;
    1274           0 :   return Dyld->getSymbolLocalAddress(Name);
    1275             : }
    1276             : 
    1277         386 : JITEvaluatedSymbol RuntimeDyld::getSymbol(StringRef Name) const {
    1278         386 :   if (!Dyld)
    1279             :     return nullptr;
    1280         352 :   return Dyld->getSymbol(Name);
    1281             : }
    1282             : 
    1283         133 : std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
    1284         133 :   if (!Dyld)
    1285           0 :     return std::map<StringRef, JITEvaluatedSymbol>();
    1286         133 :   return Dyld->getSymbolTable();
    1287             : }
    1288             : 
    1289         892 : void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
    1290             : 
    1291           0 : void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
    1292           0 :   Dyld->reassignSectionAddress(SectionID, Addr);
    1293           0 : }
    1294             : 
    1295         218 : void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
    1296             :                                     uint64_t TargetAddress) {
    1297         218 :   Dyld->mapSectionAddress(LocalAddress, TargetAddress);
    1298         218 : }
    1299             : 
    1300         784 : bool RuntimeDyld::hasError() { return Dyld->hasError(); }
    1301             : 
    1302           0 : StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
    1303             : 
    1304         102 : void RuntimeDyld::finalizeWithMemoryManagerLocking() {
    1305         102 :   bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
    1306         102 :   MemMgr.FinalizationLocked = true;
    1307         102 :   resolveRelocations();
    1308         102 :   registerEHFrames();
    1309         102 :   if (!MemoryFinalizationLocked) {
    1310          84 :     MemMgr.finalizeMemory();
    1311          84 :     MemMgr.FinalizationLocked = false;
    1312             :   }
    1313         102 : }
    1314             : 
    1315         439 : void RuntimeDyld::registerEHFrames() {
    1316         439 :   if (Dyld)
    1317         439 :     Dyld->registerEHFrames();
    1318         439 : }
    1319             : 
    1320          49 : void RuntimeDyld::deregisterEHFrames() {
    1321          49 :   if (Dyld)
    1322          46 :     Dyld->deregisterEHFrames();
    1323          49 : }
    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          31 : 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          62 :   RuntimeDyld RTDyld(MemMgr, Resolver);
    1338             :   RTDyld.setProcessAllSections(ProcessAllSections);
    1339             : 
    1340          31 :   auto Info = RTDyld.loadObject(Obj);
    1341             : 
    1342          31 :   if (RTDyld.hasError()) {
    1343           0 :     OnEmitted(make_error<StringError>(RTDyld.getErrorString(),
    1344           0 :                                       inconvertibleErrorCode()));
    1345             :     return;
    1346             :   }
    1347             : 
    1348          62 :   if (auto Err = OnLoaded(std::move(Info), RTDyld.getSymbolTable()))
    1349           0 :     OnEmitted(std::move(Err));
    1350             : 
    1351          93 :   RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
    1352             :                                  std::move(UnderlyingBuffer));
    1353             : }
    1354             : 
    1355             : } // end namespace llvm

Generated by: LCOV version 1.13