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