ELFDumper.cpp

//===- ELFDumper.cpp - ELF-specific dumper --------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file implements the ELF-specific dumper for llvm-readobj.
///
//===----------------------------------------------------------------------===//

#include"ARMEHABIPrinter.h"
#include"DwarfCFIEHPrinter.h"
#include"ObjDumper.h"
#include"StackMapPrinter.h"
#include"llvm-readobj.h"
#include"llvm/ADT/ArrayRef.h"
#include"llvm/ADT/BitVector.h"
#include"llvm/ADT/DenseMap.h"
#include"llvm/ADT/DenseSet.h"
#include"llvm/ADT/MapVector.h"
#include"llvm/ADT/Optional.h"
#include"llvm/ADT/PointerIntPair.h"
#include"llvm/ADT/STLExtras.h"
#include"llvm/ADT/SmallString.h"
#include"llvm/ADT/SmallVector.h"
#include"llvm/ADT/StringExtras.h"
#include"llvm/ADT/StringRef.h"
#include"llvm/ADT/Twine.h"
#include"llvm/BinaryFormat/AMDGPUMetadataVerifier.h"
#include"llvm/BinaryFormat/ELF.h"
#include"llvm/BinaryFormat/MsgPackDocument.h"
#include"llvm/Demangle/Demangle.h"
#include"llvm/Object/Archive.h"
#include"llvm/Object/ELF.h"
#include"llvm/Object/ELFObjectFile.h"
#include"llvm/Object/ELFTypes.h"
#include"llvm/Object/Error.h"
#include"llvm/Object/ObjectFile.h"
#include"llvm/Object/RelocationResolver.h"
#include"llvm/Object/StackMapParser.h"
#include"llvm/Support/AMDGPUMetadata.h"
#include"llvm/Support/ARMAttributeParser.h"
#include"llvm/Support/ARMBuildAttributes.h"
#include"llvm/Support/Casting.h"
#include"llvm/Support/Compiler.h"
#include"llvm/Support/Endian.h"
#include"llvm/Support/ErrorHandling.h"
#include"llvm/Support/Format.h"
#include"llvm/Support/FormatVariadic.h"
#include"llvm/Support/FormattedStream.h"
#include"llvm/Support/LEB128.h"
#include"llvm/Support/MSP430AttributeParser.h"
#include"llvm/Support/MSP430Attributes.h"
#include"llvm/Support/MathExtras.h"
#include"llvm/Support/MipsABIFlags.h"
#include"llvm/Support/RISCVAttributeParser.h"
#include"llvm/Support/RISCVAttributes.h"
#include"llvm/Support/ScopedPrinter.h"
#include"llvm/Support/raw_ostream.h"
#include<algorithm>
#include<cinttypes>
#include<cstddef>
#include<cstdint>
#include<cstdlib>
#include<iterator>
#include<memory>
#include<string>
#include<system_error>
#include<vector>

usingnamespacellvm;
usingnamespacellvm::object;
usingnamespaceELF;

#defineLLVM_READOBJ_ENUM_CASE(ns, enum) \
case ns::enum: \
return #enum;

