Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- ELF.h - ELF object file implementation -------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file declares the ELFFile template class.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_OBJECT_ELF_H

#define LLVM_OBJECT_ELF_H

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/SmallString.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/BinaryFormat/ELF.h"

#include "llvm/Object/ELFTypes.h"

#include "llvm/Object/Error.h"

#include "llvm/Support/Endian.h"

#include "llvm/Support/Error.h"

#include <cassert>

#include <cstddef>

#include <cstdint>

#include <limits>

#include <utility>

namespace llvm {

namespace object {

struct VerdAux {

  unsigned Offset;

  std::string Name;

};

struct VerDef {

  unsigned Offset;

  unsigned Version;

  unsigned Flags;

  unsigned Ndx;

  unsigned Cnt;

  unsigned Hash;

  std::string Name;

  std::vector<VerdAux> AuxV;

};

struct VernAux {

  unsigned Hash;

  unsigned Flags;

  unsigned Other;

  unsigned Offset;

  std::string Name;

};

struct VerNeed {

  unsigned Version;

  unsigned Cnt;

  unsigned Offset;

  std::string File;

  std::vector<VernAux> AuxV;

};

struct VersionEntry {

  std::string Name;

  bool IsVerDef;

};

StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type);

uint32_t getELFRelativeRelocationType(uint32_t Machine);

StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type);

// Subclasses of ELFFile may need this for template instantiation

inline std::pair<unsigned char, unsigned char>

getElfArchType(StringRef Object) {

  if (Object.size() < ELF::EI_NIDENT)

    return std::make_pair((uint8_t)ELF::ELFCLASSNONE,

                          (uint8_t)ELF::ELFDATANONE);

  return std::make_pair((uint8_t)Object[ELF::EI_CLASS],

                        (uint8_t)Object[ELF::EI_DATA]);

}

enum PPCInstrMasks : uint64_t {

  PADDI_R12_NO_DISP = 0x0610000039800000,

  ADDIS_R12_TO_R2_NO_DISP = 0x3D820000,

  ADDI_R12_TO_R2_NO_DISP = 0x39820000,

  ADDI_R12_TO_R12_NO_DISP = 0x398C0000,

  PLD_R12_NO_DISP = 0x04100000E5800000,

  MTCTR_R12 = 0x7D8903A6,

  BCTR = 0x4E800420,

};

template <class ELFT> class ELFFile;

template <class T> struct DataRegion {

  // This constructor is used when we know the start and the size of a data

  // region. We assume that Arr does not go past the end of the file.

  DataRegion(ArrayRef<T> Arr) : First(Arr.data()), Size(Arr.size()) {}

  // Sometimes we only know the start of a data region. We still don't want to

  // read past the end of the file, so we provide the end of a buffer.

  DataRegion(const T *Data, const uint8_t *BufferEnd)

      : First(Data), BufEnd(BufferEnd) {}

  Expected<T> operator[](uint64_t N) {

    assert(Size || BufEnd);

    if (Size) {

      if (N >= *Size)

        return createError(

            "the index is greater than or equal to the number of entries (" +

            Twine(*Size) + ")");

    } else {

      const uint8_t *EntryStart = (const uint8_t *)First + N * sizeof(T);

      if (EntryStart + sizeof(T) > BufEnd)

        return createError("can't read past the end of the file");

    }

    return *(First + N);

  }

  const T *First;

  std::optional<uint64_t> Size;

  const uint8_t *BufEnd = nullptr;

};

template <class ELFT>

std::string getSecIndexForError(const ELFFile<ELFT> &Obj,

                                const typename ELFT::Shdr &Sec) {

  auto TableOrErr = Obj.sections();

  if (TableOrErr)

    return "[index " + std::to_string(&Sec - &TableOrErr->front()) + "]";

  // To make this helper be more convenient for error reporting purposes we

  // drop the error. But really it should never be triggered. Before this point,

  // our code should have called 'sections()' and reported a proper error on

  // failure.

  llvm::consumeError(TableOrErr.takeError());

  return "[unknown index]";

}

