LLVM  9.0.0svn
ELFObjectFile.h
Go to the documentation of this file.
1 //===- ELFObjectFile.h - ELF object file implementation ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file declares the ELFObjectFile template class.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_OBJECT_ELFOBJECTFILE_H
14 #define LLVM_OBJECT_ELFOBJECTFILE_H
15 
16 #include "llvm/ADT/ArrayRef.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/Triple.h"
22 #include "llvm/BinaryFormat/ELF.h"
24 #include "llvm/Object/Binary.h"
25 #include "llvm/Object/ELF.h"
26 #include "llvm/Object/ELFTypes.h"
27 #include "llvm/Object/Error.h"
28 #include "llvm/Object/ObjectFile.h"
32 #include "llvm/Support/Casting.h"
33 #include "llvm/Support/Endian.h"
34 #include "llvm/Support/Error.h"
37 #include <cassert>
38 #include <cstdint>
39 #include <system_error>
40 
41 namespace llvm {
42 namespace object {
43 
44 constexpr int NumElfSymbolTypes = 8;
46 
48 
49 class ELFObjectFileBase : public ObjectFile {
50  friend class ELFRelocationRef;
51  friend class ELFSectionRef;
52  friend class ELFSymbolRef;
53 
54 protected:
56 
57  virtual uint16_t getEMachine() const = 0;
58  virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0;
59  virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
60  virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
61 
62  virtual uint32_t getSectionType(DataRefImpl Sec) const = 0;
63  virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0;
64  virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0;
65 
66  virtual Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
67 
68 public:
70 
72 
73  /// Returns platform-specific object flags, if any.
74  virtual unsigned getPlatformFlags() const = 0;
75 
77 
78  static bool classof(const Binary *v) { return v->isELF(); }
79 
80  SubtargetFeatures getFeatures() const override;
81 
83 
85 
87 
88  void setARMSubArch(Triple &TheTriple) const override;
89 
90  virtual uint16_t getEType() const = 0;
91 
92  std::vector<std::pair<DataRefImpl, uint64_t>> getPltAddresses() const;
93 };
94 
95 class ELFSectionRef : public SectionRef {
96 public:
98  assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
99  }
100 
101  const ELFObjectFileBase *getObject() const {
102  return cast<ELFObjectFileBase>(SectionRef::getObject());
103  }
104 
105  uint32_t getType() const {
106  return getObject()->getSectionType(getRawDataRefImpl());
107  }
108 
109  uint64_t getFlags() const {
110  return getObject()->getSectionFlags(getRawDataRefImpl());
111  }
112 
113  uint64_t getOffset() const {
114  return getObject()->getSectionOffset(getRawDataRefImpl());
115  }
116 };
117 
119 public:
121  assert(isa<ELFObjectFileBase>(B->getObject()));
122  }
123 
124  const ELFSectionRef *operator->() const {
125  return static_cast<const ELFSectionRef *>(section_iterator::operator->());
126  }
127 
128  const ELFSectionRef &operator*() const {
129  return static_cast<const ELFSectionRef &>(section_iterator::operator*());
130  }
131 };
132 
133 class ELFSymbolRef : public SymbolRef {
134 public:
136  assert(isa<ELFObjectFileBase>(SymbolRef::getObject()));
137  }
138 
139  const ELFObjectFileBase *getObject() const {
140  return cast<ELFObjectFileBase>(BasicSymbolRef::getObject());
141  }
142 
143  uint64_t getSize() const {
144  return getObject()->getSymbolSize(getRawDataRefImpl());
145  }
146 
147  uint8_t getOther() const {
148  return getObject()->getSymbolOther(getRawDataRefImpl());
149  }
150 
151  uint8_t getELFType() const {
152  return getObject()->getSymbolELFType(getRawDataRefImpl());
153  }
154 
156  uint8_t Type = getELFType();
157  for (auto &EE : ElfSymbolTypes) {
158  if (EE.Value == Type) {
159  return EE.AltName;
160  }
161  }
162  return "";
163  }
164 };
165 
167 public:
169  : symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
170  cast<ELFObjectFileBase>(B->getObject()))) {}
171 
172  const ELFSymbolRef *operator->() const {
173  return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->());
174  }
175 
176  const ELFSymbolRef &operator*() const {
177  return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*());
178  }
179 };
180 
182 public:
184  assert(isa<ELFObjectFileBase>(RelocationRef::getObject()));
185  }
186 
187  const ELFObjectFileBase *getObject() const {
188  return cast<ELFObjectFileBase>(RelocationRef::getObject());
189  }
190 
192  return getObject()->getRelocationAddend(getRawDataRefImpl());
193  }
194 };
195 
197 public:
200  B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {}
201 
202  const ELFRelocationRef *operator->() const {
203  return static_cast<const ELFRelocationRef *>(
205  }
206 
207  const ELFRelocationRef &operator*() const {
208  return static_cast<const ELFRelocationRef &>(
210  }
211 };
212 
216 }
217 
218 template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
219  uint16_t getEMachine() const override;
220  uint16_t getEType() const override;
221  uint64_t getSymbolSize(DataRefImpl Sym) const override;
222 
223 public:
225 
226  using uintX_t = typename ELFT::uint;
227 
228  using Elf_Sym = typename ELFT::Sym;
229  using Elf_Shdr = typename ELFT::Shdr;
230  using Elf_Ehdr = typename ELFT::Ehdr;
231  using Elf_Rel = typename ELFT::Rel;
232  using Elf_Rela = typename ELFT::Rela;
233  using Elf_Dyn = typename ELFT::Dyn;
234 
235 private:
236  ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
237  const Elf_Shdr *DotDynSymSec, const Elf_Shdr *DotSymtabSec,
238  ArrayRef<Elf_Word> ShndxTable);
239 
240 protected:
241  ELFFile<ELFT> EF;
242 
243  const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section.
244  const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section.
245  ArrayRef<Elf_Word> ShndxTable;
246 
247  void moveSymbolNext(DataRefImpl &Symb) const override;
249  Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
250  uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
252  uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
253  uint32_t getSymbolFlags(DataRefImpl Symb) const override;
254  uint8_t getSymbolOther(DataRefImpl Symb) const override;
255  uint8_t getSymbolELFType(DataRefImpl Symb) const override;
258  const Elf_Shdr *SymTab) const;
260 
261  void moveSectionNext(DataRefImpl &Sec) const override;
262  std::error_code getSectionName(DataRefImpl Sec,
263  StringRef &Res) const override;
264  uint64_t getSectionAddress(DataRefImpl Sec) const override;
265  uint64_t getSectionIndex(DataRefImpl Sec) const override;
266  uint64_t getSectionSize(DataRefImpl Sec) const override;
267  std::error_code getSectionContents(DataRefImpl Sec,
268  StringRef &Res) const override;
269  uint64_t getSectionAlignment(DataRefImpl Sec) const override;
270  bool isSectionCompressed(DataRefImpl Sec) const override;
271  bool isSectionText(DataRefImpl Sec) const override;
272  bool isSectionData(DataRefImpl Sec) const override;
273  bool isSectionBSS(DataRefImpl Sec) const override;
274  bool isSectionVirtual(DataRefImpl Sec) const override;
275  bool isBerkeleyText(DataRefImpl Sec) const override;
276  bool isBerkeleyData(DataRefImpl Sec) const override;
278  relocation_iterator section_rel_end(DataRefImpl Sec) const override;
279  std::vector<SectionRef> dynamic_relocation_sections() const override;
281 
282  void moveRelocationNext(DataRefImpl &Rel) const override;
283  uint64_t getRelocationOffset(DataRefImpl Rel) const override;
284  symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
285  uint64_t getRelocationType(DataRefImpl Rel) const override;
287  SmallVectorImpl<char> &Result) const override;
288 
289  uint32_t getSectionType(DataRefImpl Sec) const override;
290  uint64_t getSectionFlags(DataRefImpl Sec) const override;
291  uint64_t getSectionOffset(DataRefImpl Sec) const override;
293 
294  /// Get the relocation section that contains \a Rel.
295  const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
296  auto RelSecOrErr = EF.getSection(Rel.d.a);
297  if (!RelSecOrErr)
298  report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message());
299  return *RelSecOrErr;
300  }
301 
302  DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
303  DataRefImpl DRI;
304  if (!SymTable) {
305  DRI.d.a = 0;
306  DRI.d.b = 0;
307  return DRI;
308  }
309  assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
310  SymTable->sh_type == ELF::SHT_DYNSYM);
311 
312  auto SectionsOrErr = EF.sections();
313  if (!SectionsOrErr) {
314  DRI.d.a = 0;
315  DRI.d.b = 0;
316  return DRI;
317  }
318  uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
319  unsigned SymTableIndex =
320  (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr);
321 
322  DRI.d.a = SymTableIndex;
323  DRI.d.b = SymbolNum;
324  return DRI;
325  }
326 
327  const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const {
328  return reinterpret_cast<const Elf_Shdr *>(Sec.p);
329  }
330 
331  DataRefImpl toDRI(const Elf_Shdr *Sec) const {
332  DataRefImpl DRI;
333  DRI.p = reinterpret_cast<uintptr_t>(Sec);
334  return DRI;
335  }
336 
337  DataRefImpl toDRI(const Elf_Dyn *Dyn) const {
338  DataRefImpl DRI;
339  DRI.p = reinterpret_cast<uintptr_t>(Dyn);
340  return DRI;
341  }
342 
343  bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
344  unsigned char Binding = ESym->getBinding();
345  unsigned char Visibility = ESym->getVisibility();
346 
347  // A symbol is exported if its binding is either GLOBAL or WEAK, and its
348  // visibility is either DEFAULT or PROTECTED. All other symbols are not
349  // exported.
350  return (
351  (Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK ||
352  Binding == ELF::STB_GNU_UNIQUE) &&
353  (Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_PROTECTED));
354  }
355 
356  // This flag is used for classof, to distinguish ELFObjectFile from
357  // its subclass. If more subclasses will be created, this flag will
358  // have to become an enum.
360 
361 public:
363  static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object);
364 
365  const Elf_Rel *getRel(DataRefImpl Rel) const;
366  const Elf_Rela *getRela(DataRefImpl Rela) const;
367 
368  const Elf_Sym *getSymbol(DataRefImpl Sym) const {
369  auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
370  if (!Ret)
371  report_fatal_error(errorToErrorCode(Ret.takeError()).message());
372  return *Ret;
373  }
374 
375  const Elf_Shdr *getSection(DataRefImpl Sec) const {
376  return reinterpret_cast<const Elf_Shdr *>(Sec.p);
377  }
378 
379  basic_symbol_iterator symbol_begin() const override;
380  basic_symbol_iterator symbol_end() const override;
381 
382  elf_symbol_iterator dynamic_symbol_begin() const;
383  elf_symbol_iterator dynamic_symbol_end() const;
384 
385  section_iterator section_begin() const override;
386  section_iterator section_end() const override;
387 
389 
390  uint8_t getBytesInAddress() const override;
391  StringRef getFileFormatName() const override;
392  Triple::ArchType getArch() const override;
393  Expected<uint64_t> getStartAddress() const override;
394 
395  unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; }
396 
397  std::error_code getBuildAttributes(ARMAttributeParser &Attributes) const override {
398  auto SectionsOrErr = EF.sections();
399  if (!SectionsOrErr)
400  return errorToErrorCode(SectionsOrErr.takeError());
401 
402  for (const Elf_Shdr &Sec : *SectionsOrErr) {
403  if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
404  auto ErrorOrContents = EF.getSectionContents(&Sec);
405  if (!ErrorOrContents)
406  return errorToErrorCode(ErrorOrContents.takeError());
407 
408  auto Contents = ErrorOrContents.get();
409  if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
410  return std::error_code();
411 
412  Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
413  break;
414  }
415  }
416  return std::error_code();
417  }
418 
419  const ELFFile<ELFT> *getELFFile() const { return &EF; }
420 
421  bool isDyldType() const { return isDyldELFObject; }
422  static bool classof(const Binary *v) {
423  return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
424  ELFT::Is64Bits);
425  }
426 
428 
429  bool isRelocatableObject() const override;
430 };
431 
436 
437 template <class ELFT>
439  ++Sym.d.b;
440 }
441 
442 template <class ELFT>
444  const Elf_Sym *ESym = getSymbol(Sym);
445  auto SymTabOrErr = EF.getSection(Sym.d.a);
446  if (!SymTabOrErr)
447  return SymTabOrErr.takeError();
448  const Elf_Shdr *SymTableSec = *SymTabOrErr;
449  auto StrTabOrErr = EF.getSection(SymTableSec->sh_link);
450  if (!StrTabOrErr)
451  return StrTabOrErr.takeError();
452  const Elf_Shdr *StringTableSec = *StrTabOrErr;
453  auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
454  if (!SymStrTabOrErr)
455  return SymStrTabOrErr.takeError();
456  Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr);
457 
458  // If the symbol name is empty use the section name.
459  if ((!Name || Name->empty()) && ESym->getType() == ELF::STT_SECTION) {
460  StringRef SecName;
462  if (Sec && !(*Sec)->getName(SecName))
463  return SecName;
464  }
465  return Name;
466 }
467 
468 template <class ELFT>
470  return getSection(Sec)->sh_flags;
471 }
472 
473 template <class ELFT>
475  return getSection(Sec)->sh_type;
476 }
477 
478 template <class ELFT>
480  return getSection(Sec)->sh_offset;
481 }
482 
483 template <class ELFT>
485  const Elf_Sym *ESym = getSymbol(Symb);
486  uint64_t Ret = ESym->st_value;
487  if (ESym->st_shndx == ELF::SHN_ABS)
488  return Ret;
489 
490  const Elf_Ehdr *Header = EF.getHeader();
491  // Clear the ARM/Thumb or microMIPS indicator flag.
492  if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
493  ESym->getType() == ELF::STT_FUNC)
494  Ret &= ~1;
495 
496  return Ret;
497 }
498 
499 template <class ELFT>
502  uint64_t Result = getSymbolValue(Symb);
503  const Elf_Sym *ESym = getSymbol(Symb);
504  switch (ESym->st_shndx) {
505  case ELF::SHN_COMMON:
506  case ELF::SHN_UNDEF:
507  case ELF::SHN_ABS:
508  return Result;
509  }
510 
511  const Elf_Ehdr *Header = EF.getHeader();
512  auto SymTabOrErr = EF.getSection(Symb.d.a);
513  if (!SymTabOrErr)
514  return SymTabOrErr.takeError();
515  const Elf_Shdr *SymTab = *SymTabOrErr;
516 
517  if (Header->e_type == ELF::ET_REL) {
518  auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
519  if (!SectionOrErr)
520  return SectionOrErr.takeError();
521  const Elf_Shdr *Section = *SectionOrErr;
522  if (Section)
523  Result += Section->sh_addr;
524  }
525 
526  return Result;
527 }
528 
529 template <class ELFT>
531  const Elf_Sym *Sym = getSymbol(Symb);
532  if (Sym->st_shndx == ELF::SHN_COMMON)
533  return Sym->st_value;
534  return 0;
535 }
536 
537 template <class ELFT>
538 uint16_t ELFObjectFile<ELFT>::getEMachine() const {
539  return EF.getHeader()->e_machine;
540 }
541 
542 template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const {
543  return EF.getHeader()->e_type;
544 }
545 
546 template <class ELFT>
548  return getSymbol(Sym)->st_size;
549 }
550 
551 template <class ELFT>
553  return getSymbol(Symb)->st_size;
554 }
555 
556 template <class ELFT>
558  return getSymbol(Symb)->st_other;
559 }
560 
561 template <class ELFT>
563  return getSymbol(Symb)->getType();
564 }
565 
566 template <class ELFT>
569  const Elf_Sym *ESym = getSymbol(Symb);
570 
571  switch (ESym->getType()) {
572  case ELF::STT_NOTYPE:
573  return SymbolRef::ST_Unknown;
574  case ELF::STT_SECTION:
575  return SymbolRef::ST_Debug;
576  case ELF::STT_FILE:
577  return SymbolRef::ST_File;
578  case ELF::STT_FUNC:
579  return SymbolRef::ST_Function;
580  case ELF::STT_OBJECT:
581  case ELF::STT_COMMON:
582  case ELF::STT_TLS:
583  return SymbolRef::ST_Data;
584  default:
585  return SymbolRef::ST_Other;
586  }
587 }
588 
589 template <class ELFT>
591  const Elf_Sym *ESym = getSymbol(Sym);
592 
593  uint32_t Result = SymbolRef::SF_None;
594 
595  if (ESym->getBinding() != ELF::STB_LOCAL)
596  Result |= SymbolRef::SF_Global;
597 
598  if (ESym->getBinding() == ELF::STB_WEAK)
599  Result |= SymbolRef::SF_Weak;
600 
601  if (ESym->st_shndx == ELF::SHN_ABS)
602  Result |= SymbolRef::SF_Absolute;
603 
604  if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION)
606 
607  auto DotSymtabSecSyms = EF.symbols(DotSymtabSec);
608  if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
610  auto DotDynSymSecSyms = EF.symbols(DotDynSymSec);
611  if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
613 
614  if (EF.getHeader()->e_machine == ELF::EM_ARM) {
615  if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
616  StringRef Name = *NameOrErr;
617  if (Name.startswith("$d") || Name.startswith("$t") ||
618  Name.startswith("$a"))
620  } else {
621  // TODO: Actually report errors helpfully.
622  consumeError(NameOrErr.takeError());
623  }
624  if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 1)
625  Result |= SymbolRef::SF_Thumb;
626  }
627 
628  if (ESym->st_shndx == ELF::SHN_UNDEF)
629  Result |= SymbolRef::SF_Undefined;
630 
631  if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON)
632  Result |= SymbolRef::SF_Common;
633 
634  if (isExportedToOtherDSO(ESym))
635  Result |= SymbolRef::SF_Exported;
636 
637  if (ESym->getVisibility() == ELF::STV_HIDDEN)
638  Result |= SymbolRef::SF_Hidden;
639 
640  return Result;
641 }
642 
643 template <class ELFT>
646  const Elf_Shdr *SymTab) const {
647  auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
648  if (!ESecOrErr)
649  return ESecOrErr.takeError();
650 
651  const Elf_Shdr *ESec = *ESecOrErr;
652  if (!ESec)
653  return section_end();
654 
655  DataRefImpl Sec;
656  Sec.p = reinterpret_cast<intptr_t>(ESec);
657  return section_iterator(SectionRef(Sec, this));
658 }
659 
660 template <class ELFT>
663  const Elf_Sym *Sym = getSymbol(Symb);
664  auto SymTabOrErr = EF.getSection(Symb.d.a);
665  if (!SymTabOrErr)
666  return SymTabOrErr.takeError();
667  const Elf_Shdr *SymTab = *SymTabOrErr;
668  return getSymbolSection(Sym, SymTab);
669 }
670 
671 template <class ELFT>
673  const Elf_Shdr *ESec = getSection(Sec);
674  Sec = toDRI(++ESec);
675 }
676 
677 template <class ELFT>
679  StringRef &Result) const {
680  auto Name = EF.getSectionName(&*getSection(Sec));
681  if (!Name)
682  return errorToErrorCode(Name.takeError());
683  Result = *Name;
684  return std::error_code();
685 }
686 
687 template <class ELFT>
689  return getSection(Sec)->sh_addr;
690 }
691 
692 template <class ELFT>
694  auto SectionsOrErr = EF.sections();
695  handleAllErrors(std::move(SectionsOrErr.takeError()),
696  [](const ErrorInfoBase &) {
697  llvm_unreachable("unable to get section index");
698  });
699  const Elf_Shdr *First = SectionsOrErr->begin();
700  return getSection(Sec) - First;
701 }
702 
703 template <class ELFT>
705  return getSection(Sec)->sh_size;
706 }
707 
708 template <class ELFT>
709 std::error_code
711  StringRef &Result) const {
712  const Elf_Shdr *EShdr = getSection(Sec);
713  if (std::error_code EC =
715  (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
716  return EC;
717  Result = StringRef((const char *)base() + EShdr->sh_offset, EShdr->sh_size);
718  return std::error_code();
719 }
720 
721 template <class ELFT>
723  return getSection(Sec)->sh_addralign;
724 }
725 
726 template <class ELFT>
728  return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED;
729 }
730 
731 template <class ELFT>
733  return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR;
734 }
735 
736 template <class ELFT>
738  const Elf_Shdr *EShdr = getSection(Sec);
739  return EShdr->sh_type == ELF::SHT_PROGBITS &&
740  EShdr->sh_flags & ELF::SHF_ALLOC &&
741  !(EShdr->sh_flags & ELF::SHF_EXECINSTR);
742 }
743 
744 template <class ELFT>
746  const Elf_Shdr *EShdr = getSection(Sec);
747  return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
748  EShdr->sh_type == ELF::SHT_NOBITS;
749 }
750 
751 template <class ELFT>
752 std::vector<SectionRef>
754  std::vector<SectionRef> Res;
755  std::vector<uintptr_t> Offsets;
756 
757  auto SectionsOrErr = EF.sections();
758  if (!SectionsOrErr)
759  return Res;
760 
761  for (const Elf_Shdr &Sec : *SectionsOrErr) {
762  if (Sec.sh_type != ELF::SHT_DYNAMIC)
763  continue;
764  Elf_Dyn *Dynamic =
765  reinterpret_cast<Elf_Dyn *>((uintptr_t)base() + Sec.sh_offset);
766  for (; Dynamic->d_tag != ELF::DT_NULL; Dynamic++) {
767  if (Dynamic->d_tag == ELF::DT_REL || Dynamic->d_tag == ELF::DT_RELA ||
768  Dynamic->d_tag == ELF::DT_JMPREL) {
769  Offsets.push_back(Dynamic->d_un.d_val);
770  }
771  }
772  }
773  for (const Elf_Shdr &Sec : *SectionsOrErr) {
774  if (is_contained(Offsets, Sec.sh_offset))
775  Res.emplace_back(toDRI(&Sec), this);
776  }
777  return Res;
778 }
779 
780 template <class ELFT>
782  return getSection(Sec)->sh_type == ELF::SHT_NOBITS;
783 }
784 
785 template <class ELFT>
787  return getSection(Sec)->sh_flags & ELF::SHF_ALLOC &&
788  (getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR ||
789  !(getSection(Sec)->sh_flags & ELF::SHF_WRITE));
790 }
791 
792 template <class ELFT>
794  const Elf_Shdr *EShdr = getSection(Sec);
795  return !isBerkeleyText(Sec) && EShdr->sh_type != ELF::SHT_NOBITS &&
796  EShdr->sh_flags & ELF::SHF_ALLOC;
797 }
798 
799 template <class ELFT>
802  DataRefImpl RelData;
803  auto SectionsOrErr = EF.sections();
804  if (!SectionsOrErr)
806  uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
807  RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
808  RelData.d.b = 0;
809  return relocation_iterator(RelocationRef(RelData, this));
810 }
811 
812 template <class ELFT>
815  const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
817  if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
818  return Begin;
819  DataRefImpl RelData = Begin->getRawDataRefImpl();
820  const Elf_Shdr *RelSec = getRelSection(RelData);
821 
822  // Error check sh_link here so that getRelocationSymbol can just use it.
823  auto SymSecOrErr = EF.getSection(RelSec->sh_link);
824  if (!SymSecOrErr)
825  report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message());
826 
827  RelData.d.b += S->sh_size / S->sh_entsize;
828  return relocation_iterator(RelocationRef(RelData, this));
829 }
830 
831 template <class ELFT>
834  if (EF.getHeader()->e_type != ELF::ET_REL)
835  return section_end();
836 
837  const Elf_Shdr *EShdr = getSection(Sec);
838  uintX_t Type = EShdr->sh_type;
839  if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
840  return section_end();
841 
842  auto R = EF.getSection(EShdr->sh_info);
843  if (!R)
844  report_fatal_error(errorToErrorCode(R.takeError()).message());
845  return section_iterator(SectionRef(toDRI(*R), this));
846 }
847 
848 // Relocations
849 template <class ELFT>
851  ++Rel.d.b;
852 }
853 
854 template <class ELFT>
857  uint32_t symbolIdx;
858  const Elf_Shdr *sec = getRelSection(Rel);
859  if (sec->sh_type == ELF::SHT_REL)
860  symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL());
861  else
862  symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL());
863  if (!symbolIdx)
864  return symbol_end();
865 
866  // FIXME: error check symbolIdx
867  DataRefImpl SymbolData;
868  SymbolData.d.a = sec->sh_link;
869  SymbolData.d.b = symbolIdx;
870  return symbol_iterator(SymbolRef(SymbolData, this));
871 }
872 
873 template <class ELFT>
875  const Elf_Shdr *sec = getRelSection(Rel);
876  if (sec->sh_type == ELF::SHT_REL)
877  return getRel(Rel)->r_offset;
878 
879  return getRela(Rel)->r_offset;
880 }
881 
882 template <class ELFT>
884  const Elf_Shdr *sec = getRelSection(Rel);
885  if (sec->sh_type == ELF::SHT_REL)
886  return getRel(Rel)->getType(EF.isMips64EL());
887  else
888  return getRela(Rel)->getType(EF.isMips64EL());
889 }
890 
891 template <class ELFT>
893  return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
894 }
895 
896 template <class ELFT>
898  DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
900  EF.getRelocationTypeName(type, Result);
901 }
902 
903 template <class ELFT>
906  if (getRelSection(Rel)->sh_type != ELF::SHT_RELA)
907  return createError("Section is not SHT_RELA");
908  return (int64_t)getRela(Rel)->r_addend;
909 }
910 
911 template <class ELFT>
912 const typename ELFObjectFile<ELFT>::Elf_Rel *
914  assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
915  auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b);
916  if (!Ret)
917  report_fatal_error(errorToErrorCode(Ret.takeError()).message());
918  return *Ret;
919 }
920 
921 template <class ELFT>
922 const typename ELFObjectFile<ELFT>::Elf_Rela *
924  assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
925  auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b);
926  if (!Ret)
927  report_fatal_error(errorToErrorCode(Ret.takeError()).message());
928  return *Ret;
929 }
930 
931 template <class ELFT>
934  auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
935  if (Error E = EFOrErr.takeError())
936  return std::move(E);
937  auto EF = std::move(*EFOrErr);
938 
939  auto SectionsOrErr = EF.sections();
940  if (!SectionsOrErr)
941  return SectionsOrErr.takeError();
942 
943  const Elf_Shdr *DotDynSymSec = nullptr;
944  const Elf_Shdr *DotSymtabSec = nullptr;
945  ArrayRef<Elf_Word> ShndxTable;
946  for (const Elf_Shdr &Sec : *SectionsOrErr) {
947  switch (Sec.sh_type) {
948  case ELF::SHT_DYNSYM: {
949  if (DotDynSymSec)
950  return createError("More than one dynamic symbol table!");
951  DotDynSymSec = &Sec;
952  break;
953  }
954  case ELF::SHT_SYMTAB: {
955  if (DotSymtabSec)
956  return createError("More than one static symbol table!");
957  DotSymtabSec = &Sec;
958  break;
959  }
960  case ELF::SHT_SYMTAB_SHNDX: {
961  auto TableOrErr = EF.getSHNDXTable(Sec);
962  if (!TableOrErr)
963  return TableOrErr.takeError();
964  ShndxTable = *TableOrErr;
965  break;
966  }
967  }
968  }
969  return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec,
970  ShndxTable);
971 }
972 
973 template <class ELFT>
975  const Elf_Shdr *DotDynSymSec,
976  const Elf_Shdr *DotSymtabSec,
977  ArrayRef<Elf_Word> ShndxTable)
979  getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
980  Object),
981  EF(EF), DotDynSymSec(DotDynSymSec), DotSymtabSec(DotSymtabSec),
982  ShndxTable(ShndxTable) {}
983 
984 template <class ELFT>
985 ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other)
986  : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec,
987  Other.DotSymtabSec, Other.ShndxTable) {}
988 
989 template <class ELFT>
991  DataRefImpl Sym = toDRI(DotSymtabSec, 0);
992  return basic_symbol_iterator(SymbolRef(Sym, this));
993 }
994 
995 template <class ELFT>
997  const Elf_Shdr *SymTab = DotSymtabSec;
998  if (!SymTab)
999  return symbol_begin();
1000  DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
1001  return basic_symbol_iterator(SymbolRef(Sym, this));
1002 }
1003 
1004 template <class ELFT>
1006  DataRefImpl Sym = toDRI(DotDynSymSec, 0);
1007  return symbol_iterator(SymbolRef(Sym, this));
1008 }
1009 
1010 template <class ELFT>
1012  const Elf_Shdr *SymTab = DotDynSymSec;
1013  if (!SymTab)
1014  return dynamic_symbol_begin();
1015  DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
1016  return basic_symbol_iterator(SymbolRef(Sym, this));
1017 }
1018 
1019 template <class ELFT>
1021  auto SectionsOrErr = EF.sections();
1022  if (!SectionsOrErr)
1023  return section_iterator(SectionRef());
1024  return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this));
1025 }
1026 
1027 template <class ELFT>
1029  auto SectionsOrErr = EF.sections();
1030  if (!SectionsOrErr)
1031  return section_iterator(SectionRef());
1032  return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this));
1033 }
1034 
1035 template <class ELFT>
1037  return ELFT::Is64Bits ? 8 : 4;
1038 }
1039 
1040 template <class ELFT>
1042  bool IsLittleEndian = ELFT::TargetEndianness == support::little;
1043  switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
1044  case ELF::ELFCLASS32:
1045  switch (EF.getHeader()->e_machine) {
1046  case ELF::EM_386:
1047  return "ELF32-i386";
1048  case ELF::EM_IAMCU:
1049  return "ELF32-iamcu";
1050  case ELF::EM_X86_64:
1051  return "ELF32-x86-64";
1052  case ELF::EM_ARM:
1053  return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
1054  case ELF::EM_AVR:
1055  return "ELF32-avr";
1056  case ELF::EM_HEXAGON:
1057  return "ELF32-hexagon";
1058  case ELF::EM_LANAI:
1059  return "ELF32-lanai";
1060  case ELF::EM_MIPS:
1061  return "ELF32-mips";
1062  case ELF::EM_MSP430:
1063  return "ELF32-msp430";
1064  case ELF::EM_PPC:
1065  return "ELF32-ppc";
1066  case ELF::EM_RISCV:
1067  return "ELF32-riscv";
1068  case ELF::EM_SPARC:
1069  case ELF::EM_SPARC32PLUS:
1070  return "ELF32-sparc";
1071  case ELF::EM_AMDGPU:
1072  return "ELF32-amdgpu";
1073  default:
1074  return "ELF32-unknown";
1075  }
1076  case ELF::ELFCLASS64:
1077  switch (EF.getHeader()->e_machine) {
1078  case ELF::EM_386:
1079  return "ELF64-i386";
1080  case ELF::EM_X86_64:
1081  return "ELF64-x86-64";
1082  case ELF::EM_AARCH64:
1083  return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
1084  case ELF::EM_PPC64:
1085  return "ELF64-ppc64";
1086  case ELF::EM_RISCV:
1087  return "ELF64-riscv";
1088  case ELF::EM_S390:
1089  return "ELF64-s390";
1090  case ELF::EM_SPARCV9:
1091  return "ELF64-sparc";
1092  case ELF::EM_MIPS:
1093  return "ELF64-mips";
1094  case ELF::EM_AMDGPU:
1095  return "ELF64-amdgpu";
1096  case ELF::EM_BPF:
1097  return "ELF64-BPF";
1098  default:
1099  return "ELF64-unknown";
1100  }
1101  default:
1102  // FIXME: Proper error handling.
1103  report_fatal_error("Invalid ELFCLASS!");
1104  }
1105 }
1106 
1107 template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
1108  bool IsLittleEndian = ELFT::TargetEndianness == support::little;
1109  switch (EF.getHeader()->e_machine) {
1110  case ELF::EM_386:
1111  case ELF::EM_IAMCU:
1112  return Triple::x86;
1113  case ELF::EM_X86_64:
1114  return Triple::x86_64;
1115  case ELF::EM_AARCH64:
1116  return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be;
1117  case ELF::EM_ARM:
1118  return Triple::arm;
1119  case ELF::EM_AVR:
1120  return Triple::avr;
1121  case ELF::EM_HEXAGON:
1122  return Triple::hexagon;
1123  case ELF::EM_LANAI:
1124  return Triple::lanai;
1125  case ELF::EM_MIPS:
1126  switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
1127  case ELF::ELFCLASS32:
1128  return IsLittleEndian ? Triple::mipsel : Triple::mips;
1129  case ELF::ELFCLASS64:
1130  return IsLittleEndian ? Triple::mips64el : Triple::mips64;
1131  default:
1132  report_fatal_error("Invalid ELFCLASS!");
1133  }
1134  case ELF::EM_MSP430:
1135  return Triple::msp430;
1136  case ELF::EM_PPC:
1137  return Triple::ppc;
1138  case ELF::EM_PPC64:
1139  return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
1140  case ELF::EM_RISCV:
1141  switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
1142  case ELF::ELFCLASS32:
1143  return Triple::riscv32;
1144  case ELF::ELFCLASS64:
1145  return Triple::riscv64;
1146  default:
1147  report_fatal_error("Invalid ELFCLASS!");
1148  }
1149  case ELF::EM_S390:
1150  return Triple::systemz;
1151 
1152  case ELF::EM_SPARC:
1153  case ELF::EM_SPARC32PLUS:
1154  return IsLittleEndian ? Triple::sparcel : Triple::sparc;
1155  case ELF::EM_SPARCV9:
1156  return Triple::sparcv9;
1157 
1158  case ELF::EM_AMDGPU: {
1159  if (!IsLittleEndian)
1160  return Triple::UnknownArch;
1161 
1162  unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH;
1163  if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST &&
1165  return Triple::r600;
1166  if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST &&
1168  return Triple::amdgcn;
1169 
1170  return Triple::UnknownArch;
1171  }
1172 
1173  case ELF::EM_BPF:
1174  return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
1175 
1176  default:
1177  return Triple::UnknownArch;
1178  }
1179 }
1180 
1181 template <class ELFT>
1183  return EF.getHeader()->e_entry;
1184 }
1185 
1186 template <class ELFT>
1190 }
1191 
1192 template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
1193  return EF.getHeader()->e_type == ELF::ET_REL;
1194 }
1195 
1196 } // end namespace object
1197 } // end namespace llvm
1198 
1199 #endif // LLVM_OBJECT_ELFOBJECTFILE_H
const content_type & operator*() const
Definition: SymbolicFile.h:78
void getRelocationTypeName(DataRefImpl Rel, SmallVectorImpl< char > &Result) const override
uint64_t getSectionSize(DataRefImpl Sec) const override
virtual uint16_t getEMachine() const =0
static bool classof(const Binary *v)
Expected< uint64_t > getStartAddress() const override
friend class SymbolRef
Definition: ObjectFile.h:243
virtual bool isBerkeleyData(DataRefImpl Sec) const
Definition: ObjectFile.cpp:83
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static Expected< ELFFile > create(StringRef Object)
Definition: ELF.h:446
SubtargetFeatures getFeatures() const override
const Elf_Shdr * toELFShdrIter(DataRefImpl Sec) const
std::vector< SectionRef > dynamic_relocation_sections() const override
bool isSectionBSS(DataRefImpl Sec) const override
bool isSectionText(DataRefImpl Sec) const override
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
friend class SectionRef
Definition: ObjectFile.h:257
elf_relocation_iterator(const relocation_iterator &B)
LLVM_NODISCARD bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:256
This provides a very simple, boring adaptor for a begin and end iterator into a range type...
const ELFObjectFileBase * getObject() const
void moveSymbolNext(DataRefImpl &Symb) const override
static std::error_code checkOffset(MemoryBufferRef M, uintptr_t Addr, const uint64_t Size)
Definition: Binary.h:155
bool isRelocatableObject() const override
True if this is a relocatable object (.o/.obj).
Expected< StringRef > getSymbolName(DataRefImpl Symb) const override
Offsets
Offsets in bytes from the start of the input buffer.
Definition: SIInstrInfo.h:1034
virtual bool isSectionBSS(DataRefImpl Sec) const =0
This class is the base class for all object file types.
Definition: ObjectFile.h:225
elf_symbol_iterator_range symbols() const
typename ELFT::Rel Elf_Rel
virtual uint64_t getRelocationOffset(DataRefImpl Rel) const =0
static std::error_code getObject(const T *&Obj, MemoryBufferRef M, const void *Ptr, const uint64_t Size=sizeof(T))
const uint8_t * base() const
Definition: ObjectFile.h:231
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:848
virtual std::error_code getSectionName(DataRefImpl Sec, StringRef &Res) const =0
static Error createError(StringRef Err)
Definition: ELF.h:47
const ObjectFile * getObject() const
Definition: ObjectFile.h:554
virtual uint32_t getSymbolAlignment(DataRefImpl Symb) const
Definition: ObjectFile.cpp:68
Base class for error info classes.
Definition: Error.h:48
bool isSectionVirtual(DataRefImpl Sec) const override
virtual Expected< StringRef > getSymbolName(DataRefImpl Symb) const =0
uint32_t getSectionType(DataRefImpl Sec) const override
virtual Expected< int64_t > getRelocationAddend(DataRefImpl Rel) const =0
void moveRelocationNext(DataRefImpl &Rel) const override
virtual relocation_iterator section_rel_end(DataRefImpl Sec) const =0
basic_symbol_iterator symbol_begin() const override
symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override
virtual basic_symbol_iterator symbol_begin() const =0
Definition: BitVector.h:937
void setARMSubArch(Triple &TheTriple) const override
uint8_t getSymbolOther(DataRefImpl Symb) const override
const Elf_Shdr * DotSymtabSec
uint64_t getSectionAlignment(DataRefImpl Sec) const override
virtual std::error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const =0
Expected< Elf_Shdr_Range > sections() const
Definition: ELF.h:453
StringRef getBuffer() const
Definition: MemoryBuffer.h:272
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:41
This is a value type class that represents a single relocation in the list of relocations in the obje...
Definition: ObjectFile.h:51
Expected< section_iterator > getSymbolSection(const Elf_Sym *Symb, const Elf_Shdr *SymTab) const
elf_section_iterator(const section_iterator &B)
typename ELFT::Ehdr Elf_Ehdr
virtual uint64_t getSectionIndex(DataRefImpl Sec) const =0
const ELFObjectFileBase * getObject() const
Tagged union holding either a T or a Error.
Definition: CachePruning.h:22
ELFYAML::ELF_STO Other
Definition: ELFYAML.cpp:849
Expected< const typename ELFT::Shdr * > getSection(typename ELFT::ShdrRange Sections, uint32_t Index)
Definition: ELF.h:272
virtual relocation_iterator section_rel_begin(DataRefImpl Sec) const =0
content_iterator< SectionRef > section_iterator
Definition: ObjectFile.h:47
uint64_t getSymbolValueImpl(DataRefImpl Symb) const override
const ObjectFile * getObject() const
Definition: ObjectFile.h:413
uint8_t getBytesInAddress() const override
The number of bytes used to represent an address in this object file format.
DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const
virtual uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const =0
section_iterator section_begin() const override
std::error_code getSectionContents(DataRefImpl Sec, StringRef &Res) const override
MemoryBufferRef getMemoryBufferRef() const
Definition: Binary.cpp:43
void moveSectionNext(DataRefImpl &Sec) const override
elf_symbol_iterator_range getDynamicSymbolIterators() const override
virtual uint64_t getSectionAlignment(DataRefImpl Sec) const =0
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:32
virtual Expected< uint64_t > getStartAddress() const
Definition: ObjectFile.h:327
const llvm::EnumEntry< unsigned > ElfSymbolTypes[NumElfSymbolTypes]
DataRefImpl toDRI(const Elf_Dyn *Dyn) const
constexpr int NumElfSymbolTypes
Definition: ELFObjectFile.h:44
std::error_code getBuildAttributes(ARMAttributeParser &Attributes) const override
const ObjectFile * getObject() const
Definition: ObjectFile.h:516
virtual uint64_t getSectionOffset(DataRefImpl Sec) const =0
Expected< const typename ELFT::Sym * > getSymbol(typename ELFT::SymRange Symbols, uint32_t Index)
Definition: ELF.h:334
std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type cast(const Y &Val)
Definition: Casting.h:249
elf_symbol_iterator dynamic_symbol_begin() const
relocation_iterator section_rel_end(DataRefImpl Sec) const override
struct llvm::object::DataRefImpl::@290 d
typename ELFT::Shdr Elf_Shdr
Expected< int64_t > getRelocationAddend(DataRefImpl Rel) const override
std::vector< std::pair< DataRefImpl, uint64_t > > getPltAddresses() const
const content_type * operator->() const
Definition: SymbolicFile.h:76
unsigned getPlatformFlags() const override
Returns platform-specific object flags, if any.
const Elf_Shdr * getSection(DataRefImpl Sec) const
virtual Expected< SymbolRef::Type > getSymbolType(DataRefImpl Symb) const =0
virtual uint32_t getSymbolFlags(DataRefImpl Symb) const =0
const Elf_Sym * getSymbol(DataRefImpl Sym) const
ELFRelocationRef(const RelocationRef &B)
static bool classof(const Binary *v)
Definition: ELFObjectFile.h:78
const ELFObjectFileBase * getObject() const
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
const Elf_Rela * getRela(DataRefImpl Rela) const
virtual uint8_t getBytesInAddress() const =0
The number of bytes used to represent an address in this object file format.
virtual void moveRelocationNext(DataRefImpl &Rel) const =0
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
unsigned int getType() const
Definition: Binary.h:95
uint32_t getSymbolFlags(DataRefImpl Symb) const override
virtual uint64_t getSectionFlags(DataRefImpl Sec) const =0
iterator_range< elf_symbol_iterator > elf_symbol_iterator_range
Definition: ELFObjectFile.h:69
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
typename ELFT::Sym Elf_Sym
const Elf_Shdr * DotDynSymSec
Expected< int64_t > getAddend() const
static unsigned int getELFType(bool isLE, bool is64Bits)
Definition: Binary.h:71
section_iterator getRelocatedSection(DataRefImpl Sec) const override
const Elf_Rel * getRel(DataRefImpl Rel) const
virtual std::vector< SectionRef > dynamic_relocation_sections() const
Definition: ObjectFile.h:302
uint32_t getSymbolAlignment(DataRefImpl Symb) const override
bool isSectionData(DataRefImpl Sec) const override
typename ELFT::Dyn Elf_Dyn
virtual basic_symbol_iterator symbol_end() const =0
static Expected< ELFObjectFile< ELFT > > create(MemoryBufferRef Object)
StringRef getELFTypeName() const
bool isExportedToOtherDSO(const Elf_Sym *ESym) const
uint8_t getSymbolELFType(DataRefImpl Symb) const override
uint64_t getSectionIndex(DataRefImpl Sec) const override
bool isELF() const
Definition: Binary.h:112
StringRef getFileFormatName() const override
const ELFSymbolRef & operator*() const
void consumeError(Error Err)
Consume a Error without doing anything.
Definition: Error.h:981
const ELFSectionRef & operator*() const
DataRefImpl toDRI(const Elf_Shdr *Sec) const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const ELFSectionRef * operator->() const
ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:43
uint64_t getSectionAddress(DataRefImpl Sec) const override
std::error_code getSectionName(DataRefImpl Sec, StringRef &Res) const override
uint64_t getRelocationOffset(DataRefImpl Rel) const override
bool isBerkeleyText(DataRefImpl Sec) const override
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type)
Definition: ELF.cpp:22
typename ELFT::Rela Elf_Rela
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:904
virtual Expected< uint64_t > getSymbolAddress(DataRefImpl Symb) const =0
uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override
friend class RelocationRef
Definition: ObjectFile.h:283
const ELFFile< ELFT > * getELFFile() const
virtual section_iterator section_begin() const =0
const SymbolicFile * getObject() const
Definition: SymbolicFile.h:208
const SymbolRef & operator*() const
Definition: ObjectFile.h:216
virtual uint64_t getSectionAddress(DataRefImpl Sec) const =0
virtual Triple::ArchType getArch() const =0
uint64_t getSymbolValue(DataRefImpl Symb) const
Definition: ObjectFile.cpp:50
virtual unsigned getPlatformFlags() const =0
Returns platform-specific object flags, if any.
virtual symbol_iterator getRelocationSymbol(DataRefImpl Rel) const =0
uint64_t getSectionFlags(DataRefImpl Sec) const override
Expected< uint64_t > getSymbolAddress(DataRefImpl Symb) const override
Triple::ArchType getArch() const override
content_iterator< BasicSymbolRef > basic_symbol_iterator
Definition: SymbolicFile.h:138
elf_symbol_iterator dynamic_symbol_end() const
A range adaptor for a pair of iterators.
MemoryBufferRef Data
Definition: Binary.h:37
Manages the enabling and disabling of subtarget specific features.
bool isBerkeleyData(DataRefImpl Sec) const override
uint64_t getOffset() const
virtual bool isSectionText(DataRefImpl Sec) const =0
virtual uint64_t getSymbolSize(DataRefImpl Symb) const =0
SubtargetFeatures getMIPSFeatures() const
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: ObjectFile.h:164
relocation_iterator section_rel_begin(DataRefImpl Sec) const override
Expected< SymbolRef::Type > getSymbolType(DataRefImpl Symb) const override
uint8_t getELFType() const
virtual void moveSectionNext(DataRefImpl &Sec) const =0
virtual section_iterator section_end() const =0
virtual bool isBerkeleyText(DataRefImpl Sec) const
Definition: ObjectFile.cpp:79
basic_symbol_iterator symbol_end() const override
virtual uint16_t getEType() const =0
bool isSectionCompressed(DataRefImpl Sec) const override
virtual bool isSectionData(DataRefImpl Sec) const =0
ELFSectionRef(const SectionRef &B)
Definition: ELFObjectFile.h:97
const ELFSymbolRef * operator->() const
uint64_t getSectionOffset(DataRefImpl Sec) const override
virtual section_iterator getRelocatedSection(DataRefImpl Sec) const
Definition: ObjectFile.cpp:87
virtual uint32_t getSectionType(DataRefImpl Sec) const =0
virtual void moveSymbolNext(DataRefImpl &Symb) const =0
virtual uint64_t getSymbolValueImpl(DataRefImpl Symb) const =0
virtual bool isRelocatableObject() const =0
True if this is a relocatable object (.o/.obj).
section_iterator section_end() const override
const SymbolRef * operator->() const
Definition: ObjectFile.h:211
virtual bool isSectionCompressed(DataRefImpl Sec) const =0
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
virtual Expected< section_iterator > getSymbolSection(DataRefImpl Symb) const =0
uint64_t getSize() const
aarch64 promote const
virtual elf_symbol_iterator_range getDynamicSymbolIterators() const =0
virtual bool isSectionVirtual(DataRefImpl Sec) const =0
void Parse(ArrayRef< uint8_t > Section, bool isLittle)
virtual uint64_t getSectionSize(DataRefImpl Sec) const =0
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
virtual void getRelocationTypeName(DataRefImpl Rel, SmallVectorImpl< char > &Result) const =0
const ELFRelocationRef & operator*() const
content_iterator< RelocationRef > relocation_iterator
Definition: ObjectFile.h:76
SubtargetFeatures getARMFeatures() const
uint64_t getRelocationType(DataRefImpl Rel) const override
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
Definition: ELFTypes.h:103
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
virtual uint8_t getSymbolELFType(DataRefImpl Symb) const =0
SubtargetFeatures getRISCVFeatures() const
const Elf_Ehdr * getHeader() const
Definition: ELF.h:92
virtual uint8_t getSymbolOther(DataRefImpl Symb) const =0
const ELFRelocationRef * operator->() const
elf_symbol_iterator(const basic_symbol_iterator &B)
virtual StringRef getFileFormatName() const =0
virtual uint64_t getRelocationType(DataRefImpl Rel) const =0
std::error_code errorToErrorCode(Error Err)
Helper for converting an ECError to a std::error_code.
Definition: Error.cpp:93
typename ELFT::uint uintX_t
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:80
ELFSymbolRef(const SymbolRef &B)
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:1244