#defineENUM_ENT(enum, altName) \
 { #enum, altName, ELF::enum }

#defineENUM_ENT_1(enum) \
 { #enum, #enum, ELF::enum }

namespace {

template <classELFT> structRelSymbol {
RelSymbol(consttypename ELFT::Sym *S, StringRef N)
 : Sym(S), Name(N.str()) {}
consttypename ELFT::Sym *Sym;
 std::string Name;
};

/// Represents a contiguous uniform range in the file. We cannot just create a
/// range directly because when creating one of these from the .dynamic table
/// the size, entity size and virtual address are different entries in arbitrary
/// order (DT_REL, DT_RELSZ, DT_RELENT for example).
structDynRegionInfo {
DynRegionInfo(const Binary &Owner, const ObjDumper &D)
 : Obj(&Owner), Dumper(&D) {}
DynRegionInfo(const Binary &Owner, const ObjDumper &D, constuint8_t *A,
uint64_t S, uint64_t ES)
 : Addr(A), Size(S), EntSize(ES), Obj(&Owner), Dumper(&D) {}

/// Address in current address space.
constuint8_t *Addr = nullptr;
/// Size in bytes of the region.
uint64_tSize = 0;
/// Size of each entity in the region.
uint64_t EntSize = 0;

/// Owner object. Used for error reporting.
const Binary *Obj;
/// Dumper used for error reporting.
const ObjDumper *Dumper;
/// Error prefix. Used for error reporting to provide more information.
 std::string Context;
/// Region size name. Used for error reporting.
 StringRef SizePrintName = "size";
/// Entry size name. Used for error reporting. If this field is empty, errors
/// will not mention the entry size.
 StringRef EntSizePrintName = "entry size";

template <typename Type> ArrayRef<Type> getAsArrayRef() const {
const Type *Start = reinterpret_cast<const Type *>(Addr);
if (!Start)
return {Start, Start};

constuint64_t Offset =
 Addr - (constuint8_t *)Obj->getMemoryBufferRef().getBufferStart();
constuint64_t ObjSize = Obj->getMemoryBufferRef().getBufferSize();

if (Size > ObjSize - Offset) {
 Dumper->reportUniqueWarning(
"unable to read data at 0x" + Twine::utohexstr(Offset) +
" of size 0x" + Twine::utohexstr(Size) + " (" + SizePrintName +
"): it goes past the end of the file of size 0x" +
Twine::utohexstr(ObjSize));
return {Start, Start};
 }

if (EntSize == sizeof(Type) && (Size % EntSize == 0))
return {Start, Start + (Size / EntSize)};

 std::string Msg;
if (!Context.empty())
 Msg += Context + " has ";

 Msg += ("invalid " + SizePrintName + " (0x" + Twine::utohexstr(Size) + ")")
 .str();
if (!EntSizePrintName.empty())
 Msg +=
 (" or " + EntSizePrintName + " (0x" + Twine::utohexstr(EntSize) + ")")
 .str();

 Dumper->reportUniqueWarning(Msg);
return {Start, Start};
 }
};

structGroupMember {
 StringRef Name;
uint64_t Index;
};

structGroupSection {
 StringRef Name;
 std::string Signature;
uint64_t ShName;
uint64_t Index;
uint32_t Link;
uint32_t Info;
uint32_t Type;
 std::vector<GroupMember> Members;
};

namespace {

structNoteType {
uint32_t ID;
 StringRef Name;
};

} // namespace

template <classELFT> classRelocation {
public:
Relocation(consttypename ELFT::Rel &R, bool IsMips64EL)
 : Type(R.getType(IsMips64EL)), Symbol(R.getSymbol(IsMips64EL)),
Offset(R.r_offset), Info(R.r_info) {}

Relocation(consttypename ELFT::Rela &R, bool IsMips64EL)
 : Relocation((consttypename ELFT::Rel &)R, IsMips64EL) {
 Addend = R.r_addend;
 }

uint32_t Type;
uint32_t Symbol;
typename ELFT::uint Offset;
typename ELFT::uint Info;
 Optional<int64_t> Addend;
};

template <classELFT> classMipsGOTParser;

template <typename ELFT> classELFDumper : publicObjDumper {
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)

public:
ELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer);

voidprintUnwindInfo() override;
voidprintNeededLibraries() override;
voidprintHashTable() override;
voidprintGnuHashTable() override;
voidprintLoadName() override;
voidprintVersionInfo() override;
voidprintArchSpecificInfo() override;
voidprintStackMap() constoverride;

const object::ELFObjectFile<ELFT> &getElfObject() const { return ObjF; };

 std::string describe(const Elf_Shdr &Sec) const;

unsignedgetHashTableEntSize() const {
// EM_S390 and ELF::EM_ALPHA platforms use 8-bytes entries in SHT_HASH
// sections. This violates the ELF specification.
if (Obj.getHeader().e_machine == ELF::EM_S390 ||
 Obj.getHeader().e_machine == ELF::EM_ALPHA)
return8;
return4;
 }

 Elf_Dyn_Range dynamic_table() const {
// A valid .dynamic section contains an array of entries terminated
// with a DT_NULL entry. However, sometimes the section content may
// continue past the DT_NULL entry, so to dump the section correctly,
// we first find the end of the entries by iterating over them.
 Elf_Dyn_Range Table = DynamicTable.templategetAsArrayRef<Elf_Dyn>();

size_tSize = 0;
while (Size < Table.size())
if (Table[Size++].getTag() == DT_NULL)
break;

return Table.slice(0, Size);
 }

 Elf_Sym_Range dynamic_symbols() const {
if (!DynSymRegion)
returnElf_Sym_Range();
return DynSymRegion->templategetAsArrayRef<Elf_Sym>();
 }

const Elf_Shdr *findSectionByName(StringRef Name) const;

 StringRef getDynamicStringTable() const { return DynamicStringTable; }

protected:
virtualvoidprintVersionSymbolSection(const Elf_Shdr *Sec) = 0;
virtualvoidprintVersionDefinitionSection(const Elf_Shdr *Sec) = 0;
virtualvoidprintVersionDependencySection(const Elf_Shdr *Sec) = 0;

void
printDependentLibsHelper(function_ref<void(const Elf_Shdr &)> OnSectionStart,
 function_ref<void(StringRef, uint64_t)> OnLibEntry);

virtualvoidprintRelRelaReloc(const Relocation<ELFT> &R,
const RelSymbol<ELFT> &RelSym) = 0;
virtualvoidprintRelrReloc(const Elf_Relr &R) = 0;
virtualvoidprintDynamicRelocHeader(unsigned Type, StringRef Name,
const DynRegionInfo &Reg) {}
voidprintReloc(const Relocation<ELFT> &R, unsigned RelIndex,
const Elf_Shdr &Sec, const Elf_Shdr *SymTab);
voidprintDynamicReloc(const Relocation<ELFT> &R);
voidprintDynamicRelocationsHelper();
voidprintRelocationsHelper(const Elf_Shdr &Sec);
voidforEachRelocationDo(
const Elf_Shdr &Sec, bool RawRelr,
 llvm::function_ref<void(const Relocation<ELFT> &, unsigned,
const Elf_Shdr &, const Elf_Shdr *)>
 RelRelaFn,
 llvm::function_ref<void(const Elf_Relr &)> RelrFn);

virtualvoidprintSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
bool NonVisibilityBitsUsed) const {};
virtualvoidprintSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable,
 Optional<StringRef> StrTable, bool IsDynamic,
bool NonVisibilityBitsUsed) const = 0;

