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