1 //===-- ELFDumper.cpp - ELF-specific dumper ---------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief This file implements the ELF-specific dumper for llvm-readobj.
13 //===----------------------------------------------------------------------===//
15 #include "llvm-readobj.h"
16 #include "ARMAttributeParser.h"
17 #include "ARMEHABIPrinter.h"
19 #include "ObjDumper.h"
20 #include "StackMapPrinter.h"
21 #include "StreamWriter.h"
22 #include "llvm/ADT/Optional.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringExtras.h"
25 #include "llvm/Object/ELFObjectFile.h"
26 #include "llvm/Support/ARMBuildAttributes.h"
27 #include "llvm/Support/Compiler.h"
28 #include "llvm/Support/Format.h"
29 #include "llvm/Support/MathExtras.h"
30 #include "llvm/Support/MipsABIFlags.h"
31 #include "llvm/Support/raw_ostream.h"
34 using namespace llvm::object;
37 #define LLVM_READOBJ_ENUM_CASE(ns, enum) \
38 case ns::enum: return #enum;
42 template<typename ELFT>
43 class ELFDumper : public ObjDumper {
45 ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer);
47 void printFileHeaders() override;
48 void printSections() override;
49 void printRelocations() override;
50 void printDynamicRelocations() override;
51 void printSymbols() override;
52 void printDynamicSymbols() override;
53 void printUnwindInfo() override;
55 void printDynamicTable() override;
56 void printNeededLibraries() override;
57 void printProgramHeaders() override;
58 void printHashTable() override;
59 void printLoadName() override;
61 void printAttributes() override;
62 void printMipsPLTGOT() override;
63 void printMipsABIFlags() override;
64 void printMipsReginfo() override;
66 void printStackMap() const override;
69 typedef ELFFile<ELFT> ELFO;
70 typedef typename ELFO::Elf_Shdr Elf_Shdr;
71 typedef typename ELFO::Elf_Sym Elf_Sym;
72 typedef typename ELFO::Elf_Dyn Elf_Dyn;
73 typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
74 typedef typename ELFO::Elf_Rel Elf_Rel;
75 typedef typename ELFO::Elf_Rela Elf_Rela;
76 typedef typename ELFO::Elf_Rela_Range Elf_Rela_Range;
77 typedef typename ELFO::Elf_Phdr Elf_Phdr;
78 typedef typename ELFO::Elf_Hash Elf_Hash;
79 typedef typename ELFO::Elf_Ehdr Elf_Ehdr;
80 typedef typename ELFO::uintX_t uintX_t;
82 /// \brief Represents a region described by entries in the .dynamic table.
83 struct DynRegionInfo {
84 DynRegionInfo() : Addr(nullptr), Size(0), EntSize(0) {}
85 /// \brief Address in current address space.
87 /// \brief Size in bytes of the region.
89 /// \brief Size of each entity in the region.
93 void printSymbol(const Elf_Sym *Symbol, StringRef StrTable, bool IsDynamic);
95 void printRelocations(const Elf_Shdr *Sec);
96 void printRelocation(const Elf_Shdr *Sec, Elf_Rela Rel);
97 void printValue(uint64_t Type, uint64_t Value);
99 const Elf_Rela *dyn_rela_begin() const;
100 const Elf_Rela *dyn_rela_end() const;
101 Elf_Rela_Range dyn_relas() const;
102 StringRef getDynamicString(uint64_t Offset) const;
103 const Elf_Dyn *dynamic_table_begin() const;
104 const Elf_Dyn *dynamic_table_end() const;
105 Elf_Dyn_Range dynamic_table() const {
106 return make_range(dynamic_table_begin(), dynamic_table_end());
110 DynRegionInfo DynRelaRegion;
111 DynRegionInfo DynamicRegion;
112 StringRef DynamicStringTable;
114 const Elf_Hash *HashTable = nullptr;
117 template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) {
119 error(Val.getError());
129 template <class ELFT>
130 static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
131 StreamWriter &Writer,
132 std::unique_ptr<ObjDumper> &Result) {
133 Result.reset(new ELFDumper<ELFT>(Obj, Writer));
134 return readobj_error::success;
137 std::error_code createELFDumper(const object::ObjectFile *Obj,
138 StreamWriter &Writer,
139 std::unique_ptr<ObjDumper> &Result) {
140 // Little-endian 32-bit
141 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
142 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
145 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
146 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
148 // Little-endian 64-bit
149 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
150 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
153 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
154 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
156 return readobj_error::unsupported_obj_file_format;
161 template <typename ELFO>
162 static std::string getFullSymbolName(const ELFO &Obj,
163 const typename ELFO::Elf_Sym *Symbol,
164 StringRef StrTable, bool IsDynamic) {
165 StringRef SymbolName = errorOrDefault(Symbol->getName(StrTable));
169 std::string FullSymbolName(SymbolName);
172 ErrorOr<StringRef> Version =
173 Obj.getSymbolVersion(StrTable, &*Symbol, IsDefault);
175 FullSymbolName += (IsDefault ? "@@" : "@");
176 FullSymbolName += *Version;
178 error(Version.getError());
179 return FullSymbolName;
182 template <typename ELFO>
184 getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol,
185 StringRef &SectionName, unsigned &SectionIndex) {
186 SectionIndex = Symbol->st_shndx;
187 if (Symbol->isUndefined())
188 SectionName = "Undefined";
189 else if (Symbol->isProcessorSpecific())
190 SectionName = "Processor Specific";
191 else if (Symbol->isOSSpecific())
192 SectionName = "Operating System Specific";
193 else if (Symbol->isAbsolute())
194 SectionName = "Absolute";
195 else if (Symbol->isCommon())
196 SectionName = "Common";
197 else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX)
198 SectionName = "Reserved";
200 if (SectionIndex == SHN_XINDEX)
201 SectionIndex = Obj.getExtendedSymbolTableIndex(&*Symbol);
202 ErrorOr<const typename ELFO::Elf_Shdr *> Sec = Obj.getSection(SectionIndex);
203 error(Sec.getError());
204 SectionName = errorOrDefault(Obj.getSectionName(*Sec));
208 template <class ELFO>
209 static const typename ELFO::Elf_Shdr *findSectionByAddress(const ELFO *Obj,
211 for (const auto &Shdr : Obj->sections())
212 if (Shdr.sh_addr == Addr)
217 template <class ELFO>
218 static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj,
220 for (const auto &Shdr : Obj.sections()) {
221 if (Name == errorOrDefault(Obj.getSectionName(&Shdr)))
227 static const EnumEntry<unsigned> ElfClass[] = {
228 { "None", ELF::ELFCLASSNONE },
229 { "32-bit", ELF::ELFCLASS32 },
230 { "64-bit", ELF::ELFCLASS64 },
233 static const EnumEntry<unsigned> ElfDataEncoding[] = {
234 { "None", ELF::ELFDATANONE },
235 { "LittleEndian", ELF::ELFDATA2LSB },
236 { "BigEndian", ELF::ELFDATA2MSB },
239 static const EnumEntry<unsigned> ElfObjectFileType[] = {
240 { "None", ELF::ET_NONE },
241 { "Relocatable", ELF::ET_REL },
242 { "Executable", ELF::ET_EXEC },
243 { "SharedObject", ELF::ET_DYN },
244 { "Core", ELF::ET_CORE },
247 static const EnumEntry<unsigned> ElfOSABI[] = {
248 { "SystemV", ELF::ELFOSABI_NONE },
249 { "HPUX", ELF::ELFOSABI_HPUX },
250 { "NetBSD", ELF::ELFOSABI_NETBSD },
251 { "GNU/Linux", ELF::ELFOSABI_LINUX },
252 { "GNU/Hurd", ELF::ELFOSABI_HURD },
253 { "Solaris", ELF::ELFOSABI_SOLARIS },
254 { "AIX", ELF::ELFOSABI_AIX },
255 { "IRIX", ELF::ELFOSABI_IRIX },
256 { "FreeBSD", ELF::ELFOSABI_FREEBSD },
257 { "TRU64", ELF::ELFOSABI_TRU64 },
258 { "Modesto", ELF::ELFOSABI_MODESTO },
259 { "OpenBSD", ELF::ELFOSABI_OPENBSD },
260 { "OpenVMS", ELF::ELFOSABI_OPENVMS },
261 { "NSK", ELF::ELFOSABI_NSK },
262 { "AROS", ELF::ELFOSABI_AROS },
263 { "FenixOS", ELF::ELFOSABI_FENIXOS },
264 { "CloudABI", ELF::ELFOSABI_CLOUDABI },
265 { "C6000_ELFABI", ELF::ELFOSABI_C6000_ELFABI },
266 { "C6000_LINUX" , ELF::ELFOSABI_C6000_LINUX },
267 { "ARM", ELF::ELFOSABI_ARM },
268 { "Standalone" , ELF::ELFOSABI_STANDALONE }
271 static const EnumEntry<unsigned> ElfMachineType[] = {
272 LLVM_READOBJ_ENUM_ENT(ELF, EM_NONE ),
273 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32 ),
274 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC ),
275 LLVM_READOBJ_ENUM_ENT(ELF, EM_386 ),
276 LLVM_READOBJ_ENUM_ENT(ELF, EM_68K ),
277 LLVM_READOBJ_ENUM_ENT(ELF, EM_88K ),
278 LLVM_READOBJ_ENUM_ENT(ELF, EM_IAMCU ),
279 LLVM_READOBJ_ENUM_ENT(ELF, EM_860 ),
280 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS ),
281 LLVM_READOBJ_ENUM_ENT(ELF, EM_S370 ),
282 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_RS3_LE ),
283 LLVM_READOBJ_ENUM_ENT(ELF, EM_PARISC ),
284 LLVM_READOBJ_ENUM_ENT(ELF, EM_VPP500 ),
285 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC32PLUS ),
286 LLVM_READOBJ_ENUM_ENT(ELF, EM_960 ),
287 LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC ),
288 LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC64 ),
289 LLVM_READOBJ_ENUM_ENT(ELF, EM_S390 ),
290 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPU ),
291 LLVM_READOBJ_ENUM_ENT(ELF, EM_V800 ),
292 LLVM_READOBJ_ENUM_ENT(ELF, EM_FR20 ),
293 LLVM_READOBJ_ENUM_ENT(ELF, EM_RH32 ),
294 LLVM_READOBJ_ENUM_ENT(ELF, EM_RCE ),
295 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARM ),
296 LLVM_READOBJ_ENUM_ENT(ELF, EM_ALPHA ),
297 LLVM_READOBJ_ENUM_ENT(ELF, EM_SH ),
298 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARCV9 ),
299 LLVM_READOBJ_ENUM_ENT(ELF, EM_TRICORE ),
300 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC ),
301 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300 ),
302 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300H ),
303 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8S ),
304 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_500 ),
305 LLVM_READOBJ_ENUM_ENT(ELF, EM_IA_64 ),
306 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_X ),
307 LLVM_READOBJ_ENUM_ENT(ELF, EM_COLDFIRE ),
308 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC12 ),
309 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMA ),
310 LLVM_READOBJ_ENUM_ENT(ELF, EM_PCP ),
311 LLVM_READOBJ_ENUM_ENT(ELF, EM_NCPU ),
312 LLVM_READOBJ_ENUM_ENT(ELF, EM_NDR1 ),
313 LLVM_READOBJ_ENUM_ENT(ELF, EM_STARCORE ),
314 LLVM_READOBJ_ENUM_ENT(ELF, EM_ME16 ),
315 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST100 ),
316 LLVM_READOBJ_ENUM_ENT(ELF, EM_TINYJ ),
317 LLVM_READOBJ_ENUM_ENT(ELF, EM_X86_64 ),
318 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDSP ),
319 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP10 ),
320 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP11 ),
321 LLVM_READOBJ_ENUM_ENT(ELF, EM_FX66 ),
322 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST9PLUS ),
323 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST7 ),
324 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC16 ),
325 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC11 ),
326 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC08 ),
327 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC05 ),
328 LLVM_READOBJ_ENUM_ENT(ELF, EM_SVX ),
329 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST19 ),
330 LLVM_READOBJ_ENUM_ENT(ELF, EM_VAX ),
331 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRIS ),
332 LLVM_READOBJ_ENUM_ENT(ELF, EM_JAVELIN ),
333 LLVM_READOBJ_ENUM_ENT(ELF, EM_FIREPATH ),
334 LLVM_READOBJ_ENUM_ENT(ELF, EM_ZSP ),
335 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMIX ),
336 LLVM_READOBJ_ENUM_ENT(ELF, EM_HUANY ),
337 LLVM_READOBJ_ENUM_ENT(ELF, EM_PRISM ),
338 LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR ),
339 LLVM_READOBJ_ENUM_ENT(ELF, EM_FR30 ),
340 LLVM_READOBJ_ENUM_ENT(ELF, EM_D10V ),
341 LLVM_READOBJ_ENUM_ENT(ELF, EM_D30V ),
342 LLVM_READOBJ_ENUM_ENT(ELF, EM_V850 ),
343 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32R ),
344 LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10300 ),
345 LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10200 ),
346 LLVM_READOBJ_ENUM_ENT(ELF, EM_PJ ),
347 LLVM_READOBJ_ENUM_ENT(ELF, EM_OPENRISC ),
348 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT ),
349 LLVM_READOBJ_ENUM_ENT(ELF, EM_XTENSA ),
350 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE ),
351 LLVM_READOBJ_ENUM_ENT(ELF, EM_TMM_GPP ),
352 LLVM_READOBJ_ENUM_ENT(ELF, EM_NS32K ),
353 LLVM_READOBJ_ENUM_ENT(ELF, EM_TPC ),
354 LLVM_READOBJ_ENUM_ENT(ELF, EM_SNP1K ),
355 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST200 ),
356 LLVM_READOBJ_ENUM_ENT(ELF, EM_IP2K ),
357 LLVM_READOBJ_ENUM_ENT(ELF, EM_MAX ),
358 LLVM_READOBJ_ENUM_ENT(ELF, EM_CR ),
359 LLVM_READOBJ_ENUM_ENT(ELF, EM_F2MC16 ),
360 LLVM_READOBJ_ENUM_ENT(ELF, EM_MSP430 ),
361 LLVM_READOBJ_ENUM_ENT(ELF, EM_BLACKFIN ),
362 LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C33 ),
363 LLVM_READOBJ_ENUM_ENT(ELF, EM_SEP ),
364 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARCA ),
365 LLVM_READOBJ_ENUM_ENT(ELF, EM_UNICORE ),
366 LLVM_READOBJ_ENUM_ENT(ELF, EM_EXCESS ),
367 LLVM_READOBJ_ENUM_ENT(ELF, EM_DXP ),
368 LLVM_READOBJ_ENUM_ENT(ELF, EM_ALTERA_NIOS2 ),
369 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRX ),
370 LLVM_READOBJ_ENUM_ENT(ELF, EM_XGATE ),
371 LLVM_READOBJ_ENUM_ENT(ELF, EM_C166 ),
372 LLVM_READOBJ_ENUM_ENT(ELF, EM_M16C ),
373 LLVM_READOBJ_ENUM_ENT(ELF, EM_DSPIC30F ),
374 LLVM_READOBJ_ENUM_ENT(ELF, EM_CE ),
375 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32C ),
376 LLVM_READOBJ_ENUM_ENT(ELF, EM_TSK3000 ),
377 LLVM_READOBJ_ENUM_ENT(ELF, EM_RS08 ),
378 LLVM_READOBJ_ENUM_ENT(ELF, EM_SHARC ),
379 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG2 ),
380 LLVM_READOBJ_ENUM_ENT(ELF, EM_SCORE7 ),
381 LLVM_READOBJ_ENUM_ENT(ELF, EM_DSP24 ),
382 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE3 ),
383 LLVM_READOBJ_ENUM_ENT(ELF, EM_LATTICEMICO32),
384 LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17 ),
385 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000 ),
386 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000 ),
387 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500 ),
388 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS ),
389 LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C ),
390 LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C ),
391 LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA ),
392 LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON ),
393 LLVM_READOBJ_ENUM_ENT(ELF, EM_8051 ),
394 LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X ),
395 LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32 ),
396 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1 ),
397 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X ),
398 LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30 ),
399 LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16 ),
400 LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK ),
401 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRAYNV2 ),
402 LLVM_READOBJ_ENUM_ENT(ELF, EM_RX ),
403 LLVM_READOBJ_ENUM_ENT(ELF, EM_METAG ),
404 LLVM_READOBJ_ENUM_ENT(ELF, EM_MCST_ELBRUS ),
405 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG16 ),
406 LLVM_READOBJ_ENUM_ENT(ELF, EM_CR16 ),
407 LLVM_READOBJ_ENUM_ENT(ELF, EM_ETPU ),
408 LLVM_READOBJ_ENUM_ENT(ELF, EM_SLE9X ),
409 LLVM_READOBJ_ENUM_ENT(ELF, EM_L10M ),
410 LLVM_READOBJ_ENUM_ENT(ELF, EM_K10M ),
411 LLVM_READOBJ_ENUM_ENT(ELF, EM_AARCH64 ),
412 LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR32 ),
413 LLVM_READOBJ_ENUM_ENT(ELF, EM_STM8 ),
414 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILE64 ),
415 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEPRO ),
416 LLVM_READOBJ_ENUM_ENT(ELF, EM_CUDA ),
417 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEGX ),
418 LLVM_READOBJ_ENUM_ENT(ELF, EM_CLOUDSHIELD ),
419 LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_1ST ),
420 LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_2ND ),
421 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT2 ),
422 LLVM_READOBJ_ENUM_ENT(ELF, EM_OPEN8 ),
423 LLVM_READOBJ_ENUM_ENT(ELF, EM_RL78 ),
424 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE5 ),
425 LLVM_READOBJ_ENUM_ENT(ELF, EM_78KOR ),
426 LLVM_READOBJ_ENUM_ENT(ELF, EM_56800EX ),
427 LLVM_READOBJ_ENUM_ENT(ELF, EM_AMDGPU )
430 static const EnumEntry<unsigned> ElfSymbolBindings[] = {
431 { "Local", ELF::STB_LOCAL },
432 { "Global", ELF::STB_GLOBAL },
433 { "Weak", ELF::STB_WEAK },
434 { "Unique", ELF::STB_GNU_UNIQUE }
437 static const EnumEntry<unsigned> ElfSymbolTypes[] = {
438 { "None", ELF::STT_NOTYPE },
439 { "Object", ELF::STT_OBJECT },
440 { "Function", ELF::STT_FUNC },
441 { "Section", ELF::STT_SECTION },
442 { "File", ELF::STT_FILE },
443 { "Common", ELF::STT_COMMON },
444 { "TLS", ELF::STT_TLS },
445 { "GNU_IFunc", ELF::STT_GNU_IFUNC }
448 static const char *getElfSectionType(unsigned Arch, unsigned Type) {
452 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
453 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
454 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
455 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
456 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
458 case ELF::EM_HEXAGON:
459 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
461 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
463 case ELF::EM_MIPS_RS3_LE:
465 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
466 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
467 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
472 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL );
473 LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS );
474 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB );
475 LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB );
476 LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA );
477 LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH );
478 LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC );
479 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE );
480 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS );
481 LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL );
482 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB );
483 LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM );
484 LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY );
485 LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY );
486 LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY );
487 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP );
488 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX );
489 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES );
490 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH );
491 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef );
492 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed );
493 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym );
498 static const EnumEntry<unsigned> ElfSectionFlags[] = {
499 LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE ),
500 LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC ),
501 LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE ),
502 LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR ),
503 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE ),
504 LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS ),
505 LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK ),
506 LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER ),
507 LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING),
508 LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP ),
509 LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS ),
510 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
511 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION),
512 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP )
515 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
516 // Check potentially overlapped processor-specific
517 // program header type.
521 LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
524 case ELF::EM_MIPS_RS3_LE:
526 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
527 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
528 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
529 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
534 LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL );
535 LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD );
536 LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
537 LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
538 LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE );
539 LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB );
540 LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR );
541 LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS );
543 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
544 LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
546 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
547 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
552 static const EnumEntry<unsigned> ElfSegmentFlags[] = {
553 LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
554 LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
555 LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
558 static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
559 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
560 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
561 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
562 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
563 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
564 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_FP64),
565 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
566 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
567 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O64),
568 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI32),
569 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI64),
570 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_3900),
571 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4010),
572 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4100),
573 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4650),
574 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4120),
575 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4111),
576 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_SB1),
577 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON),
578 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_XLR),
579 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON2),
580 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON3),
581 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5400),
582 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5900),
583 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5500),
584 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_9000),
585 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2E),
586 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2F),
587 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS3A),
588 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
589 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
590 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_MDMX),
591 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
592 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
593 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
594 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
595 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
596 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
597 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
598 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
599 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
600 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
601 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
604 template <typename ELFT>
605 ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
606 : ObjDumper(Writer), Obj(Obj) {
608 SmallVector<const Elf_Phdr *, 4> LoadSegments;
609 for (const Elf_Phdr &Phdr : Obj->program_headers()) {
610 if (Phdr.p_type == ELF::PT_DYNAMIC) {
611 DynamicRegion.Addr = Obj->base() + Phdr.p_offset;
612 uint64_t Size = Phdr.p_filesz;
613 if (Size % sizeof(Elf_Dyn))
614 report_fatal_error("Invalid dynamic table size");
615 DynamicRegion.Size = Phdr.p_filesz;
618 if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0)
620 LoadSegments.push_back(&Phdr);
623 auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
624 const Elf_Phdr **I = std::upper_bound(
625 LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>);
626 if (I == LoadSegments.begin())
627 report_fatal_error("Virtual address is not in any segment");
629 const Elf_Phdr &Phdr = **I;
630 uint64_t Delta = VAddr - Phdr.p_vaddr;
631 if (Delta >= Phdr.p_filesz)
632 report_fatal_error("Virtual address is not in any segment");
633 return Obj->base() + Phdr.p_offset + Delta;
636 uint64_t SONameOffset = 0;
637 const char *StringTableBegin = nullptr;
638 uint64_t StringTableSize = 0;
639 for (const Elf_Dyn &Dyn : dynamic_table()) {
643 reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
646 DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
649 DynRelaRegion.Size = Dyn.getVal();
651 case ELF::DT_RELAENT:
652 DynRelaRegion.EntSize = Dyn.getVal();
655 SONameOffset = Dyn.getVal();
658 StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr());
661 StringTableSize = Dyn.getVal();
665 if (StringTableBegin)
666 DynamicStringTable = StringRef(StringTableBegin, StringTableSize);
668 SOName = getDynamicString(SONameOffset);
671 template <typename ELFT>
672 const typename ELFDumper<ELFT>::Elf_Rela *
673 ELFDumper<ELFT>::dyn_rela_begin() const {
674 if (DynRelaRegion.Size && DynRelaRegion.EntSize != sizeof(Elf_Rela))
675 report_fatal_error("Invalid relocation entry size");
676 return reinterpret_cast<const Elf_Rela *>(DynRelaRegion.Addr);
679 template <typename ELFT>
680 const typename ELFDumper<ELFT>::Elf_Rela *
681 ELFDumper<ELFT>::dyn_rela_end() const {
682 uint64_t Size = DynRelaRegion.Size;
683 if (Size % sizeof(Elf_Rela))
684 report_fatal_error("Invalid relocation table size");
685 return dyn_rela_begin() + Size / sizeof(Elf_Rela);
688 template <typename ELFT>
689 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
690 return make_range(dyn_rela_begin(), dyn_rela_end());
693 template <typename ELFT>
694 const typename ELFDumper<ELFT>::Elf_Dyn *
695 ELFDumper<ELFT>::dynamic_table_begin() const {
696 return reinterpret_cast<const Elf_Dyn *>(DynamicRegion.Addr);
699 template <typename ELFT>
700 const typename ELFDumper<ELFT>::Elf_Dyn *
701 ELFDumper<ELFT>::dynamic_table_end() const {
702 uint64_t Size = DynamicRegion.Size;
703 return dynamic_table_begin() + Size / sizeof(Elf_Dyn);
707 void ELFDumper<ELFT>::printFileHeaders() {
708 const Elf_Ehdr *Header = Obj->getHeader();
711 DictScope D(W, "ElfHeader");
713 DictScope D(W, "Ident");
714 W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0,
716 W.printEnum ("Class", Header->e_ident[ELF::EI_CLASS],
717 makeArrayRef(ElfClass));
718 W.printEnum ("DataEncoding", Header->e_ident[ELF::EI_DATA],
719 makeArrayRef(ElfDataEncoding));
720 W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]);
722 // Handle architecture specific OS/ABI values.
723 if (Header->e_machine == ELF::EM_AMDGPU &&
724 Header->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
725 W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
727 W.printEnum ("OS/ABI", Header->e_ident[ELF::EI_OSABI],
728 makeArrayRef(ElfOSABI));
729 W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]);
730 W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD));
733 W.printEnum ("Type", Header->e_type, makeArrayRef(ElfObjectFileType));
734 W.printEnum ("Machine", Header->e_machine, makeArrayRef(ElfMachineType));
735 W.printNumber("Version", Header->e_version);
736 W.printHex ("Entry", Header->e_entry);
737 W.printHex ("ProgramHeaderOffset", Header->e_phoff);
738 W.printHex ("SectionHeaderOffset", Header->e_shoff);
739 if (Header->e_machine == EM_MIPS)
740 W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags),
741 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
742 unsigned(ELF::EF_MIPS_MACH));
744 W.printFlags("Flags", Header->e_flags);
745 W.printNumber("HeaderSize", Header->e_ehsize);
746 W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize);
747 W.printNumber("ProgramHeaderCount", Header->e_phnum);
748 W.printNumber("SectionHeaderEntrySize", Header->e_shentsize);
749 W.printNumber("SectionHeaderCount", Header->e_shnum);
750 W.printNumber("StringTableSectionIndex", Header->e_shstrndx);
755 void ELFDumper<ELFT>::printSections() {
756 ListScope SectionsD(W, "Sections");
758 int SectionIndex = -1;
759 for (const Elf_Shdr &Sec : Obj->sections()) {
762 StringRef Name = errorOrDefault(Obj->getSectionName(&Sec));
764 DictScope SectionD(W, "Section");
765 W.printNumber("Index", SectionIndex);
766 W.printNumber("Name", Name, Sec.sh_name);
768 getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type),
770 W.printFlags("Flags", Sec.sh_flags, makeArrayRef(ElfSectionFlags));
771 W.printHex("Address", Sec.sh_addr);
772 W.printHex("Offset", Sec.sh_offset);
773 W.printNumber("Size", Sec.sh_size);
774 W.printNumber("Link", Sec.sh_link);
775 W.printNumber("Info", Sec.sh_info);
776 W.printNumber("AddressAlignment", Sec.sh_addralign);
777 W.printNumber("EntrySize", Sec.sh_entsize);
779 if (opts::SectionRelocations) {
780 ListScope D(W, "Relocations");
781 printRelocations(&Sec);
784 if (opts::SectionSymbols) {
785 ListScope D(W, "Symbols");
786 const Elf_Shdr *Symtab = Obj->getDotSymtabSec();
787 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
788 error(StrTableOrErr.getError());
789 StringRef StrTable = *StrTableOrErr;
791 for (const Elf_Sym &Sym : Obj->symbols()) {
792 ErrorOr<const Elf_Shdr *> SymSec = Obj->getSection(&Sym);
796 printSymbol(&Sym, StrTable, false);
800 if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
801 ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(&Sec));
802 W.printBinaryBlock("SectionData",
803 StringRef((const char *)Data.data(), Data.size()));
809 void ELFDumper<ELFT>::printRelocations() {
810 ListScope D(W, "Relocations");
812 int SectionNumber = -1;
813 for (const Elf_Shdr &Sec : Obj->sections()) {
816 if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA)
819 StringRef Name = errorOrDefault(Obj->getSectionName(&Sec));
821 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
824 printRelocations(&Sec);
827 W.startLine() << "}\n";
832 void ELFDumper<ELFT>::printDynamicRelocations() {
833 W.startLine() << "Dynamic Relocations {\n";
835 for (const Elf_Rela &Rel : dyn_relas()) {
836 SmallString<32> RelocName;
837 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
838 StringRef SymbolName;
839 uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
840 const Elf_Sym *Sym = Obj->dynamic_symbol_begin() + SymIndex;
841 SymbolName = errorOrDefault(Sym->getName(DynamicStringTable));
842 if (opts::ExpandRelocs) {
843 DictScope Group(W, "Relocation");
844 W.printHex("Offset", Rel.r_offset);
845 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
846 W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-");
847 W.printHex("Addend", Rel.r_addend);
850 raw_ostream& OS = W.startLine();
851 OS << W.hex(Rel.r_offset) << " " << RelocName << " "
852 << (SymbolName.size() > 0 ? SymbolName : "-") << " "
853 << W.hex(Rel.r_addend) << "\n";
857 W.startLine() << "}\n";
860 template <class ELFT>
861 void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
862 switch (Sec->sh_type) {
864 for (const Elf_Rel &R : Obj->rels(Sec)) {
866 Rela.r_offset = R.r_offset;
867 Rela.r_info = R.r_info;
869 printRelocation(Sec, Rela);
873 for (const Elf_Rela &R : Obj->relas(Sec))
874 printRelocation(Sec, R);
879 template <class ELFT>
880 void ELFDumper<ELFT>::printRelocation(const Elf_Shdr *Sec, Elf_Rela Rel) {
881 SmallString<32> RelocName;
882 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
883 StringRef TargetName;
884 std::pair<const Elf_Shdr *, const Elf_Sym *> Sym =
885 Obj->getRelocationSymbol(Sec, &Rel);
886 if (Sym.second && Sym.second->getType() == ELF::STT_SECTION) {
887 ErrorOr<const Elf_Shdr *> Sec = Obj->getSection(Sym.second);
888 error(Sec.getError());
889 ErrorOr<StringRef> SecName = Obj->getSectionName(*Sec);
891 TargetName = SecName.get();
892 } else if (Sym.first) {
893 const Elf_Shdr *SymTable = Sym.first;
894 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*SymTable);
895 error(StrTableOrErr.getError());
896 TargetName = errorOrDefault(Sym.second->getName(*StrTableOrErr));
899 if (opts::ExpandRelocs) {
900 DictScope Group(W, "Relocation");
901 W.printHex("Offset", Rel.r_offset);
902 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
903 W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-",
904 Rel.getSymbol(Obj->isMips64EL()));
905 W.printHex("Addend", Rel.r_addend);
907 raw_ostream& OS = W.startLine();
908 OS << W.hex(Rel.r_offset) << " " << RelocName << " "
909 << (TargetName.size() > 0 ? TargetName : "-") << " "
910 << W.hex(Rel.r_addend) << "\n";
915 void ELFDumper<ELFT>::printSymbols() {
916 ListScope Group(W, "Symbols");
918 const Elf_Shdr *Symtab = Obj->getDotSymtabSec();
919 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
920 error(StrTableOrErr.getError());
921 StringRef StrTable = *StrTableOrErr;
922 for (const Elf_Sym &Sym : Obj->symbols())
923 printSymbol(&Sym, StrTable, false);
927 void ELFDumper<ELFT>::printDynamicSymbols() {
928 ListScope Group(W, "DynamicSymbols");
930 const Elf_Shdr *Symtab = Obj->getDotDynSymSec();
931 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
932 error(StrTableOrErr.getError());
933 StringRef StrTable = *StrTableOrErr;
934 for (const Elf_Sym &Sym : Obj->dynamic_symbols())
935 printSymbol(&Sym, StrTable, true);
938 template <class ELFT>
939 void ELFDumper<ELFT>::printSymbol(const Elf_Sym *Symbol, StringRef StrTable,
941 unsigned SectionIndex = 0;
942 StringRef SectionName;
943 getSectionNameIndex(*Obj, Symbol, SectionName, SectionIndex);
944 std::string FullSymbolName =
945 getFullSymbolName(*Obj, Symbol, StrTable, IsDynamic);
947 DictScope D(W, "Symbol");
948 W.printNumber("Name", FullSymbolName, Symbol->st_name);
949 W.printHex ("Value", Symbol->st_value);
950 W.printNumber("Size", Symbol->st_size);
951 W.printEnum ("Binding", Symbol->getBinding(),
952 makeArrayRef(ElfSymbolBindings));
953 W.printEnum ("Type", Symbol->getType(), makeArrayRef(ElfSymbolTypes));
954 W.printNumber("Other", Symbol->st_other);
955 W.printHex("Section", SectionName, SectionIndex);
958 #define LLVM_READOBJ_TYPE_CASE(name) \
959 case DT_##name: return #name
961 static const char *getTypeString(uint64_t Type) {
963 LLVM_READOBJ_TYPE_CASE(BIND_NOW);
964 LLVM_READOBJ_TYPE_CASE(DEBUG);
965 LLVM_READOBJ_TYPE_CASE(FINI);
966 LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
967 LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
968 LLVM_READOBJ_TYPE_CASE(FLAGS);
969 LLVM_READOBJ_TYPE_CASE(FLAGS_1);
970 LLVM_READOBJ_TYPE_CASE(HASH);
971 LLVM_READOBJ_TYPE_CASE(INIT);
972 LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
973 LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
974 LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
975 LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
976 LLVM_READOBJ_TYPE_CASE(JMPREL);
977 LLVM_READOBJ_TYPE_CASE(NEEDED);
978 LLVM_READOBJ_TYPE_CASE(NULL);
979 LLVM_READOBJ_TYPE_CASE(PLTGOT);
980 LLVM_READOBJ_TYPE_CASE(PLTREL);
981 LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
982 LLVM_READOBJ_TYPE_CASE(REL);
983 LLVM_READOBJ_TYPE_CASE(RELA);
984 LLVM_READOBJ_TYPE_CASE(RELENT);
985 LLVM_READOBJ_TYPE_CASE(RELSZ);
986 LLVM_READOBJ_TYPE_CASE(RELAENT);
987 LLVM_READOBJ_TYPE_CASE(RELASZ);
988 LLVM_READOBJ_TYPE_CASE(RPATH);
989 LLVM_READOBJ_TYPE_CASE(RUNPATH);
990 LLVM_READOBJ_TYPE_CASE(SONAME);
991 LLVM_READOBJ_TYPE_CASE(STRSZ);
992 LLVM_READOBJ_TYPE_CASE(STRTAB);
993 LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
994 LLVM_READOBJ_TYPE_CASE(SYMENT);
995 LLVM_READOBJ_TYPE_CASE(SYMTAB);
996 LLVM_READOBJ_TYPE_CASE(TEXTREL);
997 LLVM_READOBJ_TYPE_CASE(VERNEED);
998 LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
999 LLVM_READOBJ_TYPE_CASE(VERSYM);
1000 LLVM_READOBJ_TYPE_CASE(RELCOUNT);
1001 LLVM_READOBJ_TYPE_CASE(GNU_HASH);
1002 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
1003 LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
1004 LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
1005 LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
1006 LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
1007 LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
1008 LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
1009 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
1010 LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
1011 LLVM_READOBJ_TYPE_CASE(MIPS_OPTIONS);
1012 default: return "unknown";
1016 #undef LLVM_READOBJ_TYPE_CASE
1018 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
1019 { #enum, prefix##_##enum }
1021 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
1022 LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
1023 LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
1024 LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
1025 LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
1026 LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
1029 static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
1030 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
1031 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
1032 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
1033 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
1034 LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
1035 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
1036 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
1037 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
1038 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
1039 LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
1040 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
1041 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
1042 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
1043 LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
1044 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
1045 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
1046 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
1047 LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
1048 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
1049 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
1050 LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
1051 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
1052 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
1053 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
1054 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON)
1057 static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
1058 LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
1059 LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
1060 LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
1061 LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
1062 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
1063 LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
1064 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
1065 LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
1066 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
1067 LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
1068 LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
1069 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
1070 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
1071 LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
1072 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
1073 LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
1076 #undef LLVM_READOBJ_DT_FLAG_ENT
1078 template <typename T, typename TFlag>
1079 void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
1080 typedef EnumEntry<TFlag> FlagEntry;
1081 typedef SmallVector<FlagEntry, 10> FlagVector;
1082 FlagVector SetFlags;
1084 for (const auto &Flag : Flags) {
1085 if (Flag.Value == 0)
1088 if ((Value & Flag.Value) == Flag.Value)
1089 SetFlags.push_back(Flag);
1092 for (const auto &Flag : SetFlags) {
1093 OS << Flag.Name << " ";
1097 template <class ELFT>
1098 StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const {
1099 if (Value >= DynamicStringTable.size())
1100 reportError("Invalid dynamic string table reference");
1101 return StringRef(DynamicStringTable.data() + Value);
1104 template <class ELFT>
1105 void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) {
1106 raw_ostream &OS = W.getOStream();
1109 if (Value == DT_REL) {
1112 } else if (Value == DT_RELA) {
1128 case DT_PREINIT_ARRAY:
1134 case DT_MIPS_BASE_ADDRESS:
1135 case DT_MIPS_GOTSYM:
1136 case DT_MIPS_RLD_MAP:
1137 case DT_MIPS_PLTGOT:
1138 case DT_MIPS_OPTIONS:
1139 OS << format("0x%" PRIX64, Value);
1143 case DT_MIPS_RLD_VERSION:
1144 case DT_MIPS_LOCAL_GOTNO:
1145 case DT_MIPS_SYMTABNO:
1146 case DT_MIPS_UNREFEXTNO:
1156 case DT_INIT_ARRAYSZ:
1157 case DT_FINI_ARRAYSZ:
1158 case DT_PREINIT_ARRAYSZ:
1159 OS << Value << " (bytes)";
1162 OS << "SharedLibrary (" << getDynamicString(Value) << ")";
1165 OS << "LibrarySoname (" << getDynamicString(Value) << ")";
1169 OS << getDynamicString(Value);
1172 printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
1175 printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
1178 printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
1181 OS << format("0x%" PRIX64, Value);
1186 template<class ELFT>
1187 void ELFDumper<ELFT>::printUnwindInfo() {
1188 W.startLine() << "UnwindInfo not implemented.\n";
1192 template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() {
1193 const unsigned Machine = Obj->getHeader()->e_machine;
1194 if (Machine == EM_ARM) {
1195 ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx(W, Obj);
1196 return Ctx.PrintUnwindInformation();
1198 W.startLine() << "UnwindInfo not implemented.\n";
1202 template<class ELFT>
1203 void ELFDumper<ELFT>::printDynamicTable() {
1204 auto I = dynamic_table_begin();
1205 auto E = dynamic_table_end();
1211 while (I != E && E->getTag() == ELF::DT_NULL)
1213 if (E->getTag() != ELF::DT_NULL)
1217 ptrdiff_t Total = std::distance(I, E);
1221 raw_ostream &OS = W.getOStream();
1222 W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
1224 bool Is64 = ELFT::Is64Bits;
1227 << " Tag" << (Is64 ? " " : " ") << "Type"
1228 << " " << "Name/Value\n";
1230 const Elf_Dyn &Entry = *I;
1234 << format(Is64 ? "0x%016" PRIX64 : "0x%08" PRIX64, Entry.getTag())
1235 << " " << format("%-21s", getTypeString(Entry.getTag()));
1236 printValue(Entry.getTag(), Entry.getVal());
1240 W.startLine() << "]\n";
1243 template<class ELFT>
1244 void ELFDumper<ELFT>::printNeededLibraries() {
1245 ListScope D(W, "NeededLibraries");
1247 typedef std::vector<StringRef> LibsTy;
1250 for (const auto &Entry : dynamic_table())
1251 if (Entry.d_tag == ELF::DT_NEEDED)
1252 Libs.push_back(getDynamicString(Entry.d_un.d_val));
1254 std::stable_sort(Libs.begin(), Libs.end());
1256 for (LibsTy::const_iterator I = Libs.begin(), E = Libs.end(); I != E; ++I) {
1257 outs() << " " << *I << "\n";
1261 template<class ELFT>
1262 void ELFDumper<ELFT>::printProgramHeaders() {
1263 ListScope L(W, "ProgramHeaders");
1265 for (const Elf_Phdr &Phdr : Obj->program_headers()) {
1266 DictScope P(W, "ProgramHeader");
1268 getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
1270 W.printHex("Offset", Phdr.p_offset);
1271 W.printHex("VirtualAddress", Phdr.p_vaddr);
1272 W.printHex("PhysicalAddress", Phdr.p_paddr);
1273 W.printNumber("FileSize", Phdr.p_filesz);
1274 W.printNumber("MemSize", Phdr.p_memsz);
1275 W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
1276 W.printNumber("Alignment", Phdr.p_align);
1280 template <typename ELFT>
1281 void ELFDumper<ELFT>::printHashTable() {
1282 DictScope D(W, "HashTable");
1285 W.printNumber("Num Buckets", HashTable->nbucket);
1286 W.printNumber("Num Chains", HashTable->nchain);
1287 W.printList("Buckets", HashTable->buckets());
1288 W.printList("Chains", HashTable->chains());
1291 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
1292 outs() << "LoadName: " << SOName << '\n';
1295 template <class ELFT>
1296 void ELFDumper<ELFT>::printAttributes() {
1297 W.startLine() << "Attributes not implemented.\n";
1301 template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() {
1302 if (Obj->getHeader()->e_machine != EM_ARM) {
1303 W.startLine() << "Attributes not implemented.\n";
1307 DictScope BA(W, "BuildAttributes");
1308 for (const ELFO::Elf_Shdr &Sec : Obj->sections()) {
1309 if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
1312 ErrorOr<ArrayRef<uint8_t>> Contents = Obj->getSectionContents(&Sec);
1316 if ((*Contents)[0] != ARMBuildAttrs::Format_Version) {
1317 errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0])
1322 W.printHex("FormatVersion", (*Contents)[0]);
1323 if (Contents->size() == 1)
1326 ARMAttributeParser(W).Parse(*Contents);
1332 template <class ELFT> class MipsGOTParser {
1334 typedef object::ELFFile<ELFT> ELFO;
1335 typedef typename ELFO::Elf_Shdr Elf_Shdr;
1336 typedef typename ELFO::Elf_Sym Elf_Sym;
1337 typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
1338 typedef typename ELFO::Elf_Addr GOTEntry;
1339 typedef typename ELFO::Elf_Rel Elf_Rel;
1340 typedef typename ELFO::Elf_Rela Elf_Rela;
1342 MipsGOTParser(const ELFO *Obj, Elf_Dyn_Range DynTable, StreamWriter &W);
1350 llvm::Optional<uint64_t> DtPltGot;
1351 llvm::Optional<uint64_t> DtLocalGotNum;
1352 llvm::Optional<uint64_t> DtGotSym;
1353 llvm::Optional<uint64_t> DtMipsPltGot;
1354 llvm::Optional<uint64_t> DtJmpRel;
1356 std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1357 const GOTEntry *makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1359 void printGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1360 const GOTEntry *It);
1361 void printGlobalGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1362 const GOTEntry *It, const Elf_Sym *Sym,
1363 StringRef StrTable, bool IsDynamic);
1364 void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1365 const GOTEntry *It, StringRef Purpose);
1366 void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1367 const GOTEntry *It, StringRef StrTable,
1368 const Elf_Sym *Sym);
1372 template <class ELFT>
1373 MipsGOTParser<ELFT>::MipsGOTParser(const ELFO *Obj, Elf_Dyn_Range DynTable,
1376 for (const auto &Entry : DynTable) {
1377 switch (Entry.getTag()) {
1378 case ELF::DT_PLTGOT:
1379 DtPltGot = Entry.getVal();
1381 case ELF::DT_MIPS_LOCAL_GOTNO:
1382 DtLocalGotNum = Entry.getVal();
1384 case ELF::DT_MIPS_GOTSYM:
1385 DtGotSym = Entry.getVal();
1387 case ELF::DT_MIPS_PLTGOT:
1388 DtMipsPltGot = Entry.getVal();
1390 case ELF::DT_JMPREL:
1391 DtJmpRel = Entry.getVal();
1397 template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() {
1398 // See "Global Offset Table" in Chapter 5 in the following document
1399 // for detailed GOT description.
1400 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1402 W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1405 if (!DtLocalGotNum) {
1406 W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1410 W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1414 const Elf_Shdr *GOTShdr = findSectionByAddress(Obj, *DtPltGot);
1416 W.startLine() << "There is no .got section in the file.\n";
1420 ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(GOTShdr);
1422 W.startLine() << "The .got section is empty.\n";
1426 if (*DtLocalGotNum > getGOTTotal(*GOT)) {
1427 W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n";
1431 const Elf_Shdr *DynSymSec = Obj->getDotDynSymSec();
1432 ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(*DynSymSec);
1433 error(StrTable.getError());
1434 const Elf_Sym *DynSymBegin = Obj->dynamic_symbol_begin();
1435 const Elf_Sym *DynSymEnd = Obj->dynamic_symbol_end();
1436 std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1438 if (*DtGotSym > DynSymTotal) {
1439 W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n";
1443 std::size_t GlobalGotNum = DynSymTotal - *DtGotSym;
1445 if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) {
1446 W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n";
1450 const GOTEntry *GotBegin = makeGOTIter(*GOT, 0);
1451 const GOTEntry *GotLocalEnd = makeGOTIter(*GOT, *DtLocalGotNum);
1452 const GOTEntry *It = GotBegin;
1454 DictScope GS(W, "Primary GOT");
1456 W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0);
1458 ListScope RS(W, "Reserved entries");
1461 DictScope D(W, "Entry");
1462 printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1463 W.printString("Purpose", StringRef("Lazy resolver"));
1466 if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
1467 DictScope D(W, "Entry");
1468 printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1469 W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
1473 ListScope LS(W, "Local entries");
1474 for (; It != GotLocalEnd; ++It) {
1475 DictScope D(W, "Entry");
1476 printGotEntry(GOTShdr->sh_addr, GotBegin, It);
1480 ListScope GS(W, "Global entries");
1482 const GOTEntry *GotGlobalEnd =
1483 makeGOTIter(*GOT, *DtLocalGotNum + GlobalGotNum);
1484 const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym;
1485 for (; It != GotGlobalEnd; ++It) {
1486 DictScope D(W, "Entry");
1487 printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++,
1492 std::size_t SpecGotNum = getGOTTotal(*GOT) - *DtLocalGotNum - GlobalGotNum;
1493 W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
1496 template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() {
1497 if (!DtMipsPltGot) {
1498 W.startLine() << "Cannot find MIPS_PLTGOT dynamic table tag.\n";
1502 W.startLine() << "Cannot find JMPREL dynamic table tag.\n";
1506 const Elf_Shdr *PLTShdr = findSectionByAddress(Obj, *DtMipsPltGot);
1508 W.startLine() << "There is no .got.plt section in the file.\n";
1511 ErrorOr<ArrayRef<uint8_t>> PLT = Obj->getSectionContents(PLTShdr);
1513 W.startLine() << "The .got.plt section is empty.\n";
1517 const Elf_Shdr *PLTRelShdr = findSectionByAddress(Obj, *DtJmpRel);
1519 W.startLine() << "There is no .rel.plt section in the file.\n";
1522 ErrorOr<const Elf_Shdr *> SymTableOrErr =
1523 Obj->getSection(PLTRelShdr->sh_link);
1524 error(SymTableOrErr.getError());
1525 ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(**SymTableOrErr);
1526 error(StrTable.getError());
1528 const GOTEntry *PLTBegin = makeGOTIter(*PLT, 0);
1529 const GOTEntry *PLTEnd = makeGOTIter(*PLT, getGOTTotal(*PLT));
1530 const GOTEntry *It = PLTBegin;
1532 DictScope GS(W, "PLT GOT");
1534 ListScope RS(W, "Reserved entries");
1535 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "PLT lazy resolver");
1537 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "Module pointer");
1540 ListScope GS(W, "Entries");
1542 switch (PLTRelShdr->sh_type) {
1544 for (const Elf_Rel *RI = Obj->rel_begin(PLTRelShdr),
1545 *RE = Obj->rel_end(PLTRelShdr);
1546 RI != RE && It != PLTEnd; ++RI, ++It) {
1547 const Elf_Sym *Sym =
1548 Obj->getRelocationSymbol(&*PLTRelShdr, &*RI).second;
1549 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym);
1553 for (const Elf_Rela *RI = Obj->rela_begin(PLTRelShdr),
1554 *RE = Obj->rela_end(PLTRelShdr);
1555 RI != RE && It != PLTEnd; ++RI, ++It) {
1556 const Elf_Sym *Sym =
1557 Obj->getRelocationSymbol(&*PLTRelShdr, &*RI).second;
1558 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym);
1565 template <class ELFT>
1566 std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
1567 return GOT.size() / sizeof(GOTEntry);
1570 template <class ELFT>
1571 const typename MipsGOTParser<ELFT>::GOTEntry *
1572 MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
1573 const char *Data = reinterpret_cast<const char *>(GOT.data());
1574 return reinterpret_cast<const GOTEntry *>(Data + EntryNum * sizeof(GOTEntry));
1577 template <class ELFT>
1578 void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr,
1579 const GOTEntry *BeginIt,
1580 const GOTEntry *It) {
1581 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1582 W.printHex("Address", GotAddr + Offset);
1583 W.printNumber("Access", Offset - 0x7ff0);
1584 W.printHex("Initial", *It);
1587 template <class ELFT>
1588 void MipsGOTParser<ELFT>::printGlobalGotEntry(
1589 uint64_t GotAddr, const GOTEntry *BeginIt, const GOTEntry *It,
1590 const Elf_Sym *Sym, StringRef StrTable, bool IsDynamic) {
1591 printGotEntry(GotAddr, BeginIt, It);
1593 W.printHex("Value", Sym->st_value);
1594 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1596 unsigned SectionIndex = 0;
1597 StringRef SectionName;
1598 getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1599 W.printHex("Section", SectionName, SectionIndex);
1601 std::string FullSymbolName =
1602 getFullSymbolName(*Obj, Sym, StrTable, IsDynamic);
1603 W.printNumber("Name", FullSymbolName, Sym->st_name);
1606 template <class ELFT>
1607 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
1608 const GOTEntry *BeginIt,
1609 const GOTEntry *It, StringRef Purpose) {
1610 DictScope D(W, "Entry");
1611 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1612 W.printHex("Address", PLTAddr + Offset);
1613 W.printHex("Initial", *It);
1614 W.printString("Purpose", Purpose);
1617 template <class ELFT>
1618 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
1619 const GOTEntry *BeginIt,
1620 const GOTEntry *It, StringRef StrTable,
1621 const Elf_Sym *Sym) {
1622 DictScope D(W, "Entry");
1623 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1624 W.printHex("Address", PLTAddr + Offset);
1625 W.printHex("Initial", *It);
1626 W.printHex("Value", Sym->st_value);
1627 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1629 unsigned SectionIndex = 0;
1630 StringRef SectionName;
1631 getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1632 W.printHex("Section", SectionName, SectionIndex);
1634 std::string FullSymbolName = getFullSymbolName(*Obj, Sym, StrTable, true);
1635 W.printNumber("Name", FullSymbolName, Sym->st_name);
1638 template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
1639 if (Obj->getHeader()->e_machine != EM_MIPS) {
1640 W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
1644 MipsGOTParser<ELFT> GOTParser(Obj, dynamic_table(), W);
1645 GOTParser.parseGOT();
1646 GOTParser.parsePLT();
1649 static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
1650 {"None", Mips::AFL_EXT_NONE},
1651 {"Broadcom SB-1", Mips::AFL_EXT_SB1},
1652 {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON},
1653 {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
1654 {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
1655 {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
1656 {"LSI R4010", Mips::AFL_EXT_4010},
1657 {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E},
1658 {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F},
1659 {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A},
1660 {"MIPS R4650", Mips::AFL_EXT_4650},
1661 {"MIPS R5900", Mips::AFL_EXT_5900},
1662 {"MIPS R10000", Mips::AFL_EXT_10000},
1663 {"NEC VR4100", Mips::AFL_EXT_4100},
1664 {"NEC VR4111/VR4181", Mips::AFL_EXT_4111},
1665 {"NEC VR4120", Mips::AFL_EXT_4120},
1666 {"NEC VR5400", Mips::AFL_EXT_5400},
1667 {"NEC VR5500", Mips::AFL_EXT_5500},
1668 {"RMI Xlr", Mips::AFL_EXT_XLR},
1669 {"Toshiba R3900", Mips::AFL_EXT_3900}
1672 static const EnumEntry<unsigned> ElfMipsASEFlags[] = {
1673 {"DSP", Mips::AFL_ASE_DSP},
1674 {"DSPR2", Mips::AFL_ASE_DSPR2},
1675 {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
1676 {"MCU", Mips::AFL_ASE_MCU},
1677 {"MDMX", Mips::AFL_ASE_MDMX},
1678 {"MIPS-3D", Mips::AFL_ASE_MIPS3D},
1679 {"MT", Mips::AFL_ASE_MT},
1680 {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS},
1681 {"VZ", Mips::AFL_ASE_VIRT},
1682 {"MSA", Mips::AFL_ASE_MSA},
1683 {"MIPS16", Mips::AFL_ASE_MIPS16},
1684 {"microMIPS", Mips::AFL_ASE_MICROMIPS},
1685 {"XPA", Mips::AFL_ASE_XPA}
1688 static const EnumEntry<unsigned> ElfMipsFpABIType[] = {
1689 {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY},
1690 {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
1691 {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
1692 {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT},
1693 {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
1694 Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
1695 {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX},
1696 {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
1697 {"Hard float compat (32-bit CPU, 64-bit FPU)",
1698 Mips::Val_GNU_MIPS_ABI_FP_64A}
1701 static const EnumEntry<unsigned> ElfMipsFlags1[] {
1702 {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
1705 static int getMipsRegisterSize(uint8_t Flag) {
1707 case Mips::AFL_REG_NONE:
1709 case Mips::AFL_REG_32:
1711 case Mips::AFL_REG_64:
1713 case Mips::AFL_REG_128:
1720 template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() {
1721 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags");
1723 W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
1726 ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr);
1728 W.startLine() << "The .MIPS.abiflags section is empty.\n";
1731 if (Sec->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
1732 W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
1736 auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec->data());
1738 raw_ostream &OS = W.getOStream();
1739 DictScope GS(W, "MIPS ABI Flags");
1741 W.printNumber("Version", Flags->version);
1742 W.startLine() << "ISA: ";
1743 if (Flags->isa_rev <= 1)
1744 OS << format("MIPS%u", Flags->isa_level);
1746 OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
1748 W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType));
1749 W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
1750 W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
1751 W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
1752 W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
1753 W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
1754 W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
1755 W.printHex("Flags 2", Flags->flags2);
1758 template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
1759 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo");
1761 W.startLine() << "There is no .reginfo section in the file.\n";
1764 ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr);
1766 W.startLine() << "The .reginfo section is empty.\n";
1769 if (Sec->size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
1770 W.startLine() << "The .reginfo section has a wrong size.\n";
1774 auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec->data());
1776 DictScope GS(W, "MIPS RegInfo");
1777 W.printHex("GP", Reginfo->ri_gp_value);
1778 W.printHex("General Mask", Reginfo->ri_gprmask);
1779 W.printHex("Co-Proc Mask0", Reginfo->ri_cprmask[0]);
1780 W.printHex("Co-Proc Mask1", Reginfo->ri_cprmask[1]);
1781 W.printHex("Co-Proc Mask2", Reginfo->ri_cprmask[2]);
1782 W.printHex("Co-Proc Mask3", Reginfo->ri_cprmask[3]);
1785 template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
1786 const Elf_Shdr *StackMapSection = nullptr;
1787 for (const auto &Sec : Obj->sections()) {
1788 ErrorOr<StringRef> Name = Obj->getSectionName(&Sec);
1789 if (*Name == ".llvm_stackmaps") {
1790 StackMapSection = &Sec;
1795 if (!StackMapSection)
1798 StringRef StackMapContents;
1799 ErrorOr<ArrayRef<uint8_t>> StackMapContentsArray =
1800 Obj->getSectionContents(StackMapSection);
1802 prettyPrintStackMap(
1804 StackMapV1Parser<ELFT::TargetEndianness>(*StackMapContentsArray));