virtualvoidprintMipsABIFlags() = 0;
virtualvoidprintMipsGOT(const MipsGOTParser<ELFT> &Parser) = 0;
virtualvoidprintMipsPLT(const MipsGOTParser<ELFT> &Parser) = 0;

 Expected<ArrayRef<Elf_Versym>>
getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab,
 StringRef *StrTab, const Elf_Shdr **SymTabSec) const;
 StringRef getPrintableSectionName(const Elf_Shdr &Sec) const;

 std::vector<GroupSection> getGroups();

// Returns the function symbol index for the given address. Matches the
// symbol's section with FunctionSec when specified.
// Returns None if no function symbol can be found for the address or in case
// it is not defined in the specified section.
 SmallVector<uint32_t>
getSymbolIndexesForFunctionAddress(uint64_t SymValue,
 Optional<const Elf_Shdr *> FunctionSec);
boolprintFunctionStackSize(uint64_t SymValue,
 Optional<const Elf_Shdr *> FunctionSec,
const Elf_Shdr &StackSizeSec, DataExtractor Data,
uint64_t *Offset);
voidprintStackSize(const Relocation<ELFT> &R, const Elf_Shdr &RelocSec,
unsigned Ndx, const Elf_Shdr *SymTab,
const Elf_Shdr *FunctionSec, const Elf_Shdr &StackSizeSec,
const RelocationResolver &Resolver, DataExtractor Data);
virtualvoidprintStackSizeEntry(uint64_tSize,
 ArrayRef<std::string> FuncNames) = 0;

voidprintRelocatableStackSizes(std::function<void()> PrintHeader);
voidprintNonRelocatableStackSizes(std::function<void()> PrintHeader);

/// Retrieves sections with corresponding relocation sections based on
/// IsMatch.
voidgetSectionAndRelocations(
 std::function<bool(const Elf_Shdr &)> IsMatch,
 llvm::MapVector<const Elf_Shdr *, const Elf_Shdr *> &SecToRelocMap);

const object::ELFObjectFile<ELFT> &ObjF;
const ELFFile<ELFT> &Obj;
 StringRef FileName;

 Expected<DynRegionInfo> createDRI(uint64_t Offset, uint64_tSize,
uint64_t EntSize) {
if (Offset + Size < Offset || Offset + Size > Obj.getBufSize())
returncreateError("offset (0x" + Twine::utohexstr(Offset) +
") + size (0x" + Twine::utohexstr(Size) +
") is greater than the file size (0x" +
Twine::utohexstr(Obj.getBufSize()) + ")");
returnDynRegionInfo(ObjF, *this, Obj.base() + Offset, Size, EntSize);
 }

voidprintAttributes(unsigned, std::unique_ptr<ELFAttributeParser>,
 support::endianness);
voidprintMipsReginfo();
voidprintMipsOptions();

 std::pair<const Elf_Phdr *, const Elf_Shdr *> findDynamic();
voidloadDynamicTable();
voidparseDynamicTable();

 Expected<StringRef> getSymbolVersion(const Elf_Sym &Sym,
bool &IsDefault) const;
 Expected<SmallVector<Optional<VersionEntry>, 0> *> getVersionMap() const;

 DynRegionInfo DynRelRegion;
 DynRegionInfo DynRelaRegion;
 DynRegionInfo DynRelrRegion;
 DynRegionInfo DynPLTRelRegion;
 Optional<DynRegionInfo> DynSymRegion;
 DynRegionInfo DynSymTabShndxRegion;
 DynRegionInfo DynamicTable;
 StringRef DynamicStringTable;
const Elf_Hash *HashTable = nullptr;
const Elf_GnuHash *GnuHashTable = nullptr;
const Elf_Shdr *DotSymtabSec = nullptr;
const Elf_Shdr *DotDynsymSec = nullptr;
const Elf_Shdr *DotAddrsigSec = nullptr;
 DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables;
 Optional<uint64_t> SONameOffset;
 Optional<DenseMap<uint64_t, std::vector<uint32_t>>> AddressToIndexMap;

