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"
23 #include <mutex>
24 
25 #include <future>
26 
27 using namespace llvm;
28 using namespace llvm::object;
29 
30 #define DEBUG_TYPE "dyld"
31 
32 namespace {
33 
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  std::lock_guard<sys::Mutex> 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  std::lock_guard<sys::Mutex> 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  std::lock_guard<sys::Mutex> 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  Expected<StringRef> NameOrErr = Section.getName();
539  if (!NameOrErr)
540  return NameOrErr.takeError();
541  StringRef Name = *NameOrErr;
542 
543  uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
544 
545  uint64_t PaddingSize = 0;
546  if (Name == ".eh_frame")
547  PaddingSize += 4;
548  if (StubBufSize != 0)
549  PaddingSize += getStubAlignment() - 1;
550 
551  uint64_t SectionSize = DataSize + PaddingSize + StubBufSize;
552 
553  // The .eh_frame section (at least on Linux) needs an extra four bytes
554  // padded
555  // with zeroes added at the end. For MachO objects, this section has a
556  // slightly different name, so this won't have any effect for MachO
557  // objects.
558  if (Name == ".eh_frame")
559  SectionSize += 4;
560 
561  if (!SectionSize)
562  SectionSize = 1;
563 
564  if (IsCode) {
565  CodeAlign = std::max(CodeAlign, Alignment);
566  CodeSectionSizes.push_back(SectionSize);
567  } else if (IsReadOnly) {
568  RODataAlign = std::max(RODataAlign, Alignment);
569  ROSectionSizes.push_back(SectionSize);
570  } else {
571  RWDataAlign = std::max(RWDataAlign, Alignment);
572  RWSectionSizes.push_back(SectionSize);
573  }
574  }
575  }
576 
577  // Compute Global Offset Table size. If it is not zero we
578  // also update alignment, which is equal to a size of a
579  // single GOT entry.
580  if (unsigned GotSize = computeGOTSize(Obj)) {
581  RWSectionSizes.push_back(GotSize);
582  RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
583  }
584 
585  // Compute the size of all common symbols
586  uint64_t CommonSize = 0;
587  uint32_t CommonAlign = 1;
588  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
589  ++I) {
590  uint32_t Flags = I->getFlags();
591  if (Flags & SymbolRef::SF_Common) {
592  // Add the common symbols to a list. We'll allocate them all below.
593  uint64_t Size = I->getCommonSize();
594  uint32_t Align = I->getAlignment();
595  // If this is the first common symbol, use its alignment as the alignment
596  // for the common symbols section.
597  if (CommonSize == 0)
598  CommonAlign = Align;
599  CommonSize = alignTo(CommonSize, Align) + Size;
600  }
601  }
602  if (CommonSize != 0) {
603  RWSectionSizes.push_back(CommonSize);
604  RWDataAlign = std::max(RWDataAlign, CommonAlign);
605  }
606 
607  // Compute the required allocation space for each different type of sections
608  // (code, read-only data, read-write data) assuming that all sections are
609  // allocated with the max alignment. Note that we cannot compute with the
610  // individual alignments of the sections, because then the required size
611  // depends on the order, in which the sections are allocated.
612  CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
613  RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
614  RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
615 
616  return Error::success();
617 }
618 
619 // compute GOT size
621  size_t GotEntrySize = getGOTEntrySize();
622  if (!GotEntrySize)
623  return 0;
624 
625  size_t GotSize = 0;
626  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
627  SI != SE; ++SI) {
628 
629  for (const RelocationRef &Reloc : SI->relocations())
630  if (relocationNeedsGot(Reloc))
631  GotSize += GotEntrySize;
632  }
633 
634  return GotSize;
635 }
636 
637 // compute stub buffer size for the given section
639  const SectionRef &Section) {
640  unsigned StubSize = getMaxStubSize();
641  if (StubSize == 0) {
642  return 0;
643  }
644  // FIXME: this is an inefficient way to handle this. We should computed the
645  // necessary section allocation size in loadObject by walking all the sections
646  // once.
647  unsigned StubBufSize = 0;
648  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
649  SI != SE; ++SI) {
650  section_iterator RelSecI = SI->getRelocatedSection();
651  if (!(RelSecI == Section))
652  continue;
653 
654  for (const RelocationRef &Reloc : SI->relocations())
655  if (relocationNeedsStub(Reloc))
656  StubBufSize += StubSize;
657  }
658 
659  // Get section data size and alignment
660  uint64_t DataSize = Section.getSize();
661  uint64_t Alignment64 = Section.getAlignment();
662 
663  // Add stubbuf size alignment
664  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
665  unsigned StubAlignment = getStubAlignment();
666  unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
667  if (StubAlignment > EndAlignment)
668  StubBufSize += StubAlignment - EndAlignment;
669  return StubBufSize;
670 }
671 
673  unsigned Size) const {
674  uint64_t Result = 0;
675  if (IsTargetLittleEndian) {
676  Src += Size - 1;
677  while (Size--)
678  Result = (Result << 8) | *Src--;
679  } else
680  while (Size--)
681  Result = (Result << 8) | *Src++;
682 
683  return Result;
684 }
685 
686 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
687  unsigned Size) const {
688  if (IsTargetLittleEndian) {
689  while (Size--) {
690  *Dst++ = Value & 0xFF;
691  Value >>= 8;
692  }
693  } else {
694  Dst += Size - 1;
695  while (Size--) {
696  *Dst-- = Value & 0xFF;
697  Value >>= 8;
698  }
699  }
700 }
701 
705 }
706 
708  CommonSymbolList &SymbolsToAllocate,
709  uint64_t CommonSize,
710  uint32_t CommonAlign) {
711  if (SymbolsToAllocate.empty())
712  return Error::success();
713 
714  // Allocate memory for the section
715  unsigned SectionID = Sections.size();
716  uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
717  "<common symbols>", false);
718  if (!Addr)
719  report_fatal_error("Unable to allocate memory for common symbols!");
720  uint64_t Offset = 0;
721  Sections.push_back(
722  SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
723  memset(Addr, 0, CommonSize);
724 
725  LLVM_DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID
726  << " new addr: " << format("%p", Addr)
727  << " DataSize: " << CommonSize << "\n");
728 
729  // Assign the address of each symbol
730  for (auto &Sym : SymbolsToAllocate) {
731  uint32_t Align = Sym.getAlignment();
732  uint64_t Size = Sym.getCommonSize();
733  StringRef Name;
734  if (auto NameOrErr = Sym.getName())
735  Name = *NameOrErr;
736  else
737  return NameOrErr.takeError();
738  if (Align) {
739  // This symbol has an alignment requirement.
740  uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
741  Addr += AlignOffset;
742  Offset += AlignOffset;
743  }
744  auto JITSymFlags = getJITSymbolFlags(Sym);
745 
746  if (!JITSymFlags)
747  return JITSymFlags.takeError();
748 
749  LLVM_DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
750  << format("%p", Addr) << "\n");
751  GlobalSymbolTable[Name] =
752  SymbolTableEntry(SectionID, Offset, std::move(*JITSymFlags));
753  Offset += Size;
754  Addr += Size;
755  }
756 
757  return Error::success();
758 }
759 
762  const SectionRef &Section,
763  bool IsCode) {
764  StringRef data;
765  uint64_t Alignment64 = Section.getAlignment();
766 
767  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
768  unsigned PaddingSize = 0;
769  unsigned StubBufSize = 0;
770  bool IsRequired = isRequiredForExecution(Section);
771  bool IsVirtual = Section.isVirtual();
772  bool IsZeroInit = isZeroInit(Section);
773  bool IsReadOnly = isReadOnlyData(Section);
774  uint64_t DataSize = Section.getSize();
775 
776  // An alignment of 0 (at least with ELF) is identical to an alignment of 1,
777  // while being more "polite". Other formats do not support 0-aligned sections
778  // anyway, so we should guarantee that the alignment is always at least 1.
779  Alignment = std::max(1u, Alignment);
780 
781  Expected<StringRef> NameOrErr = Section.getName();
782  if (!NameOrErr)
783  return NameOrErr.takeError();
784  StringRef Name = *NameOrErr;
785 
786  StubBufSize = computeSectionStubBufSize(Obj, Section);
787 
788  // The .eh_frame section (at least on Linux) needs an extra four bytes padded
789  // with zeroes added at the end. For MachO objects, this section has a
790  // slightly different name, so this won't have any effect for MachO objects.
791  if (Name == ".eh_frame")
792  PaddingSize = 4;
793 
794  uintptr_t Allocate;
795  unsigned SectionID = Sections.size();
796  uint8_t *Addr;
797  const char *pData = nullptr;
798 
799  // If this section contains any bits (i.e. isn't a virtual or bss section),
800  // grab a reference to them.
801  if (!IsVirtual && !IsZeroInit) {
802  // In either case, set the location of the unrelocated section in memory,
803  // since we still process relocations for it even if we're not applying them.
804  if (Expected<StringRef> E = Section.getContents())
805  data = *E;
806  else
807  return E.takeError();
808  pData = data.data();
809  }
810 
811  // If there are any stubs then the section alignment needs to be at least as
812  // high as stub alignment or padding calculations may by incorrect when the
813  // section is remapped.
814  if (StubBufSize != 0) {
815  Alignment = std::max(Alignment, getStubAlignment());
816  PaddingSize += getStubAlignment() - 1;
817  }
818 
819  // Some sections, such as debug info, don't need to be loaded for execution.
820  // Process those only if explicitly requested.
821  if (IsRequired || ProcessAllSections) {
822  Allocate = DataSize + PaddingSize + StubBufSize;
823  if (!Allocate)
824  Allocate = 1;
825  Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
826  Name)
827  : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
828  Name, IsReadOnly);
829  if (!Addr)
830  report_fatal_error("Unable to allocate section memory!");
831 
832  // Zero-initialize or copy the data from the image
833  if (IsZeroInit || IsVirtual)
834  memset(Addr, 0, DataSize);
835  else
836  memcpy(Addr, pData, DataSize);
837 
838  // Fill in any extra bytes we allocated for padding
839  if (PaddingSize != 0) {
840  memset(Addr + DataSize, 0, PaddingSize);
841  // Update the DataSize variable to include padding.
842  DataSize += PaddingSize;
843 
844  // Align DataSize to stub alignment if we have any stubs (PaddingSize will
845  // have been increased above to account for this).
846  if (StubBufSize > 0)
847  DataSize &= -(uint64_t)getStubAlignment();
848  }
849 
850  LLVM_DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: "
851  << Name << " obj addr: " << format("%p", pData)
852  << " new addr: " << format("%p", Addr) << " DataSize: "
853  << DataSize << " StubBufSize: " << StubBufSize
854  << " Allocate: " << Allocate << "\n");
855  } else {
856  // Even if we didn't load the section, we need to record an entry for it
857  // to handle later processing (and by 'handle' I mean don't do anything
858  // with these sections).
859  Allocate = 0;
860  Addr = nullptr;
861  LLVM_DEBUG(
862  dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
863  << " obj addr: " << format("%p", data.data()) << " new addr: 0"
864  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
865  << " Allocate: " << Allocate << "\n");
866  }
867 
868  Sections.push_back(
869  SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
870 
871  // Debug info sections are linked as if their load address was zero
872  if (!IsRequired)
873  Sections.back().setLoadAddress(0);
874 
875  return SectionID;
876 }
877 
880  const SectionRef &Section,
881  bool IsCode,
882  ObjSectionToIDMap &LocalSections) {
883 
884  unsigned SectionID = 0;
885  ObjSectionToIDMap::iterator i = LocalSections.find(Section);
886  if (i != LocalSections.end())
887  SectionID = i->second;
888  else {
889  if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
890  SectionID = *SectionIDOrErr;
891  else
892  return SectionIDOrErr.takeError();
893  LocalSections[Section] = SectionID;
894  }
895  return SectionID;
896 }
897 
899  unsigned SectionID) {
900  Relocations[SectionID].push_back(RE);
901 }
902 
905  // Relocation by symbol. If the symbol is found in the global symbol table,
906  // create an appropriate section relocation. Otherwise, add it to
907  // ExternalSymbolRelocations.
908  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
909  if (Loc == GlobalSymbolTable.end()) {
910  ExternalSymbolRelocations[SymbolName].push_back(RE);
911  } else {
912  // Copy the RE since we want to modify its addend.
913  RelocationEntry RECopy = RE;
914  const auto &SymInfo = Loc->second;
915  RECopy.Addend += SymInfo.getOffset();
916  Relocations[SymInfo.getSectionID()].push_back(RECopy);
917  }
918 }
919 
920 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
921  unsigned AbiVariant) {
922  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be) {
923  // This stub has to be able to access the full address space,
924  // since symbol lookup won't necessarily find a handy, in-range,
925  // PLT stub for functions which could be anywhere.
926  // Stub can use ip0 (== x16) to calculate address
927  writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
928  writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
929  writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
930  writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
931  writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
932 
933  return Addr;
934  } else if (Arch == Triple::arm || Arch == Triple::armeb) {
935  // TODO: There is only ARM far stub now. We should add the Thumb stub,
936  // and stubs for branches Thumb - ARM and ARM - Thumb.
937  writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
938  return Addr + 4;
939  } else if (IsMipsO32ABI || IsMipsN32ABI) {
940  // 0: 3c190000 lui t9,%hi(addr).
941  // 4: 27390000 addiu t9,t9,%lo(addr).
942  // 8: 03200008 jr t9.
943  // c: 00000000 nop.
944  const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
945  const unsigned NopInstr = 0x0;
946  unsigned JrT9Instr = 0x03200008;
947  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 ||
948  (AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
949  JrT9Instr = 0x03200009;
950 
951  writeBytesUnaligned(LuiT9Instr, Addr, 4);
952  writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
953  writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
954  writeBytesUnaligned(NopInstr, Addr + 12, 4);
955  return Addr;
956  } else if (IsMipsN64ABI) {
957  // 0: 3c190000 lui t9,%highest(addr).
958  // 4: 67390000 daddiu t9,t9,%higher(addr).
959  // 8: 0019CC38 dsll t9,t9,16.
960  // c: 67390000 daddiu t9,t9,%hi(addr).
961  // 10: 0019CC38 dsll t9,t9,16.
962  // 14: 67390000 daddiu t9,t9,%lo(addr).
963  // 18: 03200008 jr t9.
964  // 1c: 00000000 nop.
965  const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000,
966  DsllT9Instr = 0x19CC38;
967  const unsigned NopInstr = 0x0;
968  unsigned JrT9Instr = 0x03200008;
969  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
970  JrT9Instr = 0x03200009;
971 
972  writeBytesUnaligned(LuiT9Instr, Addr, 4);
973  writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
974  writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
975  writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
976  writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
977  writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
978  writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
979  writeBytesUnaligned(NopInstr, Addr + 28, 4);
980  return Addr;
981  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
982  // Depending on which version of the ELF ABI is in use, we need to
983  // generate one of two variants of the stub. They both start with
984  // the same sequence to load the target address into r12.
985  writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
986  writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
987  writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
988  writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
989  writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
990  if (AbiVariant == 2) {
991  // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
992  // The address is already in r12 as required by the ABI. Branch to it.
993  writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
994  writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
995  writeInt32BE(Addr+28, 0x4E800420); // bctr
996  } else {
997  // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
998  // Load the function address on r11 and sets it to control register. Also
999  // loads the function TOC in r2 and environment pointer to r11.
1000  writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
1001  writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
1002  writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
1003  writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
1004  writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
1005  writeInt32BE(Addr+40, 0x4E800420); // bctr
1006  }
1007  return Addr;
1008  } else if (Arch == Triple::systemz) {
1009  writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
1010  writeInt16BE(Addr+2, 0x0000);
1011  writeInt16BE(Addr+4, 0x0004);
1012  writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
1013  // 8-byte address stored at Addr + 8
1014  return Addr;
1015  } else if (Arch == Triple::x86_64) {
1016  *Addr = 0xFF; // jmp
1017  *(Addr+1) = 0x25; // rip
1018  // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
1019  } else if (Arch == Triple::x86) {
1020  *Addr = 0xE9; // 32-bit pc-relative jump.
1021  }
1022  return Addr;
1023 }
1024 
1025 // Assign an address to a symbol name and resolve all the relocations
1026 // associated with it.
1028  uint64_t Addr) {
1029  // The address to use for relocation resolution is not
1030  // the address of the local section buffer. We must be doing
1031  // a remote execution environment of some sort. Relocations can't
1032  // be applied until all the sections have been moved. The client must
1033  // trigger this with a call to MCJIT::finalize() or
1034  // RuntimeDyld::resolveRelocations().
1035  //
1036  // Addr is a uint64_t because we can't assume the pointer width
1037  // of the target is the same as that of the host. Just use a generic
1038  // "big enough" type.
1039  LLVM_DEBUG(
1040  dbgs() << "Reassigning address for section " << SectionID << " ("
1041  << Sections[SectionID].getName() << "): "
1042  << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
1043  << " -> " << format("0x%016" PRIx64, Addr) << "\n");
1044  Sections[SectionID].setLoadAddress(Addr);
1045 }
1046 
1048  uint64_t Value) {
1049  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
1050  const RelocationEntry &RE = Relocs[i];
1051  // Ignore relocations for sections that were not loaded
1052  if (Sections[RE.SectionID].getAddress() == nullptr)
1053  continue;
1054  resolveRelocation(RE, Value);
1055  }
1056 }
1057 
1059  const StringMap<JITEvaluatedSymbol> ExternalSymbolMap) {
1060  while (!ExternalSymbolRelocations.empty()) {
1061 
1062  StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
1063 
1064  StringRef Name = i->first();
1065  if (Name.size() == 0) {
1066  // This is an absolute symbol, use an address of zero.
1067  LLVM_DEBUG(dbgs() << "Resolving absolute relocations."
1068  << "\n");
1069  RelocationList &Relocs = i->second;
1070  resolveRelocationList(Relocs, 0);
1071  } else {
1072  uint64_t Addr = 0;
1073  JITSymbolFlags Flags;
1074  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
1075  if (Loc == GlobalSymbolTable.end()) {
1076  auto RRI = ExternalSymbolMap.find(Name);
1077  assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
1078  Addr = RRI->second.getAddress();
1079  Flags = RRI->second.getFlags();
1080  // The call to getSymbolAddress may have caused additional modules to
1081  // be loaded, which may have added new entries to the
1082  // ExternalSymbolRelocations map. Consquently, we need to update our
1083  // iterator. This is also why retrieval of the relocation list
1084  // associated with this symbol is deferred until below this point.
1085  // New entries may have been added to the relocation list.
1086  i = ExternalSymbolRelocations.find(Name);
1087  } else {
1088  // We found the symbol in our global table. It was probably in a
1089  // Module that we loaded previously.
1090  const auto &SymInfo = Loc->second;
1091  Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
1092  SymInfo.getOffset();
1093  Flags = SymInfo.getFlags();
1094  }
1095 
1096  // FIXME: Implement error handling that doesn't kill the host program!
1097  if (!Addr)
1098  report_fatal_error("Program used external function '" + Name +
1099  "' which could not be resolved!");
1100 
1101  // If Resolver returned UINT64_MAX, the client wants to handle this symbol
1102  // manually and we shouldn't resolve its relocations.
1103  if (Addr != UINT64_MAX) {
1104 
1105  // Tweak the address based on the symbol flags if necessary.
1106  // For example, this is used by RuntimeDyldMachOARM to toggle the low bit
1107  // if the target symbol is Thumb.
1108  Addr = modifyAddressBasedOnFlags(Addr, Flags);
1109 
1110  LLVM_DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
1111  << format("0x%lx", Addr) << "\n");
1112  // This list may have been updated when we called getSymbolAddress, so
1113  // don't change this code to get the list earlier.
1114  RelocationList &Relocs = i->second;
1115  resolveRelocationList(Relocs, Addr);
1116  }
1117  }
1118 
1119  ExternalSymbolRelocations.erase(i);
1120  }
1121 }
1122 
1124  StringMap<JITEvaluatedSymbol> ExternalSymbolMap;
1125 
1126  // Resolution can trigger emission of more symbols, so iterate until
1127  // we've resolved *everything*.
1128  {
1129  JITSymbolResolver::LookupSet ResolvedSymbols;
1130 
1131  while (true) {
1132  JITSymbolResolver::LookupSet NewSymbols;
1133 
1134  for (auto &RelocKV : ExternalSymbolRelocations) {
1135  StringRef Name = RelocKV.first();
1136  if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
1137  !ResolvedSymbols.count(Name))
1138  NewSymbols.insert(Name);
1139  }
1140 
1141  if (NewSymbols.empty())
1142  break;
1143 
1144 #ifdef _MSC_VER
1145  using ExpectedLookupResult =
1147 #else
1148  using ExpectedLookupResult = Expected<JITSymbolResolver::LookupResult>;
1149 #endif
1150 
1151  auto NewSymbolsP = std::make_shared<std::promise<ExpectedLookupResult>>();
1152  auto NewSymbolsF = NewSymbolsP->get_future();
1153  Resolver.lookup(NewSymbols,
1155  NewSymbolsP->set_value(std::move(Result));
1156  });
1157 
1158  auto NewResolverResults = NewSymbolsF.get();
1159 
1160  if (!NewResolverResults)
1161  return NewResolverResults.takeError();
1162 
1163  assert(NewResolverResults->size() == NewSymbols.size() &&
1164  "Should have errored on unresolved symbols");
1165 
1166  for (auto &RRKV : *NewResolverResults) {
1167  assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
1168  ExternalSymbolMap.insert(RRKV);
1169  ResolvedSymbols.insert(RRKV.first);
1170  }
1171  }
1172  }
1173 
1174  applyExternalSymbolRelocations(ExternalSymbolMap);
1175 
1176  return Error::success();
1177 }
1178 
1180  std::unique_ptr<RuntimeDyldImpl> This, std::function<void(Error)> OnEmitted,
1181  std::unique_ptr<MemoryBuffer> UnderlyingBuffer) {
1182 
1183  // FIXME: Move-capture OnRelocsApplied and UnderlyingBuffer once we have
1184  // c++14.
1185  auto SharedUnderlyingBuffer =
1186  std::shared_ptr<MemoryBuffer>(std::move(UnderlyingBuffer));
1187  auto SharedThis = std::shared_ptr<RuntimeDyldImpl>(std::move(This));
1188  auto PostResolveContinuation =
1189  [SharedThis, OnEmitted, SharedUnderlyingBuffer](
1191  if (!Result) {
1192  OnEmitted(Result.takeError());
1193  return;
1194  }
1195 
1196  /// Copy the result into a StringMap, where the keys are held by value.
1198  for (auto &KV : *Result)
1199  Resolved[KV.first] = KV.second;
1200 
1201  SharedThis->applyExternalSymbolRelocations(Resolved);
1202  SharedThis->resolveLocalRelocations();
1203  SharedThis->registerEHFrames();
1204  std::string ErrMsg;
1205  if (SharedThis->MemMgr.finalizeMemory(&ErrMsg))
1206  OnEmitted(make_error<StringError>(std::move(ErrMsg),
1208  else
1209  OnEmitted(Error::success());
1210  };
1211 
1213 
1214  for (auto &RelocKV : SharedThis->ExternalSymbolRelocations) {
1215  StringRef Name = RelocKV.first();
1216  assert(!Name.empty() && "Symbol has no name?");
1217  assert(!SharedThis->GlobalSymbolTable.count(Name) &&
1218  "Name already processed. RuntimeDyld instances can not be re-used "
1219  "when finalizing with finalizeAsync.");
1220  Symbols.insert(Name);
1221  }
1222 
1223  if (!Symbols.empty()) {
1224  SharedThis->Resolver.lookup(Symbols, PostResolveContinuation);
1225  } else
1226  PostResolveContinuation(std::map<StringRef, JITEvaluatedSymbol>());
1227 }
1228 
1229 //===----------------------------------------------------------------------===//
1230 // RuntimeDyld class implementation
1231 
1233  const object::SectionRef &Sec) const {
1234 
1235  auto I = ObjSecToIDMap.find(Sec);
1236  if (I != ObjSecToIDMap.end())
1237  return RTDyld.Sections[I->second].getLoadAddress();
1238 
1239  return 0;
1240 }
1241 
1242 void RuntimeDyld::MemoryManager::anchor() {}
1243 void JITSymbolResolver::anchor() {}
1244 void LegacyJITSymbolResolver::anchor() {}
1245 
1248  : MemMgr(MemMgr), Resolver(Resolver) {
1249  // FIXME: There's a potential issue lurking here if a single instance of
1250  // RuntimeDyld is used to load multiple objects. The current implementation
1251  // associates a single memory manager with a RuntimeDyld instance. Even
1252  // though the public class spawns a new 'impl' instance for each load,
1253  // they share a single memory manager. This can become a problem when page
1254  // permissions are applied.
1255  Dyld = nullptr;
1256  ProcessAllSections = false;
1257 }
1258 
1260 
1261 static std::unique_ptr<RuntimeDyldCOFF>
1264  JITSymbolResolver &Resolver, bool ProcessAllSections,
1265  RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1266  std::unique_ptr<RuntimeDyldCOFF> Dyld =
1267  RuntimeDyldCOFF::create(Arch, MM, Resolver);
1268  Dyld->setProcessAllSections(ProcessAllSections);
1269  Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1270  return Dyld;
1271 }
1272 
1273 static std::unique_ptr<RuntimeDyldELF>
1275  JITSymbolResolver &Resolver, bool ProcessAllSections,
1276  RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1277  std::unique_ptr<RuntimeDyldELF> Dyld =
1278  RuntimeDyldELF::create(Arch, MM, Resolver);
1279  Dyld->setProcessAllSections(ProcessAllSections);
1280  Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1281  return Dyld;
1282 }
1283 
1284 static std::unique_ptr<RuntimeDyldMachO>
1288  bool ProcessAllSections,
1289  RuntimeDyld::NotifyStubEmittedFunction NotifyStubEmitted) {
1290  std::unique_ptr<RuntimeDyldMachO> Dyld =
1291  RuntimeDyldMachO::create(Arch, MM, Resolver);
1292  Dyld->setProcessAllSections(ProcessAllSections);
1293  Dyld->setNotifyStubEmitted(std::move(NotifyStubEmitted));
1294  return Dyld;
1295 }
1296 
1297 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1299  if (!Dyld) {
1300  if (Obj.isELF())
1301  Dyld =
1302  createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1303  MemMgr, Resolver, ProcessAllSections,
1304  std::move(NotifyStubEmitted));
1305  else if (Obj.isMachO())
1306  Dyld = createRuntimeDyldMachO(
1307  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1308  ProcessAllSections, std::move(NotifyStubEmitted));
1309  else if (Obj.isCOFF())
1310  Dyld = createRuntimeDyldCOFF(
1311  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1312  ProcessAllSections, std::move(NotifyStubEmitted));
1313  else
1314  report_fatal_error("Incompatible object format!");
1315  }
1316 
1317  if (!Dyld->isCompatibleFile(Obj))
1318  report_fatal_error("Incompatible object format!");
1319 
1320  auto LoadedObjInfo = Dyld->loadObject(Obj);
1321  MemMgr.notifyObjectLoaded(*this, Obj);
1322  return LoadedObjInfo;
1323 }
1324 
1326  if (!Dyld)
1327  return nullptr;
1328  return Dyld->getSymbolLocalAddress(Name);
1329 }
1330 
1332  assert(Dyld && "No RuntimeDyld instance attached");
1333  return Dyld->getSymbolSectionID(Name);
1334 }
1335 
1337  if (!Dyld)
1338  return nullptr;
1339  return Dyld->getSymbol(Name);
1340 }
1341 
1342 std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
1343  if (!Dyld)
1344  return std::map<StringRef, JITEvaluatedSymbol>();
1345  return Dyld->getSymbolTable();
1346 }
1347 
1348 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1349 
1350 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
1351  Dyld->reassignSectionAddress(SectionID, Addr);
1352 }
1353 
1354 void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1355  uint64_t TargetAddress) {
1356  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1357 }
1358 
1359 bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1360 
1361 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1362 
1364  bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1365  MemMgr.FinalizationLocked = true;
1367  registerEHFrames();
1368  if (!MemoryFinalizationLocked) {
1369  MemMgr.finalizeMemory();
1370  MemMgr.FinalizationLocked = false;
1371  }
1372 }
1373 
1374 StringRef RuntimeDyld::getSectionContent(unsigned SectionID) const {
1375  assert(Dyld && "No Dyld instance attached");
1376  return Dyld->getSectionContent(SectionID);
1377 }
1378 
1379 uint64_t RuntimeDyld::getSectionLoadAddress(unsigned SectionID) const {
1380  assert(Dyld && "No Dyld instance attached");
1381  return Dyld->getSectionLoadAddress(SectionID);
1382 }
1383 
1385  if (Dyld)
1386  Dyld->registerEHFrames();
1387 }
1388 
1390  if (Dyld)
1391  Dyld->deregisterEHFrames();
1392 }
1393 // FIXME: Kill this with fire once we have a new JIT linker: this is only here
1394 // so that we can re-use RuntimeDyld's implementation without twisting the
1395 // interface any further for ORC's purposes.
1397  std::unique_ptr<MemoryBuffer> UnderlyingBuffer,
1399  JITSymbolResolver &Resolver, bool ProcessAllSections,
1401  std::unique_ptr<RuntimeDyld::LoadedObjectInfo> LoadedObj,
1402  std::map<StringRef, JITEvaluatedSymbol>)>
1403  OnLoaded,
1404  std::function<void(Error)> OnEmitted) {
1405 
1406  RuntimeDyld RTDyld(MemMgr, Resolver);
1407  RTDyld.setProcessAllSections(ProcessAllSections);
1408 
1409  auto Info = RTDyld.loadObject(Obj);
1410 
1411  if (RTDyld.hasError()) {
1412  OnEmitted(make_error<StringError>(RTDyld.getErrorString(),
1414  return;
1415  }
1416 
1417  if (auto Err = OnLoaded(std::move(Info), RTDyld.getSymbolTable()))
1418  OnEmitted(std::move(Err));
1419 
1420  RuntimeDyldImpl::finalizeAsync(std::move(RTDyld.Dyld), std::move(OnEmitted),
1421  std::move(UnderlyingBuffer));
1422 }
1423 
1424 } // 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: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: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:453
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: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: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:966
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
uint64_t getAddress() const
Definition: ObjectFile.h:441
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:469
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: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:517
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.
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:481
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:1863
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:449
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: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: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.
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
Expected< StringRef > getName() const
Definition: ObjectFile.h:437
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
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:126
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:461
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:73
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:731
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: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: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