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