const Elf_Shdr *SymbolVersionSection = nullptr; // .gnu.version
const Elf_Shdr *SymbolVersionNeedSection = nullptr; // .gnu.version_r
const Elf_Shdr *SymbolVersionDefSection = nullptr; // .gnu.version_d

 std::string getFullSymbolName(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable,
 Optional<StringRef> StrTable,
bool IsDynamic) const;
 Expected<unsigned>
getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable) const;
 Expected<StringRef> getSymbolSectionName(const Elf_Sym &Symbol,
unsigned SectionIndex) const;
 std::string getStaticSymbolName(uint32_t Index) const;
 StringRef getDynamicString(uint64_t Value) const;

voidprintSymbolsHelper(bool IsDynamic) const;
 std::string getDynamicEntry(uint64_t Type, uint64_t Value) const;

 Expected<RelSymbol<ELFT>> getRelocationTarget(const Relocation<ELFT> &R,
const Elf_Shdr *SymTab) const;

 ArrayRef<Elf_Word> getShndxTable(const Elf_Shdr *Symtab) const;

private:
mutable SmallVector<Optional<VersionEntry>, 0> VersionMap;
};

template <classELFT>
std::string ELFDumper<ELFT>::describe(const Elf_Shdr &Sec) const {
return ::describe(Obj, Sec);
}

namespace {

template <classELFT> structSymtabLink {
typename ELFT::SymRange Symbols;
 StringRef StringTable;
consttypename ELFT::Shdr *SymTab;
};

// Returns the linked symbol table, symbols and associated string table for a
// given section.
template <classELFT>
Expected<SymtabLink<ELFT>> getLinkAsSymtab(const ELFFile<ELFT> &Obj,
consttypename ELFT::Shdr &Sec,
unsigned ExpectedType) {
 Expected<consttypename ELFT::Shdr *> SymtabOrErr =
 Obj.getSection(Sec.sh_link);
if (!SymtabOrErr)
returncreateError("invalid section linked to " + describe(Obj, Sec) +
": " + toString(SymtabOrErr.takeError()));

if ((*SymtabOrErr)->sh_type != ExpectedType)
returncreateError(
"invalid section linked to " + describe(Obj, Sec) + ": expected " +
object::getELFSectionTypeName(Obj.getHeader().e_machine, ExpectedType) +
", but got " +
object::getELFSectionTypeName(Obj.getHeader().e_machine,
 (*SymtabOrErr)->sh_type));

 Expected<StringRef> StrTabOrErr = Obj.getLinkAsStrtab(**SymtabOrErr);
if (!StrTabOrErr)
returncreateError(
"can't get a string table for the symbol table linked to " +
describe(Obj, Sec) + ": " + toString(StrTabOrErr.takeError()));

 Expected<typename ELFT::SymRange> SymsOrErr = Obj.symbols(*SymtabOrErr);
if (!SymsOrErr)
returncreateError("unable to read symbols from the " + describe(Obj, Sec) +
": " + toString(SymsOrErr.takeError()));

return SymtabLink<ELFT>{*SymsOrErr, *StrTabOrErr, *SymtabOrErr};
}

} // namespace

template <classELFT>
Expected<ArrayRef<typename ELFT::Versym>>
ELFDumper<ELFT>::getVersionTable(const Elf_Shdr &Sec, ArrayRef<Elf_Sym> *SymTab,
 StringRef *StrTab,
const Elf_Shdr **SymTabSec) const {
assert((!SymTab && !StrTab && !SymTabSec) || (SymTab && StrTab && SymTabSec));
if (reinterpret_cast<uintptr_t>(Obj.base() + Sec.sh_offset) %
sizeof(uint16_t) !=
0)
returncreateError("the " + describe(Sec) + " is misaligned");

 Expected<ArrayRef<Elf_Versym>> VersionsOrErr =
 Obj.templategetSectionContentsAsArray<Elf_Versym>(Sec);
if (!VersionsOrErr)
returncreateError("cannot read content of " + describe(Sec) + ": " +
toString(VersionsOrErr.takeError()));

 Expected<SymtabLink<ELFT>> SymTabOrErr =
getLinkAsSymtab(Obj, Sec, SHT_DYNSYM);
if (!SymTabOrErr) {
reportUniqueWarning(SymTabOrErr.takeError());
return *VersionsOrErr;
 }

if (SymTabOrErr->Symbols.size() != VersionsOrErr->size())
reportUniqueWarning(describe(Sec) + ": the number of entries (" +
Twine(VersionsOrErr->size()) +
") does not match the number of symbols (" +
Twine(SymTabOrErr->Symbols.size()) +
") in the symbol table with index " +
Twine(Sec.sh_link));

if (SymTab) {
 *SymTab = SymTabOrErr->Symbols;
 *StrTab = SymTabOrErr->StringTable;
 *SymTabSec = SymTabOrErr->SymTab;
 }
return *VersionsOrErr;
}

