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