ELFDumper.cpp revision 280031 
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};
379
380static const EnumEntry<unsigned> ElfSymbolTypes[] = {
381  { "None",      ELF::STT_NOTYPE    },
382  { "Object",    ELF::STT_OBJECT    },
383  { "Function",  ELF::STT_FUNC      },
384  { "Section",   ELF::STT_SECTION   },
385  { "File",      ELF::STT_FILE      },
386  { "Common",    ELF::STT_COMMON    },
387  { "TLS",       ELF::STT_TLS       },
388  { "GNU_IFunc", ELF::STT_GNU_IFUNC }
389};
390
391static const char *getElfSectionType(unsigned Arch, unsigned Type) {
392  switch (Arch) {
393  case ELF::EM_ARM:
394    switch (Type) {
395    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
396    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
397    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
398    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
399    LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
400    }
401  case ELF::EM_HEXAGON:
402    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
403  case ELF::EM_X86_64:
404    switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
405  case ELF::EM_MIPS:
406  case ELF::EM_MIPS_RS3_LE:
407    switch (Type) {
408    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
409    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
410    LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
411    }
412  }
413
414  switch (Type) {
415  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL              );
416  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS          );
417  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB            );
418  LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB            );
419  LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA              );
420  LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH              );
421  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC           );
422  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE              );
423  LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS            );
424  LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL               );
425  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB             );
426  LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM            );
427  LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY        );
428  LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY        );
429  LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY     );
430  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP             );
431  LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX      );
432  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES    );
433  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH          );
434  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef        );
435  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed       );
436  LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym        );
437  default: return "";
438  }
439}
440
441static const EnumEntry<unsigned> ElfSectionFlags[] = {
442  LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE           ),
443  LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC           ),
444  LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE         ),
445  LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR       ),
446  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE           ),
447  LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS         ),
448  LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK       ),
449  LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER      ),
450  LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING),
451  LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP           ),
452  LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS             ),
453  LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
454  LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION),
455  LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP    )
456};
457
458static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
459  // Check potentially overlapped processor-specific
460  // program header type.
461  switch (Arch) {
462  case ELF::EM_ARM:
463    switch (Type) {
464    LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
465    }
466  case ELF::EM_MIPS:
467  case ELF::EM_MIPS_RS3_LE:
468    switch (Type) {
469    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
470    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
471    LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
472    }
473  }
474
475  switch (Type) {
476  LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL   );
477  LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD   );
478  LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
479  LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
480  LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE   );
481  LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB  );
482  LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR   );
483  LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS    );
484
485  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
486  LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
487
488  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
489  LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
490  default: return "";
491  }
492}
493
494static const EnumEntry<unsigned> ElfSegmentFlags[] = {
495  LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
496  LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
497  LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
498};
499
500static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
501  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
502  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
503  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
504  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
505  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
506  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
507  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
508  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
509  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
510  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
511  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
512  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
513  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
514  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
515  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
516  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
517  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
518  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
519  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
520  LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
521};
522
523template<class ELFT>
524void ELFDumper<ELFT>::printFileHeaders() {
525  const typename ELFO::Elf_Ehdr *Header = Obj->getHeader();
526
527  {
528    DictScope D(W, "ElfHeader");
529    {
530      DictScope D(W, "Ident");
531      W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0,
532                                                                 4));
533      W.printEnum  ("Class", Header->e_ident[ELF::EI_CLASS],
534                      makeArrayRef(ElfClass));
535      W.printEnum  ("DataEncoding", Header->e_ident[ELF::EI_DATA],
536                      makeArrayRef(ElfDataEncoding));
537      W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]);
538      W.printEnum  ("OS/ABI", Header->e_ident[ELF::EI_OSABI],
539                      makeArrayRef(ElfOSABI));
540      W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]);
541      W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD));
542    }
543
544    W.printEnum  ("Type", Header->e_type, makeArrayRef(ElfObjectFileType));
545    W.printEnum  ("Machine", Header->e_machine, makeArrayRef(ElfMachineType));
546    W.printNumber("Version", Header->e_version);
547    W.printHex   ("Entry", Header->e_entry);
548    W.printHex   ("ProgramHeaderOffset", Header->e_phoff);
549    W.printHex   ("SectionHeaderOffset", Header->e_shoff);
550    if (Header->e_machine == EM_MIPS)
551      W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags),
552                   unsigned(ELF::EF_MIPS_ARCH));
553    else
554      W.printFlags("Flags", Header->e_flags);
555    W.printNumber("HeaderSize", Header->e_ehsize);
556    W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize);
557    W.printNumber("ProgramHeaderCount", Header->e_phnum);
558    W.printNumber("SectionHeaderEntrySize", Header->e_shentsize);
559    W.printNumber("SectionHeaderCount", Header->e_shnum);
560    W.printNumber("StringTableSectionIndex", Header->e_shstrndx);
561  }
562}
563
564template<class ELFT>
565void ELFDumper<ELFT>::printSections() {
566  ListScope SectionsD(W, "Sections");
567
568  int SectionIndex = -1;
569  for (typename ELFO::Elf_Shdr_Iter SecI = Obj->begin_sections(),
570                                    SecE = Obj->end_sections();
571       SecI != SecE; ++SecI) {
572    ++SectionIndex;
573
574    const Elf_Shdr *Section = &*SecI;
575    StringRef Name = errorOrDefault(Obj->getSectionName(Section));
576
577    DictScope SectionD(W, "Section");
578    W.printNumber("Index", SectionIndex);
579    W.printNumber("Name", Name, Section->sh_name);
580    W.printHex("Type",
581               getElfSectionType(Obj->getHeader()->e_machine, Section->sh_type),
582               Section->sh_type);
583    W.printFlags ("Flags", Section->sh_flags, makeArrayRef(ElfSectionFlags));
584    W.printHex   ("Address", Section->sh_addr);
585    W.printHex   ("Offset", Section->sh_offset);
586    W.printNumber("Size", Section->sh_size);
587    W.printNumber("Link", Section->sh_link);
588    W.printNumber("Info", Section->sh_info);
589    W.printNumber("AddressAlignment", Section->sh_addralign);
590    W.printNumber("EntrySize", Section->sh_entsize);
591
592    if (opts::SectionRelocations) {
593      ListScope D(W, "Relocations");
594      printRelocations(Section);
595    }
596
597    if (opts::SectionSymbols) {
598      ListScope D(W, "Symbols");
599      for (typename ELFO::Elf_Sym_Iter SymI = Obj->begin_symbols(),
600                                       SymE = Obj->end_symbols();
601           SymI != SymE; ++SymI) {
602        if (Obj->getSection(&*SymI) == Section)
603          printSymbol(SymI);
604      }
605    }
606
607    if (opts::SectionData && Section->sh_type != ELF::SHT_NOBITS) {
608      ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(Section));
609      W.printBinaryBlock("SectionData",
610                         StringRef((const char *)Data.data(), Data.size()));
611    }
612  }
613}
614
615template<class ELFT>
616void ELFDumper<ELFT>::printRelocations() {
617  ListScope D(W, "Relocations");
618
619  int SectionNumber = -1;
620  for (typename ELFO::Elf_Shdr_Iter SecI = Obj->begin_sections(),
621                                    SecE = Obj->end_sections();
622       SecI != SecE; ++SecI) {
623    ++SectionNumber;
624
625    if (SecI->sh_type != ELF::SHT_REL && SecI->sh_type != ELF::SHT_RELA)
626      continue;
627
628    StringRef Name = errorOrDefault(Obj->getSectionName(&*SecI));
629
630    W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
631    W.indent();
632
633    printRelocations(&*SecI);
634
635    W.unindent();
636    W.startLine() << "}\n";
637  }
638}
639
640template <class ELFT>
641void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
642  switch (Sec->sh_type) {
643  case ELF::SHT_REL:
644    for (typename ELFO::Elf_Rel_Iter RI = Obj->begin_rel(Sec),
645                                     RE = Obj->end_rel(Sec);
646         RI != RE; ++RI) {
647      typename ELFO::Elf_Rela Rela;
648      Rela.r_offset = RI->r_offset;
649      Rela.r_info = RI->r_info;
650      Rela.r_addend = 0;
651      printRelocation(Sec, Rela);
652    }
653    break;
654  case ELF::SHT_RELA:
655    for (typename ELFO::Elf_Rela_Iter RI = Obj->begin_rela(Sec),
656                                      RE = Obj->end_rela(Sec);
657         RI != RE; ++RI) {
658      printRelocation(Sec, *RI);
659    }
660    break;
661  }
662}
663
664template <class ELFT>
665void ELFDumper<ELFT>::printRelocation(const Elf_Shdr *Sec,
666                                      typename ELFO::Elf_Rela Rel) {
667  SmallString<32> RelocName;
668  Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
669  StringRef SymbolName;
670  std::pair<const Elf_Shdr *, const Elf_Sym *> Sym =
671      Obj->getRelocationSymbol(Sec, &Rel);
672  if (Sym.first)
673    SymbolName = errorOrDefault(Obj->getSymbolName(Sym.first, Sym.second));
674
675  if (opts::ExpandRelocs) {
676    DictScope Group(W, "Relocation");
677    W.printHex("Offset", Rel.r_offset);
678    W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
679    W.printNumber("Symbol", SymbolName.size() > 0 ? SymbolName : "-",
680                  Rel.getSymbol(Obj->isMips64EL()));
681    W.printHex("Addend", Rel.r_addend);
682  } else {
683    raw_ostream& OS = W.startLine();
684    OS << W.hex(Rel.r_offset)
685       << " " << RelocName
686       << " " << (SymbolName.size() > 0 ? SymbolName : "-")
687       << " " << W.hex(Rel.r_addend)
688       << "\n";
689  }
690}
691
692template<class ELFT>
693void ELFDumper<ELFT>::printSymbols() {
694  ListScope Group(W, "Symbols");
695  for (typename ELFO::Elf_Sym_Iter SymI = Obj->begin_symbols(),
696                                   SymE = Obj->end_symbols();
697       SymI != SymE; ++SymI) {
698    printSymbol(SymI);
699  }
700}
701
702template<class ELFT>
703void ELFDumper<ELFT>::printDynamicSymbols() {
704  ListScope Group(W, "DynamicSymbols");
705
706  for (typename ELFO::Elf_Sym_Iter SymI = Obj->begin_dynamic_symbols(),
707                                   SymE = Obj->end_dynamic_symbols();
708       SymI != SymE; ++SymI) {
709    printSymbol(SymI);
710  }
711}
712
713template <class ELFT>
714void ELFDumper<ELFT>::printSymbol(typename ELFO::Elf_Sym_Iter Symbol) {
715  unsigned SectionIndex = 0;
716  StringRef SectionName;
717  getSectionNameIndex(*Obj, Symbol, SectionName, SectionIndex);
718  std::string FullSymbolName = getFullSymbolName(*Obj, Symbol);
719
720  DictScope D(W, "Symbol");
721  W.printNumber("Name", FullSymbolName, Symbol->st_name);
722  W.printHex   ("Value", Symbol->st_value);
723  W.printNumber("Size", Symbol->st_size);
724  W.printEnum  ("Binding", Symbol->getBinding(),
725                  makeArrayRef(ElfSymbolBindings));
726  W.printEnum  ("Type", Symbol->getType(), makeArrayRef(ElfSymbolTypes));
727  W.printNumber("Other", Symbol->st_other);
728  W.printHex("Section", SectionName, SectionIndex);
729}
730
731#define LLVM_READOBJ_TYPE_CASE(name) \
732  case DT_##name: return #name
733
734static const char *getTypeString(uint64_t Type) {
735  switch (Type) {
736  LLVM_READOBJ_TYPE_CASE(BIND_NOW);
737  LLVM_READOBJ_TYPE_CASE(DEBUG);
738  LLVM_READOBJ_TYPE_CASE(FINI);
739  LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
740  LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
741  LLVM_READOBJ_TYPE_CASE(FLAGS);
742  LLVM_READOBJ_TYPE_CASE(HASH);
743  LLVM_READOBJ_TYPE_CASE(INIT);
744  LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
745  LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
746  LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
747  LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
748  LLVM_READOBJ_TYPE_CASE(JMPREL);
749  LLVM_READOBJ_TYPE_CASE(NEEDED);
750  LLVM_READOBJ_TYPE_CASE(NULL);
751  LLVM_READOBJ_TYPE_CASE(PLTGOT);
752  LLVM_READOBJ_TYPE_CASE(PLTREL);
753  LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
754  LLVM_READOBJ_TYPE_CASE(REL);
755  LLVM_READOBJ_TYPE_CASE(RELA);
756  LLVM_READOBJ_TYPE_CASE(RELENT);
757  LLVM_READOBJ_TYPE_CASE(RELSZ);
758  LLVM_READOBJ_TYPE_CASE(RELAENT);
759  LLVM_READOBJ_TYPE_CASE(RELASZ);
760  LLVM_READOBJ_TYPE_CASE(RPATH);
761  LLVM_READOBJ_TYPE_CASE(RUNPATH);
762  LLVM_READOBJ_TYPE_CASE(SONAME);
763  LLVM_READOBJ_TYPE_CASE(STRSZ);
764  LLVM_READOBJ_TYPE_CASE(STRTAB);
765  LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
766  LLVM_READOBJ_TYPE_CASE(SYMENT);
767  LLVM_READOBJ_TYPE_CASE(SYMTAB);
768  LLVM_READOBJ_TYPE_CASE(TEXTREL);
769  LLVM_READOBJ_TYPE_CASE(VERNEED);
770  LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
771  LLVM_READOBJ_TYPE_CASE(VERSYM);
772  LLVM_READOBJ_TYPE_CASE(RELCOUNT);
773  LLVM_READOBJ_TYPE_CASE(GNU_HASH);
774  LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
775  LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
776  LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
777  LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
778  LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
779  LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
780  LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
781  LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
782  LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
783  default: return "unknown";
784  }
785}
786
787#undef LLVM_READOBJ_TYPE_CASE
788
789#define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
790  { #enum, prefix##_##enum }
791
792static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
793  LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
794  LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
795  LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
796  LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
797  LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
798};
799
800static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
801  LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
802  LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
803  LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
804  LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
805  LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
806  LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
807  LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
808  LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
809  LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
810  LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
811  LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
812  LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
813  LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
814  LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
815  LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
816  LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
817};
818
819#undef LLVM_READOBJ_DT_FLAG_ENT
820
821template <typename T, typename TFlag>
822void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
823  typedef EnumEntry<TFlag> FlagEntry;
824  typedef SmallVector<FlagEntry, 10> FlagVector;
825  FlagVector SetFlags;
826
827  for (const auto &Flag : Flags) {
828    if (Flag.Value == 0)
829      continue;
830
831    if ((Value & Flag.Value) == Flag.Value)
832      SetFlags.push_back(Flag);
833  }
834
835  for (const auto &Flag : SetFlags) {
836    OS << Flag.Name << " ";
837  }
838}
839
840template <class ELFT>
841static void printValue(const ELFFile<ELFT> *O, uint64_t Type, uint64_t Value,
842                       bool Is64, raw_ostream &OS) {
843  switch (Type) {
844  case DT_PLTREL:
845    if (Value == DT_REL) {
846      OS << "REL";
847      break;
848    } else if (Value == DT_RELA) {
849      OS << "RELA";
850      break;
851    }
852  // Fallthrough.
853  case DT_PLTGOT:
854  case DT_HASH:
855  case DT_STRTAB:
856  case DT_SYMTAB:
857  case DT_RELA:
858  case DT_INIT:
859  case DT_FINI:
860  case DT_REL:
861  case DT_JMPREL:
862  case DT_INIT_ARRAY:
863  case DT_FINI_ARRAY:
864  case DT_PREINIT_ARRAY:
865  case DT_DEBUG:
866  case DT_VERNEED:
867  case DT_VERSYM:
868  case DT_GNU_HASH:
869  case DT_NULL:
870  case DT_MIPS_BASE_ADDRESS:
871  case DT_MIPS_GOTSYM:
872  case DT_MIPS_RLD_MAP:
873  case DT_MIPS_PLTGOT:
874    OS << format("0x%" PRIX64, Value);
875    break;
876  case DT_RELCOUNT:
877  case DT_VERNEEDNUM:
878  case DT_MIPS_RLD_VERSION:
879  case DT_MIPS_LOCAL_GOTNO:
880  case DT_MIPS_SYMTABNO:
881  case DT_MIPS_UNREFEXTNO:
882    OS << Value;
883    break;
884  case DT_PLTRELSZ:
885  case DT_RELASZ:
886  case DT_RELAENT:
887  case DT_STRSZ:
888  case DT_SYMENT:
889  case DT_RELSZ:
890  case DT_RELENT:
891  case DT_INIT_ARRAYSZ:
892  case DT_FINI_ARRAYSZ:
893  case DT_PREINIT_ARRAYSZ:
894    OS << Value << " (bytes)";
895    break;
896  case DT_NEEDED:
897    OS << "SharedLibrary (" << O->getDynamicString(Value) << ")";
898    break;
899  case DT_SONAME:
900    OS << "LibrarySoname (" << O->getDynamicString(Value) << ")";
901    break;
902  case DT_RPATH:
903  case DT_RUNPATH:
904    OS << O->getDynamicString(Value);
905    break;
906  case DT_MIPS_FLAGS:
907    printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
908    break;
909  case DT_FLAGS:
910    printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
911    break;
912  }
913}
914
915template<class ELFT>
916void ELFDumper<ELFT>::printUnwindInfo() {
917  W.startLine() << "UnwindInfo not implemented.\n";
918}
919
920namespace {
921template <>
922void ELFDumper<ELFType<support::little, 2, false> >::printUnwindInfo() {
923  const unsigned Machine = Obj->getHeader()->e_machine;
924  if (Machine == EM_ARM) {
925    ARM::EHABI::PrinterContext<ELFType<support::little, 2, false> > Ctx(W, Obj);
926    return Ctx.PrintUnwindInformation();
927  }
928  W.startLine() << "UnwindInfo not implemented.\n";
929}
930}
931
932template<class ELFT>
933void ELFDumper<ELFT>::printDynamicTable() {
934  auto DynTable = Obj->dynamic_table(true);
935
936  ptrdiff_t Total = std::distance(DynTable.begin(), DynTable.end());
937  if (Total == 0)
938    return;
939
940  raw_ostream &OS = W.getOStream();
941  W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
942
943  bool Is64 = ELFT::Is64Bits;
944
945  W.startLine()
946     << "  Tag" << (Is64 ? "                " : "        ") << "Type"
947     << "                 " << "Name/Value\n";
948  for (const auto &Entry : DynTable) {
949    W.startLine()
950       << "  "
951       << format(Is64 ? "0x%016" PRIX64 : "0x%08" PRIX64, Entry.getTag())
952       << " " << format("%-21s", getTypeString(Entry.getTag()));
953    printValue(Obj, Entry.getTag(), Entry.getVal(), Is64, OS);
954    OS << "\n";
955  }
956
957  W.startLine() << "]\n";
958}
959
960template<class ELFT>
961void ELFDumper<ELFT>::printNeededLibraries() {
962  ListScope D(W, "NeededLibraries");
963
964  typedef std::vector<StringRef> LibsTy;
965  LibsTy Libs;
966
967  for (const auto &Entry : Obj->dynamic_table())
968    if (Entry.d_tag == ELF::DT_NEEDED)
969      Libs.push_back(Obj->getDynamicString(Entry.d_un.d_val));
970
971  std::stable_sort(Libs.begin(), Libs.end());
972
973  for (LibsTy::const_iterator I = Libs.begin(), E = Libs.end(); I != E; ++I) {
974    outs() << "  " << *I << "\n";
975  }
976}
977
978template<class ELFT>
979void ELFDumper<ELFT>::printProgramHeaders() {
980  ListScope L(W, "ProgramHeaders");
981
982  for (typename ELFO::Elf_Phdr_Iter PI = Obj->begin_program_headers(),
983                                    PE = Obj->end_program_headers();
984                                    PI != PE; ++PI) {
985    DictScope P(W, "ProgramHeader");
986    W.printHex   ("Type",
987                  getElfSegmentType(Obj->getHeader()->e_machine, PI->p_type),
988                  PI->p_type);
989    W.printHex   ("Offset", PI->p_offset);
990    W.printHex   ("VirtualAddress", PI->p_vaddr);
991    W.printHex   ("PhysicalAddress", PI->p_paddr);
992    W.printNumber("FileSize", PI->p_filesz);
993    W.printNumber("MemSize", PI->p_memsz);
994    W.printFlags ("Flags", PI->p_flags, makeArrayRef(ElfSegmentFlags));
995    W.printNumber("Alignment", PI->p_align);
996  }
997}
998
999template <class ELFT>
1000void ELFDumper<ELFT>::printAttributes() {
1001  W.startLine() << "Attributes not implemented.\n";
1002}
1003
1004namespace {
1005template <>
1006void ELFDumper<ELFType<support::little, 2, false> >::printAttributes() {
1007  if (Obj->getHeader()->e_machine != EM_ARM) {
1008    W.startLine() << "Attributes not implemented.\n";
1009    return;
1010  }
1011
1012  DictScope BA(W, "BuildAttributes");
1013  for (ELFO::Elf_Shdr_Iter SI = Obj->begin_sections(), SE = Obj->end_sections();
1014       SI != SE; ++SI) {
1015    if (SI->sh_type != ELF::SHT_ARM_ATTRIBUTES)
1016      continue;
1017
1018    ErrorOr<ArrayRef<uint8_t> > Contents = Obj->getSectionContents(&(*SI));
1019    if (!Contents)
1020      continue;
1021
1022    if ((*Contents)[0] != ARMBuildAttrs::Format_Version) {
1023      errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0])
1024             << '\n';
1025      continue;
1026    }
1027
1028    W.printHex("FormatVersion", (*Contents)[0]);
1029    if (Contents->size() == 1)
1030      continue;
1031
1032    ARMAttributeParser(W).Parse(*Contents);
1033  }
1034}
1035}
1036
1037namespace {
1038template <class ELFT> class MipsGOTParser {
1039public:
1040  typedef object::ELFFile<ELFT> ObjectFile;
1041  typedef typename ObjectFile::Elf_Shdr Elf_Shdr;
1042
1043  MipsGOTParser(const ObjectFile *Obj, StreamWriter &W) : Obj(Obj), W(W) {}
1044
1045  void parseGOT(const Elf_Shdr &GOTShdr);
1046
1047private:
1048  typedef typename ObjectFile::Elf_Sym_Iter Elf_Sym_Iter;
1049  typedef typename ObjectFile::Elf_Addr GOTEntry;
1050  typedef typename ObjectFile::template ELFEntityIterator<const GOTEntry>
1051  GOTIter;
1052
1053  const ObjectFile *Obj;
1054  StreamWriter &W;
1055
1056  std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1057  GOTIter makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1058
1059  bool getGOTTags(uint64_t &LocalGotNum, uint64_t &GotSym);
1060  void printGotEntry(uint64_t GotAddr, GOTIter BeginIt, GOTIter It);
1061  void printGlobalGotEntry(uint64_t GotAddr, GOTIter BeginIt, GOTIter It,
1062                           Elf_Sym_Iter Sym);
1063};
1064}
1065
1066template <class ELFT>
1067void MipsGOTParser<ELFT>::parseGOT(const Elf_Shdr &GOTShdr) {
1068  // See "Global Offset Table" in Chapter 5 in the following document
1069  // for detailed GOT description.
1070  // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1071
1072  ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(&GOTShdr);
1073  if (!GOT) {
1074    W.startLine() << "The .got section is empty.\n";
1075    return;
1076  }
1077
1078  uint64_t DtLocalGotNum;
1079  uint64_t DtGotSym;
1080  if (!getGOTTags(DtLocalGotNum, DtGotSym))
1081    return;
1082
1083  if (DtLocalGotNum > getGOTTotal(*GOT)) {
1084    W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n";
1085    return;
1086  }
1087
1088  Elf_Sym_Iter DynSymBegin = Obj->begin_dynamic_symbols();
1089  Elf_Sym_Iter DynSymEnd = Obj->end_dynamic_symbols();
1090  std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1091
1092  if (DtGotSym > DynSymTotal) {
1093    W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n";
1094    return;
1095  }
1096
1097  std::size_t GlobalGotNum = DynSymTotal - DtGotSym;
1098
1099  if (DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) {
1100    W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n";
1101    return;
1102  }
1103
1104  GOTIter GotBegin = makeGOTIter(*GOT, 0);
1105  GOTIter GotLocalEnd = makeGOTIter(*GOT, DtLocalGotNum);
1106  GOTIter It = GotBegin;
1107
1108  DictScope GS(W, "Primary GOT");
1109
1110  W.printHex("Canonical gp value", GOTShdr.sh_addr + 0x7ff0);
1111  {
1112    ListScope RS(W, "Reserved entries");
1113
1114    {
1115      DictScope D(W, "Entry");
1116      printGotEntry(GOTShdr.sh_addr, GotBegin, It++);
1117      W.printString("Purpose", StringRef("Lazy resolver"));
1118    }
1119
1120    if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
1121      DictScope D(W, "Entry");
1122      printGotEntry(GOTShdr.sh_addr, GotBegin, It++);
1123      W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
1124    }
1125  }
1126  {
1127    ListScope LS(W, "Local entries");
1128    for (; It != GotLocalEnd; ++It) {
1129      DictScope D(W, "Entry");
1130      printGotEntry(GOTShdr.sh_addr, GotBegin, It);
1131    }
1132  }
1133  {
1134    ListScope GS(W, "Global entries");
1135
1136    GOTIter GotGlobalEnd = makeGOTIter(*GOT, DtLocalGotNum + GlobalGotNum);
1137    Elf_Sym_Iter GotDynSym = DynSymBegin + DtGotSym;
1138    for (; It != GotGlobalEnd; ++It) {
1139      DictScope D(W, "Entry");
1140      printGlobalGotEntry(GOTShdr.sh_addr, GotBegin, It, GotDynSym++);
1141    }
1142  }
1143
1144  std::size_t SpecGotNum = getGOTTotal(*GOT) - DtLocalGotNum - GlobalGotNum;
1145  W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
1146}
1147
1148template <class ELFT>
1149std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
1150  return GOT.size() / sizeof(GOTEntry);
1151}
1152
1153template <class ELFT>
1154typename MipsGOTParser<ELFT>::GOTIter
1155MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
1156  const char *Data = reinterpret_cast<const char *>(GOT.data());
1157  return GOTIter(sizeof(GOTEntry), Data + EntryNum * sizeof(GOTEntry));
1158}
1159
1160template <class ELFT>
1161bool MipsGOTParser<ELFT>::getGOTTags(uint64_t &LocalGotNum, uint64_t &GotSym) {
1162  bool FoundLocalGotNum = false;
1163  bool FoundGotSym = false;
1164  for (const auto &Entry : Obj->dynamic_table()) {
1165    switch (Entry.getTag()) {
1166    case ELF::DT_MIPS_LOCAL_GOTNO:
1167      LocalGotNum = Entry.getVal();
1168      FoundLocalGotNum = true;
1169      break;
1170    case ELF::DT_MIPS_GOTSYM:
1171      GotSym = Entry.getVal();
1172      FoundGotSym = true;
1173      break;
1174    }
1175  }
1176
1177  if (!FoundLocalGotNum) {
1178    W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1179    return false;
1180  }
1181
1182  if (!FoundGotSym) {
1183    W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1184    return false;
1185  }
1186
1187  return true;
1188}
1189
1190template <class ELFT>
1191void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr, GOTIter BeginIt,
1192                                        GOTIter It) {
1193  int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1194  W.printHex("Address", GotAddr + Offset);
1195  W.printNumber("Access", Offset - 0x7ff0);
1196  W.printHex("Initial", *It);
1197}
1198
1199template <class ELFT>
1200void MipsGOTParser<ELFT>::printGlobalGotEntry(uint64_t GotAddr, GOTIter BeginIt,
1201                                              GOTIter It, Elf_Sym_Iter Sym) {
1202  printGotEntry(GotAddr, BeginIt, It);
1203
1204  W.printHex("Value", Sym->st_value);
1205  W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1206
1207  unsigned SectionIndex = 0;
1208  StringRef SectionName;
1209  getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1210  W.printHex("Section", SectionName, SectionIndex);
1211
1212  std::string FullSymbolName = getFullSymbolName(*Obj, Sym);
1213  W.printNumber("Name", FullSymbolName, Sym->st_name);
1214}
1215
1216template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
1217  if (Obj->getHeader()->e_machine != EM_MIPS) {
1218    W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
1219    return;
1220  }
1221
1222  llvm::Optional<uint64_t> DtPltGot;
1223  for (const auto &Entry : Obj->dynamic_table()) {
1224    if (Entry.getTag() == ELF::DT_PLTGOT) {
1225      DtPltGot = Entry.getVal();
1226      break;
1227    }
1228  }
1229
1230  if (!DtPltGot) {
1231    W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1232    return;
1233  }
1234
1235  const Elf_Shdr *GotShdr = findSectionByAddress(Obj, *DtPltGot);
1236  if (!GotShdr) {
1237    W.startLine() << "There is no .got section in the file.\n";
1238    return;
1239  }
1240
1241  MipsGOTParser<ELFT>(Obj, W).parseGOT(*GotShdr);
1242}
1243