template <classELFT>
void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
 Optional<StringRef> StrTable;
size_t Entries = 0;
 Elf_Sym_Range Syms(nullptr, nullptr);
const Elf_Shdr *SymtabSec = IsDynamic ? DotDynsymSec : DotSymtabSec;

if (IsDynamic) {
 StrTable = DynamicStringTable;
 Syms = dynamic_symbols();
 Entries = Syms.size();
 } elseif (DotSymtabSec) {
if (Expected<StringRef> StrTableOrErr =
 Obj.getStringTableForSymtab(*DotSymtabSec))
 StrTable = *StrTableOrErr;
else
reportUniqueWarning(
"unable to get the string table for the SHT_SYMTAB section: " +
toString(StrTableOrErr.takeError()));

if (Expected<Elf_Sym_Range> SymsOrErr = Obj.symbols(DotSymtabSec))
 Syms = *SymsOrErr;
else
reportUniqueWarning(
"unable to read symbols from the SHT_SYMTAB section: " +
toString(SymsOrErr.takeError()));
 Entries = DotSymtabSec->getEntityCount();
 }
if (Syms.empty())
return;

// The st_other field has 2 logical parts. The first two bits hold the symbol
// visibility (STV_*) and the remainder hold other platform-specific values.
bool NonVisibilityBitsUsed =
llvm::any_of(Syms, [](const Elf_Sym &S) { return S.st_other & ~0x3; });

 DataRegion<Elf_Word> ShndxTable =
 IsDynamic ? DataRegion<Elf_Word>(
 (const Elf_Word *)this->DynSymTabShndxRegion.Addr,
this->getElfObject().getELFFile().end())
 : DataRegion<Elf_Word>(this->getShndxTable(SymtabSec));

printSymtabMessage(SymtabSec, Entries, NonVisibilityBitsUsed);
for (const Elf_Sym &Sym : Syms)
printSymbol(Sym, &Sym - Syms.begin(), ShndxTable, StrTable, IsDynamic,
 NonVisibilityBitsUsed);
}

template <typename ELFT> classGNUELFDumper : publicELFDumper<ELFT> {
 formatted_raw_ostream &OS;

public:
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)

GNUELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer)
 : ELFDumper<ELFT>(ObjF, Writer),
OS(static_cast<formatted_raw_ostream &>(Writer.getOStream())) {
assert(&this->W.getOStream() == &llvm::fouts());
 }

voidprintFileSummary(StringRef FileStr, ObjectFile &Obj,
 ArrayRef<std::string> InputFilenames,
const Archive *A) override;
voidprintFileHeaders() override;
voidprintGroupSections() override;
voidprintRelocations() override;
voidprintSectionHeaders() override;
voidprintSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
voidprintHashSymbols() override;
voidprintSectionDetails() override;
voidprintDependentLibs() override;
voidprintDynamicTable() override;
voidprintDynamicRelocations() override;
voidprintSymtabMessage(const Elf_Shdr *Symtab, size_t Offset,
bool NonVisibilityBitsUsed) constoverride;
voidprintProgramHeaders(bool PrintProgramHeaders,
 cl::boolOrDefault PrintSectionMapping) override;
voidprintVersionSymbolSection(const Elf_Shdr *Sec) override;
voidprintVersionDefinitionSection(const Elf_Shdr *Sec) override;
voidprintVersionDependencySection(const Elf_Shdr *Sec) override;
voidprintHashHistograms() override;
voidprintCGProfile() override;
voidprintBBAddrMaps() override;
voidprintAddrsig() override;
voidprintNotes() override;
voidprintELFLinkerOptions() override;
voidprintStackSizes() override;

private:
voidprintHashHistogram(const Elf_Hash &HashTable);
voidprintGnuHashHistogram(const Elf_GnuHash &GnuHashTable);
voidprintHashTableSymbols(const Elf_Hash &HashTable);
voidprintGnuHashTableSymbols(const Elf_GnuHash &GnuHashTable);

structField {
 std::string Str;
unsigned Column;

Field(StringRef S, unsigned Col) : Str(std::string(S)), Column(Col) {}
Field(unsigned Col) : Column(Col) {}
 };

