LLVM  3.7.0
RuntimeDyld.cpp
Go to the documentation of this file.
1 //===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Implementation of the MC-JIT runtime dynamic linker.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "RuntimeDyldCheckerImpl.h"
16 #include "RuntimeDyldCOFF.h"
17 #include "RuntimeDyldELF.h"
18 #include "RuntimeDyldImpl.h"
19 #include "RuntimeDyldMachO.h"
21 #include "llvm/Object/COFF.h"
24 
25 using namespace llvm;
26 using namespace llvm::object;
27 
28 #define DEBUG_TYPE "dyld"
29 
30 // Empty out-of-line virtual destructor as the key function.
32 
33 // Pin LoadedObjectInfo's vtables to this file.
35 
36 namespace llvm {
37 
39 
41 
42 #ifndef NDEBUG
43 static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
44  dbgs() << "----- Contents of section " << S.Name << " " << State << " -----";
45 
46  if (S.Address == nullptr) {
47  dbgs() << "\n <section not emitted>\n";
48  return;
49  }
50 
51  const unsigned ColsPerRow = 16;
52 
53  uint8_t *DataAddr = S.Address;
54  uint64_t LoadAddr = S.LoadAddress;
55 
56  unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
57  unsigned BytesRemaining = S.Size;
58 
59  if (StartPadding) {
60  dbgs() << "\n" << format("0x%016" PRIx64,
61  LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
62  while (StartPadding--)
63  dbgs() << " ";
64  }
65 
66  while (BytesRemaining > 0) {
67  if ((LoadAddr & (ColsPerRow - 1)) == 0)
68  dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":";
69 
70  dbgs() << " " << format("%02x", *DataAddr);
71 
72  ++DataAddr;
73  ++LoadAddr;
74  --BytesRemaining;
75  }
76 
77  dbgs() << "\n";
78 }
79 #endif
80 
81 // Resolve the relocations for all symbols we currently know about.
83  MutexGuard locked(lock);
84 
85  // First, resolve relocations associated with external symbols.
86  resolveExternalSymbols();
87 
88  // Just iterate over the sections we have and resolve all the relocations
89  // in them. Gross overkill, but it gets the job done.
90  for (int i = 0, e = Sections.size(); i != e; ++i) {
91  // The Section here (Sections[i]) refers to the section in which the
92  // symbol for the relocation is located. The SectionID in the relocation
93  // entry provides the section to which the relocation will be applied.
94  uint64_t Addr = Sections[i].LoadAddress;
95  DEBUG(dbgs() << "Resolving relocations Section #" << i << "\t"
96  << format("%p", (uintptr_t)Addr) << "\n");
97  DEBUG(dumpSectionMemory(Sections[i], "before relocations"));
98  resolveRelocationList(Relocations[i], Addr);
99  DEBUG(dumpSectionMemory(Sections[i], "after relocations"));
100  Relocations.erase(i);
101  }
102 }
103 
104 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
105  uint64_t TargetAddress) {
106  MutexGuard locked(lock);
107  for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
108  if (Sections[i].Address == LocalAddress) {
109  reassignSectionAddress(i, TargetAddress);
110  return;
111  }
112  }
113  llvm_unreachable("Attempting to remap address of unknown section!");
114 }
115 
116 static std::error_code getOffset(const SymbolRef &Sym, SectionRef Sec,
117  uint64_t &Result) {
118  ErrorOr<uint64_t> AddressOrErr = Sym.getAddress();
119  if (std::error_code EC = AddressOrErr.getError())
120  return EC;
121  Result = *AddressOrErr - Sec.getAddress();
122  return std::error_code();
123 }
124 
125 std::pair<unsigned, unsigned>
127  MutexGuard locked(lock);
128 
129  // Grab the first Section ID. We'll use this later to construct the underlying
130  // range for the returned LoadedObjectInfo.
131  unsigned SectionsAddedBeginIdx = Sections.size();
132 
133  // Save information about our target
134  Arch = (Triple::ArchType)Obj.getArch();
135  IsTargetLittleEndian = Obj.isLittleEndian();
136  setMipsABI(Obj);
137 
138  // Compute the memory size required to load all sections to be loaded
139  // and pass this information to the memory manager
140  if (MemMgr.needsToReserveAllocationSpace()) {
141  uint64_t CodeSize = 0, DataSizeRO = 0, DataSizeRW = 0;
142  computeTotalAllocSize(Obj, CodeSize, DataSizeRO, DataSizeRW);
143  MemMgr.reserveAllocationSpace(CodeSize, DataSizeRO, DataSizeRW);
144  }
145 
146  // Used sections from the object file
147  ObjSectionToIDMap LocalSections;
148 
149  // Common symbols requiring allocation, with their sizes and alignments
150  CommonSymbolList CommonSymbols;
151 
152  // Parse symbols
153  DEBUG(dbgs() << "Parse symbols:\n");
154  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
155  ++I) {
156  uint32_t Flags = I->getFlags();
157 
158  bool IsCommon = Flags & SymbolRef::SF_Common;
159  if (IsCommon)
160  CommonSymbols.push_back(*I);
161  else {
162  object::SymbolRef::Type SymType = I->getType();
163 
164  if (SymType == object::SymbolRef::ST_Function ||
165  SymType == object::SymbolRef::ST_Data ||
166  SymType == object::SymbolRef::ST_Unknown) {
167 
168  ErrorOr<StringRef> NameOrErr = I->getName();
169  Check(NameOrErr.getError());
170  StringRef Name = *NameOrErr;
172  Check(I->getSection(SI));
173  if (SI == Obj.section_end())
174  continue;
175  uint64_t SectOffset;
176  Check(getOffset(*I, *SI, SectOffset));
177  StringRef SectionData;
178  Check(SI->getContents(SectionData));
179  bool IsCode = SI->isText();
180  unsigned SectionID =
181  findOrEmitSection(Obj, *SI, IsCode, LocalSections);
182  DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
183  << " SID: " << SectionID << " Offset: "
184  << format("%p", (uintptr_t)SectOffset)
185  << " flags: " << Flags << "\n");
186  JITSymbolFlags RTDyldSymFlags = JITSymbolFlags::None;
187  if (Flags & SymbolRef::SF_Weak)
188  RTDyldSymFlags |= JITSymbolFlags::Weak;
189  if (Flags & SymbolRef::SF_Exported)
190  RTDyldSymFlags |= JITSymbolFlags::Exported;
191  GlobalSymbolTable[Name] =
192  SymbolTableEntry(SectionID, SectOffset, RTDyldSymFlags);
193  }
194  }
195  }
196 
197  // Allocate common symbols
198  emitCommonSymbols(Obj, CommonSymbols);
199 
200  // Parse and process relocations
201  DEBUG(dbgs() << "Parse relocations:\n");
202  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
203  SI != SE; ++SI) {
204  unsigned SectionID = 0;
205  StubMap Stubs;
206  section_iterator RelocatedSection = SI->getRelocatedSection();
207 
208  if (RelocatedSection == SE)
209  continue;
210 
211  relocation_iterator I = SI->relocation_begin();
212  relocation_iterator E = SI->relocation_end();
213 
214  if (I == E && !ProcessAllSections)
215  continue;
216 
217  bool IsCode = RelocatedSection->isText();
218  SectionID =
219  findOrEmitSection(Obj, *RelocatedSection, IsCode, LocalSections);
220  DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
221 
222  for (; I != E;)
223  I = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs);
224 
225  // If there is an attached checker, notify it about the stubs for this
226  // section so that they can be verified.
227  if (Checker)
228  Checker->registerStubMap(Obj.getFileName(), SectionID, Stubs);
229  }
230 
231  // Give the subclasses a chance to tie-up any loose ends.
232  finalizeLoad(Obj, LocalSections);
233 
234  unsigned SectionsAddedEndIdx = Sections.size();
235 
236  return std::make_pair(SectionsAddedBeginIdx, SectionsAddedEndIdx);
237 }
238 
239 // A helper method for computeTotalAllocSize.
240 // Computes the memory size required to allocate sections with the given sizes,
241 // assuming that all sections are allocated with the given alignment
242 static uint64_t
243 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
244  uint64_t Alignment) {
245  uint64_t TotalSize = 0;
246  for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
247  uint64_t AlignedSize =
248  (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
249  TotalSize += AlignedSize;
250  }
251  return TotalSize;
252 }
253 
255  const ObjectFile *Obj = Section.getObject();
256  if (isa<object::ELFObjectFileBase>(Obj))
257  return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
258  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
259  const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
260  // Avoid loading zero-sized COFF sections.
261  // In PE files, VirtualSize gives the section size, and SizeOfRawData
262  // may be zero for sections with content. In Obj files, SizeOfRawData
263  // gives the section size, and VirtualSize is always zero. Hence
264  // the need to check for both cases below.
265  bool HasContent = (CoffSection->VirtualSize > 0)
266  || (CoffSection->SizeOfRawData > 0);
267  bool IsDiscardable = CoffSection->Characteristics &
269  return HasContent && !IsDiscardable;
270  }
271 
272  assert(isa<MachOObjectFile>(Obj));
273  return true;
274 }
275 
276 static bool isReadOnlyData(const SectionRef Section) {
277  const ObjectFile *Obj = Section.getObject();
278  if (isa<object::ELFObjectFileBase>(Obj))
279  return !(ELFSectionRef(Section).getFlags() &
281  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
282  return ((COFFObj->getCOFFSection(Section)->Characteristics &
286  ==
289 
290  assert(isa<MachOObjectFile>(Obj));
291  return false;
292 }
293 
294 static bool isZeroInit(const SectionRef Section) {
295  const ObjectFile *Obj = Section.getObject();
296  if (isa<object::ELFObjectFileBase>(Obj))
297  return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
298  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
299  return COFFObj->getCOFFSection(Section)->Characteristics &
301 
302  auto *MachO = cast<MachOObjectFile>(Obj);
303  unsigned SectionType = MachO->getSectionType(Section);
304  return SectionType == MachO::S_ZEROFILL ||
305  SectionType == MachO::S_GB_ZEROFILL;
306 }
307 
308 // Compute an upper bound of the memory size that is required to load all
309 // sections
311  uint64_t &CodeSize,
312  uint64_t &DataSizeRO,
313  uint64_t &DataSizeRW) {
314  // Compute the size of all sections required for execution
315  std::vector<uint64_t> CodeSectionSizes;
316  std::vector<uint64_t> ROSectionSizes;
317  std::vector<uint64_t> RWSectionSizes;
318  uint64_t MaxAlignment = sizeof(void *);
319 
320  // Collect sizes of all sections to be loaded;
321  // also determine the max alignment of all sections
322  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
323  SI != SE; ++SI) {
324  const SectionRef &Section = *SI;
325 
326  bool IsRequired = isRequiredForExecution(Section);
327 
328  // Consider only the sections that are required to be loaded for execution
329  if (IsRequired) {
330  StringRef Name;
331  uint64_t DataSize = Section.getSize();
332  uint64_t Alignment64 = Section.getAlignment();
333  bool IsCode = Section.isText();
334  bool IsReadOnly = isReadOnlyData(Section);
335  Check(Section.getName(Name));
336  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
337 
338  uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
339  uint64_t SectionSize = DataSize + StubBufSize;
340 
341  // The .eh_frame section (at least on Linux) needs an extra four bytes
342  // padded
343  // with zeroes added at the end. For MachO objects, this section has a
344  // slightly different name, so this won't have any effect for MachO
345  // objects.
346  if (Name == ".eh_frame")
347  SectionSize += 4;
348 
349  if (!SectionSize)
350  SectionSize = 1;
351 
352  if (IsCode) {
353  CodeSectionSizes.push_back(SectionSize);
354  } else if (IsReadOnly) {
355  ROSectionSizes.push_back(SectionSize);
356  } else {
357  RWSectionSizes.push_back(SectionSize);
358  }
359 
360  // update the max alignment
361  if (Alignment > MaxAlignment) {
362  MaxAlignment = Alignment;
363  }
364  }
365  }
366 
367  // Compute the size of all common symbols
368  uint64_t CommonSize = 0;
369  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
370  ++I) {
371  uint32_t Flags = I->getFlags();
372  if (Flags & SymbolRef::SF_Common) {
373  // Add the common symbols to a list. We'll allocate them all below.
374  uint64_t Size = I->getCommonSize();
375  CommonSize += Size;
376  }
377  }
378  if (CommonSize != 0) {
379  RWSectionSizes.push_back(CommonSize);
380  }
381 
382  // Compute the required allocation space for each different type of sections
383  // (code, read-only data, read-write data) assuming that all sections are
384  // allocated with the max alignment. Note that we cannot compute with the
385  // individual alignments of the sections, because then the required size
386  // depends on the order, in which the sections are allocated.
387  CodeSize = computeAllocationSizeForSections(CodeSectionSizes, MaxAlignment);
388  DataSizeRO = computeAllocationSizeForSections(ROSectionSizes, MaxAlignment);
389  DataSizeRW = computeAllocationSizeForSections(RWSectionSizes, MaxAlignment);
390 }
391 
392 // compute stub buffer size for the given section
394  const SectionRef &Section) {
395  unsigned StubSize = getMaxStubSize();
396  if (StubSize == 0) {
397  return 0;
398  }
399  // FIXME: this is an inefficient way to handle this. We should computed the
400  // necessary section allocation size in loadObject by walking all the sections
401  // once.
402  unsigned StubBufSize = 0;
403  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
404  SI != SE; ++SI) {
405  section_iterator RelSecI = SI->getRelocatedSection();
406  if (!(RelSecI == Section))
407  continue;
408 
409  for (const RelocationRef &Reloc : SI->relocations()) {
410  (void)Reloc;
411  StubBufSize += StubSize;
412  }
413  }
414 
415  // Get section data size and alignment
416  uint64_t DataSize = Section.getSize();
417  uint64_t Alignment64 = Section.getAlignment();
418 
419  // Add stubbuf size alignment
420  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
421  unsigned StubAlignment = getStubAlignment();
422  unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
423  if (StubAlignment > EndAlignment)
424  StubBufSize += StubAlignment - EndAlignment;
425  return StubBufSize;
426 }
427 
429  unsigned Size) const {
430  uint64_t Result = 0;
431  if (IsTargetLittleEndian) {
432  Src += Size - 1;
433  while (Size--)
434  Result = (Result << 8) | *Src--;
435  } else
436  while (Size--)
437  Result = (Result << 8) | *Src++;
438 
439  return Result;
440 }
441 
442 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
443  unsigned Size) const {
444  if (IsTargetLittleEndian) {
445  while (Size--) {
446  *Dst++ = Value & 0xFF;
447  Value >>= 8;
448  }
449  } else {
450  Dst += Size - 1;
451  while (Size--) {
452  *Dst-- = Value & 0xFF;
453  Value >>= 8;
454  }
455  }
456 }
457 
459  CommonSymbolList &CommonSymbols) {
460  if (CommonSymbols.empty())
461  return;
462 
463  uint64_t CommonSize = 0;
464  CommonSymbolList SymbolsToAllocate;
465 
466  DEBUG(dbgs() << "Processing common symbols...\n");
467 
468  for (const auto &Sym : CommonSymbols) {
469  ErrorOr<StringRef> NameOrErr = Sym.getName();
470  Check(NameOrErr.getError());
471  StringRef Name = *NameOrErr;
472 
473  // Skip common symbols already elsewhere.
474  if (GlobalSymbolTable.count(Name) ||
475  Resolver.findSymbolInLogicalDylib(Name)) {
476  DEBUG(dbgs() << "\tSkipping already emitted common symbol '" << Name
477  << "'\n");
478  continue;
479  }
480 
481  uint32_t Align = Sym.getAlignment();
482  uint64_t Size = Sym.getCommonSize();
483 
484  CommonSize += Align + Size;
485  SymbolsToAllocate.push_back(Sym);
486  }
487 
488  // Allocate memory for the section
489  unsigned SectionID = Sections.size();
490  uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, sizeof(void *),
491  SectionID, StringRef(), false);
492  if (!Addr)
493  report_fatal_error("Unable to allocate memory for common symbols!");
494  uint64_t Offset = 0;
495  Sections.push_back(SectionEntry("<common symbols>", Addr, CommonSize, 0));
496  memset(Addr, 0, CommonSize);
497 
498  DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID << " new addr: "
499  << format("%p", Addr) << " DataSize: " << CommonSize << "\n");
500 
501  // Assign the address of each symbol
502  for (auto &Sym : SymbolsToAllocate) {
503  uint32_t Align = Sym.getAlignment();
504  uint64_t Size = Sym.getCommonSize();
505  ErrorOr<StringRef> NameOrErr = Sym.getName();
506  Check(NameOrErr.getError());
507  StringRef Name = *NameOrErr;
508  if (Align) {
509  // This symbol has an alignment requirement.
510  uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
511  Addr += AlignOffset;
512  Offset += AlignOffset;
513  }
514  uint32_t Flags = Sym.getFlags();
515  JITSymbolFlags RTDyldSymFlags = JITSymbolFlags::None;
516  if (Flags & SymbolRef::SF_Weak)
517  RTDyldSymFlags |= JITSymbolFlags::Weak;
518  if (Flags & SymbolRef::SF_Exported)
519  RTDyldSymFlags |= JITSymbolFlags::Exported;
520  DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
521  << format("%p", Addr) << "\n");
522  GlobalSymbolTable[Name] =
523  SymbolTableEntry(SectionID, Offset, RTDyldSymFlags);
524  Offset += Size;
525  Addr += Size;
526  }
527 }
528 
530  const SectionRef &Section, bool IsCode) {
531 
532  StringRef data;
533  uint64_t Alignment64 = Section.getAlignment();
534 
535  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
536  unsigned PaddingSize = 0;
537  unsigned StubBufSize = 0;
538  StringRef Name;
539  bool IsRequired = isRequiredForExecution(Section);
540  bool IsVirtual = Section.isVirtual();
541  bool IsZeroInit = isZeroInit(Section);
542  bool IsReadOnly = isReadOnlyData(Section);
543  uint64_t DataSize = Section.getSize();
544  Check(Section.getName(Name));
545 
546  StubBufSize = computeSectionStubBufSize(Obj, Section);
547 
548  // The .eh_frame section (at least on Linux) needs an extra four bytes padded
549  // with zeroes added at the end. For MachO objects, this section has a
550  // slightly different name, so this won't have any effect for MachO objects.
551  if (Name == ".eh_frame")
552  PaddingSize = 4;
553 
554  uintptr_t Allocate;
555  unsigned SectionID = Sections.size();
556  uint8_t *Addr;
557  const char *pData = nullptr;
558 
559  // In either case, set the location of the unrelocated section in memory,
560  // since we still process relocations for it even if we're not applying them.
561  Check(Section.getContents(data));
562  // Virtual sections have no data in the object image, so leave pData = 0
563  if (!IsVirtual)
564  pData = data.data();
565 
566  // Some sections, such as debug info, don't need to be loaded for execution.
567  // Leave those where they are.
568  if (IsRequired) {
569  Allocate = DataSize + PaddingSize + StubBufSize;
570  if (!Allocate)
571  Allocate = 1;
572  Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
573  Name)
574  : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
575  Name, IsReadOnly);
576  if (!Addr)
577  report_fatal_error("Unable to allocate section memory!");
578 
579  // Zero-initialize or copy the data from the image
580  if (IsZeroInit || IsVirtual)
581  memset(Addr, 0, DataSize);
582  else
583  memcpy(Addr, pData, DataSize);
584 
585  // Fill in any extra bytes we allocated for padding
586  if (PaddingSize != 0) {
587  memset(Addr + DataSize, 0, PaddingSize);
588  // Update the DataSize variable so that the stub offset is set correctly.
589  DataSize += PaddingSize;
590  }
591 
592  DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
593  << " obj addr: " << format("%p", pData)
594  << " new addr: " << format("%p", Addr)
595  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
596  << " Allocate: " << Allocate << "\n");
597  } else {
598  // Even if we didn't load the section, we need to record an entry for it
599  // to handle later processing (and by 'handle' I mean don't do anything
600  // with these sections).
601  Allocate = 0;
602  Addr = nullptr;
603  DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
604  << " obj addr: " << format("%p", data.data()) << " new addr: 0"
605  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
606  << " Allocate: " << Allocate << "\n");
607  }
608 
609  Sections.push_back(SectionEntry(Name, Addr, DataSize, (uintptr_t)pData));
610 
611  if (Checker)
612  Checker->registerSection(Obj.getFileName(), SectionID);
613 
614  return SectionID;
615 }
616 
618  const SectionRef &Section,
619  bool IsCode,
620  ObjSectionToIDMap &LocalSections) {
621 
622  unsigned SectionID = 0;
623  ObjSectionToIDMap::iterator i = LocalSections.find(Section);
624  if (i != LocalSections.end())
625  SectionID = i->second;
626  else {
627  SectionID = emitSection(Obj, Section, IsCode);
628  LocalSections[Section] = SectionID;
629  }
630  return SectionID;
631 }
632 
634  unsigned SectionID) {
635  Relocations[SectionID].push_back(RE);
636 }
637 
639  StringRef SymbolName) {
640  // Relocation by symbol. If the symbol is found in the global symbol table,
641  // create an appropriate section relocation. Otherwise, add it to
642  // ExternalSymbolRelocations.
643  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
644  if (Loc == GlobalSymbolTable.end()) {
645  ExternalSymbolRelocations[SymbolName].push_back(RE);
646  } else {
647  // Copy the RE since we want to modify its addend.
648  RelocationEntry RECopy = RE;
649  const auto &SymInfo = Loc->second;
650  RECopy.Addend += SymInfo.getOffset();
651  Relocations[SymInfo.getSectionID()].push_back(RECopy);
652  }
653 }
654 
655 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
656  unsigned AbiVariant) {
657  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be) {
658  // This stub has to be able to access the full address space,
659  // since symbol lookup won't necessarily find a handy, in-range,
660  // PLT stub for functions which could be anywhere.
661  // Stub can use ip0 (== x16) to calculate address
662  writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
663  writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
664  writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
665  writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
666  writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
667 
668  return Addr;
669  } else if (Arch == Triple::arm || Arch == Triple::armeb) {
670  // TODO: There is only ARM far stub now. We should add the Thumb stub,
671  // and stubs for branches Thumb - ARM and ARM - Thumb.
672  writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc,<label>
673  return Addr + 4;
674  } else if (IsMipsO32ABI) {
675  // 0: 3c190000 lui t9,%hi(addr).
676  // 4: 27390000 addiu t9,t9,%lo(addr).
677  // 8: 03200008 jr t9.
678  // c: 00000000 nop.
679  const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
680  const unsigned JrT9Instr = 0x03200008, NopInstr = 0x0;
681 
682  writeBytesUnaligned(LuiT9Instr, Addr, 4);
683  writeBytesUnaligned(AdduiT9Instr, Addr+4, 4);
684  writeBytesUnaligned(JrT9Instr, Addr+8, 4);
685  writeBytesUnaligned(NopInstr, Addr+12, 4);
686  return Addr;
687  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
688  // Depending on which version of the ELF ABI is in use, we need to
689  // generate one of two variants of the stub. They both start with
690  // the same sequence to load the target address into r12.
691  writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
692  writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
693  writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
694  writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
695  writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
696  if (AbiVariant == 2) {
697  // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
698  // The address is already in r12 as required by the ABI. Branch to it.
699  writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
700  writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
701  writeInt32BE(Addr+28, 0x4E800420); // bctr
702  } else {
703  // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
704  // Load the function address on r11 and sets it to control register. Also
705  // loads the function TOC in r2 and environment pointer to r11.
706  writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
707  writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
708  writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
709  writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
710  writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
711  writeInt32BE(Addr+40, 0x4E800420); // bctr
712  }
713  return Addr;
714  } else if (Arch == Triple::systemz) {
715  writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
716  writeInt16BE(Addr+2, 0x0000);
717  writeInt16BE(Addr+4, 0x0004);
718  writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
719  // 8-byte address stored at Addr + 8
720  return Addr;
721  } else if (Arch == Triple::x86_64) {
722  *Addr = 0xFF; // jmp
723  *(Addr+1) = 0x25; // rip
724  // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
725  } else if (Arch == Triple::x86) {
726  *Addr = 0xE9; // 32-bit pc-relative jump.
727  }
728  return Addr;
729 }
730 
731 // Assign an address to a symbol name and resolve all the relocations
732 // associated with it.
734  uint64_t Addr) {
735  // The address to use for relocation resolution is not
736  // the address of the local section buffer. We must be doing
737  // a remote execution environment of some sort. Relocations can't
738  // be applied until all the sections have been moved. The client must
739  // trigger this with a call to MCJIT::finalize() or
740  // RuntimeDyld::resolveRelocations().
741  //
742  // Addr is a uint64_t because we can't assume the pointer width
743  // of the target is the same as that of the host. Just use a generic
744  // "big enough" type.
745  DEBUG(dbgs() << "Reassigning address for section "
746  << SectionID << " (" << Sections[SectionID].Name << "): "
747  << format("0x%016" PRIx64, Sections[SectionID].LoadAddress) << " -> "
748  << format("0x%016" PRIx64, Addr) << "\n");
749  Sections[SectionID].LoadAddress = Addr;
750 }
751 
753  uint64_t Value) {
754  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
755  const RelocationEntry &RE = Relocs[i];
756  // Ignore relocations for sections that were not loaded
757  if (Sections[RE.SectionID].Address == nullptr)
758  continue;
759  resolveRelocation(RE, Value);
760  }
761 }
762 
764  while (!ExternalSymbolRelocations.empty()) {
765  StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
766 
767  StringRef Name = i->first();
768  if (Name.size() == 0) {
769  // This is an absolute symbol, use an address of zero.
770  DEBUG(dbgs() << "Resolving absolute relocations."
771  << "\n");
772  RelocationList &Relocs = i->second;
773  resolveRelocationList(Relocs, 0);
774  } else {
775  uint64_t Addr = 0;
776  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
777  if (Loc == GlobalSymbolTable.end()) {
778  // This is an external symbol, try to get its address from the symbol
779  // resolver.
780  Addr = Resolver.findSymbol(Name.data()).getAddress();
781  // The call to getSymbolAddress may have caused additional modules to
782  // be loaded, which may have added new entries to the
783  // ExternalSymbolRelocations map. Consquently, we need to update our
784  // iterator. This is also why retrieval of the relocation list
785  // associated with this symbol is deferred until below this point.
786  // New entries may have been added to the relocation list.
787  i = ExternalSymbolRelocations.find(Name);
788  } else {
789  // We found the symbol in our global table. It was probably in a
790  // Module that we loaded previously.
791  const auto &SymInfo = Loc->second;
792  Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
793  SymInfo.getOffset();
794  }
795 
796  // FIXME: Implement error handling that doesn't kill the host program!
797  if (!Addr)
798  report_fatal_error("Program used external function '" + Name +
799  "' which could not be resolved!");
800 
801  // If Resolver returned UINT64_MAX, the client wants to handle this symbol
802  // manually and we shouldn't resolve its relocations.
803  if (Addr != UINT64_MAX) {
804  DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
805  << format("0x%lx", Addr) << "\n");
806  // This list may have been updated when we called getSymbolAddress, so
807  // don't change this code to get the list earlier.
808  RelocationList &Relocs = i->second;
809  resolveRelocationList(Relocs, Addr);
810  }
811  }
812 
813  ExternalSymbolRelocations.erase(i);
814  }
815 }
816 
817 //===----------------------------------------------------------------------===//
818 // RuntimeDyld class implementation
819 
821  StringRef SectionName) const {
822  for (unsigned I = BeginIdx; I != EndIdx; ++I)
823  if (RTDyld.Sections[I].Name == SectionName)
824  return RTDyld.Sections[I].LoadAddress;
825 
826  return 0;
827 }
828 
829 void RuntimeDyld::MemoryManager::anchor() {}
830 void RuntimeDyld::SymbolResolver::anchor() {}
831 
832 RuntimeDyld::RuntimeDyld(RuntimeDyld::MemoryManager &MemMgr,
833  RuntimeDyld::SymbolResolver &Resolver)
834  : MemMgr(MemMgr), Resolver(Resolver) {
835  // FIXME: There's a potential issue lurking here if a single instance of
836  // RuntimeDyld is used to load multiple objects. The current implementation
837  // associates a single memory manager with a RuntimeDyld instance. Even
838  // though the public class spawns a new 'impl' instance for each load,
839  // they share a single memory manager. This can become a problem when page
840  // permissions are applied.
841  Dyld = nullptr;
842  ProcessAllSections = false;
843  Checker = nullptr;
844 }
845 
847 
848 static std::unique_ptr<RuntimeDyldCOFF>
850  RuntimeDyld::SymbolResolver &Resolver,
851  bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker) {
852  std::unique_ptr<RuntimeDyldCOFF> Dyld =
853  RuntimeDyldCOFF::create(Arch, MM, Resolver);
854  Dyld->setProcessAllSections(ProcessAllSections);
855  Dyld->setRuntimeDyldChecker(Checker);
856  return Dyld;
857 }
858 
859 static std::unique_ptr<RuntimeDyldELF>
861  RuntimeDyld::SymbolResolver &Resolver,
862  bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker) {
863  std::unique_ptr<RuntimeDyldELF> Dyld(new RuntimeDyldELF(MM, Resolver));
864  Dyld->setProcessAllSections(ProcessAllSections);
865  Dyld->setRuntimeDyldChecker(Checker);
866  return Dyld;
867 }
868 
869 static std::unique_ptr<RuntimeDyldMachO>
871  RuntimeDyld::SymbolResolver &Resolver,
872  bool ProcessAllSections,
873  RuntimeDyldCheckerImpl *Checker) {
874  std::unique_ptr<RuntimeDyldMachO> Dyld =
875  RuntimeDyldMachO::create(Arch, MM, Resolver);
876  Dyld->setProcessAllSections(ProcessAllSections);
877  Dyld->setRuntimeDyldChecker(Checker);
878  return Dyld;
879 }
880 
881 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
883  if (!Dyld) {
884  if (Obj.isELF())
885  Dyld = createRuntimeDyldELF(MemMgr, Resolver, ProcessAllSections, Checker);
886  else if (Obj.isMachO())
887  Dyld = createRuntimeDyldMachO(
888  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
889  ProcessAllSections, Checker);
890  else if (Obj.isCOFF())
891  Dyld = createRuntimeDyldCOFF(
892  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
893  ProcessAllSections, Checker);
894  else
895  report_fatal_error("Incompatible object format!");
896  }
897 
898  if (!Dyld->isCompatibleFile(Obj))
899  report_fatal_error("Incompatible object format!");
900 
901  return Dyld->loadObject(Obj);
902 }
903 
905  if (!Dyld)
906  return nullptr;
907  return Dyld->getSymbolLocalAddress(Name);
908 }
909 
911  if (!Dyld)
912  return nullptr;
913  return Dyld->getSymbol(Name);
914 }
915 
916 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
917 
918 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
919  Dyld->reassignSectionAddress(SectionID, Addr);
920 }
921 
922 void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
923  uint64_t TargetAddress) {
924  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
925 }
926 
927 bool RuntimeDyld::hasError() { return Dyld->hasError(); }
928 
929 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
930 
932  if (Dyld)
933  Dyld->registerEHFrames();
934 }
935 
937  if (Dyld)
938  Dyld->deregisterEHFrames();
939 }
940 
941 } // end namespace llvm
bool isELF() const
Definition: Binary.h:104
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
std::error_code getError() const
Definition: ErrorOr.h:178
size_t Size
Size - section size. Doesn't include the stubs.
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
Represents either an error or a value T.
Definition: ErrorOr.h:82
std::unique_ptr< LoadedObjectInfo > loadObject(const object::ObjectFile &O)
Add the referenced object file to the list of objects to be loaded and relocated. ...
void registerEHFrames()
Register any EH frame sections that have been loaded but not previously registered with the memory ma...
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
std::pair< unsigned, unsigned > loadObjectImpl(const object::ObjectFile &Obj)
std::string Name
Name - section name.
void computeTotalAllocSize(const ObjectFile &Obj, uint64_t &CodeSize, uint64_t &DataSizeRO, uint64_t &DataSizeRW)
StringRef getErrorString()
void resolveExternalSymbols()
Resolve relocations to external symbols.
static bool isReadOnlyData(const SectionRef Section)
This class is the base class for all object file types.
Definition: ObjectFile.h:176
uint8_t * Address
Address - address in the linker's memory where the section resides.
unsigned findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
static std::error_code getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
static std::unique_ptr< RuntimeDyldCOFF > createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, RuntimeDyld::SymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
virtual unsigned getArch() const =0
SymbolInfo getSymbol(StringRef Name) const
Get the target address and flags for the named symbol.
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
unsigned SectionID
SectionID - the section this relocation points to.
bool isVirtual() const
Definition: ObjectFile.h:394
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
void resolveRelocationList(const RelocationList &Relocs, uint64_t Value)
Resolves relocations from Relocs list with address from Value.
static std::unique_ptr< RuntimeDyldELF > createRuntimeDyldELF(RuntimeDyld::MemoryManager &MM, RuntimeDyld::SymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
unsigned emitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode)
Emits section data from the object file to the MemoryManager.
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:40
static bool isRequiredForExecution(const SectionRef Section)
std::map< RelocationValueRef, uintptr_t > StubMap
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
virtual void registerEHFrames()
Definition: RuntimeDyld.cpp:38
support::ulittle32_t VirtualSize
Definition: Object/COFF.h:401
static uint64_t computeAllocationSizeForSections(std::vector< uint64_t > &SectionSizes, uint64_t Alignment)
basic_symbol_iterator symbol_begin() const
Definition: SymbolicFile.h:136
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:107
std::error_code getName(StringRef &Result) const
Definition: ObjectFile.h:362
virtual ~RuntimeDyldImpl()
Definition: RuntimeDyld.cpp:31
uint32_t getType() const
Definition: ELFObjectFile.h:78
void * getSymbolLocalAddress(StringRef Name) const
Get the address of our local copy of the symbol.
static std::unique_ptr< RuntimeDyldCOFF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, RuntimeDyld::SymbolResolver &Resolver)
format_object< Ts...> format(const char *Fmt, const Ts &...Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:111
uint64_t getAlignment() const
Get the alignment of this section as the actual value (not log 2).
Definition: ObjectFile.h:378
bool isCOFF() const
Definition: Binary.h:112
Instances of this class acquire a given Mutex Lock when constructed and hold that lock until destruct...
Definition: MutexGuard.h:27
support::ulittle32_t Characteristics
Definition: Object/COFF.h:409
void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName)
JITSymbolFlags
Flags for symbols in the JIT.
S_GB_ZEROFILL - Zero fill on demand section (that can be larger than 4 gigabytes).
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
void emitCommonSymbols(const ObjectFile &Obj, CommonSymbolList &CommonSymbols)
Given the common symbols discovered in the object file, emit a new section for them and update the sy...
bool isText() const
Definition: ObjectFile.h:382
static std::unique_ptr< RuntimeDyldMachO > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, RuntimeDyld::SymbolResolver &Resolver)
Create a RuntimeDyldMachO instance for the given target architecture.
uint64_t getSize() const
Definition: ObjectFile.h:370
std::vector< SymbolRef > CommonSymbolList
support::ulittle32_t SizeOfRawData
Definition: Object/COFF.h:403
uint64_t getAddress() const
Definition: ObjectFile.h:366
StringRef getFileName() const
Definition: Binary.cpp:35
const ObjectFile * getObject() const
Definition: ObjectFile.h:414
basic_symbol_iterator symbol_end() const
Definition: SymbolicFile.h:139
static void dumpSectionMemory(const SectionEntry &S, StringRef State)
Definition: RuntimeDyld.cpp:43
unsigned computeSectionStubBufSize(const ObjectFile &Obj, const SectionRef &Section)
virtual section_iterator section_begin() const =0
bool isMachO() const
Definition: Binary.h:108
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
static std::unique_ptr< RuntimeDyldMachO > createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, RuntimeDyld::SymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
uint64_t TargetAddress
Represents an address in the target process's address space.
Definition: JITSymbol.h:26
uint8_t * createStubFunction(uint8_t *Addr, unsigned AbiVariant=0)
Emits long jump instruction to Addr.
static cl::opt< AlignMode > Align(cl::desc("Load/store alignment support"), cl::Hidden, cl::init(NoStrictAlign), cl::values(clEnumValN(StrictAlign,"aarch64-strict-align","Disallow all unaligned memory accesses"), clEnumValN(NoStrictAlign,"aarch64-no-strict-align","Allow unaligned memory accesses"), clEnumValEnd))
uint64_t getSectionLoadAddress(StringRef Name) const
Obtain the Load Address of a section by Name.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:123
Symbol info for RuntimeDyld.
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
std::error_code getContents(StringRef &Result) const
Definition: ObjectFile.h:374
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:114
static bool isZeroInit(const SectionRef Section)
virtual section_iterator section_end() const =0
std::map< SectionRef, unsigned > ObjSectionToIDMap
std::error_code Check(std::error_code Err)
#define I(x, y, z)
Definition: MD5.cpp:54
uint64_t LoadAddress
LoadAddress - the address of the section in the target process's memory.
Information about a named symbol.
Definition: RuntimeDyld.h:47
bool isLittleEndian() const
Definition: Binary.h:120
void resolveRelocations()
Resolve the relocations for all symbols we currently know about.
SectionEntry - represents a section emitted into memory by the dynamic linker.
virtual void deregisterEHFrames()
Definition: RuntimeDyld.cpp:40
LLVM Value Representation.
Definition: Value.h:69
uint64_t OffsetToAlignment(uint64_t Value, uint64_t Align)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: MathExtras.h:616
#define DEBUG(X)
Definition: Debug.h:92
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
S_ZEROFILL - Zero fill on demand section.
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
Map a section to its target address space value.
SectionType
These are the section type and attributes fields.
ErrorOr< uint64_t > getAddress() const
Returns the symbol virtual address (i.e.
Definition: ObjectFile.h:310
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:69
uint64_t getFlags() const
Definition: ELFObjectFile.h:82