ELFDumper.cpp revision 288943 
1//===-- ELFDumper.cpp - ELF-specific dumper ---------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
11/// \brief This file implements the ELF-specific dumper for llvm-readobj.
12///
13//===----------------------------------------------------------------------===//
14
15#include "llvm-readobj.h"
16#include "ARMAttributeParser.h"
17#include "ARMEHABIPrinter.h"
18#include "Error.h"
19#include "ObjDumper.h"
20#include "StackMapPrinter.h"
21#include "StreamWriter.h"
22#include "llvm/ADT/Optional.h"
23#include "llvm/ADT/SmallString.h"
24#include "llvm/ADT/StringExtras.h"
25#include "llvm/Object/ELFObjectFile.h"
26#include "llvm/Support/ARMBuildAttributes.h"
27#include "llvm/Support/Compiler.h"
28#include "llvm/Support/Format.h"
29#include "llvm/Support/MathExtras.h"
30#include "llvm/Support/MipsABIFlags.h"
31#include "llvm/Support/raw_ostream.h"
32
33using namespace llvm;
34using namespace llvm::object;
35using namespace ELF;
36
37#define LLVM_READOBJ_ENUM_CASE(ns, enum) \
38  case ns::enum: return #enum;
39
40namespace {
41
42template<typename ELFT>
43class ELFDumper : public ObjDumper {
44public:
45  ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
46      : ObjDumper(Writer), Obj(Obj) {}
47
48  void printFileHeaders() override;
49  void printSections() override;
50  void printRelocations() override;
51  void printDynamicRelocations() override;
52  void printSymbols() override;
53  void printDynamicSymbols() override;
54  void printUnwindInfo() override;
55
56  void printDynamicTable() override;
57  void printNeededLibraries() override;
58  void printProgramHeaders() override;
59  void printHashTable() override;
60
61  void printAttributes() override;
62  void printMipsPLTGOT() override;
63  void printMipsABIFlags() override;
64  void printMipsReginfo() override;
65
66  void printStackMap() const override;
67
68private:
69  typedef ELFFile<ELFT> ELFO;
70  typedef typename ELFO::Elf_Shdr Elf_Shdr;
71  typedef typename ELFO::Elf_Sym Elf_Sym;
72
73  void printSymbol(const Elf_Sym *Symbol, bool IsDynamic);
74
75  void printRelocations(const Elf_Shdr *Sec);
76  void printRelocation(const Elf_Shdr *Sec, typename ELFO::Elf_Rela Rel);
77
78  const ELFO *Obj;
79};
80
81template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) {
82  if (!Val) {
83    error(Val.getError());
84    return Default;
85  }
86
87  return *Val;
88}
89} // namespace
90
91namespace llvm {
92
93template <class ELFT>
94static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
95                                       StreamWriter &Writer,
96                                       std::unique_ptr<ObjDumper> &Result) {
97  Result.reset(new ELFDumper<ELFT>(Obj, Writer));
98  return readobj_error::success;
99}
100
101std::error_code createELFDumper(const object::ObjectFile *Obj,
102                                StreamWriter &Writer,
103                                std::unique_ptr<ObjDumper> &Result) {
104  // Little-endian 32-bit
105  if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
106    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
107
108  // Big-endian 32-bit
109  if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
110    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
111
112  // Little-endian 64-bit
113  if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
114    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
115
116  // Big-endian 64-bit
117  if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
118    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
119
120  return readobj_error::unsupported_obj_file_format;
121}
122
123} // namespace llvm
124
125template <typename ELFO>
126static std::string getFullSymbolName(const ELFO &Obj,
127                                     const typename ELFO::Elf_Sym *Symbol,
128                                     bool IsDynamic) {
129  StringRef SymbolName = errorOrDefault(Obj.getSymbolName(Symbol, IsDynamic));
130  if (!IsDynamic)
131    return SymbolName;
132
133  std::string FullSymbolName(SymbolName);
134
135  bool IsDefault;
136  ErrorOr<StringRef> Version =
137      Obj.getSymbolVersion(nullptr, &*Symbol, IsDefault);
138  if (Version) {
139    FullSymbolName += (IsDefault ? "@@" : "@");
140    FullSymbolName += *Version;
141  } else
142    error(Version.getError());
143  return FullSymbolName;
144}
145
146template <typename ELFO>
147static void
148getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol,
149                    StringRef &SectionName, unsigned &SectionIndex) {
150  SectionIndex = Symbol->st_shndx;
151  if (Symbol->isUndefined())
152    SectionName = "Undefined";
153  else if (Symbol->isProcessorSpecific())
154    SectionName = "Processor Specific";
155  else if (Symbol->isOSSpecific())
156    SectionName = "Operating System Specific";
157  else if (Symbol->isAbsolute())
158    SectionName = "Absolute";
159  else if (Symbol->isCommon())
160    SectionName = "Common";
161  else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX)
162    SectionName = "Reserved";
163  else {
164    if (SectionIndex == SHN_XINDEX)
165      SectionIndex = Obj.getExtendedSymbolTableIndex(&*Symbol);
166    ErrorOr<const typename ELFO::Elf_Shdr *> Sec = Obj.getSection(SectionIndex);
167    if (!error(Sec.getError()))
168      SectionName = errorOrDefault(Obj.getSectionName(*Sec));
169  }
170}
171
172template <class ELFT>
173static const typename ELFFile<ELFT>::Elf_Shdr *
174findSectionByAddress(const ELFFile<ELFT> *Obj, uint64_t Addr) {
175  for (const auto &Shdr : Obj->sections())
176    if (Shdr.sh_addr == Addr)
177      return &Shdr;
178  return nullptr;
179}
180
181template <class ELFT>
182static const typename ELFFile<ELFT>::Elf_Shdr *
183findSectionByName(const ELFFile<ELFT> &Obj, StringRef Name) {
184  for (const auto &Shdr : Obj.sections()) {
185    if (Name == errorOrDefault(Obj.getSectionName(&Shdr)))
186      return &Shdr;
187  }
188  return nullptr;
189}
190
191static const EnumEntry<unsigned> ElfClass[] = {
192  { "None",   ELF::ELFCLASSNONE },
193  { "32-bit", ELF::ELFCLASS32   },
194  { "64-bit", ELF::ELFCLASS64   },
195};
196
197static const EnumEntry<unsigned> ElfDataEncoding[] = {
198  { "None",         ELF::ELFDATANONE },
199  { "LittleEndian", ELF::ELFDATA2LSB },
200  { "BigEndian",    ELF::ELFDATA2MSB },
201};
202
203static const EnumEntry<unsigned> ElfObjectFileType[] = {
204  { "None",         ELF::ET_NONE },
205  { "Relocatable",  ELF::ET_REL  },
206  { "Executable",   ELF::ET_EXEC },
207  { "SharedObject", ELF::ET_DYN  },
208  { "Core",         ELF::ET_CORE },
209};
210
211static const EnumEntry<unsigned> ElfOSABI[] = {
212  { "SystemV",      ELF::ELFOSABI_NONE         },
213  { "HPUX",         ELF::ELFOSABI_HPUX         },
214  { "NetBSD",       ELF::ELFOSABI_NETBSD       },
215  { "GNU/Linux",    ELF::ELFOSABI_LINUX        },
216  { "GNU/Hurd",     ELF::ELFOSABI_HURD         },
217  { "Solaris",      ELF::ELFOSABI_SOLARIS      },
218  { "AIX",          ELF::ELFOSABI_AIX          },
219  { "IRIX",         ELF::ELFOSABI_IRIX         },
220  { "FreeBSD",      ELF::ELFOSABI_FREEBSD      },
221  { "TRU64",        ELF::ELFOSABI_TRU64        },
222  { "Modesto",      ELF::ELFOSABI_MODESTO      },
223  { "OpenBSD",      ELF::ELFOSABI_OPENBSD      },
224  { "OpenVMS",      ELF::ELFOSABI_OPENVMS      },
225  { "NSK",          ELF::ELFOSABI_NSK          },
226  { "AROS",         ELF::ELFOSABI_AROS         },
227  { "FenixOS",      ELF::ELFOSABI_FENIXOS      },
228  { "CloudABI",     ELF::ELFOSABI_CLOUDABI     },
229  { "C6000_ELFABI", ELF::ELFOSABI_C6000_ELFABI },
230  { "C6000_LINUX" , ELF::ELFOSABI_C6000_LINUX  },
231  { "ARM",          ELF::ELFOSABI_ARM          },
232  { "Standalone"  , ELF::ELFOSABI_STANDALONE   }
233};
234
235static const EnumEntry<unsigned> ElfMachineType[] = {
236  LLVM_READOBJ_ENUM_ENT(ELF, EM_NONE         ),
237  LLVM_READOBJ_ENUM_ENT(ELF, EM_M32          ),
238  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC        ),
239  LLVM_READOBJ_ENUM_ENT(ELF, EM_386          ),
240  LLVM_READOBJ_ENUM_ENT(ELF, EM_68K          ),
241  LLVM_READOBJ_ENUM_ENT(ELF, EM_88K          ),
242  LLVM_READOBJ_ENUM_ENT(ELF, EM_IAMCU        ),
243  LLVM_READOBJ_ENUM_ENT(ELF, EM_860          ),
244  LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS         ),
245  LLVM_READOBJ_ENUM_ENT(ELF, EM_S370         ),
246  LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_RS3_LE  ),
247  LLVM_READOBJ_ENUM_ENT(ELF, EM_PARISC       ),
248  LLVM_READOBJ_ENUM_ENT(ELF, EM_VPP500       ),
249  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC32PLUS  ),
250  LLVM_READOBJ_ENUM_ENT(ELF, EM_960          ),
251  LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC          ),
252  LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC64        ),
253  LLVM_READOBJ_ENUM_ENT(ELF, EM_S390         ),
254  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPU          ),
255  LLVM_READOBJ_ENUM_ENT(ELF, EM_V800         ),
256  LLVM_READOBJ_ENUM_ENT(ELF, EM_FR20         ),
257  LLVM_READOBJ_ENUM_ENT(ELF, EM_RH32         ),
258  LLVM_READOBJ_ENUM_ENT(ELF, EM_RCE          ),
259  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARM          ),
260  LLVM_READOBJ_ENUM_ENT(ELF, EM_ALPHA        ),
261  LLVM_READOBJ_ENUM_ENT(ELF, EM_SH           ),
262  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARCV9      ),
263  LLVM_READOBJ_ENUM_ENT(ELF, EM_TRICORE      ),
264  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC          ),
265  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300       ),
266  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300H      ),
267  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8S          ),
268  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_500       ),
269  LLVM_READOBJ_ENUM_ENT(ELF, EM_IA_64        ),
270  LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_X       ),
271  LLVM_READOBJ_ENUM_ENT(ELF, EM_COLDFIRE     ),
272  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC12       ),
273  LLVM_READOBJ_ENUM_ENT(ELF, EM_MMA          ),
274  LLVM_READOBJ_ENUM_ENT(ELF, EM_PCP          ),
275  LLVM_READOBJ_ENUM_ENT(ELF, EM_NCPU         ),
276  LLVM_READOBJ_ENUM_ENT(ELF, EM_NDR1         ),
277  LLVM_READOBJ_ENUM_ENT(ELF, EM_STARCORE     ),
278  LLVM_READOBJ_ENUM_ENT(ELF, EM_ME16         ),
279  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST100        ),
280  LLVM_READOBJ_ENUM_ENT(ELF, EM_TINYJ        ),
281  LLVM_READOBJ_ENUM_ENT(ELF, EM_X86_64       ),
282  LLVM_READOBJ_ENUM_ENT(ELF, EM_PDSP         ),
283  LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP10        ),
284  LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP11        ),
285  LLVM_READOBJ_ENUM_ENT(ELF, EM_FX66         ),
286  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST9PLUS      ),
287  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST7          ),
288  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC16       ),
289  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC11       ),
290  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC08       ),
291  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC05       ),
292  LLVM_READOBJ_ENUM_ENT(ELF, EM_SVX          ),
293  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST19         ),
294  LLVM_READOBJ_ENUM_ENT(ELF, EM_VAX          ),
295  LLVM_READOBJ_ENUM_ENT(ELF, EM_CRIS         ),
296  LLVM_READOBJ_ENUM_ENT(ELF, EM_JAVELIN      ),
297  LLVM_READOBJ_ENUM_ENT(ELF, EM_FIREPATH     ),
298  LLVM_READOBJ_ENUM_ENT(ELF, EM_ZSP          ),
299  LLVM_READOBJ_ENUM_ENT(ELF, EM_MMIX         ),
300  LLVM_READOBJ_ENUM_ENT(ELF, EM_HUANY        ),
301  LLVM_READOBJ_ENUM_ENT(ELF, EM_PRISM        ),
302  LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR          ),
303  LLVM_READOBJ_ENUM_ENT(ELF, EM_FR30         ),
304  LLVM_READOBJ_ENUM_ENT(ELF, EM_D10V         ),
305  LLVM_READOBJ_ENUM_ENT(ELF, EM_D30V         ),
306  LLVM_READOBJ_ENUM_ENT(ELF, EM_V850         ),
307  LLVM_READOBJ_ENUM_ENT(ELF, EM_M32R         ),
308  LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10300      ),
309  LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10200      ),
310  LLVM_READOBJ_ENUM_ENT(ELF, EM_PJ           ),
311  LLVM_READOBJ_ENUM_ENT(ELF, EM_OPENRISC     ),
312  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT  ),
313  LLVM_READOBJ_ENUM_ENT(ELF, EM_XTENSA       ),
314  LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE    ),
315  LLVM_READOBJ_ENUM_ENT(ELF, EM_TMM_GPP      ),
316  LLVM_READOBJ_ENUM_ENT(ELF, EM_NS32K        ),
317  LLVM_READOBJ_ENUM_ENT(ELF, EM_TPC          ),
318  LLVM_READOBJ_ENUM_ENT(ELF, EM_SNP1K        ),
319  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST200        ),
320  LLVM_READOBJ_ENUM_ENT(ELF, EM_IP2K         ),
321  LLVM_READOBJ_ENUM_ENT(ELF, EM_MAX          ),
322  LLVM_READOBJ_ENUM_ENT(ELF, EM_CR           ),
323  LLVM_READOBJ_ENUM_ENT(ELF, EM_F2MC16       ),
324  LLVM_READOBJ_ENUM_ENT(ELF, EM_MSP430       ),
325  LLVM_READOBJ_ENUM_ENT(ELF, EM_BLACKFIN     ),
326  LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C33       ),
327  LLVM_READOBJ_ENUM_ENT(ELF, EM_SEP          ),
328  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARCA         ),
329  LLVM_READOBJ_ENUM_ENT(ELF, EM_UNICORE      ),
330  LLVM_READOBJ_ENUM_ENT(ELF, EM_EXCESS       ),
331  LLVM_READOBJ_ENUM_ENT(ELF, EM_DXP          ),
332  LLVM_READOBJ_ENUM_ENT(ELF, EM_ALTERA_NIOS2 ),
333  LLVM_READOBJ_ENUM_ENT(ELF, EM_CRX          ),
334  LLVM_READOBJ_ENUM_ENT(ELF, EM_XGATE        ),
335  LLVM_READOBJ_ENUM_ENT(ELF, EM_C166         ),
336  LLVM_READOBJ_ENUM_ENT(ELF, EM_M16C         ),
337  LLVM_READOBJ_ENUM_ENT(ELF, EM_DSPIC30F     ),
338  LLVM_READOBJ_ENUM_ENT(ELF, EM_CE           ),
339  LLVM_READOBJ_ENUM_ENT(ELF, EM_M32C         ),
340  LLVM_READOBJ_ENUM_ENT(ELF, EM_TSK3000      ),
341  LLVM_READOBJ_ENUM_ENT(ELF, EM_RS08         ),
342  LLVM_READOBJ_ENUM_ENT(ELF, EM_SHARC        ),
343  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG2        ),
344  LLVM_READOBJ_ENUM_ENT(ELF, EM_SCORE7       ),
345  LLVM_READOBJ_ENUM_ENT(ELF, EM_DSP24        ),
346  LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE3   ),
347  LLVM_READOBJ_ENUM_ENT(ELF, EM_LATTICEMICO32),
348  LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17       ),
349  LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000     ),
350  LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000     ),
351  LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500     ),
352  LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS   ),
353  LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C  ),
354  LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C         ),
355  LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA     ),
356  LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON      ),
357  LLVM_READOBJ_ENUM_ENT(ELF, EM_8051         ),
358  LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X       ),
359  LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32        ),
360  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1        ),
361  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X       ),
362  LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30       ),
363  LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16       ),
364  LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK        ),
365  LLVM_READOBJ_ENUM_ENT(ELF, EM_CRAYNV2      ),
366  LLVM_READOBJ_ENUM_ENT(ELF, EM_RX           ),
367  LLVM_READOBJ_ENUM_ENT(ELF, EM_METAG        ),
368  LLVM_READOBJ_ENUM_ENT(ELF, EM_MCST_ELBRUS  ),
369  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG16       ),
370  LLVM_READOBJ_ENUM_ENT(ELF, EM_CR16         ),
371  LLVM_READOBJ_ENUM_ENT(ELF, EM_ETPU         ),
372  LLVM_READOBJ_ENUM_ENT(ELF, EM_SLE9X        ),
373  LLVM_READOBJ_ENUM_ENT(ELF, EM_L10M         ),
374  LLVM_READOBJ_ENUM_ENT(ELF, EM_K10M         ),
375  LLVM_READOBJ_ENUM_ENT(ELF, EM_AARCH64      ),
376  LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR32        ),
377  LLVM_READOBJ_ENUM_ENT(ELF, EM_STM8         ),
378  LLVM_READOBJ_ENUM_ENT(ELF, EM_TILE64       ),
379  LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEPRO      ),
380  LLVM_READOBJ_ENUM_ENT(ELF, EM_CUDA         ),
381  LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEGX       ),
382  LLVM_READOBJ_ENUM_ENT(ELF, EM_CLOUDSHIELD  ),
383  LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_1ST    ),
384  LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_2ND    ),
385  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT2 ),
386  LLVM_READOBJ_ENUM_ENT(ELF, EM_OPEN8        ),
387  LLVM_READOBJ_ENUM_ENT(ELF, EM_RL78         ),
388  LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE5   ),
389  LLVM_READOBJ_ENUM_ENT(ELF, EM_78KOR        ),
390  LLVM_READOBJ_ENUM_ENT(ELF, EM_56800EX      ),
391  LLVM_READOBJ_ENUM_ENT(ELF, EM_AMDGPU       )
392};
393
394static const EnumEntry<unsigned> ElfSymbolBindings[] = {
395  { "Local",  ELF::STB_LOCAL        },
396  { "Global", ELF::STB_GLOBAL       },
397  { "Weak",   ELF::STB_WEAK         },
398  { "Unique", ELF::STB_GNU_UNIQUE   }
399};
400
401static const EnumEntry<unsigned> ElfSymbolTypes[] = {
402  { "None",      ELF::STT_NOTYPE    },
403  { "Object",    ELF::STT_OBJECT    },
404  { "Function",  ELF::STT_FUNC      },
405  { "Section",   ELF::STT_SECTION   },
406  { "File",      ELF::STT_FILE      },
407  { "Common",    ELF::STT_COMMON    },
408  { "TLS",       ELF::STT_TLS       },
409  { "GNU_IFunc", ELF::STT_GNU_IFUNC }
410};
411
412static const char *getElfSectionType(unsigned Arch, unsigned Type) {
413  switch (Arch) {
414  case ELF::EM_ARM:
415    switch (Type) {
416    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
417    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
418    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
419    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
420    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
421    }
422  case ELF::EM_HEXAGON:
423    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
424  case ELF::EM_X86_64:
425    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
426  case ELF::EM_MIPS:
427  case ELF::EM_MIPS_RS3_LE:
428    switch (Type) {
429    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
430    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
431    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
432    }
433  }
434
435  switch (Type) {
436  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL              );
437  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS          );
438  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB            );
439  LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB            );
440  LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA              );
441  LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH              );
442  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC           );
443  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE              );
444  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS            );
445  LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL               );
446  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB             );
447  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM            );
448  LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY        );
449  LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY        );
450  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY     );
451  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP             );
452  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX      );
453  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES    );
454  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
455  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
456  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
457  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
458  default: return "";
459  }
460}
461
462static const EnumEntry<unsigned> ElfSectionFlags[] = {
463  LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE           ),
464  LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC           ),
465  LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE         ),
466  LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR       ),
467  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE           ),
468  LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS         ),
469  LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK       ),
470  LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER      ),
471  LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING),
472  LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP           ),
473  LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS             ),
474  LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
475  LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION),
476  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP    )
477};
478
479static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
480  // Check potentially overlapped processor-specific
481  // program header type.
482  switch (Arch) {
483  case ELF::EM_ARM:
484    switch (Type) {
485    LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
486    }
487  case ELF::EM_MIPS:
488  case ELF::EM_MIPS_RS3_LE:
489    switch (Type) {
490    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
491    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
492    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
493    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
494    }
495  }
496
497  switch (Type) {
498  LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL   );
499  LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD   );
500  LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
501  LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
502  LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE   );
503  LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB  );
504  LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR   );
505  LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS    );
506
507  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
508  LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
509
510  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
511  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
512  default: return "";
513  }
514}
515
516static const EnumEntry<unsigned> ElfSegmentFlags[] = {
517  LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
518  LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
519  LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
520};
521
522static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
523  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
524  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
525  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
526  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
527  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
528  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_FP64),
529  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
530  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
531  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O64),
532  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI32),
533  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI64),
534  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_3900),
535  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4010),
536  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4100),
537  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4650),
538  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4120),
539  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4111),
540  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_SB1),
541  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON),
542  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_XLR),
543  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON2),
544  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON3),
545  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5400),
546  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5900),
547  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5500),
548  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_9000),
549  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2E),
550  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2F),
551  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS3A),
552  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
553  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
554  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_MDMX),
555  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
556  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
557  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
558  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
559  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
560  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
561  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
562  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
563  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
564  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
565  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
566};
567
568template<class ELFT>
569void ELFDumper<ELFT>::printFileHeaders() {
570  const typename ELFO::Elf_Ehdr *Header = Obj->getHeader();
571
572  {
573    DictScope D(W, "ElfHeader");
574    {
575      DictScope D(W, "Ident");
576      W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0,
577                                                                 4));
578      W.printEnum  ("Class", Header->e_ident[ELF::EI_CLASS],
579                      makeArrayRef(ElfClass));
580      W.printEnum  ("DataEncoding", Header->e_ident[ELF::EI_DATA],
581                      makeArrayRef(ElfDataEncoding));
582      W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]);
583
584      // Handle architecture specific OS/ABI values.
585      if (Header->e_machine == ELF::EM_AMDGPU &&
586          Header->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
587        W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
588      else
589        W.printEnum  ("OS/ABI", Header->e_ident[ELF::EI_OSABI],
590                      makeArrayRef(ElfOSABI));
591      W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]);
592      W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD));
593    }
594
595    W.printEnum  ("Type", Header->e_type, makeArrayRef(ElfObjectFileType));
596    W.printEnum  ("Machine", Header->e_machine, makeArrayRef(ElfMachineType));
597    W.printNumber("Version", Header->e_version);
598    W.printHex   ("Entry", Header->e_entry);
599    W.printHex   ("ProgramHeaderOffset", Header->e_phoff);
600    W.printHex   ("SectionHeaderOffset", Header->e_shoff);
601    if (Header->e_machine == EM_MIPS)
602      W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags),
603                   unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
604                   unsigned(ELF::EF_MIPS_MACH));
605    else
606      W.printFlags("Flags", Header->e_flags);
607    W.printNumber("HeaderSize", Header->e_ehsize);
608    W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize);
609    W.printNumber("ProgramHeaderCount", Header->e_phnum);
610    W.printNumber("SectionHeaderEntrySize", Header->e_shentsize);
611    W.printNumber("SectionHeaderCount", Header->e_shnum);
612    W.printNumber("StringTableSectionIndex", Header->e_shstrndx);
613  }
614}
615
616template<class ELFT>
617void ELFDumper<ELFT>::printSections() {
618  ListScope SectionsD(W, "Sections");
619
620  int SectionIndex = -1;
621  for (const typename ELFO::Elf_Shdr &Sec : Obj->sections()) {
622    ++SectionIndex;
623
624    StringRef Name = errorOrDefault(Obj->getSectionName(&Sec));
625
626    DictScope SectionD(W, "Section");
627    W.printNumber("Index", SectionIndex);
628    W.printNumber("Name", Name, Sec.sh_name);
629    W.printHex("Type",
630               getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type),
631               Sec.sh_type);
632    W.printFlags("Flags", Sec.sh_flags, makeArrayRef(ElfSectionFlags));
633    W.printHex("Address", Sec.sh_addr);
634    W.printHex("Offset", Sec.sh_offset);
635    W.printNumber("Size", Sec.sh_size);
636    W.printNumber("Link", Sec.sh_link);
637    W.printNumber("Info", Sec.sh_info);
638    W.printNumber("AddressAlignment", Sec.sh_addralign);
639    W.printNumber("EntrySize", Sec.sh_entsize);
640
641    if (opts::SectionRelocations) {
642      ListScope D(W, "Relocations");
643      printRelocations(&Sec);
644    }
645
646    if (opts::SectionSymbols) {
647      ListScope D(W, "Symbols");
648      for (const typename ELFO::Elf_Sym &Sym : Obj->symbols()) {
649        ErrorOr<const Elf_Shdr *> SymSec = Obj->getSection(&Sym);
650        if (!SymSec)
651          continue;
652        if (*SymSec == &Sec)
653          printSymbol(&Sym, false);
654      }
655    }
656
657    if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
658      ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(&Sec));
659      W.printBinaryBlock("SectionData",
660                         StringRef((const char *)Data.data(), Data.size()));
661    }
662  }
663}
664
665template<class ELFT>
666void ELFDumper<ELFT>::printRelocations() {
667  ListScope D(W, "Relocations");
668
669  int SectionNumber = -1;
670  for (const typename ELFO::Elf_Shdr &Sec : Obj->sections()) {
671    ++SectionNumber;
672
673    if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA)
674      continue;
675
676    StringRef Name = errorOrDefault(Obj->getSectionName(&Sec));
677
678    W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
679    W.indent();
680
681    printRelocations(&Sec);
682
683    W.unindent();
684    W.startLine() << "}\n";
685  }
686}
687
688template<class ELFT>
689void ELFDumper<ELFT>::printDynamicRelocations() {
690  W.startLine() << "Dynamic Relocations {\n";
691  W.indent();
692  for (typename ELFO::Elf_Rela_Iter RelI = Obj->dyn_rela_begin(),
693                                    RelE = Obj->dyn_rela_end();
694       RelI != RelE; ++RelI) {
695    SmallString<32> RelocName;
696    Obj->getRelocationTypeName(RelI->getType(Obj->isMips64EL()), RelocName);
697    StringRef SymbolName;
698    uint32_t SymIndex = RelI->getSymbol(Obj->isMips64EL());
699    const typename ELFO::Elf_Sym *Sym = Obj->dynamic_symbol_begin() + SymIndex;
700    SymbolName = errorOrDefault(Obj->getSymbolName(Sym, true));
701    if (opts::ExpandRelocs) {
702      DictScope Group(W, "Relocation");
703      W.printHex("Offset", RelI->r_offset);
704      W.printNumber("Type", RelocName, (int)RelI->getType(Obj->isMips64EL()));
705      W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-");
706      W.printHex("Addend", RelI->r_addend);
707    }
708    else {
709      raw_ostream& OS = W.startLine();
710      OS << W.hex(RelI->r_offset)
711        << " " << RelocName
712        << " " << (SymbolName.size() > 0 ? SymbolName : "-")
713        << " " << W.hex(RelI->r_addend)
714        << "\n";
715    }
716  }
717  W.unindent();
718  W.startLine() << "}\n";
719}
720
721template <class ELFT>
722void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
723  switch (Sec->sh_type) {
724  case ELF::SHT_REL:
725    for (typename ELFO::Elf_Rel_Iter RI = Obj->rel_begin(Sec),
726                                     RE = Obj->rel_end(Sec);
727         RI != RE; ++RI) {
728      typename ELFO::Elf_Rela Rela;
729      Rela.r_offset = RI->r_offset;
730      Rela.r_info = RI->r_info;
731      Rela.r_addend = 0;
732      printRelocation(Sec, Rela);
733    }
734    break;
735  case ELF::SHT_RELA:
736    for (typename ELFO::Elf_Rela_Iter RI = Obj->rela_begin(Sec),
737                                      RE = Obj->rela_end(Sec);
738         RI != RE; ++RI) {
739      printRelocation(Sec, *RI);
740    }
741    break;
742  }
743}
744
745template <class ELFT>
746void ELFDumper<ELFT>::printRelocation(const Elf_Shdr *Sec,
747                                      typename ELFO::Elf_Rela Rel) {
748  SmallString<32> RelocName;
749  Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
750  StringRef TargetName;
751  std::pair<const Elf_Shdr *, const Elf_Sym *> Sym =
752      Obj->getRelocationSymbol(Sec, &Rel);
753  if (Sym.second && Sym.second->getType() == ELF::STT_SECTION) {
754    ErrorOr<const Elf_Shdr *> Sec = Obj->getSection(Sym.second);
755    if (!error(Sec.getError())) {
756      ErrorOr<StringRef> SecName = Obj->getSectionName(*Sec);
757      if (SecName)
758        TargetName = SecName.get();
759    }
760  } else if (Sym.first) {
761    const Elf_Shdr *SymTable = Sym.first;
762    ErrorOr<const Elf_Shdr *> StrTableSec = Obj->getSection(SymTable->sh_link);
763    if (!error(StrTableSec.getError())) {
764      ErrorOr<StringRef> StrTableOrErr = Obj->getStringTable(*StrTableSec);
765      if (!error(StrTableOrErr.getError()))
766        TargetName = errorOrDefault(Sym.second->getName(*StrTableOrErr));
767    }
768  }
769
770  if (opts::ExpandRelocs) {
771    DictScope Group(W, "Relocation");
772    W.printHex("Offset", Rel.r_offset);
773    W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
774    W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-",
775                  Rel.getSymbol(Obj->isMips64EL()));
776    W.printHex("Addend", Rel.r_addend);
777  } else {
778    raw_ostream& OS = W.startLine();
779    OS << W.hex(Rel.r_offset) << " " << RelocName << " "
780       << (TargetName.size() > 0 ? TargetName : "-") << " "
781       << W.hex(Rel.r_addend) << "\n";
782  }
783}
784
785template<class ELFT>
786void ELFDumper<ELFT>::printSymbols() {
787  ListScope Group(W, "Symbols");
788  for (const typename ELFO::Elf_Sym &Sym : Obj->symbols())
789    printSymbol(&Sym, false);
790}
791
792template<class ELFT>
793void ELFDumper<ELFT>::printDynamicSymbols() {
794  ListScope Group(W, "DynamicSymbols");
795
796  for (const typename ELFO::Elf_Sym &Sym : Obj->dynamic_symbols())
797    printSymbol(&Sym, true);
798}
799
800template <class ELFT>
801void ELFDumper<ELFT>::printSymbol(const typename ELFO::Elf_Sym *Symbol,
802                                  bool IsDynamic) {
803  unsigned SectionIndex = 0;
804  StringRef SectionName;
805  getSectionNameIndex(*Obj, Symbol, SectionName, SectionIndex);
806  std::string FullSymbolName = getFullSymbolName(*Obj, Symbol, IsDynamic);
807
808  DictScope D(W, "Symbol");
809  W.printNumber("Name", FullSymbolName, Symbol->st_name);
810  W.printHex   ("Value", Symbol->st_value);
811  W.printNumber("Size", Symbol->st_size);
812  W.printEnum  ("Binding", Symbol->getBinding(),
813                  makeArrayRef(ElfSymbolBindings));
814  W.printEnum  ("Type", Symbol->getType(), makeArrayRef(ElfSymbolTypes));
815  W.printNumber("Other", Symbol->st_other);
816  W.printHex("Section", SectionName, SectionIndex);
817}
818
819#define LLVM_READOBJ_TYPE_CASE(name) \
820  case DT_##name: return #name
821
822static const char *getTypeString(uint64_t Type) {
823  switch (Type) {
824  LLVM_READOBJ_TYPE_CASE(BIND_NOW);
825  LLVM_READOBJ_TYPE_CASE(DEBUG);
826  LLVM_READOBJ_TYPE_CASE(FINI);
827  LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
828  LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
829  LLVM_READOBJ_TYPE_CASE(FLAGS);
830  LLVM_READOBJ_TYPE_CASE(FLAGS_1);
831  LLVM_READOBJ_TYPE_CASE(HASH);
832  LLVM_READOBJ_TYPE_CASE(INIT);
833  LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
834  LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
835  LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
836  LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
837  LLVM_READOBJ_TYPE_CASE(JMPREL);
838  LLVM_READOBJ_TYPE_CASE(NEEDED);
839  LLVM_READOBJ_TYPE_CASE(NULL);
840  LLVM_READOBJ_TYPE_CASE(PLTGOT);
841  LLVM_READOBJ_TYPE_CASE(PLTREL);
842  LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
843  LLVM_READOBJ_TYPE_CASE(REL);
844  LLVM_READOBJ_TYPE_CASE(RELA);
845  LLVM_READOBJ_TYPE_CASE(RELENT);
846  LLVM_READOBJ_TYPE_CASE(RELSZ);
847  LLVM_READOBJ_TYPE_CASE(RELAENT);
848  LLVM_READOBJ_TYPE_CASE(RELASZ);
849  LLVM_READOBJ_TYPE_CASE(RPATH);
850  LLVM_READOBJ_TYPE_CASE(RUNPATH);
851  LLVM_READOBJ_TYPE_CASE(SONAME);
852  LLVM_READOBJ_TYPE_CASE(STRSZ);
853  LLVM_READOBJ_TYPE_CASE(STRTAB);
854  LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
855  LLVM_READOBJ_TYPE_CASE(SYMENT);
856  LLVM_READOBJ_TYPE_CASE(SYMTAB);
857  LLVM_READOBJ_TYPE_CASE(TEXTREL);
858  LLVM_READOBJ_TYPE_CASE(VERNEED);
859  LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
860  LLVM_READOBJ_TYPE_CASE(VERSYM);
861  LLVM_READOBJ_TYPE_CASE(RELCOUNT);
862  LLVM_READOBJ_TYPE_CASE(GNU_HASH);
863  LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
864  LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
865  LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
866  LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
867  LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
868  LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
869  LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
870  LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
871  LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
872  LLVM_READOBJ_TYPE_CASE(MIPS_OPTIONS);
873  default: return "unknown";
874  }
875}
876
877#undef LLVM_READOBJ_TYPE_CASE
878
879#define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
880  { #enum, prefix##_##enum }
881
882static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
883  LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
884  LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
885  LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
886  LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
887  LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
888};
889
890static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
891  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
892  LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
893  LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
894  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
895  LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
896  LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
897  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
898  LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
899  LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
900  LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
901  LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
902  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
903  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
904  LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
905  LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
906  LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
907  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
908  LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
909  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
910  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
911  LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
912  LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
913  LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
914  LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
915  LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON)
916};
917
918static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
919  LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
920  LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
921  LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
922  LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
923  LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
924  LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
925  LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
926  LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
927  LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
928  LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
929  LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
930  LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
931  LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
932  LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
933  LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
934  LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
935};
936
937#undef LLVM_READOBJ_DT_FLAG_ENT
938
939template <typename T, typename TFlag>
940void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
941  typedef EnumEntry<TFlag> FlagEntry;
942  typedef SmallVector<FlagEntry, 10> FlagVector;
943  FlagVector SetFlags;
944
945  for (const auto &Flag : Flags) {
946    if (Flag.Value == 0)
947      continue;
948
949    if ((Value & Flag.Value) == Flag.Value)
950      SetFlags.push_back(Flag);
951  }
952
953  for (const auto &Flag : SetFlags) {
954    OS << Flag.Name << " ";
955  }
956}
957
958template <class ELFT>
959static void printValue(const ELFFile<ELFT> *O, uint64_t Type, uint64_t Value,
960                       bool Is64, raw_ostream &OS) {
961  switch (Type) {
962  case DT_PLTREL:
963    if (Value == DT_REL) {
964      OS << "REL";
965      break;
966    } else if (Value == DT_RELA) {
967      OS << "RELA";
968      break;
969    }
970  // Fallthrough.
971  case DT_PLTGOT:
972  case DT_HASH:
973  case DT_STRTAB:
974  case DT_SYMTAB:
975  case DT_RELA:
976  case DT_INIT:
977  case DT_FINI:
978  case DT_REL:
979  case DT_JMPREL:
980  case DT_INIT_ARRAY:
981  case DT_FINI_ARRAY:
982  case DT_PREINIT_ARRAY:
983  case DT_DEBUG:
984  case DT_VERNEED:
985  case DT_VERSYM:
986  case DT_GNU_HASH:
987  case DT_NULL:
988  case DT_MIPS_BASE_ADDRESS:
989  case DT_MIPS_GOTSYM:
990  case DT_MIPS_RLD_MAP:
991  case DT_MIPS_PLTGOT:
992  case DT_MIPS_OPTIONS:
993    OS << format("0x%" PRIX64, Value);
994    break;
995  case DT_RELCOUNT:
996  case DT_VERNEEDNUM:
997  case DT_MIPS_RLD_VERSION:
998  case DT_MIPS_LOCAL_GOTNO:
999  case DT_MIPS_SYMTABNO:
1000  case DT_MIPS_UNREFEXTNO:
1001    OS << Value;
1002    break;
1003  case DT_PLTRELSZ:
1004  case DT_RELASZ:
1005  case DT_RELAENT:
1006  case DT_STRSZ:
1007  case DT_SYMENT:
1008  case DT_RELSZ:
1009  case DT_RELENT:
1010  case DT_INIT_ARRAYSZ:
1011  case DT_FINI_ARRAYSZ:
1012  case DT_PREINIT_ARRAYSZ:
1013    OS << Value << " (bytes)";
1014    break;
1015  case DT_NEEDED:
1016    OS << "SharedLibrary (" << O->getDynamicString(Value) << ")";
1017    break;
1018  case DT_SONAME:
1019    OS << "LibrarySoname (" << O->getDynamicString(Value) << ")";
1020    break;
1021  case DT_RPATH:
1022  case DT_RUNPATH:
1023    OS << O->getDynamicString(Value);
1024    break;
1025  case DT_MIPS_FLAGS:
1026    printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
1027    break;
1028  case DT_FLAGS:
1029    printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
1030    break;
1031  case DT_FLAGS_1:
1032    printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
1033    break;
1034  default:
1035    OS << format("0x%" PRIX64, Value);
1036    break;
1037  }
1038}
1039
1040template<class ELFT>
1041void ELFDumper<ELFT>::printUnwindInfo() {
1042  W.startLine() << "UnwindInfo not implemented.\n";
1043}
1044
1045namespace {
1046template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() {
1047  const unsigned Machine = Obj->getHeader()->e_machine;
1048  if (Machine == EM_ARM) {
1049    ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx(W, Obj);
1050    return Ctx.PrintUnwindInformation();
1051  }
1052  W.startLine() << "UnwindInfo not implemented.\n";
1053}
1054}
1055
1056template<class ELFT>
1057void ELFDumper<ELFT>::printDynamicTable() {
1058  auto DynTable = Obj->dynamic_table(true);
1059
1060  ptrdiff_t Total = std::distance(DynTable.begin(), DynTable.end());
1061  if (Total == 0)
1062    return;
1063
1064  raw_ostream &OS = W.getOStream();
1065  W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
1066
1067  bool Is64 = ELFT::Is64Bits;
1068
1069  W.startLine()
1070     << "  Tag" << (Is64 ? "                " : "        ") << "Type"
1071     << "                 " << "Name/Value\n";
1072  for (const auto &Entry : DynTable) {
1073    W.startLine()
1074       << "  "
1075       << format(Is64 ? "0x%016" PRIX64 : "0x%08" PRIX64, Entry.getTag())
1076       << " " << format("%-21s", getTypeString(Entry.getTag()));
1077    printValue(Obj, Entry.getTag(), Entry.getVal(), Is64, OS);
1078    OS << "\n";
1079  }
1080
1081  W.startLine() << "]\n";
1082}
1083
1084template<class ELFT>
1085void ELFDumper<ELFT>::printNeededLibraries() {
1086  ListScope D(W, "NeededLibraries");
1087
1088  typedef std::vector<StringRef> LibsTy;
1089  LibsTy Libs;
1090
1091  for (const auto &Entry : Obj->dynamic_table())
1092    if (Entry.d_tag == ELF::DT_NEEDED)
1093      Libs.push_back(Obj->getDynamicString(Entry.d_un.d_val));
1094
1095  std::stable_sort(Libs.begin(), Libs.end());
1096
1097  for (LibsTy::const_iterator I = Libs.begin(), E = Libs.end(); I != E; ++I) {
1098    outs() << "  " << *I << "\n";
1099  }
1100}
1101
1102template<class ELFT>
1103void ELFDumper<ELFT>::printProgramHeaders() {
1104  ListScope L(W, "ProgramHeaders");
1105
1106  for (typename ELFO::Elf_Phdr_Iter PI = Obj->program_header_begin(),
1107                                    PE = Obj->program_header_end();
1108       PI != PE; ++PI) {
1109    DictScope P(W, "ProgramHeader");
1110    W.printHex   ("Type",
1111                  getElfSegmentType(Obj->getHeader()->e_machine, PI->p_type),
1112                  PI->p_type);
1113    W.printHex   ("Offset", PI->p_offset);
1114    W.printHex   ("VirtualAddress", PI->p_vaddr);
1115    W.printHex   ("PhysicalAddress", PI->p_paddr);
1116    W.printNumber("FileSize", PI->p_filesz);
1117    W.printNumber("MemSize", PI->p_memsz);
1118    W.printFlags ("Flags", PI->p_flags, makeArrayRef(ElfSegmentFlags));
1119    W.printNumber("Alignment", PI->p_align);
1120  }
1121}
1122
1123template <typename ELFT>
1124void ELFDumper<ELFT>::printHashTable() {
1125  DictScope D(W, "HashTable");
1126  auto HT = Obj->getHashTable();
1127  if (!HT)
1128    return;
1129  W.printNumber("Num Buckets", HT->nbucket);
1130  W.printNumber("Num Chains", HT->nchain);
1131  W.printList("Buckets", HT->buckets());
1132  W.printList("Chains", HT->chains());
1133}
1134
1135template <class ELFT>
1136void ELFDumper<ELFT>::printAttributes() {
1137  W.startLine() << "Attributes not implemented.\n";
1138}
1139
1140namespace {
1141template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() {
1142  if (Obj->getHeader()->e_machine != EM_ARM) {
1143    W.startLine() << "Attributes not implemented.\n";
1144    return;
1145  }
1146
1147  DictScope BA(W, "BuildAttributes");
1148  for (const ELFO::Elf_Shdr &Sec : Obj->sections()) {
1149    if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
1150      continue;
1151
1152    ErrorOr<ArrayRef<uint8_t>> Contents = Obj->getSectionContents(&Sec);
1153    if (!Contents)
1154      continue;
1155
1156    if ((*Contents)[0] != ARMBuildAttrs::Format_Version) {
1157      errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0])
1158             << '\n';
1159      continue;
1160    }
1161
1162    W.printHex("FormatVersion", (*Contents)[0]);
1163    if (Contents->size() == 1)
1164      continue;
1165
1166    ARMAttributeParser(W).Parse(*Contents);
1167  }
1168}
1169}
1170
1171namespace {
1172template <class ELFT> class MipsGOTParser {
1173public:
1174  typedef object::ELFFile<ELFT> ObjectFile;
1175  typedef typename ObjectFile::Elf_Shdr Elf_Shdr;
1176  typedef typename ObjectFile::Elf_Sym Elf_Sym;
1177
1178  MipsGOTParser(const ObjectFile *Obj, StreamWriter &W);
1179
1180  void parseGOT();
1181  void parsePLT();
1182
1183private:
1184  typedef typename ObjectFile::Elf_Addr GOTEntry;
1185  typedef typename ObjectFile::template ELFEntityIterator<const GOTEntry>
1186  GOTIter;
1187
1188  const ObjectFile *Obj;
1189  StreamWriter &W;
1190  llvm::Optional<uint64_t> DtPltGot;
1191  llvm::Optional<uint64_t> DtLocalGotNum;
1192  llvm::Optional<uint64_t> DtGotSym;
1193  llvm::Optional<uint64_t> DtMipsPltGot;
1194  llvm::Optional<uint64_t> DtJmpRel;
1195
1196  std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1197  GOTIter makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1198
1199  void printGotEntry(uint64_t GotAddr, GOTIter BeginIt, GOTIter It);
1200  void printGlobalGotEntry(uint64_t GotAddr, GOTIter BeginIt, GOTIter It,
1201                           const Elf_Sym *Sym, bool IsDynamic);
1202  void printPLTEntry(uint64_t PLTAddr, GOTIter BeginIt, GOTIter It,
1203                     StringRef Purpose);
1204  void printPLTEntry(uint64_t PLTAddr, GOTIter BeginIt, GOTIter It,
1205                     const Elf_Sym *Sym);
1206};
1207}
1208
1209template <class ELFT>
1210MipsGOTParser<ELFT>::MipsGOTParser(const ObjectFile *Obj, StreamWriter &W)
1211    : Obj(Obj), W(W) {
1212  for (const auto &Entry : Obj->dynamic_table()) {
1213    switch (Entry.getTag()) {
1214    case ELF::DT_PLTGOT:
1215      DtPltGot = Entry.getVal();
1216      break;
1217    case ELF::DT_MIPS_LOCAL_GOTNO:
1218      DtLocalGotNum = Entry.getVal();
1219      break;
1220    case ELF::DT_MIPS_GOTSYM:
1221      DtGotSym = Entry.getVal();
1222      break;
1223    case ELF::DT_MIPS_PLTGOT:
1224      DtMipsPltGot = Entry.getVal();
1225      break;
1226    case ELF::DT_JMPREL:
1227      DtJmpRel = Entry.getVal();
1228      break;
1229    }
1230  }
1231}
1232
1233template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() {
1234  // See "Global Offset Table" in Chapter 5 in the following document
1235  // for detailed GOT description.
1236  // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1237  if (!DtPltGot) {
1238    W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1239    return;
1240  }
1241  if (!DtLocalGotNum) {
1242    W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1243    return;
1244  }
1245  if (!DtGotSym) {
1246    W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1247    return;
1248  }
1249
1250  const Elf_Shdr *GOTShdr = findSectionByAddress(Obj, *DtPltGot);
1251  if (!GOTShdr) {
1252    W.startLine() << "There is no .got section in the file.\n";
1253    return;
1254  }
1255
1256  ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(GOTShdr);
1257  if (!GOT) {
1258    W.startLine() << "The .got section is empty.\n";
1259    return;
1260  }
1261
1262  if (*DtLocalGotNum > getGOTTotal(*GOT)) {
1263    W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n";
1264    return;
1265  }
1266
1267  const Elf_Sym *DynSymBegin = Obj->dynamic_symbol_begin();
1268  const Elf_Sym *DynSymEnd = Obj->dynamic_symbol_end();
1269  std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1270
1271  if (*DtGotSym > DynSymTotal) {
1272    W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n";
1273    return;
1274  }
1275
1276  std::size_t GlobalGotNum = DynSymTotal - *DtGotSym;
1277
1278  if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) {
1279    W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n";
1280    return;
1281  }
1282
1283  GOTIter GotBegin = makeGOTIter(*GOT, 0);
1284  GOTIter GotLocalEnd = makeGOTIter(*GOT, *DtLocalGotNum);
1285  GOTIter It = GotBegin;
1286
1287  DictScope GS(W, "Primary GOT");
1288
1289  W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0);
1290  {
1291    ListScope RS(W, "Reserved entries");
1292
1293    {
1294      DictScope D(W, "Entry");
1295      printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1296      W.printString("Purpose", StringRef("Lazy resolver"));
1297    }
1298
1299    if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
1300      DictScope D(W, "Entry");
1301      printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1302      W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
1303    }
1304  }
1305  {
1306    ListScope LS(W, "Local entries");
1307    for (; It != GotLocalEnd; ++It) {
1308      DictScope D(W, "Entry");
1309      printGotEntry(GOTShdr->sh_addr, GotBegin, It);
1310    }
1311  }
1312  {
1313    ListScope GS(W, "Global entries");
1314
1315    GOTIter GotGlobalEnd = makeGOTIter(*GOT, *DtLocalGotNum + GlobalGotNum);
1316    const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym;
1317    for (; It != GotGlobalEnd; ++It) {
1318      DictScope D(W, "Entry");
1319      printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++, true);
1320    }
1321  }
1322
1323  std::size_t SpecGotNum = getGOTTotal(*GOT) - *DtLocalGotNum - GlobalGotNum;
1324  W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
1325}
1326
1327template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() {
1328  if (!DtMipsPltGot) {
1329    W.startLine() << "Cannot find MIPS_PLTGOT dynamic table tag.\n";
1330    return;
1331  }
1332  if (!DtJmpRel) {
1333    W.startLine() << "Cannot find JMPREL dynamic table tag.\n";
1334    return;
1335  }
1336
1337  const Elf_Shdr *PLTShdr = findSectionByAddress(Obj, *DtMipsPltGot);
1338  if (!PLTShdr) {
1339    W.startLine() << "There is no .got.plt section in the file.\n";
1340    return;
1341  }
1342  ErrorOr<ArrayRef<uint8_t>> PLT = Obj->getSectionContents(PLTShdr);
1343  if (!PLT) {
1344    W.startLine() << "The .got.plt section is empty.\n";
1345    return;
1346  }
1347
1348  const Elf_Shdr *PLTRelShdr = findSectionByAddress(Obj, *DtJmpRel);
1349  if (!PLTShdr) {
1350    W.startLine() << "There is no .rel.plt section in the file.\n";
1351    return;
1352  }
1353
1354  GOTIter PLTBegin = makeGOTIter(*PLT, 0);
1355  GOTIter PLTEnd = makeGOTIter(*PLT, getGOTTotal(*PLT));
1356  GOTIter It = PLTBegin;
1357
1358  DictScope GS(W, "PLT GOT");
1359  {
1360    ListScope RS(W, "Reserved entries");
1361    printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "PLT lazy resolver");
1362    if (It != PLTEnd)
1363      printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "Module pointer");
1364  }
1365  {
1366    ListScope GS(W, "Entries");
1367
1368    switch (PLTRelShdr->sh_type) {
1369    case ELF::SHT_REL:
1370      for (typename ObjectFile::Elf_Rel_Iter RI = Obj->rel_begin(PLTRelShdr),
1371                                             RE = Obj->rel_end(PLTRelShdr);
1372           RI != RE && It != PLTEnd; ++RI, ++It) {
1373        const Elf_Sym *Sym =
1374            Obj->getRelocationSymbol(&*PLTRelShdr, &*RI).second;
1375        printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, Sym);
1376      }
1377      break;
1378    case ELF::SHT_RELA:
1379      for (typename ObjectFile::Elf_Rela_Iter RI = Obj->rela_begin(PLTRelShdr),
1380                                              RE = Obj->rela_end(PLTRelShdr);
1381           RI != RE && It != PLTEnd; ++RI, ++It) {
1382        const Elf_Sym *Sym =
1383            Obj->getRelocationSymbol(&*PLTRelShdr, &*RI).second;
1384        printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, Sym);
1385      }
1386      break;
1387    }
1388  }
1389}
1390
1391template <class ELFT>
1392std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
1393  return GOT.size() / sizeof(GOTEntry);
1394}
1395
1396template <class ELFT>
1397typename MipsGOTParser<ELFT>::GOTIter
1398MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
1399  const char *Data = reinterpret_cast<const char *>(GOT.data());
1400  return GOTIter(sizeof(GOTEntry), Data + EntryNum * sizeof(GOTEntry));
1401}
1402
1403template <class ELFT>
1404void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr, GOTIter BeginIt,
1405                                        GOTIter It) {
1406  int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1407  W.printHex("Address", GotAddr + Offset);
1408  W.printNumber("Access", Offset - 0x7ff0);
1409  W.printHex("Initial", *It);
1410}
1411
1412template <class ELFT>
1413void MipsGOTParser<ELFT>::printGlobalGotEntry(uint64_t GotAddr, GOTIter BeginIt,
1414                                              GOTIter It, const Elf_Sym *Sym,
1415                                              bool IsDynamic) {
1416  printGotEntry(GotAddr, BeginIt, It);
1417
1418  W.printHex("Value", Sym->st_value);
1419  W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1420
1421  unsigned SectionIndex = 0;
1422  StringRef SectionName;
1423  getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1424  W.printHex("Section", SectionName, SectionIndex);
1425
1426  std::string FullSymbolName = getFullSymbolName(*Obj, Sym, IsDynamic);
1427  W.printNumber("Name", FullSymbolName, Sym->st_name);
1428}
1429
1430template <class ELFT>
1431void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr, GOTIter BeginIt,
1432                                        GOTIter It, StringRef Purpose) {
1433  DictScope D(W, "Entry");
1434  int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1435  W.printHex("Address", PLTAddr + Offset);
1436  W.printHex("Initial", *It);
1437  W.printString("Purpose", Purpose);
1438}
1439
1440template <class ELFT>
1441void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr, GOTIter BeginIt,
1442                                        GOTIter It, const Elf_Sym *Sym) {
1443  DictScope D(W, "Entry");
1444  int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1445  W.printHex("Address", PLTAddr + Offset);
1446  W.printHex("Initial", *It);
1447  W.printHex("Value", Sym->st_value);
1448  W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1449
1450  unsigned SectionIndex = 0;
1451  StringRef SectionName;
1452  getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1453  W.printHex("Section", SectionName, SectionIndex);
1454
1455  std::string FullSymbolName = getFullSymbolName(*Obj, Sym, true);
1456  W.printNumber("Name", FullSymbolName, Sym->st_name);
1457}
1458
1459template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
1460  if (Obj->getHeader()->e_machine != EM_MIPS) {
1461    W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
1462    return;
1463  }
1464
1465  MipsGOTParser<ELFT> GOTParser(Obj, W);
1466  GOTParser.parseGOT();
1467  GOTParser.parsePLT();
1468}
1469
1470static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
1471  {"None",                    Mips::AFL_EXT_NONE},
1472  {"Broadcom SB-1",           Mips::AFL_EXT_SB1},
1473  {"Cavium Networks Octeon",  Mips::AFL_EXT_OCTEON},
1474  {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
1475  {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
1476  {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
1477  {"LSI R4010",               Mips::AFL_EXT_4010},
1478  {"Loongson 2E",             Mips::AFL_EXT_LOONGSON_2E},
1479  {"Loongson 2F",             Mips::AFL_EXT_LOONGSON_2F},
1480  {"Loongson 3A",             Mips::AFL_EXT_LOONGSON_3A},
1481  {"MIPS R4650",              Mips::AFL_EXT_4650},
1482  {"MIPS R5900",              Mips::AFL_EXT_5900},
1483  {"MIPS R10000",             Mips::AFL_EXT_10000},
1484  {"NEC VR4100",              Mips::AFL_EXT_4100},
1485  {"NEC VR4111/VR4181",       Mips::AFL_EXT_4111},
1486  {"NEC VR4120",              Mips::AFL_EXT_4120},
1487  {"NEC VR5400",              Mips::AFL_EXT_5400},
1488  {"NEC VR5500",              Mips::AFL_EXT_5500},
1489  {"RMI Xlr",                 Mips::AFL_EXT_XLR},
1490  {"Toshiba R3900",           Mips::AFL_EXT_3900}
1491};
1492
1493static const EnumEntry<unsigned> ElfMipsASEFlags[] = {
1494  {"DSP",                Mips::AFL_ASE_DSP},
1495  {"DSPR2",              Mips::AFL_ASE_DSPR2},
1496  {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
1497  {"MCU",                Mips::AFL_ASE_MCU},
1498  {"MDMX",               Mips::AFL_ASE_MDMX},
1499  {"MIPS-3D",            Mips::AFL_ASE_MIPS3D},
1500  {"MT",                 Mips::AFL_ASE_MT},
1501  {"SmartMIPS",          Mips::AFL_ASE_SMARTMIPS},
1502  {"VZ",                 Mips::AFL_ASE_VIRT},
1503  {"MSA",                Mips::AFL_ASE_MSA},
1504  {"MIPS16",             Mips::AFL_ASE_MIPS16},
1505  {"microMIPS",          Mips::AFL_ASE_MICROMIPS},
1506  {"XPA",                Mips::AFL_ASE_XPA}
1507};
1508
1509static const EnumEntry<unsigned> ElfMipsFpABIType[] = {
1510  {"Hard or soft float",                  Mips::Val_GNU_MIPS_ABI_FP_ANY},
1511  {"Hard float (double precision)",       Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
1512  {"Hard float (single precision)",       Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
1513  {"Soft float",                          Mips::Val_GNU_MIPS_ABI_FP_SOFT},
1514  {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
1515   Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
1516  {"Hard float (32-bit CPU, Any FPU)",    Mips::Val_GNU_MIPS_ABI_FP_XX},
1517  {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
1518  {"Hard float compat (32-bit CPU, 64-bit FPU)",
1519   Mips::Val_GNU_MIPS_ABI_FP_64A}
1520};
1521
1522static const EnumEntry<unsigned> ElfMipsFlags1[] {
1523  {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
1524};
1525
1526static int getMipsRegisterSize(uint8_t Flag) {
1527  switch (Flag) {
1528  case Mips::AFL_REG_NONE:
1529    return 0;
1530  case Mips::AFL_REG_32:
1531    return 32;
1532  case Mips::AFL_REG_64:
1533    return 64;
1534  case Mips::AFL_REG_128:
1535    return 128;
1536  default:
1537    return -1;
1538  }
1539}
1540
1541template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() {
1542  const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags");
1543  if (!Shdr) {
1544    W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
1545    return;
1546  }
1547  ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr);
1548  if (!Sec) {
1549    W.startLine() << "The .MIPS.abiflags section is empty.\n";
1550    return;
1551  }
1552  if (Sec->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
1553    W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
1554    return;
1555  }
1556
1557  auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec->data());
1558
1559  raw_ostream &OS = W.getOStream();
1560  DictScope GS(W, "MIPS ABI Flags");
1561
1562  W.printNumber("Version", Flags->version);
1563  W.startLine() << "ISA: ";
1564  if (Flags->isa_rev <= 1)
1565    OS << format("MIPS%u", Flags->isa_level);
1566  else
1567    OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
1568  OS << "\n";
1569  W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType));
1570  W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
1571  W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
1572  W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
1573  W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
1574  W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
1575  W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
1576  W.printHex("Flags 2", Flags->flags2);
1577}
1578
1579template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
1580  const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo");
1581  if (!Shdr) {
1582    W.startLine() << "There is no .reginfo section in the file.\n";
1583    return;
1584  }
1585  ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr);
1586  if (!Sec) {
1587    W.startLine() << "The .reginfo section is empty.\n";
1588    return;
1589  }
1590  if (Sec->size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
1591    W.startLine() << "The .reginfo section has a wrong size.\n";
1592    return;
1593  }
1594
1595  auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec->data());
1596
1597  DictScope GS(W, "MIPS RegInfo");
1598  W.printHex("GP", Reginfo->ri_gp_value);
1599  W.printHex("General Mask", Reginfo->ri_gprmask);
1600  W.printHex("Co-Proc Mask0", Reginfo->ri_cprmask[0]);
1601  W.printHex("Co-Proc Mask1", Reginfo->ri_cprmask[1]);
1602  W.printHex("Co-Proc Mask2", Reginfo->ri_cprmask[2]);
1603  W.printHex("Co-Proc Mask3", Reginfo->ri_cprmask[3]);
1604}
1605
1606template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
1607  const typename ELFFile<ELFT>::Elf_Shdr *StackMapSection = nullptr;
1608  for (const auto &Sec : Obj->sections()) {
1609    ErrorOr<StringRef> Name = Obj->getSectionName(&Sec);
1610    if (*Name == ".llvm_stackmaps") {
1611      StackMapSection = &Sec;
1612      break;
1613    }
1614  }
1615
1616  if (!StackMapSection)
1617    return;
1618
1619  StringRef StackMapContents;
1620  ErrorOr<ArrayRef<uint8_t>> StackMapContentsArray =
1621    Obj->getSectionContents(StackMapSection);
1622
1623  prettyPrintStackMap(
1624              llvm::outs(),
1625              StackMapV1Parser<ELFT::TargetEndianness>(*StackMapContentsArray));
1626}
1627