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