LLVM  10.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 "RuntimeDyldELF.h"
16 #include "RuntimeDyldImpl.h"
17 #include "RuntimeDyldMachO.h"
18 #include "llvm/Object/COFF.h"
20 #include "llvm/Support/Alignment.h"
24 #include <mutex>
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  std::lock_guard<sys::Mutex> 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  std::lock_guard<sys::Mutex> 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  std::lock_guard<sys::Mutex> 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 a NotifyStubEmitted callback set, call it to register any
379  // stubs created for this section.
380  if (NotifyStubEmitted) {
381  StringRef FileName = Obj.getFileName();
382  StringRef SectionName = Sections[SectionID].getName();
383  for (auto &KV : Stubs) {
384 
385  auto &VR = KV.first;
386  uint64_t StubAddr = KV.second;
387 
388  // If this is a named stub, just call NotifyStubEmitted.
389  if (VR.SymbolName) {
390  NotifyStubEmitted(FileName, SectionName, VR.SymbolName, SectionID,
391  StubAddr);
392  continue;
393  }
394 
395  // Otherwise we will have to try a reverse lookup on the globla symbol table.
396  for (auto &GSTMapEntry : GlobalSymbolTable) {
397  StringRef SymbolName = GSTMapEntry.first();
398  auto &GSTEntry = GSTMapEntry.second;
399  if (GSTEntry.getSectionID() == VR.SectionID &&
400  GSTEntry.getOffset() == VR.Offset) {
401  NotifyStubEmitted(FileName, SectionName, SymbolName, SectionID,
402  StubAddr);
403  break;
404  }
405  }
406  }
407  }
408  }
409 
410  // Process remaining sections
411  if (ProcessAllSections) {
412  LLVM_DEBUG(dbgs() << "Process remaining sections:\n");
413  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
414  SI != SE; ++SI) {
415 
416  /* Ignore already loaded sections */
417  if (LocalSections.find(*SI) != LocalSections.end())
418  continue;
419 
420  bool IsCode = SI->isText();
421  if (auto SectionIDOrErr =
422  findOrEmitSection(Obj, *SI, IsCode, LocalSections))
423  LLVM_DEBUG(dbgs() << "\tSectionID: " << (*SectionIDOrErr) << "\n");
424  else
425  return SectionIDOrErr.takeError();
426  }
427  }
428 
429  // Give the subclasses a chance to tie-up any loose ends.
430  if (auto Err = finalizeLoad(Obj, LocalSections))
431  return std::move(Err);
432 
433 // for (auto E : LocalSections)
434 // llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
435 
436  return LocalSections;
437 }
438 
439 // A helper method for computeTotalAllocSize.
440 // Computes the memory size required to allocate sections with the given sizes,
441 // assuming that all sections are allocated with the given alignment
442 static uint64_t
443 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
444  uint64_t Alignment) {
445  uint64_t TotalSize = 0;
446  for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
447  uint64_t AlignedSize =
448  (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
449  TotalSize += AlignedSize;
450  }
451  return TotalSize;
452 }
453 
455  const ObjectFile *Obj = Section.getObject();
456  if (isa<object::ELFObjectFileBase>(Obj))
457  return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
458  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
459  const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
460  // Avoid loading zero-sized COFF sections.
461  // In PE files, VirtualSize gives the section size, and SizeOfRawData
462  // may be zero for sections with content. In Obj files, SizeOfRawData
463  // gives the section size, and VirtualSize is always zero. Hence
464  // the need to check for both cases below.
465  bool HasContent =
466  (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
467  bool IsDiscardable =
468  CoffSection->Characteristics &
470  return HasContent && !IsDiscardable;
471  }
472 
473  assert(isa<MachOObjectFile>(Obj));
474  return true;
475 }
476 
477 static bool isReadOnlyData(const SectionRef Section) {
478  const ObjectFile *Obj = Section.getObject();
479  if (isa<object::ELFObjectFileBase>(Obj))
480  return !(ELFSectionRef(Section).getFlags() &
482  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
483  return ((COFFObj->getCOFFSection(Section)->Characteristics &
487  ==
490 
491  assert(isa<MachOObjectFile>(Obj));
492  return false;
493 }
494 
495 static bool isZeroInit(const SectionRef Section) {
496  const ObjectFile *Obj = Section.getObject();
497  if (isa<object::ELFObjectFileBase>(Obj))
498  return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
499  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
500  return COFFObj->getCOFFSection(Section)->Characteristics &
502 
503  auto *MachO = cast<MachOObjectFile>(Obj);
504  unsigned SectionType = MachO->getSectionType(Section);
505  return SectionType == MachO::S_ZEROFILL ||
506  SectionType == MachO::S_GB_ZEROFILL;
507 }
508 
509 // Compute an upper bound of the memory size that is required to load all
510 // sections
512  uint64_t &CodeSize,
513  uint32_t &CodeAlign,
514  uint64_t &RODataSize,
515  uint32_t &RODataAlign,
516  uint64_t &RWDataSize,
517  uint32_t &RWDataAlign) {
518  // Compute the size of all sections required for execution
519  std::vector<uint64_t> CodeSectionSizes;
520  std::vector<uint64_t> ROSectionSizes;
521  std::vector<uint64_t> RWSectionSizes;
522 
523  // Collect sizes of all sections to be loaded;
524  // also determine the max alignment of all sections
525  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
526  SI != SE; ++SI) {
527  const SectionRef &Section = *SI;
528 
529  bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections;
530 
531  // Consider only the sections that are required to be loaded for execution
532  if (IsRequired) {
533  uint64_t DataSize = Section.getSize();
534  uint64_t Alignment64 = Section.getAlignment();
535  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
536  bool IsCode = Section.isText();
537  bool IsReadOnly = isReadOnlyData(Section);
538 
539  Expected<StringRef> NameOrErr = Section.getName();
540  if (!NameOrErr)
541  return NameOrErr.takeError();
542  StringRef Name = *NameOrErr;
543 
544  uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
545 
546  uint64_t PaddingSize = 0;
547  if (Name == ".eh_frame")
548  PaddingSize += 4;
549  if (StubBufSize != 0)
550  PaddingSize += getStubAlignment() - 1;
551 
552  uint64_t SectionSize = DataSize + PaddingSize + StubBufSize;
553 
554  // The .eh_frame section (at least on Linux) needs an extra four bytes
555  // padded
556  // with zeroes added at the end. For MachO objects, this section has a
557  // slightly different name, so this won't have any effect for MachO
558  // objects.
559  if (Name == ".eh_frame")
560  SectionSize += 4;
561 
562  if (!SectionSize)
563  SectionSize = 1;
564 
565  if (IsCode) {
566  CodeAlign = std::max(CodeAlign, Alignment);
567  CodeSectionSizes.push_back(SectionSize);
568  } else if (IsReadOnly) {
569  RODataAlign = std::max(RODataAlign, Alignment);
570  ROSectionSizes.push_back(SectionSize);
571  } else {
572  RWDataAlign = std::max(RWDataAlign, Alignment);
573  RWSectionSizes.push_back(SectionSize);
574  }
575  }
576  }
577 
578  // Compute Global Offset Table size. If it is not zero we
579  // also update alignment, which is equal to a size of a
580  // single GOT entry.
581  if (unsigned GotSize = computeGOTSize(Obj)) {
582  RWSectionSizes.push_back(GotSize);
583  RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
584  }
585 
586  // Compute the size of all common symbols
587  uint64_t CommonSize = 0;
588  uint32_t CommonAlign = 1;
589  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
590  ++I) {
591  uint32_t Flags = I->getFlags();
592  if (Flags & SymbolRef::SF_Common) {
593  // Add the common symbols to a list. We'll allocate them all below.
594  uint64_t Size = I->getCommonSize();
595  uint32_t Align = I->getAlignment();
596  // If this is the first common symbol, use its alignment as the alignment
597  // for the common symbols section.
598  if (CommonSize == 0)
599  CommonAlign = Align;
600  CommonSize = alignTo(CommonSize, Align) + Size;
601  }
602  }
603  if (CommonSize != 0) {
604  RWSectionSizes.push_back(CommonSize);
605  RWDataAlign = std::max(RWDataAlign, CommonAlign);
606  }
607 
608  // Compute the required allocation space for each different type of sections
609  // (code, read-only data, read-write data) assuming that all sections are
610  // allocated with the max alignment. Note that we cannot compute with the
611  // individual alignments of the sections, because then the required size
612  // depends on the order, in which the sections are allocated.
613  CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
614  RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
615  RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
616 
617  return Error::success();
618 }
619 
620 // compute GOT size
622  size_t GotEntrySize = getGOTEntrySize();
623  if (!GotEntrySize)
624  return 0;
625 
626  size_t GotSize = 0;
627  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
628  SI != SE; ++SI) {
629 
630  for (const RelocationRef &Reloc : SI->relocations())
631  if (relocationNeedsGot(Reloc))
632  GotSize += GotEntrySize;
633  }
634 
635  return GotSize;
636 }
637 
638 // compute stub buffer size for the given section
640  const SectionRef &Section) {
641  unsigned StubSize = getMaxStubSize();
642  if (StubSize == 0) {
643  return 0;
644  }
645  // FIXME: this is an inefficient way to handle this. We should computed the
646  // necessary section allocation size in loadObject by walking all the sections
647  // once.
648  unsigned StubBufSize = 0;
649  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
650  SI != SE; ++SI) {
651  section_iterator RelSecI = SI->getRelocatedSection();
652  if (!(RelSecI == Section))
653  continue;
654 
655  for (const RelocationRef &Reloc : SI->relocations())
656  if (relocationNeedsStub(Reloc))
657  StubBufSize += StubSize;
658  }
659 
660  // Get section data size and alignment
661  uint64_t DataSize = Section.getSize();
662  uint64_t Alignment64 = Section.getAlignment();
663 
664  // Add stubbuf size alignment
665  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
666  unsigned StubAlignment = getStubAlignment();
667  unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
668  if (StubAlignment > EndAlignment)
669  StubBufSize += StubAlignment - EndAlignment;
670  return StubBufSize;
671 }
672 
674  unsigned Size) const {
675  uint64_t Result = 0;
676  if (IsTargetLittleEndian) {
677  Src += Size - 1;
678  while (Size--)
679  Result = (Result << 8) | *Src--;
680  } else
681  while (Size--)
682  Result = (Result << 8) | *Src++;
683 
684  return Result;
685 }
686 
687 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
688  unsigned Size) const {
689  if (IsTargetLittleEndian) {
690  while (Size--) {
691  *Dst++ = Value & 0xFF;
692  Value >>= 8;
693  }
694  } else {
695  Dst += Size - 1;
696  while (Size--) {
697  *Dst-- = Value & 0xFF;
698  Value >>= 8;
699  }
700  }
701 }
702 
706 }
707 
709  CommonSymbolList &SymbolsToAllocate,
710  uint64_t CommonSize,
711  uint32_t CommonAlign) {
712  if (SymbolsToAllocate.empty())
713  return Error::success();
714 
715  // Allocate memory for the section
716  unsigned SectionID = Sections.size();
717  uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
718  "<common symbols>", false);
719  if (!Addr)
720  report_fatal_error("Unable to allocate memory for common symbols!");
721  uint64_t Offset = 0;
722  Sections.push_back(
723  SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
724  memset(Addr, 0, CommonSize);
725 
726  LLVM_DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
727  << " new addr: " << format("%p", Addr)
728  << " DataSize: " << CommonSize << "\n");
729 
730  // Assign the address of each symbol
731  for (auto &Sym : SymbolsToAllocate) {
732  uint32_t Align = Sym.getAlignment();
733  uint64_t Size = Sym.getCommonSize();
734  StringRef Name;
735  if (auto NameOrErr = Sym.getName())
736  Name = *NameOrErr;
737  else
738  return NameOrErr.takeError();
739  if (Align) {
740  // This symbol has an alignment requirement.
741  uint64_t AlignOffset =
742  offsetToAlignment((uint64_t)Addr, llvm::Align(Align));
743  Addr += AlignOffset;
744  Offset += AlignOffset;
745  }
746  auto JITSymFlags = getJITSymbolFlags(Sym);
747 
748  if (!JITSymFlags)
749  return JITSymFlags.takeError();
750 
751  LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
752  << format("%p", Addr) << "\n");
753  GlobalSymbolTable[Name] =
754  SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
755  Offset += Size;
756  Addr += Size;
757  }
758 
759  return Error::success();
760 }
761 
764  const SectionRef &Section,
765  bool IsCode) {
766  StringRef data;
767  uint64_t Alignment64 = Section.getAlignment();
768 
769  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
770  unsigned PaddingSize = 0;
771  unsigned StubBufSize = 0;
772  bool IsRequired = isRequiredForExecution(Section);
773  bool IsVirtual = Section.isVirtual();
774  bool IsZeroInit = isZeroInit(Section);
775  bool IsReadOnly = isReadOnlyData(Section);
776  uint64_t DataSize = Section.getSize();
777 
778  // An alignment of 0 (at least with ELF) is identical to an alignment of 1,
779  // while being more "polite". Other formats do not support 0-aligned sections
780  // anyway, so we should guarantee that the alignment is always at least 1.
781  Alignment = std::max(1u, Alignment);
782 
783  Expected<StringRef> NameOrErr = Section.getName();
784  if (!NameOrErr)
785  return NameOrErr.takeError();
786  StringRef Name = *NameOrErr;
787 
788  StubBufSize = computeSectionStubBufSize(Obj, Section);
789 
790  // The .eh_frame section (at least on Linux) needs an extra four bytes padded
791  // with zeroes added at the end. For MachO objects, this section has a
792  // slightly different name, so this won't have any effect for MachO objects.
793  if (Name == ".eh_frame")
794  PaddingSize = 4;
795 
796  uintptr_t Allocate;
797  unsigned SectionID = Sections.size();
798  uint8_t *Addr;
799  const char *pData = nullptr;
800 
801  // If this section contains any bits (i.e. isn't a virtual or bss section),
802  // grab a reference to them.
803  if (!IsVirtual && !IsZeroInit) {
804  // In either case, set the location of the unrelocated section in memory,
805  // since we still process relocations for it even if we're not applying them.
806  if (Expected<StringRef> E = Section.getContents())
807  data = *E;
808  else
809  return E.takeError();
810  pData = data.data();
811  }
812 
813  // If there are any stubs then the section alignment needs to be at least as
814  // high as stub alignment or padding calculations may by incorrect when the
815  // section is remapped.
816  if (StubBufSize != 0) {
817  Alignment = std::max(Alignment, getStubAlignment());
818  PaddingSize += getStubAlignment() - 1;
819  }
820 
821  // Some sections, such as debug info, don't need to be loaded for execution.
822  // Process those only if explicitly requested.
823  if (IsRequired || ProcessAllSections) {
824  Allocate = DataSize + PaddingSize + StubBufSize;
825  if (!Allocate)
826  Allocate = 1;
827  Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
828  Name)
829  : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
830  Name, IsReadOnly);
831  if (!Addr)
832  report_fatal_error("Unable to allocate section memory!");
833 
834  // Zero-initialize or copy the data from the image
835  if (IsZeroInit || IsVirtual)
836  memset(Addr, 0, DataSize);
837  else
838  memcpy(Addr, pData, DataSize);
839 
840  // Fill in any extra bytes we allocated for padding
841  if (PaddingSize != 0) {
842  memset(Addr + DataSize, 0, PaddingSize);
843  // Update the DataSize variable to include padding.
844  DataSize += PaddingSize;
845 
846  // Align DataSize to stub alignment if we have any stubs (PaddingSize will
847  // have been increased above to account for this).
848  if (StubBufSize > 0)
849  DataSize &= -(uint64_t)getStubAlignment();
850  }
851 
852  LLVM_DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: "
853  << Name << " obj addr: " << format("%p", pData)
854  << " new addr: " << format("%p", Addr) << " DataSize: "
855  << DataSize << " StubBufSize: " << StubBufSize
856  << " Allocate: " << Allocate << "\n");
857  } else {
858  // Even if we didn't load the section, we need to record an entry for it
859  // to handle later processing (and by 'handle' I mean don't do anything
860  // with these sections).
861  Allocate = 0;
862  Addr = nullptr;
863  LLVM_DEBUG(
864  dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
865  << " obj addr: " << format("%p", data.data()) << " new addr: 0"
866  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
867  << " Allocate: " << Allocate << "\n");
868  }
869 
870  Sections.push_back(
871  SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
872 
873  // Debug info sections are linked as if their load address was zero
874  if (!IsRequired)
875  Sections.back().setLoadAddress(0);
876 
877  return SectionID;
878 }
879 
882  const SectionRef &Section,
883  bool IsCode,
884  ObjSectionToIDMap &LocalSections) {
885 
886  unsigned SectionID = 0;
887  ObjSectionToIDMap::iterator i = LocalSections.find(Section);
888  if (i != LocalSections.end())
889  SectionID = i->second;
890  else {
891  if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
892  SectionID = *SectionIDOrErr;
893  else
894  return SectionIDOrErr.takeError();
895  LocalSections[Section] = SectionID;
896  }
897  return SectionID;
898 }
899 
901  unsigned SectionID) {
902  Relocations[SectionID].push_back(RE);
903 }
904 
907  // Relocation by symbol. If the symbol is found in the global symbol table,
908  // create an appropriate section relocation. Otherwise, add it to
909  // ExternalSymbolRelocations.
910  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
911  if (Loc == GlobalSymbolTable.end()) {
912  ExternalSymbolRelocations[SymbolName].push_back(RE);
913  } else {
914  // Copy the RE since we want to modify its addend.
915  RelocationEntry RECopy = RE;
916  const auto &SymInfo = Loc->second;
917  RECopy.Addend += SymInfo.getOffset();
918  Relocations[SymInfo.getSectionID()].push_back(RECopy);
919  }
920 }
921 
922 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
923  unsigned AbiVariant) {
924  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be ||
925  Arch == Triple::aarch64_32) {
926  // This stub has to be able to access the full address space,
927  // since symbol lookup won't necessarily find a handy, in-range,
928  // PLT stub for functions which could be anywhere.
929  // Stub can use ip0 (== x16) to calculate address
930  writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
931  writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
932  writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
933  writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
934  writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
935 
936  return Addr;
937  } else if (Arch == Triple::arm || Arch == Triple::armeb) {
938  // TODO: There is only ARM far stub now. We should add the Thumb stub,
939  // and stubs for branches Thumb - ARM and ARM - Thumb.
940  writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
941  return Addr + 4;
942  } else if (IsMipsO32ABI || IsMipsN32ABI) {
943  // 0: 3c190000 lui t9,%hi(addr).
944  // 4: 27390000 addiu t9,t9,%lo(addr).
945  // 8: 03200008 jr t9.
946  // c: 00000000 nop.
947  const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
948  const unsigned NopInstr = 0x0;
949  unsigned JrT9Instr = 0x03200008;
950  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 ||
951  (AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
952  JrT9Instr = 0x03200009;
953 
954  writeBytesUnaligned(LuiT9Instr, Addr, 4);
955  writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
956  writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
957  writeBytesUnaligned(NopInstr, Addr + 12, 4);
958  return Addr;
959  } else if (IsMipsN64ABI) {
960  // 0: 3c190000 lui t9,%highest(addr).
961  // 4: 67390000 daddiu t9,t9,%higher(addr).
962  // 8: 0019CC38 dsll t9,t9,16.
963  // c: 67390000 daddiu t9,t9,%hi(addr).
964  // 10: 0019CC38 dsll t9,t9,16.
965  // 14: 67390000 daddiu t9,t9,%lo(addr).
966  // 18: 03200008 jr t9.
967  // 1c: 00000000 nop.
968  const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000,
969  DsllT9Instr = 0x19CC38;
970  const unsigned NopInstr = 0x0;
971  unsigned JrT9Instr = 0x03200008;
972  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
973  JrT9Instr = 0x03200009;
974 
975  writeBytesUnaligned(LuiT9Instr, Addr, 4);
976  writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
977  writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
978  writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
979  writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
980  writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
981  writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
982  writeBytesUnaligned(NopInstr, Addr + 28, 4);
983  return Addr;
984  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
985  // Depending on which version of the ELF ABI is in use, we need to
986  // generate one of two variants of the stub. They both start with
987  // the same sequence to load the target address into r12.
988  writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
989  writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
990  writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
991  writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
992  writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
993  if (AbiVariant == 2) {
994  // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
995  // The address is already in r12 as required by the ABI. Branch to it.
996  writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
997  writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
998  writeInt32BE(Addr+28, 0x4E800420); // bctr
999  } else {
1000  // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
1001  // Load the function address on r11 and sets it to control register. Also
1002  // loads the function TOC in r2 and environment pointer to r11.
1003  writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
1004  writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
1005  writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
1006  writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
1007  writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
1008  writeInt32BE(Addr+40, 0x4E800420); // bctr
1009  }
1010  return Addr;
1011  } else if (Arch == Triple::systemz) {
1012  writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
1013  writeInt16BE(Addr+2, 0x0000);
1014  writeInt16BE(Addr+4, 0x0004);
1015  writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
1016  // 8-byte address stored at Addr + 8
1017  return Addr;
1018  } else if (Arch == Triple::x86_64) {
1019  *Addr = 0xFF; // jmp
1020  *(Addr+1) = 0x25; // rip
1021  // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
1022  } else if (Arch == Triple::x86) {
1023  *Addr = 0xE9; // 32-bit pc-relative jump.
1024  }
1025  return Addr;
1026 }
1027 
1028 // Assign an address to a symbol name and resolve all the relocations
1029 // associated with it.
1031  uint64_t Addr) {
1032  // The address to use for relocation resolution is not
1033  // the address of the local section buffer. We must be doing
1034  // a remote execution environment of some sort. Relocations can't
1035  // be applied until all the sections have been moved. The client must
1036  // trigger this with a call to MCJIT::finalize() or
1037  // RuntimeDyld::resolveRelocations().
1038  //
1039  // Addr is a uint64_t because we can't assume the pointer width
1040  // of the target is the same as that of the host. Just use a generic
1041  // "big enough" type.
1042  LLVM_DEBUG(
1043  dbgs() << "Reassigning address for section " << SectionID << " ("
1044  << Sections[SectionID].getName() << "): "
1045  << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
1046  << " -> " << format("0x%016" PRIx64, Addr) << "\n");
1047  Sections[SectionID].setLoadAddress(Addr);
1048 }
1049 
1051  uint64_t Value) {
1052  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
1053  const RelocationEntry &RE = Relocs[i];
1054  // Ignore relocations for sections that were not loaded
1055  if (Sections[RE.SectionID].getAddress() == nullptr)
1056  continue;
1057  resolveRelocation(RE, Value);
1058  }
1059 }
1060 
1062  const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
1063  while (!ExternalSymbolRelocations.empty()) {
1064 
1065  StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
1066 
1067  StringRef Name = i->first();
1068  if (Name.size() == 0) {
1069  // This is an absolute symbol, use an address of zero.
1070  LLVM_DEBUG(dbgs() << "Resolving absolute relocations."
1071  << "\n");
1072  RelocationList &Relocs = i->second;
1073  resolveRelocationList(Relocs, 0);
1074  } else {
1075  uint64_t Addr = 0;
1076  JITSymbolFlags Flags;
1077  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
1078  if (Loc == GlobalSymbolTable.end()) {
1079  auto RRI = ExternalSymbolMap.find(Name);
1080  assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
1081  Addr = RRI->second.getAddress();
1082  Flags = RRI->second.getFlags();
1083  // The call to getSymbolAddress may have caused additional modules to
1084  // be loaded, which may have added new entries to the
1085  // ExternalSymbolRelocations map. Consquently, we need to update our
1086  // iterator. This is also why retrieval of the relocation list
1087  // associated with this symbol is deferred until below this point.
1088  // New entries may have been added to the relocation list.
1089  i = ExternalSymbolRelocations.find(Name);
1090  } else {
1091  // We found the symbol in our global table. It was probably in a
1092  // Module that we loaded previously.
1093  const auto &SymInfo = Loc->second;
1094  Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
1095  SymInfo.getOffset();
1096  Flags = SymInfo.getFlags();
1097  }
1098 
1099  // FIXME: Implement error handling that doesn't kill the host program!
1100  if (!Addr)
1101  report_fatal_error("Program used external function '" + Name +
1102  "' which could not be resolved!");
1103 
1104  // If Resolver returned UINT64_MAX, the client wants to handle this symbol
1105  // manually and we shouldn't resolve its relocations.
1106  if (Addr != UINT64_MAX) {
1107 
1108  // Tweak the address based on the symbol flags if necessary.
1109  // For example, this is used by RuntimeDyldMachOARM to toggle the low bit
1110  // if the target symbol is Thumb.
1111  Addr = modifyAddressBasedOnFlags(Addr, Flags);
1112 
1113  LLVM_DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
1114  << format("0x%lx", Addr) << "\n");
1115  // This list may have been updated when we called getSymbolAddress, so
1116  // don't change this code to get the list earlier.
1117  RelocationList &Relocs = i->second;
1118  resolveRelocationList(Relocs, Addr);
1119  }
1120  }
1121 
1122  ExternalSymbolRelocations.erase(i);
1123  }
1124 }
1125 
1127  StringMap<JITEvaluatedSymbol> ExternalSymbolMap;
1128 
1129  // Resolution can trigger emission of more symbols, so iterate until
1130  // we've resolved *everything*.
1131  {
1132  JITSymbolResolver::LookupSet ResolvedSymbols;
1133 
1134  while (true) {
1135  JITSymbolResolver::LookupSet NewSymbols;
1136 
1137  for (auto &RelocKV : ExternalSymbolRelocations) {
1138  StringRef Name = RelocKV.first();
1139  if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
1140  !ResolvedSymbols.count(Name))
1141  NewSymbols.insert(Name);
1142  }
1143 
1144  if (NewSymbols.empty())
1145  break;
1146 
1147 #ifdef _MSC_VER
1148  using ExpectedLookupResult =
1150 #else
1151  using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>;
1152 #endif
1153 
1154  auto NewSymbolsP = std::make_shared<std::promise<ExpectedLookupResult>>();
1155  auto NewSymbolsF = NewSymbolsP->get_future();
1156  Resolver.lookup(NewSymbols,
1158  NewSymbolsP->set_value(std::move(Result));
1159  });
1160 
1161  auto NewResolverResults = NewSymbolsF.get();
1162 
1163  if (!NewResolverResults)
1164  return NewResolverResults.takeError();
1165 
1166  assert(NewResolverResults->size() == NewSymbols.size() &&
1167  "Should have errored on unresolved symbols");
1168 
1169  for (auto &RRKV : *NewResolverResults) {
1170  assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
1171  ExternalSymbolMap.insert(RRKV);
1172  ResolvedSymbols.insert(RRKV.first);
1173  }
1174  }
1175  }
1176 
1177  applyExternalSymbolRelocations(ExternalSymbolMap);
1178 
1179  return Error::success();
1180 }
1181 
1183  std::unique_ptr<RuntimeDyldImpl> This,
1184  unique_function<void(Error)> OnEmitted,
1185  std::unique_ptr<MemoryBuffer> UnderlyingBuffer) {
1186 
1187  auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This));
1188  auto PostResolveContinuation =
1189  [SharedThis, OnEmitted = std::move(OnEmitted),
1190  UnderlyingBuffer = std::move(UnderlyingBuffer)](
1192  if (!Result) {
1193  OnEmitted(Result.takeError());
1194  return;
1195  }
1196 
1197  /// Copy the result into a StringMap, where the keys are held by value.
1199  for (auto &KV : *Result)
1200  Resolved[KV.first] = KV.second;
1201 
1202  SharedThis->applyExternalSymbolRelocations(Resolved);
1203  SharedThis->resolveLocalRelocations();
1204  SharedThis->registerEHFrames();
1205  std::string ErrMsg;
1206  if (SharedThis->MemMgr.finalizeMemory(&ErrMsg))
1207  OnEmitted(make_error<StringError>(std::move(ErrMsg),
1209  else
1210  OnEmitted(Error::success());
1211  };
1212 
1214 
1215  for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
1216  StringRef Name = RelocKV.first();
1217  assert(!Name.empty() && "Symbol has no name?");
1218  assert(!SharedThis->GlobalSymbolTable.count(Name) &&
1219  "Name already processed. RuntimeDyld instances can not be re-used "
1220  "when finalizing with finalizeAsync.");
1221  Symbols.insert(Name);
1222  }
1223 
1224  if (!Symbols.empty()) {
1225  SharedThis->Resolver.lookup(Symbols, std::move(PostResolveContinuation));
1226  } else
1227  PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>());
1228 }
1229 
1230 //===----------------------------------------------------------------------===//
1231 // RuntimeDyld class implementation
1232 
1234  const object::SectionRef &Sec) const {
1235 
1236  auto I = ObjSecToIDMap.find(Sec);
1237  if (I != ObjSecToIDMap.end())
1238  return RTDyld.Sections[I->second].getLoadAddress();
1239 
1240  return 0;
1241 }
1242 
1243 void RuntimeDyld::MemoryManager::anchor() {}
1244 void JITSymbolResolver::anchor() {}
1245 void LegacyJITSymbolResolver::anchor() {}
1246 
1249  : MemMgr(MemMgr), Resolver(Resolver) {
1250  // FIXME: There's a potential issue lurking here if a single instance of
1251  // RuntimeDyld is used to load multiple objects. The current implementation
1252  // associates a single memory manager with a RuntimeDyld instance. Even
1253  // though the public class spawns a new 'impl' instance for each load,
1254  // they share a single memory manager. This can become a problem when page
1255  // permissions are applied.
1256  Dyld = nullptr;
1257  ProcessAllSections = false;
1258 }
1259 
1261 
1262 static std::unique_ptr<RuntimeDyldCOFF>
1265  JITSymbolResolver &Resolver, bool ProcessAllSections,
1266  RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1267  std::unique_ptr<RuntimeDyldCOFF> Dyld =
1268  RuntimeDyldCOFF::create(Arch, MM, Resolver);
1269  Dyld->setProcessAllSections(ProcessAllSections);
1270  Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1271  return Dyld;
1272 }
1273 
1274 static std::unique_ptr<RuntimeDyldELF>
1276  JITSymbolResolver &Resolver, bool ProcessAllSections,
1277  RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1278  std::unique_ptr<RuntimeDyldELF> Dyld =
1279  RuntimeDyldELF::create(Arch, MM, Resolver);
1280  Dyld->setProcessAllSections(ProcessAllSections);
1281  Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1282  return Dyld;
1283 }
1284 
1285 static std::unique_ptr<RuntimeDyldMachO>
1289  bool ProcessAllSections,
1290  RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1291  std::unique_ptr<RuntimeDyldMachO> Dyld =
1292  RuntimeDyldMachO::create(Arch, MM, Resolver);
1293  Dyld->setProcessAllSections(ProcessAllSections);
1294  Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1295  return Dyld;
1296 }
1297 
1298 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1300  if (!Dyld) {
1301  if (Obj.isELF())
1302  Dyld =
1303  createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1304  MemMgr, Resolver, ProcessAllSections,
1305  std::move(NotifyStubEmitted));
1306  else if (Obj.isMachO())
1307  Dyld = createRuntimeDyldMachO(
1308  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1309  ProcessAllSections, std::move(NotifyStubEmitted));
1310  else if (Obj.isCOFF())
1311  Dyld = createRuntimeDyldCOFF(
1312  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1313  ProcessAllSections, std::move(NotifyStubEmitted));
1314  else
1315  report_fatal_error("Incompatible object format!");
1316  }
1317 
1318  if (!Dyld->isCompatibleFile(Obj))
1319  report_fatal_error("Incompatible object format!");
1320 
1321  auto LoadedObjInfo = Dyld->loadObject(Obj);
1322  MemMgr.notifyObjectLoaded(*this, Obj);
1323  return LoadedObjInfo;
1324 }
1325 
1327  if (!Dyld)
1328  return nullptr;
1329  return Dyld->getSymbolLocalAddress(Name);
1330 }
1331 
1333  assert(Dyld && "No RuntimeDyld instance attached");
1334  return Dyld->getSymbolSectionID(Name);
1335 }
1336 
1338  if (!Dyld)
1339  return nullptr;
1340  return Dyld->getSymbol(Name);
1341 }
1342 
1343 std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
1344  if (!Dyld)
1345  return std::map<StringRef, JITEvaluatedSymbol>();
1346  return Dyld->getSymbolTable();
1347 }
1348 
1349 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1350 
1351 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
1352  Dyld->reassignSectionAddress(SectionID, Addr);
1353 }
1354 
1355 void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1356  uint64_t TargetAddress) {
1357  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1358 }
1359 
1360 bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1361 
1362 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1363 
1365  bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1366  MemMgr.FinalizationLocked = true;
1368  registerEHFrames();
1369  if (!MemoryFinalizationLocked) {
1370  MemMgr.finalizeMemory();
1371  MemMgr.FinalizationLocked = false;
1372  }
1373 }
1374 
1375 StringRef RuntimeDyld::getSectionContent(unsigned SectionID) const {
1376  assert(Dyld && "No Dyld instance attached");
1377  return Dyld->getSectionContent(SectionID);
1378 }
1379 
1380 uint64_t RuntimeDyld::getSectionLoadAddress(unsigned SectionID) const {
1381  assert(Dyld && "No Dyld instance attached");
1382  return Dyld->getSectionLoadAddress(SectionID);
1383 }
1384 
1386  if (Dyld)
1387  Dyld->registerEHFrames();
1388 }
1389 
1391  if (Dyld)
1392  Dyld->deregisterEHFrames();
1393 }
1394 // FIXME: Kill this with fire once we have a new JIT linker: this is only here
1395 // so that we can re-use RuntimeDyld's implementation without twisting the
1396 // interface any further for ORC's purposes.
1398  std::unique_ptr<MemoryBuffer> UnderlyingBuffer,
1400  JITSymbolResolver &Resolver, bool ProcessAllSections,
1402  std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObj,
1403  std::map<StringRef, JITEvaluatedSymbol>)>
1404  OnLoaded,
1405  unique_function<void(Error)> OnEmitted) {
1406 
1407  RuntimeDyld RTDyld(MemMgr, Resolver);
1408  RTDyld.setProcessAllSections(ProcessAllSections);
1409 
1410  auto Info = RTDyld.loadObject(Obj);
1411 
1412  if (RTDyld.hasError()) {
1413  OnEmitted(make_error<StringError>(RTDyld.getErrorString(),
1415  return;
1416  }
1417 
1418  if (auto Err = OnLoaded(std::move(Info), RTDyld.getSymbolTable()))
1419  OnEmitted(std::move(Err));
1420 
1421  RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
1422  std::move(UnderlyingBuffer));
1423 }
1424 
1425 } // end namespace llvm
static std::unique_ptr< RuntimeDyldCOFF > createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted)
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
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:42
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)
static std::unique_ptr< RuntimeDyldELF > createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted)
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:64
iterator find(StringRef Key)
Definition: StringMap.h:332
This class is the base class for all object file types.
Definition: ObjectFile.h:221
Expected< StringRef > getContents() const
Definition: ObjectFile.h:448
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
uint8_t * getAddress() const
Error takeError()
Take ownership of the stored error.
Definition: Error.h:552
std::set< StringRef > LookupSet
Definition: JITSymbol.h:327
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:126
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:436
void resolveRelocationList(const RelocationList &Relocs, uint64_t Value)
Resolves relocations from Relocs list with address from Value.
std::function< void(StringRef FileName, StringRef SectionName, StringRef SymbolName, unsigned SectionID, uint32_t StubOffset)> NotifyStubEmittedFunction
Definition: RuntimeDyld.h:67
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)
bool isText() const
Whether this section contains instructions.
Definition: ObjectFile.h:464
static bool isRequiredForExecution(const SectionRef Section)
std::map< RelocationValueRef, uintptr_t > StubMap
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
LLVM_NODISCARD bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:140
virtual void registerEHFrames()
Definition: RuntimeDyld.cpp:76
uint64_t getSectionLoadAddress(unsigned SectionID) const
If the section was loaded, return the section&#39;s load address, otherwise return None.
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)
friend void jitLinkForORC(object::ObjectFile &Obj, std::unique_ptr< MemoryBuffer > UnderlyingBuffer, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver, bool ProcessAllSections, unique_function< Error(std::unique_ptr< LoadedObjectInfo >, std::map< StringRef, JITEvaluatedSymbol >)> OnLoaded, unique_function< void(Error)> OnEmitted)
#define UINT64_MAX
Definition: DataTypes.h:83
static std::unique_ptr< RuntimeDyldMachO > createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted)
virtual ~RuntimeDyldImpl()
Definition: RuntimeDyld.cpp:69
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
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:512
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:245
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
uint64_t offsetToAlignment(uint64_t Value, llvm::Align Align)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition: Alignment.h:138
RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Construct a RuntimeDyld instance.
StringRef getSectionContent(unsigned SectionID) const
Returns the section&#39;s working memory.
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:165
bool isVirtual() const
Definition: ObjectFile.h:476
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1863
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:444
Flags for symbols in the JIT.
Definition: JITSymbol.h:56
Symbol resolution interface.
Definition: JITSymbol.h:325
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:379
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:118
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:146
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:40
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:837
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
virtual Triple::ArchType getArch() const =0
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:370
Expected< StringRef > getName() const
Definition: ObjectFile.h:432
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
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:190
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:160
size_t getSize() const
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:302
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:126
unsigned getSymbolSectionID(StringRef Name) const
Get the section ID for the section containing the given symbol.
static void finalizeAsync(std::unique_ptr< RuntimeDyldImpl > This, unique_function< void(Error)> OnEmitted, std::unique_ptr< MemoryBuffer > UnderlyingBuffer)
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:456
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:136
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:157
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)
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:83
bool isMachO() const
Definition: Binary.h:122
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: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