template <class ELFT>

static std::string describe(const ELFFile<ELFT> &Obj,

                            const typename ELFT::Shdr &Sec) {

  unsigned SecNdx = &Sec - &cantFail(Obj.sections()).front();

  return (object::getELFSectionTypeName(Obj.getHeader().e_machine,

                                        Sec.sh_type) +

          " section with index " + Twine(SecNdx))

      .str();

}

template <class ELFT>

std::string getPhdrIndexForError(const ELFFile<ELFT> &Obj,

                                 const typename ELFT::Phdr &Phdr) {

  auto Headers = Obj.program_headers();

  if (Headers)

    return ("[index " + Twine(&Phdr - &Headers->front()) + "]").str();

  // See comment in the getSecIndexForError() above.

  llvm::consumeError(Headers.takeError());

  return "[unknown index]";

}

static inline Error defaultWarningHandler(const Twine &Msg) {

  return createError(Msg);

}

template <class ELFT>

class ELFFile {

public:

  LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)

  // This is a callback that can be passed to a number of functions.

  // It can be used to ignore non-critical errors (warnings), which is

  // useful for dumpers, like llvm-readobj.

  // It accepts a warning message string and returns a success

  // when the warning should be ignored or an error otherwise.

  using WarningHandler = llvm::function_ref<Error(const Twine &Msg)>;

  const uint8_t *base() const { return Buf.bytes_begin(); }

  const uint8_t *end() const { return base() + getBufSize(); }

  size_t getBufSize() const { return Buf.size(); }

private:

  StringRef Buf;

  std::vector<Elf_Shdr> FakeSections;

  SmallString<0> FakeSectionStrings;

  ELFFile(StringRef Object);

