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