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
31 #include "elf/common.h"
35 #include "elf/external.h"
36 #include "elf/internal.h"
41 #ifdef ANSI_PROTOTYPES
47 char * program_name
= "readelf";
48 unsigned int dynamic_addr
;
49 unsigned int dynamic_size
;
50 unsigned int rela_addr
;
51 unsigned int rela_size
;
52 char * dynamic_strings
;
54 Elf_Internal_Sym
* dynamic_symbols
;
55 char program_interpreter
[64];
56 int dynamic_info
[DT_JMPREL
+ 1];
57 int version_info
[16];
59 Elf_Internal_Ehdr elf_header
;
60 Elf_Internal_Shdr
* section_headers
;
61 Elf_Internal_Dyn
* dynamic_segment
;
73 static unsigned long int (* byte_get
) PARAMS ((unsigned char *, int));
75 #define NUM_DUMP_SECTS 100
76 char dump_sects
[NUM_DUMP_SECTS
];
81 /* Forward declarations for dumb compilers. */
82 static const char * get_mips_dynamic_type
PARAMS ((unsigned long type
));
83 static const char * get_dynamic_type
PARAMS ((unsigned long type
));
84 static char * get_i386_rel_type
PARAMS ((unsigned long rtype
));
85 static char * get_m68k_rel_type
PARAMS ((unsigned long rtype
));
86 static char * get_sparc_rel_type
PARAMS ((unsigned long rtype
));
87 static char * get_m32r_rel_type
PARAMS ((unsigned long rtype
));
88 static char * get_v850_rel_type
PARAMS ((unsigned long rtype
));
89 static char * get_d10v_rel_type
PARAMS ((unsigned long rtype
));
90 /* start-sanitize-d30v */
91 static char * get_d30v_rel_type
PARAMS ((unsigned long rtype
));
92 /* end-sanitize-d30v */
93 static char * get_sh_rel_type
PARAMS ((unsigned long rtype
));
94 static char * get_mn10300_rel_type
PARAMS ((unsigned long rtype
));
95 static char * get_mn10200_rel_type
PARAMS ((unsigned long rtype
));
96 static char * get_ppc_rel_type
PARAMS ((unsigned long rtype
));
97 static int dump_relocations
98 PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, char *));
99 static char * get_file_type
PARAMS ((unsigned e_type
));
100 static char * get_machine_name
PARAMS ((unsigned e_machine
));
101 static char * get_machine_data
PARAMS ((unsigned e_data
));
102 static char * get_machine_flags
PARAMS ((unsigned, unsigned e_machine
));
103 static const char * get_mips_segment_type
PARAMS ((unsigned long type
));
104 static const char * get_segment_type
PARAMS ((unsigned long p_type
));
105 static char * get_section_type_name
PARAMS ((unsigned int sh_type
));
106 static char * get_symbol_binding
PARAMS ((unsigned int binding
));
107 static char * get_symbol_type
PARAMS ((unsigned int type
));
108 static void usage
PARAMS ((void));
109 static void parse_args
PARAMS ((int argc
, char ** argv
));
110 static int process_file_header
PARAMS ((void));
111 static int process_program_headers
PARAMS ((FILE *));
112 static int process_section_headers
PARAMS ((FILE *));
113 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*entry
));
114 static int process_dynamic_segment
PARAMS ((FILE *));
115 static int process_symbol_table
PARAMS ((FILE *));
116 static int process_section_contents
PARAMS ((FILE *));
117 static void process_file
PARAMS ((char * file_name
));
118 static int process_relocs
PARAMS ((FILE *));
119 static int process_version_sections
PARAMS ((FILE *));
120 static char * get_ver_flags
PARAMS ((unsigned int flags
));
121 static char * get_symbol_index_type
PARAMS ((unsigned int type
));
122 static int get_section_headers
PARAMS ((FILE * file
));
123 static int get_file_header
PARAMS ((FILE * file
));
124 static Elf_Internal_Sym
* get_elf_symbols
125 PARAMS ((FILE * file
, unsigned long offset
, unsigned long number
));
126 static int * get_dynamic_data
PARAMS ((FILE * file
, unsigned int number
));
128 typedef int Elf32_Word
;
130 #define SECTION_NAME(X) (string_table + (X)->sh_name)
132 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
134 #define BYTE_GET(field) byte_get (field, sizeof (field))
136 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
138 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
139 if (fseek (file, offset, SEEK_SET)) \
141 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
145 var = (type) malloc (size); \
149 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
153 if (fread (var, size, 1, file) != 1) \
155 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
162 #define GET_DATA(offset, var, reason) \
163 if (fseek (file, offset, SEEK_SET)) \
165 error (_("Unable to seek to %x for %s\n"), offset, reason); \
168 else if (fread (& var, sizeof (var), 1, file) != 1) \
170 error (_("Unable to read data at %x for %s\n"), offset, reason); \
174 #ifdef ANSI_PROTOTYPES
176 error (const char * message
, ...)
180 fprintf (stderr
, _("%s: Error: "), program_name
);
181 va_start (args
, message
);
182 vfprintf (stderr
, message
, args
);
188 warn (const char * message
, ...)
192 fprintf (stderr
, _("%s: Warning: "), program_name
);
193 va_start (args
, message
);
194 vfprintf (stderr
, message
, args
);
206 fprintf (stderr
, _("%s: Error: "), program_name
);
208 message
= va_arg (args
, char *);
209 vfprintf (stderr
, message
, args
);
221 fprintf (stderr
, _("%s: Warning: "), program_name
);
223 message
= va_arg (args
, char *);
224 vfprintf (stderr
, message
, args
);
230 static unsigned long int
231 byte_get_little_endian (field
, size
)
232 unsigned char * field
;
241 return ((unsigned int) (field
[0]))
242 | (((unsigned int) (field
[1])) << 8);
245 return ((unsigned long) (field
[0]))
246 | (((unsigned long) (field
[1])) << 8)
247 | (((unsigned long) (field
[2])) << 16)
248 | (((unsigned long) (field
[3])) << 24);
251 error (_("Unhandled data length: %d\n"), size
);
256 static unsigned long int
257 byte_get_big_endian (field
, size
)
258 unsigned char * field
;
267 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
270 return ((unsigned long) (field
[3]))
271 | (((unsigned long) (field
[2])) << 8)
272 | (((unsigned long) (field
[1])) << 16)
273 | (((unsigned long) (field
[0])) << 24);
276 error (_("Unhandled data length: %d\n"), size
);
282 get_i386_rel_type (rtype
)
287 case 0: return "R_386_NONE";
288 case 1: return "R_386_32";
289 case 2: return "R_386_PC32";
290 case 3: return "R_386_GOT32";
291 case 4: return "R_386_PLT32";
292 case 5: return "R_386_COPY";
293 case 6: return "R_386_GLOB_DAT";
294 case 7: return "R_386_JMP_SLOT";
295 case 8: return "R_386_RELATIVE";
296 case 9: return "R_386_GOTOFF";
297 case 10: return "R_386_GOTPC";
298 case 20: return "R_386_16";
299 case 21: return "R_386_PC16";
300 case 22: return "R_386_PC8";
301 case 23: return "R_386_max";
302 default: return _("*INVALID*");
307 get_m68k_rel_type (rtype
)
312 case 0: return "R_68K_NONE";
313 case 1: return "R_68K_32";
314 case 2: return "R_68K_16";
315 case 3: return "R_68K_8";
316 case 4: return "R_68K_PC32";
317 case 5: return "R_68K_PC16";
318 case 6: return "R_68K_PC8";
319 case 7: return "R_68K_GOT32";
320 case 8: return "R_68K_GOT16";
321 case 9: return "R_68K_GOT8";
322 case 10: return "R_68K_GOT32O";
323 case 11: return "R_68K_GOT16O";
324 case 12: return "R_68K_GOT8O";
325 case 13: return "R_68K_PLT32";
326 case 14: return "R_68K_PLT16";
327 case 15: return "R_68K_PLT8";
328 case 16: return "R_68K_PLT32O";
329 case 17: return "R_68K_PLT16O";
330 case 18: return "R_68K_PLT8O";
331 case 19: return "R_68K_COPY";
332 case 20: return "R_68K_GLOB_DAT";
333 case 21: return "R_68K_JMP_SLOT";
334 case 22: return "R_68K_RELATIVE";
335 default: return _("*INVALID*");
341 get_sparc_rel_type (rtype
)
346 case 0: return "R_SPARC_NONE";
347 case 1: return "R_SPARC_8";
348 case 2: return "R_SPARC_16";
349 case 3: return "R_SPARC_32";
350 case 4: return "R_SPARC_DISP8";
351 case 5: return "R_SPARC_DISP16";
352 case 6: return "R_SPARC_DISP32";
353 case 7: return "R_SPARC_WDISP30";
354 case 8: return "R_SPARC_WDISP22";
355 case 9: return "R_SPARC_HI22";
356 case 10: return "R_SPARC_22";
357 case 11: return "R_SPARC_13";
358 case 12: return "R_SPARC_LO10";
359 case 13: return "R_SPARC_GOT10";
360 case 14: return "R_SPARC_GOT13";
361 case 15: return "R_SPARC_GOT22";
362 case 16: return "R_SPARC_PC10";
363 case 17: return "R_SPARC_PC22";
364 case 18: return "R_SPARC_WPLT30";
365 case 19: return "R_SPARC_COPY";
366 case 20: return "R_SPARC_GLOB_DAT";
367 case 21: return "R_SPARC_JMP_SLOT";
368 case 22: return "R_SPARC_RELATIVE";
369 case 23: return "R_SPARC_UA32";
370 case 24: return "R_SPARC_10";
371 case 25: return "R_SPARC_11";
372 case 26: return "R_SPARC_64";
373 case 27: return "R_SPARC_OLO10";
374 case 28: return "R_SPARC_HH22";
375 case 29: return "R_SPARC_HM10";
376 case 30: return "R_SPARC_LM22";
377 case 31: return "R_SPARC_PC_HH22";
378 case 32: return "R_SPARC_PC_HM10";
379 case 33: return "R_SPARC_PC_LM22";
380 case 34: return "R_SPARC_WDISP16";
381 case 35: return "R_SPARC_WDISP19";
382 case 36: return "R_SPARC_UNUSED_42";
383 case 37: return "R_SPARC_7";
384 case 38: return "R_SPARC_5";
385 case 39: return "R_SPARC_6";
386 case 40: return "R_SPARC_DISP64";
387 case 41: return "R_SPARC_PLT64";
388 case 42: return "R_SPARC_HIX22";
389 case 43: return "R_SPARC_LOX10";
390 case 44: return "R_SPARC_H44";
391 case 45: return "R_SPARC_M44";
392 case 46: return "R_SPARC_L44";
393 case 47: return "R_SPARC_REGISTER";
394 case 48: return "R_SPARC_UA64";
395 case 49: return "R_SPARC_UA16";
396 case 50: return "R_SPARC_32LE";
397 default: return _("*INVALID*");
403 get_m32r_rel_type (rtype
)
408 case 0: return "R_M32R_NONE";
409 case 1: return "R_M32R_16";
410 case 2: return "R_M32R_32";
411 case 3: return "R_M32R_24";
412 case 4: return "R_M32R_10_PCREL";
413 case 5: return "R_M32R_18_PCREL";
414 case 6: return "R_M32R_26_PCREL";
415 case 7: return "R_M32R_HI16_ULO";
416 case 8: return "R_M32R_HI16_SLO";
417 case 9: return "R_M32R_LO16";
418 case 10: return "R_M32R_SDA16";
419 default: return _("*INVALID*");
425 get_v850_rel_type (rtype
)
430 case 0: return "R_V850_NONE";
431 case 1: return "R_V850_9_PCREL";
432 case 2: return "R_V850_22_PCREL";
433 case 3: return "R_V850_HI16_S";
434 case 4: return "R_V850_HI16";
435 case 5: return "R_V850_LO16";
436 case 6: return "R_V850_32";
437 case 7: return "R_V850_16";
438 case 8: return "R_V850_8";
439 case 9: return "R_V850_SDA_16_16_OFFSET";
440 case 10: return "R_V850_SDA_15_16_OFFSET";
441 case 11: return "R_V850_ZDA_16_16_OFFSET";
442 case 12: return "R_V850_ZDA_15_16_OFFSET";
443 case 13: return "R_V850_TDA_6_8_OFFSET";
444 case 14: return "R_V850_TDA_7_8_OFFSET";
445 case 15: return "R_V850_TDA_7_7_OFFSET";
446 case 16: return "R_V850_TDA_16_16_OFFSET";
447 /* start-sanitize-v850e */
448 case 17: return "R_V850_TDA_4_5_OFFSET";
449 case 18: return "R_V850_TDA_4_4_OFFSET";
450 case 19: return "R_V850_SDA_16_16_SPLIT_OFFSET";
451 case 20: return "R_V850_ZDA_16_16_SPLIT_OFFSET";
452 case 21: return "R_V850_CALLT_6_7_OFFSET";
453 case 22: return "R_V850_CALLT_16_16_OFFSET";
454 /* end-sanitize-v850e */
455 default: return _("*INVALID*");
461 get_d10v_rel_type (rtype
)
466 case 0: return "R_D10V_NONE";
467 case 1: return "R_D10V_10_PCREL_R";
468 case 2: return "R_D10V_10_PCREL_L";
469 case 3: return "R_D10V_16";
470 case 4: return "R_D10V_18";
471 case 5: return "R_D10V_18_PCREL";
472 case 6: return "R_D10V_32";
473 default: return _("*INVALID*");
477 /* start-sanitize-d30v */
479 get_d30v_rel_type (rtype
)
484 case 0: return "R_D30V_NONE";
485 case 1: return "R_D30V_6";
486 case 2: return "R_D30V_9_PCREL";
487 case 3: return "R_D30V_9_PCREL_R";
488 case 4: return "R_D30V_15";
489 case 5: return "R_D30V_15_PCREL";
490 case 6: return "R_D30V_15_PCREL_R";
491 case 7: return "R_D30V_21";
492 case 8: return "R_D30V_21_PCREL";
493 case 9: return "R_D30V_21_PCREL_R";
494 case 10: return "R_D30V_32";
495 case 11: return "R_D30V_32_PCREL";
496 case 12: return "R_D30V_32_NORMAL";
497 default: return _("*INVALID*");
501 /* end-sanitize-d30v */
503 get_sh_rel_type (rtype
)
508 case 0: return "R_SH_NONE";
509 case 1: return "R_SH_DIR32";
510 case 2: return "R_SH_REL32";
511 case 3: return "R_SH_DIR8WPN";
512 case 4: return "R_SH_IND12W";
513 case 5: return "R_SH_DIR8WPL";
514 case 6: return "R_SH_DIR8WPZ";
515 case 7: return "R_SH_DIR8BP";
516 case 8: return "R_SH_DIR8W";
517 case 9: return "R_SH_DIR8L";
518 case 25: return "R_SH_SWITCH16";
519 case 26: return "R_SH_SWITCH32";
520 case 27: return "R_SH_USES";
521 case 28: return "R_SH_COUNT";
522 case 29: return "R_SH_ALIGN";
523 case 30: return "R_SH_CODE";
524 case 31: return "R_SH_DATA";
525 case 32: return "R_SH_LABEL";
526 default: return _("*INVALID*");
532 get_mn10300_rel_type (rtype
)
537 case 0: return "R_MN10300_NONE";
538 case 1: return "R_MN10300_32";
539 case 2: return "R_MN10300_16";
540 case 3: return "R_MN10300_8";
541 case 4: return "R_MN10300_PCREL32";
542 case 5: return "R_MN10300_PCREL16";
543 case 6: return "R_MN10300_PCREL8";
544 default: return _("*INVALID*");
550 get_mn10200_rel_type (rtype
)
555 case 0: return "R_MN10200_NONE";
556 case 1: return "R_MN10200_32";
557 case 2: return "R_MN10200_16";
558 case 3: return "R_MN10200_8";
559 case 4: return "R_MN10200_24";
560 case 5: return "R_MN10200_PCREL8";
561 case 6: return "R_MN10200_PCREL16";
562 case 7: return "R_MN10200_PCREL24";
563 default: return _("*INVALID*");
569 get_ppc_rel_type (rtype
)
574 case 0: return "R_PPC_NONE,";
575 case 1: return "R_PPC_ADDR32,";
576 case 2: return "R_PPC_ADDR24,";
577 case 3: return "R_PPC_ADDR16,";
578 case 4: return "R_PPC_ADDR16_LO,";
579 case 5: return "R_PPC_ADDR16_HI,";
580 case 6: return "R_PPC_ADDR16_HA,";
581 case 7: return "R_PPC_ADDR14,";
582 case 8: return "R_PPC_ADDR14_BRTAKEN,";
583 case 9: return "R_PPC_ADDR14_BRNTAKEN,";
584 case 10: return "R_PPC_REL24,";
585 case 11: return "R_PPC_REL14,";
586 case 12: return "R_PPC_REL14_BRTAKEN,";
587 case 13: return "R_PPC_REL14_BRNTAKEN,";
588 case 14: return "R_PPC_GOT16,";
589 case 15: return "R_PPC_GOT16_LO,";
590 case 16: return "R_PPC_GOT16_HI,";
591 case 17: return "R_PPC_GOT16_HA,";
592 case 18: return "R_PPC_PLT24,";
593 case 19: return "R_PPC_COPY,";
594 case 21: return "R_PPC_JMP_SLOT,";
595 case 22: return "R_PPC_RELATIVE,";
596 case 23: return "R_PPC_LOCAL24PC,";
597 case 24: return "R_PPC_UADDR32,";
598 case 25: return "R_PPC_UADDR16,";
599 case 26: return "R_PPC_REL32,";
600 case 27: return "R_PPC_PLT32,";
601 case 28: return "R_PPC_PLTREL32,";
602 case 29: return "R_PPC_PLT16_LO,";
603 case 30: return "R_PPC_PLT16_HI,";
604 case 31: return "R_PPC_PLT16_HA,";
605 case 32: return "R_PPC_SDAREL,";
606 case 33: return "R_PPC_SECTOFF,";
607 case 34: return "R_PPC_SECTOFF_LO,";
608 case 35: return "R_PPC_SECTOFF_HI,";
609 case 36: return "R_PPC_SECTOFF_HA,";
610 case 101: return "R_PPC_EMB_NADDR32,";
611 case 102: return "R_PPC_EMB_NADDR16,";
612 case 103: return "R_PPC_EMB_NADDR16_LO,";
613 case 104: return "R_PPC_EMB_NADDR16_HI,";
614 case 105: return "R_PPC_EMB_NADDR16_HA,";
615 case 106: return "R_PPC_EMB_SDAI16,";
616 case 107: return "R_PPC_EMB_SDA2I16,";
617 case 108: return "R_PPC_EMB_SDA2REL,";
618 case 109: return "R_PPC_EMB_SDA21,";
619 case 110: return "R_PPC_EMB_MRKREF,";
620 case 111: return "R_PPC_EMB_RELSEC16,";
621 case 112: return "R_PPC_EMB_RELST_LO,";
622 case 113: return "R_PPC_EMB_RELST_HI,";
623 case 114: return "R_PPC_EMB_RELST_HA,";
624 case 115: return "R_PPC_EMB_BIT_FLD,";
625 case 116: return "R_PPC_EMB_RELSDA,";
626 default: return _("*INVALID*");
631 /* Display the contents of the relocation data
632 found at the specified offset. */
634 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
)
636 unsigned long rel_offset
;
637 unsigned long rel_size
;
638 Elf_Internal_Sym
* symtab
;
643 Elf_Internal_Rel
* rels
;
644 Elf_Internal_Rela
* relas
;
647 /* Compute number of relocations and read them in. */
648 switch (elf_header
.e_machine
)
655 Elf32_External_Rel
* erels
;
657 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
658 Elf32_External_Rel
*, "relocs");
660 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
662 rels
= (Elf_Internal_Rel
*) malloc (rel_size
*
663 sizeof (Elf_Internal_Rel
));
665 for (i
= 0; i
< rel_size
; i
++)
667 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
668 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
674 relas
= (Elf_Internal_Rela
*) rels
;
682 /* start-sanitize-d30v */
684 /* end-sanitize-d30v */
685 case EM_CYGNUS_MN10200
:
686 case EM_CYGNUS_MN10300
:
689 Elf32_External_Rela
* erelas
;
691 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
692 Elf32_External_Rela
*, "relocs");
694 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
696 relas
= (Elf_Internal_Rela
*) malloc (rel_size
*
697 sizeof (Elf_Internal_Rela
));
699 for (i
= 0; i
< rel_size
; i
++)
701 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
702 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
703 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
709 rels
= (Elf_Internal_Rel
*) relas
;
714 warn (_("Don't know about relocations on this machine architecture\n"));
720 (_(" Offset Value Type Symbol's Value Symbol's Name Addend\n"));
723 (_(" Offset Value Type Symbol's Value Symbol's Name\n"));
725 for (i
= 0; i
< rel_size
; i
++)
728 unsigned long offset
;
734 offset
= relas
[i
].r_offset
;
735 info
= relas
[i
].r_info
;
739 offset
= rels
[i
].r_offset
;
740 info
= rels
[i
].r_info
;
743 printf (" %8.8lx %5.5lx ", offset
, info
);
745 switch (elf_header
.e_machine
)
752 rtype
= get_m32r_rel_type (ELF32_R_TYPE (info
));
757 rtype
= get_i386_rel_type (ELF32_R_TYPE (info
));
761 rtype
= get_m68k_rel_type (ELF32_R_TYPE (info
));
765 rtype
= get_sparc_rel_type (ELF32_R_TYPE (info
));
769 rtype
= get_v850_rel_type (ELF32_R_TYPE (info
));
773 rtype
= get_d10v_rel_type (ELF32_R_TYPE (info
));
776 /* start-sanitize-d30v */
778 rtype
= get_d30v_rel_type (ELF32_R_TYPE (info
));
781 /* end-sanitize-d30v */
783 rtype
= get_sh_rel_type (ELF32_R_TYPE (info
));
786 case EM_CYGNUS_MN10300
:
787 rtype
= get_mn10300_rel_type (ELF32_R_TYPE (info
));
790 case EM_CYGNUS_MN10200
:
791 rtype
= get_mn10200_rel_type (ELF32_R_TYPE (info
));
795 rtype
= get_ppc_rel_type (ELF32_R_TYPE (info
));
799 printf ("%-21.21s", rtype
);
801 symtab_index
= ELF32_R_SYM (info
);
803 if (symtab_index
&& symtab
!= NULL
)
805 Elf_Internal_Sym
* psym
;
807 psym
= symtab
+ symtab_index
;
809 printf (" %08lx ", (unsigned long) psym
->st_value
);
811 if (psym
->st_name
== 0)
813 SECTION_NAME (section_headers
+ psym
->st_shndx
));
814 else if (strtab
== NULL
)
815 printf (_("<string table index %d>"), psym
->st_name
);
817 printf ("%-17.17s", strtab
+ psym
->st_name
);
820 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
832 get_mips_dynamic_type (type
)
837 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
838 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
839 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
840 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
841 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
842 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
843 case DT_MIPS_MSYM
: return "MIPS_MSYM";
844 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
845 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
846 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
847 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
848 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
849 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
850 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
851 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
852 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
853 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
854 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
855 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
856 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
857 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
858 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
859 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
860 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
861 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
862 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
863 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
864 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
865 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
866 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
867 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
868 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
869 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
870 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
871 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
872 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
873 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
874 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
875 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
876 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
877 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
878 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
879 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
886 get_dynamic_type (type
)
889 static char buff
[32];
893 case DT_NULL
: return _("NULL");
894 case DT_NEEDED
: return _("NEEDED");
895 case DT_PLTRELSZ
: return _("PLTRELSZ");
896 case DT_PLTGOT
: return _("PLTGOT");
897 case DT_HASH
: return _("HASH");
898 case DT_STRTAB
: return _("STRTAB");
899 case DT_SYMTAB
: return _("SYMTAB");
900 case DT_RELA
: return _("RELA");
901 case DT_RELASZ
: return _("RELASZ");
902 case DT_RELAENT
: return _("RELAENT");
903 case DT_STRSZ
: return _("STRSZ");
904 case DT_SYMENT
: return _("SYMENT");
905 case DT_INIT
: return _("INIT");
906 case DT_FINI
: return _("FINI");
907 case DT_SONAME
: return _("SONAME");
908 case DT_RPATH
: return _("RPATH");
909 case DT_SYMBOLIC
: return _("SYMBOLIC");
910 case DT_REL
: return _("REL");
911 case DT_RELSZ
: return _("RELSZ");
912 case DT_RELENT
: return _("RELENT");
913 case DT_PLTREL
: return _("PLTREL");
914 case DT_DEBUG
: return _("DEBUG");
915 case DT_TEXTREL
: return _("TEXTREL");
916 case DT_JMPREL
: return _("JMPREL");
917 case DT_VERDEF
: return _("VERDEF");
918 case DT_VERDEFNUM
: return _("VERDEFNUM");
919 case DT_VERNEED
: return _("VERNEED");
920 case DT_VERNEEDNUM
: return _("VERNEEDNUM");
921 case DT_VERSYM
: return _("VERSYN");
922 case DT_AUXILIARY
: return _("AUXILARY");
923 case DT_FILTER
: return _("FILTER");
926 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
928 const char *result
= NULL
;
929 switch (elf_header
.e_machine
)
933 result
= get_mips_dynamic_type (type
);
939 sprintf (buff
, _("Processor Specific: (%x)"), type
);
945 sprintf (buff
, _("<unknown>: %x"), type
);
951 get_file_type (e_type
)
954 static char buff
[32];
958 case ET_NONE
: return _("None");
959 case ET_REL
: return _("Relocatable file");
960 case ET_EXEC
: return _("Executable file");
961 case ET_DYN
: return _("Shared object file");
962 case ET_CORE
: return _("Core file");
965 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
966 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
968 sprintf (buff
, _("<unknown>: %x"), e_type
);
974 get_machine_name (e_machine
)
977 static char buff
[32];
981 case EM_NONE
: return _("None");
982 case EM_M32
: return "WE32100";
983 case EM_SPARC
: return "Sparc";
984 case EM_386
: return "80386";
985 case EM_68K
: return "MC68000";
986 case EM_88K
: return "MC88000";
987 case EM_486
: return "Intel 80486";
988 case EM_860
: return "Intel 80860";
989 case EM_MIPS
: return "MIPS R3000 big-endian";
990 case EM_S370
: return "Amdahl";
991 case EM_MIPS_RS4_BE
: return "MIPS R400 big-endian";
992 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
993 case EM_PARISC
: return "HPPA";
994 case EM_PPC_OLD
: return "Power PC (old)";
995 case EM_SPARC32PLUS
: return "Sparc v8+" ;
996 case EM_960
: return "Intel 90860";
997 case EM_PPC
: return "PowerPC";
998 case EM_V800
: return "NEC V800";
999 case EM_FR20
: return "Fujitsu FR20";
1000 case EM_RH32
: return "TRW RH32";
1001 case EM_MMA
: return "Fujitsu MMA";
1002 case EM_ARM
: return "ARM";
1003 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1004 case EM_SH
: return "Hitachi SH";
1005 case EM_SPARCV9
: return "Sparc v9";
1006 case EM_ALPHA
: return "Alpha";
1007 case EM_CYGNUS_D10V
: return "d10v";
1008 /* start-sanitize-d30v */
1009 case EM_CYGNUS_D30V
: return "d30v";
1010 /* end-sanitize-d30v */
1011 case EM_CYGNUS_M32R
: return "M32r";
1012 case EM_CYGNUS_V850
: return "v850";
1013 case EM_CYGNUS_MN10300
: return "mn10300";
1014 case EM_CYGNUS_MN10200
: return "mn10200";
1017 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1023 get_machine_flags (e_flags
, e_machine
)
1027 static char buf
[1024];
1038 if (e_flags
& EF_PPC_EMB
)
1039 strcat (buf
, ", emb");
1041 if (e_flags
& EF_PPC_RELOCATABLE
)
1042 strcat (buf
, ", relocatable");
1044 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1045 strcat (buf
, ", relocatable-lib");
1048 case EM_CYGNUS_M32R
:
1049 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1050 strcat (buf
, ", m32r");
1052 /* start-sanitize-m32rx */
1054 if ((e_flags
& EF_M32R_ARCH
) == E_M32RX_ARCH
)
1055 strcat (buf
, ", m32rx");
1057 /* end-sanitize-m32rx */
1061 case EM_MIPS_RS4_BE
:
1062 if (e_flags
& EF_MIPS_NOREORDER
)
1063 strcat (buf
, ", noreorder");
1065 if (e_flags
& EF_MIPS_PIC
)
1066 strcat (buf
, ", pic");
1068 if (e_flags
& EF_MIPS_CPIC
)
1069 strcat (buf
, ", cpic");
1071 if (e_flags
& EF_MIPS_ABI2
)
1072 strcat (buf
, ", abi2");
1074 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1075 strcat (buf
, ", mips1");
1077 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1078 strcat (buf
, ", mips2");
1080 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1081 strcat (buf
, ", mips3");
1083 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1084 strcat (buf
, ", mips4");
1093 get_machine_data (e_data
)
1096 static char buff
[32];
1100 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
1101 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
1103 sprintf (buff
, _("<unknown>: %x"), e_data
);
1109 get_mips_segment_type (type
)
1114 case PT_MIPS_REGINFO
:
1115 return "Register Info";
1116 case PT_MIPS_RTPROC
:
1117 return "Runtime Proc Table";
1118 case PT_MIPS_OPTIONS
:
1121 return "Processor Specific";
1126 get_segment_type (p_type
)
1127 unsigned long p_type
;
1129 static char buff
[32];
1133 case PT_NULL
: return _("Unused");
1134 case PT_LOAD
: return _("Loadable");
1135 case PT_DYNAMIC
: return _("Dynamic link info");
1136 case PT_INTERP
: return _("Interpreter");
1137 case PT_NOTE
: return _("Auxillary Info");
1138 case PT_SHLIB
: return _("Shared Library");
1139 case PT_PHDR
: return _("Program Header");
1142 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1143 switch (elf_header
.e_machine
)
1146 case EM_MIPS_RS4_BE
:
1147 return get_mips_segment_type (p_type
);
1149 return "Processor Specific";
1153 sprintf (buff
, _("<unknown>: %x"), p_type
);
1160 get_section_type_name (sh_type
)
1161 unsigned int sh_type
;
1163 static char buff
[32];
1167 case SHT_NULL
: return _("Unused");
1168 case SHT_PROGBITS
: return _("Program data");
1169 case SHT_SYMTAB
: return _("Symbol table");
1170 case SHT_STRTAB
: return _("String table");
1171 case SHT_RELA
: return _("Relocations");
1172 case SHT_HASH
: return _("Symbol hashes");
1173 case SHT_DYNAMIC
: return _("Dynamic info");
1174 case SHT_NOTE
: return _("Notes");
1175 case SHT_NOBITS
: return _("Space, no data");
1176 case SHT_REL
: return _("Relocations");
1177 case SHT_SHLIB
: return _("Shared lib info");
1178 case SHT_DYNSYM
: return _("Dynamic symbols");
1179 case SHT_GNU_verdef
: return _("Version definition");
1180 case SHT_GNU_verneed
: return _("Version needs");
1181 case SHT_GNU_versym
: return _("Version symbols");
1182 case 0x6ffffff0: return "VERSYM";
1183 case 0x6ffffffc: return "VERDEF";
1184 case 0x7ffffffd: return "AUXILIARY";
1185 case 0x7fffffff: return "FILTER";
1188 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1189 sprintf (buff
, _("cpu defined (%d)"), sh_type
- SHT_LOPROC
);
1190 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1191 sprintf (buff
, _("app defined (%d)"), sh_type
- SHT_LOUSER
);
1193 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1198 struct option options
[] =
1200 {"all", no_argument
, 0, 'a'},
1201 {"file-header", no_argument
, 0, 'h'},
1202 {"program-headers", no_argument
, 0, 'l'},
1203 {"headers", no_argument
, 0, 'e'},
1204 {"segments", no_argument
, 0, 'l'},
1205 {"sections", no_argument
, 0, 'S'},
1206 {"section-headers", no_argument
, 0, 'S'},
1207 {"symbols", no_argument
, 0, 's'},
1208 {"relocs", no_argument
, 0, 'r'},
1209 {"dynamic", no_argument
, 0, 'd'},
1210 {"version-info", no_argument
, 0, 'V'},
1211 {"use-dynamic", no_argument
, 0, 'D'},
1213 {"hex-dump", required_argument
, 0, 'x'},
1214 #ifdef SUPPORT_DISASSEMBLY
1215 {"instruction-dump", required_argument
, 0, 'i'},
1218 {"version", no_argument
, 0, 'v'},
1219 {"help", no_argument
, 0, 'H'},
1221 {0, no_argument
, 0, 0}
1227 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1228 fprintf (stdout
, _(" Options are:\n"));
1229 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V\n"));
1230 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1231 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1232 fprintf (stdout
, _(" Display the program headers\n"));
1233 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1234 fprintf (stdout
, _(" Display the sections' header\n"));
1235 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1236 fprintf (stdout
, _(" -s or --symbols Display the symbol table\n"));
1237 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1238 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1239 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1240 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1241 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1242 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1243 #ifdef SUPPORT_DISASSEMBLY
1244 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1245 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1247 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1248 fprintf (stdout
, _(" -H or --help Display this information\n"));
1249 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1255 parse_args (argc
, argv
)
1264 while ((c
= getopt_long
1265 (argc
, argv
, "ersahldSDx:i:vV", options
, NULL
)) != EOF
)
1291 do_using_dynamic
++;
1313 section
= strtoul (optarg
, & cp
, 0);
1314 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1316 dump_sects
[section
] |= HEX_DUMP
;
1320 #ifdef SUPPORT_DISASSEMBLY
1323 section
= strtoul (optarg
, & cp
, 0);
1324 if (! * cp
&& section
>= 0 && section
< NUM_DUMP_SECTS
)
1326 dump_sects
[section
] |= DISASS_DUMP
;
1332 print_version (program_name
);
1339 /* xgettext:c-format */
1340 error (_("Invalid option '-%c'\n"), c
);
1347 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1348 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
)
1352 warn (_("Nothing to do.\n"));
1357 /* Decode the data held in 'elf_header'. */
1359 process_file_header ()
1361 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1362 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1363 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1364 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1367 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1371 if (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS32
)
1373 error (_("Not a 32 bit ELF file\n"));
1381 printf (_("ELF Header:\n"));
1382 printf (_(" Magic: "));
1383 for (i
= 0; i
< EI_NIDENT
; i
++)
1384 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1386 printf (_(" Type: %s\n"),
1387 get_file_type (elf_header
.e_type
));
1388 printf (_(" Machine: %s\n"),
1389 get_machine_name (elf_header
.e_machine
));
1390 printf (_(" Version: 0x%lx\n"),
1391 (unsigned long) elf_header
.e_version
);
1392 printf (_(" Data: %s\n"),
1393 get_machine_data (elf_header
.e_ident
[EI_DATA
]));
1394 printf (_(" Entry point address: 0x%lx\n"),
1395 (unsigned long) elf_header
.e_entry
);
1396 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1397 (long) elf_header
.e_phoff
);
1398 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1399 (long) elf_header
.e_shoff
);
1400 printf (_(" Flags: 0x%lx%s\n"),
1401 (unsigned long) elf_header
.e_flags
,
1402 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1403 printf (_(" Size of this header: %ld (bytes)\n"),
1404 (long) elf_header
.e_ehsize
);
1405 printf (_(" Size of program headers: %ld (bytes)\n"),
1406 (long) elf_header
.e_phentsize
);
1407 printf (_(" Number of program headers: %ld\n"),
1408 (long) elf_header
.e_phnum
);
1409 printf (_(" Size of section headers: %ld (bytes)\n"),
1410 (long) elf_header
.e_shentsize
);
1411 printf (_(" Number of section headers: %ld\n"),
1412 (long) elf_header
.e_shnum
);
1413 printf (_(" Section header string table index: %ld\n"),
1414 (long) elf_header
.e_shstrndx
);
1422 process_program_headers (file
)
1425 Elf32_External_Phdr
* phdrs
;
1426 Elf32_Internal_Phdr
* program_headers
;
1427 Elf32_Internal_Phdr
* segment
;
1430 if (elf_header
.e_phnum
== 0)
1433 printf (_("\nThere are no program headers in this file.\n"));
1437 if (do_segments
&& !do_header
)
1439 printf (_("\nElf file is %s\n"), get_file_type (elf_header
.e_type
));
1440 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header
.e_entry
);
1441 printf (_("There are %d program headers, starting at offset %lx:\n"),
1442 elf_header
.e_phnum
, (unsigned long) elf_header
.e_phoff
);
1445 GET_DATA_ALLOC (elf_header
.e_phoff
,
1446 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1447 phdrs
, Elf32_External_Phdr
*, "program headers");
1449 program_headers
= (Elf32_Internal_Phdr
*) malloc
1450 (elf_header
.e_phnum
* sizeof (Elf32_Internal_Phdr
));
1452 if (program_headers
== NULL
)
1454 error (_("Out of memory\n"));
1458 for (i
= 0, segment
= program_headers
;
1459 i
< elf_header
.e_phnum
;
1462 segment
->p_type
= BYTE_GET (phdrs
[i
].p_type
);
1463 segment
->p_offset
= BYTE_GET (phdrs
[i
].p_offset
);
1464 segment
->p_vaddr
= BYTE_GET (phdrs
[i
].p_vaddr
);
1465 segment
->p_paddr
= BYTE_GET (phdrs
[i
].p_paddr
);
1466 segment
->p_filesz
= BYTE_GET (phdrs
[i
].p_filesz
);
1467 segment
->p_memsz
= BYTE_GET (phdrs
[i
].p_memsz
);
1468 segment
->p_flags
= BYTE_GET (phdrs
[i
].p_flags
);
1469 segment
->p_align
= BYTE_GET (phdrs
[i
].p_align
);
1477 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
1479 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1485 for (i
= 0, segment
= program_headers
;
1486 i
< elf_header
.e_phnum
;
1491 printf (" %-16.16s ", get_segment_type (segment
->p_type
));
1492 printf ("0x%5.5lx ", (unsigned long) segment
->p_offset
);
1493 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
1494 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
1495 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
1496 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
1498 (segment
->p_flags
& PF_R
? 'R' : ' '),
1499 (segment
->p_flags
& PF_W
? 'W' : ' '),
1500 (segment
->p_flags
& PF_X
? 'E' : ' '));
1501 printf ("%#lx", (unsigned long) segment
->p_align
);
1504 switch (segment
->p_type
)
1508 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
1509 - (segment
->p_offset
& 0xfffff000);
1514 error (_("more than one dynamic segment\n"));
1516 dynamic_addr
= segment
->p_offset
;
1517 dynamic_size
= segment
->p_filesz
;
1521 if (fseek (file
, segment
->p_offset
, SEEK_SET
))
1522 error (_("Unable to find program interpreter name\n"));
1525 program_interpreter
[0] = 0;
1526 fscanf (file
, "%63s", program_interpreter
);
1529 printf (_("\n [Requesting program interpreter: %s]"),
1530 program_interpreter
);
1536 putc ('\n', stdout
);
1545 if (do_segments
&& section_headers
!= NULL
)
1547 printf (_("\n Section to Segment mapping:\n"));
1548 printf (_(" Segment Sections...\n"));
1550 assert (string_table
!= NULL
);
1552 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
1555 Elf32_Internal_Shdr
* section
;
1557 segment
= program_headers
+ i
;
1558 section
= section_headers
;
1560 printf (" %2.2d ", i
);
1562 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
1564 if (section
->sh_size
> 0
1565 /* Compare allocated sections by VMA, unallocated
1566 sections by file offset. */
1567 && (section
->sh_flags
& SHF_ALLOC
1568 ? (section
->sh_addr
>= segment
->p_vaddr
1569 && section
->sh_addr
+ section
->sh_size
1570 <= segment
->p_vaddr
+ segment
->p_memsz
)
1571 : (section
->sh_offset
>= segment
->p_offset
1572 && (section
->sh_offset
+ section
->sh_size
1573 <= segment
->p_offset
+ segment
->p_filesz
))))
1574 printf ("%s ", SECTION_NAME (section
));
1581 free (program_headers
);
1588 get_section_headers (file
)
1591 Elf32_External_Shdr
* shdrs
;
1592 Elf32_Internal_Shdr
* internal
;
1595 GET_DATA_ALLOC (elf_header
.e_shoff
,
1596 elf_header
.e_shentsize
* elf_header
.e_shnum
,
1597 shdrs
, Elf32_External_Shdr
*, "section headers");
1599 section_headers
= (Elf32_Internal_Shdr
*) malloc
1600 (elf_header
.e_shnum
* sizeof (Elf32_Internal_Shdr
));
1602 if (section_headers
== NULL
)
1604 error (_("Out of memory\n"));
1608 for (i
= 0, internal
= section_headers
;
1609 i
< elf_header
.e_shnum
;
1612 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
1613 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
1614 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
1615 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
1616 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
1617 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
1618 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
1619 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
1620 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
1621 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
1629 static Elf_Internal_Sym
*
1630 get_elf_symbols (file
, offset
, number
)
1632 unsigned long offset
;
1633 unsigned long number
;
1635 Elf32_External_Sym
* esyms
;
1636 Elf_Internal_Sym
* isyms
;
1637 Elf_Internal_Sym
* psym
;
1640 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
1641 esyms
, Elf32_External_Sym
*, "symbols");
1643 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
1647 error (_("Out of memory\n"));
1653 for (j
= 0, psym
= isyms
;
1657 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
1658 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
1659 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
1660 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
1661 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
1662 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
1671 process_section_headers (file
)
1674 Elf32_Internal_Shdr
* section
;
1677 section_headers
= NULL
;
1679 if (elf_header
.e_shnum
== 0)
1682 printf (_("\nThere are no sections in this file.\n"));
1687 if (do_sections
&& !do_header
)
1688 printf (_("There are %d section headers, starting at offset %x:\n"),
1689 elf_header
.e_shnum
, elf_header
.e_shoff
);
1691 if (! get_section_headers (file
))
1694 /* Read in the string table, so that we have names to display. */
1695 section
= section_headers
+ elf_header
.e_shstrndx
;
1697 if (section
->sh_size
!= 0)
1699 unsigned long string_table_offset
;
1701 string_table_offset
= section
->sh_offset
;
1703 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1704 string_table
, char *, "string table");
1707 /* Scan the sections for the dynamic symbol table
1708 and dynamic string table. */
1709 dynamic_symbols
= NULL
;
1710 dynamic_strings
= NULL
;
1711 for (i
= 0, section
= section_headers
;
1712 i
< elf_header
.e_shnum
;
1715 if (section
->sh_type
== SHT_DYNSYM
)
1717 if (dynamic_symbols
!= NULL
)
1719 error (_("File contains multiple dynamic symbol tables\n"));
1723 dynamic_symbols
= get_elf_symbols
1724 (file
, section
->sh_offset
, section
->sh_size
/ section
->sh_entsize
);
1726 else if (section
->sh_type
== SHT_STRTAB
1727 && strcmp (SECTION_NAME (section
), ".dynstr") == 0)
1729 if (dynamic_strings
!= NULL
)
1731 error (_("File contains multiple dynamic string tables\n"));
1735 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1736 dynamic_strings
, char *, "dynamic strings");
1743 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
1745 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1747 for (i
= 0, section
= section_headers
;
1748 i
< elf_header
.e_shnum
;
1751 printf (" [%2d] %-17.17s %-15.15s ",
1753 SECTION_NAME (section
),
1754 get_section_type_name (section
->sh_type
));
1756 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
1757 (unsigned long) section
->sh_addr
,
1758 (unsigned long) section
->sh_offset
,
1759 (unsigned long) section
->sh_size
,
1760 (unsigned long) section
->sh_entsize
);
1762 printf (" %c%c%c %2ld %3lx %ld \n",
1763 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
1764 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
1765 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
1766 (unsigned long) section
->sh_link
,
1767 (unsigned long) section
->sh_info
,
1768 (unsigned long) section
->sh_addralign
);
1774 /* Process the reloc section. */
1776 process_relocs (file
)
1779 unsigned long rel_size
;
1780 unsigned long rel_offset
;
1786 if (do_using_dynamic
)
1791 if (dynamic_info
[DT_REL
])
1793 rel_offset
= dynamic_info
[DT_REL
];
1794 rel_size
= dynamic_info
[DT_RELSZ
];
1796 else if (dynamic_info
[DT_RELA
])
1798 rel_offset
= dynamic_info
[DT_RELA
];
1799 rel_size
= dynamic_info
[DT_RELASZ
];
1801 else if (dynamic_info
[DT_JMPREL
])
1803 rel_offset
= dynamic_info
[DT_JMPREL
];
1804 rel_size
= dynamic_info
[DT_PLTRELSZ
];
1810 (_("\nRelocation section at offset 0x%x contains %d bytes:\n"),
1811 rel_offset
, rel_size
);
1813 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
1814 dynamic_symbols
, dynamic_strings
);
1817 printf (_("\nThere are no dynamic relocations in this file.\n"));
1821 Elf32_Internal_Shdr
* section
;
1825 assert (string_table
!= NULL
);
1827 for (i
= 0, section
= section_headers
;
1828 i
< elf_header
.e_shnum
;
1831 if ( section
->sh_type
!= SHT_RELA
1832 && section
->sh_type
!= SHT_REL
)
1835 rel_offset
= section
->sh_offset
;
1836 rel_size
= section
->sh_size
;
1840 Elf32_Internal_Shdr
* strsec
;
1841 Elf32_Internal_Shdr
* symsec
;
1842 Elf_Internal_Sym
* symtab
;
1846 (_("\nRelocation section '%s' at offset 0x%x contains %d entries:\n"),
1847 SECTION_NAME (section
), rel_offset
,
1848 rel_size
/ section
->sh_entsize
);
1850 symsec
= section_headers
+ section
->sh_link
;
1852 symtab
= get_elf_symbols (file
, symsec
->sh_offset
,
1853 symsec
->sh_size
/ symsec
->sh_entsize
);
1858 strsec
= section_headers
+ symsec
->sh_link
;
1860 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
1861 char *, "string table");
1863 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
);
1873 printf (_("\nThere are no relocations in this file.\n"));
1881 dynamic_segment_mips_val (entry
)
1882 Elf_Internal_Dyn
*entry
;
1884 switch (entry
->d_tag
)
1886 case DT_MIPS_LOCAL_GOTNO
:
1887 case DT_MIPS_CONFLICTNO
:
1888 case DT_MIPS_LIBLISTNO
:
1889 case DT_MIPS_SYMTABNO
:
1890 case DT_MIPS_UNREFEXTNO
:
1891 case DT_MIPS_HIPAGENO
:
1892 case DT_MIPS_DELTA_CLASS_NO
:
1893 case DT_MIPS_DELTA_INSTANCE_NO
:
1894 case DT_MIPS_DELTA_RELOC_NO
:
1895 case DT_MIPS_DELTA_SYM_NO
:
1896 case DT_MIPS_DELTA_CLASSSYM_NO
:
1898 printf ("%#ld\n", (long) entry
->d_un
.d_ptr
);
1902 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
1906 /* Parse the dynamic segment */
1908 process_dynamic_segment (file
)
1911 Elf_Internal_Dyn
* entry
;
1912 Elf32_External_Dyn
* edyn
;
1915 if (dynamic_size
== 0)
1918 printf (_("\nThere is no dynamic segment in this file.\n"));
1923 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
1924 edyn
, Elf32_External_Dyn
*, "dynamic segment");
1926 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
1927 how large .dynamic is now. We can do this even before the byte
1928 swapping since the DT_NULL tag is recognizable. */
1930 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
1933 dynamic_segment
= (Elf_Internal_Dyn
*)
1934 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
1936 if (dynamic_segment
== NULL
)
1938 error (_("Out of memory\n"));
1943 for (i
= 0, entry
= dynamic_segment
;
1947 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
1948 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
1953 /* Find the appropriate symbol table. */
1954 if (dynamic_symbols
== NULL
)
1956 for (i
= 0, entry
= dynamic_segment
;
1960 unsigned long offset
;
1963 if (entry
->d_tag
!= DT_SYMTAB
)
1966 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
1968 /* Since we do not know how big the symbol table is,
1969 we default to reading in the entire file (!) and
1970 processing that. This is overkill, I know, but it
1973 offset
= entry
->d_un
.d_val
- loadaddr
;
1975 if (fseek (file
, 0, SEEK_END
))
1976 error (_("Unable to seek to end of file!"));
1978 num_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
1982 error (_("Unable to determine the number of symbols to load\n"));
1986 dynamic_symbols
= get_elf_symbols (file
, offset
, num_syms
);
1990 /* Similarly find a string table. */
1991 if (dynamic_strings
== NULL
)
1993 for (i
= 0, entry
= dynamic_segment
;
1997 unsigned long offset
;
2000 if (entry
->d_tag
!= DT_STRTAB
)
2003 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
2005 /* Since we do not know how big the string table is,
2006 we default to reading in the entire file (!) and
2007 processing that. This is overkill, I know, but it
2010 offset
= entry
->d_un
.d_val
- loadaddr
;
2011 if (fseek (file
, 0, SEEK_END
))
2012 error (_("Unable to seek to end of file\n"));
2013 str_tab_len
= ftell (file
) - offset
;
2015 if (str_tab_len
< 1)
2018 (_("Unable to determine the length of the dynamic string table\n"));
2022 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
2023 "dynamic string table");
2029 if (do_dynamic
&& dynamic_addr
)
2030 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
2031 dynamic_addr
, dynamic_size
);
2033 printf (_(" Tag Type Name/Value\n"));
2035 for (i
= 0, entry
= dynamic_segment
;
2040 printf (_(" 0x%-8.8lx (%s)%*s"),
2041 (unsigned long) entry
->d_tag
,
2042 get_dynamic_type (entry
->d_tag
),
2043 27 - strlen (get_dynamic_type (entry
->d_tag
)),
2046 switch (entry
->d_tag
)
2052 if (entry
->d_tag
== DT_AUXILIARY
)
2053 printf (_("Auxiliary library"));
2055 printf (_("Filter library"));
2057 if (dynamic_strings
)
2058 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
2060 printf (": %#lx\n", (long) entry
->d_un
.d_val
);
2088 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
2094 if (dynamic_strings
== NULL
)
2097 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2101 switch (entry
->d_tag
)
2104 printf (_("Shared library: [%s]"), name
);
2106 if (strcmp (name
, program_interpreter
))
2109 printf (_(" program interpreter\n"));
2113 printf (_("Library soname: [%s]\n"), name
);
2117 printf (_("Library rpath: [%s]\n"), name
);
2121 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2125 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2130 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
2132 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
2136 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2139 switch (elf_header
.e_machine
)
2142 case EM_MIPS_RS4_BE
:
2143 dynamic_segment_mips_val (entry
);
2147 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2157 get_ver_flags (flags
)
2160 static char buff
[32];
2167 if (flags
& VER_FLG_BASE
)
2168 strcat (buff
, "BASE ");
2170 if (flags
& VER_FLG_WEAK
)
2172 if (flags
& VER_FLG_BASE
)
2173 strcat (buff
, "| ");
2175 strcat (buff
, "WEAK ");
2178 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
2179 strcat (buff
, "| <unknown>");
2184 /* Display the contents of the version sections. */
2186 process_version_sections (file
)
2189 Elf32_Internal_Shdr
* section
;
2196 for (i
= 0, section
= section_headers
;
2197 i
< elf_header
.e_shnum
;
2200 switch (section
->sh_type
)
2202 case SHT_GNU_verdef
:
2204 Elf_External_Verdef
* edefs
;
2211 (_("\nVersion definition section '%s' contains %d entries:\n"),
2212 SECTION_NAME (section
), section
->sh_info
);
2214 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2215 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2216 SECTION_NAME (section_headers
+ section
->sh_link
));
2218 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2219 edefs
, Elf_External_Verdef
*,
2220 "version definition section");
2222 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
2225 Elf_External_Verdef
* edef
;
2226 Elf_Internal_Verdef ent
;
2227 Elf_External_Verdaux
* eaux
;
2228 Elf_Internal_Verdaux aux
;
2232 vstart
= ((char *) edefs
) + idx
;
2234 edef
= (Elf_External_Verdef
*) vstart
;
2236 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
2237 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
2238 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
2239 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
2240 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
2241 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
2242 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
2244 printf (_(" %#06x: Rev: %d Flags: %s"),
2245 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
2247 printf (_(" Index: %ld Cnt: %ld "), ent
.vd_ndx
, ent
.vd_cnt
);
2249 vstart
+= ent
.vd_aux
;
2251 eaux
= (Elf_External_Verdaux
*) vstart
;
2253 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2254 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2256 if (dynamic_strings
)
2257 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
2259 printf (_("Name index: %ld\n"), aux
.vda_name
);
2261 isum
= idx
+ ent
.vd_aux
;
2263 for (j
= 1; j
< ent
.vd_cnt
; j
++)
2265 isum
+= aux
.vda_next
;
2266 vstart
+= aux
.vda_next
;
2268 eaux
= (Elf_External_Verdaux
*) vstart
;
2270 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2271 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2273 if (dynamic_strings
)
2274 printf (_(" %#06x: Parent %d: %s\n"),
2275 isum
, j
, dynamic_strings
+ aux
.vda_name
);
2277 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2278 isum
, j
, aux
.vda_name
);
2288 case SHT_GNU_verneed
:
2290 Elf_External_Verneed
* eneed
;
2296 printf (_("\nVersion needs section '%s' contains %d entries:\n"),
2297 SECTION_NAME (section
), section
->sh_info
);
2300 (_(" Addr: %#08x Offset: %#08x Link to section: %d (%s)\n"),
2301 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2302 SECTION_NAME (section_headers
+ section
->sh_link
));
2304 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2305 eneed
, Elf_External_Verneed
*,
2306 "version need section");
2308 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
2310 Elf_External_Verneed
* entry
;
2311 Elf_Internal_Verneed ent
;
2316 vstart
= ((char *) eneed
) + idx
;
2318 entry
= (Elf_External_Verneed
*) vstart
;
2320 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
2321 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
2322 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
2323 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
2324 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
2326 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
2328 if (dynamic_strings
)
2329 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
2331 printf (_(" File: %lx"), ent
.vn_file
);
2333 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
2335 vstart
+= ent
.vn_aux
;
2337 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
2339 Elf_External_Vernaux
* eaux
;
2340 Elf_Internal_Vernaux aux
;
2342 eaux
= (Elf_External_Vernaux
*) vstart
;
2344 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
2345 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
2346 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
2347 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
2348 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
2350 if (dynamic_strings
)
2351 printf (_(" %#06x: Name: %s"),
2352 isum
, dynamic_strings
+ aux
.vna_name
);
2354 printf (_(" %#06x: Name index: %lx"),
2355 isum
, aux
.vna_name
);
2357 printf (_(" Flags: %s Version: %d\n"),
2358 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
2360 isum
+= aux
.vna_next
;
2361 vstart
+= aux
.vna_next
;
2371 case SHT_GNU_versym
:
2373 Elf32_Internal_Shdr
* link_section
;
2376 unsigned char * edata
;
2377 unsigned short * data
;
2379 Elf_Internal_Sym
* symbols
;
2380 Elf32_Internal_Shdr
* string_sec
;
2382 link_section
= section_headers
+ section
->sh_link
;
2383 total
= section
->sh_size
/ section
->sh_entsize
;
2387 symbols
= get_elf_symbols
2388 (file
, link_section
->sh_offset
,
2389 link_section
->sh_size
/ link_section
->sh_entsize
);
2391 string_sec
= section_headers
+ link_section
->sh_link
;
2393 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2394 strtab
, char *, "version string table");
2396 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2397 SECTION_NAME (section
), total
);
2399 printf (_(" Addr: %#08x Offset: %#08x Link: %x (%s)\n"),
2400 section
->sh_addr
, section
->sh_offset
, section
->sh_link
,
2401 SECTION_NAME (link_section
));
2403 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2405 total
* sizeof (short), edata
,
2406 char *, "version symbol data");
2408 data
= (unsigned short *) malloc (total
* sizeof (short));
2410 for (cnt
= total
; cnt
--;)
2411 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short), sizeof (short));
2415 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2419 printf (" %03x:", cnt
);
2421 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2422 switch (data
[cnt
+ j
])
2425 fputs (_(" 0 (*local*) "), stdout
);
2429 fputs (_(" 1 (*global*) "), stdout
);
2433 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
2434 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2436 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
2437 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
2440 /* We must test both. */
2441 Elf_Internal_Verneed ivn
;
2442 unsigned long offset
;
2444 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2449 Elf_External_Verneed evn
;
2450 Elf_External_Vernaux evna
;
2451 Elf_Internal_Vernaux ivna
;
2452 unsigned long vna_off
;
2454 GET_DATA (offset
, evn
, "version need");
2456 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2457 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2459 vna_off
= offset
+ ivn
.vn_aux
;
2463 GET_DATA (vna_off
, evna
,
2464 "version need aux (1)");
2466 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2467 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2469 vna_off
+= ivna
.vna_next
;
2471 while (ivna
.vna_other
!= data
[cnt
+ j
]
2472 && ivna
.vna_next
!= 0);
2474 if (ivna
.vna_other
== data
[cnt
+ j
])
2476 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2478 nn
+= printf ("(%s%-*s",
2479 strtab
+ ivna
.vna_name
,
2485 else if (ivn
.vn_next
== 0)
2487 if (data
[cnt
+ j
] != 0x8001)
2489 Elf_Internal_Verdef ivd
;
2490 Elf_External_Verdef evd
;
2492 offset
= version_info
2493 [DT_VERSIONTAGIDX (DT_VERDEF
)]
2498 GET_DATA (offset
, evd
,
2499 "version definition");
2501 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2502 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2504 offset
+= ivd
.vd_next
;
2507 != (data
[cnt
+ j
] & 0x7fff)
2508 && ivd
.vd_next
!= 0);
2511 == (data
[cnt
+ j
] & 0x7fff))
2513 Elf_External_Verdaux evda
;
2514 Elf_Internal_Verdaux ivda
;
2516 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2518 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
2519 "version definition aux");
2522 BYTE_GET (evda
.vda_name
);
2526 strtab
+ ivda
.vda_name
,
2537 offset
+= ivn
.vn_next
;
2539 while (ivn
.vn_next
);
2541 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
2543 Elf_Internal_Verneed ivn
;
2544 unsigned long offset
;
2546 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2551 Elf_Internal_Vernaux ivna
;
2552 Elf_External_Verneed evn
;
2553 Elf_External_Vernaux evna
;
2554 unsigned long a_off
;
2556 GET_DATA (offset
, evn
, "version need");
2558 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2559 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2561 a_off
= offset
+ ivn
.vn_aux
;
2565 GET_DATA (a_off
, evna
,
2566 "version need aux (2)");
2568 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2569 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2571 a_off
+= ivna
.vna_next
;
2573 while (ivna
.vna_other
!= data
[cnt
+ j
]
2574 && ivna
.vna_next
!= 0);
2576 if (ivna
.vna_other
== data
[cnt
+ j
])
2578 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2580 nn
+= printf ("(%s%-*s",
2581 strtab
+ ivna
.vna_name
,
2588 offset
+= ivn
.vn_next
;
2590 while (ivn
.vn_next
);
2592 else if (data
[cnt
+ j
] != 0x8001)
2594 Elf_Internal_Verdef ivd
;
2595 Elf_External_Verdef evd
;
2596 unsigned long offset
;
2598 offset
= version_info
2599 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
2603 GET_DATA (offset
, evd
, "version def");
2605 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2606 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2608 offset
+= ivd
.vd_next
;
2610 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
2611 && ivd
.vd_next
!= 0);
2613 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
2615 Elf_External_Verdaux evda
;
2616 Elf_Internal_Verdaux ivda
;
2618 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2620 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
2621 evda
, "version def aux");
2623 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2625 nn
+= printf ("(%s%-*s",
2626 strtab
+ ivda
.vda_name
,
2634 printf ("%*c", 18 - nn
, ' ');
2652 printf (_("\nNo version information found in this file.\n"));
2658 get_symbol_binding (binding
)
2659 unsigned int binding
;
2661 static char buff
[32];
2665 case STB_LOCAL
: return _("LOCAL");
2666 case STB_GLOBAL
: return _("GLOBAL");
2667 case STB_WEAK
: return _("WEAK");
2669 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
2670 sprintf (buff
, _("<processor specific>: %d"), binding
);
2672 sprintf (buff
, _("<unknown>: %d"), binding
);
2678 get_symbol_type (type
)
2681 static char buff
[32];
2685 case STT_NOTYPE
: return _("NOTYPE");
2686 case STT_OBJECT
: return _("OBJECT");
2687 case STT_FUNC
: return _("FUNC");
2688 case STT_SECTION
: return _("SECTION");
2689 case STT_FILE
: return _("FILE");
2691 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
2692 sprintf (buff
, _("<processor specific>: %d"), type
);
2694 sprintf (buff
, _("<unknown>: %d"), type
);
2700 get_symbol_index_type (type
)
2705 case SHN_UNDEF
: return "UND";
2706 case SHN_ABS
: return "ABS";
2707 case SHN_COMMON
: return "COM";
2709 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
2711 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
2715 static char buff
[32];
2717 sprintf (buff
, "%3d", type
);
2725 get_dynamic_data (file
, number
)
2727 unsigned int number
;
2732 e_data
= (char *) malloc (number
* 4);
2736 error (_("Out of memory\n"));
2740 if (fread (e_data
, 4, number
, file
) != number
)
2742 error (_("Unable to read in dynamic data\n"));
2746 i_data
= (int *) malloc (number
* sizeof (* i_data
));
2750 error (_("Out of memory\n"));
2756 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
2763 /* Dump the symbol table */
2765 process_symbol_table (file
)
2768 Elf32_Internal_Shdr
* section
;
2773 if (dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
2784 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
2786 error (_("Unable to seek to start of dynamic information"));
2790 if (fread (& nb
, sizeof (nb
), 1, file
) != 1)
2792 error (_("Failed to read in number of buckets\n"));
2796 if (fread (& nc
, sizeof (nc
), 1, file
) != 1)
2798 error (_("Failed to read in number of chains\n"));
2802 nbuckets
= byte_get (nb
, 4);
2803 nchains
= byte_get (nc
, 4);
2805 buckets
= get_dynamic_data (file
, nbuckets
);
2806 chains
= get_dynamic_data (file
, nchains
);
2808 if (buckets
== NULL
|| chains
== NULL
)
2811 printf (_("\nSymbol table for image:\n"));
2812 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
2814 for (hn
= 0; hn
< nbuckets
; hn
++)
2819 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
2821 Elf_Internal_Sym
* psym
;
2823 psym
= dynamic_symbols
+ si
;
2825 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
2827 (unsigned long) psym
->st_value
,
2828 (unsigned long) psym
->st_size
,
2829 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
2830 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
2833 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
2835 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
2842 else if (!do_using_dynamic
)
2846 for (i
= 0, section
= section_headers
;
2847 i
< elf_header
.e_shnum
;
2852 Elf_Internal_Sym
* symtab
;
2853 Elf_Internal_Sym
* psym
;
2856 if ( section
->sh_type
!= SHT_SYMTAB
2857 && section
->sh_type
!= SHT_DYNSYM
)
2860 printf (_("\nSymbol table '%s' contains %d entries:\n"),
2861 SECTION_NAME (section
),
2862 section
->sh_size
/ section
->sh_entsize
);
2863 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
2866 symtab
= get_elf_symbols (file
, section
->sh_offset
,
2867 section
->sh_size
/ section
->sh_entsize
);
2871 if (section
->sh_link
== elf_header
.e_shstrndx
)
2872 strtab
= string_table
;
2875 Elf32_Internal_Shdr
* string_sec
;
2877 string_sec
= section_headers
+ section
->sh_link
;
2879 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2880 strtab
, char *, "string table");
2883 for (si
= 0, psym
= symtab
;
2884 si
< section
->sh_size
/ section
->sh_entsize
;
2887 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
2889 (unsigned long) psym
->st_value
,
2890 (unsigned long) psym
->st_size
,
2891 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
2892 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
2895 if (psym
->st_shndx
== 0)
2896 fputs ("UND", stdout
);
2897 else if ((psym
->st_shndx
& 0xffff) == 0xfff1)
2898 fputs ("ABS", stdout
);
2899 else if ((psym
->st_shndx
& 0xffff) == 0xfff2)
2900 fputs ("COM", stdout
);
2902 printf ("%3d", psym
->st_shndx
);
2904 printf (" %s", strtab
+ psym
->st_name
);
2906 if (section
->sh_type
== SHT_DYNSYM
&&
2907 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
2909 unsigned char data
[2];
2910 unsigned short vers_data
;
2911 unsigned long offset
;
2915 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2918 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
2921 vers_data
= byte_get (data
, 2);
2923 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
2924 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
2927 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
2929 if ((vers_data
& 0x8000) || vers_data
> 1)
2931 if (is_nobits
|| ! check_def
)
2933 Elf_External_Verneed evn
;
2934 Elf_Internal_Verneed ivn
;
2935 Elf_Internal_Vernaux ivna
;
2937 /* We must test both. */
2938 offset
= version_info
2939 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
2941 GET_DATA (offset
, evn
, "version need");
2943 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2944 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2948 unsigned long vna_off
;
2950 vna_off
= offset
+ ivn
.vn_aux
;
2954 Elf_External_Vernaux evna
;
2956 GET_DATA (vna_off
, evna
,
2957 "version need aux (3)");
2959 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2960 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2961 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2963 vna_off
+= ivna
.vna_next
;
2965 while (ivna
.vna_other
!= vers_data
2966 && ivna
.vna_next
!= 0);
2968 if (ivna
.vna_other
== vers_data
)
2971 offset
+= ivn
.vn_next
;
2973 while (ivn
.vn_next
!= 0);
2975 if (ivna
.vna_other
== vers_data
)
2978 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
2981 else if (! is_nobits
)
2982 error (_("bad dynamic symbol"));
2989 if (vers_data
!= 0x8001)
2991 Elf_Internal_Verdef ivd
;
2992 Elf_Internal_Verdaux ivda
;
2993 Elf_External_Verdaux evda
;
2994 unsigned long offset
;
2997 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
3002 Elf_External_Verdef evd
;
3004 GET_DATA (offset
, evd
, "version def");
3006 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3007 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3008 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3010 offset
+= ivd
.vd_next
;
3012 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
3013 && ivd
.vd_next
!= 0);
3015 offset
-= ivd
.vd_next
;
3016 offset
+= ivd
.vd_aux
;
3018 GET_DATA (offset
, evda
, "version def aux");
3020 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3022 if (psym
->st_name
!= ivda
.vda_name
)
3023 printf ((vers_data
& 0x8000)
3025 strtab
+ ivda
.vda_name
);
3035 if (strtab
!= string_table
)
3041 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
3047 process_section_contents (file
)
3050 Elf32_Internal_Shdr
* section
;
3056 for (i
= 0, section
= section_headers
;
3057 i
< elf_header
.e_shnum
;
3060 #ifdef SUPPORT_DISASSEMBLY
3061 /* See if we need an assembly dump of this section */
3063 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & DISASS_DUMP
))
3065 printf (_("\nAssembly dump of section %s\n"),
3066 SECTION_NAME (section
));
3068 /* XXX -- to be done --- XXX */
3071 /* See if we need a hex dump of this section. */
3072 if ((i
< NUM_DUMP_SECTS
) && (dump_sects
[i
] & HEX_DUMP
))
3076 unsigned char * data
;
3079 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
3081 bytes
= section
->sh_size
;
3082 addr
= section
->sh_addr
;
3084 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, char *,
3095 lbytes
= (bytes
> 16 ? 16 : bytes
);
3097 printf (" 0x%8.8x ", addr
);
3099 switch (elf_header
.e_ident
[EI_DATA
])
3102 for (j
= 15; j
>= 0; j
--)
3105 printf ("%2.2x", data
[j
]);
3115 for (j
= 0; j
< 16; j
++)
3118 printf ("%2.2x", data
[j
]);
3128 for (j
= 0; j
< lbytes
; j
++)
3131 if (k
>= ' ' && k
< 0x80)
3152 process_mips_fpe_exception (mask
)
3158 if (mask
& OEX_FPU_INEX
)
3159 fputs ("INEX", stdout
), first
= 0;
3160 if (mask
& OEX_FPU_UFLO
)
3161 printf ("%sUFLO", first
? "" : "|"), first
= 0;
3162 if (mask
& OEX_FPU_OFLO
)
3163 printf ("%sOFLO", first
? "" : "|"), first
= 0;
3164 if (mask
& OEX_FPU_DIV0
)
3165 printf ("%sDIV0", first
? "" : "|"), first
= 0;
3166 if (mask
& OEX_FPU_INVAL
)
3167 printf ("%sINVAL", first
? "" : "|");
3170 fputs ("0", stdout
);
3174 process_mips_specific (file
)
3177 Elf_Internal_Dyn
* entry
;
3178 size_t liblist_offset
= 0;
3179 size_t liblistno
= 0;
3180 size_t options_offset
= 0;
3182 /* We have a lot of special sections. Thanks SGI! */
3183 if (dynamic_segment
== NULL
)
3184 /* No information available. */
3187 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
3188 switch (entry
->d_tag
)
3190 case DT_MIPS_LIBLIST
:
3191 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
3193 case DT_MIPS_LIBLISTNO
:
3194 liblistno
= entry
->d_un
.d_val
;
3196 case DT_MIPS_OPTIONS
:
3197 options_offset
= entry
->d_un
.d_val
- loadaddr
;
3203 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
3205 Elf32_External_Lib
*elib
;
3208 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
3209 elib
, Elf32_External_Lib
*, "liblist");
3211 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
3212 fputs (" Library Time Stamp Checksum Version Flags\n",
3215 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
3221 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
3222 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
3223 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
3224 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
3225 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
3227 strftime (timebuf
, 17, "%Y-%m-%dT%H:%M", gmtime (&time
));
3229 printf ("%3d: %-20s %s %#10lx %-7ld %#lx\n", cnt
,
3230 dynamic_strings
+ liblist
.l_name
, timebuf
,
3231 liblist
.l_checksum
, liblist
.l_version
, liblist
.l_flags
);
3237 if (options_offset
!= 0)
3239 Elf_External_Options
*eopt
;
3240 Elf_Internal_Shdr
*sect
= section_headers
;
3241 Elf_Internal_Options
*iopt
;
3242 Elf_Internal_Options
*option
;
3246 /* Find the section header so that we get the size. */
3247 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
3250 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
3251 Elf_External_Options
*, "options");
3253 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
3257 error (_("Out of memory"));
3263 while (offset
< sect
->sh_size
)
3265 Elf_External_Options
*eoption
;
3267 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
3269 option
->kind
= BYTE_GET (eoption
->kind
);
3270 option
->size
= BYTE_GET (eoption
->size
);
3271 option
->section
= BYTE_GET (eoption
->section
);
3272 option
->info
= BYTE_GET (eoption
->info
);
3274 offset
+= option
->size
;
3279 printf (_("\nSection '%s' contains %d entries:\n"),
3280 string_table
+ sect
->sh_name
, cnt
);
3287 switch (option
->kind
)
3290 /* This shouldn't happen. */
3291 printf (" NULL %d %x", option
->section
, option
->info
);
3294 printf (" REGINFO ");
3295 if (elf_header
.e_machine
== EM_MIPS
)
3298 Elf32_External_RegInfo
*ereg
;
3299 Elf32_RegInfo reginfo
;
3301 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
3302 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3303 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3304 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3305 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3306 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3307 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3309 printf ("GPR %08lx GP %ld\n",
3310 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3311 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3312 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3313 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3318 Elf64_External_RegInfo
*ereg
;
3319 Elf64_Internal_RegInfo reginfo
;
3321 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
3322 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
3323 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
3324 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
3325 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
3326 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
3327 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
3329 printf ("GPR %08lx GP %ld\n",
3330 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
3331 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
3332 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
3333 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
3337 case ODK_EXCEPTIONS
:
3338 fputs (" EXCEPTIONS fpe_min(", stdout
);
3339 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
3340 fputs (") fpe_max(", stdout
);
3341 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
3342 fputs (")", stdout
);
3344 if (option
->info
& OEX_PAGE0
)
3345 fputs (" PAGE0", stdout
);
3346 if (option
->info
& OEX_SMM
)
3347 fputs (" SMM", stdout
);
3348 if (option
->info
& OEX_FPDBUG
)
3349 fputs (" FPDBUG", stdout
);
3350 if (option
->info
& OEX_DISMISS
)
3351 fputs (" DISMISS", stdout
);
3354 fputs (" PAD ", stdout
);
3355 if (option
->info
& OPAD_PREFIX
)
3356 fputs (" PREFIX", stdout
);
3357 if (option
->info
& OPAD_POSTFIX
)
3358 fputs (" POSTFIX", stdout
);
3359 if (option
->info
& OPAD_SYMBOL
)
3360 fputs (" SYMBOL", stdout
);
3363 fputs (" HWPATCH ", stdout
);
3364 if (option
->info
& OHW_R4KEOP
)
3365 fputs (" R4KEOP", stdout
);
3366 if (option
->info
& OHW_R8KPFETCH
)
3367 fputs (" R8KPFETCH", stdout
);
3368 if (option
->info
& OHW_R5KEOP
)
3369 fputs (" R5KEOP", stdout
);
3370 if (option
->info
& OHW_R5KCVTL
)
3371 fputs (" R5KCVTL", stdout
);
3374 fputs (" FILL ", stdout
);
3375 /* XXX Print content of info word? */
3378 fputs (" TAGS ", stdout
);
3379 /* XXX Print content of info word? */
3382 fputs (" HWAND ", stdout
);
3383 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3384 fputs (" R4KEOP_CHECKED", stdout
);
3385 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3386 fputs (" R4KEOP_CLEAN", stdout
);
3389 fputs (" HWOR ", stdout
);
3390 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
3391 fputs (" R4KEOP_CHECKED", stdout
);
3392 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
3393 fputs (" R4KEOP_CLEAN", stdout
);
3396 printf (" GP_GROUP %#06x self-contained %#06x",
3397 option
->info
& OGP_GROUP
,
3398 (option
->info
& OGP_SELF
) >> 16);
3401 printf (" IDENT %#06x self-contained %#06x",
3402 option
->info
& OGP_GROUP
,
3403 (option
->info
& OGP_SELF
) >> 16);
3406 /* This shouldn't happen. */
3407 printf (" %3d ??? %d %x",
3408 option
->kind
, option
->section
, option
->info
);
3412 len
= sizeof (*eopt
);
3413 while (len
< option
->size
)
3414 if (((char *) option
)[len
] >= ' '
3415 && ((char *) option
)[len
++] < 0x7f)
3416 printf ("%c", ((char *) option
)[len
++]);
3418 printf ("\\%03o", ((char *) option
)[len
++]);
3420 fputs ("\n", stdout
);
3431 process_arch_specific (file
)
3434 switch (elf_header
.e_machine
)
3437 case EM_MIPS_RS4_BE
:
3438 return process_mips_specific (file
);
3447 get_file_header (file
)
3450 Elf32_External_Ehdr ehdr
;
3452 if (fread (& ehdr
, sizeof (ehdr
), 1, file
) != 1)
3455 memcpy (elf_header
.e_ident
, ehdr
.e_ident
, EI_NIDENT
);
3457 if (elf_header
.e_ident
[EI_DATA
] == ELFDATA2LSB
)
3458 byte_get
= byte_get_little_endian
;
3460 byte_get
= byte_get_big_endian
;
3462 elf_header
.e_entry
= BYTE_GET (ehdr
.e_entry
);
3463 elf_header
.e_phoff
= BYTE_GET (ehdr
.e_phoff
);
3464 elf_header
.e_shoff
= BYTE_GET (ehdr
.e_shoff
);
3465 elf_header
.e_version
= BYTE_GET (ehdr
.e_version
);
3466 elf_header
.e_flags
= BYTE_GET (ehdr
.e_flags
);
3467 elf_header
.e_type
= BYTE_GET (ehdr
.e_type
);
3468 elf_header
.e_machine
= BYTE_GET (ehdr
.e_machine
);
3469 elf_header
.e_ehsize
= BYTE_GET (ehdr
.e_ehsize
);
3470 elf_header
.e_phentsize
= BYTE_GET (ehdr
.e_phentsize
);
3471 elf_header
.e_phnum
= BYTE_GET (ehdr
.e_phnum
);
3472 elf_header
.e_shentsize
= BYTE_GET (ehdr
.e_shentsize
);
3473 elf_header
.e_shnum
= BYTE_GET (ehdr
.e_shnum
);
3474 elf_header
.e_shstrndx
= BYTE_GET (ehdr
.e_shstrndx
);
3480 process_file (file_name
)
3484 struct stat statbuf
;
3487 if (stat (file_name
, & statbuf
) < 0)
3489 error (_("Cannot stat input file %s.\n"), file_name
);
3493 file
= fopen (file_name
, "rb");
3496 error (_("Input file %s not found.\n"), file_name
);
3500 if (! get_file_header (file
))
3502 error (_("%s: Failed to read file header\n"), file_name
);
3507 /* Initialise per file variables. */
3508 for (i
= NUM_ELEM (version_info
); i
--;)
3509 version_info
[i
] = 0;
3511 for (i
= NUM_ELEM (dynamic_info
); i
--;)
3512 dynamic_info
[i
] = 0;
3515 /* Process the file. */
3517 printf (_("\nFile: %s\n"), file_name
);
3519 if (! process_file_header ())
3525 process_section_headers (file
);
3527 process_program_headers (file
);
3529 process_dynamic_segment (file
);
3531 process_relocs (file
);
3533 process_symbol_table (file
);
3535 process_version_sections (file
);
3537 process_section_contents (file
);
3539 process_arch_specific (file
);
3543 if (section_headers
)
3545 free (section_headers
);
3546 section_headers
= NULL
;
3551 free (string_table
);
3552 string_table
= NULL
;
3555 if (dynamic_strings
)
3557 free (dynamic_strings
);
3558 dynamic_strings
= NULL
;
3561 if (dynamic_symbols
)
3563 free (dynamic_symbols
);
3564 dynamic_symbols
= NULL
;
3568 #ifdef SUPPORT_DISASSEMBLY
3569 /* Needed by the i386 disassembler. For extra credit, someone could
3570 fix this so that we insert symbolic addresses here, esp for GOT/PLT
3574 print_address (unsigned int addr
, FILE * outfile
)
3576 fprintf (outfile
,"0x%8.8x", addr
);
3579 /* Needed by the i386 disassembler. */
3581 db_task_printsym (unsigned int addr
)
3583 print_address (addr
, stderr
);
3592 parse_args (argc
, argv
);
3594 if (optind
< (argc
- 1))
3597 while (optind
< argc
)
3598 process_file (argv
[optind
++]);