LLVM  8.0.0svn
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 "RuntimeDyldCOFF.h"
16 #include "RuntimeDyldCheckerImpl.h"
17 #include "RuntimeDyldELF.h"
18 #include "RuntimeDyldImpl.h"
19 #include "RuntimeDyldMachO.h"
20 #include "llvm/Object/COFF.h"
26 
27 #include <future>
28 
29 using namespace llvm;
30 using namespace llvm::object;
31 
32 #define DEBUG_TYPE "dyld"
33 
34 namespace {
35 
37  GenericRTDyldError = 1
38 };
39 
40 // FIXME: This class is only here to support the transition to llvm::Error. It
41 // will be removed once this transition is complete. Clients should prefer to
42 // deal with the Error value directly, rather than converting to error_code.
43 class RuntimeDyldErrorCategory : public std::error_category {
44 public:
45  const char *name() const noexcept override { return "runtimedyld"; }
46 
47  std::string message(int Condition) const override {
48  switch (static_cast<RuntimeDyldErrorCode>(Condition)) {
49  case GenericRTDyldError: return "Generic RuntimeDyld error";
50  }
51  llvm_unreachable("Unrecognized RuntimeDyldErrorCode");
52  }
53 };
54 
55 static ManagedStatic<RuntimeDyldErrorCategory> RTDyldErrorCategory;
56 
57 }
58 
59 char RuntimeDyldError::ID = 0;
60 
62  OS << ErrMsg << "\n";
63 }
64 
65 std::error_code RuntimeDyldError::convertToErrorCode() const {
66  return std::error_code(GenericRTDyldError, *RTDyldErrorCategory);
67 }
68 
69 // Empty out-of-line virtual destructor as the key function.
71 
72 // Pin LoadedObjectInfo's vtables to this file.
74 
75 namespace llvm {
76 
78 
80  MemMgr.deregisterEHFrames();
81 }
82 
83 #ifndef NDEBUG
84 static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
85  dbgs() << "----- Contents of section " << S.getName() << " " << State
86  << " -----";
87 
88  if (S.getAddress() == nullptr) {
89  dbgs() << "\n <section not emitted>\n";
90  return;
91  }
92 
93  const unsigned ColsPerRow = 16;
94 
95  uint8_t *DataAddr = S.getAddress();
96  uint64_t LoadAddr = S.getLoadAddress();
97 
98  unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
99  unsigned BytesRemaining = S.getSize();
100 
101  if (StartPadding) {
102  dbgs() << "\n" << format("0x%016" PRIx64,
103  LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
104  while (StartPadding--)
105  dbgs() << " ";
106  }
107 
108  while (BytesRemaining > 0) {
109  if ((LoadAddr & (ColsPerRow - 1)) == 0)
110  dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":";
111 
112  dbgs() << " " << format("%02x", *DataAddr);
113 
114  ++DataAddr;
115  ++LoadAddr;
116  --BytesRemaining;
117  }
118 
119  dbgs() << "\n";
120 }
121 #endif
122 
123 // Resolve the relocations for all symbols we currently know about.
125  MutexGuard locked(lock);
126 
127  // Print out the sections prior to relocation.
128  LLVM_DEBUG(for (int i = 0, e = Sections.size(); i != e; ++i)
129  dumpSectionMemory(Sections[i], "before relocations"););
130 
131  // First, resolve relocations associated with external symbols.
132  if (auto Err = resolveExternalSymbols()) {
133  HasError = true;
134  ErrorStr = toString(std::move(Err));
135  }
136 
137  resolveLocalRelocations();
138 
139  // Print out sections after relocation.
140  LLVM_DEBUG(for (int i = 0, e = Sections.size(); i != e; ++i)
141  dumpSectionMemory(Sections[i], "after relocations"););
142 }
143 
145  // Iterate over all outstanding relocations
146  for (auto it = Relocations.begin(), e = Relocations.end(); it != e; ++it) {
147  // The Section here (Sections[i]) refers to the section in which the
148  // symbol for the relocation is located. The SectionID in the relocation
149  // entry provides the section to which the relocation will be applied.
150  int Idx = it->first;
151  uint64_t Addr = Sections[Idx].getLoadAddress();
152  LLVM_DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
153  << format("%p", (uintptr_t)Addr) << "\n");
154  resolveRelocationList(it->second, Addr);
155  }
156  Relocations.clear();
157 }
158 
159 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
160  uint64_t TargetAddress) {
161  MutexGuard locked(lock);
162  for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
163  if (Sections[i].getAddress() == LocalAddress) {
164  reassignSectionAddress(i, TargetAddress);
165  return;
166  }
167  }
168  llvm_unreachable("Attempting to remap address of unknown section!");
169 }
170 
171 static Error getOffset(const SymbolRef &Sym, SectionRef Sec,
172  uint64_t &Result) {
173  Expected<uint64_t> AddressOrErr = Sym.getAddress();
174  if (!AddressOrErr)
175  return AddressOrErr.takeError();
176  Result = *AddressOrErr - Sec.getAddress();
177  return Error::success();
178 }
179 
182  MutexGuard locked(lock);
183 
184  // Save information about our target
185  Arch = (Triple::ArchType)Obj.getArch();
186  IsTargetLittleEndian = Obj.isLittleEndian();
187  setMipsABI(Obj);
188 
189  // Compute the memory size required to load all sections to be loaded
190  // and pass this information to the memory manager
191  if (MemMgr.needsToReserveAllocationSpace()) {
192  uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0;
193  uint32_t CodeAlign = 1, RODataAlign = 1, RWDataAlign = 1;
194  if (auto Err = computeTotalAllocSize(Obj,
195  CodeSize, CodeAlign,
196  RODataSize, RODataAlign,
197  RWDataSize, RWDataAlign))
198  return std::move(Err);
199  MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
200  RWDataSize, RWDataAlign);
201  }
202 
203  // Used sections from the object file
204  ObjSectionToIDMap LocalSections;
205 
206  // Common symbols requiring allocation, with their sizes and alignments
207  CommonSymbolList CommonSymbolsToAllocate;
208 
209  uint64_t CommonSize = 0;
210  uint32_t CommonAlign = 0;
211 
212  // First, collect all weak and common symbols. We need to know if stronger
213  // definitions occur elsewhere.
214  JITSymbolResolver::LookupSet ResponsibilitySet;
215  {
217  for (auto &Sym : Obj.symbols()) {
218  uint32_t Flags = Sym.getFlags();
219  if ((Flags & SymbolRef::SF_Common) || (Flags & SymbolRef::SF_Weak)) {
220  // Get symbol name.
221  if (auto NameOrErr = Sym.getName())
222  Symbols.insert(*NameOrErr);
223  else
224  return NameOrErr.takeError();
225  }
226  }
227 
228  if (auto ResultOrErr = Resolver.getResponsibilitySet(Symbols))
229  ResponsibilitySet = std::move(*ResultOrErr);
230  else
231  return ResultOrErr.takeError();
232  }
233 
234  // Parse symbols
235  LLVM_DEBUG(dbgs() << "Parse symbols:\n");
236  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
237  ++I) {
238  uint32_t Flags = I->getFlags();
239 
240  // Skip undefined symbols.
241  if (Flags & SymbolRef::SF_Undefined)
242  continue;
243 
244  // Get the symbol type.
245  object::SymbolRef::Type SymType;
246  if (auto SymTypeOrErr = I->getType())
247  SymType = *SymTypeOrErr;
248  else
249  return SymTypeOrErr.takeError();
250 
251  // Get symbol name.
252  StringRef Name;
253  if (auto NameOrErr = I->getName())
254  Name = *NameOrErr;
255  else
256  return NameOrErr.takeError();
257 
258  // Compute JIT symbol flags.
259  auto JITSymFlags = getJITSymbolFlags(*I);
260  if (!JITSymFlags)
261  return JITSymFlags.takeError();
262 
263  // If this is a weak definition, check to see if there's a strong one.
264  // If there is, skip this symbol (we won't be providing it: the strong
265  // definition will). If there's no strong definition, make this definition
266  // strong.
267  if (JITSymFlags->isWeak() || JITSymFlags->isCommon()) {
268  // First check whether there's already a definition in this instance.
269  if (GlobalSymbolTable.count(Name))
270  continue;
271 
272  // If we're not responsible for this symbol, skip it.
273  if (!ResponsibilitySet.count(Name))
274  continue;
275 
276  // Otherwise update the flags on the symbol to make this definition
277  // strong.
278  if (JITSymFlags->isWeak())
279  *JITSymFlags &= ~JITSymbolFlags::Weak;
280  if (JITSymFlags->isCommon()) {
281  *JITSymFlags &= ~JITSymbolFlags::Common;
282  uint32_t Align = I->getAlignment();
283  uint64_t Size = I->getCommonSize();
284  if (!CommonAlign)
285  CommonAlign = Align;
286  CommonSize = alignTo(CommonSize, Align) + Size;
287  CommonSymbolsToAllocate.push_back(*I);
288  }
289  }
290 
291  if (Flags & SymbolRef::SF_Absolute &&
292  SymType != object::SymbolRef::ST_File) {
293  uint64_t Addr = 0;
294  if (auto AddrOrErr = I->getAddress())
295  Addr = *AddrOrErr;
296  else
297  return AddrOrErr.takeError();
298 
299  unsigned SectionID = AbsoluteSymbolSection;
300 
301  LLVM_DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name
302  << " SID: " << SectionID
303  << " Offset: " << format("%p", (uintptr_t)Addr)
304  << " flags: " << Flags << "\n");
305  GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, *JITSymFlags);
306  } else if (SymType == object::SymbolRef::ST_Function ||
307  SymType == object::SymbolRef::ST_Data ||
308  SymType == object::SymbolRef::ST_Unknown ||
309  SymType == object::SymbolRef::ST_Other) {
310 
312  if (auto SIOrErr = I->getSection())
313  SI = *SIOrErr;
314  else
315  return SIOrErr.takeError();
316 
317  if (SI == Obj.section_end())
318  continue;
319 
320  // Get symbol offset.
321  uint64_t SectOffset;
322  if (auto Err = getOffset(*I, *SI, SectOffset))
323  return std::move(Err);
324 
325  bool IsCode = SI->isText();
326  unsigned SectionID;
327  if (auto SectionIDOrErr =
328  findOrEmitSection(Obj, *SI, IsCode, LocalSections))
329  SectionID = *SectionIDOrErr;
330  else
331  return SectionIDOrErr.takeError();
332 
333  LLVM_DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
334  << " SID: " << SectionID
335  << " Offset: " << format("%p", (uintptr_t)SectOffset)
336  << " flags: " << Flags << "\n");
337  GlobalSymbolTable[Name] =
338  SymbolTableEntry(SectionID, SectOffset, *JITSymFlags);
339  }
340  }
341 
342  // Allocate common symbols
343  if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
344  CommonAlign))
345  return std::move(Err);
346 
347  // Parse and process relocations
348  LLVM_DEBUG(dbgs() << "Parse relocations:\n");
349  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
350  SI != SE; ++SI) {
351  StubMap Stubs;
352  section_iterator RelocatedSection = SI->getRelocatedSection();
353 
354  if (RelocatedSection == SE)
355  continue;
356 
357  relocation_iterator I = SI->relocation_begin();
358  relocation_iterator E = SI->relocation_end();
359 
360  if (I == E && !ProcessAllSections)
361  continue;
362 
363  bool IsCode = RelocatedSection->isText();
364  unsigned SectionID = 0;
365  if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode,
366  LocalSections))
367  SectionID = *SectionIDOrErr;
368  else
369  return SectionIDOrErr.takeError();
370 
371  LLVM_DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
372 
373  for (; I != E;)
374  if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs))
375  I = *IOrErr;
376  else
377  return IOrErr.takeError();
378 
379  // If there is an attached checker, notify it about the stubs for this
380  // section so that they can be verified.
381  if (Checker)
382  Checker->registerStubMap(Obj.getFileName(), SectionID, Stubs);
383  }
384 
385  // Give the subclasses a chance to tie-up any loose ends.
386  if (auto Err = finalizeLoad(Obj, LocalSections))
387  return std::move(Err);
388 
389 // for (auto E : LocalSections)
390 // llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
391 
392  return LocalSections;
393 }
394 
395 // A helper method for computeTotalAllocSize.
396 // Computes the memory size required to allocate sections with the given sizes,
397 // assuming that all sections are allocated with the given alignment
398 static uint64_t
399 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
400  uint64_t Alignment) {
401  uint64_t TotalSize = 0;
402  for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
403  uint64_t AlignedSize =
404  (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
405  TotalSize += AlignedSize;
406  }
407  return TotalSize;
408 }
409 
411  const ObjectFile *Obj = Section.getObject();
412  if (isa<object::ELFObjectFileBase>(Obj))
413  return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
414  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
415  const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
416  // Avoid loading zero-sized COFF sections.
417  // In PE files, VirtualSize gives the section size, and SizeOfRawData
418  // may be zero for sections with content. In Obj files, SizeOfRawData
419  // gives the section size, and VirtualSize is always zero. Hence
420  // the need to check for both cases below.
421  bool HasContent =
422  (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
423  bool IsDiscardable =
424  CoffSection->Characteristics &
426  return HasContent && !IsDiscardable;
427  }
428 
429  assert(isa<MachOObjectFile>(Obj));
430  return true;
431 }
432 
433 static bool isReadOnlyData(const SectionRef Section) {
434  const ObjectFile *Obj = Section.getObject();
435  if (isa<object::ELFObjectFileBase>(Obj))
436  return !(ELFSectionRef(Section).getFlags() &
438  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
439  return ((COFFObj->getCOFFSection(Section)->Characteristics &
443  ==
446 
447  assert(isa<MachOObjectFile>(Obj));
448  return false;
449 }
450 
451 static bool isZeroInit(const SectionRef Section) {
452  const ObjectFile *Obj = Section.getObject();
453  if (isa<object::ELFObjectFileBase>(Obj))
454  return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
455  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
456  return COFFObj->getCOFFSection(Section)->Characteristics &
458 
459  auto *MachO = cast<MachOObjectFile>(Obj);
460  unsigned SectionType = MachO->getSectionType(Section);
461  return SectionType == MachO::S_ZEROFILL ||
462  SectionType == MachO::S_GB_ZEROFILL;
463 }
464 
465 // Compute an upper bound of the memory size that is required to load all
466 // sections
468  uint64_t &CodeSize,
469  uint32_t &CodeAlign,
470  uint64_t &RODataSize,
471  uint32_t &RODataAlign,
472  uint64_t &RWDataSize,
473  uint32_t &RWDataAlign) {
474  // Compute the size of all sections required for execution
475  std::vector<uint64_t> CodeSectionSizes;
476  std::vector<uint64_t> ROSectionSizes;
477  std::vector<uint64_t> RWSectionSizes;
478 
479  // Collect sizes of all sections to be loaded;
480  // also determine the max alignment of all sections
481  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
482  SI != SE; ++SI) {
483  const SectionRef &Section = *SI;
484 
485  bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections;
486 
487  // Consider only the sections that are required to be loaded for execution
488  if (IsRequired) {
489  uint64_t DataSize = Section.getSize();
490  uint64_t Alignment64 = Section.getAlignment();
491  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
492  bool IsCode = Section.isText();
493  bool IsReadOnly = isReadOnlyData(Section);
494 
495  StringRef Name;
496  if (auto EC = Section.getName(Name))
497  return errorCodeToError(EC);
498 
499  uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
500  uint64_t SectionSize = DataSize + StubBufSize;
501 
502  // The .eh_frame section (at least on Linux) needs an extra four bytes
503  // padded
504  // with zeroes added at the end. For MachO objects, this section has a
505  // slightly different name, so this won't have any effect for MachO
506  // objects.
507  if (Name == ".eh_frame")
508  SectionSize += 4;
509 
510  if (!SectionSize)
511  SectionSize = 1;
512 
513  if (IsCode) {
514  CodeAlign = std::max(CodeAlign, Alignment);
515  CodeSectionSizes.push_back(SectionSize);
516  } else if (IsReadOnly) {
517  RODataAlign = std::max(RODataAlign, Alignment);
518  ROSectionSizes.push_back(SectionSize);
519  } else {
520  RWDataAlign = std::max(RWDataAlign, Alignment);
521  RWSectionSizes.push_back(SectionSize);
522  }
523  }
524  }
525 
526  // Compute Global Offset Table size. If it is not zero we
527  // also update alignment, which is equal to a size of a
528  // single GOT entry.
529  if (unsigned GotSize = computeGOTSize(Obj)) {
530  RWSectionSizes.push_back(GotSize);
531  RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
532  }
533 
534  // Compute the size of all common symbols
535  uint64_t CommonSize = 0;
536  uint32_t CommonAlign = 1;
537  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
538  ++I) {
539  uint32_t Flags = I->getFlags();
540  if (Flags & SymbolRef::SF_Common) {
541  // Add the common symbols to a list. We'll allocate them all below.
542  uint64_t Size = I->getCommonSize();
543  uint32_t Align = I->getAlignment();
544  // If this is the first common symbol, use its alignment as the alignment
545  // for the common symbols section.
546  if (CommonSize == 0)
547  CommonAlign = Align;
548  CommonSize = alignTo(CommonSize, Align) + Size;
549  }
550  }
551  if (CommonSize != 0) {
552  RWSectionSizes.push_back(CommonSize);
553  RWDataAlign = std::max(RWDataAlign, CommonAlign);
554  }
555 
556  // Compute the required allocation space for each different type of sections
557  // (code, read-only data, read-write data) assuming that all sections are
558  // allocated with the max alignment. Note that we cannot compute with the
559  // individual alignments of the sections, because then the required size
560  // depends on the order, in which the sections are allocated.
561  CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
562  RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
563  RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
564 
565  return Error::success();
566 }
567 
568 // compute GOT size
570  size_t GotEntrySize = getGOTEntrySize();
571  if (!GotEntrySize)
572  return 0;
573 
574  size_t GotSize = 0;
575  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
576  SI != SE; ++SI) {
577 
578  for (const RelocationRef &Reloc : SI->relocations())
579  if (relocationNeedsGot(Reloc))
580  GotSize += GotEntrySize;
581  }
582 
583  return GotSize;
584 }
585 
586 // compute stub buffer size for the given section
588  const SectionRef &Section) {
589  unsigned StubSize = getMaxStubSize();
590  if (StubSize == 0) {
591  return 0;
592  }
593  // FIXME: this is an inefficient way to handle this. We should computed the
594  // necessary section allocation size in loadObject by walking all the sections
595  // once.
596  unsigned StubBufSize = 0;
597  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
598  SI != SE; ++SI) {
599  section_iterator RelSecI = SI->getRelocatedSection();
600  if (!(RelSecI == Section))
601  continue;
602 
603  for (const RelocationRef &Reloc : SI->relocations())
604  if (relocationNeedsStub(Reloc))
605  StubBufSize += StubSize;
606  }
607 
608  // Get section data size and alignment
609  uint64_t DataSize = Section.getSize();
610  uint64_t Alignment64 = Section.getAlignment();
611 
612  // Add stubbuf size alignment
613  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
614  unsigned StubAlignment = getStubAlignment();
615  unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
616  if (StubAlignment > EndAlignment)
617  StubBufSize += StubAlignment - EndAlignment;
618  return StubBufSize;
619 }
620 
622  unsigned Size) const {
623  uint64_t Result = 0;
624  if (IsTargetLittleEndian) {
625  Src += Size - 1;
626  while (Size--)
627  Result = (Result << 8) | *Src--;
628  } else
629  while (Size--)
630  Result = (Result << 8) | *Src++;
631 
632  return Result;
633 }
634 
635 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
636  unsigned Size) const {
637  if (IsTargetLittleEndian) {
638  while (Size--) {
639  *Dst++ = Value & 0xFF;
640  Value >>= 8;
641  }
642  } else {
643  Dst += Size - 1;
644  while (Size--) {
645  *Dst-- = Value & 0xFF;
646  Value >>= 8;
647  }
648  }
649 }
650 
654 }
655 
657  CommonSymbolList &SymbolsToAllocate,
658  uint64_t CommonSize,
659  uint32_t CommonAlign) {
660  if (SymbolsToAllocate.empty())
661  return Error::success();
662 
663  // Allocate memory for the section
664  unsigned SectionID = Sections.size();
665  uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
666  "<common symbols>", false);
667  if (!Addr)
668  report_fatal_error("Unable to allocate memory for common symbols!");
669  uint64_t Offset = 0;
670  Sections.push_back(
671  SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
672  memset(Addr, 0, CommonSize);
673 
674  LLVM_DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
675  << " new addr: " << format("%p", Addr)
676  << " DataSize: " << CommonSize << "\n");
677 
678  // Assign the address of each symbol
679  for (auto &Sym : SymbolsToAllocate) {
680  uint32_t Align = Sym.getAlignment();
681  uint64_t Size = Sym.getCommonSize();
682  StringRef Name;
683  if (auto NameOrErr = Sym.getName())
684  Name = *NameOrErr;
685  else
686  return NameOrErr.takeError();
687  if (Align) {
688  // This symbol has an alignment requirement.
689  uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
690  Addr += AlignOffset;
691  Offset += AlignOffset;
692  }
693  auto JITSymFlags = getJITSymbolFlags(Sym);
694 
695  if (!JITSymFlags)
696  return JITSymFlags.takeError();
697 
698  LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
699  << format("%p", Addr) << "\n");
700  GlobalSymbolTable[Name] =
701  SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
702  Offset += Size;
703  Addr += Size;
704  }
705 
706  if (Checker)
707  Checker->registerSection(Obj.getFileName(), SectionID);
708 
709  return Error::success();
710 }
711 
714  const SectionRef &Section,
715  bool IsCode) {
716  StringRef data;
717  uint64_t Alignment64 = Section.getAlignment();
718 
719  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
720  unsigned PaddingSize = 0;
721  unsigned StubBufSize = 0;
722  bool IsRequired = isRequiredForExecution(Section);
723  bool IsVirtual = Section.isVirtual();
724  bool IsZeroInit = isZeroInit(Section);
725  bool IsReadOnly = isReadOnlyData(Section);
726  uint64_t DataSize = Section.getSize();
727 
728  StringRef Name;
729  if (auto EC = Section.getName(Name))
730  return errorCodeToError(EC);
731 
732  StubBufSize = computeSectionStubBufSize(Obj, Section);
733 
734  // The .eh_frame section (at least on Linux) needs an extra four bytes padded
735  // with zeroes added at the end. For MachO objects, this section has a
736  // slightly different name, so this won't have any effect for MachO objects.
737  if (Name == ".eh_frame")
738  PaddingSize = 4;
739 
740  uintptr_t Allocate;
741  unsigned SectionID = Sections.size();
742  uint8_t *Addr;
743  const char *pData = nullptr;
744 
745  // If this section contains any bits (i.e. isn't a virtual or bss section),
746  // grab a reference to them.
747  if (!IsVirtual && !IsZeroInit) {
748  // In either case, set the location of the unrelocated section in memory,
749  // since we still process relocations for it even if we're not applying them.
750  if (auto EC = Section.getContents(data))
751  return errorCodeToError(EC);
752  pData = data.data();
753  }
754 
755  // Code section alignment needs to be at least as high as stub alignment or
756  // padding calculations may by incorrect when the section is remapped to a
757  // higher alignment.
758  if (IsCode) {
759  Alignment = std::max(Alignment, getStubAlignment());
760  if (StubBufSize > 0)
761  PaddingSize += getStubAlignment() - 1;
762  }
763 
764  // Some sections, such as debug info, don't need to be loaded for execution.
765  // Process those only if explicitly requested.
766  if (IsRequired || ProcessAllSections) {
767  Allocate = DataSize + PaddingSize + StubBufSize;
768  if (!Allocate)
769  Allocate = 1;
770  Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
771  Name)
772  : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
773  Name, IsReadOnly);
774  if (!Addr)
775  report_fatal_error("Unable to allocate section memory!");
776 
777  // Zero-initialize or copy the data from the image
778  if (IsZeroInit || IsVirtual)
779  memset(Addr, 0, DataSize);
780  else
781  memcpy(Addr, pData, DataSize);
782 
783  // Fill in any extra bytes we allocated for padding
784  if (PaddingSize != 0) {
785  memset(Addr + DataSize, 0, PaddingSize);
786  // Update the DataSize variable to include padding.
787  DataSize += PaddingSize;
788 
789  // Align DataSize to stub alignment if we have any stubs (PaddingSize will
790  // have been increased above to account for this).
791  if (StubBufSize > 0)
792  DataSize &= ~(getStubAlignment() - 1);
793  }
794 
795  LLVM_DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: "
796  << Name << " obj addr: " << format("%p", pData)
797  << " new addr: " << format("%p", Addr) << " DataSize: "
798  << DataSize << " StubBufSize: " << StubBufSize
799  << " Allocate: " << Allocate << "\n");
800  } else {
801  // Even if we didn't load the section, we need to record an entry for it
802  // to handle later processing (and by 'handle' I mean don't do anything
803  // with these sections).
804  Allocate = 0;
805  Addr = nullptr;
806  LLVM_DEBUG(
807  dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
808  << " obj addr: " << format("%p", data.data()) << " new addr: 0"
809  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
810  << " Allocate: " << Allocate << "\n");
811  }
812 
813  Sections.push_back(
814  SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
815 
816  // Debug info sections are linked as if their load address was zero
817  if (!IsRequired)
818  Sections.back().setLoadAddress(0);
819 
820  if (Checker)
821  Checker->registerSection(Obj.getFileName(), SectionID);
822 
823  return SectionID;
824 }
825 
828  const SectionRef &Section,
829  bool IsCode,
830  ObjSectionToIDMap &LocalSections) {
831 
832  unsigned SectionID = 0;
833  ObjSectionToIDMap::iterator i = LocalSections.find(Section);
834  if (i != LocalSections.end())
835  SectionID = i->second;
836  else {
837  if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
838  SectionID = *SectionIDOrErr;
839  else
840  return SectionIDOrErr.takeError();
841  LocalSections[Section] = SectionID;
842  }
843  return SectionID;
844 }
845 
847  unsigned SectionID) {
848  Relocations[SectionID].push_back(RE);
849 }
850 
853  // Relocation by symbol. If the symbol is found in the global symbol table,
854  // create an appropriate section relocation. Otherwise, add it to
855  // ExternalSymbolRelocations.
856  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
857  if (Loc == GlobalSymbolTable.end()) {
858  ExternalSymbolRelocations[SymbolName].push_back(RE);
859  } else {
860  // Copy the RE since we want to modify its addend.
861  RelocationEntry RECopy = RE;
862  const auto &SymInfo = Loc->second;
863  RECopy.Addend += SymInfo.getOffset();
864  Relocations[SymInfo.getSectionID()].push_back(RECopy);
865  }
866 }
867 
868 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
869  unsigned AbiVariant) {
870  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be) {
871  // This stub has to be able to access the full address space,
872  // since symbol lookup won't necessarily find a handy, in-range,
873  // PLT stub for functions which could be anywhere.
874  // Stub can use ip0 (== x16) to calculate address
875  writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
876  writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
877  writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
878  writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
879  writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
880 
881  return Addr;
882  } else if (Arch == Triple::arm || Arch == Triple::armeb) {
883  // TODO: There is only ARM far stub now. We should add the Thumb stub,
884  // and stubs for branches Thumb - ARM and ARM - Thumb.
885  writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
886  return Addr + 4;
887  } else if (IsMipsO32ABI || IsMipsN32ABI) {
888  // 0: 3c190000 lui t9,%hi(addr).
889  // 4: 27390000 addiu t9,t9,%lo(addr).
890  // 8: 03200008 jr t9.
891  // c: 00000000 nop.
892  const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
893  const unsigned NopInstr = 0x0;
894  unsigned JrT9Instr = 0x03200008;
895  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 ||
896  (AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
897  JrT9Instr = 0x03200009;
898 
899  writeBytesUnaligned(LuiT9Instr, Addr, 4);
900  writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
901  writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
902  writeBytesUnaligned(NopInstr, Addr + 12, 4);
903  return Addr;
904  } else if (IsMipsN64ABI) {
905  // 0: 3c190000 lui t9,%highest(addr).
906  // 4: 67390000 daddiu t9,t9,%higher(addr).
907  // 8: 0019CC38 dsll t9,t9,16.
908  // c: 67390000 daddiu t9,t9,%hi(addr).
909  // 10: 0019CC38 dsll t9,t9,16.
910  // 14: 67390000 daddiu t9,t9,%lo(addr).
911  // 18: 03200008 jr t9.
912  // 1c: 00000000 nop.
913  const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000,
914  DsllT9Instr = 0x19CC38;
915  const unsigned NopInstr = 0x0;
916  unsigned JrT9Instr = 0x03200008;
917  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
918  JrT9Instr = 0x03200009;
919 
920  writeBytesUnaligned(LuiT9Instr, Addr, 4);
921  writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
922  writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
923  writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
924  writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
925  writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
926  writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
927  writeBytesUnaligned(NopInstr, Addr + 28, 4);
928  return Addr;
929  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
930  // Depending on which version of the ELF ABI is in use, we need to
931  // generate one of two variants of the stub. They both start with
932  // the same sequence to load the target address into r12.
933  writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
934  writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
935  writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
936  writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
937  writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
938  if (AbiVariant == 2) {
939  // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
940  // The address is already in r12 as required by the ABI. Branch to it.
941  writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
942  writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
943  writeInt32BE(Addr+28, 0x4E800420); // bctr
944  } else {
945  // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
946  // Load the function address on r11 and sets it to control register. Also
947  // loads the function TOC in r2 and environment pointer to r11.
948  writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
949  writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
950  writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
951  writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
952  writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
953  writeInt32BE(Addr+40, 0x4E800420); // bctr
954  }
955  return Addr;
956  } else if (Arch == Triple::systemz) {
957  writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
958  writeInt16BE(Addr+2, 0x0000);
959  writeInt16BE(Addr+4, 0x0004);
960  writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
961  // 8-byte address stored at Addr + 8
962  return Addr;
963  } else if (Arch == Triple::x86_64) {
964  *Addr = 0xFF; // jmp
965  *(Addr+1) = 0x25; // rip
966  // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
967  } else if (Arch == Triple::x86) {
968  *Addr = 0xE9; // 32-bit pc-relative jump.
969  }
970  return Addr;
971 }
972 
973 // Assign an address to a symbol name and resolve all the relocations
974 // associated with it.
976  uint64_t Addr) {
977  // The address to use for relocation resolution is not
978  // the address of the local section buffer. We must be doing
979  // a remote execution environment of some sort. Relocations can't
980  // be applied until all the sections have been moved. The client must
981  // trigger this with a call to MCJIT::finalize() or
982  // RuntimeDyld::resolveRelocations().
983  //
984  // Addr is a uint64_t because we can't assume the pointer width
985  // of the target is the same as that of the host. Just use a generic
986  // "big enough" type.
987  LLVM_DEBUG(
988  dbgs() << "Reassigning address for section " << SectionID << " ("
989  << Sections[SectionID].getName() << "): "
990  << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
991  << " -> " << format("0x%016" PRIx64, Addr) << "\n");
992  Sections[SectionID].setLoadAddress(Addr);
993 }
994 
996  uint64_t Value) {
997  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
998  const RelocationEntry &RE = Relocs[i];
999  // Ignore relocations for sections that were not loaded
1000  if (Sections[RE.SectionID].getAddress() == nullptr)
1001  continue;
1002  resolveRelocation(RE, Value);
1003  }
1004 }
1005 
1007  const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
1008  while (!ExternalSymbolRelocations.empty()) {
1009 
1010  StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
1011 
1012  StringRef Name = i->first();
1013  if (Name.size() == 0) {
1014  // This is an absolute symbol, use an address of zero.
1015  LLVM_DEBUG(dbgs() << "Resolving absolute relocations."
1016  << "\n");
1017  RelocationList &Relocs = i->second;
1018  resolveRelocationList(Relocs, 0);
1019  } else {
1020  uint64_t Addr = 0;
1021  JITSymbolFlags Flags;
1022  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
1023  if (Loc == GlobalSymbolTable.end()) {
1024  auto RRI = ExternalSymbolMap.find(Name);
1025  assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
1026  Addr = RRI->second.getAddress();
1027  Flags = RRI->second.getFlags();
1028  // The call to getSymbolAddress may have caused additional modules to
1029  // be loaded, which may have added new entries to the
1030  // ExternalSymbolRelocations map. Consquently, we need to update our
1031  // iterator. This is also why retrieval of the relocation list
1032  // associated with this symbol is deferred until below this point.
1033  // New entries may have been added to the relocation list.
1034  i = ExternalSymbolRelocations.find(Name);
1035  } else {
1036  // We found the symbol in our global table. It was probably in a
1037  // Module that we loaded previously.
1038  const auto &SymInfo = Loc->second;
1039  Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
1040  SymInfo.getOffset();
1041  Flags = SymInfo.getFlags();
1042  }
1043 
1044  // FIXME: Implement error handling that doesn't kill the host program!
1045  if (!Addr)
1046  report_fatal_error("Program used external function '" + Name +
1047  "' which could not be resolved!");
1048 
1049  // If Resolver returned UINT64_MAX, the client wants to handle this symbol
1050  // manually and we shouldn't resolve its relocations.
1051  if (Addr != UINT64_MAX) {
1052 
1053  // Tweak the address based on the symbol flags if necessary.
1054  // For example, this is used by RuntimeDyldMachOARM to toggle the low bit
1055  // if the target symbol is Thumb.
1056  Addr = modifyAddressBasedOnFlags(Addr, Flags);
1057 
1058  LLVM_DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
1059  << format("0x%lx", Addr) << "\n");
1060  // This list may have been updated when we called getSymbolAddress, so
1061  // don't change this code to get the list earlier.
1062  RelocationList &Relocs = i->second;
1063  resolveRelocationList(Relocs, Addr);
1064  }
1065  }
1066 
1067  ExternalSymbolRelocations.erase(i);
1068  }
1069 }
1070 
1072  StringMap<JITEvaluatedSymbol> ExternalSymbolMap;
1073 
1074  // Resolution can trigger emission of more symbols, so iterate until
1075  // we've resolved *everything*.
1076  {
1077  JITSymbolResolver::LookupSet ResolvedSymbols;
1078 
1079  while (true) {
1080  JITSymbolResolver::LookupSet NewSymbols;
1081 
1082  for (auto &RelocKV : ExternalSymbolRelocations) {
1083  StringRef Name = RelocKV.first();
1084  if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
1085  !ResolvedSymbols.count(Name))
1086  NewSymbols.insert(Name);
1087  }
1088 
1089  if (NewSymbols.empty())
1090  break;
1091 
1092 #ifdef _MSC_VER
1093  using ExpectedLookupResult =
1095 #else
1096  using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>;
1097 #endif
1098 
1099  auto NewSymbolsP = std::make_shared<std::promise<ExpectedLookupResult>>();
1100  auto NewSymbolsF = NewSymbolsP->get_future();
1101  Resolver.lookup(NewSymbols,
1103  NewSymbolsP->set_value(std::move(Result));
1104  });
1105 
1106  auto NewResolverResults = NewSymbolsF.get();
1107 
1108  if (!NewResolverResults)
1109  return NewResolverResults.takeError();
1110 
1111  assert(NewResolverResults->size() == NewSymbols.size() &&
1112  "Should have errored on unresolved symbols");
1113 
1114  for (auto &RRKV : *NewResolverResults) {
1115  assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
1116  ExternalSymbolMap.insert(RRKV);
1117  ResolvedSymbols.insert(RRKV.first);
1118  }
1119  }
1120  }
1121 
1122  applyExternalSymbolRelocations(ExternalSymbolMap);
1123 
1124  return Error::success();
1125 }
1126 
1128  std::unique_ptr<RuntimeDyldImpl> This, std::function<void(Error)> OnEmitted,
1129  std::unique_ptr<MemoryBuffer> UnderlyingBuffer) {
1130 
1131  // FIXME: Move-capture OnRelocsApplied and UnderlyingBuffer once we have
1132  // c++14.
1133  auto SharedUnderlyingBuffer =
1134  std::shared_ptr<MemoryBuffer>(std::move(UnderlyingBuffer));
1135  auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This));
1136  auto PostResolveContinuation =
1137  [SharedThis, OnEmitted, SharedUnderlyingBuffer](
1139  if (!Result) {
1140  OnEmitted(Result.takeError());
1141  return;
1142  }
1143 
1144  /// Copy the result into a StringMap, where the keys are held by value.
1146  for (auto &KV : *Result)
1147  Resolved[KV.first] = KV.second;
1148 
1149  SharedThis->applyExternalSymbolRelocations(Resolved);
1150  SharedThis->resolveLocalRelocations();
1151  SharedThis->registerEHFrames();
1152  std::string ErrMsg;
1153  if (SharedThis->MemMgr.finalizeMemory(&ErrMsg))
1154  OnEmitted(make_error<StringError>(std::move(ErrMsg),
1156  else
1157  OnEmitted(Error::success());
1158  };
1159 
1161 
1162  for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
1163  StringRef Name = RelocKV.first();
1164  assert(!Name.empty() && "Symbol has no name?");
1165  assert(!SharedThis->GlobalSymbolTable.count(Name) &&
1166  "Name already processed. RuntimeDyld instances can not be re-used "
1167  "when finalizing with finalizeAsync.");
1168  Symbols.insert(Name);
1169  }
1170 
1171  if (!Symbols.empty()) {
1172  SharedThis->Resolver.lookup(Symbols, PostResolveContinuation);
1173  } else
1174  PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>());
1175 }
1176 
1177 //===----------------------------------------------------------------------===//
1178 // RuntimeDyld class implementation
1179 
1181  const object::SectionRef &Sec) const {
1182 
1183  auto I = ObjSecToIDMap.find(Sec);
1184  if (I != ObjSecToIDMap.end())
1185  return RTDyld.Sections[I->second].getLoadAddress();
1186 
1187  return 0;
1188 }
1189 
1190 void RuntimeDyld::MemoryManager::anchor() {}
1191 void JITSymbolResolver::anchor() {}
1192 void LegacyJITSymbolResolver::anchor() {}
1193 
1196  : MemMgr(MemMgr), Resolver(Resolver) {
1197  // FIXME: There's a potential issue lurking here if a single instance of
1198  // RuntimeDyld is used to load multiple objects. The current implementation
1199  // associates a single memory manager with a RuntimeDyld instance. Even
1200  // though the public class spawns a new 'impl' instance for each load,
1201  // they share a single memory manager. This can become a problem when page
1202  // permissions are applied.
1203  Dyld = nullptr;
1204  ProcessAllSections = false;
1205  Checker = nullptr;
1206 }
1207 
1209 
1210 static std::unique_ptr<RuntimeDyldCOFF>
1212  JITSymbolResolver &Resolver, bool ProcessAllSections,
1213  RuntimeDyldCheckerImpl *Checker) {
1214  std::unique_ptr<RuntimeDyldCOFF> Dyld =
1215  RuntimeDyldCOFF::create(Arch, MM, Resolver);
1216  Dyld->setProcessAllSections(ProcessAllSections);
1217  Dyld->setRuntimeDyldChecker(Checker);
1218  return Dyld;
1219 }
1220 
1221 static std::unique_ptr<RuntimeDyldELF>
1223  JITSymbolResolver &Resolver, bool ProcessAllSections,
1224  RuntimeDyldCheckerImpl *Checker) {
1225  std::unique_ptr<RuntimeDyldELF> Dyld =
1226  RuntimeDyldELF::create(Arch, MM, Resolver);
1227  Dyld->setProcessAllSections(ProcessAllSections);
1228  Dyld->setRuntimeDyldChecker(Checker);
1229  return Dyld;
1230 }
1231 
1232 static std::unique_ptr<RuntimeDyldMachO>
1235  bool ProcessAllSections,
1236  RuntimeDyldCheckerImpl *Checker) {
1237  std::unique_ptr<RuntimeDyldMachO> Dyld =
1238  RuntimeDyldMachO::create(Arch, MM, Resolver);
1239  Dyld->setProcessAllSections(ProcessAllSections);
1240  Dyld->setRuntimeDyldChecker(Checker);
1241  return Dyld;
1242 }
1243 
1244 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1246  if (!Dyld) {
1247  if (Obj.isELF())
1248  Dyld =
1249  createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1250  MemMgr, Resolver, ProcessAllSections, Checker);
1251  else if (Obj.isMachO())
1252  Dyld = createRuntimeDyldMachO(
1253  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1254  ProcessAllSections, Checker);
1255  else if (Obj.isCOFF())
1256  Dyld = createRuntimeDyldCOFF(
1257  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1258  ProcessAllSections, Checker);
1259  else
1260  report_fatal_error("Incompatible object format!");
1261  }
1262 
1263  if (!Dyld->isCompatibleFile(Obj))
1264  report_fatal_error("Incompatible object format!");
1265 
1266  auto LoadedObjInfo = Dyld->loadObject(Obj);
1267  MemMgr.notifyObjectLoaded(*this, Obj);
1268  return LoadedObjInfo;
1269 }
1270 
1272  if (!Dyld)
1273  return nullptr;
1274  return Dyld->getSymbolLocalAddress(Name);
1275 }
1276 
1278  if (!Dyld)
1279  return nullptr;
1280  return Dyld->getSymbol(Name);
1281 }
1282 
1283 std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
1284  if (!Dyld)
1285  return std::map<StringRef, JITEvaluatedSymbol>();
1286  return Dyld->getSymbolTable();
1287 }
1288 
1289 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1290 
1291 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
1292  Dyld->reassignSectionAddress(SectionID, Addr);
1293 }
1294 
1295 void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1296  uint64_t TargetAddress) {
1297  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1298 }
1299 
1300 bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1301 
1302 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1303 
1305  bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1306  MemMgr.FinalizationLocked = true;
1308  registerEHFrames();
1309  if (!MemoryFinalizationLocked) {
1310  MemMgr.finalizeMemory();
1311  MemMgr.FinalizationLocked = false;
1312  }
1313 }
1314 
1316  if (Dyld)
1317  Dyld->registerEHFrames();
1318 }
1319 
1321  if (Dyld)
1322  Dyld->deregisterEHFrames();
1323 }
1324 // FIXME: Kill this with fire once we have a new JIT linker: this is only here
1325 // so that we can re-use RuntimeDyld's implementation without twisting the
1326 // interface any further for ORC's purposes.
1328  std::unique_ptr<MemoryBuffer> UnderlyingBuffer,
1330  JITSymbolResolver &Resolver, bool ProcessAllSections,
1332  std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObj,
1333  std::map<StringRef, JITEvaluatedSymbol>)>
1334  OnLoaded,
1335  std::function<void(Error)> OnEmitted) {
1336 
1337  RuntimeDyld RTDyld(MemMgr, Resolver);
1338  RTDyld.setProcessAllSections(ProcessAllSections);
1339 
1340  auto Info = RTDyld.loadObject(Obj);
1341 
1342  if (RTDyld.hasError()) {
1343  OnEmitted(make_error<StringError>(RTDyld.getErrorString(),
1345  return;
1346  }
1347 
1348  if (auto Err = OnLoaded(std::move(Info), RTDyld.getSymbolTable()))
1349  OnEmitted(std::move(Err));
1350 
1351  RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
1352  std::move(UnderlyingBuffer));
1353 }
1354 
1355 } // end namespace llvm
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
friend void jitLinkForORC(object::ObjectFile &Obj, std::unique_ptr< MemoryBuffer > UnderlyingBuffer, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver, bool ProcessAllSections, std::function< Error(std::unique_ptr< LoadedObjectInfo >, std::map< StringRef, JITEvaluatedSymbol >)> OnLoaded, std::function< void(Error)> OnEmitted)
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
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...
GCNRegPressure max(const GCNRegPressure &P1, const GCNRegPressure &P2)
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
StringRef getFileName() const
Definition: Binary.cpp:41
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
StringRef getErrorString()
unsigned computeGOTSize(const ObjectFile &Obj)
static bool isReadOnlyData(const SectionRef Section)
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: RuntimeDyld.cpp:65
iterator find(StringRef Key)
Definition: StringMap.h:333
This class is the base class for all object file types.
Definition: ObjectFile.h:190
static Expected< JITSymbolFlags > fromObjectSymbol(const object::SymbolRef &Symbol)
Construct a JITSymbolFlags value based on the flags of the given libobject symbol.
Definition: JITSymbol.cpp:41
uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew=0)
Returns the next integer (mod 2**64) that is greater than or equal to Value and is a multiple of Alig...
Definition: MathExtras.h:685
uint8_t * getAddress() const
Error takeError()
Take ownership of the stored error.
Definition: Error.h:553
std::set< StringRef > LookupSet
Definition: JITSymbol.h:334
JITEvaluatedSymbol getSymbol(StringRef Name) const
Get the target address and flags for the named symbol.
uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override
Obtain the Load Address of a section by SectionRef.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
static std::unique_ptr< RuntimeDyldELF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
virtual basic_symbol_iterator symbol_begin() const =0
RuntimeDyldErrorCode
Definition: RuntimeDyld.cpp:36
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
bool isCOFF() const
Definition: Binary.h:117
unsigned SectionID
SectionID - the section this relocation points to.
amdgpu Simplify well known AMD library false Value Value const Twine & Name
std::string toString(Error E)
Write all error messages (if any) in E to a string.
Definition: Error.h:963
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
uint64_t getAddress() const
Definition: ObjectFile.h:404
void resolveRelocationList(const RelocationList &Relocs, uint64_t Value)
Resolves relocations from Relocs list with address from Value.
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:52
static StringRef getName(Value *V)
static bool isRequiredForExecution(const SectionRef Section)
std::map< RelocationValueRef, uintptr_t > StubMap
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
virtual void registerEHFrames()
Definition: RuntimeDyld.cpp:77
static std::unique_ptr< RuntimeDyldMachO > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Create a RuntimeDyldMachO instance for the given target architecture.
support::ulittle32_t VirtualSize
Definition: COFF.h:440
static uint64_t computeAllocationSizeForSections(std::vector< uint64_t > &SectionSizes, uint64_t Alignment)
#define UINT64_MAX
Definition: DataTypes.h:83
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
virtual ~RuntimeDyldImpl()
Definition: RuntimeDyld.cpp:70
virtual Expected< JITSymbolFlags > getJITSymbolFlags(const SymbolRef &Sym)
Generate JITSymbolFlags from a libObject symbol.
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
const ObjectFile * getObject() const
Definition: ObjectFile.h:468
void setProcessAllSections(bool ProcessAllSections)
By default, only sections that are "required for execution" are passed to the RTDyldMemoryManager, and other sections are discarded.
Definition: RuntimeDyld.h:228
RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Construct a RuntimeDyld instance.
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: COFF.h:448
void addRelocationForSymbol(const RelocationEntry &RE, StringRef SymbolName)
virtual bool finalizeMemory(std::string *ErrMsg=nullptr)=0
This method is called when object loading is complete and section page permissions can be applied...
void * getSymbolLocalAddress(StringRef Name) const
Get the address of our local copy of the symbol.
* if(!EatIfPresent(lltok::kw_thread_local)) return false
ParseOptionalThreadLocal := /*empty.
S_GB_ZEROFILL - Zero fill on demand section (that can be larger than 4 gigabytes).
Definition: MachO.h:148
virtual void notifyObjectLoaded(RuntimeDyld &RTDyld, const object::ObjectFile &Obj)
This method is called after an object has been loaded into memory but before relocations are applied ...
Definition: RuntimeDyld.h:164
bool isVirtual() const
Definition: ObjectFile.h:440
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1774
static ManagedStatic< _object_error_category > error_category
Definition: Error.cpp:74
Error computeTotalAllocSize(const ObjectFile &Obj, uint64_t &CodeSize, uint32_t &CodeAlign, uint64_t &RODataSize, uint32_t &RODataAlign, uint64_t &RWDataSize, uint32_t &RWDataAlign)
uint64_t getSize() const
Definition: ObjectFile.h:412
Flags for symbols in the JIT.
Definition: JITSymbol.h:44
Symbol resolution interface.
Definition: JITSymbol.h:332
std::vector< SymbolRef > CommonSymbolList
virtual basic_symbol_iterator symbol_end() const =0
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: RuntimeDyld.cpp:61
Expected< unsigned > findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
support::ulittle32_t SizeOfRawData
Definition: COFF.h:442
Expected< uint64_t > getAddress() const
Returns the symbol virtual address (i.e.
Definition: ObjectFile.h:349
Error emitCommonSymbols(const ObjectFile &Obj, CommonSymbolList &CommonSymbols, uint64_t CommonSize, uint32_t CommonAlign)
Given the common symbols discovered in the object file, emit a new section for them and update the sy...
bool isELF() const
Definition: Binary.h:109
size_t size() const
Definition: SmallVector.h:53
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool isLittleEndian() const
Definition: Binary.h:131
void applyExternalSymbolRelocations(const StringMap< JITEvaluatedSymbol > ExternalSymbolMap)
static void dumpSectionMemory(const SectionEntry &S, StringRef State)
Definition: RuntimeDyld.cpp:84
static ErrorSuccess success()
Create a success value.
Definition: Error.h:327
unsigned computeSectionStubBufSize(const ObjectFile &Obj, const SectionRef &Section)
virtual section_iterator section_begin() const =0
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
std::error_code getName(StringRef &Result) const
Definition: ObjectFile.h:400
virtual Triple::ArchType getArch() const =0
std::error_code getContents(StringRef &Result) const
Definition: ObjectFile.h:416
uint8_t * createStubFunction(uint8_t *Addr, unsigned AbiVariant=0)
Emits long jump instruction to Addr.
bool insert(MapEntryTy *KeyValue)
insert - Insert the specified key/value pair into the map.
Definition: StringMap.h:366
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
Symbol info for RuntimeDyld.
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:220
static std::unique_ptr< RuntimeDyldCOFF > createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:197
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:129
size_t getSize() const
static std::unique_ptr< RuntimeDyldELF > createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
static bool isZeroInit(const SectionRef Section)
std::map< StringRef, JITEvaluatedSymbol > getSymbolTable() const
Returns a copy of the symbol table.
symbol_iterator_range symbols() const
Definition: ObjectFile.h:270
virtual section_iterator section_end() const =0
std::map< SectionRef, unsigned > ObjSectionToIDMap
void finalizeWithMemoryManagerLocking()
Perform all actions needed to make the code owned by this RuntimeDyld instance executable: ...
static std::unique_ptr< RuntimeDyldCOFF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
#define I(x, y, z)
Definition: MD5.cpp:58
uint64_t getLoadAddress() const
uint32_t Size
Definition: Profile.cpp:47
Expected< unsigned > emitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode)
Emits section data from the object file to the MemoryManager.
uint64_t getAlignment() const
Get the alignment of this section as the actual value (not log 2).
Definition: ObjectFile.h:420
static std::unique_ptr< RuntimeDyldMachO > createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
static void finalizeAsync(std::unique_ptr< RuntimeDyldImpl > This, std::function< void(Error)> OnEmitted, std::unique_ptr< MemoryBuffer > UnderlyingBuffer)
void resolveRelocations()
Resolve the relocations for all symbols we currently know about.
StringRef getName() const
SymInfo contains information about symbol: it&#39;s address and section index which is -1LL for absolute ...
SectionEntry - represents a section emitted into memory by the dynamic linker.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
static const char * name
Lightweight error class with error context and mandatory checking.
Definition: Error.h:158
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:727
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
print Print MemDeps of function
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Expected< ObjSectionToIDMap > loadObjectImpl(const object::ObjectFile &Obj)
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
bool isMachO() const
Definition: Binary.h:113
S_ZEROFILL - Zero fill on demand section.
Definition: MachO.h:122
Error resolveExternalSymbols()
Resolve relocations to external symbols.
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
Map a section to its target address space value.
#define LLVM_DEBUG(X)
Definition: Debug.h:123
SectionType
These are the section type and attributes fields.
Definition: MachO.h:115
iterator end()
Definition: StringMap.h:318
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77