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

   1 //===-- RuntimeDyldELF.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 ELF support for the MC-JIT runtime dynamic linker.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "RuntimeDyldELF.h"
  15 #include "RuntimeDyldCheckerImpl.h"
  16 #include "Targets/RuntimeDyldELFMips.h"
  17 #include "llvm/ADT/IntervalMap.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/Triple.h"
  21 #include "llvm/MC/MCStreamer.h"
  22 #include "llvm/Object/ELFObjectFile.h"
  23 #include "llvm/Object/ObjectFile.h"
  24 #include "llvm/Support/ELF.h"
  25 #include "llvm/Support/Endian.h"
  26 #include "llvm/Support/MemoryBuffer.h"
  27 #include "llvm/Support/TargetRegistry.h"
  28
  29 using namespace llvm;
  30 using namespace llvm::object;
  31 using namespace llvm::support::endian;
  32
  33 #define DEBUG_TYPE "dyld"
  34
  35 static void or32le(void *P, int32_t V) { write32le(P, read32le(P) | V); }
  36
  37 static void or32AArch64Imm(void *L, uint64_t Imm) {
  38   or32le(L, (Imm & 0xFFF) << 10);
  39 }
  40
  41 template <class T> static void write(bool isBE, void *P, T V) {
  42   isBE ? write<T, support::big>(P, V) : write<T, support::little>(P, V);
  43 }
  44
  45 static void write32AArch64Addr(void *L, uint64_t Imm) {
  46   uint32_t ImmLo = (Imm & 0x3) << 29;
  47   uint32_t ImmHi = (Imm & 0x1FFFFC) << 3;
  48   uint64_t Mask = (0x3 << 29) | (0x1FFFFC << 3);
  49   write32le(L, (read32le(L) & ~Mask) | ImmLo | ImmHi);
  50 }
  51
  52 // Return the bits [Start, End] from Val shifted Start bits.
  53 // For instance, getBits(0xF0, 4, 8) returns 0xF.
  54 static uint64_t getBits(uint64_t Val, int Start, int End) {
  55   uint64_t Mask = ((uint64_t)1 << (End + 1 - Start)) - 1;
  56   return (Val >> Start) & Mask;
  57 }
  58
  59 namespace {
  60
  61 template <class ELFT> class DyldELFObject : public ELFObjectFile<ELFT> {
  62   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
  63
  64   typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
  65   typedef Elf_Sym_Impl<ELFT> Elf_Sym;
  66   typedef Elf_Rel_Impl<ELFT, false> Elf_Rel;
  67   typedef Elf_Rel_Impl<ELFT, true> Elf_Rela;
  68
  69   typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
  70
  71   typedef typename ELFDataTypeTypedefHelper<ELFT>::value_type addr_type;
  72
  73 public:
  74   DyldELFObject(MemoryBufferRef Wrapper, std::error_code &ec);
  75
  76   void updateSectionAddress(const SectionRef &Sec, uint64_t Addr);
  77
  78   void updateSymbolAddress(const SymbolRef &SymRef, uint64_t Addr);
  79
  80   // Methods for type inquiry through isa, cast and dyn_cast
  81   static inline bool classof(const Binary *v) {
  82     return (isa<ELFObjectFile<ELFT>>(v) &&
  83             classof(cast<ELFObjectFile<ELFT>>(v)));
  84   }
  85   static inline bool classof(const ELFObjectFile<ELFT> *v) {
  86     return v->isDyldType();
  87   }
  88 };
  89
  90
  91
  92 // The MemoryBuffer passed into this constructor is just a wrapper around the
  93 // actual memory.  Ultimately, the Binary parent class will take ownership of
  94 // this MemoryBuffer object but not the underlying memory.
  95 template <class ELFT>
  96 DyldELFObject<ELFT>::DyldELFObject(MemoryBufferRef Wrapper, std::error_code &EC)
  97     : ELFObjectFile<ELFT>(Wrapper, EC) {
  98   this->isDyldELFObject = true;
  99 }
 100
 101 template <class ELFT>
 102 void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec,
 103                                                uint64_t Addr) {
 104   DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
 105   Elf_Shdr *shdr =
 106       const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
 107
 108   // This assumes the address passed in matches the target address bitness
 109   // The template-based type cast handles everything else.
 110   shdr->sh_addr = static_cast<addr_type>(Addr);
 111 }
 112
 113 template <class ELFT>
 114 void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef,
 115                                               uint64_t Addr) {
 116
 117   Elf_Sym *sym = const_cast<Elf_Sym *>(
 118       ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl()));
 119
 120   // This assumes the address passed in matches the target address bitness
 121   // The template-based type cast handles everything else.
 122   sym->st_value = static_cast<addr_type>(Addr);
 123 }
 124
 125 class LoadedELFObjectInfo final
 126     : public RuntimeDyld::LoadedObjectInfoHelper<LoadedELFObjectInfo> {
 127 public:
 128   LoadedELFObjectInfo(RuntimeDyldImpl &RTDyld, ObjSectionToIDMap ObjSecToIDMap)
 129       : LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {}
 130
 131   OwningBinary<ObjectFile>
 132   getObjectForDebug(const ObjectFile &Obj) const override;
 133 };
 134
 135 template <typename ELFT>
 136 std::unique_ptr<DyldELFObject<ELFT>>
 137 createRTDyldELFObject(MemoryBufferRef Buffer,
 138                       const ObjectFile &SourceObject,
 139                       const LoadedELFObjectInfo &L,
 140                       std::error_code &ec) {
 141   typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 142   typedef typename ELFDataTypeTypedefHelper<ELFT>::value_type addr_type;
 143
 144   std::unique_ptr<DyldELFObject<ELFT>> Obj =
 145     llvm::make_unique<DyldELFObject<ELFT>>(Buffer, ec);
 146
 147   // Iterate over all sections in the object.
 148   auto SI = SourceObject.section_begin();
 149   for (const auto &Sec : Obj->sections()) {
 150     StringRef SectionName;
 151     Sec.getName(SectionName);
 152     if (SectionName != "") {
 153       DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
 154       Elf_Shdr *shdr = const_cast<Elf_Shdr *>(
 155           reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
 156
 157       if (uint64_t SecLoadAddr = L.getSectionLoadAddress(*SI)) {
 158         // This assumes that the address passed in matches the target address
 159         // bitness. The template-based type cast handles everything else.
 160         shdr->sh_addr = static_cast<addr_type>(SecLoadAddr);
 161       }
 162     }
 163     ++SI;
 164   }
 165
 166   return Obj;
 167 }
 168
 169 OwningBinary<ObjectFile> createELFDebugObject(const ObjectFile &Obj,
 170                                               const LoadedELFObjectInfo &L) {
 171   assert(Obj.isELF() && "Not an ELF object file.");
 172
 173   std::unique_ptr<MemoryBuffer> Buffer =
 174     MemoryBuffer::getMemBufferCopy(Obj.getData(), Obj.getFileName());
 175
 176   std::error_code ec;
 177
 178   std::unique_ptr<ObjectFile> DebugObj;
 179   if (Obj.getBytesInAddress() == 4 && Obj.isLittleEndian()) {
 180     typedef ELFType<support::little, false> ELF32LE;
 181     DebugObj = createRTDyldELFObject<ELF32LE>(Buffer->getMemBufferRef(), Obj, L,
 182                                               ec);
 183   } else if (Obj.getBytesInAddress() == 4 && !Obj.isLittleEndian()) {
 184     typedef ELFType<support::big, false> ELF32BE;
 185     DebugObj = createRTDyldELFObject<ELF32BE>(Buffer->getMemBufferRef(), Obj, L,
 186                                               ec);
 187   } else if (Obj.getBytesInAddress() == 8 && !Obj.isLittleEndian()) {
 188     typedef ELFType<support::big, true> ELF64BE;
 189     DebugObj = createRTDyldELFObject<ELF64BE>(Buffer->getMemBufferRef(), Obj, L,
 190                                               ec);
 191   } else if (Obj.getBytesInAddress() == 8 && Obj.isLittleEndian()) {
 192     typedef ELFType<support::little, true> ELF64LE;
 193     DebugObj = createRTDyldELFObject<ELF64LE>(Buffer->getMemBufferRef(), Obj, L,
 194                                               ec);
 195   } else
 196     llvm_unreachable("Unexpected ELF format");
 197
 198   assert(!ec && "Could not construct copy ELF object file");
 199
 200   return OwningBinary<ObjectFile>(std::move(DebugObj), std::move(Buffer));
 201 }
 202
 203 OwningBinary<ObjectFile>
 204 LoadedELFObjectInfo::getObjectForDebug(const ObjectFile &Obj) const {
 205   return createELFDebugObject(Obj, *this);
 206 }
 207
 208 } // anonymous namespace
 209
 210 namespace llvm {
 211
 212 RuntimeDyldELF::RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr,
 213                                JITSymbolResolver &Resolver)
 214     : RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0) {}
 215 RuntimeDyldELF::~RuntimeDyldELF() {}
 216
 217 void RuntimeDyldELF::registerEHFrames() {
 218   for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
 219     SID EHFrameSID = UnregisteredEHFrameSections[i];
 220     uint8_t *EHFrameAddr = Sections[EHFrameSID].getAddress();
 221     uint64_t EHFrameLoadAddr = Sections[EHFrameSID].getLoadAddress();
 222     size_t EHFrameSize = Sections[EHFrameSID].getSize();
 223     MemMgr.registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
 224     RegisteredEHFrameSections.push_back(EHFrameSID);
 225   }
 226   UnregisteredEHFrameSections.clear();
 227 }
 228
 229 void RuntimeDyldELF::deregisterEHFrames() {
 230   for (int i = 0, e = RegisteredEHFrameSections.size(); i != e; ++i) {
 231     SID EHFrameSID = RegisteredEHFrameSections[i];
 232     uint8_t *EHFrameAddr = Sections[EHFrameSID].getAddress();
 233     uint64_t EHFrameLoadAddr = Sections[EHFrameSID].getLoadAddress();
 234     size_t EHFrameSize = Sections[EHFrameSID].getSize();
 235     MemMgr.deregisterEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
 236   }
 237   RegisteredEHFrameSections.clear();
 238 }
 239
 240 std::unique_ptr<RuntimeDyldELF>
 241 llvm::RuntimeDyldELF::create(Triple::ArchType Arch,
 242                              RuntimeDyld::MemoryManager &MemMgr,
 243                              JITSymbolResolver &Resolver) {
 244   switch (Arch) {
 245   default:
 246     return make_unique<RuntimeDyldELF>(MemMgr, Resolver);
 247   case Triple::mips:
 248   case Triple::mipsel:
 249   case Triple::mips64:
 250   case Triple::mips64el:
 251     return make_unique<RuntimeDyldELFMips>(MemMgr, Resolver);
 252   }
 253 }
 254
 255 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
 256 RuntimeDyldELF::loadObject(const object::ObjectFile &O) {
 257   if (auto ObjSectionToIDOrErr = loadObjectImpl(O))
 258     return llvm::make_unique<LoadedELFObjectInfo>(*this, *ObjSectionToIDOrErr);
 259   else {
 260     HasError = true;
 261     raw_string_ostream ErrStream(ErrorStr);
 262     logAllUnhandledErrors(ObjSectionToIDOrErr.takeError(), ErrStream, "");
 263     return nullptr;
 264   }
 265 }
 266
 267 void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
 268                                              uint64_t Offset, uint64_t Value,
 269                                              uint32_t Type, int64_t Addend,
 270                                              uint64_t SymOffset) {
 271   switch (Type) {
 272   default:
 273     llvm_unreachable("Relocation type not implemented yet!");
 274     break;
 275   case ELF::R_X86_64_NONE:
 276     break;
 277   case ELF::R_X86_64_64: {
 278     support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
 279         Value + Addend;
 280     DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
 281                  << format("%p\n", Section.getAddressWithOffset(Offset)));
 282     break;
 283   }
 284   case ELF::R_X86_64_32:
 285   case ELF::R_X86_64_32S: {
 286     Value += Addend;
 287     assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) ||
 288            (Type == ELF::R_X86_64_32S &&
 289             ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
 290     uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
 291     support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
 292         TruncatedAddr;
 293     DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
 294                  << format("%p\n", Section.getAddressWithOffset(Offset)));
 295     break;
 296   }
 297   case ELF::R_X86_64_PC8: {
 298     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 299     int64_t RealOffset = Value + Addend - FinalAddress;
 300     assert(isInt<8>(RealOffset));
 301     int8_t TruncOffset = (RealOffset & 0xFF);
 302     Section.getAddress()[Offset] = TruncOffset;
 303     break;
 304   }
 305   case ELF::R_X86_64_PC32: {
 306     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 307     int64_t RealOffset = Value + Addend - FinalAddress;
 308     assert(isInt<32>(RealOffset));
 309     int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
 310     support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
 311         TruncOffset;
 312     break;
 313   }
 314   case ELF::R_X86_64_PC64: {
 315     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 316     int64_t RealOffset = Value + Addend - FinalAddress;
 317     support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
 318         RealOffset;
 319     break;
 320   }
 321   }
 322 }
 323
 324 void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section,
 325                                           uint64_t Offset, uint32_t Value,
 326                                           uint32_t Type, int32_t Addend) {
 327   switch (Type) {
 328   case ELF::R_386_32: {
 329     support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
 330         Value + Addend;
 331     break;
 332   }
 333   case ELF::R_386_PC32: {
 334     uint32_t FinalAddress =
 335         Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
 336     uint32_t RealOffset = Value + Addend - FinalAddress;
 337     support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
 338         RealOffset;
 339     break;
 340   }
 341   default:
 342     // There are other relocation types, but it appears these are the
 343     // only ones currently used by the LLVM ELF object writer
 344     llvm_unreachable("Relocation type not implemented yet!");
 345     break;
 346   }
 347 }
 348
 349 void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
 350                                               uint64_t Offset, uint64_t Value,
 351                                               uint32_t Type, int64_t Addend) {
 352   uint32_t *TargetPtr =
 353       reinterpret_cast<uint32_t *>(Section.getAddressWithOffset(Offset));
 354   uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 355   // Data should use target endian. Code should always use little endian.
 356   bool isBE = Arch == Triple::aarch64_be;
 357
 358   DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x"
 359                << format("%llx", Section.getAddressWithOffset(Offset))
 360                << " FinalAddress: 0x" << format("%llx", FinalAddress)
 361                << " Value: 0x" << format("%llx", Value) << " Type: 0x"
 362                << format("%x", Type) << " Addend: 0x" << format("%llx", Addend)
 363                << "\n");
 364
 365   switch (Type) {
 366   default:
 367     llvm_unreachable("Relocation type not implemented yet!");
 368     break;
 369   case ELF::R_AARCH64_ABS64:
 370     write(isBE, TargetPtr, Value + Addend);
 371     break;
 372   case ELF::R_AARCH64_PREL32: {
 373     uint64_t Result = Value + Addend - FinalAddress;
 374     assert(static_cast<int64_t>(Result) >= INT32_MIN &&
 375            static_cast<int64_t>(Result) <= UINT32_MAX);
 376     write(isBE, TargetPtr, static_cast<uint32_t>(Result & 0xffffffffU));
 377     break;
 378   }
 379   case ELF::R_AARCH64_PREL64:
 380     write(isBE, TargetPtr, Value + Addend - FinalAddress);
 381     break;
 382   case ELF::R_AARCH64_CALL26: // fallthrough
 383   case ELF::R_AARCH64_JUMP26: {
 384     // Operation: S+A-P. Set Call or B immediate value to bits fff_fffc of the
 385     // calculation.
 386     uint64_t BranchImm = Value + Addend - FinalAddress;
 387
 388     // "Check that -2^27 <= result < 2^27".
 389     assert(isInt<28>(BranchImm));
 390     or32le(TargetPtr, (BranchImm & 0x0FFFFFFC) >> 2);
 391     break;
 392   }
 393   case ELF::R_AARCH64_MOVW_UABS_G3:
 394     or32le(TargetPtr, ((Value + Addend) & 0xFFFF000000000000) >> 43);
 395     break;
 396   case ELF::R_AARCH64_MOVW_UABS_G2_NC:
 397     or32le(TargetPtr, ((Value + Addend) & 0xFFFF00000000) >> 27);
 398     break;
 399   case ELF::R_AARCH64_MOVW_UABS_G1_NC:
 400     or32le(TargetPtr, ((Value + Addend) & 0xFFFF0000) >> 11);
 401     break;
 402   case ELF::R_AARCH64_MOVW_UABS_G0_NC:
 403     or32le(TargetPtr, ((Value + Addend) & 0xFFFF) << 5);
 404     break;
 405   case ELF::R_AARCH64_ADR_PREL_PG_HI21: {
 406     // Operation: Page(S+A) - Page(P)
 407     uint64_t Result =
 408         ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
 409
 410     // Check that -2^32 <= X < 2^32
 411     assert(isInt<33>(Result) && "overflow check failed for relocation");
 412
 413     // Immediate goes in bits 30:29 + 5:23 of ADRP instruction, taken
 414     // from bits 32:12 of X.
 415     write32AArch64Addr(TargetPtr, Result >> 12);
 416     break;
 417   }
 418   case ELF::R_AARCH64_ADD_ABS_LO12_NC:
 419     // Operation: S + A
 420     // Immediate goes in bits 21:10 of LD/ST instruction, taken
 421     // from bits 11:0 of X
 422     or32AArch64Imm(TargetPtr, Value + Addend);
 423     break;
 424   case ELF::R_AARCH64_LDST8_ABS_LO12_NC:
 425     // Operation: S + A
 426     // Immediate goes in bits 21:10 of LD/ST instruction, taken
 427     // from bits 11:0 of X
 428     or32AArch64Imm(TargetPtr, getBits(Value + Addend, 0, 11));
 429     break;
 430   case ELF::R_AARCH64_LDST16_ABS_LO12_NC:
 431     // Operation: S + A
 432     // Immediate goes in bits 21:10 of LD/ST instruction, taken
 433     // from bits 11:1 of X
 434     or32AArch64Imm(TargetPtr, getBits(Value + Addend, 1, 11));
 435     break;
 436   case ELF::R_AARCH64_LDST32_ABS_LO12_NC:
 437     // Operation: S + A
 438     // Immediate goes in bits 21:10 of LD/ST instruction, taken
 439     // from bits 11:2 of X
 440     or32AArch64Imm(TargetPtr, getBits(Value + Addend, 2, 11));
 441     break;
 442   case ELF::R_AARCH64_LDST64_ABS_LO12_NC:
 443     // Operation: S + A
 444     // Immediate goes in bits 21:10 of LD/ST instruction, taken
 445     // from bits 11:3 of X
 446     or32AArch64Imm(TargetPtr, getBits(Value + Addend, 3, 11));
 447     break;
 448   case ELF::R_AARCH64_LDST128_ABS_LO12_NC:
 449     // Operation: S + A
 450     // Immediate goes in bits 21:10 of LD/ST instruction, taken
 451     // from bits 11:4 of X
 452     or32AArch64Imm(TargetPtr, getBits(Value + Addend, 4, 11));
 453     break;
 454   }
 455 }
 456
 457 void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
 458                                           uint64_t Offset, uint32_t Value,
 459                                           uint32_t Type, int32_t Addend) {
 460   // TODO: Add Thumb relocations.
 461   uint32_t *TargetPtr =
 462       reinterpret_cast<uint32_t *>(Section.getAddressWithOffset(Offset));
 463   uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
 464   Value += Addend;
 465
 466   DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: "
 467                << Section.getAddressWithOffset(Offset)
 468                << " FinalAddress: " << format("%p", FinalAddress) << " Value: "
 469                << format("%x", Value) << " Type: " << format("%x", Type)
 470                << " Addend: " << format("%x", Addend) << "\n");
 471
 472   switch (Type) {
 473   default:
 474     llvm_unreachable("Not implemented relocation type!");
 475
 476   case ELF::R_ARM_NONE:
 477     break;
 478     // Write a 31bit signed offset
 479   case ELF::R_ARM_PREL31:
 480     support::ulittle32_t::ref{TargetPtr} =
 481         (support::ulittle32_t::ref{TargetPtr} & 0x80000000) |
 482         ((Value - FinalAddress) & ~0x80000000);
 483     break;
 484   case ELF::R_ARM_TARGET1:
 485   case ELF::R_ARM_ABS32:
 486     support::ulittle32_t::ref{TargetPtr} = Value;
 487     break;
 488     // Write first 16 bit of 32 bit value to the mov instruction.
 489     // Last 4 bit should be shifted.
 490   case ELF::R_ARM_MOVW_ABS_NC:
 491   case ELF::R_ARM_MOVT_ABS:
 492     if (Type == ELF::R_ARM_MOVW_ABS_NC)
 493       Value = Value & 0xFFFF;
 494     else if (Type == ELF::R_ARM_MOVT_ABS)
 495       Value = (Value >> 16) & 0xFFFF;
 496     support::ulittle32_t::ref{TargetPtr} =
 497         (support::ulittle32_t::ref{TargetPtr} & ~0x000F0FFF) | (Value & 0xFFF) |
 498         (((Value >> 12) & 0xF) << 16);
 499     break;
 500     // Write 24 bit relative value to the branch instruction.
 501   case ELF::R_ARM_PC24: // Fall through.
 502   case ELF::R_ARM_CALL: // Fall through.
 503   case ELF::R_ARM_JUMP24:
 504     int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8);
 505     RelValue = (RelValue & 0x03FFFFFC) >> 2;
 506     assert((support::ulittle32_t::ref{TargetPtr} & 0xFFFFFF) == 0xFFFFFE);
 507     support::ulittle32_t::ref{TargetPtr} =
 508         (support::ulittle32_t::ref{TargetPtr} & 0xFF000000) | RelValue;
 509     break;
 510   }
 511 }
 512
 513 void RuntimeDyldELF::setMipsABI(const ObjectFile &Obj) {
 514   if (Arch == Triple::UnknownArch ||
 515       !StringRef(Triple::getArchTypePrefix(Arch)).equals("mips")) {
 516     IsMipsO32ABI = false;
 517     IsMipsN32ABI = false;
 518     IsMipsN64ABI = false;
 519     return;
 520   }
 521   unsigned AbiVariant;
 522   Obj.getPlatformFlags(AbiVariant);
 523   IsMipsO32ABI = AbiVariant & ELF::EF_MIPS_ABI_O32;
 524   IsMipsN32ABI = AbiVariant & ELF::EF_MIPS_ABI2;
 525   IsMipsN64ABI = Obj.getFileFormatName().equals("ELF64-mips");
 526 }
 527
 528 // Return the .TOC. section and offset.
 529 Error RuntimeDyldELF::findPPC64TOCSection(const ELFObjectFileBase &Obj,
 530                                           ObjSectionToIDMap &LocalSections,
 531                                           RelocationValueRef &Rel) {
 532   // Set a default SectionID in case we do not find a TOC section below.
 533   // This may happen for references to TOC base base (sym@toc, .odp
 534   // relocation) without a .toc directive.  In this case just use the
 535   // first section (which is usually the .odp) since the code won't
 536   // reference the .toc base directly.
 537   Rel.SymbolName = nullptr;
 538   Rel.SectionID = 0;
 539
 540   // The TOC consists of sections .got, .toc, .tocbss, .plt in that
 541   // order. The TOC starts where the first of these sections starts.
 542   for (auto &Section: Obj.sections()) {
 543     StringRef SectionName;
 544     if (auto EC = Section.getName(SectionName))
 545       return errorCodeToError(EC);
 546
 547     if (SectionName == ".got"
 548         || SectionName == ".toc"
 549         || SectionName == ".tocbss"
 550         || SectionName == ".plt") {
 551       if (auto SectionIDOrErr =
 552             findOrEmitSection(Obj, Section, false, LocalSections))
 553         Rel.SectionID = *SectionIDOrErr;
 554       else
 555         return SectionIDOrErr.takeError();
 556       break;
 557     }
 558   }
 559
 560   // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
 561   // thus permitting a full 64 Kbytes segment.
 562   Rel.Addend = 0x8000;
 563
 564   return Error::success();
 565 }
 566
 567 // Returns the sections and offset associated with the ODP entry referenced
 568 // by Symbol.
 569 Error RuntimeDyldELF::findOPDEntrySection(const ELFObjectFileBase &Obj,
 570                                           ObjSectionToIDMap &LocalSections,
 571                                           RelocationValueRef &Rel) {
 572   // Get the ELF symbol value (st_value) to compare with Relocation offset in
 573   // .opd entries
 574   for (section_iterator si = Obj.section_begin(), se = Obj.section_end();
 575        si != se; ++si) {
 576     section_iterator RelSecI = si->getRelocatedSection();
 577     if (RelSecI == Obj.section_end())
 578       continue;
 579
 580     StringRef RelSectionName;
 581     if (auto EC = RelSecI->getName(RelSectionName))
 582       return errorCodeToError(EC);
 583
 584     if (RelSectionName != ".opd")
 585       continue;
 586
 587     for (elf_relocation_iterator i = si->relocation_begin(),
 588                                  e = si->relocation_end();
 589          i != e;) {
 590       // The R_PPC64_ADDR64 relocation indicates the first field
 591       // of a .opd entry
 592       uint64_t TypeFunc = i->getType();
 593       if (TypeFunc != ELF::R_PPC64_ADDR64) {
 594         ++i;
 595         continue;
 596       }
 597
 598       uint64_t TargetSymbolOffset = i->getOffset();
 599       symbol_iterator TargetSymbol = i->getSymbol();
 600       int64_t Addend;
 601       if (auto AddendOrErr = i->getAddend())
 602         Addend = *AddendOrErr;
 603       else
 604         return errorCodeToError(AddendOrErr.getError());
 605
 606       ++i;
 607       if (i == e)
 608         break;
 609
 610       // Just check if following relocation is a R_PPC64_TOC
 611       uint64_t TypeTOC = i->getType();
 612       if (TypeTOC != ELF::R_PPC64_TOC)
 613         continue;
 614
 615       // Finally compares the Symbol value and the target symbol offset
 616       // to check if this .opd entry refers to the symbol the relocation
 617       // points to.
 618       if (Rel.Addend != (int64_t)TargetSymbolOffset)
 619         continue;
 620
 621       section_iterator TSI = Obj.section_end();
 622       if (auto TSIOrErr = TargetSymbol->getSection())
 623         TSI = *TSIOrErr;
 624       else
 625         return TSIOrErr.takeError();
 626       assert(TSI != Obj.section_end() && "TSI should refer to a valid section");
 627
 628       bool IsCode = TSI->isText();
 629       if (auto SectionIDOrErr = findOrEmitSection(Obj, *TSI, IsCode,
 630                                                   LocalSections))
 631         Rel.SectionID = *SectionIDOrErr;
 632       else
 633         return SectionIDOrErr.takeError();
 634       Rel.Addend = (intptr_t)Addend;
 635       return Error::success();
 636     }
 637   }
 638   llvm_unreachable("Attempting to get address of ODP entry!");
 639 }
 640
 641 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 642 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 643 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
 644 // document.
 645
 646 static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; }
 647
 648 static inline uint16_t applyPPChi(uint64_t value) {
 649   return (value >> 16) & 0xffff;
 650 }
 651
 652 static inline uint16_t applyPPCha (uint64_t value) {
 653   return ((value + 0x8000) >> 16) & 0xffff;
 654 }
 655
 656 static inline uint16_t applyPPChigher(uint64_t value) {
 657   return (value >> 32) & 0xffff;
 658 }
 659
 660 static inline uint16_t applyPPChighera (uint64_t value) {
 661   return ((value + 0x8000) >> 32) & 0xffff;
 662 }
 663
 664 static inline uint16_t applyPPChighest(uint64_t value) {
 665   return (value >> 48) & 0xffff;
 666 }
 667
 668 static inline uint16_t applyPPChighesta (uint64_t value) {
 669   return ((value + 0x8000) >> 48) & 0xffff;
 670 }
 671
 672 void RuntimeDyldELF::resolvePPC32Relocation(const SectionEntry &Section,
 673                                             uint64_t Offset, uint64_t Value,
 674                                             uint32_t Type, int64_t Addend) {
 675   uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
 676   switch (Type) {
 677   default:
 678     llvm_unreachable("Relocation type not implemented yet!");
 679     break;
 680   case ELF::R_PPC_ADDR16_LO:
 681     writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
 682     break;
 683   case ELF::R_PPC_ADDR16_HI:
 684     writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
 685     break;
 686   case ELF::R_PPC_ADDR16_HA:
 687     writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
 688     break;
 689   }
 690 }
 691
 692 void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
 693                                             uint64_t Offset, uint64_t Value,
 694                                             uint32_t Type, int64_t Addend) {
 695   uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
 696   switch (Type) {
 697   default:
 698     llvm_unreachable("Relocation type not implemented yet!");
 699     break;
 700   case ELF::R_PPC64_ADDR16:
 701     writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
 702     break;
 703   case ELF::R_PPC64_ADDR16_DS:
 704     writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
 705     break;
 706   case ELF::R_PPC64_ADDR16_LO:
 707     writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
 708     break;
 709   case ELF::R_PPC64_ADDR16_LO_DS:
 710     writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
 711     break;
 712   case ELF::R_PPC64_ADDR16_HI:
 713     writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
 714     break;
 715   case ELF::R_PPC64_ADDR16_HA:
 716     writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
 717     break;
 718   case ELF::R_PPC64_ADDR16_HIGHER:
 719     writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
 720     break;
 721   case ELF::R_PPC64_ADDR16_HIGHERA:
 722     writeInt16BE(LocalAddress, applyPPChighera(Value + Addend));
 723     break;
 724   case ELF::R_PPC64_ADDR16_HIGHEST:
 725     writeInt16BE(LocalAddress, applyPPChighest(Value + Addend));
 726     break;
 727   case ELF::R_PPC64_ADDR16_HIGHESTA:
 728     writeInt16BE(LocalAddress, applyPPChighesta(Value + Addend));
 729     break;
 730   case ELF::R_PPC64_ADDR14: {
 731     assert(((Value + Addend) & 3) == 0);
 732     // Preserve the AA/LK bits in the branch instruction
 733     uint8_t aalk = *(LocalAddress + 3);
 734     writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
 735   } break;
 736   case ELF::R_PPC64_REL16_LO: {
 737     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 738     uint64_t Delta = Value - FinalAddress + Addend;
 739     writeInt16BE(LocalAddress, applyPPClo(Delta));
 740   } break;
 741   case ELF::R_PPC64_REL16_HI: {
 742     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 743     uint64_t Delta = Value - FinalAddress + Addend;
 744     writeInt16BE(LocalAddress, applyPPChi(Delta));
 745   } break;
 746   case ELF::R_PPC64_REL16_HA: {
 747     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 748     uint64_t Delta = Value - FinalAddress + Addend;
 749     writeInt16BE(LocalAddress, applyPPCha(Delta));
 750   } break;
 751   case ELF::R_PPC64_ADDR32: {
 752     int32_t Result = static_cast<int32_t>(Value + Addend);
 753     if (SignExtend32<32>(Result) != Result)
 754       llvm_unreachable("Relocation R_PPC64_ADDR32 overflow");
 755     writeInt32BE(LocalAddress, Result);
 756   } break;
 757   case ELF::R_PPC64_REL24: {
 758     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 759     int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
 760     if (SignExtend32<26>(delta) != delta)
 761       llvm_unreachable("Relocation R_PPC64_REL24 overflow");
 762     // Generates a 'bl <address>' instruction
 763     writeInt32BE(LocalAddress, 0x48000001 | (delta & 0x03FFFFFC));
 764   } break;
 765   case ELF::R_PPC64_REL32: {
 766     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 767     int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
 768     if (SignExtend32<32>(delta) != delta)
 769       llvm_unreachable("Relocation R_PPC64_REL32 overflow");
 770     writeInt32BE(LocalAddress, delta);
 771   } break;
 772   case ELF::R_PPC64_REL64: {
 773     uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
 774     uint64_t Delta = Value - FinalAddress + Addend;
 775     writeInt64BE(LocalAddress, Delta);
 776   } break;
 777   case ELF::R_PPC64_ADDR64:
 778     writeInt64BE(LocalAddress, Value + Addend);
 779     break;
 780   }
 781 }
 782
 783 void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,
 784                                               uint64_t Offset, uint64_t Value,
 785                                               uint32_t Type, int64_t Addend) {
 786   uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
 787   switch (Type) {
 788   default:
 789     llvm_unreachable("Relocation type not implemented yet!");
 790     break;
 791   case ELF::R_390_PC16DBL:
 792   case ELF::R_390_PLT16DBL: {
 793     int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
 794     assert(int16_t(Delta / 2) * 2 == Delta && "R_390_PC16DBL overflow");
 795     writeInt16BE(LocalAddress, Delta / 2);
 796     break;
 797   }
 798   case ELF::R_390_PC32DBL:
 799   case ELF::R_390_PLT32DBL: {
 800     int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
 801     assert(int32_t(Delta / 2) * 2 == Delta && "R_390_PC32DBL overflow");
 802     writeInt32BE(LocalAddress, Delta / 2);
 803     break;
 804   }
 805   case ELF::R_390_PC32: {
 806     int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
 807     assert(int32_t(Delta) == Delta && "R_390_PC32 overflow");
 808     writeInt32BE(LocalAddress, Delta);
 809     break;
 810   }
 811   case ELF::R_390_64:
 812     writeInt64BE(LocalAddress, Value + Addend);
 813     break;
 814   case ELF::R_390_PC64: {
 815     int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
 816     writeInt64BE(LocalAddress, Delta);
 817     break;
 818   }
 819   }
 820 }
 821
 822 // The target location for the relocation is described by RE.SectionID and
 823 // RE.Offset.  RE.SectionID can be used to find the SectionEntry.  Each
 824 // SectionEntry has three members describing its location.
 825 // SectionEntry::Address is the address at which the section has been loaded
 826 // into memory in the current (host) process.  SectionEntry::LoadAddress is the
 827 // address that the section will have in the target process.
 828 // SectionEntry::ObjAddress is the address of the bits for this section in the
 829 // original emitted object image (also in the current address space).
 830 //
 831 // Relocations will be applied as if the section were loaded at
 832 // SectionEntry::LoadAddress, but they will be applied at an address based
 833 // on SectionEntry::Address.  SectionEntry::ObjAddress will be used to refer to
 834 // Target memory contents if they are required for value calculations.
 835 //
 836 // The Value parameter here is the load address of the symbol for the
 837 // relocation to be applied.  For relocations which refer to symbols in the
 838 // current object Value will be the LoadAddress of the section in which
 839 // the symbol resides (RE.Addend provides additional information about the
 840 // symbol location).  For external symbols, Value will be the address of the
 841 // symbol in the target address space.
 842 void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE,
 843                                        uint64_t Value) {
 844   const SectionEntry &Section = Sections[RE.SectionID];
 845   return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
 846                            RE.SymOffset, RE.SectionID);
 847 }
 848
 849 void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
 850                                        uint64_t Offset, uint64_t Value,
 851                                        uint32_t Type, int64_t Addend,
 852                                        uint64_t SymOffset, SID SectionID) {
 853   switch (Arch) {
 854   case Triple::x86_64:
 855     resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
 856     break;
 857   case Triple::x86:
 858     resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
 859                          (uint32_t)(Addend & 0xffffffffL));
 860     break;
 861   case Triple::aarch64:
 862   case Triple::aarch64_be:
 863     resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
 864     break;
 865   case Triple::arm: // Fall through.
 866   case Triple::armeb:
 867   case Triple::thumb:
 868   case Triple::thumbeb:
 869     resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
 870                          (uint32_t)(Addend & 0xffffffffL));
 871     break;
 872   case Triple::ppc:
 873     resolvePPC32Relocation(Section, Offset, Value, Type, Addend);
 874     break;
 875   case Triple::ppc64: // Fall through.
 876   case Triple::ppc64le:
 877     resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
 878     break;
 879   case Triple::systemz:
 880     resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
 881     break;
 882   default:
 883     llvm_unreachable("Unsupported CPU type!");
 884   }
 885 }
 886
 887 void *RuntimeDyldELF::computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const {
 888   return (void *)(Sections[SectionID].getObjAddress() + Offset);
 889 }
 890
 891 void RuntimeDyldELF::processSimpleRelocation(unsigned SectionID, uint64_t Offset, unsigned RelType, RelocationValueRef Value) {
 892   RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, Value.Offset);
 893   if (Value.SymbolName)
 894     addRelocationForSymbol(RE, Value.SymbolName);
 895   else
 896     addRelocationForSection(RE, Value.SectionID);
 897 }
 898
 899 uint32_t RuntimeDyldELF::getMatchingLoRelocation(uint32_t RelType,
 900                                                  bool IsLocal) const {
 901   switch (RelType) {
 902   case ELF::R_MICROMIPS_GOT16:
 903     if (IsLocal)
 904       return ELF::R_MICROMIPS_LO16;
 905     break;
 906   case ELF::R_MICROMIPS_HI16:
 907     return ELF::R_MICROMIPS_LO16;
 908   case ELF::R_MIPS_GOT16:
 909     if (IsLocal)
 910       return ELF::R_MIPS_LO16;
 911     break;
 912   case ELF::R_MIPS_HI16:
 913     return ELF::R_MIPS_LO16;
 914   case ELF::R_MIPS_PCHI16:
 915     return ELF::R_MIPS_PCLO16;
 916   default:
 917     break;
 918   }
 919   return ELF::R_MIPS_NONE;
 920 }
 921
 922 // Sometimes we don't need to create thunk for a branch.
 923 // This typically happens when branch target is located
 924 // in the same object file. In such case target is either
 925 // a weak symbol or symbol in a different executable section.
 926 // This function checks if branch target is located in the
 927 // same object file and if distance between source and target
 928 // fits R_AARCH64_CALL26 relocation. If both conditions are
 929 // met, it emits direct jump to the target and returns true.
 930 // Otherwise false is returned and thunk is created.
 931 bool RuntimeDyldELF::resolveAArch64ShortBranch(
 932     unsigned SectionID, relocation_iterator RelI,
 933     const RelocationValueRef &Value) {
 934   uint64_t Address;
 935   if (Value.SymbolName) {
 936     auto Loc = GlobalSymbolTable.find(Value.SymbolName);
 937
 938     // Don't create direct branch for external symbols.
 939     if (Loc == GlobalSymbolTable.end())
 940       return false;
 941
 942     const auto &SymInfo = Loc->second;
 943     Address =
 944         uint64_t(Sections[SymInfo.getSectionID()].getLoadAddressWithOffset(
 945             SymInfo.getOffset()));
 946   } else {
 947     Address = uint64_t(Sections[Value.SectionID].getLoadAddress());
 948   }
 949   uint64_t Offset = RelI->getOffset();
 950   uint64_t SourceAddress = Sections[SectionID].getLoadAddressWithOffset(Offset);
 951
 952   // R_AARCH64_CALL26 requires immediate to be in range -2^27 <= imm < 2^27
 953   // If distance between source and target is out of range then we should
 954   // create thunk.
 955   if (!isInt<28>(Address + Value.Addend - SourceAddress))
 956     return false;
 957
 958   resolveRelocation(Sections[SectionID], Offset, Address, RelI->getType(),
 959                     Value.Addend);
 960
 961   return true;
 962 }
 963
 964 void RuntimeDyldELF::resolveAArch64Branch(unsigned SectionID,
 965                                           const RelocationValueRef &Value,
 966                                           relocation_iterator RelI,
 967                                           StubMap &Stubs) {
 968
 969   DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation.");
 970   SectionEntry &Section = Sections[SectionID];
 971
 972   uint64_t Offset = RelI->getOffset();
 973   unsigned RelType = RelI->getType();
 974   // Look for an existing stub.
 975   StubMap::const_iterator i = Stubs.find(Value);
 976   if (i != Stubs.end()) {
 977     resolveRelocation(Section, Offset,
 978                       (uint64_t)Section.getAddressWithOffset(i->second),
 979                       RelType, 0);
 980     DEBUG(dbgs() << " Stub function found\n");
 981   } else if (!resolveAArch64ShortBranch(SectionID, RelI, Value)) {
 982     // Create a new stub function.
 983     DEBUG(dbgs() << " Create a new stub function\n");
 984     Stubs[Value] = Section.getStubOffset();
 985     uint8_t *StubTargetAddr = createStubFunction(
 986         Section.getAddressWithOffset(Section.getStubOffset()));
 987
 988     RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.getAddress(),
 989                               ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
 990     RelocationEntry REmovk_g2(SectionID,
 991                               StubTargetAddr - Section.getAddress() + 4,
 992                               ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
 993     RelocationEntry REmovk_g1(SectionID,
 994                               StubTargetAddr - Section.getAddress() + 8,
 995                               ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
 996     RelocationEntry REmovk_g0(SectionID,
 997                               StubTargetAddr - Section.getAddress() + 12,
 998                               ELF::R_AARCH64_MOVW_UABS_G0_NC, Value.Addend);
 999
1000     if (Value.SymbolName) {
1001       addRelocationForSymbol(REmovz_g3, Value.SymbolName);
1002       addRelocationForSymbol(REmovk_g2, Value.SymbolName);
1003       addRelocationForSymbol(REmovk_g1, Value.SymbolName);
1004       addRelocationForSymbol(REmovk_g0, Value.SymbolName);
1005     } else {
1006       addRelocationForSection(REmovz_g3, Value.SectionID);
1007       addRelocationForSection(REmovk_g2, Value.SectionID);
1008       addRelocationForSection(REmovk_g1, Value.SectionID);
1009       addRelocationForSection(REmovk_g0, Value.SectionID);
1010     }
1011     resolveRelocation(Section, Offset,
1012                       reinterpret_cast<uint64_t>(Section.getAddressWithOffset(
1013                           Section.getStubOffset())),
1014                       RelType, 0);
1015     Section.advanceStubOffset(getMaxStubSize());
1016   }
1017 }
1018
1019 Expected<relocation_iterator>
1020 RuntimeDyldELF::processRelocationRef(
1021     unsigned SectionID, relocation_iterator RelI, const ObjectFile &O,
1022     ObjSectionToIDMap &ObjSectionToID, StubMap &Stubs) {
1023   const auto &Obj = cast<ELFObjectFileBase>(O);
1024   uint64_t RelType = RelI->getType();
1025   ErrorOr<int64_t> AddendOrErr = ELFRelocationRef(*RelI).getAddend();
1026   int64_t Addend = AddendOrErr ? *AddendOrErr : 0;
1027   elf_symbol_iterator Symbol = RelI->getSymbol();
1028
1029   // Obtain the symbol name which is referenced in the relocation
1030   StringRef TargetName;
1031   if (Symbol != Obj.symbol_end()) {
1032     if (auto TargetNameOrErr = Symbol->getName())
1033       TargetName = *TargetNameOrErr;
1034     else
1035       return TargetNameOrErr.takeError();
1036   }
1037   DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend
1038                << " TargetName: " << TargetName << "\n");
1039   RelocationValueRef Value;
1040   // First search for the symbol in the local symbol table
1041   SymbolRef::Type SymType = SymbolRef::ST_Unknown;
1042
1043   // Search for the symbol in the global symbol table
1044   RTDyldSymbolTable::const_iterator gsi = GlobalSymbolTable.end();
1045   if (Symbol != Obj.symbol_end()) {
1046     gsi = GlobalSymbolTable.find(TargetName.data());
1047     Expected<SymbolRef::Type> SymTypeOrErr = Symbol->getType();
1048     if (!SymTypeOrErr) {
1049       std::string Buf;
1050       raw_string_ostream OS(Buf);
1051       logAllUnhandledErrors(SymTypeOrErr.takeError(), OS, "");
1052       OS.flush();
1053       report_fatal_error(Buf);
1054     }
1055     SymType = *SymTypeOrErr;
1056   }
1057   if (gsi != GlobalSymbolTable.end()) {
1058     const auto &SymInfo = gsi->second;
1059     Value.SectionID = SymInfo.getSectionID();
1060     Value.Offset = SymInfo.getOffset();
1061     Value.Addend = SymInfo.getOffset() + Addend;
1062   } else {
1063     switch (SymType) {
1064     case SymbolRef::ST_Debug: {
1065       // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
1066       // and can be changed by another developers. Maybe best way is add
1067       // a new symbol type ST_Section to SymbolRef and use it.
1068       auto SectionOrErr = Symbol->getSection();
1069       if (!SectionOrErr) {
1070         std::string Buf;
1071         raw_string_ostream OS(Buf);
1072         logAllUnhandledErrors(SectionOrErr.takeError(), OS, "");
1073         OS.flush();
1074         report_fatal_error(Buf);
1075       }
1076       section_iterator si = *SectionOrErr;
1077       if (si == Obj.section_end())
1078         llvm_unreachable("Symbol section not found, bad object file format!");
1079       DEBUG(dbgs() << "\t\tThis is section symbol\n");
1080       bool isCode = si->isText();
1081       if (auto SectionIDOrErr = findOrEmitSection(Obj, (*si), isCode,
1082                                                   ObjSectionToID))
1083         Value.SectionID = *SectionIDOrErr;
1084       else
1085         return SectionIDOrErr.takeError();
1086       Value.Addend = Addend;
1087       break;
1088     }
1089     case SymbolRef::ST_Data:
1090     case SymbolRef::ST_Function:
1091     case SymbolRef::ST_Unknown: {
1092       Value.SymbolName = TargetName.data();
1093       Value.Addend = Addend;
1094
1095       // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
1096       // will manifest here as a NULL symbol name.
1097       // We can set this as a valid (but empty) symbol name, and rely
1098       // on addRelocationForSymbol to handle this.
1099       if (!Value.SymbolName)
1100         Value.SymbolName = "";
1101       break;
1102     }
1103     default:
1104       llvm_unreachable("Unresolved symbol type!");
1105       break;
1106     }
1107   }
1108
1109   uint64_t Offset = RelI->getOffset();
1110
1111   DEBUG(dbgs() << "\t\tSectionID: " << SectionID << " Offset: " << Offset
1112                << "\n");
1113   if ((Arch == Triple::aarch64 || Arch == Triple::aarch64_be)) {
1114     if (RelType == ELF::R_AARCH64_CALL26 || RelType == ELF::R_AARCH64_JUMP26) {
1115       resolveAArch64Branch(SectionID, Value, RelI, Stubs);
1116     } else if (RelType == ELF::R_AARCH64_ADR_GOT_PAGE) {
1117       // Craete new GOT entry or find existing one. If GOT entry is
1118       // to be created, then we also emit ABS64 relocation for it.
1119       uint64_t GOTOffset = findOrAllocGOTEntry(Value, ELF::R_AARCH64_ABS64);
1120       resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1121                                  ELF::R_AARCH64_ADR_PREL_PG_HI21);
1122
1123     } else if (RelType == ELF::R_AARCH64_LD64_GOT_LO12_NC) {
1124       uint64_t GOTOffset = findOrAllocGOTEntry(Value, ELF::R_AARCH64_ABS64);
1125       resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1126                                  ELF::R_AARCH64_LDST64_ABS_LO12_NC);
1127     } else {
1128       processSimpleRelocation(SectionID, Offset, RelType, Value);
1129     }
1130   } else if (Arch == Triple::arm) {
1131     if (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL ||
1132       RelType == ELF::R_ARM_JUMP24) {
1133       // This is an ARM branch relocation, need to use a stub function.
1134       DEBUG(dbgs() << "\t\tThis is an ARM branch relocation.\n");
1135       SectionEntry &Section = Sections[SectionID];
1136
1137       // Look for an existing stub.
1138       StubMap::const_iterator i = Stubs.find(Value);
1139       if (i != Stubs.end()) {
1140         resolveRelocation(
1141             Section, Offset,
1142             reinterpret_cast<uint64_t>(Section.getAddressWithOffset(i->second)),
1143             RelType, 0);
1144         DEBUG(dbgs() << " Stub function found\n");
1145       } else {
1146         // Create a new stub function.
1147         DEBUG(dbgs() << " Create a new stub function\n");
1148         Stubs[Value] = Section.getStubOffset();
1149         uint8_t *StubTargetAddr = createStubFunction(
1150             Section.getAddressWithOffset(Section.getStubOffset()));
1151         RelocationEntry RE(SectionID, StubTargetAddr - Section.getAddress(),
1152                            ELF::R_ARM_ABS32, Value.Addend);
1153         if (Value.SymbolName)
1154           addRelocationForSymbol(RE, Value.SymbolName);
1155         else
1156           addRelocationForSection(RE, Value.SectionID);
1157
1158         resolveRelocation(Section, Offset, reinterpret_cast<uint64_t>(
1159                                                Section.getAddressWithOffset(
1160                                                    Section.getStubOffset())),
1161                           RelType, 0);
1162         Section.advanceStubOffset(getMaxStubSize());
1163       }
1164     } else {
1165       uint32_t *Placeholder =
1166         reinterpret_cast<uint32_t*>(computePlaceholderAddress(SectionID, Offset));
1167       if (RelType == ELF::R_ARM_PREL31 || RelType == ELF::R_ARM_TARGET1 ||
1168           RelType == ELF::R_ARM_ABS32) {
1169         Value.Addend += *Placeholder;
1170       } else if (RelType == ELF::R_ARM_MOVW_ABS_NC || RelType == ELF::R_ARM_MOVT_ABS) {
1171         // See ELF for ARM documentation
1172         Value.Addend += (int16_t)((*Placeholder & 0xFFF) | (((*Placeholder >> 16) & 0xF) << 12));
1173       }
1174       processSimpleRelocation(SectionID, Offset, RelType, Value);
1175     }
1176   } else if (IsMipsO32ABI) {
1177     uint8_t *Placeholder = reinterpret_cast<uint8_t *>(
1178         computePlaceholderAddress(SectionID, Offset));
1179     uint32_t Opcode = readBytesUnaligned(Placeholder, 4);
1180     if (RelType == ELF::R_MIPS_26) {
1181       // This is an Mips branch relocation, need to use a stub function.
1182       DEBUG(dbgs() << "\t\tThis is a Mips branch relocation.");
1183       SectionEntry &Section = Sections[SectionID];
1184
1185       // Extract the addend from the instruction.
1186       // We shift up by two since the Value will be down shifted again
1187       // when applying the relocation.
1188       uint32_t Addend = (Opcode & 0x03ffffff) << 2;
1189
1190       Value.Addend += Addend;
1191
1192       //  Look up for existing stub.
1193       StubMap::const_iterator i = Stubs.find(Value);
1194       if (i != Stubs.end()) {
1195         RelocationEntry RE(SectionID, Offset, RelType, i->second);
1196         addRelocationForSection(RE, SectionID);
1197         DEBUG(dbgs() << " Stub function found\n");
1198       } else {
1199         // Create a new stub function.
1200         DEBUG(dbgs() << " Create a new stub function\n");
1201         Stubs[Value] = Section.getStubOffset();
1202
1203         unsigned AbiVariant;
1204         O.getPlatformFlags(AbiVariant);
1205
1206         uint8_t *StubTargetAddr = createStubFunction(
1207             Section.getAddressWithOffset(Section.getStubOffset()), AbiVariant);
1208
1209         // Creating Hi and Lo relocations for the filled stub instructions.
1210         RelocationEntry REHi(SectionID, StubTargetAddr - Section.getAddress(),
1211                              ELF::R_MIPS_HI16, Value.Addend);
1212         RelocationEntry RELo(SectionID,
1213                              StubTargetAddr - Section.getAddress() + 4,
1214                              ELF::R_MIPS_LO16, Value.Addend);
1215
1216         if (Value.SymbolName) {
1217           addRelocationForSymbol(REHi, Value.SymbolName);
1218           addRelocationForSymbol(RELo, Value.SymbolName);
1219         }
1220         else {
1221           addRelocationForSection(REHi, Value.SectionID);
1222           addRelocationForSection(RELo, Value.SectionID);
1223         }
1224
1225         RelocationEntry RE(SectionID, Offset, RelType, Section.getStubOffset());
1226         addRelocationForSection(RE, SectionID);
1227         Section.advanceStubOffset(getMaxStubSize());
1228       }
1229     } else if (RelType == ELF::R_MIPS_HI16 || RelType == ELF::R_MIPS_PCHI16) {
1230       int64_t Addend = (Opcode & 0x0000ffff) << 16;
1231       RelocationEntry RE(SectionID, Offset, RelType, Addend);
1232       PendingRelocs.push_back(std::make_pair(Value, RE));
1233     } else if (RelType == ELF::R_MIPS_LO16 || RelType == ELF::R_MIPS_PCLO16) {
1234       int64_t Addend = Value.Addend + SignExtend32<16>(Opcode & 0x0000ffff);
1235       for (auto I = PendingRelocs.begin(); I != PendingRelocs.end();) {
1236         const RelocationValueRef &MatchingValue = I->first;
1237         RelocationEntry &Reloc = I->second;
1238         if (MatchingValue == Value &&
1239             RelType == getMatchingLoRelocation(Reloc.RelType) &&
1240             SectionID == Reloc.SectionID) {
1241           Reloc.Addend += Addend;
1242           if (Value.SymbolName)
1243             addRelocationForSymbol(Reloc, Value.SymbolName);
1244           else
1245             addRelocationForSection(Reloc, Value.SectionID);
1246           I = PendingRelocs.erase(I);
1247         } else
1248           ++I;
1249       }
1250       RelocationEntry RE(SectionID, Offset, RelType, Addend);
1251       if (Value.SymbolName)
1252         addRelocationForSymbol(RE, Value.SymbolName);
1253       else
1254         addRelocationForSection(RE, Value.SectionID);
1255     } else {
1256       if (RelType == ELF::R_MIPS_32)
1257         Value.Addend += Opcode;
1258       else if (RelType == ELF::R_MIPS_PC16)
1259         Value.Addend += SignExtend32<18>((Opcode & 0x0000ffff) << 2);
1260       else if (RelType == ELF::R_MIPS_PC19_S2)
1261         Value.Addend += SignExtend32<21>((Opcode & 0x0007ffff) << 2);
1262       else if (RelType == ELF::R_MIPS_PC21_S2)
1263         Value.Addend += SignExtend32<23>((Opcode & 0x001fffff) << 2);
1264       else if (RelType == ELF::R_MIPS_PC26_S2)
1265         Value.Addend += SignExtend32<28>((Opcode & 0x03ffffff) << 2);
1266       processSimpleRelocation(SectionID, Offset, RelType, Value);
1267     }
1268   } else if (IsMipsN32ABI || IsMipsN64ABI) {
1269     uint32_t r_type = RelType & 0xff;
1270     RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1271     if (r_type == ELF::R_MIPS_CALL16 || r_type == ELF::R_MIPS_GOT_PAGE
1272         || r_type == ELF::R_MIPS_GOT_DISP) {
1273       StringMap<uint64_t>::iterator i = GOTSymbolOffsets.find(TargetName);
1274       if (i != GOTSymbolOffsets.end())
1275         RE.SymOffset = i->second;
1276       else {
1277         RE.SymOffset = allocateGOTEntries(1);
1278         GOTSymbolOffsets[TargetName] = RE.SymOffset;
1279       }
1280     }
1281     if (Value.SymbolName)
1282       addRelocationForSymbol(RE, Value.SymbolName);
1283     else
1284       addRelocationForSection(RE, Value.SectionID);
1285   } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
1286     if (RelType == ELF::R_PPC64_REL24) {
1287       // Determine ABI variant in use for this object.
1288       unsigned AbiVariant;
1289       Obj.getPlatformFlags(AbiVariant);
1290       AbiVariant &= ELF::EF_PPC64_ABI;
1291       // A PPC branch relocation will need a stub function if the target is
1292       // an external symbol (Symbol::ST_Unknown) or if the target address
1293       // is not within the signed 24-bits branch address.
1294       SectionEntry &Section = Sections[SectionID];
1295       uint8_t *Target = Section.getAddressWithOffset(Offset);
1296       bool RangeOverflow = false;
1297       if (SymType != SymbolRef::ST_Unknown) {
1298         if (AbiVariant != 2) {
1299           // In the ELFv1 ABI, a function call may point to the .opd entry,
1300           // so the final symbol value is calculated based on the relocation
1301           // values in the .opd section.
1302           if (auto Err = findOPDEntrySection(Obj, ObjSectionToID, Value))
1303             return std::move(Err);
1304         } else {
1305           // In the ELFv2 ABI, a function symbol may provide a local entry
1306           // point, which must be used for direct calls.
1307           uint8_t SymOther = Symbol->getOther();
1308           Value.Addend += ELF::decodePPC64LocalEntryOffset(SymOther);
1309         }
1310         uint8_t *RelocTarget =
1311             Sections[Value.SectionID].getAddressWithOffset(Value.Addend);
1312         int32_t delta = static_cast<int32_t>(Target - RelocTarget);
1313         // If it is within 26-bits branch range, just set the branch target
1314         if (SignExtend32<26>(delta) == delta) {
1315           RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1316           if (Value.SymbolName)
1317             addRelocationForSymbol(RE, Value.SymbolName);
1318           else
1319             addRelocationForSection(RE, Value.SectionID);
1320         } else {
1321           RangeOverflow = true;
1322         }
1323       }
1324       if (SymType == SymbolRef::ST_Unknown || RangeOverflow) {
1325         // It is an external symbol (SymbolRef::ST_Unknown) or within a range
1326         // larger than 24-bits.
1327         StubMap::const_iterator i = Stubs.find(Value);
1328         if (i != Stubs.end()) {
1329           // Symbol function stub already created, just relocate to it
1330           resolveRelocation(Section, Offset,
1331                             reinterpret_cast<uint64_t>(
1332                                 Section.getAddressWithOffset(i->second)),
1333                             RelType, 0);
1334           DEBUG(dbgs() << " Stub function found\n");
1335         } else {
1336           // Create a new stub function.
1337           DEBUG(dbgs() << " Create a new stub function\n");
1338           Stubs[Value] = Section.getStubOffset();
1339           uint8_t *StubTargetAddr = createStubFunction(
1340               Section.getAddressWithOffset(Section.getStubOffset()),
1341               AbiVariant);
1342           RelocationEntry RE(SectionID, StubTargetAddr - Section.getAddress(),
1343                              ELF::R_PPC64_ADDR64, Value.Addend);
1344
1345           // Generates the 64-bits address loads as exemplified in section
1346           // 4.5.1 in PPC64 ELF ABI.  Note that the relocations need to
1347           // apply to the low part of the instructions, so we have to update
1348           // the offset according to the target endianness.
1349           uint64_t StubRelocOffset = StubTargetAddr - Section.getAddress();
1350           if (!IsTargetLittleEndian)
1351             StubRelocOffset += 2;
1352
1353           RelocationEntry REhst(SectionID, StubRelocOffset + 0,
1354                                 ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
1355           RelocationEntry REhr(SectionID, StubRelocOffset + 4,
1356                                ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
1357           RelocationEntry REh(SectionID, StubRelocOffset + 12,
1358                               ELF::R_PPC64_ADDR16_HI, Value.Addend);
1359           RelocationEntry REl(SectionID, StubRelocOffset + 16,
1360                               ELF::R_PPC64_ADDR16_LO, Value.Addend);
1361
1362           if (Value.SymbolName) {
1363             addRelocationForSymbol(REhst, Value.SymbolName);
1364             addRelocationForSymbol(REhr, Value.SymbolName);
1365             addRelocationForSymbol(REh, Value.SymbolName);
1366             addRelocationForSymbol(REl, Value.SymbolName);
1367           } else {
1368             addRelocationForSection(REhst, Value.SectionID);
1369             addRelocationForSection(REhr, Value.SectionID);
1370             addRelocationForSection(REh, Value.SectionID);
1371             addRelocationForSection(REl, Value.SectionID);
1372           }
1373
1374           resolveRelocation(Section, Offset, reinterpret_cast<uint64_t>(
1375                                                  Section.getAddressWithOffset(
1376                                                      Section.getStubOffset())),
1377                             RelType, 0);
1378           Section.advanceStubOffset(getMaxStubSize());
1379         }
1380         if (SymType == SymbolRef::ST_Unknown) {
1381           // Restore the TOC for external calls
1382           if (AbiVariant == 2)
1383             writeInt32BE(Target + 4, 0xE8410018); // ld r2,28(r1)
1384           else
1385             writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1)
1386         }
1387       }
1388     } else if (RelType == ELF::R_PPC64_TOC16 ||
1389                RelType == ELF::R_PPC64_TOC16_DS ||
1390                RelType == ELF::R_PPC64_TOC16_LO ||
1391                RelType == ELF::R_PPC64_TOC16_LO_DS ||
1392                RelType == ELF::R_PPC64_TOC16_HI ||
1393                RelType == ELF::R_PPC64_TOC16_HA) {
1394       // These relocations are supposed to subtract the TOC address from
1395       // the final value.  This does not fit cleanly into the RuntimeDyld
1396       // scheme, since there may be *two* sections involved in determining
1397       // the relocation value (the section of the symbol referred to by the
1398       // relocation, and the TOC section associated with the current module).
1399       //
1400       // Fortunately, these relocations are currently only ever generated
1401       // referring to symbols that themselves reside in the TOC, which means
1402       // that the two sections are actually the same.  Thus they cancel out
1403       // and we can immediately resolve the relocation right now.
1404       switch (RelType) {
1405       case ELF::R_PPC64_TOC16: RelType = ELF::R_PPC64_ADDR16; break;
1406       case ELF::R_PPC64_TOC16_DS: RelType = ELF::R_PPC64_ADDR16_DS; break;
1407       case ELF::R_PPC64_TOC16_LO: RelType = ELF::R_PPC64_ADDR16_LO; break;
1408       case ELF::R_PPC64_TOC16_LO_DS: RelType = ELF::R_PPC64_ADDR16_LO_DS; break;
1409       case ELF::R_PPC64_TOC16_HI: RelType = ELF::R_PPC64_ADDR16_HI; break;
1410       case ELF::R_PPC64_TOC16_HA: RelType = ELF::R_PPC64_ADDR16_HA; break;
1411       default: llvm_unreachable("Wrong relocation type.");
1412       }
1413
1414       RelocationValueRef TOCValue;
1415       if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, TOCValue))
1416         return std::move(Err);
1417       if (Value.SymbolName || Value.SectionID != TOCValue.SectionID)
1418         llvm_unreachable("Unsupported TOC relocation.");
1419       Value.Addend -= TOCValue.Addend;
1420       resolveRelocation(Sections[SectionID], Offset, Value.Addend, RelType, 0);
1421     } else {
1422       // There are two ways to refer to the TOC address directly: either
1423       // via a ELF::R_PPC64_TOC relocation (where both symbol and addend are
1424       // ignored), or via any relocation that refers to the magic ".TOC."
1425       // symbols (in which case the addend is respected).
1426       if (RelType == ELF::R_PPC64_TOC) {
1427         RelType = ELF::R_PPC64_ADDR64;
1428         if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, Value))
1429           return std::move(Err);
1430       } else if (TargetName == ".TOC.") {
1431         if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, Value))
1432           return std::move(Err);
1433         Value.Addend += Addend;
1434       }
1435
1436       RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1437
1438       if (Value.SymbolName)
1439         addRelocationForSymbol(RE, Value.SymbolName);
1440       else
1441         addRelocationForSection(RE, Value.SectionID);
1442     }
1443   } else if (Arch == Triple::systemz &&
1444              (RelType == ELF::R_390_PLT32DBL || RelType == ELF::R_390_GOTENT)) {
1445     // Create function stubs for both PLT and GOT references, regardless of
1446     // whether the GOT reference is to data or code.  The stub contains the
1447     // full address of the symbol, as needed by GOT references, and the
1448     // executable part only adds an overhead of 8 bytes.
1449     //
1450     // We could try to conserve space by allocating the code and data
1451     // parts of the stub separately.  However, as things stand, we allocate
1452     // a stub for every relocation, so using a GOT in JIT code should be
1453     // no less space efficient than using an explicit constant pool.
1454     DEBUG(dbgs() << "\t\tThis is a SystemZ indirect relocation.");
1455     SectionEntry &Section = Sections[SectionID];
1456
1457     // Look for an existing stub.
1458     StubMap::const_iterator i = Stubs.find(Value);
1459     uintptr_t StubAddress;
1460     if (i != Stubs.end()) {
1461       StubAddress = uintptr_t(Section.getAddressWithOffset(i->second));
1462       DEBUG(dbgs() << " Stub function found\n");
1463     } else {
1464       // Create a new stub function.
1465       DEBUG(dbgs() << " Create a new stub function\n");
1466
1467       uintptr_t BaseAddress = uintptr_t(Section.getAddress());
1468       uintptr_t StubAlignment = getStubAlignment();
1469       StubAddress =
1470           (BaseAddress + Section.getStubOffset() + StubAlignment - 1) &
1471           -StubAlignment;
1472       unsigned StubOffset = StubAddress - BaseAddress;
1473
1474       Stubs[Value] = StubOffset;
1475       createStubFunction((uint8_t *)StubAddress);
1476       RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64,
1477                          Value.Offset);
1478       if (Value.SymbolName)
1479         addRelocationForSymbol(RE, Value.SymbolName);
1480       else
1481         addRelocationForSection(RE, Value.SectionID);
1482       Section.advanceStubOffset(getMaxStubSize());
1483     }
1484
1485     if (RelType == ELF::R_390_GOTENT)
1486       resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL,
1487                         Addend);
1488     else
1489       resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
1490   } else if (Arch == Triple::x86_64) {
1491     if (RelType == ELF::R_X86_64_PLT32) {
1492       // The way the PLT relocations normally work is that the linker allocates
1493       // the
1494       // PLT and this relocation makes a PC-relative call into the PLT.  The PLT
1495       // entry will then jump to an address provided by the GOT.  On first call,
1496       // the
1497       // GOT address will point back into PLT code that resolves the symbol. After
1498       // the first call, the GOT entry points to the actual function.
1499       //
1500       // For local functions we're ignoring all of that here and just replacing
1501       // the PLT32 relocation type with PC32, which will translate the relocation
1502       // into a PC-relative call directly to the function. For external symbols we
1503       // can't be sure the function will be within 2^32 bytes of the call site, so
1504       // we need to create a stub, which calls into the GOT.  This case is
1505       // equivalent to the usual PLT implementation except that we use the stub
1506       // mechanism in RuntimeDyld (which puts stubs at the end of the section)
1507       // rather than allocating a PLT section.
1508       if (Value.SymbolName) {
1509         // This is a call to an external function.
1510         // Look for an existing stub.
1511         SectionEntry &Section = Sections[SectionID];
1512         StubMap::const_iterator i = Stubs.find(Value);
1513         uintptr_t StubAddress;
1514         if (i != Stubs.end()) {
1515           StubAddress = uintptr_t(Section.getAddress()) + i->second;
1516           DEBUG(dbgs() << " Stub function found\n");
1517         } else {
1518           // Create a new stub function (equivalent to a PLT entry).
1519           DEBUG(dbgs() << " Create a new stub function\n");
1520
1521           uintptr_t BaseAddress = uintptr_t(Section.getAddress());
1522           uintptr_t StubAlignment = getStubAlignment();
1523           StubAddress =
1524               (BaseAddress + Section.getStubOffset() + StubAlignment - 1) &
1525               -StubAlignment;
1526           unsigned StubOffset = StubAddress - BaseAddress;
1527           Stubs[Value] = StubOffset;
1528           createStubFunction((uint8_t *)StubAddress);
1529
1530           // Bump our stub offset counter
1531           Section.advanceStubOffset(getMaxStubSize());
1532
1533           // Allocate a GOT Entry
1534           uint64_t GOTOffset = allocateGOTEntries(1);
1535
1536           // The load of the GOT address has an addend of -4
1537           resolveGOTOffsetRelocation(SectionID, StubOffset + 2, GOTOffset - 4,
1538                                      ELF::R_X86_64_PC32);
1539
1540           // Fill in the value of the symbol we're targeting into the GOT
1541           addRelocationForSymbol(
1542               computeGOTOffsetRE(GOTOffset, 0, ELF::R_X86_64_64),
1543               Value.SymbolName);
1544         }
1545
1546         // Make the target call a call into the stub table.
1547         resolveRelocation(Section, Offset, StubAddress, ELF::R_X86_64_PC32,
1548                           Addend);
1549       } else {
1550         RelocationEntry RE(SectionID, Offset, ELF::R_X86_64_PC32, Value.Addend,
1551                   Value.Offset);
1552         addRelocationForSection(RE, Value.SectionID);
1553       }
1554     } else if (RelType == ELF::R_X86_64_GOTPCREL ||
1555                RelType == ELF::R_X86_64_GOTPCRELX ||
1556                RelType == ELF::R_X86_64_REX_GOTPCRELX) {
1557       uint64_t GOTOffset = allocateGOTEntries(1);
1558       resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1559                                  ELF::R_X86_64_PC32);
1560
1561       // Fill in the value of the symbol we're targeting into the GOT
1562       RelocationEntry RE =
1563           computeGOTOffsetRE(GOTOffset, Value.Offset, ELF::R_X86_64_64);
1564       if (Value.SymbolName)
1565         addRelocationForSymbol(RE, Value.SymbolName);
1566       else
1567         addRelocationForSection(RE, Value.SectionID);
1568     } else if (RelType == ELF::R_X86_64_PC32) {
1569       Value.Addend += support::ulittle32_t::ref(computePlaceholderAddress(SectionID, Offset));
1570       processSimpleRelocation(SectionID, Offset, RelType, Value);
1571     } else if (RelType == ELF::R_X86_64_PC64) {
1572       Value.Addend += support::ulittle64_t::ref(computePlaceholderAddress(SectionID, Offset));
1573       processSimpleRelocation(SectionID, Offset, RelType, Value);
1574     } else {
1575       processSimpleRelocation(SectionID, Offset, RelType, Value);
1576     }
1577   } else {
1578     if (Arch == Triple::x86) {
1579       Value.Addend += support::ulittle32_t::ref(computePlaceholderAddress(SectionID, Offset));
1580     }
1581     processSimpleRelocation(SectionID, Offset, RelType, Value);
1582   }
1583   return ++RelI;
1584 }
1585
1586 size_t RuntimeDyldELF::getGOTEntrySize() {
1587   // We don't use the GOT in all of these cases, but it's essentially free
1588   // to put them all here.
1589   size_t Result = 0;
1590   switch (Arch) {
1591   case Triple::x86_64:
1592   case Triple::aarch64:
1593   case Triple::aarch64_be:
1594   case Triple::ppc64:
1595   case Triple::ppc64le:
1596   case Triple::systemz:
1597     Result = sizeof(uint64_t);
1598     break;
1599   case Triple::x86:
1600   case Triple::arm:
1601   case Triple::thumb:
1602     Result = sizeof(uint32_t);
1603     break;
1604   case Triple::mips:
1605   case Triple::mipsel:
1606   case Triple::mips64:
1607   case Triple::mips64el:
1608     if (IsMipsO32ABI || IsMipsN32ABI)
1609       Result = sizeof(uint32_t);
1610     else if (IsMipsN64ABI)
1611       Result = sizeof(uint64_t);
1612     else
1613       llvm_unreachable("Mips ABI not handled");
1614     break;
1615   default:
1616     llvm_unreachable("Unsupported CPU type!");
1617   }
1618   return Result;
1619 }
1620
1621 uint64_t RuntimeDyldELF::allocateGOTEntries(unsigned no) {
1622   if (GOTSectionID == 0) {
1623     GOTSectionID = Sections.size();
1624     // Reserve a section id. We'll allocate the section later
1625     // once we know the total size
1626     Sections.push_back(SectionEntry(".got", nullptr, 0, 0, 0));
1627   }
1628   uint64_t StartOffset = CurrentGOTIndex * getGOTEntrySize();
1629   CurrentGOTIndex += no;
1630   return StartOffset;
1631 }
1632
1633 uint64_t RuntimeDyldELF::findOrAllocGOTEntry(const RelocationValueRef &Value,
1634                                              unsigned GOTRelType) {
1635   auto E = GOTOffsetMap.insert({Value, 0});
1636   if (E.second) {
1637     uint64_t GOTOffset = allocateGOTEntries(1);
1638
1639     // Create relocation for newly created GOT entry
1640     RelocationEntry RE =
1641         computeGOTOffsetRE(GOTOffset, Value.Offset, GOTRelType);
1642     if (Value.SymbolName)
1643       addRelocationForSymbol(RE, Value.SymbolName);
1644     else
1645       addRelocationForSection(RE, Value.SectionID);
1646
1647     E.first->second = GOTOffset;
1648   }
1649
1650   return E.first->second;
1651 }
1652
1653 void RuntimeDyldELF::resolveGOTOffsetRelocation(unsigned SectionID,
1654                                                 uint64_t Offset,
1655                                                 uint64_t GOTOffset,
1656                                                 uint32_t Type) {
1657   // Fill in the relative address of the GOT Entry into the stub
1658   RelocationEntry GOTRE(SectionID, Offset, Type, GOTOffset);
1659   addRelocationForSection(GOTRE, GOTSectionID);
1660 }
1661
1662 RelocationEntry RuntimeDyldELF::computeGOTOffsetRE(uint64_t GOTOffset,
1663                                                    uint64_t SymbolOffset,
1664                                                    uint32_t Type) {
1665   return RelocationEntry(GOTSectionID, GOTOffset, Type, SymbolOffset);
1666 }
1667
1668 Error RuntimeDyldELF::finalizeLoad(const ObjectFile &Obj,
1669                                   ObjSectionToIDMap &SectionMap) {
1670   if (IsMipsO32ABI)
1671     if (!PendingRelocs.empty())
1672       return make_error<RuntimeDyldError>("Can't find matching LO16 reloc");
1673
1674   // If necessary, allocate the global offset table
1675   if (GOTSectionID != 0) {
1676     // Allocate memory for the section
1677     size_t TotalSize = CurrentGOTIndex * getGOTEntrySize();
1678     uint8_t *Addr = MemMgr.allocateDataSection(TotalSize, getGOTEntrySize(),
1679                                                 GOTSectionID, ".got", false);
1680     if (!Addr)
1681       return make_error<RuntimeDyldError>("Unable to allocate memory for GOT!");
1682
1683     Sections[GOTSectionID] =
1684         SectionEntry(".got", Addr, TotalSize, TotalSize, 0);
1685
1686     if (Checker)
1687       Checker->registerSection(Obj.getFileName(), GOTSectionID);
1688
1689     // For now, initialize all GOT entries to zero.  We'll fill them in as
1690     // needed when GOT-based relocations are applied.
1691     memset(Addr, 0, TotalSize);
1692     if (IsMipsN32ABI || IsMipsN64ABI) {
1693       // To correctly resolve Mips GOT relocations, we need a mapping from
1694       // object's sections to GOTs.
1695       for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
1696            SI != SE; ++SI) {
1697         if (SI->relocation_begin() != SI->relocation_end()) {
1698           section_iterator RelocatedSection = SI->getRelocatedSection();
1699           ObjSectionToIDMap::iterator i = SectionMap.find(*RelocatedSection);
1700           assert (i != SectionMap.end());
1701           SectionToGOTMap[i->second] = GOTSectionID;
1702         }
1703       }
1704       GOTSymbolOffsets.clear();
1705     }
1706   }
1707
1708   // Look for and record the EH frame section.
1709   ObjSectionToIDMap::iterator i, e;
1710   for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {
1711     const SectionRef &Section = i->first;
1712     StringRef Name;
1713     Section.getName(Name);
1714     if (Name == ".eh_frame") {
1715       UnregisteredEHFrameSections.push_back(i->second);
1716       break;
1717     }
1718   }
1719
1720   GOTSectionID = 0;
1721   CurrentGOTIndex = 0;
1722
1723   return Error::success();
1724 }
1725
1726 bool RuntimeDyldELF::isCompatibleFile(const object::ObjectFile &Obj) const {
1727   return Obj.isELF();
1728 }
1729
1730 bool RuntimeDyldELF::relocationNeedsGot(const RelocationRef &R) const {
1731   unsigned RelTy = R.getType();
1732   if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be)
1733     return RelTy == ELF::R_AARCH64_ADR_GOT_PAGE ||
1734            RelTy == ELF::R_AARCH64_LD64_GOT_LO12_NC;
1735
1736   if (Arch == Triple::x86_64)
1737     return RelTy == ELF::R_X86_64_GOTPCREL ||
1738            RelTy == ELF::R_X86_64_GOTPCRELX ||
1739            RelTy == ELF::R_X86_64_REX_GOTPCRELX;
1740   return false;
1741 }
1742
1743 bool RuntimeDyldELF::relocationNeedsStub(const RelocationRef &R) const {
1744   if (Arch != Triple::x86_64)
1745     return true;  // Conservative answer
1746
1747   switch (R.getType()) {
1748   default:
1749     return true;  // Conservative answer
1750
1751
1752   case ELF::R_X86_64_GOTPCREL:
1753   case ELF::R_X86_64_GOTPCRELX:
1754   case ELF::R_X86_64_REX_GOTPCRELX:
1755   case ELF::R_X86_64_PC32:
1756   case ELF::R_X86_64_PC64:
1757   case ELF::R_X86_64_64:
1758     // We know that these reloation types won't need a stub function.  This list
1759     // can be extended as needed.
1760     return false;
1761   }
1762 }
1763
1764 } // namespace llvm