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 //===----------------------------------------------------------------------===//
   8
   9 #include "Error.h"
  10 #include "llvm/ADT/DenseSet.h"
  11 #include "llvm/ADT/STLExtras.h"
  12 #include "llvm/Object/ELFObjectFile.h"
  13 #include "llvm/ObjectYAML/ELFYAML.h"
  14 #include "llvm/Support/ErrorHandling.h"
  15 #include "llvm/Support/YAMLTraits.h"
  16
  17 using namespace llvm;
  18
  19 namespace {
  20
  21 template <class ELFT>
  22 class ELFDumper {
  23   typedef object::Elf_Sym_Impl<ELFT> Elf_Sym;
  24   typedef typename ELFT::Dyn Elf_Dyn;
  25   typedef typename ELFT::Shdr Elf_Shdr;
  26   typedef typename ELFT::Word Elf_Word;
  27   typedef typename ELFT::Rel Elf_Rel;
  28   typedef typename ELFT::Rela Elf_Rela;
  29
  30   ArrayRef<Elf_Shdr> Sections;
  31   ArrayRef<Elf_Sym> SymTable;
  32
  33   DenseMap<StringRef, uint32_t> UsedSectionNames;
  34   std::vector<std::string> SectionNames;
  35
  36   DenseMap<StringRef, uint32_t> UsedSymbolNames;
  37   std::vector<std::string> SymbolNames;
  38
  39   Expected<StringRef> getUniquedSectionName(const Elf_Shdr *Sec);
  40   Expected<StringRef> getUniquedSymbolName(const Elf_Sym *Sym,
  41                                            StringRef StrTable,
  42                                            const Elf_Shdr *SymTab);
  43
  44   const object::ELFFile<ELFT> &Obj;
  45   ArrayRef<Elf_Word> ShndxTable;
  46
  47   Error dumpSymbols(const Elf_Shdr *Symtab,
  48                     std::vector<ELFYAML::Symbol> &Symbols);
  49   Error dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
  50                    StringRef StrTable, ELFYAML::Symbol &S);
  51   Error dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S);
  52   Error dumpCommonRelocationSection(const Elf_Shdr *Shdr,
  53                                     ELFYAML::RelocationSection &S);
  54   template <class RelT>
  55   Error dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
  56                        ELFYAML::Relocation &R);
  57
  58   Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
  59   Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
  60   Expected<ELFYAML::RawContentSection *>
  61   dumpContentSection(const Elf_Shdr *Shdr);
  62   Expected<ELFYAML::SymtabShndxSection *>
  63   dumpSymtabShndxSection(const Elf_Shdr *Shdr);
  64   Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
  65   Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
  66   Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
  67   Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
  68   Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
  69   Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
  70
  71 public:
  72   ELFDumper(const object::ELFFile<ELFT> &O);
  73   Expected<ELFYAML::Object *> dump();
  74 };
  75
  76 }
  77
  78 template <class ELFT>
  79 ELFDumper<ELFT>::ELFDumper(const object::ELFFile<ELFT> &O)
  80     : Obj(O) {}
  81
  82 template <class ELFT>
  83 Expected<StringRef>
  84 ELFDumper<ELFT>::getUniquedSectionName(const Elf_Shdr *Sec) {
  85   unsigned SecIndex = Sec - &Sections[0];
  86   assert(&Sections[SecIndex] == Sec);
  87   if (!SectionNames[SecIndex].empty())
  88     return SectionNames[SecIndex];
  89
  90   auto NameOrErr = Obj.getSectionName(Sec);
  91   if (!NameOrErr)
  92     return NameOrErr;
  93   StringRef Name = *NameOrErr;
  94   std::string &Ret = SectionNames[SecIndex];
  95
  96   auto It = UsedSectionNames.insert({Name, 0});
  97   if (!It.second)
  98     Ret = (Name + " [" + Twine(++It.first->second) + "]").str();
  99   else
 100     Ret = Name;
 101   return Ret;
 102 }
 103
 104 template <class ELFT>
 105 Expected<StringRef>
 106 ELFDumper<ELFT>::getUniquedSymbolName(const Elf_Sym *Sym, StringRef StrTable,
 107                                       const Elf_Shdr *SymTab) {
 108   Expected<StringRef> SymbolNameOrErr = Sym->getName(StrTable);
 109   if (!SymbolNameOrErr)
 110     return SymbolNameOrErr;
 111   StringRef Name = *SymbolNameOrErr;
 112   if (Name.empty() && Sym->getType() == ELF::STT_SECTION) {
 113     auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
 114     if (!ShdrOrErr)
 115       return ShdrOrErr.takeError();
 116     return getUniquedSectionName(*ShdrOrErr);
 117   }
 118
 119   // Symbols in .symtab can have duplicate names. For example, it is a common
 120   // situation for local symbols in a relocatable object. Here we assign unique
 121   // suffixes for such symbols so that we can differentiate them.
 122   if (SymTab->sh_type == ELF::SHT_SYMTAB) {
 123     unsigned Index = Sym - SymTable.data();
 124     if (!SymbolNames[Index].empty())
 125       return SymbolNames[Index];
 126
 127     auto It = UsedSymbolNames.insert({Name, 0});
 128     if (!It.second)
 129       SymbolNames[Index] =
 130           (Name + " [" + Twine(++It.first->second) + "]").str();
 131     else
 132       SymbolNames[Index] = Name;
 133     return SymbolNames[Index];
 134   }
 135
 136   return Name;
 137 }
 138
 139 template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
 140   auto Y = std::make_unique<ELFYAML::Object>();
 141
 142   // Dump header. We do not dump SHEntSize, SHOffset, SHNum and SHStrNdx field.
 143   // When not explicitly set, the values are set by yaml2obj automatically
 144   // and there is no need to dump them here.
 145   Y->Header.Class = ELFYAML::ELF_ELFCLASS(Obj.getHeader()->getFileClass());
 146   Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader()->getDataEncoding());
 147   Y->Header.OSABI = Obj.getHeader()->e_ident[ELF::EI_OSABI];
 148   Y->Header.ABIVersion = Obj.getHeader()->e_ident[ELF::EI_ABIVERSION];
 149   Y->Header.Type = Obj.getHeader()->e_type;
 150   Y->Header.Machine = Obj.getHeader()->e_machine;
 151   Y->Header.Flags = Obj.getHeader()->e_flags;
 152   Y->Header.Entry = Obj.getHeader()->e_entry;
 153
 154   // Dump sections
 155   auto SectionsOrErr = Obj.sections();
 156   if (!SectionsOrErr)
 157     return SectionsOrErr.takeError();
 158   Sections = *SectionsOrErr;
 159   SectionNames.resize(Sections.size());
 160
 161   // Dump symbols. We need to do this early because other sections might want
 162   // to access the deduplicated symbol names that we also create here.
 163   const Elf_Shdr *SymTab = nullptr;
 164   const Elf_Shdr *SymTabShndx = nullptr;
 165   const Elf_Shdr *DynSymTab = nullptr;
 166
 167   for (const Elf_Shdr &Sec : Sections) {
 168     if (Sec.sh_type == ELF::SHT_SYMTAB) {
 169       SymTab = &Sec;
 170     } else if (Sec.sh_type == ELF::SHT_DYNSYM) {
 171       DynSymTab = &Sec;
 172     } else if (Sec.sh_type == ELF::SHT_SYMTAB_SHNDX) {
 173       // ABI allows us to have one SHT_SYMTAB_SHNDX for each symbol table.
 174       // We only support having the SHT_SYMTAB_SHNDX for SHT_SYMTAB now.
 175       if (SymTabShndx)
 176         return createStringError(obj2yaml_error::not_implemented,
 177                                  "multiple SHT_SYMTAB_SHNDX sections are not supported");
 178       SymTabShndx = &Sec;
 179     }
 180   }
 181
 182   // We need to locate the SHT_SYMTAB_SHNDX section early, because it might be
 183   // needed for dumping symbols.
 184   if (SymTabShndx) {
 185     if (!SymTab || SymTabShndx->sh_link != SymTab - Sections.begin())
 186       return createStringError(
 187           obj2yaml_error::not_implemented,
 188           "only SHT_SYMTAB_SHNDX associated with SHT_SYMTAB are supported");
 189
 190     auto TableOrErr = Obj.getSHNDXTable(*SymTabShndx);
 191     if (!TableOrErr)
 192       return TableOrErr.takeError();
 193     ShndxTable = *TableOrErr;
 194   }
 195   if (SymTab)
 196     if (Error E = dumpSymbols(SymTab, Y->Symbols))
 197       return std::move(E);
 198   if (DynSymTab)
 199     if (Error E = dumpSymbols(DynSymTab, Y->DynamicSymbols))
 200       return std::move(E);
 201
 202   for (const Elf_Shdr &Sec : Sections) {
 203     switch (Sec.sh_type) {
 204     case ELF::SHT_DYNAMIC: {
 205       Expected<ELFYAML::DynamicSection *> SecOrErr = dumpDynamicSection(&Sec);
 206       if (!SecOrErr)
 207         return SecOrErr.takeError();
 208       Y->Sections.emplace_back(*SecOrErr);
 209       break;
 210     }
 211     case ELF::SHT_STRTAB:
 212     case ELF::SHT_SYMTAB:
 213     case ELF::SHT_DYNSYM:
 214       // Do not dump these sections.
 215       break;
 216     case ELF::SHT_SYMTAB_SHNDX: {
 217       Expected<ELFYAML::SymtabShndxSection *> SecOrErr =
 218           dumpSymtabShndxSection(&Sec);
 219       if (!SecOrErr)
 220         return SecOrErr.takeError();
 221       Y->Sections.emplace_back(*SecOrErr);
 222       break;
 223     }
 224     case ELF::SHT_REL:
 225     case ELF::SHT_RELA: {
 226       Expected<ELFYAML::RelocationSection *> SecOrErr = dumpRelocSection(&Sec);
 227       if (!SecOrErr)
 228         return SecOrErr.takeError();
 229       Y->Sections.emplace_back(*SecOrErr);
 230       break;
 231     }
 232     case ELF::SHT_GROUP: {
 233       Expected<ELFYAML::Group *> GroupOrErr = dumpGroup(&Sec);
 234       if (!GroupOrErr)
 235         return GroupOrErr.takeError();
 236       Y->Sections.emplace_back(*GroupOrErr);
 237       break;
 238     }
 239     case ELF::SHT_MIPS_ABIFLAGS: {
 240       Expected<ELFYAML::MipsABIFlags *> SecOrErr = dumpMipsABIFlags(&Sec);
 241       if (!SecOrErr)
 242         return SecOrErr.takeError();
 243       Y->Sections.emplace_back(*SecOrErr);
 244       break;
 245     }
 246     case ELF::SHT_NOBITS: {
 247       Expected<ELFYAML::NoBitsSection *> SecOrErr = dumpNoBitsSection(&Sec);
 248       if (!SecOrErr)
 249         return SecOrErr.takeError();
 250       Y->Sections.emplace_back(*SecOrErr);
 251       break;
 252     }
 253     case ELF::SHT_GNU_verdef: {
 254       Expected<ELFYAML::VerdefSection *> SecOrErr = dumpVerdefSection(&Sec);
 255       if (!SecOrErr)
 256         return SecOrErr.takeError();
 257       Y->Sections.emplace_back(*SecOrErr);
 258       break;
 259     }
 260     case ELF::SHT_GNU_versym: {
 261       Expected<ELFYAML::SymverSection *> SecOrErr = dumpSymverSection(&Sec);
 262       if (!SecOrErr)
 263         return SecOrErr.takeError();
 264       Y->Sections.emplace_back(*SecOrErr);
 265       break;
 266     }
 267     case ELF::SHT_GNU_verneed: {
 268       Expected<ELFYAML::VerneedSection *> SecOrErr = dumpVerneedSection(&Sec);
 269       if (!SecOrErr)
 270         return SecOrErr.takeError();
 271       Y->Sections.emplace_back(*SecOrErr);
 272       break;
 273     }
 274     case ELF::SHT_NULL: {
 275       // We only dump the SHT_NULL section at index 0 when it
 276       // has at least one non-null field, because yaml2obj
 277       // normally creates the zero section at index 0 implicitly.
 278       if (&Sec == &Sections[0]) {
 279         const uint8_t *Begin = reinterpret_cast<const uint8_t *>(&Sec);
 280         const uint8_t *End = Begin + sizeof(Elf_Shdr);
 281         if (std::find_if(Begin, End, [](uint8_t V) { return V != 0; }) == End)
 282           break;
 283       }
 284       LLVM_FALLTHROUGH;
 285     }
 286     default: {
 287       Expected<ELFYAML::RawContentSection *> SecOrErr =
 288           dumpContentSection(&Sec);
 289       if (!SecOrErr)
 290         return SecOrErr.takeError();
 291       Y->Sections.emplace_back(*SecOrErr);
 292     }
 293     }
 294   }
 295
 296   return Y.release();
 297 }
 298
 299 template <class ELFT>
 300 Error ELFDumper<ELFT>::dumpSymbols(const Elf_Shdr *Symtab,
 301                              std::vector<ELFYAML::Symbol> &Symbols) {
 302   if (!Symtab)
 303     return Error::success();
 304
 305   auto StrTableOrErr = Obj.getStringTableForSymtab(*Symtab);
 306   if (!StrTableOrErr)
 307     return StrTableOrErr.takeError();
 308   StringRef StrTable = *StrTableOrErr;
 309
 310   auto SymtabOrErr = Obj.symbols(Symtab);
 311   if (!SymtabOrErr)
 312     return SymtabOrErr.takeError();
 313
 314   if (Symtab->sh_type == ELF::SHT_SYMTAB) {
 315     SymTable = *SymtabOrErr;
 316     SymbolNames.resize(SymTable.size());
 317   }
 318
 319   for (const auto &Sym : (*SymtabOrErr).drop_front()) {
 320     ELFYAML::Symbol S;
 321     if (auto EC = dumpSymbol(&Sym, Symtab, StrTable, S))
 322       return EC;
 323     Symbols.push_back(S);
 324   }
 325
 326   return Error::success();
 327 }
 328
 329 template <class ELFT>
 330 Error ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
 331                                   StringRef StrTable, ELFYAML::Symbol &S) {
 332   S.Type = Sym->getType();
 333   S.Value = Sym->st_value;
 334   S.Size = Sym->st_size;
 335   S.Other = Sym->st_other;
 336   S.Binding = Sym->getBinding();
 337
 338   Expected<StringRef> SymbolNameOrErr =
 339       getUniquedSymbolName(Sym, StrTable, SymTab);
 340   if (!SymbolNameOrErr)
 341     return SymbolNameOrErr.takeError();
 342   S.Name = SymbolNameOrErr.get();
 343
 344   if (Sym->st_shndx >= ELF::SHN_LORESERVE) {
 345     S.Index = (ELFYAML::ELF_SHN)Sym->st_shndx;
 346     return Error::success();
 347   }
 348
 349   auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
 350   if (!ShdrOrErr)
 351     return ShdrOrErr.takeError();
 352   const Elf_Shdr *Shdr = *ShdrOrErr;
 353   if (!Shdr)
 354     return Error::success();
 355
 356   auto NameOrErr = getUniquedSectionName(Shdr);
 357   if (!NameOrErr)
 358     return NameOrErr.takeError();
 359   S.Section = NameOrErr.get();
 360
 361   return Error::success();
 362 }
 363
 364 template <class ELFT>
 365 template <class RelT>
 366 Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
 367                                       ELFYAML::Relocation &R) {
 368   R.Type = Rel->getType(Obj.isMips64EL());
 369   R.Offset = Rel->r_offset;
 370   R.Addend = 0;
 371
 372   auto SymOrErr = Obj.getRelocationSymbol(Rel, SymTab);
 373   if (!SymOrErr)
 374     return SymOrErr.takeError();
 375   const Elf_Sym *Sym = *SymOrErr;
 376   auto StrTabSec = Obj.getSection(SymTab->sh_link);
 377   if (!StrTabSec)
 378     return StrTabSec.takeError();
 379   auto StrTabOrErr = Obj.getStringTable(*StrTabSec);
 380   if (!StrTabOrErr)
 381     return StrTabOrErr.takeError();
 382   StringRef StrTab = *StrTabOrErr;
 383
 384   if (Sym) {
 385     Expected<StringRef> NameOrErr = getUniquedSymbolName(Sym, StrTab, SymTab);
 386     if (!NameOrErr)
 387       return NameOrErr.takeError();
 388     R.Symbol = NameOrErr.get();
 389   } else {
 390     // We have some edge cases of relocations without a symbol associated,
 391     // e.g. an object containing the invalid (according to the System V
 392     // ABI) R_X86_64_NONE reloc. Create a symbol with an empty name instead
 393     // of crashing.
 394     R.Symbol = "";
 395   }
 396
 397   return Error::success();
 398 }
 399
 400 template <class ELFT>
 401 Error ELFDumper<ELFT>::dumpCommonSection(const Elf_Shdr *Shdr,
 402                                          ELFYAML::Section &S) {
 403   // Dump fields. We do not dump the ShOffset field. When not explicitly
 404   // set, the value is set by yaml2obj automatically.
 405   S.Type = Shdr->sh_type;
 406   if (Shdr->sh_flags)
 407     S.Flags = static_cast<ELFYAML::ELF_SHF>(Shdr->sh_flags);
 408   S.Address = Shdr->sh_addr;
 409   S.AddressAlign = Shdr->sh_addralign;
 410   if (Shdr->sh_entsize)
 411     S.EntSize = static_cast<llvm::yaml::Hex64>(Shdr->sh_entsize);
 412
 413   auto NameOrErr = getUniquedSectionName(Shdr);
 414   if (!NameOrErr)
 415     return NameOrErr.takeError();
 416   S.Name = NameOrErr.get();
 417
 418   if (Shdr->sh_link != ELF::SHN_UNDEF) {
 419     auto LinkSection = Obj.getSection(Shdr->sh_link);
 420     if (!LinkSection)
 421       return make_error<StringError>(
 422           "unable to resolve sh_link reference in section '" + S.Name +
 423               "': " + toString(LinkSection.takeError()),
 424           inconvertibleErrorCode());
 425
 426     NameOrErr = getUniquedSectionName(*LinkSection);
 427     if (!NameOrErr)
 428       return NameOrErr.takeError();
 429     S.Link = NameOrErr.get();
 430   }
 431
 432   return Error::success();
 433 }
 434
 435 template <class ELFT>
 436 Error ELFDumper<ELFT>::dumpCommonRelocationSection(
 437     const Elf_Shdr *Shdr, ELFYAML::RelocationSection &S) {
 438   if (Error E = dumpCommonSection(Shdr, S))
 439     return E;
 440
 441   auto InfoSection = Obj.getSection(Shdr->sh_info);
 442   if (!InfoSection)
 443     return InfoSection.takeError();
 444
 445   auto NameOrErr = getUniquedSectionName(*InfoSection);
 446   if (!NameOrErr)
 447     return NameOrErr.takeError();
 448   S.RelocatableSec = NameOrErr.get();
 449
 450   return Error::success();
 451 }
 452
 453 template <class ELFT>
 454 Expected<ELFYAML::DynamicSection *>
 455 ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
 456   auto S = std::make_unique<ELFYAML::DynamicSection>();
 457   if (Error E = dumpCommonSection(Shdr, *S))
 458     return std::move(E);
 459
 460   auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
 461   if (!DynTagsOrErr)
 462     return DynTagsOrErr.takeError();
 463
 464   for (const Elf_Dyn &Dyn : *DynTagsOrErr)
 465     S->Entries.push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()});
 466
 467   return S.release();
 468 }
 469
 470 template <class ELFT>
 471 Expected<ELFYAML::RelocationSection *>
 472 ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
 473   auto S = std::make_unique<ELFYAML::RelocationSection>();
 474   if (auto E = dumpCommonRelocationSection(Shdr, *S))
 475     return std::move(E);
 476
 477   auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
 478   if (!SymTabOrErr)
 479     return SymTabOrErr.takeError();
 480   const Elf_Shdr *SymTab = *SymTabOrErr;
 481
 482   if (Shdr->sh_type == ELF::SHT_REL) {
 483     auto Rels = Obj.rels(Shdr);
 484     if (!Rels)
 485       return Rels.takeError();
 486     for (const Elf_Rel &Rel : *Rels) {
 487       ELFYAML::Relocation R;
 488       if (Error E = dumpRelocation(&Rel, SymTab, R))
 489         return std::move(E);
 490       S->Relocations.push_back(R);
 491     }
 492   } else {
 493     auto Rels = Obj.relas(Shdr);
 494     if (!Rels)
 495       return Rels.takeError();
 496     for (const Elf_Rela &Rel : *Rels) {
 497       ELFYAML::Relocation R;
 498       if (Error E = dumpRelocation(&Rel, SymTab, R))
 499         return std::move(E);
 500       R.Addend = Rel.r_addend;
 501       S->Relocations.push_back(R);
 502     }
 503   }
 504
 505   return S.release();
 506 }
 507
 508 template <class ELFT>
 509 Expected<ELFYAML::RawContentSection *>
 510 ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
 511   auto S = std::make_unique<ELFYAML::RawContentSection>();
 512   if (Error E = dumpCommonSection(Shdr, *S))
 513     return std::move(E);
 514
 515   unsigned SecIndex = Shdr - &Sections[0];
 516   if (SecIndex != 0 || Shdr->sh_type != ELF::SHT_NULL) {
 517     auto ContentOrErr = Obj.getSectionContents(Shdr);
 518     if (!ContentOrErr)
 519       return ContentOrErr.takeError();
 520     ArrayRef<uint8_t> Content = *ContentOrErr;
 521     if (!Content.empty())
 522       S->Content = yaml::BinaryRef(Content);
 523   } else {
 524     S->Size = static_cast<llvm::yaml::Hex64>(Shdr->sh_size);
 525   }
 526
 527   if (Shdr->sh_info)
 528     S->Info = static_cast<llvm::yaml::Hex64>(Shdr->sh_info);
 529   return S.release();
 530 }
 531
 532 template <class ELFT>
 533 Expected<ELFYAML::SymtabShndxSection *>
 534 ELFDumper<ELFT>::dumpSymtabShndxSection(const Elf_Shdr *Shdr) {
 535   auto S = std::make_unique<ELFYAML::SymtabShndxSection>();
 536   if (Error E = dumpCommonSection(Shdr, *S))
 537     return std::move(E);
 538
 539   auto EntriesOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);
 540   if (!EntriesOrErr)
 541     return EntriesOrErr.takeError();
 542   for (const Elf_Word &E : *EntriesOrErr)
 543     S->Entries.push_back(E);
 544   return S.release();
 545 }
 546
 547 template <class ELFT>
 548 Expected<ELFYAML::NoBitsSection *>
 549 ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
 550   auto S = std::make_unique<ELFYAML::NoBitsSection>();
 551   if (Error E = dumpCommonSection(Shdr, *S))
 552     return std::move(E);
 553   S->Size = Shdr->sh_size;
 554
 555   return S.release();
 556 }
 557
 558 template <class ELFT>
 559 Expected<ELFYAML::VerdefSection *>
 560 ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
 561   typedef typename ELFT::Verdef Elf_Verdef;
 562   typedef typename ELFT::Verdaux Elf_Verdaux;
 563
 564   auto S = std::make_unique<ELFYAML::VerdefSection>();
 565   if (Error E = dumpCommonSection(Shdr, *S))
 566     return std::move(E);
 567
 568   S->Info = Shdr->sh_info;
 569
 570   auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
 571   if (!StringTableShdrOrErr)
 572     return StringTableShdrOrErr.takeError();
 573
 574   auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
 575   if (!StringTableOrErr)
 576     return StringTableOrErr.takeError();
 577
 578   auto Contents = Obj.getSectionContents(Shdr);
 579   if (!Contents)
 580     return Contents.takeError();
 581
 582   llvm::ArrayRef<uint8_t> Data = *Contents;
 583   const uint8_t *Buf = Data.data();
 584   while (Buf) {
 585     const Elf_Verdef *Verdef = reinterpret_cast<const Elf_Verdef *>(Buf);
 586     ELFYAML::VerdefEntry Entry;
 587     Entry.Version = Verdef->vd_version;
 588     Entry.Flags = Verdef->vd_flags;
 589     Entry.VersionNdx = Verdef->vd_ndx;
 590     Entry.Hash = Verdef->vd_hash;
 591
 592     const uint8_t *BufAux = Buf + Verdef->vd_aux;
 593     while (BufAux) {
 594       const Elf_Verdaux *Verdaux =
 595           reinterpret_cast<const Elf_Verdaux *>(BufAux);
 596       Entry.VerNames.push_back(
 597           StringTableOrErr->drop_front(Verdaux->vda_name).data());
 598       BufAux = Verdaux->vda_next ? BufAux + Verdaux->vda_next : nullptr;
 599     }
 600
 601     S->Entries.push_back(Entry);
 602     Buf = Verdef->vd_next ? Buf + Verdef->vd_next : nullptr;
 603   }
 604
 605   return S.release();
 606 }
 607
 608 template <class ELFT>
 609 Expected<ELFYAML::SymverSection *>
 610 ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
 611   typedef typename ELFT::Half Elf_Half;
 612
 613   auto S = std::make_unique<ELFYAML::SymverSection>();
 614   if (Error E = dumpCommonSection(Shdr, *S))
 615     return std::move(E);
 616
 617   auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(Shdr);
 618   if (!VersionsOrErr)
 619     return VersionsOrErr.takeError();
 620   for (const Elf_Half &E : *VersionsOrErr)
 621     S->Entries.push_back(E);
 622
 623   return S.release();
 624 }
 625
 626 template <class ELFT>
 627 Expected<ELFYAML::VerneedSection *>
 628 ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
 629   typedef typename ELFT::Verneed Elf_Verneed;
 630   typedef typename ELFT::Vernaux Elf_Vernaux;
 631
 632   auto S = std::make_unique<ELFYAML::VerneedSection>();
 633   if (Error E = dumpCommonSection(Shdr, *S))
 634     return std::move(E);
 635
 636   S->Info = Shdr->sh_info;
 637
 638   auto Contents = Obj.getSectionContents(Shdr);
 639   if (!Contents)
 640     return Contents.takeError();
 641
 642   auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
 643   if (!StringTableShdrOrErr)
 644     return StringTableShdrOrErr.takeError();
 645
 646   auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
 647   if (!StringTableOrErr)
 648     return StringTableOrErr.takeError();
 649
 650   llvm::ArrayRef<uint8_t> Data = *Contents;
 651   const uint8_t *Buf = Data.data();
 652   while (Buf) {
 653     const Elf_Verneed *Verneed = reinterpret_cast<const Elf_Verneed *>(Buf);
 654
 655     ELFYAML::VerneedEntry Entry;
 656     Entry.Version = Verneed->vn_version;
 657     Entry.File =
 658         StringRef(StringTableOrErr->drop_front(Verneed->vn_file).data());
 659
 660     const uint8_t *BufAux = Buf + Verneed->vn_aux;
 661     while (BufAux) {
 662       const Elf_Vernaux *Vernaux =
 663           reinterpret_cast<const Elf_Vernaux *>(BufAux);
 664
 665       ELFYAML::VernauxEntry Aux;
 666       Aux.Hash = Vernaux->vna_hash;
 667       Aux.Flags = Vernaux->vna_flags;
 668       Aux.Other = Vernaux->vna_other;
 669       Aux.Name =
 670           StringRef(StringTableOrErr->drop_front(Vernaux->vna_name).data());
 671
 672       Entry.AuxV.push_back(Aux);
 673       BufAux = Vernaux->vna_next ? BufAux + Vernaux->vna_next : nullptr;
 674     }
 675
 676     S->VerneedV.push_back(Entry);
 677     Buf = Verneed->vn_next ? Buf + Verneed->vn_next : nullptr;
 678   }
 679
 680   return S.release();
 681 }
 682
 683 template <class ELFT>
 684 Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
 685   auto S = std::make_unique<ELFYAML::Group>();
 686   if (Error E = dumpCommonSection(Shdr, *S))
 687     return std::move(E);
 688
 689   auto SymtabOrErr = Obj.getSection(Shdr->sh_link);
 690   if (!SymtabOrErr)
 691     return SymtabOrErr.takeError();
 692   // Get symbol with index sh_info which name is the signature of the group.
 693   const Elf_Shdr *Symtab = *SymtabOrErr;
 694   auto SymOrErr = Obj.getSymbol(Symtab, Shdr->sh_info);
 695   if (!SymOrErr)
 696     return SymOrErr.takeError();
 697   auto StrTabOrErr = Obj.getStringTableForSymtab(*Symtab);
 698   if (!StrTabOrErr)
 699     return StrTabOrErr.takeError();
 700
 701   Expected<StringRef> SymbolName =
 702       getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
 703   if (!SymbolName)
 704     return SymbolName.takeError();
 705   S->Signature = *SymbolName;
 706
 707   auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);
 708   if (!MembersOrErr)
 709     return MembersOrErr.takeError();
 710
 711   for (Elf_Word Member : *MembersOrErr) {
 712     if (Member == llvm::ELF::GRP_COMDAT) {
 713       S->Members.push_back({"GRP_COMDAT"});
 714       continue;
 715     }
 716
 717     auto SHdrOrErr = Obj.getSection(Member);
 718     if (!SHdrOrErr)
 719       return SHdrOrErr.takeError();
 720     auto NameOrErr = getUniquedSectionName(*SHdrOrErr);
 721     if (!NameOrErr)
 722       return NameOrErr.takeError();
 723     S->Members.push_back({*NameOrErr});
 724   }
 725   return S.release();
 726 }
 727
 728 template <class ELFT>
 729 Expected<ELFYAML::MipsABIFlags *>
 730 ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
 731   assert(Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS &&
 732          "Section type is not SHT_MIPS_ABIFLAGS");
 733   auto S = std::make_unique<ELFYAML::MipsABIFlags>();
 734   if (Error E = dumpCommonSection(Shdr, *S))
 735     return std::move(E);
 736
 737   auto ContentOrErr = Obj.getSectionContents(Shdr);
 738   if (!ContentOrErr)
 739     return ContentOrErr.takeError();
 740
 741   auto *Flags = reinterpret_cast<const object::Elf_Mips_ABIFlags<ELFT> *>(
 742       ContentOrErr.get().data());
 743   S->Version = Flags->version;
 744   S->ISALevel = Flags->isa_level;
 745   S->ISARevision = Flags->isa_rev;
 746   S->GPRSize = Flags->gpr_size;
 747   S->CPR1Size = Flags->cpr1_size;
 748   S->CPR2Size = Flags->cpr2_size;
 749   S->FpABI = Flags->fp_abi;
 750   S->ISAExtension = Flags->isa_ext;
 751   S->ASEs = Flags->ases;
 752   S->Flags1 = Flags->flags1;
 753   S->Flags2 = Flags->flags2;
 754   return S.release();
 755 }
 756
 757 template <class ELFT>
 758 static Error elf2yaml(raw_ostream &Out, const object::ELFFile<ELFT> &Obj) {
 759   ELFDumper<ELFT> Dumper(Obj);
 760   Expected<ELFYAML::Object *> YAMLOrErr = Dumper.dump();
 761   if (!YAMLOrErr)
 762     return YAMLOrErr.takeError();
 763
 764   std::unique_ptr<ELFYAML::Object> YAML(YAMLOrErr.get());
 765   yaml::Output Yout(Out);
 766   Yout << *YAML;
 767
 768   return Error::success();
 769 }
 770
 771 Error elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) {
 772   if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(&Obj))
 773     return elf2yaml(Out, *ELFObj->getELFFile());
 774
 775   if (const auto *ELFObj = dyn_cast<object::ELF32BEObjectFile>(&Obj))
 776     return elf2yaml(Out, *ELFObj->getELFFile());
 777
 778   if (const auto *ELFObj = dyn_cast<object::ELF64LEObjectFile>(&Obj))
 779     return elf2yaml(Out, *ELFObj->getELFFile());
 780
 781   if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(&Obj))
 782     return elf2yaml(Out, *ELFObj->getELFFile());
 783
 784   llvm_unreachable("unknown ELF file format");
 785 }