/build/source/llvm/tools/obj2yaml/elf2yaml.cpp

Bug Summary

File:	build/source/llvm/tools/obj2yaml/elf2yaml.cpp
Warning:	line 1047, column 41 Division by zero

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name elf2yaml.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/obj2yaml -I /build/source/llvm/tools/obj2yaml -I include -I /build/source/llvm/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/llvm/tools/obj2yaml/elf2yaml.cpp

/build/source/llvm/tools/obj2yaml/elf2yaml.cpp

→

1//===------ utils/elf2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//

9#include "obj2yaml.h"
10#include "llvm/ADT/DenseSet.h"
11#include "llvm/ADT/STLExtras.h"
12#include "llvm/ADT/Twine.h"
13#include "llvm/DebugInfo/DWARF/DWARFContext.h"
14#include "llvm/Object/ELFObjectFile.h"
15#include "llvm/ObjectYAML/DWARFYAML.h"
16#include "llvm/ObjectYAML/ELFYAML.h"
17#include "llvm/Support/DataExtractor.h"
18#include "llvm/Support/Errc.h"
19#include "llvm/Support/ErrorHandling.h"
20#include "llvm/Support/YAMLTraits.h"
21#include <optional>

23using namespace llvm;

25namespace {

27template <class ELFT>
28class ELFDumper {
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)using Elf_Addr = typename ELFT::Addr; using Elf_Off = typename
 ELFT::Off; using Elf_Half = typename ELFT::Half; using Elf_Word
 = typename ELFT::Word; using Elf_Sword = typename ELFT::Sword
; using Elf_Xword = typename ELFT::Xword; using Elf_Sxword = typename
 ELFT::Sxword; using uintX_t = typename ELFT::uint; using Elf_Ehdr
 = typename ELFT::Ehdr; using Elf_Shdr = typename ELFT::Shdr;
 using Elf_Sym = typename ELFT::Sym; using Elf_Dyn = typename
 ELFT::Dyn; using Elf_Phdr = typename ELFT::Phdr; using Elf_Rel
 = typename ELFT::Rel; using Elf_Rela = typename ELFT::Rela; using
 Elf_Relr = typename ELFT::Relr; using Elf_Verdef = typename ELFT
::Verdef; using Elf_Verdaux = typename ELFT::Verdaux; using Elf_Verneed
 = typename ELFT::Verneed; using Elf_Vernaux = typename ELFT::
Vernaux; using Elf_Versym = typename ELFT::Versym; using Elf_Hash
 = typename ELFT::Hash; using Elf_GnuHash = typename ELFT::GnuHash
; using Elf_Chdr = typename ELFT::Chdr; using Elf_Nhdr = typename
 ELFT::Nhdr; using Elf_Note = typename ELFT::Note; using Elf_Note_Iterator
 = typename ELFT::NoteIterator; using Elf_CGProfile = typename
 ELFT::CGProfile; using Elf_Dyn_Range = typename ELFT::DynRange
; using Elf_Shdr_Range = typename ELFT::ShdrRange; using Elf_Sym_Range
 = typename ELFT::SymRange; using Elf_Rel_Range = typename ELFT
::RelRange; using Elf_Rela_Range = typename ELFT::RelaRange; using
 Elf_Relr_Range = typename ELFT::RelrRange; using Elf_Phdr_Range
 = typename ELFT::PhdrRange;

ArrayRef<Elf_Shdr> Sections;
ArrayRef<Elf_Sym> SymTable;

DenseMap<StringRef, uint32_t> UsedSectionNames;
std::vector<std::string> SectionNames;
std::optional<uint32_t> ShStrTabIndex;

DenseMap<StringRef, uint32_t> UsedSymbolNames;
std::vector<std::string> SymbolNames;

BumpPtrAllocator StringAllocator;

Expected<StringRef> getUniquedSectionName(const Elf_Shdr &Sec);
Expected<StringRef> getUniquedSymbolName(const Elf_Sym *Sym,
                                         StringRef StrTable,
                                         const Elf_Shdr *SymTab);
Expected<StringRef> getSymbolName(uint32_t SymtabNdx, uint32_t SymbolNdx);

const object::ELFFile<ELFT> &Obj;
std::unique_ptr<DWARFContext> DWARFCtx;

DenseMap<const Elf_Shdr *, ArrayRef<Elf_Word>> ShndxTables;

Expected<std::vector<ELFYAML::ProgramHeader>>
dumpProgramHeaders(ArrayRef<std::unique_ptr<ELFYAML::Chunk>> Sections);

std::optional<DWARFYAML::Data>
dumpDWARFSections(std::vector<std::unique_ptr<ELFYAML::Chunk>> &Sections);

Error dumpSymbols(const Elf_Shdr *Symtab,
                  std::optional<std::vector<ELFYAML::Symbol>> &Symbols);
Error dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                 StringRef StrTable, ELFYAML::Symbol &S);
Expected<std::vector<std::unique_ptr<ELFYAML::Chunk>>> dumpSections();
Error dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S);
Error dumpCommonRelocationSection(const Elf_Shdr *Shdr,
                                  ELFYAML::RelocationSection &S);
template <class RelT>
Error dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                     ELFYAML::Relocation &R);

Expected<ELFYAML::AddrsigSection *> dumpAddrsigSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::LinkerOptionsSection *>
dumpLinkerOptionsSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::DependentLibrariesSection *>
dumpDependentLibrariesSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::CallGraphProfileSection *>
dumpCallGraphProfileSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::RelrSection *> dumpRelrSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::RawContentSection *>
dumpContentSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::SymtabShndxSection *>
dumpSymtabShndxSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::HashSection *> dumpHashSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::NoteSection *> dumpNoteSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::GnuHashSection *> dumpGnuHashSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::GroupSection *> dumpGroupSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::ARMIndexTableSection *>
dumpARMIndexTableSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
Expected<ELFYAML::StackSizesSection *>
dumpStackSizesSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::BBAddrMapSection *>
dumpBBAddrMapSection(const Elf_Shdr *Shdr);
Expected<ELFYAML::RawContentSection *>
dumpPlaceholderSection(const Elf_Shdr *Shdr);

bool shouldPrintSection(const ELFYAML::Section &S, const Elf_Shdr &SHdr,
                        std::optional<DWARFYAML::Data> DWARF);

107public:
ELFDumper(const object::ELFFile<ELFT> &O, std::unique_ptr<DWARFContext> DCtx);
Expected<ELFYAML::Object *> dump();
110};

112}

114template <class ELFT>
115ELFDumper<ELFT>::ELFDumper(const object::ELFFile<ELFT> &O,
                         std::unique_ptr<DWARFContext> DCtx)
  : Obj(O), DWARFCtx(std::move(DCtx)) {}

119template <class ELFT>
120Expected<StringRef>
121ELFDumper<ELFT>::getUniquedSectionName(const Elf_Shdr &Sec) {
unsigned SecIndex = &Sec - &Sections[0];
if (!SectionNames[SecIndex].empty())
  return SectionNames[SecIndex];

auto NameOrErr = Obj.getSectionName(Sec);
if (!NameOrErr)
  return NameOrErr;
StringRef Name = *NameOrErr;
// In some specific cases we might have more than one section without a
// name (sh_name == 0). It normally doesn't happen, but when we have this case
// it doesn't make sense to uniquify their names and add noise to the output.
if (Name.empty())
  return "";

std::string &Ret = SectionNames[SecIndex];

auto It = UsedSectionNames.insert({Name, 0});
if (!It.second)
  Ret = ELFYAML::appendUniqueSuffix(Name, Twine(++It.first->second));
else
  Ret = std::string(Name);
return Ret;
144}

146template <class ELFT>
147Expected<StringRef>
148ELFDumper<ELFT>::getUniquedSymbolName(const Elf_Sym *Sym, StringRef StrTable,
                                    const Elf_Shdr *SymTab) {
Expected<StringRef> SymbolNameOrErr = Sym->getName(StrTable);
if (!SymbolNameOrErr)
  return SymbolNameOrErr;
StringRef Name = *SymbolNameOrErr;
if (Name.empty() && Sym->getType() == ELF::STT_SECTION) {
  Expected<const Elf_Shdr *> ShdrOrErr =
      Obj.getSection(*Sym, SymTab, ShndxTables.lookup(SymTab));
  if (!ShdrOrErr)
    return ShdrOrErr.takeError();
  // The null section has no name.
  return (*ShdrOrErr == nullptr) ? "" : getUniquedSectionName(**ShdrOrErr);
}

// Symbols in .symtab can have duplicate names. For example, it is a common
// situation for local symbols in a relocatable object. Here we assign unique
// suffixes for such symbols so that we can differentiate them.
if (SymTab->sh_type == ELF::SHT_SYMTAB) {
  unsigned Index = Sym - SymTable.data();
  if (!SymbolNames[Index].empty())
    return SymbolNames[Index];

  auto It = UsedSymbolNames.insert({Name, 0});
  if (!It.second)
    SymbolNames[Index] =
        ELFYAML::appendUniqueSuffix(Name, Twine(++It.first->second));
  else
    SymbolNames[Index] = std::string(Name);
  return SymbolNames[Index];
}

return Name;
181}

183template <class ELFT>
184bool ELFDumper<ELFT>::shouldPrintSection(const ELFYAML::Section &S,
                                       const Elf_Shdr &SHdr,
                                       std::optional<DWARFYAML::Data> DWARF) {
// We only print the SHT_NULL section at index 0 when it
// has at least one non-null field, because yaml2obj
// normally creates the zero section at index 0 implicitly.
if (S.Type == ELF::SHT_NULL && (&SHdr == &Sections[0])) {
  const uint8_t *Begin = reinterpret_cast<const uint8_t *>(&SHdr);
  const uint8_t *End = Begin + sizeof(Elf_Shdr);
  return std::any_of(Begin, End, [](uint8_t V) { return V != 0; });
}

// Normally we use "DWARF:" to describe contents of DWARF sections. Sometimes
// the content of DWARF sections can be successfully parsed into the "DWARF:"
// entry but their section headers may have special flags, entry size, address
// alignment, etc. We will preserve the header for them under such
// circumstances.
StringRef SecName = S.Name.substr(1);
if (DWARF && DWARF->getNonEmptySectionNames().count(SecName)) {
  if (const ELFYAML::RawContentSection *RawSec =
          dyn_cast<const ELFYAML::RawContentSection>(&S)) {
    if (RawSec->Type != ELF::SHT_PROGBITS || RawSec->Link || RawSec->Info ||
        RawSec->AddressAlign != yaml::Hex64{1} || RawSec->Address ||
        RawSec->EntSize)
      return true;

    ELFYAML::ELF_SHF ShFlags = RawSec->Flags.value_or(ELFYAML::ELF_SHF(0));

    if (SecName == "debug_str")
      return ShFlags != ELFYAML::ELF_SHF(ELF::SHF_MERGE | ELF::SHF_STRINGS);

    return ShFlags != ELFYAML::ELF_SHF{0};
  }
}

// Normally we use "Symbols:" and "DynamicSymbols:" to describe contents of
// symbol tables. We also build and emit corresponding string tables
// implicitly. But sometimes it is important to preserve positions and virtual
// addresses of allocatable sections, e.g. for creating program headers.
// Generally we are trying to reduce noise in the YAML output. Because
// of that we do not print non-allocatable versions of such sections and
// assume they are placed at the end.
// We also dump symbol tables when the Size field is set. It happens when they
// are empty, which should not normally happen.
if (S.Type == ELF::SHT_STRTAB || S.Type == ELF::SHT_SYMTAB ||
    S.Type == ELF::SHT_DYNSYM) {
  return S.Size || S.Flags.value_or(ELFYAML::ELF_SHF(0)) & ELF::SHF_ALLOC;
}

return true;
234}

236template <class ELFT>
237static void dumpSectionOffsets(const typename ELFT::Ehdr &Header,
                             ArrayRef<ELFYAML::ProgramHeader> Phdrs,
                             std::vector<std::unique_ptr<ELFYAML::Chunk>> &V,
                             ArrayRef<typename ELFT::Shdr> S) {
if (V.empty())
  return;

uint64_t ExpectedOffset;
if (Header.e_phoff > 0)
  ExpectedOffset = Header.e_phoff + Header.e_phentsize * Header.e_phnum;
else
  ExpectedOffset = sizeof(typename ELFT::Ehdr);

for (const std::unique_ptr<ELFYAML::Chunk> &C : ArrayRef(V).drop_front()) {
  ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
  const typename ELFT::Shdr &SecHdr = S[Sec.OriginalSecNdx];

  ExpectedOffset = alignTo(ExpectedOffset,
                           SecHdr.sh_addralign ? SecHdr.sh_addralign : 1uLL);

  // We only set the "Offset" field when it can't be naturally derived
  // from the offset and size of the previous section. This reduces
  // the noise in the YAML output.
  if (SecHdr.sh_offset != ExpectedOffset)
    Sec.Offset = (yaml::Hex64)SecHdr.sh_offset;

  if (Sec.Type == ELF::SHT_NOBITS &&
      !ELFYAML::shouldAllocateFileSpace(Phdrs,
                                        *cast<ELFYAML::NoBitsSection>(&Sec)))
    ExpectedOffset = SecHdr.sh_offset;
  else
    ExpectedOffset = SecHdr.sh_offset + SecHdr.sh_size;
}
270}

272template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
auto Y = std::make_unique<ELFYAML::Object>();

// Dump header. We do not dump EPh* and ESh* fields. When not explicitly set,
// the values are set by yaml2obj automatically and there is no need to dump
// them here.
Y->Header.Class = ELFYAML::ELF_ELFCLASS(Obj.getHeader().getFileClass());
Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader().getDataEncoding());
Y->Header.OSABI = Obj.getHeader().e_ident[ELF::EI_OSABI];
Y->Header.ABIVersion = Obj.getHeader().e_ident[ELF::EI_ABIVERSION];
Y->Header.Type = Obj.getHeader().e_type;
if (Obj.getHeader().e_machine != 0)
  Y->Header.Machine = ELFYAML::ELF_EM(Obj.getHeader().e_machine);
Y->Header.Flags = Obj.getHeader().e_flags;
Y->Header.Entry = Obj.getHeader().e_entry;

