ELFDumper.cpp revision ebe69fe11e48d322045d5949c83283927a0d790b 
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 "StreamWriter.h"
21#include "llvm/ADT/Optional.h"
22#include "llvm/ADT/SmallString.h"
23#include "llvm/ADT/StringExtras.h"
24#include "llvm/Object/ELFObjectFile.h"
25#include "llvm/Support/ARMBuildAttributes.h"
26#include "llvm/Support/Compiler.h"
27#include "llvm/Support/Format.h"
28#include "llvm/Support/MathExtras.h"
29#include "llvm/Support/raw_ostream.h"
30
31using namespace llvm;
32using namespace llvm::object;
33using namespace ELF;
34
35#define LLVM_READOBJ_ENUM_CASE(ns, enum) \
36  case ns::enum: return #enum;
37
38namespace {
39
40template<typename ELFT>
41class ELFDumper : public ObjDumper {
42public:
43  ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
44      : ObjDumper(Writer), Obj(Obj) {}
45
46  void printFileHeaders() override;
47  void printSections() override;
48  void printRelocations() override;
49  void printSymbols() override;
50  void printDynamicSymbols() override;
51  void printUnwindInfo() override;
52
53  void printDynamicTable() override;
54  void printNeededLibraries() override;
55  void printProgramHeaders() override;
56
57  void printAttributes() override;
58  void printMipsPLTGOT() override;
59
60private:
61  typedef ELFFile<ELFT> ELFO;
62  typedef typename ELFO::Elf_Shdr Elf_Shdr;
63  typedef typename ELFO::Elf_Sym Elf_Sym;
64
65  void printSymbol(typename ELFO::Elf_Sym_Iter Symbol);
66
67  void printRelocations(const Elf_Shdr *Sec);
68  void printRelocation(const Elf_Shdr *Sec, typename ELFO::Elf_Rela Rel);
69
70  const ELFO *Obj;
71};
72
73template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) {
74  if (!Val) {
75    error(Val.getError());
76    return Default;
77  }
78
79  return *Val;
80}
81} // namespace
82
83namespace llvm {
84
85template <class ELFT>
86static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
87                                       StreamWriter &Writer,
88                                       std::unique_ptr<ObjDumper> &Result) {
89  Result.reset(new ELFDumper<ELFT>(Obj, Writer));
90  return readobj_error::success;
91}
92
93std::error_code createELFDumper(const object::ObjectFile *Obj,
94                                StreamWriter &Writer,
95                                std::unique_ptr<ObjDumper> &Result) {
96  // Little-endian 32-bit
97  if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
98    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
99
100  // Big-endian 32-bit
101  if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
102    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
103
104  // Little-endian 64-bit
105  if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
106    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
107
108  // Big-endian 64-bit
109  if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
110    return createELFDumper(ELFObj->getELFFile(), Writer, Result);
111
112  return readobj_error::unsupported_obj_file_format;
113}
114
115} // namespace llvm
116
117template <typename ELFO>
118static std::string getFullSymbolName(const ELFO &Obj,
119                                     typename ELFO::Elf_Sym_Iter Symbol) {
120  StringRef SymbolName = errorOrDefault(Obj.getSymbolName(Symbol));
121  if (!Symbol.isDynamic())
122    return SymbolName;
123
124  std::string FullSymbolName(SymbolName);
125
126  bool IsDefault;
127  ErrorOr<StringRef> Version =
128      Obj.getSymbolVersion(nullptr, &*Symbol, IsDefault);
129  if (Version) {
130    FullSymbolName += (IsDefault ? "@@" : "@");
131    FullSymbolName += *Version;
132  } else
133    error(Version.getError());
134  return FullSymbolName;
135}
136
137template <typename ELFO>
138static void
139getSectionNameIndex(const ELFO &Obj, typename ELFO::Elf_Sym_Iter Symbol,
140                    StringRef &SectionName, unsigned &SectionIndex) {
141  SectionIndex = Symbol->st_shndx;
142  if (SectionIndex == SHN_UNDEF) {
143    SectionName = "Undefined";
144  } else if (SectionIndex >= SHN_LOPROC && SectionIndex <= SHN_HIPROC) {
145    SectionName = "Processor Specific";
146  } else if (SectionIndex >= SHN_LOOS && SectionIndex <= SHN_HIOS) {
147    SectionName = "Operating System Specific";
148  } else if (SectionIndex > SHN_HIOS && SectionIndex < SHN_ABS) {
149    SectionName = "Reserved";
150  } else if (SectionIndex == SHN_ABS) {
151    SectionName = "Absolute";
152  } else if (SectionIndex == SHN_COMMON) {
153    SectionName = "Common";
154  } else {
155    if (SectionIndex == SHN_XINDEX)
156      SectionIndex = Obj.getSymbolTableIndex(&*Symbol);
157    assert(SectionIndex != SHN_XINDEX &&
158           "getSymbolTableIndex should handle this");
159    const typename ELFO::Elf_Shdr *Sec = Obj.getSection(SectionIndex);
160    SectionName = errorOrDefault(Obj.getSectionName(Sec));
161  }
162}
163
164template <class ELFT>
165static const typename ELFFile<ELFT>::Elf_Shdr *
166findSectionByAddress(const ELFFile<ELFT> *Obj, uint64_t Addr) {
167  for (const auto &Shdr : Obj->sections())
168    if (Shdr.sh_addr == Addr)
169      return &Shdr;
170  return nullptr;
171}
172
173static const EnumEntry<unsigned> ElfClass[] = {
174  { "None",   ELF::ELFCLASSNONE },
175  { "32-bit", ELF::ELFCLASS32   },
176  { "64-bit", ELF::ELFCLASS64   },
177};
178
179static const EnumEntry<unsigned> ElfDataEncoding[] = {
180  { "None",         ELF::ELFDATANONE },
181  { "LittleEndian", ELF::ELFDATA2LSB },
182  { "BigEndian",    ELF::ELFDATA2MSB },
183};
184
185static const EnumEntry<unsigned> ElfObjectFileType[] = {
186  { "None",         ELF::ET_NONE },
187  { "Relocatable",  ELF::ET_REL  },
188  { "Executable",   ELF::ET_EXEC },
189  { "SharedObject", ELF::ET_DYN  },
190  { "Core",         ELF::ET_CORE },
191};
192
193static const EnumEntry<unsigned> ElfOSABI[] = {
194  { "SystemV",      ELF::ELFOSABI_NONE         },
195  { "HPUX",         ELF::ELFOSABI_HPUX         },
196  { "NetBSD",       ELF::ELFOSABI_NETBSD       },
197  { "GNU/Linux",    ELF::ELFOSABI_LINUX        },
198  { "GNU/Hurd",     ELF::ELFOSABI_HURD         },
199  { "Solaris",      ELF::ELFOSABI_SOLARIS      },
200  { "AIX",          ELF::ELFOSABI_AIX          },
201  { "IRIX",         ELF::ELFOSABI_IRIX         },
202  { "FreeBSD",      ELF::ELFOSABI_FREEBSD      },
203  { "TRU64",        ELF::ELFOSABI_TRU64        },
204  { "Modesto",      ELF::ELFOSABI_MODESTO      },
205  { "OpenBSD",      ELF::ELFOSABI_OPENBSD      },
206  { "OpenVMS",      ELF::ELFOSABI_OPENVMS      },
207  { "NSK",          ELF::ELFOSABI_NSK          },
208  { "AROS",         ELF::ELFOSABI_AROS         },
209  { "FenixOS",      ELF::ELFOSABI_FENIXOS      },
210  { "C6000_ELFABI", ELF::ELFOSABI_C6000_ELFABI },
211  { "C6000_LINUX" , ELF::ELFOSABI_C6000_LINUX  },
212  { "ARM",          ELF::ELFOSABI_ARM          },
213  { "Standalone"  , ELF::ELFOSABI_STANDALONE   }
214};
215
216static const EnumEntry<unsigned> ElfMachineType[] = {
217  LLVM_READOBJ_ENUM_ENT(ELF, EM_NONE         ),
218  LLVM_READOBJ_ENUM_ENT(ELF, EM_M32          ),
219  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC        ),
220  LLVM_READOBJ_ENUM_ENT(ELF, EM_386          ),
221  LLVM_READOBJ_ENUM_ENT(ELF, EM_68K          ),
222  LLVM_READOBJ_ENUM_ENT(ELF, EM_88K          ),
223  LLVM_READOBJ_ENUM_ENT(ELF, EM_486          ),
224  LLVM_READOBJ_ENUM_ENT(ELF, EM_860          ),
225  LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS         ),
226  LLVM_READOBJ_ENUM_ENT(ELF, EM_S370         ),
227  LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_RS3_LE  ),
228  LLVM_READOBJ_ENUM_ENT(ELF, EM_PARISC       ),
229  LLVM_READOBJ_ENUM_ENT(ELF, EM_VPP500       ),
230  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC32PLUS  ),
231  LLVM_READOBJ_ENUM_ENT(ELF, EM_960          ),
232  LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC          ),
233  LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC64        ),
234  LLVM_READOBJ_ENUM_ENT(ELF, EM_S390         ),
235  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPU          ),
236  LLVM_READOBJ_ENUM_ENT(ELF, EM_V800         ),
237  LLVM_READOBJ_ENUM_ENT(ELF, EM_FR20         ),
238  LLVM_READOBJ_ENUM_ENT(ELF, EM_RH32         ),
239  LLVM_READOBJ_ENUM_ENT(ELF, EM_RCE          ),
240  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARM          ),
241  LLVM_READOBJ_ENUM_ENT(ELF, EM_ALPHA        ),
242  LLVM_READOBJ_ENUM_ENT(ELF, EM_SH           ),
243  LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARCV9      ),
244  LLVM_READOBJ_ENUM_ENT(ELF, EM_TRICORE      ),
245  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC          ),
246  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300       ),
247  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300H      ),
248  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8S          ),
249  LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_500       ),
250  LLVM_READOBJ_ENUM_ENT(ELF, EM_IA_64        ),
251  LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_X       ),
252  LLVM_READOBJ_ENUM_ENT(ELF, EM_COLDFIRE     ),
253  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC12       ),
254  LLVM_READOBJ_ENUM_ENT(ELF, EM_MMA          ),
255  LLVM_READOBJ_ENUM_ENT(ELF, EM_PCP          ),
256  LLVM_READOBJ_ENUM_ENT(ELF, EM_NCPU         ),
257  LLVM_READOBJ_ENUM_ENT(ELF, EM_NDR1         ),
258  LLVM_READOBJ_ENUM_ENT(ELF, EM_STARCORE     ),
259  LLVM_READOBJ_ENUM_ENT(ELF, EM_ME16         ),
260  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST100        ),
261  LLVM_READOBJ_ENUM_ENT(ELF, EM_TINYJ        ),
262  LLVM_READOBJ_ENUM_ENT(ELF, EM_X86_64       ),
263  LLVM_READOBJ_ENUM_ENT(ELF, EM_PDSP         ),
264  LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP10        ),
265  LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP11        ),
266  LLVM_READOBJ_ENUM_ENT(ELF, EM_FX66         ),
267  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST9PLUS      ),
268  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST7          ),
269  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC16       ),
270  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC11       ),
271  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC08       ),
272  LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC05       ),
273  LLVM_READOBJ_ENUM_ENT(ELF, EM_SVX          ),
274  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST19         ),
275  LLVM_READOBJ_ENUM_ENT(ELF, EM_VAX          ),
276  LLVM_READOBJ_ENUM_ENT(ELF, EM_CRIS         ),
277  LLVM_READOBJ_ENUM_ENT(ELF, EM_JAVELIN      ),
278  LLVM_READOBJ_ENUM_ENT(ELF, EM_FIREPATH     ),
279  LLVM_READOBJ_ENUM_ENT(ELF, EM_ZSP          ),
280  LLVM_READOBJ_ENUM_ENT(ELF, EM_MMIX         ),
281  LLVM_READOBJ_ENUM_ENT(ELF, EM_HUANY        ),
282  LLVM_READOBJ_ENUM_ENT(ELF, EM_PRISM        ),
283  LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR          ),
284  LLVM_READOBJ_ENUM_ENT(ELF, EM_FR30         ),
285  LLVM_READOBJ_ENUM_ENT(ELF, EM_D10V         ),
286  LLVM_READOBJ_ENUM_ENT(ELF, EM_D30V         ),
287  LLVM_READOBJ_ENUM_ENT(ELF, EM_V850         ),
288  LLVM_READOBJ_ENUM_ENT(ELF, EM_M32R         ),
289  LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10300      ),
290  LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10200      ),
291  LLVM_READOBJ_ENUM_ENT(ELF, EM_PJ           ),
292  LLVM_READOBJ_ENUM_ENT(ELF, EM_OPENRISC     ),
293  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT  ),
294  LLVM_READOBJ_ENUM_ENT(ELF, EM_XTENSA       ),
295  LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE    ),
296  LLVM_READOBJ_ENUM_ENT(ELF, EM_TMM_GPP      ),
297  LLVM_READOBJ_ENUM_ENT(ELF, EM_NS32K        ),
298  LLVM_READOBJ_ENUM_ENT(ELF, EM_TPC          ),
299  LLVM_READOBJ_ENUM_ENT(ELF, EM_SNP1K        ),
300  LLVM_READOBJ_ENUM_ENT(ELF, EM_ST200        ),
301  LLVM_READOBJ_ENUM_ENT(ELF, EM_IP2K         ),
302  LLVM_READOBJ_ENUM_ENT(ELF, EM_MAX          ),
303  LLVM_READOBJ_ENUM_ENT(ELF, EM_CR           ),
304  LLVM_READOBJ_ENUM_ENT(ELF, EM_F2MC16       ),
305  LLVM_READOBJ_ENUM_ENT(ELF, EM_MSP430       ),
306  LLVM_READOBJ_ENUM_ENT(ELF, EM_BLACKFIN     ),
307  LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C33       ),
308  LLVM_READOBJ_ENUM_ENT(ELF, EM_SEP          ),
309  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARCA         ),
310  LLVM_READOBJ_ENUM_ENT(ELF, EM_UNICORE      ),
311  LLVM_READOBJ_ENUM_ENT(ELF, EM_EXCESS       ),
312  LLVM_READOBJ_ENUM_ENT(ELF, EM_DXP          ),
313  LLVM_READOBJ_ENUM_ENT(ELF, EM_ALTERA_NIOS2 ),
314  LLVM_READOBJ_ENUM_ENT(ELF, EM_CRX          ),
315  LLVM_READOBJ_ENUM_ENT(ELF, EM_XGATE        ),
316  LLVM_READOBJ_ENUM_ENT(ELF, EM_C166         ),
317  LLVM_READOBJ_ENUM_ENT(ELF, EM_M16C         ),
318  LLVM_READOBJ_ENUM_ENT(ELF, EM_DSPIC30F     ),
319  LLVM_READOBJ_ENUM_ENT(ELF, EM_CE           ),
320  LLVM_READOBJ_ENUM_ENT(ELF, EM_M32C         ),
321  LLVM_READOBJ_ENUM_ENT(ELF, EM_TSK3000      ),
322  LLVM_READOBJ_ENUM_ENT(ELF, EM_RS08         ),
323  LLVM_READOBJ_ENUM_ENT(ELF, EM_SHARC        ),
324  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG2        ),
325  LLVM_READOBJ_ENUM_ENT(ELF, EM_SCORE7       ),
326  LLVM_READOBJ_ENUM_ENT(ELF, EM_DSP24        ),
327  LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE3   ),
328  LLVM_READOBJ_ENUM_ENT(ELF, EM_LATTICEMICO32),
329  LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17       ),
330  LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000     ),
331  LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000     ),
332  LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500     ),
333  LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS   ),
334  LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C  ),
335  LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C         ),
336  LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA     ),
337  LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON      ),
338  LLVM_READOBJ_ENUM_ENT(ELF, EM_8051         ),
339  LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X       ),
340  LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32        ),
341  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1        ),
342  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X       ),
343  LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30       ),
344  LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16       ),
345  LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK        ),
346  LLVM_READOBJ_ENUM_ENT(ELF, EM_CRAYNV2      ),
347  LLVM_READOBJ_ENUM_ENT(ELF, EM_RX           ),
348  LLVM_READOBJ_ENUM_ENT(ELF, EM_METAG        ),
349  LLVM_READOBJ_ENUM_ENT(ELF, EM_MCST_ELBRUS  ),
350  LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG16       ),
351  LLVM_READOBJ_ENUM_ENT(ELF, EM_CR16         ),
352  LLVM_READOBJ_ENUM_ENT(ELF, EM_ETPU         ),
353  LLVM_READOBJ_ENUM_ENT(ELF, EM_SLE9X        ),
354  LLVM_READOBJ_ENUM_ENT(ELF, EM_L10M         ),
355  LLVM_READOBJ_ENUM_ENT(ELF, EM_K10M         ),
356  LLVM_READOBJ_ENUM_ENT(ELF, EM_AARCH64      ),
357  LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR32        ),
358  LLVM_READOBJ_ENUM_ENT(ELF, EM_STM8         ),
359  LLVM_READOBJ_ENUM_ENT(ELF, EM_TILE64       ),
360  LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEPRO      ),
361  LLVM_READOBJ_ENUM_ENT(ELF, EM_CUDA         ),
362  LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEGX       ),
363  LLVM_READOBJ_ENUM_ENT(ELF, EM_CLOUDSHIELD  ),
364  LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_1ST    ),
365  LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_2ND    ),
366  LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT2 ),
367  LLVM_READOBJ_ENUM_ENT(ELF, EM_OPEN8        ),
368  LLVM_READOBJ_ENUM_ENT(ELF, EM_RL78         ),
369  LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE5   ),
370  LLVM_READOBJ_ENUM_ENT(ELF, EM_78KOR        ),
371  LLVM_READOBJ_ENUM_ENT(ELF, EM_56800EX      )
372};
373
374static const EnumEntry<unsigned> ElfSymbolBindings[] = {
375  { "Local",  ELF::STB_LOCAL        },
376  { "Global", ELF::STB_GLOBAL       },
377  { "Weak",   ELF::STB_WEAK         },
378  { "Unique", ELF::STB_GNU_UNIQUE   }
379};
380
381static const EnumEntry<unsigned> ElfSymbolTypes[] = {
382  { "None",      ELF::STT_NOTYPE    },
383  { "Object",    ELF::STT_OBJECT    },
384  { "Function",  ELF::STT_FUNC      },
385  { "Section",   ELF::STT_SECTION   },
386  { "File",      ELF::STT_FILE      },
387  { "Common",    ELF::STT_COMMON    },
388  { "TLS",       ELF::STT_TLS       },
389  { "GNU_IFunc", ELF::STT_GNU_IFUNC }
390};
391
392static const char *getElfSectionType(unsigned Arch, unsigned Type) {
393  switch (Arch) {
394  case ELF::EM_ARM:
395    switch (Type) {
396    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
397    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
398    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
399    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
400    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
401    }
402  case ELF::EM_HEXAGON:
403    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
404  case ELF::EM_X86_64:
405    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
406  case ELF::EM_MIPS:
407  case ELF::EM_MIPS_RS3_LE:
408    switch (Type) {
409    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
410    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
411    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
412    }
413  }
414
415  switch (Type) {
416  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL              );
417  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS          );
418  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB            );
419  LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB            );
420  LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA              );
421  LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH              );
422  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC           );
423  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE              );
424  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS            );
425  LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL               );
426  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB             );
427  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM            );
428  LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY        );
429  LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY        );
430  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY     );
431  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP             );
432  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX      );
433  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES    );
434  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
435  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
436  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
437  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
438  default: return "";
439  }
440}
441
442static const EnumEntry<unsigned> ElfSectionFlags[] = {
443  LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE           ),
444  LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC           ),
445  LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE         ),
446  LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR       ),
447  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE           ),
448  LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS         ),
449  LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK       ),
450  LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER      ),
451  LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING),
452  LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP           ),
453  LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS             ),
454  LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
455  LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION),
456  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP    )
457};
458
459static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
460  // Check potentially overlapped processor-specific
461  // program header type.
462  switch (Arch) {
463  case ELF::EM_ARM:
464    switch (Type) {
465    LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
466    }
467  case ELF::EM_MIPS:
468  case ELF::EM_MIPS_RS3_LE:
469    switch (Type) {
470    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
471    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
472    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
473    }
474  }
475
476  switch (Type) {
477  LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL   );
478  LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD   );
479  LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
480  LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
481  LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE   );
482  LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB  );
483  LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR   );
484  LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS    );
485
486  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
487  LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
488
489  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
490  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
491  default: return "";
492  }
493}
494
495static const EnumEntry<unsigned> ElfSegmentFlags[] = {
496  LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
497  LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
498  LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
499};
500
501static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
502  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
503  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
504  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
505  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
506  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
507  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
508  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
509  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
510  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
511  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
512  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
513  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
514  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
515  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
516  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
517  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
518  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
519  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
520  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
521  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
522};
523
524template<class ELFT>
525void ELFDumper<ELFT>::printFileHeaders() {
526  const typename ELFO::Elf_Ehdr *Header = Obj->getHeader();
527
528  {
529    DictScope D(W, "ElfHeader");
530    {
531      DictScope D(W, "Ident");
532      W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0,
533                                                                 4));
534      W.printEnum  ("Class", Header->e_ident[ELF::EI_CLASS],
535                      makeArrayRef(ElfClass));
536      W.printEnum  ("DataEncoding", Header->e_ident[ELF::EI_DATA],
537                      makeArrayRef(ElfDataEncoding));
538      W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]);
539      W.printEnum  ("OS/ABI", Header->e_ident[ELF::EI_OSABI],
540                      makeArrayRef(ElfOSABI));
541      W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]);
542      W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD));
543    }
544
545    W.printEnum  ("Type", Header->e_type, makeArrayRef(ElfObjectFileType));
546    W.printEnum  ("Machine", Header->e_machine, makeArrayRef(ElfMachineType));
547    W.printNumber("Version", Header->e_version);
548    W.printHex   ("Entry", Header->e_entry);
549    W.printHex   ("ProgramHeaderOffset", Header->e_phoff);
550    W.printHex   ("SectionHeaderOffset", Header->e_shoff);
551    if (Header->e_machine == EM_MIPS)
552      W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags),
553                   unsigned(ELF::EF_MIPS_ARCH));
554    else
555      W.printFlags("Flags", Header->e_flags);
556    W.printNumber("HeaderSize", Header->e_ehsize);
557    W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize);
558    W.printNumber("ProgramHeaderCount", Header->e_phnum);
559    W.printNumber("SectionHeaderEntrySize", Header->e_shentsize);
560    W.printNumber("SectionHeaderCount", Header->e_shnum);
561    W.printNumber("StringTableSectionIndex", Header->e_shstrndx);
562  }
563}
564
565template<class ELFT>
566void ELFDumper<ELFT>::printSections() {
567  ListScope SectionsD(W, "Sections");
568
569  int SectionIndex = -1;
570  for (typename ELFO::Elf_Shdr_Iter SecI = Obj->begin_sections(),
571                                    SecE = Obj->end_sections();
572       SecI != SecE; ++SecI) {
573    ++SectionIndex;
574
575    const Elf_Shdr *Section = &*SecI;
576    StringRef Name = errorOrDefault(Obj->getSectionName(Section));
577
578    DictScope SectionD(W, "Section");
579    W.printNumber("Index", SectionIndex);
580    W.printNumber("Name", Name, Section->sh_name);
581    W.printHex("Type",
582               getElfSectionType(Obj->getHeader()->e_machine, Section->sh_type),
583               Section->sh_type);
584    W.printFlags ("Flags", Section->sh_flags, makeArrayRef(ElfSectionFlags));
585    W.printHex   ("Address", Section->sh_addr);
586    W.printHex   ("Offset", Section->sh_offset);
587    W.printNumber("Size", Section->sh_size);
588    W.printNumber("Link", Section->sh_link);
589    W.printNumber("Info", Section->sh_info);
590    W.printNumber("AddressAlignment", Section->sh_addralign);
591    W.printNumber("EntrySize", Section->sh_entsize);
592
593    if (opts::SectionRelocations) {
594      ListScope D(W, "Relocations");
595      printRelocations(Section);
596    }
597
598    if (opts::SectionSymbols) {
599      ListScope D(W, "Symbols");
600      for (typename ELFO::Elf_Sym_Iter SymI = Obj->begin_symbols(),
601                                       SymE = Obj->end_symbols();
602           SymI != SymE; ++SymI) {
603        if (Obj->getSection(&*SymI) == Section)
604          printSymbol(SymI);
605      }
606    }
607
608    if (opts::SectionData && Section->sh_type != ELF::SHT_NOBITS) {
609      ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(Section));
610      W.printBinaryBlock("SectionData",
611                         StringRef((const char *)Data.data(), Data.size()));
612    }
613  }
614}
615
616template<class ELFT>
617void ELFDumper<ELFT>::printRelocations() {
618  ListScope D(W, "Relocations");
619
620  int SectionNumber = -1;
621  for (typename ELFO::Elf_Shdr_Iter SecI = Obj->begin_sections(),
622                                    SecE = Obj->end_sections();
623       SecI != SecE; ++SecI) {
624    ++SectionNumber;
625
626    if (SecI->sh_type != ELF::SHT_REL && SecI->sh_type != ELF::SHT_RELA)
627      continue;
628
629    StringRef Name = errorOrDefault(Obj->getSectionName(&*SecI));
630
631    W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
632    W.indent();
633
634    printRelocations(&*SecI);
635
636    W.unindent();
637    W.startLine() << "}\n";
638  }
639}
640
641template <class ELFT>
642void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
643  switch (Sec->sh_type) {
644  case ELF::SHT_REL:
645    for (typename ELFO::Elf_Rel_Iter RI = Obj->begin_rel(Sec),
646                                     RE = Obj->end_rel(Sec);
647         RI != RE; ++RI) {
648      typename ELFO::Elf_Rela Rela;
649      Rela.r_offset = RI->r_offset;
650      Rela.r_info = RI->r_info;
651      Rela.r_addend = 0;
652      printRelocation(Sec, Rela);
653    }
654    break;
655  case ELF::SHT_RELA:
656    for (typename ELFO::Elf_Rela_Iter RI = Obj->begin_rela(Sec),
657                                      RE = Obj->end_rela(Sec);
658         RI != RE; ++RI) {
659      printRelocation(Sec, *RI);
660    }
661    break;
662  }
663}
664
665template <class ELFT>
666void ELFDumper<ELFT>::printRelocation(const Elf_Shdr *Sec,
667                                      typename ELFO::Elf_Rela Rel) {
668  SmallString<32> RelocName;
669  Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
670  StringRef SymbolName;
671  std::pair<const Elf_Shdr *, const Elf_Sym *> Sym =
672      Obj->getRelocationSymbol(Sec, &Rel);
673  if (Sym.first)
674    SymbolName = errorOrDefault(Obj->getSymbolName(Sym.first, Sym.second));
675
676  if (opts::ExpandRelocs) {
677    DictScope Group(W, "Relocation");
678    W.printHex("Offset", Rel.r_offset);
679    W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
680    W.printNumber("Symbol", SymbolName.size() > 0 ? SymbolName : "-",
681                  Rel.getSymbol(Obj->isMips64EL()));
682    W.printHex("Addend", Rel.r_addend);
683  } else {
684    raw_ostream& OS = W.startLine();
685    OS << W.hex(Rel.r_offset)
686       << " " << RelocName
687       << " " << (SymbolName.size() > 0 ? SymbolName : "-")
688       << " " << W.hex(Rel.r_addend)
689       << "\n";
690  }
691}
692
693template<class ELFT>
694void ELFDumper<ELFT>::printSymbols() {
695  ListScope Group(W, "Symbols");
696  for (typename ELFO::Elf_Sym_Iter SymI = Obj->begin_symbols(),
697                                   SymE = Obj->end_symbols();
698       SymI != SymE; ++SymI) {
699    printSymbol(SymI);
700  }
701}
702
703template<class ELFT>
704void ELFDumper<ELFT>::printDynamicSymbols() {
705  ListScope Group(W, "DynamicSymbols");
706
707  for (typename ELFO::Elf_Sym_Iter SymI = Obj->begin_dynamic_symbols(),
708                                   SymE = Obj->end_dynamic_symbols();
709       SymI != SymE; ++SymI) {
710    printSymbol(SymI);
711  }
712}
713
714template <class ELFT>
715void ELFDumper<ELFT>::printSymbol(typename ELFO::Elf_Sym_Iter Symbol) {
716  unsigned SectionIndex = 0;
717  StringRef SectionName;
718  getSectionNameIndex(*Obj, Symbol, SectionName, SectionIndex);
719  std::string FullSymbolName = getFullSymbolName(*Obj, Symbol);
720
721  DictScope D(W, "Symbol");
722  W.printNumber("Name", FullSymbolName, Symbol->st_name);
723  W.printHex   ("Value", Symbol->st_value);
724  W.printNumber("Size", Symbol->st_size);
725  W.printEnum  ("Binding", Symbol->getBinding(),
726                  makeArrayRef(ElfSymbolBindings));
727  W.printEnum  ("Type", Symbol->getType(), makeArrayRef(ElfSymbolTypes));
728  W.printNumber("Other", Symbol->st_other);
729  W.printHex("Section", SectionName, SectionIndex);
730}
731
732#define LLVM_READOBJ_TYPE_CASE(name) \
733  case DT_##name: return #name
734
735static const char *getTypeString(uint64_t Type) {
736  switch (Type) {
737  LLVM_READOBJ_TYPE_CASE(BIND_NOW);
738  LLVM_READOBJ_TYPE_CASE(DEBUG);
739  LLVM_READOBJ_TYPE_CASE(FINI);
740  LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
741  LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
742  LLVM_READOBJ_TYPE_CASE(FLAGS);
743  LLVM_READOBJ_TYPE_CASE(HASH);
744  LLVM_READOBJ_TYPE_CASE(INIT);
745  LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
746  LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
747  LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
748  LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
749  LLVM_READOBJ_TYPE_CASE(JMPREL);
750  LLVM_READOBJ_TYPE_CASE(NEEDED);
751  LLVM_READOBJ_TYPE_CASE(NULL);
752  LLVM_READOBJ_TYPE_CASE(PLTGOT);
753  LLVM_READOBJ_TYPE_CASE(PLTREL);
754  LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
755  LLVM_READOBJ_TYPE_CASE(REL);
756  LLVM_READOBJ_TYPE_CASE(RELA);
757  LLVM_READOBJ_TYPE_CASE(RELENT);
758  LLVM_READOBJ_TYPE_CASE(RELSZ);
759  LLVM_READOBJ_TYPE_CASE(RELAENT);
760  LLVM_READOBJ_TYPE_CASE(RELASZ);
761  LLVM_READOBJ_TYPE_CASE(RPATH);
762  LLVM_READOBJ_TYPE_CASE(RUNPATH);
763  LLVM_READOBJ_TYPE_CASE(SONAME);
764  LLVM_READOBJ_TYPE_CASE(STRSZ);
765  LLVM_READOBJ_TYPE_CASE(STRTAB);
766  LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
767  LLVM_READOBJ_TYPE_CASE(SYMENT);
768  LLVM_READOBJ_TYPE_CASE(SYMTAB);
769  LLVM_READOBJ_TYPE_CASE(TEXTREL);
770  LLVM_READOBJ_TYPE_CASE(VERNEED);
771  LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
772  LLVM_READOBJ_TYPE_CASE(VERSYM);
773  LLVM_READOBJ_TYPE_CASE(RELCOUNT);
774  LLVM_READOBJ_TYPE_CASE(GNU_HASH);
775  LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
776  LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
777  LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
778  LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
779  LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
780  LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
781  LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
782  LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
783  LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
784  default: return "unknown";
785  }
786}
787
788#undef LLVM_READOBJ_TYPE_CASE
789
790#define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
791  { #enum, prefix##_##enum }
792
793static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
794  LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
795  LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
796  LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
797  LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
798  LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
799};
800
801static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
802  LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
803  LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
804  LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
805  LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
806  LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
807  LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
808  LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
809  LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
810  LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
811  LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
812  LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
813  LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
814  LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
815  LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
816  LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
817  LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
818};
819
820#undef LLVM_READOBJ_DT_FLAG_ENT
821
822template <typename T, typename TFlag>
823void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
824  typedef EnumEntry<TFlag> FlagEntry;
825  typedef SmallVector<FlagEntry, 10> FlagVector;
826  FlagVector SetFlags;
827
828  for (const auto &Flag : Flags) {
829    if (Flag.Value == 0)
830      continue;
831
832    if ((Value & Flag.Value) == Flag.Value)
833      SetFlags.push_back(Flag);
834  }
835
836  for (const auto &Flag : SetFlags) {
837    OS << Flag.Name << " ";
838  }
839}
840
841template <class ELFT>
842static void printValue(const ELFFile<ELFT> *O, uint64_t Type, uint64_t Value,
843                       bool Is64, raw_ostream &OS) {
844  switch (Type) {
845  case DT_PLTREL:
846    if (Value == DT_REL) {
847      OS << "REL";
848      break;
849    } else if (Value == DT_RELA) {
850      OS << "RELA";
851      break;
852    }
853  // Fallthrough.
854  case DT_PLTGOT:
855  case DT_HASH:
856  case DT_STRTAB:
857  case DT_SYMTAB:
858  case DT_RELA:
859  case DT_INIT:
860  case DT_FINI:
861  case DT_REL:
862  case DT_JMPREL:
863  case DT_INIT_ARRAY:
864  case DT_FINI_ARRAY:
865  case DT_PREINIT_ARRAY:
866  case DT_DEBUG:
867  case DT_VERNEED:
868  case DT_VERSYM:
869  case DT_GNU_HASH:
870  case DT_NULL:
871  case DT_MIPS_BASE_ADDRESS:
872  case DT_MIPS_GOTSYM:
873  case DT_MIPS_RLD_MAP:
874  case DT_MIPS_PLTGOT:
875    OS << format("0x%" PRIX64, Value);
876    break;
877  case DT_RELCOUNT:
878  case DT_VERNEEDNUM:
879  case DT_MIPS_RLD_VERSION:
880  case DT_MIPS_LOCAL_GOTNO:
881  case DT_MIPS_SYMTABNO:
882  case DT_MIPS_UNREFEXTNO:
883    OS << Value;
884    break;
885  case DT_PLTRELSZ:
886  case DT_RELASZ:
887  case DT_RELAENT:
888  case DT_STRSZ:
889  case DT_SYMENT:
890  case DT_RELSZ:
891  case DT_RELENT:
892  case DT_INIT_ARRAYSZ:
893  case DT_FINI_ARRAYSZ:
894  case DT_PREINIT_ARRAYSZ:
895    OS << Value << " (bytes)";
896    break;
897  case DT_NEEDED:
898    OS << "SharedLibrary (" << O->getDynamicString(Value) << ")";
899    break;
900  case DT_SONAME:
901    OS << "LibrarySoname (" << O->getDynamicString(Value) << ")";
902    break;
903  case DT_RPATH:
904  case DT_RUNPATH:
905    OS << O->getDynamicString(Value);
906    break;
907  case DT_MIPS_FLAGS:
908    printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
909    break;
910  case DT_FLAGS:
911    printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
912    break;
913  }
914}
915
916template<class ELFT>
917void ELFDumper<ELFT>::printUnwindInfo() {
918  W.startLine() << "UnwindInfo not implemented.\n";
919}
920
921namespace {
922template <>
923void ELFDumper<ELFType<support::little, 2, false> >::printUnwindInfo() {
924  const unsigned Machine = Obj->getHeader()->e_machine;
925  if (Machine == EM_ARM) {
926    ARM::EHABI::PrinterContext<ELFType<support::little, 2, false> > Ctx(W, Obj);
927    return Ctx.PrintUnwindInformation();
928  }
929  W.startLine() << "UnwindInfo not implemented.\n";
930}
931}
932
933template<class ELFT>
934void ELFDumper<ELFT>::printDynamicTable() {
935  auto DynTable = Obj->dynamic_table(true);
936
937  ptrdiff_t Total = std::distance(DynTable.begin(), DynTable.end());
938  if (Total == 0)
939    return;
940
941  raw_ostream &OS = W.getOStream();
942  W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
943
944  bool Is64 = ELFT::Is64Bits;
945
946  W.startLine()
947     << "  Tag" << (Is64 ? "                " : "        ") << "Type"
948     << "                 " << "Name/Value\n";
949  for (const auto &Entry : DynTable) {
950    W.startLine()
951       << "  "
952       << format(Is64 ? "0x%016" PRIX64 : "0x%08" PRIX64, Entry.getTag())
953       << " " << format("%-21s", getTypeString(Entry.getTag()));
954    printValue(Obj, Entry.getTag(), Entry.getVal(), Is64, OS);
955    OS << "\n";
956  }
957
958  W.startLine() << "]\n";
959}
960
961template<class ELFT>
962void ELFDumper<ELFT>::printNeededLibraries() {
963  ListScope D(W, "NeededLibraries");
964
965  typedef std::vector<StringRef> LibsTy;
966  LibsTy Libs;
967
968  for (const auto &Entry : Obj->dynamic_table())
969    if (Entry.d_tag == ELF::DT_NEEDED)
970      Libs.push_back(Obj->getDynamicString(Entry.d_un.d_val));
971
972  std::stable_sort(Libs.begin(), Libs.end());
973
974  for (LibsTy::const_iterator I = Libs.begin(), E = Libs.end(); I != E; ++I) {
975    outs() << "  " << *I << "\n";
976  }
977}
978
979template<class ELFT>
980void ELFDumper<ELFT>::printProgramHeaders() {
981  ListScope L(W, "ProgramHeaders");
982
983  for (typename ELFO::Elf_Phdr_Iter PI = Obj->begin_program_headers(),
984                                    PE = Obj->end_program_headers();
985                                    PI != PE; ++PI) {
986    DictScope P(W, "ProgramHeader");
987    W.printHex   ("Type",
988                  getElfSegmentType(Obj->getHeader()->e_machine, PI->p_type),
989                  PI->p_type);
990    W.printHex   ("Offset", PI->p_offset);
991    W.printHex   ("VirtualAddress", PI->p_vaddr);
992    W.printHex   ("PhysicalAddress", PI->p_paddr);
993    W.printNumber("FileSize", PI->p_filesz);
994    W.printNumber("MemSize", PI->p_memsz);
995    W.printFlags ("Flags", PI->p_flags, makeArrayRef(ElfSegmentFlags));
996    W.printNumber("Alignment", PI->p_align);
997  }
998}
999
1000template <class ELFT>
1001void ELFDumper<ELFT>::printAttributes() {
1002  W.startLine() << "Attributes not implemented.\n";
1003}
1004
1005namespace {
1006template <>
1007void ELFDumper<ELFType<support::little, 2, false> >::printAttributes() {
1008  if (Obj->getHeader()->e_machine != EM_ARM) {
1009    W.startLine() << "Attributes not implemented.\n";
1010    return;
1011  }
1012
1013  DictScope BA(W, "BuildAttributes");
1014  for (ELFO::Elf_Shdr_Iter SI = Obj->begin_sections(), SE = Obj->end_sections();
1015       SI != SE; ++SI) {
1016    if (SI->sh_type != ELF::SHT_ARM_ATTRIBUTES)
1017      continue;
1018
1019    ErrorOr<ArrayRef<uint8_t> > Contents = Obj->getSectionContents(&(*SI));
1020    if (!Contents)
1021      continue;
1022
1023    if ((*Contents)[0] != ARMBuildAttrs::Format_Version) {
1024      errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0])
1025             << '\n';
1026      continue;
1027    }
1028
1029    W.printHex("FormatVersion", (*Contents)[0]);
1030    if (Contents->size() == 1)
1031      continue;
1032
1033    ARMAttributeParser(W).Parse(*Contents);
1034  }
1035}
1036}
1037
1038namespace {
1039template <class ELFT> class MipsGOTParser {
1040public:
1041  typedef object::ELFFile<ELFT> ObjectFile;
1042  typedef typename ObjectFile::Elf_Shdr Elf_Shdr;
1043
1044  MipsGOTParser(const ObjectFile *Obj, StreamWriter &W) : Obj(Obj), W(W) {}
1045
1046  void parseGOT(const Elf_Shdr &GOTShdr);
1047
1048private:
1049  typedef typename ObjectFile::Elf_Sym_Iter Elf_Sym_Iter;
1050  typedef typename ObjectFile::Elf_Addr GOTEntry;
1051  typedef typename ObjectFile::template ELFEntityIterator<const GOTEntry>
1052  GOTIter;
1053
1054  const ObjectFile *Obj;
1055  StreamWriter &W;
1056
1057  std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1058  GOTIter makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1059
1060  bool getGOTTags(uint64_t &LocalGotNum, uint64_t &GotSym);
1061  void printGotEntry(uint64_t GotAddr, GOTIter BeginIt, GOTIter It);
1062  void printGlobalGotEntry(uint64_t GotAddr, GOTIter BeginIt, GOTIter It,
1063                           Elf_Sym_Iter Sym);
1064};
1065}
1066
1067template <class ELFT>
1068void MipsGOTParser<ELFT>::parseGOT(const Elf_Shdr &GOTShdr) {
1069  // See "Global Offset Table" in Chapter 5 in the following document
1070  // for detailed GOT description.
1071  // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1072
1073  ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(&GOTShdr);
1074  if (!GOT) {
1075    W.startLine() << "The .got section is empty.\n";
1076    return;
1077  }
1078
1079  uint64_t DtLocalGotNum;
1080  uint64_t DtGotSym;
1081  if (!getGOTTags(DtLocalGotNum, DtGotSym))
1082    return;
1083
1084  if (DtLocalGotNum > getGOTTotal(*GOT)) {
1085    W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n";
1086    return;
1087  }
1088
1089  Elf_Sym_Iter DynSymBegin = Obj->begin_dynamic_symbols();
1090  Elf_Sym_Iter DynSymEnd = Obj->end_dynamic_symbols();
1091  std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1092
1093  if (DtGotSym > DynSymTotal) {
1094    W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n";
1095    return;
1096  }
1097
1098  std::size_t GlobalGotNum = DynSymTotal - DtGotSym;
1099
1100  if (DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) {
1101    W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n";
1102    return;
1103  }
1104
1105  GOTIter GotBegin = makeGOTIter(*GOT, 0);
1106  GOTIter GotLocalEnd = makeGOTIter(*GOT, DtLocalGotNum);
1107  GOTIter It = GotBegin;
1108
1109  DictScope GS(W, "Primary GOT");
1110
1111  W.printHex("Canonical gp value", GOTShdr.sh_addr + 0x7ff0);
1112  {
1113    ListScope RS(W, "Reserved entries");
1114
1115    {
1116      DictScope D(W, "Entry");
1117      printGotEntry(GOTShdr.sh_addr, GotBegin, It++);
1118      W.printString("Purpose", StringRef("Lazy resolver"));
1119    }
1120
1121    if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
1122      DictScope D(W, "Entry");
1123      printGotEntry(GOTShdr.sh_addr, GotBegin, It++);
1124      W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
1125    }
1126  }
1127  {
1128    ListScope LS(W, "Local entries");
1129    for (; It != GotLocalEnd; ++It) {
1130      DictScope D(W, "Entry");
1131      printGotEntry(GOTShdr.sh_addr, GotBegin, It);
1132    }
1133  }
1134  {
1135    ListScope GS(W, "Global entries");
1136
1137    GOTIter GotGlobalEnd = makeGOTIter(*GOT, DtLocalGotNum + GlobalGotNum);
1138    Elf_Sym_Iter GotDynSym = DynSymBegin + DtGotSym;
1139    for (; It != GotGlobalEnd; ++It) {
1140      DictScope D(W, "Entry");
1141      printGlobalGotEntry(GOTShdr.sh_addr, GotBegin, It, GotDynSym++);
1142    }
1143  }
1144
1145  std::size_t SpecGotNum = getGOTTotal(*GOT) - DtLocalGotNum - GlobalGotNum;
1146  W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
1147}
1148
1149template <class ELFT>
1150std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
1151  return GOT.size() / sizeof(GOTEntry);
1152}
1153
1154template <class ELFT>
1155typename MipsGOTParser<ELFT>::GOTIter
1156MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
1157  const char *Data = reinterpret_cast<const char *>(GOT.data());
1158  return GOTIter(sizeof(GOTEntry), Data + EntryNum * sizeof(GOTEntry));
1159}
1160
1161template <class ELFT>
1162bool MipsGOTParser<ELFT>::getGOTTags(uint64_t &LocalGotNum, uint64_t &GotSym) {
1163  bool FoundLocalGotNum = false;
1164  bool FoundGotSym = false;
1165  for (const auto &Entry : Obj->dynamic_table()) {
1166    switch (Entry.getTag()) {
1167    case ELF::DT_MIPS_LOCAL_GOTNO:
1168      LocalGotNum = Entry.getVal();
1169      FoundLocalGotNum = true;
1170      break;
1171    case ELF::DT_MIPS_GOTSYM:
1172      GotSym = Entry.getVal();
1173      FoundGotSym = true;
1174      break;
1175    }
1176  }
1177
1178  if (!FoundLocalGotNum) {
1179    W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1180    return false;
1181  }
1182
1183  if (!FoundGotSym) {
1184    W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1185    return false;
1186  }
1187
1188  return true;
1189}
1190
1191template <class ELFT>
1192void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr, GOTIter BeginIt,
1193                                        GOTIter It) {
1194  int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1195  W.printHex("Address", GotAddr + Offset);
1196  W.printNumber("Access", Offset - 0x7ff0);
1197  W.printHex("Initial", *It);
1198}
1199
1200template <class ELFT>
1201void MipsGOTParser<ELFT>::printGlobalGotEntry(uint64_t GotAddr, GOTIter BeginIt,
1202                                              GOTIter It, Elf_Sym_Iter Sym) {
1203  printGotEntry(GotAddr, BeginIt, It);
1204
1205  W.printHex("Value", Sym->st_value);
1206  W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1207
1208  unsigned SectionIndex = 0;
1209  StringRef SectionName;
1210  getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1211  W.printHex("Section", SectionName, SectionIndex);
1212
1213  std::string FullSymbolName = getFullSymbolName(*Obj, Sym);
1214  W.printNumber("Name", FullSymbolName, Sym->st_name);
1215}
1216
1217template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
1218  if (Obj->getHeader()->e_machine != EM_MIPS) {
1219    W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
1220    return;
1221  }
1222
1223  llvm::Optional<uint64_t> DtPltGot;
1224  for (const auto &Entry : Obj->dynamic_table()) {
1225    if (Entry.getTag() == ELF::DT_PLTGOT) {
1226      DtPltGot = Entry.getVal();
1227      break;
1228    }
1229  }
1230
1231  if (!DtPltGot) {
1232    W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1233    return;
1234  }
1235
1236  const Elf_Shdr *GotShdr = findSectionByAddress(Obj, *DtPltGot);
1237  if (!GotShdr) {
1238    W.startLine() << "There is no .got section in the file.\n";
1239    return;
1240  }
1241
1242  MipsGOTParser<ELFT>(Obj, W).parseGOT(*GotShdr);
1243}
1244