public:

  const Elf_Ehdr &getHeader() const {

    return *reinterpret_cast<const Elf_Ehdr *>(base());

  }

  template <typename T>

  Expected<const T *> getEntry(uint32_t Section, uint32_t Entry) const;

  template <typename T>

  Expected<const T *> getEntry(const Elf_Shdr &Section, uint32_t Entry) const;

  Expected<std::vector<VerDef>>

  getVersionDefinitions(const Elf_Shdr &Sec) const;

  Expected<std::vector<VerNeed>> getVersionDependencies(

      const Elf_Shdr &Sec,

      WarningHandler WarnHandler = &defaultWarningHandler) const;

  Expected<StringRef> getSymbolVersionByIndex(

      uint32_t SymbolVersionIndex, bool &IsDefault,

      SmallVector<std::optional<VersionEntry>, 0> &VersionMap,

      std::optional<bool> IsSymHidden) const;

  Expected<StringRef>

  getStringTable(const Elf_Shdr &Section,

                 WarningHandler WarnHandler = &defaultWarningHandler) const;

  Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section) const;

  Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section,

                                              Elf_Shdr_Range Sections) const;

  Expected<StringRef> getLinkAsStrtab(const typename ELFT::Shdr &Sec) const;

  Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section) const;

  Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section,

                                             Elf_Shdr_Range Sections) const;

  Expected<uint64_t> getDynSymtabSize() const;

  StringRef getRelocationTypeName(uint32_t Type) const;

  void getRelocationTypeName(uint32_t Type,

                             SmallVectorImpl<char> &Result) const;

  uint32_t getRelativeRelocationType() const;

  std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const;

  std::string getDynamicTagAsString(uint64_t Type) const;

  /// Get the symbol for a given relocation.

  Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel &Rel,

                                                const Elf_Shdr *SymTab) const;

  Expected<SmallVector<std::optional<VersionEntry>, 0>>

  loadVersionMap(const Elf_Shdr *VerNeedSec, const Elf_Shdr *VerDefSec) const;

  static Expected<ELFFile> create(StringRef Object);

  bool isLE() const {

    return getHeader().getDataEncoding() == ELF::ELFDATA2LSB;

  }

  bool isMipsELF64() const {

    return getHeader().e_machine == ELF::EM_MIPS &&

           getHeader().getFileClass() == ELF::ELFCLASS64;

  }

  bool isMips64EL() const { return isMipsELF64() && isLE(); }

  Expected<Elf_Shdr_Range> sections() const;

  Expected<Elf_Dyn_Range> dynamicEntries() const;

  Expected<const uint8_t *>

  toMappedAddr(uint64_t VAddr,

               WarningHandler WarnHandler = &defaultWarningHandler) const;

  Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {

    if (!Sec)

      return ArrayRef<Elf_Sym>(nullptr, nullptr);

    return getSectionContentsAsArray<Elf_Sym>(*Sec);

  }

  Expected<Elf_Rela_Range> relas(const Elf_Shdr &Sec) const {

    return getSectionContentsAsArray<Elf_Rela>(Sec);

  }

  Expected<Elf_Rel_Range> rels(const Elf_Shdr &Sec) const {

    return getSectionContentsAsArray<Elf_Rel>(Sec);

  }

  Expected<Elf_Relr_Range> relrs(const Elf_Shdr &Sec) const {

    return getSectionContentsAsArray<Elf_Relr>(Sec);

  }

  std::vector<Elf_Rel> decode_relrs(Elf_Relr_Range relrs) const;

  Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr &Sec) const;

  /// Iterate over program header table.

  Expected<Elf_Phdr_Range> program_headers() const {

    if (getHeader().e_phnum && getHeader().e_phentsize != sizeof(Elf_Phdr))

      return createError("invalid e_phentsize: " +

                         Twine(getHeader().e_phentsize));

    uint64_t HeadersSize =

        (uint64_t)getHeader().e_phnum * getHeader().e_phentsize;

    uint64_t PhOff = getHeader().e_phoff;

    if (PhOff + HeadersSize < PhOff || PhOff + HeadersSize > getBufSize())

      return createError("program headers are longer than binary of size " +

                         Twine(getBufSize()) + ": e_phoff = 0x" +

                         Twine::utohexstr(getHeader().e_phoff) +

                         ", e_phnum = " + Twine(getHeader().e_phnum) +

                         ", e_phentsize = " + Twine(getHeader().e_phentsize));

    auto *Begin = reinterpret_cast<const Elf_Phdr *>(base() + PhOff);

    return ArrayRef(Begin, Begin + getHeader().e_phnum);

  }

  /// Get an iterator over notes in a program header.

  ///

  /// The program header must be of type \c PT_NOTE.

  ///

  /// \param Phdr the program header to iterate over.

  /// \param Err [out] an error to support fallible iteration, which should

  ///  be checked after iteration ends.

  Elf_Note_Iterator notes_begin(const Elf_Phdr &Phdr, Error &Err) const {

    assert(Phdr.p_type == ELF::PT_NOTE && "Phdr is not of type PT_NOTE");

    ErrorAsOutParameter ErrAsOutParam(&Err);

    if (Phdr.p_offset + Phdr.p_filesz > getBufSize()) {

      Err =

          createError("invalid offset (0x" + Twine::utohexstr(Phdr.p_offset) +

                      ") or size (0x" + Twine::utohexstr(Phdr.p_filesz) + ")");

      return Elf_Note_Iterator(Err);

    }

    return Elf_Note_Iterator(base() + Phdr.p_offset, Phdr.p_filesz, Err);

  }

  /// Get an iterator over notes in a section.

  ///

  /// The section must be of type \c SHT_NOTE.

  ///

  /// \param Shdr the section to iterate over.

  /// \param Err [out] an error to support fallible iteration, which should

  ///  be checked after iteration ends.

  Elf_Note_Iterator notes_begin(const Elf_Shdr &Shdr, Error &Err) const {

    assert(Shdr.sh_type == ELF::SHT_NOTE && "Shdr is not of type SHT_NOTE");

    ErrorAsOutParameter ErrAsOutParam(&Err);

    if (Shdr.sh_offset + Shdr.sh_size > getBufSize()) {

      Err =

          createError("invalid offset (0x" + Twine::utohexstr(Shdr.sh_offset) +

                      ") or size (0x" + Twine::utohexstr(Shdr.sh_size) + ")");

      return Elf_Note_Iterator(Err);

    }

    return Elf_Note_Iterator(base() + Shdr.sh_offset, Shdr.sh_size, Err);

  }

  /// Get the end iterator for notes.

  Elf_Note_Iterator notes_end() const {

    return Elf_Note_Iterator();

  }

  /// Get an iterator range over notes of a program header.

  ///

  /// The program header must be of type \c PT_NOTE.

  ///

  /// \param Phdr the program header to iterate over.

  /// \param Err [out] an error to support fallible iteration, which should

  ///  be checked after iteration ends.

  iterator_range<Elf_Note_Iterator> notes(const Elf_Phdr &Phdr,

                                          Error &Err) const {

    return make_range(notes_begin(Phdr, Err), notes_end());

  }

  /// Get an iterator range over notes of a section.

  ///

  /// The section must be of type \c SHT_NOTE.

  ///

  /// \param Shdr the section to iterate over.

  /// \param Err [out] an error to support fallible iteration, which should

  ///  be checked after iteration ends.

  iterator_range<Elf_Note_Iterator> notes(const Elf_Shdr &Shdr,

                                          Error &Err) const {

    return make_range(notes_begin(Shdr, Err), notes_end());

  }

  Expected<StringRef> getSectionStringTable(

      Elf_Shdr_Range Sections,

      WarningHandler WarnHandler = &defaultWarningHandler) const;

  Expected<uint32_t> getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,

                                     DataRegion<Elf_Word> ShndxTable) const;

  Expected<const Elf_Shdr *> getSection(const Elf_Sym &Sym,

                                        const Elf_Shdr *SymTab,

                                        DataRegion<Elf_Word> ShndxTable) const;

  Expected<const Elf_Shdr *> getSection(const Elf_Sym &Sym,

                                        Elf_Sym_Range Symtab,

                                        DataRegion<Elf_Word> ShndxTable) const;

  Expected<const Elf_Shdr *> getSection(uint32_t Index) const;

  Expected<const Elf_Sym *> getSymbol(const Elf_Shdr *Sec,

                                      uint32_t Index) const;

  Expected<StringRef>

  getSectionName(const Elf_Shdr &Section,

                 WarningHandler WarnHandler = &defaultWarningHandler) const;

  Expected<StringRef> getSectionName(const Elf_Shdr &Section,

                                     StringRef DotShstrtab) const;

  template <typename T>

  Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr &Sec) const;

  Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr &Sec) const;

  Expected<ArrayRef<uint8_t>> getSegmentContents(const Elf_Phdr &Phdr) const;

  Expected<std::vector<BBAddrMap>> decodeBBAddrMap(const Elf_Shdr &Sec) const;

  void createFakeSections();

};