// Dump sections
auto SectionsOrErr = Obj.sections();
if (!SectionsOrErr)
  return SectionsOrErr.takeError();
Sections = *SectionsOrErr;
SectionNames.resize(Sections.size());

if (Sections.size() > 0) {
  ShStrTabIndex = Obj.getHeader().e_shstrndx;
  if (*ShStrTabIndex == ELF::SHN_XINDEX)
    ShStrTabIndex = Sections[0].sh_link;
  // TODO: Set EShStrndx if the value doesn't represent a real section.
}

// Normally an object that does not have sections has e_shnum == 0.
// Also, e_shnum might be 0, when the the number of entries in the section
// header table is larger than or equal to SHN_LORESERVE (0xff00). In this
// case the real number of entries is held in the sh_size member of the
// initial entry. We have a section header table when `e_shoff` is not 0.
if (Obj.getHeader().e_shoff != 0 && Obj.getHeader().e_shnum == 0)
  Y->Header.EShNum = 0;

// Dump symbols. We need to do this early because other sections might want
// to access the deduplicated symbol names that we also create here.
const Elf_Shdr *SymTab = nullptr;
const Elf_Shdr *DynSymTab = nullptr;

for (const Elf_Shdr &Sec : Sections) {
  if (Sec.sh_type == ELF::SHT_SYMTAB) {
    SymTab = &Sec;
  } else if (Sec.sh_type == ELF::SHT_DYNSYM) {
    DynSymTab = &Sec;
  } else if (Sec.sh_type == ELF::SHT_SYMTAB_SHNDX) {
    // We need to locate SHT_SYMTAB_SHNDX sections early, because they
    // might be needed for dumping symbols.
    if (Expected<ArrayRef<Elf_Word>> TableOrErr = Obj.getSHNDXTable(Sec)) {
      // The `getSHNDXTable` calls the `getSection` internally when validates
      // the symbol table section linked to the SHT_SYMTAB_SHNDX section.
      const Elf_Shdr *LinkedSymTab = cantFail(Obj.getSection(Sec.sh_link));
      if (!ShndxTables.insert({LinkedSymTab, *TableOrErr}).second)
        return createStringError(
            errc::invalid_argument,
            "multiple SHT_SYMTAB_SHNDX sections are "
            "linked to the same symbol table with index " +
                Twine(Sec.sh_link));
    } else {
      return createStringError(errc::invalid_argument,
                               "unable to read extended section indexes: " +
                                   toString(TableOrErr.takeError()));
    }
  }
}

if (SymTab)
  if (Error E = dumpSymbols(SymTab, Y->Symbols))
    return std::move(E);

if (DynSymTab)
  if (Error E = dumpSymbols(DynSymTab, Y->DynamicSymbols))
    return std::move(E);

// We dump all sections first. It is simple and allows us to verify that all
// sections are valid and also to generalize the code. But we are not going to
// keep all of them in the final output (see comments for
// 'shouldPrintSection()'). Undesired chunks will be removed later.
Expected<std::vector<std::unique_ptr<ELFYAML::Chunk>>> ChunksOrErr =
    dumpSections();
if (!ChunksOrErr)
  return ChunksOrErr.takeError();
std::vector<std::unique_ptr<ELFYAML::Chunk>> Chunks = std::move(*ChunksOrErr);

std::vector<ELFYAML::Section *> OriginalOrder;
if (!Chunks.empty())
  for (const std::unique_ptr<ELFYAML::Chunk> &C :
       ArrayRef(Chunks).drop_front())
    OriginalOrder.push_back(cast<ELFYAML::Section>(C.get()));

// Sometimes the order of sections in the section header table does not match
// their actual order. Here we sort sections by the file offset.
llvm::stable_sort(Chunks, [&](const std::unique_ptr<ELFYAML::Chunk> &A,
                              const std::unique_ptr<ELFYAML::Chunk> &B) {
  return Sections[cast<ELFYAML::Section>(A.get())->OriginalSecNdx].sh_offset <
         Sections[cast<ELFYAML::Section>(B.get())->OriginalSecNdx].sh_offset;
});

// Dump program headers.
Expected<std::vector<ELFYAML::ProgramHeader>> PhdrsOrErr =
    dumpProgramHeaders(Chunks);
if (!PhdrsOrErr)
  return PhdrsOrErr.takeError();
Y->ProgramHeaders = std::move(*PhdrsOrErr);

dumpSectionOffsets<ELFT>(Obj.getHeader(), Y->ProgramHeaders, Chunks,
                         Sections);

// Dump DWARF sections.
Y->DWARF = dumpDWARFSections(Chunks);

// We emit the "SectionHeaderTable" key when the order of sections in the
// sections header table doesn't match the file order.
const bool SectionsSorted =
    llvm::is_sorted(Chunks, [&](const std::unique_ptr<ELFYAML::Chunk> &A,
                                const std::unique_ptr<ELFYAML::Chunk> &B) {
      return cast<ELFYAML::Section>(A.get())->OriginalSecNdx <
             cast<ELFYAML::Section>(B.get())->OriginalSecNdx;
    });
if (!SectionsSorted) {
  std::unique_ptr<ELFYAML::SectionHeaderTable> SHT =
      std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/false);
  SHT->Sections.emplace();
  for (ELFYAML::Section *S : OriginalOrder)
    SHT->Sections->push_back({S->Name});
  Chunks.push_back(std::move(SHT));
}

llvm::erase_if(Chunks, [this, &Y](const std::unique_ptr<ELFYAML::Chunk> &C) {
  if (isa<ELFYAML::SectionHeaderTable>(*C))
    return false;

  const ELFYAML::Section &S = cast<ELFYAML::Section>(*C);
  return !shouldPrintSection(S, Sections[S.OriginalSecNdx], Y->DWARF);
});

// The section header string table by default is assumed to be called
// ".shstrtab" and be in its own unique section. However, it's possible for it
// to be called something else and shared with another section. If the name
// isn't the default, provide this in the YAML.
if (ShStrTabIndex && *ShStrTabIndex != ELF::SHN_UNDEF &&
    *ShStrTabIndex < Sections.size()) {
  StringRef ShStrtabName;
  if (SymTab && SymTab->sh_link == *ShStrTabIndex) {
    // Section header string table is shared with the symbol table. Use that
    // section's name (usually .strtab).
    ShStrtabName = cantFail(Obj.getSectionName(Sections[SymTab->sh_link]));
  } else if (DynSymTab && DynSymTab->sh_link == *ShStrTabIndex) {
    // Section header string table is shared with the dynamic symbol table.
    // Use that section's name (usually .dynstr).
    ShStrtabName = cantFail(Obj.getSectionName(Sections[DynSymTab->sh_link]));
  } else {
    // Otherwise, the section name potentially needs uniquifying.
    ShStrtabName = cantFail(getUniquedSectionName(Sections[*ShStrTabIndex]));
  }
  if (ShStrtabName != ".shstrtab")
    Y->Header.SectionHeaderStringTable = ShStrtabName;
}

Y->Chunks = std::move(Chunks);
return Y.release();
436}

438template <class ELFT>
439static bool isInSegment(const ELFYAML::Section &Sec,
                      const typename ELFT::Shdr &SHdr,
                      const typename ELFT::Phdr &Phdr) {
if (Sec.Type == ELF::SHT_NULL)
  return false;

// A section is within a segment when its location in a file is within the
// [p_offset, p_offset + p_filesz] region.
bool FileOffsetsMatch =
    SHdr.sh_offset >= Phdr.p_offset &&
    (SHdr.sh_offset + SHdr.sh_size <= Phdr.p_offset + Phdr.p_filesz);

bool VirtualAddressesMatch = SHdr.sh_addr >= Phdr.p_vaddr &&
                             SHdr.sh_addr <= Phdr.p_vaddr + Phdr.p_memsz;

if (FileOffsetsMatch) {
  // An empty section on the edges of a program header can be outside of the
  // virtual address space of the segment. This means it is not included in
  // the segment and we should ignore it.
  if (SHdr.sh_size == 0 && (SHdr.sh_offset == Phdr.p_offset ||
                            SHdr.sh_offset == Phdr.p_offset + Phdr.p_filesz))
    return VirtualAddressesMatch;
  return true;
}

// SHT_NOBITS sections usually occupy no physical space in a file. Such
// sections belong to a segment when they reside in the segment's virtual
// address space.
if (Sec.Type != ELF::SHT_NOBITS)
  return false;
return VirtualAddressesMatch;
470}

472template <class ELFT>
473Expected<std::vector<ELFYAML::ProgramHeader>>
474ELFDumper<ELFT>::dumpProgramHeaders(
  ArrayRef<std::unique_ptr<ELFYAML::Chunk>> Chunks) {
std::vector<ELFYAML::ProgramHeader> Ret;
Expected<typename ELFT::PhdrRange> PhdrsOrErr = Obj.program_headers();
if (!PhdrsOrErr)
  return PhdrsOrErr.takeError();

for (const typename ELFT::Phdr &Phdr : *PhdrsOrErr) {
  ELFYAML::ProgramHeader PH;
  PH.Type = Phdr.p_type;
  PH.Flags = Phdr.p_flags;
  PH.VAddr = Phdr.p_vaddr;
  PH.PAddr = Phdr.p_paddr;

  // yaml2obj sets the alignment of a segment to 1 by default.
  // We do not print the default alignment to reduce noise in the output.
  if (Phdr.p_align != 1)
    PH.Align = static_cast<llvm::yaml::Hex64>(Phdr.p_align);

  // Here we match sections with segments.
  // It is not possible to have a non-Section chunk, because
  // obj2yaml does not create Fill chunks.
  for (const std::unique_ptr<ELFYAML::Chunk> &C : Chunks) {
    ELFYAML::Section &S = cast<ELFYAML::Section>(*C);
    if (isInSegment<ELFT>(S, Sections[S.OriginalSecNdx], Phdr)) {
      if (!PH.FirstSec)
        PH.FirstSec = S.Name;
      PH.LastSec = S.Name;
      PH.Chunks.push_back(C.get());
    }
  }

  Ret.push_back(PH);
}

return Ret;
510}

512template <class ELFT>
513std::optional<DWARFYAML::Data> ELFDumper<ELFT>::dumpDWARFSections(
  std::vector<std::unique_ptr<ELFYAML::Chunk>> &Sections) {
DWARFYAML::Data DWARF;
for (std::unique_ptr<ELFYAML::Chunk> &C : Sections) {
  if (!C->Name.startswith(".debug_"))
    continue;

  if (ELFYAML::RawContentSection *RawSec =
          dyn_cast<ELFYAML::RawContentSection>(C.get())) {
    // FIXME: The dumpDebug* functions should take the content as stored in
    // RawSec. Currently, they just use the last section with the matching
    // name, which defeats this attempt to skip reading a section header
    // string table with the same name as a DWARF section.
    if (ShStrTabIndex && RawSec->OriginalSecNdx == *ShStrTabIndex)
      continue;
    Error Err = Error::success();
    cantFail(std::move(Err));

    if (RawSec->Name == ".debug_aranges")
      Err = dumpDebugARanges(*DWARFCtx, DWARF);
    else if (RawSec->Name == ".debug_str")
      Err = dumpDebugStrings(*DWARFCtx, DWARF);
    else if (RawSec->Name == ".debug_ranges")
      Err = dumpDebugRanges(*DWARFCtx, DWARF);
    else if (RawSec->Name == ".debug_addr")
      Err = dumpDebugAddr(*DWARFCtx, DWARF);
    else
      continue;

    // If the DWARF section cannot be successfully parsed, emit raw content
    // instead of an entry in the DWARF section of the YAML.
    if (Err)
      consumeError(std::move(Err));
    else
      RawSec->Content.reset();
  }
}

if (DWARF.getNonEmptySectionNames().empty())
  return std::nullopt;
return DWARF;
554}

556template <class ELFT>
557Expected<ELFYAML::RawContentSection *>
558ELFDumper<ELFT>::dumpPlaceholderSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::RawContentSection>();
if (Error E = dumpCommonSection(Shdr, *S.get()))
  return std::move(E);

// Normally symbol tables should not be empty. We dump the "Size"
// key when they are.
if ((Shdr->sh_type == ELF::SHT_SYMTAB || Shdr->sh_type == ELF::SHT_DYNSYM) &&
    !Shdr->sh_size)
  S->Size.emplace();

return S.release();
570}

