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