using ELF32LEFile = ELFFile<ELF32LE>;

using ELF64LEFile = ELFFile<ELF64LE>;

using ELF32BEFile = ELFFile<ELF32BE>;

using ELF64BEFile = ELFFile<ELF64BE>;

template <class ELFT>

inline Expected<const typename ELFT::Shdr *>

getSection(typename ELFT::ShdrRange Sections, uint32_t Index) {

  if (Index >= Sections.size())

    return createError("invalid section index: " + Twine(Index));

  return &Sections[Index];

}

template <class ELFT>

inline Expected<uint32_t>

getExtendedSymbolTableIndex(const typename ELFT::Sym &Sym, unsigned SymIndex,

                            DataRegion<typename ELFT::Word> ShndxTable) {

  assert(Sym.st_shndx == ELF::SHN_XINDEX);

  if (!ShndxTable.First)

    return createError(

        "found an extended symbol index (" + Twine(SymIndex) +

        "), but unable to locate the extended symbol index table");

  Expected<typename ELFT::Word> TableOrErr = ShndxTable[SymIndex];

  if (!TableOrErr)

    return createError("unable to read an extended symbol table at index " +

                       Twine(SymIndex) + ": " +

                       toString(TableOrErr.takeError()));

  return *TableOrErr;

}

template <class ELFT>

