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