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