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 "JITRegistrar.h"
16#include "ObjectImageCommon.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/ExecutionEngine/ObjectBuffer.h"
22#include "llvm/ExecutionEngine/ObjectImage.h"
23#include "llvm/Object/ELFObjectFile.h"
24#include "llvm/Object/ObjectFile.h"
25#include "llvm/Support/ELF.h"
26#include "llvm/Support/MemoryBuffer.h"
27
28using namespace llvm;
29using namespace llvm::object;
30
31#define DEBUG_TYPE "dyld"
32
33namespace {
34
35static inline std::error_code check(std::error_code Err) {
36  if (Err) {
37    report_fatal_error(Err.message());
38  }
39  return Err;
40}
41
42template <class ELFT> class DyldELFObject : public ELFObjectFile<ELFT> {
43  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
44
45  typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
46  typedef Elf_Sym_Impl<ELFT> Elf_Sym;
47  typedef Elf_Rel_Impl<ELFT, false> Elf_Rel;
48  typedef Elf_Rel_Impl<ELFT, true> Elf_Rela;
49
50  typedef Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
51
52  typedef typename ELFDataTypeTypedefHelper<ELFT>::value_type addr_type;
53
54  std::unique_ptr<ObjectFile> UnderlyingFile;
55
56public:
57  DyldELFObject(std::unique_ptr<ObjectFile> UnderlyingFile,
58                std::unique_ptr<MemoryBuffer> Wrapper, std::error_code &ec);
59
60  DyldELFObject(std::unique_ptr<MemoryBuffer> Wrapper, std::error_code &ec);
61
62  void updateSectionAddress(const SectionRef &Sec, uint64_t Addr);
63  void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr);
64
65  // Methods for type inquiry through isa, cast and dyn_cast
66  static inline bool classof(const Binary *v) {
67    return (isa<ELFObjectFile<ELFT>>(v) &&
68            classof(cast<ELFObjectFile<ELFT>>(v)));
69  }
70  static inline bool classof(const ELFObjectFile<ELFT> *v) {
71    return v->isDyldType();
72  }
73};
74
75template <class ELFT> class ELFObjectImage : public ObjectImageCommon {
76  bool Registered;
77
78public:
79  ELFObjectImage(ObjectBuffer *Input, std::unique_ptr<DyldELFObject<ELFT>> Obj)
80      : ObjectImageCommon(Input, std::move(Obj)), Registered(false) {}
81
82  virtual ~ELFObjectImage() {
83    if (Registered)
84      deregisterWithDebugger();
85  }
86
87  // Subclasses can override these methods to update the image with loaded
88  // addresses for sections and common symbols
89  void updateSectionAddress(const SectionRef &Sec, uint64_t Addr) override {
90    static_cast<DyldELFObject<ELFT>*>(getObjectFile())
91        ->updateSectionAddress(Sec, Addr);
92  }
93
94  void updateSymbolAddress(const SymbolRef &Sym, uint64_t Addr) override {
95    static_cast<DyldELFObject<ELFT>*>(getObjectFile())
96        ->updateSymbolAddress(Sym, Addr);
97  }
98
99  void registerWithDebugger() override {
100    JITRegistrar::getGDBRegistrar().registerObject(*Buffer);
101    Registered = true;
102  }
103  void deregisterWithDebugger() override {
104    JITRegistrar::getGDBRegistrar().deregisterObject(*Buffer);
105  }
106};
107
108// The MemoryBuffer passed into this constructor is just a wrapper around the
109// actual memory.  Ultimately, the Binary parent class will take ownership of
110// this MemoryBuffer object but not the underlying memory.
111template <class ELFT>
112DyldELFObject<ELFT>::DyldELFObject(std::unique_ptr<MemoryBuffer> Wrapper,
113                                   std::error_code &EC)
114    : ELFObjectFile<ELFT>(std::move(Wrapper), EC) {
115  this->isDyldELFObject = true;
116}
117
118template <class ELFT>
119DyldELFObject<ELFT>::DyldELFObject(std::unique_ptr<ObjectFile> UnderlyingFile,
120                                   std::unique_ptr<MemoryBuffer> Wrapper,
121                                   std::error_code &EC)
122    : ELFObjectFile<ELFT>(std::move(Wrapper), EC),
123      UnderlyingFile(std::move(UnderlyingFile)) {
124  this->isDyldELFObject = true;
125}
126
127template <class ELFT>
128void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec,
129                                               uint64_t Addr) {
130  DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
131  Elf_Shdr *shdr =
132      const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
133
134  // This assumes the address passed in matches the target address bitness
135  // The template-based type cast handles everything else.
136  shdr->sh_addr = static_cast<addr_type>(Addr);
137}
138
139template <class ELFT>
140void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef,
141                                              uint64_t Addr) {
142
143  Elf_Sym *sym = const_cast<Elf_Sym *>(
144      ELFObjectFile<ELFT>::getSymbol(SymRef.getRawDataRefImpl()));
145
146  // This assumes the address passed in matches the target address bitness
147  // The template-based type cast handles everything else.
148  sym->st_value = static_cast<addr_type>(Addr);
149}
150
151} // namespace
152
153namespace llvm {
154
155void RuntimeDyldELF::registerEHFrames() {
156  if (!MemMgr)
157    return;
158  for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
159    SID EHFrameSID = UnregisteredEHFrameSections[i];
160    uint8_t *EHFrameAddr = Sections[EHFrameSID].Address;
161    uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress;
162    size_t EHFrameSize = Sections[EHFrameSID].Size;
163    MemMgr->registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
164    RegisteredEHFrameSections.push_back(EHFrameSID);
165  }
166  UnregisteredEHFrameSections.clear();
167}
168
169void RuntimeDyldELF::deregisterEHFrames() {
170  if (!MemMgr)
171    return;
172  for (int i = 0, e = RegisteredEHFrameSections.size(); i != e; ++i) {
173    SID EHFrameSID = RegisteredEHFrameSections[i];
174    uint8_t *EHFrameAddr = Sections[EHFrameSID].Address;
175    uint64_t EHFrameLoadAddr = Sections[EHFrameSID].LoadAddress;
176    size_t EHFrameSize = Sections[EHFrameSID].Size;
177    MemMgr->deregisterEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
178  }
179  RegisteredEHFrameSections.clear();
180}
181
182ObjectImage *
183RuntimeDyldELF::createObjectImageFromFile(std::unique_ptr<object::ObjectFile> ObjFile) {
184  if (!ObjFile)
185    return nullptr;
186
187  std::error_code ec;
188  std::unique_ptr<MemoryBuffer> Buffer(
189      MemoryBuffer::getMemBuffer(ObjFile->getData(), "", false));
190
191  if (ObjFile->getBytesInAddress() == 4 && ObjFile->isLittleEndian()) {
192    auto Obj =
193        llvm::make_unique<DyldELFObject<ELFType<support::little, 2, false>>>(
194            std::move(ObjFile), std::move(Buffer), ec);
195    return new ELFObjectImage<ELFType<support::little, 2, false>>(
196        nullptr, std::move(Obj));
197  } else if (ObjFile->getBytesInAddress() == 4 && !ObjFile->isLittleEndian()) {
198    auto Obj =
199        llvm::make_unique<DyldELFObject<ELFType<support::big, 2, false>>>(
200            std::move(ObjFile), std::move(Buffer), ec);
201    return new ELFObjectImage<ELFType<support::big, 2, false>>(nullptr, std::move(Obj));
202  } else if (ObjFile->getBytesInAddress() == 8 && !ObjFile->isLittleEndian()) {
203    auto Obj = llvm::make_unique<DyldELFObject<ELFType<support::big, 2, true>>>(
204        std::move(ObjFile), std::move(Buffer), ec);
205    return new ELFObjectImage<ELFType<support::big, 2, true>>(nullptr,
206                                                              std::move(Obj));
207  } else if (ObjFile->getBytesInAddress() == 8 && ObjFile->isLittleEndian()) {
208    auto Obj =
209        llvm::make_unique<DyldELFObject<ELFType<support::little, 2, true>>>(
210            std::move(ObjFile), std::move(Buffer), ec);
211    return new ELFObjectImage<ELFType<support::little, 2, true>>(
212        nullptr, std::move(Obj));
213  } else
214    llvm_unreachable("Unexpected ELF format");
215}
216
217ObjectImage *RuntimeDyldELF::createObjectImage(ObjectBuffer *Buffer) {
218  if (Buffer->getBufferSize() < ELF::EI_NIDENT)
219    llvm_unreachable("Unexpected ELF object size");
220  std::pair<unsigned char, unsigned char> Ident =
221      std::make_pair((uint8_t)Buffer->getBufferStart()[ELF::EI_CLASS],
222                     (uint8_t)Buffer->getBufferStart()[ELF::EI_DATA]);
223  std::error_code ec;
224
225  std::unique_ptr<MemoryBuffer> Buf(Buffer->getMemBuffer());
226
227  if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) {
228    auto Obj =
229        llvm::make_unique<DyldELFObject<ELFType<support::little, 4, false>>>(
230            std::move(Buf), ec);
231    return new ELFObjectImage<ELFType<support::little, 4, false>>(
232        Buffer, std::move(Obj));
233  } else if (Ident.first == ELF::ELFCLASS32 &&
234             Ident.second == ELF::ELFDATA2MSB) {
235    auto Obj =
236        llvm::make_unique<DyldELFObject<ELFType<support::big, 4, false>>>(
237            std::move(Buf), ec);
238    return new ELFObjectImage<ELFType<support::big, 4, false>>(Buffer,
239                                                               std::move(Obj));
240  } else if (Ident.first == ELF::ELFCLASS64 &&
241             Ident.second == ELF::ELFDATA2MSB) {
242    auto Obj = llvm::make_unique<DyldELFObject<ELFType<support::big, 8, true>>>(
243        std::move(Buf), ec);
244    return new ELFObjectImage<ELFType<support::big, 8, true>>(Buffer, std::move(Obj));
245  } else if (Ident.first == ELF::ELFCLASS64 &&
246             Ident.second == ELF::ELFDATA2LSB) {
247    auto Obj =
248        llvm::make_unique<DyldELFObject<ELFType<support::little, 8, true>>>(
249            std::move(Buf), ec);
250    return new ELFObjectImage<ELFType<support::little, 8, true>>(Buffer, std::move(Obj));
251  } else
252    llvm_unreachable("Unexpected ELF format");
253}
254
255RuntimeDyldELF::~RuntimeDyldELF() {}
256
257void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
258                                             uint64_t Offset, uint64_t Value,
259                                             uint32_t Type, int64_t Addend,
260                                             uint64_t SymOffset) {
261  switch (Type) {
262  default:
263    llvm_unreachable("Relocation type not implemented yet!");
264    break;
265  case ELF::R_X86_64_64: {
266    uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset);
267    *Target = Value + Addend;
268    DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
269                 << format("%p\n", Target));
270    break;
271  }
272  case ELF::R_X86_64_32:
273  case ELF::R_X86_64_32S: {
274    Value += Addend;
275    assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) ||
276           (Type == ELF::R_X86_64_32S &&
277            ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
278    uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
279    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
280    *Target = TruncatedAddr;
281    DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
282                 << format("%p\n", Target));
283    break;
284  }
285  case ELF::R_X86_64_GOTPCREL: {
286    // findGOTEntry returns the 'G + GOT' part of the relocation calculation
287    // based on the load/target address of the GOT (not the current/local addr).
288    uint64_t GOTAddr = findGOTEntry(Value, SymOffset);
289    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
290    uint64_t FinalAddress = Section.LoadAddress + Offset;
291    // The processRelocationRef method combines the symbol offset and the addend
292    // and in most cases that's what we want.  For this relocation type, we need
293    // the raw addend, so we subtract the symbol offset to get it.
294    int64_t RealOffset = GOTAddr + Addend - SymOffset - FinalAddress;
295    assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN);
296    int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
297    *Target = TruncOffset;
298    break;
299  }
300  case ELF::R_X86_64_PC32: {
301    // Get the placeholder value from the generated object since
302    // a previous relocation attempt may have overwritten the loaded version
303    uint32_t *Placeholder =
304        reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
305    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
306    uint64_t FinalAddress = Section.LoadAddress + Offset;
307    int64_t RealOffset = *Placeholder + Value + Addend - FinalAddress;
308    assert(RealOffset <= INT32_MAX && RealOffset >= INT32_MIN);
309    int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
310    *Target = TruncOffset;
311    break;
312  }
313  case ELF::R_X86_64_PC64: {
314    // Get the placeholder value from the generated object since
315    // a previous relocation attempt may have overwritten the loaded version
316    uint64_t *Placeholder =
317        reinterpret_cast<uint64_t *>(Section.ObjAddress + Offset);
318    uint64_t *Target = reinterpret_cast<uint64_t *>(Section.Address + Offset);
319    uint64_t FinalAddress = Section.LoadAddress + Offset;
320    *Target = *Placeholder + Value + Addend - FinalAddress;
321    break;
322  }
323  }
324}
325
326void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section,
327                                          uint64_t Offset, uint32_t Value,
328                                          uint32_t Type, int32_t Addend) {
329  switch (Type) {
330  case ELF::R_386_32: {
331    // Get the placeholder value from the generated object since
332    // a previous relocation attempt may have overwritten the loaded version
333    uint32_t *Placeholder =
334        reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
335    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
336    *Target = *Placeholder + Value + Addend;
337    break;
338  }
339  case ELF::R_386_PC32: {
340    // Get the placeholder value from the generated object since
341    // a previous relocation attempt may have overwritten the loaded version
342    uint32_t *Placeholder =
343        reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
344    uint32_t *Target = reinterpret_cast<uint32_t *>(Section.Address + Offset);
345    uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
346    uint32_t RealOffset = *Placeholder + Value + Addend - FinalAddress;
347    *Target = RealOffset;
348    break;
349  }
350  default:
351    // There are other relocation types, but it appears these are the
352    // only ones currently used by the LLVM ELF object writer
353    llvm_unreachable("Relocation type not implemented yet!");
354    break;
355  }
356}
357
358void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
359                                              uint64_t Offset, uint64_t Value,
360                                              uint32_t Type, int64_t Addend) {
361  uint32_t *TargetPtr = reinterpret_cast<uint32_t *>(Section.Address + Offset);
362  uint64_t FinalAddress = Section.LoadAddress + Offset;
363
364  DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x"
365               << format("%llx", Section.Address + Offset)
366               << " FinalAddress: 0x" << format("%llx", FinalAddress)
367               << " Value: 0x" << format("%llx", Value) << " Type: 0x"
368               << format("%x", Type) << " Addend: 0x" << format("%llx", Addend)
369               << "\n");
370
371  switch (Type) {
372  default:
373    llvm_unreachable("Relocation type not implemented yet!");
374    break;
375  case ELF::R_AARCH64_ABS64: {
376    uint64_t *TargetPtr =
377        reinterpret_cast<uint64_t *>(Section.Address + Offset);
378    *TargetPtr = Value + Addend;
379    break;
380  }
381  case ELF::R_AARCH64_PREL32: {
382    uint64_t Result = Value + Addend - FinalAddress;
383    assert(static_cast<int64_t>(Result) >= INT32_MIN &&
384           static_cast<int64_t>(Result) <= UINT32_MAX);
385    *TargetPtr = static_cast<uint32_t>(Result & 0xffffffffU);
386    break;
387  }
388  case ELF::R_AARCH64_CALL26: // fallthrough
389  case ELF::R_AARCH64_JUMP26: {
390    // Operation: S+A-P. Set Call or B immediate value to bits fff_fffc of the
391    // calculation.
392    uint64_t BranchImm = Value + Addend - FinalAddress;
393
394    // "Check that -2^27 <= result < 2^27".
395    assert(-(1LL << 27) <= static_cast<int64_t>(BranchImm) &&
396           static_cast<int64_t>(BranchImm) < (1LL << 27));
397
398    // AArch64 code is emitted with .rela relocations. The data already in any
399    // bits affected by the relocation on entry is garbage.
400    *TargetPtr &= 0xfc000000U;
401    // Immediate goes in bits 25:0 of B and BL.
402    *TargetPtr |= static_cast<uint32_t>(BranchImm & 0xffffffcU) >> 2;
403    break;
404  }
405  case ELF::R_AARCH64_MOVW_UABS_G3: {
406    uint64_t Result = Value + Addend;
407
408    // AArch64 code is emitted with .rela relocations. The data already in any
409    // bits affected by the relocation on entry is garbage.
410    *TargetPtr &= 0xffe0001fU;
411    // Immediate goes in bits 20:5 of MOVZ/MOVK instruction
412    *TargetPtr |= Result >> (48 - 5);
413    // Shift must be "lsl #48", in bits 22:21
414    assert((*TargetPtr >> 21 & 0x3) == 3 && "invalid shift for relocation");
415    break;
416  }
417  case ELF::R_AARCH64_MOVW_UABS_G2_NC: {
418    uint64_t Result = Value + Addend;
419
420    // AArch64 code is emitted with .rela relocations. The data already in any
421    // bits affected by the relocation on entry is garbage.
422    *TargetPtr &= 0xffe0001fU;
423    // Immediate goes in bits 20:5 of MOVZ/MOVK instruction
424    *TargetPtr |= ((Result & 0xffff00000000ULL) >> (32 - 5));
425    // Shift must be "lsl #32", in bits 22:21
426    assert((*TargetPtr >> 21 & 0x3) == 2 && "invalid shift for relocation");
427    break;
428  }
429  case ELF::R_AARCH64_MOVW_UABS_G1_NC: {
430    uint64_t Result = Value + Addend;
431
432    // AArch64 code is emitted with .rela relocations. The data already in any
433    // bits affected by the relocation on entry is garbage.
434    *TargetPtr &= 0xffe0001fU;
435    // Immediate goes in bits 20:5 of MOVZ/MOVK instruction
436    *TargetPtr |= ((Result & 0xffff0000U) >> (16 - 5));
437    // Shift must be "lsl #16", in bits 22:2
438    assert((*TargetPtr >> 21 & 0x3) == 1 && "invalid shift for relocation");
439    break;
440  }
441  case ELF::R_AARCH64_MOVW_UABS_G0_NC: {
442    uint64_t Result = Value + Addend;
443
444    // AArch64 code is emitted with .rela relocations. The data already in any
445    // bits affected by the relocation on entry is garbage.
446    *TargetPtr &= 0xffe0001fU;
447    // Immediate goes in bits 20:5 of MOVZ/MOVK instruction
448    *TargetPtr |= ((Result & 0xffffU) << 5);
449    // Shift must be "lsl #0", in bits 22:21.
450    assert((*TargetPtr >> 21 & 0x3) == 0 && "invalid shift for relocation");
451    break;
452  }
453  case ELF::R_AARCH64_ADR_PREL_PG_HI21: {
454    // Operation: Page(S+A) - Page(P)
455    uint64_t Result =
456        ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
457
458    // Check that -2^32 <= X < 2^32
459    assert(static_cast<int64_t>(Result) >= (-1LL << 32) &&
460           static_cast<int64_t>(Result) < (1LL << 32) &&
461           "overflow check failed for relocation");
462
463    // AArch64 code is emitted with .rela relocations. The data already in any
464    // bits affected by the relocation on entry is garbage.
465    *TargetPtr &= 0x9f00001fU;
466    // Immediate goes in bits 30:29 + 5:23 of ADRP instruction, taken
467    // from bits 32:12 of X.
468    *TargetPtr |= ((Result & 0x3000U) << (29 - 12));
469    *TargetPtr |= ((Result & 0x1ffffc000ULL) >> (14 - 5));
470    break;
471  }
472  case ELF::R_AARCH64_LDST32_ABS_LO12_NC: {
473    // Operation: S + A
474    uint64_t Result = Value + Addend;
475
476    // AArch64 code is emitted with .rela relocations. The data already in any
477    // bits affected by the relocation on entry is garbage.
478    *TargetPtr &= 0xffc003ffU;
479    // Immediate goes in bits 21:10 of LD/ST instruction, taken
480    // from bits 11:2 of X
481    *TargetPtr |= ((Result & 0xffc) << (10 - 2));
482    break;
483  }
484  case ELF::R_AARCH64_LDST64_ABS_LO12_NC: {
485    // Operation: S + A
486    uint64_t Result = Value + Addend;
487
488    // AArch64 code is emitted with .rela relocations. The data already in any
489    // bits affected by the relocation on entry is garbage.
490    *TargetPtr &= 0xffc003ffU;
491    // Immediate goes in bits 21:10 of LD/ST instruction, taken
492    // from bits 11:3 of X
493    *TargetPtr |= ((Result & 0xff8) << (10 - 3));
494    break;
495  }
496  }
497}
498
499void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
500                                          uint64_t Offset, uint32_t Value,
501                                          uint32_t Type, int32_t Addend) {
502  // TODO: Add Thumb relocations.
503  uint32_t *Placeholder =
504      reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
505  uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset);
506  uint32_t FinalAddress = ((Section.LoadAddress + Offset) & 0xFFFFFFFF);
507  Value += Addend;
508
509  DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: "
510               << Section.Address + Offset
511               << " FinalAddress: " << format("%p", FinalAddress) << " Value: "
512               << format("%x", Value) << " Type: " << format("%x", Type)
513               << " Addend: " << format("%x", Addend) << "\n");
514
515  switch (Type) {
516  default:
517    llvm_unreachable("Not implemented relocation type!");
518
519  case ELF::R_ARM_NONE:
520    break;
521  // Write a 32bit value to relocation address, taking into account the
522  // implicit addend encoded in the target.
523  case ELF::R_ARM_PREL31:
524  case ELF::R_ARM_TARGET1:
525  case ELF::R_ARM_ABS32:
526    *TargetPtr = *Placeholder + Value;
527    break;
528  // Write first 16 bit of 32 bit value to the mov instruction.
529  // Last 4 bit should be shifted.
530  case ELF::R_ARM_MOVW_ABS_NC:
531    // We are not expecting any other addend in the relocation address.
532    // Using 0x000F0FFF because MOVW has its 16 bit immediate split into 2
533    // non-contiguous fields.
534    assert((*Placeholder & 0x000F0FFF) == 0);
535    Value = Value & 0xFFFF;
536    *TargetPtr = *Placeholder | (Value & 0xFFF);
537    *TargetPtr |= ((Value >> 12) & 0xF) << 16;
538    break;
539  // Write last 16 bit of 32 bit value to the mov instruction.
540  // Last 4 bit should be shifted.
541  case ELF::R_ARM_MOVT_ABS:
542    // We are not expecting any other addend in the relocation address.
543    // Use 0x000F0FFF for the same reason as R_ARM_MOVW_ABS_NC.
544    assert((*Placeholder & 0x000F0FFF) == 0);
545
546    Value = (Value >> 16) & 0xFFFF;
547    *TargetPtr = *Placeholder | (Value & 0xFFF);
548    *TargetPtr |= ((Value >> 12) & 0xF) << 16;
549    break;
550  // Write 24 bit relative value to the branch instruction.
551  case ELF::R_ARM_PC24: // Fall through.
552  case ELF::R_ARM_CALL: // Fall through.
553  case ELF::R_ARM_JUMP24: {
554    int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8);
555    RelValue = (RelValue & 0x03FFFFFC) >> 2;
556    assert((*TargetPtr & 0xFFFFFF) == 0xFFFFFE);
557    *TargetPtr &= 0xFF000000;
558    *TargetPtr |= RelValue;
559    break;
560  }
561  case ELF::R_ARM_PRIVATE_0:
562    // This relocation is reserved by the ARM ELF ABI for internal use. We
563    // appropriate it here to act as an R_ARM_ABS32 without any addend for use
564    // in the stubs created during JIT (which can't put an addend into the
565    // original object file).
566    *TargetPtr = Value;
567    break;
568  }
569}
570
571void RuntimeDyldELF::resolveMIPSRelocation(const SectionEntry &Section,
572                                           uint64_t Offset, uint32_t Value,
573                                           uint32_t Type, int32_t Addend) {
574  uint32_t *Placeholder =
575      reinterpret_cast<uint32_t *>(Section.ObjAddress + Offset);
576  uint32_t *TargetPtr = (uint32_t *)(Section.Address + Offset);
577  Value += Addend;
578
579  DEBUG(dbgs() << "resolveMipselocation, LocalAddress: "
580               << Section.Address + Offset << " FinalAddress: "
581               << format("%p", Section.LoadAddress + Offset) << " Value: "
582               << format("%x", Value) << " Type: " << format("%x", Type)
583               << " Addend: " << format("%x", Addend) << "\n");
584
585  switch (Type) {
586  default:
587    llvm_unreachable("Not implemented relocation type!");
588    break;
589  case ELF::R_MIPS_32:
590    *TargetPtr = Value + (*Placeholder);
591    break;
592  case ELF::R_MIPS_26:
593    *TargetPtr = ((*Placeholder) & 0xfc000000) | ((Value & 0x0fffffff) >> 2);
594    break;
595  case ELF::R_MIPS_HI16:
596    // Get the higher 16-bits. Also add 1 if bit 15 is 1.
597    Value += ((*Placeholder) & 0x0000ffff) << 16;
598    *TargetPtr =
599        ((*Placeholder) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
600    break;
601  case ELF::R_MIPS_LO16:
602    Value += ((*Placeholder) & 0x0000ffff);
603    *TargetPtr = ((*Placeholder) & 0xffff0000) | (Value & 0xffff);
604    break;
605  case ELF::R_MIPS_UNUSED1:
606    // Similar to ELF::R_ARM_PRIVATE_0, R_MIPS_UNUSED1 and R_MIPS_UNUSED2
607    // are used for internal JIT purpose. These relocations are similar to
608    // R_MIPS_HI16 and R_MIPS_LO16, but they do not take any addend into
609    // account.
610    *TargetPtr =
611        ((*TargetPtr) & 0xffff0000) | (((Value + 0x8000) >> 16) & 0xffff);
612    break;
613  case ELF::R_MIPS_UNUSED2:
614    *TargetPtr = ((*TargetPtr) & 0xffff0000) | (Value & 0xffff);
615    break;
616  }
617}
618
619// Return the .TOC. section and offset.
620void RuntimeDyldELF::findPPC64TOCSection(ObjectImage &Obj,
621                                         ObjSectionToIDMap &LocalSections,
622                                         RelocationValueRef &Rel) {
623  // Set a default SectionID in case we do not find a TOC section below.
624  // This may happen for references to TOC base base (sym@toc, .odp
625  // relocation) without a .toc directive.  In this case just use the
626  // first section (which is usually the .odp) since the code won't
627  // reference the .toc base directly.
628  Rel.SymbolName = NULL;
629  Rel.SectionID = 0;
630
631  // The TOC consists of sections .got, .toc, .tocbss, .plt in that
632  // order. The TOC starts where the first of these sections starts.
633  for (section_iterator si = Obj.begin_sections(), se = Obj.end_sections();
634       si != se; ++si) {
635
636    StringRef SectionName;
637    check(si->getName(SectionName));
638
639    if (SectionName == ".got"
640        || SectionName == ".toc"
641        || SectionName == ".tocbss"
642        || SectionName == ".plt") {
643      Rel.SectionID = findOrEmitSection(Obj, *si, false, LocalSections);
644      break;
645    }
646  }
647
648  // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
649  // thus permitting a full 64 Kbytes segment.
650  Rel.Addend = 0x8000;
651}
652
653// Returns the sections and offset associated with the ODP entry referenced
654// by Symbol.
655void RuntimeDyldELF::findOPDEntrySection(ObjectImage &Obj,
656                                         ObjSectionToIDMap &LocalSections,
657                                         RelocationValueRef &Rel) {
658  // Get the ELF symbol value (st_value) to compare with Relocation offset in
659  // .opd entries
660  for (section_iterator si = Obj.begin_sections(), se = Obj.end_sections();
661       si != se; ++si) {
662    section_iterator RelSecI = si->getRelocatedSection();
663    if (RelSecI == Obj.end_sections())
664      continue;
665
666    StringRef RelSectionName;
667    check(RelSecI->getName(RelSectionName));
668    if (RelSectionName != ".opd")
669      continue;
670
671    for (relocation_iterator i = si->relocation_begin(),
672                             e = si->relocation_end();
673         i != e;) {
674      // The R_PPC64_ADDR64 relocation indicates the first field
675      // of a .opd entry
676      uint64_t TypeFunc;
677      check(i->getType(TypeFunc));
678      if (TypeFunc != ELF::R_PPC64_ADDR64) {
679        ++i;
680        continue;
681      }
682
683      uint64_t TargetSymbolOffset;
684      symbol_iterator TargetSymbol = i->getSymbol();
685      check(i->getOffset(TargetSymbolOffset));
686      int64_t Addend;
687      check(getELFRelocationAddend(*i, Addend));
688
689      ++i;
690      if (i == e)
691        break;
692
693      // Just check if following relocation is a R_PPC64_TOC
694      uint64_t TypeTOC;
695      check(i->getType(TypeTOC));
696      if (TypeTOC != ELF::R_PPC64_TOC)
697        continue;
698
699      // Finally compares the Symbol value and the target symbol offset
700      // to check if this .opd entry refers to the symbol the relocation
701      // points to.
702      if (Rel.Addend != (int64_t)TargetSymbolOffset)
703        continue;
704
705      section_iterator tsi(Obj.end_sections());
706      check(TargetSymbol->getSection(tsi));
707      bool IsCode = false;
708      tsi->isText(IsCode);
709      Rel.SectionID = findOrEmitSection(Obj, (*tsi), IsCode, LocalSections);
710      Rel.Addend = (intptr_t)Addend;
711      return;
712    }
713  }
714  llvm_unreachable("Attempting to get address of ODP entry!");
715}
716
717// Relocation masks following the #lo(value), #hi(value), #ha(value),
718// #higher(value), #highera(value), #highest(value), and #highesta(value)
719// macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
720// document.
721
722static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; }
723
724static inline uint16_t applyPPChi(uint64_t value) {
725  return (value >> 16) & 0xffff;
726}
727
728static inline uint16_t applyPPCha (uint64_t value) {
729  return ((value + 0x8000) >> 16) & 0xffff;
730}
731
732static inline uint16_t applyPPChigher(uint64_t value) {
733  return (value >> 32) & 0xffff;
734}
735
736static inline uint16_t applyPPChighera (uint64_t value) {
737  return ((value + 0x8000) >> 32) & 0xffff;
738}
739
740static inline uint16_t applyPPChighest(uint64_t value) {
741  return (value >> 48) & 0xffff;
742}
743
744static inline uint16_t applyPPChighesta (uint64_t value) {
745  return ((value + 0x8000) >> 48) & 0xffff;
746}
747
748void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
749                                            uint64_t Offset, uint64_t Value,
750                                            uint32_t Type, int64_t Addend) {
751  uint8_t *LocalAddress = Section.Address + Offset;
752  switch (Type) {
753  default:
754    llvm_unreachable("Relocation type not implemented yet!");
755    break;
756  case ELF::R_PPC64_ADDR16:
757    writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
758    break;
759  case ELF::R_PPC64_ADDR16_DS:
760    writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
761    break;
762  case ELF::R_PPC64_ADDR16_LO:
763    writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
764    break;
765  case ELF::R_PPC64_ADDR16_LO_DS:
766    writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
767    break;
768  case ELF::R_PPC64_ADDR16_HI:
769    writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
770    break;
771  case ELF::R_PPC64_ADDR16_HA:
772    writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
773    break;
774  case ELF::R_PPC64_ADDR16_HIGHER:
775    writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
776    break;
777  case ELF::R_PPC64_ADDR16_HIGHERA:
778    writeInt16BE(LocalAddress, applyPPChighera(Value + Addend));
779    break;
780  case ELF::R_PPC64_ADDR16_HIGHEST:
781    writeInt16BE(LocalAddress, applyPPChighest(Value + Addend));
782    break;
783  case ELF::R_PPC64_ADDR16_HIGHESTA:
784    writeInt16BE(LocalAddress, applyPPChighesta(Value + Addend));
785    break;
786  case ELF::R_PPC64_ADDR14: {
787    assert(((Value + Addend) & 3) == 0);
788    // Preserve the AA/LK bits in the branch instruction
789    uint8_t aalk = *(LocalAddress + 3);
790    writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
791  } break;
792  case ELF::R_PPC64_REL16_LO: {
793    uint64_t FinalAddress = (Section.LoadAddress + Offset);
794    uint64_t Delta = Value - FinalAddress + Addend;
795    writeInt16BE(LocalAddress, applyPPClo(Delta));
796  } break;
797  case ELF::R_PPC64_REL16_HI: {
798    uint64_t FinalAddress = (Section.LoadAddress + Offset);
799    uint64_t Delta = Value - FinalAddress + Addend;
800    writeInt16BE(LocalAddress, applyPPChi(Delta));
801  } break;
802  case ELF::R_PPC64_REL16_HA: {
803    uint64_t FinalAddress = (Section.LoadAddress + Offset);
804    uint64_t Delta = Value - FinalAddress + Addend;
805    writeInt16BE(LocalAddress, applyPPCha(Delta));
806  } break;
807  case ELF::R_PPC64_ADDR32: {
808    int32_t Result = static_cast<int32_t>(Value + Addend);
809    if (SignExtend32<32>(Result) != Result)
810      llvm_unreachable("Relocation R_PPC64_ADDR32 overflow");
811    writeInt32BE(LocalAddress, Result);
812  } break;
813  case ELF::R_PPC64_REL24: {
814    uint64_t FinalAddress = (Section.LoadAddress + Offset);
815    int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
816    if (SignExtend32<24>(delta) != delta)
817      llvm_unreachable("Relocation R_PPC64_REL24 overflow");
818    // Generates a 'bl <address>' instruction
819    writeInt32BE(LocalAddress, 0x48000001 | (delta & 0x03FFFFFC));
820  } break;
821  case ELF::R_PPC64_REL32: {
822    uint64_t FinalAddress = (Section.LoadAddress + Offset);
823    int32_t delta = static_cast<int32_t>(Value - FinalAddress + Addend);
824    if (SignExtend32<32>(delta) != delta)
825      llvm_unreachable("Relocation R_PPC64_REL32 overflow");
826    writeInt32BE(LocalAddress, delta);
827  } break;
828  case ELF::R_PPC64_REL64: {
829    uint64_t FinalAddress = (Section.LoadAddress + Offset);
830    uint64_t Delta = Value - FinalAddress + Addend;
831    writeInt64BE(LocalAddress, Delta);
832  } break;
833  case ELF::R_PPC64_ADDR64:
834    writeInt64BE(LocalAddress, Value + Addend);
835    break;
836  }
837}
838
839void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,
840                                              uint64_t Offset, uint64_t Value,
841                                              uint32_t Type, int64_t Addend) {
842  uint8_t *LocalAddress = Section.Address + Offset;
843  switch (Type) {
844  default:
845    llvm_unreachable("Relocation type not implemented yet!");
846    break;
847  case ELF::R_390_PC16DBL:
848  case ELF::R_390_PLT16DBL: {
849    int64_t Delta = (Value + Addend) - (Section.LoadAddress + Offset);
850    assert(int16_t(Delta / 2) * 2 == Delta && "R_390_PC16DBL overflow");
851    writeInt16BE(LocalAddress, Delta / 2);
852    break;
853  }
854  case ELF::R_390_PC32DBL:
855  case ELF::R_390_PLT32DBL: {
856    int64_t Delta = (Value + Addend) - (Section.LoadAddress + Offset);
857    assert(int32_t(Delta / 2) * 2 == Delta && "R_390_PC32DBL overflow");
858    writeInt32BE(LocalAddress, Delta / 2);
859    break;
860  }
861  case ELF::R_390_PC32: {
862    int64_t Delta = (Value + Addend) - (Section.LoadAddress + Offset);
863    assert(int32_t(Delta) == Delta && "R_390_PC32 overflow");
864    writeInt32BE(LocalAddress, Delta);
865    break;
866  }
867  case ELF::R_390_64:
868    writeInt64BE(LocalAddress, Value + Addend);
869    break;
870  }
871}
872
873// The target location for the relocation is described by RE.SectionID and
874// RE.Offset.  RE.SectionID can be used to find the SectionEntry.  Each
875// SectionEntry has three members describing its location.
876// SectionEntry::Address is the address at which the section has been loaded
877// into memory in the current (host) process.  SectionEntry::LoadAddress is the
878// address that the section will have in the target process.
879// SectionEntry::ObjAddress is the address of the bits for this section in the
880// original emitted object image (also in the current address space).
881//
882// Relocations will be applied as if the section were loaded at
883// SectionEntry::LoadAddress, but they will be applied at an address based
884// on SectionEntry::Address.  SectionEntry::ObjAddress will be used to refer to
885// Target memory contents if they are required for value calculations.
886//
887// The Value parameter here is the load address of the symbol for the
888// relocation to be applied.  For relocations which refer to symbols in the
889// current object Value will be the LoadAddress of the section in which
890// the symbol resides (RE.Addend provides additional information about the
891// symbol location).  For external symbols, Value will be the address of the
892// symbol in the target address space.
893void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE,
894                                       uint64_t Value) {
895  const SectionEntry &Section = Sections[RE.SectionID];
896  return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
897                           RE.SymOffset);
898}
899
900void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
901                                       uint64_t Offset, uint64_t Value,
902                                       uint32_t Type, int64_t Addend,
903                                       uint64_t SymOffset) {
904  switch (Arch) {
905  case Triple::x86_64:
906    resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
907    break;
908  case Triple::x86:
909    resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
910                         (uint32_t)(Addend & 0xffffffffL));
911    break;
912  case Triple::aarch64:
913  case Triple::aarch64_be:
914  case Triple::arm64:
915  case Triple::arm64_be:
916    resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
917    break;
918  case Triple::arm: // Fall through.
919  case Triple::armeb:
920  case Triple::thumb:
921  case Triple::thumbeb:
922    resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
923                         (uint32_t)(Addend & 0xffffffffL));
924    break;
925  case Triple::mips: // Fall through.
926  case Triple::mipsel:
927    resolveMIPSRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL),
928                          Type, (uint32_t)(Addend & 0xffffffffL));
929    break;
930  case Triple::ppc64: // Fall through.
931  case Triple::ppc64le:
932    resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
933    break;
934  case Triple::systemz:
935    resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
936    break;
937  default:
938    llvm_unreachable("Unsupported CPU type!");
939  }
940}
941
942relocation_iterator RuntimeDyldELF::processRelocationRef(
943    unsigned SectionID, relocation_iterator RelI, ObjectImage &Obj,
944    ObjSectionToIDMap &ObjSectionToID, const SymbolTableMap &Symbols,
945    StubMap &Stubs) {
946  uint64_t RelType;
947  Check(RelI->getType(RelType));
948  int64_t Addend;
949  Check(getELFRelocationAddend(*RelI, Addend));
950  symbol_iterator Symbol = RelI->getSymbol();
951
952  // Obtain the symbol name which is referenced in the relocation
953  StringRef TargetName;
954  if (Symbol != Obj.end_symbols())
955    Symbol->getName(TargetName);
956  DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend
957               << " TargetName: " << TargetName << "\n");
958  RelocationValueRef Value;
959  // First search for the symbol in the local symbol table
960  SymbolTableMap::const_iterator lsi = Symbols.end();
961  SymbolRef::Type SymType = SymbolRef::ST_Unknown;
962  if (Symbol != Obj.end_symbols()) {
963    lsi = Symbols.find(TargetName.data());
964    Symbol->getType(SymType);
965  }
966  if (lsi != Symbols.end()) {
967    Value.SectionID = lsi->second.first;
968    Value.Offset = lsi->second.second;
969    Value.Addend = lsi->second.second + Addend;
970  } else {
971    // Search for the symbol in the global symbol table
972    SymbolTableMap::const_iterator gsi = GlobalSymbolTable.end();
973    if (Symbol != Obj.end_symbols())
974      gsi = GlobalSymbolTable.find(TargetName.data());
975    if (gsi != GlobalSymbolTable.end()) {
976      Value.SectionID = gsi->second.first;
977      Value.Offset = gsi->second.second;
978      Value.Addend = gsi->second.second + Addend;
979    } else {
980      switch (SymType) {
981      case SymbolRef::ST_Debug: {
982        // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
983        // and can be changed by another developers. Maybe best way is add
984        // a new symbol type ST_Section to SymbolRef and use it.
985        section_iterator si(Obj.end_sections());
986        Symbol->getSection(si);
987        if (si == Obj.end_sections())
988          llvm_unreachable("Symbol section not found, bad object file format!");
989        DEBUG(dbgs() << "\t\tThis is section symbol\n");
990        // Default to 'true' in case isText fails (though it never does).
991        bool isCode = true;
992        si->isText(isCode);
993        Value.SectionID = findOrEmitSection(Obj, (*si), isCode, ObjSectionToID);
994        Value.Addend = Addend;
995        break;
996      }
997      case SymbolRef::ST_Data:
998      case SymbolRef::ST_Unknown: {
999        Value.SymbolName = TargetName.data();
1000        Value.Addend = Addend;
1001
1002        // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
1003        // will manifest here as a NULL symbol name.
1004        // We can set this as a valid (but empty) symbol name, and rely
1005        // on addRelocationForSymbol to handle this.
1006        if (!Value.SymbolName)
1007          Value.SymbolName = "";
1008        break;
1009      }
1010      default:
1011        llvm_unreachable("Unresolved symbol type!");
1012        break;
1013      }
1014    }
1015  }
1016  uint64_t Offset;
1017  Check(RelI->getOffset(Offset));
1018
1019  DEBUG(dbgs() << "\t\tSectionID: " << SectionID << " Offset: " << Offset
1020               << "\n");
1021  if ((Arch == Triple::aarch64 || Arch == Triple::aarch64_be ||
1022       Arch == Triple::arm64 || Arch == Triple::arm64_be) &&
1023      (RelType == ELF::R_AARCH64_CALL26 || RelType == ELF::R_AARCH64_JUMP26)) {
1024    // This is an AArch64 branch relocation, need to use a stub function.
1025    DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation.");
1026    SectionEntry &Section = Sections[SectionID];
1027
1028    // Look for an existing stub.
1029    StubMap::const_iterator i = Stubs.find(Value);
1030    if (i != Stubs.end()) {
1031      resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
1032                        RelType, 0);
1033      DEBUG(dbgs() << " Stub function found\n");
1034    } else {
1035      // Create a new stub function.
1036      DEBUG(dbgs() << " Create a new stub function\n");
1037      Stubs[Value] = Section.StubOffset;
1038      uint8_t *StubTargetAddr =
1039          createStubFunction(Section.Address + Section.StubOffset);
1040
1041      RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.Address,
1042                                ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
1043      RelocationEntry REmovk_g2(SectionID, StubTargetAddr - Section.Address + 4,
1044                                ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
1045      RelocationEntry REmovk_g1(SectionID, StubTargetAddr - Section.Address + 8,
1046                                ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
1047      RelocationEntry REmovk_g0(SectionID,
1048                                StubTargetAddr - Section.Address + 12,
1049                                ELF::R_AARCH64_MOVW_UABS_G0_NC, Value.Addend);
1050
1051      if (Value.SymbolName) {
1052        addRelocationForSymbol(REmovz_g3, Value.SymbolName);
1053        addRelocationForSymbol(REmovk_g2, Value.SymbolName);
1054        addRelocationForSymbol(REmovk_g1, Value.SymbolName);
1055        addRelocationForSymbol(REmovk_g0, Value.SymbolName);
1056      } else {
1057        addRelocationForSection(REmovz_g3, Value.SectionID);
1058        addRelocationForSection(REmovk_g2, Value.SectionID);
1059        addRelocationForSection(REmovk_g1, Value.SectionID);
1060        addRelocationForSection(REmovk_g0, Value.SectionID);
1061      }
1062      resolveRelocation(Section, Offset,
1063                        (uint64_t)Section.Address + Section.StubOffset, RelType,
1064                        0);
1065      Section.StubOffset += getMaxStubSize();
1066    }
1067  } else if (Arch == Triple::arm &&
1068             (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL ||
1069              RelType == ELF::R_ARM_JUMP24)) {
1070    // This is an ARM branch relocation, need to use a stub function.
1071    DEBUG(dbgs() << "\t\tThis is an ARM branch relocation.");
1072    SectionEntry &Section = Sections[SectionID];
1073
1074    // Look for an existing stub.
1075    StubMap::const_iterator i = Stubs.find(Value);
1076    if (i != Stubs.end()) {
1077      resolveRelocation(Section, Offset, (uint64_t)Section.Address + i->second,
1078                        RelType, 0);
1079      DEBUG(dbgs() << " Stub function found\n");
1080    } else {
1081      // Create a new stub function.
1082      DEBUG(dbgs() << " Create a new stub function\n");
1083      Stubs[Value] = Section.StubOffset;
1084      uint8_t *StubTargetAddr =
1085          createStubFunction(Section.Address + Section.StubOffset);
1086      RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
1087                         ELF::R_ARM_PRIVATE_0, Value.Addend);
1088      if (Value.SymbolName)
1089        addRelocationForSymbol(RE, Value.SymbolName);
1090      else
1091        addRelocationForSection(RE, Value.SectionID);
1092
1093      resolveRelocation(Section, Offset,
1094                        (uint64_t)Section.Address + Section.StubOffset, RelType,
1095                        0);
1096      Section.StubOffset += getMaxStubSize();
1097    }
1098  } else if ((Arch == Triple::mipsel || Arch == Triple::mips) &&
1099             RelType == ELF::R_MIPS_26) {
1100    // This is an Mips branch relocation, need to use a stub function.
1101    DEBUG(dbgs() << "\t\tThis is a Mips branch relocation.");
1102    SectionEntry &Section = Sections[SectionID];
1103    uint8_t *Target = Section.Address + Offset;
1104    uint32_t *TargetAddress = (uint32_t *)Target;
1105
1106    // Extract the addend from the instruction.
1107    uint32_t Addend = ((*TargetAddress) & 0x03ffffff) << 2;
1108
1109    Value.Addend += Addend;
1110
1111    //  Look up for existing stub.
1112    StubMap::const_iterator i = Stubs.find(Value);
1113    if (i != Stubs.end()) {
1114      RelocationEntry RE(SectionID, Offset, RelType, i->second);
1115      addRelocationForSection(RE, SectionID);
1116      DEBUG(dbgs() << " Stub function found\n");
1117    } else {
1118      // Create a new stub function.
1119      DEBUG(dbgs() << " Create a new stub function\n");
1120      Stubs[Value] = Section.StubOffset;
1121      uint8_t *StubTargetAddr =
1122          createStubFunction(Section.Address + Section.StubOffset);
1123
1124      // Creating Hi and Lo relocations for the filled stub instructions.
1125      RelocationEntry REHi(SectionID, StubTargetAddr - Section.Address,
1126                           ELF::R_MIPS_UNUSED1, Value.Addend);
1127      RelocationEntry RELo(SectionID, StubTargetAddr - Section.Address + 4,
1128                           ELF::R_MIPS_UNUSED2, Value.Addend);
1129
1130      if (Value.SymbolName) {
1131        addRelocationForSymbol(REHi, Value.SymbolName);
1132        addRelocationForSymbol(RELo, Value.SymbolName);
1133      } else {
1134        addRelocationForSection(REHi, Value.SectionID);
1135        addRelocationForSection(RELo, Value.SectionID);
1136      }
1137
1138      RelocationEntry RE(SectionID, Offset, RelType, Section.StubOffset);
1139      addRelocationForSection(RE, SectionID);
1140      Section.StubOffset += getMaxStubSize();
1141    }
1142  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
1143    if (RelType == ELF::R_PPC64_REL24) {
1144      // A PPC branch relocation will need a stub function if the target is
1145      // an external symbol (Symbol::ST_Unknown) or if the target address
1146      // is not within the signed 24-bits branch address.
1147      SectionEntry &Section = Sections[SectionID];
1148      uint8_t *Target = Section.Address + Offset;
1149      bool RangeOverflow = false;
1150      if (SymType != SymbolRef::ST_Unknown) {
1151        // A function call may points to the .opd entry, so the final symbol
1152        // value
1153        // in calculated based in the relocation values in .opd section.
1154        findOPDEntrySection(Obj, ObjSectionToID, Value);
1155        uint8_t *RelocTarget = Sections[Value.SectionID].Address + Value.Addend;
1156        int32_t delta = static_cast<int32_t>(Target - RelocTarget);
1157        // If it is within 24-bits branch range, just set the branch target
1158        if (SignExtend32<24>(delta) == delta) {
1159          RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1160          if (Value.SymbolName)
1161            addRelocationForSymbol(RE, Value.SymbolName);
1162          else
1163            addRelocationForSection(RE, Value.SectionID);
1164        } else {
1165          RangeOverflow = true;
1166        }
1167      }
1168      if (SymType == SymbolRef::ST_Unknown || RangeOverflow == true) {
1169        // It is an external symbol (SymbolRef::ST_Unknown) or within a range
1170        // larger than 24-bits.
1171        StubMap::const_iterator i = Stubs.find(Value);
1172        if (i != Stubs.end()) {
1173          // Symbol function stub already created, just relocate to it
1174          resolveRelocation(Section, Offset,
1175                            (uint64_t)Section.Address + i->second, RelType, 0);
1176          DEBUG(dbgs() << " Stub function found\n");
1177        } else {
1178          // Create a new stub function.
1179          DEBUG(dbgs() << " Create a new stub function\n");
1180          Stubs[Value] = Section.StubOffset;
1181          uint8_t *StubTargetAddr =
1182              createStubFunction(Section.Address + Section.StubOffset);
1183          RelocationEntry RE(SectionID, StubTargetAddr - Section.Address,
1184                             ELF::R_PPC64_ADDR64, Value.Addend);
1185
1186          // Generates the 64-bits address loads as exemplified in section
1187          // 4.5.1 in PPC64 ELF ABI.  Note that the relocations need to
1188          // apply to the low part of the instructions, so we have to update
1189          // the offset according to the target endianness.
1190          uint64_t StubRelocOffset = StubTargetAddr - Section.Address;
1191          if (!IsTargetLittleEndian)
1192            StubRelocOffset += 2;
1193
1194          RelocationEntry REhst(SectionID, StubRelocOffset + 0,
1195                                ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
1196          RelocationEntry REhr(SectionID, StubRelocOffset + 4,
1197                               ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
1198          RelocationEntry REh(SectionID, StubRelocOffset + 12,
1199                              ELF::R_PPC64_ADDR16_HI, Value.Addend);
1200          RelocationEntry REl(SectionID, StubRelocOffset + 16,
1201                              ELF::R_PPC64_ADDR16_LO, Value.Addend);
1202
1203          if (Value.SymbolName) {
1204            addRelocationForSymbol(REhst, Value.SymbolName);
1205            addRelocationForSymbol(REhr, Value.SymbolName);
1206            addRelocationForSymbol(REh, Value.SymbolName);
1207            addRelocationForSymbol(REl, Value.SymbolName);
1208          } else {
1209            addRelocationForSection(REhst, Value.SectionID);
1210            addRelocationForSection(REhr, Value.SectionID);
1211            addRelocationForSection(REh, Value.SectionID);
1212            addRelocationForSection(REl, Value.SectionID);
1213          }
1214
1215          resolveRelocation(Section, Offset,
1216                            (uint64_t)Section.Address + Section.StubOffset,
1217                            RelType, 0);
1218          Section.StubOffset += getMaxStubSize();
1219        }
1220        if (SymType == SymbolRef::ST_Unknown)
1221          // Restore the TOC for external calls
1222          writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1)
1223      }
1224    } else if (RelType == ELF::R_PPC64_TOC16 ||
1225               RelType == ELF::R_PPC64_TOC16_DS ||
1226               RelType == ELF::R_PPC64_TOC16_LO ||
1227               RelType == ELF::R_PPC64_TOC16_LO_DS ||
1228               RelType == ELF::R_PPC64_TOC16_HI ||
1229               RelType == ELF::R_PPC64_TOC16_HA) {
1230      // These relocations are supposed to subtract the TOC address from
1231      // the final value.  This does not fit cleanly into the RuntimeDyld
1232      // scheme, since there may be *two* sections involved in determining
1233      // the relocation value (the section of the symbol refered to by the
1234      // relocation, and the TOC section associated with the current module).
1235      //
1236      // Fortunately, these relocations are currently only ever generated
1237      // refering to symbols that themselves reside in the TOC, which means
1238      // that the two sections are actually the same.  Thus they cancel out
1239      // and we can immediately resolve the relocation right now.
1240      switch (RelType) {
1241      case ELF::R_PPC64_TOC16: RelType = ELF::R_PPC64_ADDR16; break;
1242      case ELF::R_PPC64_TOC16_DS: RelType = ELF::R_PPC64_ADDR16_DS; break;
1243      case ELF::R_PPC64_TOC16_LO: RelType = ELF::R_PPC64_ADDR16_LO; break;
1244      case ELF::R_PPC64_TOC16_LO_DS: RelType = ELF::R_PPC64_ADDR16_LO_DS; break;
1245      case ELF::R_PPC64_TOC16_HI: RelType = ELF::R_PPC64_ADDR16_HI; break;
1246      case ELF::R_PPC64_TOC16_HA: RelType = ELF::R_PPC64_ADDR16_HA; break;
1247      default: llvm_unreachable("Wrong relocation type.");
1248      }
1249
1250      RelocationValueRef TOCValue;
1251      findPPC64TOCSection(Obj, ObjSectionToID, TOCValue);
1252      if (Value.SymbolName || Value.SectionID != TOCValue.SectionID)
1253        llvm_unreachable("Unsupported TOC relocation.");
1254      Value.Addend -= TOCValue.Addend;
1255      resolveRelocation(Sections[SectionID], Offset, Value.Addend, RelType, 0);
1256    } else {
1257      // There are two ways to refer to the TOC address directly: either
1258      // via a ELF::R_PPC64_TOC relocation (where both symbol and addend are
1259      // ignored), or via any relocation that refers to the magic ".TOC."
1260      // symbols (in which case the addend is respected).
1261      if (RelType == ELF::R_PPC64_TOC) {
1262        RelType = ELF::R_PPC64_ADDR64;
1263        findPPC64TOCSection(Obj, ObjSectionToID, Value);
1264      } else if (TargetName == ".TOC.") {
1265        findPPC64TOCSection(Obj, ObjSectionToID, Value);
1266        Value.Addend += Addend;
1267      }
1268
1269      RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1270
1271      if (Value.SymbolName)
1272        addRelocationForSymbol(RE, Value.SymbolName);
1273      else
1274        addRelocationForSection(RE, Value.SectionID);
1275    }
1276  } else if (Arch == Triple::systemz &&
1277             (RelType == ELF::R_390_PLT32DBL || RelType == ELF::R_390_GOTENT)) {
1278    // Create function stubs for both PLT and GOT references, regardless of
1279    // whether the GOT reference is to data or code.  The stub contains the
1280    // full address of the symbol, as needed by GOT references, and the
1281    // executable part only adds an overhead of 8 bytes.
1282    //
1283    // We could try to conserve space by allocating the code and data
1284    // parts of the stub separately.  However, as things stand, we allocate
1285    // a stub for every relocation, so using a GOT in JIT code should be
1286    // no less space efficient than using an explicit constant pool.
1287    DEBUG(dbgs() << "\t\tThis is a SystemZ indirect relocation.");
1288    SectionEntry &Section = Sections[SectionID];
1289
1290    // Look for an existing stub.
1291    StubMap::const_iterator i = Stubs.find(Value);
1292    uintptr_t StubAddress;
1293    if (i != Stubs.end()) {
1294      StubAddress = uintptr_t(Section.Address) + i->second;
1295      DEBUG(dbgs() << " Stub function found\n");
1296    } else {
1297      // Create a new stub function.
1298      DEBUG(dbgs() << " Create a new stub function\n");
1299
1300      uintptr_t BaseAddress = uintptr_t(Section.Address);
1301      uintptr_t StubAlignment = getStubAlignment();
1302      StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
1303                    -StubAlignment;
1304      unsigned StubOffset = StubAddress - BaseAddress;
1305
1306      Stubs[Value] = StubOffset;
1307      createStubFunction((uint8_t *)StubAddress);
1308      RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64,
1309                         Value.Addend - Addend);
1310      if (Value.SymbolName)
1311        addRelocationForSymbol(RE, Value.SymbolName);
1312      else
1313        addRelocationForSection(RE, Value.SectionID);
1314      Section.StubOffset = StubOffset + getMaxStubSize();
1315    }
1316
1317    if (RelType == ELF::R_390_GOTENT)
1318      resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL,
1319                        Addend);
1320    else
1321      resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
1322  } else if (Arch == Triple::x86_64 && RelType == ELF::R_X86_64_PLT32) {
1323    // The way the PLT relocations normally work is that the linker allocates
1324    // the
1325    // PLT and this relocation makes a PC-relative call into the PLT.  The PLT
1326    // entry will then jump to an address provided by the GOT.  On first call,
1327    // the
1328    // GOT address will point back into PLT code that resolves the symbol. After
1329    // the first call, the GOT entry points to the actual function.
1330    //
1331    // For local functions we're ignoring all of that here and just replacing
1332    // the PLT32 relocation type with PC32, which will translate the relocation
1333    // into a PC-relative call directly to the function. For external symbols we
1334    // can't be sure the function will be within 2^32 bytes of the call site, so
1335    // we need to create a stub, which calls into the GOT.  This case is
1336    // equivalent to the usual PLT implementation except that we use the stub
1337    // mechanism in RuntimeDyld (which puts stubs at the end of the section)
1338    // rather than allocating a PLT section.
1339    if (Value.SymbolName) {
1340      // This is a call to an external function.
1341      // Look for an existing stub.
1342      SectionEntry &Section = Sections[SectionID];
1343      StubMap::const_iterator i = Stubs.find(Value);
1344      uintptr_t StubAddress;
1345      if (i != Stubs.end()) {
1346        StubAddress = uintptr_t(Section.Address) + i->second;
1347        DEBUG(dbgs() << " Stub function found\n");
1348      } else {
1349        // Create a new stub function (equivalent to a PLT entry).
1350        DEBUG(dbgs() << " Create a new stub function\n");
1351
1352        uintptr_t BaseAddress = uintptr_t(Section.Address);
1353        uintptr_t StubAlignment = getStubAlignment();
1354        StubAddress = (BaseAddress + Section.StubOffset + StubAlignment - 1) &
1355                      -StubAlignment;
1356        unsigned StubOffset = StubAddress - BaseAddress;
1357        Stubs[Value] = StubOffset;
1358        createStubFunction((uint8_t *)StubAddress);
1359
1360        // Create a GOT entry for the external function.
1361        GOTEntries.push_back(Value);
1362
1363        // Make our stub function a relative call to the GOT entry.
1364        RelocationEntry RE(SectionID, StubOffset + 2, ELF::R_X86_64_GOTPCREL,
1365                           -4);
1366        addRelocationForSymbol(RE, Value.SymbolName);
1367
1368        // Bump our stub offset counter
1369        Section.StubOffset = StubOffset + getMaxStubSize();
1370      }
1371
1372      // Make the target call a call into the stub table.
1373      resolveRelocation(Section, Offset, StubAddress, ELF::R_X86_64_PC32,
1374                        Addend);
1375    } else {
1376      RelocationEntry RE(SectionID, Offset, ELF::R_X86_64_PC32, Value.Addend,
1377                         Value.Offset);
1378      addRelocationForSection(RE, Value.SectionID);
1379    }
1380  } else {
1381    if (Arch == Triple::x86_64 && RelType == ELF::R_X86_64_GOTPCREL) {
1382      GOTEntries.push_back(Value);
1383    }
1384    RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, Value.Offset);
1385    if (Value.SymbolName)
1386      addRelocationForSymbol(RE, Value.SymbolName);
1387    else
1388      addRelocationForSection(RE, Value.SectionID);
1389  }
1390  return ++RelI;
1391}
1392
1393void RuntimeDyldELF::updateGOTEntries(StringRef Name, uint64_t Addr) {
1394
1395  SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator it;
1396  SmallVectorImpl<std::pair<SID, GOTRelocations>>::iterator end = GOTs.end();
1397
1398  for (it = GOTs.begin(); it != end; ++it) {
1399    GOTRelocations &GOTEntries = it->second;
1400    for (int i = 0, e = GOTEntries.size(); i != e; ++i) {
1401      if (GOTEntries[i].SymbolName != nullptr &&
1402          GOTEntries[i].SymbolName == Name) {
1403        GOTEntries[i].Offset = Addr;
1404      }
1405    }
1406  }
1407}
1408
1409size_t RuntimeDyldELF::getGOTEntrySize() {
1410  // We don't use the GOT in all of these cases, but it's essentially free
1411  // to put them all here.
1412  size_t Result = 0;
1413  switch (Arch) {
1414  case Triple::x86_64:
1415  case Triple::aarch64:
1416  case Triple::aarch64_be:
1417  case Triple::arm64:
1418  case Triple::arm64_be:
1419  case Triple::ppc64:
1420  case Triple::ppc64le:
1421  case Triple::systemz:
1422    Result = sizeof(uint64_t);
1423    break;
1424  case Triple::x86:
1425  case Triple::arm:
1426  case Triple::thumb:
1427  case Triple::mips:
1428  case Triple::mipsel:
1429    Result = sizeof(uint32_t);
1430    break;
1431  default:
1432    llvm_unreachable("Unsupported CPU type!");
1433  }
1434  return Result;
1435}
1436
1437uint64_t RuntimeDyldELF::findGOTEntry(uint64_t LoadAddress, uint64_t Offset) {
1438
1439  const size_t GOTEntrySize = getGOTEntrySize();
1440
1441  SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator it;
1442  SmallVectorImpl<std::pair<SID, GOTRelocations>>::const_iterator end =
1443      GOTs.end();
1444
1445  int GOTIndex = -1;
1446  for (it = GOTs.begin(); it != end; ++it) {
1447    SID GOTSectionID = it->first;
1448    const GOTRelocations &GOTEntries = it->second;
1449
1450    // Find the matching entry in our vector.
1451    uint64_t SymbolOffset = 0;
1452    for (int i = 0, e = GOTEntries.size(); i != e; ++i) {
1453      if (!GOTEntries[i].SymbolName) {
1454        if (getSectionLoadAddress(GOTEntries[i].SectionID) == LoadAddress &&
1455            GOTEntries[i].Offset == Offset) {
1456          GOTIndex = i;
1457          SymbolOffset = GOTEntries[i].Offset;
1458          break;
1459        }
1460      } else {
1461        // GOT entries for external symbols use the addend as the address when
1462        // the external symbol has been resolved.
1463        if (GOTEntries[i].Offset == LoadAddress) {
1464          GOTIndex = i;
1465          // Don't use the Addend here.  The relocation handler will use it.
1466          break;
1467        }
1468      }
1469    }
1470
1471    if (GOTIndex != -1) {
1472      if (GOTEntrySize == sizeof(uint64_t)) {
1473        uint64_t *LocalGOTAddr = (uint64_t *)getSectionAddress(GOTSectionID);
1474        // Fill in this entry with the address of the symbol being referenced.
1475        LocalGOTAddr[GOTIndex] = LoadAddress + SymbolOffset;
1476      } else {
1477        uint32_t *LocalGOTAddr = (uint32_t *)getSectionAddress(GOTSectionID);
1478        // Fill in this entry with the address of the symbol being referenced.
1479        LocalGOTAddr[GOTIndex] = (uint32_t)(LoadAddress + SymbolOffset);
1480      }
1481
1482      // Calculate the load address of this entry
1483      return getSectionLoadAddress(GOTSectionID) + (GOTIndex * GOTEntrySize);
1484    }
1485  }
1486
1487  assert(GOTIndex != -1 && "Unable to find requested GOT entry.");
1488  return 0;
1489}
1490
1491void RuntimeDyldELF::finalizeLoad(ObjectImage &ObjImg,
1492                                  ObjSectionToIDMap &SectionMap) {
1493  // If necessary, allocate the global offset table
1494  if (MemMgr) {
1495    // Allocate the GOT if necessary
1496    size_t numGOTEntries = GOTEntries.size();
1497    if (numGOTEntries != 0) {
1498      // Allocate memory for the section
1499      unsigned SectionID = Sections.size();
1500      size_t TotalSize = numGOTEntries * getGOTEntrySize();
1501      uint8_t *Addr = MemMgr->allocateDataSection(TotalSize, getGOTEntrySize(),
1502                                                  SectionID, ".got", false);
1503      if (!Addr)
1504        report_fatal_error("Unable to allocate memory for GOT!");
1505
1506      GOTs.push_back(std::make_pair(SectionID, GOTEntries));
1507      Sections.push_back(SectionEntry(".got", Addr, TotalSize, 0));
1508      // For now, initialize all GOT entries to zero.  We'll fill them in as
1509      // needed when GOT-based relocations are applied.
1510      memset(Addr, 0, TotalSize);
1511    }
1512  } else {
1513    report_fatal_error("Unable to allocate memory for GOT!");
1514  }
1515
1516  // Look for and record the EH frame section.
1517  ObjSectionToIDMap::iterator i, e;
1518  for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {
1519    const SectionRef &Section = i->first;
1520    StringRef Name;
1521    Section.getName(Name);
1522    if (Name == ".eh_frame") {
1523      UnregisteredEHFrameSections.push_back(i->second);
1524      break;
1525    }
1526  }
1527}
1528
1529bool RuntimeDyldELF::isCompatibleFormat(const ObjectBuffer *Buffer) const {
1530  if (Buffer->getBufferSize() < strlen(ELF::ElfMagic))
1531    return false;
1532  return (memcmp(Buffer->getBufferStart(), ELF::ElfMagic,
1533                 strlen(ELF::ElfMagic))) == 0;
1534}
1535
1536bool RuntimeDyldELF::isCompatibleFile(const object::ObjectFile *Obj) const {
1537  return Obj->isELF();
1538}
1539
1540} // namespace llvm
1541