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