template <typename T, typename TEnum>
 std::string printFlags(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues,
 TEnum EnumMask1 = {}, TEnum EnumMask2 = {},
 TEnum EnumMask3 = {}) const {
 std::string Str;
for (const EnumEntry<TEnum> &Flag : EnumValues) {
if (Flag.Value == 0)
continue;

 TEnum EnumMask{};
if (Flag.Value & EnumMask1)
 EnumMask = EnumMask1;
elseif (Flag.Value & EnumMask2)
 EnumMask = EnumMask2;
elseif (Flag.Value & EnumMask3)
 EnumMask = EnumMask3;
bool IsEnum = (Flag.Value & EnumMask) != 0;
if ((!IsEnum && (Value & Flag.Value) == Flag.Value) ||
 (IsEnum && (Value & EnumMask) == Flag.Value)) {
if (!Str.empty())
 Str += ", ";
 Str += Flag.AltName;
 }
 }
return Str;
 }

 formatted_raw_ostream &printField(structField F) const {
if (F.Column != 0)
 OS.PadToColumn(F.Column);
 OS << F.Str;
 OS.flush();
return OS;
 }
voidprintHashedSymbol(const Elf_Sym *Sym, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable, StringRef StrTable,
uint32_t Bucket);
voidprintRelrReloc(const Elf_Relr &R) override;
voidprintRelRelaReloc(const Relocation<ELFT> &R,
const RelSymbol<ELFT> &RelSym) override;
voidprintSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable,
 Optional<StringRef> StrTable, bool IsDynamic,
bool NonVisibilityBitsUsed) constoverride;
voidprintDynamicRelocHeader(unsigned Type, StringRef Name,
const DynRegionInfo &Reg) override;

 std::string getSymbolSectionNdx(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable) const;
voidprintProgramHeaders() override;
voidprintSectionMapping() override;
voidprintGNUVersionSectionProlog(consttypename ELFT::Shdr &Sec,
const Twine &Label, unsigned EntriesNum);

voidprintStackSizeEntry(uint64_tSize,
 ArrayRef<std::string> FuncNames) override;

voidprintMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
voidprintMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
voidprintMipsABIFlags() override;
};

template <typename ELFT> classLLVMELFDumper : publicELFDumper<ELFT> {
public:
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)

LLVMELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer)
 : ELFDumper<ELFT>(ObjF, Writer), W(Writer) {}

voidprintFileHeaders() override;
voidprintGroupSections() override;
voidprintRelocations() override;
voidprintSectionHeaders() override;
voidprintSymbols(bool PrintSymbols, bool PrintDynamicSymbols) override;
voidprintDependentLibs() override;
voidprintDynamicTable() override;
voidprintDynamicRelocations() override;
voidprintProgramHeaders(bool PrintProgramHeaders,
 cl::boolOrDefault PrintSectionMapping) override;
voidprintVersionSymbolSection(const Elf_Shdr *Sec) override;
voidprintVersionDefinitionSection(const Elf_Shdr *Sec) override;
voidprintVersionDependencySection(const Elf_Shdr *Sec) override;
voidprintHashHistograms() override;
voidprintCGProfile() override;
voidprintBBAddrMaps() override;
voidprintAddrsig() override;
voidprintNotes() override;
voidprintELFLinkerOptions() override;
voidprintStackSizes() override;

private:
voidprintRelrReloc(const Elf_Relr &R) override;
voidprintRelRelaReloc(const Relocation<ELFT> &R,
const RelSymbol<ELFT> &RelSym) override;

voidprintSymbolSection(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable) const;
voidprintSymbol(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable,
 Optional<StringRef> StrTable, bool IsDynamic,
bool/*NonVisibilityBitsUsed*/) constoverride;
voidprintProgramHeaders() override;
voidprintSectionMapping() override {}
voidprintStackSizeEntry(uint64_tSize,
 ArrayRef<std::string> FuncNames) override;

voidprintMipsGOT(const MipsGOTParser<ELFT> &Parser) override;
voidprintMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
voidprintMipsABIFlags() override;

protected:
 ScopedPrinter &W;
};

// JSONELFDumper shares most of the same implementation as LLVMELFDumper except
// it uses a JSONScopedPrinter.
template <typename ELFT> classJSONELFDumper : publicLLVMELFDumper<ELFT> {
public:
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)

JSONELFDumper(const object::ELFObjectFile<ELFT> &ObjF, ScopedPrinter &Writer)
 : LLVMELFDumper<ELFT>(ObjF, Writer) {}

voidprintFileSummary(StringRef FileStr, ObjectFile &Obj,
 ArrayRef<std::string> InputFilenames,
const Archive *A) override;

private:
 std::unique_ptr<DictScope> FileScope;
};

} // end anonymous namespace

namespacellvm {

template <classELFT>
static std::unique_ptr<ObjDumper>
createELFDumper(const ELFObjectFile<ELFT> &Obj, ScopedPrinter &Writer) {
if (opts::Output == opts::GNU)
return std::make_unique<GNUELFDumper<ELFT>>(Obj, Writer);
elseif (opts::Output == opts::JSON)
return std::make_unique<JSONELFDumper<ELFT>>(Obj, Writer);
return std::make_unique<LLVMELFDumper<ELFT>>(Obj, Writer);
}

std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
 ScopedPrinter &Writer) {
// Little-endian 32-bit
if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(&Obj))
returncreateELFDumper(*ELFObj, Writer);

