LLVM  4.0.0
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 "RuntimeDyldCheckerImpl.h"
16 #include "RuntimeDyldCOFF.h"
17 #include "RuntimeDyldELF.h"
18 #include "RuntimeDyldImpl.h"
19 #include "RuntimeDyldMachO.h"
21 #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 
78 #ifndef NDEBUG
79 static void dumpSectionMemory(const SectionEntry &S, StringRef State) {
80  dbgs() << "----- Contents of section " << S.getName() << " " << State
81  << " -----";
82 
83  if (S.getAddress() == nullptr) {
84  dbgs() << "\n <section not emitted>\n";
85  return;
86  }
87 
88  const unsigned ColsPerRow = 16;
89 
90  uint8_t *DataAddr = S.getAddress();
91  uint64_t LoadAddr = S.getLoadAddress();
92 
93  unsigned StartPadding = LoadAddr & (ColsPerRow - 1);
94  unsigned BytesRemaining = S.getSize();
95 
96  if (StartPadding) {
97  dbgs() << "\n" << format("0x%016" PRIx64,
98  LoadAddr & ~(uint64_t)(ColsPerRow - 1)) << ":";
99  while (StartPadding--)
100  dbgs() << " ";
101  }
102 
103  while (BytesRemaining > 0) {
104  if ((LoadAddr & (ColsPerRow - 1)) == 0)
105  dbgs() << "\n" << format("0x%016" PRIx64, LoadAddr) << ":";
106 
107  dbgs() << " " << format("%02x", *DataAddr);
108 
109  ++DataAddr;
110  ++LoadAddr;
111  --BytesRemaining;
112  }
113 
114  dbgs() << "\n";
115 }
116 #endif
117 
118 // Resolve the relocations for all symbols we currently know about.
120  MutexGuard locked(lock);
121 
122  // Print out the sections prior to relocation.
123  DEBUG(
124  for (int i = 0, e = Sections.size(); i != e; ++i)
125  dumpSectionMemory(Sections[i], "before relocations");
126  );
127 
128  // First, resolve relocations associated with external symbols.
129  resolveExternalSymbols();
130 
131  // Iterate over all outstanding relocations
132  for (auto it = Relocations.begin(), e = Relocations.end(); it != e; ++it) {
133  // The Section here (Sections[i]) refers to the section in which the
134  // symbol for the relocation is located. The SectionID in the relocation
135  // entry provides the section to which the relocation will be applied.
136  int Idx = it->first;
137  uint64_t Addr = Sections[Idx].getLoadAddress();
138  DEBUG(dbgs() << "Resolving relocations Section #" << Idx << "\t"
139  << format("%p", (uintptr_t)Addr) << "\n");
140  resolveRelocationList(it->second, Addr);
141  }
142  Relocations.clear();
143 
144  // Print out sections after relocation.
145  DEBUG(
146  for (int i = 0, e = Sections.size(); i != e; ++i)
147  dumpSectionMemory(Sections[i], "after relocations");
148  );
149 
150 }
151 
152 void RuntimeDyldImpl::mapSectionAddress(const void *LocalAddress,
153  uint64_t TargetAddress) {
154  MutexGuard locked(lock);
155  for (unsigned i = 0, e = Sections.size(); i != e; ++i) {
156  if (Sections[i].getAddress() == LocalAddress) {
157  reassignSectionAddress(i, TargetAddress);
158  return;
159  }
160  }
161  llvm_unreachable("Attempting to remap address of unknown section!");
162 }
163 
164 static Error getOffset(const SymbolRef &Sym, SectionRef Sec,
165  uint64_t &Result) {
166  Expected<uint64_t> AddressOrErr = Sym.getAddress();
167  if (!AddressOrErr)
168  return AddressOrErr.takeError();
169  Result = *AddressOrErr - Sec.getAddress();
170  return Error::success();
171 }
172 
175  MutexGuard locked(lock);
176 
177  // Save information about our target
178  Arch = (Triple::ArchType)Obj.getArch();
179  IsTargetLittleEndian = Obj.isLittleEndian();
180  setMipsABI(Obj);
181 
182  // Compute the memory size required to load all sections to be loaded
183  // and pass this information to the memory manager
184  if (MemMgr.needsToReserveAllocationSpace()) {
185  uint64_t CodeSize = 0, RODataSize = 0, RWDataSize = 0;
186  uint32_t CodeAlign = 1, RODataAlign = 1, RWDataAlign = 1;
187  if (auto Err = computeTotalAllocSize(Obj,
188  CodeSize, CodeAlign,
189  RODataSize, RODataAlign,
190  RWDataSize, RWDataAlign))
191  return std::move(Err);
192  MemMgr.reserveAllocationSpace(CodeSize, CodeAlign, RODataSize, RODataAlign,
193  RWDataSize, RWDataAlign);
194  }
195 
196  // Used sections from the object file
197  ObjSectionToIDMap LocalSections;
198 
199  // Common symbols requiring allocation, with their sizes and alignments
200  CommonSymbolList CommonSymbols;
201 
202  // Parse symbols
203  DEBUG(dbgs() << "Parse symbols:\n");
204  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
205  ++I) {
206  uint32_t Flags = I->getFlags();
207 
208  // Skip undefined symbols.
209  if (Flags & SymbolRef::SF_Undefined)
210  continue;
211 
212  if (Flags & SymbolRef::SF_Common)
213  CommonSymbols.push_back(*I);
214  else {
215 
216  // Get the symbol type.
217  object::SymbolRef::Type SymType;
218  if (auto SymTypeOrErr = I->getType())
219  SymType = *SymTypeOrErr;
220  else
221  return SymTypeOrErr.takeError();
222 
223  // Get symbol name.
224  StringRef Name;
225  if (auto NameOrErr = I->getName())
226  Name = *NameOrErr;
227  else
228  return NameOrErr.takeError();
229 
230  // Compute JIT symbol flags.
232 
233  // If this is a weak definition, check to see if there's a strong one.
234  // If there is, skip this symbol (we won't be providing it: the strong
235  // definition will). If there's no strong definition, make this definition
236  // strong.
237  if (JITSymFlags.isWeak()) {
238  // First check whether there's already a definition in this instance.
239  // FIXME: Override existing weak definitions with strong ones.
240  if (GlobalSymbolTable.count(Name))
241  continue;
242  // Then check the symbol resolver to see if there's a definition
243  // elsewhere in this logical dylib.
244  if (auto Sym = Resolver.findSymbolInLogicalDylib(Name))
245  if (Sym.getFlags().isStrongDefinition())
246  continue;
247  // else
248  JITSymFlags &= ~JITSymbolFlags::Weak;
249  }
250 
251  if (Flags & SymbolRef::SF_Absolute &&
252  SymType != object::SymbolRef::ST_File) {
253  uint64_t Addr = 0;
254  if (auto AddrOrErr = I->getAddress())
255  Addr = *AddrOrErr;
256  else
257  return AddrOrErr.takeError();
258 
259  unsigned SectionID = AbsoluteSymbolSection;
260 
261  DEBUG(dbgs() << "\tType: " << SymType << " (absolute) Name: " << Name
262  << " SID: " << SectionID << " Offset: "
263  << format("%p", (uintptr_t)Addr)
264  << " flags: " << Flags << "\n");
265  GlobalSymbolTable[Name] =
266  SymbolTableEntry(SectionID, Addr, JITSymFlags);
267  } else if (SymType == object::SymbolRef::ST_Function ||
268  SymType == object::SymbolRef::ST_Data ||
269  SymType == object::SymbolRef::ST_Unknown ||
270  SymType == object::SymbolRef::ST_Other) {
271 
273  if (auto SIOrErr = I->getSection())
274  SI = *SIOrErr;
275  else
276  return SIOrErr.takeError();
277 
278  if (SI == Obj.section_end())
279  continue;
280 
281  // Get symbol offset.
282  uint64_t SectOffset;
283  if (auto Err = getOffset(*I, *SI, SectOffset))
284  return std::move(Err);
285 
286  bool IsCode = SI->isText();
287  unsigned SectionID;
288  if (auto SectionIDOrErr = findOrEmitSection(Obj, *SI, IsCode,
289  LocalSections))
290  SectionID = *SectionIDOrErr;
291  else
292  return SectionIDOrErr.takeError();
293 
294  DEBUG(dbgs() << "\tType: " << SymType << " Name: " << Name
295  << " SID: " << SectionID << " Offset: "
296  << format("%p", (uintptr_t)SectOffset)
297  << " flags: " << Flags << "\n");
298  GlobalSymbolTable[Name] =
299  SymbolTableEntry(SectionID, SectOffset, JITSymFlags);
300  }
301  }
302  }
303 
304  // Allocate common symbols
305  if (auto Err = emitCommonSymbols(Obj, CommonSymbols))
306  return std::move(Err);
307 
308  // Parse and process relocations
309  DEBUG(dbgs() << "Parse relocations:\n");
310  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
311  SI != SE; ++SI) {
312  StubMap Stubs;
313  section_iterator RelocatedSection = SI->getRelocatedSection();
314 
315  if (RelocatedSection == SE)
316  continue;
317 
318  relocation_iterator I = SI->relocation_begin();
319  relocation_iterator E = SI->relocation_end();
320 
321  if (I == E && !ProcessAllSections)
322  continue;
323 
324  bool IsCode = RelocatedSection->isText();
325  unsigned SectionID = 0;
326  if (auto SectionIDOrErr = findOrEmitSection(Obj, *RelocatedSection, IsCode,
327  LocalSections))
328  SectionID = *SectionIDOrErr;
329  else
330  return SectionIDOrErr.takeError();
331 
332  DEBUG(dbgs() << "\tSectionID: " << SectionID << "\n");
333 
334  for (; I != E;)
335  if (auto IOrErr = processRelocationRef(SectionID, I, Obj, LocalSections, Stubs))
336  I = *IOrErr;
337  else
338  return IOrErr.takeError();
339 
340  // If there is an attached checker, notify it about the stubs for this
341  // section so that they can be verified.
342  if (Checker)
343  Checker->registerStubMap(Obj.getFileName(), SectionID, Stubs);
344  }
345 
346  // Give the subclasses a chance to tie-up any loose ends.
347  if (auto Err = finalizeLoad(Obj, LocalSections))
348  return std::move(Err);
349 
350 // for (auto E : LocalSections)
351 // llvm::dbgs() << "Added: " << E.first.getRawDataRefImpl() << " -> " << E.second << "\n";
352 
353  return LocalSections;
354 }
355 
356 // A helper method for computeTotalAllocSize.
357 // Computes the memory size required to allocate sections with the given sizes,
358 // assuming that all sections are allocated with the given alignment
359 static uint64_t
360 computeAllocationSizeForSections(std::vector<uint64_t> &SectionSizes,
361  uint64_t Alignment) {
362  uint64_t TotalSize = 0;
363  for (size_t Idx = 0, Cnt = SectionSizes.size(); Idx < Cnt; Idx++) {
364  uint64_t AlignedSize =
365  (SectionSizes[Idx] + Alignment - 1) / Alignment * Alignment;
366  TotalSize += AlignedSize;
367  }
368  return TotalSize;
369 }
370 
372  const ObjectFile *Obj = Section.getObject();
373  if (isa<object::ELFObjectFileBase>(Obj))
374  return ELFSectionRef(Section).getFlags() & ELF::SHF_ALLOC;
375  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj)) {
376  const coff_section *CoffSection = COFFObj->getCOFFSection(Section);
377  // Avoid loading zero-sized COFF sections.
378  // In PE files, VirtualSize gives the section size, and SizeOfRawData
379  // may be zero for sections with content. In Obj files, SizeOfRawData
380  // gives the section size, and VirtualSize is always zero. Hence
381  // the need to check for both cases below.
382  bool HasContent =
383  (CoffSection->VirtualSize > 0) || (CoffSection->SizeOfRawData > 0);
384  bool IsDiscardable =
385  CoffSection->Characteristics &
387  return HasContent && !IsDiscardable;
388  }
389 
390  assert(isa<MachOObjectFile>(Obj));
391  return true;
392 }
393 
394 static bool isReadOnlyData(const SectionRef Section) {
395  const ObjectFile *Obj = Section.getObject();
396  if (isa<object::ELFObjectFileBase>(Obj))
397  return !(ELFSectionRef(Section).getFlags() &
399  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
400  return ((COFFObj->getCOFFSection(Section)->Characteristics &
404  ==
407 
408  assert(isa<MachOObjectFile>(Obj));
409  return false;
410 }
411 
412 static bool isZeroInit(const SectionRef Section) {
413  const ObjectFile *Obj = Section.getObject();
414  if (isa<object::ELFObjectFileBase>(Obj))
415  return ELFSectionRef(Section).getType() == ELF::SHT_NOBITS;
416  if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(Obj))
417  return COFFObj->getCOFFSection(Section)->Characteristics &
419 
420  auto *MachO = cast<MachOObjectFile>(Obj);
421  unsigned SectionType = MachO->getSectionType(Section);
422  return SectionType == MachO::S_ZEROFILL ||
423  SectionType == MachO::S_GB_ZEROFILL;
424 }
425 
426 // Compute an upper bound of the memory size that is required to load all
427 // sections
429  uint64_t &CodeSize,
430  uint32_t &CodeAlign,
431  uint64_t &RODataSize,
432  uint32_t &RODataAlign,
433  uint64_t &RWDataSize,
434  uint32_t &RWDataAlign) {
435  // Compute the size of all sections required for execution
436  std::vector<uint64_t> CodeSectionSizes;
437  std::vector<uint64_t> ROSectionSizes;
438  std::vector<uint64_t> RWSectionSizes;
439 
440  // Collect sizes of all sections to be loaded;
441  // also determine the max alignment of all sections
442  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
443  SI != SE; ++SI) {
444  const SectionRef &Section = *SI;
445 
446  bool IsRequired = isRequiredForExecution(Section);
447 
448  // Consider only the sections that are required to be loaded for execution
449  if (IsRequired) {
450  uint64_t DataSize = Section.getSize();
451  uint64_t Alignment64 = Section.getAlignment();
452  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
453  bool IsCode = Section.isText();
454  bool IsReadOnly = isReadOnlyData(Section);
455 
456  StringRef Name;
457  if (auto EC = Section.getName(Name))
458  return errorCodeToError(EC);
459 
460  uint64_t StubBufSize = computeSectionStubBufSize(Obj, Section);
461  uint64_t SectionSize = DataSize + StubBufSize;
462 
463  // The .eh_frame section (at least on Linux) needs an extra four bytes
464  // padded
465  // with zeroes added at the end. For MachO objects, this section has a
466  // slightly different name, so this won't have any effect for MachO
467  // objects.
468  if (Name == ".eh_frame")
469  SectionSize += 4;
470 
471  if (!SectionSize)
472  SectionSize = 1;
473 
474  if (IsCode) {
475  CodeAlign = std::max(CodeAlign, Alignment);
476  CodeSectionSizes.push_back(SectionSize);
477  } else if (IsReadOnly) {
478  RODataAlign = std::max(RODataAlign, Alignment);
479  ROSectionSizes.push_back(SectionSize);
480  } else {
481  RWDataAlign = std::max(RWDataAlign, Alignment);
482  RWSectionSizes.push_back(SectionSize);
483  }
484  }
485  }
486 
487  // Compute the size of all common symbols
488  uint64_t CommonSize = 0;
489  uint32_t CommonAlign = 1;
490  for (symbol_iterator I = Obj.symbol_begin(), E = Obj.symbol_end(); I != E;
491  ++I) {
492  uint32_t Flags = I->getFlags();
493  if (Flags & SymbolRef::SF_Common) {
494  // Add the common symbols to a list. We'll allocate them all below.
495  uint64_t Size = I->getCommonSize();
496  uint32_t Align = I->getAlignment();
497  // If this is the first common symbol, use its alignment as the alignment
498  // for the common symbols section.
499  if (CommonSize == 0)
500  CommonAlign = Align;
501  CommonSize = alignTo(CommonSize, Align) + Size;
502  }
503  }
504  if (CommonSize != 0) {
505  RWSectionSizes.push_back(CommonSize);
506  RWDataAlign = std::max(RWDataAlign, CommonAlign);
507  }
508 
509  // Compute the required allocation space for each different type of sections
510  // (code, read-only data, read-write data) assuming that all sections are
511  // allocated with the max alignment. Note that we cannot compute with the
512  // individual alignments of the sections, because then the required size
513  // depends on the order, in which the sections are allocated.
514  CodeSize = computeAllocationSizeForSections(CodeSectionSizes, CodeAlign);
515  RODataSize = computeAllocationSizeForSections(ROSectionSizes, RODataAlign);
516  RWDataSize = computeAllocationSizeForSections(RWSectionSizes, RWDataAlign);
517 
518  return Error::success();
519 }
520 
521 // compute stub buffer size for the given section
523  const SectionRef &Section) {
524  unsigned StubSize = getMaxStubSize();
525  if (StubSize == 0) {
526  return 0;
527  }
528  // FIXME: this is an inefficient way to handle this. We should computed the
529  // necessary section allocation size in loadObject by walking all the sections
530  // once.
531  unsigned StubBufSize = 0;
532  for (section_iterator SI = Obj.section_begin(), SE = Obj.section_end();
533  SI != SE; ++SI) {
534  section_iterator RelSecI = SI->getRelocatedSection();
535  if (!(RelSecI == Section))
536  continue;
537 
538  for (const RelocationRef &Reloc : SI->relocations())
539  if (relocationNeedsStub(Reloc))
540  StubBufSize += StubSize;
541  }
542 
543  // Get section data size and alignment
544  uint64_t DataSize = Section.getSize();
545  uint64_t Alignment64 = Section.getAlignment();
546 
547  // Add stubbuf size alignment
548  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
549  unsigned StubAlignment = getStubAlignment();
550  unsigned EndAlignment = (DataSize | Alignment) & -(DataSize | Alignment);
551  if (StubAlignment > EndAlignment)
552  StubBufSize += StubAlignment - EndAlignment;
553  return StubBufSize;
554 }
555 
557  unsigned Size) const {
558  uint64_t Result = 0;
559  if (IsTargetLittleEndian) {
560  Src += Size - 1;
561  while (Size--)
562  Result = (Result << 8) | *Src--;
563  } else
564  while (Size--)
565  Result = (Result << 8) | *Src++;
566 
567  return Result;
568 }
569 
570 void RuntimeDyldImpl::writeBytesUnaligned(uint64_t Value, uint8_t *Dst,
571  unsigned Size) const {
572  if (IsTargetLittleEndian) {
573  while (Size--) {
574  *Dst++ = Value & 0xFF;
575  Value >>= 8;
576  }
577  } else {
578  Dst += Size - 1;
579  while (Size--) {
580  *Dst-- = Value & 0xFF;
581  Value >>= 8;
582  }
583  }
584 }
585 
587  CommonSymbolList &CommonSymbols) {
588  if (CommonSymbols.empty())
589  return Error::success();
590 
591  uint64_t CommonSize = 0;
592  uint32_t CommonAlign = CommonSymbols.begin()->getAlignment();
593  CommonSymbolList SymbolsToAllocate;
594 
595  DEBUG(dbgs() << "Processing common symbols...\n");
596 
597  for (const auto &Sym : CommonSymbols) {
598  StringRef Name;
599  if (auto NameOrErr = Sym.getName())
600  Name = *NameOrErr;
601  else
602  return NameOrErr.takeError();
603 
604  // Skip common symbols already elsewhere.
605  if (GlobalSymbolTable.count(Name)) {
606  DEBUG(dbgs() << "\tSkipping already emitted common symbol '" << Name
607  << "'\n");
608  continue;
609  }
610 
611  if (auto Sym = Resolver.findSymbolInLogicalDylib(Name)) {
612  if (!Sym.getFlags().isCommon()) {
613  DEBUG(dbgs() << "\tSkipping common symbol '" << Name
614  << "' in favor of stronger definition.\n");
615  continue;
616  }
617  }
618  uint32_t Align = Sym.getAlignment();
619  uint64_t Size = Sym.getCommonSize();
620 
621  CommonSize = alignTo(CommonSize, Align) + Size;
622 
623  SymbolsToAllocate.push_back(Sym);
624  }
625 
626  // Allocate memory for the section
627  unsigned SectionID = Sections.size();
628  uint8_t *Addr = MemMgr.allocateDataSection(CommonSize, CommonAlign, SectionID,
629  "<common symbols>", false);
630  if (!Addr)
631  report_fatal_error("Unable to allocate memory for common symbols!");
632  uint64_t Offset = 0;
633  Sections.push_back(
634  SectionEntry("<common symbols>", Addr, CommonSize, CommonSize, 0));
635  memset(Addr, 0, CommonSize);
636 
637  DEBUG(dbgs() << "emitCommonSection SectionID: " << SectionID << " new addr: "
638  << format("%p", Addr) << " DataSize: " << CommonSize << "\n");
639 
640  // Assign the address of each symbol
641  for (auto &Sym : SymbolsToAllocate) {
642  uint32_t Align = Sym.getAlignment();
643  uint64_t Size = Sym.getCommonSize();
644  StringRef Name;
645  if (auto NameOrErr = Sym.getName())
646  Name = *NameOrErr;
647  else
648  return NameOrErr.takeError();
649  if (Align) {
650  // This symbol has an alignment requirement.
651  uint64_t AlignOffset = OffsetToAlignment((uint64_t)Addr, Align);
652  Addr += AlignOffset;
653  Offset += AlignOffset;
654  }
656  DEBUG(dbgs() << "Allocating common symbol " << Name << " address "
657  << format("%p", Addr) << "\n");
658  GlobalSymbolTable[Name] =
659  SymbolTableEntry(SectionID, Offset, JITSymFlags);
660  Offset += Size;
661  Addr += Size;
662  }
663 
664  if (Checker)
665  Checker->registerSection(Obj.getFileName(), SectionID);
666 
667  return Error::success();
668 }
669 
672  const SectionRef &Section,
673  bool IsCode) {
674  StringRef data;
675  uint64_t Alignment64 = Section.getAlignment();
676 
677  unsigned Alignment = (unsigned)Alignment64 & 0xffffffffL;
678  unsigned PaddingSize = 0;
679  unsigned StubBufSize = 0;
680  bool IsRequired = isRequiredForExecution(Section);
681  bool IsVirtual = Section.isVirtual();
682  bool IsZeroInit = isZeroInit(Section);
683  bool IsReadOnly = isReadOnlyData(Section);
684  uint64_t DataSize = Section.getSize();
685 
686  StringRef Name;
687  if (auto EC = Section.getName(Name))
688  return errorCodeToError(EC);
689 
690  StubBufSize = computeSectionStubBufSize(Obj, Section);
691 
692  // The .eh_frame section (at least on Linux) needs an extra four bytes padded
693  // with zeroes added at the end. For MachO objects, this section has a
694  // slightly different name, so this won't have any effect for MachO objects.
695  if (Name == ".eh_frame")
696  PaddingSize = 4;
697 
698  uintptr_t Allocate;
699  unsigned SectionID = Sections.size();
700  uint8_t *Addr;
701  const char *pData = nullptr;
702 
703  // If this section contains any bits (i.e. isn't a virtual or bss section),
704  // grab a reference to them.
705  if (!IsVirtual && !IsZeroInit) {
706  // In either case, set the location of the unrelocated section in memory,
707  // since we still process relocations for it even if we're not applying them.
708  if (auto EC = Section.getContents(data))
709  return errorCodeToError(EC);
710  pData = data.data();
711  }
712 
713  // Code section alignment needs to be at least as high as stub alignment or
714  // padding calculations may by incorrect when the section is remapped to a
715  // higher alignment.
716  if (IsCode)
717  Alignment = std::max(Alignment, getStubAlignment());
718 
719  // Some sections, such as debug info, don't need to be loaded for execution.
720  // Leave those where they are.
721  if (IsRequired) {
722  Allocate = DataSize + PaddingSize + StubBufSize;
723  if (!Allocate)
724  Allocate = 1;
725  Addr = IsCode ? MemMgr.allocateCodeSection(Allocate, Alignment, SectionID,
726  Name)
727  : MemMgr.allocateDataSection(Allocate, Alignment, SectionID,
728  Name, IsReadOnly);
729  if (!Addr)
730  report_fatal_error("Unable to allocate section memory!");
731 
732  // Zero-initialize or copy the data from the image
733  if (IsZeroInit || IsVirtual)
734  memset(Addr, 0, DataSize);
735  else
736  memcpy(Addr, pData, DataSize);
737 
738  // Fill in any extra bytes we allocated for padding
739  if (PaddingSize != 0) {
740  memset(Addr + DataSize, 0, PaddingSize);
741  // Update the DataSize variable so that the stub offset is set correctly.
742  DataSize += PaddingSize;
743  }
744 
745  DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
746  << " obj addr: " << format("%p", pData)
747  << " new addr: " << format("%p", Addr)
748  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
749  << " Allocate: " << Allocate << "\n");
750  } else {
751  // Even if we didn't load the section, we need to record an entry for it
752  // to handle later processing (and by 'handle' I mean don't do anything
753  // with these sections).
754  Allocate = 0;
755  Addr = nullptr;
756  DEBUG(dbgs() << "emitSection SectionID: " << SectionID << " Name: " << Name
757  << " obj addr: " << format("%p", data.data()) << " new addr: 0"
758  << " DataSize: " << DataSize << " StubBufSize: " << StubBufSize
759  << " Allocate: " << Allocate << "\n");
760  }
761 
762  Sections.push_back(
763  SectionEntry(Name, Addr, DataSize, Allocate, (uintptr_t)pData));
764 
765  if (Checker)
766  Checker->registerSection(Obj.getFileName(), SectionID);
767 
768  return SectionID;
769 }
770 
773  const SectionRef &Section,
774  bool IsCode,
775  ObjSectionToIDMap &LocalSections) {
776 
777  unsigned SectionID = 0;
778  ObjSectionToIDMap::iterator i = LocalSections.find(Section);
779  if (i != LocalSections.end())
780  SectionID = i->second;
781  else {
782  if (auto SectionIDOrErr = emitSection(Obj, Section, IsCode))
783  SectionID = *SectionIDOrErr;
784  else
785  return SectionIDOrErr.takeError();
786  LocalSections[Section] = SectionID;
787  }
788  return SectionID;
789 }
790 
792  unsigned SectionID) {
793  Relocations[SectionID].push_back(RE);
794 }
795 
797  StringRef SymbolName) {
798  // Relocation by symbol. If the symbol is found in the global symbol table,
799  // create an appropriate section relocation. Otherwise, add it to
800  // ExternalSymbolRelocations.
801  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(SymbolName);
802  if (Loc == GlobalSymbolTable.end()) {
803  ExternalSymbolRelocations[SymbolName].push_back(RE);
804  } else {
805  // Copy the RE since we want to modify its addend.
806  RelocationEntry RECopy = RE;
807  const auto &SymInfo = Loc->second;
808  RECopy.Addend += SymInfo.getOffset();
809  Relocations[SymInfo.getSectionID()].push_back(RECopy);
810  }
811 }
812 
813 uint8_t *RuntimeDyldImpl::createStubFunction(uint8_t *Addr,
814  unsigned AbiVariant) {
815  if (Arch == Triple::aarch64 || Arch == Triple::aarch64_be) {
816  // This stub has to be able to access the full address space,
817  // since symbol lookup won't necessarily find a handy, in-range,
818  // PLT stub for functions which could be anywhere.
819  // Stub can use ip0 (== x16) to calculate address
820  writeBytesUnaligned(0xd2e00010, Addr, 4); // movz ip0, #:abs_g3:<addr>
821  writeBytesUnaligned(0xf2c00010, Addr+4, 4); // movk ip0, #:abs_g2_nc:<addr>
822  writeBytesUnaligned(0xf2a00010, Addr+8, 4); // movk ip0, #:abs_g1_nc:<addr>
823  writeBytesUnaligned(0xf2800010, Addr+12, 4); // movk ip0, #:abs_g0_nc:<addr>
824  writeBytesUnaligned(0xd61f0200, Addr+16, 4); // br ip0
825 
826  return Addr;
827  } else if (Arch == Triple::arm || Arch == Triple::armeb) {
828  // TODO: There is only ARM far stub now. We should add the Thumb stub,
829  // and stubs for branches Thumb - ARM and ARM - Thumb.
830  writeBytesUnaligned(0xe51ff004, Addr, 4); // ldr pc,<label>
831  return Addr + 4;
832  } else if (IsMipsO32ABI) {
833  // 0: 3c190000 lui t9,%hi(addr).
834  // 4: 27390000 addiu t9,t9,%lo(addr).
835  // 8: 03200008 jr t9.
836  // c: 00000000 nop.
837  const unsigned LuiT9Instr = 0x3c190000, AdduiT9Instr = 0x27390000;
838  const unsigned NopInstr = 0x0;
839  unsigned JrT9Instr = 0x03200008;
840  if ((AbiVariant & ELF::EF_MIPS_ARCH) == ELF::EF_MIPS_ARCH_32R6)
841  JrT9Instr = 0x03200009;
842 
843  writeBytesUnaligned(LuiT9Instr, Addr, 4);
844  writeBytesUnaligned(AdduiT9Instr, Addr+4, 4);
845  writeBytesUnaligned(JrT9Instr, Addr+8, 4);
846  writeBytesUnaligned(NopInstr, Addr+12, 4);
847  return Addr;
848  } else if (Arch == Triple::ppc64 || Arch == Triple::ppc64le) {
849  // Depending on which version of the ELF ABI is in use, we need to
850  // generate one of two variants of the stub. They both start with
851  // the same sequence to load the target address into r12.
852  writeInt32BE(Addr, 0x3D800000); // lis r12, highest(addr)
853  writeInt32BE(Addr+4, 0x618C0000); // ori r12, higher(addr)
854  writeInt32BE(Addr+8, 0x798C07C6); // sldi r12, r12, 32
855  writeInt32BE(Addr+12, 0x658C0000); // oris r12, r12, h(addr)
856  writeInt32BE(Addr+16, 0x618C0000); // ori r12, r12, l(addr)
857  if (AbiVariant == 2) {
858  // PowerPC64 stub ELFv2 ABI: The address points to the function itself.
859  // The address is already in r12 as required by the ABI. Branch to it.
860  writeInt32BE(Addr+20, 0xF8410018); // std r2, 24(r1)
861  writeInt32BE(Addr+24, 0x7D8903A6); // mtctr r12
862  writeInt32BE(Addr+28, 0x4E800420); // bctr
863  } else {
864  // PowerPC64 stub ELFv1 ABI: The address points to a function descriptor.
865  // Load the function address on r11 and sets it to control register. Also
866  // loads the function TOC in r2 and environment pointer to r11.
867  writeInt32BE(Addr+20, 0xF8410028); // std r2, 40(r1)
868  writeInt32BE(Addr+24, 0xE96C0000); // ld r11, 0(r12)
869  writeInt32BE(Addr+28, 0xE84C0008); // ld r2, 0(r12)
870  writeInt32BE(Addr+32, 0x7D6903A6); // mtctr r11
871  writeInt32BE(Addr+36, 0xE96C0010); // ld r11, 16(r2)
872  writeInt32BE(Addr+40, 0x4E800420); // bctr
873  }
874  return Addr;
875  } else if (Arch == Triple::systemz) {
876  writeInt16BE(Addr, 0xC418); // lgrl %r1,.+8
877  writeInt16BE(Addr+2, 0x0000);
878  writeInt16BE(Addr+4, 0x0004);
879  writeInt16BE(Addr+6, 0x07F1); // brc 15,%r1
880  // 8-byte address stored at Addr + 8
881  return Addr;
882  } else if (Arch == Triple::x86_64) {
883  *Addr = 0xFF; // jmp
884  *(Addr+1) = 0x25; // rip
885  // 32-bit PC-relative address of the GOT entry will be stored at Addr+2
886  } else if (Arch == Triple::x86) {
887  *Addr = 0xE9; // 32-bit pc-relative jump.
888  }
889  return Addr;
890 }
891 
892 // Assign an address to a symbol name and resolve all the relocations
893 // associated with it.
895  uint64_t Addr) {
896  // The address to use for relocation resolution is not
897  // the address of the local section buffer. We must be doing
898  // a remote execution environment of some sort. Relocations can't
899  // be applied until all the sections have been moved. The client must
900  // trigger this with a call to MCJIT::finalize() or
901  // RuntimeDyld::resolveRelocations().
902  //
903  // Addr is a uint64_t because we can't assume the pointer width
904  // of the target is the same as that of the host. Just use a generic
905  // "big enough" type.
906  DEBUG(dbgs() << "Reassigning address for section " << SectionID << " ("
907  << Sections[SectionID].getName() << "): "
908  << format("0x%016" PRIx64, Sections[SectionID].getLoadAddress())
909  << " -> " << format("0x%016" PRIx64, Addr) << "\n");
910  Sections[SectionID].setLoadAddress(Addr);
911 }
912 
914  uint64_t Value) {
915  for (unsigned i = 0, e = Relocs.size(); i != e; ++i) {
916  const RelocationEntry &RE = Relocs[i];
917  // Ignore relocations for sections that were not loaded
918  if (Sections[RE.SectionID].getAddress() == nullptr)
919  continue;
920  resolveRelocation(RE, Value);
921  }
922 }
923 
925  while (!ExternalSymbolRelocations.empty()) {
926  StringMap<RelocationList>::iterator i = ExternalSymbolRelocations.begin();
927 
928  StringRef Name = i->first();
929  if (Name.size() == 0) {
930  // This is an absolute symbol, use an address of zero.
931  DEBUG(dbgs() << "Resolving absolute relocations."
932  << "\n");
933  RelocationList &Relocs = i->second;
934  resolveRelocationList(Relocs, 0);
935  } else {
936  uint64_t Addr = 0;
937  RTDyldSymbolTable::const_iterator Loc = GlobalSymbolTable.find(Name);
938  if (Loc == GlobalSymbolTable.end()) {
939  // This is an external symbol, try to get its address from the symbol
940  // resolver.
941  // First search for the symbol in this logical dylib.
942  Addr = Resolver.findSymbolInLogicalDylib(Name.data()).getAddress();
943  // If that fails, try searching for an external symbol.
944  if (!Addr)
945  Addr = Resolver.findSymbol(Name.data()).getAddress();
946  // The call to getSymbolAddress may have caused additional modules to
947  // be loaded, which may have added new entries to the
948  // ExternalSymbolRelocations map. Consquently, we need to update our
949  // iterator. This is also why retrieval of the relocation list
950  // associated with this symbol is deferred until below this point.
951  // New entries may have been added to the relocation list.
952  i = ExternalSymbolRelocations.find(Name);
953  } else {
954  // We found the symbol in our global table. It was probably in a
955  // Module that we loaded previously.
956  const auto &SymInfo = Loc->second;
957  Addr = getSectionLoadAddress(SymInfo.getSectionID()) +
958  SymInfo.getOffset();
959  }
960 
961  // FIXME: Implement error handling that doesn't kill the host program!
962  if (!Addr)
963  report_fatal_error("Program used external function '" + Name +
964  "' which could not be resolved!");
965 
966  // If Resolver returned UINT64_MAX, the client wants to handle this symbol
967  // manually and we shouldn't resolve its relocations.
968  if (Addr != UINT64_MAX) {
969  DEBUG(dbgs() << "Resolving relocations Name: " << Name << "\t"
970  << format("0x%lx", Addr) << "\n");
971  // This list may have been updated when we called getSymbolAddress, so
972  // don't change this code to get the list earlier.
973  RelocationList &Relocs = i->second;
974  resolveRelocationList(Relocs, Addr);
975  }
976  }
977 
978  ExternalSymbolRelocations.erase(i);
979  }
980 }
981 
982 //===----------------------------------------------------------------------===//
983 // RuntimeDyld class implementation
984 
986  const object::SectionRef &Sec) const {
987 
988  auto I = ObjSecToIDMap.find(Sec);
989  if (I != ObjSecToIDMap.end())
990  return RTDyld.Sections[I->second].getLoadAddress();
991 
992  return 0;
993 }
994 
995 void RuntimeDyld::MemoryManager::anchor() {}
996 void JITSymbolResolver::anchor() {}
997 
999  JITSymbolResolver &Resolver)
1000  : MemMgr(MemMgr), Resolver(Resolver) {
1001  // FIXME: There's a potential issue lurking here if a single instance of
1002  // RuntimeDyld is used to load multiple objects. The current implementation
1003  // associates a single memory manager with a RuntimeDyld instance. Even
1004  // though the public class spawns a new 'impl' instance for each load,
1005  // they share a single memory manager. This can become a problem when page
1006  // permissions are applied.
1007  Dyld = nullptr;
1008  ProcessAllSections = false;
1009  Checker = nullptr;
1010 }
1011 
1013 
1014 static std::unique_ptr<RuntimeDyldCOFF>
1016  JITSymbolResolver &Resolver, bool ProcessAllSections,
1017  RuntimeDyldCheckerImpl *Checker) {
1018  std::unique_ptr<RuntimeDyldCOFF> Dyld =
1019  RuntimeDyldCOFF::create(Arch, MM, Resolver);
1020  Dyld->setProcessAllSections(ProcessAllSections);
1021  Dyld->setRuntimeDyldChecker(Checker);
1022  return Dyld;
1023 }
1024 
1025 static std::unique_ptr<RuntimeDyldELF>
1027  JITSymbolResolver &Resolver, bool ProcessAllSections,
1028  RuntimeDyldCheckerImpl *Checker) {
1029  std::unique_ptr<RuntimeDyldELF> Dyld =
1030  RuntimeDyldELF::create(Arch, MM, Resolver);
1031  Dyld->setProcessAllSections(ProcessAllSections);
1032  Dyld->setRuntimeDyldChecker(Checker);
1033  return Dyld;
1034 }
1035 
1036 static std::unique_ptr<RuntimeDyldMachO>
1038  JITSymbolResolver &Resolver,
1039  bool ProcessAllSections,
1040  RuntimeDyldCheckerImpl *Checker) {
1041  std::unique_ptr<RuntimeDyldMachO> Dyld =
1042  RuntimeDyldMachO::create(Arch, MM, Resolver);
1043  Dyld->setProcessAllSections(ProcessAllSections);
1044  Dyld->setRuntimeDyldChecker(Checker);
1045  return Dyld;
1046 }
1047 
1048 std::unique_ptr<RuntimeDyld::LoadedObjectInfo>
1050  if (!Dyld) {
1051  if (Obj.isELF())
1052  Dyld =
1053  createRuntimeDyldELF(static_cast<Triple::ArchType>(Obj.getArch()),
1054  MemMgr, Resolver, ProcessAllSections, Checker);
1055  else if (Obj.isMachO())
1056  Dyld = createRuntimeDyldMachO(
1057  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1058  ProcessAllSections, Checker);
1059  else if (Obj.isCOFF())
1060  Dyld = createRuntimeDyldCOFF(
1061  static_cast<Triple::ArchType>(Obj.getArch()), MemMgr, Resolver,
1062  ProcessAllSections, Checker);
1063  else
1064  report_fatal_error("Incompatible object format!");
1065  }
1066 
1067  if (!Dyld->isCompatibleFile(Obj))
1068  report_fatal_error("Incompatible object format!");
1069 
1070  auto LoadedObjInfo = Dyld->loadObject(Obj);
1071  MemMgr.notifyObjectLoaded(*this, Obj);
1072  return LoadedObjInfo;
1073 }
1074 
1076  if (!Dyld)
1077  return nullptr;
1078  return Dyld->getSymbolLocalAddress(Name);
1079 }
1080 
1082  if (!Dyld)
1083  return nullptr;
1084  return Dyld->getSymbol(Name);
1085 }
1086 
1087 void RuntimeDyld::resolveRelocations() { Dyld->resolveRelocations(); }
1088 
1089 void RuntimeDyld::reassignSectionAddress(unsigned SectionID, uint64_t Addr) {
1090  Dyld->reassignSectionAddress(SectionID, Addr);
1091 }
1092 
1093 void RuntimeDyld::mapSectionAddress(const void *LocalAddress,
1094  uint64_t TargetAddress) {
1095  Dyld->mapSectionAddress(LocalAddress, TargetAddress);
1096 }
1097 
1098 bool RuntimeDyld::hasError() { return Dyld->hasError(); }
1099 
1100 StringRef RuntimeDyld::getErrorString() { return Dyld->getErrorString(); }
1101 
1103  bool MemoryFinalizationLocked = MemMgr.FinalizationLocked;
1104  MemMgr.FinalizationLocked = true;
1106  registerEHFrames();
1107  if (!MemoryFinalizationLocked) {
1108  MemMgr.finalizeMemory();
1109  MemMgr.FinalizationLocked = false;
1110  }
1111 }
1112 
1114  if (Dyld)
1115  Dyld->registerEHFrames();
1116 }
1117 
1119  if (Dyld)
1120  Dyld->deregisterEHFrames();
1121 }
1122 
1123 } // end namespace llvm
Error emitCommonSymbols(const ObjectFile &Obj, CommonSymbolList &CommonSymbols)
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:108
RelocationEntry - used to represent relocations internally in the dynamic linker. ...
size_t getSize() const
void writeBytesUnaligned(uint64_t Value, uint8_t *Dst, unsigned Size) const
Endian-aware write.
std::unique_ptr< LoadedObjectInfo > loadObject(const object::ObjectFile &O)
Add the referenced object file to the list of objects to be loaded and relocated. ...
void registerEHFrames()
Register any EH frame sections that have been loaded but not previously registered with the memory ma...
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
size_t i
StringRef getErrorString()
void resolveExternalSymbols()
Resolve relocations to external symbols.
static bool isReadOnlyData(const SectionRef Section)
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: RuntimeDyld.cpp:62
uint8_t * getAddress() const
This class is the base class for all object file types.
Definition: ObjectFile.h:178
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:664
Error takeError()
Take ownership of the stored error.
uint64_t getSectionLoadAddress(const object::SectionRef &Sec) const override
Obtain the Load Address of a section by SectionRef.
virtual unsigned getArch() const =0
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:33
unsigned SectionID
SectionID - the section this relocation points to.
struct fuzzer::@269 Flags
bool isVirtual() const
Definition: ObjectFile.h:408
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:41
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.
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: Object/COFF.h:405
static uint64_t computeAllocationSizeForSections(std::vector< uint64_t > &SectionSizes, uint64_t Alignment)
std::error_code getName(StringRef &Result) const
Definition: ObjectFile.h:372
virtual ~RuntimeDyldImpl()
Definition: RuntimeDyld.cpp:67
uint32_t getType() const
Definition: ELFObjectFile.h:87
static Error getOffset(const SymbolRef &Sym, SectionRef Sec, uint64_t &Result)
JITEvaluatedSymbol getSymbol(StringRef Name) const
Get the target address and flags for the named symbol.
void * getSymbolLocalAddress(StringRef Name) const
Get the address of our local copy of the symbol.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
RuntimeDyld(MemoryManager &MemMgr, JITSymbolResolver &Resolver)
Construct a RuntimeDyld instance.
format_object< Ts...> format(const char *Fmt, const Ts &...Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
uint64_t getAlignment() const
Get the alignment of this section as the actual value (not log 2).
Definition: ObjectFile.h:388
bool isCOFF() const
Definition: Binary.h:116
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: Object/COFF.h:413
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...
* 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).
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:178
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
void addRelocationForSection(const RelocationEntry &RE, unsigned SectionID)
uint64_t readBytesUnaligned(uint8_t *Src, unsigned Size) const
Endian-aware read Read the least significant Size bytes from Src.
bool isText() const
Definition: ObjectFile.h:396
static ManagedStatic< _object_error_category > error_category
uint32_t Offset
Error computeTotalAllocSize(const ObjectFile &Obj, uint64_t &CodeSize, uint32_t &CodeAlign, uint64_t &RODataSize, uint32_t &RODataAlign, uint64_t &RWDataSize, uint32_t &RWDataAlign)
Flags for symbols in the JIT.
Definition: JITSymbol.h:36
uint64_t getSize() const
Definition: ObjectFile.h:380
Symbol resolution.
Definition: JITSymbol.h:165
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
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: Object/COFF.h:407
uint64_t getAddress() const
Definition: ObjectFile.h:376
StringRef getFileName() const
Definition: Binary.cpp:35
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const ObjectFile * getObject() const
Definition: ObjectFile.h:432
Expected< uint64_t > getAddress() const
Returns the symbol virtual address (i.e.
Definition: ObjectFile.h:320
static void dumpSectionMemory(const SectionEntry &S, StringRef State)
Definition: RuntimeDyld.cpp:79
static ErrorSuccess success()
Create a success value.
unsigned computeSectionStubBufSize(const ObjectFile &Obj, const SectionRef &Section)
virtual section_iterator section_begin() const =0
bool isMachO() const
Definition: Binary.h:112
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
int64_t Addend
Addend - the relocation addend encoded in the instruction itself.
uint8_t * createStubFunction(uint8_t *Addr, unsigned AbiVariant=0)
Emits long jump instruction to Addr.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
Symbol info for RuntimeDyld.
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:88
std::error_code getContents(StringRef &Result) const
Definition: ObjectFile.h:384
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:116
static std::unique_ptr< RuntimeDyldELF > createRuntimeDyldELF(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
static bool isZeroInit(const SectionRef Section)
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:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
Expected< unsigned > emitSection(const ObjectFile &Obj, const SectionRef &Section, bool IsCode)
Emits section data from the object file to the MemoryManager.
bool isLittleEndian() const
Definition: Binary.h:132
static std::unique_ptr< RuntimeDyldMachO > createRuntimeDyldMachO(Triple::ArchType Arch, RuntimeDyld::MemoryManager &MM, JITSymbolResolver &Resolver, bool ProcessAllSections, RuntimeDyldCheckerImpl *Checker)
uint64_t getLoadAddress() const
void resolveRelocations()
Resolve the relocations for all symbols we currently know about.
SectionEntry - represents a section emitted into memory by the dynamic linker.
virtual void deregisterEHFrames()
Definition: RuntimeDyld.cpp:76
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
aarch64 promote const
LLVM Value Representation.
Definition: Value.h:71
static const char * name
bool isWeak() const
Returns true is the Weak flag is set.
Definition: JITSymbol.h:55
Lightweight error class with error context and mandatory checking.
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:701
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
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:125
#define DEBUG(X)
Definition: Debug.h:100
void reassignSectionAddress(unsigned SectionID, uint64_t Addr)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
Expected< ObjSectionToIDMap > loadObjectImpl(const object::ObjectFile &Obj)
ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...
Definition: ManagedStatic.h:63
S_ZEROFILL - Zero fill on demand section.
void mapSectionAddress(const void *LocalAddress, uint64_t TargetAddress)
Map a section to its target address space value.
StringRef getName() const
SectionType
These are the section type and attributes fields.
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:70
uint64_t getFlags() const
Definition: ELFObjectFile.h:91