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