// Big-endian 32-bit
if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(&Obj))
returncreateELFDumper(*ELFObj, Writer);

// Little-endian 64-bit
if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(&Obj))
returncreateELFDumper(*ELFObj, Writer);

// Big-endian 64-bit
returncreateELFDumper(*cast<ELF64BEObjectFile>(&Obj), Writer);
}

} // end namespace llvm

template <classELFT>
Expected<SmallVector<Optional<VersionEntry>, 0> *>
ELFDumper<ELFT>::getVersionMap() const {
// If the VersionMap has already been loaded or if there is no dynamic symtab
// or version table, there is nothing to do.
if (!VersionMap.empty() || !DynSymRegion || !SymbolVersionSection)
return &VersionMap;

 Expected<SmallVector<Optional<VersionEntry>, 0>> MapOrErr =
 Obj.loadVersionMap(SymbolVersionNeedSection, SymbolVersionDefSection);
if (MapOrErr)
 VersionMap = *MapOrErr;
else
return MapOrErr.takeError();

return &VersionMap;
}

template <typename ELFT>
Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym &Sym,
bool &IsDefault) const {
// This is a dynamic symbol. Look in the GNU symbol version table.
if (!SymbolVersionSection) {
// No version table.
 IsDefault = false;
return"";
 }

assert(DynSymRegion && "DynSymRegion has not been initialised");
// Determine the position in the symbol table of this entry.
size_t EntryIndex = (reinterpret_cast<uintptr_t>(&Sym) -
reinterpret_cast<uintptr_t>(DynSymRegion->Addr)) /
sizeof(Elf_Sym);

// Get the corresponding version index entry.
 Expected<const Elf_Versym *> EntryOrErr =
 Obj.templategetEntry<Elf_Versym>(*SymbolVersionSection, EntryIndex);
if (!EntryOrErr)
return EntryOrErr.takeError();

unsigned Version = (*EntryOrErr)->vs_index;
if (Version == VER_NDX_LOCAL || Version == VER_NDX_GLOBAL) {
 IsDefault = false;
return"";
 }

 Expected<SmallVector<Optional<VersionEntry>, 0> *> MapOrErr =
getVersionMap();
if (!MapOrErr)
return MapOrErr.takeError();

return Obj.getSymbolVersionByIndex(Version, IsDefault, **MapOrErr,
 Sym.st_shndx == ELF::SHN_UNDEF);
}

template <typename ELFT>
Expected<RelSymbol<ELFT>>
ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R,
const Elf_Shdr *SymTab) const {
if (R.Symbol == 0)
return RelSymbol<ELFT>(nullptr, "");

 Expected<const Elf_Sym *> SymOrErr =
 Obj.templategetEntry<Elf_Sym>(*SymTab, R.Symbol);
if (!SymOrErr)
returncreateError("unable to read an entry with index " + Twine(R.Symbol) +
" from " + describe(*SymTab) + ": " +
toString(SymOrErr.takeError()));
const Elf_Sym *Sym = *SymOrErr;
if (!Sym)
return RelSymbol<ELFT>(nullptr, "");

 Expected<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(*SymTab);
if (!StrTableOrErr)
return StrTableOrErr.takeError();

const Elf_Sym *FirstSym =
cantFail(Obj.templategetEntry<Elf_Sym>(*SymTab, 0));
 std::string SymbolName =
getFullSymbolName(*Sym, Sym - FirstSym, getShndxTable(SymTab),
 *StrTableOrErr, SymTab->sh_type == SHT_DYNSYM);
return RelSymbol<ELFT>(Sym, SymbolName);
}

template <typename ELFT>
ArrayRef<typename ELFT::Word>
ELFDumper<ELFT>::getShndxTable(const Elf_Shdr *Symtab) const {
if (Symtab) {
auto It = ShndxTables.find(Symtab);
if (It != ShndxTables.end())
return It->second;
 }
return {};
}

static std::string maybeDemangle(StringRef Name) {
return opts::Demangle ? demangle(std::string(Name)) : Name.str();
}

template <typename ELFT>
std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
auto Warn = [&](Error E) -> std::string {
reportUniqueWarning("unable to read the name of symbol with index " +
Twine(Index) + ": " + toString(std::move(E)));
return"<?>";
 };

 Expected<consttypename ELFT::Sym *> SymOrErr =
 Obj.getSymbol(DotSymtabSec, Index);
if (!SymOrErr)
returnWarn(SymOrErr.takeError());

 Expected<StringRef> StrTabOrErr = Obj.getStringTableForSymtab(*DotSymtabSec);
if (!StrTabOrErr)
returnWarn(StrTabOrErr.takeError());

 Expected<StringRef> NameOrErr = (*SymOrErr)->getName(*StrTabOrErr);