572template <class ELFT>
573Expected<std::vector<std::unique_ptr<ELFYAML::Chunk>>>
574ELFDumper<ELFT>::dumpSections() {
std::vector<std::unique_ptr<ELFYAML::Chunk>> Ret;
auto Add = [&](Expected<ELFYAML::Chunk *> SecOrErr) -> Error {
  if (!SecOrErr)
    return SecOrErr.takeError();
  Ret.emplace_back(*SecOrErr);
  return Error::success();
};

auto GetDumper = [this](unsigned Type)
    -> std::function<Expected<ELFYAML::Chunk *>(const Elf_Shdr *)> {
  if (Obj.getHeader().e_machine == ELF::EM_ARM && Type == ELF::SHT_ARM_EXIDX)
    return [this](const Elf_Shdr *S) { return dumpARMIndexTableSection(S); };

  if (Obj.getHeader().e_machine == ELF::EM_MIPS &&
      Type == ELF::SHT_MIPS_ABIFLAGS)
    return [this](const Elf_Shdr *S) { return dumpMipsABIFlags(S); };

  switch (Type) {
  case ELF::SHT_DYNAMIC:
    return [this](const Elf_Shdr *S) { return dumpDynamicSection(S); };
  case ELF::SHT_SYMTAB_SHNDX:
    return [this](const Elf_Shdr *S) { return dumpSymtabShndxSection(S); };
  case ELF::SHT_REL:
  case ELF::SHT_RELA:
    return [this](const Elf_Shdr *S) { return dumpRelocSection(S); };
  case ELF::SHT_RELR:
    return [this](const Elf_Shdr *S) { return dumpRelrSection(S); };
  case ELF::SHT_GROUP:
    return [this](const Elf_Shdr *S) { return dumpGroupSection(S); };
  case ELF::SHT_NOBITS:
    return [this](const Elf_Shdr *S) { return dumpNoBitsSection(S); };
  case ELF::SHT_NOTE:
    return [this](const Elf_Shdr *S) { return dumpNoteSection(S); };
  case ELF::SHT_HASH:
    return [this](const Elf_Shdr *S) { return dumpHashSection(S); };
  case ELF::SHT_GNU_HASH:
    return [this](const Elf_Shdr *S) { return dumpGnuHashSection(S); };
  case ELF::SHT_GNU_verdef:
    return [this](const Elf_Shdr *S) { return dumpVerdefSection(S); };
  case ELF::SHT_GNU_versym:
    return [this](const Elf_Shdr *S) { return dumpSymverSection(S); };
  case ELF::SHT_GNU_verneed:
    return [this](const Elf_Shdr *S) { return dumpVerneedSection(S); };
  case ELF::SHT_LLVM_ADDRSIG:
    return [this](const Elf_Shdr *S) { return dumpAddrsigSection(S); };
  case ELF::SHT_LLVM_LINKER_OPTIONS:
    return [this](const Elf_Shdr *S) { return dumpLinkerOptionsSection(S); };
  case ELF::SHT_LLVM_DEPENDENT_LIBRARIES:
    return [this](const Elf_Shdr *S) {
      return dumpDependentLibrariesSection(S);
    };
  case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
    return
        [this](const Elf_Shdr *S) { return dumpCallGraphProfileSection(S); };
1
Calling 'ELFDumper::dumpCallGraphProfileSection'→
  case ELF::SHT_LLVM_BB_ADDR_MAP_V0:
  case ELF::SHT_LLVM_BB_ADDR_MAP:
    return [this](const Elf_Shdr *S) { return dumpBBAddrMapSection(S); };
  case ELF::SHT_STRTAB:
  case ELF::SHT_SYMTAB:
  case ELF::SHT_DYNSYM:
    // The contents of these sections are described by other parts of the YAML
    // file. But we still want to dump them, because their properties can be
    // important. See comments for 'shouldPrintSection()' for more details.
    return [this](const Elf_Shdr *S) { return dumpPlaceholderSection(S); };
  default:
    return nullptr;
  }
};

for (const Elf_Shdr &Sec : Sections) {
  // We have dedicated dumping functions for most of the section types.
  // Try to use one of them first.
  if (std::function<Expected<ELFYAML::Chunk *>(const Elf_Shdr *)> DumpFn =
          GetDumper(Sec.sh_type)) {
    if (Error E = Add(DumpFn(&Sec)))
      return std::move(E);
    continue;
  }

  // Recognize some special SHT_PROGBITS sections by name.
  if (Sec.sh_type == ELF::SHT_PROGBITS) {
    auto NameOrErr = Obj.getSectionName(Sec);
    if (!NameOrErr)
      return NameOrErr.takeError();

    if (ELFYAML::StackSizesSection::nameMatches(*NameOrErr)) {
      if (Error E = Add(dumpStackSizesSection(&Sec)))
        return std::move(E);
      continue;
    }
  }

  if (Error E = Add(dumpContentSection(&Sec)))
    return std::move(E);
}

return std::move(Ret);
672}

674template <class ELFT>
675Error ELFDumper<ELFT>::dumpSymbols(
  const Elf_Shdr *Symtab,
  std::optional<std::vector<ELFYAML::Symbol>> &Symbols) {
if (!Symtab)
  return Error::success();

auto SymtabOrErr = Obj.symbols(Symtab);
if (!SymtabOrErr)
  return SymtabOrErr.takeError();

if (SymtabOrErr->empty())
  return Error::success();

auto StrTableOrErr = Obj.getStringTableForSymtab(*Symtab);
if (!StrTableOrErr)
  return StrTableOrErr.takeError();

if (Symtab->sh_type == ELF::SHT_SYMTAB) {
  SymTable = *SymtabOrErr;
  SymbolNames.resize(SymTable.size());
}

Symbols.emplace();
for (const auto &Sym : (*SymtabOrErr).drop_front()) {
  ELFYAML::Symbol S;
  if (auto EC = dumpSymbol(&Sym, Symtab, *StrTableOrErr, S))
    return EC;
  Symbols->push_back(S);
}

return Error::success();
706}

708template <class ELFT>
709Error ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                                StringRef StrTable, ELFYAML::Symbol &S) {
S.Type = Sym->getType();
if (Sym->st_value)
  S.Value = (yaml::Hex64)Sym->st_value;
if (Sym->st_size)
  S.Size = (yaml::Hex64)Sym->st_size;
S.Other = Sym->st_other;
S.Binding = Sym->getBinding();

Expected<StringRef> SymbolNameOrErr =
    getUniquedSymbolName(Sym, StrTable, SymTab);
if (!SymbolNameOrErr)
  return SymbolNameOrErr.takeError();
S.Name = SymbolNameOrErr.get();

if (Sym->st_shndx >= ELF::SHN_LORESERVE) {
  S.Index = (ELFYAML::ELF_SHN)Sym->st_shndx;
  return Error::success();
}

auto ShdrOrErr = Obj.getSection(*Sym, SymTab, ShndxTables.lookup(SymTab));
if (!ShdrOrErr)
  return ShdrOrErr.takeError();
const Elf_Shdr *Shdr = *ShdrOrErr;
if (!Shdr)
  return Error::success();

auto NameOrErr = getUniquedSectionName(*Shdr);
if (!NameOrErr)
  return NameOrErr.takeError();
S.Section = NameOrErr.get();

return Error::success();
743}

745template <class ELFT>
746template <class RelT>
747Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
                                    ELFYAML::Relocation &R) {
R.Type = Rel->getType(Obj.isMips64EL());
R.Offset = Rel->r_offset;
R.Addend = 0;

auto SymOrErr = Obj.getRelocationSymbol(*Rel, SymTab);
if (!SymOrErr)
  return SymOrErr.takeError();

// We have might have a relocation with symbol index 0,
// e.g. R_X86_64_NONE or R_X86_64_GOTPC32.
const Elf_Sym *Sym = *SymOrErr;
if (!Sym)
  return Error::success();

auto StrTabSec = Obj.getSection(SymTab->sh_link);
if (!StrTabSec)
  return StrTabSec.takeError();
auto StrTabOrErr = Obj.getStringTable(**StrTabSec);
if (!StrTabOrErr)
  return StrTabOrErr.takeError();

Expected<StringRef> NameOrErr =
    getUniquedSymbolName(Sym, *StrTabOrErr, SymTab);
if (!NameOrErr)
  return NameOrErr.takeError();
R.Symbol = NameOrErr.get();

return Error::success();
777}

779template <class ELFT>
780Error ELFDumper<ELFT>::dumpCommonSection(const Elf_Shdr *Shdr,
                                       ELFYAML::Section &S) {
// Dump fields. We do not dump the ShOffset field. When not explicitly
// set, the value is set by yaml2obj automatically.
S.Type = Shdr->sh_type;
if (Shdr->sh_flags)
  S.Flags = static_cast<ELFYAML::ELF_SHF>(Shdr->sh_flags);
if (Shdr->sh_addr)
  S.Address = static_cast<uint64_t>(Shdr->sh_addr);
S.AddressAlign = Shdr->sh_addralign;

S.OriginalSecNdx = Shdr - &Sections[0];

Expected<StringRef> NameOrErr = getUniquedSectionName(*Shdr);
if (!NameOrErr)
  return NameOrErr.takeError();
S.Name = NameOrErr.get();

if (Shdr->sh_entsize != ELFYAML::getDefaultShEntSize<ELFT>(
                            Obj.getHeader().e_machine, S.Type, S.Name))
  S.EntSize = static_cast<llvm::yaml::Hex64>(Shdr->sh_entsize);

if (Shdr->sh_link != ELF::SHN_UNDEF) {
  Expected<const Elf_Shdr *> LinkSection = Obj.getSection(Shdr->sh_link);
  if (!LinkSection)
    return make_error<StringError>(
        "unable to resolve sh_link reference in section '" + S.Name +
            "': " + toString(LinkSection.takeError()),
        inconvertibleErrorCode());

  NameOrErr = getUniquedSectionName(**LinkSection);
  if (!NameOrErr)
    return NameOrErr.takeError();
  S.Link = NameOrErr.get();
}

return Error::success();
817}

819template <class ELFT>
820Error ELFDumper<ELFT>::dumpCommonRelocationSection(
  const Elf_Shdr *Shdr, ELFYAML::RelocationSection &S) {
if (Error E = dumpCommonSection(Shdr, S))
  return E;

// Having a zero sh_info field is normal: .rela.dyn is a dynamic
// relocation section that normally has no value in this field.
if (!Shdr->sh_info)
  return Error::success();

auto InfoSection = Obj.getSection(Shdr->sh_info);
if (!InfoSection)
  return InfoSection.takeError();

Expected<StringRef> NameOrErr = getUniquedSectionName(**InfoSection);
if (!NameOrErr)
  return NameOrErr.takeError();
S.RelocatableSec = NameOrErr.get();

return Error::success();
840}

842template <class ELFT>
843Expected<ELFYAML::StackSizesSection *>
844ELFDumper<ELFT>::dumpStackSizesSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::StackSizesSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

ArrayRef<uint8_t> Content = *ContentOrErr;
DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);

std::vector<ELFYAML::StackSizeEntry> Entries;
DataExtractor::Cursor Cur(0);
while (Cur && Cur.tell() < Content.size()) {
  uint64_t Address = Data.getAddress(Cur);
  uint64_t Size = Data.getULEB128(Cur);
  Entries.push_back({Address, Size});
}

if (Content.empty() || !Cur) {
  // If .stack_sizes cannot be decoded, we dump it as an array of bytes.
  consumeError(Cur.takeError());
  S->Content = yaml::BinaryRef(Content);
} else {
  S->Entries = std::move(Entries);
}

return S.release();
873}

875template <class ELFT>
876Expected<ELFYAML::BBAddrMapSection *>
877ELFDumper<ELFT>::dumpBBAddrMapSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::BBAddrMapSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

ArrayRef<uint8_t> Content = *ContentOrErr;
if (Content.empty())
  return S.release();

DataExtractor Data(Content, Obj.isLE(), ELFT::Is64Bits ? 8 : 4);

std::vector<ELFYAML::BBAddrMapEntry> Entries;
DataExtractor::Cursor Cur(0);
uint8_t Version = 0;
uint8_t Feature = 0;
while (Cur && Cur.tell() < Content.size()) {
  if (Shdr->sh_type == ELF::SHT_LLVM_BB_ADDR_MAP) {
    Version = Data.getU8(Cur);
    if (Cur && Version > 2)
      return createStringError(
          errc::invalid_argument,
          "invalid SHT_LLVM_BB_ADDR_MAP section version: " +
              Twine(static_cast<int>(Version)));
    Feature = Data.getU8(Cur);
  }
  uint64_t Address = Data.getAddress(Cur);
  uint64_t NumBlocks = Data.getULEB128(Cur);
  std::vector<ELFYAML::BBAddrMapEntry::BBEntry> BBEntries;
  // Read the specified number of BB entries, or until decoding fails.
  for (uint64_t BlockIndex = 0; Cur && BlockIndex < NumBlocks; ++BlockIndex) {
    uint32_t ID = Version >= 2 ? Data.getULEB128(Cur) : BlockIndex;
    uint64_t Offset = Data.getULEB128(Cur);
    uint64_t Size = Data.getULEB128(Cur);
    uint64_t Metadata = Data.getULEB128(Cur);
    BBEntries.push_back({ID, Offset, Size, Metadata});
  }
  Entries.push_back(
      {Version, Feature, Address, /*NumBlocks=*/{}, std::move(BBEntries)});
}

if (!Cur) {
  // If the section cannot be decoded, we dump it as an array of bytes.
  consumeError(Cur.takeError());
  S->Content = yaml::BinaryRef(Content);
} else {
  S->Entries = std::move(Entries);
}

return S.release();
930}

932template <class ELFT>
933Expected<ELFYAML::AddrsigSection *>
934ELFDumper<ELFT>::dumpAddrsigSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::AddrsigSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

ArrayRef<uint8_t> Content = *ContentOrErr;
DataExtractor::Cursor Cur(0);
DataExtractor Data(Content, Obj.isLE(), /*AddressSize=*/0);
std::vector<ELFYAML::YAMLFlowString> Symbols;
while (Cur && Cur.tell() < Content.size()) {
  uint64_t SymNdx = Data.getULEB128(Cur);
  if (!Cur)
    break;

  Expected<StringRef> SymbolName = getSymbolName(Shdr->sh_link, SymNdx);
  if (!SymbolName || SymbolName->empty()) {
    consumeError(SymbolName.takeError());
    Symbols.emplace_back(
        StringRef(std::to_string(SymNdx)).copy(StringAllocator));
    continue;
  }

  Symbols.emplace_back(*SymbolName);
}

if (Cur) {
  S->Symbols = std::move(Symbols);
  return S.release();
}

consumeError(Cur.takeError());
S->Content = yaml::BinaryRef(Content);
return S.release();
971}

973template <class ELFT>
974Expected<ELFYAML::LinkerOptionsSection *>
975ELFDumper<ELFT>::dumpLinkerOptionsSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::LinkerOptionsSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

ArrayRef<uint8_t> Content = *ContentOrErr;
if (Content.empty() || Content.back() != 0) {
  S->Content = Content;
  return S.release();
}

SmallVector<StringRef, 16> Strings;
toStringRef(Content.drop_back()).split(Strings, '\0');
if (Strings.size() % 2 != 0) {
  S->Content = Content;
  return S.release();
}

S->Options.emplace();
for (size_t I = 0, E = Strings.size(); I != E; I += 2)
  S->Options->push_back({Strings[I], Strings[I + 1]});

return S.release();
1002}

1004template <class ELFT>
1005Expected<ELFYAML::DependentLibrariesSection *>
1006ELFDumper<ELFT>::dumpDependentLibrariesSection(const Elf_Shdr *Shdr) {
auto DL = std::make_unique<ELFYAML::DependentLibrariesSection>();
if (Error E = dumpCommonSection(Shdr, *DL))
  return std::move(E);

Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

ArrayRef<uint8_t> Content = *ContentOrErr;
if (!Content.empty() && Content.back() != 0) {
  DL->Content = Content;
  return DL.release();
}

DL->Libs.emplace();
for (const uint8_t *I = Content.begin(), *E = Content.end(); I < E;) {
  StringRef Lib((const char *)I);
  DL->Libs->emplace_back(Lib);
  I += Lib.size() + 1;
}

return DL.release();
1029}