Expected<uint32_t>

ELFFile<ELFT>::getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,

                               DataRegion<Elf_Word> ShndxTable) const {

  uint32_t Index = Sym.st_shndx;

  if (Index == ELF::SHN_XINDEX) {

    Expected<uint32_t> ErrorOrIndex =

        getExtendedSymbolTableIndex<ELFT>(Sym, &Sym - Syms.begin(), ShndxTable);

    if (!ErrorOrIndex)

      return ErrorOrIndex.takeError();

    return *ErrorOrIndex;

  }

  if (Index == ELF::SHN_UNDEF || Index >= ELF::SHN_LORESERVE)

    return 0;

  return Index;

}

template <class ELFT>

Expected<const typename ELFT::Shdr *>

ELFFile<ELFT>::getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab,

                          DataRegion<Elf_Word> ShndxTable) const {

  auto SymsOrErr = symbols(SymTab);

  if (!SymsOrErr)

    return SymsOrErr.takeError();

  return getSection(Sym, *SymsOrErr, ShndxTable);

}

template <class ELFT>

Expected<const typename ELFT::Shdr *>

ELFFile<ELFT>::getSection(const Elf_Sym &Sym, Elf_Sym_Range Symbols,

                          DataRegion<Elf_Word> ShndxTable) const {

  auto IndexOrErr = getSectionIndex(Sym, Symbols, ShndxTable);

  if (!IndexOrErr)

    return IndexOrErr.takeError();

  uint32_t Index = *IndexOrErr;

  if (Index == 0)

    return nullptr;

  return getSection(Index);

}

template <class ELFT>

Expected<const typename ELFT::Sym *>

ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {

  auto SymsOrErr = symbols(Sec);

  if (!SymsOrErr)

    return SymsOrErr.takeError();

  Elf_Sym_Range Symbols = *SymsOrErr;

  if (Index >= Symbols.size())

    return createError("unable to get symbol from section " +

                       getSecIndexForError(*this, *Sec) +

                       ": invalid symbol index (" + Twine(Index) + ")");

  return &Symbols[Index];

}

template <class ELFT>

template <typename T>

Expected<ArrayRef<T>>

ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr &Sec) const {

  if (Sec.sh_entsize != sizeof(T) && sizeof(T) != 1)

    return createError("section " + getSecIndexForError(*this, Sec) +

                       " has invalid sh_entsize: expected " + Twine(sizeof(T)) +

                       ", but got " + Twine(Sec.sh_entsize));

  uintX_t Offset = Sec.sh_offset;

  uintX_t Size = Sec.sh_size;

  if (Size % sizeof(T))

    return createError("section " + getSecIndexForError(*this, Sec) +

                       " has an invalid sh_size (" + Twine(Size) +

                       ") which is not a multiple of its sh_entsize (" +

                       Twine(Sec.sh_entsize) + ")");

  if (std::numeric_limits<uintX_t>::max() - Offset < Size)

    return createError("section " + getSecIndexForError(*this, Sec) +

                       " has a sh_offset (0x" + Twine::utohexstr(Offset) +

                       ") + sh_size (0x" + Twine::utohexstr(Size) +

                       ") that cannot be represented");

  if (Offset + Size > Buf.size())

    return createError("section " + getSecIndexForError(*this, Sec) +

                       " has a sh_offset (0x" + Twine::utohexstr(Offset) +

                       ") + sh_size (0x" + Twine::utohexstr(Size) +

                       ") that is greater than the file size (0x" +

                       Twine::utohexstr(Buf.size()) + ")");

  if (Offset % alignof(T))

    // TODO: this error is untested.

    return createError("unaligned data");

  const T *Start = reinterpret_cast<const T *>(base() + Offset);

  return ArrayRef(Start, Size / sizeof(T));

}

template <class ELFT>

