1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@cygnus.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
34 #ifdef ANSI_PROTOTYPES
40 unsigned int dynamic_addr
;
41 unsigned int dynamic_size
;
43 char * program_name
= "readelf";
45 int dynamic_info
[DT_JMPREL
+ 1];
46 int version_info
[16];
50 unsigned int rel_size
;
53 unsigned int rela_addr
;
54 unsigned int rela_size
;
62 Elf_Shdr
* elf_sections
;
76 long int expected_endian
;
80 "NULL", "NEEDED","PLTRELSZ","PLTGOT","HASH","STRTAB","SYMTAB","RELA",
81 "RELASZ","RELAENT","STRSZ","SYMENT","INIT","FINI","SONAME","RPATH",
82 "SYMBOLIC","REL","RELSZ","RELENT","PLTREL","DEBUG","TEXTREL","JMPREL"
87 "VERNEEDNUM", "VERNEED", "VERDEFNUM", "VERDEF",
88 "", "", "", "", "", "", "", "", "", "", "", "VERSYM"
93 "FILTER", "USED", "AUXILIARY"
97 char * sttinfo
[] = {"NOTYPE","OBJECT","FUNC","SECTION","FILE"};
98 char * stbinfo
[] = {"LOCAL","GLOBAL","WEAK"};
100 #define SECTION_NAME(X) (& header [lastmapped + (X)->sh_name])
102 #define NUM_DUMP_SECTS 100
103 char dump_sects
[NUM_DUMP_SECTS
];
105 #define DISASS_DUMP 2
107 /* Forward declarations for dumb compilers. */
108 static char * get_i386_rel_type
PARAMS ((bfd_vma rtype
));
109 static char * get_m68k_rel_type
PARAMS ((bfd_vma rtype
));
110 static char * get_sparc_rel_type
PARAMS ((bfd_vma rtype
));
111 static char * get_m32r_rel_type
PARAMS ((bfd_vma rtype
));
112 static char * get_v850_rel_type
PARAMS ((bfd_vma rtype
));
113 static char * get_d10v_rel_type
PARAMS ((bfd_vma rtype
));
114 /* start-sanitize-d30v */
115 static char * get_d30v_rel_type
PARAMS ((bfd_vma rtype
));
116 /* end-sanitize-d30v */
117 static char * get_sh_rel_type
PARAMS ((bfd_vma rtype
));
118 static char * get_mn10300_rel_type
PARAMS ((bfd_vma rtype
));
119 static char * get_mn10200_rel_type
PARAMS ((bfd_vma rtype
));
120 static char * get_ppc_rel_type
PARAMS ((bfd_vma rtype
));
121 static void dump_relocations
PARAMS ((Elf_Rel
* rpnt
, int rel_size
));
122 static char * get_file_type
PARAMS ((unsigned e_type
));
123 static char * get_machine_name
PARAMS ((unsigned e_machine
));
124 static char * get_machine_data
PARAMS ((unsigned e_data
));
125 static char * get_machine_flags
PARAMS ((unsigned e_flags
, unsigned e_machine
));
126 static char * get_segment_type
PARAMS ((unsigned long p_type
));
127 static char * get_section_type_name
PARAMS ((unsigned int sh_type
));
128 static void usage
PARAMS ((void));
129 static void parse_args
PARAMS ((int argc
, char ** argv
));
130 static int process_elf_header
PARAMS ((void));
131 static void process_program_headers
PARAMS ((void));
132 static void process_section_headers
PARAMS ((void));
133 static void process_dynamic_segment
PARAMS ((void));
134 static void process_symbol_table
PARAMS ((void));
135 static void process_section_contents
PARAMS ((void));
136 static void process_file
PARAMS ((char * file_name
));
139 #define SWAP2(val) ( (((val) << 8) & (0xff << 8)) \
140 | (((val) >> 8) & (0xff << 0)))
142 #define SWAP4(val) ( (((val) << 24) & (0xff << 24)) \
143 | (((val) << 8) & (0xff << 16)) \
144 | (((val) >> 8) & (0xff << 8)) \
145 | (((val) >> 24) & (0xff << 0)))
147 /* Warning: This macro assumes 8 bits in a char. */
148 #define BYTE_SWAP(pointer, field) \
149 if (sizeof ((pointer)->field) == 2) \
151 unsigned short val = (pointer)->field ; \
152 new_header->field = SWAP2 (val); \
154 else if (sizeof ((pointer)->field) != 4) \
158 unsigned long val = (pointer)->field ; \
159 new_header->field = SWAP4 (val); \
163 #ifdef ANSI_PROTOTYPES
165 error (const char * message
, ...)
169 fprintf (stderr
, _("%s: Error: "), program_name
);
170 va_start (args
, message
);
171 vfprintf (stderr
, message
, args
);
177 warn (const char * message
, ...)
181 fprintf (stderr
, _("%s: Warning: "), program_name
);
182 va_start (args
, message
);
183 vfprintf (stderr
, message
, args
);
194 fprintf (stderr
, _("%s: Error: "), program_name
);
196 message
= va_arg (args
, char *);
197 vfprintf (stderr
, message
, args
);
209 fprintf (stderr
, _("%s: Warning: "), program_name
);
211 message
= va_arg (args
, char *);
212 vfprintf (stderr
, message
, args
);
220 get_i386_rel_type (rtype
)
225 case 0: return "R_386_NONE";
226 case 1: return "R_386_32";
227 case 2: return "R_386_PC32";
228 case 3: return "R_386_GOT32";
229 case 4: return "R_386_PLT32";
230 case 5: return "R_386_COPY";
231 case 6: return "R_386_GLOB_DAT";
232 case 7: return "R_386_JMP_SLOT";
233 case 8: return "R_386_RELATIVE";
234 case 9: return "R_386_GOTOFF";
235 case 10: return "R_386_GOTPC";
236 case 20: return "R_386_16";
237 case 21: return "R_386_PC16";
238 case 22: return "R_386_PC8";
239 case 23: return "R_386_max";
240 default: return _("*INVALID*");
245 get_m68k_rel_type (rtype
)
250 case 0: return "R_68K_NONE";
251 case 1: return "R_68K_32";
252 case 2: return "R_68K_16";
253 case 3: return "R_68K_8";
254 case 4: return "R_68K_PC32";
255 case 5: return "R_68K_PC16";
256 case 6: return "R_68K_PC8";
257 case 7: return "R_68K_GOT32";
258 case 8: return "R_68K_GOT16";
259 case 9: return "R_68K_GOT8";
260 case 10: return "R_68K_GOT32O";
261 case 11: return "R_68K_GOT16O";
262 case 12: return "R_68K_GOT8O";
263 case 13: return "R_68K_PLT32";
264 case 14: return "R_68K_PLT16";
265 case 15: return "R_68K_PLT8";
266 case 16: return "R_68K_PLT32O";
267 case 17: return "R_68K_PLT16O";
268 case 18: return "R_68K_PLT8O";
269 case 19: return "R_68K_COPY";
270 case 20: return "R_68K_GLOB_DAT";
271 case 21: return "R_68K_JMP_SLOT";
272 case 22: return "R_68K_RELATIVE";
273 default: return _("*INVALID*");
279 get_sparc_rel_type (rtype
)
284 case 0: return "R_SPARC_NONE";
285 case 1: return "R_SPARC_8";
286 case 2: return "R_SPARC_16";
287 case 3: return "R_SPARC_32";
288 case 4: return "R_SPARC_DISP8";
289 case 5: return "R_SPARC_DISP16";
290 case 6: return "R_SPARC_DISP32";
291 case 7: return "R_SPARC_WDISP30";
292 case 8: return "R_SPARC_WDISP22";
293 case 9: return "R_SPARC_HI22";
294 case 10: return "R_SPARC_22";
295 case 11: return "R_SPARC_13";
296 case 12: return "R_SPARC_LO10";
297 case 13: return "R_SPARC_GOT10";
298 case 14: return "R_SPARC_GOT13";
299 case 15: return "R_SPARC_GOT22";
300 case 16: return "R_SPARC_PC10";
301 case 17: return "R_SPARC_PC22";
302 case 18: return "R_SPARC_WPLT30";
303 case 19: return "R_SPARC_COPY";
304 case 20: return "R_SPARC_GLOB_DAT";
305 case 21: return "R_SPARC_JMP_SLOT";
306 case 22: return "R_SPARC_RELATIVE";
307 case 23: return "R_SPARC_UA32";
308 case 24: return "R_SPARC_10";
309 case 25: return "R_SPARC_11";
310 case 26: return "R_SPARC_64";
311 case 27: return "R_SPARC_OLO10";
312 case 28: return "R_SPARC_HH22";
313 case 29: return "R_SPARC_HM10";
314 case 30: return "R_SPARC_LM22";
315 case 31: return "R_SPARC_PC_HH22";
316 case 32: return "R_SPARC_PC_HM10";
317 case 33: return "R_SPARC_PC_LM22";
318 case 34: return "R_SPARC_WDISP16";
319 case 35: return "R_SPARC_WDISP19";
320 case 36: return "R_SPARC_UNUSED_42";
321 case 37: return "R_SPARC_7";
322 case 38: return "R_SPARC_5";
323 case 39: return "R_SPARC_6";
324 case 40: return "R_SPARC_DISP64";
325 case 41: return "R_SPARC_PLT64";
326 case 42: return "R_SPARC_HIX22";
327 case 43: return "R_SPARC_LOX10";
328 case 44: return "R_SPARC_H44";
329 case 45: return "R_SPARC_M44";
330 case 46: return "R_SPARC_L44";
331 case 47: return "R_SPARC_REGISTER";
332 case 48: return "R_SPARC_UA64";
333 case 49: return "R_SPARC_UA16";
334 case 50: return "R_SPARC_32LE";
335 default: return _("*INVALID*");
341 get_m32r_rel_type (rtype
)
346 case 0: return "R_M32R_NONE";
347 case 1: return "R_M32R_16";
348 case 2: return "R_M32R_32";
349 case 3: return "R_M32R_24";
350 case 4: return "R_M32R_10_PCREL";
351 case 5: return "R_M32R_18_PCREL";
352 case 6: return "R_M32R_26_PCREL";
353 case 7: return "R_M32R_HI16_ULO";
354 case 8: return "R_M32R_HI16_SLO";
355 case 9: return "R_M32R_LO16";
356 case 10: return "R_M32R_SDA16";
357 default: return _("*INVALID*");
363 get_v850_rel_type (rtype
)
368 case 0: return "R_V850_NONE";
369 case 1: return "R_V850_9_PCREL";
370 case 2: return "R_V850_22_PCREL";
371 case 3: return "R_V850_HI16_S";
372 case 4: return "R_V850_HI16";
373 case 5: return "R_V850_LO16";
374 case 6: return "R_V850_32";
375 case 7: return "R_V850_16";
376 case 8: return "R_V850_8";
377 case 9: return "R_V850_SDA_16_16_OFFSET";
378 case 10: return "R_V850_SDA_15_16_OFFSET";
379 case 11: return "R_V850_ZDA_16_16_OFFSET";
380 case 12: return "R_V850_ZDA_15_16_OFFSET";
381 case 13: return "R_V850_TDA_6_8_OFFSET";
382 case 14: return "R_V850_TDA_7_8_OFFSET";
383 case 15: return "R_V850_TDA_7_7_OFFSET";
384 case 16: return "R_V850_TDA_16_16_OFFSET";
385 /* start-sanitize-v850e */
386 case 17: return "R_V850_TDA_4_5_OFFSET";
387 case 18: return "R_V850_TDA_4_4_OFFSET";
388 case 19: return "R_V850_SDA_16_16_SPLIT_OFFSET";
389 case 20: return "R_V850_ZDA_16_16_SPLIT_OFFSET";
390 case 21: return "R_V850_CALLT_6_7_OFFSET";
391 case 22: return "R_V850_CALLT_16_16_OFFSET";
392 /* end-sanitize-v850e */
393 default: return _("*INVALID*");
399 get_d10v_rel_type (rtype
)
404 case 0: return "R_D10V_NONE";
405 case 1: return "R_D10V_10_PCREL_R";
406 case 2: return "R_D10V_10_PCREL_L";
407 case 3: return "R_D10V_16";
408 case 4: return "R_D10V_18";
409 case 5: return "R_D10V_18_PCREL";
410 case 6: return "R_D10V_32";
411 default: return _("*INVALID*");
415 /* start-sanitize-d30v */
417 get_d30v_rel_type (rtype
)
422 case 0: return "R_D30V_NONE";
423 case 1: return "R_D30V_6";
424 case 2: return "R_D30V_9_PCREL";
425 case 3: return "R_D30V_9_PCREL_R";
426 case 4: return "R_D30V_15";
427 case 5: return "R_D30V_15_PCREL";
428 case 6: return "R_D30V_15_PCREL_R";
429 case 7: return "R_D30V_21";
430 case 8: return "R_D30V_21_PCREL";
431 case 9: return "R_D30V_21_PCREL_R";
432 case 10: return "R_D30V_32";
433 case 11: return "R_D30V_32_PCREL";
434 case 12: return "R_D30V_32_NORMAL";
435 default: return _("*INVALID*");
439 /* end-sanitize-d30v */
441 get_sh_rel_type (rtype
)
446 case 0: return "R_SH_NONE";
447 case 1: return "R_SH_DIR32";
448 case 2: return "R_SH_REL32";
449 case 3: return "R_SH_DIR8WPN";
450 case 4: return "R_SH_IND12W";
451 case 5: return "R_SH_DIR8WPL";
452 case 6: return "R_SH_DIR8WPZ";
453 case 7: return "R_SH_DIR8BP";
454 case 8: return "R_SH_DIR8W";
455 case 9: return "R_SH_DIR8L";
456 case 25: return "R_SH_SWITCH16";
457 case 26: return "R_SH_SWITCH32";
458 case 27: return "R_SH_USES";
459 case 28: return "R_SH_COUNT";
460 case 29: return "R_SH_ALIGN";
461 case 30: return "R_SH_CODE";
462 case 31: return "R_SH_DATA";
463 case 32: return "R_SH_LABEL";
464 default: return _("*INVALID*");
470 get_mn10300_rel_type (rtype
)
475 case 0: return "R_MN10300_NONE";
476 case 1: return "R_MN10300_32";
477 case 2: return "R_MN10300_16";
478 case 3: return "R_MN10300_8";
479 case 4: return "R_MN10300_PCREL32";
480 case 5: return "R_MN10300_PCREL16";
481 case 6: return "R_MN10300_PCREL8";
482 default: return _("*INVALID*");
488 get_mn10200_rel_type (rtype
)
493 case 0: return "R_MN10200_NONE";
494 case 1: return "R_MN10200_32";
495 case 2: return "R_MN10200_16";
496 case 3: return "R_MN10200_8";
497 case 4: return "R_MN10200_24";
498 case 5: return "R_MN10200_PCREL8";
499 case 6: return "R_MN10200_PCREL16";
500 case 7: return "R_MN10200_PCREL24";
501 default: return _("*INVALID*");
507 get_ppc_rel_type (rtype
)
512 case 0: return "R_PPC_NONE,";
513 case 1: return "R_PPC_ADDR32,";
514 case 2: return "R_PPC_ADDR24,";
515 case 3: return "R_PPC_ADDR16,";
516 case 4: return "R_PPC_ADDR16_LO,";
517 case 5: return "R_PPC_ADDR16_HI,";
518 case 6: return "R_PPC_ADDR16_HA,";
519 case 7: return "R_PPC_ADDR14,";
520 case 8: return "R_PPC_ADDR14_BRTAKEN,";
521 case 9: return "R_PPC_ADDR14_BRNTAKEN,";
522 case 10: return "R_PPC_REL24,";
523 case 11: return "R_PPC_REL14,";
524 case 12: return "R_PPC_REL14_BRTAKEN,";
525 case 13: return "R_PPC_REL14_BRNTAKEN,";
526 case 14: return "R_PPC_GOT16,";
527 case 15: return "R_PPC_GOT16_LO,";
528 case 16: return "R_PPC_GOT16_HI,";
529 case 17: return "R_PPC_GOT16_HA,";
530 case 18: return "R_PPC_PLT24,";
531 case 19: return "R_PPC_COPY,";
532 case 21: return "R_PPC_JMP_SLOT,";
533 case 22: return "R_PPC_RELATIVE,";
534 case 23: return "R_PPC_LOCAL24PC,";
535 case 24: return "R_PPC_UADDR32,";
536 case 25: return "R_PPC_UADDR16,";
537 case 26: return "R_PPC_REL32,";
538 case 27: return "R_PPC_PLT32,";
539 case 28: return "R_PPC_PLTREL32,";
540 case 29: return "R_PPC_PLT16_LO,";
541 case 30: return "R_PPC_PLT16_HI,";
542 case 31: return "R_PPC_PLT16_HA,";
543 case 32: return "R_PPC_SDAREL,";
544 case 33: return "R_PPC_SECTOFF,";
545 case 34: return "R_PPC_SECTOFF_LO,";
546 case 35: return "R_PPC_SECTOFF_HI,";
547 case 36: return "R_PPC_SECTOFF_HA,";
548 case 101: return "R_PPC_EMB_NADDR32,";
549 case 102: return "R_PPC_EMB_NADDR16,";
550 case 103: return "R_PPC_EMB_NADDR16_LO,";
551 case 104: return "R_PPC_EMB_NADDR16_HI,";
552 case 105: return "R_PPC_EMB_NADDR16_HA,";
553 case 106: return "R_PPC_EMB_SDAI16,";
554 case 107: return "R_PPC_EMB_SDA2I16,";
555 case 108: return "R_PPC_EMB_SDA2REL,";
556 case 109: return "R_PPC_EMB_SDA21,";
557 case 110: return "R_PPC_EMB_MRKREF,";
558 case 111: return "R_PPC_EMB_RELSEC16,";
559 case 112: return "R_PPC_EMB_RELST_LO,";
560 case 113: return "R_PPC_EMB_RELST_HI,";
561 case 114: return "R_PPC_EMB_RELST_HA,";
562 case 115: return "R_PPC_EMB_BIT_FLD,";
563 case 116: return "R_PPC_EMB_RELSDA,";
564 default: return _("*INVALID*");
570 dump_relocations (rpnt
, rel_size
)
577 Elf_Rela
* relocs
= NULL
;
580 rapnt
= (Elf_Rela
*) rpnt
;
582 /* Compute number of relocations. */
583 switch (epnt
->e_machine
)
589 rel_size
= rel_size
/ sizeof (Elf_Rel
);
593 Elf_Rel
* new_header
= malloc (sizeof (* new_header
) * rel_size
);
595 if (new_header
== NULL
)
597 error (_("out of memory\n"));
601 memcpy (new_header
, rpnt
, sizeof (* new_header
) * rel_size
);
604 relocs
= (Elf_Rela
*) new_header
;
606 for (i
= 0; i
< rel_size
; i
++)
608 BYTE_SWAP (rpnt
+ i
, r_offset
);
609 BYTE_SWAP (rpnt
+ i
, r_info
);
622 /* start-sanitize-d30v */
624 /* end-sanitize-d30v */
625 case EM_CYGNUS_MN10200
:
626 case EM_CYGNUS_MN10300
:
628 rel_size
= rel_size
/ sizeof (Elf_Rela
);
632 Elf_Rela
* new_header
= malloc (sizeof (* new_header
) * rel_size
);
634 if (new_header
== NULL
)
636 error (_("out of memory\n"));
640 memcpy (new_header
, rpnt
, sizeof (* new_header
) * rel_size
);
642 relocs
= rapnt
= new_header
;
644 for (i
= rel_size
; i
--;)
646 BYTE_SWAP (new_header
, r_offset
);
647 BYTE_SWAP (new_header
, r_info
);
648 BYTE_SWAP (new_header
, r_addend
);
658 warn (_("Don't know about relocations on this machine architecture\n"));
663 printf (_(" Offset Value Type Symbol's Value Symbol Name Addend\n"));
665 printf (_(" Offset Value Type Symbol's Value Symbol Name\n"));
667 for (i
= 0; i
< rel_size
; i
++)
672 rpnt
= (Elf_Rel
*) rapnt
;
674 printf (" %5.5lx %5.5lx ", rpnt
->r_offset
, rpnt
->r_info
);
676 switch (epnt
->e_machine
)
683 rtype
= get_m32r_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
688 rtype
= get_i386_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
692 rtype
= get_m68k_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
696 rtype
= get_sparc_rel_type (ELF32_R_TYPE (rapnt
->r_info
));
700 rtype
= get_v850_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
704 rtype
= get_d10v_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
707 /* start-sanitize-d30v */
709 rtype
= get_d30v_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
712 /* end-sanitize-d30v */
714 rtype
= get_sh_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
717 case EM_CYGNUS_MN10300
:
718 rtype
= get_mn10300_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
721 case EM_CYGNUS_MN10200
:
722 rtype
= get_mn10200_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
726 rtype
= get_ppc_rel_type (ELF32_R_TYPE (rpnt
->r_info
));
730 printf ("%-18s", rtype
);
732 symtab_index
= ELF32_R_SYM (rpnt
->r_info
);
739 psym
= symtab
+ symtab_index
;
743 Elf_Sym
* new_header
= & ssym
;
747 BYTE_SWAP (psym
, st_name
);
748 BYTE_SWAP (psym
, st_value
);
749 /* BYTE_SWAP (psym, st_size); */
750 BYTE_SWAP (psym
, st_shndx
);
755 if (psym
->st_name
== 0)
756 printf (" %08lx %-15s", psym
->st_value
,
757 SECTION_NAME (elf_sections
+ psym
->st_shndx
));
759 printf (" %08lx %-15s", psym
->st_value
, strtab
+ psym
->st_name
);
762 printf (" + %lx", rapnt
->r_addend
);
775 get_file_type (e_type
)
778 static char buff
[32];
782 case ET_NONE
: return _("None");
783 case ET_REL
: return _("Relocatable file");
784 case ET_EXEC
: return _("Executable file");
785 case ET_DYN
: return _("Shared object file");
786 case ET_CORE
: return _("Core file");
789 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
790 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
792 sprintf (buff
, _("<unknown>: %x"), e_type
);
798 get_machine_name (e_machine
)
801 static char buff
[32];
805 case EM_NONE
: return _("None");
806 case EM_M32
: return "WE32100";
807 case EM_SPARC
: return "Sparc";
808 case EM_386
: return "80386";
809 case EM_68K
: return "MC68000";
810 case EM_88K
: return "MC88000";
811 case EM_486
: return "Intel 80486";
812 case EM_860
: return "Intel 80860";
813 case EM_MIPS
: return "MIPS R3000 big-endian";
814 case EM_S370
: return "Amdahl";
815 case EM_MIPS_RS4_BE
: return "MIPS R400 big-endian";
816 case EM_PARISC
: return "HPPA";
817 case EM_SPARC32PLUS
: return "Sparc v8+" ;
818 case EM_PPC
: return "PowerPC";
819 case EM_SPARCV9
: return "Sparc v9";
820 case EM_ARM
: return "ARM";
821 case EM_SH
: return "Hitachi SH";
822 case EM_ALPHA
: return "Alpha";
823 case EM_CYGNUS_D10V
: return "d10v";
824 /* start-sanitize-d30v */
825 case EM_CYGNUS_D30V
: return "d30v";
826 /* end-sanitize-d30v */
827 case EM_CYGNUS_M32R
: return "M32r";
828 case EM_CYGNUS_V850
: return "v850";
829 case EM_CYGNUS_MN10300
: return "mn10300";
830 case EM_CYGNUS_MN10200
: return "mn10200";
833 sprintf (buff
, _("<unknown>: %x"), e_machine
);
839 get_machine_flags (e_flags
, e_machine
)
843 static char buf
[1024];
854 if (e_flags
& EF_PPC_EMB
)
855 strcat (buf
, ", emb");
857 if (e_flags
& EF_PPC_RELOCATABLE
)
858 strcat (buf
, ", relocatable");
860 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
861 strcat (buf
, ", relocatable-lib");
865 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
866 strcat (buf
, ", m32r");
868 /* start-sanitize-m32rx */
870 if ((e_flags
& EF_M32R_ARCH
) == E_M32RX_ARCH
)
871 strcat (buf
, ", m32rx");
873 /* end-sanitize-m32rx */
878 if (e_flags
& EF_MIPS_NOREORDER
)
879 strcat (buf
, ", noreorder");
881 if (e_flags
& EF_MIPS_PIC
)
882 strcat (buf
, ", pic");
884 if (e_flags
& EF_MIPS_CPIC
)
885 strcat (buf
, ", cpic");
887 if (e_flags
& EF_MIPS_ABI2
)
888 strcat (buf
, ", abi2");
890 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
891 strcat (buf
, ", mips1");
893 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
894 strcat (buf
, ", mips2");
896 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
897 strcat (buf
, ", mips3");
899 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
900 strcat (buf
, ", mips4");
909 get_machine_data (e_data
)
912 static char buff
[32];
916 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
917 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
919 sprintf (buff
, _("<unknown>: %x"), e_data
);
925 get_segment_type (p_type
)
926 unsigned long p_type
;
928 static char buff
[32];
932 case PT_NULL
: return _("Unused");
933 case PT_LOAD
: return _("Loadable");
934 case PT_DYNAMIC
: return _("Dynamic link info");
935 case PT_INTERP
: return _("Interpreter");
936 case PT_NOTE
: return _("Auxillary Info");
937 case PT_SHLIB
: return _("Shared Library");
938 case PT_PHDR
: return _("Program Headers");
941 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
942 return _("processor specific");
945 sprintf (buff
, _("<unknown>: %x"), p_type
);
952 get_section_type_name (sh_type
)
953 unsigned int sh_type
;
955 static char buff
[32];
959 case SHT_NULL
: return _("Unused");
960 case SHT_PROGBITS
: return _("Program data");
961 case SHT_SYMTAB
: return _("Symbol table");
962 case SHT_STRTAB
: return _("String table");
963 case SHT_RELA
: return _("Relocs, addends");
964 case SHT_HASH
: return _("Symbol hash table");
965 case SHT_DYNAMIC
: return _("Dynamic linking info");
966 case SHT_NOTE
: return _("Notes");
967 case SHT_NOBITS
: return _("Space, no data");
968 case SHT_REL
: return _("Relocs, no addends");
969 case SHT_SHLIB
: return _("Shared Library info");
970 case SHT_DYNSYM
: return _("Dynamic linker symbols");
971 case SHT_GNU_verdef
: return _("Version definition");
972 case SHT_GNU_verneed
: return _("Version needs");
973 case SHT_GNU_versym
: return _("Version symbols");
974 case 0x6ffffff0: return "VERSYM";
975 case 0x6ffffffc: return "VERDEF";
976 case 0x7ffffffd: return "AUXILIARY";
977 case 0x7fffffff: return "FILTER";
980 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
981 return _("processor specific");
982 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
983 return _("application specific");
986 sprintf (buff
, _("<unknown>: %x"), sh_type
);
992 struct option options
[] =
994 {"all", no_argument
, 0, 'a'},
995 {"file-header", no_argument
, 0, 'h'},
996 {"program-headers", no_argument
, 0, 'l'},
997 {"segments", no_argument
, 0, 'l'},
998 {"sections", no_argument
, 0, 'S'},
999 {"symbols", no_argument
, 0, 's'},
1000 {"relocs", no_argument
, 0, 'r'},
1001 {"dynamic", no_argument
, 0, 'd'},
1002 {"version-info", no_argument
, 0, 'V'},
1003 {"use-dynamic", no_argument
, 0, 'D'},
1005 {"hex-dump", required_argument
, 0, 'x'},
1006 #ifdef SUPPORT_DISASSEMBLY
1007 {"instruction-dump", required_argument
, 0, 'i'},
1010 {"version", no_argument
, 0, 'v'},
1011 {"help", no_argument
, 0, 'H'},
1013 {0, no_argument
, 0, 0}
1019 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1020 fprintf (stdout
, _(" Options are:\n"));
1021 fprintf (stdout
, _(" -a or --all Display all the information\n"));
1022 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1023 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1024 fprintf (stdout
, _(" Display the program headers\n"));
1025 fprintf (stdout
, _(" -S or --sections Display the sections' headers\n"));
1026 fprintf (stdout
, _(" -s or --symbols Display the symbol table\n"));
1027 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1028 fprintf (stdout
, _(" -d or --dynamic Display the dynamic section (if present)\n"));
1029 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1030 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1031 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1032 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1033 #ifdef SUPPORT_DISASSEMBLY
1034 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1035 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1037 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1038 fprintf (stdout
, _(" -H or --help Display this information\n"));
1039 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1045 parse_args (argc
, argv
)
1054 while ((c
= getopt_long
1055 (argc
, argv
, "rsahldSDx:i:vV", options
, NULL
)) != EOF
)
1098 section
= strtoul (optarg
, & cp
, 0);
1099 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1101 dump_sects
[section
] |= HEX_DUMP
;
1105 #ifdef SUPPORT_DISASSEMBLY
1108 section
= strtoul (optarg
, & cp
, 0);
1109 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1111 dump_sects
[section
] |= DISASS_DUMP
;
1117 print_version (program_name
);
1124 /* xgettext:c-format */
1125 error (_("Invalid option '-%c'\n"), c
);
1132 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_section
1133 && !do_load
&& !do_header
&& !do_dump
&& !do_version
)
1137 warn (_("Nothing to do.\n"));
1143 process_elf_header ()
1145 if ( epnt
->e_ident
[EI_MAG0
] != ELFMAG0
1146 || epnt
->e_ident
[EI_MAG1
] != ELFMAG1
1147 || epnt
->e_ident
[EI_MAG2
] != ELFMAG2
1148 || epnt
->e_ident
[EI_MAG3
] != ELFMAG3
)
1150 error (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1154 if (epnt
->e_ident
[EI_CLASS
] != ELFCLASS32
)
1156 error (_("Not a 32 bit ELF file\n"));
1160 if (epnt
->e_ident
[EI_DATA
] != expected_endian
)
1165 Elf_Ehdr
* new_header
= malloc (sizeof (* new_header
));
1167 if (new_header
== NULL
)
1169 error (_("out of memory\n"));
1173 memcpy (new_header
, epnt
, sizeof (* new_header
));
1175 BYTE_SWAP (epnt
, e_type
);
1176 BYTE_SWAP (epnt
, e_machine
);
1177 BYTE_SWAP (epnt
, e_version
);
1178 BYTE_SWAP (epnt
, e_entry
);
1179 BYTE_SWAP (epnt
, e_phoff
);
1180 BYTE_SWAP (epnt
, e_shoff
);
1181 BYTE_SWAP (epnt
, e_flags
);
1182 BYTE_SWAP (epnt
, e_ehsize
);
1183 BYTE_SWAP (epnt
, e_phentsize
);
1184 BYTE_SWAP (epnt
, e_phnum
);
1185 BYTE_SWAP (epnt
, e_shentsize
);
1186 BYTE_SWAP (epnt
, e_shnum
);
1187 BYTE_SWAP (epnt
, e_shstrndx
);
1196 printf (_("ELF Header....\n"));
1197 printf (_(" Magic: "));
1198 for (i
= 0; i
< EI_NIDENT
; i
++)
1199 printf ("%2.2x ", epnt
->e_ident
[i
]);
1201 printf (_(" Type: %s\n"), get_file_type (epnt
->e_type
));
1202 printf (_(" Machine: %s\n"), get_machine_name (epnt
->e_machine
));
1203 printf (_(" Version: 0x%lx\n"), (unsigned long)epnt
->e_version
);
1204 printf (_(" Data: %s\n"), get_machine_data (epnt
->e_ident
[EI_DATA
]));
1205 printf (_(" Entry point address: 0x%lx\n"), (unsigned long)epnt
->e_entry
);
1206 printf (_(" Start of program headers: %ld (bytes into file)\n"), (long)epnt
->e_phoff
);
1207 printf (_(" Start of section headers: %ld (bytes into file)\n"), (long)epnt
->e_shoff
);
1208 printf (_(" Flags: 0x%lx%s\n"), (unsigned long)epnt
->e_flags
,
1209 get_machine_flags (epnt
->e_flags
, epnt
->e_machine
));
1210 printf (_(" Size of this header: %ld (bytes)\n"), (long)epnt
->e_ehsize
);
1211 printf (_(" Size of program headers: %ld (bytes)\n"), (long)epnt
->e_phentsize
);
1212 printf (_(" Number of program headers: %ld\n"), (long)epnt
->e_phnum
);
1213 printf (_(" Size of section headers: %ld (bytes)\n"), (long)epnt
->e_shentsize
);
1214 printf (_(" Number of section headers: %ld\n"), (long)epnt
->e_shnum
);
1215 printf (_(" Section header string table index: %ld\n"), (long)epnt
->e_shstrndx
);
1223 process_program_headers ()
1225 Elf_Phdr
* elf_segments
;
1229 if (epnt
->e_phnum
== 0)
1232 printf (_("\nThere are no program headers in this file\n"));
1236 if (do_load
&& !do_header
)
1238 printf (_("\nElf file is %s\n"), get_file_type (epnt
->e_type
));
1239 printf (_("Entry point 0x%x\n"), epnt
->e_entry
);
1240 printf (_("There are %d program headers, starting at offset %x:\n"),
1241 epnt
->e_phnum
, epnt
->e_phoff
);
1246 Elf_Phdr
* new_header
= malloc (sizeof (* new_header
) * epnt
->e_phnum
);
1248 if (new_header
== NULL
)
1250 error (_("out of memory\n"));
1254 memcpy (new_header
, & header
[epnt
->e_phoff
],
1255 sizeof (* new_header
) * epnt
->e_phnum
);
1257 elf_segments
= ppnt
= new_header
;
1259 for (i
= 0; i
< epnt
->e_phnum
; i
++)
1261 BYTE_SWAP (ppnt
+ i
, p_type
);
1262 BYTE_SWAP (ppnt
+ i
, p_flags
);
1263 BYTE_SWAP (ppnt
+ i
, p_offset
);
1264 BYTE_SWAP (ppnt
+ i
, p_vaddr
);
1265 BYTE_SWAP (ppnt
+ i
, p_paddr
);
1266 BYTE_SWAP (ppnt
+ i
, p_filesz
);
1267 BYTE_SWAP (ppnt
+ i
, p_memsz
);
1268 BYTE_SWAP (ppnt
+ i
, p_align
);
1275 ppnt
= (Elf_Phdr
*) & header
[epnt
->e_phoff
];
1276 elf_segments
= NULL
;
1281 printf (_("\nProgram Header%s....\n"), epnt
->e_phnum
> 1 ? "s" : "");
1282 printf (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1288 for (i
= 0; i
< epnt
->e_phnum
; i
++)
1290 if (loadaddr
== -1 && ppnt
->p_type
== PT_LOAD
)
1291 loadaddr
= (ppnt
->p_vaddr
& 0xfffff000)
1292 - (ppnt
->p_offset
& 0xfffff000);
1296 printf (" %-10s ", get_segment_type (ppnt
->p_type
));
1297 printf ("0x%5.5lx ",ppnt
->p_offset
);
1298 printf ("0x%8.8lx ",ppnt
->p_vaddr
);
1299 printf ("0x%8.8lx ",ppnt
->p_paddr
);
1300 printf ("0x%5.5lx 0x%5.5lx ",ppnt
->p_filesz
, ppnt
->p_memsz
);
1302 (ppnt
->p_flags
& 4 ? 'R' : ' '),
1303 (ppnt
->p_flags
& 2 ? 'W' : ' '),
1304 (ppnt
->p_flags
& 1 ? 'E' : ' '));
1305 printf ("%#lx", ppnt
->p_align
);
1308 if (ppnt
->p_type
== PT_DYNAMIC
)
1311 error (_("more than one dynamic section\n"));
1313 dynamic_addr
= ppnt
->p_offset
;
1314 dynamic_size
= ppnt
->p_filesz
;
1317 if (ppnt
->p_type
== PT_INTERP
)
1320 printf (_("\nRequesting program interpreter [%s]"),
1321 & header
[ppnt
->p_offset
]);
1322 pint
= strdup (& header
[ppnt
->p_offset
]);
1326 putc ('\n', stdout
);
1333 printf (_("\n Section to Segment mapping:\n"));
1334 printf (_(" Segment Sections...\n"));
1337 ppnt
= elf_segments
;
1339 ppnt
= (Elf_Phdr
*) & header
[epnt
->e_phoff
];
1341 for (i
= 0; i
< epnt
->e_phnum
; i
++, ppnt
++)
1346 printf (" %2.2d ", i
);
1348 spnt
= (Elf_Shdr
*) & header
[epnt
->e_shoff
];
1352 lastmapped
= SWAP4 (spnt
[epnt
->e_shstrndx
].sh_offset
);
1354 for (j
= 0; j
< epnt
->e_shnum
; j
++)
1360 addr
= SWAP4 (spnt
[j
].sh_addr
);
1361 size
= SWAP4 (spnt
[j
].sh_size
);
1362 name
= SWAP4 (spnt
[j
].sh_name
);
1365 && (addr
>= ppnt
->p_vaddr
)
1366 && (addr
+ size
) <= (ppnt
->p_vaddr
+ ppnt
->p_memsz
))
1367 printf ("%s ", header
+ lastmapped
+ name
);
1372 lastmapped
= spnt
[epnt
->e_shstrndx
].sh_offset
;
1374 for (j
= 0; j
< epnt
->e_shnum
; j
++, spnt
++)
1376 if (spnt
->sh_size
> 0
1377 && (spnt
->sh_addr
>= ppnt
->p_vaddr
)
1378 && (spnt
->sh_addr
+ spnt
->sh_size
)
1379 <= (ppnt
->p_vaddr
+ ppnt
->p_memsz
))
1380 printf ("%s ", SECTION_NAME (spnt
));
1389 free (elf_segments
);
1394 process_section_headers ()
1401 Elf_Shdr
* new_header
= malloc (sizeof (* new_header
) * epnt
->e_shnum
);
1403 if (new_header
== NULL
)
1405 error (_("out of memory\n"));
1409 memcpy (new_header
, & header
[epnt
->e_shoff
],
1410 sizeof (* new_header
) * epnt
->e_shnum
);
1412 elf_sections
= spnt
= new_header
;
1414 for (i
= 0; i
< epnt
->e_shnum
; i
++)
1416 BYTE_SWAP (spnt
+ i
, sh_name
);
1417 BYTE_SWAP (spnt
+ i
, sh_type
);
1418 BYTE_SWAP (spnt
+ i
, sh_flags
);
1419 BYTE_SWAP (spnt
+ i
, sh_addr
);
1420 BYTE_SWAP (spnt
+ i
, sh_offset
);
1421 BYTE_SWAP (spnt
+ i
, sh_size
);
1422 BYTE_SWAP (spnt
+ i
, sh_link
);
1423 BYTE_SWAP (spnt
+ i
, sh_info
);
1424 BYTE_SWAP (spnt
+ i
, sh_addralign
);
1425 BYTE_SWAP (spnt
+ i
, sh_entsize
);
1432 elf_sections
= spnt
= (Elf_Shdr
*) & header
[epnt
->e_shoff
];
1435 spnt
+= epnt
->e_shstrndx
;
1436 lastmapped
= spnt
->sh_offset
;
1437 spnt
= elf_sections
;
1439 if (! do_section
|| (epnt
->e_shnum
== 0))
1443 printf (_("There are %d section headers, starting at offset %x:\n"),
1444 epnt
->e_shnum
, epnt
->e_shoff
);
1446 printf (_("\nSection Header%s....\n"), epnt
->e_shnum
> 1 ? "s" : "");
1447 printf (_(" [Nr] Name Type Addr Off Size ES Flg Lk In Al\n"));
1449 for (i
= 0; i
< epnt
->e_shnum
; i
++)
1451 printf (" [%2d] %-17s", i
, SECTION_NAME (spnt
));
1453 printf (" %-15s ",get_section_type_name (spnt
->sh_type
));
1454 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
1460 printf (" %c%c%c %2ld %2lx %ld \n",
1461 (spnt
->sh_flags
& 1 ? 'W' : ' '),
1462 (spnt
->sh_flags
& 2 ? 'A' : ' '),
1463 (spnt
->sh_flags
& 4 ? 'X' : ' '),
1466 spnt
->sh_addralign
);
1471 /* Parse the dynamic segment */
1473 process_dynamic_segment ()
1475 Elf_Dyn
* elf_dynamic
;
1478 dynamic_size
= dynamic_size
/ sizeof (Elf_Dyn
);
1482 Elf_Dyn
* new_header
= malloc (sizeof (* new_header
) * dynamic_size
);
1484 if (new_header
== NULL
)
1486 error (_("out of memory\n"));
1490 memcpy (new_header
, & header
[dynamic_addr
],
1491 sizeof (* new_header
) * dynamic_size
);
1493 elf_dynamic
= dpnt
= new_header
;
1495 for (i
= 0; i
< dynamic_size
; i
++)
1497 BYTE_SWAP (dpnt
+ i
, d_tag
);
1498 BYTE_SWAP (dpnt
+ i
, d_un
.d_ptr
);
1505 dpnt
= (Elf_Dyn
*) & header
[dynamic_addr
];
1510 for (i
= 0; i
< dynamic_size
; ++i
, ++dpnt
)
1511 if (dpnt
->d_tag
== DT_SYMTAB
)
1513 dynamic_info
[DT_SYMTAB
] = dpnt
->d_un
.d_val
;
1514 symtab
= (Elf_Sym
*) (header
- loadaddr
1515 + dynamic_info
[DT_SYMTAB
]);
1517 else if (dpnt
->d_tag
== DT_STRTAB
)
1519 dynamic_info
[DT_STRTAB
] = dpnt
->d_un
.d_val
;
1520 strtab
= (char *) (header
- loadaddr
+ dynamic_info
[DT_STRTAB
]);
1523 if (do_dynamic
&& dynamic_addr
)
1525 printf (_("\n Dynamic section data: %x, %d entries\n"),
1526 dynamic_addr
, dynamic_size
);
1529 for (i
= 0; i
< dynamic_size
; i
++)
1532 printf (_(" Tag: %#10x: "), dpnt
->d_tag
);
1534 switch (dpnt
->d_tag
)
1540 printf ("(%-11s)", filtertype
[DT_FILTER
- dpnt
->d_tag
]);
1542 if (dynamic_info
[DT_STRTAB
])
1544 if (dpnt
->d_tag
== DT_AUXILIARY
)
1545 printf (_("Auxiliary library"));
1547 printf (_("Filter library"));
1549 printf (": [%s]\n", (dpnt
->d_un
.d_val
+ strtab
));
1552 printf (_("Value %x\n"), dpnt
->d_un
.d_val
);
1580 dynamic_info
[dpnt
->d_tag
] = dpnt
->d_un
.d_val
;
1584 printf ("(%-11s)", dyntype
[dpnt
->d_tag
]);
1586 if (dynamic_info
[DT_STRTAB
])
1588 switch (dpnt
->d_tag
)
1591 printf (_("Shared library: [%s]\n"),
1592 (dpnt
->d_un
.d_val
+ strtab
));
1594 if (strcmp (dpnt
->d_un
.d_val
+ strtab
, pint
))
1597 printf (_(" program interpreter\n"));
1601 printf (_("Library soname: [%s]\n"),
1602 (dpnt
->d_un
.d_val
+ strtab
));
1606 printf (_("Library rpath: [%s]\n"),
1607 (dpnt
->d_un
.d_val
+ strtab
));
1611 printf (_("Value %x\n"), dpnt
->d_un
.d_val
);
1615 printf (_("Value %x\n"), dpnt
->d_un
.d_val
);
1620 if ((dpnt
->d_tag
>= DT_VERSYM
) && (dpnt
->d_tag
<= DT_VERNEEDNUM
))
1622 version_info
[DT_VERSIONTAGIDX (dpnt
->d_tag
)] = dpnt
->d_un
.d_val
;
1625 printf (_("(%-11s) Value %#x\n"),
1626 vertype
[DT_VERSIONTAGIDX (dpnt
->d_tag
)],
1630 warn (_("<Invalid> Value %#x\n"), dpnt
->d_un
.d_ptr
);
1639 if (do_using_dynamic
)
1641 if (dynamic_info
[DT_REL
])
1643 rpnt
= (Elf_Rel
*) (header
+ dynamic_info
[DT_REL
] - loadaddr
);
1644 rel_size
= dynamic_info
[DT_RELSZ
];
1647 printf (_("\nRelocation section data: %x %x\n"),
1648 dynamic_info
[DT_REL
], rel_size
);
1649 dump_relocations (rpnt
, rel_size
);
1652 printf (_("\nNo Relocations in this file\n"));
1655 if (dynamic_info
[DT_RELA
])
1657 rpnt
= (Elf_Rel
*) (header
+ dynamic_info
[DT_RELA
] - loadaddr
);
1658 rel_size
= dynamic_info
[DT_RELASZ
];
1661 printf (_("\nRelocation section data: %x %x\n"),
1662 dynamic_info
[DT_RELA
], rel_size
);
1663 dump_relocations (rpnt
, rel_size
);
1666 printf (_("\nNo Relocations in this file\n"));
1669 if (dynamic_info
[DT_JMPREL
])
1671 rpnt
= (Elf_Rel
*) (header
+ dynamic_info
[DT_JMPREL
]
1673 rel_size
= dynamic_info
[DT_PLTRELSZ
];
1676 printf (_("\nJumptable Relocation section data: %x %x\n"),
1677 dynamic_info
[DT_JMPREL
], rel_size
);
1678 dump_relocations (rpnt
, rel_size
);
1681 printf (_("\nNo Relocations in this file\n"));
1688 spnt
= elf_sections
;
1690 for (i
= 0; i
< epnt
->e_shnum
; i
++, spnt
++)
1695 if (spnt
->sh_type
!= SHT_RELA
&& spnt
->sh_type
!= SHT_REL
)
1698 rpnt
= (Elf_Rel
*) (header
+ spnt
->sh_offset
);
1700 rel_size
= spnt
->sh_size
;
1704 printf (_("\nRelocation section data: %s (%#x entries)\n"),
1705 SECTION_NAME (spnt
), rel_size
/ spnt
->sh_entsize
);
1707 symsec
= & elf_sections
[spnt
->sh_link
];
1708 symtab
= (Elf_Sym
*) (header
+ symsec
->sh_offset
);
1709 strtab
= (char *) (header
1710 + elf_sections
[symsec
->sh_link
].sh_offset
);
1712 dump_relocations (rpnt
, rel_size
);
1715 printf (_("\nNo Relocations in this file\n"));
1724 /* Dump the symbol table */
1726 process_symbol_table ()
1735 if (dynamic_info
[DT_HASH
] && do_using_dynamic
)
1745 hash_addr
= (int *) (dynamic_info
[DT_HASH
] + header
- loadaddr
);
1747 nbucket
= *hash_addr
++;
1748 nchain
= *hash_addr
++;
1749 elf_buckets
= hash_addr
;
1750 hash_addr
+= nbucket
;
1753 printf (_("\n Symbol table for image\n"));
1754 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
1756 for (hn
= 0; hn
< nbucket
; hn
++)
1758 if (! elf_buckets
[hn
])
1761 for (si
= elf_buckets
[hn
]; si
; si
= chains
[si
])
1763 pnt
= strtab
+ symtab
[si
].st_name
;
1765 printf ("%3d %3d: %8lx %5ld %6s %6s %2d ", si
, hn
,
1766 symtab
[si
].st_value
,
1768 sttinfo
[ELF_ST_TYPE (symtab
[si
].st_info
)],
1769 stbinfo
[ELF_ST_BIND (symtab
[si
].st_info
)],
1770 symtab
[si
].st_other
);
1772 if (symtab
[si
].st_shndx
== 0)
1774 else if ((symtab
[si
].st_shndx
& 0xffff) == 0xfff1)
1776 else if ((symtab
[si
].st_shndx
& 0xffff) == 0xfff2)
1779 printf ("%3d", symtab
[si
].st_shndx
);
1780 printf (" %s\n", pnt
);
1784 else if (!do_using_dynamic
)
1787 unsigned short * vers_addr
;
1789 spnt
= elf_sections
;
1790 vers_addr
= (short *) (version_info
[DT_VERNEEDNUM
- DT_VERSYM
]
1791 + header
- loadaddr
);
1793 for (i
= 0; i
< epnt
->e_shnum
; i
++, spnt
++)
1797 if (spnt
->sh_type
!= SHT_SYMTAB
&& spnt
->sh_type
!= SHT_DYNSYM
)
1800 printf (_("\nSymbol data for: %s\n"), SECTION_NAME (spnt
));
1801 printf (_(" Num: Value Size Type Bind Ot Ndx Name\n"));
1803 symtab
= (Elf_Sym
*) (header
+ spnt
->sh_offset
);
1804 strtab
= (char *) (header
+ elf_sections
[spnt
->sh_link
].sh_offset
);
1806 for (si
= 0; si
< spnt
->sh_size
/ spnt
->sh_entsize
; si
++)
1810 Elf_Sym
* new_header
;
1818 new_header
= & ssym
;
1820 BYTE_SWAP (psym
, st_name
);
1821 BYTE_SWAP (psym
, st_value
);
1822 BYTE_SWAP (psym
, st_size
);
1823 BYTE_SWAP (psym
, st_shndx
);
1828 pnt
= strtab
+ psym
->st_name
;
1830 printf (" %3d: %8lx %5ld %-7s %-6s %2d ", si
,
1833 sttinfo
[ELF_ST_TYPE (psym
->st_info
)],
1834 stbinfo
[ELF_ST_BIND (psym
->st_info
)],
1837 if (psym
->st_shndx
== 0)
1839 else if ((psym
->st_shndx
& 0xffff) == 0xfff1)
1841 else if ((psym
->st_shndx
& 0xffff) == 0xfff2)
1844 printf ("%3d", psym
->st_shndx
);
1845 printf (" %s", pnt
);
1847 if (spnt
->sh_type
== SHT_DYNSYM
&&
1848 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0 &&
1849 ((vers_addr
[si
] & 0x8000) || vers_addr
[si
] > 1))
1853 if (elf_sections
[psym
->st_shndx
].sh_type
== SHT_NOBITS
1854 || psym
->st_shndx
== SHN_UNDEF
)
1858 /* We must test both. */
1860 (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
1861 + header
- loadaddr
);
1865 a
= (Elf_Vernaux
*)((char *)v
+ v
->vn_aux
);
1867 while (a
->vna_other
!= vers_addr
[si
]
1868 && a
->vna_next
!= 0)
1869 a
= (Elf_Vernaux
*)((char *)a
+ a
->vna_next
);
1871 if (a
->vna_other
== vers_addr
[si
])
1874 if (v
->vn_next
== 0)
1876 if (elf_sections
[psym
->st_shndx
].sh_type
1878 error (_("bad dynamic symbol"));
1884 v
= (Elf_Verneed
*)((char *)v
+ v
->vn_next
);
1888 printf ("@%s (%d)", strtab
+ a
->vna_name
, a
->vna_other
);
1890 else if ((elf_sections
[psym
->st_shndx
].sh_type
1891 == SHT_NOBITS
&& a
== NULL
)
1892 || psym
->st_shndx
!= SHN_UNDEF
)
1898 (version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
1899 + header
- loadaddr
);
1901 if (vers_addr
[si
] == 0x8001)
1905 while (v
->vd_ndx
!= (vers_addr
[si
] & 0x7fff))
1906 v
= (Elf_Verdef
*)((char *)v
+ v
->vd_next
);
1908 b
= (Elf_Verdaux
*) ((char *)v
+ v
->vd_aux
);
1910 if (psym
->st_name
!= b
->vda_name
)
1911 pnt
= strtab
+ b
->vda_name
;
1917 printf ((vers_addr
[si
] & 0x8000)
1918 ? "@%s" : "@@%s", pnt
);
1930 spnt
= elf_sections
;
1932 for (i
= 0; i
< epnt
->e_shnum
; i
++, spnt
++)
1934 if (spnt
->sh_type
== SHT_GNU_verdef
)
1936 Elf_Shdr
* dspnt
= &elf_sections
[spnt
->sh_link
];
1940 strtab
= (char *) (header
- loadaddr
+ dynamic_info
[DT_STRTAB
]);
1942 printf (_("\n Version definitions:%s (%#0x entries)\n"),
1943 SECTION_NAME(spnt
), spnt
->sh_info
);
1944 printf (_("Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
1945 spnt
->sh_addr
, spnt
->sh_offset
, spnt
->sh_link
,
1946 SECTION_NAME(dspnt
));
1948 for (idx
= cnt
= 0; cnt
< spnt
->sh_info
; ++cnt
)
1950 Elf_Verdef
* ent
= (Elf_Verdef
*)
1951 ((char *) header
+ spnt
->sh_offset
+ idx
);
1952 Elf_Verdaux
* aux
= (Elf_Verdaux
*)
1953 ((char *) ent
+ ent
->vd_aux
);
1956 printf (_("%#06x: Rev: %d Flags: "), idx
, ent
->vd_version
);
1958 if (ent
->vd_flags
== 0)
1963 if (ent
->vd_flags
& 0x1)
1968 if (ent
->vd_flags
& 0x2)
1970 printf (_("%sWEAK"), f
? "" : "|");
1974 printf (_(" Index: %d Cnt: %d Name: %s\n"),
1975 ent
->vd_ndx
, ent
->vd_cnt
, strtab
+ aux
->vda_name
);
1977 isum
= idx
+ ent
->vd_aux
;
1978 while (j
< ent
->vd_cnt
)
1980 isum
+= aux
->vda_next
;
1981 aux
= (Elf_Verdaux
*)((char *)aux
+ aux
->vda_next
);
1982 printf (_(" %#06x: Parent %d: %s\n"), isum
, j
,
1983 strtab
+ aux
->vda_name
);
1987 idx
+= ent
->vd_next
;
1991 if (spnt
->sh_type
== SHT_GNU_verneed
)
1993 Elf_Shdr
* dspnt
= &elf_sections
[spnt
->sh_link
];
1997 strtab
= (char *) (header
- loadaddr
+ dynamic_info
[DT_STRTAB
]);
1998 printf (_("\n Needed versions:%s (%#0x entries)\n"),
1999 SECTION_NAME (spnt
), spnt
->sh_info
);
2000 printf (_("Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2001 spnt
->sh_addr
, spnt
->sh_offset
, spnt
->sh_link
,
2002 SECTION_NAME (dspnt
));
2004 for (idx
= cnt
= 0; cnt
< spnt
->sh_info
; ++cnt
)
2006 Elf_Verneed
* ent
= (Elf_Verneed
*)
2007 ((char *) header
+ spnt
->sh_offset
+ idx
);
2008 Elf_Vernaux
* aux
= (Elf_Vernaux
*)
2009 ((char *) ent
+ ent
->vn_aux
);
2012 printf (_("%#06x: Version: %d File: %s Cnt: %d\n"),
2013 idx
, ent
->vn_version
, strtab
+ ent
->vn_file
,ent
->vn_cnt
);
2015 for (j
= 0, isum
= idx
+ ent
->vn_aux
; j
< ent
->vn_cnt
; ++j
)
2017 printf (_(" %#06x: Name: %s Flags: %s Version: %d\n"),
2018 isum
, strtab
+aux
->vna_name
,
2019 aux
->vna_flags
& 0x2 ? "WEAK" : "none",
2021 isum
+= aux
->vna_next
;
2022 aux
= (Elf_Vernaux
*)((char *) aux
+ aux
->vna_next
);
2025 idx
+= ent
->vn_next
;
2029 if (spnt
->sh_type
== SHT_GNU_versym
)
2031 Elf_Shdr
* dspnt
= &elf_sections
[spnt
->sh_link
];
2032 int total
= spnt
->sh_size
/ spnt
->sh_entsize
;
2034 unsigned short * p
= (short *)
2035 (version_info
[DT_VERNEEDNUM
- DT_VERSYM
] + header
- loadaddr
);
2037 symtab
= (Elf_Sym
*) (header
+ dspnt
->sh_offset
);
2038 strtab
= (char *) (header
+ elf_sections
[dspnt
->sh_link
].sh_offset
);
2040 printf (_("\n Version symbols:%s (%#0x entries)\n"),
2041 SECTION_NAME (spnt
), total
);
2042 printf (_("Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2043 spnt
->sh_addr
, spnt
->sh_offset
, spnt
->sh_link
,
2044 SECTION_NAME (dspnt
));
2046 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2050 printf ("%#08x:", cnt
);
2052 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2056 printf (" 0 (*local*) ");
2059 printf (" 1 (*global*) ");
2062 nn
= printf ("%4x%c", p
[cnt
+ j
] & 0x7fff,
2063 p
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2064 if (elf_sections
[symtab
[cnt
+ j
].st_shndx
].sh_type
2067 /* We must test both. */
2068 Elf_Verneed
* v
= (Elf_Verneed
*)
2069 (version_info
[DT_VERNEEDNUM
- DT_VERNEED
]
2070 + header
- loadaddr
);
2071 Elf_Vernaux
* a
= NULL
;
2075 a
= (Elf_Vernaux
*)((char *) v
+ v
->vn_aux
);
2077 while (a
->vna_other
!= p
[cnt
+ j
]
2078 && a
->vna_next
!= 0)
2079 a
= (Elf_Vernaux
*)((char *) a
+ a
->vna_next
);
2081 if (a
->vna_other
== p
[cnt
+ j
])
2084 if (v
->vn_next
== 0)
2090 v
= (Elf_Verneed
*)((char *)v
+ v
->vn_next
);
2094 nn
+= printf ("(%s)", strtab
+ a
->vna_name
);
2097 Elf_Verdef
* v
= (Elf_Verdef
*)
2098 (version_info
[DT_VERNEEDNUM
- DT_VERDEF
]
2099 + header
- loadaddr
);
2102 if (p
[cnt
+ j
] == 0x8001)
2106 while (v
->vd_ndx
!= (p
[cnt
+ j
]&0x7fff))
2107 v
= (Elf_Verdef
*)((char *)v
+ v
->vd_next
);
2109 a
= (Elf_Verdaux
*) ((char *) v
+ v
->vd_aux
);
2110 pnt
= strtab
+ a
->vda_name
;
2114 nn
+= printf ("(%s)", pnt
);
2118 printf ("%*c", 16 - nn
, ' ');
2120 else if (symtab
[cnt
+ j
].st_shndx
==SHN_UNDEF
)
2122 Elf_Verneed
* v
= (Elf_Verneed
*)
2123 (version_info
[DT_VERNEEDNUM
- DT_VERNEED
]
2124 + header
- loadaddr
);
2129 a
= (Elf_Vernaux
*)((char *) v
+ v
->vn_aux
);
2131 while (a
->vna_other
!= p
[cnt
+ j
]
2132 && a
->vna_next
!= 0)
2133 a
= (Elf_Vernaux
*)((char *)a
+ a
->vna_next
);
2135 if (a
->vna_other
== p
[cnt
+ j
])
2138 v
= (Elf_Verneed
*)((char *) v
+ v
->vn_next
);
2141 nn
+= printf ("(%s)", strtab
+ a
->vna_name
);
2144 printf ("%*c", 16 - nn
, ' ');
2148 Elf_Verdef
* v
= (Elf_Verdef
*)
2149 (version_info
[DT_VERNEEDNUM
- DT_VERDEF
]
2150 + header
- loadaddr
);
2153 if (p
[cnt
+ j
] == 0x8001)
2157 while (v
->vd_ndx
!= (p
[cnt
+ j
] & 0x7fff))
2158 v
= (Elf_Verdef
*)((char *) v
+ v
->vd_next
);
2160 a
= (Elf_Verdaux
*) ((char *) v
+ v
->vd_aux
);
2161 pnt
= strtab
+ a
->vda_name
;
2165 nn
+= printf ("(%s)", pnt
);
2168 printf ("%*c", 16 - nn
, ' ');
2179 process_section_contents ()
2187 spnt
= elf_sections
;
2189 for (i
= 0; i
< epnt
->e_shnum
; i
++, spnt
++)
2194 unsigned char * my_addr
;
2196 #ifdef SUPPORT_DISASSEMBLY
2197 /* See if we need an assembly dump of this section */
2199 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & DISASS_DUMP
))
2201 printf (_("\nAssembly dump of section %s\n"), SECTION_NAME (spnt
));
2203 bytes
= spnt
->sh_size
;
2204 addr
= spnt
->sh_addr
;
2205 my_addr
= (unsigned char *) (header
+ spnt
->sh_offset
);
2209 printf ("0x%8.8x ", addr
);
2211 switch (epnt
->e_machine
)
2215 lbytes
= db_disasm ((unsigned int) my_addr
, 0, 0) -
2216 ((unsigned int) my_addr
);
2219 lbytes
= (m68k_disass ((unsigned int) my_addr
, addr
)
2220 - (unsigned int) my_addr
);
2223 warn (_("Unable to disassemble code for this platform\n"));
2236 /* OK, see if we need a hex dump of this section. */
2237 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & HEX_DUMP
))
2242 printf (_("\nHex dump of section %s\n"), SECTION_NAME (spnt
));
2244 bytes
= spnt
->sh_size
;
2245 addr
= spnt
->sh_addr
;
2246 my_addr
= (unsigned char *) (header
+ spnt
->sh_offset
);
2250 lbytes
= (bytes
> 16 ? 16 : bytes
);
2252 printf ("0x%8.8x ",addr
);
2254 switch (epnt
->e_ident
[EI_DATA
])
2257 for (j
= 15; j
>= 0; j
--)
2260 printf ("%2.2x", my_addr
[j
]);
2270 for (j
= 0; j
< 16; j
++)
2273 printf ("%2.2x", my_addr
[j
]);
2283 for (j
= 0; j
< lbytes
; j
++)
2286 if (k
>= ' ' && k
< 0x80)
2303 process_file (file_name
)
2307 struct stat statbuf
;
2311 fd
= open (file_name
, O_RDONLY
);
2314 error (_("Input file %s not found.\n"), file_name
);
2318 if (fstat (fd
, & statbuf
) < 0)
2320 error (_("Cannot stat input file %s.\n"), file_name
);
2325 header
= mmap (0, statbuf
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0);
2327 if ((header
== (char *) -1) || (header
== NULL
))
2329 error (_("Cannot mmap %s: %s\n"), file_name
, strerror (errno
));
2336 epnt
= (Elf_Ehdr
*) header
;
2339 printf (_("\nFile: %s\n"), file_name
);
2341 if (! process_elf_header ())
2343 munmap (header
, statbuf
.st_size
);
2347 process_program_headers ();
2355 process_section_headers ();
2357 process_dynamic_segment ();
2359 process_symbol_table ();
2361 process_section_contents ();
2363 munmap (header
, statbuf
.st_size
);
2375 free (elf_sections
);
2376 elf_sections
= NULL
;
2381 #ifdef SUPPORT_DISASSEMBLY
2382 /* Needed by the i386 disassembler. For extra credit, someone could
2383 fix this so that we insert symbolic addresses here, esp for GOT/PLT
2387 print_address (unsigned int addr
, FILE * outfile
)
2389 fprintf (outfile
,"0x%8.8x", addr
);
2392 /* Needed by the i386 disassembler. */
2394 db_task_printsym (unsigned int addr
)
2396 print_address (addr
, stderr
);
2405 parse_args (argc
, argv
);
2407 expected_endian
= 0x12345678;
2409 if (* ((char *) & expected_endian
) == 0x12)
2410 expected_endian
= ELFDATA2MSB
;
2412 expected_endian
= ELFDATA2LSB
;
2414 if (optind
< (argc
- 1))
2417 while (optind
< argc
)
2418 process_file (argv
[optind
++]);