1031template <class ELFT>
1032Expected<ELFYAML::CallGraphProfileSection *>
1033ELFDumper<ELFT>::dumpCallGraphProfileSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::CallGraphProfileSection>();
if (Error E = dumpCommonSection(Shdr, *S))
2
←
Assuming the condition is false→
3
←
Taking false branch→
  return std::move(E);

Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
4
←
Taking false branch→
  return ContentOrErr.takeError();
ArrayRef<uint8_t> Content = *ContentOrErr;
const uint32_t SizeOfEntry = ELFYAML::getDefaultShEntSize<ELFT>(
5
←
Calling 'getDefaultShEntSize<llvm::object::ELFType<llvm::support::big, true>>'→
12
←
Returning from 'getDefaultShEntSize<llvm::object::ELFType<llvm::support::big, true>>'→
13
←
'SizeOfEntry' initialized to 0→
    Obj.getHeader().e_machine, S->Type, S->Name);
// Dump the section by using the Content key when it is truncated.
// There is no need to create either "Content" or "Entries" fields when the
// section is empty.
if (Content.empty() || Content.size() % SizeOfEntry != 0) {
14
←
Assuming the condition is false→
15
←
Division by zero
  if (!Content.empty())
    S->Content = yaml::BinaryRef(Content);
  return S.release();
}

std::vector<ELFYAML::CallGraphEntryWeight> Entries(Content.size() /
                                                   SizeOfEntry);
DataExtractor Data(Content, Obj.isLE(), /*AddressSize=*/0);
DataExtractor::Cursor Cur(0);
auto ReadEntry = [&](ELFYAML::CallGraphEntryWeight &E) {
  E.Weight = Data.getU64(Cur);
  if (!Cur) {
    consumeError(Cur.takeError());
    return false;
  }
  return true;
};

for (ELFYAML::CallGraphEntryWeight &E : Entries) {
  if (ReadEntry(E))
    continue;
  S->Content = yaml::BinaryRef(Content);
  return S.release();
}

S->Entries = std::move(Entries);
return S.release();
1075}

1077template <class ELFT>
1078Expected<ELFYAML::DynamicSection *>
1079ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::DynamicSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(*Shdr);
if (!DynTagsOrErr)
  return DynTagsOrErr.takeError();

S->Entries.emplace();
for (const Elf_Dyn &Dyn : *DynTagsOrErr)
  S->Entries->push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()});

return S.release();
1093}

1095template <class ELFT>
1096Expected<ELFYAML::RelocationSection *>
1097ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::RelocationSection>();
if (auto E = dumpCommonRelocationSection(Shdr, *S))
  return std::move(E);

auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
if (!SymTabOrErr)
  return SymTabOrErr.takeError();

if (Shdr->sh_size != 0)
  S->Relocations.emplace();

if (Shdr->sh_type == ELF::SHT_REL) {
  auto Rels = Obj.rels(*Shdr);
  if (!Rels)
    return Rels.takeError();
  for (const Elf_Rel &Rel : *Rels) {
    ELFYAML::Relocation R;
    if (Error E = dumpRelocation(&Rel, *SymTabOrErr, R))
      return std::move(E);
    S->Relocations->push_back(R);
  }
} else {
  auto Rels = Obj.relas(*Shdr);
  if (!Rels)
    return Rels.takeError();
  for (const Elf_Rela &Rel : *Rels) {
    ELFYAML::Relocation R;
    if (Error E = dumpRelocation(&Rel, *SymTabOrErr, R))
      return std::move(E);
    R.Addend = Rel.r_addend;
    S->Relocations->push_back(R);
  }
}

return S.release();
1133}

1135template <class ELFT>
1136Expected<ELFYAML::RelrSection *>
1137ELFDumper<ELFT>::dumpRelrSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::RelrSection>();
if (auto E = dumpCommonSection(Shdr, *S))
  return std::move(E);

if (Expected<ArrayRef<Elf_Relr>> Relrs = Obj.relrs(*Shdr)) {
  S->Entries.emplace();
  for (Elf_Relr Rel : *Relrs)
    S->Entries->emplace_back(Rel);
  return S.release();
} else {
  // Ignore. We are going to dump the data as raw content below.
  consumeError(Relrs.takeError());
}

Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();
S->Content = *ContentOrErr;
return S.release();
1157}

1159template <class ELFT>
1160Expected<ELFYAML::RawContentSection *>
1161ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::RawContentSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

unsigned SecIndex = Shdr - &Sections[0];
if (SecIndex != 0 || Shdr->sh_type != ELF::SHT_NULL) {
  auto ContentOrErr = Obj.getSectionContents(*Shdr);
  if (!ContentOrErr)
    return ContentOrErr.takeError();
  ArrayRef<uint8_t> Content = *ContentOrErr;
  if (!Content.empty())
    S->Content = yaml::BinaryRef(Content);
} else {
  S->Size = static_cast<llvm::yaml::Hex64>(Shdr->sh_size);
}

if (Shdr->sh_info)
  S->Info = static_cast<llvm::yaml::Hex64>(Shdr->sh_info);
return S.release();
1181}

1183template <class ELFT>
1184Expected<ELFYAML::SymtabShndxSection *>
1185ELFDumper<ELFT>::dumpSymtabShndxSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::SymtabShndxSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto EntriesOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(*Shdr);
if (!EntriesOrErr)
  return EntriesOrErr.takeError();

S->Entries.emplace();
for (const Elf_Word &E : *EntriesOrErr)
  S->Entries->push_back(E);
return S.release();
1198}

1200template <class ELFT>
1201Expected<ELFYAML::NoBitsSection *>
1202ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::NoBitsSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);
if (Shdr->sh_size)
  S->Size = static_cast<llvm::yaml::Hex64>(Shdr->sh_size);
return S.release();
1209}

1211template <class ELFT>
1212Expected<ELFYAML::NoteSection *>
1213ELFDumper<ELFT>::dumpNoteSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::NoteSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

std::vector<ELFYAML::NoteEntry> Entries;
ArrayRef<uint8_t> Content = *ContentOrErr;
while (!Content.empty()) {
  if (Content.size() < sizeof(Elf_Nhdr)) {
    S->Content = yaml::BinaryRef(*ContentOrErr);
    return S.release();
  }

  const Elf_Nhdr *Header = reinterpret_cast<const Elf_Nhdr *>(Content.data());
  if (Content.size() < Header->getSize()) {
    S->Content = yaml::BinaryRef(*ContentOrErr);
    return S.release();
  }

  Elf_Note Note(*Header);
  Entries.push_back(
      {Note.getName(), Note.getDesc(), (ELFYAML::ELF_NT)Note.getType()});

  Content = Content.drop_front(Header->getSize());
}

S->Notes = std::move(Entries);
return S.release();
1245}

1247template <class ELFT>
1248Expected<ELFYAML::HashSection *>
1249ELFDumper<ELFT>::dumpHashSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::HashSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

ArrayRef<uint8_t> Content = *ContentOrErr;
if (Content.size() % 4 != 0 || Content.size() < 8) {
  S->Content = yaml::BinaryRef(Content);
  return S.release();
}

DataExtractor::Cursor Cur(0);
DataExtractor Data(Content, Obj.isLE(), /*AddressSize=*/0);
uint64_t NBucket = Data.getU32(Cur);
uint64_t NChain = Data.getU32(Cur);
if (Content.size() != (2 + NBucket + NChain) * 4) {
  S->Content = yaml::BinaryRef(Content);
  if (Cur)
    return S.release();
  llvm_unreachable("entries were not read correctly")::llvm::llvm_unreachable_internal("entries were not read correctly"
, "llvm/tools/obj2yaml/elf2yaml.cpp", 1272);
}

S->Bucket.emplace(NBucket);
for (uint32_t &V : *S->Bucket)
  V = Data.getU32(Cur);

S->Chain.emplace(NChain);
for (uint32_t &V : *S->Chain)
  V = Data.getU32(Cur);

if (Cur)
  return S.release();
llvm_unreachable("entries were not read correctly")::llvm::llvm_unreachable_internal("entries were not read correctly"
, "llvm/tools/obj2yaml/elf2yaml.cpp", 1285);
1286}

1288template <class ELFT>
1289Expected<ELFYAML::GnuHashSection *>
1290ELFDumper<ELFT>::dumpGnuHashSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::GnuHashSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

unsigned AddrSize = ELFT::Is64Bits ? 8 : 4;
ArrayRef<uint8_t> Content = *ContentOrErr;
DataExtractor Data(Content, Obj.isLE(), AddrSize);

ELFYAML::GnuHashHeader Header;
DataExtractor::Cursor Cur(0);
uint64_t NBuckets = Data.getU32(Cur);
Header.SymNdx = Data.getU32(Cur);
uint64_t MaskWords = Data.getU32(Cur);
Header.Shift2 = Data.getU32(Cur);

// Set just the raw binary content if we were unable to read the header
// or when the section data is truncated or malformed.
uint64_t Size = Data.getData().size() - Cur.tell();
if (!Cur || (Size < MaskWords * AddrSize + NBuckets * 4) ||
    (Size % 4 != 0)) {
  consumeError(Cur.takeError());
  S->Content = yaml::BinaryRef(Content);
  return S.release();
}

S->Header = Header;

S->BloomFilter.emplace(MaskWords);
for (llvm::yaml::Hex64 &Val : *S->BloomFilter)
  Val = Data.getAddress(Cur);

S->HashBuckets.emplace(NBuckets);
for (llvm::yaml::Hex32 &Val : *S->HashBuckets)
  Val = Data.getU32(Cur);

S->HashValues.emplace((Data.getData().size() - Cur.tell()) / 4);
for (llvm::yaml::Hex32 &Val : *S->HashValues)
  Val = Data.getU32(Cur);

if (Cur)
  return S.release();
llvm_unreachable("GnuHashSection was not read correctly")::llvm::llvm_unreachable_internal("GnuHashSection was not read correctly"
, "llvm/tools/obj2yaml/elf2yaml.cpp", 1336);
1337}

1339template <class ELFT>
1340Expected<ELFYAML::VerdefSection *>
1341ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::VerdefSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
if (!StringTableShdrOrErr)
  return StringTableShdrOrErr.takeError();

auto StringTableOrErr = Obj.getStringTable(**StringTableShdrOrErr);
if (!StringTableOrErr)
  return StringTableOrErr.takeError();

auto Contents = Obj.getSectionContents(*Shdr);
if (!Contents)
  return Contents.takeError();

S->Entries.emplace();

llvm::ArrayRef<uint8_t> Data = *Contents;
const uint8_t *Buf = Data.data();
while (Buf) {
  const Elf_Verdef *Verdef = reinterpret_cast<const Elf_Verdef *>(Buf);
  ELFYAML::VerdefEntry Entry;
  if (Verdef->vd_version != 1)
    return createStringError(errc::invalid_argument,
                             "invalid SHT_GNU_verdef section version: " +
                                 Twine(Verdef->vd_version));

  if (Verdef->vd_flags != 0)
    Entry.Flags = Verdef->vd_flags;

  if (Verdef->vd_ndx != 0)
    Entry.VersionNdx = Verdef->vd_ndx;

  if (Verdef->vd_hash != 0)
    Entry.Hash = Verdef->vd_hash;

  const uint8_t *BufAux = Buf + Verdef->vd_aux;
  while (BufAux) {
    const Elf_Verdaux *Verdaux =
        reinterpret_cast<const Elf_Verdaux *>(BufAux);
    Entry.VerNames.push_back(
        StringTableOrErr->drop_front(Verdaux->vda_name).data());
    BufAux = Verdaux->vda_next ? BufAux + Verdaux->vda_next : nullptr;
  }

  S->Entries->push_back(Entry);
  Buf = Verdef->vd_next ? Buf + Verdef->vd_next : nullptr;
}

if (Shdr->sh_info != S->Entries->size())
  S->Info = (llvm::yaml::Hex64)Shdr->sh_info;

return S.release();
1396}

1398template <class ELFT>
1399Expected<ELFYAML::SymverSection *>
1400ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::SymverSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(*Shdr);
if (!VersionsOrErr)
  return VersionsOrErr.takeError();

S->Entries.emplace();
for (const Elf_Half &E : *VersionsOrErr)
  S->Entries->push_back(E);

return S.release();
1414}

1416template <class ELFT>
1417Expected<ELFYAML::VerneedSection *>
1418ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::VerneedSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto Contents = Obj.getSectionContents(*Shdr);
if (!Contents)
  return Contents.takeError();

auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
if (!StringTableShdrOrErr)
  return StringTableShdrOrErr.takeError();

auto StringTableOrErr = Obj.getStringTable(**StringTableShdrOrErr);
if (!StringTableOrErr)
  return StringTableOrErr.takeError();

S->VerneedV.emplace();

llvm::ArrayRef<uint8_t> Data = *Contents;
const uint8_t *Buf = Data.data();
while (Buf) {
  const Elf_Verneed *Verneed = reinterpret_cast<const Elf_Verneed *>(Buf);

  ELFYAML::VerneedEntry Entry;
  Entry.Version = Verneed->vn_version;
  Entry.File =
      StringRef(StringTableOrErr->drop_front(Verneed->vn_file).data());

  const uint8_t *BufAux = Buf + Verneed->vn_aux;
  while (BufAux) {
    const Elf_Vernaux *Vernaux =
        reinterpret_cast<const Elf_Vernaux *>(BufAux);

    ELFYAML::VernauxEntry Aux;
    Aux.Hash = Vernaux->vna_hash;
    Aux.Flags = Vernaux->vna_flags;
    Aux.Other = Vernaux->vna_other;
    Aux.Name =
        StringRef(StringTableOrErr->drop_front(Vernaux->vna_name).data());

    Entry.AuxV.push_back(Aux);
    BufAux = Vernaux->vna_next ? BufAux + Vernaux->vna_next : nullptr;
  }

  S->VerneedV->push_back(Entry);
  Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr;
}

