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

Generated by: LCOV version 1.13