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