2 * Copyright (c) 2007-2012 Kai Wang
3 * Copyright (c) 2003 David O'Brien. All rights reserved.
4 * Copyright (c) 2001 Jake Burkholder
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/param.h>
30 #include <sys/queue.h>
46 #ifdef USE_LIBARCHIVE_AR
48 #include <archive_entry.h>
53 ELFTC_VCSID("$Id: elfdump.c 3198 2015-05-14 18:36:19Z emaste $");
55 #if defined(ELFTC_NEED_ELF_NOTE_DEFINITION)
56 #include "native-elf-format.h"
57 #if ELFTC_CLASS == ELFCLASS32
58 typedef Elf32_Nhdr Elf_Note;
60 typedef Elf64_Nhdr Elf_Note;
64 /* elfdump(1) options. */
66 #define ED_EHDR (1<<1)
68 #define ED_HASH (1<<3)
69 #define ED_INTERP (1<<4)
70 #define ED_NOTE (1<<5)
71 #define ED_PHDR (1<<6)
73 #define ED_SHDR (1<<8)
74 #define ED_SYMTAB (1<<9)
75 #define ED_SYMVER (1<<10)
76 #define ED_CHECKSUM (1<<11)
77 #define ED_ALL ((1<<12)-1)
79 /* elfdump(1) run control flags. */
80 #define SOLARIS_FMT (1<<0)
81 #define PRINT_FILENAME (1<<1)
82 #define PRINT_ARSYM (1<<2)
83 #define ONLY_ARSYM (1<<3)
85 /* Convenient print macro. */
86 #define PRT(...) fprintf(ed->out, __VA_ARGS__)
88 /* Internal data structure for sections. */
90 const char *name; /* section name */
91 Elf_Scn *scn; /* section scn */
92 uint64_t off; /* section offset */
93 uint64_t sz; /* section size */
94 uint64_t entsize; /* section entsize */
95 uint64_t align; /* section alignment */
96 uint64_t type; /* section type */
97 uint64_t flags; /* section flags */
98 uint64_t addr; /* section virtual addr */
99 uint32_t link; /* section link ndx */
100 uint32_t info; /* section info ndx */
105 STAILQ_ENTRY(spec_name) sn_list;
108 /* Structure encapsulates the global data for readelf(1). */
110 FILE *out; /* output redirection. */
111 const char *filename; /* current processing file. */
112 const char *archive; /* archive name */
113 int options; /* command line options. */
114 int flags; /* run control flags. */
115 Elf *elf; /* underlying ELF descriptor. */
116 #ifndef USE_LIBARCHIVE_AR
117 Elf *ar; /* ar(1) archive descriptor. */
119 GElf_Ehdr ehdr; /* ELF header. */
120 int ec; /* ELF class. */
121 size_t shnum; /* #sections. */
122 struct section *sl; /* list of sections. */
123 STAILQ_HEAD(, spec_name) snl; /* list of names specified by -N. */
126 /* Relocation entry. */
136 #if defined(ELFTC_NEED_BYTEORDER_EXTENSIONS)
137 static __inline uint32_t
138 be32dec(const void *pp)
140 unsigned char const *p = (unsigned char const *)pp;
142 return ((p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]);
145 static __inline uint32_t
146 le32dec(const void *pp)
148 unsigned char const *p = (unsigned char const *)pp;
150 return ((p[3] << 24) | (p[2] << 16) | (p[1] << 8) | p[0]);
154 /* http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#tag_encodings */
159 case 0: return "DT_NULL";
160 case 1: return "DT_NEEDED";
161 case 2: return "DT_PLTRELSZ";
162 case 3: return "DT_PLTGOT";
163 case 4: return "DT_HASH";
164 case 5: return "DT_STRTAB";
165 case 6: return "DT_SYMTAB";
166 case 7: return "DT_RELA";
167 case 8: return "DT_RELASZ";
168 case 9: return "DT_RELAENT";
169 case 10: return "DT_STRSZ";
170 case 11: return "DT_SYMENT";
171 case 12: return "DT_INIT";
172 case 13: return "DT_FINI";
173 case 14: return "DT_SONAME";
174 case 15: return "DT_RPATH";
175 case 16: return "DT_SYMBOLIC";
176 case 17: return "DT_REL";
177 case 18: return "DT_RELSZ";
178 case 19: return "DT_RELENT";
179 case 20: return "DT_PLTREL";
180 case 21: return "DT_DEBUG";
181 case 22: return "DT_TEXTREL";
182 case 23: return "DT_JMPREL";
183 case 24: return "DT_BIND_NOW";
184 case 25: return "DT_INIT_ARRAY";
185 case 26: return "DT_FINI_ARRAY";
186 case 27: return "DT_INIT_ARRAYSZ";
187 case 28: return "DT_FINI_ARRAYSZ";
188 case 29: return "DT_RUNPATH";
189 case 30: return "DT_FLAGS";
190 case 32: return "DT_PREINIT_ARRAY"; /* XXX: DT_ENCODING */
191 case 33: return "DT_PREINIT_ARRAYSZ";
192 /* 0x6000000D - 0x6ffff000 operating system-specific semantics */
193 case 0x6ffffdf5: return "DT_GNU_PRELINKED";
194 case 0x6ffffdf6: return "DT_GNU_CONFLICTSZ";
195 case 0x6ffffdf7: return "DT_GNU_LIBLISTSZ";
196 case 0x6ffffdf8: return "DT_SUNW_CHECKSUM";
197 case 0x6ffffdf9: return "DT_PLTPADSZ";
198 case 0x6ffffdfa: return "DT_MOVEENT";
199 case 0x6ffffdfb: return "DT_MOVESZ";
200 case 0x6ffffdfc: return "DT_FEATURE";
201 case 0x6ffffdfd: return "DT_POSFLAG_1";
202 case 0x6ffffdfe: return "DT_SYMINSZ";
203 case 0x6ffffdff: return "DT_SYMINENT (DT_VALRNGHI)";
204 case 0x6ffffe00: return "DT_ADDRRNGLO";
205 case 0x6ffffef5: return "DT_GNU_HASH";
206 case 0x6ffffef8: return "DT_GNU_CONFLICT";
207 case 0x6ffffef9: return "DT_GNU_LIBLIST";
208 case 0x6ffffefa: return "DT_SUNW_CONFIG";
209 case 0x6ffffefb: return "DT_SUNW_DEPAUDIT";
210 case 0x6ffffefc: return "DT_SUNW_AUDIT";
211 case 0x6ffffefd: return "DT_SUNW_PLTPAD";
212 case 0x6ffffefe: return "DT_SUNW_MOVETAB";
213 case 0x6ffffeff: return "DT_SYMINFO (DT_ADDRRNGHI)";
214 case 0x6ffffff9: return "DT_RELACOUNT";
215 case 0x6ffffffa: return "DT_RELCOUNT";
216 case 0x6ffffffb: return "DT_FLAGS_1";
217 case 0x6ffffffc: return "DT_VERDEF";
218 case 0x6ffffffd: return "DT_VERDEFNUM";
219 case 0x6ffffffe: return "DT_VERNEED";
220 case 0x6fffffff: return "DT_VERNEEDNUM";
221 case 0x6ffffff0: return "DT_GNU_VERSYM";
222 /* 0x70000000 - 0x7fffffff processor-specific semantics */
223 case 0x70000000: return "DT_IA_64_PLT_RESERVE";
224 case 0x7ffffffd: return "DT_SUNW_AUXILIARY";
225 case 0x7ffffffe: return "DT_SUNW_USED";
226 case 0x7fffffff: return "DT_SUNW_FILTER";
227 default: return "ERROR: TAG NOT DEFINED";
232 e_machines(unsigned int mach)
234 static char machdesc[64];
237 case EM_NONE: return "EM_NONE";
238 case EM_M32: return "EM_M32";
239 case EM_SPARC: return "EM_SPARC";
240 case EM_386: return "EM_386";
241 case EM_68K: return "EM_68K";
242 case EM_88K: return "EM_88K";
243 case EM_IAMCU: return "EM_IAMCU";
244 case EM_860: return "EM_860";
245 case EM_MIPS: return "EM_MIPS";
246 case EM_PPC: return "EM_PPC";
247 case EM_ARM: return "EM_ARM";
248 case EM_ALPHA: return "EM_ALPHA (legacy)";
249 case EM_SPARCV9:return "EM_SPARCV9";
250 case EM_IA_64: return "EM_IA_64";
251 case EM_X86_64: return "EM_X86_64";
253 snprintf(machdesc, sizeof(machdesc),
254 "(unknown machine) -- type 0x%x", mach);
258 static const char *e_types[] = {
259 "ET_NONE", "ET_REL", "ET_EXEC", "ET_DYN", "ET_CORE"
262 static const char *ei_versions[] = {
263 "EV_NONE", "EV_CURRENT"
266 static const char *ei_classes[] = {
267 "ELFCLASSNONE", "ELFCLASS32", "ELFCLASS64"
270 static const char *ei_data[] = {
271 "ELFDATANONE", "ELFDATA2LSB", "ELFDATA2MSB"
274 static const char *ei_abis[] = {
275 "ELFOSABI_SYSV", "ELFOSABI_HPUX", "ELFOSABI_NETBSD", "ELFOSABI_LINUX",
276 "ELFOSABI_HURD", "ELFOSABI_86OPEN", "ELFOSABI_SOLARIS",
277 "ELFOSABI_MONTEREY", "ELFOSABI_IRIX", "ELFOSABI_FREEBSD",
278 "ELFOSABI_TRU64", "ELFOSABI_MODESTO", "ELFOSABI_OPENBSD"
281 static const char *p_types[] = {
282 "PT_NULL", "PT_LOAD", "PT_DYNAMIC", "PT_INTERP", "PT_NOTE",
283 "PT_SHLIB", "PT_PHDR", "PT_TLS"
286 static const char *p_flags[] = {
287 "", "PF_X", "PF_W", "PF_X|PF_W", "PF_R", "PF_X|PF_R", "PF_W|PF_R",
292 sh_name(struct elfdump *ed, int ndx)
297 case SHN_UNDEF: return "UNDEF";
298 case SHN_ABS: return "ABS";
299 case SHN_COMMON: return "COMMON";
301 if ((uint64_t)ndx < ed->shnum)
302 return (ed->sl[ndx].name);
304 snprintf(num, sizeof(num), "%d", ndx);
310 /* http://www.sco.com/developers/gabi/latest/ch4.sheader.html#sh_type */
312 sh_types(u_int64_t sht) {
314 case 0: return "SHT_NULL";
315 case 1: return "SHT_PROGBITS";
316 case 2: return "SHT_SYMTAB";
317 case 3: return "SHT_STRTAB";
318 case 4: return "SHT_RELA";
319 case 5: return "SHT_HASH";
320 case 6: return "SHT_DYNAMIC";
321 case 7: return "SHT_NOTE";
322 case 8: return "SHT_NOBITS";
323 case 9: return "SHT_REL";
324 case 10: return "SHT_SHLIB";
325 case 11: return "SHT_DYNSYM";
326 case 14: return "SHT_INIT_ARRAY";
327 case 15: return "SHT_FINI_ARRAY";
328 case 16: return "SHT_PREINIT_ARRAY";
329 case 17: return "SHT_GROUP";
330 case 18: return "SHT_SYMTAB_SHNDX";
331 /* 0x60000000 - 0x6fffffff operating system-specific semantics */
332 case 0x6ffffff0: return "XXX:VERSYM";
333 case 0x6ffffff6: return "SHT_GNU_HASH";
334 case 0x6ffffff7: return "SHT_GNU_LIBLIST";
335 case 0x6ffffffc: return "XXX:VERDEF";
336 case 0x6ffffffd: return "SHT_SUNW(GNU)_verdef";
337 case 0x6ffffffe: return "SHT_SUNW(GNU)_verneed";
338 case 0x6fffffff: return "SHT_SUNW(GNU)_versym";
339 /* 0x70000000 - 0x7fffffff processor-specific semantics */
340 case 0x70000000: return "SHT_IA_64_EXT";
341 case 0x70000001: return "SHT_IA_64_UNWIND";
342 case 0x7ffffffd: return "XXX:AUXILIARY";
343 case 0x7fffffff: return "XXX:FILTER";
344 /* 0x80000000 - 0xffffffff application programs */
345 default: return "ERROR: SHT NOT DEFINED";
350 * Define known section flags. These flags are defined in the order
351 * they are to be printed out.
353 #define DEFINE_SHFLAGS() \
356 DEFINE_SHF(EXECINSTR) \
358 DEFINE_SHF(STRINGS) \
359 DEFINE_SHF(INFO_LINK) \
360 DEFINE_SHF(LINK_ORDER) \
361 DEFINE_SHF(OS_NONCONFORMING) \
366 #define DEFINE_SHF(F) "SHF_" #F "|"
367 #define ALLSHFLAGS DEFINE_SHFLAGS()
370 sh_flags(uint64_t shf)
372 static char flg[sizeof(ALLSHFLAGS)+1];
377 #define DEFINE_SHF(N) \
379 strcat(flg, "SHF_" #N "|"); \
383 flg[strlen(flg) - 1] = '\0'; /* Remove the trailing "|". */
388 static const char *st_types[] = {
389 "STT_NOTYPE", "STT_OBJECT", "STT_FUNC", "STT_SECTION", "STT_FILE",
390 "STT_COMMON", "STT_TLS"
393 static const char *st_types_S[] = {
394 "NOTY", "OBJT", "FUNC", "SECT", "FILE"
397 static const char *st_bindings[] = {
398 "STB_LOCAL", "STB_GLOBAL", "STB_WEAK"
401 static const char *st_bindings_S[] = {
402 "LOCL", "GLOB", "WEAK"
405 static unsigned char st_others[] = {
410 r_type(unsigned int mach, unsigned int type)
413 case EM_NONE: return "";
417 case 0: return "R_386_NONE";
418 case 1: return "R_386_32";
419 case 2: return "R_386_PC32";
420 case 3: return "R_386_GOT32";
421 case 4: return "R_386_PLT32";
422 case 5: return "R_386_COPY";
423 case 6: return "R_386_GLOB_DAT";
424 case 7: return "R_386_JMP_SLOT";
425 case 8: return "R_386_RELATIVE";
426 case 9: return "R_386_GOTOFF";
427 case 10: return "R_386_GOTPC";
428 case 14: return "R_386_TLS_TPOFF";
429 case 15: return "R_386_TLS_IE";
430 case 16: return "R_386_TLS_GOTIE";
431 case 17: return "R_386_TLS_LE";
432 case 18: return "R_386_TLS_GD";
433 case 19: return "R_386_TLS_LDM";
434 case 24: return "R_386_TLS_GD_32";
435 case 25: return "R_386_TLS_GD_PUSH";
436 case 26: return "R_386_TLS_GD_CALL";
437 case 27: return "R_386_TLS_GD_POP";
438 case 28: return "R_386_TLS_LDM_32";
439 case 29: return "R_386_TLS_LDM_PUSH";
440 case 30: return "R_386_TLS_LDM_CALL";
441 case 31: return "R_386_TLS_LDM_POP";
442 case 32: return "R_386_TLS_LDO_32";
443 case 33: return "R_386_TLS_IE_32";
444 case 34: return "R_386_TLS_LE_32";
445 case 35: return "R_386_TLS_DTPMOD32";
446 case 36: return "R_386_TLS_DTPOFF32";
447 case 37: return "R_386_TLS_TPOFF32";
452 case 0: return "R_ARM_NONE";
453 case 1: return "R_ARM_PC24";
454 case 2: return "R_ARM_ABS32";
455 case 3: return "R_ARM_REL32";
456 case 4: return "R_ARM_PC13";
457 case 5: return "R_ARM_ABS16";
458 case 6: return "R_ARM_ABS12";
459 case 7: return "R_ARM_THM_ABS5";
460 case 8: return "R_ARM_ABS8";
461 case 9: return "R_ARM_SBREL32";
462 case 10: return "R_ARM_THM_PC22";
463 case 11: return "R_ARM_THM_PC8";
464 case 12: return "R_ARM_AMP_VCALL9";
465 case 13: return "R_ARM_SWI24";
466 case 14: return "R_ARM_THM_SWI8";
467 case 15: return "R_ARM_XPC25";
468 case 16: return "R_ARM_THM_XPC22";
469 case 20: return "R_ARM_COPY";
470 case 21: return "R_ARM_GLOB_DAT";
471 case 22: return "R_ARM_JUMP_SLOT";
472 case 23: return "R_ARM_RELATIVE";
473 case 24: return "R_ARM_GOTOFF";
474 case 25: return "R_ARM_GOTPC";
475 case 26: return "R_ARM_GOT32";
476 case 27: return "R_ARM_PLT32";
477 case 100: return "R_ARM_GNU_VTENTRY";
478 case 101: return "R_ARM_GNU_VTINHERIT";
479 case 250: return "R_ARM_RSBREL32";
480 case 251: return "R_ARM_THM_RPC22";
481 case 252: return "R_ARM_RREL32";
482 case 253: return "R_ARM_RABS32";
483 case 254: return "R_ARM_RPC24";
484 case 255: return "R_ARM_RBASE";
489 case 0: return "R_IA_64_NONE";
490 case 33: return "R_IA_64_IMM14";
491 case 34: return "R_IA_64_IMM22";
492 case 35: return "R_IA_64_IMM64";
493 case 36: return "R_IA_64_DIR32MSB";
494 case 37: return "R_IA_64_DIR32LSB";
495 case 38: return "R_IA_64_DIR64MSB";
496 case 39: return "R_IA_64_DIR64LSB";
497 case 42: return "R_IA_64_GPREL22";
498 case 43: return "R_IA_64_GPREL64I";
499 case 44: return "R_IA_64_GPREL32MSB";
500 case 45: return "R_IA_64_GPREL32LSB";
501 case 46: return "R_IA_64_GPREL64MSB";
502 case 47: return "R_IA_64_GPREL64LSB";
503 case 50: return "R_IA_64_LTOFF22";
504 case 51: return "R_IA_64_LTOFF64I";
505 case 58: return "R_IA_64_PLTOFF22";
506 case 59: return "R_IA_64_PLTOFF64I";
507 case 62: return "R_IA_64_PLTOFF64MSB";
508 case 63: return "R_IA_64_PLTOFF64LSB";
509 case 67: return "R_IA_64_FPTR64I";
510 case 68: return "R_IA_64_FPTR32MSB";
511 case 69: return "R_IA_64_FPTR32LSB";
512 case 70: return "R_IA_64_FPTR64MSB";
513 case 71: return "R_IA_64_FPTR64LSB";
514 case 72: return "R_IA_64_PCREL60B";
515 case 73: return "R_IA_64_PCREL21B";
516 case 74: return "R_IA_64_PCREL21M";
517 case 75: return "R_IA_64_PCREL21F";
518 case 76: return "R_IA_64_PCREL32MSB";
519 case 77: return "R_IA_64_PCREL32LSB";
520 case 78: return "R_IA_64_PCREL64MSB";
521 case 79: return "R_IA_64_PCREL64LSB";
522 case 82: return "R_IA_64_LTOFF_FPTR22";
523 case 83: return "R_IA_64_LTOFF_FPTR64I";
524 case 84: return "R_IA_64_LTOFF_FPTR32MSB";
525 case 85: return "R_IA_64_LTOFF_FPTR32LSB";
526 case 86: return "R_IA_64_LTOFF_FPTR64MSB";
527 case 87: return "R_IA_64_LTOFF_FPTR64LSB";
528 case 92: return "R_IA_64_SEGREL32MSB";
529 case 93: return "R_IA_64_SEGREL32LSB";
530 case 94: return "R_IA_64_SEGREL64MSB";
531 case 95: return "R_IA_64_SEGREL64LSB";
532 case 100: return "R_IA_64_SECREL32MSB";
533 case 101: return "R_IA_64_SECREL32LSB";
534 case 102: return "R_IA_64_SECREL64MSB";
535 case 103: return "R_IA_64_SECREL64LSB";
536 case 108: return "R_IA_64_REL32MSB";
537 case 109: return "R_IA_64_REL32LSB";
538 case 110: return "R_IA_64_REL64MSB";
539 case 111: return "R_IA_64_REL64LSB";
540 case 116: return "R_IA_64_LTV32MSB";
541 case 117: return "R_IA_64_LTV32LSB";
542 case 118: return "R_IA_64_LTV64MSB";
543 case 119: return "R_IA_64_LTV64LSB";
544 case 121: return "R_IA_64_PCREL21BI";
545 case 122: return "R_IA_64_PCREL22";
546 case 123: return "R_IA_64_PCREL64I";
547 case 128: return "R_IA_64_IPLTMSB";
548 case 129: return "R_IA_64_IPLTLSB";
549 case 133: return "R_IA_64_SUB";
550 case 134: return "R_IA_64_LTOFF22X";
551 case 135: return "R_IA_64_LDXMOV";
552 case 145: return "R_IA_64_TPREL14";
553 case 146: return "R_IA_64_TPREL22";
554 case 147: return "R_IA_64_TPREL64I";
555 case 150: return "R_IA_64_TPREL64MSB";
556 case 151: return "R_IA_64_TPREL64LSB";
557 case 154: return "R_IA_64_LTOFF_TPREL22";
558 case 166: return "R_IA_64_DTPMOD64MSB";
559 case 167: return "R_IA_64_DTPMOD64LSB";
560 case 170: return "R_IA_64_LTOFF_DTPMOD22";
561 case 177: return "R_IA_64_DTPREL14";
562 case 178: return "R_IA_64_DTPREL22";
563 case 179: return "R_IA_64_DTPREL64I";
564 case 180: return "R_IA_64_DTPREL32MSB";
565 case 181: return "R_IA_64_DTPREL32LSB";
566 case 182: return "R_IA_64_DTPREL64MSB";
567 case 183: return "R_IA_64_DTPREL64LSB";
568 case 186: return "R_IA_64_LTOFF_DTPREL22";
573 case 0: return "R_MIPS_NONE";
574 case 1: return "R_MIPS_16";
575 case 2: return "R_MIPS_32";
576 case 3: return "R_MIPS_REL32";
577 case 4: return "R_MIPS_26";
578 case 5: return "R_MIPS_HI16";
579 case 6: return "R_MIPS_LO16";
580 case 7: return "R_MIPS_GPREL16";
581 case 8: return "R_MIPS_LITERAL";
582 case 9: return "R_MIPS_GOT16";
583 case 10: return "R_MIPS_PC16";
584 case 11: return "R_MIPS_CALL16";
585 case 12: return "R_MIPS_GPREL32";
586 case 21: return "R_MIPS_GOTHI16";
587 case 22: return "R_MIPS_GOTLO16";
588 case 30: return "R_MIPS_CALLHI16";
589 case 31: return "R_MIPS_CALLLO16";
594 case 0: return "R_PPC_NONE";
595 case 1: return "R_PPC_ADDR32";
596 case 2: return "R_PPC_ADDR24";
597 case 3: return "R_PPC_ADDR16";
598 case 4: return "R_PPC_ADDR16_LO";
599 case 5: return "R_PPC_ADDR16_HI";
600 case 6: return "R_PPC_ADDR16_HA";
601 case 7: return "R_PPC_ADDR14";
602 case 8: return "R_PPC_ADDR14_BRTAKEN";
603 case 9: return "R_PPC_ADDR14_BRNTAKEN";
604 case 10: return "R_PPC_REL24";
605 case 11: return "R_PPC_REL14";
606 case 12: return "R_PPC_REL14_BRTAKEN";
607 case 13: return "R_PPC_REL14_BRNTAKEN";
608 case 14: return "R_PPC_GOT16";
609 case 15: return "R_PPC_GOT16_LO";
610 case 16: return "R_PPC_GOT16_HI";
611 case 17: return "R_PPC_GOT16_HA";
612 case 18: return "R_PPC_PLTREL24";
613 case 19: return "R_PPC_COPY";
614 case 20: return "R_PPC_GLOB_DAT";
615 case 21: return "R_PPC_JMP_SLOT";
616 case 22: return "R_PPC_RELATIVE";
617 case 23: return "R_PPC_LOCAL24PC";
618 case 24: return "R_PPC_UADDR32";
619 case 25: return "R_PPC_UADDR16";
620 case 26: return "R_PPC_REL32";
621 case 27: return "R_PPC_PLT32";
622 case 28: return "R_PPC_PLTREL32";
623 case 29: return "R_PPC_PLT16_LO";
624 case 30: return "R_PPC_PLT16_HI";
625 case 31: return "R_PPC_PLT16_HA";
626 case 32: return "R_PPC_SDAREL16";
627 case 33: return "R_PPC_SECTOFF";
628 case 34: return "R_PPC_SECTOFF_LO";
629 case 35: return "R_PPC_SECTOFF_HI";
630 case 36: return "R_PPC_SECTOFF_HA";
631 case 67: return "R_PPC_TLS";
632 case 68: return "R_PPC_DTPMOD32";
633 case 69: return "R_PPC_TPREL16";
634 case 70: return "R_PPC_TPREL16_LO";
635 case 71: return "R_PPC_TPREL16_HI";
636 case 72: return "R_PPC_TPREL16_HA";
637 case 73: return "R_PPC_TPREL32";
638 case 74: return "R_PPC_DTPREL16";
639 case 75: return "R_PPC_DTPREL16_LO";
640 case 76: return "R_PPC_DTPREL16_HI";
641 case 77: return "R_PPC_DTPREL16_HA";
642 case 78: return "R_PPC_DTPREL32";
643 case 79: return "R_PPC_GOT_TLSGD16";
644 case 80: return "R_PPC_GOT_TLSGD16_LO";
645 case 81: return "R_PPC_GOT_TLSGD16_HI";
646 case 82: return "R_PPC_GOT_TLSGD16_HA";
647 case 83: return "R_PPC_GOT_TLSLD16";
648 case 84: return "R_PPC_GOT_TLSLD16_LO";
649 case 85: return "R_PPC_GOT_TLSLD16_HI";
650 case 86: return "R_PPC_GOT_TLSLD16_HA";
651 case 87: return "R_PPC_GOT_TPREL16";
652 case 88: return "R_PPC_GOT_TPREL16_LO";
653 case 89: return "R_PPC_GOT_TPREL16_HI";
654 case 90: return "R_PPC_GOT_TPREL16_HA";
655 case 101: return "R_PPC_EMB_NADDR32";
656 case 102: return "R_PPC_EMB_NADDR16";
657 case 103: return "R_PPC_EMB_NADDR16_LO";
658 case 104: return "R_PPC_EMB_NADDR16_HI";
659 case 105: return "R_PPC_EMB_NADDR16_HA";
660 case 106: return "R_PPC_EMB_SDAI16";
661 case 107: return "R_PPC_EMB_SDA2I16";
662 case 108: return "R_PPC_EMB_SDA2REL";
663 case 109: return "R_PPC_EMB_SDA21";
664 case 110: return "R_PPC_EMB_MRKREF";
665 case 111: return "R_PPC_EMB_RELSEC16";
666 case 112: return "R_PPC_EMB_RELST_LO";
667 case 113: return "R_PPC_EMB_RELST_HI";
668 case 114: return "R_PPC_EMB_RELST_HA";
669 case 115: return "R_PPC_EMB_BIT_FLD";
670 case 116: return "R_PPC_EMB_RELSDA";
676 case 0: return "R_SPARC_NONE";
677 case 1: return "R_SPARC_8";
678 case 2: return "R_SPARC_16";
679 case 3: return "R_SPARC_32";
680 case 4: return "R_SPARC_DISP8";
681 case 5: return "R_SPARC_DISP16";
682 case 6: return "R_SPARC_DISP32";
683 case 7: return "R_SPARC_WDISP30";
684 case 8: return "R_SPARC_WDISP22";
685 case 9: return "R_SPARC_HI22";
686 case 10: return "R_SPARC_22";
687 case 11: return "R_SPARC_13";
688 case 12: return "R_SPARC_LO10";
689 case 13: return "R_SPARC_GOT10";
690 case 14: return "R_SPARC_GOT13";
691 case 15: return "R_SPARC_GOT22";
692 case 16: return "R_SPARC_PC10";
693 case 17: return "R_SPARC_PC22";
694 case 18: return "R_SPARC_WPLT30";
695 case 19: return "R_SPARC_COPY";
696 case 20: return "R_SPARC_GLOB_DAT";
697 case 21: return "R_SPARC_JMP_SLOT";
698 case 22: return "R_SPARC_RELATIVE";
699 case 23: return "R_SPARC_UA32";
700 case 24: return "R_SPARC_PLT32";
701 case 25: return "R_SPARC_HIPLT22";
702 case 26: return "R_SPARC_LOPLT10";
703 case 27: return "R_SPARC_PCPLT32";
704 case 28: return "R_SPARC_PCPLT22";
705 case 29: return "R_SPARC_PCPLT10";
706 case 30: return "R_SPARC_10";
707 case 31: return "R_SPARC_11";
708 case 32: return "R_SPARC_64";
709 case 33: return "R_SPARC_OLO10";
710 case 34: return "R_SPARC_HH22";
711 case 35: return "R_SPARC_HM10";
712 case 36: return "R_SPARC_LM22";
713 case 37: return "R_SPARC_PC_HH22";
714 case 38: return "R_SPARC_PC_HM10";
715 case 39: return "R_SPARC_PC_LM22";
716 case 40: return "R_SPARC_WDISP16";
717 case 41: return "R_SPARC_WDISP19";
718 case 42: return "R_SPARC_GLOB_JMP";
719 case 43: return "R_SPARC_7";
720 case 44: return "R_SPARC_5";
721 case 45: return "R_SPARC_6";
722 case 46: return "R_SPARC_DISP64";
723 case 47: return "R_SPARC_PLT64";
724 case 48: return "R_SPARC_HIX22";
725 case 49: return "R_SPARC_LOX10";
726 case 50: return "R_SPARC_H44";
727 case 51: return "R_SPARC_M44";
728 case 52: return "R_SPARC_L44";
729 case 53: return "R_SPARC_REGISTER";
730 case 54: return "R_SPARC_UA64";
731 case 55: return "R_SPARC_UA16";
732 case 56: return "R_SPARC_TLS_GD_HI22";
733 case 57: return "R_SPARC_TLS_GD_LO10";
734 case 58: return "R_SPARC_TLS_GD_ADD";
735 case 59: return "R_SPARC_TLS_GD_CALL";
736 case 60: return "R_SPARC_TLS_LDM_HI22";
737 case 61: return "R_SPARC_TLS_LDM_LO10";
738 case 62: return "R_SPARC_TLS_LDM_ADD";
739 case 63: return "R_SPARC_TLS_LDM_CALL";
740 case 64: return "R_SPARC_TLS_LDO_HIX22";
741 case 65: return "R_SPARC_TLS_LDO_LOX10";
742 case 66: return "R_SPARC_TLS_LDO_ADD";
743 case 67: return "R_SPARC_TLS_IE_HI22";
744 case 68: return "R_SPARC_TLS_IE_LO10";
745 case 69: return "R_SPARC_TLS_IE_LD";
746 case 70: return "R_SPARC_TLS_IE_LDX";
747 case 71: return "R_SPARC_TLS_IE_ADD";
748 case 72: return "R_SPARC_TLS_LE_HIX22";
749 case 73: return "R_SPARC_TLS_LE_LOX10";
750 case 74: return "R_SPARC_TLS_DTPMOD32";
751 case 75: return "R_SPARC_TLS_DTPMOD64";
752 case 76: return "R_SPARC_TLS_DTPOFF32";
753 case 77: return "R_SPARC_TLS_DTPOFF64";
754 case 78: return "R_SPARC_TLS_TPOFF32";
755 case 79: return "R_SPARC_TLS_TPOFF64";
760 case 0: return "R_X86_64_NONE";
761 case 1: return "R_X86_64_64";
762 case 2: return "R_X86_64_PC32";
763 case 3: return "R_X86_64_GOT32";
764 case 4: return "R_X86_64_PLT32";
765 case 5: return "R_X86_64_COPY";
766 case 6: return "R_X86_64_GLOB_DAT";
767 case 7: return "R_X86_64_JMP_SLOT";
768 case 8: return "R_X86_64_RELATIVE";
769 case 9: return "R_X86_64_GOTPCREL";
770 case 10: return "R_X86_64_32";
771 case 11: return "R_X86_64_32S";
772 case 12: return "R_X86_64_16";
773 case 13: return "R_X86_64_PC16";
774 case 14: return "R_X86_64_8";
775 case 15: return "R_X86_64_PC8";
776 case 16: return "R_X86_64_DTPMOD64";
777 case 17: return "R_X86_64_DTPOFF64";
778 case 18: return "R_X86_64_TPOFF64";
779 case 19: return "R_X86_64_TLSGD";
780 case 20: return "R_X86_64_TLSLD";
781 case 21: return "R_X86_64_DTPOFF32";
782 case 22: return "R_X86_64_GOTTPOFF";
783 case 23: return "R_X86_64_TPOFF32";
790 static void add_name(struct elfdump *ed, const char *name);
791 static void elf_print_object(struct elfdump *ed);
792 static void elf_print_elf(struct elfdump *ed);
793 static void elf_print_ehdr(struct elfdump *ed);
794 static void elf_print_phdr(struct elfdump *ed);
795 static void elf_print_shdr(struct elfdump *ed);
796 static void elf_print_symtab(struct elfdump *ed, int i);
797 static void elf_print_symtabs(struct elfdump *ed);
798 static void elf_print_symver(struct elfdump *ed);
799 static void elf_print_verdef(struct elfdump *ed, struct section *s);
800 static void elf_print_verneed(struct elfdump *ed, struct section *s);
801 static void elf_print_interp(struct elfdump *ed);
802 static void elf_print_dynamic(struct elfdump *ed);
803 static void elf_print_rel_entry(struct elfdump *ed, struct section *s,
804 int j, struct rel_entry *r);
805 static void elf_print_rela(struct elfdump *ed, struct section *s,
807 static void elf_print_rel(struct elfdump *ed, struct section *s,
809 static void elf_print_reloc(struct elfdump *ed);
810 static void elf_print_got(struct elfdump *ed);
811 static void elf_print_got_section(struct elfdump *ed, struct section *s);
812 static void elf_print_note(struct elfdump *ed);
813 static void elf_print_svr4_hash(struct elfdump *ed, struct section *s);
814 static void elf_print_svr4_hash64(struct elfdump *ed, struct section *s);
815 static void elf_print_gnu_hash(struct elfdump *ed, struct section *s);
816 static void elf_print_hash(struct elfdump *ed);
817 static void elf_print_checksum(struct elfdump *ed);
818 static void find_gotrel(struct elfdump *ed, struct section *gs,
819 struct rel_entry *got);
820 static struct spec_name *find_name(struct elfdump *ed, const char *name);
821 static const char *get_symbol_name(struct elfdump *ed, int symtab, int i);
822 static const char *get_string(struct elfdump *ed, int strtab, size_t off);
823 static void get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs);
824 static void load_sections(struct elfdump *ed);
825 static void unload_sections(struct elfdump *ed);
826 static void usage(void);
827 #ifdef USE_LIBARCHIVE_AR
828 static int ac_detect_ar(int fd);
829 static void ac_print_ar(struct elfdump *ed, int fd);
831 static void elf_print_ar(struct elfdump *ed, int fd);
832 #endif /* USE_LIBARCHIVE_AR */
834 static struct option elfdump_longopts[] =
836 { "help", no_argument, NULL, 'H' },
837 { "version", no_argument, NULL, 'V' },
842 main(int ac, char **av)
844 struct elfdump *ed, ed_storage;
845 struct spec_name *sn;
849 memset(ed, 0, sizeof(*ed));
850 STAILQ_INIT(&ed->snl);
852 while ((ch = getopt_long(ac, av, "acdeiGHhknN:prsSvVw:",
853 elfdump_longopts, NULL)) != -1)
856 ed->options = ED_ALL;
859 ed->options |= ED_SHDR;
862 ed->options |= ED_DYN;
865 ed->options |= ED_EHDR;
868 ed->options |= ED_INTERP;
871 ed->options |= ED_GOT;
874 ed->options |= ED_HASH;
877 ed->options |= ED_CHECKSUM;
880 ed->options |= ED_NOTE;
883 add_name(ed, optarg);
886 ed->options |= ED_PHDR;
889 ed->options |= ED_REL;
892 ed->options |= ED_SYMTAB;
895 ed->flags |= SOLARIS_FMT;
898 ed->options |= ED_SYMVER;
901 (void) printf("%s (%s)\n", ELFTC_GETPROGNAME(),
906 if ((ed->out = fopen(optarg, "w")) == NULL)
907 err(EXIT_FAILURE, "%s", optarg);
918 if (ed->options == 0)
919 ed->options = ED_ALL;
921 if (ed->options & ED_SYMTAB &&
922 (STAILQ_EMPTY(&ed->snl) || (sn = find_name(ed, "ARSYM")) != NULL)) {
923 ed->flags |= PRINT_ARSYM;
925 STAILQ_REMOVE(&ed->snl, sn, spec_name, sn_list);
926 if (STAILQ_EMPTY(&ed->snl))
927 ed->flags |= ONLY_ARSYM;
933 ed->flags |= PRINT_FILENAME;
934 if (elf_version(EV_CURRENT) == EV_NONE)
935 errx(EXIT_FAILURE, "ELF library initialization failed: %s",
938 for (i = 0; i < ac; i++) {
939 ed->filename = av[i];
941 elf_print_object(ed);
947 #ifdef USE_LIBARCHIVE_AR
949 /* Archive symbol table entry. */
956 * Convenient wrapper for general libarchive error handling.
958 #define AC(CALL) do { \
960 warnx("%s", archive_error_string(a)); \
966 * Detect an ar(1) archive using libarchive(3).
972 struct archive_entry *entry;
976 if ((a = archive_read_new()) == NULL)
978 archive_read_support_format_ar(a);
979 if (archive_read_open_fd(a, fd, 10240) == ARCHIVE_OK)
980 r = archive_read_next_header(a, &entry);
981 archive_read_close(a);
982 archive_read_free(a);
984 return (r == ARCHIVE_OK);
988 * Dump an ar(1) archive using libarchive(3).
991 ac_print_ar(struct elfdump *ed, int fd)
994 struct archive_entry *entry;
995 struct arsym_entry *arsym;
1003 if (lseek(fd, 0, SEEK_SET) == -1)
1004 err(EXIT_FAILURE, "lseek failed");
1005 if ((a = archive_read_new()) == NULL)
1006 errx(EXIT_FAILURE, "%s", archive_error_string(a));
1007 archive_read_support_format_ar(a);
1008 AC(archive_read_open_fd(a, fd, 10240));
1010 r = archive_read_next_header(a, &entry);
1011 if (r == ARCHIVE_FATAL)
1012 errx(EXIT_FAILURE, "%s", archive_error_string(a));
1013 if (r == ARCHIVE_EOF)
1015 if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY)
1016 warnx("%s", archive_error_string(a));
1017 if (r == ARCHIVE_RETRY)
1019 name = archive_entry_pathname(entry);
1020 size = archive_entry_size(entry);
1023 if ((buff = malloc(size)) == NULL) {
1024 warn("malloc failed");
1027 if (archive_read_data(a, buff, size) != (ssize_t)size) {
1028 warnx("%s", archive_error_string(a));
1034 * Note that when processing arsym via libarchive, there is
1035 * no way to tell which member a certain symbol belongs to,
1036 * since we can not just "lseek" to a member offset and read
1037 * the member header.
1039 if (!strcmp(name, "/") && ed->flags & PRINT_ARSYM) {
1046 arsym = calloc(cnt, sizeof(*arsym));
1048 err(EXIT_FAILURE, "calloc failed");
1049 b += sizeof(uint32_t);
1050 for (i = 0; (size_t)i < cnt; i++) {
1051 arsym[i].off = be32dec(b);
1052 b += sizeof(uint32_t);
1054 for (i = 0; (size_t)i < cnt; i++) {
1055 arsym[i].sym_name = b;
1058 if (ed->flags & SOLARIS_FMT) {
1059 PRT("\nSymbol Table: (archive)\n");
1060 PRT(" index offset symbol\n");
1062 PRT("\nsymbol table (archive):\n");
1063 for (i = 0; (size_t)i < cnt; i++) {
1064 if (ed->flags & SOLARIS_FMT) {
1065 snprintf(idx, sizeof(idx), "[%d]", i);
1068 (uintmax_t)arsym[i].off);
1069 PRT("%s\n", arsym[i].sym_name);
1071 PRT("\nentry: %d\n", i);
1072 PRT("\toffset: %#jx\n",
1073 (uintmax_t)arsym[i].off);
1074 PRT("\tsymbol: %s\n",
1080 /* No need to continue if we only dump ARSYM. */
1081 if (ed->flags & ONLY_ARSYM) {
1082 AC(archive_read_close(a));
1083 AC(archive_read_free(a));
1088 if ((ed->elf = elf_memory(buff, size)) == NULL) {
1089 warnx("elf_memroy() failed: %s",
1094 /* Skip non-ELF member. */
1095 if (elf_kind(ed->elf) == ELF_K_ELF) {
1096 printf("\n%s(%s):\n", ed->archive, name);
1102 AC(archive_read_close(a));
1103 AC(archive_read_free(a));
1106 #else /* USE_LIBARCHIVE_AR */
1109 * Dump an ar(1) archive.
1112 elf_print_ar(struct elfdump *ed, int fd)
1124 if (ed->flags & PRINT_ARSYM) {
1126 if ((arsym = elf_getarsym(ed->ar, &cnt)) == NULL) {
1127 warnx("elf_getarsym failed: %s", elf_errmsg(-1));
1132 if (ed->flags & SOLARIS_FMT) {
1133 PRT("\nSymbol Table: (archive)\n");
1134 PRT(" index offset member name and symbol\n");
1136 PRT("\nsymbol table (archive):\n");
1137 for (i = 0; (size_t)i < cnt - 1; i++) {
1138 if (elf_rand(ed->ar, arsym[i].as_off) !=
1140 warnx("elf_rand failed: %s", elf_errmsg(-1));
1143 if ((e = elf_begin(fd, ELF_C_READ, ed->ar)) == NULL) {
1144 warnx("elf_begin failed: %s", elf_errmsg(-1));
1147 if ((arh = elf_getarhdr(e)) == NULL) {
1148 warnx("elf_getarhdr failed: %s",
1152 if (ed->flags & SOLARIS_FMT) {
1153 snprintf(idx, sizeof(idx), "[%d]", i);
1156 (uintmax_t)arsym[i].as_off);
1157 PRT("(%s):%s\n", arh->ar_name,
1160 PRT("\nentry: %d\n", i);
1161 PRT("\toffset: %#jx\n",
1162 (uintmax_t)arsym[i].as_off);
1163 PRT("\tmember: %s\n", arh->ar_name);
1164 PRT("\tsymbol: %s\n", arsym[i].as_name);
1169 /* No need to continue if we only dump ARSYM. */
1170 if (ed->flags & ONLY_ARSYM)
1176 /* Rewind the archive. */
1177 if (elf_rand(ed->ar, SARMAG) != SARMAG) {
1178 warnx("elf_rand failed: %s", elf_errmsg(-1));
1182 /* Dump each member of the archive. */
1184 while ((ed->elf = elf_begin(fd, cmd, ed->ar)) != NULL) {
1185 /* Skip non-ELF member. */
1186 if (elf_kind(ed->elf) == ELF_K_ELF) {
1187 if ((arh = elf_getarhdr(ed->elf)) == NULL) {
1188 warnx("elf_getarhdr failed: %s",
1192 printf("\n%s(%s):\n", ed->archive, arh->ar_name);
1195 cmd = elf_next(ed->elf);
1200 #endif /* USE_LIBARCHIVE_AR */
1203 * Dump an object. (ELF object or ar(1) archive)
1206 elf_print_object(struct elfdump *ed)
1210 if ((fd = open(ed->filename, O_RDONLY)) == -1) {
1211 warn("open %s failed", ed->filename);
1215 #ifdef USE_LIBARCHIVE_AR
1216 if (ac_detect_ar(fd)) {
1217 ed->archive = ed->filename;
1218 ac_print_ar(ed, fd);
1221 #endif /* USE_LIBARCHIVE_AR */
1223 if ((ed->elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
1224 warnx("elf_begin() failed: %s", elf_errmsg(-1));
1228 switch (elf_kind(ed->elf)) {
1230 warnx("Not an ELF file.");
1233 if (ed->flags & PRINT_FILENAME)
1234 printf("\n%s:\n", ed->filename);
1238 #ifndef USE_LIBARCHIVE_AR
1239 ed->archive = ed->filename;
1240 elf_print_ar(ed, fd);
1244 warnx("Internal: libelf returned unknown elf kind.");
1252 * Dump an ELF object.
1255 elf_print_elf(struct elfdump *ed)
1258 if (gelf_getehdr(ed->elf, &ed->ehdr) == NULL) {
1259 warnx("gelf_getehdr failed: %s", elf_errmsg(-1));
1262 if ((ed->ec = gelf_getclass(ed->elf)) == ELFCLASSNONE) {
1263 warnx("gelf_getclass failed: %s", elf_errmsg(-1));
1267 if (ed->options & (ED_SHDR | ED_DYN | ED_REL | ED_GOT | ED_SYMTAB |
1268 ED_SYMVER | ED_NOTE | ED_HASH))
1271 if (ed->options & ED_EHDR)
1273 if (ed->options & ED_PHDR)
1275 if (ed->options & ED_INTERP)
1276 elf_print_interp(ed);
1277 if (ed->options & ED_SHDR)
1279 if (ed->options & ED_DYN)
1280 elf_print_dynamic(ed);
1281 if (ed->options & ED_REL)
1282 elf_print_reloc(ed);
1283 if (ed->options & ED_GOT)
1285 if (ed->options & ED_SYMTAB)
1286 elf_print_symtabs(ed);
1287 if (ed->options & ED_SYMVER)
1288 elf_print_symver(ed);
1289 if (ed->options & ED_NOTE)
1291 if (ed->options & ED_HASH)
1293 if (ed->options & ED_CHECKSUM)
1294 elf_print_checksum(ed);
1296 unload_sections(ed);
1300 * Read the section headers from ELF object and store them in the
1304 load_sections(struct elfdump *ed)
1310 size_t shstrndx, ndx;
1313 assert(ed->sl == NULL);
1315 if (!elf_getshnum(ed->elf, &ed->shnum)) {
1316 warnx("elf_getshnum failed: %s", elf_errmsg(-1));
1321 if ((ed->sl = calloc(ed->shnum, sizeof(*ed->sl))) == NULL)
1322 err(EXIT_FAILURE, "calloc failed");
1323 if (!elf_getshstrndx(ed->elf, &shstrndx)) {
1324 warnx("elf_getshstrndx failed: %s", elf_errmsg(-1));
1327 if ((scn = elf_getscn(ed->elf, 0)) == NULL) {
1328 warnx("elf_getscn failed: %s", elf_errmsg(-1));
1333 if (gelf_getshdr(scn, &sh) == NULL) {
1334 warnx("gelf_getshdr failed: %s", elf_errmsg(-1));
1338 if ((name = elf_strptr(ed->elf, shstrndx, sh.sh_name)) == NULL) {
1342 if ((ndx = elf_ndxscn(scn)) == SHN_UNDEF)
1343 if ((elferr = elf_errno()) != 0) {
1344 warnx("elf_ndxscn failed: %s",
1345 elf_errmsg(elferr));
1348 if (ndx >= ed->shnum) {
1349 warnx("section index of '%s' out of range", name);
1355 s->off = sh.sh_offset;
1357 s->entsize = sh.sh_entsize;
1358 s->align = sh.sh_addralign;
1359 s->type = sh.sh_type;
1360 s->flags = sh.sh_flags;
1361 s->addr = sh.sh_addr;
1362 s->link = sh.sh_link;
1363 s->info = sh.sh_info;
1364 } while ((scn = elf_nextscn(ed->elf, scn)) != NULL);
1365 elferr = elf_errno();
1367 warnx("elf_nextscn failed: %s", elf_errmsg(elferr));
1371 * Release section related resources.
1374 unload_sections(struct elfdump *ed)
1376 if (ed->sl != NULL) {
1383 * Add a name to the '-N' name list.
1386 add_name(struct elfdump *ed, const char *name)
1388 struct spec_name *sn;
1390 if (find_name(ed, name))
1392 if ((sn = malloc(sizeof(*sn))) == NULL) {
1393 warn("malloc failed");
1397 STAILQ_INSERT_TAIL(&ed->snl, sn, sn_list);
1401 * Lookup a name in the '-N' name list.
1403 static struct spec_name *
1404 find_name(struct elfdump *ed, const char *name)
1406 struct spec_name *sn;
1408 STAILQ_FOREACH(sn, &ed->snl, sn_list) {
1409 if (!strcmp(sn->name, name))
1417 * Retrieve the name of a symbol using the section index of the symbol
1418 * table and the index of the symbol within that table.
1421 get_symbol_name(struct elfdump *ed, int symtab, int i)
1423 static char sname[64];
1430 s = &ed->sl[symtab];
1431 if (s->type != SHT_SYMTAB && s->type != SHT_DYNSYM)
1434 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
1435 elferr = elf_errno();
1437 warnx("elf_getdata failed: %s", elf_errmsg(elferr));
1440 if (gelf_getsym(data, i, &sym) != &sym)
1442 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION) {
1443 if (sym.st_shndx < ed->shnum) {
1444 snprintf(sname, sizeof(sname), "%s (section)",
1445 ed->sl[sym.st_shndx].name);
1450 if ((name = elf_strptr(ed->elf, s->link, sym.st_name)) == NULL)
1457 * Retrieve a string using string table section index and the string offset.
1460 get_string(struct elfdump *ed, int strtab, size_t off)
1464 if ((name = elf_strptr(ed->elf, strtab, off)) == NULL)
1471 * Dump the ELF Executable Header.
1474 elf_print_ehdr(struct elfdump *ed)
1477 if (!STAILQ_EMPTY(&ed->snl))
1480 if (ed->flags & SOLARIS_FMT) {
1481 PRT("\nELF Header\n");
1482 PRT(" ei_magic: { %#x, %c, %c, %c }\n",
1483 ed->ehdr.e_ident[0], ed->ehdr.e_ident[1],
1484 ed->ehdr.e_ident[2], ed->ehdr.e_ident[3]);
1485 PRT(" ei_class: %-18s",
1486 ei_classes[ed->ehdr.e_ident[EI_CLASS]]);
1487 PRT(" ei_data: %s\n", ei_data[ed->ehdr.e_ident[EI_DATA]]);
1488 PRT(" e_machine: %-18s", e_machines(ed->ehdr.e_machine));
1489 PRT(" e_version: %s\n", ei_versions[ed->ehdr.e_version]);
1490 PRT(" e_type: %s\n", e_types[ed->ehdr.e_type]);
1491 PRT(" e_flags: %18d\n", ed->ehdr.e_flags);
1492 PRT(" e_entry: %#18jx", (uintmax_t)ed->ehdr.e_entry);
1493 PRT(" e_ehsize: %6d", ed->ehdr.e_ehsize);
1494 PRT(" e_shstrndx:%5d\n", ed->ehdr.e_shstrndx);
1495 PRT(" e_shoff: %#18jx", (uintmax_t)ed->ehdr.e_shoff);
1496 PRT(" e_shentsize: %3d", ed->ehdr.e_shentsize);
1497 PRT(" e_shnum: %5d\n", ed->ehdr.e_shnum);
1498 PRT(" e_phoff: %#18jx", (uintmax_t)ed->ehdr.e_phoff);
1499 PRT(" e_phentsize: %3d", ed->ehdr.e_phentsize);
1500 PRT(" e_phnum: %5d\n", ed->ehdr.e_phnum);
1502 PRT("\nelf header:\n");
1504 PRT("\te_ident: %s %s %s\n",
1505 ei_classes[ed->ehdr.e_ident[EI_CLASS]],
1506 ei_data[ed->ehdr.e_ident[EI_DATA]],
1507 ei_abis[ed->ehdr.e_ident[EI_OSABI]]);
1508 PRT("\te_type: %s\n", e_types[ed->ehdr.e_type]);
1509 PRT("\te_machine: %s\n", e_machines(ed->ehdr.e_machine));
1510 PRT("\te_version: %s\n", ei_versions[ed->ehdr.e_version]);
1511 PRT("\te_entry: %#jx\n", (uintmax_t)ed->ehdr.e_entry);
1512 PRT("\te_phoff: %ju\n", (uintmax_t)ed->ehdr.e_phoff);
1513 PRT("\te_shoff: %ju\n", (uintmax_t) ed->ehdr.e_shoff);
1514 PRT("\te_flags: %u\n", ed->ehdr.e_flags);
1515 PRT("\te_ehsize: %u\n", ed->ehdr.e_ehsize);
1516 PRT("\te_phentsize: %u\n", ed->ehdr.e_phentsize);
1517 PRT("\te_phnum: %u\n", ed->ehdr.e_phnum);
1518 PRT("\te_shentsize: %u\n", ed->ehdr.e_shentsize);
1519 PRT("\te_shnum: %u\n", ed->ehdr.e_shnum);
1520 PRT("\te_shstrndx: %u\n", ed->ehdr.e_shstrndx);
1525 * Dump the ELF Program Header Table.
1528 elf_print_phdr(struct elfdump *ed)
1534 if (elf_getphnum(ed->elf, &phnum) == 0) {
1535 warnx("elf_getphnum failed: %s", elf_errmsg(-1));
1539 for (i = 0; (u_int64_t) i < phnum; i++) {
1540 if (gelf_getphdr(ed->elf, i, &ph) != &ph) {
1541 warnx("elf_getphdr failed: %s", elf_errmsg(-1));
1544 if (!STAILQ_EMPTY(&ed->snl) &&
1545 find_name(ed, p_types[ph.p_type & 0x7]) == NULL)
1547 if (ed->flags & SOLARIS_FMT) {
1548 PRT("\nProgram Header[%d]:\n", i);
1549 PRT(" p_vaddr: %#-14jx", (uintmax_t)ph.p_vaddr);
1550 PRT(" p_flags: [ %s ]\n", p_flags[ph.p_flags]);
1551 PRT(" p_paddr: %#-14jx", (uintmax_t)ph.p_paddr);
1552 PRT(" p_type: [ %s ]\n", p_types[ph.p_type & 0x7]);
1553 PRT(" p_filesz: %#-14jx",
1554 (uintmax_t)ph.p_filesz);
1555 PRT(" p_memsz: %#jx\n", (uintmax_t)ph.p_memsz);
1556 PRT(" p_offset: %#-14jx",
1557 (uintmax_t)ph.p_offset);
1558 PRT(" p_align: %#jx\n", (uintmax_t)ph.p_align);
1561 PRT("\nprogram header:\n");
1565 PRT("entry: %d\n", i);
1566 PRT("\tp_type: %s\n", p_types[ph.p_type & 0x7]);
1567 PRT("\tp_offset: %ju\n", (uintmax_t)ph.p_offset);
1568 PRT("\tp_vaddr: %#jx\n", (uintmax_t)ph.p_vaddr);
1569 PRT("\tp_paddr: %#jx\n", (uintmax_t)ph.p_paddr);
1570 PRT("\tp_filesz: %ju\n", (uintmax_t)ph.p_filesz);
1571 PRT("\tp_memsz: %ju\n", (uintmax_t)ph.p_memsz);
1572 PRT("\tp_flags: %s\n", p_flags[ph.p_flags]);
1573 PRT("\tp_align: %ju\n", (uintmax_t)ph.p_align);
1579 * Dump the ELF Section Header Table.
1582 elf_print_shdr(struct elfdump *ed)
1587 if (!STAILQ_EMPTY(&ed->snl))
1590 if ((ed->flags & SOLARIS_FMT) == 0)
1591 PRT("\nsection header:\n");
1592 for (i = 0; (size_t)i < ed->shnum; i++) {
1594 if (ed->flags & SOLARIS_FMT) {
1597 PRT("\nSection Header[%d]:", i);
1598 PRT(" sh_name: %s\n", s->name);
1599 PRT(" sh_addr: %#-14jx", (uintmax_t)s->addr);
1601 PRT(" sh_flags: [ %s ]\n", sh_flags(s->flags));
1603 PRT(" sh_flags: 0\n");
1604 PRT(" sh_size: %#-14jx", (uintmax_t)s->sz);
1605 PRT(" sh_type: [ %s ]\n", sh_types(s->type));
1606 PRT(" sh_offset: %#-14jx", (uintmax_t)s->off);
1607 PRT(" sh_entsize: %#jx\n", (uintmax_t)s->entsize);
1608 PRT(" sh_link: %-14u", s->link);
1609 PRT(" sh_info: %u\n", s->info);
1610 PRT(" sh_addralign: %#jx\n", (uintmax_t)s->align);
1613 PRT("entry: %ju\n", (uintmax_t)i);
1614 PRT("\tsh_name: %s\n", s->name);
1615 PRT("\tsh_type: %s\n", sh_types(s->type));
1616 PRT("\tsh_flags: %s\n", sh_flags(s->flags));
1617 PRT("\tsh_addr: %#jx\n", (uintmax_t)s->addr);
1618 PRT("\tsh_offset: %ju\n", (uintmax_t)s->off);
1619 PRT("\tsh_size: %ju\n", (uintmax_t)s->sz);
1620 PRT("\tsh_link: %u\n", s->link);
1621 PRT("\tsh_info: %u\n", s->info);
1622 PRT("\tsh_addralign: %ju\n", (uintmax_t)s->align);
1623 PRT("\tsh_entsize: %ju\n", (uintmax_t)s->entsize);
1629 * Retrieve the content of the corresponding SHT_SUNW_versym section for
1630 * a symbol table section.
1633 get_versym(struct elfdump *ed, int i, uint16_t **vs, int *nvs)
1640 for (j = 0; (size_t)j < ed->shnum; j++) {
1642 if (s->type == SHT_SUNW_versym && s->link == (uint32_t)i)
1645 if ((size_t)j >= ed->shnum) {
1650 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
1651 elferr = elf_errno();
1653 warnx("elf_getdata failed: %s", elf_errmsg(elferr));
1659 *nvs = data->d_size / s->entsize;
1663 * Dump the symbol table section.
1666 elf_print_symtab(struct elfdump *ed, int i)
1674 int len, j, elferr, nvs;
1677 if (ed->flags & SOLARIS_FMT)
1678 PRT("\nSymbol Table Section: %s\n", s->name);
1680 PRT("\nsymbol table (%s):\n", s->name);
1682 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
1683 elferr = elf_errno();
1685 warnx("elf_getdata failed: %s", elf_errmsg(elferr));
1690 len = data->d_size / s->entsize;
1691 if (ed->flags & SOLARIS_FMT) {
1692 if (ed->ec == ELFCLASS32)
1693 PRT(" index value ");
1695 PRT(" index value ");
1696 PRT("size type bind oth ver shndx name\n");
1697 get_versym(ed, i, &vs, &nvs);
1698 if (vs != NULL && nvs != len) {
1699 warnx("#symbol not equal to #versym");
1703 for (j = 0; j < len; j++) {
1704 if (gelf_getsym(data, j, &sym) != &sym) {
1705 warnx("gelf_getsym failed: %s", elf_errmsg(-1));
1708 name = get_string(ed, s->link, sym.st_name);
1709 if (ed->flags & SOLARIS_FMT) {
1710 snprintf(idx, sizeof(idx), "[%d]", j);
1711 if (ed->ec == ELFCLASS32)
1715 PRT("0x%8.8jx ", (uintmax_t)sym.st_value);
1716 if (ed->ec == ELFCLASS32)
1717 PRT("0x%8.8jx ", (uintmax_t)sym.st_size);
1719 PRT("0x%12.12jx ", (uintmax_t)sym.st_size);
1720 PRT("%s ", st_types_S[GELF_ST_TYPE(sym.st_info)]);
1721 PRT("%s ", st_bindings_S[GELF_ST_BIND(sym.st_info)]);
1722 PRT("%c ", st_others[sym.st_other]);
1723 PRT("%3u ", (vs == NULL ? 0 : vs[j]));
1724 PRT("%-11.11s ", sh_name(ed, sym.st_shndx));
1727 PRT("\nentry: %d\n", j);
1728 PRT("\tst_name: %s\n", name);
1729 PRT("\tst_value: %#jx\n", (uintmax_t)sym.st_value);
1730 PRT("\tst_size: %ju\n", (uintmax_t)sym.st_size);
1731 PRT("\tst_info: %s %s\n",
1732 st_types[GELF_ST_TYPE(sym.st_info)],
1733 st_bindings[GELF_ST_BIND(sym.st_info)]);
1734 PRT("\tst_shndx: %ju\n", (uintmax_t)sym.st_shndx);
1740 * Dump the symbol tables. (.dynsym and .symtab)
1743 elf_print_symtabs(struct elfdump *ed)
1747 for (i = 0; (size_t)i < ed->shnum; i++)
1748 if ((ed->sl[i].type == SHT_SYMTAB ||
1749 ed->sl[i].type == SHT_DYNSYM) &&
1750 (STAILQ_EMPTY(&ed->snl) || find_name(ed, ed->sl[i].name)))
1751 elf_print_symtab(ed, i);
1755 * Dump the content of .dynamic section.
1758 elf_print_dynamic(struct elfdump *ed)
1768 for (i = 0; (size_t)i < ed->shnum; i++) {
1770 if (s->type == SHT_DYNAMIC &&
1771 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name)))
1774 if ((size_t)i >= ed->shnum)
1777 if (ed->flags & SOLARIS_FMT) {
1778 PRT("Dynamic Section: %s\n", s->name);
1779 PRT(" index tag value\n");
1781 PRT("\ndynamic:\n");
1783 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
1784 elferr = elf_errno();
1786 warnx("elf_getdata failed: %s", elf_errmsg(elferr));
1789 len = data->d_size / s->entsize;
1790 for (i = 0; i < len; i++) {
1791 if (gelf_getdyn(data, i, &dyn) != &dyn) {
1792 warnx("gelf_getdyn failed: %s", elf_errmsg(-1));
1796 if (ed->flags & SOLARIS_FMT) {
1797 snprintf(idx, sizeof(idx), "[%d]", i);
1798 PRT("%10s %-16s ", idx, d_tags(dyn.d_tag));
1801 PRT("entry: %d\n", i);
1802 PRT("\td_tag: %s\n", d_tags(dyn.d_tag));
1808 if ((name = elf_strptr(ed->elf, s->link,
1809 dyn.d_un.d_val)) == NULL)
1811 if (ed->flags & SOLARIS_FMT)
1812 PRT("%#-16jx %s\n", (uintmax_t)dyn.d_un.d_val,
1815 PRT("\td_val: %s\n", name);
1832 if (ed->flags & SOLARIS_FMT)
1833 PRT("%#jx\n", (uintmax_t)dyn.d_un.d_val);
1835 PRT("\td_val: %ju\n",
1836 (uintmax_t)dyn.d_un.d_val);
1848 if (ed->flags & SOLARIS_FMT)
1849 PRT("%#jx\n", (uintmax_t)dyn.d_un.d_ptr);
1851 PRT("\td_ptr: %#jx\n",
1852 (uintmax_t)dyn.d_un.d_ptr);
1858 if (ed->flags & SOLARIS_FMT)
1866 * Dump a .rel/.rela section entry.
1869 elf_print_rel_entry(struct elfdump *ed, struct section *s, int j,
1870 struct rel_entry *r)
1873 if (ed->flags & SOLARIS_FMT) {
1874 PRT(" %-23s ", r_type(ed->ehdr.e_machine,
1875 GELF_R_TYPE(r->u_r.rel.r_info)));
1876 PRT("%#12jx ", (uintmax_t)r->u_r.rel.r_offset);
1877 if (r->type == SHT_RELA)
1878 PRT("%10jd ", (intmax_t)r->u_r.rela.r_addend);
1881 PRT("%-14s ", s->name);
1882 PRT("%s\n", r->symn);
1885 PRT("entry: %d\n", j);
1886 PRT("\tr_offset: %#jx\n", (uintmax_t)r->u_r.rel.r_offset);
1887 if (ed->ec == ELFCLASS32)
1888 PRT("\tr_info: %#jx\n", (uintmax_t)
1889 ELF32_R_INFO(ELF64_R_SYM(r->u_r.rel.r_info),
1890 ELF64_R_TYPE(r->u_r.rel.r_info)));
1892 PRT("\tr_info: %#jx\n", (uintmax_t)r->u_r.rel.r_info);
1893 if (r->type == SHT_RELA)
1894 PRT("\tr_addend: %jd\n",
1895 (intmax_t)r->u_r.rela.r_addend);
1900 * Dump a relocation section of type SHT_RELA.
1903 elf_print_rela(struct elfdump *ed, struct section *s, Elf_Data *data)
1908 if (ed->flags & SOLARIS_FMT) {
1909 PRT("\nRelocation Section: %s\n", s->name);
1911 "addend section with respect to\n");
1913 PRT("\nrelocation with addend (%s):\n", s->name);
1915 len = data->d_size / s->entsize;
1916 for (j = 0; j < len; j++) {
1917 if (gelf_getrela(data, j, &r.u_r.rela) != &r.u_r.rela) {
1918 warnx("gelf_getrela failed: %s",
1922 r.symn = get_symbol_name(ed, s->link,
1923 GELF_R_SYM(r.u_r.rela.r_info));
1924 elf_print_rel_entry(ed, s, j, &r);
1929 * Dump a relocation section of type SHT_REL.
1932 elf_print_rel(struct elfdump *ed, struct section *s, Elf_Data *data)
1937 if (ed->flags & SOLARIS_FMT) {
1938 PRT("\nRelocation Section: %s\n", s->name);
1940 "section with respect to\n");
1942 PRT("\nrelocation (%s):\n", s->name);
1944 len = data->d_size / s->entsize;
1945 for (j = 0; j < len; j++) {
1946 if (gelf_getrel(data, j, &r.u_r.rel) != &r.u_r.rel) {
1947 warnx("gelf_getrel failed: %s", elf_errmsg(-1));
1950 r.symn = get_symbol_name(ed, s->link,
1951 GELF_R_SYM(r.u_r.rel.r_info));
1952 elf_print_rel_entry(ed, s, j, &r);
1957 * Dump relocation sections.
1960 elf_print_reloc(struct elfdump *ed)
1966 for (i = 0; (size_t)i < ed->shnum; i++) {
1968 if ((s->type == SHT_REL || s->type == SHT_RELA) &&
1969 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) {
1971 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
1972 elferr = elf_errno();
1974 warnx("elf_getdata failed: %s",
1975 elf_errmsg(elferr));
1978 if (s->type == SHT_REL)
1979 elf_print_rel(ed, s, data);
1981 elf_print_rela(ed, s, data);
1987 * Dump the content of PT_INTERP segment.
1990 elf_print_interp(struct elfdump *ed)
1997 if (!STAILQ_EMPTY(&ed->snl) && find_name(ed, "PT_INTERP") == NULL)
2000 if ((s = elf_rawfile(ed->elf, NULL)) == NULL) {
2001 warnx("elf_rawfile failed: %s", elf_errmsg(-1));
2004 if (!elf_getphnum(ed->elf, &phnum)) {
2005 warnx("elf_getphnum failed: %s", elf_errmsg(-1));
2008 for (i = 0; (size_t)i < phnum; i++) {
2009 if (gelf_getphdr(ed->elf, i, &phdr) != &phdr) {
2010 warnx("elf_getphdr failed: %s", elf_errmsg(-1));
2013 if (phdr.p_type == PT_INTERP) {
2015 PRT("\t%s\n", s + phdr.p_offset);
2021 * Search the relocation sections for entries refering to the .got section.
2024 find_gotrel(struct elfdump *ed, struct section *gs, struct rel_entry *got)
2029 int elferr, i, j, k, len;
2031 for(i = 0; (size_t)i < ed->shnum; i++) {
2033 if (s->type != SHT_REL && s->type != SHT_RELA)
2036 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2037 elferr = elf_errno();
2039 warnx("elf_getdata failed: %s",
2040 elf_errmsg(elferr));
2043 memset(&r, 0, sizeof(struct rel_entry));
2045 len = data->d_size / s->entsize;
2046 for (j = 0; j < len; j++) {
2047 if (s->type == SHT_REL) {
2048 if (gelf_getrel(data, j, &r.u_r.rel) !=
2050 warnx("gelf_getrel failed: %s",
2055 if (gelf_getrela(data, j, &r.u_r.rela) !=
2057 warnx("gelf_getrel failed: %s",
2062 if (r.u_r.rel.r_offset >= gs->addr &&
2063 r.u_r.rel.r_offset < gs->addr + gs->sz) {
2064 r.symn = get_symbol_name(ed, s->link,
2065 GELF_R_SYM(r.u_r.rel.r_info));
2066 k = (r.u_r.rel.r_offset - gs->addr) /
2068 memcpy(&got[k], &r, sizeof(struct rel_entry));
2075 elf_print_got_section(struct elfdump *ed, struct section *s)
2077 struct rel_entry *got;
2078 Elf_Data *data, dst;
2081 if (s->entsize == 0) {
2082 /* XXX IA64 GOT section generated by gcc has entry size 0. */
2084 s->entsize = s->align;
2089 if (ed->flags & SOLARIS_FMT)
2090 PRT("\nGlobal Offset Table Section: %s (%jd entries)\n",
2091 s->name, s->sz / s->entsize);
2093 PRT("\nglobal offset table: %s\n", s->name);
2095 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2096 elferr = elf_errno();
2098 warnx("elf_getdata failed: %s", elf_errmsg(elferr));
2103 * GOT section has section type SHT_PROGBITS, thus libelf treats it as
2104 * byte stream and will not perfrom any translation on it. As a result,
2105 * an exlicit call to gelf_xlatetom is needed here. Depends on arch,
2106 * GOT section should be translated to either WORD or XWORD.
2108 if (ed->ec == ELFCLASS32)
2109 data->d_type = ELF_T_WORD;
2111 data->d_type = ELF_T_XWORD;
2112 memcpy(&dst, data, sizeof(Elf_Data));
2113 if (gelf_xlatetom(ed->elf, &dst, data, ed->ehdr.e_ident[EI_DATA]) !=
2115 warnx("gelf_xlatetom failed: %s", elf_errmsg(-1));
2118 len = dst.d_size / s->entsize;
2119 if (ed->flags & SOLARIS_FMT) {
2121 * In verbose/Solaris mode, we search the relocation sections
2122 * and try to find the corresponding reloc entry for each GOT
2125 if ((got = calloc(len, sizeof(struct rel_entry))) == NULL)
2126 err(EXIT_FAILURE, "calloc failed");
2127 find_gotrel(ed, s, got);
2128 if (ed->ec == ELFCLASS32) {
2129 PRT(" ndx addr value reloc ");
2130 PRT("addend symbol\n");
2132 PRT(" ndx addr value ");
2133 PRT("reloc addend symbol\n");
2135 for(i = 0; i < len; i++) {
2137 if (ed->ec == ELFCLASS32) {
2138 PRT("%-8.8jx ", s->addr + i * s->entsize);
2139 PRT("%-8.8x ", *((uint32_t *)dst.d_buf + i));
2141 PRT("%-16.16jx ", s->addr + i * s->entsize);
2142 PRT("%-16.16jx ", *((uint64_t *)dst.d_buf + i));
2144 PRT("%-18s ", r_type(ed->ehdr.e_machine,
2145 GELF_R_TYPE(got[i].u_r.rel.r_info)));
2146 if (ed->ec == ELFCLASS32)
2148 (intmax_t)got[i].u_r.rela.r_addend);
2151 (intmax_t)got[i].u_r.rela.r_addend);
2152 if (got[i].symn == NULL)
2154 PRT("%s\n", got[i].symn);
2158 for(i = 0; i < len; i++) {
2159 PRT("\nentry: %d\n", i);
2160 if (ed->ec == ELFCLASS32)
2161 PRT("\t%#x\n", *((uint32_t *)dst.d_buf + i));
2163 PRT("\t%#jx\n", *((uint64_t *)dst.d_buf + i));
2169 * Dump the content of Global Offset Table section.
2172 elf_print_got(struct elfdump *ed)
2177 if (!STAILQ_EMPTY(&ed->snl))
2181 for (i = 0; (size_t)i < ed->shnum; i++) {
2183 if (s->name && !strncmp(s->name, ".got", 4) &&
2184 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name)))
2185 elf_print_got_section(ed, s);
2190 * Dump the content of .note.ABI-tag section.
2193 elf_print_note(struct elfdump *ed)
2206 for (i = 0; (size_t)i < ed->shnum; i++) {
2208 if (s->type == SHT_NOTE && s->name &&
2209 !strcmp(s->name, ".note.ABI-tag") &&
2210 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name)))
2213 if ((size_t)i >= ed->shnum)
2215 if (ed->flags & SOLARIS_FMT)
2216 PRT("\nNote Section: %s\n", s->name);
2218 PRT("\nnote (%s):\n", s->name);
2220 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2221 elferr = elf_errno();
2223 warnx("elf_getdata failed: %s", elf_errmsg(elferr));
2227 count = data->d_size;
2228 while (count > sizeof(Elf_Note)) {
2229 en = (Elf_Note *) (uintptr_t) src;
2230 namesz = en->n_namesz;
2231 descsz = en->n_descsz;
2232 src += sizeof(Elf_Note);
2233 count -= sizeof(Elf_Note);
2234 if (ed->flags & SOLARIS_FMT) {
2235 PRT("\n type %#x\n", en->n_type);
2236 PRT(" namesz %#x:\n", en->n_namesz);
2240 src += roundup2(namesz, 4);
2241 count -= roundup2(namesz, 4);
2244 * Note that we dump the whole desc part if we're in
2245 * "Solaris mode", while in the normal mode, we only look
2246 * at the first 4 bytes (a 32bit word) of the desc, i.e,
2247 * we assume that it's always a FreeBSD version number.
2249 if (ed->flags & SOLARIS_FMT) {
2250 PRT(" descsz %#x:", en->n_descsz);
2251 for (i = 0; (uint32_t)i < descsz; i++) {
2252 if ((i & 0xF) == 0) {
2253 snprintf(idx, sizeof(idx), "desc[%d]",
2255 PRT("\n %-9s", idx);
2256 } else if ((i & 0x3) == 0)
2258 PRT(" %2.2x", src[i]);
2262 if (ed->ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
2263 desc = be32dec(src);
2265 desc = le32dec(src);
2268 src += roundup2(descsz, 4);
2269 count -= roundup2(descsz, 4);
2274 * Dump a hash table.
2277 elf_print_svr4_hash(struct elfdump *ed, struct section *s)
2281 uint32_t *bucket, *chain;
2282 uint32_t nbucket, nchain;
2283 uint32_t *bl, *c, maxl, total;
2284 int i, j, first, elferr;
2287 if (ed->flags & SOLARIS_FMT)
2288 PRT("\nHash Section: %s\n", s->name);
2290 PRT("\nhash table (%s):\n", s->name);
2292 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2293 elferr = elf_errno();
2295 warnx("elf_getdata failed: %s",
2296 elf_errmsg(elferr));
2299 if (data->d_size < 2 * sizeof(uint32_t)) {
2300 warnx(".hash section too small");
2306 if (nbucket <= 0 || nchain <= 0) {
2307 warnx("Malformed .hash section");
2310 if (data->d_size != (nbucket + nchain + 2) * sizeof(uint32_t)) {
2311 warnx("Malformed .hash section");
2315 chain = &buf[2 + nbucket];
2317 if (ed->flags & SOLARIS_FMT) {
2319 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL)
2320 err(EXIT_FAILURE, "calloc failed");
2321 for (i = 0; (uint32_t)i < nbucket; i++)
2322 for (j = bucket[i]; j > 0 && (uint32_t)j < nchain;
2326 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL)
2327 err(EXIT_FAILURE, "calloc failed");
2328 for (i = 0; (uint32_t)i < nbucket; i++)
2330 PRT(" bucket symndx name\n");
2331 for (i = 0; (uint32_t)i < nbucket; i++) {
2333 for (j = bucket[i]; j > 0 && (uint32_t)j < nchain;
2340 snprintf(idx, sizeof(idx), "[%d]", j);
2342 PRT("%s\n", get_symbol_name(ed, s->link, j));
2347 for (i = 0; (uint32_t)i <= maxl; i++) {
2349 PRT("%10u buckets contain %8d symbols\n", c[i], i);
2351 PRT("%10u buckets %8u symbols (globals)\n", nbucket,
2354 PRT("\nnbucket: %u\n", nbucket);
2355 PRT("nchain: %u\n\n", nchain);
2356 for (i = 0; (uint32_t)i < nbucket; i++)
2357 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]);
2358 for (i = 0; (uint32_t)i < nchain; i++)
2359 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]);
2364 * Dump a 64bit hash table.
2367 elf_print_svr4_hash64(struct elfdump *ed, struct section *s)
2369 Elf_Data *data, dst;
2371 uint64_t *bucket, *chain;
2372 uint64_t nbucket, nchain;
2373 uint64_t *bl, *c, maxl, total;
2374 int i, j, elferr, first;
2377 if (ed->flags & SOLARIS_FMT)
2378 PRT("\nHash Section: %s\n", s->name);
2380 PRT("\nhash table (%s):\n", s->name);
2383 * ALPHA uses 64-bit hash entries. Since libelf assumes that
2384 * .hash section contains only 32-bit entry, an explicit
2385 * gelf_xlatetom is needed here.
2388 if ((data = elf_rawdata(s->scn, NULL)) == NULL) {
2389 elferr = elf_errno();
2391 warnx("elf_rawdata failed: %s",
2392 elf_errmsg(elferr));
2395 data->d_type = ELF_T_XWORD;
2396 memcpy(&dst, data, sizeof(Elf_Data));
2397 if (gelf_xlatetom(ed->elf, &dst, data,
2398 ed->ehdr.e_ident[EI_DATA]) != &dst) {
2399 warnx("gelf_xlatetom failed: %s", elf_errmsg(-1));
2402 if (dst.d_size < 2 * sizeof(uint64_t)) {
2403 warnx(".hash section too small");
2409 if (nbucket <= 0 || nchain <= 0) {
2410 warnx("Malformed .hash section");
2413 if (dst.d_size != (nbucket + nchain + 2) * sizeof(uint64_t)) {
2414 warnx("Malformed .hash section");
2418 chain = &buf[2 + nbucket];
2420 if (ed->flags & SOLARIS_FMT) {
2422 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL)
2423 err(EXIT_FAILURE, "calloc failed");
2424 for (i = 0; (uint64_t)i < nbucket; i++)
2425 for (j = bucket[i]; j > 0 && (uint64_t)j < nchain;
2429 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL)
2430 err(EXIT_FAILURE, "calloc failed");
2431 for (i = 0; (uint64_t)i < nbucket; i++)
2433 PRT(" bucket symndx name\n");
2434 for (i = 0; (uint64_t)i < nbucket; i++) {
2436 for (j = bucket[i]; j > 0 && (uint64_t)j < nchain;
2443 snprintf(idx, sizeof(idx), "[%d]", j);
2445 PRT("%s\n", get_symbol_name(ed, s->link, j));
2450 for (i = 0; (uint64_t)i <= maxl; i++) {
2452 PRT("%10ju buckets contain %8d symbols\n",
2453 (uintmax_t)c[i], i);
2455 PRT("%10ju buckets %8ju symbols (globals)\n",
2456 (uintmax_t)nbucket, (uintmax_t)total);
2458 PRT("\nnbucket: %ju\n", (uintmax_t)nbucket);
2459 PRT("nchain: %ju\n\n", (uintmax_t)nchain);
2460 for (i = 0; (uint64_t)i < nbucket; i++)
2461 PRT("bucket[%d]:\n\t%ju\n\n", i, (uintmax_t)bucket[i]);
2462 for (i = 0; (uint64_t)i < nchain; i++)
2463 PRT("chain[%d]:\n\t%ju\n\n", i, (uintmax_t)chain[i]);
2469 * Dump a GNU hash table.
2472 elf_print_gnu_hash(struct elfdump *ed, struct section *s)
2477 uint32_t *bucket, *chain;
2478 uint32_t nbucket, nchain, symndx, maskwords, shift2;
2479 uint32_t *bl, *c, maxl, total;
2480 int i, j, first, elferr, dynsymcount;
2483 if (ed->flags & SOLARIS_FMT)
2484 PRT("\nGNU Hash Section: %s\n", s->name);
2486 PRT("\ngnu hash table (%s):\n", s->name);
2488 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2489 elferr = elf_errno();
2491 warnx("elf_getdata failed: %s",
2492 elf_errmsg(elferr));
2495 if (data->d_size < 4 * sizeof(uint32_t)) {
2496 warnx(".gnu.hash section too small");
2505 ds = &ed->sl[s->link];
2506 dynsymcount = ds->sz / ds->entsize;
2507 nchain = dynsymcount - symndx;
2508 if (data->d_size != 4 * sizeof(uint32_t) + maskwords *
2509 (ed->ec == ELFCLASS32 ? sizeof(uint32_t) : sizeof(uint64_t)) +
2510 (nbucket + nchain) * sizeof(uint32_t)) {
2511 warnx("Malformed .gnu.hash section");
2514 bucket = buf + (ed->ec == ELFCLASS32 ? maskwords : maskwords * 2);
2515 chain = bucket + nbucket;
2517 if (ed->flags & SOLARIS_FMT) {
2519 if ((bl = calloc(nbucket, sizeof(*bl))) == NULL)
2520 err(EXIT_FAILURE, "calloc failed");
2521 for (i = 0; (uint32_t)i < nbucket; i++)
2523 j > 0 && (uint32_t)j - symndx < nchain;
2527 if (chain[j - symndx] & 1)
2530 if ((c = calloc(maxl + 1, sizeof(*c))) == NULL)
2531 err(EXIT_FAILURE, "calloc failed");
2532 for (i = 0; (uint32_t)i < nbucket; i++)
2534 PRT(" bucket symndx name\n");
2535 for (i = 0; (uint32_t)i < nbucket; i++) {
2538 j > 0 && (uint32_t)j - symndx < nchain;
2545 snprintf(idx, sizeof(idx), "[%d]", j );
2547 PRT("%s\n", get_symbol_name(ed, s->link, j));
2548 if (chain[j - symndx] & 1)
2554 for (i = 0; (uint32_t)i <= maxl; i++) {
2556 PRT("%10u buckets contain %8d symbols\n", c[i], i);
2558 PRT("%10u buckets %8u symbols (globals)\n", nbucket,
2561 PRT("\nnbucket: %u\n", nbucket);
2562 PRT("symndx: %u\n", symndx);
2563 PRT("maskwords: %u\n", maskwords);
2564 PRT("shift2: %u\n", shift2);
2565 PRT("nchain: %u\n\n", nchain);
2566 for (i = 0; (uint32_t)i < nbucket; i++)
2567 PRT("bucket[%d]:\n\t%u\n\n", i, bucket[i]);
2568 for (i = 0; (uint32_t)i < nchain; i++)
2569 PRT("chain[%d]:\n\t%u\n\n", i, chain[i]);
2577 elf_print_hash(struct elfdump *ed)
2582 for (i = 0; (size_t)i < ed->shnum; i++) {
2584 if ((s->type == SHT_HASH || s->type == SHT_GNU_HASH) &&
2585 (STAILQ_EMPTY(&ed->snl) || find_name(ed, s->name))) {
2586 if (s->type == SHT_GNU_HASH)
2587 elf_print_gnu_hash(ed, s);
2588 else if (ed->ehdr.e_machine == EM_ALPHA &&
2590 elf_print_svr4_hash64(ed, s);
2592 elf_print_svr4_hash(ed, s);
2598 * Dump the content of a Version Definition(SHT_SUNW_Verdef) Section.
2601 elf_print_verdef(struct elfdump *ed, struct section *s)
2608 uint8_t *buf, *end, *buf2;
2609 int i, j, elferr, count;
2611 if (ed->flags & SOLARIS_FMT)
2612 PRT("Version Definition Section: %s\n", s->name);
2614 PRT("\nversion definition section (%s):\n", s->name);
2616 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2617 elferr = elf_errno();
2619 warnx("elf_getdata failed: %s",
2620 elf_errmsg(elferr));
2624 end = buf + data->d_size;
2626 if (ed->flags & SOLARIS_FMT)
2627 PRT(" index version dependency\n");
2628 while (buf + sizeof(Elf32_Verdef) <= end) {
2629 vd = (Elf32_Verdef *) (uintptr_t) buf;
2630 if (ed->flags & SOLARIS_FMT) {
2631 snprintf(idx, sizeof(idx), "[%d]", vd->vd_ndx);
2634 PRT("\nentry: %d\n", i++);
2635 PRT("\tvd_version: %u\n", vd->vd_version);
2636 PRT("\tvd_flags: %u\n", vd->vd_flags);
2637 PRT("\tvd_ndx: %u\n", vd->vd_ndx);
2638 PRT("\tvd_cnt: %u\n", vd->vd_cnt);
2639 PRT("\tvd_hash: %u\n", vd->vd_hash);
2640 PRT("\tvd_aux: %u\n", vd->vd_aux);
2641 PRT("\tvd_next: %u\n\n", vd->vd_next);
2643 buf2 = buf + vd->vd_aux;
2646 while (buf2 + sizeof(Elf32_Verdaux) <= end && j < vd->vd_cnt) {
2647 vda = (Elf32_Verdaux *) (uintptr_t) buf2;
2648 str = get_string(ed, s->link, vda->vda_name);
2649 if (ed->flags & SOLARIS_FMT) {
2651 PRT("%-26.26s", str);
2652 else if (count == 1)
2653 PRT(" %-20.20s", str);
2655 PRT("\n%40.40s", "");
2659 PRT("\t\tvda: %d\n", j++);
2660 PRT("\t\t\tvda_name: %s\n", str);
2661 PRT("\t\t\tvda_next: %u\n", vda->vda_next);
2663 if (vda->vda_next == 0) {
2664 if (ed->flags & SOLARIS_FMT) {
2665 if (vd->vd_flags & VER_FLG_BASE) {
2667 PRT("%-20.20s", "");
2668 PRT("%s", "[ BASE ]");
2674 if (ed->flags & SOLARIS_FMT)
2676 buf2 += vda->vda_next;
2678 if (vd->vd_next == 0)
2685 * Dump the content of a Version Needed(SHT_SUNW_Verneed) Section.
2688 elf_print_verneed(struct elfdump *ed, struct section *s)
2693 uint8_t *buf, *end, *buf2;
2694 int i, j, elferr, first;
2696 if (ed->flags & SOLARIS_FMT)
2697 PRT("\nVersion Needed Section: %s\n", s->name);
2699 PRT("\nversion need section (%s):\n", s->name);
2701 if ((data = elf_getdata(s->scn, NULL)) == NULL) {
2702 elferr = elf_errno();
2704 warnx("elf_getdata failed: %s",
2705 elf_errmsg(elferr));
2709 end = buf + data->d_size;
2710 if (ed->flags & SOLARIS_FMT)
2711 PRT(" file version\n");
2713 while (buf + sizeof(Elf32_Verneed) <= end) {
2714 vn = (Elf32_Verneed *) (uintptr_t) buf;
2715 if (ed->flags & SOLARIS_FMT)
2717 get_string(ed, s->link, vn->vn_file));
2719 PRT("\nentry: %d\n", i++);
2720 PRT("\tvn_version: %u\n", vn->vn_version);
2721 PRT("\tvn_cnt: %u\n", vn->vn_cnt);
2722 PRT("\tvn_file: %s\n",
2723 get_string(ed, s->link, vn->vn_file));
2724 PRT("\tvn_aux: %u\n", vn->vn_aux);
2725 PRT("\tvn_next: %u\n\n", vn->vn_next);
2727 buf2 = buf + vn->vn_aux;
2730 while (buf2 + sizeof(Elf32_Vernaux) <= end && j < vn->vn_cnt) {
2731 vna = (Elf32_Vernaux *) (uintptr_t) buf2;
2732 if (ed->flags & SOLARIS_FMT) {
2737 PRT("%s\n", get_string(ed, s->link,
2740 PRT("\t\tvna: %d\n", j++);
2741 PRT("\t\t\tvna_hash: %u\n", vna->vna_hash);
2742 PRT("\t\t\tvna_flags: %u\n", vna->vna_flags);
2743 PRT("\t\t\tvna_other: %u\n", vna->vna_other);
2744 PRT("\t\t\tvna_name: %s\n",
2745 get_string(ed, s->link, vna->vna_name));
2746 PRT("\t\t\tvna_next: %u\n", vna->vna_next);
2748 if (vna->vna_next == 0)
2750 buf2 += vna->vna_next;
2752 if (vn->vn_next == 0)
2759 * Dump the symbol-versioning sections.
2762 elf_print_symver(struct elfdump *ed)
2767 for (i = 0; (size_t)i < ed->shnum; i++) {
2769 if (!STAILQ_EMPTY(&ed->snl) && !find_name(ed, s->name))
2771 if (s->type == SHT_SUNW_verdef)
2772 elf_print_verdef(ed, s);
2773 if (s->type == SHT_SUNW_verneed)
2774 elf_print_verneed(ed, s);
2779 * Dump the ELF checksum. See gelf_checksum(3) for details.
2782 elf_print_checksum(struct elfdump *ed)
2785 if (!STAILQ_EMPTY(&ed->snl))
2788 PRT("\nelf checksum: %#lx\n", gelf_checksum(ed->elf));
2791 #define USAGE_MESSAGE "\
2792 Usage: %s [options] file...\n\
2793 Display information about ELF objects and ar(1) archives.\n\n\
2795 -a Show all information.\n\
2796 -c Show shared headers.\n\
2797 -d Show dynamic symbols.\n\
2798 -e Show the ELF header.\n\
2800 -H | --help Show a usage message and exit.\n\
2801 -h Show hash values.\n\
2802 -i Show the dynamic interpreter.\n\
2803 -k Show the ELF checksum.\n\
2804 -n Show the contents of note sections.\n\
2805 -N NAME Show the section named \"NAME\".\n\
2806 -p Show the program header.\n\
2807 -r Show relocations.\n\
2808 -s Show the symbol table.\n\
2809 -S Use the Solaris elfdump format.\n\
2810 -v Show symbol-versioning information.\n\
2811 -V | --version Print a version identifier and exit.\n\
2812 -w FILE Write output to \"FILE\".\n"
2817 fprintf(stderr, USAGE_MESSAGE, ELFTC_GETPROGNAME());