if (Shdr->sh_info != S->VerneedV->size())
  S->Info = (llvm::yaml::Hex64)Shdr->sh_info;

return S.release();
1471}

1473template <class ELFT>
1474Expected<StringRef> ELFDumper<ELFT>::getSymbolName(uint32_t SymtabNdx,
                                                 uint32_t SymbolNdx) {
auto SymtabOrErr = Obj.getSection(SymtabNdx);
if (!SymtabOrErr)
  return SymtabOrErr.takeError();

const Elf_Shdr *Symtab = *SymtabOrErr;
auto SymOrErr = Obj.getSymbol(Symtab, SymbolNdx);
if (!SymOrErr)
  return SymOrErr.takeError();

auto StrTabOrErr = Obj.getStringTableForSymtab(*Symtab);
if (!StrTabOrErr)
  return StrTabOrErr.takeError();
return getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
1489}

1491template <class ELFT>
1492Expected<ELFYAML::GroupSection *>
1493ELFDumper<ELFT>::dumpGroupSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::GroupSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

// Get symbol with index sh_info. This symbol's name is the signature of the group.
Expected<StringRef> SymbolName = getSymbolName(Shdr->sh_link, Shdr->sh_info);
if (!SymbolName)
  return SymbolName.takeError();
S->Signature = *SymbolName;

auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(*Shdr);
if (!MembersOrErr)
  return MembersOrErr.takeError();

S->Members.emplace();
for (Elf_Word Member : *MembersOrErr) {
  if (Member == llvm::ELF::GRP_COMDAT) {
    S->Members->push_back({"GRP_COMDAT"});
    continue;
  }

  Expected<const Elf_Shdr *> SHdrOrErr = Obj.getSection(Member);
  if (!SHdrOrErr)
    return SHdrOrErr.takeError();
  Expected<StringRef> NameOrErr = getUniquedSectionName(**SHdrOrErr);
  if (!NameOrErr)
    return NameOrErr.takeError();
  S->Members->push_back({*NameOrErr});
}
return S.release();
1524}

1526template <class ELFT>
1527Expected<ELFYAML::ARMIndexTableSection *>
1528ELFDumper<ELFT>::dumpARMIndexTableSection(const Elf_Shdr *Shdr) {
auto S = std::make_unique<ELFYAML::ARMIndexTableSection>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

if (ContentOrErr->size() % (sizeof(Elf_Word) * 2) != 0) {
  S->Content = yaml::BinaryRef(*ContentOrErr);
  return S.release();
}

ArrayRef<Elf_Word> Words(
    reinterpret_cast<const Elf_Word *>(ContentOrErr->data()),
    ContentOrErr->size() / sizeof(Elf_Word));

S->Entries.emplace();
for (size_t I = 0, E = Words.size(); I != E; I += 2)
  S->Entries->push_back({(yaml::Hex32)Words[I], (yaml::Hex32)Words[I + 1]});

return S.release();
1551}

1553template <class ELFT>
1554Expected<ELFYAML::MipsABIFlags *>
1555ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
assert(Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS &&(static_cast <bool> (Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS
 && "Section type is not SHT_MIPS_ABIFLAGS") ? void (
0) : __assert_fail ("Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS && \"Section type is not SHT_MIPS_ABIFLAGS\""
, "llvm/tools/obj2yaml/elf2yaml.cpp", 1557, __extension__ __PRETTY_FUNCTION__
))
       "Section type is not SHT_MIPS_ABIFLAGS")(static_cast <bool> (Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS
 && "Section type is not SHT_MIPS_ABIFLAGS") ? void (
0) : __assert_fail ("Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS && \"Section type is not SHT_MIPS_ABIFLAGS\""
, "llvm/tools/obj2yaml/elf2yaml.cpp", 1557, __extension__ __PRETTY_FUNCTION__
));
auto S = std::make_unique<ELFYAML::MipsABIFlags>();
if (Error E = dumpCommonSection(Shdr, *S))
  return std::move(E);

auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
  return ContentOrErr.takeError();

auto *Flags = reinterpret_cast<const object::Elf_Mips_ABIFlags<ELFT> *>(
    ContentOrErr.get().data());
S->Version = Flags->version;
S->ISALevel = Flags->isa_level;
S->ISARevision = Flags->isa_rev;
S->GPRSize = Flags->gpr_size;
S->CPR1Size = Flags->cpr1_size;
S->CPR2Size = Flags->cpr2_size;
S->FpABI = Flags->fp_abi;
S->ISAExtension = Flags->isa_ext;
S->ASEs = Flags->ases;
S->Flags1 = Flags->flags1;
S->Flags2 = Flags->flags2;
return S.release();
1580}

1582template <class ELFT>
1583static Error elf2yaml(raw_ostream &Out, const object::ELFFile<ELFT> &Obj,
                    std::unique_ptr<DWARFContext> DWARFCtx) {
ELFDumper<ELFT> Dumper(Obj, std::move(DWARFCtx));
Expected<ELFYAML::Object *> YAMLOrErr = Dumper.dump();
if (!YAMLOrErr)
  return YAMLOrErr.takeError();

std::unique_ptr<ELFYAML::Object> YAML(YAMLOrErr.get());
yaml::Output Yout(Out);
Yout << *YAML;

return Error::success();
1595}

1597Error elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) {
std::unique_ptr<DWARFContext> DWARFCtx = DWARFContext::create(Obj);
if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(&Obj))
  return elf2yaml(Out, ELFObj->getELFFile(), std::move(DWARFCtx));

if (const auto *ELFObj = dyn_cast<object::ELF32BEObjectFile>(&Obj))
  return elf2yaml(Out, ELFObj->getELFFile(), std::move(DWARFCtx));

if (const auto *ELFObj = dyn_cast<object::ELF64LEObjectFile>(&Obj))
  return elf2yaml(Out, ELFObj->getELFFile(), std::move(DWARFCtx));

if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(&Obj))
  return elf2yaml(Out, ELFObj->getELFFile(), std::move(DWARFCtx));

llvm_unreachable("unknown ELF file format")::llvm::llvm_unreachable_internal("unknown ELF file format", "llvm/tools/obj2yaml/elf2yaml.cpp"
, 1611);
1612}

←

/build/source/llvm/include/llvm/ObjectYAML/ELFYAML.h

1//===- ELFYAML.h - ELF YAMLIO implementation --------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8///
9/// \file
10/// This file declares classes for handling the YAML representation
11/// of ELF.
12///
13//===----------------------------------------------------------------------===//
14 
15#ifndef LLVM_OBJECTYAML_ELFYAML_H
16#define LLVM_OBJECTYAML_ELFYAML_H
17 
18#include "llvm/ADT/StringRef.h"
19#include "llvm/BinaryFormat/ELF.h"
20#include "llvm/Object/ELFTypes.h"
21#include "llvm/ObjectYAML/DWARFYAML.h"
22#include "llvm/ObjectYAML/YAML.h"
23#include "llvm/Support/YAMLTraits.h"
24#include <cstdint>
25#include <memory>
26#include <optional>
27#include <vector>
28 
29namespace llvm {
30namespace ELFYAML {
31 
32StringRef dropUniqueSuffix(StringRef S);
33std::string appendUniqueSuffix(StringRef Name, const Twine& Msg);
34 
35// These types are invariant across 32/64-bit ELF, so for simplicity just
36// directly give them their exact sizes. We don't need to worry about
37// endianness because these are just the types in the YAMLIO structures,
38// and are appropriately converted to the necessary endianness when
39// reading/generating binary object files.
40// The naming of these types is intended to be ELF_PREFIX, where PREFIX is
41// the common prefix of the respective constants. E.g. ELF_EM corresponds
42// to the `e_machine` constants, like `EM_X86_64`.
43// In the future, these would probably be better suited by C++11 enum
44// class's with appropriate fixed underlying type.
45LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_ET)struct ELF_ET { ELF_ET() = default; ELF_ET(const uint16_t v) :
 value(v) {} ELF_ET(const ELF_ET &v) = default; ELF_ET &
operator=(const ELF_ET &rhs) = default; ELF_ET &operator
=(const uint16_t &rhs) { value = rhs; return *this; } operator
 const uint16_t & () const { return value; } bool operator
==(const ELF_ET &rhs) const { return value == rhs.value; }
 bool operator==(const uint16_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_ET &rhs) const { return
 value < rhs.value; } uint16_t value; using BaseType = uint16_t
; };
46LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PT)struct ELF_PT { ELF_PT() = default; ELF_PT(const uint32_t v) :
 value(v) {} ELF_PT(const ELF_PT &v) = default; ELF_PT &
operator=(const ELF_PT &rhs) = default; ELF_PT &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_PT &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_PT &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
47LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_EM)struct ELF_EM { ELF_EM() = default; ELF_EM(const uint32_t v) :
 value(v) {} ELF_EM(const ELF_EM &v) = default; ELF_EM &
operator=(const ELF_EM &rhs) = default; ELF_EM &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_EM &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_EM &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
48LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFCLASS)struct ELF_ELFCLASS { ELF_ELFCLASS() = default; ELF_ELFCLASS(
const uint8_t v) : value(v) {} ELF_ELFCLASS(const ELF_ELFCLASS
 &v) = default; ELF_ELFCLASS &operator=(const ELF_ELFCLASS
 &rhs) = default; ELF_ELFCLASS &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const ELF_ELFCLASS
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const ELF_ELFCLASS &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
49LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFDATA)struct ELF_ELFDATA { ELF_ELFDATA() = default; ELF_ELFDATA(const
 uint8_t v) : value(v) {} ELF_ELFDATA(const ELF_ELFDATA &
v) = default; ELF_ELFDATA &operator=(const ELF_ELFDATA &
rhs) = default; ELF_ELFDATA &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
 () const { return value; } bool operator==(const ELF_ELFDATA
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const ELF_ELFDATA &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
50LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_ELFOSABI)struct ELF_ELFOSABI { ELF_ELFOSABI() = default; ELF_ELFOSABI(
const uint8_t v) : value(v) {} ELF_ELFOSABI(const ELF_ELFOSABI
 &v) = default; ELF_ELFOSABI &operator=(const ELF_ELFOSABI
 &rhs) = default; ELF_ELFOSABI &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const ELF_ELFOSABI
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const ELF_ELFOSABI &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
51// Just use 64, since it can hold 32-bit values too.
52LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_EF)struct ELF_EF { ELF_EF() = default; ELF_EF(const uint64_t v) :
 value(v) {} ELF_EF(const ELF_EF &v) = default; ELF_EF &
operator=(const ELF_EF &rhs) = default; ELF_EF &operator
=(const uint64_t &rhs) { value = rhs; return *this; } operator
 const uint64_t & () const { return value; } bool operator
==(const ELF_EF &rhs) const { return value == rhs.value; }
 bool operator==(const uint64_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_EF &rhs) const { return
 value < rhs.value; } uint64_t value; using BaseType = uint64_t
; };
53// Just use 64, since it can hold 32-bit values too.
54LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_DYNTAG)struct ELF_DYNTAG { ELF_DYNTAG() = default; ELF_DYNTAG(const uint64_t
 v) : value(v) {} ELF_DYNTAG(const ELF_DYNTAG &v) = default
; ELF_DYNTAG &operator=(const ELF_DYNTAG &rhs) = default
; ELF_DYNTAG &operator=(const uint64_t &rhs) { value =
 rhs; return *this; } operator const uint64_t & () const {
 return value; } bool operator==(const ELF_DYNTAG &rhs) const
 { return value == rhs.value; } bool operator==(const uint64_t
 &rhs) const { return value == rhs; } bool operator<(const
 ELF_DYNTAG &rhs) const { return value < rhs.value; } uint64_t
 value; using BaseType = uint64_t; };
55LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_PF)struct ELF_PF { ELF_PF() = default; ELF_PF(const uint32_t v) :
 value(v) {} ELF_PF(const ELF_PF &v) = default; ELF_PF &
operator=(const ELF_PF &rhs) = default; ELF_PF &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_PF &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_PF &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
56LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_SHT)struct ELF_SHT { ELF_SHT() = default; ELF_SHT(const uint32_t v
) : value(v) {} ELF_SHT(const ELF_SHT &v) = default; ELF_SHT
 &operator=(const ELF_SHT &rhs) = default; ELF_SHT &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
 operator==(const ELF_SHT &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_SHT &rhs) const
 { return value < rhs.value; } uint32_t value; using BaseType
 = uint32_t; };
57LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_REL)struct ELF_REL { ELF_REL() = default; ELF_REL(const uint32_t v
) : value(v) {} ELF_REL(const ELF_REL &v) = default; ELF_REL
 &operator=(const ELF_REL &rhs) = default; ELF_REL &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
 operator==(const ELF_REL &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_REL &rhs) const
 { return value < rhs.value; } uint32_t value; using BaseType
 = uint32_t; };
58LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_RSS)struct ELF_RSS { ELF_RSS() = default; ELF_RSS(const uint8_t v
) : value(v) {} ELF_RSS(const ELF_RSS &v) = default; ELF_RSS
 &operator=(const ELF_RSS &rhs) = default; ELF_RSS &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
 operator==(const ELF_RSS &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_RSS &rhs) const
 { return value < rhs.value; } uint8_t value; using BaseType
 = uint8_t; };
59// Just use 64, since it can hold 32-bit values too.
60LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)struct ELF_SHF { ELF_SHF() = default; ELF_SHF(const uint64_t v
) : value(v) {} ELF_SHF(const ELF_SHF &v) = default; ELF_SHF
 &operator=(const ELF_SHF &rhs) = default; ELF_SHF &
operator=(const uint64_t &rhs) { value = rhs; return *this
; } operator const uint64_t & () const { return value; } bool
 operator==(const ELF_SHF &rhs) const { return value == rhs
.value; } bool operator==(const uint64_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_SHF &rhs) const
 { return value < rhs.value; } uint64_t value; using BaseType
 = uint64_t; };
61LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)struct ELF_SHN { ELF_SHN() = default; ELF_SHN(const uint16_t v
) : value(v) {} ELF_SHN(const ELF_SHN &v) = default; ELF_SHN
 &operator=(const ELF_SHN &rhs) = default; ELF_SHN &
operator=(const uint16_t &rhs) { value = rhs; return *this
; } operator const uint16_t & () const { return value; } bool
 operator==(const ELF_SHN &rhs) const { return value == rhs
.value; } bool operator==(const uint16_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_SHN &rhs) const
 { return value < rhs.value; } uint16_t value; using BaseType
 = uint16_t; };
62LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)struct ELF_STB { ELF_STB() = default; ELF_STB(const uint8_t v
) : value(v) {} ELF_STB(const ELF_STB &v) = default; ELF_STB
 &operator=(const ELF_STB &rhs) = default; ELF_STB &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
 operator==(const ELF_STB &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_STB &rhs) const
 { return value < rhs.value; } uint8_t value; using BaseType
 = uint8_t; };
63LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)struct ELF_STT { ELF_STT() = default; ELF_STT(const uint8_t v
) : value(v) {} ELF_STT(const ELF_STT &v) = default; ELF_STT
 &operator=(const ELF_STT &rhs) = default; ELF_STT &
operator=(const uint8_t &rhs) { value = rhs; return *this
; } operator const uint8_t & () const { return value; } bool
 operator==(const ELF_STT &rhs) const { return value == rhs
.value; } bool operator==(const uint8_t &rhs) const { return
 value == rhs; } bool operator<(const ELF_STT &rhs) const
 { return value < rhs.value; } uint8_t value; using BaseType
 = uint8_t; };
64LLVM_YAML_STRONG_TYPEDEF(uint32_t, ELF_NT)struct ELF_NT { ELF_NT() = default; ELF_NT(const uint32_t v) :
 value(v) {} ELF_NT(const ELF_NT &v) = default; ELF_NT &
operator=(const ELF_NT &rhs) = default; ELF_NT &operator
=(const uint32_t &rhs) { value = rhs; return *this; } operator
 const uint32_t & () const { return value; } bool operator
==(const ELF_NT &rhs) const { return value == rhs.value; }
 bool operator==(const uint32_t &rhs) const { return value
 == rhs; } bool operator<(const ELF_NT &rhs) const { return
 value < rhs.value; } uint32_t value; using BaseType = uint32_t
; };
65 
66LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)struct MIPS_AFL_REG { MIPS_AFL_REG() = default; MIPS_AFL_REG(
const uint8_t v) : value(v) {} MIPS_AFL_REG(const MIPS_AFL_REG
 &v) = default; MIPS_AFL_REG &operator=(const MIPS_AFL_REG
 &rhs) = default; MIPS_AFL_REG &operator=(const uint8_t
 &rhs) { value = rhs; return *this; } operator const uint8_t
 & () const { return value; } bool operator==(const MIPS_AFL_REG
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_REG &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
67LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)struct MIPS_ABI_FP { MIPS_ABI_FP() = default; MIPS_ABI_FP(const
 uint8_t v) : value(v) {} MIPS_ABI_FP(const MIPS_ABI_FP &
v) = default; MIPS_ABI_FP &operator=(const MIPS_ABI_FP &
rhs) = default; MIPS_ABI_FP &operator=(const uint8_t &
rhs) { value = rhs; return *this; } operator const uint8_t &
 () const { return value; } bool operator==(const MIPS_ABI_FP
 &rhs) const { return value == rhs.value; } bool operator
==(const uint8_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_ABI_FP &rhs) const { return value
 < rhs.value; } uint8_t value; using BaseType = uint8_t; }
;
68LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)struct MIPS_AFL_EXT { MIPS_AFL_EXT() = default; MIPS_AFL_EXT(
const uint32_t v) : value(v) {} MIPS_AFL_EXT(const MIPS_AFL_EXT
 &v) = default; MIPS_AFL_EXT &operator=(const MIPS_AFL_EXT
 &rhs) = default; MIPS_AFL_EXT &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_EXT
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_EXT &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
69LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)struct MIPS_AFL_ASE { MIPS_AFL_ASE() = default; MIPS_AFL_ASE(
const uint32_t v) : value(v) {} MIPS_AFL_ASE(const MIPS_AFL_ASE
 &v) = default; MIPS_AFL_ASE &operator=(const MIPS_AFL_ASE
 &rhs) = default; MIPS_AFL_ASE &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_ASE
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_ASE &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
70LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)struct MIPS_AFL_FLAGS1 { MIPS_AFL_FLAGS1() = default; MIPS_AFL_FLAGS1
(const uint32_t v) : value(v) {} MIPS_AFL_FLAGS1(const MIPS_AFL_FLAGS1
 &v) = default; MIPS_AFL_FLAGS1 &operator=(const MIPS_AFL_FLAGS1
 &rhs) = default; MIPS_AFL_FLAGS1 &operator=(const uint32_t
 &rhs) { value = rhs; return *this; } operator const uint32_t
 & () const { return value; } bool operator==(const MIPS_AFL_FLAGS1
 &rhs) const { return value == rhs.value; } bool operator
==(const uint32_t &rhs) const { return value == rhs; } bool
 operator<(const MIPS_AFL_FLAGS1 &rhs) const { return value
 < rhs.value; } uint32_t value; using BaseType = uint32_t;
 };
71LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_ISA)struct MIPS_ISA { MIPS_ISA() = default; MIPS_ISA(const uint32_t
 v) : value(v) {} MIPS_ISA(const MIPS_ISA &v) = default; MIPS_ISA
 &operator=(const MIPS_ISA &rhs) = default; MIPS_ISA &
operator=(const uint32_t &rhs) { value = rhs; return *this
; } operator const uint32_t & () const { return value; } bool
 operator==(const MIPS_ISA &rhs) const { return value == rhs
.value; } bool operator==(const uint32_t &rhs) const { return
 value == rhs; } bool operator<(const MIPS_ISA &rhs) const
 { return value < rhs.value; } uint32_t value; using BaseType
 = uint32_t; };
72 
73LLVM_YAML_STRONG_TYPEDEF(StringRef, YAMLFlowString)struct YAMLFlowString { YAMLFlowString() = default; YAMLFlowString
(const StringRef v) : value(v) {} YAMLFlowString(const YAMLFlowString
 &v) = default; YAMLFlowString &operator=(const YAMLFlowString
 &rhs) = default; YAMLFlowString &operator=(const StringRef
 &rhs) { value = rhs; return *this; } operator const StringRef
 & () const { return value; } bool operator==(const YAMLFlowString
 &rhs) const { return value == rhs.value; } bool operator
==(const StringRef &rhs) const { return value == rhs; } bool
 operator<(const YAMLFlowString &rhs) const { return value
 < rhs.value; } StringRef value; using BaseType = StringRef
; };
74LLVM_YAML_STRONG_TYPEDEF(int64_t, YAMLIntUInt)struct YAMLIntUInt { YAMLIntUInt() = default; YAMLIntUInt(const
 int64_t v) : value(v) {} YAMLIntUInt(const YAMLIntUInt &
v) = default; YAMLIntUInt &operator=(const YAMLIntUInt &
rhs) = default; YAMLIntUInt &operator=(const int64_t &
rhs) { value = rhs; return *this; } operator const int64_t &
 () const { return value; } bool operator==(const YAMLIntUInt
 &rhs) const { return value == rhs.value; } bool operator
==(const int64_t &rhs) const { return value == rhs; } bool
 operator<(const YAMLIntUInt &rhs) const { return value
 < rhs.value; } int64_t value; using BaseType = int64_t; }
