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