contrib/llvm/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 "ARMAttributeParser.h"
  16 #include "ARMEHABIPrinter.h"
  17 #include "Error.h"
  18 #include "ObjDumper.h"
  19 #include "StackMapPrinter.h"
  20 #include "llvm-readobj.h"
  21 #include "llvm/ADT/Optional.h"
  22 #include "llvm/ADT/SmallString.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/Object/ELFObjectFile.h"
  25 #include "llvm/Support/ARMBuildAttributes.h"
  26 #include "llvm/Support/Compiler.h"
  27 #include "llvm/Support/Format.h"
  28 #include "llvm/Support/FormattedStream.h"
  29 #include "llvm/Support/MathExtras.h"
  30 #include "llvm/Support/MipsABIFlags.h"
  31 #include "llvm/Support/ScopedPrinter.h"
  32 #include "llvm/Support/raw_ostream.h"
  33
  34 using namespace llvm;
  35 using namespace llvm::object;
  36 using namespace ELF;
  37
  38 #define LLVM_READOBJ_ENUM_CASE(ns, enum) \
  39   case ns::enum: return #enum;
  40
  41 #define ENUM_ENT(enum, altName) \
  42   { #enum, altName, ELF::enum }
  43
  44 #define ENUM_ENT_1(enum) \
  45   { #enum, #enum, ELF::enum }
  46
  47 #define LLVM_READOBJ_PHDR_ENUM(ns, enum)                                       \
  48   case ns::enum:                                                               \
  49     return std::string(#enum).substr(3);
  50
  51 #define TYPEDEF_ELF_TYPES(ELFT)                                                \
  52   typedef ELFFile<ELFT> ELFO;                                                  \
  53   typedef typename ELFO::Elf_Shdr Elf_Shdr;                                    \
  54   typedef typename ELFO::Elf_Sym Elf_Sym;                                      \
  55   typedef typename ELFO::Elf_Dyn Elf_Dyn;                                      \
  56   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;                          \
  57   typedef typename ELFO::Elf_Rel Elf_Rel;                                      \
  58   typedef typename ELFO::Elf_Rela Elf_Rela;                                    \
  59   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;                        \
  60   typedef typename ELFO::Elf_Phdr Elf_Phdr;                                    \
  61   typedef typename ELFO::Elf_Half Elf_Half;                                    \
  62   typedef typename ELFO::Elf_Ehdr Elf_Ehdr;                                    \
  63   typedef typename ELFO::Elf_Word Elf_Word;                                    \
  64   typedef typename ELFO::Elf_Hash Elf_Hash;                                    \
  65   typedef typename ELFO::Elf_GnuHash Elf_GnuHash;                              \
  66   typedef typename ELFO::uintX_t uintX_t;
  67
  68 namespace {
  69
  70 template <class ELFT> class DumpStyle;
  71
  72 /// Represents a contiguous uniform range in the file. We cannot just create a
  73 /// range directly because when creating one of these from the .dynamic table
  74 /// the size, entity size and virtual address are different entries in arbitrary
  75 /// order (DT_REL, DT_RELSZ, DT_RELENT for example).
  76 struct DynRegionInfo {
  77   DynRegionInfo() : Addr(nullptr), Size(0), EntSize(0) {}
  78   DynRegionInfo(const void *A, uint64_t S, uint64_t ES)
  79       : Addr(A), Size(S), EntSize(ES) {}
  80   /// \brief Address in current address space.
  81   const void *Addr;
  82   /// \brief Size in bytes of the region.
  83   uint64_t Size;
  84   /// \brief Size of each entity in the region.
  85   uint64_t EntSize;
  86
  87   template <typename Type> ArrayRef<Type> getAsArrayRef() const {
  88     const Type *Start = reinterpret_cast<const Type *>(Addr);
  89     if (!Start)
  90       return {Start, Start};
  91     if (EntSize != sizeof(Type) || Size % EntSize)
  92       reportError("Invalid entity size");
  93     return {Start, Start + (Size / EntSize)};
  94   }
  95 };
  96
  97 template<typename ELFT>
  98 class ELFDumper : public ObjDumper {
  99 public:
 100   ELFDumper(const ELFFile<ELFT> *Obj, ScopedPrinter &Writer);
 101
 102   void printFileHeaders() override;
 103   void printSections() override;
 104   void printRelocations() override;
 105   void printDynamicRelocations() override;
 106   void printSymbols() override;
 107   void printDynamicSymbols() override;
 108   void printUnwindInfo() override;
 109
 110   void printDynamicTable() override;
 111   void printNeededLibraries() override;
 112   void printProgramHeaders() override;
 113   void printHashTable() override;
 114   void printGnuHashTable() override;
 115   void printLoadName() override;
 116   void printVersionInfo() override;
 117   void printGroupSections() override;
 118
 119   void printAttributes() override;
 120   void printMipsPLTGOT() override;
 121   void printMipsABIFlags() override;
 122   void printMipsReginfo() override;
 123   void printMipsOptions() override;
 124
 125   void printStackMap() const override;
 126
 127   void printHashHistogram() override;
 128
 129 private:
 130   std::unique_ptr<DumpStyle<ELFT>> ELFDumperStyle;
 131   typedef ELFFile<ELFT> ELFO;
 132   typedef typename ELFO::Elf_Shdr Elf_Shdr;
 133   typedef typename ELFO::Elf_Sym Elf_Sym;
 134   typedef typename ELFO::Elf_Sym_Range Elf_Sym_Range;
 135   typedef typename ELFO::Elf_Dyn Elf_Dyn;
 136   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
 137   typedef typename ELFO::Elf_Rel Elf_Rel;
 138   typedef typename ELFO::Elf_Rela Elf_Rela;
 139   typedef typename ELFO::Elf_Rel_Range Elf_Rel_Range;
 140   typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;
 141   typedef typename ELFO::Elf_Phdr Elf_Phdr;
 142   typedef typename ELFO::Elf_Half Elf_Half;
 143   typedef typename ELFO::Elf_Hash Elf_Hash;
 144   typedef typename ELFO::Elf_GnuHash Elf_GnuHash;
 145   typedef typename ELFO::Elf_Ehdr Elf_Ehdr;
 146   typedef typename ELFO::Elf_Word Elf_Word;
 147   typedef typename ELFO::uintX_t uintX_t;
 148   typedef typename ELFO::Elf_Versym Elf_Versym;
 149   typedef typename ELFO::Elf_Verneed Elf_Verneed;
 150   typedef typename ELFO::Elf_Vernaux Elf_Vernaux;
 151   typedef typename ELFO::Elf_Verdef Elf_Verdef;
 152   typedef typename ELFO::Elf_Verdaux Elf_Verdaux;
 153
 154   DynRegionInfo checkDRI(DynRegionInfo DRI) {
 155     if (DRI.Addr < Obj->base() ||
 156         (const uint8_t *)DRI.Addr + DRI.Size > Obj->base() + Obj->getBufSize())
 157       error(llvm::object::object_error::parse_failed);
 158     return DRI;
 159   }
 160
 161   DynRegionInfo createDRIFrom(const Elf_Phdr *P, uintX_t EntSize) {
 162     return checkDRI({Obj->base() + P->p_offset, P->p_filesz, EntSize});
 163   }
 164
 165   DynRegionInfo createDRIFrom(const Elf_Shdr *S) {
 166     return checkDRI({Obj->base() + S->sh_offset, S->sh_size, S->sh_entsize});
 167   }
 168
 169   void parseDynamicTable(ArrayRef<const Elf_Phdr *> LoadSegments);
 170
 171   void printValue(uint64_t Type, uint64_t Value);
 172
 173   StringRef getDynamicString(uint64_t Offset) const;
 174   StringRef getSymbolVersion(StringRef StrTab, const Elf_Sym *symb,
 175                              bool &IsDefault) const;
 176   void LoadVersionMap() const;
 177   void LoadVersionNeeds(const Elf_Shdr *ec) const;
 178   void LoadVersionDefs(const Elf_Shdr *sec) const;
 179
 180   const ELFO *Obj;
 181   DynRegionInfo DynRelRegion;
 182   DynRegionInfo DynRelaRegion;
 183   DynRegionInfo DynPLTRelRegion;
 184   DynRegionInfo DynSymRegion;
 185   DynRegionInfo DynamicTable;
 186   StringRef DynamicStringTable;
 187   StringRef SOName;
 188   const Elf_Hash *HashTable = nullptr;
 189   const Elf_GnuHash *GnuHashTable = nullptr;
 190   const Elf_Shdr *DotSymtabSec = nullptr;
 191   StringRef DynSymtabName;
 192   ArrayRef<Elf_Word> ShndxTable;
 193
 194   const Elf_Shdr *dot_gnu_version_sec = nullptr;   // .gnu.version
 195   const Elf_Shdr *dot_gnu_version_r_sec = nullptr; // .gnu.version_r
 196   const Elf_Shdr *dot_gnu_version_d_sec = nullptr; // .gnu.version_d
 197
 198   // Records for each version index the corresponding Verdef or Vernaux entry.
 199   // This is filled the first time LoadVersionMap() is called.
 200   class VersionMapEntry : public PointerIntPair<const void *, 1> {
 201   public:
 202     // If the integer is 0, this is an Elf_Verdef*.
 203     // If the integer is 1, this is an Elf_Vernaux*.
 204     VersionMapEntry() : PointerIntPair<const void *, 1>(nullptr, 0) {}
 205     VersionMapEntry(const Elf_Verdef *verdef)
 206         : PointerIntPair<const void *, 1>(verdef, 0) {}
 207     VersionMapEntry(const Elf_Vernaux *vernaux)
 208         : PointerIntPair<const void *, 1>(vernaux, 1) {}
 209     bool isNull() const { return getPointer() == nullptr; }
 210     bool isVerdef() const { return !isNull() && getInt() == 0; }
 211     bool isVernaux() const { return !isNull() && getInt() == 1; }
 212     const Elf_Verdef *getVerdef() const {
 213       return isVerdef() ? (const Elf_Verdef *)getPointer() : nullptr;
 214     }
 215     const Elf_Vernaux *getVernaux() const {
 216       return isVernaux() ? (const Elf_Vernaux *)getPointer() : nullptr;
 217     }
 218   };
 219   mutable SmallVector<VersionMapEntry, 16> VersionMap;
 220
 221 public:
 222   Elf_Dyn_Range dynamic_table() const {
 223     return DynamicTable.getAsArrayRef<Elf_Dyn>();
 224   }
 225
 226   Elf_Sym_Range dynamic_symbols() const {
 227     return DynSymRegion.getAsArrayRef<Elf_Sym>();
 228   }
 229
 230   Elf_Rel_Range dyn_rels() const;
 231   Elf_Rela_Range dyn_relas() const;
 232   std::string getFullSymbolName(const Elf_Sym *Symbol, StringRef StrTable,
 233                                 bool IsDynamic) const;
 234
 235   void printSymbolsHelper(bool IsDynamic) const;
 236   const Elf_Shdr *getDotSymtabSec() const { return DotSymtabSec; }
 237   ArrayRef<Elf_Word> getShndxTable() const { return ShndxTable; }
 238   StringRef getDynamicStringTable() const { return DynamicStringTable; }
 239   const DynRegionInfo &getDynRelRegion() const { return DynRelRegion; }
 240   const DynRegionInfo &getDynRelaRegion() const { return DynRelaRegion; }
 241   const DynRegionInfo &getDynPLTRelRegion() const { return DynPLTRelRegion; }
 242   const Elf_Hash *getHashTable() const { return HashTable; }
 243   const Elf_GnuHash *getGnuHashTable() const { return GnuHashTable; }
 244 };
 245
 246 template <class ELFT>
 247 void ELFDumper<ELFT>::printSymbolsHelper(bool IsDynamic) const {
 248   StringRef StrTable, SymtabName;
 249   size_t Entries = 0;
 250   Elf_Sym_Range Syms(nullptr, nullptr);
 251   if (IsDynamic) {
 252     StrTable = DynamicStringTable;
 253     Syms = dynamic_symbols();
 254     SymtabName = DynSymtabName;
 255     if (DynSymRegion.Addr)
 256       Entries = DynSymRegion.Size / DynSymRegion.EntSize;
 257   } else {
 258     if (!DotSymtabSec)
 259       return;
 260     StrTable = unwrapOrError(Obj->getStringTableForSymtab(*DotSymtabSec));
 261     Syms = Obj->symbols(DotSymtabSec);
 262     SymtabName = unwrapOrError(Obj->getSectionName(DotSymtabSec));
 263     Entries = DotSymtabSec->getEntityCount();
 264   }
 265   if (Syms.begin() == Syms.end())
 266     return;
 267   ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries);
 268   for (const auto &Sym : Syms)
 269     ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic);
 270 }
 271
 272 template <typename ELFT> class DumpStyle {
 273 public:
 274   using Elf_Shdr = typename ELFFile<ELFT>::Elf_Shdr;
 275   using Elf_Sym =  typename ELFFile<ELFT>::Elf_Sym;
 276
 277   DumpStyle(ELFDumper<ELFT> *Dumper) : Dumper(Dumper) {}
 278   virtual ~DumpStyle() {}
 279   virtual void printFileHeaders(const ELFFile<ELFT> *Obj) = 0;
 280   virtual void printGroupSections(const ELFFile<ELFT> *Obj) = 0;
 281   virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
 282   virtual void printSections(const ELFFile<ELFT> *Obj) = 0;
 283   virtual void printSymbols(const ELFFile<ELFT> *Obj) = 0;
 284   virtual void printDynamicSymbols(const ELFFile<ELFT> *Obj) = 0;
 285   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
 286   virtual void printSymtabMessage(const ELFFile<ELFT> *obj, StringRef Name,
 287                                   size_t Offset) {
 288     return;
 289   }
 290   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
 291                            const Elf_Sym *FirstSym, StringRef StrTable,
 292                            bool IsDynamic) = 0;
 293   virtual void printProgramHeaders(const ELFFile<ELFT> *Obj) = 0;
 294   virtual void printHashHistogram(const ELFFile<ELFT> *Obj) = 0;
 295   const ELFDumper<ELFT> *dumper() const { return Dumper; }
 296 private:
 297   const ELFDumper<ELFT> *Dumper;
 298 };
 299
 300 template <typename ELFT> class GNUStyle : public DumpStyle<ELFT> {
 301   formatted_raw_ostream OS;
 302 public:
 303   TYPEDEF_ELF_TYPES(ELFT)
 304   GNUStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
 305       : DumpStyle<ELFT>(Dumper), OS(W.getOStream()) {}
 306   void printFileHeaders(const ELFO *Obj) override;
 307   void printGroupSections(const ELFFile<ELFT> *Obj) override;
 308   void printRelocations(const ELFO *Obj) override;
 309   void printSections(const ELFO *Obj) override;
 310   void printSymbols(const ELFO *Obj) override;
 311   void printDynamicSymbols(const ELFO *Obj) override;
 312   void printDynamicRelocations(const ELFO *Obj) override;
 313   virtual void printSymtabMessage(const ELFO *Obj, StringRef Name,
 314                                   size_t Offset) override;
 315   void printProgramHeaders(const ELFO *Obj) override;
 316   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
 317
 318 private:
 319   struct Field {
 320     StringRef Str;
 321     unsigned Column;
 322     Field(StringRef S, unsigned Col) : Str(S), Column(Col) {}
 323     Field(unsigned Col) : Str(""), Column(Col) {}
 324   };
 325
 326   template <typename T, typename TEnum>
 327   std::string printEnum(T Value, ArrayRef<EnumEntry<TEnum>> EnumValues) {
 328     for (const auto &EnumItem : EnumValues)
 329       if (EnumItem.Value == Value)
 330         return EnumItem.AltName;
 331     return to_hexString(Value, false);
 332   }
 333
 334   formatted_raw_ostream &printField(struct Field F) {
 335     if (F.Column != 0)
 336       OS.PadToColumn(F.Column);
 337     OS << F.Str;
 338     OS.flush();
 339     return OS;
 340   }
 341   void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
 342                        const Elf_Rela &R, bool IsRela);
 343   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
 344                    StringRef StrTable, bool IsDynamic) override;
 345   std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
 346                                   const Elf_Sym *FirstSym);
 347   void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela);
 348   bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
 349   bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
 350   bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
 351   bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
 352 };
 353
 354 template <typename ELFT> class LLVMStyle : public DumpStyle<ELFT> {
 355 public:
 356   TYPEDEF_ELF_TYPES(ELFT)
 357   LLVMStyle(ScopedPrinter &W, ELFDumper<ELFT> *Dumper)
 358       : DumpStyle<ELFT>(Dumper), W(W) {}
 359
 360   void printFileHeaders(const ELFO *Obj) override;
 361   void printGroupSections(const ELFFile<ELFT> *Obj) override;
 362   void printRelocations(const ELFO *Obj) override;
 363   void printRelocations(const Elf_Shdr *Sec, const ELFO *Obj);
 364   void printSections(const ELFO *Obj) override;
 365   void printSymbols(const ELFO *Obj) override;
 366   void printDynamicSymbols(const ELFO *Obj) override;
 367   void printDynamicRelocations(const ELFO *Obj) override;
 368   void printProgramHeaders(const ELFO *Obj) override;
 369   void printHashHistogram(const ELFFile<ELFT> *Obj) override;
 370
 371 private:
 372   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
 373   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
 374   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
 375                    StringRef StrTable, bool IsDynamic) override;
 376   ScopedPrinter &W;
 377 };
 378
 379 } // namespace
 380
 381 namespace llvm {
 382
 383 template <class ELFT>
 384 static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
 385                                        ScopedPrinter &Writer,
 386                                        std::unique_ptr<ObjDumper> &Result) {
 387   Result.reset(new ELFDumper<ELFT>(Obj, Writer));
 388   return readobj_error::success;
 389 }
 390
 391 std::error_code createELFDumper(const object::ObjectFile *Obj,
 392                                 ScopedPrinter &Writer,
 393                                 std::unique_ptr<ObjDumper> &Result) {
 394   // Little-endian 32-bit
 395   if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
 396     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 397
 398   // Big-endian 32-bit
 399   if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
 400     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 401
 402   // Little-endian 64-bit
 403   if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
 404     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 405
 406   // Big-endian 64-bit
 407   if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
 408     return createELFDumper(ELFObj->getELFFile(), Writer, Result);
 409
 410   return readobj_error::unsupported_obj_file_format;
 411 }
 412
 413 } // namespace llvm
 414
 415 // Iterate through the versions needed section, and place each Elf_Vernaux
 416 // in the VersionMap according to its index.
 417 template <class ELFT>
 418 void ELFDumper<ELFT>::LoadVersionNeeds(const Elf_Shdr *sec) const {
 419   unsigned vn_size = sec->sh_size;  // Size of section in bytes
 420   unsigned vn_count = sec->sh_info; // Number of Verneed entries
 421   const char *sec_start = (const char *)Obj->base() + sec->sh_offset;
 422   const char *sec_end = sec_start + vn_size;
 423   // The first Verneed entry is at the start of the section.
 424   const char *p = sec_start;
 425   for (unsigned i = 0; i < vn_count; i++) {
 426     if (p + sizeof(Elf_Verneed) > sec_end)
 427       report_fatal_error("Section ended unexpectedly while scanning "
 428                          "version needed records.");
 429     const Elf_Verneed *vn = reinterpret_cast<const Elf_Verneed *>(p);
 430     if (vn->vn_version != ELF::VER_NEED_CURRENT)
 431       report_fatal_error("Unexpected verneed version");
 432     // Iterate through the Vernaux entries
 433     const char *paux = p + vn->vn_aux;
 434     for (unsigned j = 0; j < vn->vn_cnt; j++) {
 435       if (paux + sizeof(Elf_Vernaux) > sec_end)
 436         report_fatal_error("Section ended unexpected while scanning auxiliary "
 437                            "version needed records.");
 438       const Elf_Vernaux *vna = reinterpret_cast<const Elf_Vernaux *>(paux);
 439       size_t index = vna->vna_other & ELF::VERSYM_VERSION;
 440       if (index >= VersionMap.size())
 441         VersionMap.resize(index + 1);
 442       VersionMap[index] = VersionMapEntry(vna);
 443       paux += vna->vna_next;
 444     }
 445     p += vn->vn_next;
 446   }
 447 }
 448
 449 // Iterate through the version definitions, and place each Elf_Verdef
 450 // in the VersionMap according to its index.
 451 template <class ELFT>
 452 void ELFDumper<ELFT>::LoadVersionDefs(const Elf_Shdr *sec) const {
 453   unsigned vd_size = sec->sh_size;  // Size of section in bytes
 454   unsigned vd_count = sec->sh_info; // Number of Verdef entries
 455   const char *sec_start = (const char *)Obj->base() + sec->sh_offset;
 456   const char *sec_end = sec_start + vd_size;
 457   // The first Verdef entry is at the start of the section.
 458   const char *p = sec_start;
 459   for (unsigned i = 0; i < vd_count; i++) {
 460     if (p + sizeof(Elf_Verdef) > sec_end)
 461       report_fatal_error("Section ended unexpectedly while scanning "
 462                          "version definitions.");
 463     const Elf_Verdef *vd = reinterpret_cast<const Elf_Verdef *>(p);
 464     if (vd->vd_version != ELF::VER_DEF_CURRENT)
 465       report_fatal_error("Unexpected verdef version");
 466     size_t index = vd->vd_ndx & ELF::VERSYM_VERSION;
 467     if (index >= VersionMap.size())
 468       VersionMap.resize(index + 1);
 469     VersionMap[index] = VersionMapEntry(vd);
 470     p += vd->vd_next;
 471   }
 472 }
 473
 474 template <class ELFT> void ELFDumper<ELFT>::LoadVersionMap() const {
 475   // If there is no dynamic symtab or version table, there is nothing to do.
 476   if (!DynSymRegion.Addr || !dot_gnu_version_sec)
 477     return;
 478
 479   // Has the VersionMap already been loaded?
 480   if (VersionMap.size() > 0)
 481     return;
 482
 483   // The first two version indexes are reserved.
 484   // Index 0 is LOCAL, index 1 is GLOBAL.
 485   VersionMap.push_back(VersionMapEntry());
 486   VersionMap.push_back(VersionMapEntry());
 487
 488   if (dot_gnu_version_d_sec)
 489     LoadVersionDefs(dot_gnu_version_d_sec);
 490
 491   if (dot_gnu_version_r_sec)
 492     LoadVersionNeeds(dot_gnu_version_r_sec);
 493 }
 494
 495 template <typename ELFO, class ELFT>
 496 static void printVersionSymbolSection(ELFDumper<ELFT> *Dumper, const ELFO *Obj,
 497                                       const typename ELFO::Elf_Shdr *Sec,
 498                                       ScopedPrinter &W) {
 499   DictScope SS(W, "Version symbols");
 500   if (!Sec)
 501     return;
 502   StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
 503   W.printNumber("Section Name", Name, Sec->sh_name);
 504   W.printHex("Address", Sec->sh_addr);
 505   W.printHex("Offset", Sec->sh_offset);
 506   W.printNumber("Link", Sec->sh_link);
 507
 508   const uint8_t *P = (const uint8_t *)Obj->base() + Sec->sh_offset;
 509   StringRef StrTable = Dumper->getDynamicStringTable();
 510
 511   // Same number of entries in the dynamic symbol table (DT_SYMTAB).
 512   ListScope Syms(W, "Symbols");
 513   for (const typename ELFO::Elf_Sym &Sym : Dumper->dynamic_symbols()) {
 514     DictScope S(W, "Symbol");
 515     std::string FullSymbolName =
 516         Dumper->getFullSymbolName(&Sym, StrTable, true /* IsDynamic */);
 517     W.printNumber("Version", *P);
 518     W.printString("Name", FullSymbolName);
 519     P += sizeof(typename ELFO::Elf_Half);
 520   }
 521 }
 522
 523 static const EnumEntry<unsigned> SymVersionFlags[] = {
 524     {"Base", "BASE", VER_FLG_BASE},
 525     {"Weak", "WEAK", VER_FLG_WEAK},
 526     {"Info", "INFO", VER_FLG_INFO}};
 527
 528 template <typename ELFO, class ELFT>
 529 static void printVersionDefinitionSection(ELFDumper<ELFT> *Dumper,
 530                                           const ELFO *Obj,
 531                                           const typename ELFO::Elf_Shdr *Sec,
 532                                           ScopedPrinter &W) {
 533   typedef typename ELFO::Elf_Verdef VerDef;
 534   typedef typename ELFO::Elf_Verdaux VerdAux;
 535
 536   DictScope SD(W, "SHT_GNU_verdef");
 537   if (!Sec)
 538     return;
 539
 540   // The number of entries in the section SHT_GNU_verdef
 541   // is determined by DT_VERDEFNUM tag.
 542   unsigned VerDefsNum = 0;
 543   for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table()) {
 544     if (Dyn.d_tag == DT_VERDEFNUM)
 545       VerDefsNum = Dyn.d_un.d_val;
 546   }
 547   const uint8_t *SecStartAddress =
 548       (const uint8_t *)Obj->base() + Sec->sh_offset;
 549   const uint8_t *SecEndAddress = SecStartAddress + Sec->sh_size;
 550   const uint8_t *P = SecStartAddress;
 551   const typename ELFO::Elf_Shdr *StrTab =
 552       unwrapOrError(Obj->getSection(Sec->sh_link));
 553
 554   while (VerDefsNum--) {
 555     if (P + sizeof(VerDef) > SecEndAddress)
 556       report_fatal_error("invalid offset in the section");
 557
 558     auto *VD = reinterpret_cast<const VerDef *>(P);
 559     DictScope Def(W, "Definition");
 560     W.printNumber("Version", VD->vd_version);
 561     W.printEnum("Flags", VD->vd_flags, makeArrayRef(SymVersionFlags));
 562     W.printNumber("Index", VD->vd_ndx);
 563     W.printNumber("Hash", VD->vd_hash);
 564     W.printString("Name",
 565                   StringRef((const char *)(Obj->base() + StrTab->sh_offset +
 566                                            VD->getAux()->vda_name)));
 567     if (!VD->vd_cnt)
 568       report_fatal_error("at least one definition string must exist");
 569     if (VD->vd_cnt > 2)
 570       report_fatal_error("more than one predecessor is not expected");
 571
 572     if (VD->vd_cnt == 2) {
 573       const uint8_t *PAux = P + VD->vd_aux + VD->getAux()->vda_next;
 574       const VerdAux *Aux = reinterpret_cast<const VerdAux *>(PAux);
 575       W.printString("Predecessor",
 576                     StringRef((const char *)(Obj->base() + StrTab->sh_offset +
 577                                              Aux->vda_name)));
 578     }
 579
 580     P += VD->vd_next;
 581   }
 582 }
 583
 584 template <typename ELFO, class ELFT>
 585 static void printVersionDependencySection(ELFDumper<ELFT> *Dumper,
 586                                           const ELFO *Obj,
 587                                           const typename ELFO::Elf_Shdr *Sec,
 588                                           ScopedPrinter &W) {
 589   typedef typename ELFO::Elf_Verneed VerNeed;
 590   typedef typename ELFO::Elf_Vernaux VernAux;
 591
 592   DictScope SD(W, "SHT_GNU_verneed");
 593   if (!Sec)
 594     return;
 595
 596   unsigned VerNeedNum = 0;
 597   for (const typename ELFO::Elf_Dyn &Dyn : Dumper->dynamic_table())
 598     if (Dyn.d_tag == DT_VERNEEDNUM)
 599       VerNeedNum = Dyn.d_un.d_val;
 600
 601   const uint8_t *SecData = (const uint8_t *)Obj->base() + Sec->sh_offset;
 602   const typename ELFO::Elf_Shdr *StrTab =
 603       unwrapOrError(Obj->getSection(Sec->sh_link));
 604
 605   const uint8_t *P = SecData;
 606   for (unsigned I = 0; I < VerNeedNum; ++I) {
 607     const VerNeed *Need = reinterpret_cast<const VerNeed *>(P);
 608     DictScope Entry(W, "Dependency");
 609     W.printNumber("Version", Need->vn_version);
 610     W.printNumber("Count", Need->vn_cnt);
 611     W.printString("FileName",
 612                   StringRef((const char *)(Obj->base() + StrTab->sh_offset +
 613                                            Need->vn_file)));
 614
 615     const uint8_t *PAux = P + Need->vn_aux;
 616     for (unsigned J = 0; J < Need->vn_cnt; ++J) {
 617       const VernAux *Aux = reinterpret_cast<const VernAux *>(PAux);
 618       DictScope Entry(W, "Entry");
 619       W.printNumber("Hash", Aux->vna_hash);
 620       W.printEnum("Flags", Aux->vna_flags, makeArrayRef(SymVersionFlags));
 621       W.printNumber("Index", Aux->vna_other);
 622       W.printString("Name",
 623                     StringRef((const char *)(Obj->base() + StrTab->sh_offset +
 624                                              Aux->vna_name)));
 625       PAux += Aux->vna_next;
 626     }
 627     P += Need->vn_next;
 628   }
 629 }
 630
 631 template <typename ELFT> void ELFDumper<ELFT>::printVersionInfo() {
 632   // Dump version symbol section.
 633   printVersionSymbolSection(this, Obj, dot_gnu_version_sec, W);
 634
 635   // Dump version definition section.
 636   printVersionDefinitionSection(this, Obj, dot_gnu_version_d_sec, W);
 637
 638   // Dump version dependency section.
 639   printVersionDependencySection(this, Obj, dot_gnu_version_r_sec, W);
 640 }
 641
 642 template <typename ELFT>
 643 StringRef ELFDumper<ELFT>::getSymbolVersion(StringRef StrTab,
 644                                             const Elf_Sym *symb,
 645                                             bool &IsDefault) const {
 646   // This is a dynamic symbol. Look in the GNU symbol version table.
 647   if (!dot_gnu_version_sec) {
 648     // No version table.
 649     IsDefault = false;
 650     return StringRef("");
 651   }
 652
 653   // Determine the position in the symbol table of this entry.
 654   size_t entry_index = (reinterpret_cast<uintptr_t>(symb) -
 655                         reinterpret_cast<uintptr_t>(DynSymRegion.Addr)) /
 656                        sizeof(Elf_Sym);
 657
 658   // Get the corresponding version index entry
 659   const Elf_Versym *vs =
 660       Obj->template getEntry<Elf_Versym>(dot_gnu_version_sec, entry_index);
 661   size_t version_index = vs->vs_index & ELF::VERSYM_VERSION;
 662
 663   // Special markers for unversioned symbols.
 664   if (version_index == ELF::VER_NDX_LOCAL ||
 665       version_index == ELF::VER_NDX_GLOBAL) {
 666     IsDefault = false;
 667     return StringRef("");
 668   }
 669
 670   // Lookup this symbol in the version table
 671   LoadVersionMap();
 672   if (version_index >= VersionMap.size() || VersionMap[version_index].isNull())
 673     reportError("Invalid version entry");
 674   const VersionMapEntry &entry = VersionMap[version_index];
 675
 676   // Get the version name string
 677   size_t name_offset;
 678   if (entry.isVerdef()) {
 679     // The first Verdaux entry holds the name.
 680     name_offset = entry.getVerdef()->getAux()->vda_name;
 681     IsDefault = !(vs->vs_index & ELF::VERSYM_HIDDEN);
 682   } else {
 683     name_offset = entry.getVernaux()->vna_name;
 684     IsDefault = false;
 685   }
 686   if (name_offset >= StrTab.size())
 687     reportError("Invalid string offset");
 688   return StringRef(StrTab.data() + name_offset);
 689 }
 690
 691 template <typename ELFT>
 692 std::string ELFDumper<ELFT>::getFullSymbolName(const Elf_Sym *Symbol,
 693                                                StringRef StrTable,
 694                                                bool IsDynamic) const {
 695   StringRef SymbolName = unwrapOrError(Symbol->getName(StrTable));
 696   if (!IsDynamic)
 697     return SymbolName;
 698
 699   std::string FullSymbolName(SymbolName);
 700
 701   bool IsDefault;
 702   StringRef Version = getSymbolVersion(StrTable, &*Symbol, IsDefault);
 703   FullSymbolName += (IsDefault ? "@@" : "@");
 704   FullSymbolName += Version;
 705   return FullSymbolName;
 706 }
 707
 708 template <typename ELFO>
 709 static void
 710 getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol,
 711                     const typename ELFO::Elf_Sym *FirstSym,
 712                     ArrayRef<typename ELFO::Elf_Word> ShndxTable,
 713                     StringRef &SectionName, unsigned &SectionIndex) {
 714   SectionIndex = Symbol->st_shndx;
 715   if (Symbol->isUndefined())
 716     SectionName = "Undefined";
 717   else if (Symbol->isProcessorSpecific())
 718     SectionName = "Processor Specific";
 719   else if (Symbol->isOSSpecific())
 720     SectionName = "Operating System Specific";
 721   else if (Symbol->isAbsolute())
 722     SectionName = "Absolute";
 723   else if (Symbol->isCommon())
 724     SectionName = "Common";
 725   else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX)
 726     SectionName = "Reserved";
 727   else {
 728     if (SectionIndex == SHN_XINDEX)
 729       SectionIndex =
 730           Obj.getExtendedSymbolTableIndex(Symbol, FirstSym, ShndxTable);
 731     const typename ELFO::Elf_Shdr *Sec =
 732         unwrapOrError(Obj.getSection(SectionIndex));
 733     SectionName = unwrapOrError(Obj.getSectionName(Sec));
 734   }
 735 }
 736
 737 template <class ELFO>
 738 static const typename ELFO::Elf_Shdr *
 739 findNotEmptySectionByAddress(const ELFO *Obj, uint64_t Addr) {
 740   for (const auto &Shdr : Obj->sections())
 741     if (Shdr.sh_addr == Addr && Shdr.sh_size > 0)
 742       return &Shdr;
 743   return nullptr;
 744 }
 745
 746 template <class ELFO>
 747 static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj,
 748                                                         StringRef Name) {
 749   for (const auto &Shdr : Obj.sections()) {
 750     if (Name == unwrapOrError(Obj.getSectionName(&Shdr)))
 751       return &Shdr;
 752   }
 753   return nullptr;
 754 }
 755
 756 static const EnumEntry<unsigned> ElfClass[] = {
 757   {"None",   "none",   ELF::ELFCLASSNONE},
 758   {"32-bit", "ELF32",  ELF::ELFCLASS32},
 759   {"64-bit", "ELF64",  ELF::ELFCLASS64},
 760 };
 761
 762 static const EnumEntry<unsigned> ElfDataEncoding[] = {
 763   {"None",         "none",                          ELF::ELFDATANONE},
 764   {"LittleEndian", "2's complement, little endian", ELF::ELFDATA2LSB},
 765   {"BigEndian",    "2's complement, big endian",    ELF::ELFDATA2MSB},
 766 };
 767
 768 static const EnumEntry<unsigned> ElfObjectFileType[] = {
 769   {"None",         "NONE (none)",              ELF::ET_NONE},
 770   {"Relocatable",  "REL (Relocatable file)",   ELF::ET_REL},
 771   {"Executable",   "EXEC (Executable file)",   ELF::ET_EXEC},
 772   {"SharedObject", "DYN (Shared object file)", ELF::ET_DYN},
 773   {"Core",         "CORE (Core file)",         ELF::ET_CORE},
 774 };
 775
 776 static const EnumEntry<unsigned> ElfOSABI[] = {
 777   {"SystemV",      "UNIX - System V",      ELF::ELFOSABI_NONE},
 778   {"HPUX",         "UNIX - HP-UX",         ELF::ELFOSABI_HPUX},
 779   {"NetBSD",       "UNIX - NetBSD",        ELF::ELFOSABI_NETBSD},
 780   {"GNU/Linux",    "UNIX - GNU",           ELF::ELFOSABI_LINUX},
 781   {"GNU/Hurd",     "GNU/Hurd",             ELF::ELFOSABI_HURD},
 782   {"Solaris",      "UNIX - Solaris",       ELF::ELFOSABI_SOLARIS},
 783   {"AIX",          "UNIX - AIX",           ELF::ELFOSABI_AIX},
 784   {"IRIX",         "UNIX - IRIX",          ELF::ELFOSABI_IRIX},
 785   {"FreeBSD",      "UNIX - FreeBSD",       ELF::ELFOSABI_FREEBSD},
 786   {"TRU64",        "UNIX - TRU64",         ELF::ELFOSABI_TRU64},
 787   {"Modesto",      "Novell - Modesto",     ELF::ELFOSABI_MODESTO},
 788   {"OpenBSD",      "UNIX - OpenBSD",       ELF::ELFOSABI_OPENBSD},
 789   {"OpenVMS",      "VMS - OpenVMS",        ELF::ELFOSABI_OPENVMS},
 790   {"NSK",          "HP - Non-Stop Kernel", ELF::ELFOSABI_NSK},
 791   {"AROS",         "AROS",                 ELF::ELFOSABI_AROS},
 792   {"FenixOS",      "FenixOS",              ELF::ELFOSABI_FENIXOS},
 793   {"CloudABI",     "CloudABI",             ELF::ELFOSABI_CLOUDABI},
 794   {"C6000_ELFABI", "Bare-metal C6000",     ELF::ELFOSABI_C6000_ELFABI},
 795   {"C6000_LINUX",  "Linux C6000",          ELF::ELFOSABI_C6000_LINUX},
 796   {"ARM",          "ARM",                  ELF::ELFOSABI_ARM},
 797   {"Standalone",   "Standalone App",       ELF::ELFOSABI_STANDALONE}
 798 };
 799
 800 static const EnumEntry<unsigned> ElfMachineType[] = {
 801   ENUM_ENT(EM_NONE,          "None"),
 802   ENUM_ENT(EM_M32,           "WE32100"),
 803   ENUM_ENT(EM_SPARC,         "Sparc"),
 804   ENUM_ENT(EM_386,           "Intel 80386"),
 805   ENUM_ENT(EM_68K,           "MC68000"),
 806   ENUM_ENT(EM_88K,           "MC88000"),
 807   ENUM_ENT(EM_IAMCU,         "EM_IAMCU"),
 808   ENUM_ENT(EM_860,           "Intel 80860"),
 809   ENUM_ENT(EM_MIPS,          "MIPS R3000"),
 810   ENUM_ENT(EM_S370,          "IBM System/370"),
 811   ENUM_ENT(EM_MIPS_RS3_LE,   "MIPS R3000 little-endian"),
 812   ENUM_ENT(EM_PARISC,        "HPPA"),
 813   ENUM_ENT(EM_VPP500,        "Fujitsu VPP500"),
 814   ENUM_ENT(EM_SPARC32PLUS,   "Sparc v8+"),
 815   ENUM_ENT(EM_960,           "Intel 80960"),
 816   ENUM_ENT(EM_PPC,           "PowerPC"),
 817   ENUM_ENT(EM_PPC64,         "PowerPC64"),
 818   ENUM_ENT(EM_S390,          "IBM S/390"),
 819   ENUM_ENT(EM_SPU,           "SPU"),
 820   ENUM_ENT(EM_V800,          "NEC V800 series"),
 821   ENUM_ENT(EM_FR20,          "Fujistsu FR20"),
 822   ENUM_ENT(EM_RH32,          "TRW RH-32"),
 823   ENUM_ENT(EM_RCE,           "Motorola RCE"),
 824   ENUM_ENT(EM_ARM,           "ARM"),
 825   ENUM_ENT(EM_ALPHA,         "EM_ALPHA"),
 826   ENUM_ENT(EM_SH,            "Hitachi SH"),
 827   ENUM_ENT(EM_SPARCV9,       "Sparc v9"),
 828   ENUM_ENT(EM_TRICORE,       "Siemens Tricore"),
 829   ENUM_ENT(EM_ARC,           "ARC"),
 830   ENUM_ENT(EM_H8_300,        "Hitachi H8/300"),
 831   ENUM_ENT(EM_H8_300H,       "Hitachi H8/300H"),
 832   ENUM_ENT(EM_H8S,           "Hitachi H8S"),
 833   ENUM_ENT(EM_H8_500,        "Hitachi H8/500"),
 834   ENUM_ENT(EM_IA_64,         "Intel IA-64"),
 835   ENUM_ENT(EM_MIPS_X,        "Stanford MIPS-X"),
 836   ENUM_ENT(EM_COLDFIRE,      "Motorola Coldfire"),
 837   ENUM_ENT(EM_68HC12,        "Motorola MC68HC12 Microcontroller"),
 838   ENUM_ENT(EM_MMA,           "Fujitsu Multimedia Accelerator"),
 839   ENUM_ENT(EM_PCP,           "Siemens PCP"),
 840   ENUM_ENT(EM_NCPU,          "Sony nCPU embedded RISC processor"),
 841   ENUM_ENT(EM_NDR1,          "Denso NDR1 microprocesspr"),
 842   ENUM_ENT(EM_STARCORE,      "Motorola Star*Core processor"),
 843   ENUM_ENT(EM_ME16,          "Toyota ME16 processor"),
 844   ENUM_ENT(EM_ST100,         "STMicroelectronics ST100 processor"),
 845   ENUM_ENT(EM_TINYJ,         "Advanced Logic Corp. TinyJ embedded processor"),
 846   ENUM_ENT(EM_X86_64,        "Advanced Micro Devices X86-64"),
 847   ENUM_ENT(EM_PDSP,          "Sony DSP processor"),
 848   ENUM_ENT(EM_PDP10,         "Digital Equipment Corp. PDP-10"),
 849   ENUM_ENT(EM_PDP11,         "Digital Equipment Corp. PDP-11"),
 850   ENUM_ENT(EM_FX66,          "Siemens FX66 microcontroller"),
 851   ENUM_ENT(EM_ST9PLUS,       "STMicroelectronics ST9+ 8/16 bit microcontroller"),
 852   ENUM_ENT(EM_ST7,           "STMicroelectronics ST7 8-bit microcontroller"),
 853   ENUM_ENT(EM_68HC16,        "Motorola MC68HC16 Microcontroller"),
 854   ENUM_ENT(EM_68HC11,        "Motorola MC68HC11 Microcontroller"),
 855   ENUM_ENT(EM_68HC08,        "Motorola MC68HC08 Microcontroller"),
 856   ENUM_ENT(EM_68HC05,        "Motorola MC68HC05 Microcontroller"),
 857   ENUM_ENT(EM_SVX,           "Silicon Graphics SVx"),
 858   ENUM_ENT(EM_ST19,          "STMicroelectronics ST19 8-bit microcontroller"),
 859   ENUM_ENT(EM_VAX,           "Digital VAX"),
 860   ENUM_ENT(EM_CRIS,          "Axis Communications 32-bit embedded processor"),
 861   ENUM_ENT(EM_JAVELIN,       "Infineon Technologies 32-bit embedded cpu"),
 862   ENUM_ENT(EM_FIREPATH,      "Element 14 64-bit DSP processor"),
 863   ENUM_ENT(EM_ZSP,           "LSI Logic's 16-bit DSP processor"),
 864   ENUM_ENT(EM_MMIX,          "Donald Knuth's educational 64-bit processor"),
 865   ENUM_ENT(EM_HUANY,         "Harvard Universitys's machine-independent object format"),
 866   ENUM_ENT(EM_PRISM,         "Vitesse Prism"),
 867   ENUM_ENT(EM_AVR,           "Atmel AVR 8-bit microcontroller"),
 868   ENUM_ENT(EM_FR30,          "Fujitsu FR30"),
 869   ENUM_ENT(EM_D10V,          "Mitsubishi D10V"),
 870   ENUM_ENT(EM_D30V,          "Mitsubishi D30V"),
 871   ENUM_ENT(EM_V850,          "NEC v850"),
 872   ENUM_ENT(EM_M32R,          "Renesas M32R (formerly Mitsubishi M32r)"),
 873   ENUM_ENT(EM_MN10300,       "Matsushita MN10300"),
 874   ENUM_ENT(EM_MN10200,       "Matsushita MN10200"),
 875   ENUM_ENT(EM_PJ,            "picoJava"),
 876   ENUM_ENT(EM_OPENRISC,      "OpenRISC 32-bit embedded processor"),
 877   ENUM_ENT(EM_ARC_COMPACT,   "EM_ARC_COMPACT"),
 878   ENUM_ENT(EM_XTENSA,        "Tensilica Xtensa Processor"),
 879   ENUM_ENT(EM_VIDEOCORE,     "Alphamosaic VideoCore processor"),
 880   ENUM_ENT(EM_TMM_GPP,       "Thompson Multimedia General Purpose Processor"),
 881   ENUM_ENT(EM_NS32K,         "National Semiconductor 32000 series"),
 882   ENUM_ENT(EM_TPC,           "Tenor Network TPC processor"),
 883   ENUM_ENT(EM_SNP1K,         "EM_SNP1K"),
 884   ENUM_ENT(EM_ST200,         "STMicroelectronics ST200 microcontroller"),
 885   ENUM_ENT(EM_IP2K,          "Ubicom IP2xxx 8-bit microcontrollers"),
 886   ENUM_ENT(EM_MAX,           "MAX Processor"),
 887   ENUM_ENT(EM_CR,            "National Semiconductor CompactRISC"),
 888   ENUM_ENT(EM_F2MC16,        "Fujitsu F2MC16"),
 889   ENUM_ENT(EM_MSP430,        "Texas Instruments msp430 microcontroller"),
 890   ENUM_ENT(EM_BLACKFIN,      "Analog Devices Blackfin"),
 891   ENUM_ENT(EM_SE_C33,        "S1C33 Family of Seiko Epson processors"),
 892   ENUM_ENT(EM_SEP,           "Sharp embedded microprocessor"),
 893   ENUM_ENT(EM_ARCA,          "Arca RISC microprocessor"),
 894   ENUM_ENT(EM_UNICORE,       "Unicore"),
 895   ENUM_ENT(EM_EXCESS,        "eXcess 16/32/64-bit configurable embedded CPU"),
 896   ENUM_ENT(EM_DXP,           "Icera Semiconductor Inc. Deep Execution Processor"),
 897   ENUM_ENT(EM_ALTERA_NIOS2,  "Altera Nios"),
 898   ENUM_ENT(EM_CRX,           "National Semiconductor CRX microprocessor"),
 899   ENUM_ENT(EM_XGATE,         "Motorola XGATE embedded processor"),
 900   ENUM_ENT(EM_C166,          "Infineon Technologies xc16x"),
 901   ENUM_ENT(EM_M16C,          "Renesas M16C"),
 902   ENUM_ENT(EM_DSPIC30F,      "Microchip Technology dsPIC30F Digital Signal Controller"),
 903   ENUM_ENT(EM_CE,            "Freescale Communication Engine RISC core"),
 904   ENUM_ENT(EM_M32C,          "Renesas M32C"),
 905   ENUM_ENT(EM_TSK3000,       "Altium TSK3000 core"),
 906   ENUM_ENT(EM_RS08,          "Freescale RS08 embedded processor"),
 907   ENUM_ENT(EM_SHARC,         "EM_SHARC"),
 908   ENUM_ENT(EM_ECOG2,         "Cyan Technology eCOG2 microprocessor"),
 909   ENUM_ENT(EM_SCORE7,        "SUNPLUS S+Core"),
 910   ENUM_ENT(EM_DSP24,         "New Japan Radio (NJR) 24-bit DSP Processor"),
 911   ENUM_ENT(EM_VIDEOCORE3,    "Broadcom VideoCore III processor"),
 912   ENUM_ENT(EM_LATTICEMICO32, "Lattice Mico32"),
 913   ENUM_ENT(EM_SE_C17,        "Seiko Epson C17 family"),
 914   ENUM_ENT(EM_TI_C6000,      "Texas Instruments TMS320C6000 DSP family"),
 915   ENUM_ENT(EM_TI_C2000,      "Texas Instruments TMS320C2000 DSP family"),
 916   ENUM_ENT(EM_TI_C5500,      "Texas Instruments TMS320C55x DSP family"),
 917   ENUM_ENT(EM_MMDSP_PLUS,    "STMicroelectronics 64bit VLIW Data Signal Processor"),
 918   ENUM_ENT(EM_CYPRESS_M8C,   "Cypress M8C microprocessor"),
 919   ENUM_ENT(EM_R32C,          "Renesas R32C series microprocessors"),
 920   ENUM_ENT(EM_TRIMEDIA,      "NXP Semiconductors TriMedia architecture family"),
 921   ENUM_ENT(EM_HEXAGON,       "Qualcomm Hexagon"),
 922   ENUM_ENT(EM_8051,          "Intel 8051 and variants"),
 923   ENUM_ENT(EM_STXP7X,        "STMicroelectronics STxP7x family"),
 924   ENUM_ENT(EM_NDS32,         "Andes Technology compact code size embedded RISC processor family"),
 925   ENUM_ENT(EM_ECOG1,         "Cyan Technology eCOG1 microprocessor"),
 926   ENUM_ENT(EM_ECOG1X,        "Cyan Technology eCOG1X family"),
 927   ENUM_ENT(EM_MAXQ30,        "Dallas Semiconductor MAXQ30 Core microcontrollers"),
 928   ENUM_ENT(EM_XIMO16,        "New Japan Radio (NJR) 16-bit DSP Processor"),
 929   ENUM_ENT(EM_MANIK,         "M2000 Reconfigurable RISC Microprocessor"),
 930   ENUM_ENT(EM_CRAYNV2,       "Cray Inc. NV2 vector architecture"),
 931   ENUM_ENT(EM_RX,            "Renesas RX"),
 932   ENUM_ENT(EM_METAG,         "Imagination Technologies Meta processor architecture"),
 933   ENUM_ENT(EM_MCST_ELBRUS,   "MCST Elbrus general purpose hardware architecture"),
 934   ENUM_ENT(EM_ECOG16,        "Cyan Technology eCOG16 family"),
 935   ENUM_ENT(EM_CR16,          "Xilinx MicroBlaze"),
 936   ENUM_ENT(EM_ETPU,          "Freescale Extended Time Processing Unit"),
 937   ENUM_ENT(EM_SLE9X,         "Infineon Technologies SLE9X core"),
 938   ENUM_ENT(EM_L10M,          "EM_L10M"),
 939   ENUM_ENT(EM_K10M,          "EM_K10M"),
 940   ENUM_ENT(EM_AARCH64,       "AArch64"),
 941   ENUM_ENT(EM_AVR32,         "Atmel AVR 8-bit microcontroller"),
 942   ENUM_ENT(EM_STM8,          "STMicroeletronics STM8 8-bit microcontroller"),
 943   ENUM_ENT(EM_TILE64,        "Tilera TILE64 multicore architecture family"),
 944   ENUM_ENT(EM_TILEPRO,       "Tilera TILEPro multicore architecture family"),
 945   ENUM_ENT(EM_CUDA,          "NVIDIA CUDA architecture"),
 946   ENUM_ENT(EM_TILEGX,        "Tilera TILE-Gx multicore architecture family"),
 947   ENUM_ENT(EM_CLOUDSHIELD,   "EM_CLOUDSHIELD"),
 948   ENUM_ENT(EM_COREA_1ST,     "EM_COREA_1ST"),
 949   ENUM_ENT(EM_COREA_2ND,     "EM_COREA_2ND"),
 950   ENUM_ENT(EM_ARC_COMPACT2,  "EM_ARC_COMPACT2"),
 951   ENUM_ENT(EM_OPEN8,         "EM_OPEN8"),
 952   ENUM_ENT(EM_RL78,          "Renesas RL78"),
 953   ENUM_ENT(EM_VIDEOCORE5,    "Broadcom VideoCore V processor"),
 954   ENUM_ENT(EM_78KOR,         "EM_78KOR"),
 955   ENUM_ENT(EM_56800EX,       "EM_56800EX"),
 956   ENUM_ENT(EM_AMDGPU,        "EM_AMDGPU"),
 957   ENUM_ENT(EM_WEBASSEMBLY,   "EM_WEBASSEMBLY"),
 958   ENUM_ENT(EM_LANAI,         "EM_LANAI"),
 959   ENUM_ENT(EM_BPF,           "EM_BPF"),
 960 };
 961
 962 static const EnumEntry<unsigned> ElfSymbolBindings[] = {
 963     {"Local",  "LOCAL",  ELF::STB_LOCAL},
 964     {"Global", "GLOBAL", ELF::STB_GLOBAL},
 965     {"Weak",   "WEAK",   ELF::STB_WEAK},
 966     {"Unique", "UNIQUE", ELF::STB_GNU_UNIQUE}};
 967
 968 static const EnumEntry<unsigned> ElfSymbolVisibilities[] = {
 969     {"DEFAULT",   "DEFAULT",   ELF::STV_DEFAULT},
 970     {"INTERNAL",  "INTERNAL",  ELF::STV_INTERNAL},
 971     {"HIDDEN",    "HIDDEN",    ELF::STV_HIDDEN},
 972     {"PROTECTED", "PROTECTED", ELF::STV_PROTECTED}};
 973
 974 static const EnumEntry<unsigned> ElfSymbolTypes[] = {
 975     {"None",      "NOTYPE",  ELF::STT_NOTYPE},
 976     {"Object",    "OBJECT",  ELF::STT_OBJECT},
 977     {"Function",  "FUNC",    ELF::STT_FUNC},
 978     {"Section",   "SECTION", ELF::STT_SECTION},
 979     {"File",      "FILE",    ELF::STT_FILE},
 980     {"Common",    "COMMON",  ELF::STT_COMMON},
 981     {"TLS",       "TLS",     ELF::STT_TLS},
 982     {"GNU_IFunc", "IFUNC",   ELF::STT_GNU_IFUNC}};
 983
 984 static const EnumEntry<unsigned> AMDGPUSymbolTypes[] = {
 985   { "AMDGPU_HSA_KERNEL",            ELF::STT_AMDGPU_HSA_KERNEL },
 986   { "AMDGPU_HSA_INDIRECT_FUNCTION", ELF::STT_AMDGPU_HSA_INDIRECT_FUNCTION },
 987   { "AMDGPU_HSA_METADATA",          ELF::STT_AMDGPU_HSA_METADATA }
 988 };
 989
 990 static const char *getElfSectionType(unsigned Arch, unsigned Type) {
 991   switch (Arch) {
 992   case ELF::EM_ARM:
 993     switch (Type) {
 994     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
 995     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
 996     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
 997     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
 998     LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
 999     }
1000   case ELF::EM_HEXAGON:
1001     switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
1002   case ELF::EM_X86_64:
1003     switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
1004   case ELF::EM_MIPS:
1005   case ELF::EM_MIPS_RS3_LE:
1006     switch (Type) {
1007     LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
1008     LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
1009     LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
1010     }
1011   }
1012
1013   switch (Type) {
1014   LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL              );
1015   LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS          );
1016   LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB            );
1017   LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB            );
1018   LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA              );
1019   LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH              );
1020   LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC           );
1021   LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE              );
1022   LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS            );
1023   LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL               );
1024   LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB             );
1025   LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM            );
1026   LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY        );
1027   LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY        );
1028   LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY     );
1029   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP             );
1030   LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX      );
1031   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES    );
1032   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
1033   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
1034   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
1035   LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
1036   default: return "";
1037   }
1038 }
1039
1040 static const char *getGroupType(uint32_t Flag) {
1041   if (Flag & ELF::GRP_COMDAT)
1042     return "COMDAT";
1043   else
1044     return "(unknown)";
1045 }
1046
1047 static const EnumEntry<unsigned> ElfSectionFlags[] = {
1048   ENUM_ENT(SHF_WRITE,            "W"),
1049   ENUM_ENT(SHF_ALLOC,            "A"),
1050   ENUM_ENT(SHF_EXCLUDE,          "E"),
1051   ENUM_ENT(SHF_EXECINSTR,        "X"),
1052   ENUM_ENT(SHF_MERGE,            "M"),
1053   ENUM_ENT(SHF_STRINGS,          "S"),
1054   ENUM_ENT(SHF_INFO_LINK,        "I"),
1055   ENUM_ENT(SHF_LINK_ORDER,       "L"),
1056   ENUM_ENT(SHF_OS_NONCONFORMING, "o"),
1057   ENUM_ENT(SHF_GROUP,            "G"),
1058   ENUM_ENT(SHF_TLS,              "T"),
1059   ENUM_ENT(SHF_MASKOS,           "o"),
1060   ENUM_ENT(SHF_MASKPROC,         "p"),
1061   ENUM_ENT_1(SHF_COMPRESSED),
1062 };
1063
1064 static const EnumEntry<unsigned> ElfXCoreSectionFlags[] = {
1065   LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
1066   LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION)
1067 };
1068
1069 static const EnumEntry<unsigned> ElfAMDGPUSectionFlags[] = {
1070   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_GLOBAL),
1071   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_READONLY),
1072   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_CODE),
1073   LLVM_READOBJ_ENUM_ENT(ELF, SHF_AMDGPU_HSA_AGENT)
1074 };
1075
1076 static const EnumEntry<unsigned> ElfHexagonSectionFlags[] = {
1077   LLVM_READOBJ_ENUM_ENT(ELF, SHF_HEX_GPREL)
1078 };
1079
1080 static const EnumEntry<unsigned> ElfMipsSectionFlags[] = {
1081   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NODUPES),
1082   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NAMES  ),
1083   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_LOCAL  ),
1084   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP),
1085   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_GPREL  ),
1086   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_MERGE  ),
1087   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_ADDR   ),
1088   LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_STRING )
1089 };
1090
1091 static const EnumEntry<unsigned> ElfX86_64SectionFlags[] = {
1092   LLVM_READOBJ_ENUM_ENT(ELF, SHF_X86_64_LARGE)
1093 };
1094
1095 static std::string getGNUFlags(uint64_t Flags) {
1096   std::string Str;
1097   for (auto Entry : ElfSectionFlags) {
1098     uint64_t Flag = Entry.Value & Flags;
1099     Flags &= ~Entry.Value;
1100     switch (Flag) {
1101     case ELF::SHF_WRITE:
1102     case ELF::SHF_ALLOC:
1103     case ELF::SHF_EXECINSTR:
1104     case ELF::SHF_MERGE:
1105     case ELF::SHF_STRINGS:
1106     case ELF::SHF_INFO_LINK:
1107     case ELF::SHF_LINK_ORDER:
1108     case ELF::SHF_OS_NONCONFORMING:
1109     case ELF::SHF_GROUP:
1110     case ELF::SHF_TLS:
1111     case ELF::SHF_EXCLUDE:
1112       Str += Entry.AltName;
1113       break;
1114     default:
1115       if (Flag & ELF::SHF_MASKOS)
1116         Str += "o";
1117       else if (Flag & ELF::SHF_MASKPROC)
1118         Str += "p";
1119       else if (Flag)
1120         Str += "x";
1121     }
1122   }
1123   return Str;
1124 }
1125
1126 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
1127   // Check potentially overlapped processor-specific
1128   // program header type.
1129   switch (Arch) {
1130   case ELF::EM_AMDGPU:
1131     switch (Type) {
1132     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM);
1133     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT);
1134     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_READONLY_AGENT);
1135     LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_CODE_AGENT);
1136     }
1137   case ELF::EM_ARM:
1138     switch (Type) {
1139     LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
1140     }
1141   case ELF::EM_MIPS:
1142   case ELF::EM_MIPS_RS3_LE:
1143     switch (Type) {
1144     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
1145     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
1146     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
1147     LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
1148     }
1149   }
1150
1151   switch (Type) {
1152   LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL   );
1153   LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD   );
1154   LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
1155   LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
1156   LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE   );
1157   LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB  );
1158   LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR   );
1159   LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS    );
1160
1161   LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
1162   LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
1163
1164   LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
1165   LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
1166   default: return "";
1167   }
1168 }
1169
1170 static std::string getElfPtType(unsigned Arch, unsigned Type) {
1171   switch (Type) {
1172     LLVM_READOBJ_PHDR_ENUM(ELF, PT_NULL)
1173     LLVM_READOBJ_PHDR_ENUM(ELF, PT_LOAD)
1174     LLVM_READOBJ_PHDR_ENUM(ELF, PT_DYNAMIC)
1175     LLVM_READOBJ_PHDR_ENUM(ELF, PT_INTERP)
1176     LLVM_READOBJ_PHDR_ENUM(ELF, PT_NOTE)
1177     LLVM_READOBJ_PHDR_ENUM(ELF, PT_SHLIB)
1178     LLVM_READOBJ_PHDR_ENUM(ELF, PT_PHDR)
1179     LLVM_READOBJ_PHDR_ENUM(ELF, PT_TLS)
1180     LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_EH_FRAME)
1181     LLVM_READOBJ_PHDR_ENUM(ELF, PT_SUNW_UNWIND)
1182     LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_STACK)
1183     LLVM_READOBJ_PHDR_ENUM(ELF, PT_GNU_RELRO)
1184   default:
1185     // All machine specific PT_* types
1186     switch (Arch) {
1187     case ELF::EM_AMDGPU:
1188       switch (Type) {
1189         LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_PROGRAM);
1190         LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_GLOBAL_AGENT);
1191         LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_READONLY_AGENT);
1192         LLVM_READOBJ_ENUM_CASE(ELF, PT_AMDGPU_HSA_LOAD_CODE_AGENT);
1193       }
1194       return "";
1195     case ELF::EM_ARM:
1196       if (Type == ELF::PT_ARM_EXIDX)
1197         return "EXIDX";
1198       return "";
1199     case ELF::EM_MIPS:
1200     case ELF::EM_MIPS_RS3_LE:
1201       switch (Type) {
1202       case PT_MIPS_REGINFO:
1203         return "REGINFO";
1204       case PT_MIPS_RTPROC:
1205         return "RTPROC";
1206       case PT_MIPS_OPTIONS:
1207         return "OPTIONS";
1208       case PT_MIPS_ABIFLAGS:
1209         return "ABIFLAGS";
1210       }
1211       return "";
1212     }
1213   }
1214   return std::string("<unknown>: ") + to_string(format_hex(Type, 1));
1215 }
1216
1217 static const EnumEntry<unsigned> ElfSegmentFlags[] = {
1218   LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
1219   LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
1220   LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
1221 };
1222
1223 static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
1224   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
1225   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
1226   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
1227   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
1228   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
1229   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_FP64),
1230   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
1231   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
1232   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O64),
1233   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI32),
1234   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI64),
1235   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_3900),
1236   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4010),
1237   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4100),
1238   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4650),
1239   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4120),
1240   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4111),
1241   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_SB1),
1242   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON),
1243   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_XLR),
1244   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON2),
1245   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON3),
1246   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5400),
1247   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5900),
1248   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5500),
1249   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_9000),
1250   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2E),
1251   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2F),
1252   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS3A),
1253   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
1254   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
1255   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_MDMX),
1256   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
1257   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
1258   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
1259   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
1260   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
1261   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
1262   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
1263   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
1264   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
1265   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
1266   LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
1267 };
1268
1269 static const EnumEntry<unsigned> ElfSymOtherFlags[] = {
1270   LLVM_READOBJ_ENUM_ENT(ELF, STV_INTERNAL),
1271   LLVM_READOBJ_ENUM_ENT(ELF, STV_HIDDEN),
1272   LLVM_READOBJ_ENUM_ENT(ELF, STV_PROTECTED)
1273 };
1274
1275 static const EnumEntry<unsigned> ElfMipsSymOtherFlags[] = {
1276   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
1277   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT),
1278   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PIC),
1279   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MICROMIPS)
1280 };
1281
1282 static const EnumEntry<unsigned> ElfMips16SymOtherFlags[] = {
1283   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_OPTIONAL),
1284   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_PLT),
1285   LLVM_READOBJ_ENUM_ENT(ELF, STO_MIPS_MIPS16)
1286 };
1287
1288 static const char *getElfMipsOptionsOdkType(unsigned Odk) {
1289   switch (Odk) {
1290   LLVM_READOBJ_ENUM_CASE(ELF, ODK_NULL);
1291   LLVM_READOBJ_ENUM_CASE(ELF, ODK_REGINFO);
1292   LLVM_READOBJ_ENUM_CASE(ELF, ODK_EXCEPTIONS);
1293   LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAD);
1294   LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWPATCH);
1295   LLVM_READOBJ_ENUM_CASE(ELF, ODK_FILL);
1296   LLVM_READOBJ_ENUM_CASE(ELF, ODK_TAGS);
1297   LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWAND);
1298   LLVM_READOBJ_ENUM_CASE(ELF, ODK_HWOR);
1299   LLVM_READOBJ_ENUM_CASE(ELF, ODK_GP_GROUP);
1300   LLVM_READOBJ_ENUM_CASE(ELF, ODK_IDENT);
1301   LLVM_READOBJ_ENUM_CASE(ELF, ODK_PAGESIZE);
1302   default:
1303     return "Unknown";
1304   }
1305 }
1306
1307 template <typename ELFT>
1308 ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, ScopedPrinter &Writer)
1309     : ObjDumper(Writer), Obj(Obj) {
1310
1311   SmallVector<const Elf_Phdr *, 4> LoadSegments;
1312   for (const Elf_Phdr &Phdr : Obj->program_headers()) {
1313     if (Phdr.p_type == ELF::PT_DYNAMIC) {
1314       DynamicTable = createDRIFrom(&Phdr, sizeof(Elf_Dyn));
1315       continue;
1316     }
1317     if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0)
1318       continue;
1319     LoadSegments.push_back(&Phdr);
1320   }
1321
1322   for (const Elf_Shdr &Sec : Obj->sections()) {
1323     switch (Sec.sh_type) {
1324     case ELF::SHT_SYMTAB:
1325       if (DotSymtabSec != nullptr)
1326         reportError("Multilpe SHT_SYMTAB");
1327       DotSymtabSec = &Sec;
1328       break;
1329     case ELF::SHT_DYNSYM:
1330       if (DynSymRegion.Size)
1331         reportError("Multilpe SHT_DYNSYM");
1332       DynSymRegion = createDRIFrom(&Sec);
1333       // This is only used (if Elf_Shdr present)for naming section in GNU style
1334       DynSymtabName = unwrapOrError(Obj->getSectionName(&Sec));
1335       break;
1336     case ELF::SHT_SYMTAB_SHNDX:
1337       ShndxTable = unwrapOrError(Obj->getSHNDXTable(Sec));
1338       break;
1339     case ELF::SHT_GNU_versym:
1340       if (dot_gnu_version_sec != nullptr)
1341         reportError("Multiple SHT_GNU_versym");
1342       dot_gnu_version_sec = &Sec;
1343       break;
1344     case ELF::SHT_GNU_verdef:
1345       if (dot_gnu_version_d_sec != nullptr)
1346         reportError("Multiple SHT_GNU_verdef");
1347       dot_gnu_version_d_sec = &Sec;
1348       break;
1349     case ELF::SHT_GNU_verneed:
1350       if (dot_gnu_version_r_sec != nullptr)
1351         reportError("Multilpe SHT_GNU_verneed");
1352       dot_gnu_version_r_sec = &Sec;
1353       break;
1354     }
1355   }
1356
1357   parseDynamicTable(LoadSegments);
1358
1359   if (opts::Output == opts::GNU)
1360     ELFDumperStyle.reset(new GNUStyle<ELFT>(Writer, this));
1361   else
1362     ELFDumperStyle.reset(new LLVMStyle<ELFT>(Writer, this));
1363 }
1364
1365 template <typename ELFT>
1366 void ELFDumper<ELFT>::parseDynamicTable(
1367     ArrayRef<const Elf_Phdr *> LoadSegments) {
1368   auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
1369     const Elf_Phdr *const *I = std::upper_bound(
1370         LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>);
1371     if (I == LoadSegments.begin())
1372       report_fatal_error("Virtual address is not in any segment");
1373     --I;
1374     const Elf_Phdr &Phdr = **I;
1375     uint64_t Delta = VAddr - Phdr.p_vaddr;
1376     if (Delta >= Phdr.p_filesz)
1377       report_fatal_error("Virtual address is not in any segment");
1378     return Obj->base() + Phdr.p_offset + Delta;
1379   };
1380
1381   uint64_t SONameOffset = 0;
1382   const char *StringTableBegin = nullptr;
1383   uint64_t StringTableSize = 0;
1384   for (const Elf_Dyn &Dyn : dynamic_table()) {
1385     switch (Dyn.d_tag) {
1386     case ELF::DT_HASH:
1387       HashTable =
1388           reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
1389       break;
1390     case ELF::DT_GNU_HASH:
1391       GnuHashTable =
1392           reinterpret_cast<const Elf_GnuHash *>(toMappedAddr(Dyn.getPtr()));
1393       break;
1394     case ELF::DT_STRTAB:
1395       StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr());
1396       break;
1397     case ELF::DT_STRSZ:
1398       StringTableSize = Dyn.getVal();
1399       break;
1400     case ELF::DT_SYMTAB:
1401       DynSymRegion.Addr = toMappedAddr(Dyn.getPtr());
1402       DynSymRegion.EntSize = sizeof(Elf_Sym);
1403       break;
1404     case ELF::DT_RELA:
1405       DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
1406       break;
1407     case ELF::DT_RELASZ:
1408       DynRelaRegion.Size = Dyn.getVal();
1409       break;
1410     case ELF::DT_RELAENT:
1411       DynRelaRegion.EntSize = Dyn.getVal();
1412       break;
1413     case ELF::DT_SONAME:
1414       SONameOffset = Dyn.getVal();
1415       break;
1416     case ELF::DT_REL:
1417       DynRelRegion.Addr = toMappedAddr(Dyn.getPtr());
1418       break;
1419     case ELF::DT_RELSZ:
1420       DynRelRegion.Size = Dyn.getVal();
1421       break;
1422     case ELF::DT_RELENT:
1423       DynRelRegion.EntSize = Dyn.getVal();
1424       break;
1425     case ELF::DT_PLTREL:
1426       if (Dyn.getVal() == DT_REL)
1427         DynPLTRelRegion.EntSize = sizeof(Elf_Rel);
1428       else if (Dyn.getVal() == DT_RELA)
1429         DynPLTRelRegion.EntSize = sizeof(Elf_Rela);
1430       else
1431         reportError(Twine("unknown DT_PLTREL value of ") +
1432                     Twine((uint64_t)Dyn.getVal()));
1433       break;
1434     case ELF::DT_JMPREL:
1435       DynPLTRelRegion.Addr = toMappedAddr(Dyn.getPtr());
1436       break;
1437     case ELF::DT_PLTRELSZ:
1438       DynPLTRelRegion.Size = Dyn.getVal();
1439       break;
1440     }
1441   }
1442   if (StringTableBegin)
1443     DynamicStringTable = StringRef(StringTableBegin, StringTableSize);
1444   if (SONameOffset)
1445     SOName = getDynamicString(SONameOffset);
1446 }
1447
1448 template <typename ELFT>
1449 typename ELFDumper<ELFT>::Elf_Rel_Range ELFDumper<ELFT>::dyn_rels() const {
1450   return DynRelRegion.getAsArrayRef<Elf_Rel>();
1451 }
1452
1453 template <typename ELFT>
1454 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
1455   return DynRelaRegion.getAsArrayRef<Elf_Rela>();
1456 }
1457
1458 template<class ELFT>
1459 void ELFDumper<ELFT>::printFileHeaders() {
1460   ELFDumperStyle->printFileHeaders(Obj);
1461 }
1462
1463 template<class ELFT>
1464 void ELFDumper<ELFT>::printSections() {
1465   ELFDumperStyle->printSections(Obj);
1466 }
1467
1468 template<class ELFT>
1469 void ELFDumper<ELFT>::printRelocations() {
1470   ELFDumperStyle->printRelocations(Obj);
1471 }
1472
1473 template <class ELFT> void ELFDumper<ELFT>::printProgramHeaders() {
1474   ELFDumperStyle->printProgramHeaders(Obj);
1475 }
1476
1477 template <class ELFT> void ELFDumper<ELFT>::printDynamicRelocations() {
1478   ELFDumperStyle->printDynamicRelocations(Obj);
1479 }
1480
1481 template<class ELFT>
1482 void ELFDumper<ELFT>::printSymbols() {
1483   ELFDumperStyle->printSymbols(Obj);
1484 }
1485
1486 template<class ELFT>
1487 void ELFDumper<ELFT>::printDynamicSymbols() {
1488   ELFDumperStyle->printDynamicSymbols(Obj);
1489 }
1490
1491 template <class ELFT> void ELFDumper<ELFT>::printHashHistogram() {
1492   ELFDumperStyle->printHashHistogram(Obj);
1493 }
1494 #define LLVM_READOBJ_TYPE_CASE(name) \
1495   case DT_##name: return #name
1496
1497 static const char *getTypeString(uint64_t Type) {
1498   switch (Type) {
1499   LLVM_READOBJ_TYPE_CASE(BIND_NOW);
1500   LLVM_READOBJ_TYPE_CASE(DEBUG);
1501   LLVM_READOBJ_TYPE_CASE(FINI);
1502   LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
1503   LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
1504   LLVM_READOBJ_TYPE_CASE(FLAGS);
1505   LLVM_READOBJ_TYPE_CASE(FLAGS_1);
1506   LLVM_READOBJ_TYPE_CASE(HASH);
1507   LLVM_READOBJ_TYPE_CASE(INIT);
1508   LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
1509   LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
1510   LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
1511   LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
1512   LLVM_READOBJ_TYPE_CASE(JMPREL);
1513   LLVM_READOBJ_TYPE_CASE(NEEDED);
1514   LLVM_READOBJ_TYPE_CASE(NULL);
1515   LLVM_READOBJ_TYPE_CASE(PLTGOT);
1516   LLVM_READOBJ_TYPE_CASE(PLTREL);
1517   LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
1518   LLVM_READOBJ_TYPE_CASE(REL);
1519   LLVM_READOBJ_TYPE_CASE(RELA);
1520   LLVM_READOBJ_TYPE_CASE(RELENT);
1521   LLVM_READOBJ_TYPE_CASE(RELSZ);
1522   LLVM_READOBJ_TYPE_CASE(RELAENT);
1523   LLVM_READOBJ_TYPE_CASE(RELASZ);
1524   LLVM_READOBJ_TYPE_CASE(RPATH);
1525   LLVM_READOBJ_TYPE_CASE(RUNPATH);
1526   LLVM_READOBJ_TYPE_CASE(SONAME);
1527   LLVM_READOBJ_TYPE_CASE(STRSZ);
1528   LLVM_READOBJ_TYPE_CASE(STRTAB);
1529   LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
1530   LLVM_READOBJ_TYPE_CASE(SYMENT);
1531   LLVM_READOBJ_TYPE_CASE(SYMTAB);
1532   LLVM_READOBJ_TYPE_CASE(TEXTREL);
1533   LLVM_READOBJ_TYPE_CASE(VERDEF);
1534   LLVM_READOBJ_TYPE_CASE(VERDEFNUM);
1535   LLVM_READOBJ_TYPE_CASE(VERNEED);
1536   LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
1537   LLVM_READOBJ_TYPE_CASE(VERSYM);
1538   LLVM_READOBJ_TYPE_CASE(RELACOUNT);
1539   LLVM_READOBJ_TYPE_CASE(RELCOUNT);
1540   LLVM_READOBJ_TYPE_CASE(GNU_HASH);
1541   LLVM_READOBJ_TYPE_CASE(TLSDESC_PLT);
1542   LLVM_READOBJ_TYPE_CASE(TLSDESC_GOT);
1543   LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
1544   LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP_REL);
1545   LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
1546   LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
1547   LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
1548   LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
1549   LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
1550   LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
1551   LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
1552   LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
1553   LLVM_READOBJ_TYPE_CASE(MIPS_OPTIONS);
1554   default: return "unknown";
1555   }
1556 }
1557
1558 #undef LLVM_READOBJ_TYPE_CASE
1559
1560 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
1561   { #enum, prefix##_##enum }
1562
1563 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
1564   LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
1565   LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
1566   LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
1567   LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
1568   LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
1569 };
1570
1571 static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
1572   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
1573   LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
1574   LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
1575   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
1576   LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
1577   LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
1578   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
1579   LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
1580   LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
1581   LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
1582   LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
1583   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
1584   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
1585   LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
1586   LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
1587   LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
1588   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
1589   LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
1590   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
1591   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
1592   LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
1593   LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
1594   LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
1595   LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
1596   LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON)
1597 };
1598
1599 static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
1600   LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
1601   LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
1602   LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
1603   LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
1604   LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
1605   LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
1606   LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
1607   LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
1608   LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
1609   LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
1610   LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
1611   LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
1612   LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
1613   LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
1614   LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
1615   LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
1616 };
1617
1618 #undef LLVM_READOBJ_DT_FLAG_ENT
1619
1620 template <typename T, typename TFlag>
1621 void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
1622   typedef EnumEntry<TFlag> FlagEntry;
1623   typedef SmallVector<FlagEntry, 10> FlagVector;
1624   FlagVector SetFlags;
1625
1626   for (const auto &Flag : Flags) {
1627     if (Flag.Value == 0)
1628       continue;
1629
1630     if ((Value & Flag.Value) == Flag.Value)
1631       SetFlags.push_back(Flag);
1632   }
1633
1634   for (const auto &Flag : SetFlags) {
1635     OS << Flag.Name << " ";
1636   }
1637 }
1638
1639 template <class ELFT>
1640 StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const {
1641   if (Value >= DynamicStringTable.size())
1642     reportError("Invalid dynamic string table reference");
1643   return StringRef(DynamicStringTable.data() + Value);
1644 }
1645
1646 template <class ELFT>
1647 void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) {
1648   raw_ostream &OS = W.getOStream();
1649   const char* ConvChar = (opts::Output == opts::GNU) ? "0x%" PRIx64 : "0x%" PRIX64;
1650   switch (Type) {
1651   case DT_PLTREL:
1652     if (Value == DT_REL) {
1653       OS << "REL";
1654       break;
1655     } else if (Value == DT_RELA) {
1656       OS << "RELA";
1657       break;
1658     }
1659   // Fallthrough.
1660   case DT_PLTGOT:
1661   case DT_HASH:
1662   case DT_STRTAB:
1663   case DT_SYMTAB:
1664   case DT_RELA:
1665   case DT_INIT:
1666   case DT_FINI:
1667   case DT_REL:
1668   case DT_JMPREL:
1669   case DT_INIT_ARRAY:
1670   case DT_FINI_ARRAY:
1671   case DT_PREINIT_ARRAY:
1672   case DT_DEBUG:
1673   case DT_VERDEF:
1674   case DT_VERNEED:
1675   case DT_VERSYM:
1676   case DT_GNU_HASH:
1677   case DT_NULL:
1678   case DT_MIPS_BASE_ADDRESS:
1679   case DT_MIPS_GOTSYM:
1680   case DT_MIPS_RLD_MAP:
1681   case DT_MIPS_RLD_MAP_REL:
1682   case DT_MIPS_PLTGOT:
1683   case DT_MIPS_OPTIONS:
1684     OS << format(ConvChar, Value);
1685     break;
1686   case DT_RELACOUNT:
1687   case DT_RELCOUNT:
1688   case DT_VERDEFNUM:
1689   case DT_VERNEEDNUM:
1690   case DT_MIPS_RLD_VERSION:
1691   case DT_MIPS_LOCAL_GOTNO:
1692   case DT_MIPS_SYMTABNO:
1693   case DT_MIPS_UNREFEXTNO:
1694     OS << Value;
1695     break;
1696   case DT_PLTRELSZ:
1697   case DT_RELASZ:
1698   case DT_RELAENT:
1699   case DT_STRSZ:
1700   case DT_SYMENT:
1701   case DT_RELSZ:
1702   case DT_RELENT:
1703   case DT_INIT_ARRAYSZ:
1704   case DT_FINI_ARRAYSZ:
1705   case DT_PREINIT_ARRAYSZ:
1706     OS << Value << " (bytes)";
1707     break;
1708   case DT_NEEDED:
1709     OS << "SharedLibrary (" << getDynamicString(Value) << ")";
1710     break;
1711   case DT_SONAME:
1712     OS << "LibrarySoname (" << getDynamicString(Value) << ")";
1713     break;
1714   case DT_RPATH:
1715   case DT_RUNPATH:
1716     OS << getDynamicString(Value);
1717     break;
1718   case DT_MIPS_FLAGS:
1719     printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
1720     break;
1721   case DT_FLAGS:
1722     printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
1723     break;
1724   case DT_FLAGS_1:
1725     printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
1726     break;
1727   default:
1728     OS << format(ConvChar, Value);
1729     break;
1730   }
1731 }
1732
1733 template<class ELFT>
1734 void ELFDumper<ELFT>::printUnwindInfo() {
1735   W.startLine() << "UnwindInfo not implemented.\n";
1736 }
1737
1738 namespace {
1739 template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() {
1740   const unsigned Machine = Obj->getHeader()->e_machine;
1741   if (Machine == EM_ARM) {
1742     ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx(
1743         W, Obj, DotSymtabSec);
1744     return Ctx.PrintUnwindInformation();
1745   }
1746   W.startLine() << "UnwindInfo not implemented.\n";
1747 }
1748 }
1749
1750 template<class ELFT>
1751 void ELFDumper<ELFT>::printDynamicTable() {
1752   auto I = dynamic_table().begin();
1753   auto E = dynamic_table().end();
1754
1755   if (I == E)
1756     return;
1757
1758   --E;
1759   while (I != E && E->getTag() == ELF::DT_NULL)
1760     --E;
1761   if (E->getTag() != ELF::DT_NULL)
1762     ++E;
1763   ++E;
1764
1765   ptrdiff_t Total = std::distance(I, E);
1766   if (Total == 0)
1767     return;
1768
1769   raw_ostream &OS = W.getOStream();
1770   W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
1771
1772   bool Is64 = ELFT::Is64Bits;
1773
1774   W.startLine()
1775      << "  Tag" << (Is64 ? "                " : "        ") << "Type"
1776      << "                 " << "Name/Value\n";
1777   while (I != E) {
1778     const Elf_Dyn &Entry = *I;
1779     uintX_t Tag = Entry.getTag();
1780     ++I;
1781     W.startLine() << "  " << format_hex(Tag, Is64 ? 18 : 10, opts::Output != opts::GNU) << " "
1782                   << format("%-21s", getTypeString(Tag));
1783     printValue(Tag, Entry.getVal());
1784     OS << "\n";
1785   }
1786
1787   W.startLine() << "]\n";
1788 }
1789
1790 template<class ELFT>
1791 void ELFDumper<ELFT>::printNeededLibraries() {
1792   ListScope D(W, "NeededLibraries");
1793
1794   typedef std::vector<StringRef> LibsTy;
1795   LibsTy Libs;
1796
1797   for (const auto &Entry : dynamic_table())
1798     if (Entry.d_tag == ELF::DT_NEEDED)
1799       Libs.push_back(getDynamicString(Entry.d_un.d_val));
1800
1801   std::stable_sort(Libs.begin(), Libs.end());
1802
1803   for (const auto &L : Libs) {
1804     outs() << "  " << L << "\n";
1805   }
1806 }
1807
1808
1809 template <typename ELFT>
1810 void ELFDumper<ELFT>::printHashTable() {
1811   DictScope D(W, "HashTable");
1812   if (!HashTable)
1813     return;
1814   W.printNumber("Num Buckets", HashTable->nbucket);
1815   W.printNumber("Num Chains", HashTable->nchain);
1816   W.printList("Buckets", HashTable->buckets());
1817   W.printList("Chains", HashTable->chains());
1818 }
1819
1820 template <typename ELFT>
1821 void ELFDumper<ELFT>::printGnuHashTable() {
1822   DictScope D(W, "GnuHashTable");
1823   if (!GnuHashTable)
1824     return;
1825   W.printNumber("Num Buckets", GnuHashTable->nbuckets);
1826   W.printNumber("First Hashed Symbol Index", GnuHashTable->symndx);
1827   W.printNumber("Num Mask Words", GnuHashTable->maskwords);
1828   W.printNumber("Shift Count", GnuHashTable->shift2);
1829   W.printHexList("Bloom Filter", GnuHashTable->filter());
1830   W.printList("Buckets", GnuHashTable->buckets());
1831   Elf_Sym_Range Syms = dynamic_symbols();
1832   unsigned NumSyms = std::distance(Syms.begin(), Syms.end());
1833   if (!NumSyms)
1834     reportError("No dynamic symbol section");
1835   W.printHexList("Values", GnuHashTable->values(NumSyms));
1836 }
1837
1838 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
1839   outs() << "LoadName: " << SOName << '\n';
1840 }
1841
1842 template <class ELFT>
1843 void ELFDumper<ELFT>::printAttributes() {
1844   W.startLine() << "Attributes not implemented.\n";
1845 }
1846
1847 namespace {
1848 template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() {
1849   if (Obj->getHeader()->e_machine != EM_ARM) {
1850     W.startLine() << "Attributes not implemented.\n";
1851     return;
1852   }
1853
1854   DictScope BA(W, "BuildAttributes");
1855   for (const ELFO::Elf_Shdr &Sec : Obj->sections()) {
1856     if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
1857       continue;
1858
1859     ArrayRef<uint8_t> Contents = unwrapOrError(Obj->getSectionContents(&Sec));
1860     if (Contents[0] != ARMBuildAttrs::Format_Version) {
1861       errs() << "unrecognised FormatVersion: 0x" << utohexstr(Contents[0])
1862              << '\n';
1863       continue;
1864     }
1865
1866     W.printHex("FormatVersion", Contents[0]);
1867     if (Contents.size() == 1)
1868       continue;
1869
1870     ARMAttributeParser(W).Parse(Contents);
1871   }
1872 }
1873 }
1874
1875 namespace {
1876 template <class ELFT> class MipsGOTParser {
1877 public:
1878   typedef object::ELFFile<ELFT> ELFO;
1879   typedef typename ELFO::Elf_Shdr Elf_Shdr;
1880   typedef typename ELFO::Elf_Sym Elf_Sym;
1881   typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
1882   typedef typename ELFO::Elf_Addr GOTEntry;
1883   typedef typename ELFO::Elf_Rel Elf_Rel;
1884   typedef typename ELFO::Elf_Rela Elf_Rela;
1885
1886   MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj,
1887                 Elf_Dyn_Range DynTable, ScopedPrinter &W);
1888
1889   void parseGOT();
1890   void parsePLT();
1891
1892 private:
1893   ELFDumper<ELFT> *Dumper;
1894   const ELFO *Obj;
1895   ScopedPrinter &W;
1896   llvm::Optional<uint64_t> DtPltGot;
1897   llvm::Optional<uint64_t> DtLocalGotNum;
1898   llvm::Optional<uint64_t> DtGotSym;
1899   llvm::Optional<uint64_t> DtMipsPltGot;
1900   llvm::Optional<uint64_t> DtJmpRel;
1901
1902   std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1903   const GOTEntry *makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1904
1905   void printGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1906                      const GOTEntry *It);
1907   void printGlobalGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1908                            const GOTEntry *It, const Elf_Sym *Sym,
1909                            StringRef StrTable, bool IsDynamic);
1910   void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1911                      const GOTEntry *It, StringRef Purpose);
1912   void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1913                      const GOTEntry *It, StringRef StrTable,
1914                      const Elf_Sym *Sym);
1915 };
1916 }
1917
1918 template <class ELFT>
1919 MipsGOTParser<ELFT>::MipsGOTParser(ELFDumper<ELFT> *Dumper, const ELFO *Obj,
1920                                    Elf_Dyn_Range DynTable, ScopedPrinter &W)
1921     : Dumper(Dumper), Obj(Obj), W(W) {
1922   for (const auto &Entry : DynTable) {
1923     switch (Entry.getTag()) {
1924     case ELF::DT_PLTGOT:
1925       DtPltGot = Entry.getVal();
1926       break;
1927     case ELF::DT_MIPS_LOCAL_GOTNO:
1928       DtLocalGotNum = Entry.getVal();
1929       break;
1930     case ELF::DT_MIPS_GOTSYM:
1931       DtGotSym = Entry.getVal();
1932       break;
1933     case ELF::DT_MIPS_PLTGOT:
1934       DtMipsPltGot = Entry.getVal();
1935       break;
1936     case ELF::DT_JMPREL:
1937       DtJmpRel = Entry.getVal();
1938       break;
1939     }
1940   }
1941 }
1942
1943 template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() {
1944   // See "Global Offset Table" in Chapter 5 in the following document
1945   // for detailed GOT description.
1946   // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1947   if (!DtPltGot) {
1948     W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1949     return;
1950   }
1951   if (!DtLocalGotNum) {
1952     W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1953     return;
1954   }
1955   if (!DtGotSym) {
1956     W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1957     return;
1958   }
1959
1960   StringRef StrTable = Dumper->getDynamicStringTable();
1961   const Elf_Sym *DynSymBegin = Dumper->dynamic_symbols().begin();
1962   const Elf_Sym *DynSymEnd = Dumper->dynamic_symbols().end();
1963   std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1964
1965   if (*DtGotSym > DynSymTotal)
1966     report_fatal_error("MIPS_GOTSYM exceeds a number of dynamic symbols");
1967
1968   std::size_t GlobalGotNum = DynSymTotal - *DtGotSym;
1969
1970   if (*DtLocalGotNum + GlobalGotNum == 0) {
1971     W.startLine() << "GOT is empty.\n";
1972     return;
1973   }
1974
1975   const Elf_Shdr *GOTShdr = findNotEmptySectionByAddress(Obj, *DtPltGot);
1976   if (!GOTShdr)
1977     report_fatal_error("There is no not empty GOT section at 0x" +
1978                        Twine::utohexstr(*DtPltGot));
1979
1980   ArrayRef<uint8_t> GOT = unwrapOrError(Obj->getSectionContents(GOTShdr));
1981
1982   if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(GOT))
1983     report_fatal_error("Number of GOT entries exceeds the size of GOT section");
1984
1985   const GOTEntry *GotBegin = makeGOTIter(GOT, 0);
1986   const GOTEntry *GotLocalEnd = makeGOTIter(GOT, *DtLocalGotNum);
1987   const GOTEntry *It = GotBegin;
1988
1989   DictScope GS(W, "Primary GOT");
1990
1991   W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0);
1992   {
1993     ListScope RS(W, "Reserved entries");
1994
1995     {
1996       DictScope D(W, "Entry");
1997       printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1998       W.printString("Purpose", StringRef("Lazy resolver"));
1999     }
2000
2001     if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
2002       DictScope D(W, "Entry");
2003       printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
2004       W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
2005     }
2006   }
2007   {
2008     ListScope LS(W, "Local entries");
2009     for (; It != GotLocalEnd; ++It) {
2010       DictScope D(W, "Entry");
2011       printGotEntry(GOTShdr->sh_addr, GotBegin, It);
2012     }
2013   }
2014   {
2015     ListScope GS(W, "Global entries");
2016
2017     const GOTEntry *GotGlobalEnd =
2018         makeGOTIter(GOT, *DtLocalGotNum + GlobalGotNum);
2019     const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym;
2020     for (; It != GotGlobalEnd; ++It) {
2021       DictScope D(W, "Entry");
2022       printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++, StrTable,
2023                           true);
2024     }
2025   }
2026
2027   std::size_t SpecGotNum = getGOTTotal(GOT) - *DtLocalGotNum - GlobalGotNum;
2028   W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
2029 }
2030
2031 template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() {
2032   if (!DtMipsPltGot) {
2033     W.startLine() << "Cannot find MIPS_PLTGOT dynamic table tag.\n";
2034     return;
2035   }
2036   if (!DtJmpRel) {
2037     W.startLine() << "Cannot find JMPREL dynamic table tag.\n";
2038     return;
2039   }
2040
2041   const Elf_Shdr *PLTShdr = findNotEmptySectionByAddress(Obj, *DtMipsPltGot);
2042   if (!PLTShdr)
2043     report_fatal_error("There is no not empty PLTGOT section at 0x " +
2044                        Twine::utohexstr(*DtMipsPltGot));
2045   ArrayRef<uint8_t> PLT = unwrapOrError(Obj->getSectionContents(PLTShdr));
2046
2047   const Elf_Shdr *PLTRelShdr = findNotEmptySectionByAddress(Obj, *DtJmpRel);
2048   if (!PLTRelShdr)
2049     report_fatal_error("There is no not empty RELPLT section at 0x" +
2050                        Twine::utohexstr(*DtJmpRel));
2051   const Elf_Shdr *SymTable =
2052       unwrapOrError(Obj->getSection(PLTRelShdr->sh_link));
2053   StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTable));
2054
2055   const GOTEntry *PLTBegin = makeGOTIter(PLT, 0);
2056   const GOTEntry *PLTEnd = makeGOTIter(PLT, getGOTTotal(PLT));
2057   const GOTEntry *It = PLTBegin;
2058
2059   DictScope GS(W, "PLT GOT");
2060   {
2061     ListScope RS(W, "Reserved entries");
2062     printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "PLT lazy resolver");
2063     if (It != PLTEnd)
2064       printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "Module pointer");
2065   }
2066   {
2067     ListScope GS(W, "Entries");
2068
2069     switch (PLTRelShdr->sh_type) {
2070     case ELF::SHT_REL:
2071       for (const Elf_Rel *RI = Obj->rel_begin(PLTRelShdr),
2072                          *RE = Obj->rel_end(PLTRelShdr);
2073            RI != RE && It != PLTEnd; ++RI, ++It) {
2074         const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable);
2075         printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, StrTable, Sym);
2076       }
2077       break;
2078     case ELF::SHT_RELA:
2079       for (const Elf_Rela *RI = Obj->rela_begin(PLTRelShdr),
2080                           *RE = Obj->rela_end(PLTRelShdr);
2081            RI != RE && It != PLTEnd; ++RI, ++It) {
2082         const Elf_Sym *Sym = Obj->getRelocationSymbol(&*RI, SymTable);
2083         printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, StrTable, Sym);
2084       }
2085       break;
2086     }
2087   }
2088 }
2089
2090 template <class ELFT>
2091 std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
2092   return GOT.size() / sizeof(GOTEntry);
2093 }
2094
2095 template <class ELFT>
2096 const typename MipsGOTParser<ELFT>::GOTEntry *
2097 MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
2098   const char *Data = reinterpret_cast<const char *>(GOT.data());
2099   return reinterpret_cast<const GOTEntry *>(Data + EntryNum * sizeof(GOTEntry));
2100 }
2101
2102 template <class ELFT>
2103 void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr,
2104                                         const GOTEntry *BeginIt,
2105                                         const GOTEntry *It) {
2106   int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
2107   W.printHex("Address", GotAddr + Offset);
2108   W.printNumber("Access", Offset - 0x7ff0);
2109   W.printHex("Initial", *It);
2110 }
2111
2112 template <class ELFT>
2113 void MipsGOTParser<ELFT>::printGlobalGotEntry(
2114     uint64_t GotAddr, const GOTEntry *BeginIt, const GOTEntry *It,
2115     const Elf_Sym *Sym, StringRef StrTable, bool IsDynamic) {
2116   printGotEntry(GotAddr, BeginIt, It);
2117
2118   W.printHex("Value", Sym->st_value);
2119   W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
2120
2121   unsigned SectionIndex = 0;
2122   StringRef SectionName;
2123   getSectionNameIndex(*Obj, Sym, Dumper->dynamic_symbols().begin(),
2124                       Dumper->getShndxTable(), SectionName, SectionIndex);
2125   W.printHex("Section", SectionName, SectionIndex);
2126
2127   std::string FullSymbolName =
2128       Dumper->getFullSymbolName(Sym, StrTable, IsDynamic);
2129   W.printNumber("Name", FullSymbolName, Sym->st_name);
2130 }
2131
2132 template <class ELFT>
2133 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
2134                                         const GOTEntry *BeginIt,
2135                                         const GOTEntry *It, StringRef Purpose) {
2136   DictScope D(W, "Entry");
2137   int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
2138   W.printHex("Address", PLTAddr + Offset);
2139   W.printHex("Initial", *It);
2140   W.printString("Purpose", Purpose);
2141 }
2142
2143 template <class ELFT>
2144 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
2145                                         const GOTEntry *BeginIt,
2146                                         const GOTEntry *It, StringRef StrTable,
2147                                         const Elf_Sym *Sym) {
2148   DictScope D(W, "Entry");
2149   int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
2150   W.printHex("Address", PLTAddr + Offset);
2151   W.printHex("Initial", *It);
2152   W.printHex("Value", Sym->st_value);
2153   W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
2154
2155   unsigned SectionIndex = 0;
2156   StringRef SectionName;
2157   getSectionNameIndex(*Obj, Sym, Dumper->dynamic_symbols().begin(),
2158                       Dumper->getShndxTable(), SectionName, SectionIndex);
2159   W.printHex("Section", SectionName, SectionIndex);
2160
2161   std::string FullSymbolName = Dumper->getFullSymbolName(Sym, StrTable, true);
2162   W.printNumber("Name", FullSymbolName, Sym->st_name);
2163 }
2164
2165 template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
2166   if (Obj->getHeader()->e_machine != EM_MIPS) {
2167     W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
2168     return;
2169   }
2170
2171   MipsGOTParser<ELFT> GOTParser(this, Obj, dynamic_table(), W);
2172   GOTParser.parseGOT();
2173   GOTParser.parsePLT();
2174 }
2175
2176 static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
2177   {"None",                    Mips::AFL_EXT_NONE},
2178   {"Broadcom SB-1",           Mips::AFL_EXT_SB1},
2179   {"Cavium Networks Octeon",  Mips::AFL_EXT_OCTEON},
2180   {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
2181   {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
2182   {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
2183   {"LSI R4010",               Mips::AFL_EXT_4010},
2184   {"Loongson 2E",             Mips::AFL_EXT_LOONGSON_2E},
2185   {"Loongson 2F",             Mips::AFL_EXT_LOONGSON_2F},
2186   {"Loongson 3A",             Mips::AFL_EXT_LOONGSON_3A},
2187   {"MIPS R4650",              Mips::AFL_EXT_4650},
2188   {"MIPS R5900",              Mips::AFL_EXT_5900},
2189   {"MIPS R10000",             Mips::AFL_EXT_10000},
2190   {"NEC VR4100",              Mips::AFL_EXT_4100},
2191   {"NEC VR4111/VR4181",       Mips::AFL_EXT_4111},
2192   {"NEC VR4120",              Mips::AFL_EXT_4120},
2193   {"NEC VR5400",              Mips::AFL_EXT_5400},
2194   {"NEC VR5500",              Mips::AFL_EXT_5500},
2195   {"RMI Xlr",                 Mips::AFL_EXT_XLR},
2196   {"Toshiba R3900",           Mips::AFL_EXT_3900}
2197 };
2198
2199 static const EnumEntry<unsigned> ElfMipsASEFlags[] = {
2200   {"DSP",                Mips::AFL_ASE_DSP},
2201   {"DSPR2",              Mips::AFL_ASE_DSPR2},
2202   {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
2203   {"MCU",                Mips::AFL_ASE_MCU},
2204   {"MDMX",               Mips::AFL_ASE_MDMX},
2205   {"MIPS-3D",            Mips::AFL_ASE_MIPS3D},
2206   {"MT",                 Mips::AFL_ASE_MT},
2207   {"SmartMIPS",          Mips::AFL_ASE_SMARTMIPS},
2208   {"VZ",                 Mips::AFL_ASE_VIRT},
2209   {"MSA",                Mips::AFL_ASE_MSA},
2210   {"MIPS16",             Mips::AFL_ASE_MIPS16},
2211   {"microMIPS",          Mips::AFL_ASE_MICROMIPS},
2212   {"XPA",                Mips::AFL_ASE_XPA}
2213 };
2214
2215 static const EnumEntry<unsigned> ElfMipsFpABIType[] = {
2216   {"Hard or soft float",                  Mips::Val_GNU_MIPS_ABI_FP_ANY},
2217   {"Hard float (double precision)",       Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
2218   {"Hard float (single precision)",       Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
2219   {"Soft float",                          Mips::Val_GNU_MIPS_ABI_FP_SOFT},
2220   {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
2221    Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
2222   {"Hard float (32-bit CPU, Any FPU)",    Mips::Val_GNU_MIPS_ABI_FP_XX},
2223   {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
2224   {"Hard float compat (32-bit CPU, 64-bit FPU)",
2225    Mips::Val_GNU_MIPS_ABI_FP_64A}
2226 };
2227
2228 static const EnumEntry<unsigned> ElfMipsFlags1[] {
2229   {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
2230 };
2231
2232 static int getMipsRegisterSize(uint8_t Flag) {
2233   switch (Flag) {
2234   case Mips::AFL_REG_NONE:
2235     return 0;
2236   case Mips::AFL_REG_32:
2237     return 32;
2238   case Mips::AFL_REG_64:
2239     return 64;
2240   case Mips::AFL_REG_128:
2241     return 128;
2242   default:
2243     return -1;
2244   }
2245 }
2246
2247 template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() {
2248   const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags");
2249   if (!Shdr) {
2250     W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
2251     return;
2252   }
2253   ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2254   if (Sec.size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
2255     W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
2256     return;
2257   }
2258
2259   auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec.data());
2260
2261   raw_ostream &OS = W.getOStream();
2262   DictScope GS(W, "MIPS ABI Flags");
2263
2264   W.printNumber("Version", Flags->version);
2265   W.startLine() << "ISA: ";
2266   if (Flags->isa_rev <= 1)
2267     OS << format("MIPS%u", Flags->isa_level);
2268   else
2269     OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
2270   OS << "\n";
2271   W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType));
2272   W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
2273   W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
2274   W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
2275   W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
2276   W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
2277   W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
2278   W.printHex("Flags 2", Flags->flags2);
2279 }
2280
2281 template <class ELFT>
2282 static void printMipsReginfoData(ScopedPrinter &W,
2283                                  const Elf_Mips_RegInfo<ELFT> &Reginfo) {
2284   W.printHex("GP", Reginfo.ri_gp_value);
2285   W.printHex("General Mask", Reginfo.ri_gprmask);
2286   W.printHex("Co-Proc Mask0", Reginfo.ri_cprmask[0]);
2287   W.printHex("Co-Proc Mask1", Reginfo.ri_cprmask[1]);
2288   W.printHex("Co-Proc Mask2", Reginfo.ri_cprmask[2]);
2289   W.printHex("Co-Proc Mask3", Reginfo.ri_cprmask[3]);
2290 }
2291
2292 template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
2293   const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo");
2294   if (!Shdr) {
2295     W.startLine() << "There is no .reginfo section in the file.\n";
2296     return;
2297   }
2298   ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2299   if (Sec.size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
2300     W.startLine() << "The .reginfo section has a wrong size.\n";
2301     return;
2302   }
2303
2304   DictScope GS(W, "MIPS RegInfo");
2305   auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec.data());
2306   printMipsReginfoData(W, *Reginfo);
2307 }
2308
2309 template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
2310   const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.options");
2311   if (!Shdr) {
2312     W.startLine() << "There is no .MIPS.options section in the file.\n";
2313     return;
2314   }
2315
2316   DictScope GS(W, "MIPS Options");
2317
2318   ArrayRef<uint8_t> Sec = unwrapOrError(Obj->getSectionContents(Shdr));
2319   while (!Sec.empty()) {
2320     if (Sec.size() < sizeof(Elf_Mips_Options<ELFT>)) {
2321       W.startLine() << "The .MIPS.options section has a wrong size.\n";
2322       return;
2323     }
2324     auto *O = reinterpret_cast<const Elf_Mips_Options<ELFT> *>(Sec.data());
2325     DictScope GS(W, getElfMipsOptionsOdkType(O->kind));
2326     switch (O->kind) {
2327     case ODK_REGINFO:
2328       printMipsReginfoData(W, O->getRegInfo());
2329       break;
2330     default:
2331       W.startLine() << "Unsupported MIPS options tag.\n";
2332       break;
2333     }
2334     Sec = Sec.slice(O->size);
2335   }
2336 }
2337
2338 template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
2339   const Elf_Shdr *StackMapSection = nullptr;
2340   for (const auto &Sec : Obj->sections()) {
2341     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2342     if (Name == ".llvm_stackmaps") {
2343       StackMapSection = &Sec;
2344       break;
2345     }
2346   }
2347
2348   if (!StackMapSection)
2349     return;
2350
2351   StringRef StackMapContents;
2352   ArrayRef<uint8_t> StackMapContentsArray =
2353       unwrapOrError(Obj->getSectionContents(StackMapSection));
2354
2355   prettyPrintStackMap(llvm::outs(), StackMapV1Parser<ELFT::TargetEndianness>(
2356                                         StackMapContentsArray));
2357 }
2358
2359 template <class ELFT> void ELFDumper<ELFT>::printGroupSections() {
2360   ELFDumperStyle->printGroupSections(Obj);
2361 }
2362
2363 static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
2364                                StringRef Str2) {
2365   OS.PadToColumn(2u);
2366   OS << Str1;
2367   OS.PadToColumn(37u);
2368   OS << Str2 << "\n";
2369   OS.flush();
2370 }
2371
2372 template <class ELFT> void GNUStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
2373   const Elf_Ehdr *e = Obj->getHeader();
2374   OS << "ELF Header:\n";
2375   OS << "  Magic:  ";
2376   std::string Str;
2377   for (int i = 0; i < ELF::EI_NIDENT; i++)
2378     OS << format(" %02x", static_cast<int>(e->e_ident[i]));
2379   OS << "\n";
2380   Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
2381   printFields(OS, "Class:", Str);
2382   Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
2383   printFields(OS, "Data:", Str);
2384   OS.PadToColumn(2u);
2385   OS << "Version:";
2386   OS.PadToColumn(37u);
2387   OS << to_hexString(e->e_ident[ELF::EI_VERSION]);
2388   if (e->e_version == ELF::EV_CURRENT)
2389     OS << " (current)";
2390   OS << "\n";
2391   Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
2392   printFields(OS, "OS/ABI:", Str);
2393   Str = "0x" + to_hexString(e->e_version);
2394   Str = to_hexString(e->e_ident[ELF::EI_ABIVERSION]);
2395   printFields(OS, "ABI Version:", Str);
2396   Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType));
2397   printFields(OS, "Type:", Str);
2398   Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType));
2399   printFields(OS, "Machine:", Str);
2400   Str = "0x" + to_hexString(e->e_version);
2401   printFields(OS, "Version:", Str);
2402   Str = "0x" + to_hexString(e->e_entry);
2403   printFields(OS, "Entry point address:", Str);
2404   Str = to_string(e->e_phoff) + " (bytes into file)";
2405   printFields(OS, "Start of program headers:", Str);
2406   Str = to_string(e->e_shoff) + " (bytes into file)";
2407   printFields(OS, "Start of section headers:", Str);
2408   Str = "0x" + to_hexString(e->e_flags);
2409   printFields(OS, "Flags:", Str);
2410   Str = to_string(e->e_ehsize) + " (bytes)";
2411   printFields(OS, "Size of this header:", Str);
2412   Str = to_string(e->e_phentsize) + " (bytes)";
2413   printFields(OS, "Size of program headers:", Str);
2414   Str = to_string(e->e_phnum);
2415   printFields(OS, "Number of program headers:", Str);
2416   Str = to_string(e->e_shentsize) + " (bytes)";
2417   printFields(OS, "Size of section headers:", Str);
2418   Str = to_string(e->e_shnum);
2419   printFields(OS, "Number of section headers:", Str);
2420   Str = to_string(e->e_shstrndx);
2421   printFields(OS, "Section header string table index:", Str);
2422 }
2423
2424 template <class ELFT> void GNUStyle<ELFT>::printGroupSections(const ELFO *Obj) {
2425   uint32_t SectionIndex = 0;
2426   bool HasGroups = false;
2427   for (const Elf_Shdr &Sec : Obj->sections()) {
2428     if (Sec.sh_type == ELF::SHT_GROUP) {
2429       HasGroups = true;
2430       const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
2431       StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
2432       const Elf_Sym *Signature =
2433           Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info);
2434       ArrayRef<Elf_Word> Data = unwrapOrError(
2435           Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
2436       StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2437       OS << "\n" << getGroupType(Data[0]) << " group section ["
2438          << format_decimal(SectionIndex, 5) << "] `" << Name << "' ["
2439          << StrTable.data() + Signature->st_name << "] contains "
2440          << (Data.size() - 1) << " sections:\n"
2441          << "   [Index]    Name\n";
2442       for (auto &Ndx : Data.slice(1)) {
2443         auto Sec = unwrapOrError(Obj->getSection(Ndx));
2444         const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
2445         OS << "   [" << format_decimal(Ndx, 5) << "]   " << Name
2446            << "\n";
2447       }
2448     }
2449     ++SectionIndex;
2450   }
2451   if (!HasGroups)
2452     OS << "There are no section groups in this file.\n";
2453 }
2454
2455 template <class ELFT>
2456 void GNUStyle<ELFT>::printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
2457                                      const Elf_Rela &R, bool IsRela) {
2458   std::string Offset, Info, Addend = "", Value;
2459   SmallString<32> RelocName;
2460   StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
2461   StringRef TargetName;
2462   const Elf_Sym *Sym = nullptr;
2463   unsigned Width = ELFT::Is64Bits ? 16 : 8;
2464   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
2465
2466   // First two fields are bit width dependent. The rest of them are after are
2467   // fixed width.
2468   Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
2469   Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
2470   Sym = Obj->getRelocationSymbol(&R, SymTab);
2471   if (Sym && Sym->getType() == ELF::STT_SECTION) {
2472     const Elf_Shdr *Sec = unwrapOrError(
2473         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
2474     TargetName = unwrapOrError(Obj->getSectionName(Sec));
2475   } else if (Sym) {
2476     TargetName = unwrapOrError(Sym->getName(StrTable));
2477   }
2478
2479   if (Sym && IsRela) {
2480     if (R.r_addend < 0)
2481       Addend = " - ";
2482     else
2483       Addend = " + ";
2484   }
2485
2486   Offset = to_string(format_hex_no_prefix(R.r_offset, Width));
2487   Info = to_string(format_hex_no_prefix(R.r_info, Width));
2488
2489   int64_t RelAddend = R.r_addend;
2490   if (IsRela)
2491     Addend += to_hexString(std::abs(RelAddend), false);
2492
2493   if (Sym)
2494     Value = to_string(format_hex_no_prefix(Sym->getValue(), Width));
2495
2496   Fields[0].Str = Offset;
2497   Fields[1].Str = Info;
2498   Fields[2].Str = RelocName;
2499   Fields[3].Str = Value;
2500   Fields[4].Str = TargetName;
2501   for (auto &field : Fields)
2502     printField(field);
2503   OS << Addend;
2504   OS << "\n";
2505 }
2506
2507 static inline void printRelocHeader(raw_ostream &OS, bool Is64, bool IsRela) {
2508   if (Is64)
2509     OS << "    Offset             Info             Type"
2510        << "               Symbol's Value  Symbol's Name";
2511   else
2512     OS << " Offset     Info    Type                Sym. Value  "
2513        << "Symbol's Name";
2514   if (IsRela)
2515     OS << (IsRela ? " + Addend" : "");
2516   OS << "\n";
2517 }
2518
2519 template <class ELFT> void GNUStyle<ELFT>::printRelocations(const ELFO *Obj) {
2520   bool HasRelocSections = false;
2521   for (const Elf_Shdr &Sec : Obj->sections()) {
2522     if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA)
2523       continue;
2524     HasRelocSections = true;
2525     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
2526     unsigned Entries = Sec.getEntityCount();
2527     uintX_t Offset = Sec.sh_offset;
2528     OS << "\nRelocation section '" << Name << "' at offset 0x"
2529        << to_hexString(Offset, false) << " contains " << Entries
2530        << " entries:\n";
2531     printRelocHeader(OS,  ELFT::Is64Bits, (Sec.sh_type == ELF::SHT_RELA));
2532     const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec.sh_link));
2533     if (Sec.sh_type == ELF::SHT_REL) {
2534       for (const auto &R : Obj->rels(&Sec)) {
2535         Elf_Rela Rela;
2536         Rela.r_offset = R.r_offset;
2537         Rela.r_info = R.r_info;
2538         Rela.r_addend = 0;
2539         printRelocation(Obj, SymTab, Rela, false);
2540       }
2541     } else {
2542       for (const auto &R : Obj->relas(&Sec))
2543         printRelocation(Obj, SymTab, R, true);
2544     }
2545   }
2546   if (!HasRelocSections)
2547     OS << "\nThere are no relocations in this file.\n";
2548 }
2549
2550 std::string getSectionTypeString(unsigned Arch, unsigned Type) {
2551   using namespace ELF;
2552   switch (Arch) {
2553   case EM_ARM:
2554     switch (Type) {
2555     case SHT_ARM_EXIDX:
2556       return "ARM_EXIDX";
2557     case SHT_ARM_PREEMPTMAP:
2558       return "ARM_PREEMPTMAP";
2559     case SHT_ARM_ATTRIBUTES:
2560       return "ARM_ATTRIBUTES";
2561     case SHT_ARM_DEBUGOVERLAY:
2562       return "ARM_DEBUGOVERLAY";
2563     case SHT_ARM_OVERLAYSECTION:
2564       return "ARM_OVERLAYSECTION";
2565     }
2566   case EM_X86_64:
2567     switch (Type) {
2568     case SHT_X86_64_UNWIND:
2569       return "X86_64_UNWIND";
2570     }
2571   case EM_MIPS:
2572   case EM_MIPS_RS3_LE:
2573     switch (Type) {
2574     case SHT_MIPS_REGINFO:
2575       return "MIPS_REGINFO";
2576     case SHT_MIPS_OPTIONS:
2577       return "MIPS_OPTIONS";
2578     case SHT_MIPS_ABIFLAGS:
2579       return "MIPS_ABIFLAGS";
2580     }
2581   }
2582   switch (Type) {
2583   case SHT_NULL:
2584     return "NULL";
2585   case SHT_PROGBITS:
2586     return "PROGBITS";
2587   case SHT_SYMTAB:
2588     return "SYMTAB";
2589   case SHT_STRTAB:
2590     return "STRTAB";
2591   case SHT_RELA:
2592     return "RELA";
2593   case SHT_HASH:
2594     return "HASH";
2595   case SHT_DYNAMIC:
2596     return "DYNAMIC";
2597   case SHT_NOTE:
2598     return "NOTE";
2599   case SHT_NOBITS:
2600     return "NOBITS";
2601   case SHT_REL:
2602     return "REL";
2603   case SHT_SHLIB:
2604     return "SHLIB";
2605   case SHT_DYNSYM:
2606     return "DYNSYM";
2607   case SHT_INIT_ARRAY:
2608     return "INIT_ARRAY";
2609   case SHT_FINI_ARRAY:
2610     return "FINI_ARRAY";
2611   case SHT_PREINIT_ARRAY:
2612     return "PREINIT_ARRAY";
2613   case SHT_GROUP:
2614     return "GROUP";
2615   case SHT_SYMTAB_SHNDX:
2616     return "SYMTAB SECTION INDICES";
2617   // FIXME: Parse processor specific GNU attributes
2618   case SHT_GNU_ATTRIBUTES:
2619     return "ATTRIBUTES";
2620   case SHT_GNU_HASH:
2621     return "GNU_HASH";
2622   case SHT_GNU_verdef:
2623     return "VERDEF";
2624   case SHT_GNU_verneed:
2625     return "VERNEED";
2626   case SHT_GNU_versym:
2627     return "VERSYM";
2628   default:
2629     return "";
2630   }
2631   return "";
2632 }
2633
2634 template <class ELFT> void GNUStyle<ELFT>::printSections(const ELFO *Obj) {
2635   size_t SectionIndex = 0;
2636   std::string Number, Type, Size, Address, Offset, Flags, Link, Info, EntrySize,
2637       Alignment;
2638   unsigned Bias;
2639   unsigned Width;
2640
2641   if (ELFT::Is64Bits) {
2642     Bias = 0;
2643     Width = 16;
2644   } else {
2645     Bias = 8;
2646     Width = 8;
2647   }
2648   OS << "There are " << to_string(Obj->getHeader()->e_shnum)
2649      << " section headers, starting at offset "
2650      << "0x" << to_hexString(Obj->getHeader()->e_shoff, false) << ":\n\n";
2651   OS << "Section Headers:\n";
2652   Field Fields[11] = {{"[Nr]", 2},
2653                       {"Name", 7},
2654                       {"Type", 25},
2655                       {"Address", 41},
2656                       {"Off", 58 - Bias},
2657                       {"Size", 65 - Bias},
2658                       {"ES", 72 - Bias},
2659                       {"Flg", 75 - Bias},
2660                       {"Lk", 79 - Bias},
2661                       {"Inf", 82 - Bias},
2662                       {"Al", 86 - Bias}};
2663   for (auto &f : Fields)
2664     printField(f);
2665   OS << "\n";
2666
2667   for (const Elf_Shdr &Sec : Obj->sections()) {
2668     Number = to_string(SectionIndex);
2669     Fields[0].Str = Number;
2670     Fields[1].Str = unwrapOrError(Obj->getSectionName(&Sec));
2671     Type = getSectionTypeString(Obj->getHeader()->e_machine, Sec.sh_type);
2672     Fields[2].Str = Type;
2673     Address = to_string(format_hex_no_prefix(Sec.sh_addr, Width));
2674     Fields[3].Str = Address;
2675     Offset = to_string(format_hex_no_prefix(Sec.sh_offset, 6));
2676     Fields[4].Str = Offset;
2677     Size = to_string(format_hex_no_prefix(Sec.sh_size, 6));
2678     Fields[5].Str = Size;
2679     EntrySize = to_string(format_hex_no_prefix(Sec.sh_entsize, 2));
2680     Fields[6].Str = EntrySize;
2681     Flags = getGNUFlags(Sec.sh_flags);
2682     Fields[7].Str = Flags;
2683     Link = to_string(Sec.sh_link);
2684     Fields[8].Str = Link;
2685     Info = to_string(Sec.sh_info);
2686     Fields[9].Str = Info;
2687     Alignment = to_string(Sec.sh_addralign);
2688     Fields[10].Str = Alignment;
2689     OS.PadToColumn(Fields[0].Column);
2690     OS << "[" << right_justify(Fields[0].Str, 2) << "]";
2691     for (int i = 1; i < 7; i++)
2692       printField(Fields[i]);
2693     OS.PadToColumn(Fields[7].Column);
2694     OS << right_justify(Fields[7].Str, 3);
2695     OS.PadToColumn(Fields[8].Column);
2696     OS << right_justify(Fields[8].Str, 2);
2697     OS.PadToColumn(Fields[9].Column);
2698     OS << right_justify(Fields[9].Str, 3);
2699     OS.PadToColumn(Fields[10].Column);
2700     OS << right_justify(Fields[10].Str, 2);
2701     OS << "\n";
2702     ++SectionIndex;
2703   }
2704   OS << "Key to Flags:\n"
2705      << "  W (write), A (alloc), X (execute), M (merge), S (strings), l "
2706         "(large)\n"
2707      << "  I (info), L (link order), G (group), T (TLS), E (exclude),\
2708  x (unknown)\n"
2709      << "  O (extra OS processing required) o (OS specific),\
2710  p (processor specific)\n";
2711 }
2712
2713 template <class ELFT>
2714 void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, StringRef Name,
2715                                         size_t Entries) {
2716   if (Name.size())
2717     OS << "\nSymbol table '" << Name << "' contains " << Entries
2718        << " entries:\n";
2719   else
2720     OS << "\n Symbol table for image:\n";
2721
2722   if (ELFT::Is64Bits)
2723     OS << "   Num:    Value          Size Type    Bind   Vis      Ndx Name\n";
2724   else
2725     OS << "   Num:    Value  Size Type    Bind   Vis      Ndx Name\n";
2726 }
2727
2728 template <class ELFT>
2729 std::string GNUStyle<ELFT>::getSymbolSectionNdx(const ELFO *Obj,
2730                                                 const Elf_Sym *Symbol,
2731                                                 const Elf_Sym *FirstSym) {
2732   unsigned SectionIndex = Symbol->st_shndx;
2733   switch (SectionIndex) {
2734   case ELF::SHN_UNDEF:
2735     return "UND";
2736   case ELF::SHN_ABS:
2737     return "ABS";
2738   case ELF::SHN_COMMON:
2739     return "COM";
2740   case ELF::SHN_XINDEX:
2741     SectionIndex = Obj->getExtendedSymbolTableIndex(
2742         Symbol, FirstSym, this->dumper()->getShndxTable());
2743   default:
2744     // Find if:
2745     // Processor specific
2746     if (SectionIndex >= ELF::SHN_LOPROC && SectionIndex <= ELF::SHN_HIPROC)
2747       return std::string("PRC[0x") +
2748              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
2749     // OS specific
2750     if (SectionIndex >= ELF::SHN_LOOS && SectionIndex <= ELF::SHN_HIOS)
2751       return std::string("OS[0x") +
2752              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
2753     // Architecture reserved:
2754     if (SectionIndex >= ELF::SHN_LORESERVE &&
2755         SectionIndex <= ELF::SHN_HIRESERVE)
2756       return std::string("RSV[0x") +
2757              to_string(format_hex_no_prefix(SectionIndex, 4)) + "]";
2758     // A normal section with an index
2759     return to_string(format_decimal(SectionIndex, 3));
2760   }
2761 }
2762
2763 template <class ELFT>
2764 void GNUStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
2765                                  const Elf_Sym *FirstSym, StringRef StrTable,
2766                                  bool IsDynamic) {
2767   static int Idx = 0;
2768   static bool Dynamic = true;
2769   size_t Width;
2770
2771   // If this function was called with a different value from IsDynamic
2772   // from last call, happens when we move from dynamic to static symbol
2773   // table, "Num" field should be reset.
2774   if (!Dynamic != !IsDynamic) {
2775     Idx = 0;
2776     Dynamic = false;
2777   }
2778   std::string Num, Name, Value, Size, Binding, Type, Visibility, Section;
2779   unsigned Bias = 0;
2780   if (ELFT::Is64Bits) {
2781     Bias = 8;
2782     Width = 16;
2783   } else {
2784     Bias = 0;
2785     Width = 8;
2786   }
2787   Field Fields[8] = {0,         8,         17 + Bias, 23 + Bias,
2788                      31 + Bias, 38 + Bias, 47 + Bias, 51 + Bias};
2789   Num = to_string(format_decimal(Idx++, 6)) + ":";
2790   Value = to_string(format_hex_no_prefix(Symbol->st_value, Width));
2791   Size = to_string(format_decimal(Symbol->st_size, 5));
2792   unsigned char SymbolType = Symbol->getType();
2793   if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
2794       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
2795     Type = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
2796   else
2797     Type = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
2798   unsigned Vis = Symbol->getVisibility();
2799   Binding = printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
2800   Visibility = printEnum(Vis, makeArrayRef(ElfSymbolVisibilities));
2801   Section = getSymbolSectionNdx(Obj, Symbol, FirstSym);
2802   Name = this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
2803   Fields[0].Str = Num;
2804   Fields[1].Str = Value;
2805   Fields[2].Str = Size;
2806   Fields[3].Str = Type;
2807   Fields[4].Str = Binding;
2808   Fields[5].Str = Visibility;
2809   Fields[6].Str = Section;
2810   Fields[7].Str = Name;
2811   for (auto &Entry : Fields)
2812     printField(Entry);
2813   OS << "\n";
2814 }
2815
2816 template <class ELFT> void GNUStyle<ELFT>::printSymbols(const ELFO *Obj) {
2817   this->dumper()->printSymbolsHelper(true);
2818   this->dumper()->printSymbolsHelper(false);
2819 }
2820
2821 template <class ELFT>
2822 void GNUStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
2823   this->dumper()->printSymbolsHelper(true);
2824 }
2825
2826 static inline std::string printPhdrFlags(unsigned Flag) {
2827   std::string Str;
2828   Str = (Flag & PF_R) ? "R" : " ";
2829   Str += (Flag & PF_W) ? "W" : " ";
2830   Str += (Flag & PF_X) ? "E" : " ";
2831   return Str;
2832 }
2833
2834 // SHF_TLS sections are only in PT_TLS, PT_LOAD or PT_GNU_RELRO
2835 // PT_TLS must only have SHF_TLS sections
2836 template <class ELFT>
2837 bool GNUStyle<ELFT>::checkTLSSections(const Elf_Phdr &Phdr,
2838                                       const Elf_Shdr &Sec) {
2839   return (((Sec.sh_flags & ELF::SHF_TLS) &&
2840            ((Phdr.p_type == ELF::PT_TLS) || (Phdr.p_type == ELF::PT_LOAD) ||
2841             (Phdr.p_type == ELF::PT_GNU_RELRO))) ||
2842           (!(Sec.sh_flags & ELF::SHF_TLS) && Phdr.p_type != ELF::PT_TLS));
2843 }
2844
2845 // Non-SHT_NOBITS must have its offset inside the segment
2846 // Only non-zero section can be at end of segment
2847 template <class ELFT>
2848 bool GNUStyle<ELFT>::checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
2849   if (Sec.sh_type == ELF::SHT_NOBITS)
2850     return true;
2851   bool IsSpecial =
2852       (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0);
2853   // .tbss is special, it only has memory in PT_TLS and has NOBITS properties
2854   auto SectionSize =
2855       (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size;
2856   if (Sec.sh_offset >= Phdr.p_offset)
2857     return ((Sec.sh_offset + SectionSize <= Phdr.p_filesz + Phdr.p_offset)
2858             /*only non-zero sized sections at end*/ &&
2859             (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz));
2860   return false;
2861 }
2862
2863 // SHF_ALLOC must have VMA inside segment
2864 // Only non-zero section can be at end of segment
2865 template <class ELFT>
2866 bool GNUStyle<ELFT>::checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
2867   if (!(Sec.sh_flags & ELF::SHF_ALLOC))
2868     return true;
2869   bool IsSpecial =
2870       (Sec.sh_type == ELF::SHT_NOBITS) && ((Sec.sh_flags & ELF::SHF_TLS) != 0);
2871   // .tbss is special, it only has memory in PT_TLS and has NOBITS properties
2872   auto SectionSize =
2873       (IsSpecial && Phdr.p_type != ELF::PT_TLS) ? 0 : Sec.sh_size;
2874   if (Sec.sh_addr >= Phdr.p_vaddr)
2875     return ((Sec.sh_addr + SectionSize <= Phdr.p_vaddr + Phdr.p_memsz) &&
2876             (Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz));
2877   return false;
2878 }
2879
2880 // No section with zero size must be at start or end of PT_DYNAMIC
2881 template <class ELFT>
2882 bool GNUStyle<ELFT>::checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec) {
2883   if (Phdr.p_type != ELF::PT_DYNAMIC || Sec.sh_size != 0 || Phdr.p_memsz == 0)
2884     return true;
2885   // Is section within the phdr both based on offset and VMA ?
2886   return ((Sec.sh_type == ELF::SHT_NOBITS) ||
2887           (Sec.sh_offset > Phdr.p_offset &&
2888            Sec.sh_offset < Phdr.p_offset + Phdr.p_filesz)) &&
2889          (!(Sec.sh_flags & ELF::SHF_ALLOC) ||
2890           (Sec.sh_addr > Phdr.p_vaddr && Sec.sh_addr < Phdr.p_memsz));
2891 }
2892
2893 template <class ELFT>
2894 void GNUStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
2895   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
2896   unsigned Width = ELFT::Is64Bits ? 18 : 10;
2897   unsigned SizeWidth = ELFT::Is64Bits ? 8 : 7;
2898   std::string Type, Offset, VMA, LMA, FileSz, MemSz, Flag, Align;
2899
2900   const Elf_Ehdr *Header = Obj->getHeader();
2901   Field Fields[8] = {2,         17,        26,        37 + Bias,
2902                      48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias};
2903   OS << "\nElf file type is "
2904      << printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n"
2905      << "Entry point " << format_hex(Header->e_entry, 3) << "\n"
2906      << "There are " << Header->e_phnum << " program headers,"
2907      << " starting at offset " << Header->e_phoff << "\n\n"
2908      << "Program Headers:\n";
2909   if (ELFT::Is64Bits)
2910     OS << "  Type           Offset   VirtAddr           PhysAddr         "
2911        << "  FileSiz  MemSiz   Flg Align\n";
2912   else
2913     OS << "  Type           Offset   VirtAddr   PhysAddr   FileSiz "
2914        << "MemSiz  Flg Align\n";
2915   for (const auto &Phdr : Obj->program_headers()) {
2916     Type = getElfPtType(Header->e_machine, Phdr.p_type);
2917     Offset = to_string(format_hex(Phdr.p_offset, 8));
2918     VMA = to_string(format_hex(Phdr.p_vaddr, Width));
2919     LMA = to_string(format_hex(Phdr.p_paddr, Width));
2920     FileSz = to_string(format_hex(Phdr.p_filesz, SizeWidth));
2921     MemSz = to_string(format_hex(Phdr.p_memsz, SizeWidth));
2922     Flag = printPhdrFlags(Phdr.p_flags);
2923     Align = to_string(format_hex(Phdr.p_align, 1));
2924     Fields[0].Str = Type;
2925     Fields[1].Str = Offset;
2926     Fields[2].Str = VMA;
2927     Fields[3].Str = LMA;
2928     Fields[4].Str = FileSz;
2929     Fields[5].Str = MemSz;
2930     Fields[6].Str = Flag;
2931     Fields[7].Str = Align;
2932     for (auto Field : Fields)
2933       printField(Field);
2934     if (Phdr.p_type == ELF::PT_INTERP) {
2935       OS << "\n      [Requesting program interpreter: ";
2936       OS << reinterpret_cast<const char *>(Obj->base()) + Phdr.p_offset << "]";
2937     }
2938     OS << "\n";
2939   }
2940   OS << "\n Section to Segment mapping:\n  Segment Sections...\n";
2941   int Phnum = 0;
2942   for (const Elf_Phdr &Phdr : Obj->program_headers()) {
2943     std::string Sections;
2944     OS << format("   %2.2d     ", Phnum++);
2945     for (const Elf_Shdr &Sec : Obj->sections()) {
2946       // Check if each section is in a segment and then print mapping.
2947       // readelf additionally makes sure it does not print zero sized sections
2948       // at end of segments and for PT_DYNAMIC both start and end of section
2949       // .tbss must only be shown in PT_TLS section.
2950       bool TbssInNonTLS = (Sec.sh_type == ELF::SHT_NOBITS) &&
2951                           ((Sec.sh_flags & ELF::SHF_TLS) != 0) &&
2952                           Phdr.p_type != ELF::PT_TLS;
2953       if (!TbssInNonTLS && checkTLSSections(Phdr, Sec) &&
2954           checkoffsets(Phdr, Sec) && checkVMA(Phdr, Sec) &&
2955           checkPTDynamic(Phdr, Sec) && (Sec.sh_type != ELF::SHT_NULL))
2956         Sections += unwrapOrError(Obj->getSectionName(&Sec)).str() + " ";
2957     }
2958     OS << Sections << "\n";
2959     OS.flush();
2960   }
2961 }
2962
2963 template <class ELFT>
2964 void GNUStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela R,
2965                                             bool IsRela) {
2966   SmallString<32> RelocName;
2967   StringRef SymbolName;
2968   unsigned Width = ELFT::Is64Bits ? 16 : 8;
2969   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
2970   // First two fields are bit width dependent. The rest of them are after are
2971   // fixed width.
2972   Field Fields[5] = {0, 10 + Bias, 19 + 2 * Bias, 42 + 2 * Bias, 53 + 2 * Bias};
2973
2974   uint32_t SymIndex = R.getSymbol(Obj->isMips64EL());
2975   const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex;
2976   Obj->getRelocationTypeName(R.getType(Obj->isMips64EL()), RelocName);
2977   SymbolName =
2978       unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable()));
2979   std::string Addend = "", Info, Offset, Value;
2980   Offset = to_string(format_hex_no_prefix(R.r_offset, Width));
2981   Info = to_string(format_hex_no_prefix(R.r_info, Width));
2982   Value = to_string(format_hex_no_prefix(Sym->getValue(), Width));
2983   int64_t RelAddend = R.r_addend;
2984   if (SymbolName.size() && IsRela) {
2985     if (R.r_addend < 0)
2986       Addend = " - ";
2987     else
2988       Addend = " + ";
2989   }
2990
2991   if (!SymbolName.size() && Sym->getValue() == 0)
2992     Value = "";
2993
2994   if (IsRela)
2995     Addend += to_string(format_hex_no_prefix(std::abs(RelAddend), 1));
2996
2997
2998   Fields[0].Str = Offset;
2999   Fields[1].Str = Info;
3000   Fields[2].Str = RelocName.c_str();
3001   Fields[3].Str = Value;
3002   Fields[4].Str = SymbolName;
3003   for (auto &Field : Fields)
3004     printField(Field);
3005   OS << Addend;
3006   OS << "\n";
3007 }
3008
3009 template <class ELFT>
3010 void GNUStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
3011   const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
3012   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
3013   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
3014   if (DynRelaRegion.Size > 0) {
3015     OS << "\n'RELA' relocation section at offset "
3016        << format_hex(reinterpret_cast<const uint8_t *>(DynRelaRegion.Addr) -
3017                          Obj->base(),
3018                      1) << " contains " << DynRelaRegion.Size << " bytes:\n";
3019     printRelocHeader(OS, ELFT::Is64Bits, true);
3020     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
3021       printDynamicRelocation(Obj, Rela, true);
3022   }
3023   if (DynRelRegion.Size > 0) {
3024     OS << "\n'REL' relocation section at offset "
3025        << format_hex(reinterpret_cast<const uint8_t *>(DynRelRegion.Addr) -
3026                          Obj->base(),
3027                      1) << " contains " << DynRelRegion.Size << " bytes:\n";
3028     printRelocHeader(OS, ELFT::Is64Bits, false);
3029     for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
3030       Elf_Rela Rela;
3031       Rela.r_offset = Rel.r_offset;
3032       Rela.r_info = Rel.r_info;
3033       Rela.r_addend = 0;
3034       printDynamicRelocation(Obj, Rela, false);
3035     }
3036   }
3037   if (DynPLTRelRegion.Size) {
3038     OS << "\n'PLT' relocation section at offset "
3039        << format_hex(reinterpret_cast<const uint8_t *>(DynPLTRelRegion.Addr) -
3040                          Obj->base(),
3041                      1) << " contains " << DynPLTRelRegion.Size << " bytes:\n";
3042   }
3043   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela)) {
3044     printRelocHeader(OS, ELFT::Is64Bits, true);
3045     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
3046       printDynamicRelocation(Obj, Rela, true);
3047   } else {
3048     printRelocHeader(OS, ELFT::Is64Bits, false);
3049     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
3050       Elf_Rela Rela;
3051       Rela.r_offset = Rel.r_offset;
3052       Rela.r_info = Rel.r_info;
3053       Rela.r_addend = 0;
3054       printDynamicRelocation(Obj, Rela, false);
3055     }
3056   }
3057 }
3058
3059 // Hash histogram shows  statistics of how efficient the hash was for the
3060 // dynamic symbol table. The table shows number of hash buckets for different
3061 // lengths of chains as absolute number and percentage of the total buckets.
3062 // Additionally cumulative coverage of symbols for each set of buckets.
3063 template <class ELFT>
3064 void GNUStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) {
3065
3066   const Elf_Hash *HashTable = this->dumper()->getHashTable();
3067   const Elf_GnuHash *GnuHashTable = this->dumper()->getGnuHashTable();
3068
3069   // Print histogram for .hash section
3070   if (HashTable) {
3071     size_t NBucket = HashTable->nbucket;
3072     size_t NChain = HashTable->nchain;
3073     ArrayRef<Elf_Word> Buckets = HashTable->buckets();
3074     ArrayRef<Elf_Word> Chains = HashTable->chains();
3075     size_t TotalSyms = 0;
3076     // If hash table is correct, we have at least chains with 0 length
3077     size_t MaxChain = 1;
3078     size_t CumulativeNonZero = 0;
3079
3080     if (NChain == 0 || NBucket == 0)
3081       return;
3082
3083     std::vector<size_t> ChainLen(NBucket, 0);
3084     // Go over all buckets and and note chain lengths of each bucket (total
3085     // unique chain lengths).
3086     for (size_t B = 0; B < NBucket; B++) {
3087       for (size_t C = Buckets[B]; C > 0 && C < NChain; C = Chains[C])
3088         if (MaxChain <= ++ChainLen[B])
3089           MaxChain++;
3090       TotalSyms += ChainLen[B];
3091     }
3092
3093     if (!TotalSyms)
3094       return;
3095
3096     std::vector<size_t> Count(MaxChain, 0) ;
3097     // Count how long is the chain for each bucket
3098     for (size_t B = 0; B < NBucket; B++)
3099       ++Count[ChainLen[B]];
3100     // Print Number of buckets with each chain lengths and their cumulative
3101     // coverage of the symbols
3102     OS << "Histogram for bucket list length (total of " << NBucket
3103        << " buckets)\n"
3104        << " Length  Number     % of total  Coverage\n";
3105     for (size_t I = 0; I < MaxChain; I++) {
3106       CumulativeNonZero += Count[I] * I;
3107       OS << format("%7lu  %-10lu (%5.1f%%)     %5.1f%%\n", I, Count[I],
3108                    (Count[I] * 100.0) / NBucket,
3109                    (CumulativeNonZero * 100.0) / TotalSyms);
3110     }
3111   }
3112
3113   // Print histogram for .gnu.hash section
3114   if (GnuHashTable) {
3115     size_t NBucket = GnuHashTable->nbuckets;
3116     ArrayRef<Elf_Word> Buckets = GnuHashTable->buckets();
3117     unsigned NumSyms = this->dumper()->dynamic_symbols().size();
3118     if (!NumSyms)
3119       return;
3120     ArrayRef<Elf_Word> Chains = GnuHashTable->values(NumSyms);
3121     size_t Symndx = GnuHashTable->symndx;
3122     size_t TotalSyms = 0;
3123     size_t MaxChain = 1;
3124     size_t CumulativeNonZero = 0;
3125
3126     if (Chains.size() == 0 || NBucket == 0)
3127       return;
3128
3129     std::vector<size_t> ChainLen(NBucket, 0);
3130
3131     for (size_t B = 0; B < NBucket; B++) {
3132       if (!Buckets[B])
3133         continue;
3134       size_t Len = 1;
3135       for (size_t C = Buckets[B] - Symndx;
3136            C < Chains.size() && (Chains[C] & 1) == 0; C++)
3137         if (MaxChain < ++Len)
3138           MaxChain++;
3139       ChainLen[B] = Len;
3140       TotalSyms += Len;
3141     }
3142     MaxChain++;
3143
3144     if (!TotalSyms)
3145       return;
3146
3147     std::vector<size_t> Count(MaxChain, 0) ;
3148     for (size_t B = 0; B < NBucket; B++)
3149       ++Count[ChainLen[B]];
3150     // Print Number of buckets with each chain lengths and their cumulative
3151     // coverage of the symbols
3152     OS << "Histogram for `.gnu.hash' bucket list length (total of " << NBucket
3153        << " buckets)\n"
3154        << " Length  Number     % of total  Coverage\n";
3155     for (size_t I = 0; I <MaxChain; I++) {
3156       CumulativeNonZero += Count[I] * I;
3157       OS << format("%7lu  %-10lu (%5.1f%%)     %5.1f%%\n", I, Count[I],
3158                    (Count[I] * 100.0) / NBucket,
3159                    (CumulativeNonZero * 100.0) / TotalSyms);
3160     }
3161   }
3162 }
3163
3164 template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders(const ELFO *Obj) {
3165   const Elf_Ehdr *e = Obj->getHeader();
3166   {
3167     DictScope D(W, "ElfHeader");
3168     {
3169       DictScope D(W, "Ident");
3170       W.printBinary("Magic", makeArrayRef(e->e_ident).slice(ELF::EI_MAG0, 4));
3171       W.printEnum("Class", e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
3172       W.printEnum("DataEncoding", e->e_ident[ELF::EI_DATA],
3173                   makeArrayRef(ElfDataEncoding));
3174       W.printNumber("FileVersion", e->e_ident[ELF::EI_VERSION]);
3175
3176       // Handle architecture specific OS/ABI values.
3177       if (e->e_machine == ELF::EM_AMDGPU &&
3178           e->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
3179         W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
3180       else
3181         W.printEnum("OS/ABI", e->e_ident[ELF::EI_OSABI],
3182                     makeArrayRef(ElfOSABI));
3183       W.printNumber("ABIVersion", e->e_ident[ELF::EI_ABIVERSION]);
3184       W.printBinary("Unused", makeArrayRef(e->e_ident).slice(ELF::EI_PAD));
3185     }
3186
3187     W.printEnum("Type", e->e_type, makeArrayRef(ElfObjectFileType));
3188     W.printEnum("Machine", e->e_machine, makeArrayRef(ElfMachineType));
3189     W.printNumber("Version", e->e_version);
3190     W.printHex("Entry", e->e_entry);
3191     W.printHex("ProgramHeaderOffset", e->e_phoff);
3192     W.printHex("SectionHeaderOffset", e->e_shoff);
3193     if (e->e_machine == EM_MIPS)
3194       W.printFlags("Flags", e->e_flags, makeArrayRef(ElfHeaderMipsFlags),
3195                    unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
3196                    unsigned(ELF::EF_MIPS_MACH));
3197     else
3198       W.printFlags("Flags", e->e_flags);
3199     W.printNumber("HeaderSize", e->e_ehsize);
3200     W.printNumber("ProgramHeaderEntrySize", e->e_phentsize);
3201     W.printNumber("ProgramHeaderCount", e->e_phnum);
3202     W.printNumber("SectionHeaderEntrySize", e->e_shentsize);
3203     W.printNumber("SectionHeaderCount", e->e_shnum);
3204     W.printNumber("StringTableSectionIndex", e->e_shstrndx);
3205   }
3206 }
3207
3208 template <class ELFT>
3209 void LLVMStyle<ELFT>::printGroupSections(const ELFO *Obj) {
3210   DictScope Lists(W, "Groups");
3211   uint32_t SectionIndex = 0;
3212   bool HasGroups = false;
3213   for (const Elf_Shdr &Sec : Obj->sections()) {
3214     if (Sec.sh_type == ELF::SHT_GROUP) {
3215       HasGroups = true;
3216       const Elf_Shdr *Symtab = unwrapOrError(Obj->getSection(Sec.sh_link));
3217       StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
3218       const Elf_Sym *Sym = Obj->template getEntry<Elf_Sym>(Symtab, Sec.sh_info);
3219       auto Data = unwrapOrError(
3220           Obj->template getSectionContentsAsArray<Elf_Word>(&Sec));
3221       DictScope D(W, "Group");
3222       StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
3223       W.printNumber("Name", Name, Sec.sh_name);
3224       W.printNumber("Index", SectionIndex);
3225       W.printHex("Type", getGroupType(Data[0]), Data[0]);
3226       W.startLine() << "Signature: " << StrTable.data() + Sym->st_name << "\n";
3227       {
3228         ListScope L(W, "Section(s) in group");
3229         size_t Member = 1;
3230         while (Member < Data.size()) {
3231           auto Sec = unwrapOrError(Obj->getSection(Data[Member]));
3232           const StringRef Name = unwrapOrError(Obj->getSectionName(Sec));
3233           W.startLine() << Name << " (" << Data[Member++] << ")\n";
3234         }
3235       }
3236     }
3237     ++SectionIndex;
3238   }
3239   if (!HasGroups)
3240     W.startLine() << "There are no group sections in the file.\n";
3241 }
3242
3243 template <class ELFT> void LLVMStyle<ELFT>::printRelocations(const ELFO *Obj) {
3244   ListScope D(W, "Relocations");
3245
3246   int SectionNumber = -1;
3247   for (const Elf_Shdr &Sec : Obj->sections()) {
3248     ++SectionNumber;
3249
3250     if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA)
3251       continue;
3252
3253     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
3254
3255     W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
3256     W.indent();
3257
3258     printRelocations(&Sec, Obj);
3259
3260     W.unindent();
3261     W.startLine() << "}\n";
3262   }
3263 }
3264
3265 template <class ELFT>
3266 void LLVMStyle<ELFT>::printRelocations(const Elf_Shdr *Sec, const ELFO *Obj) {
3267   const Elf_Shdr *SymTab = unwrapOrError(Obj->getSection(Sec->sh_link));
3268
3269   switch (Sec->sh_type) {
3270   case ELF::SHT_REL:
3271     for (const Elf_Rel &R : Obj->rels(Sec)) {
3272       Elf_Rela Rela;
3273       Rela.r_offset = R.r_offset;
3274       Rela.r_info = R.r_info;
3275       Rela.r_addend = 0;
3276       printRelocation(Obj, Rela, SymTab);
3277     }
3278     break;
3279   case ELF::SHT_RELA:
3280     for (const Elf_Rela &R : Obj->relas(Sec))
3281       printRelocation(Obj, R, SymTab);
3282     break;
3283   }
3284 }
3285
3286 template <class ELFT>
3287 void LLVMStyle<ELFT>::printRelocation(const ELFO *Obj, Elf_Rela Rel,
3288                                       const Elf_Shdr *SymTab) {
3289   SmallString<32> RelocName;
3290   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
3291   StringRef TargetName;
3292   const Elf_Sym *Sym = Obj->getRelocationSymbol(&Rel, SymTab);
3293   if (Sym && Sym->getType() == ELF::STT_SECTION) {
3294     const Elf_Shdr *Sec = unwrapOrError(
3295         Obj->getSection(Sym, SymTab, this->dumper()->getShndxTable()));
3296     TargetName = unwrapOrError(Obj->getSectionName(Sec));
3297   } else if (Sym) {
3298     StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*SymTab));
3299     TargetName = unwrapOrError(Sym->getName(StrTable));
3300   }
3301
3302   if (opts::ExpandRelocs) {
3303     DictScope Group(W, "Relocation");
3304     W.printHex("Offset", Rel.r_offset);
3305     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
3306     W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-",
3307                   Rel.getSymbol(Obj->isMips64EL()));
3308     W.printHex("Addend", Rel.r_addend);
3309   } else {
3310     raw_ostream &OS = W.startLine();
3311     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
3312        << (TargetName.size() > 0 ? TargetName : "-") << " "
3313        << W.hex(Rel.r_addend) << "\n";
3314   }
3315 }
3316
3317 template <class ELFT> void LLVMStyle<ELFT>::printSections(const ELFO *Obj) {
3318   ListScope SectionsD(W, "Sections");
3319
3320   int SectionIndex = -1;
3321   for (const Elf_Shdr &Sec : Obj->sections()) {
3322     ++SectionIndex;
3323
3324     StringRef Name = unwrapOrError(Obj->getSectionName(&Sec));
3325
3326     DictScope SectionD(W, "Section");
3327     W.printNumber("Index", SectionIndex);
3328     W.printNumber("Name", Name, Sec.sh_name);
3329     W.printHex("Type",
3330                getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type),
3331                Sec.sh_type);
3332     std::vector<EnumEntry<unsigned>> SectionFlags(std::begin(ElfSectionFlags),
3333                                                   std::end(ElfSectionFlags));
3334     switch (Obj->getHeader()->e_machine) {
3335     case EM_AMDGPU:
3336       SectionFlags.insert(SectionFlags.end(), std::begin(ElfAMDGPUSectionFlags),
3337                           std::end(ElfAMDGPUSectionFlags));
3338       break;
3339     case EM_HEXAGON:
3340       SectionFlags.insert(SectionFlags.end(),
3341                           std::begin(ElfHexagonSectionFlags),
3342                           std::end(ElfHexagonSectionFlags));
3343       break;
3344     case EM_MIPS:
3345       SectionFlags.insert(SectionFlags.end(), std::begin(ElfMipsSectionFlags),
3346                           std::end(ElfMipsSectionFlags));
3347       break;
3348     case EM_X86_64:
3349       SectionFlags.insert(SectionFlags.end(), std::begin(ElfX86_64SectionFlags),
3350                           std::end(ElfX86_64SectionFlags));
3351       break;
3352     case EM_XCORE:
3353       SectionFlags.insert(SectionFlags.end(), std::begin(ElfXCoreSectionFlags),
3354                           std::end(ElfXCoreSectionFlags));
3355       break;
3356     default:
3357       // Nothing to do.
3358       break;
3359     }
3360     W.printFlags("Flags", Sec.sh_flags, makeArrayRef(SectionFlags));
3361     W.printHex("Address", Sec.sh_addr);
3362     W.printHex("Offset", Sec.sh_offset);
3363     W.printNumber("Size", Sec.sh_size);
3364     W.printNumber("Link", Sec.sh_link);
3365     W.printNumber("Info", Sec.sh_info);
3366     W.printNumber("AddressAlignment", Sec.sh_addralign);
3367     W.printNumber("EntrySize", Sec.sh_entsize);
3368
3369     if (opts::SectionRelocations) {
3370       ListScope D(W, "Relocations");
3371       printRelocations(&Sec, Obj);
3372     }
3373
3374     if (opts::SectionSymbols) {
3375       ListScope D(W, "Symbols");
3376       const Elf_Shdr *Symtab = this->dumper()->getDotSymtabSec();
3377       StringRef StrTable = unwrapOrError(Obj->getStringTableForSymtab(*Symtab));
3378
3379       for (const Elf_Sym &Sym : Obj->symbols(Symtab)) {
3380         const Elf_Shdr *SymSec = unwrapOrError(
3381             Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable()));
3382         if (SymSec == &Sec)
3383           printSymbol(Obj, &Sym, Obj->symbol_begin(Symtab), StrTable, false);
3384       }
3385     }
3386
3387     if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
3388       ArrayRef<uint8_t> Data = unwrapOrError(Obj->getSectionContents(&Sec));
3389       W.printBinaryBlock("SectionData",
3390                          StringRef((const char *)Data.data(), Data.size()));
3391     }
3392   }
3393 }
3394
3395 template <class ELFT>
3396 void LLVMStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
3397                                   const Elf_Sym *First, StringRef StrTable,
3398                                   bool IsDynamic) {
3399   unsigned SectionIndex = 0;
3400   StringRef SectionName;
3401   getSectionNameIndex(*Obj, Symbol, First, this->dumper()->getShndxTable(),
3402                       SectionName, SectionIndex);
3403   std::string FullSymbolName =
3404       this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
3405   unsigned char SymbolType = Symbol->getType();
3406
3407   DictScope D(W, "Symbol");
3408   W.printNumber("Name", FullSymbolName, Symbol->st_name);
3409   W.printHex("Value", Symbol->st_value);
3410   W.printNumber("Size", Symbol->st_size);
3411   W.printEnum("Binding", Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
3412   if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
3413       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
3414     W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes));
3415   else
3416     W.printEnum("Type", SymbolType, makeArrayRef(ElfSymbolTypes));
3417   if (Symbol->st_other == 0)
3418     // Usually st_other flag is zero. Do not pollute the output
3419     // by flags enumeration in that case.
3420     W.printNumber("Other", 0);
3421   else {
3422     std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags),
3423                                                    std::end(ElfSymOtherFlags));
3424     if (Obj->getHeader()->e_machine == EM_MIPS) {
3425       // Someones in their infinite wisdom decided to make STO_MIPS_MIPS16
3426       // flag overlapped with other ST_MIPS_xxx flags. So consider both
3427       // cases separately.
3428       if ((Symbol->st_other & STO_MIPS_MIPS16) == STO_MIPS_MIPS16)
3429         SymOtherFlags.insert(SymOtherFlags.end(),
3430                              std::begin(ElfMips16SymOtherFlags),
3431                              std::end(ElfMips16SymOtherFlags));
3432       else
3433         SymOtherFlags.insert(SymOtherFlags.end(),
3434                              std::begin(ElfMipsSymOtherFlags),
3435                              std::end(ElfMipsSymOtherFlags));
3436     }
3437     W.printFlags("Other", Symbol->st_other, makeArrayRef(SymOtherFlags), 0x3u);
3438   }
3439   W.printHex("Section", SectionName, SectionIndex);
3440 }
3441
3442 template <class ELFT> void LLVMStyle<ELFT>::printSymbols(const ELFO *Obj) {
3443   ListScope Group(W, "Symbols");
3444   this->dumper()->printSymbolsHelper(false);
3445 }
3446
3447 template <class ELFT>
3448 void LLVMStyle<ELFT>::printDynamicSymbols(const ELFO *Obj) {
3449   ListScope Group(W, "DynamicSymbols");
3450   this->dumper()->printSymbolsHelper(true);
3451 }
3452
3453 template <class ELFT>
3454 void LLVMStyle<ELFT>::printDynamicRelocations(const ELFO *Obj) {
3455   const DynRegionInfo &DynRelRegion = this->dumper()->getDynRelRegion();
3456   const DynRegionInfo &DynRelaRegion = this->dumper()->getDynRelaRegion();
3457   const DynRegionInfo &DynPLTRelRegion = this->dumper()->getDynPLTRelRegion();
3458   if (DynRelRegion.Size && DynRelaRegion.Size)
3459     report_fatal_error("There are both REL and RELA dynamic relocations");
3460   W.startLine() << "Dynamic Relocations {\n";
3461   W.indent();
3462   if (DynRelaRegion.Size > 0)
3463     for (const Elf_Rela &Rela : this->dumper()->dyn_relas())
3464       printDynamicRelocation(Obj, Rela);
3465   else
3466     for (const Elf_Rel &Rel : this->dumper()->dyn_rels()) {
3467       Elf_Rela Rela;
3468       Rela.r_offset = Rel.r_offset;
3469       Rela.r_info = Rel.r_info;
3470       Rela.r_addend = 0;
3471       printDynamicRelocation(Obj, Rela);
3472     }
3473   if (DynPLTRelRegion.EntSize == sizeof(Elf_Rela))
3474     for (const Elf_Rela &Rela : DynPLTRelRegion.getAsArrayRef<Elf_Rela>())
3475       printDynamicRelocation(Obj, Rela);
3476   else
3477     for (const Elf_Rel &Rel : DynPLTRelRegion.getAsArrayRef<Elf_Rel>()) {
3478       Elf_Rela Rela;
3479       Rela.r_offset = Rel.r_offset;
3480       Rela.r_info = Rel.r_info;
3481       Rela.r_addend = 0;
3482       printDynamicRelocation(Obj, Rela);
3483     }
3484   W.unindent();
3485   W.startLine() << "}\n";
3486 }
3487
3488 template <class ELFT>
3489 void LLVMStyle<ELFT>::printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel) {
3490   SmallString<32> RelocName;
3491   Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
3492   StringRef SymbolName;
3493   uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
3494   const Elf_Sym *Sym = this->dumper()->dynamic_symbols().begin() + SymIndex;
3495   SymbolName =
3496       unwrapOrError(Sym->getName(this->dumper()->getDynamicStringTable()));
3497   if (opts::ExpandRelocs) {
3498     DictScope Group(W, "Relocation");
3499     W.printHex("Offset", Rel.r_offset);
3500     W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
3501     W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-");
3502     W.printHex("Addend", Rel.r_addend);
3503   } else {
3504     raw_ostream &OS = W.startLine();
3505     OS << W.hex(Rel.r_offset) << " " << RelocName << " "
3506        << (SymbolName.size() > 0 ? SymbolName : "-") << " "
3507        << W.hex(Rel.r_addend) << "\n";
3508   }
3509 }
3510
3511 template <class ELFT>
3512 void LLVMStyle<ELFT>::printProgramHeaders(const ELFO *Obj) {
3513   ListScope L(W, "ProgramHeaders");
3514
3515   for (const Elf_Phdr &Phdr : Obj->program_headers()) {
3516     DictScope P(W, "ProgramHeader");
3517     W.printHex("Type",
3518                getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
3519                Phdr.p_type);
3520     W.printHex("Offset", Phdr.p_offset);
3521     W.printHex("VirtualAddress", Phdr.p_vaddr);
3522     W.printHex("PhysicalAddress", Phdr.p_paddr);
3523     W.printNumber("FileSize", Phdr.p_filesz);
3524     W.printNumber("MemSize", Phdr.p_memsz);
3525     W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
3526     W.printNumber("Alignment", Phdr.p_align);
3527   }
3528 }
3529 template <class ELFT>
3530 void LLVMStyle<ELFT>::printHashHistogram(const ELFFile<ELFT> *Obj) {
3531   W.startLine() << "Hash Histogram not implemented!\n";
3532 }