Expected<ArrayRef<uint8_t>>

ELFFile<ELFT>::getSegmentContents(const Elf_Phdr &Phdr) const {

  uintX_t Offset = Phdr.p_offset;

  uintX_t Size = Phdr.p_filesz;

  if (std::numeric_limits<uintX_t>::max() - Offset < Size)

    return createError("program header " + getPhdrIndexForError(*this, Phdr) +

                       " has a p_offset (0x" + Twine::utohexstr(Offset) +

                       ") + p_filesz (0x" + Twine::utohexstr(Size) +

                       ") that cannot be represented");

  if (Offset + Size > Buf.size())

    return createError("program header  " + getPhdrIndexForError(*this, Phdr) +

                       " has a p_offset (0x" + Twine::utohexstr(Offset) +

                       ") + p_filesz (0x" + Twine::utohexstr(Size) +

                       ") that is greater than the file size (0x" +

                       Twine::utohexstr(Buf.size()) + ")");

  return ArrayRef(base() + Offset, Size);

}

template <class ELFT>

Expected<ArrayRef<uint8_t>>

ELFFile<ELFT>::getSectionContents(const Elf_Shdr &Sec) const {

  return getSectionContentsAsArray<uint8_t>(Sec);

}

template <class ELFT>

StringRef ELFFile<ELFT>::getRelocationTypeName(uint32_t Type) const {

  return getELFRelocationTypeName(getHeader().e_machine, Type);

}

template <class ELFT>

void ELFFile<ELFT>::getRelocationTypeName(uint32_t Type,

                                          SmallVectorImpl<char> &Result) const {

  if (!isMipsELF64()) {

    StringRef Name = getRelocationTypeName(Type);

    Result.append(Name.begin(), Name.end());

  } else {

    // The Mips N64 ABI allows up to three operations to be specified per

    // relocation record. Unfortunately there's no easy way to test for the

    // presence of N64 ELFs as they have no special flag that identifies them

    // as being N64. We can safely assume at the moment that all Mips

    // ELFCLASS64 ELFs are N64. New Mips64 ABIs should provide enough

    // information to disambiguate between old vs new ABIs.

    uint8_t Type1 = (Type >> 0) & 0xFF;

    uint8_t Type2 = (Type >> 8) & 0xFF;

    uint8_t Type3 = (Type >> 16) & 0xFF;

    // Concat all three relocation type names.

    StringRef Name = getRelocationTypeName(Type1);

    Result.append(Name.begin(), Name.end());

    Name = getRelocationTypeName(Type2);

    Result.append(1, '/');

    Result.append(Name.begin(), Name.end());

    Name = getRelocationTypeName(Type3);

    Result.append(1, '/');

    Result.append(Name.begin(), Name.end());

  }

}

template <class ELFT>

uint32_t ELFFile<ELFT>::getRelativeRelocationType() const {

  return getELFRelativeRelocationType(getHeader().e_machine);

}

template <class ELFT>

Expected<SmallVector<std::optional<VersionEntry>, 0>>

ELFFile<ELFT>::loadVersionMap(const Elf_Shdr *VerNeedSec,

                              const Elf_Shdr *VerDefSec) const {

  SmallVector<std::optional<VersionEntry>, 0> VersionMap;

  // The first two version indexes are reserved.

  // Index 0 is VER_NDX_LOCAL, index 1 is VER_NDX_GLOBAL.

  VersionMap.push_back(VersionEntry());

  VersionMap.push_back(VersionEntry());

  auto InsertEntry = [&](unsigned N, StringRef Version, bool IsVerdef) {

    if (N >= VersionMap.size())

      VersionMap.resize(N + 1);

    VersionMap[N] = {std::string(Version), IsVerdef};

  };

  if (VerDefSec) {

    Expected<std::vector<VerDef>> Defs = getVersionDefinitions(*VerDefSec);

    if (!Defs)

      return Defs.takeError();

    for (const VerDef &Def : *Defs)

      InsertEntry(Def.Ndx & ELF::VERSYM_VERSION, Def.Name, true);

  }

  if (VerNeedSec) {

    Expected<std::vector<VerNeed>> Deps = getVersionDependencies(*VerNeedSec);

    if (!Deps)

      return Deps.takeError();

    for (const VerNeed &Dep : *Deps)

      for (const VernAux &Aux : Dep.AuxV)

        InsertEntry(Aux.Other & ELF::VERSYM_VERSION, Aux.Name, false);

  }

  return VersionMap;

}

