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