;
75 
76template <class ELFT>
77unsigned getDefaultShEntSize(unsigned EMachine, ELF_SHT SecType,
78                             StringRef SecName) {
79  if (EMachine == ELF::EM_MIPS && SecType == ELF::SHT_MIPS_ABIFLAGS)
6
←
Assuming 'EMachine' is not equal to EM_MIPS→
7
←
Taking false branch→
80    return sizeof(object::Elf_Mips_ABIFlags<ELFT>);
81 
82  switch (SecType) {
8
←
Control jumps to the 'default' case at line 104→
83  case ELF::SHT_SYMTAB:
84  case ELF::SHT_DYNSYM:
85    return sizeof(typename ELFT::Sym);
86  case ELF::SHT_GROUP:
87    return sizeof(typename ELFT::Word);
88  case ELF::SHT_REL:
89    return sizeof(typename ELFT::Rel);
90  case ELF::SHT_RELA:
91    return sizeof(typename ELFT::Rela);
92  case ELF::SHT_RELR:
93    return sizeof(typename ELFT::Relr);
94  case ELF::SHT_DYNAMIC:
95    return sizeof(typename ELFT::Dyn);
96  case ELF::SHT_HASH:
97    return sizeof(typename ELFT::Word);
98  case ELF::SHT_SYMTAB_SHNDX:
99    return sizeof(typename ELFT::Word);
100  case ELF::SHT_GNU_versym:
101    return sizeof(typename ELFT::Half);
102  case ELF::SHT_LLVM_CALL_GRAPH_PROFILE:
103    return sizeof(object::Elf_CGProfile_Impl<ELFT>);
104  default:
105    if (SecName == ".debug_str")
9
←
Assuming the condition is false→
10
←
Taking false branch→
106      return 1;
107    return 0;
11
←
Returning zero→
108  }
109}
110 
111// For now, hardcode 64 bits everywhere that 32 or 64 would be needed
112// since 64-bit can hold 32-bit values too.
113struct FileHeader {
114  ELF_ELFCLASS Class;
115  ELF_ELFDATA Data;
116  ELF_ELFOSABI OSABI;
117  llvm::yaml::Hex8 ABIVersion;
118  ELF_ET Type;
119  std::optional<ELF_EM> Machine;
120  ELF_EF Flags;
121  llvm::yaml::Hex64 Entry;
122  std::optional<StringRef> SectionHeaderStringTable;
123 
124  std::optional<llvm::yaml::Hex64> EPhOff;
125  std::optional<llvm::yaml::Hex16> EPhEntSize;
126  std::optional<llvm::yaml::Hex16> EPhNum;
127  std::optional<llvm::yaml::Hex16> EShEntSize;
128  std::optional<llvm::yaml::Hex64> EShOff;
129  std::optional<llvm::yaml::Hex16> EShNum;
130  std::optional<llvm::yaml::Hex16> EShStrNdx;
131};
132 
133struct SectionHeader {
134  StringRef Name;
135};
136 
137struct Symbol {
138  StringRef Name;
139  ELF_STT Type;
140  std::optional<StringRef> Section;
141  std::optional<ELF_SHN> Index;
142  ELF_STB Binding;
143  std::optional<llvm::yaml::Hex64> Value;
144  std::optional<llvm::yaml::Hex64> Size;
145  std::optional<uint8_t> Other;
146 
147  std::optional<uint32_t> StName;
148};
149 
150struct SectionOrType {
151  StringRef sectionNameOrType;
152};
153 
154struct DynamicEntry {
155  ELF_DYNTAG Tag;
156  llvm::yaml::Hex64 Val;
157};
158 
159struct BBAddrMapEntry {
160  struct BBEntry {
161    uint32_t ID;
162    llvm::yaml::Hex64 AddressOffset;
163    llvm::yaml::Hex64 Size;
164    llvm::yaml::Hex64 Metadata;
165  };
166  uint8_t Version;
167  llvm::yaml::Hex8 Feature;
168  llvm::yaml::Hex64 Address;
169  std::optional<uint64_t> NumBlocks;
170  std::optional<std::vector<BBEntry>> BBEntries;
171};
172 
173struct StackSizeEntry {
174  llvm::yaml::Hex64 Address;
175  llvm::yaml::Hex64 Size;
176};
177 
178struct NoteEntry {
179  StringRef Name;
180  yaml::BinaryRef Desc;
181  ELF_NT Type;
182};
183 
184struct Chunk {
185  enum class ChunkKind {
186    Dynamic,
187    Group,
188    RawContent,
189    Relocation,
190    Relr,
191    NoBits,
192    Note,
193    Hash,
194    GnuHash,
195    Verdef,
196    Verneed,
197    StackSizes,
198    SymtabShndxSection,
199    Symver,
200    ARMIndexTable,
201    MipsABIFlags,
202    Addrsig,
203    LinkerOptions,
204    DependentLibraries,
205    CallGraphProfile,
206    BBAddrMap,
207 
208    // Special chunks.
209    SpecialChunksStart,
210    Fill = SpecialChunksStart,
211    SectionHeaderTable,
212  };
213 
214  ChunkKind Kind;
215  StringRef Name;
216  std::optional<llvm::yaml::Hex64> Offset;
217 
218  // Usually chunks are not created implicitly, but rather loaded from YAML.
219  // This flag is used to signal whether this is the case or not.
220  bool IsImplicit;
221 
222  Chunk(ChunkKind K, bool Implicit) : Kind(K), IsImplicit(Implicit) {}
223  virtual ~Chunk();
224};
225 
226struct Section : public Chunk {
227  ELF_SHT Type;
228  std::optional<ELF_SHF> Flags;
229  std::optional<llvm::yaml::Hex64> Address;
230  std::optional<StringRef> Link;
231  llvm::yaml::Hex64 AddressAlign;
232  std::optional<llvm::yaml::Hex64> EntSize;
233 
234  std::optional<yaml::BinaryRef> Content;
235  std::optional<llvm::yaml::Hex64> Size;
236 
237  // Holds the original section index.
238  unsigned OriginalSecNdx;
239 
240  Section(ChunkKind Kind, bool IsImplicit = false) : Chunk(Kind, IsImplicit) {}
241 
242  static bool classof(const Chunk *S) {
243    return S->Kind < ChunkKind::SpecialChunksStart;
244  }
245 
246  // Some derived sections might have their own special entries. This method
247  // returns a vector of <entry name, is used> pairs. It is used for section
248  // validation.
249  virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
250    return {};
251  };
252 
253  // The following members are used to override section fields which is
254  // useful for creating invalid objects.
255 
256  // This can be used to override the sh_addralign field.
257  std::optional<llvm::yaml::Hex64> ShAddrAlign;
258 
259  // This can be used to override the offset stored in the sh_name field.
260  // It does not affect the name stored in the string table.
261  std::optional<llvm::yaml::Hex64> ShName;
262 
263  // This can be used to override the sh_offset field. It does not place the
264  // section data at the offset specified.
265  std::optional<llvm::yaml::Hex64> ShOffset;
266 
267  // This can be used to override the sh_size field. It does not affect the
268  // content written.
269  std::optional<llvm::yaml::Hex64> ShSize;
270 
271  // This can be used to override the sh_flags field.
272  std::optional<llvm::yaml::Hex64> ShFlags;
273 
274  // This can be used to override the sh_type field. It is useful when we
275  // want to use specific YAML keys for a section of a particular type to
276  // describe the content, but still want to have a different final type
277  // for the section.
278  std::optional<ELF_SHT> ShType;
279};
280 
281// Fill is a block of data which is placed outside of sections. It is
282// not present in the sections header table, but it might affect the output file
283// size and program headers produced.
284struct Fill : Chunk {
285  std::optional<yaml::BinaryRef> Pattern;
286  llvm::yaml::Hex64 Size;
287 
288  Fill() : Chunk(ChunkKind::Fill, /*Implicit=*/false) {}
289 
290  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
291};
292 
293struct SectionHeaderTable : Chunk {
294  SectionHeaderTable(bool IsImplicit)
295      : Chunk(ChunkKind::SectionHeaderTable, IsImplicit) {}
296 
297  static bool classof(const Chunk *S) {
298    return S->Kind == ChunkKind::SectionHeaderTable;
299  }
300 
301  std::optional<std::vector<SectionHeader>> Sections;
302  std::optional<std::vector<SectionHeader>> Excluded;
303  std::optional<bool> NoHeaders;
304 
305  size_t getNumHeaders(size_t SectionsNum) const {
306    if (IsImplicit || isDefault())
307      return SectionsNum;
308    if (NoHeaders)
309      return (*NoHeaders) ? 0 : SectionsNum;
310    return (Sections ? Sections->size() : 0) + /*Null section*/ 1;
311  }
312 
313  bool isDefault() const { return !Sections && !Excluded && !NoHeaders; }
314 
315  static constexpr StringRef TypeStr = "SectionHeaderTable";
316};
317 
318struct BBAddrMapSection : Section {
319  std::optional<std::vector<BBAddrMapEntry>> Entries;
320 
321  BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
322 
323  std::vector<std::pair<StringRef, bool>> getEntries() const override {
324    return {{"Entries", Entries.has_value()}};
325  };
326 
327  static bool classof(const Chunk *S) {
328    return S->Kind == ChunkKind::BBAddrMap;
329  }
330};
331 
332struct StackSizesSection : Section {
333  std::optional<std::vector<StackSizeEntry>> Entries;
334 
335  StackSizesSection() : Section(ChunkKind::StackSizes) {}
336 
337  std::vector<std::pair<StringRef, bool>> getEntries() const override {
338    return {{"Entries", Entries.has_value()}};
339  };
340 
341  static bool classof(const Chunk *S) {
342    return S->Kind == ChunkKind::StackSizes;
343  }
344 
345  static bool nameMatches(StringRef Name) {
346    return Name == ".stack_sizes";
347  }
348};
349 
350struct DynamicSection : Section {
351  std::optional<std::vector<DynamicEntry>> Entries;
352 
353  DynamicSection() : Section(ChunkKind::Dynamic) {}
354 
355  std::vector<std::pair<StringRef, bool>> getEntries() const override {
356    return {{"Entries", Entries.has_value()}};
357  };
358 
359  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Dynamic; }
360};
361 
362struct RawContentSection : Section {
363  std::optional<llvm::yaml::Hex64> Info;
364 
365  RawContentSection() : Section(ChunkKind::RawContent) {}
366 
367  static bool classof(const Chunk *S) {
368    return S->Kind == ChunkKind::RawContent;
369  }
370 
371  // Is used when a content is read as an array of bytes.
372  std::optional<std::vector<uint8_t>> ContentBuf;
373};
374 
375struct NoBitsSection : Section {
376  NoBitsSection() : Section(ChunkKind::NoBits) {}
377 
378  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::NoBits; }
379};
380 
381struct NoteSection : Section {
382  std::optional<std::vector<ELFYAML::NoteEntry>> Notes;
383 
384  NoteSection() : Section(ChunkKind::Note) {}
385 
386  std::vector<std::pair<StringRef, bool>> getEntries() const override {
387    return {{"Notes", Notes.has_value()}};
388  };
389 
390  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Note; }
391};
392 
393struct HashSection : Section {
394  std::optional<std::vector<uint32_t>> Bucket;
395  std::optional<std::vector<uint32_t>> Chain;
396 
397  std::vector<std::pair<StringRef, bool>> getEntries() const override {
398    return {{"Bucket", Bucket.has_value()}, {"Chain", Chain.has_value()}};
399  };
400 
401  // The following members are used to override section fields.
402  // This is useful for creating invalid objects.
403  std::optional<llvm::yaml::Hex64> NBucket;
404  std::optional<llvm::yaml::Hex64> NChain;
405 
406  HashSection() : Section(ChunkKind::Hash) {}
407 
408  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Hash; }
409};
410 
411struct GnuHashHeader {
412  // The number of hash buckets.
413  // Not used when dumping the object, but can be used to override
414  // the real number of buckets when emiting an object from a YAML document.
415  std::optional<llvm::yaml::Hex32> NBuckets;
416 
417  // Index of the first symbol in the dynamic symbol table
418  // included in the hash table.
419  llvm::yaml::Hex32 SymNdx;
420 
421  // The number of words in the Bloom filter.
422  // Not used when dumping the object, but can be used to override the real
423  // number of words in the Bloom filter when emiting an object from a YAML
424  // document.
425  std::optional<llvm::yaml::Hex32> MaskWords;
426 
427  // A shift constant used by the Bloom filter.
428  llvm::yaml::Hex32 Shift2;
429};
430 
431struct GnuHashSection : Section {
432  std::optional<GnuHashHeader> Header;
433  std::optional<std::vector<llvm::yaml::Hex64>> BloomFilter;
434  std::optional<std::vector<llvm::yaml::Hex32>> HashBuckets;
435  std::optional<std::vector<llvm::yaml::Hex32>> HashValues;
436 
437  GnuHashSection() : Section(ChunkKind::GnuHash) {}
438 
439  std::vector<std::pair<StringRef, bool>> getEntries() const override {
440    return {{"Header", Header.has_value()},
441            {"BloomFilter", BloomFilter.has_value()},
442            {"HashBuckets", HashBuckets.has_value()},
443            {"HashValues", HashValues.has_value()}};
444  };
445 
446  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; }
447};
448 
449struct VernauxEntry {
450  uint32_t Hash;
451  uint16_t Flags;
452  uint16_t Other;
453  StringRef Name;
454};
455 
456struct VerneedEntry {
457  uint16_t Version;
458  StringRef File;
459  std::vector<VernauxEntry> AuxV;
460};
461 
462struct VerneedSection : Section {
463  std::optional<std::vector<VerneedEntry>> VerneedV;
464  std::optional<llvm::yaml::Hex64> Info;
465 
466  VerneedSection() : Section(ChunkKind::Verneed) {}
467 
468  std::vector<std::pair<StringRef, bool>> getEntries() const override {
469    return {{"Dependencies", VerneedV.has_value()}};
470  };
471 
472  static bool classof(const Chunk *S) {
473    return S->Kind == ChunkKind::Verneed;
474  }
475};
476 
477struct AddrsigSection : Section {
478  std::optional<std::vector<YAMLFlowString>> Symbols;
479 
480  AddrsigSection() : Section(ChunkKind::Addrsig) {}
481 
482  std::vector<std::pair<StringRef, bool>> getEntries() const override {
483    return {{"Symbols", Symbols.has_value()}};
484  };
485 
486  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Addrsig; }
487};
488 
489struct LinkerOption {
490  StringRef Key;
491  StringRef Value;
492};
493 
494struct LinkerOptionsSection : Section {
495  std::optional<std::vector<LinkerOption>> Options;
496 
497  LinkerOptionsSection() : Section(ChunkKind::LinkerOptions) {}
498 
499  std::vector<std::pair<StringRef, bool>> getEntries() const override {
500    return {{"Options", Options.has_value()}};
501  };
502 
503  static bool classof(const Chunk *S) {
504    return S->Kind == ChunkKind::LinkerOptions;
505  }
506};
507 
508struct DependentLibrariesSection : Section {
509  std::optional<std::vector<YAMLFlowString>> Libs;
510 
511  DependentLibrariesSection() : Section(ChunkKind::DependentLibraries) {}
512 
513  std::vector<std::pair<StringRef, bool>> getEntries() const override {
514    return {{"Libraries", Libs.has_value()}};
515  };
516 
517  static bool classof(const Chunk *S) {
518    return S->Kind == ChunkKind::DependentLibraries;
519  }
520};
521 
522// Represents the call graph profile section entry.
523struct CallGraphEntryWeight {
524  // The weight of the edge.
525  uint64_t Weight;
526};
527 
528struct CallGraphProfileSection : Section {
529  std::optional<std::vector<CallGraphEntryWeight>> Entries;
530 
531  CallGraphProfileSection() : Section(ChunkKind::CallGraphProfile) {}
532 
533  std::vector<std::pair<StringRef, bool>> getEntries() const override {
534    return {{"Entries", Entries.has_value()}};
535  };
536 
537  static bool classof(const Chunk *S) {
538    return S->Kind == ChunkKind::CallGraphProfile;
539  }
540};
541 
542struct SymverSection : Section {
543  std::optional<std::vector<uint16_t>> Entries;
544 
545  SymverSection() : Section(ChunkKind::Symver) {}
546 
547  std::vector<std::pair<StringRef, bool>> getEntries() const override {
548    return {{"Entries", Entries.has_value()}};
549  };
550 
551  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Symver; }
552};
553 
554struct VerdefEntry {
555  std::optional<uint16_t> Version;
556  std::optional<uint16_t> Flags;
557  std::optional<uint16_t> VersionNdx;
558  std::optional<uint32_t> Hash;
559  std::vector<StringRef> VerNames;
560};
561 
562struct VerdefSection : Section {
563  std::optional<std::vector<VerdefEntry>> Entries;
564  std::optional<llvm::yaml::Hex64> Info;
565 
566  VerdefSection() : Section(ChunkKind::Verdef) {}
567 
568  std::vector<std::pair<StringRef, bool>> getEntries() const override {
569    return {{"Entries", Entries.has_value()}};
570  };
571 
572  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Verdef; }
573};
574 
575struct GroupSection : Section {
576  // Members of a group contain a flag and a list of section indices
577  // that are part of the group.
578  std::optional<std::vector<SectionOrType>> Members;
579  std::optional<StringRef> Signature; /* Info */
580 
581  GroupSection() : Section(ChunkKind::Group) {}
582 
583  std::vector<std::pair<StringRef, bool>> getEntries() const override {
584    return {{"Members", Members.has_value()}};
585  };
586 
587  static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Group; }
588};
589 
590struct Relocation {
591  llvm::yaml::Hex64 Offset;
592  YAMLIntUInt Addend;
593  ELF_REL Type;
594  std::optional<StringRef> Symbol;
595};
596 
597struct RelocationSection : Section {
598  std::optional<std::vector<Relocation>> Relocations;
599  StringRef RelocatableSec; /* Info */
600 
601  RelocationSection() : Section(ChunkKind::Relocation) {}
602 
603  std::vector<std::pair<StringRef, bool>> getEntries() const override {
604    return {{"Relocations", Relocations.has_value()}};
605  };
606 
607  static bool classof(const Chunk *S) {
608    return S->Kind == ChunkKind::Relocation;
609  }
610};
611 
612struct RelrSection : Section {
613  std::optional<std::vector<llvm::yaml::Hex64>> Entries;
614 
615  RelrSection() : Section(ChunkKind::Relr) {}
616 
617  std::vector<std::pair<StringRef, bool>> getEntries() const override {
618    return {{"Entries", Entries.has_value()}};
619  };
620 
621  static bool classof(const Chunk *S) {
622    return S->Kind == ChunkKind::Relr;
623  }
624};
625 
626struct SymtabShndxSection : Section {
627  std::optional<std::vector<uint32_t>> Entries;
628 
629  SymtabShndxSection() : Section(ChunkKind::SymtabShndxSection) {}
630 
631  std::vector<std::pair<StringRef, bool>> getEntries() const override {
632    return {{"Entries", Entries.has_value()}};
633  };
634 
635  static bool classof(const Chunk *S) {
636    return S->Kind == ChunkKind::SymtabShndxSection;
637  }
638};
639 
640struct ARMIndexTableEntry {
641  llvm::yaml::Hex32 Offset;
642  llvm::yaml::Hex32 Value;
643};
644 
645struct ARMIndexTableSection : Section {
646  std::optional<std::vector<ARMIndexTableEntry>> Entries;
647 
648  ARMIndexTableSection() : Section(ChunkKind::ARMIndexTable) {}
649 
650  std::vector<std::pair<StringRef, bool>> getEntries() const override {
651    return {{"Entries", Entries.has_value()}};
652  };
653 
654  static bool classof(const Chunk *S) {
655    return S->Kind == ChunkKind::ARMIndexTable;
656  }
657};
658 
659// Represents .MIPS.abiflags section
660struct MipsABIFlags : Section {
661  llvm::yaml::Hex16 Version;
662  MIPS_ISA ISALevel;
663  llvm::yaml::Hex8 ISARevision;
664  MIPS_AFL_REG GPRSize;
665  MIPS_AFL_REG CPR1Size;
666  MIPS_AFL_REG CPR2Size;
667  MIPS_ABI_FP FpABI;
668  MIPS_AFL_EXT ISAExtension;
669  MIPS_AFL_ASE ASEs;
670  MIPS_AFL_FLAGS1 Flags1;
671  llvm::yaml::Hex32 Flags2;
672 
673  MipsABIFlags() : Section(ChunkKind::MipsABIFlags) {}
674 
675  static bool classof(const Chunk *S) {
676    return S->Kind == ChunkKind::MipsABIFlags;
677  }
678};
679 
680struct ProgramHeader {
681  ELF_PT Type;
682  ELF_PF Flags;
683  llvm::yaml::Hex64 VAddr;
684  llvm::yaml::Hex64 PAddr;
685  std::optional<llvm::yaml::Hex64> Align;
686  std::optional<llvm::yaml::Hex64> FileSize;
687  std::optional<llvm::yaml::Hex64> MemSize;
688  std::optional<llvm::yaml::Hex64> Offset;
689  std::optional<StringRef> FirstSec;
690  std::optional<StringRef> LastSec;
691 
692  // This vector contains all chunks from [FirstSec, LastSec].
693  std::vector<Chunk *> Chunks;
694};
695 
696struct Object {
697  FileHeader Header;
698  std::vector<ProgramHeader> ProgramHeaders;
699 
700  // An object might contain output section descriptions as well as
701  // custom data that does not belong to any section.
702  std::vector<std::unique_ptr<Chunk>> Chunks;
703 
704  // Although in reality the symbols reside in a section, it is a lot
705  // cleaner and nicer if we read them from the YAML as a separate
706  // top-level key, which automatically ensures that invariants like there
707  // being a single SHT_SYMTAB section are upheld.
708  std::optional<std::vector<Symbol>> Symbols;
709  std::optional<std::vector<Symbol>> DynamicSymbols;
710  std::optional<DWARFYAML::Data> DWARF;
711 
712  std::vector<Section *> getSections() {
713    std::vector<Section *> Ret;
714    for (const std::unique_ptr<Chunk> &Sec : Chunks)
715      if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
716        Ret.push_back(S);
717    return Ret;
718  }
719 
720  const SectionHeaderTable &getSectionHeaderTable() const {
721    for (const std::unique_ptr<Chunk> &C : Chunks)
722      if (auto *S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get()))
723        return *S;
724    llvm_unreachable("the section header table chunk must always be present")::llvm::llvm_unreachable_internal("the section header table chunk must always be present"
, "llvm/include/llvm/ObjectYAML/ELFYAML.h", 724);
725  }
726 
727  ELF_ELFOSABI getOSAbi() const;
728  unsigned getMachine() const;
729};
730 
731bool shouldAllocateFileSpace(ArrayRef<ProgramHeader> Phdrs,
732                             const NoBitsSection &S);
733 
734} // end namespace ELFYAML
735} // end namespace llvm
736 
737LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::StackSizeEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::StackSizeEntry> && !std::is_same_v
<llvm::ELFYAML::StackSizeEntry, std::string> &&
 !std::is_same_v<llvm::ELFYAML::StackSizeEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::StackSizeEntry> { static const bool flow = false; }; } }
738LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::BBAddrMapEntry> && !std::is_same_v
<llvm::ELFYAML::BBAddrMapEntry, std::string> &&
 !std::is_same_v<llvm::ELFYAML::BBAddrMapEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::BBAddrMapEntry> { static const bool flow = false; }; } }
739LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::BBAddrMapEntry::BBEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::BBAddrMapEntry::BBEntry> && !std
::is_same_v<llvm::ELFYAML::BBAddrMapEntry::BBEntry, std::string
> && !std::is_same_v<llvm::ELFYAML::BBAddrMapEntry
::BBEntry, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::BBAddrMapEntry::BBEntry> { static const bool flow = false
; }; } }
740LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::DynamicEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::DynamicEntry> && !std::is_same_v
<llvm::ELFYAML::DynamicEntry, std::string> && !
std::is_same_v<llvm::ELFYAML::DynamicEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::DynamicEntry> { static const bool flow = false; }; } }
741LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::LinkerOption)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::LinkerOption> && !std::is_same_v
<llvm::ELFYAML::LinkerOption, std::string> && !
std::is_same_v<llvm::ELFYAML::LinkerOption, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::LinkerOption> { static const bool flow = false; }; } }
742LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::CallGraphEntryWeight)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::CallGraphEntryWeight> && !std::
is_same_v<llvm::ELFYAML::CallGraphEntryWeight, std::string
> && !std::is_same_v<llvm::ELFYAML::CallGraphEntryWeight
, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::CallGraphEntryWeight> { static const bool flow = false; }
; } }
743LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::NoteEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::NoteEntry> && !std::is_same_v<
llvm::ELFYAML::NoteEntry, std::string> && !std::is_same_v
<llvm::ELFYAML::NoteEntry, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::NoteEntry> { static const bool flow = false; }; } }
744LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::ProgramHeader> && !std::is_same_v
<llvm::ELFYAML::ProgramHeader, std::string> && !
std::is_same_v<llvm::ELFYAML::ProgramHeader, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::ProgramHeader> { static const bool flow = false; }; } }
745LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionHeader)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::SectionHeader> && !std::is_same_v
<llvm::ELFYAML::SectionHeader, std::string> && !
std::is_same_v<llvm::ELFYAML::SectionHeader, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::SectionHeader> { static const bool flow = false; }; } }
746LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Chunk>)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<std::unique_ptr<llvm::ELFYAML::Chunk> > &&
 !std::is_same_v<std::unique_ptr<llvm::ELFYAML::Chunk>
, std::string> && !std::is_same_v<std::unique_ptr
<llvm::ELFYAML::Chunk>, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<std::unique_ptr
<llvm::ELFYAML::Chunk> > { static const bool flow = false
; }; } }
747LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::Symbol> && !std::is_same_v<llvm
::ELFYAML::Symbol, std::string> && !std::is_same_v
<llvm::ELFYAML::Symbol, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::Symbol> { static const bool flow = false; }; } }
748LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::VerdefEntry> && !std::is_same_v
<llvm::ELFYAML::VerdefEntry, std::string> && !std
::is_same_v<llvm::ELFYAML::VerdefEntry, llvm::StringRef>
, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VerdefEntry> { static const bool flow = false; }; } }
749LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::VernauxEntry> && !std::is_same_v
<llvm::ELFYAML::VernauxEntry, std::string> && !
std::is_same_v<llvm::ELFYAML::VernauxEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VernauxEntry> { static const bool flow = false; }; } }
750LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::VerneedEntry> && !std::is_same_v
<llvm::ELFYAML::VerneedEntry, std::string> && !
std::is_same_v<llvm::ELFYAML::VerneedEntry, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::VerneedEntry> { static const bool flow = false; }; } }
751LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::Relocation> && !std::is_same_v<
llvm::ELFYAML::Relocation, std::string> && !std::is_same_v
<llvm::ELFYAML::Relocation, llvm::StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::Relocation> { static const bool flow = false; }; } }
752LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::SectionOrType> && !std::is_same_v
<llvm::ELFYAML::SectionOrType, std::string> && !
std::is_same_v<llvm::ELFYAML::SectionOrType, llvm::StringRef
>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::SectionOrType> { static const bool flow = false; }; } }
753LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ARMIndexTableEntry)namespace llvm { namespace yaml { static_assert( !std::is_fundamental_v
<llvm::ELFYAML::ARMIndexTableEntry> && !std::is_same_v
<llvm::ELFYAML::ARMIndexTableEntry, std::string> &&
 !std::is_same_v<llvm::ELFYAML::ARMIndexTableEntry, llvm::
StringRef>, "only use LLVM_YAML_IS_SEQUENCE_VECTOR for types you control"
); template <> struct SequenceElementTraits<llvm::ELFYAML
::ARMIndexTableEntry> { static const bool flow = false; };
 } }
754 
755namespace llvm {
756namespace yaml {
757 
758template <> struct ScalarTraits<ELFYAML::YAMLIntUInt> {
759  static void output(const ELFYAML::YAMLIntUInt &Val, void *Ctx,
760                     raw_ostream &Out);
761  static StringRef input(StringRef Scalar, void *Ctx,
762                         ELFYAML::YAMLIntUInt &Val);
763  static QuotingType mustQuote(StringRef) { return QuotingType::None; }
764};
765 
766template <>
767struct ScalarEnumerationTraits<ELFYAML::ELF_ET> {
768  static void enumeration(IO &IO, ELFYAML::ELF_ET &Value);
769};
770 
771template <> struct ScalarEnumerationTraits<ELFYAML::ELF_PT> {
772  static void enumeration(IO &IO, ELFYAML::ELF_PT &Value);
773};
774 
775template <> struct ScalarEnumerationTraits<ELFYAML::ELF_NT> {
776  static void enumeration(IO &IO, ELFYAML::ELF_NT &Value);
777};
778 
779template <>
780struct ScalarEnumerationTraits<ELFYAML::ELF_EM> {
781  static void enumeration(IO &IO, ELFYAML::ELF_EM &Value);
782};
783 
784template <>
785struct ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS> {
786  static void enumeration(IO &IO, ELFYAML::ELF_ELFCLASS &Value);
787};
788 
789template <>
790struct ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA> {
791  static void enumeration(IO &IO, ELFYAML::ELF_ELFDATA &Value);
792};
793 
794template <>
795struct ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI> {
796  static void enumeration(IO &IO, ELFYAML::ELF_ELFOSABI &Value);
797};
798 
799template <>
800struct ScalarBitSetTraits<ELFYAML::ELF_EF> {
801  static void bitset(IO &IO, ELFYAML::ELF_EF &Value);
802};
803 
804template <> struct ScalarBitSetTraits<ELFYAML::ELF_PF> {
805  static void bitset(IO &IO, ELFYAML::ELF_PF &Value);
806};
807 
808template <>
809struct ScalarEnumerationTraits<ELFYAML::ELF_SHT> {
810  static void enumeration(IO &IO, ELFYAML::ELF_SHT &Value);
811};
812 
813template <>
814struct ScalarBitSetTraits<ELFYAML::ELF_SHF> {
815  static void bitset(IO &IO, ELFYAML::ELF_SHF &Value);
816};
817 
818template <> struct ScalarEnumerationTraits<ELFYAML::ELF_SHN> {
819  static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
820};
821 
822template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
823  static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
824};
825 
826template <>
827struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
828  static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
829};
830 
831template <>
832struct ScalarEnumerationTraits<ELFYAML::ELF_REL> {
833  static void enumeration(IO &IO, ELFYAML::ELF_REL &Value);
834};
835 
836template <>
837struct ScalarEnumerationTraits<ELFYAML::ELF_DYNTAG> {
838  static void enumeration(IO &IO, ELFYAML::ELF_DYNTAG &Value);
839};
840 
841template <>
842struct ScalarEnumerationTraits<ELFYAML::ELF_RSS> {
843  static void enumeration(IO &IO, ELFYAML::ELF_RSS &Value);
844};
845 
846template <>
847struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG> {
848  static void enumeration(IO &IO, ELFYAML::MIPS_AFL_REG &Value);
849};
850 
851template <>
852struct ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP> {
853  static void enumeration(IO &IO, ELFYAML::MIPS_ABI_FP &Value);
854};
855 
856template <>
857struct ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT> {
858  static void enumeration(IO &IO, ELFYAML::MIPS_AFL_EXT &Value);
859};
860 
861template <>
862struct ScalarEnumerationTraits<ELFYAML::MIPS_ISA> {
863  static void enumeration(IO &IO, ELFYAML::MIPS_ISA &Value);
864};
865 
866template <>
867struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE> {
868  static void bitset(IO &IO, ELFYAML::MIPS_AFL_ASE &Value);
869};
870 
871template <>
872struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
873  static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
874};
875 
876template <>
877struct MappingTraits<ELFYAML::FileHeader> {
878  static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
879};
880 
881template <> struct MappingTraits<ELFYAML::SectionHeader> {
882  static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
883};
884 
885template <> struct MappingTraits<ELFYAML::ProgramHeader> {
886  static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
887  static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
888};
889 
890template <>
891struct MappingTraits<ELFYAML::Symbol> {
892  static void mapping(IO &IO, ELFYAML::Symbol &Symbol);
893  static std::string validate(IO &IO, ELFYAML::Symbol &Symbol);
894};
895 
896template <> struct MappingTraits<ELFYAML::StackSizeEntry> {
897  static void mapping(IO &IO, ELFYAML::StackSizeEntry &Rel);
898};
899 
900template <> struct MappingTraits<ELFYAML::BBAddrMapEntry> {
901  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry &Rel);
902};
903 
904template <> struct MappingTraits<ELFYAML::BBAddrMapEntry::BBEntry> {
905  static void mapping(IO &IO, ELFYAML::BBAddrMapEntry::BBEntry &Rel);
906};
907 
908template <> struct MappingTraits<ELFYAML::GnuHashHeader> {
909  static void mapping(IO &IO, ELFYAML::GnuHashHeader &Rel);
910};
911 
912template <> struct MappingTraits<ELFYAML::DynamicEntry> {
913  static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
914};
915 
916template <> struct MappingTraits<ELFYAML::NoteEntry> {
917  static void mapping(IO &IO, ELFYAML::NoteEntry &N);
918};
919 
920template <> struct MappingTraits<ELFYAML::VerdefEntry> {
921  static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
922};
923 
924template <> struct MappingTraits<ELFYAML::VerneedEntry> {
925  static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
926};
927 
928template <> struct MappingTraits<ELFYAML::VernauxEntry> {
929  static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
930};
931 
932template <> struct MappingTraits<ELFYAML::LinkerOption> {
933  static void mapping(IO &IO, ELFYAML::LinkerOption &Sym);
934};
935 
936template <> struct MappingTraits<ELFYAML::CallGraphEntryWeight> {
937  static void mapping(IO &IO, ELFYAML::CallGraphEntryWeight &E);
938};
939 
940template <> struct MappingTraits<ELFYAML::Relocation> {
941  static void mapping(IO &IO, ELFYAML::Relocation &Rel);
942};
943 
944template <> struct MappingTraits<ELFYAML::ARMIndexTableEntry> {
945  static void mapping(IO &IO, ELFYAML::ARMIndexTableEntry &E);
946};
947 
948template <> struct MappingTraits<std::unique_ptr<ELFYAML::Chunk>> {
949  static void mapping(IO &IO, std::unique_ptr<ELFYAML::Chunk> &C);
950  static std::string validate(IO &io, std::unique_ptr<ELFYAML::Chunk> &C);
951};
952 
953template <>
954struct MappingTraits<ELFYAML::Object> {
955  static void mapping(IO &IO, ELFYAML::Object &Object);
956};
957 
958template <> struct MappingTraits<ELFYAML::SectionOrType> {
959  static void mapping(IO &IO, ELFYAML::SectionOrType &sectionOrType);
960};
961 
962} // end namespace yaml
963} // end namespace llvm
964 
965#endif // LLVM_OBJECTYAML_ELFYAML_H