LCOV - code coverage report
Current view: top level - include/llvm/Object - ELFObjectFile.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 375 433 86.6 %
Date: 2018-07-13 00:08:38 Functions: 229 254 90.2 %
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/STLExtras.h"
      19             : #include "llvm/ADT/SmallVector.h"
      20             : #include "llvm/ADT/StringRef.h"
      21             : #include "llvm/ADT/Triple.h"
      22             : #include "llvm/ADT/iterator_range.h"
      23             : #include "llvm/BinaryFormat/ELF.h"
      24             : #include "llvm/MC/SubtargetFeature.h"
      25             : #include "llvm/Object/Binary.h"
      26             : #include "llvm/Object/ELF.h"
      27             : #include "llvm/Object/ELFTypes.h"
      28             : #include "llvm/Object/Error.h"
      29             : #include "llvm/Object/ObjectFile.h"
      30             : #include "llvm/Object/SymbolicFile.h"
      31             : #include "llvm/Support/ARMAttributeParser.h"
      32             : #include "llvm/Support/ARMBuildAttributes.h"
      33             : #include "llvm/Support/Casting.h"
      34             : #include "llvm/Support/Endian.h"
      35             : #include "llvm/Support/Error.h"
      36             : #include "llvm/Support/ErrorHandling.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             : 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 Expected<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             :   /// Returns platform-specific object flags, if any.
      72             :   virtual unsigned getPlatformFlags() const = 0;
      73             : 
      74             :   elf_symbol_iterator_range symbols() const;
      75             : 
      76       16276 :   static bool classof(const Binary *v) { return v->isELF(); }
      77             : 
      78             :   SubtargetFeatures getFeatures() const override;
      79             : 
      80             :   SubtargetFeatures getMIPSFeatures() const;
      81             : 
      82             :   SubtargetFeatures getARMFeatures() const;
      83             : 
      84             :   SubtargetFeatures getRISCVFeatures() const;
      85             : 
      86             :   void setARMSubArch(Triple &TheTriple) const override;
      87             : 
      88             :   virtual uint16_t getEType() const = 0;
      89             : };
      90             : 
      91             : class ELFSectionRef : public SectionRef {
      92             : public:
      93        2663 :   ELFSectionRef(const SectionRef &B) : SectionRef(B) {
      94             :     assert(isa<ELFObjectFileBase>(SectionRef::getObject()));
      95             :   }
      96             : 
      97             :   const ELFObjectFileBase *getObject() const {
      98         458 :     return cast<ELFObjectFileBase>(SectionRef::getObject());
      99             :   }
     100             : 
     101             :   uint32_t getType() const {
     102        2472 :     return getObject()->getSectionType(getRawDataRefImpl());
     103             :   }
     104             : 
     105             :   uint64_t getFlags() const {
     106        4654 :     return getObject()->getSectionFlags(getRawDataRefImpl());
     107             :   }
     108             : 
     109             :   uint64_t getOffset() const {
     110             :     return getObject()->getSectionOffset(getRawDataRefImpl());
     111             :   }
     112             : };
     113             : 
     114             : class elf_section_iterator : public section_iterator {
     115             : public:
     116         458 :   elf_section_iterator(const section_iterator &B) : section_iterator(B) {
     117             :     assert(isa<ELFObjectFileBase>(B->getObject()));
     118             :   }
     119             : 
     120             :   const ELFSectionRef *operator->() const {
     121             :     return static_cast<const ELFSectionRef *>(section_iterator::operator->());
     122             :   }
     123             : 
     124             :   const ELFSectionRef &operator*() const {
     125             :     return static_cast<const ELFSectionRef &>(section_iterator::operator*());
     126             :   }
     127             : };
     128             : 
     129             : class ELFSymbolRef : public SymbolRef {
     130             : public:
     131         726 :   ELFSymbolRef(const SymbolRef &B) : SymbolRef(B) {
     132             :     assert(isa<ELFObjectFileBase>(SymbolRef::getObject()));
     133             :   }
     134             : 
     135             :   const ELFObjectFileBase *getObject() const {
     136          63 :     return cast<ELFObjectFileBase>(BasicSymbolRef::getObject());
     137             :   }
     138             : 
     139             :   uint64_t getSize() const {
     140    25390906 :     return getObject()->getSymbolSize(getRawDataRefImpl());
     141             :   }
     142             : 
     143             :   uint8_t getOther() const {
     144           0 :     return getObject()->getSymbolOther(getRawDataRefImpl());
     145             :   }
     146             : 
     147             :   uint8_t getELFType() const {
     148         156 :     return getObject()->getSymbolELFType(getRawDataRefImpl());
     149             :   }
     150             : };
     151             : 
     152             : class elf_symbol_iterator : public symbol_iterator {
     153             : public:
     154        2375 :   elf_symbol_iterator(const basic_symbol_iterator &B)
     155        2375 :       : symbol_iterator(SymbolRef(B->getRawDataRefImpl(),
     156        4750 :                                   cast<ELFObjectFileBase>(B->getObject()))) {}
     157             : 
     158             :   const ELFSymbolRef *operator->() const {
     159             :     return static_cast<const ELFSymbolRef *>(symbol_iterator::operator->());
     160             :   }
     161             : 
     162             :   const ELFSymbolRef &operator*() const {
     163             :     return static_cast<const ELFSymbolRef &>(symbol_iterator::operator*());
     164             :   }
     165             : };
     166             : 
     167             : class ELFRelocationRef : public RelocationRef {
     168             : public:
     169       12131 :   ELFRelocationRef(const RelocationRef &B) : RelocationRef(B) {
     170             :     assert(isa<ELFObjectFileBase>(RelocationRef::getObject()));
     171             :   }
     172             : 
     173             :   const ELFObjectFileBase *getObject() const {
     174           0 :     return cast<ELFObjectFileBase>(RelocationRef::getObject());
     175             :   }
     176             : 
     177             :   Expected<int64_t> getAddend() const {
     178       24262 :     return getObject()->getRelocationAddend(getRawDataRefImpl());
     179             :   }
     180             : };
     181             : 
     182             : class elf_relocation_iterator : public relocation_iterator {
     183             : public:
     184             :   elf_relocation_iterator(const relocation_iterator &B)
     185             :       : relocation_iterator(RelocationRef(
     186           0 :             B->getRawDataRefImpl(), cast<ELFObjectFileBase>(B->getObject()))) {}
     187             : 
     188             :   const ELFRelocationRef *operator->() const {
     189             :     return static_cast<const ELFRelocationRef *>(
     190             :         relocation_iterator::operator->());
     191             :   }
     192             : 
     193             :   const ELFRelocationRef &operator*() const {
     194             :     return static_cast<const ELFRelocationRef &>(
     195             :         relocation_iterator::operator*());
     196             :   }
     197             : };
     198             : 
     199             : inline ELFObjectFileBase::elf_symbol_iterator_range
     200         182 : ELFObjectFileBase::symbols() const {
     201         364 :   return elf_symbol_iterator_range(symbol_begin(), symbol_end());
     202             : }
     203             : 
     204       22660 : template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
     205             :   uint16_t getEMachine() const override;
     206             :   uint16_t getEType() const override;
     207             :   uint64_t getSymbolSize(DataRefImpl Sym) const override;
     208             : 
     209             : public:
     210             :   LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
     211             : 
     212             :   using uintX_t = typename ELFT::uint;
     213             : 
     214             :   using Elf_Sym = typename ELFT::Sym;
     215             :   using Elf_Shdr = typename ELFT::Shdr;
     216             :   using Elf_Ehdr = typename ELFT::Ehdr;
     217             :   using Elf_Rel = typename ELFT::Rel;
     218             :   using Elf_Rela = typename ELFT::Rela;
     219             :   using Elf_Dyn = typename ELFT::Dyn;
     220             : 
     221             : private:
     222             :   ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
     223             :                 const Elf_Shdr *DotDynSymSec, const Elf_Shdr *DotSymtabSec,
     224             :                 ArrayRef<Elf_Word> ShndxTable);
     225             : 
     226             : protected:
     227             :   ELFFile<ELFT> EF;
     228             : 
     229             :   const Elf_Shdr *DotDynSymSec = nullptr; // Dynamic symbol table section.
     230             :   const Elf_Shdr *DotSymtabSec = nullptr; // Symbol table section.
     231             :   ArrayRef<Elf_Word> ShndxTable;
     232             : 
     233             :   void moveSymbolNext(DataRefImpl &Symb) const override;
     234             :   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
     235             :   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
     236             :   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
     237             :   uint32_t getSymbolAlignment(DataRefImpl Symb) const override;
     238             :   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
     239             :   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
     240             :   uint8_t getSymbolOther(DataRefImpl Symb) const override;
     241             :   uint8_t getSymbolELFType(DataRefImpl Symb) const override;
     242             :   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
     243             :   Expected<section_iterator> getSymbolSection(const Elf_Sym *Symb,
     244             :                                               const Elf_Shdr *SymTab) const;
     245             :   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
     246             : 
     247             :   void moveSectionNext(DataRefImpl &Sec) const override;
     248             :   std::error_code getSectionName(DataRefImpl Sec,
     249             :                                  StringRef &Res) const override;
     250             :   uint64_t getSectionAddress(DataRefImpl Sec) const override;
     251             :   uint64_t getSectionIndex(DataRefImpl Sec) const override;
     252             :   uint64_t getSectionSize(DataRefImpl Sec) const override;
     253             :   std::error_code getSectionContents(DataRefImpl Sec,
     254             :                                      StringRef &Res) const override;
     255             :   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
     256             :   bool isSectionCompressed(DataRefImpl Sec) const override;
     257             :   bool isSectionText(DataRefImpl Sec) const override;
     258             :   bool isSectionData(DataRefImpl Sec) const override;
     259             :   bool isSectionBSS(DataRefImpl Sec) const override;
     260             :   bool isSectionVirtual(DataRefImpl Sec) const override;
     261             :   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
     262             :   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
     263             :   std::vector<SectionRef> dynamic_relocation_sections() const override;
     264             :   section_iterator getRelocatedSection(DataRefImpl Sec) const override;
     265             : 
     266             :   void moveRelocationNext(DataRefImpl &Rel) const override;
     267             :   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
     268             :   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
     269             :   uint64_t getRelocationType(DataRefImpl Rel) const override;
     270             :   void getRelocationTypeName(DataRefImpl Rel,
     271             :                              SmallVectorImpl<char> &Result) const override;
     272             : 
     273             :   uint32_t getSectionType(DataRefImpl Sec) const override;
     274             :   uint64_t getSectionFlags(DataRefImpl Sec) const override;
     275             :   uint64_t getSectionOffset(DataRefImpl Sec) const override;
     276             :   StringRef getRelocationTypeName(uint32_t Type) const;
     277             : 
     278             :   /// Get the relocation section that contains \a Rel.
     279       57408 :   const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
     280       57408 :     auto RelSecOrErr = EF.getSection(Rel.d.a);
     281       57408 :     if (!RelSecOrErr)
     282           0 :       report_fatal_error(errorToErrorCode(RelSecOrErr.takeError()).message());
     283       57408 :     return *RelSecOrErr;
     284             :   }
     285             : 
     286       19381 :   DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
     287             :     DataRefImpl DRI;
     288       19381 :     if (!SymTable) {
     289             :       DRI.d.a = 0;
     290             :       DRI.d.b = 0;
     291         274 :       return DRI;
     292             :     }
     293             :     assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
     294             :            SymTable->sh_type == ELF::SHT_DYNSYM);
     295             : 
     296       19107 :     auto SectionsOrErr = EF.sections();
     297       19107 :     if (!SectionsOrErr) {
     298             :       DRI.d.a = 0;
     299             :       DRI.d.b = 0;
     300           0 :       return DRI;
     301             :     }
     302       19107 :     uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
     303       19107 :     unsigned SymTableIndex =
     304       19107 :         (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr);
     305             : 
     306       19107 :     DRI.d.a = SymTableIndex;
     307       19107 :     DRI.d.b = SymbolNum;
     308       19107 :     return DRI;
     309             :   }
     310             : 
     311             :   const Elf_Shdr *toELFShdrIter(DataRefImpl Sec) const {
     312             :     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
     313             :   }
     314             : 
     315             :   DataRefImpl toDRI(const Elf_Shdr *Sec) const {
     316             :     DataRefImpl DRI;
     317      234364 :     DRI.p = reinterpret_cast<uintptr_t>(Sec);
     318             :     return DRI;
     319             :   }
     320             : 
     321             :   DataRefImpl toDRI(const Elf_Dyn *Dyn) const {
     322             :     DataRefImpl DRI;
     323             :     DRI.p = reinterpret_cast<uintptr_t>(Dyn);
     324             :     return DRI;
     325             :   }
     326             : 
     327             :   bool isExportedToOtherDSO(const Elf_Sym *ESym) const {
     328             :     unsigned char Binding = ESym->getBinding();
     329    12893231 :     unsigned char Visibility = ESym->getVisibility();
     330             : 
     331             :     // A symbol is exported if its binding is either GLOBAL or WEAK, and its
     332             :     // visibility is either DEFAULT or PROTECTED. All other symbols are not
     333             :     // exported.
     334    14126032 :     return ((Binding == ELF::STB_GLOBAL || Binding == ELF::STB_WEAK) &&
     335     2465602 :             (Visibility == ELF::STV_DEFAULT ||
     336     1232801 :              Visibility == ELF::STV_PROTECTED));
     337             :   }
     338             : 
     339             :   // This flag is used for classof, to distinguish ELFObjectFile from
     340             :   // its subclass. If more subclasses will be created, this flag will
     341             :   // have to become an enum.
     342             :   bool isDyldELFObject;
     343             : 
     344             : public:
     345             :   ELFObjectFile(ELFObjectFile<ELFT> &&Other);
     346             :   static Expected<ELFObjectFile<ELFT>> create(MemoryBufferRef Object);
     347             : 
     348             :   const Elf_Rel *getRel(DataRefImpl Rel) const;
     349             :   const Elf_Rela *getRela(DataRefImpl Rela) const;
     350             : 
     351    76598131 :   const Elf_Sym *getSymbol(DataRefImpl Sym) const {
     352    76598131 :     auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
     353    76598131 :     if (!Ret)
     354           0 :       report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     355    76598131 :     return *Ret;
     356             :   }
     357             : 
     358             :   const Elf_Shdr *getSection(DataRefImpl Sec) const {
     359     3040637 :     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
     360             :   }
     361             : 
     362             :   basic_symbol_iterator symbol_begin() const override;
     363             :   basic_symbol_iterator symbol_end() const override;
     364             : 
     365             :   elf_symbol_iterator dynamic_symbol_begin() const;
     366             :   elf_symbol_iterator dynamic_symbol_end() const;
     367             : 
     368             :   section_iterator section_begin() const override;
     369             :   section_iterator section_end() const override;
     370             : 
     371             :   Expected<int64_t> getRelocationAddend(DataRefImpl Rel) const override;
     372             : 
     373             :   uint8_t getBytesInAddress() const override;
     374             :   StringRef getFileFormatName() const override;
     375             :   Triple::ArchType getArch() const override;
     376             :   Expected<uint64_t> getStartAddress() const override;
     377             : 
     378         288 :   unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; }
     379             : 
     380         202 :   std::error_code getBuildAttributes(ARMAttributeParser &Attributes) const override {
     381         202 :     auto SectionsOrErr = EF.sections();
     382         202 :     if (!SectionsOrErr)
     383           0 :       return errorToErrorCode(SectionsOrErr.takeError());
     384             : 
     385        3252 :     for (const Elf_Shdr &Sec : *SectionsOrErr) {
     386        1485 :       if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES) {
     387             :         auto ErrorOrContents = EF.getSectionContents(&Sec);
     388          61 :         if (!ErrorOrContents)
     389           0 :           return errorToErrorCode(ErrorOrContents.takeError());
     390             : 
     391          61 :         auto Contents = ErrorOrContents.get();
     392          61 :         if (Contents[0] != ARMBuildAttrs::Format_Version || Contents.size() == 1)
     393           0 :           return std::error_code();
     394             : 
     395          61 :         Attributes.Parse(Contents, ELFT::TargetEndianness == support::little);
     396             :         break;
     397             :       }
     398             :     }
     399         202 :     return std::error_code();
     400             :   }
     401             : 
     402        3160 :   const ELFFile<ELFT> *getELFFile() const { return &EF; }
     403             : 
     404             :   bool isDyldType() const { return isDyldELFObject; }
     405             :   static bool classof(const Binary *v) {
     406       12805 :     return v->getType() == getELFType(ELFT::TargetEndianness == support::little,
     407             :                                       ELFT::Is64Bits);
     408             :   }
     409             : 
     410             :   elf_symbol_iterator_range getDynamicSymbolIterators() const override;
     411             : 
     412             :   bool isRelocatableObject() const override;
     413             : };
     414             : 
     415             : using ELF32LEObjectFile = ELFObjectFile<ELF32LE>;
     416             : using ELF64LEObjectFile = ELFObjectFile<ELF64LE>;
     417             : using ELF32BEObjectFile = ELFObjectFile<ELF32BE>;
     418             : using ELF64BEObjectFile = ELFObjectFile<ELF64BE>;
     419             : 
     420             : template <class ELFT>
     421    12819770 : void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
     422    12819770 :   ++Sym.d.b;
     423    12819770 : }
     424             : 
     425             : template <class ELFT>
     426    12778223 : Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
     427    12778223 :   const Elf_Sym *ESym = getSymbol(Sym);
     428    12778223 :   auto SymTabOrErr = EF.getSection(Sym.d.a);
     429    12778223 :   if (!SymTabOrErr)
     430             :     return SymTabOrErr.takeError();
     431    12778223 :   const Elf_Shdr *SymTableSec = *SymTabOrErr;
     432    12778223 :   auto StrTabOrErr = EF.getSection(SymTableSec->sh_link);
     433    12778223 :   if (!StrTabOrErr)
     434             :     return StrTabOrErr.takeError();
     435    12778223 :   const Elf_Shdr *StringTableSec = *StrTabOrErr;
     436    12778223 :   auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
     437    12778223 :   if (!SymStrTabOrErr)
     438             :     return SymStrTabOrErr.takeError();
     439    12778223 :   return ESym->getName(*SymStrTabOrErr);
     440             : }
     441             : 
     442             : template <class ELFT>
     443        2327 : uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const {
     444        2327 :   return getSection(Sec)->sh_flags;
     445             : }
     446             : 
     447             : template <class ELFT>
     448        1236 : uint32_t ELFObjectFile<ELFT>::getSectionType(DataRefImpl Sec) const {
     449        1236 :   return getSection(Sec)->sh_type;
     450             : }
     451             : 
     452             : template <class ELFT>
     453           0 : uint64_t ELFObjectFile<ELFT>::getSectionOffset(DataRefImpl Sec) const {
     454           0 :   return getSection(Sec)->sh_offset;
     455             : }
     456             : 
     457             : template <class ELFT>
     458    12735340 : uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const {
     459    12735340 :   const Elf_Sym *ESym = getSymbol(Symb);
     460        7837 :   uint64_t Ret = ESym->st_value;
     461    12735340 :   if (ESym->st_shndx == ELF::SHN_ABS)
     462             :     return Ret;
     463             : 
     464             :   const Elf_Ehdr *Header = EF.getHeader();
     465             :   // Clear the ARM/Thumb or microMIPS indicator flag.
     466    12738823 :   if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
     467        6800 :       ESym->getType() == ELF::STT_FUNC)
     468        2979 :     Ret &= ~1;
     469             : 
     470             :   return Ret;
     471             : }
     472             : 
     473             : template <class ELFT>
     474             : Expected<uint64_t>
     475    12772031 : ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
     476    12772031 :   uint64_t Result = getSymbolValue(Symb);
     477    12772031 :   const Elf_Sym *ESym = getSymbol(Symb);
     478    12772031 :   switch (ESym->st_shndx) {
     479             :   case ELF::SHN_COMMON:
     480             :   case ELF::SHN_UNDEF:
     481             :   case ELF::SHN_ABS:
     482             :     return Result;
     483             :   }
     484             : 
     485             :   const Elf_Ehdr *Header = EF.getHeader();
     486    12732023 :   auto SymTabOrErr = EF.getSection(Symb.d.a);
     487    12732023 :   if (!SymTabOrErr)
     488             :     return SymTabOrErr.takeError();
     489    12732023 :   const Elf_Shdr *SymTab = *SymTabOrErr;
     490             : 
     491    12732023 :   if (Header->e_type == ELF::ET_REL) {
     492        5634 :     auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
     493        5634 :     if (!SectionOrErr)
     494             :       return SectionOrErr.takeError();
     495        5634 :     const Elf_Shdr *Section = *SectionOrErr;
     496        5634 :     if (Section)
     497        5633 :       Result += Section->sh_addr;
     498             :   }
     499             : 
     500             :   return Result;
     501             : }
     502             : 
     503             : template <class ELFT>
     504          85 : uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const {
     505          85 :   const Elf_Sym *Sym = getSymbol(Symb);
     506          85 :   if (Sym->st_shndx == ELF::SHN_COMMON)
     507          85 :     return Sym->st_value;
     508             :   return 0;
     509             : }
     510             : 
     511             : template <class ELFT>
     512        1172 : uint16_t ELFObjectFile<ELFT>::getEMachine() const {
     513        1172 :   return EF.getHeader()->e_machine;
     514             : }
     515             : 
     516           0 : template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const {
     517           0 :   return EF.getHeader()->e_type;
     518             : }
     519             : 
     520             : template <class ELFT>
     521    12695453 : uint64_t ELFObjectFile<ELFT>::getSymbolSize(DataRefImpl Sym) const {
     522    25390906 :   return getSymbol(Sym)->st_size;
     523             : }
     524             : 
     525             : template <class ELFT>
     526         670 : uint64_t ELFObjectFile<ELFT>::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
     527        1340 :   return getSymbol(Symb)->st_size;
     528             : }
     529             : 
     530             : template <class ELFT>
     531           0 : uint8_t ELFObjectFile<ELFT>::getSymbolOther(DataRefImpl Symb) const {
     532           0 :   return getSymbol(Symb)->st_other;
     533             : }
     534             : 
     535             : template <class ELFT>
     536          78 : uint8_t ELFObjectFile<ELFT>::getSymbolELFType(DataRefImpl Symb) const {
     537         156 :   return getSymbol(Symb)->getType();
     538             : }
     539             : 
     540             : template <class ELFT>
     541             : Expected<SymbolRef::Type>
     542    12698043 : ELFObjectFile<ELFT>::getSymbolType(DataRefImpl Symb) const {
     543    12698043 :   const Elf_Sym *ESym = getSymbol(Symb);
     544             : 
     545    25396086 :   switch (ESym->getType()) {
     546        2754 :   case ELF::STT_NOTYPE:
     547             :     return SymbolRef::ST_Unknown;
     548        4036 :   case ELF::STT_SECTION:
     549             :     return SymbolRef::ST_Debug;
     550       40029 :   case ELF::STT_FILE:
     551             :     return SymbolRef::ST_File;
     552     1926529 :   case ELF::STT_FUNC:
     553             :     return SymbolRef::ST_Function;
     554    10723789 :   case ELF::STT_OBJECT:
     555             :   case ELF::STT_COMMON:
     556             :   case ELF::STT_TLS:
     557             :     return SymbolRef::ST_Data;
     558         906 :   default:
     559             :     return SymbolRef::ST_Other;
     560             :   }
     561             : }
     562             : 
     563             : template <class ELFT>
     564    12893231 : uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
     565    12893231 :   const Elf_Sym *ESym = getSymbol(Sym);
     566             : 
     567             :   uint32_t Result = SymbolRef::SF_None;
     568             : 
     569    25786462 :   if (ESym->getBinding() != ELF::STB_LOCAL)
     570             :     Result |= SymbolRef::SF_Global;
     571             : 
     572    12893231 :   if (ESym->getBinding() == ELF::STB_WEAK)
     573      326651 :     Result |= SymbolRef::SF_Weak;
     574             : 
     575    12893231 :   if (ESym->st_shndx == ELF::SHN_ABS)
     576        8044 :     Result |= SymbolRef::SF_Absolute;
     577             : 
     578    12893231 :   if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION)
     579       14364 :     Result |= SymbolRef::SF_FormatSpecific;
     580             : 
     581    12893231 :   auto DotSymtabSecSyms = EF.symbols(DotSymtabSec);
     582    12893231 :   if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
     583        2579 :     Result |= SymbolRef::SF_FormatSpecific;
     584    12893231 :   auto DotDynSymSecSyms = EF.symbols(DotDynSymSec);
     585    12893231 :   if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
     586           5 :     Result |= SymbolRef::SF_FormatSpecific;
     587             : 
     588    12893231 :   if (EF.getHeader()->e_machine == ELF::EM_ARM) {
     589       12928 :     if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
     590        6464 :       StringRef Name = *NameOrErr;
     591             :       if (Name.startswith("$d") || Name.startswith("$t") ||
     592             :           Name.startswith("$a"))
     593        2825 :         Result |= SymbolRef::SF_FormatSpecific;
     594             :     } else {
     595             :       // TODO: Actually report errors helpfully.
     596           0 :       consumeError(NameOrErr.takeError());
     597             :     }
     598       15744 :     if (ESym->getType() == ELF::STT_FUNC && (ESym->st_value & 1) == 1)
     599        2149 :       Result |= SymbolRef::SF_Thumb;
     600             :   }
     601             : 
     602    12893231 :   if (ESym->st_shndx == ELF::SHN_UNDEF)
     603       40160 :     Result |= SymbolRef::SF_Undefined;
     604             : 
     605    25786462 :   if (ESym->getType() == ELF::STT_COMMON || ESym->st_shndx == ELF::SHN_COMMON)
     606         978 :     Result |= SymbolRef::SF_Common;
     607             : 
     608             :   if (isExportedToOtherDSO(ESym))
     609     1088570 :     Result |= SymbolRef::SF_Exported;
     610             : 
     611    12893231 :   if (ESym->getVisibility() == ELF::STV_HIDDEN)
     612      520186 :     Result |= SymbolRef::SF_Hidden;
     613             : 
     614    12893231 :   return Result;
     615             : }
     616             : 
     617             : template <class ELFT>
     618             : Expected<section_iterator>
     619       14929 : ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
     620             :                                       const Elf_Shdr *SymTab) const {
     621       14929 :   auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
     622       14929 :   if (!ESecOrErr)
     623             :     return ESecOrErr.takeError();
     624             : 
     625       14929 :   const Elf_Shdr *ESec = *ESecOrErr;
     626       14929 :   if (!ESec)
     627        3022 :     return section_end();
     628             : 
     629             :   DataRefImpl Sec;
     630       13418 :   Sec.p = reinterpret_cast<intptr_t>(ESec);
     631       26836 :   return section_iterator(SectionRef(Sec, this));
     632             : }
     633             : 
     634             : template <class ELFT>
     635             : Expected<section_iterator>
     636       14929 : ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const {
     637       14929 :   const Elf_Sym *Sym = getSymbol(Symb);
     638       14929 :   auto SymTabOrErr = EF.getSection(Symb.d.a);
     639       14929 :   if (!SymTabOrErr)
     640             :     return SymTabOrErr.takeError();
     641       14929 :   const Elf_Shdr *SymTab = *SymTabOrErr;
     642       14929 :   return getSymbolSection(Sym, SymTab);
     643             : }
     644             : 
     645             : template <class ELFT>
     646      131900 : void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
     647             :   const Elf_Shdr *ESec = getSection(Sec);
     648      263800 :   Sec = toDRI(++ESec);
     649      131900 : }
     650             : 
     651             : template <class ELFT>
     652      114469 : std::error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec,
     653             :                                                     StringRef &Result) const {
     654      228938 :   auto Name = EF.getSectionName(&*getSection(Sec));
     655      114469 :   if (!Name)
     656          64 :     return errorToErrorCode(Name.takeError());
     657      114437 :   Result = *Name;
     658      114437 :   return std::error_code();
     659             : }
     660             : 
     661             : template <class ELFT>
     662       13975 : uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const {
     663       13975 :   return getSection(Sec)->sh_addr;
     664             : }
     665             : 
     666             : template <class ELFT>
     667        2319 : uint64_t ELFObjectFile<ELFT>::getSectionIndex(DataRefImpl Sec) const {
     668        2319 :   auto SectionsOrErr = EF.sections();
     669        4638 :   handleAllErrors(std::move(SectionsOrErr.takeError()),
     670             :                   [](const ErrorInfoBase &) {
     671           0 :                     llvm_unreachable("unable to get section index");
     672             :                   });
     673        2319 :   const Elf_Shdr *First = SectionsOrErr->begin();
     674        4638 :   return getSection(Sec) - First;
     675             : }
     676             : 
     677             : template <class ELFT>
     678     2665905 : uint64_t ELFObjectFile<ELFT>::getSectionSize(DataRefImpl Sec) const {
     679     2665905 :   return getSection(Sec)->sh_size;
     680             : }
     681             : 
     682             : template <class ELFT>
     683             : std::error_code
     684       19084 : ELFObjectFile<ELFT>::getSectionContents(DataRefImpl Sec,
     685             :                                         StringRef &Result) const {
     686             :   const Elf_Shdr *EShdr = getSection(Sec);
     687       19084 :   if (std::error_code EC =
     688       40411 :           checkOffset(getMemoryBufferRef(),
     689        2243 :                       (uintptr_t)base() + EShdr->sh_offset, EShdr->sh_size))
     690          16 :     return EC;
     691       21295 :   Result = StringRef((const char *)base() + EShdr->sh_offset, EShdr->sh_size);
     692       19068 :   return std::error_code();
     693             : }
     694             : 
     695             : template <class ELFT>
     696        1596 : uint64_t ELFObjectFile<ELFT>::getSectionAlignment(DataRefImpl Sec) const {
     697        1596 :   return getSection(Sec)->sh_addralign;
     698             : }
     699             : 
     700             : template <class ELFT>
     701       14478 : bool ELFObjectFile<ELFT>::isSectionCompressed(DataRefImpl Sec) const {
     702       14478 :   return getSection(Sec)->sh_flags & ELF::SHF_COMPRESSED;
     703             : }
     704             : 
     705             : template <class ELFT>
     706       12628 : bool ELFObjectFile<ELFT>::isSectionText(DataRefImpl Sec) const {
     707       12628 :   return getSection(Sec)->sh_flags & ELF::SHF_EXECINSTR;
     708             : }
     709             : 
     710             : template <class ELFT>
     711        1306 : bool ELFObjectFile<ELFT>::isSectionData(DataRefImpl Sec) const {
     712             :   const Elf_Shdr *EShdr = getSection(Sec);
     713         523 :   return EShdr->sh_type == ELF::SHT_PROGBITS &&
     714        2163 :          EShdr->sh_flags & ELF::SHF_ALLOC &&
     715        1640 :          !(EShdr->sh_flags & ELF::SHF_EXECINSTR);
     716             : }
     717             : 
     718             : template <class ELFT>
     719       18004 : bool ELFObjectFile<ELFT>::isSectionBSS(DataRefImpl Sec) const {
     720             :   const Elf_Shdr *EShdr = getSection(Sec);
     721       24373 :   return EShdr->sh_flags & (ELF::SHF_ALLOC | ELF::SHF_WRITE) &&
     722       18004 :          EShdr->sh_type == ELF::SHT_NOBITS;
     723             : }
     724             : 
     725             : template <class ELFT>
     726             : std::vector<SectionRef>
     727           0 : ELFObjectFile<ELFT>::dynamic_relocation_sections() const {
     728             :   std::vector<SectionRef> Res;
     729             :   std::vector<uintptr_t> Offsets;
     730             : 
     731           0 :   auto SectionsOrErr = EF.sections();
     732           0 :   if (!SectionsOrErr)
     733             :     return Res;
     734             : 
     735           0 :   for (const Elf_Shdr &Sec : *SectionsOrErr) {
     736           0 :     if (Sec.sh_type != ELF::SHT_DYNAMIC)
     737           0 :       continue;
     738           0 :     Elf_Dyn *Dynamic =
     739           0 :         reinterpret_cast<Elf_Dyn *>((uintptr_t)base() + Sec.sh_offset);
     740           0 :     for (; Dynamic->d_tag != ELF::DT_NULL; Dynamic++) {
     741           0 :       if (Dynamic->d_tag == ELF::DT_REL || Dynamic->d_tag == ELF::DT_RELA ||
     742             :           Dynamic->d_tag == ELF::DT_JMPREL) {
     743           0 :         Offsets.push_back(Dynamic->d_un.d_val);
     744             :       }
     745             :     }
     746             :   }
     747           0 :   for (const Elf_Shdr &Sec : *SectionsOrErr) {
     748           0 :     if (is_contained(Offsets, Sec.sh_offset))
     749           0 :       Res.emplace_back(toDRI(&Sec), this);
     750             :   }
     751             :   return Res;
     752             : }
     753             : 
     754             : template <class ELFT>
     755       21233 : bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const {
     756       21233 :   return getSection(Sec)->sh_type == ELF::SHT_NOBITS;
     757             : }
     758             : 
     759             : template <class ELFT>
     760             : relocation_iterator
     761        7112 : ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
     762             :   DataRefImpl RelData;
     763        7112 :   auto SectionsOrErr = EF.sections();
     764        7112 :   if (!SectionsOrErr)
     765           0 :     return relocation_iterator(RelocationRef());
     766        7112 :   uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
     767       14224 :   RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
     768             :   RelData.d.b = 0;
     769       14224 :   return relocation_iterator(RelocationRef(RelData, this));
     770             : }
     771             : 
     772             : template <class ELFT>
     773             : relocation_iterator
     774        3556 : ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
     775        3556 :   const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
     776        3556 :   relocation_iterator Begin = section_rel_begin(Sec);
     777        3556 :   if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
     778         576 :     return Begin;
     779        2980 :   DataRefImpl RelData = Begin->getRawDataRefImpl();
     780        2980 :   const Elf_Shdr *RelSec = getRelSection(RelData);
     781             : 
     782             :   // Error check sh_link here so that getRelocationSymbol can just use it.
     783        5960 :   auto SymSecOrErr = EF.getSection(RelSec->sh_link);
     784        2980 :   if (!SymSecOrErr)
     785           0 :     report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message());
     786             : 
     787        2980 :   RelData.d.b += S->sh_size / S->sh_entsize;
     788        5960 :   return relocation_iterator(RelocationRef(RelData, this));
     789             : }
     790             : 
     791             : template <class ELFT>
     792             : section_iterator
     793       32792 : ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
     794       32792 :   if (EF.getHeader()->e_type != ELF::ET_REL)
     795       10526 :     return section_end();
     796             : 
     797             :   const Elf_Shdr *EShdr = getSection(Sec);
     798       19258 :   uintX_t Type = EShdr->sh_type;
     799       22266 :   if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
     800       18216 :     return section_end();
     801             : 
     802        8100 :   auto R = EF.getSection(EShdr->sh_info);
     803        4050 :   if (!R)
     804           0 :     report_fatal_error(errorToErrorCode(R.takeError()).message());
     805        8100 :   return section_iterator(SectionRef(toDRI(*R), this));
     806             : }
     807             : 
     808             : // Relocations
     809             : template <class ELFT>
     810       14860 : void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const {
     811       14860 :   ++Rel.d.b;
     812       14860 : }
     813             : 
     814             : template <class ELFT>
     815             : symbol_iterator
     816       13452 : ELFObjectFile<ELFT>::getRelocationSymbol(DataRefImpl Rel) const {
     817             :   uint32_t symbolIdx;
     818       13452 :   const Elf_Shdr *sec = getRelSection(Rel);
     819       13452 :   if (sec->sh_type == ELF::SHT_REL)
     820         712 :     symbolIdx = getRel(Rel)->getSymbol(EF.isMips64EL());
     821             :   else
     822       12740 :     symbolIdx = getRela(Rel)->getSymbol(EF.isMips64EL());
     823       13452 :   if (!symbolIdx)
     824          27 :     return symbol_end();
     825             : 
     826             :   // FIXME: error check symbolIdx
     827             :   DataRefImpl SymbolData;
     828       13425 :   SymbolData.d.a = sec->sh_link;
     829       13425 :   SymbolData.d.b = symbolIdx;
     830       26850 :   return symbol_iterator(SymbolRef(SymbolData, this));
     831             : }
     832             : 
     833             : template <class ELFT>
     834       14138 : uint64_t ELFObjectFile<ELFT>::getRelocationOffset(DataRefImpl Rel) const {
     835       14138 :   const Elf_Shdr *sec = getRelSection(Rel);
     836       14138 :   if (sec->sh_type == ELF::SHT_REL)
     837        2054 :     return getRel(Rel)->r_offset;
     838             : 
     839       26222 :   return getRela(Rel)->r_offset;
     840             : }
     841             : 
     842             : template <class ELFT>
     843       14707 : uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const {
     844       14707 :   const Elf_Shdr *sec = getRelSection(Rel);
     845       14707 :   if (sec->sh_type == ELF::SHT_REL)
     846        1418 :     return getRel(Rel)->getType(EF.isMips64EL());
     847             :   else
     848       27996 :     return getRela(Rel)->getType(EF.isMips64EL());
     849             : }
     850             : 
     851             : template <class ELFT>
     852             : StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
     853             :   return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
     854             : }
     855             : 
     856             : template <class ELFT>
     857         832 : void ELFObjectFile<ELFT>::getRelocationTypeName(
     858             :     DataRefImpl Rel, SmallVectorImpl<char> &Result) const {
     859         832 :   uint32_t type = getRelocationType(Rel);
     860         832 :   EF.getRelocationTypeName(type, Result);
     861         832 : }
     862             : 
     863             : template <class ELFT>
     864             : Expected<int64_t>
     865       12131 : ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const {
     866       24262 :   if (getRelSection(Rel)->sh_type != ELF::SHT_RELA)
     867             :     return createError("Section is not SHT_RELA");
     868       12156 :   return (int64_t)getRela(Rel)->r_addend;
     869             : }
     870             : 
     871             : template <class ELFT>
     872             : const typename ELFObjectFile<ELFT>::Elf_Rel *
     873        2448 : ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const {
     874             :   assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
     875        2448 :   auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b);
     876        2448 :   if (!Ret)
     877           0 :     report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     878        2448 :   return *Ret;
     879             : }
     880             : 
     881             : template <class ELFT>
     882             : const typename ELFObjectFile<ELFT>::Elf_Rela *
     883       52575 : ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
     884             :   assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
     885       52575 :   auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b);
     886       52575 :   if (!Ret)
     887           0 :     report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     888       52575 :   return *Ret;
     889             : }
     890             : 
     891             : template <class ELFT>
     892             : Expected<ELFObjectFile<ELFT>>
     893        5810 : ELFObjectFile<ELFT>::create(MemoryBufferRef Object) {
     894        5810 :   auto EFOrErr = ELFFile<ELFT>::create(Object.getBuffer());
     895        5810 :   if (Error E = EFOrErr.takeError())
     896             :     return std::move(E);
     897        5809 :   auto EF = std::move(*EFOrErr);
     898             : 
     899        5809 :   auto SectionsOrErr = EF.sections();
     900        5809 :   if (!SectionsOrErr)
     901             :     return SectionsOrErr.takeError();
     902             : 
     903             :   const Elf_Shdr *DotDynSymSec = nullptr;
     904             :   const Elf_Shdr *DotSymtabSec = nullptr;
     905             :   ArrayRef<Elf_Word> ShndxTable;
     906     1436932 :   for (const Elf_Shdr &Sec : *SectionsOrErr) {
     907      712661 :     switch (Sec.sh_type) {
     908        1141 :     case ELF::SHT_DYNSYM: {
     909        1141 :       if (DotDynSymSec)
     910             :         return createError("More than one dynamic symbol table!");
     911             :       DotDynSymSec = &Sec;
     912             :       break;
     913             :     }
     914        5732 :     case ELF::SHT_SYMTAB: {
     915        5732 :       if (DotSymtabSec)
     916             :         return createError("More than one static symbol table!");
     917             :       DotSymtabSec = &Sec;
     918             :       break;
     919             :     }
     920           7 :     case ELF::SHT_SYMTAB_SHNDX: {
     921           7 :       auto TableOrErr = EF.getSHNDXTable(Sec);
     922           7 :       if (!TableOrErr)
     923             :         return TableOrErr.takeError();
     924           6 :       ShndxTable = *TableOrErr;
     925             :       break;
     926             :     }
     927             :     }
     928             :   }
     929             :   return ELFObjectFile<ELFT>(Object, EF, DotDynSymSec, DotSymtabSec,
     930        5805 :                              ShndxTable);
     931             : }
     932             : 
     933             : template <class ELFT>
     934       17415 : ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, ELFFile<ELFT> EF,
     935             :                                    const Elf_Shdr *DotDynSymSec,
     936             :                                    const Elf_Shdr *DotSymtabSec,
     937             :                                    ArrayRef<Elf_Word> ShndxTable)
     938             :     : ELFObjectFileBase(
     939             :           getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
     940             :           Object),
     941             :       EF(EF), DotDynSymSec(DotDynSymSec), DotSymtabSec(DotSymtabSec),
     942       17415 :       ShndxTable(ShndxTable) {}
     943             : 
     944             : template <class ELFT>
     945       11610 : ELFObjectFile<ELFT>::ELFObjectFile(ELFObjectFile<ELFT> &&Other)
     946             :     : ELFObjectFile(Other.Data, Other.EF, Other.DotDynSymSec,
     947       23220 :                     Other.DotSymtabSec, Other.ShndxTable) {}
     948             : 
     949             : template <class ELFT>
     950        2629 : basic_symbol_iterator ELFObjectFile<ELFT>::symbol_begin() const {
     951        2629 :   DataRefImpl Sym = toDRI(DotSymtabSec, 0);
     952        5258 :   return basic_symbol_iterator(SymbolRef(Sym, this));
     953             : }
     954             : 
     955             : template <class ELFT>
     956       16488 : basic_symbol_iterator ELFObjectFile<ELFT>::symbol_end() const {
     957       16488 :   const Elf_Shdr *SymTab = DotSymtabSec;
     958       16488 :   if (!SymTab)
     959          18 :     return symbol_begin();
     960       16470 :   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
     961       32940 :   return basic_symbol_iterator(SymbolRef(Sym, this));
     962             : }
     963             : 
     964             : template <class ELFT>
     965         260 : elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_begin() const {
     966         260 :   DataRefImpl Sym = toDRI(DotDynSymSec, 0);
     967         520 :   return symbol_iterator(SymbolRef(Sym, this));
     968             : }
     969             : 
     970             : template <class ELFT>
     971         141 : elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const {
     972         141 :   const Elf_Shdr *SymTab = DotDynSymSec;
     973         141 :   if (!SymTab)
     974         119 :     return dynamic_symbol_begin();
     975          22 :   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
     976          44 :   return basic_symbol_iterator(SymbolRef(Sym, this));
     977             : }
     978             : 
     979             : template <class ELFT>
     980        6680 : section_iterator ELFObjectFile<ELFT>::section_begin() const {
     981        6680 :   auto SectionsOrErr = EF.sections();
     982        6680 :   if (!SectionsOrErr)
     983           0 :     return section_iterator(SectionRef());
     984       13360 :   return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this));
     985             : }
     986             : 
     987             : template <class ELFT>
     988       91734 : section_iterator ELFObjectFile<ELFT>::section_end() const {
     989       91734 :   auto SectionsOrErr = EF.sections();
     990       91734 :   if (!SectionsOrErr)
     991           0 :     return section_iterator(SectionRef());
     992      183468 :   return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this));
     993             : }
     994             : 
     995             : template <class ELFT>
     996       16759 : uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {
     997       16759 :   return ELFT::Is64Bits ? 8 : 4;
     998             : }
     999             : 
    1000             : template <class ELFT>
    1001        4022 : StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
    1002             :   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
    1003        4022 :   switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1004        1241 :   case ELF::ELFCLASS32:
    1005        1241 :     switch (EF.getHeader()->e_machine) {
    1006             :     case ELF::EM_386:
    1007         223 :       return "ELF32-i386";
    1008             :     case ELF::EM_IAMCU:
    1009           3 :       return "ELF32-iamcu";
    1010             :     case ELF::EM_X86_64:
    1011           6 :       return "ELF32-x86-64";
    1012             :     case ELF::EM_ARM:
    1013         426 :       return (IsLittleEndian ? "ELF32-arm-little" : "ELF32-arm-big");
    1014             :     case ELF::EM_AVR:
    1015          10 :       return "ELF32-avr";
    1016             :     case ELF::EM_HEXAGON:
    1017         114 :       return "ELF32-hexagon";
    1018             :     case ELF::EM_LANAI:
    1019           4 :       return "ELF32-lanai";
    1020             :     case ELF::EM_MIPS:
    1021         398 :       return "ELF32-mips";
    1022             :     case ELF::EM_PPC:
    1023          11 :       return "ELF32-ppc";
    1024             :     case ELF::EM_RISCV:
    1025           0 :       return "ELF32-riscv";
    1026             :     case ELF::EM_SPARC:
    1027             :     case ELF::EM_SPARC32PLUS:
    1028           8 :       return "ELF32-sparc";
    1029             :     case ELF::EM_WEBASSEMBLY:
    1030           0 :       return "ELF32-wasm";
    1031             :     case ELF::EM_AMDGPU:
    1032          36 :       return "ELF32-amdgpu";
    1033             :     default:
    1034           2 :       return "ELF32-unknown";
    1035             :     }
    1036        2781 :   case ELF::ELFCLASS64:
    1037        2781 :     switch (EF.getHeader()->e_machine) {
    1038             :     case ELF::EM_386:
    1039           0 :       return "ELF64-i386";
    1040             :     case ELF::EM_X86_64:
    1041        1758 :       return "ELF64-x86-64";
    1042             :     case ELF::EM_AARCH64:
    1043         605 :       return (IsLittleEndian ? "ELF64-aarch64-little" : "ELF64-aarch64-big");
    1044             :     case ELF::EM_PPC64:
    1045         118 :       return "ELF64-ppc64";
    1046             :     case ELF::EM_RISCV:
    1047           0 :       return "ELF64-riscv";
    1048             :     case ELF::EM_S390:
    1049          10 :       return "ELF64-s390";
    1050             :     case ELF::EM_SPARCV9:
    1051          14 :       return "ELF64-sparc";
    1052             :     case ELF::EM_MIPS:
    1053         149 :       return "ELF64-mips";
    1054             :     case ELF::EM_WEBASSEMBLY:
    1055           0 :       return "ELF64-wasm";
    1056             :     case ELF::EM_AMDGPU:
    1057         109 :       return "ELF64-amdgpu";
    1058             :     case ELF::EM_BPF:
    1059          17 :       return "ELF64-BPF";
    1060             :     default:
    1061           1 :       return "ELF64-unknown";
    1062             :     }
    1063           0 :   default:
    1064             :     // FIXME: Proper error handling.
    1065           0 :     report_fatal_error("Invalid ELFCLASS!");
    1066             :   }
    1067             : }
    1068             : 
    1069    31177940 : template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
    1070             :   bool IsLittleEndian = ELFT::TargetEndianness == support::little;
    1071    31177940 :   switch (EF.getHeader()->e_machine) {
    1072             :   case ELF::EM_386:
    1073             :   case ELF::EM_IAMCU:
    1074             :     return Triple::x86;
    1075       34676 :   case ELF::EM_X86_64:
    1076       34676 :     return Triple::x86_64;
    1077             :   case ELF::EM_AARCH64:
    1078      242187 :     return IsLittleEndian ? Triple::aarch64 : Triple::aarch64_be;
    1079       51540 :   case ELF::EM_ARM:
    1080       51540 :     return Triple::arm;
    1081          24 :   case ELF::EM_AVR:
    1082          24 :     return Triple::avr;
    1083       22211 :   case ELF::EM_HEXAGON:
    1084       22211 :     return Triple::hexagon;
    1085          10 :   case ELF::EM_LANAI:
    1086          10 :     return Triple::lanai;
    1087      358705 :   case ELF::EM_MIPS:
    1088      358705 :     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1089             :     case ELF::ELFCLASS32:
    1090             :       return IsLittleEndian ? Triple::mipsel : Triple::mips;
    1091             :     case ELF::ELFCLASS64:
    1092        2443 :       return IsLittleEndian ? Triple::mips64el : Triple::mips64;
    1093           0 :     default:
    1094           0 :       report_fatal_error("Invalid ELFCLASS!");
    1095             :     }
    1096         167 :   case ELF::EM_PPC:
    1097         167 :     return Triple::ppc;
    1098             :   case ELF::EM_PPC64:
    1099    30338485 :     return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
    1100           0 :   case ELF::EM_RISCV:
    1101           0 :     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1102             :     case ELF::ELFCLASS32:
    1103             :       return Triple::riscv32;
    1104           0 :     case ELF::ELFCLASS64:
    1105           0 :       return Triple::riscv64;
    1106           0 :     default:
    1107           0 :       report_fatal_error("Invalid ELFCLASS!");
    1108             :     }
    1109         264 :   case ELF::EM_S390:
    1110         264 :     return Triple::systemz;
    1111             : 
    1112             :   case ELF::EM_SPARC:
    1113             :   case ELF::EM_SPARC32PLUS:
    1114          98 :     return IsLittleEndian ? Triple::sparcel : Triple::sparc;
    1115         106 :   case ELF::EM_SPARCV9:
    1116         106 :     return Triple::sparcv9;
    1117           0 :   case ELF::EM_WEBASSEMBLY:
    1118           0 :     switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
    1119             :     case ELF::ELFCLASS32: return Triple::wasm32;
    1120           0 :     case ELF::ELFCLASS64: return Triple::wasm64;
    1121           0 :     default: return Triple::UnknownArch;
    1122             :     }
    1123             : 
    1124             :   case ELF::EM_AMDGPU: {
    1125             :     if (!IsLittleEndian)
    1126           0 :       return Triple::UnknownArch;
    1127             : 
    1128        2824 :     unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH;
    1129        2824 :     if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST &&
    1130             :         MACH <= ELF::EF_AMDGPU_MACH_R600_LAST)
    1131             :       return Triple::r600;
    1132        2719 :     if (MACH >= ELF::EF_AMDGPU_MACH_AMDGCN_FIRST &&
    1133             :         MACH <= ELF::EF_AMDGPU_MACH_AMDGCN_LAST)
    1134             :       return Triple::amdgcn;
    1135             : 
    1136          44 :     return Triple::UnknownArch;
    1137             :   }
    1138             : 
    1139             :   case ELF::EM_BPF:
    1140        2906 :     return IsLittleEndian ? Triple::bpfel : Triple::bpfeb;
    1141             : 
    1142           2 :   default:
    1143           2 :     return Triple::UnknownArch;
    1144             :   }
    1145             : }
    1146             : 
    1147             : template <class ELFT>
    1148           2 : Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
    1149           2 :   return EF.getHeader()->e_entry;
    1150             : }
    1151             : 
    1152             : template <class ELFT>
    1153             : ELFObjectFileBase::elf_symbol_iterator_range
    1154         141 : ELFObjectFile<ELFT>::getDynamicSymbolIterators() const {
    1155         282 :   return make_range(dynamic_symbol_begin(), dynamic_symbol_end());
    1156             : }
    1157             : 
    1158        1373 : template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
    1159        1373 :   return EF.getHeader()->e_type == ELF::ET_REL;
    1160             : }
    1161             : 
    1162             : } // end namespace object
    1163             : } // end namespace llvm
    1164             : 
    1165             : #endif // LLVM_OBJECT_ELFOBJECTFILE_H

Generated by: LCOV version 1.13