LLVM  14.0.0git
RuntimeDyldELF.cpp
Go to the documentation of this file.
1 //===-- RuntimeDyldELF.cpp - Run-time dynamic linker for MC-JIT -*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Implementation of ELF support for the MC-JIT runtime dynamic linker.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "RuntimeDyldELF.h"
14 #include "RuntimeDyldCheckerImpl.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/ADT/Triple.h"
19 #include "llvm/BinaryFormat/ELF.h"
21 #include "llvm/Object/ObjectFile.h"
22 #include "llvm/Support/Endian.h"
24 
25 using namespace llvm;
26 using namespace llvm::object;
27 using namespace llvm::support::endian;
28 
29 #define DEBUG_TYPE "dyld"
30 
31 static void or32le(void *P, int32_t V) { write32le(P, read32le(P) | V); }
32 
33 static void or32AArch64Imm(void *L, uint64_t Imm) {
34  or32le(L, (Imm & 0xFFF) << 10);
35 }
36 
37 template <class T> static void write(bool isBE, void *P, T V) {
38  isBE ? write<T, support::big>(P, V) : write<T, support::little>(P, V);
39 }
40 
41 static void write32AArch64Addr(void *L, uint64_t Imm) {
42  uint32_t ImmLo = (Imm & 0x3) << 29;
43  uint32_t ImmHi = (Imm & 0x1FFFFC) << 3;
44  uint64_t Mask = (0x3 << 29) | (0x1FFFFC << 3);
45  write32le(L, (read32le(L) & ~Mask) | ImmLo | ImmHi);
46 }
47 
48 // Return the bits [Start, End] from Val shifted Start bits.
49 // For instance, getBits(0xF0, 4, 8) returns 0xF.
50 static uint64_t getBits(uint64_t Val, int Start, int End) {
51  uint64_t Mask = ((uint64_t)1 << (End + 1 - Start)) - 1;
52  return (Val >> Start) & Mask;
53 }
54 
55 namespace {
56 
57 template <class ELFT> class DyldELFObject : public ELFObjectFile<ELFT> {
59 
60  typedef typename ELFT::uint addr_type;
61 
62  DyldELFObject(ELFObjectFile<ELFT> &&Obj);
63 
64 public:
66  create(MemoryBufferRef Wrapper);
67 
68  void updateSectionAddress(const SectionRef &Sec, uint64_t Addr);
69 
70  void updateSymbolAddress(const SymbolRef &SymRef, uint64_t Addr);
71 
72  // Methods for type inquiry through isa, cast and dyn_cast
73  static bool classof(const Binary *v) {
74  return (isa<ELFObjectFile<ELFT>>(v) &&
75  classof(cast<ELFObjectFile<ELFT>>(v)));
76  }
77  static bool classof(const ELFObjectFile<ELFT> *v) {
78  return v->isDyldType();
79  }
80 };
81 
82 
83 
84 // The MemoryBuffer passed into this constructor is just a wrapper around the
85 // actual memory. Ultimately, the Binary parent class will take ownership of
86 // this MemoryBuffer object but not the underlying memory.
87 template <class ELFT>
88 DyldELFObject<ELFT>::DyldELFObject(ELFObjectFile<ELFT> &&Obj)
89  : ELFObjectFile<ELFT>(std::move(Obj)) {
90  this->isDyldELFObject = true;
91 }
92 
93 template <class ELFT>
95 DyldELFObject<ELFT>::create(MemoryBufferRef Wrapper) {
97  if (auto E = Obj.takeError())
98  return std::move(E);
99  std::unique_ptr<DyldELFObject<ELFT>> Ret(
100  new DyldELFObject<ELFT>(std::move(*Obj)));
101  return std::move(Ret);
102 }
103 
104 template <class ELFT>
105 void DyldELFObject<ELFT>::updateSectionAddress(const SectionRef &Sec,
106  uint64_t Addr) {
107  DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
108  Elf_Shdr *shdr =
109  const_cast<Elf_Shdr *>(reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
110 
111  // This assumes the address passed in matches the target address bitness
112  // The template-based type cast handles everything else.
113  shdr->sh_addr = static_cast<addr_type>(Addr);
114 }
115 
116 template <class ELFT>
117 void DyldELFObject<ELFT>::updateSymbolAddress(const SymbolRef &SymRef,
118  uint64_t Addr) {
119 
120  Elf_Sym *sym = const_cast<Elf_Sym *>(
122 
123  // This assumes the address passed in matches the target address bitness
124  // The template-based type cast handles everything else.
125  sym->st_value = static_cast<addr_type>(Addr);
126 }
127 
128 class LoadedELFObjectInfo final
129  : public LoadedObjectInfoHelper<LoadedELFObjectInfo,
130  RuntimeDyld::LoadedObjectInfo> {
131 public:
132  LoadedELFObjectInfo(RuntimeDyldImpl &RTDyld, ObjSectionToIDMap ObjSecToIDMap)
133  : LoadedObjectInfoHelper(RTDyld, std::move(ObjSecToIDMap)) {}
134 
136  getObjectForDebug(const ObjectFile &Obj) const override;
137 };
138 
139 template <typename ELFT>
141 createRTDyldELFObject(MemoryBufferRef Buffer, const ObjectFile &SourceObject,
142  const LoadedELFObjectInfo &L) {
143  typedef typename ELFT::Shdr Elf_Shdr;
144  typedef typename ELFT::uint addr_type;
145 
147  DyldELFObject<ELFT>::create(Buffer);
148  if (Error E = ObjOrErr.takeError())
149  return std::move(E);
150 
151  std::unique_ptr<DyldELFObject<ELFT>> Obj = std::move(*ObjOrErr);
152 
153  // Iterate over all sections in the object.
154  auto SI = SourceObject.section_begin();
155  for (const auto &Sec : Obj->sections()) {
156  Expected<StringRef> NameOrErr = Sec.getName();
157  if (!NameOrErr) {
158  consumeError(NameOrErr.takeError());
159  continue;
160  }
161 
162  if (*NameOrErr != "") {
163  DataRefImpl ShdrRef = Sec.getRawDataRefImpl();
164  Elf_Shdr *shdr = const_cast<Elf_Shdr *>(
165  reinterpret_cast<const Elf_Shdr *>(ShdrRef.p));
166 
167  if (uint64_t SecLoadAddr = L.getSectionLoadAddress(*SI)) {
168  // This assumes that the address passed in matches the target address
169  // bitness. The template-based type cast handles everything else.
170  shdr->sh_addr = static_cast<addr_type>(SecLoadAddr);
171  }
172  }
173  ++SI;
174  }
175 
176  return std::move(Obj);
177 }
178 
180 createELFDebugObject(const ObjectFile &Obj, const LoadedELFObjectInfo &L) {
181  assert(Obj.isELF() && "Not an ELF object file.");
182 
183  std::unique_ptr<MemoryBuffer> Buffer =
184  MemoryBuffer::getMemBufferCopy(Obj.getData(), Obj.getFileName());
185 
186  Expected<std::unique_ptr<ObjectFile>> DebugObj(nullptr);
187  handleAllErrors(DebugObj.takeError());
188  if (Obj.getBytesInAddress() == 4 && Obj.isLittleEndian())
189  DebugObj =
190  createRTDyldELFObject<ELF32LE>(Buffer->getMemBufferRef(), Obj, L);
191  else if (Obj.getBytesInAddress() == 4 && !Obj.isLittleEndian())
192  DebugObj =
193  createRTDyldELFObject<ELF32BE>(Buffer->getMemBufferRef(), Obj, L);
194  else if (Obj.getBytesInAddress() == 8 && !Obj.isLittleEndian())
195  DebugObj =
196  createRTDyldELFObject<ELF64BE>(Buffer->getMemBufferRef(), Obj, L);
197  else if (Obj.getBytesInAddress() == 8 && Obj.isLittleEndian())
198  DebugObj =
199  createRTDyldELFObject<ELF64LE>(Buffer->getMemBufferRef(), Obj, L);
200  else
201  llvm_unreachable("Unexpected ELF format");
202 
203  handleAllErrors(DebugObj.takeError());
204  return OwningBinary<ObjectFile>(std::move(*DebugObj), std::move(Buffer));
205 }
206 
208 LoadedELFObjectInfo::getObjectForDebug(const ObjectFile &Obj) const {
209  return createELFDebugObject(Obj, *this);
210 }
211 
212 } // anonymous namespace
213 
214 namespace llvm {
215 
218  : RuntimeDyldImpl(MemMgr, Resolver), GOTSectionID(0), CurrentGOTIndex(0) {}
220 
222  for (int i = 0, e = UnregisteredEHFrameSections.size(); i != e; ++i) {
223  SID EHFrameSID = UnregisteredEHFrameSections[i];
224  uint8_t *EHFrameAddr = Sections[EHFrameSID].getAddress();
225  uint64_t EHFrameLoadAddr = Sections[EHFrameSID].getLoadAddress();
226  size_t EHFrameSize = Sections[EHFrameSID].getSize();
227  MemMgr.registerEHFrames(EHFrameAddr, EHFrameLoadAddr, EHFrameSize);
228  }
229  UnregisteredEHFrameSections.clear();
230 }
231 
232 std::unique_ptr<RuntimeDyldELF>
236  switch (Arch) {
237  default:
238  return std::make_unique<RuntimeDyldELF>(MemMgr, Resolver);
239  case Triple::mips:
240  case Triple::mipsel:
241  case Triple::mips64:
242  case Triple::mips64el:
243  return std::make_unique<RuntimeDyldELFMips>(MemMgr, Resolver);
244  }
245 }
246 
247 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
249  if (auto ObjSectionToIDOrErr = loadObjectImpl(O))
250  return std::make_unique<LoadedELFObjectInfo>(*this, *ObjSectionToIDOrErr);
251  else {
252  HasError = true;
253  raw_string_ostream ErrStream(ErrorStr);
254  logAllUnhandledErrors(ObjSectionToIDOrErr.takeError(), ErrStream);
255  return nullptr;
256  }
257 }
258 
259 void RuntimeDyldELF::resolveX86_64Relocation(const SectionEntry &Section,
261  uint32_t Type, int64_t Addend,
262  uint64_t SymOffset) {
263  switch (Type) {
264  default:
265  report_fatal_error("Relocation type not implemented yet!");
266  break;
267  case ELF::R_X86_64_NONE:
268  break;
269  case ELF::R_X86_64_8: {
270  Value += Addend;
271  assert((int64_t)Value <= INT8_MAX && (int64_t)Value >= INT8_MIN);
272  uint8_t TruncatedAddr = (Value & 0xFF);
273  *Section.getAddressWithOffset(Offset) = TruncatedAddr;
274  LLVM_DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
275  << format("%p\n", Section.getAddressWithOffset(Offset)));
276  break;
277  }
278  case ELF::R_X86_64_16: {
279  Value += Addend;
280  assert((int64_t)Value <= INT16_MAX && (int64_t)Value >= INT16_MIN);
281  uint16_t TruncatedAddr = (Value & 0xFFFF);
282  support::ulittle16_t::ref(Section.getAddressWithOffset(Offset)) =
283  TruncatedAddr;
284  LLVM_DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
285  << format("%p\n", Section.getAddressWithOffset(Offset)));
286  break;
287  }
288  case ELF::R_X86_64_64: {
289  support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
290  Value + Addend;
291  LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
292  << format("%p\n", Section.getAddressWithOffset(Offset)));
293  break;
294  }
295  case ELF::R_X86_64_32:
296  case ELF::R_X86_64_32S: {
297  Value += Addend;
298  assert((Type == ELF::R_X86_64_32 && (Value <= UINT32_MAX)) ||
299  (Type == ELF::R_X86_64_32S &&
300  ((int64_t)Value <= INT32_MAX && (int64_t)Value >= INT32_MIN)));
301  uint32_t TruncatedAddr = (Value & 0xFFFFFFFF);
302  support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
303  TruncatedAddr;
304  LLVM_DEBUG(dbgs() << "Writing " << format("%p", TruncatedAddr) << " at "
305  << format("%p\n", Section.getAddressWithOffset(Offset)));
306  break;
307  }
308  case ELF::R_X86_64_PC8: {
309  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
310  int64_t RealOffset = Value + Addend - FinalAddress;
311  assert(isInt<8>(RealOffset));
312  int8_t TruncOffset = (RealOffset & 0xFF);
313  Section.getAddress()[Offset] = TruncOffset;
314  break;
315  }
316  case ELF::R_X86_64_PC32: {
317  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
318  int64_t RealOffset = Value + Addend - FinalAddress;
319  assert(isInt<32>(RealOffset));
320  int32_t TruncOffset = (RealOffset & 0xFFFFFFFF);
321  support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
322  TruncOffset;
323  break;
324  }
325  case ELF::R_X86_64_PC64: {
326  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
327  int64_t RealOffset = Value + Addend - FinalAddress;
328  support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
329  RealOffset;
330  LLVM_DEBUG(dbgs() << "Writing " << format("%p", RealOffset) << " at "
331  << format("%p\n", FinalAddress));
332  break;
333  }
334  case ELF::R_X86_64_GOTOFF64: {
335  // Compute Value - GOTBase.
336  uint64_t GOTBase = 0;
337  for (const auto &Section : Sections) {
338  if (Section.getName() == ".got") {
339  GOTBase = Section.getLoadAddressWithOffset(0);
340  break;
341  }
342  }
343  assert(GOTBase != 0 && "missing GOT");
344  int64_t GOTOffset = Value - GOTBase + Addend;
345  support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) = GOTOffset;
346  break;
347  }
348  case ELF::R_X86_64_DTPMOD64: {
349  // We only have one DSO, so the module id is always 1.
350  support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) = 1;
351  break;
352  }
353  case ELF::R_X86_64_DTPOFF64:
354  case ELF::R_X86_64_TPOFF64: {
355  // DTPOFF64 should resolve to the offset in the TLS block, TPOFF64 to the
356  // offset in the *initial* TLS block. Since we are statically linking, all
357  // TLS blocks already exist in the initial block, so resolve both
358  // relocations equally.
359  support::ulittle64_t::ref(Section.getAddressWithOffset(Offset)) =
360  Value + Addend;
361  break;
362  }
363  case ELF::R_X86_64_DTPOFF32:
364  case ELF::R_X86_64_TPOFF32: {
365  // As for the (D)TPOFF64 relocations above, both DTPOFF32 and TPOFF32 can
366  // be resolved equally.
367  int64_t RealValue = Value + Addend;
368  assert(RealValue >= INT32_MIN && RealValue <= INT32_MAX);
369  int32_t TruncValue = RealValue;
370  support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
371  TruncValue;
372  break;
373  }
374  }
375 }
376 
377 void RuntimeDyldELF::resolveX86Relocation(const SectionEntry &Section,
379  uint32_t Type, int32_t Addend) {
380  switch (Type) {
381  case ELF::R_386_32: {
382  support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
383  Value + Addend;
384  break;
385  }
386  // Handle R_386_PLT32 like R_386_PC32 since it should be able to
387  // reach any 32 bit address.
388  case ELF::R_386_PLT32:
389  case ELF::R_386_PC32: {
390  uint32_t FinalAddress =
391  Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
392  uint32_t RealOffset = Value + Addend - FinalAddress;
393  support::ulittle32_t::ref(Section.getAddressWithOffset(Offset)) =
394  RealOffset;
395  break;
396  }
397  default:
398  // There are other relocation types, but it appears these are the
399  // only ones currently used by the LLVM ELF object writer
400  report_fatal_error("Relocation type not implemented yet!");
401  break;
402  }
403 }
404 
405 void RuntimeDyldELF::resolveAArch64Relocation(const SectionEntry &Section,
407  uint32_t Type, int64_t Addend) {
408  uint32_t *TargetPtr =
409  reinterpret_cast<uint32_t *>(Section.getAddressWithOffset(Offset));
410  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
411  // Data should use target endian. Code should always use little endian.
412  bool isBE = Arch == Triple::aarch64_be;
413 
414  LLVM_DEBUG(dbgs() << "resolveAArch64Relocation, LocalAddress: 0x"
415  << format("%llx", Section.getAddressWithOffset(Offset))
416  << " FinalAddress: 0x" << format("%llx", FinalAddress)
417  << " Value: 0x" << format("%llx", Value) << " Type: 0x"
418  << format("%x", Type) << " Addend: 0x"
419  << format("%llx", Addend) << "\n");
420 
421  switch (Type) {
422  default:
423  report_fatal_error("Relocation type not implemented yet!");
424  break;
425  case ELF::R_AARCH64_NONE:
426  break;
427  case ELF::R_AARCH64_ABS16: {
428  uint64_t Result = Value + Addend;
429  assert(static_cast<int64_t>(Result) >= INT16_MIN && Result < UINT16_MAX);
430  write(isBE, TargetPtr, static_cast<uint16_t>(Result & 0xffffU));
431  break;
432  }
433  case ELF::R_AARCH64_ABS32: {
434  uint64_t Result = Value + Addend;
435  assert(static_cast<int64_t>(Result) >= INT32_MIN && Result < UINT32_MAX);
436  write(isBE, TargetPtr, static_cast<uint32_t>(Result & 0xffffffffU));
437  break;
438  }
439  case ELF::R_AARCH64_ABS64:
440  write(isBE, TargetPtr, Value + Addend);
441  break;
442  case ELF::R_AARCH64_PLT32: {
443  uint64_t Result = Value + Addend - FinalAddress;
444  assert(static_cast<int64_t>(Result) >= INT32_MIN &&
445  static_cast<int64_t>(Result) <= INT32_MAX);
446  write(isBE, TargetPtr, static_cast<uint32_t>(Result));
447  break;
448  }
449  case ELF::R_AARCH64_PREL32: {
450  uint64_t Result = Value + Addend - FinalAddress;
451  assert(static_cast<int64_t>(Result) >= INT32_MIN &&
452  static_cast<int64_t>(Result) <= UINT32_MAX);
453  write(isBE, TargetPtr, static_cast<uint32_t>(Result & 0xffffffffU));
454  break;
455  }
456  case ELF::R_AARCH64_PREL64:
457  write(isBE, TargetPtr, Value + Addend - FinalAddress);
458  break;
459  case ELF::R_AARCH64_CONDBR19: {
460  uint64_t BranchImm = Value + Addend - FinalAddress;
461 
462  assert(isInt<21>(BranchImm));
463  *TargetPtr &= 0xff00001fU;
464  // Immediate:20:2 goes in bits 23:5 of Bcc, CBZ, CBNZ
465  or32le(TargetPtr, (BranchImm & 0x001FFFFC) << 3);
466  break;
467  }
468  case ELF::R_AARCH64_TSTBR14: {
469  uint64_t BranchImm = Value + Addend - FinalAddress;
470 
471  assert(isInt<16>(BranchImm));
472 
473  *TargetPtr &= 0xfff8001fU;
474  // Immediate:15:2 goes in bits 18:5 of TBZ, TBNZ
475  or32le(TargetPtr, (BranchImm & 0x0FFFFFFC) << 3);
476  break;
477  }
478  case ELF::R_AARCH64_CALL26: // fallthrough
479  case ELF::R_AARCH64_JUMP26: {
480  // Operation: S+A-P. Set Call or B immediate value to bits fff_fffc of the
481  // calculation.
482  uint64_t BranchImm = Value + Addend - FinalAddress;
483 
484  // "Check that -2^27 <= result < 2^27".
485  assert(isInt<28>(BranchImm));
486  or32le(TargetPtr, (BranchImm & 0x0FFFFFFC) >> 2);
487  break;
488  }
489  case ELF::R_AARCH64_MOVW_UABS_G3:
490  or32le(TargetPtr, ((Value + Addend) & 0xFFFF000000000000) >> 43);
491  break;
492  case ELF::R_AARCH64_MOVW_UABS_G2_NC:
493  or32le(TargetPtr, ((Value + Addend) & 0xFFFF00000000) >> 27);
494  break;
495  case ELF::R_AARCH64_MOVW_UABS_G1_NC:
496  or32le(TargetPtr, ((Value + Addend) & 0xFFFF0000) >> 11);
497  break;
498  case ELF::R_AARCH64_MOVW_UABS_G0_NC:
499  or32le(TargetPtr, ((Value + Addend) & 0xFFFF) << 5);
500  break;
501  case ELF::R_AARCH64_ADR_PREL_PG_HI21: {
502  // Operation: Page(S+A) - Page(P)
503  uint64_t Result =
504  ((Value + Addend) & ~0xfffULL) - (FinalAddress & ~0xfffULL);
505 
506  // Check that -2^32 <= X < 2^32
507  assert(isInt<33>(Result) && "overflow check failed for relocation");
508 
509  // Immediate goes in bits 30:29 + 5:23 of ADRP instruction, taken
510  // from bits 32:12 of X.
511  write32AArch64Addr(TargetPtr, Result >> 12);
512  break;
513  }
514  case ELF::R_AARCH64_ADD_ABS_LO12_NC:
515  // Operation: S + A
516  // Immediate goes in bits 21:10 of LD/ST instruction, taken
517  // from bits 11:0 of X
518  or32AArch64Imm(TargetPtr, Value + Addend);
519  break;
520  case ELF::R_AARCH64_LDST8_ABS_LO12_NC:
521  // Operation: S + A
522  // Immediate goes in bits 21:10 of LD/ST instruction, taken
523  // from bits 11:0 of X
524  or32AArch64Imm(TargetPtr, getBits(Value + Addend, 0, 11));
525  break;
526  case ELF::R_AARCH64_LDST16_ABS_LO12_NC:
527  // Operation: S + A
528  // Immediate goes in bits 21:10 of LD/ST instruction, taken
529  // from bits 11:1 of X
530  or32AArch64Imm(TargetPtr, getBits(Value + Addend, 1, 11));
531  break;
532  case ELF::R_AARCH64_LDST32_ABS_LO12_NC:
533  // Operation: S + A
534  // Immediate goes in bits 21:10 of LD/ST instruction, taken
535  // from bits 11:2 of X
536  or32AArch64Imm(TargetPtr, getBits(Value + Addend, 2, 11));
537  break;
538  case ELF::R_AARCH64_LDST64_ABS_LO12_NC:
539  // Operation: S + A
540  // Immediate goes in bits 21:10 of LD/ST instruction, taken
541  // from bits 11:3 of X
542  or32AArch64Imm(TargetPtr, getBits(Value + Addend, 3, 11));
543  break;
544  case ELF::R_AARCH64_LDST128_ABS_LO12_NC:
545  // Operation: S + A
546  // Immediate goes in bits 21:10 of LD/ST instruction, taken
547  // from bits 11:4 of X
548  or32AArch64Imm(TargetPtr, getBits(Value + Addend, 4, 11));
549  break;
550  case ELF::R_AARCH64_LD_PREL_LO19: {
551  // Operation: S + A - P
552  uint64_t Result = Value + Addend - FinalAddress;
553 
554  // "Check that -2^20 <= result < 2^20".
555  assert(isInt<21>(Result));
556 
557  *TargetPtr &= 0xff00001fU;
558  // Immediate goes in bits 23:5 of LD imm instruction, taken
559  // from bits 20:2 of X
560  *TargetPtr |= ((Result & 0xffc) << (5 - 2));
561  break;
562  }
563  case ELF::R_AARCH64_ADR_PREL_LO21: {
564  // Operation: S + A - P
565  uint64_t Result = Value + Addend - FinalAddress;
566 
567  // "Check that -2^20 <= result < 2^20".
568  assert(isInt<21>(Result));
569 
570  *TargetPtr &= 0x9f00001fU;
571  // Immediate goes in bits 23:5, 30:29 of ADR imm instruction, taken
572  // from bits 20:0 of X
573  *TargetPtr |= ((Result & 0xffc) << (5 - 2));
574  *TargetPtr |= (Result & 0x3) << 29;
575  break;
576  }
577  }
578 }
579 
580 void RuntimeDyldELF::resolveARMRelocation(const SectionEntry &Section,
582  uint32_t Type, int32_t Addend) {
583  // TODO: Add Thumb relocations.
584  uint32_t *TargetPtr =
585  reinterpret_cast<uint32_t *>(Section.getAddressWithOffset(Offset));
586  uint32_t FinalAddress = Section.getLoadAddressWithOffset(Offset) & 0xFFFFFFFF;
587  Value += Addend;
588 
589  LLVM_DEBUG(dbgs() << "resolveARMRelocation, LocalAddress: "
590  << Section.getAddressWithOffset(Offset)
591  << " FinalAddress: " << format("%p", FinalAddress)
592  << " Value: " << format("%x", Value)
593  << " Type: " << format("%x", Type)
594  << " Addend: " << format("%x", Addend) << "\n");
595 
596  switch (Type) {
597  default:
598  llvm_unreachable("Not implemented relocation type!");
599 
600  case ELF::R_ARM_NONE:
601  break;
602  // Write a 31bit signed offset
603  case ELF::R_ARM_PREL31:
604  support::ulittle32_t::ref{TargetPtr} =
605  (support::ulittle32_t::ref{TargetPtr} & 0x80000000) |
606  ((Value - FinalAddress) & ~0x80000000);
607  break;
608  case ELF::R_ARM_TARGET1:
609  case ELF::R_ARM_ABS32:
610  support::ulittle32_t::ref{TargetPtr} = Value;
611  break;
612  // Write first 16 bit of 32 bit value to the mov instruction.
613  // Last 4 bit should be shifted.
614  case ELF::R_ARM_MOVW_ABS_NC:
615  case ELF::R_ARM_MOVT_ABS:
616  if (Type == ELF::R_ARM_MOVW_ABS_NC)
617  Value = Value & 0xFFFF;
618  else if (Type == ELF::R_ARM_MOVT_ABS)
619  Value = (Value >> 16) & 0xFFFF;
620  support::ulittle32_t::ref{TargetPtr} =
621  (support::ulittle32_t::ref{TargetPtr} & ~0x000F0FFF) | (Value & 0xFFF) |
622  (((Value >> 12) & 0xF) << 16);
623  break;
624  // Write 24 bit relative value to the branch instruction.
625  case ELF::R_ARM_PC24: // Fall through.
626  case ELF::R_ARM_CALL: // Fall through.
627  case ELF::R_ARM_JUMP24:
628  int32_t RelValue = static_cast<int32_t>(Value - FinalAddress - 8);
629  RelValue = (RelValue & 0x03FFFFFC) >> 2;
630  assert((support::ulittle32_t::ref{TargetPtr} & 0xFFFFFF) == 0xFFFFFE);
631  support::ulittle32_t::ref{TargetPtr} =
632  (support::ulittle32_t::ref{TargetPtr} & 0xFF000000) | RelValue;
633  break;
634  }
635 }
636 
637 void RuntimeDyldELF::setMipsABI(const ObjectFile &Obj) {
638  if (Arch == Triple::UnknownArch ||
639  !StringRef(Triple::getArchTypePrefix(Arch)).equals("mips")) {
640  IsMipsO32ABI = false;
641  IsMipsN32ABI = false;
642  IsMipsN64ABI = false;
643  return;
644  }
645  if (auto *E = dyn_cast<ELFObjectFileBase>(&Obj)) {
646  unsigned AbiVariant = E->getPlatformFlags();
647  IsMipsO32ABI = AbiVariant & ELF::EF_MIPS_ABI_O32;
648  IsMipsN32ABI = AbiVariant & ELF::EF_MIPS_ABI2;
649  }
650  IsMipsN64ABI = Obj.getFileFormatName().equals("elf64-mips");
651 }
652 
653 // Return the .TOC. section and offset.
654 Error RuntimeDyldELF::findPPC64TOCSection(const ELFObjectFileBase &Obj,
655  ObjSectionToIDMap &LocalSections,
656  RelocationValueRef &Rel) {
657  // Set a default SectionID in case we do not find a TOC section below.
658  // This may happen for references to TOC base base (sym@toc, .odp
659  // relocation) without a .toc directive. In this case just use the
660  // first section (which is usually the .odp) since the code won't
661  // reference the .toc base directly.
662  Rel.SymbolName = nullptr;
663  Rel.SectionID = 0;
664 
665  // The TOC consists of sections .got, .toc, .tocbss, .plt in that
666  // order. The TOC starts where the first of these sections starts.
667  for (auto &Section : Obj.sections()) {
668  Expected<StringRef> NameOrErr = Section.getName();
669  if (!NameOrErr)
670  return NameOrErr.takeError();
671  StringRef SectionName = *NameOrErr;
672 
673  if (SectionName == ".got"
674  || SectionName == ".toc"
675  || SectionName == ".tocbss"
676  || SectionName == ".plt") {
677  if (auto SectionIDOrErr =
678  findOrEmitSection(Obj, Section, false, LocalSections))
679  Rel.SectionID = *SectionIDOrErr;
680  else
681  return SectionIDOrErr.takeError();
682  break;
683  }
684  }
685 
686  // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
687  // thus permitting a full 64 Kbytes segment.
688  Rel.Addend = 0x8000;
689 
690  return Error::success();
691 }
692 
693 // Returns the sections and offset associated with the ODP entry referenced
694 // by Symbol.
695 Error RuntimeDyldELF::findOPDEntrySection(const ELFObjectFileBase &Obj,
696  ObjSectionToIDMap &LocalSections,
697  RelocationValueRef &Rel) {
698  // Get the ELF symbol value (st_value) to compare with Relocation offset in
699  // .opd entries
700  for (section_iterator si = Obj.section_begin(), se = Obj.section_end();
701  si != se; ++si) {
702 
703  Expected<section_iterator> RelSecOrErr = si->getRelocatedSection();
704  if (!RelSecOrErr)
705  report_fatal_error(Twine(toString(RelSecOrErr.takeError())));
706 
707  section_iterator RelSecI = *RelSecOrErr;
708  if (RelSecI == Obj.section_end())
709  continue;
710 
711  Expected<StringRef> NameOrErr = RelSecI->getName();
712  if (!NameOrErr)
713  return NameOrErr.takeError();
714  StringRef RelSectionName = *NameOrErr;
715 
716  if (RelSectionName != ".opd")
717  continue;
718 
719  for (elf_relocation_iterator i = si->relocation_begin(),
720  e = si->relocation_end();
721  i != e;) {
722  // The R_PPC64_ADDR64 relocation indicates the first field
723  // of a .opd entry
724  uint64_t TypeFunc = i->getType();
725  if (TypeFunc != ELF::R_PPC64_ADDR64) {
726  ++i;
727  continue;
728  }
729 
730  uint64_t TargetSymbolOffset = i->getOffset();
731  symbol_iterator TargetSymbol = i->getSymbol();
732  int64_t Addend;
733  if (auto AddendOrErr = i->getAddend())
734  Addend = *AddendOrErr;
735  else
736  return AddendOrErr.takeError();
737 
738  ++i;
739  if (i == e)
740  break;
741 
742  // Just check if following relocation is a R_PPC64_TOC
743  uint64_t TypeTOC = i->getType();
744  if (TypeTOC != ELF::R_PPC64_TOC)
745  continue;
746 
747  // Finally compares the Symbol value and the target symbol offset
748  // to check if this .opd entry refers to the symbol the relocation
749  // points to.
750  if (Rel.Addend != (int64_t)TargetSymbolOffset)
751  continue;
752 
753  section_iterator TSI = Obj.section_end();
754  if (auto TSIOrErr = TargetSymbol->getSection())
755  TSI = *TSIOrErr;
756  else
757  return TSIOrErr.takeError();
758  assert(TSI != Obj.section_end() && "TSI should refer to a valid section");
759 
760  bool IsCode = TSI->isText();
761  if (auto SectionIDOrErr = findOrEmitSection(Obj, *TSI, IsCode,
762  LocalSections))
763  Rel.SectionID = *SectionIDOrErr;
764  else
765  return SectionIDOrErr.takeError();
766  Rel.Addend = (intptr_t)Addend;
767  return Error::success();
768  }
769  }
770  llvm_unreachable("Attempting to get address of ODP entry!");
771 }
772 
773 // Relocation masks following the #lo(value), #hi(value), #ha(value),
774 // #higher(value), #highera(value), #highest(value), and #highesta(value)
775 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi
776 // document.
777 
778 static inline uint16_t applyPPClo(uint64_t value) { return value & 0xffff; }
779 
780 static inline uint16_t applyPPChi(uint64_t value) {
781  return (value >> 16) & 0xffff;
782 }
783 
784 static inline uint16_t applyPPCha (uint64_t value) {
785  return ((value + 0x8000) >> 16) & 0xffff;
786 }
787 
788 static inline uint16_t applyPPChigher(uint64_t value) {
789  return (value >> 32) & 0xffff;
790 }
791 
792 static inline uint16_t applyPPChighera (uint64_t value) {
793  return ((value + 0x8000) >> 32) & 0xffff;
794 }
795 
796 static inline uint16_t applyPPChighest(uint64_t value) {
797  return (value >> 48) & 0xffff;
798 }
799 
800 static inline uint16_t applyPPChighesta (uint64_t value) {
801  return ((value + 0x8000) >> 48) & 0xffff;
802 }
803 
804 void RuntimeDyldELF::resolvePPC32Relocation(const SectionEntry &Section,
806  uint32_t Type, int64_t Addend) {
807  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
808  switch (Type) {
809  default:
810  report_fatal_error("Relocation type not implemented yet!");
811  break;
812  case ELF::R_PPC_ADDR16_LO:
813  writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
814  break;
815  case ELF::R_PPC_ADDR16_HI:
816  writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
817  break;
818  case ELF::R_PPC_ADDR16_HA:
819  writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
820  break;
821  }
822 }
823 
824 void RuntimeDyldELF::resolvePPC64Relocation(const SectionEntry &Section,
826  uint32_t Type, int64_t Addend) {
827  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
828  switch (Type) {
829  default:
830  report_fatal_error("Relocation type not implemented yet!");
831  break;
832  case ELF::R_PPC64_ADDR16:
833  writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
834  break;
835  case ELF::R_PPC64_ADDR16_DS:
836  writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
837  break;
838  case ELF::R_PPC64_ADDR16_LO:
839  writeInt16BE(LocalAddress, applyPPClo(Value + Addend));
840  break;
841  case ELF::R_PPC64_ADDR16_LO_DS:
842  writeInt16BE(LocalAddress, applyPPClo(Value + Addend) & ~3);
843  break;
844  case ELF::R_PPC64_ADDR16_HI:
845  case ELF::R_PPC64_ADDR16_HIGH:
846  writeInt16BE(LocalAddress, applyPPChi(Value + Addend));
847  break;
848  case ELF::R_PPC64_ADDR16_HA:
849  case ELF::R_PPC64_ADDR16_HIGHA:
850  writeInt16BE(LocalAddress, applyPPCha(Value + Addend));
851  break;
852  case ELF::R_PPC64_ADDR16_HIGHER:
853  writeInt16BE(LocalAddress, applyPPChigher(Value + Addend));
854  break;
855  case ELF::R_PPC64_ADDR16_HIGHERA:
856  writeInt16BE(LocalAddress, applyPPChighera(Value + Addend));
857  break;
858  case ELF::R_PPC64_ADDR16_HIGHEST:
859  writeInt16BE(LocalAddress, applyPPChighest(Value + Addend));
860  break;
861  case ELF::R_PPC64_ADDR16_HIGHESTA:
862  writeInt16BE(LocalAddress, applyPPChighesta(Value + Addend));
863  break;
864  case ELF::R_PPC64_ADDR14: {
865  assert(((Value + Addend) & 3) == 0);
866  // Preserve the AA/LK bits in the branch instruction
867  uint8_t aalk = *(LocalAddress + 3);
868  writeInt16BE(LocalAddress + 2, (aalk & 3) | ((Value + Addend) & 0xfffc));
869  } break;
870  case ELF::R_PPC64_REL16_LO: {
871  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
872  uint64_t Delta = Value - FinalAddress + Addend;
873  writeInt16BE(LocalAddress, applyPPClo(Delta));
874  } break;
875  case ELF::R_PPC64_REL16_HI: {
876  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
877  uint64_t Delta = Value - FinalAddress + Addend;
878  writeInt16BE(LocalAddress, applyPPChi(Delta));
879  } break;
880  case ELF::R_PPC64_REL16_HA: {
881  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
882  uint64_t Delta = Value - FinalAddress + Addend;
883  writeInt16BE(LocalAddress, applyPPCha(Delta));
884  } break;
885  case ELF::R_PPC64_ADDR32: {
886  int64_t Result = static_cast<int64_t>(Value + Addend);
887  if (SignExtend64<32>(Result) != Result)
888  llvm_unreachable("Relocation R_PPC64_ADDR32 overflow");
889  writeInt32BE(LocalAddress, Result);
890  } break;
891  case ELF::R_PPC64_REL24: {
892  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
893  int64_t delta = static_cast<int64_t>(Value - FinalAddress + Addend);
894  if (SignExtend64<26>(delta) != delta)
895  llvm_unreachable("Relocation R_PPC64_REL24 overflow");
896  // We preserve bits other than LI field, i.e. PO and AA/LK fields.
897  uint32_t Inst = readBytesUnaligned(LocalAddress, 4);
898  writeInt32BE(LocalAddress, (Inst & 0xFC000003) | (delta & 0x03FFFFFC));
899  } break;
900  case ELF::R_PPC64_REL32: {
901  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
902  int64_t delta = static_cast<int64_t>(Value - FinalAddress + Addend);
903  if (SignExtend64<32>(delta) != delta)
904  llvm_unreachable("Relocation R_PPC64_REL32 overflow");
905  writeInt32BE(LocalAddress, delta);
906  } break;
907  case ELF::R_PPC64_REL64: {
908  uint64_t FinalAddress = Section.getLoadAddressWithOffset(Offset);
909  uint64_t Delta = Value - FinalAddress + Addend;
910  writeInt64BE(LocalAddress, Delta);
911  } break;
912  case ELF::R_PPC64_ADDR64:
913  writeInt64BE(LocalAddress, Value + Addend);
914  break;
915  }
916 }
917 
918 void RuntimeDyldELF::resolveSystemZRelocation(const SectionEntry &Section,
920  uint32_t Type, int64_t Addend) {
921  uint8_t *LocalAddress = Section.getAddressWithOffset(Offset);
922  switch (Type) {
923  default:
924  report_fatal_error("Relocation type not implemented yet!");
925  break;
926  case ELF::R_390_PC16DBL:
927  case ELF::R_390_PLT16DBL: {
928  int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
929  assert(int16_t(Delta / 2) * 2 == Delta && "R_390_PC16DBL overflow");
930  writeInt16BE(LocalAddress, Delta / 2);
931  break;
932  }
933  case ELF::R_390_PC32DBL:
934  case ELF::R_390_PLT32DBL: {
935  int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
936  assert(int32_t(Delta / 2) * 2 == Delta && "R_390_PC32DBL overflow");
937  writeInt32BE(LocalAddress, Delta / 2);
938  break;
939  }
940  case ELF::R_390_PC16: {
941  int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
942  assert(int16_t(Delta) == Delta && "R_390_PC16 overflow");
943  writeInt16BE(LocalAddress, Delta);
944  break;
945  }
946  case ELF::R_390_PC32: {
947  int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
948  assert(int32_t(Delta) == Delta && "R_390_PC32 overflow");
949  writeInt32BE(LocalAddress, Delta);
950  break;
951  }
952  case ELF::R_390_PC64: {
953  int64_t Delta = (Value + Addend) - Section.getLoadAddressWithOffset(Offset);
954  writeInt64BE(LocalAddress, Delta);
955  break;
956  }
957  case ELF::R_390_8:
958  *LocalAddress = (uint8_t)(Value + Addend);
959  break;
960  case ELF::R_390_16:
961  writeInt16BE(LocalAddress, Value + Addend);
962  break;
963  case ELF::R_390_32:
964  writeInt32BE(LocalAddress, Value + Addend);
965  break;
966  case ELF::R_390_64:
967  writeInt64BE(LocalAddress, Value + Addend);
968  break;
969  }
970 }
971 
972 void RuntimeDyldELF::resolveBPFRelocation(const SectionEntry &Section,
974  uint32_t Type, int64_t Addend) {
975  bool isBE = Arch == Triple::bpfeb;
976 
977  switch (Type) {
978  default:
979  report_fatal_error("Relocation type not implemented yet!");
980  break;
981  case ELF::R_BPF_NONE:
982  case ELF::R_BPF_64_64:
983  case ELF::R_BPF_64_32:
984  case ELF::R_BPF_64_NODYLD32:
985  break;
986  case ELF::R_BPF_64_ABS64: {
987  write(isBE, Section.getAddressWithOffset(Offset), Value + Addend);
988  LLVM_DEBUG(dbgs() << "Writing " << format("%p", (Value + Addend)) << " at "
989  << format("%p\n", Section.getAddressWithOffset(Offset)));
990  break;
991  }
992  case ELF::R_BPF_64_ABS32: {
993  Value += Addend;
994  assert(Value <= UINT32_MAX);
995  write(isBE, Section.getAddressWithOffset(Offset), static_cast<uint32_t>(Value));
996  LLVM_DEBUG(dbgs() << "Writing " << format("%p", Value) << " at "
997  << format("%p\n", Section.getAddressWithOffset(Offset)));
998  break;
999  }
1000  }
1001 }
1002 
1003 // The target location for the relocation is described by RE.SectionID and
1004 // RE.Offset. RE.SectionID can be used to find the SectionEntry. Each
1005 // SectionEntry has three members describing its location.
1006 // SectionEntry::Address is the address at which the section has been loaded
1007 // into memory in the current (host) process. SectionEntry::LoadAddress is the
1008 // address that the section will have in the target process.
1009 // SectionEntry::ObjAddress is the address of the bits for this section in the
1010 // original emitted object image (also in the current address space).
1011 //
1012 // Relocations will be applied as if the section were loaded at
1013 // SectionEntry::LoadAddress, but they will be applied at an address based
1014 // on SectionEntry::Address. SectionEntry::ObjAddress will be used to refer to
1015 // Target memory contents if they are required for value calculations.
1016 //
1017 // The Value parameter here is the load address of the symbol for the
1018 // relocation to be applied. For relocations which refer to symbols in the
1019 // current object Value will be the LoadAddress of the section in which
1020 // the symbol resides (RE.Addend provides additional information about the
1021 // symbol location). For external symbols, Value will be the address of the
1022 // symbol in the target address space.
1023 void RuntimeDyldELF::resolveRelocation(const RelocationEntry &RE,
1024  uint64_t Value) {
1025  const SectionEntry &Section = Sections[RE.SectionID];
1026  return resolveRelocation(Section, RE.Offset, Value, RE.RelType, RE.Addend,
1027  RE.SymOffset, RE.SectionID);
1028 }
1029 
1030 void RuntimeDyldELF::resolveRelocation(const SectionEntry &Section,
1032  uint32_t Type, int64_t Addend,
1033  uint64_t SymOffset, SID SectionID) {
1034  switch (Arch) {
1035  case Triple::x86_64:
1036  resolveX86_64Relocation(Section, Offset, Value, Type, Addend, SymOffset);
1037  break;
1038  case Triple::x86:
1039  resolveX86Relocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
1040  (uint32_t)(Addend & 0xffffffffL));
1041  break;
1042  case Triple::aarch64:
1043  case Triple::aarch64_be:
1044  resolveAArch64Relocation(Section, Offset, Value, Type, Addend);
1045  break;
1046  case Triple::arm: // Fall through.
1047  case Triple::armeb:
1048  case Triple::thumb:
1049  case Triple::thumbeb:
1050  resolveARMRelocation(Section, Offset, (uint32_t)(Value & 0xffffffffL), Type,
1051  (uint32_t)(Addend & 0xffffffffL));
1052  break;
1053  case Triple::ppc: // Fall through.
1054  case Triple::ppcle:
1055  resolvePPC32Relocation(Section, Offset, Value, Type, Addend);
1056  break;
1057  case Triple::ppc64: // Fall through.
1058  case Triple::ppc64le:
1059  resolvePPC64Relocation(Section, Offset, Value, Type, Addend);
1060  break;
1061  case Triple::systemz:
1062  resolveSystemZRelocation(Section, Offset, Value, Type, Addend);
1063  break;
1064  case Triple::bpfel:
1065  case Triple::bpfeb:
1066  resolveBPFRelocation(Section, Offset, Value, Type, Addend);
1067  break;
1068  default:
1069  llvm_unreachable("Unsupported CPU type!");
1070  }
1071 }
1072 
1073 void *RuntimeDyldELF::computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const {
1074  return (void *)(Sections[SectionID].getObjAddress() + Offset);
1075 }
1076 
1077 void RuntimeDyldELF::processSimpleRelocation(unsigned SectionID, uint64_t Offset, unsigned RelType, RelocationValueRef Value) {
1078  RelocationEntry RE(SectionID, Offset, RelType, Value.Addend, Value.Offset);
1079  if (Value.SymbolName)
1080  addRelocationForSymbol(RE, Value.SymbolName);
1081  else
1082  addRelocationForSection(RE, Value.SectionID);
1083 }
1084 
1085 uint32_t RuntimeDyldELF::getMatchingLoRelocation(uint32_t RelType,
1086  bool IsLocal) const {
1087  switch (RelType) {
1088  case ELF::R_MICROMIPS_GOT16:
1089  if (IsLocal)
1090  return ELF::R_MICROMIPS_LO16;
1091  break;
1092  case ELF::R_MICROMIPS_HI16:
1093  return ELF::R_MICROMIPS_LO16;
1094  case ELF::R_MIPS_GOT16:
1095  if (IsLocal)
1096  return ELF::R_MIPS_LO16;
1097  break;
1098  case ELF::R_MIPS_HI16:
1099  return ELF::R_MIPS_LO16;
1100  case ELF::R_MIPS_PCHI16:
1101  return ELF::R_MIPS_PCLO16;
1102  default:
1103  break;
1104  }
1105  return ELF::R_MIPS_NONE;
1106 }
1107 
1108 // Sometimes we don't need to create thunk for a branch.
1109 // This typically happens when branch target is located
1110 // in the same object file. In such case target is either
1111 // a weak symbol or symbol in a different executable section.
1112 // This function checks if branch target is located in the
1113 // same object file and if distance between source and target
1114 // fits R_AARCH64_CALL26 relocation. If both conditions are
1115 // met, it emits direct jump to the target and returns true.
1116 // Otherwise false is returned and thunk is created.
1117 bool RuntimeDyldELF::resolveAArch64ShortBranch(
1118  unsigned SectionID, relocation_iterator RelI,
1119  const RelocationValueRef &Value) {
1120  uint64_t Address;
1121  if (Value.SymbolName) {
1122  auto Loc = GlobalSymbolTable.find(Value.SymbolName);
1123 
1124  // Don't create direct branch for external symbols.
1125  if (Loc == GlobalSymbolTable.end())
1126  return false;
1127 
1128  const auto &SymInfo = Loc->second;
1129  Address =
1130  uint64_t(Sections[SymInfo.getSectionID()].getLoadAddressWithOffset(
1131  SymInfo.getOffset()));
1132  } else {
1133  Address = uint64_t(Sections[Value.SectionID].getLoadAddress());
1134  }
1135  uint64_t Offset = RelI->getOffset();
1136  uint64_t SourceAddress = Sections[SectionID].getLoadAddressWithOffset(Offset);
1137 
1138  // R_AARCH64_CALL26 requires immediate to be in range -2^27 <= imm < 2^27
1139  // If distance between source and target is out of range then we should
1140  // create thunk.
1141  if (!isInt<28>(Address + Value.Addend - SourceAddress))
1142  return false;
1143 
1144  resolveRelocation(Sections[SectionID], Offset, Address, RelI->getType(),
1145  Value.Addend);
1146 
1147  return true;
1148 }
1149 
1150 void RuntimeDyldELF::resolveAArch64Branch(unsigned SectionID,
1151  const RelocationValueRef &Value,
1152  relocation_iterator RelI,
1153  StubMap &Stubs) {
1154 
1155  LLVM_DEBUG(dbgs() << "\t\tThis is an AArch64 branch relocation.");
1156  SectionEntry &Section = Sections[SectionID];
1157 
1158  uint64_t Offset = RelI->getOffset();
1159  unsigned RelType = RelI->getType();
1160  // Look for an existing stub.
1161  StubMap::const_iterator i = Stubs.find(Value);
1162  if (i != Stubs.end()) {
1163  resolveRelocation(Section, Offset,
1164  (uint64_t)Section.getAddressWithOffset(i->second),
1165  RelType, 0);
1166  LLVM_DEBUG(dbgs() << " Stub function found\n");
1167  } else if (!resolveAArch64ShortBranch(SectionID, RelI, Value)) {
1168  // Create a new stub function.
1169  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1170  Stubs[Value] = Section.getStubOffset();
1171  uint8_t *StubTargetAddr = createStubFunction(
1172  Section.getAddressWithOffset(Section.getStubOffset()));
1173 
1174  RelocationEntry REmovz_g3(SectionID, StubTargetAddr - Section.getAddress(),
1175  ELF::R_AARCH64_MOVW_UABS_G3, Value.Addend);
1176  RelocationEntry REmovk_g2(SectionID,
1177  StubTargetAddr - Section.getAddress() + 4,
1178  ELF::R_AARCH64_MOVW_UABS_G2_NC, Value.Addend);
1179  RelocationEntry REmovk_g1(SectionID,
1180  StubTargetAddr - Section.getAddress() + 8,
1181  ELF::R_AARCH64_MOVW_UABS_G1_NC, Value.Addend);
1182  RelocationEntry REmovk_g0(SectionID,
1183  StubTargetAddr - Section.getAddress() + 12,
1184  ELF::R_AARCH64_MOVW_UABS_G0_NC, Value.Addend);
1185 
1186  if (Value.SymbolName) {
1187  addRelocationForSymbol(REmovz_g3, Value.SymbolName);
1188  addRelocationForSymbol(REmovk_g2, Value.SymbolName);
1189  addRelocationForSymbol(REmovk_g1, Value.SymbolName);
1190  addRelocationForSymbol(REmovk_g0, Value.SymbolName);
1191  } else {
1192  addRelocationForSection(REmovz_g3, Value.SectionID);
1193  addRelocationForSection(REmovk_g2, Value.SectionID);
1194  addRelocationForSection(REmovk_g1, Value.SectionID);
1195  addRelocationForSection(REmovk_g0, Value.SectionID);
1196  }
1197  resolveRelocation(Section, Offset,
1198  reinterpret_cast<uint64_t>(Section.getAddressWithOffset(
1199  Section.getStubOffset())),
1200  RelType, 0);
1201  Section.advanceStubOffset(getMaxStubSize());
1202  }
1203 }
1204 
1207  unsigned SectionID, relocation_iterator RelI, const ObjectFile &O,
1208  ObjSectionToIDMap &ObjSectionToID, StubMap &Stubs) {
1209  const auto &Obj = cast<ELFObjectFileBase>(O);
1210  uint64_t RelType = RelI->getType();
1211  int64_t Addend = 0;
1212  if (Expected<int64_t> AddendOrErr = ELFRelocationRef(*RelI).getAddend())
1213  Addend = *AddendOrErr;
1214  else
1215  consumeError(AddendOrErr.takeError());
1216  elf_symbol_iterator Symbol = RelI->getSymbol();
1217 
1218  // Obtain the symbol name which is referenced in the relocation
1219  StringRef TargetName;
1220  if (Symbol != Obj.symbol_end()) {
1221  if (auto TargetNameOrErr = Symbol->getName())
1222  TargetName = *TargetNameOrErr;
1223  else
1224  return TargetNameOrErr.takeError();
1225  }
1226  LLVM_DEBUG(dbgs() << "\t\tRelType: " << RelType << " Addend: " << Addend
1227  << " TargetName: " << TargetName << "\n");
1229  // First search for the symbol in the local symbol table
1230  SymbolRef::Type SymType = SymbolRef::ST_Unknown;
1231 
1232  // Search for the symbol in the global symbol table
1234  if (Symbol != Obj.symbol_end()) {
1235  gsi = GlobalSymbolTable.find(TargetName.data());
1236  Expected<SymbolRef::Type> SymTypeOrErr = Symbol->getType();
1237  if (!SymTypeOrErr) {
1238  std::string Buf;
1239  raw_string_ostream OS(Buf);
1240  logAllUnhandledErrors(SymTypeOrErr.takeError(), OS);
1241  report_fatal_error(Twine(OS.str()));
1242  }
1243  SymType = *SymTypeOrErr;
1244  }
1245  if (gsi != GlobalSymbolTable.end()) {
1246  const auto &SymInfo = gsi->second;
1247  Value.SectionID = SymInfo.getSectionID();
1248  Value.Offset = SymInfo.getOffset();
1249  Value.Addend = SymInfo.getOffset() + Addend;
1250  } else {
1251  switch (SymType) {
1252  case SymbolRef::ST_Debug: {
1253  // TODO: Now ELF SymbolRef::ST_Debug = STT_SECTION, it's not obviously
1254  // and can be changed by another developers. Maybe best way is add
1255  // a new symbol type ST_Section to SymbolRef and use it.
1256  auto SectionOrErr = Symbol->getSection();
1257  if (!SectionOrErr) {
1258  std::string Buf;
1259  raw_string_ostream OS(Buf);
1260  logAllUnhandledErrors(SectionOrErr.takeError(), OS);
1261  report_fatal_error(Twine(OS.str()));
1262  }
1263  section_iterator si = *SectionOrErr;
1264  if (si == Obj.section_end())
1265  llvm_unreachable("Symbol section not found, bad object file format!");
1266  LLVM_DEBUG(dbgs() << "\t\tThis is section symbol\n");
1267  bool isCode = si->isText();
1268  if (auto SectionIDOrErr = findOrEmitSection(Obj, (*si), isCode,
1269  ObjSectionToID))
1270  Value.SectionID = *SectionIDOrErr;
1271  else
1272  return SectionIDOrErr.takeError();
1273  Value.Addend = Addend;
1274  break;
1275  }
1276  case SymbolRef::ST_Data:
1277  case SymbolRef::ST_Function:
1278  case SymbolRef::ST_Unknown: {
1279  Value.SymbolName = TargetName.data();
1280  Value.Addend = Addend;
1281 
1282  // Absolute relocations will have a zero symbol ID (STN_UNDEF), which
1283  // will manifest here as a NULL symbol name.
1284  // We can set this as a valid (but empty) symbol name, and rely
1285  // on addRelocationForSymbol to handle this.
1286  if (!Value.SymbolName)
1287  Value.SymbolName = "";
1288  break;
1289  }
1290  default:
1291  llvm_unreachable("Unresolved symbol type!");
1292  break;
1293  }
1294  }
1295 
1296  uint64_t Offset = RelI->getOffset();
1297 
1298  LLVM_DEBUG(dbgs() << "\t\tSectionID: " << SectionID << " Offset: " << Offset
1299  << "\n");
1300  if ((Arch == Triple::aarch64 || Arch == Triple::aarch64_be)) {
1301  if ((RelType == ELF::R_AARCH64_CALL26 ||
1302  RelType == ELF::R_AARCH64_JUMP26) &&
1304  resolveAArch64Branch(SectionID, Value, RelI, Stubs);
1305  } else if (RelType == ELF::R_AARCH64_ADR_GOT_PAGE) {
1306  // Create new GOT entry or find existing one. If GOT entry is
1307  // to be created, then we also emit ABS64 relocation for it.
1308  uint64_t GOTOffset = findOrAllocGOTEntry(Value, ELF::R_AARCH64_ABS64);
1309  resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1310  ELF::R_AARCH64_ADR_PREL_PG_HI21);
1311 
1312  } else if (RelType == ELF::R_AARCH64_LD64_GOT_LO12_NC) {
1313  uint64_t GOTOffset = findOrAllocGOTEntry(Value, ELF::R_AARCH64_ABS64);
1314  resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1315  ELF::R_AARCH64_LDST64_ABS_LO12_NC);
1316  } else {
1317  processSimpleRelocation(SectionID, Offset, RelType, Value);
1318  }
1319  } else if (Arch == Triple::arm) {
1320  if (RelType == ELF::R_ARM_PC24 || RelType == ELF::R_ARM_CALL ||
1321  RelType == ELF::R_ARM_JUMP24) {
1322  // This is an ARM branch relocation, need to use a stub function.
1323  LLVM_DEBUG(dbgs() << "\t\tThis is an ARM branch relocation.\n");
1324  SectionEntry &Section = Sections[SectionID];
1325 
1326  // Look for an existing stub.
1327  StubMap::const_iterator i = Stubs.find(Value);
1328  if (i != Stubs.end()) {
1329  resolveRelocation(
1330  Section, Offset,
1331  reinterpret_cast<uint64_t>(Section.getAddressWithOffset(i->second)),
1332  RelType, 0);
1333  LLVM_DEBUG(dbgs() << " Stub function found\n");
1334  } else {
1335  // Create a new stub function.
1336  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1337  Stubs[Value] = Section.getStubOffset();
1338  uint8_t *StubTargetAddr = createStubFunction(
1339  Section.getAddressWithOffset(Section.getStubOffset()));
1340  RelocationEntry RE(SectionID, StubTargetAddr - Section.getAddress(),
1341  ELF::R_ARM_ABS32, Value.Addend);
1342  if (Value.SymbolName)
1343  addRelocationForSymbol(RE, Value.SymbolName);
1344  else
1345  addRelocationForSection(RE, Value.SectionID);
1346 
1347  resolveRelocation(Section, Offset, reinterpret_cast<uint64_t>(
1348  Section.getAddressWithOffset(
1349  Section.getStubOffset())),
1350  RelType, 0);
1351  Section.advanceStubOffset(getMaxStubSize());
1352  }
1353  } else {
1354  uint32_t *Placeholder =
1355  reinterpret_cast<uint32_t*>(computePlaceholderAddress(SectionID, Offset));
1356  if (RelType == ELF::R_ARM_PREL31 || RelType == ELF::R_ARM_TARGET1 ||
1357  RelType == ELF::R_ARM_ABS32) {
1358  Value.Addend += *Placeholder;
1359  } else if (RelType == ELF::R_ARM_MOVW_ABS_NC || RelType == ELF::R_ARM_MOVT_ABS) {
1360  // See ELF for ARM documentation
1361  Value.Addend += (int16_t)((*Placeholder & 0xFFF) | (((*Placeholder >> 16) & 0xF) << 12));
1362  }
1363  processSimpleRelocation(SectionID, Offset, RelType, Value);
1364  }
1365  } else if (IsMipsO32ABI) {
1366  uint8_t *Placeholder = reinterpret_cast<uint8_t *>(
1367  computePlaceholderAddress(SectionID, Offset));
1368  uint32_t Opcode = readBytesUnaligned(Placeholder, 4);
1369  if (RelType == ELF::R_MIPS_26) {
1370  // This is an Mips branch relocation, need to use a stub function.
1371  LLVM_DEBUG(dbgs() << "\t\tThis is a Mips branch relocation.");
1372  SectionEntry &Section = Sections[SectionID];
1373 
1374  // Extract the addend from the instruction.
1375  // We shift up by two since the Value will be down shifted again
1376  // when applying the relocation.
1377  uint32_t Addend = (Opcode & 0x03ffffff) << 2;
1378 
1379  Value.Addend += Addend;
1380 
1381  // Look up for existing stub.
1382  StubMap::const_iterator i = Stubs.find(Value);
1383  if (i != Stubs.end()) {
1384  RelocationEntry RE(SectionID, Offset, RelType, i->second);
1385  addRelocationForSection(RE, SectionID);
1386  LLVM_DEBUG(dbgs() << " Stub function found\n");
1387  } else {
1388  // Create a new stub function.
1389  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1390  Stubs[Value] = Section.getStubOffset();
1391 
1392  unsigned AbiVariant = Obj.getPlatformFlags();
1393 
1394  uint8_t *StubTargetAddr = createStubFunction(
1395  Section.getAddressWithOffset(Section.getStubOffset()), AbiVariant);
1396 
1397  // Creating Hi and Lo relocations for the filled stub instructions.
1398  RelocationEntry REHi(SectionID, StubTargetAddr - Section.getAddress(),
1399  ELF::R_MIPS_HI16, Value.Addend);
1400  RelocationEntry RELo(SectionID,
1401  StubTargetAddr - Section.getAddress() + 4,
1402  ELF::R_MIPS_LO16, Value.Addend);
1403 
1404  if (Value.SymbolName) {
1405  addRelocationForSymbol(REHi, Value.SymbolName);
1406  addRelocationForSymbol(RELo, Value.SymbolName);
1407  } else {
1408  addRelocationForSection(REHi, Value.SectionID);
1409  addRelocationForSection(RELo, Value.SectionID);
1410  }
1411 
1412  RelocationEntry RE(SectionID, Offset, RelType, Section.getStubOffset());
1413  addRelocationForSection(RE, SectionID);
1414  Section.advanceStubOffset(getMaxStubSize());
1415  }
1416  } else if (RelType == ELF::R_MIPS_HI16 || RelType == ELF::R_MIPS_PCHI16) {
1417  int64_t Addend = (Opcode & 0x0000ffff) << 16;
1418  RelocationEntry RE(SectionID, Offset, RelType, Addend);
1419  PendingRelocs.push_back(std::make_pair(Value, RE));
1420  } else if (RelType == ELF::R_MIPS_LO16 || RelType == ELF::R_MIPS_PCLO16) {
1421  int64_t Addend = Value.Addend + SignExtend32<16>(Opcode & 0x0000ffff);
1422  for (auto I = PendingRelocs.begin(); I != PendingRelocs.end();) {
1423  const RelocationValueRef &MatchingValue = I->first;
1424  RelocationEntry &Reloc = I->second;
1425  if (MatchingValue == Value &&
1426  RelType == getMatchingLoRelocation(Reloc.RelType) &&
1427  SectionID == Reloc.SectionID) {
1428  Reloc.Addend += Addend;
1429  if (Value.SymbolName)
1430  addRelocationForSymbol(Reloc, Value.SymbolName);
1431  else
1432  addRelocationForSection(Reloc, Value.SectionID);
1433  I = PendingRelocs.erase(I);
1434  } else
1435  ++I;
1436  }
1437  RelocationEntry RE(SectionID, Offset, RelType, Addend);
1438  if (Value.SymbolName)
1439  addRelocationForSymbol(RE, Value.SymbolName);
1440  else
1441  addRelocationForSection(RE, Value.SectionID);
1442  } else {
1443  if (RelType == ELF::R_MIPS_32)
1444  Value.Addend += Opcode;
1445  else if (RelType == ELF::R_MIPS_PC16)
1446  Value.Addend += SignExtend32<18>((Opcode & 0x0000ffff) << 2);
1447  else if (RelType == ELF::R_MIPS_PC19_S2)
1448  Value.Addend += SignExtend32<21>((Opcode & 0x0007ffff) << 2);
1449  else if (RelType == ELF::R_MIPS_PC21_S2)
1450  Value.Addend += SignExtend32<23>((Opcode & 0x001fffff) << 2);
1451  else if (RelType == ELF::R_MIPS_PC26_S2)
1452  Value.Addend += SignExtend32<28>((Opcode & 0x03ffffff) << 2);
1453  processSimpleRelocation(SectionID, Offset, RelType, Value);
1454  }
1455  } else if (IsMipsN32ABI || IsMipsN64ABI) {
1456  uint32_t r_type = RelType & 0xff;
1457  RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1458  if (r_type == ELF::R_MIPS_CALL16 || r_type == ELF::R_MIPS_GOT_PAGE
1459  || r_type == ELF::R_MIPS_GOT_DISP) {
1460  StringMap<uint64_t>::iterator i = GOTSymbolOffsets.find(TargetName);
1461  if (i != GOTSymbolOffsets.end())
1462  RE.SymOffset = i->second;
1463  else {
1464  RE.SymOffset = allocateGOTEntries(1);
1465  GOTSymbolOffsets[TargetName] = RE.SymOffset;
1466  }
1467  if (Value.SymbolName)
1468  addRelocationForSymbol(RE, Value.SymbolName);
1469  else
1470  addRelocationForSection(RE, Value.SectionID);
1471  } else if (RelType == ELF::R_MIPS_26) {
1472  // This is an Mips branch relocation, need to use a stub function.
1473  LLVM_DEBUG(dbgs() << "\t\tThis is a Mips branch relocation.");
1474  SectionEntry &Section = Sections[SectionID];
1475 
1476  // Look up for existing stub.
1477  StubMap::const_iterator i = Stubs.find(Value);
1478  if (i != Stubs.end()) {
1479  RelocationEntry RE(SectionID, Offset, RelType, i->second);
1480  addRelocationForSection(RE, SectionID);
1481  LLVM_DEBUG(dbgs() << " Stub function found\n");
1482  } else {
1483  // Create a new stub function.
1484  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1485  Stubs[Value] = Section.getStubOffset();
1486 
1487  unsigned AbiVariant = Obj.getPlatformFlags();
1488 
1489  uint8_t *StubTargetAddr = createStubFunction(
1490  Section.getAddressWithOffset(Section.getStubOffset()), AbiVariant);
1491 
1492  if (IsMipsN32ABI) {
1493  // Creating Hi and Lo relocations for the filled stub instructions.
1494  RelocationEntry REHi(SectionID, StubTargetAddr - Section.getAddress(),
1495  ELF::R_MIPS_HI16, Value.Addend);
1496  RelocationEntry RELo(SectionID,
1497  StubTargetAddr - Section.getAddress() + 4,
1498  ELF::R_MIPS_LO16, Value.Addend);
1499  if (Value.SymbolName) {
1500  addRelocationForSymbol(REHi, Value.SymbolName);
1501  addRelocationForSymbol(RELo, Value.SymbolName);
1502  } else {
1503  addRelocationForSection(REHi, Value.SectionID);
1504  addRelocationForSection(RELo, Value.SectionID);
1505  }
1506  } else {
1507  // Creating Highest, Higher, Hi and Lo relocations for the filled stub
1508  // instructions.
1509  RelocationEntry REHighest(SectionID,
1510  StubTargetAddr - Section.getAddress(),
1511  ELF::R_MIPS_HIGHEST, Value.Addend);
1512  RelocationEntry REHigher(SectionID,
1513  StubTargetAddr - Section.getAddress() + 4,
1514  ELF::R_MIPS_HIGHER, Value.Addend);
1515  RelocationEntry REHi(SectionID,
1516  StubTargetAddr - Section.getAddress() + 12,
1517  ELF::R_MIPS_HI16, Value.Addend);
1518  RelocationEntry RELo(SectionID,
1519  StubTargetAddr - Section.getAddress() + 20,
1520  ELF::R_MIPS_LO16, Value.Addend);
1521  if (Value.SymbolName) {
1522  addRelocationForSymbol(REHighest, Value.SymbolName);
1523  addRelocationForSymbol(REHigher, Value.SymbolName);
1524  addRelocationForSymbol(REHi, Value.SymbolName);
1525  addRelocationForSymbol(RELo, Value.SymbolName);
1526  } else {
1527  addRelocationForSection(REHighest, Value.SectionID);
1528  addRelocationForSection(REHigher, Value.SectionID);
1529  addRelocationForSection(REHi, Value.SectionID);
1530  addRelocationForSection(RELo, Value.SectionID);
1531  }
1532  }
1533  RelocationEntry RE(SectionID, Offset, RelType, Section.getStubOffset());
1534  addRelocationForSection(RE, SectionID);
1535  Section.advanceStubOffset(getMaxStubSize());
1536  }
1537  } else {
1538  processSimpleRelocation(SectionID, Offset, RelType, Value);
1539  }
1540 
1541  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
1542  if (RelType == ELF::R_PPC64_REL24) {
1543  // Determine ABI variant in use for this object.
1544  unsigned AbiVariant = Obj.getPlatformFlags();
1545  AbiVariant &= ELF::EF_PPC64_ABI;
1546  // A PPC branch relocation will need a stub function if the target is
1547  // an external symbol (either Value.SymbolName is set, or SymType is
1548  // Symbol::ST_Unknown) or if the target address is not within the
1549  // signed 24-bits branch address.
1550  SectionEntry &Section = Sections[SectionID];
1551  uint8_t *Target = Section.getAddressWithOffset(Offset);
1552  bool RangeOverflow = false;
1553  bool IsExtern = Value.SymbolName || SymType == SymbolRef::ST_Unknown;
1554  if (!IsExtern) {
1555  if (AbiVariant != 2) {
1556  // In the ELFv1 ABI, a function call may point to the .opd entry,
1557  // so the final symbol value is calculated based on the relocation
1558  // values in the .opd section.
1559  if (auto Err = findOPDEntrySection(Obj, ObjSectionToID, Value))
1560  return std::move(Err);
1561  } else {
1562  // In the ELFv2 ABI, a function symbol may provide a local entry
1563  // point, which must be used for direct calls.
1564  if (Value.SectionID == SectionID){
1565  uint8_t SymOther = Symbol->getOther();
1566  Value.Addend += ELF::decodePPC64LocalEntryOffset(SymOther);
1567  }
1568  }
1569  uint8_t *RelocTarget =
1570  Sections[Value.SectionID].getAddressWithOffset(Value.Addend);
1571  int64_t delta = static_cast<int64_t>(Target - RelocTarget);
1572  // If it is within 26-bits branch range, just set the branch target
1573  if (SignExtend64<26>(delta) != delta) {
1574  RangeOverflow = true;
1575  } else if ((AbiVariant != 2) ||
1576  (AbiVariant == 2 && Value.SectionID == SectionID)) {
1577  RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1578  addRelocationForSection(RE, Value.SectionID);
1579  }
1580  }
1581  if (IsExtern || (AbiVariant == 2 && Value.SectionID != SectionID) ||
1582  RangeOverflow) {
1583  // It is an external symbol (either Value.SymbolName is set, or
1584  // SymType is SymbolRef::ST_Unknown) or out of range.
1585  StubMap::const_iterator i = Stubs.find(Value);
1586  if (i != Stubs.end()) {
1587  // Symbol function stub already created, just relocate to it
1588  resolveRelocation(Section, Offset,
1589  reinterpret_cast<uint64_t>(
1590  Section.getAddressWithOffset(i->second)),
1591  RelType, 0);
1592  LLVM_DEBUG(dbgs() << " Stub function found\n");
1593  } else {
1594  // Create a new stub function.
1595  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1596  Stubs[Value] = Section.getStubOffset();
1597  uint8_t *StubTargetAddr = createStubFunction(
1598  Section.getAddressWithOffset(Section.getStubOffset()),
1599  AbiVariant);
1600  RelocationEntry RE(SectionID, StubTargetAddr - Section.getAddress(),
1601  ELF::R_PPC64_ADDR64, Value.Addend);
1602 
1603  // Generates the 64-bits address loads as exemplified in section
1604  // 4.5.1 in PPC64 ELF ABI. Note that the relocations need to
1605  // apply to the low part of the instructions, so we have to update
1606  // the offset according to the target endianness.
1607  uint64_t StubRelocOffset = StubTargetAddr - Section.getAddress();
1608  if (!IsTargetLittleEndian)
1609  StubRelocOffset += 2;
1610 
1611  RelocationEntry REhst(SectionID, StubRelocOffset + 0,
1612  ELF::R_PPC64_ADDR16_HIGHEST, Value.Addend);
1613  RelocationEntry REhr(SectionID, StubRelocOffset + 4,
1614  ELF::R_PPC64_ADDR16_HIGHER, Value.Addend);
1615  RelocationEntry REh(SectionID, StubRelocOffset + 12,
1616  ELF::R_PPC64_ADDR16_HI, Value.Addend);
1617  RelocationEntry REl(SectionID, StubRelocOffset + 16,
1618  ELF::R_PPC64_ADDR16_LO, Value.Addend);
1619 
1620  if (Value.SymbolName) {
1621  addRelocationForSymbol(REhst, Value.SymbolName);
1622  addRelocationForSymbol(REhr, Value.SymbolName);
1623  addRelocationForSymbol(REh, Value.SymbolName);
1624  addRelocationForSymbol(REl, Value.SymbolName);
1625  } else {
1626  addRelocationForSection(REhst, Value.SectionID);
1627  addRelocationForSection(REhr, Value.SectionID);
1628  addRelocationForSection(REh, Value.SectionID);
1629  addRelocationForSection(REl, Value.SectionID);
1630  }
1631 
1632  resolveRelocation(Section, Offset, reinterpret_cast<uint64_t>(
1633  Section.getAddressWithOffset(
1634  Section.getStubOffset())),
1635  RelType, 0);
1636  Section.advanceStubOffset(getMaxStubSize());
1637  }
1638  if (IsExtern || (AbiVariant == 2 && Value.SectionID != SectionID)) {
1639  // Restore the TOC for external calls
1640  if (AbiVariant == 2)
1641  writeInt32BE(Target + 4, 0xE8410018); // ld r2,24(r1)
1642  else
1643  writeInt32BE(Target + 4, 0xE8410028); // ld r2,40(r1)
1644  }
1645  }
1646  } else if (RelType == ELF::R_PPC64_TOC16 ||
1647  RelType == ELF::R_PPC64_TOC16_DS ||
1648  RelType == ELF::R_PPC64_TOC16_LO ||
1649  RelType == ELF::R_PPC64_TOC16_LO_DS ||
1650  RelType == ELF::R_PPC64_TOC16_HI ||
1651  RelType == ELF::R_PPC64_TOC16_HA) {
1652  // These relocations are supposed to subtract the TOC address from
1653  // the final value. This does not fit cleanly into the RuntimeDyld
1654  // scheme, since there may be *two* sections involved in determining
1655  // the relocation value (the section of the symbol referred to by the
1656  // relocation, and the TOC section associated with the current module).
1657  //
1658  // Fortunately, these relocations are currently only ever generated
1659  // referring to symbols that themselves reside in the TOC, which means
1660  // that the two sections are actually the same. Thus they cancel out
1661  // and we can immediately resolve the relocation right now.
1662  switch (RelType) {
1663  case ELF::R_PPC64_TOC16: RelType = ELF::R_PPC64_ADDR16; break;
1664  case ELF::R_PPC64_TOC16_DS: RelType = ELF::R_PPC64_ADDR16_DS; break;
1665  case ELF::R_PPC64_TOC16_LO: RelType = ELF::R_PPC64_ADDR16_LO; break;
1666  case ELF::R_PPC64_TOC16_LO_DS: RelType = ELF::R_PPC64_ADDR16_LO_DS; break;
1667  case ELF::R_PPC64_TOC16_HI: RelType = ELF::R_PPC64_ADDR16_HI; break;
1668  case ELF::R_PPC64_TOC16_HA: RelType = ELF::R_PPC64_ADDR16_HA; break;
1669  default: llvm_unreachable("Wrong relocation type.");
1670  }
1671 
1672  RelocationValueRef TOCValue;
1673  if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, TOCValue))
1674  return std::move(Err);
1675  if (Value.SymbolName || Value.SectionID != TOCValue.SectionID)
1676  llvm_unreachable("Unsupported TOC relocation.");
1677  Value.Addend -= TOCValue.Addend;
1678  resolveRelocation(Sections[SectionID], Offset, Value.Addend, RelType, 0);
1679  } else {
1680  // There are two ways to refer to the TOC address directly: either
1681  // via a ELF::R_PPC64_TOC relocation (where both symbol and addend are
1682  // ignored), or via any relocation that refers to the magic ".TOC."
1683  // symbols (in which case the addend is respected).
1684  if (RelType == ELF::R_PPC64_TOC) {
1685  RelType = ELF::R_PPC64_ADDR64;
1686  if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, Value))
1687  return std::move(Err);
1688  } else if (TargetName == ".TOC.") {
1689  if (auto Err = findPPC64TOCSection(Obj, ObjSectionToID, Value))
1690  return std::move(Err);
1691  Value.Addend += Addend;
1692  }
1693 
1694  RelocationEntry RE(SectionID, Offset, RelType, Value.Addend);
1695 
1696  if (Value.SymbolName)
1697  addRelocationForSymbol(RE, Value.SymbolName);
1698  else
1699  addRelocationForSection(RE, Value.SectionID);
1700  }
1701  } else if (Arch == Triple::systemz &&
1702  (RelType == ELF::R_390_PLT32DBL || RelType == ELF::R_390_GOTENT)) {
1703  // Create function stubs for both PLT and GOT references, regardless of
1704  // whether the GOT reference is to data or code. The stub contains the
1705  // full address of the symbol, as needed by GOT references, and the
1706  // executable part only adds an overhead of 8 bytes.
1707  //
1708  // We could try to conserve space by allocating the code and data
1709  // parts of the stub separately. However, as things stand, we allocate
1710  // a stub for every relocation, so using a GOT in JIT code should be
1711  // no less space efficient than using an explicit constant pool.
1712  LLVM_DEBUG(dbgs() << "\t\tThis is a SystemZ indirect relocation.");
1713  SectionEntry &Section = Sections[SectionID];
1714 
1715  // Look for an existing stub.
1716  StubMap::const_iterator i = Stubs.find(Value);
1717  uintptr_t StubAddress;
1718  if (i != Stubs.end()) {
1719  StubAddress = uintptr_t(Section.getAddressWithOffset(i->second));
1720  LLVM_DEBUG(dbgs() << " Stub function found\n");
1721  } else {
1722  // Create a new stub function.
1723  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1724 
1725  uintptr_t BaseAddress = uintptr_t(Section.getAddress());
1726  uintptr_t StubAlignment = getStubAlignment();
1727  StubAddress =
1728  (BaseAddress + Section.getStubOffset() + StubAlignment - 1) &
1729  -StubAlignment;
1730  unsigned StubOffset = StubAddress - BaseAddress;
1731 
1732  Stubs[Value] = StubOffset;
1733  createStubFunction((uint8_t *)StubAddress);
1734  RelocationEntry RE(SectionID, StubOffset + 8, ELF::R_390_64,
1735  Value.Offset);
1736  if (Value.SymbolName)
1737  addRelocationForSymbol(RE, Value.SymbolName);
1738  else
1739  addRelocationForSection(RE, Value.SectionID);
1740  Section.advanceStubOffset(getMaxStubSize());
1741  }
1742 
1743  if (RelType == ELF::R_390_GOTENT)
1744  resolveRelocation(Section, Offset, StubAddress + 8, ELF::R_390_PC32DBL,
1745  Addend);
1746  else
1747  resolveRelocation(Section, Offset, StubAddress, RelType, Addend);
1748  } else if (Arch == Triple::x86_64) {
1749  if (RelType == ELF::R_X86_64_PLT32) {
1750  // The way the PLT relocations normally work is that the linker allocates
1751  // the
1752  // PLT and this relocation makes a PC-relative call into the PLT. The PLT
1753  // entry will then jump to an address provided by the GOT. On first call,
1754  // the
1755  // GOT address will point back into PLT code that resolves the symbol. After
1756  // the first call, the GOT entry points to the actual function.
1757  //
1758  // For local functions we're ignoring all of that here and just replacing
1759  // the PLT32 relocation type with PC32, which will translate the relocation
1760  // into a PC-relative call directly to the function. For external symbols we
1761  // can't be sure the function will be within 2^32 bytes of the call site, so
1762  // we need to create a stub, which calls into the GOT. This case is
1763  // equivalent to the usual PLT implementation except that we use the stub
1764  // mechanism in RuntimeDyld (which puts stubs at the end of the section)
1765  // rather than allocating a PLT section.
1766  if (Value.SymbolName && MemMgr.allowStubAllocation()) {
1767  // This is a call to an external function.
1768  // Look for an existing stub.
1769  SectionEntry *Section = &Sections[SectionID];
1770  StubMap::const_iterator i = Stubs.find(Value);
1771  uintptr_t StubAddress;
1772  if (i != Stubs.end()) {
1773  StubAddress = uintptr_t(Section->getAddress()) + i->second;
1774  LLVM_DEBUG(dbgs() << " Stub function found\n");
1775  } else {
1776  // Create a new stub function (equivalent to a PLT entry).
1777  LLVM_DEBUG(dbgs() << " Create a new stub function\n");
1778 
1779  uintptr_t BaseAddress = uintptr_t(Section->getAddress());
1780  uintptr_t StubAlignment = getStubAlignment();
1781  StubAddress =
1782  (BaseAddress + Section->getStubOffset() + StubAlignment - 1) &
1783  -StubAlignment;
1784  unsigned StubOffset = StubAddress - BaseAddress;
1785  Stubs[Value] = StubOffset;
1786  createStubFunction((uint8_t *)StubAddress);
1787 
1788  // Bump our stub offset counter
1789  Section->advanceStubOffset(getMaxStubSize());
1790 
1791  // Allocate a GOT Entry
1792  uint64_t GOTOffset = allocateGOTEntries(1);
1793  // This potentially creates a new Section which potentially
1794  // invalidates the Section pointer, so reload it.
1795  Section = &Sections[SectionID];
1796 
1797  // The load of the GOT address has an addend of -4
1798  resolveGOTOffsetRelocation(SectionID, StubOffset + 2, GOTOffset - 4,
1799  ELF::R_X86_64_PC32);
1800 
1801  // Fill in the value of the symbol we're targeting into the GOT
1803  computeGOTOffsetRE(GOTOffset, 0, ELF::R_X86_64_64),
1804  Value.SymbolName);
1805  }
1806 
1807  // Make the target call a call into the stub table.
1808  resolveRelocation(*Section, Offset, StubAddress, ELF::R_X86_64_PC32,
1809  Addend);
1810  } else {
1811  Value.Addend += support::ulittle32_t::ref(
1812  computePlaceholderAddress(SectionID, Offset));
1813  processSimpleRelocation(SectionID, Offset, ELF::R_X86_64_PC32, Value);
1814  }
1815  } else if (RelType == ELF::R_X86_64_GOTPCREL ||
1816  RelType == ELF::R_X86_64_GOTPCRELX ||
1817  RelType == ELF::R_X86_64_REX_GOTPCRELX) {
1818  uint64_t GOTOffset = allocateGOTEntries(1);
1819  resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1820  ELF::R_X86_64_PC32);
1821 
1822  // Fill in the value of the symbol we're targeting into the GOT
1823  RelocationEntry RE =
1824  computeGOTOffsetRE(GOTOffset, Value.Offset, ELF::R_X86_64_64);
1825  if (Value.SymbolName)
1826  addRelocationForSymbol(RE, Value.SymbolName);
1827  else
1828  addRelocationForSection(RE, Value.SectionID);
1829  } else if (RelType == ELF::R_X86_64_GOT64) {
1830  // Fill in a 64-bit GOT offset.
1831  uint64_t GOTOffset = allocateGOTEntries(1);
1832  resolveRelocation(Sections[SectionID], Offset, GOTOffset,
1833  ELF::R_X86_64_64, 0);
1834 
1835  // Fill in the value of the symbol we're targeting into the GOT
1836  RelocationEntry RE =
1837  computeGOTOffsetRE(GOTOffset, Value.Offset, ELF::R_X86_64_64);
1838  if (Value.SymbolName)
1839  addRelocationForSymbol(RE, Value.SymbolName);
1840  else
1841  addRelocationForSection(RE, Value.SectionID);
1842  } else if (RelType == ELF::R_X86_64_GOTPC32) {
1843  // Materialize the address of the base of the GOT relative to the PC.
1844  // This doesn't create a GOT entry, but it does mean we need a GOT
1845  // section.
1846  (void)allocateGOTEntries(0);
1847  resolveGOTOffsetRelocation(SectionID, Offset, Addend, ELF::R_X86_64_PC32);
1848  } else if (RelType == ELF::R_X86_64_GOTPC64) {
1849  (void)allocateGOTEntries(0);
1850  resolveGOTOffsetRelocation(SectionID, Offset, Addend, ELF::R_X86_64_PC64);
1851  } else if (RelType == ELF::R_X86_64_GOTOFF64) {
1852  // GOTOFF relocations ultimately require a section difference relocation.
1853  (void)allocateGOTEntries(0);
1854  processSimpleRelocation(SectionID, Offset, RelType, Value);
1855  } else if (RelType == ELF::R_X86_64_PC32) {
1856  Value.Addend += support::ulittle32_t::ref(computePlaceholderAddress(SectionID, Offset));
1857  processSimpleRelocation(SectionID, Offset, RelType, Value);
1858  } else if (RelType == ELF::R_X86_64_PC64) {
1859  Value.Addend += support::ulittle64_t::ref(computePlaceholderAddress(SectionID, Offset));
1860  processSimpleRelocation(SectionID, Offset, RelType, Value);
1861  } else if (RelType == ELF::R_X86_64_GOTTPOFF) {
1862  processX86_64GOTTPOFFRelocation(SectionID, Offset, Value, Addend);
1863  } else if (RelType == ELF::R_X86_64_TLSGD ||
1864  RelType == ELF::R_X86_64_TLSLD) {
1865  // The next relocation must be the relocation for __tls_get_addr.
1866  ++RelI;
1867  auto &GetAddrRelocation = *RelI;
1868  processX86_64TLSRelocation(SectionID, Offset, RelType, Value, Addend,
1869  GetAddrRelocation);
1870  } else {
1871  processSimpleRelocation(SectionID, Offset, RelType, Value);
1872  }
1873  } else {
1874  if (Arch == Triple::x86) {
1875  Value.Addend += support::ulittle32_t::ref(computePlaceholderAddress(SectionID, Offset));
1876  }
1877  processSimpleRelocation(SectionID, Offset, RelType, Value);
1878  }
1879  return ++RelI;
1880 }
1881 
1882 void RuntimeDyldELF::processX86_64GOTTPOFFRelocation(unsigned SectionID,
1883  uint64_t Offset,
1885  int64_t Addend) {
1886  // Use the approach from "x86-64 Linker Optimizations" from the TLS spec
1887  // to replace the GOTTPOFF relocation with a TPOFF relocation. The spec
1888  // only mentions one optimization even though there are two different
1889  // code sequences for the Initial Exec TLS Model. We match the code to
1890  // find out which one was used.
1891 
1892  // A possible TLS code sequence and its replacement
1893  struct CodeSequence {
1894  // The expected code sequence
1895  ArrayRef<uint8_t> ExpectedCodeSequence;
1896  // The negative offset of the GOTTPOFF relocation to the beginning of
1897  // the sequence
1898  uint64_t TLSSequenceOffset;
1899  // The new code sequence
1900  ArrayRef<uint8_t> NewCodeSequence;
1901  // The offset of the new TPOFF relocation
1902  uint64_t TpoffRelocationOffset;
1903  };
1904 
1905  std::array<CodeSequence, 2> CodeSequences;
1906 
1907  // Initial Exec Code Model Sequence
1908  {
1909  static const std::initializer_list<uint8_t> ExpectedCodeSequenceList = {
1910  0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00,
1911  0x00, // mov %fs:0, %rax
1912  0x48, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00 // add x@gotpoff(%rip),
1913  // %rax
1914  };
1915  CodeSequences[0].ExpectedCodeSequence =
1916  ArrayRef<uint8_t>(ExpectedCodeSequenceList);
1917  CodeSequences[0].TLSSequenceOffset = 12;
1918 
1919  static const std::initializer_list<uint8_t> NewCodeSequenceList = {
1920  0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0, %rax
1921  0x48, 0x8d, 0x80, 0x00, 0x00, 0x00, 0x00 // lea x@tpoff(%rax), %rax
1922  };
1923  CodeSequences[0].NewCodeSequence = ArrayRef<uint8_t>(NewCodeSequenceList);
1924  CodeSequences[0].TpoffRelocationOffset = 12;
1925  }
1926 
1927  // Initial Exec Code Model Sequence, II
1928  {
1929  static const std::initializer_list<uint8_t> ExpectedCodeSequenceList = {
1930  0x48, 0x8b, 0x05, 0x00, 0x00, 0x00, 0x00, // mov x@gotpoff(%rip), %rax
1931  0x64, 0x48, 0x8b, 0x00, 0x00, 0x00, 0x00 // mov %fs:(%rax), %rax
1932  };
1933  CodeSequences[1].ExpectedCodeSequence =
1934  ArrayRef<uint8_t>(ExpectedCodeSequenceList);
1935  CodeSequences[1].TLSSequenceOffset = 3;
1936 
1937  static const std::initializer_list<uint8_t> NewCodeSequenceList = {
1938  0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00, // 6 byte nop
1939  0x64, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:x@tpoff, %rax
1940  };
1941  CodeSequences[1].NewCodeSequence = ArrayRef<uint8_t>(NewCodeSequenceList);
1942  CodeSequences[1].TpoffRelocationOffset = 10;
1943  }
1944 
1945  bool Resolved = false;
1946  auto &Section = Sections[SectionID];
1947  for (const auto &C : CodeSequences) {
1948  assert(C.ExpectedCodeSequence.size() == C.NewCodeSequence.size() &&
1949  "Old and new code sequences must have the same size");
1950 
1951  if (Offset < C.TLSSequenceOffset ||
1952  (Offset - C.TLSSequenceOffset + C.NewCodeSequence.size()) >
1953  Section.getSize()) {
1954  // This can't be a matching sequence as it doesn't fit in the current
1955  // section
1956  continue;
1957  }
1958 
1959  auto TLSSequenceStartOffset = Offset - C.TLSSequenceOffset;
1960  auto *TLSSequence = Section.getAddressWithOffset(TLSSequenceStartOffset);
1961  if (ArrayRef<uint8_t>(TLSSequence, C.ExpectedCodeSequence.size()) !=
1962  C.ExpectedCodeSequence) {
1963  continue;
1964  }
1965 
1966  memcpy(TLSSequence, C.NewCodeSequence.data(), C.NewCodeSequence.size());
1967 
1968  // The original GOTTPOFF relocation has an addend as it is PC relative,
1969  // so it needs to be corrected. The TPOFF32 relocation is used as an
1970  // absolute value (which is an offset from %fs:0), so remove the addend
1971  // again.
1972  RelocationEntry RE(SectionID,
1973  TLSSequenceStartOffset + C.TpoffRelocationOffset,
1974  ELF::R_X86_64_TPOFF32, Value.Addend - Addend);
1975 
1976  if (Value.SymbolName)
1977  addRelocationForSymbol(RE, Value.SymbolName);
1978  else
1979  addRelocationForSection(RE, Value.SectionID);
1980 
1981  Resolved = true;
1982  break;
1983  }
1984 
1985  if (!Resolved) {
1986  // The GOTTPOFF relocation was not used in one of the sequences
1987  // described in the spec, so we can't optimize it to a TPOFF
1988  // relocation.
1989  uint64_t GOTOffset = allocateGOTEntries(1);
1990  resolveGOTOffsetRelocation(SectionID, Offset, GOTOffset + Addend,
1991  ELF::R_X86_64_PC32);
1992  RelocationEntry RE =
1993  computeGOTOffsetRE(GOTOffset, Value.Offset, ELF::R_X86_64_TPOFF64);
1994  if (Value.SymbolName)
1995  addRelocationForSymbol(RE, Value.SymbolName);
1996  else
1997  addRelocationForSection(RE, Value.SectionID);
1998  }
1999 }
2000 
2001 void RuntimeDyldELF::processX86_64TLSRelocation(
2002  unsigned SectionID, uint64_t Offset, uint64_t RelType,
2003  RelocationValueRef Value, int64_t Addend,
2004  const RelocationRef &GetAddrRelocation) {
2005  // Since we are statically linking and have no additional DSOs, we can resolve
2006  // the relocation directly without using __tls_get_addr.
2007  // Use the approach from "x86-64 Linker Optimizations" from the TLS spec
2008  // to replace it with the Local Exec relocation variant.
2009 
2010  // Find out whether the code was compiled with the large or small memory
2011  // model. For this we look at the next relocation which is the relocation
2012  // for the __tls_get_addr function. If it's a 32 bit relocation, it's the
2013  // small code model, with a 64 bit relocation it's the large code model.
2014  bool IsSmallCodeModel;
2015  // Is the relocation for the __tls_get_addr a PC-relative GOT relocation?
2016  bool IsGOTPCRel = false;
2017 
2018  switch (GetAddrRelocation.getType()) {
2019  case ELF::R_X86_64_GOTPCREL:
2020  case ELF::R_X86_64_REX_GOTPCRELX:
2021  case ELF::R_X86_64_GOTPCRELX:
2022  IsGOTPCRel = true;
2024  case ELF::R_X86_64_PLT32:
2025  IsSmallCodeModel = true;
2026  break;
2027  case ELF::R_X86_64_PLTOFF64:
2028  IsSmallCodeModel = false;
2029  break;
2030  default:
2032  "invalid TLS relocations for General/Local Dynamic TLS Model: "
2033  "expected PLT or GOT relocation for __tls_get_addr function");
2034  }
2035 
2036  // The negative offset to the start of the TLS code sequence relative to
2037  // the offset of the TLSGD/TLSLD relocation
2038  uint64_t TLSSequenceOffset;
2039  // The expected start of the code sequence
2040  ArrayRef<uint8_t> ExpectedCodeSequence;
2041  // The new TLS code sequence that will replace the existing code
2042  ArrayRef<uint8_t> NewCodeSequence;
2043 
2044  if (RelType == ELF::R_X86_64_TLSGD) {
2045  // The offset of the new TPOFF32 relocation (offset starting from the
2046  // beginning of the whole TLS sequence)
2047  uint64_t TpoffRelocOffset;
2048 
2049  if (IsSmallCodeModel) {
2050  if (!IsGOTPCRel) {
2051  static const std::initializer_list<uint8_t> CodeSequence = {
2052  0x66, // data16 (no-op prefix)
2053  0x48, 0x8d, 0x3d, 0x00, 0x00,
2054  0x00, 0x00, // lea <disp32>(%rip), %rdi
2055  0x66, 0x66, // two data16 prefixes
2056  0x48, // rex64 (no-op prefix)
2057  0xe8, 0x00, 0x00, 0x00, 0x00 // call __tls_get_addr@plt
2058  };
2059  ExpectedCodeSequence = ArrayRef<uint8_t>(CodeSequence);
2060  TLSSequenceOffset = 4;
2061  } else {
2062  // This code sequence is not described in the TLS spec but gcc
2063  // generates it sometimes.
2064  static const std::initializer_list<uint8_t> CodeSequence = {
2065  0x66, // data16 (no-op prefix)
2066  0x48, 0x8d, 0x3d, 0x00, 0x00,
2067  0x00, 0x00, // lea <disp32>(%rip), %rdi
2068  0x66, // data16 prefix (no-op prefix)
2069  0x48, // rex64 (no-op prefix)
2070  0xff, 0x15, 0x00, 0x00, 0x00,
2071  0x00 // call *__tls_get_addr@gotpcrel(%rip)
2072  };
2073  ExpectedCodeSequence = ArrayRef<uint8_t>(CodeSequence);
2074  TLSSequenceOffset = 4;
2075  }
2076 
2077  // The replacement code for the small code model. It's the same for
2078  // both sequences.
2079  static const std::initializer_list<uint8_t> SmallSequence = {
2080  0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00,
2081  0x00, // mov %fs:0, %rax
2082  0x48, 0x8d, 0x80, 0x00, 0x00, 0x00, 0x00 // lea x@tpoff(%rax),
2083  // %rax
2084  };
2085  NewCodeSequence = ArrayRef<uint8_t>(SmallSequence);
2086  TpoffRelocOffset = 12;
2087  } else {
2088  static const std::initializer_list<uint8_t> CodeSequence = {
2089  0x48, 0x8d, 0x3d, 0x00, 0x00, 0x00, 0x00, // lea <disp32>(%rip),
2090  // %rdi
2091  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2092  0x00, // movabs $__tls_get_addr@pltoff, %rax
2093  0x48, 0x01, 0xd8, // add %rbx, %rax
2094  0xff, 0xd0 // call *%rax
2095  };
2096  ExpectedCodeSequence = ArrayRef<uint8_t>(CodeSequence);
2097  TLSSequenceOffset = 3;
2098 
2099  // The replacement code for the large code model
2100  static const std::initializer_list<uint8_t> LargeSequence = {
2101  0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00,
2102  0x00, // mov %fs:0, %rax
2103  0x48, 0x8d, 0x80, 0x00, 0x00, 0x00, 0x00, // lea x@tpoff(%rax),
2104  // %rax
2105  0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00 // nopw 0x0(%rax,%rax,1)
2106  };
2107  NewCodeSequence = ArrayRef<uint8_t>(LargeSequence);
2108  TpoffRelocOffset = 12;
2109  }
2110 
2111  // The TLSGD/TLSLD relocations are PC-relative, so they have an addend.
2112  // The new TPOFF32 relocations is used as an absolute offset from
2113  // %fs:0, so remove the TLSGD/TLSLD addend again.
2114  RelocationEntry RE(SectionID, Offset - TLSSequenceOffset + TpoffRelocOffset,
2115  ELF::R_X86_64_TPOFF32, Value.Addend - Addend);
2116  if (Value.SymbolName)
2117  addRelocationForSymbol(RE, Value.SymbolName);
2118  else
2119  addRelocationForSection(RE, Value.SectionID);
2120  } else if (RelType == ELF::R_X86_64_TLSLD) {
2121  if (IsSmallCodeModel) {
2122  if (!IsGOTPCRel) {
2123  static const std::initializer_list<uint8_t> CodeSequence = {
2124  0x48, 0x8d, 0x3d, 0x00, 0x00, 0x00, // leaq <disp32>(%rip), %rdi
2125  0x00, 0xe8, 0x00, 0x00, 0x00, 0x00 // call __tls_get_addr@plt
2126  };
2127  ExpectedCodeSequence = ArrayRef<uint8_t>(CodeSequence);
2128  TLSSequenceOffset = 3;
2129 
2130  // The replacement code for the small code model
2131  static const std::initializer_list<uint8_t> SmallSequence = {
2132  0x66, 0x66, 0x66, // three data16 prefixes (no-op)
2133  0x64, 0x48, 0x8b, 0x04, 0x25,
2134  0x00, 0x00, 0x00, 0x00 // mov %fs:0, %rax
2135  };
2136  NewCodeSequence = ArrayRef<uint8_t>(SmallSequence);
2137  } else {
2138  // This code sequence is not described in the TLS spec but gcc
2139  // generates it sometimes.
2140  static const std::initializer_list<uint8_t> CodeSequence = {
2141  0x48, 0x8d, 0x3d, 0x00,
2142  0x00, 0x00, 0x00, // leaq <disp32>(%rip), %rdi
2143  0xff, 0x15, 0x00, 0x00,
2144  0x00, 0x00 // call
2145  // *__tls_get_addr@gotpcrel(%rip)
2146  };
2147  ExpectedCodeSequence = ArrayRef<uint8_t>(CodeSequence);
2148  TLSSequenceOffset = 3;
2149 
2150  // The replacement is code is just like above but it needs to be
2151  // one byte longer.
2152  static const std::initializer_list<uint8_t> SmallSequence = {
2153  0x0f, 0x1f, 0x40, 0x00, // 4 byte nop
2154  0x64, 0x48, 0x8b, 0x04, 0x25,
2155  0x00, 0x00, 0x00, 0x00 // mov %fs:0, %rax
2156  };
2157  NewCodeSequence = ArrayRef<uint8_t>(SmallSequence);
2158  }
2159  } else {
2160  // This is the same sequence as for the TLSGD sequence with the large
2161  // memory model above
2162  static const std::initializer_list<uint8_t> CodeSequence = {
2163  0x48, 0x8d, 0x3d, 0x00, 0x00, 0x00, 0x00, // lea <disp32>(%rip),
2164  // %rdi
2165  0x48, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2166  0x48, // movabs $__tls_get_addr@pltoff, %rax
2167  0x01, 0xd8, // add %rbx, %rax
2168  0xff, 0xd0 // call *%rax
2169  };
2170  ExpectedCodeSequence = ArrayRef<uint8_t>(CodeSequence);
2171  TLSSequenceOffset = 3;
2172 
2173  // The replacement code for the large code model
2174  static const std::initializer_list<uint8_t> LargeSequence = {
2175  0x66, 0x66, 0x66, // three data16 prefixes (no-op)
2176  0x66, 0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00,
2177  0x00, // 10 byte nop
2178  0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00 // mov %fs:0,%rax
2179  };
2180  NewCodeSequence = ArrayRef<uint8_t>(LargeSequence);
2181  }
2182  } else {
2183  llvm_unreachable("both TLS relocations handled above");
2184  }
2185 
2186  assert(ExpectedCodeSequence.size() == NewCodeSequence.size() &&
2187  "Old and new code sequences must have the same size");
2188 
2189  auto &Section = Sections[SectionID];
2190  if (Offset < TLSSequenceOffset ||
2191  (Offset - TLSSequenceOffset + NewCodeSequence.size()) >
2192  Section.getSize()) {
2193  report_fatal_error("unexpected end of section in TLS sequence");
2194  }
2195 
2196  auto *TLSSequence = Section.getAddressWithOffset(Offset - TLSSequenceOffset);
2197  if (ArrayRef<uint8_t>(TLSSequence, ExpectedCodeSequence.size()) !=
2198  ExpectedCodeSequence) {
2200  "invalid TLS sequence for Global/Local Dynamic TLS Model");
2201  }
2202 
2203  memcpy(TLSSequence, NewCodeSequence.data(), NewCodeSequence.size());
2204 }
2205 
2207  // We don't use the GOT in all of these cases, but it's essentially free
2208  // to put them all here.
2209  size_t Result = 0;
2210  switch (Arch) {
2211  case Triple::x86_64:
2212  case Triple::aarch64:
2213  case Triple::aarch64_be:
2214  case Triple::ppc64:
2215  case Triple::ppc64le:
2216  case Triple::systemz:
2217  Result = sizeof(uint64_t);
2218  break;
2219  case Triple::x86:
2220  case Triple::arm:
2221  case Triple::thumb:
2222  Result = sizeof(uint32_t);
2223  break;
2224  case Triple::mips:
2225  case Triple::mipsel:
2226  case Triple::mips64:
2227  case Triple::mips64el:
2228  if (IsMipsO32ABI || IsMipsN32ABI)
2229  Result = sizeof(uint32_t);
2230  else if (IsMipsN64ABI)
2231  Result = sizeof(uint64_t);
2232  else
2233  llvm_unreachable("Mips ABI not handled");
2234  break;
2235  default:
2236  llvm_unreachable("Unsupported CPU type!");
2237  }
2238  return Result;
2239 }
2240 
2241 uint64_t RuntimeDyldELF::allocateGOTEntries(unsigned no) {
2242  if (GOTSectionID == 0) {
2243  GOTSectionID = Sections.size();
2244  // Reserve a section id. We'll allocate the section later
2245  // once we know the total size
2246  Sections.push_back(SectionEntry(".got", nullptr, 0, 0, 0));
2247  }
2248  uint64_t StartOffset = CurrentGOTIndex * getGOTEntrySize();
2249  CurrentGOTIndex += no;
2250  return StartOffset;
2251 }
2252 
2253 uint64_t RuntimeDyldELF::findOrAllocGOTEntry(const RelocationValueRef &Value,
2254  unsigned GOTRelType) {
2255  auto E = GOTOffsetMap.insert({Value, 0});
2256  if (E.second) {
2257  uint64_t GOTOffset = allocateGOTEntries(1);
2258 
2259  // Create relocation for newly created GOT entry
2260  RelocationEntry RE =
2261  computeGOTOffsetRE(GOTOffset, Value.Offset, GOTRelType);
2262  if (Value.SymbolName)
2263  addRelocationForSymbol(RE, Value.SymbolName);
2264  else
2265  addRelocationForSection(RE, Value.SectionID);
2266 
2267  E.first->second = GOTOffset;
2268  }
2269 
2270  return E.first->second;
2271 }
2272 
2273 void RuntimeDyldELF::resolveGOTOffsetRelocation(unsigned SectionID,
2274  uint64_t Offset,
2275  uint64_t GOTOffset,
2276  uint32_t Type) {
2277  // Fill in the relative address of the GOT Entry into the stub
2278  RelocationEntry GOTRE(SectionID, Offset, Type, GOTOffset);
2279  addRelocationForSection(GOTRE, GOTSectionID);
2280 }
2281 
2282 RelocationEntry RuntimeDyldELF::computeGOTOffsetRE(uint64_t GOTOffset,
2283  uint64_t SymbolOffset,
2284  uint32_t Type) {
2285  return RelocationEntry(GOTSectionID, GOTOffset, Type, SymbolOffset);
2286 }
2287 
2289  ObjSectionToIDMap &SectionMap) {
2290  if (IsMipsO32ABI)
2291  if (!PendingRelocs.empty())
2292  return make_error<RuntimeDyldError>("Can't find matching LO16 reloc");
2293 
2294  // If necessary, allocate the global offset table
2295  if (GOTSectionID != 0) {
2296  // Allocate memory for the section
2297  size_t TotalSize = CurrentGOTIndex * getGOTEntrySize();
2298  uint8_t *Addr = MemMgr.allocateDataSection(TotalSize, getGOTEntrySize(),
2299  GOTSectionID, ".got", false);
2300  if (!Addr)
2301  return make_error<RuntimeDyldError>("Unable to allocate memory for GOT!");
2302 
2303  Sections[GOTSectionID] =
2304  SectionEntry(".got", Addr, TotalSize, TotalSize, 0);
2305 
2306  // For now, initialize all GOT entries to zero. We'll fill them in as
2307  // needed when GOT-based relocations are applied.
2308  memset(Addr, 0, TotalSize);
2309  if (IsMipsN32ABI || IsMipsN64ABI) {
2310  // To correctly resolve Mips GOT relocations, we need a mapping from
2311  // object's sections to GOTs.
2312  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
2313  SI != SE; ++SI) {
2314  if (SI->relocation_begin() != SI->relocation_end()) {
2315  Expected<section_iterator> RelSecOrErr = SI->getRelocatedSection();
2316  if (!RelSecOrErr)
2317  return make_error<RuntimeDyldError>(
2318  toString(RelSecOrErr.takeError()));
2319 
2320  section_iterator RelocatedSection = *RelSecOrErr;
2321  ObjSectionToIDMap::iterator i = SectionMap.find(*RelocatedSection);
2322  assert (i != SectionMap.end());
2323  SectionToGOTMap[i->second] = GOTSectionID;
2324  }
2325  }
2326  GOTSymbolOffsets.clear();
2327  }
2328  }
2329 
2330  // Look for and record the EH frame section.
2331  ObjSectionToIDMap::iterator i, e;
2332  for (i = SectionMap.begin(), e = SectionMap.end(); i != e; ++i) {
2333  const SectionRef &Section = i->first;
2334 
2335  StringRef Name;
2336  Expected<StringRef> NameOrErr = Section.getName();
2337  if (NameOrErr)
2338  Name = *NameOrErr;
2339  else
2340  consumeError(NameOrErr.takeError());
2341 
2342  if (Name == ".eh_frame") {
2343  UnregisteredEHFrameSections.push_back(i->second);
2344  break;
2345  }
2346  }
2347 
2348  GOTSectionID = 0;
2349  CurrentGOTIndex = 0;
2350 
2351  return Error::success();
2352 }
2353 
2355  return Obj.isELF();
2356 }
2357 
2358 bool RuntimeDyldELF::relocationNeedsGot(const RelocationRef &R) const {
2359  unsigned RelTy = R.getType();
2361  return RelTy == ELF::R_AARCH64_ADR_GOT_PAGE ||
2362  RelTy == ELF::R_AARCH64_LD64_GOT_LO12_NC;
2363 
2364  if (Arch == Triple::x86_64)
2365  return RelTy == ELF::R_X86_64_GOTPCREL ||
2366  RelTy == ELF::R_X86_64_GOTPCRELX ||
2367  RelTy == ELF::R_X86_64_GOT64 ||
2368  RelTy == ELF::R_X86_64_REX_GOTPCRELX;
2369  return false;
2370 }
2371 
2372 bool RuntimeDyldELF::relocationNeedsStub(const RelocationRef &R) const {
2373  if (Arch != Triple::x86_64)
2374  return true; // Conservative answer
2375 
2376  switch (R.getType()) {
2377  default:
2378  return true; // Conservative answer
2379 
2380 
2381  case ELF::R_X86_64_GOTPCREL:
2382  case ELF::R_X86_64_GOTPCRELX:
2383  case ELF::R_X86_64_REX_GOTPCRELX:
2384  case ELF::R_X86_64_GOTPC64:
2385  case ELF::R_X86_64_GOT64:
2386  case ELF::R_X86_64_GOTOFF64:
2387  case ELF::R_X86_64_PC32:
2388  case ELF::R_X86_64_PC64:
2389  case ELF::R_X86_64_64:
2390  // We know that these reloation types won't need a stub function. This list
2391  // can be extended as needed.
2392  return false;
2393  }
2394 }
2395 
2396 } // namespace llvm
i
i
Definition: README.txt:29
MemoryBuffer.h
llvm::RuntimeDyldImpl::writeInt64BE
void writeInt64BE(uint8_t *Addr, uint64_t Value)
Definition: RuntimeDyldImpl.h:330
llvm::applyPPChighesta
static uint16_t applyPPChighesta(uint64_t value)
Definition: RuntimeDyldELF.cpp:800
llvm::cast
std::enable_if_t<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type > cast(const Y &Val)
Definition: Casting.h:254
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:22
llvm::object::ObjectFile::getBytesInAddress
virtual uint8_t getBytesInAddress() const =0
The number of bytes used to represent an address in this object file format.
llvm::ELF::EF_MIPS_ABI2
@ EF_MIPS_ABI2
Definition: ELF.h:508
llvm::RuntimeDyldImpl::MemMgr
RuntimeDyld::MemoryManager & MemMgr
Definition: RuntimeDyldImpl.h:244
llvm::Triple::bpfeb
@ bpfeb
Definition: Triple.h:57
llvm::Triple::UnknownArch
@ UnknownArch
Definition: Triple.h:47
intptr_t
llvm::RuntimeDyldELF::registerEHFrames
void registerEHFrames() override
Definition: RuntimeDyldELF.cpp:221
llvm::support::detail::packed_endian_specific_integral::ref
Definition: Endian.h:251
T
llvm::RuntimeDyldELF::isCompatibleFile
bool isCompatibleFile(const object::ObjectFile &Obj) const override
Definition: RuntimeDyldELF.cpp:2354
llvm::applyPPCha
static uint16_t applyPPCha(uint64_t value)
Definition: RuntimeDyldELF.cpp:784
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::Triple::x86
@ x86
Definition: Triple.h:82
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:632
llvm::write
Error write(MCStreamer &Out, ArrayRef< std::string > Inputs)
Definition: DWP.cpp:535
llvm::object::Binary::isLittleEndian
bool isLittleEndian() const
Definition: Binary.h:148
llvm::RuntimeDyldImpl::ErrorStr
std::string ErrorStr
Definition: RuntimeDyldImpl.h:318
llvm::Target
Target - Wrapper for Target specific information.
Definition: TargetRegistry.h:137
llvm::toString
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:1028
llvm::RuntimeDyldImpl::Sections
SectionList Sections
Definition: RuntimeDyldImpl.h:254
Wrapper
amdgpu aa AMDGPU Address space based Alias Analysis Wrapper
Definition: AMDGPUAliasAnalysis.cpp:31
llvm::LoadedObjectInfoHelper
Definition: DIContext.h:296
llvm::support::endian::write32le
void write32le(void *P, uint32_t V)
Definition: Endian.h:416
llvm::isa
LLVM_NODISCARD bool isa(const Y &Val)
Definition: Casting.h:141
llvm::object::SectionRef::getRawDataRefImpl
DataRefImpl getRawDataRefImpl() const
Definition: ObjectFile.h:525
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:329
llvm::object::SectionRef::getName
Expected< StringRef > getName() const
Definition: ObjectFile.h:445
llvm::StringMap::end
iterator end()
Definition: StringMap.h:204
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::Triple::x86_64
@ x86_64
Definition: Triple.h:83
llvm::RuntimeDyldImpl::addRelocationForSection
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
Definition: RuntimeDyld.cpp:952
llvm::Triple::ppc
@ ppc
Definition: Triple.h:66
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:80
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::RuntimeDyldImpl
Definition: RuntimeDyldImpl.h:238
STLExtras.h
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:217
llvm::object::ObjectFile::section_begin
virtual section_iterator section_begin() const =0
llvm::RuntimeDyldImpl::addRelocationForSymbol
void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName)
Definition: RuntimeDyld.cpp:957
llvm::BitmaskEnumDetail::Mask
std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
llvm::RuntimeDyldImpl::IsMipsO32ABI
bool IsMipsO32ABI
Definition: RuntimeDyldImpl.h:290
llvm::Triple::mips64
@ mips64
Definition: Triple.h:63
llvm::consumeError
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:1043
llvm::MemoryBufferRef
Definition: MemoryBufferRef.h:22
llvm::RelocationEntry::SymOffset
uint64_t SymOffset
Definition: RuntimeDyldImpl.h:140
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::ArrayRef::data
const T * data() const
Definition: ArrayRef.h:160
uint
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint
Definition: README.txt:239
llvm::applyPPChi
static uint16_t applyPPChi(uint64_t value)
Definition: RuntimeDyldELF.cpp:780
llvm::RelocationEntry::SectionID
unsigned SectionID
SectionID - the section this relocation points to.
Definition: RuntimeDyldImpl.h:120
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::object::ELFObjectFileBase
Definition: ELFObjectFile.h:50
llvm::ARMBuildAttrs::Section
@ Section
Legacy Tags.
Definition: ARMBuildAttributes.h:82
llvm::Resolver
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:2012
llvm::applyPPChighest
static uint16_t applyPPChighest(uint64_t value)
Definition: RuntimeDyldELF.cpp:796
llvm::support::endian
Definition: Endian.h:42
llvm::object::RelocationRef::getType
uint64_t getType() const
Definition: ObjectFile.h:555
llvm::object::SymbolicFile::symbol_end
virtual basic_symbol_iterator symbol_end() const =0
llvm::RuntimeDyldELF::finalizeLoad
Error finalizeLoad(const ObjectFile &Obj, ObjSectionToIDMap &SectionMap) override
Definition: RuntimeDyldELF.cpp:2288
llvm::RelocationEntry::Offset
uint64_t Offset
Offset - offset into the section.
Definition: RuntimeDyldImpl.h:123
llvm::object::ELFObjectFileBase::getPlatformFlags
virtual unsigned getPlatformFlags() const =0
Returns platform-specific object flags, if any.
llvm::object::ELFRelocationRef
Definition: ELFObjectFile.h:196
llvm::object
Definition: ObjectFileTransformer.h:18
llvm::RuntimeDyldImpl::HasError
bool HasError
Definition: RuntimeDyldImpl.h:317
ELF.h
llvm::Triple::ArchType
ArchType
Definition: Triple.h:46
llvm::RuntimeDyldImpl::SID
unsigned SID
Definition: RuntimeDyldImpl.h:256
llvm::applyPPChighera
static uint16_t applyPPChighera(uint64_t value)
Definition: RuntimeDyldELF.cpp:792
llvm::object::ObjectFile::section_end
virtual section_iterator section_end() const =0
llvm::RuntimeDyldImpl::IsMipsN64ABI
bool IsMipsN64ABI
Definition: RuntimeDyldImpl.h:292
llvm::object::BasicSymbolRef::getRawDataRefImpl
DataRefImpl getRawDataRefImpl() const
Definition: SymbolicFile.h:206
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
getBits
static uint64_t getBits(uint64_t Val, int Start, int End)
Definition: RuntimeDyldELF.cpp:50
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::Triple::mips64el
@ mips64el
Definition: Triple.h:64
llvm::StringMapConstIterator
Definition: StringMap.h:25
llvm::object::ObjectFile::getFileFormatName
virtual StringRef getFileFormatName() const =0
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::Triple::ppc64
@ ppc64
Definition: Triple.h:68
llvm::StringMap::clear
void clear()
Definition: StringMap.h:347
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
llvm::object::DataRefImpl::p
uintptr_t p
Definition: SymbolicFile.h:39
llvm::RuntimeDyld::MemoryManager::registerEHFrames
virtual void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size)=0
Register the EH frames with the runtime so that c++ exceptions work.
llvm::StringRef::equals
LLVM_NODISCARD bool equals(StringRef RHS) const
equals - Check for string equality, this is more efficient than compare() when the relative ordering ...
Definition: StringRef.h:187
llvm::RuntimeDyldImpl::writeInt32BE
void writeInt32BE(uint8_t *Addr, uint32_t Value)
Definition: RuntimeDyldImpl.h:325
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:109
llvm::RelocationEntry::Addend
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
Definition: RuntimeDyldImpl.h:130
llvm::object::SectionRef
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:79
llvm::RelocationEntry
RelocationEntry - used to represent relocations internally in the dynamic linker.
Definition: RuntimeDyldImpl.h:117
llvm::isInt< 8 >
constexpr bool isInt< 8 >(int64_t x)
Definition: MathExtras.h:367
llvm::Triple::ppc64le
@ ppc64le
Definition: Triple.h:69
RuntimeDyldELFMips.h
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:207
llvm::object::SymbolRef::getSection
Expected< section_iterator > getSection() const
Get section this symbol is defined in reference to.
Definition: ObjectFile.h:408
llvm::isInt< 32 >
constexpr bool isInt< 32 >(int64_t x)
Definition: MathExtras.h:373
uint64_t
llvm::object::symbol_iterator
Definition: ObjectFile.h:206
llvm::RuntimeDyldELF::RuntimeDyldELF
RuntimeDyldELF(RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Definition: RuntimeDyldELF.cpp:216
Addr
uint64_t Addr
Definition: ELFObjHandler.cpp:79
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::RuntimeDyldImpl::loadObjectImpl
Expected< ObjSectionToIDMap > loadObjectImpl(const object::ObjectFile &Obj)
Definition: RuntimeDyld.cpp:184
llvm::or32le
static void or32le(void *P, int32_t V)
Definition: RuntimeDyldCOFFAArch64.h:35
or32AArch64Imm
static void or32AArch64Imm(void *L, uint64_t Imm)
Definition: RuntimeDyldELF.cpp:33
llvm::RuntimeDyldImpl::IsTargetLittleEndian
bool IsTargetLittleEndian
Definition: RuntimeDyldImpl.h:289
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::SectionEntry
SectionEntry - represents a section emitted into memory by the dynamic linker.
Definition: RuntimeDyldImpl.h:45
llvm::HighlightColor::Address
@ Address
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
RuntimeDyldELF.h
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1650
ObjectFile.h
memcpy
<%struct.s * > cast struct s *S to sbyte *< sbyte * > sbyte uint cast struct s *agg result to sbyte *< sbyte * > sbyte uint cast struct s *memtmp to sbyte *< sbyte * > sbyte uint ret void llc ends up issuing two memcpy or custom lower memcpy(of small size) to be ldmia/stmia. I think option 2 is better but the current register allocator cannot allocate a chunk of registers at a time. A feasible temporary solution is to use specific physical registers at the lowering time for small(<
SI
StandardInstrumentations SI(Debug, VerifyEach)
llvm::object::Binary::isELF
bool isELF() const
Definition: Binary.h:120
llvm::object::content_iterator
Definition: SymbolicFile.h:67
llvm::Triple::bpfel
@ bpfel
Definition: Triple.h:56
llvm::ELF::decodePPC64LocalEntryOffset
static int64_t decodePPC64LocalEntryOffset(unsigned Other)
Definition: ELF.h:409
llvm::RuntimeDyldImpl::IsMipsN32ABI
bool IsMipsN32ABI
Definition: RuntimeDyldImpl.h:291
llvm::Triple::armeb
@ armeb
Definition: Triple.h:50
llvm::object::elf_relocation_iterator
Definition: ELFObjectFile.h:211
Triple.h
llvm::ArrayRef< uint8_t >
llvm::Triple::arm
@ arm
Definition: Triple.h:49
llvm::ELF::EF_PPC64_ABI
@ EF_PPC64_ABI
Definition: ELF.h:401
llvm::Triple::aarch64_be
@ aarch64_be
Definition: Triple.h:52
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::object::ObjectFile
This class is the base class for all object file types.
Definition: ObjectFile.h:227
llvm::object::Binary
Definition: Binary.h:32
llvm::Triple::ppcle
@ ppcle
Definition: Triple.h:67
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
uint32_t
llvm::Triple::thumb
@ thumb
Definition: Triple.h:80
RuntimeDyldCheckerImpl.h
llvm::object::DataRefImpl
Definition: SymbolicFile.h:33
llvm::format
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
LLVM_FALLTHROUGH
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:287
ELFObjectFile.h
llvm::RelocationValueRef::SectionID
unsigned SectionID
Definition: RuntimeDyldImpl.h:192
LLVM_ELF_IMPORT_TYPES_ELFT
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
Definition: ELFTypes.h:104
llvm::RuntimeDyldImpl::createStubFunction
uint8_t * createStubFunction(uint8_t *Addr, unsigned AbiVariant=0)
Emits long jump instruction to Addr.
Definition: RuntimeDyld.cpp:976
llvm::logAllUnhandledErrors
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner={})
Log all errors (if any) in E to OS.
Definition: Error.cpp:61
llvm::RuntimeDyldELF::getGOTEntrySize
size_t getGOTEntrySize() override
Definition: RuntimeDyldELF.cpp:2206
llvm::isInt< 16 >
constexpr bool isInt< 16 >(int64_t x)
Definition: MathExtras.h:370
llvm::JITSymbolResolver
Symbol resolution interface.
Definition: JITSymbol.h:371
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
std
Definition: BitVector.h:850
llvm::object::SymbolRef::Type
Type
Definition: ObjectFile.h:170
llvm::RuntimeDyldELF::create
static std::unique_ptr< RuntimeDyldELF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Definition: RuntimeDyldELF.cpp:233
llvm::RuntimeDyldImpl::findOrEmitSection
Expected< unsigned > findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
Definition: RuntimeDyld.cpp:933
uint16_t
llvm::object::OwningBinary
Definition: RuntimeDyld.h:36
llvm::SectionName
Definition: DWARFSection.h:21
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:155
llvm::applyPPClo
static uint16_t applyPPClo(uint64_t value)
Definition: RuntimeDyldELF.cpp:778
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::Triple::mipsel
@ mipsel
Definition: Triple.h:62
llvm::Triple::getArchTypePrefix
static StringRef getArchTypePrefix(ArchType Kind)
Get the "prefix" canonical name for the Kind architecture.
Definition: Triple.cpp:88
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:580
llvm::Triple::systemz
@ systemz
Definition: Triple.h:77
llvm::ARMBuildAttrs::Symbol
@ Symbol
Definition: ARMBuildAttributes.h:83
llvm::RuntimeDyldImpl::Arch
Triple::ArchType Arch
Definition: RuntimeDyldImpl.h:288
llvm::Expected::takeError
Error takeError()
Take ownership of the stored error.
Definition: Error.h:597
llvm::RuntimeDyldELF::SectionToGOTMap
DenseMap< SID, SID > SectionToGOTMap
Definition: RuntimeDyldELF.h:143
llvm::object::Binary::getFileName
StringRef getFileName() const
Definition: Binary.cpp:42
llvm::support::endian::read32le
uint32_t read32le(const void *P)
Definition: Endian.h:381
llvm::Triple::thumbeb
@ thumbeb
Definition: Triple.h:81
llvm::RelocationValueRef::SymbolName
const char * SymbolName
Definition: RuntimeDyldImpl.h:195
llvm::RuntimeDyld::MemoryManager::allowStubAllocation
virtual bool allowStubAllocation() const
Override to return false to tell LLVM no stub space will be needed.
Definition: RuntimeDyld.h:149
llvm::ArrayRef::size
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:163
llvm::RuntimeDyldELF::loadObject
std::unique_ptr< RuntimeDyld::LoadedObjectInfo > loadObject(const object::ObjectFile &O) override
Definition: RuntimeDyldELF.cpp:248
llvm::object::ObjectFile::sections
section_iterator_range sections() const
Definition: ObjectFile.h:321
SymInfo
SymInfo contains information about symbol: it's address and section index which is -1LL for absolute ...
Definition: DWARFContext.cpp:1457
llvm::object::elf_symbol_iterator
Definition: ELFObjectFile.h:181
llvm::RuntimeDyldImpl::readBytesUnaligned
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
Definition: RuntimeDyld.cpp:711
llvm::StringRef::data
const LLVM_NODISCARD char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:149
llvm::object::SymbolRef
This is a value type class that represents a single symbol in the list of symbols in the object file.
Definition: ObjectFile.h:166
llvm::object::Binary::getData
StringRef getData() const
Definition: Binary.cpp:40
llvm::RuntimeDyldImpl::StubMap
std::map< RelocationValueRef, uintptr_t > StubMap
Definition: RuntimeDyldImpl.h:286
llvm::object::ELFObjectFile::isDyldType
bool isDyldType() const
Definition: ELFObjectFile.h:444
llvm::applyPPChigher
static uint16_t applyPPChigher(uint64_t value)
Definition: RuntimeDyldELF.cpp:788
llvm::orc::SymbolState::Resolved
@ Resolved
Queried, materialization begun.
llvm::object::RelocationRef
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:50
llvm::ELF::EF_MIPS_ABI_O32
@ EF_MIPS_ABI_O32
Definition: ELF.h:516
llvm::object::ELFRelocationRef::getAddend
Expected< int64_t > getAddend() const
Definition: ELFObjectFile.h:206
llvm::RuntimeDyld::MemoryManager::allocateDataSection
virtual uint8_t * allocateDataSection(uintptr_t Size, unsigned Alignment, unsigned SectionID, StringRef SectionName, bool IsReadOnly)=0
Allocate a memory block of (at least) the given size suitable for data.
llvm::RuntimeDyldELF::~RuntimeDyldELF
~RuntimeDyldELF() override
Definition: RuntimeDyldELF.cpp:219
llvm::write32AArch64Addr
static void write32AArch64Addr(void *T, uint64_t s, uint64_t p, int shift)
Definition: RuntimeDyldCOFFAArch64.h:55
Endian.h
llvm::RelocationValueRef
Definition: RuntimeDyldImpl.h:190
llvm::object::ELFObjectFile
Definition: ELFObjectFile.h:233
llvm::raw_string_ostream::str
std::string & str()
Returns the string's reference.
Definition: raw_ostream.h:650
llvm::RelocationValueRef::Addend
int64_t Addend
Definition: RuntimeDyldImpl.h:194
llvm::handleAllErrors
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:966
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::Triple::mips
@ mips
Definition: Triple.h:61
llvm::RelocationEntry::RelType
uint32_t RelType
RelType - relocation type.
Definition: RuntimeDyldImpl.h:126
llvm::RuntimeDyldImpl::writeInt16BE
void writeInt16BE(uint8_t *Addr, uint16_t Value)
Definition: RuntimeDyldImpl.h:320
llvm::Triple::aarch64
@ aarch64
Definition: Triple.h:51
llvm::RuntimeDyldImpl::GlobalSymbolTable
RTDyldSymbolTable GlobalSymbolTable
Definition: RuntimeDyldImpl.h:264
llvm::RuntimeDyldELF::processRelocationRef
Expected< relocation_iterator > processRelocationRef(unsigned SectionID, relocation_iterator RelI, const ObjectFile &Obj, ObjSectionToIDMap &ObjSectionToID, StubMap &Stubs) override
Parses one or more object file relocations (some object files use relocation pairs) and stores it to ...
Definition: RuntimeDyldELF.cpp:1206
llvm::RuntimeDyldImpl::ObjSectionToIDMap
std::map< SectionRef, unsigned > ObjSectionToIDMap
Definition: RuntimeDyldImpl.h:261
Shdr
Elf_Shdr Shdr
Definition: ELFObjHandler.cpp:78
llvm::RuntimeDyld::MemoryManager
Memory Management.
Definition: RuntimeDyld.h:92