template <class ELFT>

Expected<const typename ELFT::Sym *>

ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel &Rel,

                                   const Elf_Shdr *SymTab) const {

  uint32_t Index = Rel.getSymbol(isMips64EL());

  if (Index == 0)

    return nullptr;

  return getEntry<Elf_Sym>(*SymTab, Index);

}

template <class ELFT>

Expected<StringRef>

ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections,

                                     WarningHandler WarnHandler) const {

  uint32_t Index = getHeader().e_shstrndx;

  if (Index == ELF::SHN_XINDEX) {

    // If the section name string table section index is greater than

    // or equal to SHN_LORESERVE, then the actual index of the section name

    // string table section is contained in the sh_link field of the section

    // header at index 0.

    if (Sections.empty())

      return createError(

          "e_shstrndx == SHN_XINDEX, but the section header table is empty");

    Index = Sections[0].sh_link;

  }

  // There is no section name string table. Return FakeSectionStrings which

  // is non-empty if we have created fake sections.

  if (!Index)

    return FakeSectionStrings;

  if (Index >= Sections.size())

    return createError("section header string table index " + Twine(Index) +

                       " does not exist");

  return getStringTable(Sections[Index], WarnHandler);

}

/// This function finds the number of dynamic symbols using a GNU hash table.

///

/// @param Table The GNU hash table for .dynsym.

template <class ELFT>

static Expected<uint64_t>

getDynSymtabSizeFromGnuHash(const typename ELFT::GnuHash &Table,

                            const void *BufEnd) {

  using Elf_Word = typename ELFT::Word;

  if (Table.nbuckets == 0)

    return Table.symndx + 1;

  uint64_t LastSymIdx = 0;

  // Find the index of the first symbol in the last chain.

  for (Elf_Word Val : Table.buckets())

    LastSymIdx = std::max(LastSymIdx, (uint64_t)Val);

  const Elf_Word *It =

      reinterpret_cast<const Elf_Word *>(Table.values(LastSymIdx).end());

  // Locate the end of the chain to find the last symbol index.

  while (It < BufEnd && (*It & 1) == 0) {

    ++LastSymIdx;

    ++It;

  }

  if (It >= BufEnd) {

    return createStringError(

        object_error::parse_failed,

        "no terminator found for GNU hash section before buffer end");

  }

  return LastSymIdx + 1;

}

/// This function determines the number of dynamic symbols. It reads section

/// headers first. If section headers are not available, the number of

/// symbols will be inferred by parsing dynamic hash tables.

template <class ELFT>

Expected<uint64_t> ELFFile<ELFT>::getDynSymtabSize() const {

  // Read .dynsym section header first if available.

  Expected<Elf_Shdr_Range> SectionsOrError = sections();

  if (!SectionsOrError)

    return SectionsOrError.takeError();

  for (const Elf_Shdr &Sec : *SectionsOrError) {

    if (Sec.sh_type == ELF::SHT_DYNSYM) {

      if (Sec.sh_size % Sec.sh_entsize != 0) {

        return createStringError(object_error::parse_failed,

                                 "SHT_DYNSYM section has sh_size (" +

                                     Twine(Sec.sh_size) + ") % sh_entsize (" +

                                     Twine(Sec.sh_entsize) + ") that is not 0");

      }

      return Sec.sh_size / Sec.sh_entsize;

    }

  }

  if (!SectionsOrError->empty()) {

    // Section headers are available but .dynsym header is not found.

    // Return 0 as .dynsym does not exist.

    return 0;

  }