LLVM  7.0.0svn
RuntimeDyld.cpp
Go to the documentation of this file.
1 //===-- RuntimeDyld.cpp - Run-time dynamic linker for MC-JIT ----*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Implementation of the MC-JIT runtime dynamic linker.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "RuntimeDyldCOFF.h"
16 #include "RuntimeDyldCheckerImpl.h"
17 #include "RuntimeDyldELF.h"
18 #include "RuntimeDyldImpl.h"
19 #include "RuntimeDyldMachO.h"
20 #include "llvm/Object/COFF.h"
25 
26 using namespace llvm;
27 using namespace llvm::object;
28 
29 #define DEBUG_TYPE "dyld"
30 
31 namespace {
32 
34  GenericRTDyldError = 1
35 };
36 
37 // FIXME: This class is only here to support the transition to llvm::Error. It
38 // will be removed once this transition is complete. Clients should prefer to
39 // deal with the Error value directly, rather than converting to error_code.
40 class RuntimeDyldErrorCategory : public std::error_category {
41 public:
42  const char *name() const noexcept override { return "runtimedyld"; }
43 
44  std::string message(int Condition) const override {
45  switch (static_cast<RuntimeDyldErrorCode>(Condition)) {
46  case GenericRTDyldError: return "Generic RuntimeDyld error";
47  }
48  llvm_unreachable("Unrecognized RuntimeDyldErrorCode");
49  }
50 };
51 
52 static ManagedStatic<RuntimeDyldErrorCategory> RTDyldErrorCategory;
53 
54 }
55 
56 char RuntimeDyldError::ID = 0;
57 
59  OS << ErrMsg << "\n";
60 }
61 
62 std::error_code RuntimeDyldError::convertToErrorCode() const {
63  return std::error_code(GenericRTDyldError, *RTDyldErrorCategory);
64 }
65 
66 // Empty out-of-line virtual destructor as the key function.
68 
69 // Pin LoadedObjectInfo's vtables to this file.
71 
72 namespace llvm {
73 
75 
77  MemMgr.deregisterEHFrames();
78 }
79 
80 #ifndef NDEBUG
81 static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
82  dbgs() << "----- Contents of section " << S.getName() << " " << State
83  << " -----";
84 
85  if (S.getAddress() == nullptr) {
86  dbgs() << "\n <section not emitted>\n";
87  return;
88  }
89 
90  const unsigned ColsPerRow = 16;
91 
92  uint8_t *DataAddr = S.getAddress();
93  uint64_t LoadAddr = S.getLoadAddress();
94 
95  unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
96  unsigned BytesRemaining = S.getSize();
97 
98  if (StartPadding) {
99  dbgs() << "\n" << format("0x%016" PRIx64,
100  LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
101  while (StartPadding--)
102  dbgs() << " ";
103  }
104 
105  while (BytesRemaining > 0) {
106  if ((LoadAddr & (ColsPerRow - 1)) == 0)
107  dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":";
108 
109  dbgs() << " " << format("%02x", *DataAddr);
110 
111  ++DataAddr;
112  ++LoadAddr;
113  --BytesRemaining;
114  }
115 
116  dbgs() << "\n";
117 }
118 #endif
119 
120 // Resolve the relocations for all symbols we currently know about.
122  MutexGuard locked(lock);
123 
124  // Print out the sections prior to relocation.
125  DEBUG(
126  for (int i = 0, e = Sections.size(); i != e; ++i)
127  dumpSectionMemory(Sections[i], "before relocations");
128  );
129 
130  // First, resolve relocations associated with external symbols.
131  if (auto Err = resolveExternalSymbols()) {
132  HasError = true;
133  ErrorStr = toString(std::move(Err));
134  }
135 
136  // Iterate over all outstanding relocations
137  for (auto it = Relocations.begin(), e = Relocations.end(); it != e; ++it) {
138  // The Section here (Sections[i]) refers to the section in which the
139  // symbol for the relocation is located. The SectionID in the relocation
140  // entry provides the section to which the relocation will be applied.
141  int Idx = it->first;
142  uint64_t Addr = Sections[Idx].getLoadAddress();
143  DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
144  << format("%p", (uintptr_t)Addr) << "\n");
145  resolveRelocationList(it->second, Addr);
146  }
147  Relocations.clear();
148 
149  // Print out sections after relocation.
150  DEBUG(
151  for (int i = 0, e = Sections.size(); i != e; ++i)
152  dumpSectionMemory(Sections[i], "after relocations");
153  );
154 
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.
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 FlagsResultOrErr = Resolver.lookupFlags(Symbols))
227  SymbolFlags = std::move(*FlagsResultOrErr);
228  else
229  return FlagsResultOrErr.takeError();
230  }
231 
232  // Parse symbols
233  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  JITSymbolFlags JITSymFlags = getJITSymbolFlags(*I);
258 
259  // If this is a weak definition, check to see if there's a strong one.
260  // If there is, skip this symbol (we won't be providing it: the strong
261  // definition will). If there's no strong definition, make this definition
262  // strong.
263  if (JITSymFlags.isWeak() || JITSymFlags.isCommon()) {
264  // First check whether there's already a definition in this instance.
265  // FIXME: Override existing weak definitions with strong ones.
266  if (GlobalSymbolTable.count(Name))
267  continue;
268 
269  // Then check whether we found flags for an existing symbol during the
270  // flags lookup earlier.
271  auto FlagsI = SymbolFlags.find(Name);
272  if (FlagsI == SymbolFlags.end() ||
273  (JITSymFlags.isWeak() && !FlagsI->second.isStrong()) ||
274  (JITSymFlags.isCommon() && FlagsI->second.isCommon())) {
275  if (JITSymFlags.isWeak())
276  JITSymFlags &= ~JITSymbolFlags::Weak;
277  if (JITSymFlags.isCommon()) {
278  JITSymFlags &= ~JITSymbolFlags::Common;
279  uint32_t Align = I->getAlignment();
280  uint64_t Size = I->getCommonSize();
281  if (!CommonAlign)
282  CommonAlign = Align;
283  CommonSize += alignTo(CommonSize, Align) + Size;
284  CommonSymbolsToAllocate.push_back(*I);
285  }
286  } else
287  continue;
288  }
289 
290  if (Flags & SymbolRef::SF_Absolute &&
291  SymType != object::SymbolRef::ST_File) {
292  uint64_t Addr = 0;
293  if (auto AddrOrErr = I->getAddress())
294  Addr = *AddrOrErr;
295  else
296  return AddrOrErr.takeError();
297 
298  unsigned SectionID = AbsoluteSymbolSection;
299 
300  DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name
301  << " SID: " << SectionID
302  << " Offset: " << format("%p", (uintptr_t)Addr)
303  << " flags: " << Flags << "\n");
304  GlobalSymbolTable[Name] = SymbolTableEntry(SectionID, Addr, JITSymFlags);
305  } else if (SymType == object::SymbolRef::ST_Function ||
306  SymType == object::SymbolRef::ST_Data ||
307  SymType == object::SymbolRef::ST_Unknown ||
308  SymType == object::SymbolRef::ST_Other) {
309 
311  if (auto SIOrErr = I->getSection())
312  SI = *SIOrErr;
313  else
314  return SIOrErr.takeError();
315 
316  if (SI == Obj.section_end())
317  continue;
318 
319  // Get symbol offset.
320  uint64_t SectOffset;
321  if (auto Err = getOffset(*I, *SI, SectOffset))
322  return std::move(Err);
323 
324  bool IsCode = SI->isText();
325  unsigned SectionID;
326  if (auto SectionIDOrErr =
327  findOrEmitSection(Obj, *SI, IsCode, LocalSections))
328  SectionID = *SectionIDOrErr;
329  else
330  return SectionIDOrErr.takeError();
331 
332  DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
333  << " SID: " << SectionID
334  << " Offset: " << format("%p", (uintptr_t)SectOffset)
335  << " flags: " << Flags << "\n");
336  GlobalSymbolTable[Name] =
337  SymbolTableEntry(SectionID, SectOffset, JITSymFlags);
338  }
339  }
340 
341  // Allocate common symbols
342  if (auto Err = emitCommonSymbols(Obj, CommonSymbolsToAllocate, CommonSize,
343  CommonAlign))
344  return std::move(Err);
345 
346  // Parse and process relocations
347  DEBUG(dbgs() << "Parse relocations:\n");
348  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
349  SI != SE; ++SI) {
350  StubMap Stubs;
351  section_iterator RelocatedSection = SI->getRelocatedSection();
352 
353  if (RelocatedSection == SE)
354  continue;
355 
356  relocation_iterator I = SI->relocation_begin();
357  relocation_iterator E = SI->relocation_end();
358 
359  if (I == E && !ProcessAllSections)
360  continue;
361 
362  bool IsCode = RelocatedSection->isText();
363  unsigned SectionID = 0;
364  if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode,
365  LocalSections))
366  SectionID = *SectionIDOrErr;
367  else
368  return SectionIDOrErr.takeError();
369 
370  DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
371 
372  for (; I != E;)
373  if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs))
374  I = *IOrErr;
375  else
376  return IOrErr.takeError();
377 
378  // If there is an attached checker, notify it about the stubs for this
379  // section so that they can be verified.
380  if (Checker)
381  Checker->registerStubMap(Obj.getFileName(), SectionID, Stubs);
382  }
383 
384  // Give the subclasses a chance to tie-up any loose ends.
385  if (auto Err = finalizeLoad(Obj, LocalSections))
386  return std::move(Err);
387 
388 // for (auto E : LocalSections)
389 // llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
390 
391  return LocalSections;
392 }
393 
394 // A helper method for computeTotalAllocSize.
395 // Computes the memory size required to allocate sections with the given sizes,
396 // assuming that all sections are allocated with the given alignment
397 static uint64_t
398 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
399  uint64_t Alignment) {
400  uint64_t TotalSize = 0;
401  for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
402  uint64_t AlignedSize =
403  (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
404  TotalSize += AlignedSize;
405  }
406  return TotalSize;
407 }
408 
410  const ObjectFile *Obj = Section.getObject();
411  if (isa<object::ELFObjectFileBase>(Obj))
412  return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
413  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
414  const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
415  // Avoid loading zero-sized COFF sections.
416  // In PE files, VirtualSize gives the section size, and SizeOfRawData
417  // may be zero for sections with content. In Obj files, SizeOfRawData
418  // gives the section size, and VirtualSize is always zero. Hence
419  // the need to check for both cases below.
420  bool HasContent =
421  (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
422  bool IsDiscardable =
423  CoffSection->Characteristics &
425  return HasContent && !IsDiscardable;
426  }
427 
428  assert(isa<MachOObjectFile>(Obj));
429  return true;
430 }
431 
432 static bool isReadOnlyData(const SectionRef Section) {
433  const ObjectFile *Obj = Section.getObject();
434  if (isa<object::ELFObjectFileBase>(Obj))
435  return !(ELFSectionRef(Section).getFlags() &
437  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
438  return ((COFFObj->getCOFFSection(Section)->Characteristics &
442  ==
445 
446  assert(isa<MachOObjectFile>(Obj));
447  return false;
448 }
449 
450 static bool isZeroInit(const SectionRef Section) {
451  const ObjectFile *Obj = Section.getObject();
452  if (isa<object::ELFObjectFileBase>(Obj))
453  return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
454  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
455  return COFFObj->getCOFFSection(Section)->Characteristics &
457 
458  auto *MachO = cast<MachOObjectFile>(Obj);
459  unsigned SectionType = MachO->getSectionType(Section);
460  return SectionType == MachO::S_ZEROFILL ||
461  SectionType == MachO::S_GB_ZEROFILL;
462 }
463 
464 // Compute an upper bound of the memory size that is required to load all
465 // sections
467  uint64_t &CodeSize,
468  uint32_t &CodeAlign,
469  uint64_t &RODataSize,
470  uint32_t &RODataAlign,
471  uint64_t &RWDataSize,
472  uint32_t &RWDataAlign) {
473  // Compute the size of all sections required for execution
474  std::vector<uint64_t> CodeSectionSizes;
475  std::vector<uint64_t> ROSectionSizes;
476  std::vector<uint64_t> RWSectionSizes;
477 
478  // Collect sizes of all sections to be loaded;
479  // also determine the max alignment of all sections
480  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
481  SI != SE; ++SI) {
482  const SectionRef &Section = *SI;
483 
484  bool IsRequired = isRequiredForExecution(Section) || ProcessAllSections;
485 
486  // Consider only the sections that are required to be loaded for execution
487  if (IsRequired) {
488  uint64_t DataSize = Section.getSize();
489  uint64_t Alignment64 = Section.getAlignment();
490  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
491  bool IsCode = Section.isText();
492  bool IsReadOnly = isReadOnlyData(Section);
493 
494  StringRef Name;
495  if (auto EC = Section.getName(Name))
496  return errorCodeToError(EC);
497 
498  uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
499  uint64_t SectionSize = DataSize + StubBufSize;
500 
501  // The .eh_frame section (at least on Linux) needs an extra four bytes
502  // padded
503  // with zeroes added at the end. For MachO objects, this section has a
504  // slightly different name, so this won't have any effect for MachO
505  // objects.
506  if (Name == ".eh_frame")
507  SectionSize += 4;
508 
509  if (!SectionSize)
510  SectionSize = 1;
511 
512  if (IsCode) {
513  CodeAlign = std::max(CodeAlign, Alignment);
514  CodeSectionSizes.push_back(SectionSize);
515  } else if (IsReadOnly) {
516  RODataAlign = std::max(RODataAlign, Alignment);
517  ROSectionSizes.push_back(SectionSize);
518  } else {
519  RWDataAlign = std::max(RWDataAlign, Alignment);
520  RWSectionSizes.push_back(SectionSize);
521  }
522  }
523  }
524 
525  // Compute Global Offset Table size. If it is not zero we
526  // also update alignment, which is equal to a size of a
527  // single GOT entry.
528  if (unsigned GotSize = computeGOTSize(Obj)) {
529  RWSectionSizes.push_back(GotSize);
530  RWDataAlign = std::max<uint32_t>(RWDataAlign, getGOTEntrySize());
531  }
532 
533  // Compute the size of all common symbols
534  uint64_t CommonSize = 0;
535  uint32_t CommonAlign = 1;
536  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
537  ++I) {
538  uint32_t Flags = I->getFlags();
539  if (Flags & SymbolRef::SF_Common) {
540  // Add the common symbols to a list. We'll allocate them all below.
541  uint64_t Size = I->getCommonSize();
542  uint32_t Align = I->getAlignment();
543  // If this is the first common symbol, use its alignment as the alignment
544  // for the common symbols section.
545  if (CommonSize == 0)
546  CommonAlign = Align;
547  CommonSize = alignTo(CommonSize, Align) + Size;
548  }
549  }
550  if (CommonSize != 0) {
551  RWSectionSizes.push_back(CommonSize);
552  RWDataAlign = std::max(RWDataAlign, CommonAlign);
553  }
554 
555  // Compute the required allocation space for each different type of sections
556  // (code, read-only data, read-write data) assuming that all sections are
557  // allocated with the max alignment. Note that we cannot compute with the
558  // individual alignments of the sections, because then the required size
559  // depends on the order, in which the sections are allocated.
560  CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
561  RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
562  RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
563 
564  return Error::success();
565 }
566 
567 // compute GOT size
569  size_t GotEntrySize = getGOTEntrySize();
570  if (!GotEntrySize)
571  return 0;
572 
573  size_t GotSize = 0;
574  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
575  SI != SE; ++SI) {
576 
577  for (const RelocationRef &Reloc : SI->relocations())
578  if (relocationNeedsGot(Reloc))
579  GotSize += GotEntrySize;
580  }
581 
582  return GotSize;
583 }
584 
585 // compute stub buffer size for the given section
587  const SectionRef &Section) {
588  unsigned StubSize = getMaxStubSize();
589  if (StubSize == 0) {
590  return 0;
591  }
592  // FIXME: this is an inefficient way to handle this. We should computed the
593  // necessary section allocation size in loadObject by walking all the sections
594  // once.
595  unsigned StubBufSize = 0;
596  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
597  SI != SE; ++SI) {
598  section_iterator RelSecI = SI->getRelocatedSection();
599  if (!(RelSecI == Section))
600  continue;
601 
602  for (const RelocationRef &Reloc : SI->relocations())
603  if (relocationNeedsStub(Reloc))
604  StubBufSize += StubSize;
605  }
606 
607  // Get section data size and alignment
608  uint64_t DataSize = Section.getSize();
609  uint64_t Alignment64 = Section.getAlignment();
610 
611  // Add stubbuf size alignment
612  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
613  unsigned StubAlignment = getStubAlignment();
614  unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
615  if (StubAlignment > EndAlignment)
616  StubBufSize += StubAlignment - EndAlignment;
617  return StubBufSize;
618 }
619 
621  unsigned Size) const {
622  uint64_t Result = 0;
623  if (IsTargetLittleEndian) {
624  Src += Size - 1;
625  while (Size--)
626  Result = (Result << 8) | *Src--;
627  } else
628  while (Size--)
629  Result = (Result << 8) | *Src++;
630 
631  return Result;
632 }
633 
634 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
635  unsigned Size) const {
636  if (IsTargetLittleEndian) {
637  while (Size--) {
638  *Dst++ = Value & 0xFF;
639  Value >>= 8;
640  }
641  } else {
642  Dst += Size - 1;
643  while (Size--) {
644  *Dst-- = Value & 0xFF;
645  Value >>= 8;
646  }
647  }
648 }
649 
652 }
653 
655  CommonSymbolList &SymbolsToAllocate,
656  uint64_t CommonSize,
657  uint32_t CommonAlign) {
658  if (SymbolsToAllocate.empty())
659  return Error::success();
660 
661  // Allocate memory for the section
662  unsigned SectionID = Sections.size();
663  uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
664  "<common symbols>", false);
665  if (!Addr)
666  report_fatal_error("Unable to allocate memory for common symbols!");
667  uint64_t Offset = 0;
668  Sections.push_back(
669  SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
670  memset(Addr, 0, CommonSize);
671 
672  DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID << " new addr: "
673  << format("%p", Addr) << " DataSize: " << CommonSize << "\n");
674 
675  // Assign the address of each symbol
676  for (auto &Sym : SymbolsToAllocate) {
677  uint32_t Align = Sym.getAlignment();
678  uint64_t Size = Sym.getCommonSize();
679  StringRef Name;
680  if (auto NameOrErr = Sym.getName())
681  Name = *NameOrErr;
682  else
683  return NameOrErr.takeError();
684  if (Align) {
685  // This symbol has an alignment requirement.
686  uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
687  Addr += AlignOffset;
688  Offset += AlignOffset;
689  }
690  JITSymbolFlags JITSymFlags = getJITSymbolFlags(Sym);
691  DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
692  << format("%p", Addr) << "\n");
693  GlobalSymbolTable[Name] =
694  SymbolTableEntry(SectionID, Offset, JITSymFlags);
695  Offset += Size;
696  Addr += Size;
697  }
698 
699  if (Checker)
700  Checker->registerSection(Obj.getFileName(), SectionID);
701 
702  return Error::success();
703 }
704 
707  const SectionRef &Section,
708  bool IsCode) {
709  StringRef data;
710  uint64_t Alignment64 = Section.getAlignment();
711 
712  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
713  unsigned PaddingSize = 0;
714  unsigned StubBufSize = 0;
715  bool IsRequired = isRequiredForExecution(Section);
716  bool IsVirtual = Section.isVirtual();
717  bool IsZeroInit = isZeroInit(Section);
718  bool IsReadOnly = isReadOnlyData(Section);
719  uint64_t DataSize = Section.getSize();
720 
721  StringRef Name;
722  if (auto EC = Section.getName(Name))
723  return errorCodeToError(EC);
724 
725  StubBufSize = computeSectionStubBufSize(Obj, Section);
726 
727  // The .eh_frame section (at least on Linux) needs an extra four bytes padded
728  // with zeroes added at the end. For MachO objects, this section has a
729  // slightly different name, so this won't have any effect for MachO objects.
730  if (Name == ".eh_frame")
731  PaddingSize = 4;
732 
733  uintptr_t Allocate;
734  unsigned SectionID = Sections.size();
735  uint8_t *Addr;
736  const char *pData = nullptr;
737 
738  // If this section contains any bits (i.e. isn't a virtual or bss section),
739  // grab a reference to them.
740  if (!IsVirtual && !IsZeroInit) {
741  // In either case, set the location of the unrelocated section in memory,
742  // since we still process relocations for it even if we're not applying them.
743  if (auto EC = Section.getContents(data))
744  return errorCodeToError(EC);
745  pData = data.data();
746  }
747 
748  // Code section alignment needs to be at least as high as stub alignment or
749  // padding calculations may by incorrect when the section is remapped to a
750  // higher alignment.
751  if (IsCode) {
752  Alignment = std::max(Alignment, getStubAlignment());
753  if (StubBufSize > 0)
754  PaddingSize += getStubAlignment() - 1;
755  }
756 
757  // Some sections, such as debug info, don't need to be loaded for execution.
758  // Process those only if explicitly requested.
759  if (IsRequired || ProcessAllSections) {
760  Allocate = DataSize + PaddingSize + StubBufSize;
761  if (!Allocate)
762  Allocate = 1;
763  Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
764  Name)
765  : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
766  Name, IsReadOnly);
767  if (!Addr)
768  report_fatal_error("Unable to allocate section memory!");
769 
770  // Zero-initialize or copy the data from the image
771  if (IsZeroInit || IsVirtual)
772  memset(Addr, 0, DataSize);
773  else
774  memcpy(Addr, pData, DataSize);
775 
776  // Fill in any extra bytes we allocated for padding
777  if (PaddingSize != 0) {
778  memset(Addr + DataSize, 0, PaddingSize);
779  // Update the DataSize variable to include padding.
780  DataSize += PaddingSize;
781 
782  // Align DataSize to stub alignment if we have any stubs (PaddingSize will
783  // have been increased above to account for this).
784  if (StubBufSize > 0)
785  DataSize &= ~(getStubAlignment() - 1);
786  }
787 
788  DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
789  << " obj addr: " << format("%p", pData)
790  << " new addr: " << format("%p", Addr)
791  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
792  << " Allocate: " << Allocate << "\n");
793  } else {
794  // Even if we didn't load the section, we need to record an entry for it
795  // to handle later processing (and by 'handle' I mean don't do anything
796  // with these sections).
797  Allocate = 0;
798  Addr = nullptr;
799  DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
800  << " obj addr: " << format("%p", data.data()) << " new addr: 0"
801  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
802  << " Allocate: " << Allocate << "\n");
803  }
804 
805  Sections.push_back(
806  SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
807 
808  // Debug info sections are linked as if their load address was zero
809  if (!IsRequired)
810  Sections.back().setLoadAddress(0);
811 
812  if (Checker)
813  Checker->registerSection(Obj.getFileName(), SectionID);
814 
815  return SectionID;
816 }
817 
820  const SectionRef &Section,
821  bool IsCode,
822  ObjSectionToIDMap &LocalSections) {
823 
824  unsigned SectionID = 0;
825  ObjSectionToIDMap::iterator i = LocalSections.find(Section);
826  if (i != LocalSections.end())
827  SectionID = i->second;
828  else {
829  if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
830  SectionID = *SectionIDOrErr;
831  else
832  return SectionIDOrErr.takeError();
833  LocalSections[Section] = SectionID;
834  }
835  return SectionID;
836 }
837 
839  unsigned SectionID) {
840  Relocations[SectionID].push_back(RE);
841 }
842 
845  // Relocation by symbol. If the symbol is found in the global symbol table,
846  // create an appropriate section relocation. Otherwise, add it to
847  // ExternalSymbolRelocations.
848  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
849  if (Loc == GlobalSymbolTable.end()) {
850  ExternalSymbolRelocations[SymbolName].push_back(RE);
851  } else {
852  // Copy the RE since we want to modify its addend.
853  RelocationEntry RECopy = RE;
854  const auto &SymInfo = Loc->second;
855  RECopy.Addend += SymInfo.getOffset();
856  Relocations[SymInfo.getSectionID()].push_back(RECopy);
857  }
858 }
859 
860 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
861  unsigned AbiVariant) {
862  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be) {
863  // This stub has to be able to access the full address space,
864  // since symbol lookup won't necessarily find a handy, in-range,
865  // PLT stub for functions which could be anywhere.
866  // Stub can use ip0 (== x16) to calculate address
867  writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
868  writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
869  writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
870  writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
871  writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
872 
873  return Addr;
874  } else if (Arch == Triple::arm || Arch == Triple::armeb) {
875  // TODO: There is only ARM far stub now. We should add the Thumb stub,
876  // and stubs for branches Thumb - ARM and ARM - Thumb.
877  writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc, [pc, #-4]
878  return Addr + 4;
879  } else if (IsMipsO32ABI || IsMipsN32ABI) {
880  // 0: 3c190000 lui t9,%hi(addr).
881  // 4: 27390000 addiu t9,t9,%lo(addr).
882  // 8: 03200008 jr t9.
883  // c: 00000000 nop.
884  const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
885  const unsigned NopInstr = 0x0;
886  unsigned JrT9Instr = 0x03200008;
887  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6 ||
888  (AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
889  JrT9Instr = 0x03200009;
890 
891  writeBytesUnaligned(LuiT9Instr, Addr, 4);
892  writeBytesUnaligned(AdduiT9Instr, Addr + 4, 4);
893  writeBytesUnaligned(JrT9Instr, Addr + 8, 4);
894  writeBytesUnaligned(NopInstr, Addr + 12, 4);
895  return Addr;
896  } else if (IsMipsN64ABI) {
897  // 0: 3c190000 lui t9,%highest(addr).
898  // 4: 67390000 daddiu t9,t9,%higher(addr).
899  // 8: 0019CC38 dsll t9,t9,16.
900  // c: 67390000 daddiu t9,t9,%hi(addr).
901  // 10: 0019CC38 dsll t9,t9,16.
902  // 14: 67390000 daddiu t9,t9,%lo(addr).
903  // 18: 03200008 jr t9.
904  // 1c: 00000000 nop.
905  const unsigned LuiT9Instr = 0x3c190000, DaddiuT9Instr = 0x67390000,
906  DsllT9Instr = 0x19CC38;
907  const unsigned NopInstr = 0x0;
908  unsigned JrT9Instr = 0x03200008;
909  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_64R6)
910  JrT9Instr = 0x03200009;
911 
912  writeBytesUnaligned(LuiT9Instr, Addr, 4);
913  writeBytesUnaligned(DaddiuT9Instr, Addr + 4, 4);
914  writeBytesUnaligned(DsllT9Instr, Addr + 8, 4);
915  writeBytesUnaligned(DaddiuT9Instr, Addr + 12, 4);
916  writeBytesUnaligned(DsllT9Instr, Addr + 16, 4);
917  writeBytesUnaligned(DaddiuT9Instr, Addr + 20, 4);
918  writeBytesUnaligned(JrT9Instr, Addr + 24, 4);
919  writeBytesUnaligned(NopInstr, Addr + 28, 4);
920  return Addr;
921  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
922  // Depending on which version of the ELF ABI is in use, we need to
923  // generate one of two variants of the stub. They both start with
924  // the same sequence to load the target address into r12.
925  writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
926  writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
927  writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
928  writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
929  writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
930  if (AbiVariant == 2) {
931  // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
932  // The address is already in r12 as required by the ABI. Branch to it.
933  writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
934  writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
935  writeInt32BE(Addr+28, 0x4E800420); // bctr
936  } else {
937  // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
938  // Load the function address on r11 and sets it to control register. Also
939  // loads the function TOC in r2 and environment pointer to r11.
940  writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
941  writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
942  writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
943  writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
944  writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
945  writeInt32BE(Addr+40, 0x4E800420); // bctr
946  }
947  return Addr;
948  } else if (Arch == Triple::systemz) {
949  writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
950  writeInt16BE(Addr+2, 0x0000);
951  writeInt16BE(Addr+4, 0x0004);
952  writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
953  // 8-byte address stored at Addr + 8
954  return Addr;
955  } else if (Arch == Triple::x86_64) {
956  *Addr = 0xFF; // jmp
957  *(Addr+1) = 0x25; // rip
958  // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
959  } else if (Arch == Triple::x86) {
960  *Addr = 0xE9; // 32-bit pc-relative jump.
961  }
962  return Addr;
963 }
964 
965 // Assign an address to a symbol name and resolve all the relocations
966 // associated with it.
968  uint64_t Addr) {
969  // The address to use for relocation resolution is not
970  // the address of the local section buffer. We must be doing
971  // a remote execution environment of some sort. Relocations can't
972  // be applied until all the sections have been moved. The client must
973  // trigger this with a call to MCJIT::finalize() or
974  // RuntimeDyld::resolveRelocations().
975  //
976  // Addr is a uint64_t because we can't assume the pointer width
977  // of the target is the same as that of the host. Just use a generic
978  // "big enough" type.
979  DEBUG(dbgs() << "Reassigning address for section " << SectionID << " ("
980  << Sections[SectionID].getName() << "): "
981  << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
982  << " -> " << format("0x%016" PRIx64, Addr) << "\n");
983  Sections[SectionID].setLoadAddress(Addr);
984 }
985 
987  uint64_t Value) {
988  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
989  const RelocationEntry &RE = Relocs[i];
990  // Ignore relocations for sections that were not loaded
991  if (Sections[RE.SectionID].getAddress() == nullptr)
992  continue;
993  resolveRelocation(RE, Value);
994  }
995 }
996 
998  StringMap<JITEvaluatedSymbol> ExternalSymbolMap;
999 
1000  // Resolution can trigger emission of more symbols, so iterate until
1001  // we've resolved *everything*.
1002  {
1003  JITSymbolResolver::LookupSet ResolvedSymbols;
1004 
1005  while (true) {
1006  JITSymbolResolver::LookupSet NewSymbols;
1007 
1008  for (auto &RelocKV : ExternalSymbolRelocations) {
1009  StringRef Name = RelocKV.first();
1010  if (!Name.empty() && !GlobalSymbolTable.count(Name) &&
1011  !ResolvedSymbols.count(Name))
1012  NewSymbols.insert(Name);
1013  }
1014 
1015  if (NewSymbols.empty())
1016  break;
1017 
1018  auto NewResolverResults = Resolver.lookup(NewSymbols);
1019  if (!NewResolverResults)
1020  return NewResolverResults.takeError();
1021 
1022  for (auto &RRKV : *NewResolverResults) {
1023  assert(!ResolvedSymbols.count(RRKV.first) && "Redundant resolution?");
1024  ExternalSymbolMap.insert(RRKV);
1025  ResolvedSymbols.insert(RRKV.first);
1026  }
1027  }
1028  }
1029 
1030  while (!ExternalSymbolRelocations.empty()) {
1031 
1032  StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
1033 
1034  StringRef Name = i->first();
1035  if (Name.size() == 0) {
1036  // This is an absolute symbol, use an address of zero.
1037  DEBUG(dbgs() << "Resolving absolute relocations."
1038  << "\n");
1039  RelocationList &Relocs = i->second;
1040  resolveRelocationList(Relocs, 0);
1041  } else {
1042  uint64_t Addr = 0;
1043  JITSymbolFlags Flags;
1044  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
1045  if (Loc == GlobalSymbolTable.end()) {
1046  auto RRI = ExternalSymbolMap.find(Name);
1047  assert(RRI != ExternalSymbolMap.end() && "No result for symbol");
1048  Addr = RRI->second.getAddress();
1049  Flags = RRI->second.getFlags();
1050  // The call to getSymbolAddress may have caused additional modules to
1051  // be loaded, which may have added new entries to the
1052  // ExternalSymbolRelocations map. Consquently, we need to update our
1053  // iterator. This is also why retrieval of the relocation list
1054  // associated with this symbol is deferred until below this point.
1055  // New entries may have been added to the relocation list.
1056  i = ExternalSymbolRelocations.find(Name);
1057  } else {
1058  // We found the symbol in our global table. It was probably in a
1059  // Module that we loaded previously.
1060  const auto &SymInfo = Loc->second;
1061  Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
1062  SymInfo.getOffset();
1063  Flags = SymInfo.getFlags();
1064  }
1065 
1066  // FIXME: Implement error handling that doesn't kill the host program!
1067  if (!Addr)
1068  report_fatal_error("Program used external function '" + Name +
1069  "' which could not be resolved!");
1070 
1071  // If Resolver returned UINT64_MAX, the client wants to handle this symbol
1072  // manually and we shouldn't resolve its relocations.
1073  if (Addr != UINT64_MAX) {
1074 
1075  // Tweak the address based on the symbol flags if necessary.
1076  // For example, this is used by RuntimeDyldMachOARM to toggle the low bit
1077  // if the target symbol is Thumb.
1078  Addr = modifyAddressBasedOnFlags(Addr, Flags);
1079 
1080  DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
1081  << format("0x%lx", Addr) << "\n");
1082  // This list may have been updated when we called getSymbolAddress, so
1083  // don't change this code to get the list earlier.
1084  RelocationList &Relocs = i->second;
1085  resolveRelocationList(Relocs, Addr);
1086  }
1087  }
1088 
1089  ExternalSymbolRelocations.erase(i);
1090  }
1091 
1092  return Error::success();
1093 }
1094 
1095 //===----------------------------------------------------------------------===//
1096 // RuntimeDyld class implementation
1097 
1099  const object::SectionRef &Sec) const {
1100 
1101  auto I = ObjSecToIDMap.find(Sec);
1102  if (I != ObjSecToIDMap.end())
1103  return RTDyld.Sections[I->second].getLoadAddress();
1104 
1105  return 0;
1106 }
1107 
1108 void RuntimeDyld::MemoryManager::anchor() {}
1109 void JITSymbolResolver::anchor() {}
1110 void LegacyJITSymbolResolver::anchor() {}
1111 
1114  : MemMgr(MemMgr), Resolver(Resolver) {
1115  // FIXME: There's a potential issue lurking here if a single instance of
1116  // RuntimeDyld is used to load multiple objects. The current implementation
1117  // associates a single memory manager with a RuntimeDyld instance. Even
1118  // though the public class spawns a new 'impl' instance for each load,
1119  // they share a single memory manager. This can become a problem when page
1120  // permissions are applied.
1121  Dyld = nullptr;
1122  ProcessAllSections = false;
1123  Checker = nullptr;
1124 }
1125 
1127 
1128 static std::unique_ptr<RuntimeDyldCOFF>
1130  JITSymbolResolver &Resolver, bool ProcessAllSections,
1131  RuntimeDyldCheckerImpl *Checker) {
1132  std::unique_ptr<RuntimeDyldCOFF> Dyld =
1133  RuntimeDyldCOFF::create(Arch, MM, Resolver);
1134  Dyld->setProcessAllSections(ProcessAllSections);
1135  Dyld->setRuntimeDyldChecker(Checker);
1136  return Dyld;
1137 }
1138 
1139 static std::unique_ptr<RuntimeDyldELF>
1141  JITSymbolResolver &Resolver, bool ProcessAllSections,
1142  RuntimeDyldCheckerImpl *Checker) {
1143  std::unique_ptr<RuntimeDyldELF> Dyld =
1144  RuntimeDyldELF::create(Arch, MM, Resolver);
1145  Dyld->setProcessAllSections(ProcessAllSections);
1146  Dyld->setRuntimeDyldChecker(Checker);
1147  return Dyld;
1148 }
1149 
1150 static std::unique_ptr<RuntimeDyldMachO>
1153  bool ProcessAllSections,
1154  RuntimeDyldCheckerImpl *Checker) {
1155  std::unique_ptr<RuntimeDyldMachO> Dyld =
1156  RuntimeDyldMachO::create(Arch, MM, Resolver);
1157  Dyld->setProcessAllSections(ProcessAllSections);
1158  Dyld->setRuntimeDyldChecker(Checker);
1159  return Dyld;
1160 }
1161 
1162 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1164  if (!Dyld) {
1165  if (Obj.isELF())
1166  Dyld =
1167  createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1168  MemMgr, Resolver, ProcessAllSections, Checker);
1169  else if (Obj.isMachO())
1170  Dyld = createRuntimeDyldMachO(
1171  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1172  ProcessAllSections, Checker);
1173  else if (Obj.isCOFF())
1174  Dyld = createRuntimeDyldCOFF(
1175  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1176  ProcessAllSections, Checker);
1177  else
1178  report_fatal_error("Incompatible object format!");
1179  }
1180 
1181  if (!Dyld->isCompatibleFile(Obj))
1182  report_fatal_error("Incompatible object format!");
1183 
1184  auto LoadedObjInfo = Dyld->loadObject(Obj);
1185  MemMgr.notifyObjectLoaded(*this, Obj);
1186  return LoadedObjInfo;
1187 }
1188 
1190  if (!Dyld)
1191  return nullptr;
1192  return Dyld->getSymbolLocalAddress(Name);
1193 }
1194 
1196  if (!Dyld)
1197  return nullptr;
1198  return Dyld->getSymbol(Name);
1199 }
1200 
1201 std::map<StringRef, JITEvaluatedSymbol> RuntimeDyld::getSymbolTable() const {
1202  if (!Dyld)
1203  return std::map<StringRef, JITEvaluatedSymbol>();
1204  return Dyld->getSymbolTable();
1205 }
1206 
1207 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1208 
1209 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
1210  Dyld->reassignSectionAddress(SectionID, Addr);
1211 }
1212 
1213 void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1214  uint64_t TargetAddress) {
1215  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1216 }
1217 
1218 bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1219 
1220 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1221 
1223  bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1224  MemMgr.FinalizationLocked = true;
1226  registerEHFrames();
1227  if (!MemoryFinalizationLocked) {
1228  MemMgr.finalizeMemory();
1229  MemMgr.FinalizationLocked = false;
1230  }
1231 }
1232 
1234  if (Dyld)
1235  Dyld->registerEHFrames();
1236 }
1237 
1239  if (Dyld)
1240  Dyld->deregisterEHFrames();
1241 }
1242 
1243 } // end namespace llvm
std::map< StringRef, JITSymbolFlags > LookupFlagsResult
Definition: JITSymbol.h:293
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
std::unique_ptr< LoadedObjectInfo > loadObject(const object::ObjectFile &O)
Add the referenced object file to the list of objects to be loaded and relocated. ...
void registerEHFrames()
Register any EH frame sections that have been loaded but not previously registered with the memory ma...
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:115
bool isCommon() const
Returns true if the Common flag is set.
Definition: JITSymbol.h:98
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:136
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.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
StringRef getErrorString()
unsigned computeGOTSize(const ObjectFile &Obj)
static bool isReadOnlyData(const SectionRef Section)
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:62
iterator find(StringRef Key)
Definition: StringMap.h:335
This class is the base class for all object file types.
Definition: ObjectFile.h:190
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:677
uint8_t * getAddress() const
Error takeError()
Take ownership of the stored error.
Definition: Error.h:537
std::set< StringRef > LookupSet
Definition: JITSymbol.h:291
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.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:128
static std::unique_ptr< RuntimeDyldELF > create(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MemMgr, JITSymbolResolver &Resolver)
virtual basic_symbol_iterator symbol_begin() const =0
bool isWeak() const
Returns true if the Weak flag is set.
Definition: JITSymbol.h:93
RuntimeDyldErrorCode
Definition: RuntimeDyld.cpp:33
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
bool isCOFF() const
Definition: Binary.h:117
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:947
constexpr char SymbolName[]
Key for Kernel::Metadata::mSymbolName.
uint64_t getAddress() const
Definition: ObjectFile.h:397
void resolveRelocationList(const RelocationList &Relocs, uint64_t Value)
Resolves relocations from Relocs list with address from Value.
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)
static bool isRequiredForExecution(const SectionRef Section)
std::map< RelocationValueRef, uintptr_t > StubMap
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
virtual void registerEHFrames()
Definition: RuntimeDyld.cpp:74
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:432
static uint64_t computeAllocationSizeForSections(std::vector< uint64_t > &SectionSizes, uint64_t Alignment)
#define UINT64_MAX
Definition: DataTypes.h:83
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
virtual ~RuntimeDyldImpl()
Definition: RuntimeDyld.cpp:67
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
uint32_t getType() const
Definition: ELFObjectFile.h:98
const ObjectFile * getObject() const
Definition: ObjectFile.h:461
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:27
support::ulittle32_t Characteristics
Definition: COFF.h:440
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:148
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:433
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:78
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
Interface for looking up the initializer for a variable name, used by Init::resolveReferences.
Definition: Record.h:1794
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:405
Flags for symbols in the JIT.
Definition: JITSymbol.h:43
Symbol resolution interface.
Definition: JITSymbol.h:289
static JITSymbolFlags fromObjectSymbol(const object::BasicSymbolRef &Symbol)
Construct a JITSymbolFlags value based on the flags of the given libobject symbol.
Definition: JITSymbol.cpp:32
std::vector< SymbolRef > CommonSymbolList
virtual basic_symbol_iterator symbol_end() const =0
virtual JITSymbolFlags getJITSymbolFlags(const BasicSymbolRef &Sym)
Generate JITSymbolFlags from a libObject symbol.
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: RuntimeDyld.cpp:58
Expected< unsigned > findOrEmitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode, ObjSectionToIDMap &LocalSections)
Find Section in LocalSections.
support::ulittle32_t SizeOfRawData
Definition: COFF.h:434
Expected< uint64_t > getAddress() const
Returns the symbol virtual address (i.e.
Definition: ObjectFile.h:342
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:109
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool isLittleEndian() const
Definition: Binary.h:131
static void dumpSectionMemory(const SectionEntry &S, StringRef State)
Definition: RuntimeDyld.cpp:81
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
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:862
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
std::error_code getName(StringRef &Result) const
Definition: ObjectFile.h:393
virtual Triple::ArchType getArch() const =0
std::error_code getContents(StringRef &Result) const
Definition: ObjectFile.h:409
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:368
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:222
static std::unique_ptr< RuntimeDyldCOFF > createRuntimeDyldCOFF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
Represents a symbol that has been evaluated to an address already.
Definition: JITSymbol.h:157
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:129
size_t getSize() const
static std::unique_ptr< RuntimeDyldELF > createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
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:266
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
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: SymbolicFile.h:99
uint64_t getLoadAddress() const
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:413
static std::unique_ptr< RuntimeDyldMachO > createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
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.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
static const char * name
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
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:719
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
#define DEBUG(X)
Definition: Debug.h:118
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Expected< ObjSectionToIDMap > loadObjectImpl(const object::ObjectFile &Obj)
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:61
bool isMachO() const
Definition: Binary.h:113
S_ZEROFILL - Zero fill on demand section.
Definition: MachO.h:122
Error resolveExternalSymbols()
Resolve relocations to external symbols.
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
Map a section to its target address space value.
SectionType
These are the section type and attributes fields.
Definition: MachO.h:115
iterator end()
Definition: StringMap.h:320
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81