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