tools/llvm-readobj/ELFDumper.cpp

   1 //===-- ELFDumper.cpp - ELF-specific dumper ---------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 ///
  10 /// \file
  11 /// \brief This file implements the ELF-specific dumper for llvm-readobj.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm-readobj.h"
  16 #include "ARMAttributeParser.h"
  17 #include "ARMEHABIPrinter.h"
  18 #include "Error.h"
  19 #include "ObjDumper.h"
  20 #include "StackMapPrinter.h"
  21 #include "StreamWriter.h"
  22 #include "llvm/ADT/Optional.h"
  23 #include "llvm/ADT/SmallString.h"
  24 #include "llvm/ADT/StringExtras.h"
  25 #include "llvm/Object/ELFObjectFile.h"
  26 #include "llvm/Support/ARMBuildAttributes.h"
  27 #include "llvm/Support/Compiler.h"
  28 #include "llvm/Support/Format.h"
  29 #include "llvm/Support/MathExtras.h"
  30 #include "llvm/Support/MipsABIFlags.h"
  31 #include "llvm/Support/raw_ostream.h"
  32 #include "llvm/Support/FormattedStream.h"
  33
  34 using namespace llvm;
  35 using namespace llvm::object;
  36 using namespace ELF;
  37
  38 #define LLVM_READOBJ_ENUM_CASE(ns, enum) \
  39   case ns::enum: return #enum;
  40
  41 #define ENUM_ENT(enum, altName) \
  42   { #enum, altName, ELF::enum }
  43
  44 #define ENUM_ENT_1(enum) \
  45   { #enum, #enum, ELF::enum }
  46
  47 namespace {
  48
  49 template <class ELFT> class DumpStyle;
  50
  51 /// Represents a contiguous uniform range in the file. We cannot just create a
  52 /// range directly because when creating one of these from the .dynamic table
  53 /// the size, entity size and virtual address are different entries in arbitrary
  54 /// order (DT_REL, DT_RELSZ, DT_RELENT for example).
  55 struct DynRegionInfo {
  56   DynRegionInfo() : Addr(nullptr), Size(0), EntSize(0) {}
  57   DynRegionInfo(const void *A, uint64_t S, uint64_t ES)
  58       : Addr(A), Size(S), EntSize(ES) {}
  59   /// \brief Address in current address space.
  60   const void *Addr;
  61   /// \brief Size in bytes of the region.
  62   uint64_t Size;
  63   /// \brief Size of each entity in the region.
  64   uint64_t EntSize;
  65
  66   template <typename Type> iterator_range<const Type *> getAsRange() const {
  67     const Type *Start = reinterpret_cast<const Type *>(Addr);
  68     if (!Start)
  69       return {Start, Start};
  70     if (EntSize != sizeof(Type) || Size % EntSize)
  71       reportError("Invalid entity size");
  72     return {Start, Start + (Size / EntSize)};
  73   }
  74 };
  75
  76 template<typename ELFT>
  77 class ELFDumper : public ObjDumper {
  78 public:
  79   ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer);
  80
  81   void printFileHeaders() override;
  82   void printSections() override;
  83   void printRelocations() override;
  84   void printDynamicRelocations() override;
  85   void printSymbols() override;
  86   void printDynamicSymbols() override;
  87   void printUnwindInfo() override;
  88
  89   void printDynamicTable() override;
  90   void printNeededLibraries() override;
  91   void printProgramHeaders() override;
  92   void printHashTable() override;
  93   void printGnuHashTable() override;
  94   void printLoadName() override;
  95   void printVersionInfo() override;
  96   void printGroupSections() override;
  97
  98   void printAttributes() override;
  99   void printMipsPLTGOT() override;
 100   void printMipsABIFlags() override;
 101   void printMipsReginfo() override;
 102
 103   void printStackMap() const override;
 104
 105 private:
 106   std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
 107   typedef ELFFile<ELFT> ELFO;
 108   typedef typename ELFO::Elf_Shdr Elf_Shdr;
 109   typedef typename ELFO::Elf_Sym Elf_Sym;
 110   typedef typename ELFO::Elf_Sym_Range Elf_Sym_Range;
 111   typedef typename ELFO::Elf_Dyn Elf_Dyn;
 112   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
 113   typedef typename ELFO::Elf_Rel Elf_Rel;
 114   typedef typename ELFO::Elf_Rela Elf_Rela;
 115   typedef typename ELFO::Elf_Rel_Range Elf_Rel_Range;
 116   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;
 117   typedef typename ELFO::Elf_Phdr Elf_Phdr;
 118   typedef typename ELFO::Elf_Half Elf_Half;
 119   typedef typename ELFO::Elf_Hash Elf_Hash;
 120   typedef typename ELFO::Elf_GnuHash Elf_GnuHash;
 121   typedef typename ELFO::Elf_Ehdr Elf_Ehdr;
 122   typedef typename ELFO::Elf_Word Elf_Word;
 123   typedef typename ELFO::uintX_t uintX_t;
 124   typedef typename ELFO::Elf_Versym Elf_Versym;
 125   typedef typename ELFO::Elf_Verneed Elf_Verneed;
 126   typedef typename ELFO::Elf_Vernaux Elf_Vernaux;
 127   typedef typename ELFO::Elf_Verdef Elf_Verdef;
 128   typedef typename ELFO::Elf_Verdaux Elf_Verdaux;
 129
 130   DynRegionInfo checkDRI(DynRegionInfo DRI) {
 131     if (DRI.Addr < Obj->base() ||
 132         (const uint8_t *)DRI.Addr + DRI.Size > Obj->base() + Obj->getBufSize())
 133       error(llvm::object::object_error::parse_failed);
 134     return DRI;
 135   }
 136
 137   DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) {
 138     return checkDRI({Obj->base() + P->p_offset, P->p_filesz, EntSize});
 139   }
 140
 141   DynRegionInfo createDRIFrom(const Elf_Shdr *S) {
 142     return checkDRI({Obj->base() + S->sh_offset, S->sh_size, S->sh_entsize});
 143   }
 144
 145   void parseDynamicTable(ArrayRef<const Elf_Phdr *> LoadSegments);
 146
 147   void printSymbolsHelper(bool IsDynamic);
 148   void printSymbol(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
 149                    StringRef StrTable, bool IsDynamic);
 150
 151   void printDynamicRelocation(Elf_Rela Rel);
 152   void printRelocations(const Elf_Shdr *Sec);
 153   void printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab);
 154   void printValue(uint64_t Type, uint64_t Value);
 155
 156   Elf_Rel_Range dyn_rels() const;
 157   Elf_Rela_Range dyn_relas() const;
 158   StringRef getDynamicString(uint64_t Offset) const;
 159   StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
 160                              bool &IsDefault);
 161   void LoadVersionMap();
 162   void LoadVersionNeeds(const Elf_Shdr *ec) const;
 163   void LoadVersionDefs(const Elf_Shdr *sec) const;
 164
 165   const ELFO *Obj;
 166   DynRegionInfo DynRelRegion;
 167   DynRegionInfo DynRelaRegion;
 168   DynRegionInfo DynPLTRelRegion;
 169   DynRegionInfo DynSymRegion;
 170   DynRegionInfo DynamicTable;
 171   StringRef DynamicStringTable;
 172   StringRef SOName;
 173   const Elf_Hash *HashTable = nullptr;
 174   const Elf_GnuHash *GnuHashTable = nullptr;
 175   const Elf_Shdr *DotSymtabSec = nullptr;
 176   ArrayRef<Elf_Word> ShndxTable;
 177
 178   const Elf_Shdr *dot_gnu_version_sec = nullptr;   // .gnu.version
 179   const Elf_Shdr *dot_gnu_version_r_sec = nullptr; // .gnu.version_r
 180   const Elf_Shdr *dot_gnu_version_d_sec = nullptr; // .gnu.version_d
 181
 182   // Records for each version index the corresponding Verdef or Vernaux entry.
 183   // This is filled the first time LoadVersionMap() is called.
 184   class VersionMapEntry : public PointerIntPair<const void *, 1> {
 185   public:
 186     // If the integer is 0, this is an Elf_Verdef*.
 187     // If the integer is 1, this is an Elf_Vernaux*.
 188     VersionMapEntry() : PointerIntPair<const void *, 1>(nullptr, 0) {}
 189     VersionMapEntry(const Elf_Verdef *verdef)
 190         : PointerIntPair<const void *, 1>(verdef, 0) {}
 191     VersionMapEntry(const Elf_Vernaux *vernaux)
 192         : PointerIntPair<const void *, 1>(vernaux, 1) {}
 193     bool isNull() const { return getPointer() == nullptr; }
 194     bool isVerdef() const { return !isNull() && getInt() == 0; }
 195     bool isVernaux() const { return !isNull() && getInt() == 1; }
 196     const Elf_Verdef *getVerdef() const {
 197       return isVerdef() ? (const Elf_Verdef *)getPointer() : nullptr;
 198     }
 199     const Elf_Vernaux *getVernaux() const {
 200       return isVernaux() ? (const Elf_Vernaux *)getPointer() : nullptr;
 201     }
 202   };
 203   mutable SmallVector<VersionMapEntry, 16> VersionMap;
 204
 205 public:
 206   Elf_Dyn_Range dynamic_table() const {
 207     return DynamicTable.getAsRange<Elf_Dyn>();
 208   }
 209
 210   Elf_Sym_Range dynamic_symbols() const {
 211     return DynSymRegion.getAsRange<Elf_Sym>();
 212   }
 213
 214   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
 215                                 bool IsDynamic);
 216   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
 217   ArrayRef<Elf_Word> getShndxTable() { return ShndxTable; }
 218   StringRef getDynamicStringTable() const { return DynamicStringTable; }
 219 };
 220
 221 template <typename ELFT> class DumpStyle {
 222 public:
 223   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
 224   virtual ~DumpStyle() { }
 225 };
 226
 227 template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
 228   formatted_raw_ostream OS;
 229
 230 public:
 231   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
 232   GNUStyle(StreamWriter &W) : OS(W.getOStream()) {}
 233   void printFileHeaders(const ELFFile<ELFT> *Obj) override;
 234
 235 private:
 236   template <typename T, typename TEnum>
 237   std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
 238     for (const auto &EnumItem : EnumValues)
 239       if (EnumItem.Value == Value)
 240         return EnumItem.AltName;
 241     return to_hexString(Value);
 242   }
 243 };
 244
 245 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 246 public:
 247   typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
 248   LLVMStyle(StreamWriter &W) : W(W) {}
 249
 250   void printFileHeaders(const ELFFile<ELFT> *Obj) override;
 251
 252 private:
 253   StreamWriter &W;
 254 };
 255
 256 } // namespace
 257
 258 namespace llvm {
 259
 260 template <class ELFT>
 261 static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
 262                                        StreamWriter &Writer,
 263                                        std::unique_ptr<ObjDumper> &Result) {
 264   Result.reset(new ELFDumper<ELFT>(Obj, Writer));
 265   return readobj_error::success;
 266 }
 267
 268 std::error_code createELFDumper(const object::ObjectFile *Obj,
 269                                 StreamWriter &Writer,
 270                                 std::unique_ptr<ObjDumper> &Result) {
 271   // Little-endian 32-bit
 272   if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
 273     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 274
 275   // Big-endian 32-bit
 276   if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
 277     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 278
 279   // Little-endian 64-bit
 280   if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
 281     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 282
 283   // Big-endian 64-bit
 284   if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
 285     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 286
 287   return readobj_error::unsupported_obj_file_format;
 288 }
 289
 290 } // namespace llvm
 291
 292 // Iterate through the versions needed section, and place each Elf_Vernaux
 293 // in the VersionMap according to its index.
 294 template <class ELFT>
 295 void ELFDumper<ELFT>::LoadVersionNeeds(const Elf_Shdr *sec) const {
 296   unsigned vn_size = sec->sh_size;  // Size of section in bytes
 297   unsigned vn_count = sec->sh_info; // Number of Verneed entries
 298   const char *sec_start = (const char *)Obj->base() + sec->sh_offset;
 299   const char *sec_end = sec_start + vn_size;
 300   // The first Verneed entry is at the start of the section.
 301   const char *p = sec_start;
 302   for (unsigned i = 0; i < vn_count; i++) {
 303     if (p + sizeof(Elf_Verneed) > sec_end)
 304       report_fatal_error("Section ended unexpectedly while scanning "
 305                          "version needed records.");
 306     const Elf_Verneed *vn = reinterpret_cast<const Elf_Verneed *>(p);
 307     if (vn->vn_version != ELF::VER_NEED_CURRENT)
 308       report_fatal_error("Unexpected verneed version");
 309     // Iterate through the Vernaux entries
 310     const char *paux = p + vn->vn_aux;
 311     for (unsigned j = 0; j < vn->vn_cnt; j++) {
 312       if (paux + sizeof(Elf_Vernaux) > sec_end)
 313         report_fatal_error("Section ended unexpected while scanning auxiliary "
 314                            "version needed records.");
 315       const Elf_Vernaux *vna = reinterpret_cast<const Elf_Vernaux *>(paux);
 316       size_t index = vna->vna_other & ELF::VERSYM_VERSION;
 317       if (index >= VersionMap.size())
 318         VersionMap.resize(index + 1);
 319       VersionMap[index] = VersionMapEntry(vna);
 320       paux += vna->vna_next;
 321     }
 322     p += vn->vn_next;
 323   }
 324 }
 325
 326 // Iterate through the version definitions, and place each Elf_Verdef
 327 // in the VersionMap according to its index.
 328 template <class ELFT>
 329 void ELFDumper<ELFT>::LoadVersionDefs(const Elf_Shdr *sec) const {
 330   unsigned vd_size = sec->sh_size;  // Size of section in bytes
 331   unsigned vd_count = sec->sh_info; // Number of Verdef entries
 332   const char *sec_start = (const char *)Obj->base() + sec->sh_offset;
 333   const char *sec_end = sec_start + vd_size;
 334   // The first Verdef entry is at the start of the section.
 335   const char *p = sec_start;
 336   for (unsigned i = 0; i < vd_count; i++) {
 337     if (p + sizeof(Elf_Verdef) > sec_end)
 338       report_fatal_error("Section ended unexpectedly while scanning "
 339                          "version definitions.");
 340     const Elf_Verdef *vd = reinterpret_cast<const Elf_Verdef *>(p);
 341     if (vd->vd_version != ELF::VER_DEF_CURRENT)
 342       report_fatal_error("Unexpected verdef version");
 343     size_t index = vd->vd_ndx & ELF::VERSYM_VERSION;
 344     if (index >= VersionMap.size())
 345       VersionMap.resize(index + 1);
 346     VersionMap[index] = VersionMapEntry(vd);
 347     p += vd->vd_next;
 348   }
 349 }
 350
 351 template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() {
 352   // If there is no dynamic symtab or version table, there is nothing to do.
 353   if (!DynSymRegion.Addr || !dot_gnu_version_sec)
 354     return;
 355
 356   // Has the VersionMap already been loaded?
 357   if (VersionMap.size() > 0)
 358     return;
 359
 360   // The first two version indexes are reserved.
 361   // Index 0 is LOCAL, index 1 is GLOBAL.
 362   VersionMap.push_back(VersionMapEntry());
 363   VersionMap.push_back(VersionMapEntry());
 364
 365   if (dot_gnu_version_d_sec)
 366     LoadVersionDefs(dot_gnu_version_d_sec);
 367
 368   if (dot_gnu_version_r_sec)
 369     LoadVersionNeeds(dot_gnu_version_r_sec);
 370 }
 371
 372
 373 template <typename ELFO, class ELFT>
 374 static void printVersionSymbolSection(ELFDumper<ELFT> *Dumper,
 375                                       const ELFO *Obj,
 376                                       const typename ELFO::Elf_Shdr *Sec,
 377                                       StreamWriter &W) {
 378   DictScope SS(W, "Version symbols");
 379   if (!Sec)
 380     return;
 381   StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
 382   W.printNumber("Section Name", Name, Sec->sh_name);
 383   W.printHex("Address", Sec->sh_addr);
 384   W.printHex("Offset", Sec->sh_offset);
 385   W.printNumber("Link", Sec->sh_link);
 386
 387   const uint8_t *P = (const uint8_t *)Obj->base() + Sec->sh_offset;
 388   StringRef StrTable = Dumper->getDynamicStringTable();
 389
 390   // Same number of entries in the dynamic symbol table (DT_SYMTAB).
 391   ListScope Syms(W, "Symbols");
 392   for (const typename ELFO::Elf_Sym &Sym : Dumper->dynamic_symbols()) {
 393     DictScope S(W, "Symbol");
 394     std::string FullSymbolName =
 395         Dumper->getFullSymbolName(&Sym, StrTable, true /* IsDynamic */);
 396     W.printNumber("Version", *P);
 397     W.printString("Name", FullSymbolName);
 398     P += sizeof(typename ELFO::Elf_Half);
 399   }
 400 }
 401
 402 template <typename ELFO, class ELFT>
 403 static void printVersionDefinitionSection(ELFDumper<ELFT> *Dumper,
 404                                           const ELFO *Obj,
 405                                           const typename ELFO::Elf_Shdr *Sec,
 406                                           StreamWriter &W) {
 407   DictScope SD(W, "Version definition");
 408   if (!Sec)
 409     return;
 410   StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
 411   W.printNumber("Section Name", Name, Sec->sh_name);
 412   W.printHex("Address", Sec->sh_addr);
 413   W.printHex("Offset", Sec->sh_offset);
 414   W.printNumber("Link", Sec->sh_link);
 415
 416   unsigned verdef_entries = 0;
 417   // The number of entries in the section SHT_GNU_verdef
 418   // is determined by DT_VERDEFNUM tag.
 419   for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) {
 420     if (Dyn.d_tag == DT_VERDEFNUM)
 421       verdef_entries = Dyn.d_un.d_val;
 422   }
 423   const uint8_t *SecStartAddress =
 424       (const uint8_t *)Obj->base() + Sec->sh_offset;
 425   const uint8_t *SecEndAddress = SecStartAddress + Sec->sh_size;
 426   const uint8_t *P = SecStartAddress;
 427   const typename ELFO::Elf_Shdr *StrTab =
 428       unwrapOrError(Obj->getSection(Sec->sh_link));
 429
 430   ListScope Entries(W, "Entries");
 431   for (unsigned i = 0; i < verdef_entries; ++i) {
 432     if (P + sizeof(typename ELFO::Elf_Verdef) > SecEndAddress)
 433       report_fatal_error("invalid offset in the section");
 434     auto *VD = reinterpret_cast<const typename ELFO::Elf_Verdef *>(P);
 435     DictScope Entry(W, "Entry");
 436     W.printHex("Offset", (uintptr_t)P - (uintptr_t)SecStartAddress);
 437     W.printNumber("Rev", VD->vd_version);
 438     // FIXME: print something more readable.
 439     W.printNumber("Flags", VD->vd_flags);
 440     W.printNumber("Index", VD->vd_ndx);
 441     W.printNumber("Cnt", VD->vd_cnt);
 442     W.printString("Name",
 443                   StringRef((const char *)(Obj->base() + StrTab->sh_offset +
 444                                            VD->getAux()->vda_name)));
 445     P += VD->vd_next;
 446   }
 447 }
 448
 449 template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() {
 450   // Dump version symbol section.
 451   printVersionSymbolSection(this, Obj, dot_gnu_version_sec, W);
 452
 453   // Dump version definition section.
 454   printVersionDefinitionSection(this, Obj, dot_gnu_version_d_sec, W);
 455 }
 456
 457 template <typename ELFT>
 458 StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab,
 459                                             const Elf_Sym *symb,
 460                                             bool &IsDefault) {
 461   // This is a dynamic symbol. Look in the GNU symbol version table.
 462   if (!dot_gnu_version_sec) {
 463     // No version table.
 464     IsDefault = false;
 465     return StringRef("");
 466   }
 467
 468   // Determine the position in the symbol table of this entry.
 469   size_t entry_index = (reinterpret_cast<uintptr_t>(symb) -
 470                         reinterpret_cast<uintptr_t>(DynSymRegion.Addr)) /
 471                        sizeof(Elf_Sym);
 472
 473   // Get the corresponding version index entry
 474   const Elf_Versym *vs =
 475       Obj->template getEntry<Elf_Versym>(dot_gnu_version_sec, entry_index);
 476   size_t version_index = vs->vs_index & ELF::VERSYM_VERSION;
 477
 478   // Special markers for unversioned symbols.
 479   if (version_index == ELF::VER_NDX_LOCAL ||
 480       version_index == ELF::VER_NDX_GLOBAL) {
 481     IsDefault = false;
 482     return StringRef("");
 483   }
 484
 485   // Lookup this symbol in the version table
 486   LoadVersionMap();
 487   if (version_index >= VersionMap.size() || VersionMap[version_index].isNull())
 488     reportError("Invalid version entry");
 489   const VersionMapEntry &entry = VersionMap[version_index];
 490
 491   // Get the version name string
 492   size_t name_offset;
 493   if (entry.isVerdef()) {
 494     // The first Verdaux entry holds the name.
 495     name_offset = entry.getVerdef()->getAux()->vda_name;
 496     IsDefault = !(vs->vs_index & ELF::VERSYM_HIDDEN);
 497   } else {
 498     name_offset = entry.getVernaux()->vna_name;
 499     IsDefault = false;
 500   }
 501   if (name_offset >= StrTab.size())
 502     reportError("Invalid string offset");
 503   return StringRef(StrTab.data() + name_offset);
 504 }
 505
 506 template <typename ELFT>
 507 std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
 508                                                StringRef StrTable,
 509                                                bool IsDynamic) {
 510   StringRef SymbolName = unwrapOrError(Symbol->getName(StrTable));
 511   if (!IsDynamic)
 512     return SymbolName;
 513
 514   std::string FullSymbolName(SymbolName);
 515
 516   bool IsDefault;
 517   StringRef Version = getSymbolVersion(StrTable, &*Symbol, IsDefault);
 518   FullSymbolName += (IsDefault ? "@@" : "@");
 519   FullSymbolName += Version;
 520   return FullSymbolName;
 521 }
 522
 523 template <typename ELFO>
 524 static void
 525 getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol,
 526                     const typename ELFO::Elf_Sym *FirstSym,
 527                     ArrayRef<typename ELFO::Elf_Word> ShndxTable,
 528                     StringRef &SectionName, unsigned &SectionIndex) {
 529   SectionIndex = Symbol->st_shndx;
 530   if (Symbol->isUndefined())
 531     SectionName = "Undefined";
 532   else if (Symbol->isProcessorSpecific())
 533     SectionName = "Processor Specific";
 534   else if (Symbol->isOSSpecific())
 535     SectionName = "Operating System Specific";
 536   else if (Symbol->isAbsolute())
 537     SectionName = "Absolute";
 538   else if (Symbol->isCommon())
 539     SectionName = "Common";
 540   else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX)
 541     SectionName = "Reserved";
 542   else {
 543     if (SectionIndex == SHN_XINDEX)
 544       SectionIndex =
 545           Obj.getExtendedSymbolTableIndex(Symbol, FirstSym, ShndxTable);
 546     const typename ELFO::Elf_Shdr *Sec =
 547         unwrapOrError(Obj.getSection(SectionIndex));
 548     SectionName = unwrapOrError(Obj.getSectionName(Sec));
 549   }
 550 }
 551
 552 template <class ELFO>
 553 static const typename ELFO::Elf_Shdr *
 554 findNotEmptySectionByAddress(const ELFO *Obj, uint64_t Addr) {
 555   for (const auto &Shdr : Obj->sections())
 556     if (Shdr.sh_addr == Addr && Shdr.sh_size > 0)
 557       return &Shdr;
 558   return nullptr;
 559 }
 560
 561 template <class ELFO>
 562 static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj,
 563                                                         StringRef Name) {
 564   for (const auto &Shdr : Obj.sections()) {
 565     if (Name == unwrapOrError(Obj.getSectionName(&Shdr)))
 566       return &Shdr;
 567   }
 568   return nullptr;
 569 }
 570
 571 static const EnumEntry<unsigned> ElfClass[] = {
 572   {"None",   "none",   ELF::ELFCLASSNONE},
 573   {"32-bit", "ELF32",  ELF::ELFCLASS32},
 574   {"64-bit", "ELF64",  ELF::ELFCLASS64},
 575 };
 576
 577 static const EnumEntry<unsigned> ElfDataEncoding[] = {
 578   {"None",         "none",                          ELF::ELFDATANONE},
 579   {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB},
 580   {"BigEndian",    "2's complement, big endian",    ELF::ELFDATA2MSB},
 581 };
 582
 583 static const EnumEntry<unsigned> ElfObjectFileType[] = {
 584   {"None",         "NONE (none)",              ELF::ET_NONE},
 585   {"Relocatable",  "REL (Relocatable file)",   ELF::ET_REL},
 586   {"Executable",   "EXEC (Executable file)",   ELF::ET_EXEC},
 587   {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN},
 588   {"Core",         "CORE (Core file)",         ELF::ET_CORE},
 589 };
 590
 591 static const EnumEntry<unsigned> ElfOSABI[] = {
 592   {"SystemV",      "UNIX - System V",      ELF::ELFOSABI_NONE},
 593   {"HPUX",         "UNIX - HP-UX",         ELF::ELFOSABI_HPUX},
 594   {"NetBSD",       "UNIX - NetBSD",        ELF::ELFOSABI_NETBSD},
 595   {"GNU/Linux",    "UNIX - GNU",           ELF::ELFOSABI_LINUX},
 596   {"GNU/Hurd",     "GNU/Hurd",             ELF::ELFOSABI_HURD},
 597   {"Solaris",      "UNIX - Solaris",       ELF::ELFOSABI_SOLARIS},
 598   {"AIX",          "UNIX - AIX",           ELF::ELFOSABI_AIX},
 599   {"IRIX",         "UNIX - IRIX",          ELF::ELFOSABI_IRIX},
 600   {"FreeBSD",      "UNIX - FreeBSD",       ELF::ELFOSABI_FREEBSD},
 601   {"TRU64",        "UNIX - TRU64",         ELF::ELFOSABI_TRU64},
 602   {"Modesto",      "Novell - Modesto",     ELF::ELFOSABI_MODESTO},
 603   {"OpenBSD",      "UNIX - OpenBSD",       ELF::ELFOSABI_OPENBSD},
 604   {"OpenVMS",      "VMS - OpenVMS",        ELF::ELFOSABI_OPENVMS},
 605   {"NSK",          "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK},
 606   {"AROS",         "AROS",                 ELF::ELFOSABI_AROS},
 607   {"FenixOS",      "FenixOS",              ELF::ELFOSABI_FENIXOS},
 608   {"CloudABI",     "CloudABI",             ELF::ELFOSABI_CLOUDABI},
 609   {"C6000_ELFABI", "Bare-metal C6000",     ELF::ELFOSABI_C6000_ELFABI},
 610   {"C6000_LINUX",  "Linux C6000",          ELF::ELFOSABI_C6000_LINUX},
 611   {"ARM",          "ARM",                  ELF::ELFOSABI_ARM},
 612   {"Standalone",   "Standalone App",       ELF::ELFOSABI_STANDALONE}
 613 };
 614
 615 static const EnumEntry<unsigned> ElfMachineType[] = {
 616   ENUM_ENT(EM_NONE,          "None"),
 617   ENUM_ENT(EM_M32,           "WE32100"),
 618   ENUM_ENT(EM_SPARC,         "Sparc"),
 619   ENUM_ENT(EM_386,           "Intel 80386"),
 620   ENUM_ENT(EM_68K,           "MC68000"),
 621   ENUM_ENT(EM_88K,           "MC88000"),
 622   ENUM_ENT(EM_IAMCU,         "EM_IAMCU"),
 623   ENUM_ENT(EM_860,           "Intel 80860"),
 624   ENUM_ENT(EM_MIPS,          "MIPS R3000"),
 625   ENUM_ENT(EM_S370,          "IBM System/370"),
 626   ENUM_ENT(EM_MIPS_RS3_LE,   "MIPS R3000 little-endian"),
 627   ENUM_ENT(EM_PARISC,        "HPPA"),
 628   ENUM_ENT(EM_VPP500,        "Fujitsu VPP500"),
 629   ENUM_ENT(EM_SPARC32PLUS,   "Sparc v8+"),
 630   ENUM_ENT(EM_960,           "Intel 80960"),
 631   ENUM_ENT(EM_PPC,           "PowerPC"),
 632   ENUM_ENT(EM_PPC64,         "PowerPC64"),
 633   ENUM_ENT(EM_S390,          "IBM S/390"),
 634   ENUM_ENT(EM_SPU,           "SPU"),
 635   ENUM_ENT(EM_V800,          "NEC V800 series"),
 636   ENUM_ENT(EM_FR20,          "Fujistsu FR20"),
 637   ENUM_ENT(EM_RH32,          "TRW RH-32"),
 638   ENUM_ENT(EM_RCE,           "Motorola RCE"),
 639   ENUM_ENT(EM_ARM,           "ARM"),
 640   ENUM_ENT(EM_ALPHA,         "EM_ALPHA"),
 641   ENUM_ENT(EM_SH,            "Hitachi SH"),
 642   ENUM_ENT(EM_SPARCV9,       "Sparc v9"),
 643   ENUM_ENT(EM_TRICORE,       "Siemens Tricore"),
 644   ENUM_ENT(EM_ARC,           "ARC"),
 645   ENUM_ENT(EM_H8_300,        "Hitachi H8/300"),
 646   ENUM_ENT(EM_H8_300H,       "Hitachi H8/300H"),
 647   ENUM_ENT(EM_H8S,           "Hitachi H8S"),
 648   ENUM_ENT(EM_H8_500,        "Hitachi H8/500"),
 649   ENUM_ENT(EM_IA_64,         "Intel IA-64"),
 650   ENUM_ENT(EM_MIPS_X,        "Stanford MIPS-X"),
 651   ENUM_ENT(EM_COLDFIRE,      "Motorola Coldfire"),
 652   ENUM_ENT(EM_68HC12,        "Motorola MC68HC12 Microcontroller"),
 653   ENUM_ENT(EM_MMA,           "Fujitsu Multimedia Accelerator"),
 654   ENUM_ENT(EM_PCP,           "Siemens PCP"),
 655   ENUM_ENT(EM_NCPU,          "Sony nCPU embedded RISC processor"),
 656   ENUM_ENT(EM_NDR1,          "Denso NDR1 microprocesspr"),
 657   ENUM_ENT(EM_STARCORE,      "Motorola Star*Core processor"),
 658   ENUM_ENT(EM_ME16,          "Toyota ME16 processor"),
 659   ENUM_ENT(EM_ST100,         "STMicroelectronics ST100 processor"),
 660   ENUM_ENT(EM_TINYJ,         "Advanced Logic Corp. TinyJ embedded processor"),
 661   ENUM_ENT(EM_X86_64,        "Advanced Micro Devices X86-64"),
 662   ENUM_ENT(EM_PDSP,          "Sony DSP processor"),
 663   ENUM_ENT(EM_PDP10,         "Digital Equipment Corp. PDP-10"),
 664   ENUM_ENT(EM_PDP11,         "Digital Equipment Corp. PDP-11"),
 665   ENUM_ENT(EM_FX66,          "Siemens FX66 microcontroller"),
 666   ENUM_ENT(EM_ST9PLUS,       "STMicroelectronics ST9+ 8/16 bit microcontroller"),
 667   ENUM_ENT(EM_ST7,           "STMicroelectronics ST7 8-bit microcontroller"),
 668   ENUM_ENT(EM_68HC16,        "Motorola MC68HC16 Microcontroller"),
 669   ENUM_ENT(EM_68HC11,        "Motorola MC68HC11 Microcontroller"),
 670   ENUM_ENT(EM_68HC08,        "Motorola MC68HC08 Microcontroller"),
 671   ENUM_ENT(EM_68HC05,        "Motorola MC68HC05 Microcontroller"),
 672   ENUM_ENT(EM_SVX,           "Silicon Graphics SVx"),
 673   ENUM_ENT(EM_ST19,          "STMicroelectronics ST19 8-bit microcontroller"),
 674   ENUM_ENT(EM_VAX,           "Digital VAX"),
 675   ENUM_ENT(EM_CRIS,          "Axis Communications 32-bit embedded processor"),
 676   ENUM_ENT(EM_JAVELIN,       "Infineon Technologies 32-bit embedded cpu"),
 677   ENUM_ENT(EM_FIREPATH,      "Element 14 64-bit DSP processor"),
 678   ENUM_ENT(EM_ZSP,           "LSI Logic's 16-bit DSP processor"),
 679   ENUM_ENT(EM_MMIX,          "Donald Knuth's educational 64-bit processor"),
 680   ENUM_ENT(EM_HUANY,         "Harvard Universitys's machine-independent object format"),
 681   ENUM_ENT(EM_PRISM,         "Vitesse Prism"),
 682   ENUM_ENT(EM_AVR,           "Atmel AVR 8-bit microcontroller"),
 683   ENUM_ENT(EM_FR30,          "Fujitsu FR30"),
 684   ENUM_ENT(EM_D10V,          "Mitsubishi D10V"),
 685   ENUM_ENT(EM_D30V,          "Mitsubishi D30V"),
 686   ENUM_ENT(EM_V850,          "NEC v850"),
 687   ENUM_ENT(EM_M32R,          "Renesas M32R (formerly Mitsubishi M32r)"),
 688   ENUM_ENT(EM_MN10300,       "Matsushita MN10300"),
 689   ENUM_ENT(EM_MN10200,       "Matsushita MN10200"),
 690   ENUM_ENT(EM_PJ,            "picoJava"),
 691   ENUM_ENT(EM_OPENRISC,      "OpenRISC 32-bit embedded processor"),
 692   ENUM_ENT(EM_ARC_COMPACT,   "EM_ARC_COMPACT"),
 693   ENUM_ENT(EM_XTENSA,        "Tensilica Xtensa Processor"),
 694   ENUM_ENT(EM_VIDEOCORE,     "Alphamosaic VideoCore processor"),
 695   ENUM_ENT(EM_TMM_GPP,       "Thompson Multimedia General Purpose Processor"),
 696   ENUM_ENT(EM_NS32K,         "National Semiconductor 32000 series"),
 697   ENUM_ENT(EM_TPC,           "Tenor Network TPC processor"),
 698   ENUM_ENT(EM_SNP1K,         "EM_SNP1K"),
 699   ENUM_ENT(EM_ST200,         "STMicroelectronics ST200 microcontroller"),
 700   ENUM_ENT(EM_IP2K,          "Ubicom IP2xxx 8-bit microcontrollers"),
 701   ENUM_ENT(EM_MAX,           "MAX Processor"),
 702   ENUM_ENT(EM_CR,            "National Semiconductor CompactRISC"),
 703   ENUM_ENT(EM_F2MC16,        "Fujitsu F2MC16"),
 704   ENUM_ENT(EM_MSP430,        "Texas Instruments msp430 microcontroller"),
 705   ENUM_ENT(EM_BLACKFIN,      "Analog Devices Blackfin"),
 706   ENUM_ENT(EM_SE_C33,        "S1C33 Family of Seiko Epson processors"),
 707   ENUM_ENT(EM_SEP,           "Sharp embedded microprocessor"),
 708   ENUM_ENT(EM_ARCA,          "Arca RISC microprocessor"),
 709   ENUM_ENT(EM_UNICORE,       "Unicore"),
 710   ENUM_ENT(EM_EXCESS,        "eXcess 16/32/64-bit configurable embedded CPU"),
 711   ENUM_ENT(EM_DXP,           "Icera Semiconductor Inc. Deep Execution Processor"),
 712   ENUM_ENT(EM_ALTERA_NIOS2,  "Altera Nios"),
 713   ENUM_ENT(EM_CRX,           "National Semiconductor CRX microprocessor"),
 714   ENUM_ENT(EM_XGATE,         "Motorola XGATE embedded processor"),
 715   ENUM_ENT(EM_C166,          "Infineon Technologies xc16x"),
 716   ENUM_ENT(EM_M16C,          "Renesas M16C"),
 717   ENUM_ENT(EM_DSPIC30F,      "Microchip Technology dsPIC30F Digital Signal Controller"),
 718   ENUM_ENT(EM_CE,            "Freescale Communication Engine RISC core"),
 719   ENUM_ENT(EM_M32C,          "Renesas M32C"),
 720   ENUM_ENT(EM_TSK3000,       "Altium TSK3000 core"),
 721   ENUM_ENT(EM_RS08,          "Freescale RS08 embedded processor"),
 722   ENUM_ENT(EM_SHARC,         "EM_SHARC"),
 723   ENUM_ENT(EM_ECOG2,         "Cyan Technology eCOG2 microprocessor"),
 724   ENUM_ENT(EM_SCORE7,        "SUNPLUS S+Core"),
 725   ENUM_ENT(EM_DSP24,         "New Japan Radio (NJR) 24-bit DSP Processor"),
 726   ENUM_ENT(EM_VIDEOCORE3,    "Broadcom VideoCore III processor"),
 727   ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"),
 728   ENUM_ENT(EM_SE_C17,        "Seiko Epson C17 family"),
 729   ENUM_ENT(EM_TI_C6000,      "Texas Instruments TMS320C6000 DSP family"),
 730   ENUM_ENT(EM_TI_C2000,      "Texas Instruments TMS320C2000 DSP family"),
 731   ENUM_ENT(EM_TI_C5500,      "Texas Instruments TMS320C55x DSP family"),
 732   ENUM_ENT(EM_MMDSP_PLUS,    "STMicroelectronics 64bit VLIW Data Signal Processor"),
 733   ENUM_ENT(EM_CYPRESS_M8C,   "Cypress M8C microprocessor"),
 734   ENUM_ENT(EM_R32C,          "Renesas R32C series microprocessors"),
 735   ENUM_ENT(EM_TRIMEDIA,      "NXP Semiconductors TriMedia architecture family"),
 736   ENUM_ENT(EM_HEXAGON,       "Qualcomm Hexagon"),
 737   ENUM_ENT(EM_8051,          "Intel 8051 and variants"),
 738   ENUM_ENT(EM_STXP7X,        "STMicroelectronics STxP7x family"),
 739   ENUM_ENT(EM_NDS32,         "Andes Technology compact code size embedded RISC processor family"),
 740   ENUM_ENT(EM_ECOG1,         "Cyan Technology eCOG1 microprocessor"),
 741   ENUM_ENT(EM_ECOG1X,        "Cyan Technology eCOG1X family"),
 742   ENUM_ENT(EM_MAXQ30,        "Dallas Semiconductor MAXQ30 Core microcontrollers"),
 743   ENUM_ENT(EM_XIMO16,        "New Japan Radio (NJR) 16-bit DSP Processor"),
 744   ENUM_ENT(EM_MANIK,         "M2000 Reconfigurable RISC Microprocessor"),
 745   ENUM_ENT(EM_CRAYNV2,       "Cray Inc. NV2 vector architecture"),
 746   ENUM_ENT(EM_RX,            "Renesas RX"),
 747   ENUM_ENT(EM_METAG,         "Imagination Technologies Meta processor architecture"),
 748   ENUM_ENT(EM_MCST_ELBRUS,   "MCST Elbrus general purpose hardware architecture"),
 749   ENUM_ENT(EM_ECOG16,        "Cyan Technology eCOG16 family"),
 750   ENUM_ENT(EM_CR16,          "Xilinx MicroBlaze"),
 751   ENUM_ENT(EM_ETPU,          "Freescale Extended Time Processing Unit"),
 752   ENUM_ENT(EM_SLE9X,         "Infineon Technologies SLE9X core"),
 753   ENUM_ENT(EM_L10M,          "EM_L10M"),
 754   ENUM_ENT(EM_K10M,          "EM_K10M"),
 755   ENUM_ENT(EM_AARCH64,       "AArch64"),
 756   ENUM_ENT(EM_AVR32,         "Atmel AVR 8-bit microcontroller"),
 757   ENUM_ENT(EM_STM8,          "STMicroeletronics STM8 8-bit microcontroller"),
 758   ENUM_ENT(EM_TILE64,        "Tilera TILE64 multicore architecture family"),
 759   ENUM_ENT(EM_TILEPRO,       "Tilera TILEPro multicore architecture family"),
 760   ENUM_ENT(EM_CUDA,          "NVIDIA CUDA architecture"),
 761   ENUM_ENT(EM_TILEGX,        "Tilera TILE-Gx multicore architecture family"),
 762   ENUM_ENT(EM_CLOUDSHIELD,   "EM_CLOUDSHIELD"),
 763   ENUM_ENT(EM_COREA_1ST,     "EM_COREA_1ST"),
 764   ENUM_ENT(EM_COREA_2ND,     "EM_COREA_2ND"),
 765   ENUM_ENT(EM_ARC_COMPACT2,  "EM_ARC_COMPACT2"),
 766   ENUM_ENT(EM_OPEN8,         "EM_OPEN8"),
 767   ENUM_ENT(EM_RL78,          "Renesas RL78"),
 768   ENUM_ENT(EM_VIDEOCORE5,    "Broadcom VideoCore V processor"),
 769   ENUM_ENT(EM_78KOR,         "EM_78KOR"),
 770   ENUM_ENT(EM_56800EX,       "EM_56800EX"),
 771   ENUM_ENT(EM_AMDGPU,        "EM_AMDGPU"),
 772   ENUM_ENT(EM_WEBASSEMBLY,   "EM_WEBASSEMBLY"),
 773   ENUM_ENT(EM_LANAI,         "EM_LANAI"),
 774 };
 775
 776 static const EnumEntry<unsigned> ElfSymbolBindings[] = {
 777     {"Local",  "LOCAL",  ELF::STB_LOCAL},
 778     {"Global", "GLOBAL", ELF::STB_GLOBAL},
 779     {"Weak",   "WEAK",   ELF::STB_WEAK},
 780     {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};
 781
 782 static const EnumEntry<unsigned> ElfSymbolTypes[] = {
 783     {"None",      "NOTYPE",   ELF::STT_NOTYPE},
 784     {"Object",    "OBJECT",   ELF::STT_OBJECT},
 785     {"Function",  "FUNCTION", ELF::STT_FUNC},
 786     {"Section",   "SECTION",  ELF::STT_SECTION},
 787     {"File",      "FILE",     ELF::STT_FILE},
 788     {"Common",    "COMMON",   ELF::STT_COMMON},
 789     {"TLS",       "TLS",      ELF::STT_TLS},
 790     {"GNU_IFunc", "IFUNC",    ELF::STT_GNU_IFUNC}};
 791
 792 static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
 793   { "AMDGPU_HSA_KERNEL",            ELF::STT_AMDGPU_HSA_KERNEL },
 794   { "AMDGPU_HSA_INDIRECT_FUNCTION", ELF::STT_AMDGPU_HSA_INDIRECT_FUNCTION },
 795   { "AMDGPU_HSA_METADATA",          ELF::STT_AMDGPU_HSA_METADATA }
 796 };
 797
 798 static const char *getElfSectionType(unsigned Arch, unsigned Type) {
 799   switch (Arch) {
 800   case ELF::EM_ARM:
 801     switch (Type) {
 802     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
 803     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
 804     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
 805     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
 806     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
 807     }
 808   case ELF::EM_HEXAGON:
 809     switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
 810   case ELF::EM_X86_64:
 811     switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
 812   case ELF::EM_MIPS:
 813   case ELF::EM_MIPS_RS3_LE:
 814     switch (Type) {
 815     LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
 816     LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
 817     LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
 818     }
 819   }
 820
 821   switch (Type) {
 822   LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL              );
 823   LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS          );
 824   LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB            );
 825   LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB            );
 826   LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA              );
 827   LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH              );
 828   LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC           );
 829   LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE              );
 830   LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS            );
 831   LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL               );
 832   LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB             );
 833   LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM            );
 834   LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY        );
 835   LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY        );
 836   LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY     );
 837   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP             );
 838   LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX      );
 839   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES    );
 840   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
 841   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
 842   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
 843   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
 844   default: return "";
 845   }
 846 }
 847
 848 static const char *getGroupType(uint32_t Flag) {
 849   if (Flag & ELF::GRP_COMDAT)
 850     return "COMDAT";
 851   else
 852     return "(unknown)";
 853 }
 854
 855 static const EnumEntry<unsigned> ElfSectionFlags[] = {
 856   ENUM_ENT(SHF_WRITE,            "W"),
 857   ENUM_ENT(SHF_ALLOC,            "A"),
 858   ENUM_ENT(SHF_EXCLUDE,          "E"),
 859   ENUM_ENT(SHF_EXECINSTR,        "X"),
 860   ENUM_ENT(SHF_MERGE,            "M"),
 861   ENUM_ENT(SHF_STRINGS,          "S"),
 862   ENUM_ENT(SHF_INFO_LINK,        "I"),
 863   ENUM_ENT(SHF_LINK_ORDER,       "L"),
 864   ENUM_ENT(SHF_OS_NONCONFORMING, "o"),
 865   ENUM_ENT(SHF_GROUP,            "G"),
 866   ENUM_ENT(SHF_TLS,              "T"),
 867   ENUM_ENT_1(XCORE_SHF_CP_SECTION),
 868   ENUM_ENT_1(XCORE_SHF_DP_SECTION),
 869 };
 870
 871 static const EnumEntry<unsigned> ElfAMDGPUSectionFlags[] = {
 872   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_GLOBAL),
 873   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_READONLY),
 874   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_CODE),
 875   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_AGENT)
 876 };
 877
 878 static const EnumEntry<unsigned> ElfHexagonSectionFlags[] = {
 879   LLVM_READOBJ_ENUM_ENT(ELF, SHF_HEX_GPREL)
 880 };
 881
 882 static const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
 883   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NODUPES),
 884   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NAMES  ),
 885   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_LOCAL  ),
 886   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP),
 887   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_GPREL  ),
 888   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_MERGE  ),
 889   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_ADDR   ),
 890   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_STRING )
 891 };
 892
 893 static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
 894   LLVM_READOBJ_ENUM_ENT(ELF, SHF_X86_64_LARGE)
 895 };
 896
 897 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
 898   // Check potentially overlapped processor-specific
 899   // program header type.
 900   switch (Arch) {
 901   case ELF::EM_AMDGPU:
 902     switch (Type) {
 903     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM);
 904     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT);
 905     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_READONLY_AGENT);
 906     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_CODE_AGENT);
 907     }
 908   case ELF::EM_ARM:
 909     switch (Type) {
 910     LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
 911     }
 912   case ELF::EM_MIPS:
 913   case ELF::EM_MIPS_RS3_LE:
 914     switch (Type) {
 915     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
 916     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
 917     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
 918     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
 919     }
 920   }
 921
 922   switch (Type) {
 923   LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL   );
 924   LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD   );
 925   LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
 926   LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
 927   LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE   );
 928   LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB  );
 929   LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR   );
 930   LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS    );
 931
 932   LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
 933   LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
 934
 935   LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
 936   LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
 937   default: return "";
 938   }
 939 }
 940
 941 static const EnumEntry<unsigned> ElfSegmentFlags[] = {
 942   LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
 943   LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
 944   LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
 945 };
 946
 947 static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
 948   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
 949   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
 950   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
 951   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
 952   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
 953   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_FP64),
 954   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
 955   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
 956   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O64),
 957   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI32),
 958   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI64),
 959   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_3900),
 960   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4010),
 961   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4100),
 962   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4650),
 963   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4120),
 964   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4111),
 965   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_SB1),
 966   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON),
 967   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_XLR),
 968   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON2),
 969   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON3),
 970   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5400),
 971   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5900),
 972   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5500),
 973   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_9000),
 974   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2E),
 975   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2F),
 976   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS3A),
 977   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
 978   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
 979   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_MDMX),
 980   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
 981   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
 982   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
 983   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
 984   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
 985   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
 986   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
 987   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
 988   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
 989   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
 990   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
 991 };
 992
 993 template <typename ELFT>
 994 ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
 995     : ObjDumper(Writer), Obj(Obj) {
 996
 997   SmallVector<const Elf_Phdr *, 4> LoadSegments;
 998   for (const Elf_Phdr &Phdr : Obj->program_headers()) {
 999     if (Phdr.p_type == ELF::PT_DYNAMIC) {
1000       DynamicTable = createDRIFrom(&Phdr, sizeof(Elf_Dyn));
1001       continue;
1002     }
1003     if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0)
1004       continue;
1005     LoadSegments.push_back(&Phdr);
1006   }
1007
1008   for (const Elf_Shdr &Sec : Obj->sections()) {
1009     switch (Sec.sh_type) {
1010     case ELF::SHT_SYMTAB:
1011       if (DotSymtabSec != nullptr)
1012         reportError("Multilpe SHT_SYMTAB");
1013       DotSymtabSec = &Sec;
1014       break;
1015     case ELF::SHT_DYNSYM:
1016       if (DynSymRegion.Size)
1017         reportError("Multilpe SHT_DYNSYM");
1018       DynSymRegion = createDRIFrom(&Sec);
1019       break;
1020     case ELF::SHT_SYMTAB_SHNDX:
1021       ShndxTable = unwrapOrError(Obj->getSHNDXTable(Sec));
1022       break;
1023     case ELF::SHT_GNU_versym:
1024       if (dot_gnu_version_sec != nullptr)
1025         reportError("Multiple SHT_GNU_versym");
1026       dot_gnu_version_sec = &Sec;
1027       break;
1028     case ELF::SHT_GNU_verdef:
1029       if (dot_gnu_version_d_sec != nullptr)
1030         reportError("Multiple SHT_GNU_verdef");
1031       dot_gnu_version_d_sec = &Sec;
1032       break;
1033     case ELF::SHT_GNU_verneed:
1034       if (dot_gnu_version_r_sec != nullptr)
1035         reportError("Multilpe SHT_GNU_verneed");
1036       dot_gnu_version_r_sec = &Sec;
1037       break;
1038     }
1039   }
1040
1041   parseDynamicTable(LoadSegments);
1042
1043   if (opts::Output == opts::GNU)
1044     ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer));
1045   else
1046     ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer));
1047 }
1048
1049 template <typename ELFT>
1050 void ELFDumper<ELFT>::parseDynamicTable(
1051     ArrayRef<const Elf_Phdr *> LoadSegments) {
1052   auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
1053     const Elf_Phdr *const *I = std::upper_bound(
1054         LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>);
1055     if (I == LoadSegments.begin())
1056       report_fatal_error("Virtual address is not in any segment");
1057     --I;
1058     const Elf_Phdr &Phdr = **I;
1059     uint64_t Delta = VAddr - Phdr.p_vaddr;
1060     if (Delta >= Phdr.p_filesz)
1061       report_fatal_error("Virtual address is not in any segment");
1062     return Obj->base() + Phdr.p_offset + Delta;
1063   };
1064
1065   uint64_t SONameOffset = 0;
1066   const char *StringTableBegin = nullptr;
1067   uint64_t StringTableSize = 0;
1068   for (const Elf_Dyn &Dyn : dynamic_table()) {
1069     switch (Dyn.d_tag) {
1070     case ELF::DT_HASH:
1071       HashTable =
1072           reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
1073       break;
1074     case ELF::DT_GNU_HASH:
1075       GnuHashTable =
1076           reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr()));
1077       break;
1078     case ELF::DT_STRTAB:
1079       StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr());
1080       break;
1081     case ELF::DT_STRSZ:
1082       StringTableSize = Dyn.getVal();
1083       break;
1084     case ELF::DT_SYMTAB:
1085       DynSymRegion.Addr = toMappedAddr(Dyn.getPtr());
1086       DynSymRegion.EntSize = sizeof(Elf_Sym);
1087       break;
1088     case ELF::DT_RELA:
1089       DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
1090       break;
1091     case ELF::DT_RELASZ:
1092       DynRelaRegion.Size = Dyn.getVal();
1093       break;
1094     case ELF::DT_RELAENT:
1095       DynRelaRegion.EntSize = Dyn.getVal();
1096       break;
1097     case ELF::DT_SONAME:
1098       SONameOffset = Dyn.getVal();
1099       break;
1100     case ELF::DT_REL:
1101       DynRelRegion.Addr = toMappedAddr(Dyn.getPtr());
1102       break;
1103     case ELF::DT_RELSZ:
1104       DynRelRegion.Size = Dyn.getVal();
1105       break;
1106     case ELF::DT_RELENT:
1107       DynRelRegion.EntSize = Dyn.getVal();
1108       break;
1109     case ELF::DT_PLTREL:
1110       if (Dyn.getVal() == DT_REL)
1111         DynPLTRelRegion.EntSize = sizeof(Elf_Rel);
1112       else if (Dyn.getVal() == DT_RELA)
1113         DynPLTRelRegion.EntSize = sizeof(Elf_Rela);
1114       else
1115         reportError(Twine("unknown DT_PLTREL value of ") +
1116                     Twine((uint64_t)Dyn.getVal()));
1117       break;
1118     case ELF::DT_JMPREL:
1119       DynPLTRelRegion.Addr = toMappedAddr(Dyn.getPtr());
1120       break;
1121     case ELF::DT_PLTRELSZ:
1122       DynPLTRelRegion.Size = Dyn.getVal();
1123       break;
1124     }
1125   }
1126   if (StringTableBegin)
1127     DynamicStringTable = StringRef(StringTableBegin, StringTableSize);
1128   if (SONameOffset)
1129     SOName = getDynamicString(SONameOffset);
1130 }
1131
1132 template <typename ELFT>
1133 typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const {
1134   return DynRelRegion.getAsRange<Elf_Rel>();
1135 }
1136
1137 template <typename ELFT>
1138 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
1139   return DynRelaRegion.getAsRange<Elf_Rela>();
1140 }
1141
1142 template<class ELFT>
1143 void ELFDumper<ELFT>::printFileHeaders() {
1144   ELFDumperStyle->printFileHeaders(Obj);
1145 }
1146
1147 template<class ELFT>
1148 void ELFDumper<ELFT>::printSections() {
1149   ListScope SectionsD(W, "Sections");
1150
1151   int SectionIndex = -1;
1152   for (const Elf_Shdr &Sec : Obj->sections()) {
1153     ++SectionIndex;
1154
1155     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
1156
1157     DictScope SectionD(W, "Section");
1158     W.printNumber("Index", SectionIndex);
1159     W.printNumber("Name", Name, Sec.sh_name);
1160     W.printHex("Type",
1161                getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type),
1162                Sec.sh_type);
1163     std::vector<EnumEntry<unsigned>> SectionFlags(std::begin(ElfSectionFlags),
1164                                                   std::end(ElfSectionFlags));
1165     switch (Obj->getHeader()->e_machine) {
1166     case EM_AMDGPU:
1167       SectionFlags.insert(SectionFlags.end(), std::begin(ElfAMDGPUSectionFlags),
1168                           std::end(ElfAMDGPUSectionFlags));
1169       break;
1170     case EM_HEXAGON:
1171       SectionFlags.insert(SectionFlags.end(),
1172                           std::begin(ElfHexagonSectionFlags),
1173                           std::end(ElfHexagonSectionFlags));
1174       break;
1175     case EM_MIPS:
1176       SectionFlags.insert(SectionFlags.end(), std::begin(ElfMipsSectionFlags),
1177                           std::end(ElfMipsSectionFlags));
1178       break;
1179     case EM_X86_64:
1180       SectionFlags.insert(SectionFlags.end(), std::begin(ElfX86_64SectionFlags),
1181                           std::end(ElfX86_64SectionFlags));
1182       break;
1183     default:
1184       // Nothing to do.
1185       break;
1186     }
1187     W.printFlags("Flags", Sec.sh_flags, makeArrayRef(SectionFlags));
1188     W.printHex("Address", Sec.sh_addr);
1189     W.printHex("Offset", Sec.sh_offset);
1190     W.printNumber("Size", Sec.sh_size);
1191     W.printNumber("Link", Sec.sh_link);
1192     W.printNumber("Info", Sec.sh_info);
1193     W.printNumber("AddressAlignment", Sec.sh_addralign);
1194     W.printNumber("EntrySize", Sec.sh_entsize);
1195
1196     if (opts::SectionRelocations) {
1197       ListScope D(W, "Relocations");
1198       printRelocations(&Sec);
1199     }
1200
1201     if (opts::SectionSymbols) {
1202       ListScope D(W, "Symbols");
1203       const Elf_Shdr *Symtab = DotSymtabSec;
1204       StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
1205
1206       for (const Elf_Sym &Sym : Obj->symbols(Symtab)) {
1207         const Elf_Shdr *SymSec =
1208             unwrapOrError(Obj->getSection(&Sym, Symtab, ShndxTable));
1209         if (SymSec == &Sec)
1210           printSymbol(&Sym, Obj->symbol_begin(Symtab), StrTable, false);
1211       }
1212     }
1213
1214     if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
1215       ArrayRef<uint8_t> Data = unwrapOrError(Obj->getSectionContents(&Sec));
1216       W.printBinaryBlock("SectionData",
1217                          StringRef((const char *)Data.data(), Data.size()));
1218     }
1219   }
1220 }
1221
1222 template<class ELFT>
1223 void ELFDumper<ELFT>::printRelocations() {
1224   ListScope D(W, "Relocations");
1225
1226   int SectionNumber = -1;
1227   for (const Elf_Shdr &Sec : Obj->sections()) {
1228     ++SectionNumber;
1229
1230     if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA)
1231       continue;
1232
1233     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
1234
1235     W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
1236     W.indent();
1237
1238     printRelocations(&Sec);
1239
1240     W.unindent();
1241     W.startLine() << "}\n";
1242   }
1243 }
1244
1245 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
1246   if (DynRelRegion.Size && DynRelaRegion.Size)
1247     report_fatal_error("There are both REL and RELA dynamic relocations");
1248   W.startLine() << "Dynamic Relocations {\n";
1249   W.indent();
1250   if (DynRelaRegion.Size > 0)
1251     for (const Elf_Rela &Rela : dyn_relas())
1252       printDynamicRelocation(Rela);
1253   else
1254     for (const Elf_Rel &Rel : dyn_rels()) {
1255       Elf_Rela Rela;
1256       Rela.r_offset = Rel.r_offset;
1257       Rela.r_info = Rel.r_info;
1258       Rela.r_addend = 0;
1259       printDynamicRelocation(Rela);
1260     }
1261   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
1262     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsRange<Elf_Rela>())
1263       printDynamicRelocation(Rela);
1264   else
1265     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsRange<Elf_Rel>()) {
1266       Elf_Rela Rela;
1267       Rela.r_offset = Rel.r_offset;
1268       Rela.r_info = Rel.r_info;
1269       Rela.r_addend = 0;
1270       printDynamicRelocation(Rela);
1271     }
1272   W.unindent();
1273   W.startLine() << "}\n";
1274 }
1275
1276 template <class ELFT>
1277 void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
1278   const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec->sh_link));
1279
1280   switch (Sec->sh_type) {
1281   case ELF::SHT_REL:
1282     for (const Elf_Rel &R : Obj->rels(Sec)) {
1283       Elf_Rela Rela;
1284       Rela.r_offset = R.r_offset;
1285       Rela.r_info = R.r_info;
1286       Rela.r_addend = 0;
1287       printRelocation(Rela, SymTab);
1288     }
1289     break;
1290   case ELF::SHT_RELA:
1291     for (const Elf_Rela &R : Obj->relas(Sec))
1292       printRelocation(R, SymTab);
1293     break;
1294   }
1295 }
1296
1297 template <class ELFT>
1298 void ELFDumper<ELFT>::printRelocation(Elf_Rela Rel, const Elf_Shdr *SymTab) {
1299   SmallString<32> RelocName;
1300   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
1301   StringRef TargetName;
1302   const Elf_Sym *Sym = Obj->getRelocationSymbol(&Rel, SymTab);
1303   if (Sym && Sym->getType() == ELF::STT_SECTION) {
1304     const Elf_Shdr *Sec =
1305         unwrapOrError(Obj->getSection(Sym, SymTab, ShndxTable));
1306     TargetName = unwrapOrError(Obj->getSectionName(Sec));
1307   } else if (Sym) {
1308     StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
1309     TargetName = unwrapOrError(Sym->getName(StrTable));
1310   }
1311
1312   if (opts::ExpandRelocs) {
1313     DictScope Group(W, "Relocation");
1314     W.printHex("Offset", Rel.r_offset);
1315     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
1316     W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-",
1317                   Rel.getSymbol(Obj->isMips64EL()));
1318     W.printHex("Addend", Rel.r_addend);
1319   } else {
1320     raw_ostream& OS = W.startLine();
1321     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
1322        << (TargetName.size() > 0 ? TargetName : "-") << " "
1323        << W.hex(Rel.r_addend) << "\n";
1324   }
1325 }
1326
1327 template <class ELFT>
1328 void ELFDumper<ELFT>::printDynamicRelocation(Elf_Rela Rel) {
1329   SmallString<32> RelocName;
1330   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
1331   StringRef SymbolName;
1332   uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
1333   const Elf_Sym *Sym = dynamic_symbols().begin() + SymIndex;
1334   SymbolName = unwrapOrError(Sym->getName(DynamicStringTable));
1335   if (opts::ExpandRelocs) {
1336     DictScope Group(W, "Relocation");
1337     W.printHex("Offset", Rel.r_offset);
1338     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
1339     W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-");
1340     W.printHex("Addend", Rel.r_addend);
1341   } else {
1342     raw_ostream &OS = W.startLine();
1343     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
1344        << (SymbolName.size() > 0 ? SymbolName : "-") << " "
1345        << W.hex(Rel.r_addend) << "\n";
1346   }
1347 }
1348
1349 template<class ELFT>
1350 void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) {
1351   StringRef StrTable;
1352   Elf_Sym_Range Syms(nullptr, nullptr);
1353
1354   if (IsDynamic) {
1355     StrTable = DynamicStringTable;
1356     Syms = dynamic_symbols();
1357   } else {
1358     if (!DotSymtabSec)
1359       return;
1360     StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
1361     Syms = Obj->symbols(DotSymtabSec);
1362   }
1363   for (const Elf_Sym &Sym : Syms)
1364     printSymbol(&Sym, Syms.begin(), StrTable, IsDynamic);
1365 }
1366
1367 template<class ELFT>
1368 void ELFDumper<ELFT>::printSymbols() {
1369   ListScope Group(W, "Symbols");
1370   printSymbolsHelper(false);
1371 }
1372
1373 template<class ELFT>
1374 void ELFDumper<ELFT>::printDynamicSymbols() {
1375   ListScope Group(W, "DynamicSymbols");
1376   printSymbolsHelper(true);
1377 }
1378
1379 template <class ELFT>
1380 void ELFDumper<ELFT>::printSymbol(const Elf_Sym *Symbol,
1381                                   const Elf_Sym *FirstSym, StringRef StrTable,
1382                                   bool IsDynamic) {
1383   unsigned SectionIndex = 0;
1384   StringRef SectionName;
1385   getSectionNameIndex(*Obj, Symbol, FirstSym, ShndxTable, SectionName,
1386                       SectionIndex);
1387   std::string FullSymbolName = getFullSymbolName(Symbol, StrTable, IsDynamic);
1388   unsigned char SymbolType = Symbol->getType();
1389
1390   DictScope D(W, "Symbol");
1391   W.printNumber("Name", FullSymbolName, Symbol->st_name);
1392   W.printHex   ("Value", Symbol->st_value);
1393   W.printNumber("Size", Symbol->st_size);
1394   W.printEnum  ("Binding", Symbol->getBinding(),
1395                   makeArrayRef(ElfSymbolBindings));
1396   if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
1397       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
1398     W.printEnum  ("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes));
1399   else
1400     W.printEnum  ("Type", SymbolType, makeArrayRef(ElfSymbolTypes));
1401   W.printNumber("Other", Symbol->st_other);
1402   W.printHex("Section", SectionName, SectionIndex);
1403 }
1404
1405 #define LLVM_READOBJ_TYPE_CASE(name) \
1406   case DT_##name: return #name
1407
1408 static const char *getTypeString(uint64_t Type) {
1409   switch (Type) {
1410   LLVM_READOBJ_TYPE_CASE(BIND_NOW);
1411   LLVM_READOBJ_TYPE_CASE(DEBUG);
1412   LLVM_READOBJ_TYPE_CASE(FINI);
1413   LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
1414   LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
1415   LLVM_READOBJ_TYPE_CASE(FLAGS);
1416   LLVM_READOBJ_TYPE_CASE(FLAGS_1);
1417   LLVM_READOBJ_TYPE_CASE(HASH);
1418   LLVM_READOBJ_TYPE_CASE(INIT);
1419   LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
1420   LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
1421   LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
1422   LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
1423   LLVM_READOBJ_TYPE_CASE(JMPREL);
1424   LLVM_READOBJ_TYPE_CASE(NEEDED);
1425   LLVM_READOBJ_TYPE_CASE(NULL);
1426   LLVM_READOBJ_TYPE_CASE(PLTGOT);
1427   LLVM_READOBJ_TYPE_CASE(PLTREL);
1428   LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
1429   LLVM_READOBJ_TYPE_CASE(REL);
1430   LLVM_READOBJ_TYPE_CASE(RELA);
1431   LLVM_READOBJ_TYPE_CASE(RELENT);
1432   LLVM_READOBJ_TYPE_CASE(RELSZ);
1433   LLVM_READOBJ_TYPE_CASE(RELAENT);
1434   LLVM_READOBJ_TYPE_CASE(RELASZ);
1435   LLVM_READOBJ_TYPE_CASE(RPATH);
1436   LLVM_READOBJ_TYPE_CASE(RUNPATH);
1437   LLVM_READOBJ_TYPE_CASE(SONAME);
1438   LLVM_READOBJ_TYPE_CASE(STRSZ);
1439   LLVM_READOBJ_TYPE_CASE(STRTAB);
1440   LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
1441   LLVM_READOBJ_TYPE_CASE(SYMENT);
1442   LLVM_READOBJ_TYPE_CASE(SYMTAB);
1443   LLVM_READOBJ_TYPE_CASE(TEXTREL);
1444   LLVM_READOBJ_TYPE_CASE(VERDEF);
1445   LLVM_READOBJ_TYPE_CASE(VERDEFNUM);
1446   LLVM_READOBJ_TYPE_CASE(VERNEED);
1447   LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
1448   LLVM_READOBJ_TYPE_CASE(VERSYM);
1449   LLVM_READOBJ_TYPE_CASE(RELACOUNT);
1450   LLVM_READOBJ_TYPE_CASE(RELCOUNT);
1451   LLVM_READOBJ_TYPE_CASE(GNU_HASH);
1452   LLVM_READOBJ_TYPE_CASE(TLSDESC_PLT);
1453   LLVM_READOBJ_TYPE_CASE(TLSDESC_GOT);
1454   LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
1455   LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP_REL);
1456   LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
1457   LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
1458   LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
1459   LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
1460   LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
1461   LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
1462   LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
1463   LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
1464   LLVM_READOBJ_TYPE_CASE(MIPS_OPTIONS);
1465   default: return "unknown";
1466   }
1467 }
1468
1469 #undef LLVM_READOBJ_TYPE_CASE
1470
1471 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
1472   { #enum, prefix##_##enum }
1473
1474 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
1475   LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
1476   LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
1477   LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
1478   LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
1479   LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
1480 };
1481
1482 static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
1483   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
1484   LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
1485   LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
1486   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
1487   LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
1488   LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
1489   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
1490   LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
1491   LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
1492   LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
1493   LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
1494   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
1495   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
1496   LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
1497   LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
1498   LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
1499   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
1500   LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
1501   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
1502   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
1503   LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
1504   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
1505   LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
1506   LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
1507   LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON)
1508 };
1509
1510 static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
1511   LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
1512   LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
1513   LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
1514   LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
1515   LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
1516   LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
1517   LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
1518   LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
1519   LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
1520   LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
1521   LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
1522   LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
1523   LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
1524   LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
1525   LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
1526   LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
1527 };
1528
1529 #undef LLVM_READOBJ_DT_FLAG_ENT
1530
1531 template <typename T, typename TFlag>
1532 void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
1533   typedef EnumEntry<TFlag> FlagEntry;
1534   typedef SmallVector<FlagEntry, 10> FlagVector;
1535   FlagVector SetFlags;
1536
1537   for (const auto &Flag : Flags) {
1538     if (Flag.Value == 0)
1539       continue;
1540
1541     if ((Value & Flag.Value) == Flag.Value)
1542       SetFlags.push_back(Flag);
1543   }
1544
1545   for (const auto &Flag : SetFlags) {
1546     OS << Flag.Name << " ";
1547   }
1548 }
1549
1550 template <class ELFT>
1551 StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const {
1552   if (Value >= DynamicStringTable.size())
1553     reportError("Invalid dynamic string table reference");
1554   return StringRef(DynamicStringTable.data() + Value);
1555 }
1556
1557 template <class ELFT>
1558 void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) {
1559   raw_ostream &OS = W.getOStream();
1560   switch (Type) {
1561   case DT_PLTREL:
1562     if (Value == DT_REL) {
1563       OS << "REL";
1564       break;
1565     } else if (Value == DT_RELA) {
1566       OS << "RELA";
1567       break;
1568     }
1569   // Fallthrough.
1570   case DT_PLTGOT:
1571   case DT_HASH:
1572   case DT_STRTAB:
1573   case DT_SYMTAB:
1574   case DT_RELA:
1575   case DT_INIT:
1576   case DT_FINI:
1577   case DT_REL:
1578   case DT_JMPREL:
1579   case DT_INIT_ARRAY:
1580   case DT_FINI_ARRAY:
1581   case DT_PREINIT_ARRAY:
1582   case DT_DEBUG:
1583   case DT_VERDEF:
1584   case DT_VERNEED:
1585   case DT_VERSYM:
1586   case DT_GNU_HASH:
1587   case DT_NULL:
1588   case DT_MIPS_BASE_ADDRESS:
1589   case DT_MIPS_GOTSYM:
1590   case DT_MIPS_RLD_MAP:
1591   case DT_MIPS_RLD_MAP_REL:
1592   case DT_MIPS_PLTGOT:
1593   case DT_MIPS_OPTIONS:
1594     OS << format("0x%" PRIX64, Value);
1595     break;
1596   case DT_RELACOUNT:
1597   case DT_RELCOUNT:
1598   case DT_VERDEFNUM:
1599   case DT_VERNEEDNUM:
1600   case DT_MIPS_RLD_VERSION:
1601   case DT_MIPS_LOCAL_GOTNO:
1602   case DT_MIPS_SYMTABNO:
1603   case DT_MIPS_UNREFEXTNO:
1604     OS << Value;
1605     break;
1606   case DT_PLTRELSZ:
1607   case DT_RELASZ:
1608   case DT_RELAENT:
1609   case DT_STRSZ:
1610   case DT_SYMENT:
1611   case DT_RELSZ:
1612   case DT_RELENT:
1613   case DT_INIT_ARRAYSZ:
1614   case DT_FINI_ARRAYSZ:
1615   case DT_PREINIT_ARRAYSZ:
1616     OS << Value << " (bytes)";
1617     break;
1618   case DT_NEEDED:
1619     OS << "SharedLibrary (" << getDynamicString(Value) << ")";
1620     break;
1621   case DT_SONAME:
1622     OS << "LibrarySoname (" << getDynamicString(Value) << ")";
1623     break;
1624   case DT_RPATH:
1625   case DT_RUNPATH:
1626     OS << getDynamicString(Value);
1627     break;
1628   case DT_MIPS_FLAGS:
1629     printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
1630     break;
1631   case DT_FLAGS:
1632     printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
1633     break;
1634   case DT_FLAGS_1:
1635     printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
1636     break;
1637   default:
1638     OS << format("0x%" PRIX64, Value);
1639     break;
1640   }
1641 }
1642
1643 template<class ELFT>
1644 void ELFDumper<ELFT>::printUnwindInfo() {
1645   W.startLine() << "UnwindInfo not implemented.\n";
1646 }
1647
1648 namespace {
1649 template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() {
1650   const unsigned Machine = Obj->getHeader()->e_machine;
1651   if (Machine == EM_ARM) {
1652     ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx(
1653         W, Obj, DotSymtabSec);
1654     return Ctx.PrintUnwindInformation();
1655   }
1656   W.startLine() << "UnwindInfo not implemented.\n";
1657 }
1658 }
1659
1660 template<class ELFT>
1661 void ELFDumper<ELFT>::printDynamicTable() {
1662   auto I = dynamic_table().begin();
1663   auto E = dynamic_table().end();
1664
1665   if (I == E)
1666     return;
1667
1668   --E;
1669   while (I != E && E->getTag() == ELF::DT_NULL)
1670     --E;
1671   if (E->getTag() != ELF::DT_NULL)
1672     ++E;
1673   ++E;
1674
1675   ptrdiff_t Total = std::distance(I, E);
1676   if (Total == 0)
1677     return;
1678
1679   raw_ostream &OS = W.getOStream();
1680   W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
1681
1682   bool Is64 = ELFT::Is64Bits;
1683
1684   W.startLine()
1685      << "  Tag" << (Is64 ? "                " : "        ") << "Type"
1686      << "                 " << "Name/Value\n";
1687   while (I != E) {
1688     const Elf_Dyn &Entry = *I;
1689     uintX_t Tag = Entry.getTag();
1690     ++I;
1691     W.startLine() << "  " << format_hex(Tag, Is64 ? 18 : 10, true) << " "
1692                   << format("%-21s", getTypeString(Tag));
1693     printValue(Tag, Entry.getVal());
1694     OS << "\n";
1695   }
1696
1697   W.startLine() << "]\n";
1698 }
1699
1700 template<class ELFT>
1701 void ELFDumper<ELFT>::printNeededLibraries() {
1702   ListScope D(W, "NeededLibraries");
1703
1704   typedef std::vector<StringRef> LibsTy;
1705   LibsTy Libs;
1706
1707   for (const auto &Entry : dynamic_table())
1708     if (Entry.d_tag == ELF::DT_NEEDED)
1709       Libs.push_back(getDynamicString(Entry.d_un.d_val));
1710
1711   std::stable_sort(Libs.begin(), Libs.end());
1712
1713   for (const auto &L : Libs) {
1714     outs() << "  " << L << "\n";
1715   }
1716 }
1717
1718 template<class ELFT>
1719 void ELFDumper<ELFT>::printProgramHeaders() {
1720   ListScope L(W, "ProgramHeaders");
1721
1722   for (const Elf_Phdr &Phdr : Obj->program_headers()) {
1723     DictScope P(W, "ProgramHeader");
1724     W.printHex("Type",
1725                getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
1726                Phdr.p_type);
1727     W.printHex("Offset", Phdr.p_offset);
1728     W.printHex("VirtualAddress", Phdr.p_vaddr);
1729     W.printHex("PhysicalAddress", Phdr.p_paddr);
1730     W.printNumber("FileSize", Phdr.p_filesz);
1731     W.printNumber("MemSize", Phdr.p_memsz);
1732     W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
1733     W.printNumber("Alignment", Phdr.p_align);
1734   }
1735 }
1736
1737 template <typename ELFT>
1738 void ELFDumper<ELFT>::printHashTable() {
1739   DictScope D(W, "HashTable");
1740   if (!HashTable)
1741     return;
1742   W.printNumber("Num Buckets", HashTable->nbucket);
1743   W.printNumber("Num Chains", HashTable->nchain);
1744   W.printList("Buckets", HashTable->buckets());
1745   W.printList("Chains", HashTable->chains());
1746 }
1747
1748 template <typename ELFT>
1749 void ELFDumper<ELFT>::printGnuHashTable() {
1750   DictScope D(W, "GnuHashTable");
1751   if (!GnuHashTable)
1752     return;
1753   W.printNumber("Num Buckets", GnuHashTable->nbuckets);
1754   W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx);
1755   W.printNumber("Num Mask Words", GnuHashTable->maskwords);
1756   W.printNumber("Shift Count", GnuHashTable->shift2);
1757   W.printHexList("Bloom Filter", GnuHashTable->filter());
1758   W.printList("Buckets", GnuHashTable->buckets());
1759   Elf_Sym_Range Syms = dynamic_symbols();
1760   unsigned NumSyms = std::distance(Syms.begin(), Syms.end());
1761   if (!NumSyms)
1762     reportError("No dynamic symbol section");
1763   W.printHexList("Values", GnuHashTable->values(NumSyms));
1764 }
1765
1766 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
1767   outs() << "LoadName: " << SOName << '\n';
1768 }
1769
1770 template <class ELFT>
1771 void ELFDumper<ELFT>::printAttributes() {
1772   W.startLine() << "Attributes not implemented.\n";
1773 }
1774
1775 namespace {
1776 template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() {
1777   if (Obj->getHeader()->e_machine != EM_ARM) {
1778     W.startLine() << "Attributes not implemented.\n";
1779     return;
1780   }
1781
1782   DictScope BA(W, "BuildAttributes");
1783   for (const ELFO::Elf_Shdr &Sec : Obj->sections()) {
1784     if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
1785       continue;
1786
1787     ArrayRef<uint8_t> Contents = unwrapOrError(Obj->getSectionContents(&Sec));
1788     if (Contents[0] != ARMBuildAttrs::Format_Version) {
1789       errs() << "unrecognised FormatVersion: 0x" << utohexstr(Contents[0])
1790              << '\n';
1791       continue;
1792     }
1793
1794     W.printHex("FormatVersion", Contents[0]);
1795     if (Contents.size() == 1)
1796       continue;
1797
1798     ARMAttributeParser(W).Parse(Contents);
1799   }
1800 }
1801 }
1802
1803 namespace {
1804 template <class ELFT> class MipsGOTParser {
1805 public:
1806   typedef object::ELFFile<ELFT> ELFO;
1807   typedef typename ELFO::Elf_Shdr Elf_Shdr;
1808   typedef typename ELFO::Elf_Sym Elf_Sym;
1809   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
1810   typedef typename ELFO::Elf_Addr GOTEntry;
1811   typedef typename ELFO::Elf_Rel Elf_Rel;
1812   typedef typename ELFO::Elf_Rela Elf_Rela;
1813
1814   MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj,
1815                 Elf_Dyn_Range DynTable, StreamWriter &W);
1816
1817   void parseGOT();
1818   void parsePLT();
1819
1820 private:
1821   ELFDumper<ELFT> *Dumper;
1822   const ELFO *Obj;
1823   StreamWriter &W;
1824   llvm::Optional<uint64_t> DtPltGot;
1825   llvm::Optional<uint64_t> DtLocalGotNum;
1826   llvm::Optional<uint64_t> DtGotSym;
1827   llvm::Optional<uint64_t> DtMipsPltGot;
1828   llvm::Optional<uint64_t> DtJmpRel;
1829
1830   std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1831   const GOTEntry *makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1832
1833   void printGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1834                      const GOTEntry *It);
1835   void printGlobalGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1836                            const GOTEntry *It, const Elf_Sym *Sym,
1837                            StringRef StrTable, bool IsDynamic);
1838   void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1839                      const GOTEntry *It, StringRef Purpose);
1840   void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1841                      const GOTEntry *It, StringRef StrTable,
1842                      const Elf_Sym *Sym);
1843 };
1844 }
1845
1846 template <class ELFT>
1847 MipsGOTParser<ELFT>::MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj,
1848                                    Elf_Dyn_Range DynTable, StreamWriter &W)
1849     : Dumper(Dumper), Obj(Obj), W(W) {
1850   for (const auto &Entry : DynTable) {
1851     switch (Entry.getTag()) {
1852     case ELF::DT_PLTGOT:
1853       DtPltGot = Entry.getVal();
1854       break;
1855     case ELF::DT_MIPS_LOCAL_GOTNO:
1856       DtLocalGotNum = Entry.getVal();
1857       break;
1858     case ELF::DT_MIPS_GOTSYM:
1859       DtGotSym = Entry.getVal();
1860       break;
1861     case ELF::DT_MIPS_PLTGOT:
1862       DtMipsPltGot = Entry.getVal();
1863       break;
1864     case ELF::DT_JMPREL:
1865       DtJmpRel = Entry.getVal();
1866       break;
1867     }
1868   }
1869 }
1870
1871 template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() {
1872   // See "Global Offset Table" in Chapter 5 in the following document
1873   // for detailed GOT description.
1874   // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1875   if (!DtPltGot) {
1876     W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1877     return;
1878   }
1879   if (!DtLocalGotNum) {
1880     W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1881     return;
1882   }
1883   if (!DtGotSym) {
1884     W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1885     return;
1886   }
1887
1888   StringRef StrTable = Dumper->getDynamicStringTable();
1889   const Elf_Sym *DynSymBegin = Dumper->dynamic_symbols().begin();
1890   const Elf_Sym *DynSymEnd = Dumper->dynamic_symbols().end();
1891   std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1892
1893   if (*DtGotSym > DynSymTotal)
1894     report_fatal_error("MIPS_GOTSYM exceeds a number of dynamic symbols");
1895
1896   std::size_t GlobalGotNum = DynSymTotal - *DtGotSym;
1897
1898   if (*DtLocalGotNum + GlobalGotNum == 0) {
1899     W.startLine() << "GOT is empty.\n";
1900     return;
1901   }
1902
1903   const Elf_Shdr *GOTShdr = findNotEmptySectionByAddress(Obj, *DtPltGot);
1904   if (!GOTShdr)
1905     report_fatal_error("There is no not empty GOT section at 0x" +
1906                        Twine::utohexstr(*DtPltGot));
1907
1908   ArrayRef<uint8_t> GOT = unwrapOrError(Obj->getSectionContents(GOTShdr));
1909
1910   if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(GOT))
1911     report_fatal_error("Number of GOT entries exceeds the size of GOT section");
1912
1913   const GOTEntry *GotBegin = makeGOTIter(GOT, 0);
1914   const GOTEntry *GotLocalEnd = makeGOTIter(GOT, *DtLocalGotNum);
1915   const GOTEntry *It = GotBegin;
1916
1917   DictScope GS(W, "Primary GOT");
1918
1919   W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0);
1920   {
1921     ListScope RS(W, "Reserved entries");
1922
1923     {
1924       DictScope D(W, "Entry");
1925       printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1926       W.printString("Purpose", StringRef("Lazy resolver"));
1927     }
1928
1929     if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
1930       DictScope D(W, "Entry");
1931       printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1932       W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
1933     }
1934   }
1935   {
1936     ListScope LS(W, "Local entries");
1937     for (; It != GotLocalEnd; ++It) {
1938       DictScope D(W, "Entry");
1939       printGotEntry(GOTShdr->sh_addr, GotBegin, It);
1940     }
1941   }
1942   {
1943     ListScope GS(W, "Global entries");
1944
1945     const GOTEntry *GotGlobalEnd =
1946         makeGOTIter(GOT, *DtLocalGotNum + GlobalGotNum);
1947     const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym;
1948     for (; It != GotGlobalEnd; ++It) {
1949       DictScope D(W, "Entry");
1950       printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++, StrTable,
1951                           true);
1952     }
1953   }
1954
1955   std::size_t SpecGotNum = getGOTTotal(GOT) - *DtLocalGotNum - GlobalGotNum;
1956   W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
1957 }
1958
1959 template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() {
1960   if (!DtMipsPltGot) {
1961     W.startLine() << "Cannot find MIPS_PLTGOT dynamic table tag.\n";
1962     return;
1963   }
1964   if (!DtJmpRel) {
1965     W.startLine() << "Cannot find JMPREL dynamic table tag.\n";
1966     return;
1967   }
1968
1969   const Elf_Shdr *PLTShdr = findNotEmptySectionByAddress(Obj, *DtMipsPltGot);
1970   if (!PLTShdr)
1971     report_fatal_error("There is no not empty PLTGOT section at 0x " +
1972                        Twine::utohexstr(*DtMipsPltGot));
1973   ArrayRef<uint8_t> PLT = unwrapOrError(Obj->getSectionContents(PLTShdr));
1974
1975   const Elf_Shdr *PLTRelShdr = findNotEmptySectionByAddress(Obj, *DtJmpRel);
1976   if (!PLTRelShdr)
1977     report_fatal_error("There is no not empty RELPLT section at 0x" +
1978                        Twine::utohexstr(*DtJmpRel));
1979   const Elf_Shdr *SymTable =
1980       unwrapOrError(Obj->getSection(PLTRelShdr->sh_link));
1981   StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTable));
1982
1983   const GOTEntry *PLTBegin = makeGOTIter(PLT, 0);
1984   const GOTEntry *PLTEnd = makeGOTIter(PLT, getGOTTotal(PLT));
1985   const GOTEntry *It = PLTBegin;
1986
1987   DictScope GS(W, "PLT GOT");
1988   {
1989     ListScope RS(W, "Reserved entries");
1990     printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "PLT lazy resolver");
1991     if (It != PLTEnd)
1992       printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "Module pointer");
1993   }
1994   {
1995     ListScope GS(W, "Entries");
1996
1997     switch (PLTRelShdr->sh_type) {
1998     case ELF::SHT_REL:
1999       for (const Elf_Rel *RI = Obj->rel_begin(PLTRelShdr),
2000                          *RE = Obj->rel_end(PLTRelShdr);
2001            RI != RE && It != PLTEnd; ++RI, ++It) {
2002         const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable);
2003         printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, StrTable, Sym);
2004       }
2005       break;
2006     case ELF::SHT_RELA:
2007       for (const Elf_Rela *RI = Obj->rela_begin(PLTRelShdr),
2008                           *RE = Obj->rela_end(PLTRelShdr);
2009            RI != RE && It != PLTEnd; ++RI, ++It) {
2010         const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable);
2011         printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, StrTable, Sym);
2012       }
2013       break;
2014     }
2015   }
2016 }
2017
2018 template <class ELFT>
2019 std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
2020   return GOT.size() / sizeof(GOTEntry);
2021 }
2022
2023 template <class ELFT>
2024 const typename MipsGOTParser<ELFT>::GOTEntry *
2025 MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
2026   const char *Data = reinterpret_cast<const char *>(GOT.data());
2027   return reinterpret_cast<const GOTEntry *>(Data + EntryNum * sizeof(GOTEntry));
2028 }
2029
2030 template <class ELFT>
2031 void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr,
2032                                         const GOTEntry *BeginIt,
2033                                         const GOTEntry *It) {
2034   int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
2035   W.printHex("Address", GotAddr + Offset);
2036   W.printNumber("Access", Offset - 0x7ff0);
2037   W.printHex("Initial", *It);
2038 }
2039
2040 template <class ELFT>
2041 void MipsGOTParser<ELFT>::printGlobalGotEntry(
2042     uint64_t GotAddr, const GOTEntry *BeginIt, const GOTEntry *It,
2043     const Elf_Sym *Sym, StringRef StrTable, bool IsDynamic) {
2044   printGotEntry(GotAddr, BeginIt, It);
2045
2046   W.printHex("Value", Sym->st_value);
2047   W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
2048
2049   unsigned SectionIndex = 0;
2050   StringRef SectionName;
2051   getSectionNameIndex(*Obj, Sym, Dumper->dynamic_symbols().begin(),
2052                       Dumper->getShndxTable(), SectionName, SectionIndex);
2053   W.printHex("Section", SectionName, SectionIndex);
2054
2055   std::string FullSymbolName =
2056       Dumper->getFullSymbolName(Sym, StrTable, IsDynamic);
2057   W.printNumber("Name", FullSymbolName, Sym->st_name);
2058 }
2059
2060 template <class ELFT>
2061 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
2062                                         const GOTEntry *BeginIt,
2063                                         const GOTEntry *It, StringRef Purpose) {
2064   DictScope D(W, "Entry");
2065   int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
2066   W.printHex("Address", PLTAddr + Offset);
2067   W.printHex("Initial", *It);
2068   W.printString("Purpose", Purpose);
2069 }
2070
2071 template <class ELFT>
2072 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
2073                                         const GOTEntry *BeginIt,
2074                                         const GOTEntry *It, StringRef StrTable,
2075                                         const Elf_Sym *Sym) {
2076   DictScope D(W, "Entry");
2077   int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
2078   W.printHex("Address", PLTAddr + Offset);
2079   W.printHex("Initial", *It);
2080   W.printHex("Value", Sym->st_value);
2081   W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
2082
2083   unsigned SectionIndex = 0;
2084   StringRef SectionName;
2085   getSectionNameIndex(*Obj, Sym, Dumper->dynamic_symbols().begin(),
2086                       Dumper->getShndxTable(), SectionName, SectionIndex);
2087   W.printHex("Section", SectionName, SectionIndex);
2088
2089   std::string FullSymbolName = Dumper->getFullSymbolName(Sym, StrTable, true);
2090   W.printNumber("Name", FullSymbolName, Sym->st_name);
2091 }
2092
2093 template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
2094   if (Obj->getHeader()->e_machine != EM_MIPS) {
2095     W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
2096     return;
2097   }
2098
2099   MipsGOTParser<ELFT> GOTParser(this, Obj, dynamic_table(), W);
2100   GOTParser.parseGOT();
2101   GOTParser.parsePLT();
2102 }
2103
2104 static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
2105   {"None",                    Mips::AFL_EXT_NONE},
2106   {"Broadcom SB-1",           Mips::AFL_EXT_SB1},
2107   {"Cavium Networks Octeon",  Mips::AFL_EXT_OCTEON},
2108   {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
2109   {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
2110   {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
2111   {"LSI R4010",               Mips::AFL_EXT_4010},
2112   {"Loongson 2E",             Mips::AFL_EXT_LOONGSON_2E},
2113   {"Loongson 2F",             Mips::AFL_EXT_LOONGSON_2F},
2114   {"Loongson 3A",             Mips::AFL_EXT_LOONGSON_3A},
2115   {"MIPS R4650",              Mips::AFL_EXT_4650},
2116   {"MIPS R5900",              Mips::AFL_EXT_5900},
2117   {"MIPS R10000",             Mips::AFL_EXT_10000},
2118   {"NEC VR4100",              Mips::AFL_EXT_4100},
2119   {"NEC VR4111/VR4181",       Mips::AFL_EXT_4111},
2120   {"NEC VR4120",              Mips::AFL_EXT_4120},
2121   {"NEC VR5400",              Mips::AFL_EXT_5400},
2122   {"NEC VR5500",              Mips::AFL_EXT_5500},
2123   {"RMI Xlr",                 Mips::AFL_EXT_XLR},
2124   {"Toshiba R3900",           Mips::AFL_EXT_3900}
2125 };
2126
2127 static const EnumEntry<unsigned> ElfMipsASEFlags[] = {
2128   {"DSP",                Mips::AFL_ASE_DSP},
2129   {"DSPR2",              Mips::AFL_ASE_DSPR2},
2130   {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
2131   {"MCU",                Mips::AFL_ASE_MCU},
2132   {"MDMX",               Mips::AFL_ASE_MDMX},
2133   {"MIPS-3D",            Mips::AFL_ASE_MIPS3D},
2134   {"MT",                 Mips::AFL_ASE_MT},
2135   {"SmartMIPS",          Mips::AFL_ASE_SMARTMIPS},
2136   {"VZ",                 Mips::AFL_ASE_VIRT},
2137   {"MSA",                Mips::AFL_ASE_MSA},
2138   {"MIPS16",             Mips::AFL_ASE_MIPS16},
2139   {"microMIPS",          Mips::AFL_ASE_MICROMIPS},
2140   {"XPA",                Mips::AFL_ASE_XPA}
2141 };
2142
2143 static const EnumEntry<unsigned> ElfMipsFpABIType[] = {
2144   {"Hard or soft float",                  Mips::Val_GNU_MIPS_ABI_FP_ANY},
2145   {"Hard float (double precision)",       Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
2146   {"Hard float (single precision)",       Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
2147   {"Soft float",                          Mips::Val_GNU_MIPS_ABI_FP_SOFT},
2148   {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
2149    Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
2150   {"Hard float (32-bit CPU, Any FPU)",    Mips::Val_GNU_MIPS_ABI_FP_XX},
2151   {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
2152   {"Hard float compat (32-bit CPU, 64-bit FPU)",
2153    Mips::Val_GNU_MIPS_ABI_FP_64A}
2154 };
2155
2156 static const EnumEntry<unsigned> ElfMipsFlags1[] {
2157   {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
2158 };
2159
2160 static int getMipsRegisterSize(uint8_t Flag) {
2161   switch (Flag) {
2162   case Mips::AFL_REG_NONE:
2163     return 0;
2164   case Mips::AFL_REG_32:
2165     return 32;
2166   case Mips::AFL_REG_64:
2167     return 64;
2168   case Mips::AFL_REG_128:
2169     return 128;
2170   default:
2171     return -1;
2172   }
2173 }
2174
2175 template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() {
2176   const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags");
2177   if (!Shdr) {
2178     W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
2179     return;
2180   }
2181   ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2182   if (Sec.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
2183     W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
2184     return;
2185   }
2186
2187   auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec.data());
2188
2189   raw_ostream &OS = W.getOStream();
2190   DictScope GS(W, "MIPS ABI Flags");
2191
2192   W.printNumber("Version", Flags->version);
2193   W.startLine() << "ISA: ";
2194   if (Flags->isa_rev <= 1)
2195     OS << format("MIPS%u", Flags->isa_level);
2196   else
2197     OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
2198   OS << "\n";
2199   W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType));
2200   W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
2201   W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
2202   W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
2203   W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
2204   W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
2205   W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
2206   W.printHex("Flags 2", Flags->flags2);
2207 }
2208
2209 template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
2210   const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo");
2211   if (!Shdr) {
2212     W.startLine() << "There is no .reginfo section in the file.\n";
2213     return;
2214   }
2215   ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2216   if (Sec.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
2217     W.startLine() << "The .reginfo section has a wrong size.\n";
2218     return;
2219   }
2220
2221   auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec.data());
2222
2223   DictScope GS(W, "MIPS RegInfo");
2224   W.printHex("GP", Reginfo->ri_gp_value);
2225   W.printHex("General Mask", Reginfo->ri_gprmask);
2226   W.printHex("Co-Proc Mask0", Reginfo->ri_cprmask[0]);
2227   W.printHex("Co-Proc Mask1", Reginfo->ri_cprmask[1]);
2228   W.printHex("Co-Proc Mask2", Reginfo->ri_cprmask[2]);
2229   W.printHex("Co-Proc Mask3", Reginfo->ri_cprmask[3]);
2230 }
2231
2232 template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
2233   const Elf_Shdr *StackMapSection = nullptr;
2234   for (const auto &Sec : Obj->sections()) {
2235     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2236     if (Name == ".llvm_stackmaps") {
2237       StackMapSection = &Sec;
2238       break;
2239     }
2240   }
2241
2242   if (!StackMapSection)
2243     return;
2244
2245   StringRef StackMapContents;
2246   ArrayRef<uint8_t> StackMapContentsArray =
2247       unwrapOrError(Obj->getSectionContents(StackMapSection));
2248
2249   prettyPrintStackMap(llvm::outs(), StackMapV1Parser<ELFT::TargetEndianness>(
2250                                         StackMapContentsArray));
2251 }
2252
2253 template <class ELFT> void ELFDumper<ELFT>::printGroupSections() {
2254   DictScope Lists(W, "Groups");
2255   uint32_t SectionIndex = 0;
2256   bool HasGroups = false;
2257   for (const Elf_Shdr &Sec : Obj->sections()) {
2258     if (Sec.sh_type == ELF::SHT_GROUP) {
2259       HasGroups = true;
2260       const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
2261       StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
2262       const Elf_Sym *Sym = Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info);
2263       auto Data = unwrapOrError(
2264           Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
2265       DictScope D(W, "Group");
2266       StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2267       W.printNumber("Name", Name, Sec.sh_name);
2268       W.printNumber("Index", SectionIndex);
2269       W.printHex("Type", getGroupType(Data[0]), Data[0]);
2270       W.startLine() << "Signature: " << StrTable.data() + Sym->st_name << "\n";
2271       {
2272         ListScope L(W, "Section(s) in group");
2273         size_t Member = 1;
2274         while (Member < Data.size()) {
2275           auto Sec = unwrapOrError(Obj->getSection(Data[Member]));
2276           const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
2277           W.startLine() << Name << " (" << Data[Member++] << ")\n";
2278         }
2279       }
2280     }
2281     ++SectionIndex;
2282   }
2283   if (!HasGroups)
2284     W.startLine() << "There are no group sections in the file.\n";
2285 }
2286
2287 static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
2288                                StringRef Str2) {
2289   OS.PadToColumn(2u);
2290   OS << Str1;
2291   OS.PadToColumn(37u);
2292   OS << Str2 << "\n";
2293   OS.flush();
2294 }
2295
2296 template <class ELFT>
2297 void GNUStyle<ELFT>::printFileHeaders(const ELFFile<ELFT> *Obj) {
2298   const Elf_Ehdr *e = Obj->getHeader();
2299   OS << "ELF Header:\n";
2300   OS << "  Magic:  ";
2301   std::string Str;
2302   for (int i = 0; i < ELF::EI_NIDENT; i++)
2303     OS << format(" %02x", static_cast<int>(e->e_ident[i]));
2304   OS << "\n";
2305   Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
2306   printFields(OS, "Class:", Str);
2307   Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
2308   printFields(OS, "Data:", Str);
2309   OS.PadToColumn(2u);
2310   OS << "Version:";
2311   OS.PadToColumn(37u);
2312   OS << to_hexString(e->e_ident[ELF::EI_VERSION]);
2313   if (e->e_version == ELF::EV_CURRENT)
2314     OS << " (current)";
2315   OS << "\n";
2316   Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
2317   printFields(OS, "OS/ABI:", Str);
2318   Str = "0x" + to_hexString(e->e_version);
2319   Str = to_hexString(e->e_ident[ELF::EI_ABIVERSION]);
2320   printFields(OS, "ABI Version:", Str);
2321   Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType));
2322   printFields(OS, "Type:", Str);
2323   Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType));
2324   printFields(OS, "Machine:", Str);
2325   Str = "0x" + to_hexString(e->e_version);
2326   printFields(OS, "Version:", Str);
2327   Str = "0x" + to_hexString(e->e_entry);
2328   printFields(OS, "Entry point address:", Str);
2329   Str = to_string(e->e_phoff) + " (bytes into file)";
2330   printFields(OS, "Start of program headers:", Str);
2331   Str = to_string(e->e_shoff) + " (bytes into file)";
2332   printFields(OS, "Start of section headers:", Str);
2333   Str = "0x" + to_hexString(e->e_flags);
2334   printFields(OS, "Flags:", Str);
2335   Str = to_string(e->e_ehsize) + " (bytes)";
2336   printFields(OS, "Size of this header:", Str);
2337   Str = to_string(e->e_phentsize) + " (bytes)";
2338   printFields(OS, "Size of program headers:", Str);
2339   Str = to_string(e->e_phnum);
2340   printFields(OS, "Number of program headers:", Str);
2341   Str = to_string(e->e_shentsize) + " (bytes)";
2342   printFields(OS, "Size of section headers:", Str);
2343   Str = to_string(e->e_shnum);
2344   printFields(OS, "Number of section headers:", Str);
2345   Str = to_string(e->e_shstrndx);
2346   printFields(OS, "Section header string table index:", Str);
2347 }
2348
2349 template <class ELFT>
2350 void LLVMStyle<ELFT>::printFileHeaders(const ELFFile<ELFT> *Obj) {
2351   const Elf_Ehdr *e = Obj->getHeader();
2352   {
2353     DictScope D(W, "ElfHeader");
2354     {
2355       DictScope D(W, "Ident");
2356       W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4));
2357       W.printEnum("Class", e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
2358       W.printEnum("DataEncoding", e->e_ident[ELF::EI_DATA],
2359                   makeArrayRef(ElfDataEncoding));
2360       W.printNumber("FileVersion", e->e_ident[ELF::EI_VERSION]);
2361
2362       // Handle architecture specific OS/ABI values.
2363       if (e->e_machine == ELF::EM_AMDGPU &&
2364           e->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
2365         W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
2366       else
2367         W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI],
2368                     makeArrayRef(ElfOSABI));
2369       W.printNumber("ABIVersion", e->e_ident[ELF::EI_ABIVERSION]);
2370       W.printBinary("Unused", makeArrayRef(e->e_ident).slice(ELF::EI_PAD));
2371     }
2372
2373     W.printEnum("Type", e->e_type, makeArrayRef(ElfObjectFileType));
2374     W.printEnum("Machine", e->e_machine, makeArrayRef(ElfMachineType));
2375     W.printNumber("Version", e->e_version);
2376     W.printHex("Entry", e->e_entry);
2377     W.printHex("ProgramHeaderOffset", e->e_phoff);
2378     W.printHex("SectionHeaderOffset", e->e_shoff);
2379     if (e->e_machine == EM_MIPS)
2380       W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderMipsFlags),
2381                    unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
2382                    unsigned(ELF::EF_MIPS_MACH));
2383     else
2384       W.printFlags("Flags", e->e_flags);
2385     W.printNumber("HeaderSize", e->e_ehsize);
2386     W.printNumber("ProgramHeaderEntrySize", e->e_phentsize);
2387     W.printNumber("ProgramHeaderCount", e->e_phnum);
2388     W.printNumber("SectionHeaderEntrySize", e->e_shentsize);
2389     W.printNumber("SectionHeaderCount", e->e_shnum);
2390     W.printNumber("StringTableSectionIndex", e->e_shstrndx);
2391   }
2392 }