if (!NameOrErr)
returnWarn(NameOrErr.takeError());
returnmaybeDemangle(*NameOrErr);
}

template <typename ELFT>
std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym &Symbol,
unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable,
 Optional<StringRef> StrTable,
bool IsDynamic) const {
if (!StrTable)
return"<?>";

 std::string SymbolName;
if (Expected<StringRef> NameOrErr = Symbol.getName(*StrTable)) {
 SymbolName = maybeDemangle(*NameOrErr);
 } else {
reportUniqueWarning(NameOrErr.takeError());
return"<?>";
 }

if (SymbolName.empty() && Symbol.getType() == ELF::STT_SECTION) {
 Expected<unsigned> SectionIndex =
getSymbolSectionIndex(Symbol, SymIndex, ShndxTable);
if (!SectionIndex) {
reportUniqueWarning(SectionIndex.takeError());
return"<?>";
 }
 Expected<StringRef> NameOrErr = getSymbolSectionName(Symbol, *SectionIndex);
if (!NameOrErr) {
reportUniqueWarning(NameOrErr.takeError());
return ("<section " + Twine(*SectionIndex) + ">").str();
 }
returnstd::string(*NameOrErr);
 }

if (!IsDynamic)
return SymbolName;

bool IsDefault;
 Expected<StringRef> VersionOrErr = getSymbolVersion(Symbol, IsDefault);
if (!VersionOrErr) {
reportUniqueWarning(VersionOrErr.takeError());
return SymbolName + "@<corrupt>";
 }

if (!VersionOrErr->empty()) {
 SymbolName += (IsDefault ? "@@" : "@");
 SymbolName += *VersionOrErr;
 }
return SymbolName;
}

template <typename ELFT>
Expected<unsigned>
ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym &Symbol, unsigned SymIndex,
 DataRegion<Elf_Word> ShndxTable) const {
unsigned Ndx = Symbol.st_shndx;
if (Ndx == SHN_XINDEX)
return object::getExtendedSymbolTableIndex<ELFT>(Symbol, SymIndex,
 ShndxTable);
if (Ndx != SHN_UNDEF && Ndx < SHN_LORESERVE)
return Ndx;

auto CreateErr = [&](const Twine &Name, Optional<unsigned> Offset = None) {
 std::string Desc;
if (Offset)
 Desc = (Name + "+0x" + Twine::utohexstr(*Offset)).str();
else
 Desc = Name.str();
returncreateError(
"unable to get section index for symbol with st_shndx = 0x" +
Twine::utohexstr(Ndx) + " (" + Desc + ")");
 };

if (Ndx >= ELF::SHN_LOPROC && Ndx <= ELF::SHN_HIPROC)
returnCreateErr("SHN_LOPROC", Ndx - ELF::SHN_LOPROC);
if (Ndx >= ELF::SHN_LOOS && Ndx <= ELF::SHN_HIOS)
returnCreateErr("SHN_LOOS", Ndx - ELF::SHN_LOOS);
if (Ndx == ELF::SHN_UNDEF)
returnCreateErr("SHN_UNDEF");
if (Ndx == ELF::SHN_ABS)
returnCreateErr("SHN_ABS");
if (Ndx == ELF::SHN_COMMON)
returnCreateErr("SHN_COMMON");
returnCreateErr("SHN_LORESERVE", Ndx - SHN_LORESERVE);
}

template <typename ELFT>
Expected<StringRef>
ELFDumper<ELFT>::getSymbolSectionName(const Elf_Sym &Symbol,
unsigned SectionIndex) const {
 Expected<const Elf_Shdr *> SecOrErr = Obj.getSection(SectionIndex);
if (!SecOrErr)
return SecOrErr.takeError();
return Obj.getSectionName(**SecOrErr);
}

template <classELFO>
staticconsttypename ELFO::Elf_Shdr *
findNotEmptySectionByAddress(const ELFO &Obj, StringRef FileName,
uint64_t Addr) {
for (consttypename ELFO::Elf_Shdr &Shdr : cantFail(Obj.sections()))
if (Shdr.sh_addr == Addr && Shdr.sh_size > 0)
return &Shdr;
returnnullptr;
}

const EnumEntry<unsigned> ElfClass[] = {
 {"None", "none", ELF::ELFCLASSNONE},
 {"32-bit", "ELF32", ELF::ELFCLASS32},
 {"64-bit", "ELF64", ELF::ELFCLASS64},
};

const EnumEntry<unsigned> ElfDataEncoding[] = {
 {"None", "none", ELF::ELFDATANONE},
 {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB},
 {"BigEndian", "2's complement, big endian", ELF::ELFDATA2MSB},
};

const EnumEntry<unsigned> ElfObjectFileType[] = {
 {"None", "NONE (none)", ELF::ET_NONE},