LCOV - code coverage report
Current view: top level - include/llvm/Object - ELFObjectFile.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 426 483 88.2 %
Date: 2017-09-14 15:23:50 Functions: 219 238 92.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- ELFObjectFile.h - ELF object file implementation ---------*- 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             : // This file declares the ELFObjectFile template class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_OBJECT_ELFOBJECTFILE_H
      15             : #define LLVM_OBJECT_ELFOBJECTFILE_H
      16             : 
      17             : #include "llvm/ADT/ArrayRef.h"
      18             : #include "llvm/ADT/SmallVector.h"
      19             : #include "llvm/ADT/StringRef.h"
      20             : #include "llvm/ADT/Triple.h"
      21             : #include "llvm/ADT/iterator_range.h"
      22             : #include "llvm/BinaryFormat/ELF.h"
      23             : #include "llvm/MC/SubtargetFeature.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"
      29             : #include "llvm/Object/SymbolicFile.h"
      30             : #include "llvm/Support/ARMAttributeParser.h"
      31             : #include "llvm/Support/ARMBuildAttributes.h"
      32             : #include "llvm/Support/Casting.h"
      33             : #include "llvm/Support/Endian.h"
      34             : #include "llvm/Support/Error.h"
      35             : #include "llvm/Support/ErrorHandling.h"
      36             : #include "llvm/Support/ErrorOr.h"
      37             : #include "llvm/Support/MemoryBuffer.h"
      38             : #include <cassert>
      39             : #include <cstdint>
      40             : #include <system_error>
      41             : 
      42             : namespace llvm {
      43             : namespace object {
      44             : 
      45             : class elf_symbol_iterator;
      46             : 
      47        7514 : class ELFObjectFileBase : public ObjectFile {
      48             :   friend class ELFRelocationRef;
      49             :   friend class ELFSectionRef;
      50             :   friend class ELFSymbolRef;
      51             : 
      52             : protected:
      53             :   ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
      54             : 
      55             :   virtual uint16_t getEMachine() const = 0;
      56             :   virtual uint64_t getSymbolSize(DataRefImpl Symb) const = 0;
      57             :   virtual uint8_t getSymbolOther(DataRefImpl Symb) const = 0;
      58             :   virtual uint8_t getSymbolELFType(DataRefImpl Symb) const = 0;
      59             : 
      60             :   virtual uint32_t getSectionType(DataRefImpl Sec) const = 0;
      61             :   virtual uint64_t getSectionFlags(DataRefImpl Sec) const = 0;
      62             :   virtual uint64_t getSectionOffset(DataRefImpl Sec) const = 0;
      63             : 
      64             :   virtual ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
      65             : 
      66             : public:
      67             :   using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>;
      68             : 
      69             :   virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
      70             : 
      71             :   elf_symbol_iterator_range symbols() const;
      72             : 
      73        9177 :   static bool classof(const Binary *v) { return v->isELF(); }
      74             : 
      75             :   SubtargetFeatures getFeatures() const override;
      76             : 
      77             :   SubtargetFeatures getMIPSFeatures() const;
      78             : 
      79             :   SubtargetFeatures getARMFeatures() const;
      80             : 
      81             :   void setARMSubArch(Triple &TheTriple) const override;
      82             : };
      83             : 
      84             : class ELFSectionRef : public SectionRef {
      85             : public:
      86        2723 :   ELFSectionRef(const SectionRef &B) : SectionRef(B) {
      87             :     assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
      88             :   }
      89             : 
      90             :   const ELFObjectFileBase *getObject() const {
      91        7042 :     return cast<ELFObjectFileBase>(SectionRef::getObject());
      92             :   }
      93             : 
      94             :   uint32_t getType() const {
      95        2490 :     return getObject()->getSectionType(getRawDataRefImpl());
      96             :   }
      97             : 
      98             :   uint64_t getFlags() const {
      99        4552 :     return getObject()->getSectionFlags(getRawDataRefImpl());
     100             :   }
     101             : 
     102             :   uint64_t getOffset() const {
     103             :     return getObject()->getSectionOffset(getRawDataRefImpl());
     104             :   }
     105             : };
     106             : 
     107             : class elf_section_iterator : public section_iterator {
     108             : public:
     109         406 :   elf_section_iterator(const section_iterator &B) : section_iterator(B) {
     110             :     assert(isa<ELFObjectFileBase>(B->getObject()));
     111             :   }
     112             : 
     113             :   const ELFSectionRef *operator->() const {
     114         798 :     return static_cast<const ELFSectionRef *>(section_iterator::operator->());
     115             :   }
     116             : 
     117             :   const ELFSectionRef &operator*() const {
     118             :     return static_cast<const ELFSectionRef &>(section_iterator::operator*());
     119             :   }
     120             : };
     121             : 
     122             : class ELFSymbolRef : public SymbolRef {
     123             : public:
     124         645 :   ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) {
     125             :     assert(isa<ELFObjectFileBase>(SymbolRef::getObject()));
     126             :   }
     127             : 
     128             :   const ELFObjectFileBase *getObject() const {
     129    16210136 :     return cast<ELFObjectFileBase>(BasicSymbolRef::getObject());
     130             :   }
     131             : 
     132             :   uint64_t getSize() const {
     133    16209996 :     return getObject()->getSymbolSize(getRawDataRefImpl());
     134             :   }
     135             : 
     136             :   uint8_t getOther() const {
     137           0 :     return getObject()->getSymbolOther(getRawDataRefImpl());
     138             :   }
     139             : 
     140             :   uint8_t getELFType() const {
     141         140 :     return getObject()->getSymbolELFType(getRawDataRefImpl());
     142             :   }
     143             : };
     144             : 
     145             : class elf_symbol_iterator : public symbol_iterator {
     146             : public:
     147        2248 :   elf_symbol_iterator(const basic_symbol_iterator &B)
     148        2248 :       : symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
     149       11240 :                                   cast<ELFObjectFileBase>(B->getObject()))) {}
     150             : 
     151             :   const ELFSymbolRef *operator->() const {
     152        7540 :     return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->());
     153             :   }
     154             : 
     155             :   const ELFSymbolRef &operator*() const {
     156    16208724 :     return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*());
     157             :   }
     158             : };
     159             : 
     160             : class ELFRelocationRef : public RelocationRef {
     161             : public:
     162        5252 :   ELFRelocationRef(const RelocationRef &B) : RelocationRef(B) {
     163             :     assert(isa<ELFObjectFileBase>(RelocationRef::getObject()));
     164             :   }
     165             : 
     166             :   const ELFObjectFileBase *getObject() const {
     167       10504 :     return cast<ELFObjectFileBase>(RelocationRef::getObject());
     168             :   }
     169             : 
     170             :   ErrorOr<int64_t> getAddend() const {
     171       10504 :     return getObject()->getRelocationAddend(getRawDataRefImpl());
     172             :   }
     173             : };
     174             : 
     175             : class elf_relocation_iterator : public relocation_iterator {
     176             : public:
     177             :   elf_relocation_iterator(const relocation_iterator &B)
     178             :       : relocation_iterator(RelocationRef(
     179           0 :             B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {}
     180             : 
     181             :   const ELFRelocationRef *operator->() const {
     182             :     return static_cast<const ELFRelocationRef *>(
     183           0 :         relocation_iterator::operator->());
     184             :   }
     185             : 
     186             :   const ELFRelocationRef &operator*() const {
     187             :     return static_cast<const ELFRelocationRef &>(
     188             :         relocation_iterator::operator*());
     189             :   }
     190             : };
     191             : 
     192             : inline ELFObjectFileBase::elf_symbol_iterator_range
     193         147 : ELFObjectFileBase::symbols() const {
     194         294 :   return elf_symbol_iterator_range(symbol_begin(), symbol_end());
     195             : }
     196             : 
     197        7514 : template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
     198             :   uint16_t getEMachine() const override;
     199             :   uint64_t getSymbolSize(DataRefImpl Sym) const override;
     200             : 
     201             : public:
     202             :   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
     203             : 
     204             :   using uintX_t = typename ELFFile<ELFT>::uintX_t;
     205             : 
     206             :   using Elf_Sym = typename ELFFile<ELFT>::Elf_Sym;
     207             :   using Elf_Shdr = typename ELFFile<ELFT>::Elf_Shdr;
     208             :   using Elf_Ehdr = typename ELFFile<ELFT>::Elf_Ehdr;
     209             :   using Elf_Rel = typename ELFFile<ELFT>::Elf_Rel;
     210             :   using Elf_Rela = typename ELFFile<ELFT>::Elf_Rela;
     211             :   using Elf_Dyn = typename ELFFile<ELFT>::Elf_Dyn;
     212             : 
     213             : protected:
     214             :   ELFFile<ELFT> EF;
     215             : 
     216             :   const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section.
     217             :   const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section.
     218             :   ArrayRef<Elf_Word> ShndxTable;
     219             : 
     220             :   void moveSymbolNext(DataRefImpl &Symb) const override;
     221             :   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
     222             :   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
     223             :   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
     224             :   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
     225             :   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
     226             :   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
     227             :   uint8_t getSymbolOther(DataRefImpl Symb) const override;
     228             :   uint8_t getSymbolELFType(DataRefImpl Symb) const override;
     229             :   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
     230             :   Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb,
     231             :                                               const Elf_Shdr *SymTab) const;
     232             :   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
     233             : 
     234             :   void moveSectionNext(DataRefImpl &Sec) const override;
     235             :   std::error_code getSectionName(DataRefImpl Sec,
     236             :                                  StringRef &Res) const override;
     237             :   uint64_t getSectionAddress(DataRefImpl Sec) const override;
     238             :   uint64_t getSectionIndex(DataRefImpl Sec) const override;
     239             :   uint64_t getSectionSize(DataRefImpl Sec) const override;
     240             :   std::error_code getSectionContents(DataRefImpl Sec,
     241             :                                      StringRef &Res) const override;
     242             :   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
     243             :   bool isSectionCompressed(DataRefImpl Sec) const override;
     244             :   bool isSectionText(DataRefImpl Sec) const override;
     245             :   bool isSectionData(DataRefImpl Sec) const override;
     246             :   bool isSectionBSS(DataRefImpl Sec) const override;
     247             :   bool isSectionVirtual(DataRefImpl Sec) const override;
     248             :   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
     249             :   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
     250             :   section_iterator getRelocatedSection(DataRefImpl Sec) const override;
     251             : 
     252             :   void moveRelocationNext(DataRefImpl &Rel) const override;
     253             :   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
     254             :   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
     255             :   uint64_t getRelocationType(DataRefImpl Rel) const override;
     256             :   void getRelocationTypeName(DataRefImpl Rel,
     257             :                              SmallVectorImpl<char> &Result) const override;
     258             : 
     259             :   uint32_t getSectionType(DataRefImpl Sec) const override;
     260             :   uint64_t getSectionFlags(DataRefImpl Sec) const override;
     261             :   uint64_t getSectionOffset(DataRefImpl Sec) const override;
     262             :   StringRef getRelocationTypeName(uint32_t Type) const;
     263             : 
     264             :   /// \brief Get the relocation section that contains \a Rel.
     265       29674 :   const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
     266       59348 :     auto RelSecOrErr = EF.getSection(Rel.d.a);
     267       29674 :     if (!RelSecOrErr)
     268           0 :       report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message());
     269       59348 :     return *RelSecOrErr;
     270             :   }
     271             : 
     272       10238 :   DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
     273       10238 :     DataRefImpl DRI;
     274       10238 :     if (!SymTable) {
     275             :       DRI.d.a = 0;
     276             :       DRI.d.b = 0;
     277         218 :       return DRI;
     278             :     }
     279             :     assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
     280             :            SymTable->sh_type == ELF::SHT_DYNSYM);
     281             : 
     282       10020 :     auto SectionsOrErr = EF.sections();
     283       10020 :     if (!SectionsOrErr) {
     284             :       DRI.d.a = 0;
     285             :       DRI.d.b = 0;
     286           0 :       return DRI;
     287             :     }
     288       10020 :     uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
     289       10020 :     unsigned SymTableIndex =
     290       10020 :         (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr);
     291             : 
     292       10020 :     DRI.d.a = SymTableIndex;
     293       10020 :     DRI.d.b = SymbolNum;
     294       10020 :     return DRI;
     295             :   }
     296             : 
     297             :   const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const {
     298             :     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
     299             :   }
     300             : 
     301             :   DataRefImpl toDRI(const Elf_Shdr *Sec) const {
     302      181504 :     DataRefImpl DRI;
     303      181504 :     DRI.p = reinterpret_cast<uintptr_t>(Sec);
     304             :     return DRI;
     305             :   }
     306             : 
     307             :   DataRefImpl toDRI(const Elf_Dyn *Dyn) const {
     308             :     DataRefImpl DRI;
     309             :     DRI.p = reinterpret_cast<uintptr_t>(Dyn);
     310             :     return DRI;
     311             :   }
     312             : 
     313             :   bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
     314    16612898 :     unsigned char Binding = ESym->getBinding();
     315    16612898 :     unsigned char Visibility = ESym->getVisibility();
     316             : 
     317             :     // A symbol is exported if its binding is either GLOBAL or WEAK, and its
     318             :     // visibility is either DEFAULT or PROTECTED. All other symbols are not
     319             :     // exported.
     320     9243732 :     return ((Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK) &&
     321     1874566 :             (Visibility == ELF::STV_DEFAULT ||
     322      937283 :              Visibility == ELF::STV_PROTECTED));
     323             :   }
     324             : 
     325             :   // This flag is used for classof, to distinguish ELFObjectFile from
     326             :   // its subclass. If more subclasses will be created, this flag will
     327             :   // have to become an enum.
     328             :   bool isDyldELFObject;
     329             : 
     330             : public:
     331             :   ELFObjectFile(MemoryBufferRef Object, std::error_code &EC);
     332             : 
     333             :   const Elf_Rel *getRel(DataRefImpl Rel) const;
     334             :   const Elf_Rela *getRela(DataRefImpl Rela) const;
     335             : 
     336    49066097 :   const Elf_Sym *getSymbol(DataRefImpl Sym) const {
     337    98132194 :     auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
     338    49066097 :     if (!Ret)
     339           0 :       report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     340    98132194 :     return *Ret;
     341             :   }
     342             : 
     343             :   const Elf_Shdr *getSection(DataRefImpl Sec) const {
     344     2978108 :     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
     345             :   }
     346             : 
     347             :   basic_symbol_iterator symbol_begin() const override;
     348             :   basic_symbol_iterator symbol_end() const override;
     349             : 
     350             :   elf_symbol_iterator dynamic_symbol_begin() const;
     351             :   elf_symbol_iterator dynamic_symbol_end() const;
     352             : 
     353             :   section_iterator section_begin() const override;
     354             :   section_iterator section_end() const override;
     355             : 
     356             :   ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const override;
     357             : 
     358             :   uint8_t getBytesInAddress() const override;
     359             :   StringRef getFileFormatName() const override;
     360             :   unsigned getArch() const override;
     361             : 
     362         116 :   std::error_code getPlatformFlags(unsigned &Result) const override {
     363         348 :     Result = EF.getHeader()->e_flags;
     364         116 :     return std::error_code();
     365             :   }
     366             : 
     367         133 :   std::error_code getBuildAttributes(ARMAttributeParser &Attributes) const override {
     368         266 :     auto SectionsOrErr = EF.sections();
     369         133 :     if (!SectionsOrErr)
     370           0 :       return errorToErrorCode(SectionsOrErr.takeError());
     371             : 
     372        1144 :     for (const Elf_Shdr &Sec : *SectionsOrErr) {
     373        1876 :       if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
     374         120 :         auto ErrorOrContents = EF.getSectionContents(&Sec);
     375          60 :         if (!ErrorOrContents)
     376           0 :           return errorToErrorCode(ErrorOrContents.takeError());
     377             : 
     378          60 :         auto Contents = ErrorOrContents.get();
     379          60 :         if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
     380           0 :           return std::error_code();
     381             : 
     382          60 :         Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
     383          60 :         break;
     384             :       }
     385             :     }
     386         133 :     return std::error_code();
     387             :   }
     388             : 
     389        2343 :   const ELFFile<ELFT> *getELFFile() const { return &EF; }
     390             : 
     391             :   bool isDyldType() const { return isDyldELFObject; }
     392             :   static bool classof(const Binary *v) {
     393        9021 :     return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
     394             :                                       ELFT::Is64Bits);
     395             :   }
     396             : 
     397             :   elf_symbol_iterator_range getDynamicSymbolIterators() const override;
     398             : 
     399             :   bool isRelocatableObject() const override;
     400             : };
     401             : 
     402             : using ELF32LEObjectFile = ELFObjectFile<ELFType<support::little, false>>;
     403             : using ELF64LEObjectFile = ELFObjectFile<ELFType<support::little, true>>;
     404             : using ELF32BEObjectFile = ELFObjectFile<ELFType<support::big, false>>;
     405             : using ELF64BEObjectFile = ELFObjectFile<ELFType<support::big, true>>;
     406             : 
     407             : template <class ELFT>
     408     8220253 : void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
     409     8220253 :   ++Sym.d.b;
     410     8220253 : }
     411             : 
     412             : template <class ELFT>
     413     8189763 : Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
     414     8189763 :   const Elf_Sym *ESym = getSymbol(Sym);
     415    16379526 :   auto SymTabOrErr = EF.getSection(Sym.d.a);
     416     8189763 :   if (!SymTabOrErr)
     417           0 :     return SymTabOrErr.takeError();
     418     8189763 :   const Elf_Shdr *SymTableSec = *SymTabOrErr;
     419    16379526 :   auto StrTabOrErr = EF.getSection(SymTableSec->sh_link);
     420     8189763 :   if (!StrTabOrErr)
     421           0 :     return StrTabOrErr.takeError();
     422     8189763 :   const Elf_Shdr *StringTableSec = *StrTabOrErr;
     423     8189763 :   auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
     424     8189763 :   if (!SymStrTabOrErr)
     425           0 :     return SymStrTabOrErr.takeError();
     426     8189763 :   return ESym->getName(*SymStrTabOrErr);
     427             : }
     428             : 
     429             : template <class ELFT>
     430        2276 : uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const {
     431        6828 :   return getSection(Sec)->sh_flags;
     432             : }
     433             : 
     434             : template <class ELFT>
     435        1245 : uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const {
     436        3735 :   return getSection(Sec)->sh_type;
     437             : }
     438             : 
     439             : template <class ELFT>
     440           0 : uint64_t ELFObjectFile<ELFT>::getSectionOffset(DataRefImpl Sec) const {
     441           0 :   return getSection(Sec)->sh_offset;
     442             : }
     443             : 
     444             : template <class ELFT>
     445     8158944 : uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const {
     446     8158944 :   const Elf_Sym *ESym = getSymbol(Symb);
     447    16317888 :   uint64_t Ret = ESym->st_value;
     448    16317888 :   if (ESym->st_shndx == ELF::SHN_ABS)
     449             :     return Ret;
     450             : 
     451    16311672 :   const Elf_Ehdr *Header = EF.getHeader();
     452             :   // Clear the ARM/Thumb or microMIPS indicator flag.
     453    24468194 :   if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
     454        1931 :       ESym->getType() == ELF::STT_FUNC)
     455         698 :     Ret &= ~1;
     456             : 
     457             :   return Ret;
     458             : }
     459             : 
     460             : template <class ELFT>
     461             : Expected<uint64_t>
     462     8187178 : ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
     463     8187178 :   uint64_t Result = getSymbolValue(Symb);
     464     8187178 :   const Elf_Sym *ESym = getSymbol(Symb);
     465    16374356 :   switch (ESym->st_shndx) {
     466       31342 :   case ELF::SHN_COMMON:
     467             :   case ELF::SHN_UNDEF:
     468             :   case ELF::SHN_ABS:
     469             :     return Result;
     470             :   }
     471             : 
     472    16311672 :   const Elf_Ehdr *Header = EF.getHeader();
     473     8155836 :   auto SymTabOrErr = EF.getSection(Symb.d.a);
     474     8155836 :   if (!SymTabOrErr)
     475           0 :     return SymTabOrErr.takeError();
     476     8155836 :   const Elf_Shdr *SymTab = *SymTabOrErr;
     477             : 
     478    16311672 :   if (Header->e_type == ELF::ET_REL) {
     479        8832 :     auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
     480        4416 :     if (!SectionOrErr)
     481           0 :       return SectionOrErr.takeError();
     482        4416 :     const Elf_Shdr *Section = *SectionOrErr;
     483        4416 :     if (Section)
     484        8830 :       Result += Section->sh_addr;
     485             :   }
     486             : 
     487             :   return Result;
     488             : }
     489             : 
     490             : template <class ELFT>
     491         106 : uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const {
     492         106 :   const Elf_Sym *Sym = getSymbol(Symb);
     493         212 :   if (Sym->st_shndx == ELF::SHN_COMMON)
     494         212 :     return Sym->st_value;
     495             :   return 0;
     496             : }
     497             : 
     498             : template <class ELFT>
     499         500 : uint16_t ELFObjectFile<ELFT>::getEMachine() const {
     500        1500 :   return EF.getHeader()->e_machine;
     501             : }
     502             : 
     503             : template <class ELFT>
     504     8104998 : uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const {
     505    16209996 :   return getSymbol(Sym)->st_size;
     506             : }
     507             : 
     508             : template <class ELFT>
     509         130 : uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
     510         260 :   return getSymbol(Symb)->st_size;
     511             : }
     512             : 
     513             : template <class ELFT>
     514           0 : uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
     515           0 :   return getSymbol(Symb)->st_other;
     516             : }
     517             : 
     518             : template <class ELFT>
     519          70 : uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
     520         140 :   return getSymbol(Symb)->getType();
     521             : }
     522             : 
     523             : template <class ELFT>
     524             : Expected<SymbolRef::Type>
     525     8107652 : ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const {
     526     8107652 :   const Elf_Sym *ESym = getSymbol(Symb);
     527             : 
     528    16215304 :   switch (ESym->getType()) {
     529        2502 :   case ELF::STT_NOTYPE:
     530        5004 :     return SymbolRef::ST_Unknown;
     531        3754 :   case ELF::STT_SECTION:
     532        7508 :     return SymbolRef::ST_Debug;
     533       27189 :   case ELF::STT_FILE:
     534       54378 :     return SymbolRef::ST_File;
     535     1327349 :   case ELF::STT_FUNC:
     536     2654698 :     return SymbolRef::ST_Function;
     537     6746306 :   case ELF::STT_OBJECT:
     538             :   case ELF::STT_COMMON:
     539             :   case ELF::STT_TLS:
     540    13492612 :     return SymbolRef::ST_Data;
     541         552 :   default:
     542        1104 :     return SymbolRef::ST_Other;
     543             :   }
     544             : }
     545             : 
     546             : template <class ELFT>
     547     8306449 : uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
     548     8306449 :   const Elf_Sym *ESym = getSymbol(Sym);
     549             : 
     550     8306449 :   uint32_t Result = SymbolRef::SF_None;
     551             : 
     552    16612898 :   if (ESym->getBinding() != ELF::STB_LOCAL)
     553      937873 :     Result |= SymbolRef::SF_Global;
     554             : 
     555     8306449 :   if (ESym->getBinding() == ELF::STB_WEAK)
     556      230659 :     Result |= SymbolRef::SF_Weak;
     557             : 
     558    16612898 :   if (ESym->st_shndx == ELF::SHN_ABS)
     559        7603 :     Result |= SymbolRef::SF_Absolute;
     560             : 
     561    16612898 :   if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION)
     562       13318 :     Result |= SymbolRef::SF_FormatSpecific;
     563             : 
     564    24919347 :   auto DotSymtabSecSyms = EF.symbols(DotSymtabSec);
     565    16612898 :   if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
     566        1499 :     Result |= SymbolRef::SF_FormatSpecific;
     567    24919347 :   auto DotDynSymSecSyms = EF.symbols(DotDynSymSec);
     568    16612898 :   if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
     569           2 :     Result |= SymbolRef::SF_FormatSpecific;
     570             : 
     571    24919347 :   if (EF.getHeader()->e_machine == ELF::EM_ARM) {
     572        4866 :     if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
     573        1622 :       StringRef Name = *NameOrErr;
     574        3134 :       if (Name.startswith("$d") || Name.startswith("$t") ||
     575        1361 :           Name.startswith("$a"))
     576         474 :         Result |= SymbolRef::SF_FormatSpecific;
     577             :     } else {
     578             :       // TODO: Actually report errors helpfully.
     579           0 :       consumeError(NameOrErr.takeError());
     580             :     }
     581        3779 :     if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 1)
     582         311 :       Result |= SymbolRef::SF_Thumb;
     583             :   }
     584             : 
     585    16612898 :   if (ESym->st_shndx == ELF::SHN_UNDEF)
     586       31563 :     Result |= SymbolRef::SF_Undefined;
     587             : 
     588    24919347 :   if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON)
     589         293 :     Result |= SymbolRef::SF_Common;
     590             : 
     591     9099554 :   if (isExportedToOtherDSO(ESym))
     592      793105 :     Result |= SymbolRef::SF_Exported;
     593             : 
     594     8306449 :   if (ESym->getVisibility() == ELF::STV_HIDDEN)
     595      389350 :     Result |= SymbolRef::SF_Hidden;
     596             : 
     597    16612898 :   return Result;
     598             : }
     599             : 
     600             : template <class ELFT>
     601             : Expected<section_iterator>
     602        7507 : ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
     603             :                                       const Elf_Shdr *SymTab) const {
     604       15014 :   auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
     605        7507 :   if (!ESecOrErr)
     606           0 :     return ESecOrErr.takeError();
     607             : 
     608        7507 :   const Elf_Shdr *ESec = *ESecOrErr;
     609        7507 :   if (!ESec)
     610        1622 :     return section_end();
     611             : 
     612        6696 :   DataRefImpl Sec;
     613        6696 :   Sec.p = reinterpret_cast<intptr_t>(ESec);
     614       26784 :   return section_iterator(SectionRef(Sec, this));
     615             : }
     616             : 
     617             : template <class ELFT>
     618             : Expected<section_iterator>
     619        7507 : ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const {
     620        7507 :   const Elf_Sym *Sym = getSymbol(Symb);
     621       15014 :   auto SymTabOrErr = EF.getSection(Symb.d.a);
     622        7507 :   if (!SymTabOrErr)
     623           0 :     return SymTabOrErr.takeError();
     624        7507 :   const Elf_Shdr *SymTab = *SymTabOrErr;
     625        7507 :   return getSymbolSection(Sym, SymTab);
     626             : }
     627             : 
     628             : template <class ELFT>
     629      115297 : void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
     630      230594 :   const Elf_Shdr *ESec = getSection(Sec);
     631      230594 :   Sec = toDRI(++ESec);
     632      115297 : }
     633             : 
     634             : template <class ELFT>
     635      103665 : std::error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec,
     636             :                                                     StringRef &Result) const {
     637      310995 :   auto Name = EF.getSectionName(&*getSection(Sec));
     638      103665 :   if (!Name)
     639          12 :     return errorToErrorCode(Name.takeError());
     640      103659 :   Result = *Name;
     641      103659 :   return std::error_code();
     642             : }
     643             : 
     644             : template <class ELFT>
     645        8335 : uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const {
     646       25005 :   return getSection(Sec)->sh_addr;
     647             : }
     648             : 
     649             : template <class ELFT>
     650        1694 : uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const {
     651        3388 :   auto SectionsOrErr = EF.sections();
     652        6776 :   handleAllErrors(std::move(SectionsOrErr.takeError()),
     653             :                   [](const ErrorInfoBase &) {
     654           0 :                     llvm_unreachable("unable to get section index");
     655             :                   });
     656        1694 :   const Elf_Shdr *First = SectionsOrErr->begin();
     657        3388 :   return getSection(Sec) - First;
     658             : }
     659             : 
     660             : template <class ELFT>
     661     2664234 : uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const {
     662     7992702 :   return getSection(Sec)->sh_size;
     663             : }
     664             : 
     665             : template <class ELFT>
     666             : std::error_code
     667       14372 : ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec,
     668             :                                         StringRef &Result) const {
     669       28744 :   const Elf_Shdr *EShdr = getSection(Sec);
     670       14372 :   if (std::error_code EC =
     671       57488 :           checkOffset(getMemoryBufferRef(),
     672       57488 :                       (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
     673           2 :     return EC;
     674       57480 :   Result = StringRef((const char *)base() + EShdr->sh_offset, EShdr->sh_size);
     675       14370 :   return std::error_code();
     676             : }
     677             : 
     678             : template <class ELFT>
     679        1682 : uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const {
     680        5046 :   return getSection(Sec)->sh_addralign;
     681             : }
     682             : 
     683             : template <class ELFT>
     684       11088 : bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const {
     685       33264 :   return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED;
     686             : }
     687             : 
     688             : template <class ELFT>
     689        8388 : bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const {
     690       25164 :   return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR;
     691             : }
     692             : 
     693             : template <class ELFT>
     694         943 : bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const {
     695        1886 :   const Elf_Shdr *EShdr = getSection(Sec);
     696        2270 :   return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
     697        1711 :          EShdr->sh_type == ELF::SHT_PROGBITS;
     698             : }
     699             : 
     700             : template <class ELFT>
     701       13918 : bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const {
     702       27836 :   const Elf_Shdr *EShdr = getSection(Sec);
     703       32947 :   return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
     704       24140 :          EShdr->sh_type == ELF::SHT_NOBITS;
     705             : }
     706             : 
     707             : template <class ELFT>
     708       13605 : bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const {
     709       40815 :   return getSection(Sec)->sh_type == ELF::SHT_NOBITS;
     710             : }
     711             : 
     712             : template <class ELFT>
     713             : relocation_iterator
     714        6106 : ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
     715        6106 :   DataRefImpl RelData;
     716       12212 :   auto SectionsOrErr = EF.sections();
     717        6106 :   if (!SectionsOrErr)
     718           0 :     return relocation_iterator(RelocationRef());
     719        6106 :   uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
     720       18318 :   RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
     721             :   RelData.d.b = 0;
     722       18318 :   return relocation_iterator(RelocationRef(RelData, this));
     723             : }
     724             : 
     725             : template <class ELFT>
     726             : relocation_iterator
     727        3053 : ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
     728        3053 :   const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
     729        3053 :   relocation_iterator Begin = section_rel_begin(Sec);
     730        6927 :   if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
     731         578 :     return Begin;
     732        4950 :   DataRefImpl RelData = Begin->getRawDataRefImpl();
     733        2475 :   const Elf_Shdr *RelSec = getRelSection(RelData);
     734             : 
     735             :   // Error check sh_link here so that getRelocationSymbol can just use it.
     736        4950 :   auto SymSecOrErr = EF.getSection(RelSec->sh_link);
     737        2475 :   if (!SymSecOrErr)
     738           0 :     report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message());
     739             : 
     740        7425 :   RelData.d.b += S->sh_size / S->sh_entsize;
     741        7425 :   return relocation_iterator(RelocationRef(RelData, this));
     742             : }
     743             : 
     744             : template <class ELFT>
     745             : section_iterator
     746       26486 : ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
     747       79458 :   if (EF.getHeader()->e_type != ELF::ET_REL)
     748        7649 :     return section_end();
     749             : 
     750       37674 :   const Elf_Shdr *EShdr = getSection(Sec);
     751       37674 :   uintX_t Type = EShdr->sh_type;
     752       18837 :   if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
     753       15061 :     return section_end();
     754             : 
     755        7552 :   auto R = EF.getSection(EShdr->sh_info);
     756        3776 :   if (!R)
     757           0 :     report_fatal_error(errorToErrorCode(R.takeError()).message());
     758       18880 :   return section_iterator(SectionRef(toDRI(*R), this));
     759             : }
     760             : 
     761             : // Relocations
     762             : template <class ELFT>
     763        7843 : void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const {
     764        7843 :   ++Rel.d.b;
     765        7843 : }
     766             : 
     767             : template <class ELFT>
     768             : symbol_iterator
     769        6442 : ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const {
     770             :   uint32_t symbolIdx;
     771        6442 :   const Elf_Shdr *sec = getRelSection(Rel);
     772       12884 :   if (sec->sh_type == ELF::SHT_REL)
     773        1986 :     symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL());
     774             :   else
     775       17340 :     symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL());
     776        6442 :   if (!symbolIdx)
     777          27 :     return symbol_end();
     778             : 
     779             :   // FIXME: error check symbolIdx
     780        6415 :   DataRefImpl SymbolData;
     781       12830 :   SymbolData.d.a = sec->sh_link;
     782        6415 :   SymbolData.d.b = symbolIdx;
     783       19245 :   return symbol_iterator(SymbolRef(SymbolData, this));
     784             : }
     785             : 
     786             : template <class ELFT>
     787        6986 : uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
     788             :   assert(EF.getHeader()->e_type == ELF::ET_REL &&
     789             :          "Only relocatable object files have relocation offsets");
     790        6986 :   const Elf_Shdr *sec = getRelSection(Rel);
     791       13972 :   if (sec->sh_type == ELF::SHT_REL)
     792        1762 :     return getRel(Rel)->r_offset;
     793             : 
     794       12210 :   return getRela(Rel)->r_offset;
     795             : }
     796             : 
     797             : template <class ELFT>
     798        8519 : uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const {
     799        8519 :   const Elf_Shdr *sec = getRelSection(Rel);
     800       17038 :   if (sec->sh_type == ELF::SHT_REL)
     801        2508 :     return getRel(Rel)->getType(EF.isMips64EL());
     802             :   else
     803       23049 :     return getRela(Rel)->getType(EF.isMips64EL());
     804             : }
     805             : 
     806             : template <class ELFT>
     807             : StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
     808             :   return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
     809             : }
     810             : 
     811             : template <class ELFT>
     812         747 : void ELFObjectFile<ELFT>::getRelocationTypeName(
     813             :     DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
     814         747 :   uint32_t type = getRelocationType(Rel);
     815         747 :   EF.getRelocationTypeName(type, Result);
     816         747 : }
     817             : 
     818             : template <class ELFT>
     819             : ErrorOr<int64_t>
     820        5252 : ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const {
     821       10504 :   if (getRelSection(Rel)->sh_type != ELF::SHT_RELA)
     822             :     return object_error::parse_failed;
     823       15633 :   return (int64_t)getRela(Rel)->r_addend;
     824             : }
     825             : 
     826             : template <class ELFT>
     827             : const typename ELFObjectFile<ELFT>::Elf_Rel *
     828        2379 : ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const {
     829             :   assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
     830        4758 :   auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b);
     831        2379 :   if (!Ret)
     832           0 :     report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     833        4758 :   return *Ret;
     834             : }
     835             : 
     836             : template <class ELFT>
     837             : const typename ELFObjectFile<ELFT>::Elf_Rela *
     838       25339 : ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
     839             :   assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
     840       50678 :   auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b);
     841       25339 :   if (!Ret)
     842           0 :     report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     843       50678 :   return *Ret;
     844             : }
     845             : 
     846             : template <class ELFT>
     847        3870 : ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, std::error_code &EC)
     848             :     : ELFObjectFileBase(
     849             :           getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
     850             :           Object),
     851       11610 :       EF(Data.getBuffer()) {
     852        7735 :   auto SectionsOrErr = EF.sections();
     853        3870 :   if (!SectionsOrErr) {
     854           8 :     EC = errorToErrorCode(SectionsOrErr.takeError());
     855           9 :     return;
     856             :   }
     857      704104 :   for (const Elf_Shdr &Sec : *SectionsOrErr) {
     858     1392746 :     switch (Sec.sh_type) {
     859         855 :     case ELF::SHT_DYNSYM: {
     860         855 :       if (DotDynSymSec) {
     861             :         // More than one .dynsym!
     862             :         EC = object_error::parse_failed;
     863             :         return;
     864             :       }
     865         855 :       DotDynSymSec = &Sec;
     866         855 :       break;
     867             :     }
     868        3822 :     case ELF::SHT_SYMTAB: {
     869        3822 :       if (DotSymtabSec) {
     870             :         // More than one .dynsym!
     871             :         EC = object_error::parse_failed;
     872             :         return;
     873             :       }
     874        3822 :       DotSymtabSec = &Sec;
     875        3822 :       break;
     876             :     }
     877           7 :     case ELF::SHT_SYMTAB_SHNDX: {
     878           7 :       auto TableOrErr = EF.getSHNDXTable(Sec);
     879           7 :       if (!TableOrErr) {
     880           2 :         EC = errorToErrorCode(TableOrErr.takeError());
     881           1 :         return;
     882             :       }
     883           6 :       ShndxTable = *TableOrErr;
     884           6 :       break;
     885             :     }
     886             :     }
     887             :   }
     888             : }
     889             : 
     890             : template <class ELFT>
     891        1517 : basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const {
     892        1517 :   DataRefImpl Sym = toDRI(DotSymtabSec, 0);
     893        4551 :   return basic_symbol_iterator(SymbolRef(Sym, this));
     894             : }
     895             : 
     896             : template <class ELFT>
     897        8512 : basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const {
     898        8512 :   const Elf_Shdr *SymTab = DotSymtabSec;
     899        8512 :   if (!SymTab)
     900          13 :     return symbol_begin();
     901       16998 :   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
     902       25497 :   return basic_symbol_iterator(SymbolRef(Sym, this));
     903             : }
     904             : 
     905             : template <class ELFT>
     906         207 : elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
     907         207 :   DataRefImpl Sym = toDRI(DotDynSymSec, 0);
     908         621 :   return symbol_iterator(SymbolRef(Sym, this));
     909             : }
     910             : 
     911             : template <class ELFT>
     912         111 : elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const {
     913         111 :   const Elf_Shdr *SymTab = DotDynSymSec;
     914         111 :   if (!SymTab)
     915          96 :     return dynamic_symbol_begin();
     916          30 :   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
     917          45 :   return basic_symbol_iterator(SymbolRef(Sym, this));
     918             : }
     919             : 
     920             : template <class ELFT>
     921        4302 : section_iterator ELFObjectFile<ELFT>::section_begin() const {
     922        8604 :   auto SectionsOrErr = EF.sections();
     923        4302 :   if (!SectionsOrErr)
     924           0 :     return section_iterator(SectionRef());
     925       21510 :   return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this));
     926             : }
     927             : 
     928             : template <class ELFT>
     929       58129 : section_iterator ELFObjectFile<ELFT>::section_end() const {
     930      116258 :   auto SectionsOrErr = EF.sections();
     931       58129 :   if (!SectionsOrErr)
     932           0 :     return section_iterator(SectionRef());
     933      348774 :   return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this));
     934             : }
     935             : 
     936             : template <class ELFT>
     937        8319 : uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {
     938        8319 :   return ELFT::Is64Bits ? 8 : 4;
     939             : }
     940             : 
     941             : template <class ELFT>
     942        2952 : StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
     943        2952 :   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
     944        5904 :   switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
     945         996 :   case ELF::ELFCLASS32:
     946        2988 :     switch (EF.getHeader()->e_machine) {
     947         198 :     case ELF::EM_386:
     948         198 :       return "ELF32-i386";
     949           3 :     case ELF::EM_IAMCU:
     950           3 :       return "ELF32-iamcu";
     951           5 :     case ELF::EM_X86_64:
     952           5 :       return "ELF32-x86-64";
     953             :     case ELF::EM_ARM:
     954         344 :       return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
     955           0 :     case ELF::EM_AVR:
     956           0 :       return "ELF32-avr";
     957         102 :     case ELF::EM_HEXAGON:
     958         102 :       return "ELF32-hexagon";
     959           5 :     case ELF::EM_LANAI:
     960           5 :       return "ELF32-lanai";
     961         312 :     case ELF::EM_MIPS:
     962         312 :       return "ELF32-mips";
     963          11 :     case ELF::EM_PPC:
     964          11 :       return "ELF32-ppc";
     965           0 :     case ELF::EM_RISCV:
     966           0 :       return "ELF32-riscv";
     967          10 :     case ELF::EM_SPARC:
     968             :     case ELF::EM_SPARC32PLUS:
     969          10 :       return "ELF32-sparc";
     970           0 :     case ELF::EM_WEBASSEMBLY:
     971           0 :       return "ELF32-wasm";
     972           4 :     case ELF::EM_AMDGPU:
     973           4 :       return "ELF32-amdgpu";
     974           2 :     default:
     975           2 :       return "ELF32-unknown";
     976             :     }
     977        1956 :   case ELF::ELFCLASS64:
     978        5868 :     switch (EF.getHeader()->e_machine) {
     979           0 :     case ELF::EM_386:
     980           0 :       return "ELF64-i386";
     981        1541 :     case ELF::EM_X86_64:
     982        1541 :       return "ELF64-x86-64";
     983             :     case ELF::EM_AARCH64:
     984         133 :       return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
     985          52 :     case ELF::EM_PPC64:
     986          52 :       return "ELF64-ppc64";
     987           0 :     case ELF::EM_RISCV:
     988           0 :       return "ELF64-riscv";
     989          13 :     case ELF::EM_S390:
     990          13 :       return "ELF64-s390";
     991          17 :     case ELF::EM_SPARCV9:
     992          17 :       return "ELF64-sparc";
     993         145 :     case ELF::EM_MIPS:
     994         145 :       return "ELF64-mips";
     995           0 :     case ELF::EM_WEBASSEMBLY:
     996           0 :       return "ELF64-wasm";
     997          45 :     case ELF::EM_AMDGPU:
     998          90 :       return (EF.getHeader()->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA
     999             :               && IsLittleEndian) ?
    1000          90 :              "ELF64-amdgpu-hsacobj" : "ELF64-amdgpu";
    1001           9 :     case ELF::EM_BPF:
    1002           9 :       return "ELF64-BPF";
    1003           1 :     default:
    1004           1 :       return "ELF64-unknown";
    1005             :     }
    1006           0 :   default:
    1007             :     // FIXME: Proper error handling.
    1008           0 :     report_fatal_error("Invalid ELFCLASS!");
    1009             :   }
    1010             : }
    1011             : 
    1012             : template <class ELFT>
    1013      448104 : unsigned ELFObjectFile<ELFT>::getArch() const {
    1014      448104 :   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
    1015     1344312 :   switch (EF.getHeader()->e_machine) {
    1016             :   case ELF::EM_386:
    1017             :   case ELF::EM_IAMCU:
    1018             :     return Triple::x86;
    1019       20029 :   case ELF::EM_X86_64:
    1020       20029 :     return Triple::x86_64;
    1021             :   case ELF::EM_AARCH64:
    1022         900 :     return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be;
    1023       36988 :   case ELF::EM_ARM:
    1024       36988 :     return Triple::arm;
    1025           0 :   case ELF::EM_AVR:
    1026           0 :     return Triple::avr;
    1027       17670 :   case ELF::EM_HEXAGON:
    1028       17670 :     return Triple::hexagon;
    1029          13 :   case ELF::EM_LANAI:
    1030          13 :     return Triple::lanai;
    1031      305835 :   case ELF::EM_MIPS:
    1032      611670 :     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1033             :     case ELF::ELFCLASS32:
    1034             :       return IsLittleEndian ? Triple::mipsel : Triple::mips;
    1035             :     case ELF::ELFCLASS64:
    1036        2456 :       return IsLittleEndian ? Triple::mips64el : Triple::mips64;
    1037           0 :     default:
    1038           0 :       report_fatal_error("Invalid ELFCLASS!");
    1039             :     }
    1040         126 :   case ELF::EM_PPC:
    1041         126 :     return Triple::ppc;
    1042             :   case ELF::EM_PPC64:
    1043        1706 :     return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
    1044           0 :   case ELF::EM_RISCV:
    1045           0 :     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1046             :     case ELF::ELFCLASS32:
    1047             :       return Triple::riscv32;
    1048           0 :     case ELF::ELFCLASS64:
    1049           0 :       return Triple::riscv64;
    1050           0 :     default:
    1051           0 :       report_fatal_error("Invalid ELFCLASS!");
    1052             :     }
    1053         239 :   case ELF::EM_S390:
    1054         239 :     return Triple::systemz;
    1055             : 
    1056             :   case ELF::EM_SPARC:
    1057             :   case ELF::EM_SPARC32PLUS:
    1058          94 :     return IsLittleEndian ? Triple::sparcel : Triple::sparc;
    1059         110 :   case ELF::EM_SPARCV9:
    1060         110 :     return Triple::sparcv9;
    1061           0 :   case ELF::EM_WEBASSEMBLY:
    1062           0 :     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1063             :     case ELF::ELFCLASS32: return Triple::wasm32;
    1064           0 :     case ELF::ELFCLASS64: return Triple::wasm64;
    1065           0 :     default: return Triple::UnknownArch;
    1066             :     }
    1067             : 
    1068        2231 :   case ELF::EM_AMDGPU:
    1069        4462 :     return (EF.getHeader()->e_ident[ELF::EI_CLASS] == ELF::ELFCLASS64
    1070        4430 :          && EF.getHeader()->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA
    1071        2231 :          && IsLittleEndian) ?
    1072             :       Triple::amdgcn : Triple::UnknownArch;
    1073             : 
    1074             :   case ELF::EM_BPF:
    1075         881 :     return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
    1076             : 
    1077           1 :   default:
    1078           1 :     return Triple::UnknownArch;
    1079             :   }
    1080             : }
    1081             : 
    1082             : template <class ELFT>
    1083             : ELFObjectFileBase::elf_symbol_iterator_range
    1084         111 : ELFObjectFile<ELFT>::getDynamicSymbolIterators() const {
    1085         222 :   return make_range(dynamic_symbol_begin(), dynamic_symbol_end());
    1086             : }
    1087             : 
    1088         958 : template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
    1089        2874 :   return EF.getHeader()->e_type == ELF::ET_REL;
    1090             : }
    1091             : 
    1092             : } // end namespace object
    1093             : } // end namespace llvm
    1094             : 
    1095             : #endif // LLVM_OBJECT_ELFOBJECTFILE_H

Generated by: LCOV version 1.13