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;
113 const Elf_Sym *DynSymStart = nullptr;
115 const Elf_Hash *HashTable = nullptr;
118 template <class T> T errorOrDefault(ErrorOr<T> Val, T Default = T()) {
120 error(Val.getError());
130 template <class ELFT>
131 static std::error_code createELFDumper(const ELFFile<ELFT> *Obj,
132 StreamWriter &Writer,
133 std::unique_ptr<ObjDumper> &Result) {
134 Result.reset(new ELFDumper<ELFT>(Obj, Writer));
135 return readobj_error::success;
138 std::error_code createELFDumper(const object::ObjectFile *Obj,
139 StreamWriter &Writer,
140 std::unique_ptr<ObjDumper> &Result) {
141 // Little-endian 32-bit
142 if (const ELF32LEObjectFile *ELFObj = dyn_cast<ELF32LEObjectFile>(Obj))
143 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
146 if (const ELF32BEObjectFile *ELFObj = dyn_cast<ELF32BEObjectFile>(Obj))
147 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
149 // Little-endian 64-bit
150 if (const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj))
151 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
154 if (const ELF64BEObjectFile *ELFObj = dyn_cast<ELF64BEObjectFile>(Obj))
155 return createELFDumper(ELFObj->getELFFile(), Writer, Result);
157 return readobj_error::unsupported_obj_file_format;
162 template <typename ELFO>
163 static std::string getFullSymbolName(const ELFO &Obj,
164 const typename ELFO::Elf_Sym *Symbol,
165 StringRef StrTable, bool IsDynamic) {
166 StringRef SymbolName = errorOrDefault(Symbol->getName(StrTable));
170 std::string FullSymbolName(SymbolName);
173 ErrorOr<StringRef> Version =
174 Obj.getSymbolVersion(StrTable, &*Symbol, IsDefault);
176 FullSymbolName += (IsDefault ? "@@" : "@");
177 FullSymbolName += *Version;
179 error(Version.getError());
180 return FullSymbolName;
183 template <typename ELFO>
185 getSectionNameIndex(const ELFO &Obj, const typename ELFO::Elf_Sym *Symbol,
186 StringRef &SectionName, unsigned &SectionIndex) {
187 SectionIndex = Symbol->st_shndx;
188 if (Symbol->isUndefined())
189 SectionName = "Undefined";
190 else if (Symbol->isProcessorSpecific())
191 SectionName = "Processor Specific";
192 else if (Symbol->isOSSpecific())
193 SectionName = "Operating System Specific";
194 else if (Symbol->isAbsolute())
195 SectionName = "Absolute";
196 else if (Symbol->isCommon())
197 SectionName = "Common";
198 else if (Symbol->isReserved() && SectionIndex != SHN_XINDEX)
199 SectionName = "Reserved";
201 if (SectionIndex == SHN_XINDEX)
202 SectionIndex = Obj.getExtendedSymbolTableIndex(&*Symbol);
203 ErrorOr<const typename ELFO::Elf_Shdr *> Sec = Obj.getSection(SectionIndex);
204 error(Sec.getError());
205 SectionName = errorOrDefault(Obj.getSectionName(*Sec));
209 template <class ELFO>
210 static const typename ELFO::Elf_Shdr *findSectionByAddress(const ELFO *Obj,
212 for (const auto &Shdr : Obj->sections())
213 if (Shdr.sh_addr == Addr)
218 template <class ELFO>
219 static const typename ELFO::Elf_Shdr *findSectionByName(const ELFO &Obj,
221 for (const auto &Shdr : Obj.sections()) {
222 if (Name == errorOrDefault(Obj.getSectionName(&Shdr)))
228 static const EnumEntry<unsigned> ElfClass[] = {
229 { "None", ELF::ELFCLASSNONE },
230 { "32-bit", ELF::ELFCLASS32 },
231 { "64-bit", ELF::ELFCLASS64 },
234 static const EnumEntry<unsigned> ElfDataEncoding[] = {
235 { "None", ELF::ELFDATANONE },
236 { "LittleEndian", ELF::ELFDATA2LSB },
237 { "BigEndian", ELF::ELFDATA2MSB },
240 static const EnumEntry<unsigned> ElfObjectFileType[] = {
241 { "None", ELF::ET_NONE },
242 { "Relocatable", ELF::ET_REL },
243 { "Executable", ELF::ET_EXEC },
244 { "SharedObject", ELF::ET_DYN },
245 { "Core", ELF::ET_CORE },
248 static const EnumEntry<unsigned> ElfOSABI[] = {
249 { "SystemV", ELF::ELFOSABI_NONE },
250 { "HPUX", ELF::ELFOSABI_HPUX },
251 { "NetBSD", ELF::ELFOSABI_NETBSD },
252 { "GNU/Linux", ELF::ELFOSABI_LINUX },
253 { "GNU/Hurd", ELF::ELFOSABI_HURD },
254 { "Solaris", ELF::ELFOSABI_SOLARIS },
255 { "AIX", ELF::ELFOSABI_AIX },
256 { "IRIX", ELF::ELFOSABI_IRIX },
257 { "FreeBSD", ELF::ELFOSABI_FREEBSD },
258 { "TRU64", ELF::ELFOSABI_TRU64 },
259 { "Modesto", ELF::ELFOSABI_MODESTO },
260 { "OpenBSD", ELF::ELFOSABI_OPENBSD },
261 { "OpenVMS", ELF::ELFOSABI_OPENVMS },
262 { "NSK", ELF::ELFOSABI_NSK },
263 { "AROS", ELF::ELFOSABI_AROS },
264 { "FenixOS", ELF::ELFOSABI_FENIXOS },
265 { "CloudABI", ELF::ELFOSABI_CLOUDABI },
266 { "C6000_ELFABI", ELF::ELFOSABI_C6000_ELFABI },
267 { "C6000_LINUX" , ELF::ELFOSABI_C6000_LINUX },
268 { "ARM", ELF::ELFOSABI_ARM },
269 { "Standalone" , ELF::ELFOSABI_STANDALONE }
272 static const EnumEntry<unsigned> ElfMachineType[] = {
273 LLVM_READOBJ_ENUM_ENT(ELF, EM_NONE ),
274 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32 ),
275 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC ),
276 LLVM_READOBJ_ENUM_ENT(ELF, EM_386 ),
277 LLVM_READOBJ_ENUM_ENT(ELF, EM_68K ),
278 LLVM_READOBJ_ENUM_ENT(ELF, EM_88K ),
279 LLVM_READOBJ_ENUM_ENT(ELF, EM_IAMCU ),
280 LLVM_READOBJ_ENUM_ENT(ELF, EM_860 ),
281 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS ),
282 LLVM_READOBJ_ENUM_ENT(ELF, EM_S370 ),
283 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_RS3_LE ),
284 LLVM_READOBJ_ENUM_ENT(ELF, EM_PARISC ),
285 LLVM_READOBJ_ENUM_ENT(ELF, EM_VPP500 ),
286 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARC32PLUS ),
287 LLVM_READOBJ_ENUM_ENT(ELF, EM_960 ),
288 LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC ),
289 LLVM_READOBJ_ENUM_ENT(ELF, EM_PPC64 ),
290 LLVM_READOBJ_ENUM_ENT(ELF, EM_S390 ),
291 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPU ),
292 LLVM_READOBJ_ENUM_ENT(ELF, EM_V800 ),
293 LLVM_READOBJ_ENUM_ENT(ELF, EM_FR20 ),
294 LLVM_READOBJ_ENUM_ENT(ELF, EM_RH32 ),
295 LLVM_READOBJ_ENUM_ENT(ELF, EM_RCE ),
296 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARM ),
297 LLVM_READOBJ_ENUM_ENT(ELF, EM_ALPHA ),
298 LLVM_READOBJ_ENUM_ENT(ELF, EM_SH ),
299 LLVM_READOBJ_ENUM_ENT(ELF, EM_SPARCV9 ),
300 LLVM_READOBJ_ENUM_ENT(ELF, EM_TRICORE ),
301 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC ),
302 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300 ),
303 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_300H ),
304 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8S ),
305 LLVM_READOBJ_ENUM_ENT(ELF, EM_H8_500 ),
306 LLVM_READOBJ_ENUM_ENT(ELF, EM_IA_64 ),
307 LLVM_READOBJ_ENUM_ENT(ELF, EM_MIPS_X ),
308 LLVM_READOBJ_ENUM_ENT(ELF, EM_COLDFIRE ),
309 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC12 ),
310 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMA ),
311 LLVM_READOBJ_ENUM_ENT(ELF, EM_PCP ),
312 LLVM_READOBJ_ENUM_ENT(ELF, EM_NCPU ),
313 LLVM_READOBJ_ENUM_ENT(ELF, EM_NDR1 ),
314 LLVM_READOBJ_ENUM_ENT(ELF, EM_STARCORE ),
315 LLVM_READOBJ_ENUM_ENT(ELF, EM_ME16 ),
316 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST100 ),
317 LLVM_READOBJ_ENUM_ENT(ELF, EM_TINYJ ),
318 LLVM_READOBJ_ENUM_ENT(ELF, EM_X86_64 ),
319 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDSP ),
320 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP10 ),
321 LLVM_READOBJ_ENUM_ENT(ELF, EM_PDP11 ),
322 LLVM_READOBJ_ENUM_ENT(ELF, EM_FX66 ),
323 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST9PLUS ),
324 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST7 ),
325 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC16 ),
326 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC11 ),
327 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC08 ),
328 LLVM_READOBJ_ENUM_ENT(ELF, EM_68HC05 ),
329 LLVM_READOBJ_ENUM_ENT(ELF, EM_SVX ),
330 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST19 ),
331 LLVM_READOBJ_ENUM_ENT(ELF, EM_VAX ),
332 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRIS ),
333 LLVM_READOBJ_ENUM_ENT(ELF, EM_JAVELIN ),
334 LLVM_READOBJ_ENUM_ENT(ELF, EM_FIREPATH ),
335 LLVM_READOBJ_ENUM_ENT(ELF, EM_ZSP ),
336 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMIX ),
337 LLVM_READOBJ_ENUM_ENT(ELF, EM_HUANY ),
338 LLVM_READOBJ_ENUM_ENT(ELF, EM_PRISM ),
339 LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR ),
340 LLVM_READOBJ_ENUM_ENT(ELF, EM_FR30 ),
341 LLVM_READOBJ_ENUM_ENT(ELF, EM_D10V ),
342 LLVM_READOBJ_ENUM_ENT(ELF, EM_D30V ),
343 LLVM_READOBJ_ENUM_ENT(ELF, EM_V850 ),
344 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32R ),
345 LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10300 ),
346 LLVM_READOBJ_ENUM_ENT(ELF, EM_MN10200 ),
347 LLVM_READOBJ_ENUM_ENT(ELF, EM_PJ ),
348 LLVM_READOBJ_ENUM_ENT(ELF, EM_OPENRISC ),
349 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT ),
350 LLVM_READOBJ_ENUM_ENT(ELF, EM_XTENSA ),
351 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE ),
352 LLVM_READOBJ_ENUM_ENT(ELF, EM_TMM_GPP ),
353 LLVM_READOBJ_ENUM_ENT(ELF, EM_NS32K ),
354 LLVM_READOBJ_ENUM_ENT(ELF, EM_TPC ),
355 LLVM_READOBJ_ENUM_ENT(ELF, EM_SNP1K ),
356 LLVM_READOBJ_ENUM_ENT(ELF, EM_ST200 ),
357 LLVM_READOBJ_ENUM_ENT(ELF, EM_IP2K ),
358 LLVM_READOBJ_ENUM_ENT(ELF, EM_MAX ),
359 LLVM_READOBJ_ENUM_ENT(ELF, EM_CR ),
360 LLVM_READOBJ_ENUM_ENT(ELF, EM_F2MC16 ),
361 LLVM_READOBJ_ENUM_ENT(ELF, EM_MSP430 ),
362 LLVM_READOBJ_ENUM_ENT(ELF, EM_BLACKFIN ),
363 LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C33 ),
364 LLVM_READOBJ_ENUM_ENT(ELF, EM_SEP ),
365 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARCA ),
366 LLVM_READOBJ_ENUM_ENT(ELF, EM_UNICORE ),
367 LLVM_READOBJ_ENUM_ENT(ELF, EM_EXCESS ),
368 LLVM_READOBJ_ENUM_ENT(ELF, EM_DXP ),
369 LLVM_READOBJ_ENUM_ENT(ELF, EM_ALTERA_NIOS2 ),
370 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRX ),
371 LLVM_READOBJ_ENUM_ENT(ELF, EM_XGATE ),
372 LLVM_READOBJ_ENUM_ENT(ELF, EM_C166 ),
373 LLVM_READOBJ_ENUM_ENT(ELF, EM_M16C ),
374 LLVM_READOBJ_ENUM_ENT(ELF, EM_DSPIC30F ),
375 LLVM_READOBJ_ENUM_ENT(ELF, EM_CE ),
376 LLVM_READOBJ_ENUM_ENT(ELF, EM_M32C ),
377 LLVM_READOBJ_ENUM_ENT(ELF, EM_TSK3000 ),
378 LLVM_READOBJ_ENUM_ENT(ELF, EM_RS08 ),
379 LLVM_READOBJ_ENUM_ENT(ELF, EM_SHARC ),
380 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG2 ),
381 LLVM_READOBJ_ENUM_ENT(ELF, EM_SCORE7 ),
382 LLVM_READOBJ_ENUM_ENT(ELF, EM_DSP24 ),
383 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE3 ),
384 LLVM_READOBJ_ENUM_ENT(ELF, EM_LATTICEMICO32),
385 LLVM_READOBJ_ENUM_ENT(ELF, EM_SE_C17 ),
386 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C6000 ),
387 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C2000 ),
388 LLVM_READOBJ_ENUM_ENT(ELF, EM_TI_C5500 ),
389 LLVM_READOBJ_ENUM_ENT(ELF, EM_MMDSP_PLUS ),
390 LLVM_READOBJ_ENUM_ENT(ELF, EM_CYPRESS_M8C ),
391 LLVM_READOBJ_ENUM_ENT(ELF, EM_R32C ),
392 LLVM_READOBJ_ENUM_ENT(ELF, EM_TRIMEDIA ),
393 LLVM_READOBJ_ENUM_ENT(ELF, EM_HEXAGON ),
394 LLVM_READOBJ_ENUM_ENT(ELF, EM_8051 ),
395 LLVM_READOBJ_ENUM_ENT(ELF, EM_STXP7X ),
396 LLVM_READOBJ_ENUM_ENT(ELF, EM_NDS32 ),
397 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1 ),
398 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG1X ),
399 LLVM_READOBJ_ENUM_ENT(ELF, EM_MAXQ30 ),
400 LLVM_READOBJ_ENUM_ENT(ELF, EM_XIMO16 ),
401 LLVM_READOBJ_ENUM_ENT(ELF, EM_MANIK ),
402 LLVM_READOBJ_ENUM_ENT(ELF, EM_CRAYNV2 ),
403 LLVM_READOBJ_ENUM_ENT(ELF, EM_RX ),
404 LLVM_READOBJ_ENUM_ENT(ELF, EM_METAG ),
405 LLVM_READOBJ_ENUM_ENT(ELF, EM_MCST_ELBRUS ),
406 LLVM_READOBJ_ENUM_ENT(ELF, EM_ECOG16 ),
407 LLVM_READOBJ_ENUM_ENT(ELF, EM_CR16 ),
408 LLVM_READOBJ_ENUM_ENT(ELF, EM_ETPU ),
409 LLVM_READOBJ_ENUM_ENT(ELF, EM_SLE9X ),
410 LLVM_READOBJ_ENUM_ENT(ELF, EM_L10M ),
411 LLVM_READOBJ_ENUM_ENT(ELF, EM_K10M ),
412 LLVM_READOBJ_ENUM_ENT(ELF, EM_AARCH64 ),
413 LLVM_READOBJ_ENUM_ENT(ELF, EM_AVR32 ),
414 LLVM_READOBJ_ENUM_ENT(ELF, EM_STM8 ),
415 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILE64 ),
416 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEPRO ),
417 LLVM_READOBJ_ENUM_ENT(ELF, EM_CUDA ),
418 LLVM_READOBJ_ENUM_ENT(ELF, EM_TILEGX ),
419 LLVM_READOBJ_ENUM_ENT(ELF, EM_CLOUDSHIELD ),
420 LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_1ST ),
421 LLVM_READOBJ_ENUM_ENT(ELF, EM_COREA_2ND ),
422 LLVM_READOBJ_ENUM_ENT(ELF, EM_ARC_COMPACT2 ),
423 LLVM_READOBJ_ENUM_ENT(ELF, EM_OPEN8 ),
424 LLVM_READOBJ_ENUM_ENT(ELF, EM_RL78 ),
425 LLVM_READOBJ_ENUM_ENT(ELF, EM_VIDEOCORE5 ),
426 LLVM_READOBJ_ENUM_ENT(ELF, EM_78KOR ),
427 LLVM_READOBJ_ENUM_ENT(ELF, EM_56800EX ),
428 LLVM_READOBJ_ENUM_ENT(ELF, EM_AMDGPU )
431 static const EnumEntry<unsigned> ElfSymbolBindings[] = {
432 { "Local", ELF::STB_LOCAL },
433 { "Global", ELF::STB_GLOBAL },
434 { "Weak", ELF::STB_WEAK },
435 { "Unique", ELF::STB_GNU_UNIQUE }
438 static const EnumEntry<unsigned> ElfSymbolTypes[] = {
439 { "None", ELF::STT_NOTYPE },
440 { "Object", ELF::STT_OBJECT },
441 { "Function", ELF::STT_FUNC },
442 { "Section", ELF::STT_SECTION },
443 { "File", ELF::STT_FILE },
444 { "Common", ELF::STT_COMMON },
445 { "TLS", ELF::STT_TLS },
446 { "GNU_IFunc", ELF::STT_GNU_IFUNC }
449 static const char *getElfSectionType(unsigned Arch, unsigned Type) {
453 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_EXIDX);
454 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_PREEMPTMAP);
455 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_ATTRIBUTES);
456 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_DEBUGOVERLAY);
457 LLVM_READOBJ_ENUM_CASE(ELF, SHT_ARM_OVERLAYSECTION);
459 case ELF::EM_HEXAGON:
460 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_HEX_ORDERED); }
462 switch (Type) { LLVM_READOBJ_ENUM_CASE(ELF, SHT_X86_64_UNWIND); }
464 case ELF::EM_MIPS_RS3_LE:
466 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_REGINFO);
467 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_OPTIONS);
468 LLVM_READOBJ_ENUM_CASE(ELF, SHT_MIPS_ABIFLAGS);
473 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NULL );
474 LLVM_READOBJ_ENUM_CASE(ELF, SHT_PROGBITS );
475 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB );
476 LLVM_READOBJ_ENUM_CASE(ELF, SHT_STRTAB );
477 LLVM_READOBJ_ENUM_CASE(ELF, SHT_RELA );
478 LLVM_READOBJ_ENUM_CASE(ELF, SHT_HASH );
479 LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNAMIC );
480 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOTE );
481 LLVM_READOBJ_ENUM_CASE(ELF, SHT_NOBITS );
482 LLVM_READOBJ_ENUM_CASE(ELF, SHT_REL );
483 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SHLIB );
484 LLVM_READOBJ_ENUM_CASE(ELF, SHT_DYNSYM );
485 LLVM_READOBJ_ENUM_CASE(ELF, SHT_INIT_ARRAY );
486 LLVM_READOBJ_ENUM_CASE(ELF, SHT_FINI_ARRAY );
487 LLVM_READOBJ_ENUM_CASE(ELF, SHT_PREINIT_ARRAY );
488 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GROUP );
489 LLVM_READOBJ_ENUM_CASE(ELF, SHT_SYMTAB_SHNDX );
490 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_ATTRIBUTES );
491 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_HASH );
492 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verdef );
493 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_verneed );
494 LLVM_READOBJ_ENUM_CASE(ELF, SHT_GNU_versym );
499 static const EnumEntry<unsigned> ElfSectionFlags[] = {
500 LLVM_READOBJ_ENUM_ENT(ELF, SHF_WRITE ),
501 LLVM_READOBJ_ENUM_ENT(ELF, SHF_ALLOC ),
502 LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXCLUDE ),
503 LLVM_READOBJ_ENUM_ENT(ELF, SHF_EXECINSTR ),
504 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MERGE ),
505 LLVM_READOBJ_ENUM_ENT(ELF, SHF_STRINGS ),
506 LLVM_READOBJ_ENUM_ENT(ELF, SHF_INFO_LINK ),
507 LLVM_READOBJ_ENUM_ENT(ELF, SHF_LINK_ORDER ),
508 LLVM_READOBJ_ENUM_ENT(ELF, SHF_OS_NONCONFORMING),
509 LLVM_READOBJ_ENUM_ENT(ELF, SHF_GROUP ),
510 LLVM_READOBJ_ENUM_ENT(ELF, SHF_TLS ),
511 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_CP_SECTION),
512 LLVM_READOBJ_ENUM_ENT(ELF, XCORE_SHF_DP_SECTION),
513 LLVM_READOBJ_ENUM_ENT(ELF, SHF_MIPS_NOSTRIP )
516 static const char *getElfSegmentType(unsigned Arch, unsigned Type) {
517 // Check potentially overlapped processor-specific
518 // program header type.
522 LLVM_READOBJ_ENUM_CASE(ELF, PT_ARM_EXIDX);
525 case ELF::EM_MIPS_RS3_LE:
527 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_REGINFO);
528 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_RTPROC);
529 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_OPTIONS);
530 LLVM_READOBJ_ENUM_CASE(ELF, PT_MIPS_ABIFLAGS);
535 LLVM_READOBJ_ENUM_CASE(ELF, PT_NULL );
536 LLVM_READOBJ_ENUM_CASE(ELF, PT_LOAD );
537 LLVM_READOBJ_ENUM_CASE(ELF, PT_DYNAMIC);
538 LLVM_READOBJ_ENUM_CASE(ELF, PT_INTERP );
539 LLVM_READOBJ_ENUM_CASE(ELF, PT_NOTE );
540 LLVM_READOBJ_ENUM_CASE(ELF, PT_SHLIB );
541 LLVM_READOBJ_ENUM_CASE(ELF, PT_PHDR );
542 LLVM_READOBJ_ENUM_CASE(ELF, PT_TLS );
544 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_EH_FRAME);
545 LLVM_READOBJ_ENUM_CASE(ELF, PT_SUNW_UNWIND);
547 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_STACK);
548 LLVM_READOBJ_ENUM_CASE(ELF, PT_GNU_RELRO);
553 static const EnumEntry<unsigned> ElfSegmentFlags[] = {
554 LLVM_READOBJ_ENUM_ENT(ELF, PF_X),
555 LLVM_READOBJ_ENUM_ENT(ELF, PF_W),
556 LLVM_READOBJ_ENUM_ENT(ELF, PF_R)
559 static const EnumEntry<unsigned> ElfHeaderMipsFlags[] = {
560 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NOREORDER),
561 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_PIC),
562 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_CPIC),
563 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI2),
564 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_32BITMODE),
565 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_FP64),
566 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_NAN2008),
567 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O32),
568 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_O64),
569 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI32),
570 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ABI_EABI64),
571 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_3900),
572 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4010),
573 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4100),
574 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4650),
575 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4120),
576 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_4111),
577 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_SB1),
578 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON),
579 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_XLR),
580 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON2),
581 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_OCTEON3),
582 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5400),
583 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5900),
584 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_5500),
585 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_9000),
586 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2E),
587 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS2F),
588 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MACH_LS3A),
589 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_MICROMIPS),
590 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_M16),
591 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_ASE_MDMX),
592 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_1),
593 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_2),
594 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_3),
595 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_4),
596 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_5),
597 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32),
598 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64),
599 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R2),
600 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R2),
601 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_32R6),
602 LLVM_READOBJ_ENUM_ENT(ELF, EF_MIPS_ARCH_64R6)
605 template <typename ELFT>
606 ELFDumper<ELFT>::ELFDumper(const ELFFile<ELFT> *Obj, StreamWriter &Writer)
607 : ObjDumper(Writer), Obj(Obj) {
609 SmallVector<const Elf_Phdr *, 4> LoadSegments;
610 for (const Elf_Phdr &Phdr : Obj->program_headers()) {
611 if (Phdr.p_type == ELF::PT_DYNAMIC) {
612 DynamicRegion.Addr = Obj->base() + Phdr.p_offset;
613 uint64_t Size = Phdr.p_filesz;
614 if (Size % sizeof(Elf_Dyn))
615 report_fatal_error("Invalid dynamic table size");
616 DynamicRegion.Size = Phdr.p_filesz;
619 if (Phdr.p_type != ELF::PT_LOAD || Phdr.p_filesz == 0)
621 LoadSegments.push_back(&Phdr);
624 auto toMappedAddr = [&](uint64_t VAddr) -> const uint8_t * {
625 const Elf_Phdr **I = std::upper_bound(
626 LoadSegments.begin(), LoadSegments.end(), VAddr, compareAddr<ELFT>);
627 if (I == LoadSegments.begin())
628 report_fatal_error("Virtual address is not in any segment");
630 const Elf_Phdr &Phdr = **I;
631 uint64_t Delta = VAddr - Phdr.p_vaddr;
632 if (Delta >= Phdr.p_filesz)
633 report_fatal_error("Virtual address is not in any segment");
634 return Obj->base() + Phdr.p_offset + Delta;
637 uint64_t SONameOffset = 0;
638 const char *StringTableBegin = nullptr;
639 uint64_t StringTableSize = 0;
640 for (const Elf_Dyn &Dyn : dynamic_table()) {
644 reinterpret_cast<const Elf_Hash *>(toMappedAddr(Dyn.getPtr()));
647 DynRelaRegion.Addr = toMappedAddr(Dyn.getPtr());
650 DynRelaRegion.Size = Dyn.getVal();
652 case ELF::DT_RELAENT:
653 DynRelaRegion.EntSize = Dyn.getVal();
656 SONameOffset = Dyn.getVal();
659 StringTableBegin = (const char *)toMappedAddr(Dyn.getPtr());
662 StringTableSize = Dyn.getVal();
666 reinterpret_cast<const Elf_Sym *>(toMappedAddr(Dyn.getPtr()));
670 if (StringTableBegin)
671 DynamicStringTable = StringRef(StringTableBegin, StringTableSize);
673 SOName = getDynamicString(SONameOffset);
676 template <typename ELFT>
677 const typename ELFDumper<ELFT>::Elf_Rela *
678 ELFDumper<ELFT>::dyn_rela_begin() const {
679 if (DynRelaRegion.Size && DynRelaRegion.EntSize != sizeof(Elf_Rela))
680 report_fatal_error("Invalid relocation entry size");
681 return reinterpret_cast<const Elf_Rela *>(DynRelaRegion.Addr);
684 template <typename ELFT>
685 const typename ELFDumper<ELFT>::Elf_Rela *
686 ELFDumper<ELFT>::dyn_rela_end() const {
687 uint64_t Size = DynRelaRegion.Size;
688 if (Size % sizeof(Elf_Rela))
689 report_fatal_error("Invalid relocation table size");
690 return dyn_rela_begin() + Size / sizeof(Elf_Rela);
693 template <typename ELFT>
694 typename ELFDumper<ELFT>::Elf_Rela_Range ELFDumper<ELFT>::dyn_relas() const {
695 return make_range(dyn_rela_begin(), dyn_rela_end());
698 template <typename ELFT>
699 const typename ELFDumper<ELFT>::Elf_Dyn *
700 ELFDumper<ELFT>::dynamic_table_begin() const {
701 return reinterpret_cast<const Elf_Dyn *>(DynamicRegion.Addr);
704 template <typename ELFT>
705 const typename ELFDumper<ELFT>::Elf_Dyn *
706 ELFDumper<ELFT>::dynamic_table_end() const {
707 uint64_t Size = DynamicRegion.Size;
708 return dynamic_table_begin() + Size / sizeof(Elf_Dyn);
712 void ELFDumper<ELFT>::printFileHeaders() {
713 const Elf_Ehdr *Header = Obj->getHeader();
716 DictScope D(W, "ElfHeader");
718 DictScope D(W, "Ident");
719 W.printBinary("Magic", makeArrayRef(Header->e_ident).slice(ELF::EI_MAG0,
721 W.printEnum ("Class", Header->e_ident[ELF::EI_CLASS],
722 makeArrayRef(ElfClass));
723 W.printEnum ("DataEncoding", Header->e_ident[ELF::EI_DATA],
724 makeArrayRef(ElfDataEncoding));
725 W.printNumber("FileVersion", Header->e_ident[ELF::EI_VERSION]);
727 // Handle architecture specific OS/ABI values.
728 if (Header->e_machine == ELF::EM_AMDGPU &&
729 Header->e_ident[ELF::EI_OSABI] == ELF::ELFOSABI_AMDGPU_HSA)
730 W.printHex("OS/ABI", "AMDGPU_HSA", ELF::ELFOSABI_AMDGPU_HSA);
732 W.printEnum ("OS/ABI", Header->e_ident[ELF::EI_OSABI],
733 makeArrayRef(ElfOSABI));
734 W.printNumber("ABIVersion", Header->e_ident[ELF::EI_ABIVERSION]);
735 W.printBinary("Unused", makeArrayRef(Header->e_ident).slice(ELF::EI_PAD));
738 W.printEnum ("Type", Header->e_type, makeArrayRef(ElfObjectFileType));
739 W.printEnum ("Machine", Header->e_machine, makeArrayRef(ElfMachineType));
740 W.printNumber("Version", Header->e_version);
741 W.printHex ("Entry", Header->e_entry);
742 W.printHex ("ProgramHeaderOffset", Header->e_phoff);
743 W.printHex ("SectionHeaderOffset", Header->e_shoff);
744 if (Header->e_machine == EM_MIPS)
745 W.printFlags("Flags", Header->e_flags, makeArrayRef(ElfHeaderMipsFlags),
746 unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
747 unsigned(ELF::EF_MIPS_MACH));
749 W.printFlags("Flags", Header->e_flags);
750 W.printNumber("HeaderSize", Header->e_ehsize);
751 W.printNumber("ProgramHeaderEntrySize", Header->e_phentsize);
752 W.printNumber("ProgramHeaderCount", Header->e_phnum);
753 W.printNumber("SectionHeaderEntrySize", Header->e_shentsize);
754 W.printNumber("SectionHeaderCount", Header->e_shnum);
755 W.printNumber("StringTableSectionIndex", Header->e_shstrndx);
760 void ELFDumper<ELFT>::printSections() {
761 ListScope SectionsD(W, "Sections");
763 int SectionIndex = -1;
764 for (const Elf_Shdr &Sec : Obj->sections()) {
767 StringRef Name = errorOrDefault(Obj->getSectionName(&Sec));
769 DictScope SectionD(W, "Section");
770 W.printNumber("Index", SectionIndex);
771 W.printNumber("Name", Name, Sec.sh_name);
773 getElfSectionType(Obj->getHeader()->e_machine, Sec.sh_type),
775 W.printFlags("Flags", Sec.sh_flags, makeArrayRef(ElfSectionFlags));
776 W.printHex("Address", Sec.sh_addr);
777 W.printHex("Offset", Sec.sh_offset);
778 W.printNumber("Size", Sec.sh_size);
779 W.printNumber("Link", Sec.sh_link);
780 W.printNumber("Info", Sec.sh_info);
781 W.printNumber("AddressAlignment", Sec.sh_addralign);
782 W.printNumber("EntrySize", Sec.sh_entsize);
784 if (opts::SectionRelocations) {
785 ListScope D(W, "Relocations");
786 printRelocations(&Sec);
789 if (opts::SectionSymbols) {
790 ListScope D(W, "Symbols");
791 const Elf_Shdr *Symtab = Obj->getDotSymtabSec();
792 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
793 error(StrTableOrErr.getError());
794 StringRef StrTable = *StrTableOrErr;
796 for (const Elf_Sym &Sym : Obj->symbols()) {
797 ErrorOr<const Elf_Shdr *> SymSec = Obj->getSection(&Sym);
801 printSymbol(&Sym, StrTable, false);
805 if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
806 ArrayRef<uint8_t> Data = errorOrDefault(Obj->getSectionContents(&Sec));
807 W.printBinaryBlock("SectionData",
808 StringRef((const char *)Data.data(), Data.size()));
814 void ELFDumper<ELFT>::printRelocations() {
815 ListScope D(W, "Relocations");
817 int SectionNumber = -1;
818 for (const Elf_Shdr &Sec : Obj->sections()) {
821 if (Sec.sh_type != ELF::SHT_REL && Sec.sh_type != ELF::SHT_RELA)
824 StringRef Name = errorOrDefault(Obj->getSectionName(&Sec));
826 W.startLine() << "Section (" << SectionNumber << ") " << Name << " {\n";
829 printRelocations(&Sec);
832 W.startLine() << "}\n";
837 void ELFDumper<ELFT>::printDynamicRelocations() {
838 W.startLine() << "Dynamic Relocations {\n";
840 for (const Elf_Rela &Rel : dyn_relas()) {
841 SmallString<32> RelocName;
842 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
843 StringRef SymbolName;
844 uint32_t SymIndex = Rel.getSymbol(Obj->isMips64EL());
845 const Elf_Sym *Sym = DynSymStart + SymIndex;
846 SymbolName = errorOrDefault(Sym->getName(DynamicStringTable));
847 if (opts::ExpandRelocs) {
848 DictScope Group(W, "Relocation");
849 W.printHex("Offset", Rel.r_offset);
850 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
851 W.printString("Symbol", SymbolName.size() > 0 ? SymbolName : "-");
852 W.printHex("Addend", Rel.r_addend);
855 raw_ostream& OS = W.startLine();
856 OS << W.hex(Rel.r_offset) << " " << RelocName << " "
857 << (SymbolName.size() > 0 ? SymbolName : "-") << " "
858 << W.hex(Rel.r_addend) << "\n";
862 W.startLine() << "}\n";
865 template <class ELFT>
866 void ELFDumper<ELFT>::printRelocations(const Elf_Shdr *Sec) {
867 switch (Sec->sh_type) {
869 for (const Elf_Rel &R : Obj->rels(Sec)) {
871 Rela.r_offset = R.r_offset;
872 Rela.r_info = R.r_info;
874 printRelocation(Sec, Rela);
878 for (const Elf_Rela &R : Obj->relas(Sec))
879 printRelocation(Sec, R);
884 template <class ELFT>
885 void ELFDumper<ELFT>::printRelocation(const Elf_Shdr *Sec, Elf_Rela Rel) {
886 SmallString<32> RelocName;
887 Obj->getRelocationTypeName(Rel.getType(Obj->isMips64EL()), RelocName);
888 StringRef TargetName;
889 std::pair<const Elf_Shdr *, const Elf_Sym *> Sym =
890 Obj->getRelocationSymbol(Sec, &Rel);
891 if (Sym.second && Sym.second->getType() == ELF::STT_SECTION) {
892 ErrorOr<const Elf_Shdr *> Sec = Obj->getSection(Sym.second);
893 error(Sec.getError());
894 ErrorOr<StringRef> SecName = Obj->getSectionName(*Sec);
896 TargetName = SecName.get();
897 } else if (Sym.first) {
898 const Elf_Shdr *SymTable = Sym.first;
899 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*SymTable);
900 error(StrTableOrErr.getError());
901 TargetName = errorOrDefault(Sym.second->getName(*StrTableOrErr));
904 if (opts::ExpandRelocs) {
905 DictScope Group(W, "Relocation");
906 W.printHex("Offset", Rel.r_offset);
907 W.printNumber("Type", RelocName, (int)Rel.getType(Obj->isMips64EL()));
908 W.printNumber("Symbol", TargetName.size() > 0 ? TargetName : "-",
909 Rel.getSymbol(Obj->isMips64EL()));
910 W.printHex("Addend", Rel.r_addend);
912 raw_ostream& OS = W.startLine();
913 OS << W.hex(Rel.r_offset) << " " << RelocName << " "
914 << (TargetName.size() > 0 ? TargetName : "-") << " "
915 << W.hex(Rel.r_addend) << "\n";
920 void ELFDumper<ELFT>::printSymbols() {
921 ListScope Group(W, "Symbols");
923 const Elf_Shdr *Symtab = Obj->getDotSymtabSec();
924 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
925 error(StrTableOrErr.getError());
926 StringRef StrTable = *StrTableOrErr;
927 for (const Elf_Sym &Sym : Obj->symbols())
928 printSymbol(&Sym, StrTable, false);
932 void ELFDumper<ELFT>::printDynamicSymbols() {
933 ListScope Group(W, "DynamicSymbols");
935 const Elf_Shdr *Symtab = Obj->getDotDynSymSec();
936 ErrorOr<StringRef> StrTableOrErr = Obj->getStringTableForSymtab(*Symtab);
937 error(StrTableOrErr.getError());
938 StringRef StrTable = *StrTableOrErr;
939 for (const Elf_Sym &Sym : Obj->symbols(Symtab))
940 printSymbol(&Sym, StrTable, true);
943 template <class ELFT>
944 void ELFDumper<ELFT>::printSymbol(const Elf_Sym *Symbol, StringRef StrTable,
946 unsigned SectionIndex = 0;
947 StringRef SectionName;
948 getSectionNameIndex(*Obj, Symbol, SectionName, SectionIndex);
949 std::string FullSymbolName =
950 getFullSymbolName(*Obj, Symbol, StrTable, IsDynamic);
952 DictScope D(W, "Symbol");
953 W.printNumber("Name", FullSymbolName, Symbol->st_name);
954 W.printHex ("Value", Symbol->st_value);
955 W.printNumber("Size", Symbol->st_size);
956 W.printEnum ("Binding", Symbol->getBinding(),
957 makeArrayRef(ElfSymbolBindings));
958 W.printEnum ("Type", Symbol->getType(), makeArrayRef(ElfSymbolTypes));
959 W.printNumber("Other", Symbol->st_other);
960 W.printHex("Section", SectionName, SectionIndex);
963 #define LLVM_READOBJ_TYPE_CASE(name) \
964 case DT_##name: return #name
966 static const char *getTypeString(uint64_t Type) {
968 LLVM_READOBJ_TYPE_CASE(BIND_NOW);
969 LLVM_READOBJ_TYPE_CASE(DEBUG);
970 LLVM_READOBJ_TYPE_CASE(FINI);
971 LLVM_READOBJ_TYPE_CASE(FINI_ARRAY);
972 LLVM_READOBJ_TYPE_CASE(FINI_ARRAYSZ);
973 LLVM_READOBJ_TYPE_CASE(FLAGS);
974 LLVM_READOBJ_TYPE_CASE(FLAGS_1);
975 LLVM_READOBJ_TYPE_CASE(HASH);
976 LLVM_READOBJ_TYPE_CASE(INIT);
977 LLVM_READOBJ_TYPE_CASE(INIT_ARRAY);
978 LLVM_READOBJ_TYPE_CASE(INIT_ARRAYSZ);
979 LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAY);
980 LLVM_READOBJ_TYPE_CASE(PREINIT_ARRAYSZ);
981 LLVM_READOBJ_TYPE_CASE(JMPREL);
982 LLVM_READOBJ_TYPE_CASE(NEEDED);
983 LLVM_READOBJ_TYPE_CASE(NULL);
984 LLVM_READOBJ_TYPE_CASE(PLTGOT);
985 LLVM_READOBJ_TYPE_CASE(PLTREL);
986 LLVM_READOBJ_TYPE_CASE(PLTRELSZ);
987 LLVM_READOBJ_TYPE_CASE(REL);
988 LLVM_READOBJ_TYPE_CASE(RELA);
989 LLVM_READOBJ_TYPE_CASE(RELENT);
990 LLVM_READOBJ_TYPE_CASE(RELSZ);
991 LLVM_READOBJ_TYPE_CASE(RELAENT);
992 LLVM_READOBJ_TYPE_CASE(RELASZ);
993 LLVM_READOBJ_TYPE_CASE(RPATH);
994 LLVM_READOBJ_TYPE_CASE(RUNPATH);
995 LLVM_READOBJ_TYPE_CASE(SONAME);
996 LLVM_READOBJ_TYPE_CASE(STRSZ);
997 LLVM_READOBJ_TYPE_CASE(STRTAB);
998 LLVM_READOBJ_TYPE_CASE(SYMBOLIC);
999 LLVM_READOBJ_TYPE_CASE(SYMENT);
1000 LLVM_READOBJ_TYPE_CASE(SYMTAB);
1001 LLVM_READOBJ_TYPE_CASE(TEXTREL);
1002 LLVM_READOBJ_TYPE_CASE(VERNEED);
1003 LLVM_READOBJ_TYPE_CASE(VERNEEDNUM);
1004 LLVM_READOBJ_TYPE_CASE(VERSYM);
1005 LLVM_READOBJ_TYPE_CASE(RELCOUNT);
1006 LLVM_READOBJ_TYPE_CASE(GNU_HASH);
1007 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_VERSION);
1008 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP_REL);
1009 LLVM_READOBJ_TYPE_CASE(MIPS_FLAGS);
1010 LLVM_READOBJ_TYPE_CASE(MIPS_BASE_ADDRESS);
1011 LLVM_READOBJ_TYPE_CASE(MIPS_LOCAL_GOTNO);
1012 LLVM_READOBJ_TYPE_CASE(MIPS_SYMTABNO);
1013 LLVM_READOBJ_TYPE_CASE(MIPS_UNREFEXTNO);
1014 LLVM_READOBJ_TYPE_CASE(MIPS_GOTSYM);
1015 LLVM_READOBJ_TYPE_CASE(MIPS_RLD_MAP);
1016 LLVM_READOBJ_TYPE_CASE(MIPS_PLTGOT);
1017 LLVM_READOBJ_TYPE_CASE(MIPS_OPTIONS);
1018 default: return "unknown";
1022 #undef LLVM_READOBJ_TYPE_CASE
1024 #define LLVM_READOBJ_DT_FLAG_ENT(prefix, enum) \
1025 { #enum, prefix##_##enum }
1027 static const EnumEntry<unsigned> ElfDynamicDTFlags[] = {
1028 LLVM_READOBJ_DT_FLAG_ENT(DF, ORIGIN),
1029 LLVM_READOBJ_DT_FLAG_ENT(DF, SYMBOLIC),
1030 LLVM_READOBJ_DT_FLAG_ENT(DF, TEXTREL),
1031 LLVM_READOBJ_DT_FLAG_ENT(DF, BIND_NOW),
1032 LLVM_READOBJ_DT_FLAG_ENT(DF, STATIC_TLS)
1035 static const EnumEntry<unsigned> ElfDynamicDTFlags1[] = {
1036 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOW),
1037 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAL),
1038 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GROUP),
1039 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODELETE),
1040 LLVM_READOBJ_DT_FLAG_ENT(DF_1, LOADFLTR),
1041 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INITFIRST),
1042 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOOPEN),
1043 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ORIGIN),
1044 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DIRECT),
1045 LLVM_READOBJ_DT_FLAG_ENT(DF_1, TRANS),
1046 LLVM_READOBJ_DT_FLAG_ENT(DF_1, INTERPOSE),
1047 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODEFLIB),
1048 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODUMP),
1049 LLVM_READOBJ_DT_FLAG_ENT(DF_1, CONFALT),
1050 LLVM_READOBJ_DT_FLAG_ENT(DF_1, ENDFILTEE),
1051 LLVM_READOBJ_DT_FLAG_ENT(DF_1, DISPRELDNE),
1052 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NODIRECT),
1053 LLVM_READOBJ_DT_FLAG_ENT(DF_1, IGNMULDEF),
1054 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOKSYMS),
1055 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NOHDR),
1056 LLVM_READOBJ_DT_FLAG_ENT(DF_1, EDITED),
1057 LLVM_READOBJ_DT_FLAG_ENT(DF_1, NORELOC),
1058 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SYMINTPOSE),
1059 LLVM_READOBJ_DT_FLAG_ENT(DF_1, GLOBAUDIT),
1060 LLVM_READOBJ_DT_FLAG_ENT(DF_1, SINGLETON)
1063 static const EnumEntry<unsigned> ElfDynamicDTMipsFlags[] = {
1064 LLVM_READOBJ_DT_FLAG_ENT(RHF, NONE),
1065 LLVM_READOBJ_DT_FLAG_ENT(RHF, QUICKSTART),
1066 LLVM_READOBJ_DT_FLAG_ENT(RHF, NOTPOT),
1067 LLVM_READOBJ_DT_FLAG_ENT(RHS, NO_LIBRARY_REPLACEMENT),
1068 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_MOVE),
1069 LLVM_READOBJ_DT_FLAG_ENT(RHF, SGI_ONLY),
1070 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_INIT),
1071 LLVM_READOBJ_DT_FLAG_ENT(RHF, DELTA_C_PLUS_PLUS),
1072 LLVM_READOBJ_DT_FLAG_ENT(RHF, GUARANTEE_START_INIT),
1073 LLVM_READOBJ_DT_FLAG_ENT(RHF, PIXIE),
1074 LLVM_READOBJ_DT_FLAG_ENT(RHF, DEFAULT_DELAY_LOAD),
1075 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTART),
1076 LLVM_READOBJ_DT_FLAG_ENT(RHF, REQUICKSTARTED),
1077 LLVM_READOBJ_DT_FLAG_ENT(RHF, CORD),
1078 LLVM_READOBJ_DT_FLAG_ENT(RHF, NO_UNRES_UNDEF),
1079 LLVM_READOBJ_DT_FLAG_ENT(RHF, RLD_ORDER_SAFE)
1082 #undef LLVM_READOBJ_DT_FLAG_ENT
1084 template <typename T, typename TFlag>
1085 void printFlags(T Value, ArrayRef<EnumEntry<TFlag>> Flags, raw_ostream &OS) {
1086 typedef EnumEntry<TFlag> FlagEntry;
1087 typedef SmallVector<FlagEntry, 10> FlagVector;
1088 FlagVector SetFlags;
1090 for (const auto &Flag : Flags) {
1091 if (Flag.Value == 0)
1094 if ((Value & Flag.Value) == Flag.Value)
1095 SetFlags.push_back(Flag);
1098 for (const auto &Flag : SetFlags) {
1099 OS << Flag.Name << " ";
1103 template <class ELFT>
1104 StringRef ELFDumper<ELFT>::getDynamicString(uint64_t Value) const {
1105 if (Value >= DynamicStringTable.size())
1106 reportError("Invalid dynamic string table reference");
1107 return StringRef(DynamicStringTable.data() + Value);
1110 template <class ELFT>
1111 void ELFDumper<ELFT>::printValue(uint64_t Type, uint64_t Value) {
1112 raw_ostream &OS = W.getOStream();
1115 if (Value == DT_REL) {
1118 } else if (Value == DT_RELA) {
1134 case DT_PREINIT_ARRAY:
1140 case DT_MIPS_BASE_ADDRESS:
1141 case DT_MIPS_GOTSYM:
1142 case DT_MIPS_RLD_MAP:
1143 case DT_MIPS_RLD_MAP_REL:
1144 case DT_MIPS_PLTGOT:
1145 case DT_MIPS_OPTIONS:
1146 OS << format("0x%" PRIX64, Value);
1150 case DT_MIPS_RLD_VERSION:
1151 case DT_MIPS_LOCAL_GOTNO:
1152 case DT_MIPS_SYMTABNO:
1153 case DT_MIPS_UNREFEXTNO:
1163 case DT_INIT_ARRAYSZ:
1164 case DT_FINI_ARRAYSZ:
1165 case DT_PREINIT_ARRAYSZ:
1166 OS << Value << " (bytes)";
1169 OS << "SharedLibrary (" << getDynamicString(Value) << ")";
1172 OS << "LibrarySoname (" << getDynamicString(Value) << ")";
1176 OS << getDynamicString(Value);
1179 printFlags(Value, makeArrayRef(ElfDynamicDTMipsFlags), OS);
1182 printFlags(Value, makeArrayRef(ElfDynamicDTFlags), OS);
1185 printFlags(Value, makeArrayRef(ElfDynamicDTFlags1), OS);
1188 OS << format("0x%" PRIX64, Value);
1193 template<class ELFT>
1194 void ELFDumper<ELFT>::printUnwindInfo() {
1195 W.startLine() << "UnwindInfo not implemented.\n";
1199 template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() {
1200 const unsigned Machine = Obj->getHeader()->e_machine;
1201 if (Machine == EM_ARM) {
1202 ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx(W, Obj);
1203 return Ctx.PrintUnwindInformation();
1205 W.startLine() << "UnwindInfo not implemented.\n";
1209 template<class ELFT>
1210 void ELFDumper<ELFT>::printDynamicTable() {
1211 auto I = dynamic_table_begin();
1212 auto E = dynamic_table_end();
1218 while (I != E && E->getTag() == ELF::DT_NULL)
1220 if (E->getTag() != ELF::DT_NULL)
1224 ptrdiff_t Total = std::distance(I, E);
1228 raw_ostream &OS = W.getOStream();
1229 W.startLine() << "DynamicSection [ (" << Total << " entries)\n";
1231 bool Is64 = ELFT::Is64Bits;
1234 << " Tag" << (Is64 ? " " : " ") << "Type"
1235 << " " << "Name/Value\n";
1237 const Elf_Dyn &Entry = *I;
1241 << format(Is64 ? "0x%016" PRIX64 : "0x%08" PRIX64, Entry.getTag())
1242 << " " << format("%-21s", getTypeString(Entry.getTag()));
1243 printValue(Entry.getTag(), Entry.getVal());
1247 W.startLine() << "]\n";
1250 template<class ELFT>
1251 void ELFDumper<ELFT>::printNeededLibraries() {
1252 ListScope D(W, "NeededLibraries");
1254 typedef std::vector<StringRef> LibsTy;
1257 for (const auto &Entry : dynamic_table())
1258 if (Entry.d_tag == ELF::DT_NEEDED)
1259 Libs.push_back(getDynamicString(Entry.d_un.d_val));
1261 std::stable_sort(Libs.begin(), Libs.end());
1263 for (LibsTy::const_iterator I = Libs.begin(), E = Libs.end(); I != E; ++I) {
1264 outs() << " " << *I << "\n";
1268 template<class ELFT>
1269 void ELFDumper<ELFT>::printProgramHeaders() {
1270 ListScope L(W, "ProgramHeaders");
1272 for (const Elf_Phdr &Phdr : Obj->program_headers()) {
1273 DictScope P(W, "ProgramHeader");
1275 getElfSegmentType(Obj->getHeader()->e_machine, Phdr.p_type),
1277 W.printHex("Offset", Phdr.p_offset);
1278 W.printHex("VirtualAddress", Phdr.p_vaddr);
1279 W.printHex("PhysicalAddress", Phdr.p_paddr);
1280 W.printNumber("FileSize", Phdr.p_filesz);
1281 W.printNumber("MemSize", Phdr.p_memsz);
1282 W.printFlags("Flags", Phdr.p_flags, makeArrayRef(ElfSegmentFlags));
1283 W.printNumber("Alignment", Phdr.p_align);
1287 template <typename ELFT>
1288 void ELFDumper<ELFT>::printHashTable() {
1289 DictScope D(W, "HashTable");
1292 W.printNumber("Num Buckets", HashTable->nbucket);
1293 W.printNumber("Num Chains", HashTable->nchain);
1294 W.printList("Buckets", HashTable->buckets());
1295 W.printList("Chains", HashTable->chains());
1298 template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
1299 outs() << "LoadName: " << SOName << '\n';
1302 template <class ELFT>
1303 void ELFDumper<ELFT>::printAttributes() {
1304 W.startLine() << "Attributes not implemented.\n";
1308 template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() {
1309 if (Obj->getHeader()->e_machine != EM_ARM) {
1310 W.startLine() << "Attributes not implemented.\n";
1314 DictScope BA(W, "BuildAttributes");
1315 for (const ELFO::Elf_Shdr &Sec : Obj->sections()) {
1316 if (Sec.sh_type != ELF::SHT_ARM_ATTRIBUTES)
1319 ErrorOr<ArrayRef<uint8_t>> Contents = Obj->getSectionContents(&Sec);
1323 if ((*Contents)[0] != ARMBuildAttrs::Format_Version) {
1324 errs() << "unrecognised FormatVersion: 0x" << utohexstr((*Contents)[0])
1329 W.printHex("FormatVersion", (*Contents)[0]);
1330 if (Contents->size() == 1)
1333 ARMAttributeParser(W).Parse(*Contents);
1339 template <class ELFT> class MipsGOTParser {
1341 typedef object::ELFFile<ELFT> ELFO;
1342 typedef typename ELFO::Elf_Shdr Elf_Shdr;
1343 typedef typename ELFO::Elf_Sym Elf_Sym;
1344 typedef typename ELFO::Elf_Dyn_Range Elf_Dyn_Range;
1345 typedef typename ELFO::Elf_Addr GOTEntry;
1346 typedef typename ELFO::Elf_Rel Elf_Rel;
1347 typedef typename ELFO::Elf_Rela Elf_Rela;
1349 MipsGOTParser(const ELFO *Obj, Elf_Dyn_Range DynTable, StreamWriter &W);
1357 llvm::Optional<uint64_t> DtPltGot;
1358 llvm::Optional<uint64_t> DtLocalGotNum;
1359 llvm::Optional<uint64_t> DtGotSym;
1360 llvm::Optional<uint64_t> DtMipsPltGot;
1361 llvm::Optional<uint64_t> DtJmpRel;
1363 std::size_t getGOTTotal(ArrayRef<uint8_t> GOT) const;
1364 const GOTEntry *makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum);
1366 void printGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1367 const GOTEntry *It);
1368 void printGlobalGotEntry(uint64_t GotAddr, const GOTEntry *BeginIt,
1369 const GOTEntry *It, const Elf_Sym *Sym,
1370 StringRef StrTable, bool IsDynamic);
1371 void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1372 const GOTEntry *It, StringRef Purpose);
1373 void printPLTEntry(uint64_t PLTAddr, const GOTEntry *BeginIt,
1374 const GOTEntry *It, StringRef StrTable,
1375 const Elf_Sym *Sym);
1379 template <class ELFT>
1380 MipsGOTParser<ELFT>::MipsGOTParser(const ELFO *Obj, Elf_Dyn_Range DynTable,
1383 for (const auto &Entry : DynTable) {
1384 switch (Entry.getTag()) {
1385 case ELF::DT_PLTGOT:
1386 DtPltGot = Entry.getVal();
1388 case ELF::DT_MIPS_LOCAL_GOTNO:
1389 DtLocalGotNum = Entry.getVal();
1391 case ELF::DT_MIPS_GOTSYM:
1392 DtGotSym = Entry.getVal();
1394 case ELF::DT_MIPS_PLTGOT:
1395 DtMipsPltGot = Entry.getVal();
1397 case ELF::DT_JMPREL:
1398 DtJmpRel = Entry.getVal();
1404 template <class ELFT> void MipsGOTParser<ELFT>::parseGOT() {
1405 // See "Global Offset Table" in Chapter 5 in the following document
1406 // for detailed GOT description.
1407 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
1409 W.startLine() << "Cannot find PLTGOT dynamic table tag.\n";
1412 if (!DtLocalGotNum) {
1413 W.startLine() << "Cannot find MIPS_LOCAL_GOTNO dynamic table tag.\n";
1417 W.startLine() << "Cannot find MIPS_GOTSYM dynamic table tag.\n";
1421 const Elf_Shdr *GOTShdr = findSectionByAddress(Obj, *DtPltGot);
1423 W.startLine() << "There is no .got section in the file.\n";
1427 ErrorOr<ArrayRef<uint8_t>> GOT = Obj->getSectionContents(GOTShdr);
1429 W.startLine() << "The .got section is empty.\n";
1433 if (*DtLocalGotNum > getGOTTotal(*GOT)) {
1434 W.startLine() << "MIPS_LOCAL_GOTNO exceeds a number of GOT entries.\n";
1438 const Elf_Shdr *DynSymSec = Obj->getDotDynSymSec();
1439 ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(*DynSymSec);
1440 error(StrTable.getError());
1441 const Elf_Sym *DynSymBegin = Obj->symbol_begin(DynSymSec);
1442 const Elf_Sym *DynSymEnd = Obj->symbol_end(DynSymSec);
1443 std::size_t DynSymTotal = std::size_t(std::distance(DynSymBegin, DynSymEnd));
1445 if (*DtGotSym > DynSymTotal) {
1446 W.startLine() << "MIPS_GOTSYM exceeds a number of dynamic symbols.\n";
1450 std::size_t GlobalGotNum = DynSymTotal - *DtGotSym;
1452 if (*DtLocalGotNum + GlobalGotNum > getGOTTotal(*GOT)) {
1453 W.startLine() << "Number of global GOT entries exceeds the size of GOT.\n";
1457 const GOTEntry *GotBegin = makeGOTIter(*GOT, 0);
1458 const GOTEntry *GotLocalEnd = makeGOTIter(*GOT, *DtLocalGotNum);
1459 const GOTEntry *It = GotBegin;
1461 DictScope GS(W, "Primary GOT");
1463 W.printHex("Canonical gp value", GOTShdr->sh_addr + 0x7ff0);
1465 ListScope RS(W, "Reserved entries");
1468 DictScope D(W, "Entry");
1469 printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1470 W.printString("Purpose", StringRef("Lazy resolver"));
1473 if (It != GotLocalEnd && (*It >> (sizeof(GOTEntry) * 8 - 1)) != 0) {
1474 DictScope D(W, "Entry");
1475 printGotEntry(GOTShdr->sh_addr, GotBegin, It++);
1476 W.printString("Purpose", StringRef("Module pointer (GNU extension)"));
1480 ListScope LS(W, "Local entries");
1481 for (; It != GotLocalEnd; ++It) {
1482 DictScope D(W, "Entry");
1483 printGotEntry(GOTShdr->sh_addr, GotBegin, It);
1487 ListScope GS(W, "Global entries");
1489 const GOTEntry *GotGlobalEnd =
1490 makeGOTIter(*GOT, *DtLocalGotNum + GlobalGotNum);
1491 const Elf_Sym *GotDynSym = DynSymBegin + *DtGotSym;
1492 for (; It != GotGlobalEnd; ++It) {
1493 DictScope D(W, "Entry");
1494 printGlobalGotEntry(GOTShdr->sh_addr, GotBegin, It, GotDynSym++,
1499 std::size_t SpecGotNum = getGOTTotal(*GOT) - *DtLocalGotNum - GlobalGotNum;
1500 W.printNumber("Number of TLS and multi-GOT entries", uint64_t(SpecGotNum));
1503 template <class ELFT> void MipsGOTParser<ELFT>::parsePLT() {
1504 if (!DtMipsPltGot) {
1505 W.startLine() << "Cannot find MIPS_PLTGOT dynamic table tag.\n";
1509 W.startLine() << "Cannot find JMPREL dynamic table tag.\n";
1513 const Elf_Shdr *PLTShdr = findSectionByAddress(Obj, *DtMipsPltGot);
1515 W.startLine() << "There is no .got.plt section in the file.\n";
1518 ErrorOr<ArrayRef<uint8_t>> PLT = Obj->getSectionContents(PLTShdr);
1520 W.startLine() << "The .got.plt section is empty.\n";
1524 const Elf_Shdr *PLTRelShdr = findSectionByAddress(Obj, *DtJmpRel);
1526 W.startLine() << "There is no .rel.plt section in the file.\n";
1529 ErrorOr<const Elf_Shdr *> SymTableOrErr =
1530 Obj->getSection(PLTRelShdr->sh_link);
1531 error(SymTableOrErr.getError());
1532 ErrorOr<StringRef> StrTable = Obj->getStringTableForSymtab(**SymTableOrErr);
1533 error(StrTable.getError());
1535 const GOTEntry *PLTBegin = makeGOTIter(*PLT, 0);
1536 const GOTEntry *PLTEnd = makeGOTIter(*PLT, getGOTTotal(*PLT));
1537 const GOTEntry *It = PLTBegin;
1539 DictScope GS(W, "PLT GOT");
1541 ListScope RS(W, "Reserved entries");
1542 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "PLT lazy resolver");
1544 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It++, "Module pointer");
1547 ListScope GS(W, "Entries");
1549 switch (PLTRelShdr->sh_type) {
1551 for (const Elf_Rel *RI = Obj->rel_begin(PLTRelShdr),
1552 *RE = Obj->rel_end(PLTRelShdr);
1553 RI != RE && It != PLTEnd; ++RI, ++It) {
1554 const Elf_Sym *Sym =
1555 Obj->getRelocationSymbol(&*PLTRelShdr, &*RI).second;
1556 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym);
1560 for (const Elf_Rela *RI = Obj->rela_begin(PLTRelShdr),
1561 *RE = Obj->rela_end(PLTRelShdr);
1562 RI != RE && It != PLTEnd; ++RI, ++It) {
1563 const Elf_Sym *Sym =
1564 Obj->getRelocationSymbol(&*PLTRelShdr, &*RI).second;
1565 printPLTEntry(PLTShdr->sh_addr, PLTBegin, It, *StrTable, Sym);
1572 template <class ELFT>
1573 std::size_t MipsGOTParser<ELFT>::getGOTTotal(ArrayRef<uint8_t> GOT) const {
1574 return GOT.size() / sizeof(GOTEntry);
1577 template <class ELFT>
1578 const typename MipsGOTParser<ELFT>::GOTEntry *
1579 MipsGOTParser<ELFT>::makeGOTIter(ArrayRef<uint8_t> GOT, std::size_t EntryNum) {
1580 const char *Data = reinterpret_cast<const char *>(GOT.data());
1581 return reinterpret_cast<const GOTEntry *>(Data + EntryNum * sizeof(GOTEntry));
1584 template <class ELFT>
1585 void MipsGOTParser<ELFT>::printGotEntry(uint64_t GotAddr,
1586 const GOTEntry *BeginIt,
1587 const GOTEntry *It) {
1588 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1589 W.printHex("Address", GotAddr + Offset);
1590 W.printNumber("Access", Offset - 0x7ff0);
1591 W.printHex("Initial", *It);
1594 template <class ELFT>
1595 void MipsGOTParser<ELFT>::printGlobalGotEntry(
1596 uint64_t GotAddr, const GOTEntry *BeginIt, const GOTEntry *It,
1597 const Elf_Sym *Sym, StringRef StrTable, bool IsDynamic) {
1598 printGotEntry(GotAddr, BeginIt, It);
1600 W.printHex("Value", Sym->st_value);
1601 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1603 unsigned SectionIndex = 0;
1604 StringRef SectionName;
1605 getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1606 W.printHex("Section", SectionName, SectionIndex);
1608 std::string FullSymbolName =
1609 getFullSymbolName(*Obj, Sym, StrTable, IsDynamic);
1610 W.printNumber("Name", FullSymbolName, Sym->st_name);
1613 template <class ELFT>
1614 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
1615 const GOTEntry *BeginIt,
1616 const GOTEntry *It, StringRef Purpose) {
1617 DictScope D(W, "Entry");
1618 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1619 W.printHex("Address", PLTAddr + Offset);
1620 W.printHex("Initial", *It);
1621 W.printString("Purpose", Purpose);
1624 template <class ELFT>
1625 void MipsGOTParser<ELFT>::printPLTEntry(uint64_t PLTAddr,
1626 const GOTEntry *BeginIt,
1627 const GOTEntry *It, StringRef StrTable,
1628 const Elf_Sym *Sym) {
1629 DictScope D(W, "Entry");
1630 int64_t Offset = std::distance(BeginIt, It) * sizeof(GOTEntry);
1631 W.printHex("Address", PLTAddr + Offset);
1632 W.printHex("Initial", *It);
1633 W.printHex("Value", Sym->st_value);
1634 W.printEnum("Type", Sym->getType(), makeArrayRef(ElfSymbolTypes));
1636 unsigned SectionIndex = 0;
1637 StringRef SectionName;
1638 getSectionNameIndex(*Obj, Sym, SectionName, SectionIndex);
1639 W.printHex("Section", SectionName, SectionIndex);
1641 std::string FullSymbolName = getFullSymbolName(*Obj, Sym, StrTable, true);
1642 W.printNumber("Name", FullSymbolName, Sym->st_name);
1645 template <class ELFT> void ELFDumper<ELFT>::printMipsPLTGOT() {
1646 if (Obj->getHeader()->e_machine != EM_MIPS) {
1647 W.startLine() << "MIPS PLT GOT is available for MIPS targets only.\n";
1651 MipsGOTParser<ELFT> GOTParser(Obj, dynamic_table(), W);
1652 GOTParser.parseGOT();
1653 GOTParser.parsePLT();
1656 static const EnumEntry<unsigned> ElfMipsISAExtType[] = {
1657 {"None", Mips::AFL_EXT_NONE},
1658 {"Broadcom SB-1", Mips::AFL_EXT_SB1},
1659 {"Cavium Networks Octeon", Mips::AFL_EXT_OCTEON},
1660 {"Cavium Networks Octeon2", Mips::AFL_EXT_OCTEON2},
1661 {"Cavium Networks OcteonP", Mips::AFL_EXT_OCTEONP},
1662 {"Cavium Networks Octeon3", Mips::AFL_EXT_OCTEON3},
1663 {"LSI R4010", Mips::AFL_EXT_4010},
1664 {"Loongson 2E", Mips::AFL_EXT_LOONGSON_2E},
1665 {"Loongson 2F", Mips::AFL_EXT_LOONGSON_2F},
1666 {"Loongson 3A", Mips::AFL_EXT_LOONGSON_3A},
1667 {"MIPS R4650", Mips::AFL_EXT_4650},
1668 {"MIPS R5900", Mips::AFL_EXT_5900},
1669 {"MIPS R10000", Mips::AFL_EXT_10000},
1670 {"NEC VR4100", Mips::AFL_EXT_4100},
1671 {"NEC VR4111/VR4181", Mips::AFL_EXT_4111},
1672 {"NEC VR4120", Mips::AFL_EXT_4120},
1673 {"NEC VR5400", Mips::AFL_EXT_5400},
1674 {"NEC VR5500", Mips::AFL_EXT_5500},
1675 {"RMI Xlr", Mips::AFL_EXT_XLR},
1676 {"Toshiba R3900", Mips::AFL_EXT_3900}
1679 static const EnumEntry<unsigned> ElfMipsASEFlags[] = {
1680 {"DSP", Mips::AFL_ASE_DSP},
1681 {"DSPR2", Mips::AFL_ASE_DSPR2},
1682 {"Enhanced VA Scheme", Mips::AFL_ASE_EVA},
1683 {"MCU", Mips::AFL_ASE_MCU},
1684 {"MDMX", Mips::AFL_ASE_MDMX},
1685 {"MIPS-3D", Mips::AFL_ASE_MIPS3D},
1686 {"MT", Mips::AFL_ASE_MT},
1687 {"SmartMIPS", Mips::AFL_ASE_SMARTMIPS},
1688 {"VZ", Mips::AFL_ASE_VIRT},
1689 {"MSA", Mips::AFL_ASE_MSA},
1690 {"MIPS16", Mips::AFL_ASE_MIPS16},
1691 {"microMIPS", Mips::AFL_ASE_MICROMIPS},
1692 {"XPA", Mips::AFL_ASE_XPA}
1695 static const EnumEntry<unsigned> ElfMipsFpABIType[] = {
1696 {"Hard or soft float", Mips::Val_GNU_MIPS_ABI_FP_ANY},
1697 {"Hard float (double precision)", Mips::Val_GNU_MIPS_ABI_FP_DOUBLE},
1698 {"Hard float (single precision)", Mips::Val_GNU_MIPS_ABI_FP_SINGLE},
1699 {"Soft float", Mips::Val_GNU_MIPS_ABI_FP_SOFT},
1700 {"Hard float (MIPS32r2 64-bit FPU 12 callee-saved)",
1701 Mips::Val_GNU_MIPS_ABI_FP_OLD_64},
1702 {"Hard float (32-bit CPU, Any FPU)", Mips::Val_GNU_MIPS_ABI_FP_XX},
1703 {"Hard float (32-bit CPU, 64-bit FPU)", Mips::Val_GNU_MIPS_ABI_FP_64},
1704 {"Hard float compat (32-bit CPU, 64-bit FPU)",
1705 Mips::Val_GNU_MIPS_ABI_FP_64A}
1708 static const EnumEntry<unsigned> ElfMipsFlags1[] {
1709 {"ODDSPREG", Mips::AFL_FLAGS1_ODDSPREG},
1712 static int getMipsRegisterSize(uint8_t Flag) {
1714 case Mips::AFL_REG_NONE:
1716 case Mips::AFL_REG_32:
1718 case Mips::AFL_REG_64:
1720 case Mips::AFL_REG_128:
1727 template <class ELFT> void ELFDumper<ELFT>::printMipsABIFlags() {
1728 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".MIPS.abiflags");
1730 W.startLine() << "There is no .MIPS.abiflags section in the file.\n";
1733 ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr);
1735 W.startLine() << "The .MIPS.abiflags section is empty.\n";
1738 if (Sec->size() != sizeof(Elf_Mips_ABIFlags<ELFT>)) {
1739 W.startLine() << "The .MIPS.abiflags section has a wrong size.\n";
1743 auto *Flags = reinterpret_cast<const Elf_Mips_ABIFlags<ELFT> *>(Sec->data());
1745 raw_ostream &OS = W.getOStream();
1746 DictScope GS(W, "MIPS ABI Flags");
1748 W.printNumber("Version", Flags->version);
1749 W.startLine() << "ISA: ";
1750 if (Flags->isa_rev <= 1)
1751 OS << format("MIPS%u", Flags->isa_level);
1753 OS << format("MIPS%ur%u", Flags->isa_level, Flags->isa_rev);
1755 W.printEnum("ISA Extension", Flags->isa_ext, makeArrayRef(ElfMipsISAExtType));
1756 W.printFlags("ASEs", Flags->ases, makeArrayRef(ElfMipsASEFlags));
1757 W.printEnum("FP ABI", Flags->fp_abi, makeArrayRef(ElfMipsFpABIType));
1758 W.printNumber("GPR size", getMipsRegisterSize(Flags->gpr_size));
1759 W.printNumber("CPR1 size", getMipsRegisterSize(Flags->cpr1_size));
1760 W.printNumber("CPR2 size", getMipsRegisterSize(Flags->cpr2_size));
1761 W.printFlags("Flags 1", Flags->flags1, makeArrayRef(ElfMipsFlags1));
1762 W.printHex("Flags 2", Flags->flags2);
1765 template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
1766 const Elf_Shdr *Shdr = findSectionByName(*Obj, ".reginfo");
1768 W.startLine() << "There is no .reginfo section in the file.\n";
1771 ErrorOr<ArrayRef<uint8_t>> Sec = Obj->getSectionContents(Shdr);
1773 W.startLine() << "The .reginfo section is empty.\n";
1776 if (Sec->size() != sizeof(Elf_Mips_RegInfo<ELFT>)) {
1777 W.startLine() << "The .reginfo section has a wrong size.\n";
1781 auto *Reginfo = reinterpret_cast<const Elf_Mips_RegInfo<ELFT> *>(Sec->data());
1783 DictScope GS(W, "MIPS RegInfo");
1784 W.printHex("GP", Reginfo->ri_gp_value);
1785 W.printHex("General Mask", Reginfo->ri_gprmask);
1786 W.printHex("Co-Proc Mask0", Reginfo->ri_cprmask[0]);
1787 W.printHex("Co-Proc Mask1", Reginfo->ri_cprmask[1]);
1788 W.printHex("Co-Proc Mask2", Reginfo->ri_cprmask[2]);
1789 W.printHex("Co-Proc Mask3", Reginfo->ri_cprmask[3]);
1792 template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
1793 const Elf_Shdr *StackMapSection = nullptr;
1794 for (const auto &Sec : Obj->sections()) {
1795 ErrorOr<StringRef> Name = Obj->getSectionName(&Sec);
1796 if (*Name == ".llvm_stackmaps") {
1797 StackMapSection = &Sec;
1802 if (!StackMapSection)
1805 StringRef StackMapContents;
1806 ErrorOr<ArrayRef<uint8_t>> StackMapContentsArray =
1807 Obj->getSectionContents(StackMapSection);
1809 prettyPrintStackMap(
1811 StackMapV1Parser<ELFT::TargetEndianness>(*StackMapContentsArray));