1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 1999 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
32 #include "elf/common.h"
33 #include "elf/external.h"
34 #include "elf/internal.h"
35 #include "elf/dwarf2.h"
37 /* The following headers use the elf/reloc-macros.h file to
38 automatically generate relocation recognition functions
39 such as elf_mips_reloc_type() */
41 #define RELOC_MACROS_GEN_FUNC
47 #include "elf/alpha.h"
50 #include "elf/sparc.h"
55 #include "elf/mn10200.h"
56 #include "elf/mn10300.h"
60 #include "elf/mcore.h"
66 #ifdef ANSI_PROTOTYPES
72 char * program_name
= "readelf";
73 unsigned int dynamic_addr
;
74 unsigned int dynamic_size
;
75 unsigned int rela_addr
;
76 unsigned int rela_size
;
77 char * dynamic_strings
;
79 Elf_Internal_Sym
* dynamic_symbols
;
80 Elf_Internal_Syminfo
* dynamic_syminfo
;
81 unsigned long dynamic_syminfo_offset
;
82 unsigned int dynamic_syminfo_nent
;
83 char program_interpreter
[64];
84 int dynamic_info
[DT_JMPREL
+ 1];
87 Elf_Internal_Ehdr elf_header
;
88 Elf_Internal_Shdr
* section_headers
;
89 Elf_Internal_Dyn
* dynamic_segment
;
103 int do_debug_abbrevs
;
105 int do_debug_pubnames
;
106 int do_debug_aranges
;
109 /* A dynamic array of flags indicating which sections require dumping. */
110 char * dump_sects
= NULL
;
111 unsigned int num_dump_sects
= 0;
113 #define HEX_DUMP (1 << 0)
114 #define DISASS_DUMP (1 << 1)
115 #define DEBUG_DUMP (1 << 2)
117 /* Forward declarations for dumb compilers. */
118 static unsigned long (* byte_get
) PARAMS ((unsigned char *, int));
119 static const char * get_mips_dynamic_type
PARAMS ((unsigned long type
));
120 static const char * get_dynamic_type
PARAMS ((unsigned long type
));
121 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, char *, int));
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, unsigned e_machine
));
126 static const char * get_mips_segment_type
PARAMS ((unsigned long type
));
127 static const char * get_segment_type
PARAMS ((unsigned long p_type
));
128 static const char * get_mips_section_type_name
PARAMS ((unsigned int sh_type
));
129 static const char * get_section_type_name
PARAMS ((unsigned int sh_type
));
130 static char * get_symbol_binding
PARAMS ((unsigned int binding
));
131 static char * get_symbol_type
PARAMS ((unsigned int type
));
132 static void usage
PARAMS ((void));
133 static void parse_args
PARAMS ((int argc
, char ** argv
));
134 static int process_file_header
PARAMS ((void));
135 static int process_program_headers
PARAMS ((FILE *));
136 static int process_section_headers
PARAMS ((FILE *));
137 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*entry
));
138 static int process_dynamic_segment
PARAMS ((FILE *));
139 static int process_symbol_table
PARAMS ((FILE *));
140 static int process_section_contents
PARAMS ((FILE *));
141 static void process_file
PARAMS ((char * file_name
));
142 static int process_relocs
PARAMS ((FILE *));
143 static int process_version_sections
PARAMS ((FILE *));
144 static char * get_ver_flags
PARAMS ((unsigned int flags
));
145 static char * get_symbol_index_type
PARAMS ((unsigned int type
));
146 static int get_section_headers
PARAMS ((FILE * file
));
147 static int get_file_header
PARAMS ((FILE * file
));
148 static Elf_Internal_Sym
* get_elf_symbols
PARAMS ((FILE * file
, unsigned long offset
, unsigned long number
));
149 static int * get_dynamic_data
PARAMS ((FILE * file
, unsigned int number
));
150 #ifdef SUPPORT_DISASSEMBLY
151 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
153 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
154 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
155 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
156 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
157 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
158 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
159 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
160 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
161 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
162 static int process_extended_line_op
PARAMS ((unsigned char *, int));
163 static void reset_state_machine
PARAMS ((int));
164 static char * get_TAG_name
PARAMS ((unsigned long));
165 static char * get_AT_name
PARAMS ((unsigned long));
166 static char * get_FORM_name
PARAMS ((unsigned long));
167 static void free_abbrevs
PARAMS ((void));
168 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
169 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
170 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long));
171 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
172 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int));
173 static void request_dump
PARAMS ((unsigned int, char));
174 static const char * get_elf_class
PARAMS ((unsigned char));
175 static const char * get_data_encoding
PARAMS ((unsigned char));
176 static const char * get_osabi_name
PARAMS ((unsigned char));
177 static int guess_is_rela
PARAMS ((unsigned long));
179 typedef int Elf32_Word
;
187 #define SECTION_NAME(X) (string_table + (X)->sh_name)
189 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
191 #define BYTE_GET(field) byte_get (field, sizeof (field))
193 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
195 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
196 if (fseek (file, offset, SEEK_SET)) \
198 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
202 var = (type) malloc (size); \
206 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
210 if (fread (var, size, 1, file) != 1) \
212 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
219 #define GET_DATA(offset, var, reason) \
220 if (fseek (file, offset, SEEK_SET)) \
222 error (_("Unable to seek to %x for %s\n"), offset, reason); \
225 else if (fread (& var, sizeof (var), 1, file) != 1) \
227 error (_("Unable to read data at %x for %s\n"), offset, reason); \
231 #ifdef ANSI_PROTOTYPES
233 error (const char * message
, ...)
237 fprintf (stderr
, _("%s: Error: "), program_name
);
238 va_start (args
, message
);
239 vfprintf (stderr
, message
, args
);
245 warn (const char * message
, ...)
249 fprintf (stderr
, _("%s: Warning: "), program_name
);
250 va_start (args
, message
);
251 vfprintf (stderr
, message
, args
);
263 fprintf (stderr
, _("%s: Error: "), program_name
);
265 message
= va_arg (args
, char *);
266 vfprintf (stderr
, message
, args
);
278 fprintf (stderr
, _("%s: Warning: "), program_name
);
280 message
= va_arg (args
, char *);
281 vfprintf (stderr
, message
, args
);
287 static unsigned long int
288 byte_get_little_endian (field
, size
)
289 unsigned char * field
;
298 return ((unsigned int) (field
[0]))
299 | (((unsigned int) (field
[1])) << 8);
302 return ((unsigned long) (field
[0]))
303 | (((unsigned long) (field
[1])) << 8)
304 | (((unsigned long) (field
[2])) << 16)
305 | (((unsigned long) (field
[3])) << 24);
308 error (_("Unhandled data length: %d\n"), size
);
313 static unsigned long int
314 byte_get_big_endian (field
, size
)
315 unsigned char * field
;
324 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
327 return ((unsigned long) (field
[3]))
328 | (((unsigned long) (field
[2])) << 8)
329 | (((unsigned long) (field
[1])) << 16)
330 | (((unsigned long) (field
[0])) << 24);
333 error (_("Unhandled data length: %d\n"), size
);
339 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
341 guess_is_rela (e_machine
)
342 unsigned long e_machine
;
346 /* Targets that use REL relocations. */
357 /* Targets that use RELA relocations. */
363 case EM_CYGNUS_MN10200
:
364 case EM_CYGNUS_MN10300
:
372 warn (_("Don't know about relocations on this machine architecture\n"));
377 /* Display the contents of the relocation data
378 found at the specified offset. */
380 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
, is_rela
)
382 unsigned long rel_offset
;
383 unsigned long rel_size
;
384 Elf_Internal_Sym
* symtab
;
389 Elf_Internal_Rel
* rels
;
390 Elf_Internal_Rela
* relas
;
393 if (is_rela
== UNKNOWN
)
394 is_rela
= guess_is_rela (elf_header
.e_machine
);
398 Elf32_External_Rela
* erelas
;
400 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
401 Elf32_External_Rela
*, "relocs");
403 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
405 relas
= (Elf_Internal_Rela
*) malloc (rel_size
*
406 sizeof (Elf_Internal_Rela
));
410 error(_("out of memory parsing relocs"));
414 for (i
= 0; i
< rel_size
; i
++)
416 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
417 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
418 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
423 rels
= (Elf_Internal_Rel
*) relas
;
427 Elf32_External_Rel
* erels
;
428 unsigned long saved_rel_size
= rel_size
;
430 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
431 Elf32_External_Rel
*, "relocs");
433 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
435 rels
= (Elf_Internal_Rel
*) malloc (rel_size
*
436 sizeof (Elf_Internal_Rel
));
439 error(_("out of memory parsing relocs"));
443 for (i
= 0; i
< rel_size
; i
++)
445 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
446 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
451 relas
= (Elf_Internal_Rela
*) rels
;
456 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
459 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
461 for (i
= 0; i
< rel_size
; i
++)
464 unsigned long offset
;
470 offset
= relas
[i
].r_offset
;
471 info
= relas
[i
].r_info
;
475 offset
= rels
[i
].r_offset
;
476 info
= rels
[i
].r_info
;
479 printf (" %8.8lx %5.5lx ", offset
, info
);
481 switch (elf_header
.e_machine
)
488 rtype
= elf_m32r_reloc_type (ELF32_R_TYPE (info
));
493 rtype
= elf_i386_reloc_type (ELF32_R_TYPE (info
));
497 rtype
= elf_m68k_reloc_type (ELF32_R_TYPE (info
));
501 rtype
= elf_i960_reloc_type (ELF32_R_TYPE (info
));
505 rtype
= elf_sparc_reloc_type (ELF32_R_TYPE (info
));
509 rtype
= v850_reloc_type (ELF32_R_TYPE (info
));
513 rtype
= elf_d10v_reloc_type (ELF32_R_TYPE (info
));
517 rtype
= elf_d30v_reloc_type (ELF32_R_TYPE (info
));
521 rtype
= elf_sh_reloc_type (ELF32_R_TYPE (info
));
524 case EM_CYGNUS_MN10300
:
525 rtype
= elf_mn10300_reloc_type (ELF32_R_TYPE (info
));
528 case EM_CYGNUS_MN10200
:
529 rtype
= elf_mn10200_reloc_type (ELF32_R_TYPE (info
));
533 rtype
= elf_fr30_reloc_type (ELF32_R_TYPE (info
));
537 rtype
= elf_mcore_reloc_type (ELF32_R_TYPE (info
));
541 rtype
= elf_ppc_reloc_type (ELF32_R_TYPE (info
));
546 rtype
= elf_mips_reloc_type (ELF32_R_TYPE (info
));
550 rtype
= elf_alpha_reloc_type (ELF32_R_TYPE (info
));
554 rtype
= elf_arm_reloc_type (ELF32_R_TYPE (info
));
558 rtype
= elf_arc_reloc_type (ELF32_R_TYPE (info
));
562 rtype
= elf32_hppa_reloc_type (ELF32_R_TYPE (info
));
567 printf (_("unrecognised: %-7lx"), ELF32_R_TYPE (info
));
569 printf ("%-21.21s", rtype
);
571 symtab_index
= ELF32_R_SYM (info
);
573 if (symtab_index
&& symtab
!= NULL
)
575 Elf_Internal_Sym
* psym
;
577 psym
= symtab
+ symtab_index
;
579 printf (" %08lx ", (unsigned long) psym
->st_value
);
581 if (psym
->st_name
== 0)
583 SECTION_NAME (section_headers
+ psym
->st_shndx
));
584 else if (strtab
== NULL
)
585 printf (_("<string table index %3ld>"), psym
->st_name
);
587 printf ("%-25.25s", strtab
+ psym
->st_name
);
590 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
593 printf ("%34c%lx", ' ', (unsigned long) relas
[i
].r_addend
);
604 get_mips_dynamic_type (type
)
609 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
610 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
611 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
612 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
613 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
614 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
615 case DT_MIPS_MSYM
: return "MIPS_MSYM";
616 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
617 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
618 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
619 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
620 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
621 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
622 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
623 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
624 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
625 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
626 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
627 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
628 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
629 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
630 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
631 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
632 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
633 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
634 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
635 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
636 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
637 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
638 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
639 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
640 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
641 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
642 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
643 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
644 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
645 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
646 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
647 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
648 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
649 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
650 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
651 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
658 get_dynamic_type (type
)
661 static char buff
[32];
665 case DT_NULL
: return "NULL";
666 case DT_NEEDED
: return "NEEDED";
667 case DT_PLTRELSZ
: return "PLTRELSZ";
668 case DT_PLTGOT
: return "PLTGOT";
669 case DT_HASH
: return "HASH";
670 case DT_STRTAB
: return "STRTAB";
671 case DT_SYMTAB
: return "SYMTAB";
672 case DT_RELA
: return "RELA";
673 case DT_RELASZ
: return "RELASZ";
674 case DT_RELAENT
: return "RELAENT";
675 case DT_STRSZ
: return "STRSZ";
676 case DT_SYMENT
: return "SYMENT";
677 case DT_INIT
: return "INIT";
678 case DT_FINI
: return "FINI";
679 case DT_SONAME
: return "SONAME";
680 case DT_RPATH
: return "RPATH";
681 case DT_SYMBOLIC
: return "SYMBOLIC";
682 case DT_REL
: return "REL";
683 case DT_RELSZ
: return "RELSZ";
684 case DT_RELENT
: return "RELENT";
685 case DT_PLTREL
: return "PLTREL";
686 case DT_DEBUG
: return "DEBUG";
687 case DT_TEXTREL
: return "TEXTREL";
688 case DT_JMPREL
: return "JMPREL";
689 case DT_BIND_NOW
: return "BIND_NOW";
690 case DT_INIT_ARRAY
: return "INIT_ARRAY";
691 case DT_FINI_ARRAY
: return "FINI_ARRAY";
692 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
693 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
695 case DT_PLTPADSZ
: return "PLTPADSZ";
696 case DT_MOVEENT
: return "MOVEENT";
697 case DT_MOVESZ
: return "MOVESZ";
698 case DT_FEATURE_1
: return "FEATURE_1";
699 case DT_POSFLAG_1
: return "POSFLAG_1";
700 case DT_SYMINSZ
: return "SYMINSZ";
701 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
703 case DT_ADDRRNGLO
: return "ADDRRNGLO";
704 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
706 case DT_VERSYM
: return "VERSYM";
708 case DT_RELACOUNT
: return "RELACOUNT";
709 case DT_RELCOUNT
: return "RELCOUNT";
710 case DT_FLAGS_1
: return "FLAGS_1";
711 case DT_VERDEF
: return "VERDEF";
712 case DT_VERDEFNUM
: return "VERDEFNUM";
713 case DT_VERNEED
: return "VERNEED";
714 case DT_VERNEEDNUM
: return "VERNEEDNUM";
716 case DT_AUXILIARY
: return "AUXILARY";
717 case DT_USED
: return "USED";
718 case DT_FILTER
: return "FILTER";
721 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
725 switch (elf_header
.e_machine
)
729 result
= get_mips_dynamic_type (type
);
739 sprintf (buff
, _("Processor Specific: %lx"), type
);
741 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
742 sprintf (buff
, _("Operating System specific: %lx"), type
);
744 sprintf (buff
, _("<unknown>: %lx"), type
);
751 get_file_type (e_type
)
754 static char buff
[32];
758 case ET_NONE
: return _("NONE (None)");
759 case ET_REL
: return _("REL (Relocatable file)");
760 case ET_EXEC
: return _("EXEC (Executable file)");
761 case ET_DYN
: return _("DYN (Shared object file)");
762 case ET_CORE
: return _("CORE (Core file)");
765 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
766 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
767 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
768 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
770 sprintf (buff
, _("<unknown>: %x"), e_type
);
776 get_machine_name (e_machine
)
779 static char buff
[32];
783 case EM_NONE
: return _("None");
784 case EM_M32
: return "WE32100";
785 case EM_SPARC
: return "Sparc";
786 case EM_386
: return "Intel 80386";
787 case EM_68K
: return "MC68000";
788 case EM_88K
: return "MC88000";
789 case EM_486
: return "Intel 80486";
790 case EM_860
: return "Intel 80860";
791 case EM_MIPS
: return "MIPS R3000 big-endian";
792 case EM_S370
: return "Amdahl";
793 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
794 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
795 case EM_PARISC
: return "HPPA";
796 case EM_PPC_OLD
: return "Power PC (old)";
797 case EM_SPARC32PLUS
: return "Sparc v8+" ;
798 case EM_960
: return "Intel 90860";
799 case EM_PPC
: return "PowerPC";
800 case EM_V800
: return "NEC V800";
801 case EM_FR20
: return "Fujitsu FR20";
802 case EM_RH32
: return "TRW RH32";
803 case EM_MCORE
: return "MCORE";
804 case EM_ARM
: return "ARM";
805 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
806 case EM_SH
: return "Hitachi SH";
807 case EM_SPARCV9
: return "Sparc v9";
808 case EM_TRICORE
: return "Siemens Tricore";
809 case EM_ARC
: return "Argonaut RISC Core";
810 case EM_H8_300
: return "Hitachi H8/300";
811 case EM_H8_300H
: return "Hitachi H8/300H";
812 case EM_H8S
: return "Hitachi H8S";
813 case EM_H8_500
: return "Hitachi H8/500";
814 case EM_IA_64
: return "Intel Merced";
815 case EM_MIPS_X
: return "Stanford MIPS-X";
816 case EM_COLDFIRE
: return "Motorola Coldfire";
817 case EM_68HC12
: return "Motorola M68HC12";
818 case EM_ALPHA
: return "Alpha";
819 case EM_CYGNUS_D10V
: return "d10v";
820 case EM_CYGNUS_D30V
: return "d30v";
821 case EM_CYGNUS_ARC
: return "Arc";
822 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
823 case EM_CYGNUS_V850
: return "NEC v850";
824 case EM_CYGNUS_MN10300
: return "mn10300";
825 case EM_CYGNUS_MN10200
: return "mn10200";
826 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
829 sprintf (buff
, _("<unknown>: %x"), e_machine
);
835 get_machine_flags (e_flags
, e_machine
)
839 static char buf
[1024];
850 if (e_flags
& EF_CPU32
)
851 strcat (buf
, ", cpu32");
855 if (e_flags
& EF_PPC_EMB
)
856 strcat (buf
, ", emb");
858 if (e_flags
& EF_PPC_RELOCATABLE
)
859 strcat (buf
, ", relocatable");
861 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
862 strcat (buf
, ", relocatable-lib");
866 switch (e_flags
& EF_V850_ARCH
)
869 strcat (buf
, ", v850e");
872 strcat (buf
, ", v850ea");
875 strcat (buf
, ", v850");
878 strcat (buf
, ", unknown v850 architecture variant");
884 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
885 strcat (buf
, ", m32r");
891 if (e_flags
& EF_MIPS_NOREORDER
)
892 strcat (buf
, ", noreorder");
894 if (e_flags
& EF_MIPS_PIC
)
895 strcat (buf
, ", pic");
897 if (e_flags
& EF_MIPS_CPIC
)
898 strcat (buf
, ", cpic");
900 if (e_flags
& EF_MIPS_ABI2
)
901 strcat (buf
, ", abi2");
903 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
904 strcat (buf
, ", mips1");
906 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
907 strcat (buf
, ", mips2");
909 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
910 strcat (buf
, ", mips3");
912 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
913 strcat (buf
, ", mips4");
922 get_machine_data (e_data
)
925 static char buff
[32];
929 case ELFDATA2LSB
: return _("ELFDATA2LSB (little endian)");
930 case ELFDATA2MSB
: return _("ELFDATA2MSB (big endian)");
932 sprintf (buff
, _("<unknown>: %x"), e_data
);
938 get_mips_segment_type (type
)
943 case PT_MIPS_REGINFO
:
947 case PT_MIPS_OPTIONS
:
957 get_segment_type (p_type
)
958 unsigned long p_type
;
960 static char buff
[32];
964 case PT_NULL
: return "NULL";
965 case PT_LOAD
: return "LOAD";
966 case PT_DYNAMIC
: return "DYNAMIC";
967 case PT_INTERP
: return "INTERP";
968 case PT_NOTE
: return "NOTE";
969 case PT_SHLIB
: return "SHLIB";
970 case PT_PHDR
: return "PHDR";
973 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
977 switch (elf_header
.e_machine
)
981 result
= get_mips_segment_type (p_type
);
991 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
993 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
994 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
996 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1003 get_mips_section_type_name (sh_type
)
1004 unsigned int sh_type
;
1008 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1009 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1010 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1011 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1012 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1013 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1014 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1015 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1016 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1017 case SHT_MIPS_RELD
: return "MIPS_RELD";
1018 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1019 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1020 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1021 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1022 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1023 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1024 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1025 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1026 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1027 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1028 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1029 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1030 case SHT_MIPS_LINE
: return "MIPS_LINE";
1031 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1032 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1033 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1034 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1035 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1036 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1037 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1038 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1039 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1040 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1041 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1042 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1043 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1044 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1045 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1046 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1054 get_section_type_name (sh_type
)
1055 unsigned int sh_type
;
1057 static char buff
[32];
1061 case SHT_NULL
: return "NULL";
1062 case SHT_PROGBITS
: return "PROGBITS";
1063 case SHT_SYMTAB
: return "SYMTAB";
1064 case SHT_STRTAB
: return "STRTAB";
1065 case SHT_RELA
: return "RELA";
1066 case SHT_HASH
: return "HASH";
1067 case SHT_DYNAMIC
: return "DYNAMIC";
1068 case SHT_NOTE
: return "NOTE";
1069 case SHT_NOBITS
: return "NOBITS";
1070 case SHT_REL
: return "REL";
1071 case SHT_SHLIB
: return "SHLIB";
1072 case SHT_DYNSYM
: return "DYNSYM";
1073 case SHT_GNU_verdef
: return "VERDEF";
1074 case SHT_GNU_verneed
: return "VERNEED";
1075 case SHT_GNU_versym
: return "VERSYM";
1076 case 0x6ffffff0: return "VERSYM";
1077 case 0x6ffffffc: return "VERDEF";
1078 case 0x7ffffffd: return "AUXILIARY";
1079 case 0x7fffffff: return "FILTER";
1082 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1084 const char * result
;
1086 switch (elf_header
.e_machine
)
1089 case EM_MIPS_RS4_BE
:
1090 result
= get_mips_section_type_name (sh_type
);
1100 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1102 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1103 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1104 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1105 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1107 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1113 struct option options
[] =
1115 {"all", no_argument
, 0, 'a'},
1116 {"file-header", no_argument
, 0, 'h'},
1117 {"program-headers", no_argument
, 0, 'l'},
1118 {"headers", no_argument
, 0, 'e'},
1119 {"histogram", no_argument
, & do_histogram
, 1},
1120 {"segments", no_argument
, 0, 'l'},
1121 {"sections", no_argument
, 0, 'S'},
1122 {"section-headers", no_argument
, 0, 'S'},
1123 {"symbols", no_argument
, 0, 's'},
1124 {"syms", no_argument
, 0, 's'},
1125 {"relocs", no_argument
, 0, 'r'},
1126 {"dynamic", no_argument
, 0, 'd'},
1127 {"version-info", no_argument
, 0, 'V'},
1128 {"use-dynamic", no_argument
, 0, 'D'},
1129 {"hex-dump", required_argument
, 0, 'x'},
1130 {"debug-dump", optional_argument
, 0, 'w'},
1131 #ifdef SUPPORT_DISASSEMBLY
1132 {"instruction-dump", required_argument
, 0, 'i'},
1135 {"version", no_argument
, 0, 'v'},
1136 {"help", no_argument
, 0, 'H'},
1137 {0, no_argument
, 0, 0}
1143 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1144 fprintf (stdout
, _(" Options are:\n"));
1145 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V --histogram\n"));
1146 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1147 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1148 fprintf (stdout
, _(" Display the program headers\n"));
1149 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1150 fprintf (stdout
, _(" Display the sections' header\n"));
1151 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1152 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1153 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1154 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1155 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1156 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1157 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1158 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1159 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1160 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1161 #ifdef SUPPORT_DISASSEMBLY
1162 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1163 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1165 fprintf (stdout
, _(" --histogram Display histogram of bucket list lengths\n"));
1166 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1167 fprintf (stdout
, _(" -H or --help Display this information\n"));
1168 fprintf (stdout
, _("Report bugs to bug-gnu-utils@gnu.org\n"));
1174 request_dump (section
, type
)
1175 unsigned int section
;
1178 if (section
>= num_dump_sects
)
1180 char * new_dump_sects
;
1182 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1184 if (new_dump_sects
== NULL
)
1185 error (_("Out of memory allocating dump request table."));
1188 /* Copy current flag settings. */
1189 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1193 dump_sects
= new_dump_sects
;
1194 num_dump_sects
= section
+ 1;
1199 dump_sects
[section
] |= type
;
1205 parse_args (argc
, argv
)
1214 while ((c
= getopt_long
1215 (argc
, argv
, "ersahldSDw::x:i:vV", options
, NULL
)) != EOF
)
1245 do_using_dynamic
++;
1267 section
= strtoul (optarg
, & cp
, 0);
1268 if (! * cp
&& section
>= 0)
1270 request_dump (section
, HEX_DUMP
);
1290 do_debug_abbrevs
= 1;
1300 do_debug_pubnames
= 1;
1305 do_debug_aranges
= 1;
1309 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1314 #ifdef SUPPORT_DISASSEMBLY
1317 section
= strtoul (optarg
, & cp
, 0);
1318 if (! * cp
&& section
>= 0)
1320 request_dump (section
, DISASS_DUMP
);
1326 print_version (program_name
);
1333 /* xgettext:c-format */
1334 error (_("Invalid option '-%c'\n"), c
);
1341 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
1342 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
1343 && !do_histogram
&& !do_debugging
)
1347 warn (_("Nothing to do.\n"));
1353 get_elf_class (elf_class
)
1354 unsigned char elf_class
;
1358 case ELFCLASSNONE
: return _("none");
1359 case ELFCLASS32
: return _("ELF32");
1360 case ELFCLASS64
: return _("ELF64");
1361 default: return _("<unknown>");
1366 get_data_encoding (encoding
)
1367 unsigned char encoding
;
1371 case ELFDATANONE
: return _("none");
1372 case ELFDATA2LSB
: return _("2's complement, little endian");
1373 case ELFDATA2MSB
: return _("2's complement, big endian");
1374 default: return _("<unknown>");
1379 get_osabi_name (osabi
)
1380 unsigned char osabi
;
1384 case ELFOSABI_SYSV
: return _("UNIX - System V");
1385 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
1386 case ELFOSABI_STANDALONE
: return _("Standalone App");
1387 default: return _("<unknown>");
1391 /* Decode the data held in 'elf_header'. */
1393 process_file_header ()
1395 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
1396 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
1397 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
1398 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
1401 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
1409 printf (_("ELF Header:\n"));
1410 printf (_(" Magic: "));
1411 for (i
= 0; i
< EI_NIDENT
; i
++)
1412 printf ("%2.2x ", elf_header
.e_ident
[i
]);
1414 printf (_(" Class: %s\n"),
1415 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
1416 printf (_(" Data: %s\n"),
1417 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
1418 printf (_(" Version: %d %s\n"),
1419 elf_header
.e_ident
[EI_VERSION
],
1420 elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
? "(current)" :
1421 elf_header
.e_ident
[EI_VERSION
] != EV_NONE
? "<unknown>" : "");
1422 printf (_(" OS/ABI: %s\n"),
1423 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
1424 printf (_(" ABI Version: %d\n"),
1425 elf_header
.e_ident
[EI_ABIVERSION
]);
1426 printf (_(" Type: %s\n"),
1427 get_file_type (elf_header
.e_type
));
1428 printf (_(" Machine: %s\n"),
1429 get_machine_name (elf_header
.e_machine
));
1430 printf (_(" Version: 0x%lx\n"),
1431 (unsigned long) elf_header
.e_version
);
1432 printf (_(" Data: %s\n"),
1433 get_machine_data (elf_header
.e_ident
[EI_DATA
]));
1434 printf (_(" Entry point address: 0x%lx\n"),
1435 (unsigned long) elf_header
.e_entry
);
1436 printf (_(" Start of program headers: %ld (bytes into file)\n"),
1437 (long) elf_header
.e_phoff
);
1438 printf (_(" Start of section headers: %ld (bytes into file)\n"),
1439 (long) elf_header
.e_shoff
);
1440 printf (_(" Flags: 0x%lx%s\n"),
1441 (unsigned long) elf_header
.e_flags
,
1442 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
1443 printf (_(" Size of this header: %ld (bytes)\n"),
1444 (long) elf_header
.e_ehsize
);
1445 printf (_(" Size of program headers: %ld (bytes)\n"),
1446 (long) elf_header
.e_phentsize
);
1447 printf (_(" Number of program headers: %ld\n"),
1448 (long) elf_header
.e_phnum
);
1449 printf (_(" Size of section headers: %ld (bytes)\n"),
1450 (long) elf_header
.e_shentsize
);
1451 printf (_(" Number of section headers: %ld\n"),
1452 (long) elf_header
.e_shnum
);
1453 printf (_(" Section header string table index: %ld\n"),
1454 (long) elf_header
.e_shstrndx
);
1457 /* Test class after dumping header so that at least the header can be
1458 display on 64 bit binaries. */
1460 binary_class
= elf_header
.e_ident
[EI_CLASS
];
1461 if (binary_class
!= ELFCLASS32
)
1463 error (_("Not a 32 bit ELF file\n"));
1472 process_program_headers (file
)
1475 Elf32_External_Phdr
* phdrs
;
1476 Elf32_Internal_Phdr
* program_headers
;
1477 Elf32_Internal_Phdr
* segment
;
1480 if (elf_header
.e_phnum
== 0)
1483 printf (_("\nThere are no program headers in this file.\n"));
1487 if (do_segments
&& !do_header
)
1489 printf (_("\nElf file is %s\n"), get_file_type (elf_header
.e_type
));
1490 printf (_("Entry point 0x%lx\n"), (unsigned long) elf_header
.e_entry
);
1491 printf (_("There are %d program headers, starting at offset %lx:\n"),
1492 elf_header
.e_phnum
, (unsigned long) elf_header
.e_phoff
);
1495 GET_DATA_ALLOC (elf_header
.e_phoff
,
1496 elf_header
.e_phentsize
* elf_header
.e_phnum
,
1497 phdrs
, Elf32_External_Phdr
*, "program headers");
1499 program_headers
= (Elf32_Internal_Phdr
*) malloc
1500 (elf_header
.e_phnum
* sizeof (Elf32_Internal_Phdr
));
1502 if (program_headers
== NULL
)
1504 error (_("Out of memory\n"));
1508 for (i
= 0, segment
= program_headers
;
1509 i
< elf_header
.e_phnum
;
1512 segment
->p_type
= BYTE_GET (phdrs
[i
].p_type
);
1513 segment
->p_offset
= BYTE_GET (phdrs
[i
].p_offset
);
1514 segment
->p_vaddr
= BYTE_GET (phdrs
[i
].p_vaddr
);
1515 segment
->p_paddr
= BYTE_GET (phdrs
[i
].p_paddr
);
1516 segment
->p_filesz
= BYTE_GET (phdrs
[i
].p_filesz
);
1517 segment
->p_memsz
= BYTE_GET (phdrs
[i
].p_memsz
);
1518 segment
->p_flags
= BYTE_GET (phdrs
[i
].p_flags
);
1519 segment
->p_align
= BYTE_GET (phdrs
[i
].p_align
);
1527 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
1529 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
1536 for (i
= 0, segment
= program_headers
;
1537 i
< elf_header
.e_phnum
;
1542 printf (" %-11.11s ", get_segment_type (segment
->p_type
));
1543 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
1544 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
1545 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
1546 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
1547 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
1549 (segment
->p_flags
& PF_R
? 'R' : ' '),
1550 (segment
->p_flags
& PF_W
? 'W' : ' '),
1551 (segment
->p_flags
& PF_X
? 'E' : ' '));
1552 printf ("%#lx", (unsigned long) segment
->p_align
);
1555 switch (segment
->p_type
)
1559 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
1560 - (segment
->p_offset
& 0xfffff000);
1565 error (_("more than one dynamic segment\n"));
1567 dynamic_addr
= segment
->p_offset
;
1568 dynamic_size
= segment
->p_filesz
;
1572 if (fseek (file
, segment
->p_offset
, SEEK_SET
))
1573 error (_("Unable to find program interpreter name\n"));
1576 program_interpreter
[0] = 0;
1577 fscanf (file
, "%63s", program_interpreter
);
1580 printf (_("\n [Requesting program interpreter: %s]"),
1581 program_interpreter
);
1587 putc ('\n', stdout
);
1596 if (do_segments
&& section_headers
!= NULL
)
1598 printf (_("\n Section to Segment mapping:\n"));
1599 printf (_(" Segment Sections...\n"));
1601 assert (string_table
!= NULL
);
1603 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
1606 Elf32_Internal_Shdr
* section
;
1608 segment
= program_headers
+ i
;
1609 section
= section_headers
;
1611 printf (" %2.2d ", i
);
1613 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
1615 if (section
->sh_size
> 0
1616 /* Compare allocated sections by VMA, unallocated
1617 sections by file offset. */
1618 && (section
->sh_flags
& SHF_ALLOC
1619 ? (section
->sh_addr
>= segment
->p_vaddr
1620 && section
->sh_addr
+ section
->sh_size
1621 <= segment
->p_vaddr
+ segment
->p_memsz
)
1622 : (section
->sh_offset
>= segment
->p_offset
1623 && (section
->sh_offset
+ section
->sh_size
1624 <= segment
->p_offset
+ segment
->p_filesz
))))
1625 printf ("%s ", SECTION_NAME (section
));
1632 free (program_headers
);
1639 get_section_headers (file
)
1642 Elf32_External_Shdr
* shdrs
;
1643 Elf32_Internal_Shdr
* internal
;
1646 GET_DATA_ALLOC (elf_header
.e_shoff
,
1647 elf_header
.e_shentsize
* elf_header
.e_shnum
,
1648 shdrs
, Elf32_External_Shdr
*, "section headers");
1650 section_headers
= (Elf32_Internal_Shdr
*) malloc
1651 (elf_header
.e_shnum
* sizeof (Elf32_Internal_Shdr
));
1653 if (section_headers
== NULL
)
1655 error (_("Out of memory\n"));
1659 for (i
= 0, internal
= section_headers
;
1660 i
< elf_header
.e_shnum
;
1663 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
1664 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
1665 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
1666 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
1667 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
1668 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
1669 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
1670 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
1671 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
1672 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
1680 static Elf_Internal_Sym
*
1681 get_elf_symbols (file
, offset
, number
)
1683 unsigned long offset
;
1684 unsigned long number
;
1686 Elf32_External_Sym
* esyms
;
1687 Elf_Internal_Sym
* isyms
;
1688 Elf_Internal_Sym
* psym
;
1691 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
1692 esyms
, Elf32_External_Sym
*, "symbols");
1694 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
1698 error (_("Out of memory\n"));
1704 for (j
= 0, psym
= isyms
;
1708 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
1709 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
1710 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
1711 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
1712 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
1713 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
1722 process_section_headers (file
)
1725 Elf32_Internal_Shdr
* section
;
1728 section_headers
= NULL
;
1730 if (elf_header
.e_shnum
== 0)
1733 printf (_("\nThere are no sections in this file.\n"));
1738 if (do_sections
&& !do_header
)
1739 printf (_("There are %d section headers, starting at offset %lx:\n"),
1740 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
1742 if (! get_section_headers (file
))
1745 /* Read in the string table, so that we have names to display. */
1746 section
= section_headers
+ elf_header
.e_shstrndx
;
1748 if (section
->sh_size
!= 0)
1750 unsigned long string_table_offset
;
1752 string_table_offset
= section
->sh_offset
;
1754 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1755 string_table
, char *, "string table");
1758 /* Scan the sections for the dynamic symbol table
1759 and dynamic string table and debug sections. */
1760 dynamic_symbols
= NULL
;
1761 dynamic_strings
= NULL
;
1762 dynamic_syminfo
= NULL
;
1763 for (i
= 0, section
= section_headers
;
1764 i
< elf_header
.e_shnum
;
1767 char * name
= SECTION_NAME (section
);
1769 if (section
->sh_type
== SHT_DYNSYM
)
1771 if (dynamic_symbols
!= NULL
)
1773 error (_("File contains multiple dynamic symbol tables\n"));
1777 dynamic_symbols
= get_elf_symbols
1778 (file
, section
->sh_offset
,
1779 section
->sh_size
/ section
->sh_entsize
);
1781 else if (section
->sh_type
== SHT_STRTAB
1782 && strcmp (name
, ".dynstr") == 0)
1784 if (dynamic_strings
!= NULL
)
1786 error (_("File contains multiple dynamic string tables\n"));
1790 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
1791 dynamic_strings
, char *, "dynamic strings");
1793 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
1794 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
1795 && strncmp (name
, ".debug_", 7) == 0)
1800 || (do_debug_info
&& (strcmp (name
, "info") == 0))
1801 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
1802 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
1803 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
1804 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
1806 request_dump (i
, DEBUG_DUMP
);
1813 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
1815 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
1817 for (i
= 0, section
= section_headers
;
1818 i
< elf_header
.e_shnum
;
1821 printf (" [%2d] %-17.17s %-15.15s ",
1823 SECTION_NAME (section
),
1824 get_section_type_name (section
->sh_type
));
1826 printf ( "%8.8lx %6.6lx %6.6lx %2.2lx",
1827 (unsigned long) section
->sh_addr
,
1828 (unsigned long) section
->sh_offset
,
1829 (unsigned long) section
->sh_size
,
1830 (unsigned long) section
->sh_entsize
);
1832 printf (" %c%c%c %2ld %3lx %ld\n",
1833 (section
->sh_flags
& SHF_WRITE
? 'W' : ' '),
1834 (section
->sh_flags
& SHF_ALLOC
? 'A' : ' '),
1835 (section
->sh_flags
& SHF_EXECINSTR
? 'X' : ' '),
1836 (unsigned long) section
->sh_link
,
1837 (unsigned long) section
->sh_info
,
1838 (unsigned long) section
->sh_addralign
);
1844 /* Process the reloc section. */
1846 process_relocs (file
)
1849 unsigned long rel_size
;
1850 unsigned long rel_offset
;
1856 if (do_using_dynamic
)
1863 if (dynamic_info
[DT_REL
])
1865 rel_offset
= dynamic_info
[DT_REL
];
1866 rel_size
= dynamic_info
[DT_RELSZ
];
1869 else if (dynamic_info
[DT_RELA
])
1871 rel_offset
= dynamic_info
[DT_RELA
];
1872 rel_size
= dynamic_info
[DT_RELASZ
];
1875 else if (dynamic_info
[DT_JMPREL
])
1877 rel_offset
= dynamic_info
[DT_JMPREL
];
1878 rel_size
= dynamic_info
[DT_PLTRELSZ
];
1885 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
1886 rel_offset
, rel_size
);
1888 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
1889 dynamic_symbols
, dynamic_strings
, is_rela
);
1892 printf (_("\nThere are no dynamic relocations in this file.\n"));
1896 Elf32_Internal_Shdr
* section
;
1900 for (i
= 0, section
= section_headers
;
1901 i
< elf_header
.e_shnum
;
1904 if ( section
->sh_type
!= SHT_RELA
1905 && section
->sh_type
!= SHT_REL
)
1908 rel_offset
= section
->sh_offset
;
1909 rel_size
= section
->sh_size
;
1913 Elf32_Internal_Shdr
* strsec
;
1914 Elf32_Internal_Shdr
* symsec
;
1915 Elf_Internal_Sym
* symtab
;
1919 printf (_("\nRelocation section "));
1921 if (string_table
== NULL
)
1923 printf ("%d", section
->sh_name
);
1928 printf ("'%s'", SECTION_NAME (section
));
1930 if (strncmp (".rela.", SECTION_NAME (section
), 6) == 0)
1932 else if (strncmp (".rel.", SECTION_NAME (section
), 5) == 0)
1938 printf (_(" at offset 0x%lx contains %lu entries:\n"),
1939 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
1941 symsec
= section_headers
+ section
->sh_link
;
1943 symtab
= get_elf_symbols (file
, symsec
->sh_offset
,
1944 symsec
->sh_size
/ symsec
->sh_entsize
);
1949 strsec
= section_headers
+ symsec
->sh_link
;
1951 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
1952 char *, "string table");
1954 dump_relocations (file
, rel_offset
, rel_size
, symtab
, strtab
, is_rela
);
1964 printf (_("\nThere are no relocations in this file.\n"));
1972 dynamic_segment_mips_val (entry
)
1973 Elf_Internal_Dyn
* entry
;
1975 switch (entry
->d_tag
)
1978 if (entry
->d_un
.d_val
== 0)
1982 static const char * opts
[] =
1984 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
1985 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
1986 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
1987 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
1992 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
1993 if (entry
->d_un
.d_val
& (1 << cnt
))
1995 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2002 case DT_MIPS_IVERSION
:
2003 if (dynamic_strings
!= NULL
)
2004 printf ("Interface Version: %s\n",
2005 dynamic_strings
+ entry
->d_un
.d_val
);
2007 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2010 case DT_MIPS_TIME_STAMP
:
2013 time_t time
= entry
->d_un
.d_val
;
2014 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
2015 printf ("Time Stamp: %s\n", timebuf
);
2019 case DT_MIPS_RLD_VERSION
:
2020 case DT_MIPS_LOCAL_GOTNO
:
2021 case DT_MIPS_CONFLICTNO
:
2022 case DT_MIPS_LIBLISTNO
:
2023 case DT_MIPS_SYMTABNO
:
2024 case DT_MIPS_UNREFEXTNO
:
2025 case DT_MIPS_HIPAGENO
:
2026 case DT_MIPS_DELTA_CLASS_NO
:
2027 case DT_MIPS_DELTA_INSTANCE_NO
:
2028 case DT_MIPS_DELTA_RELOC_NO
:
2029 case DT_MIPS_DELTA_SYM_NO
:
2030 case DT_MIPS_DELTA_CLASSSYM_NO
:
2031 case DT_MIPS_COMPACT_SIZE
:
2032 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2036 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2040 /* Parse the dynamic segment */
2042 process_dynamic_segment (file
)
2045 Elf_Internal_Dyn
* entry
;
2046 Elf32_External_Dyn
* edyn
;
2049 if (dynamic_size
== 0)
2052 printf (_("\nThere is no dynamic segment in this file.\n"));
2057 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
2058 edyn
, Elf32_External_Dyn
*, "dynamic segment");
2060 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
2061 how large .dynamic is now. We can do this even before the byte
2062 swapping since the DT_NULL tag is recognizable. */
2064 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
2067 dynamic_segment
= (Elf_Internal_Dyn
*)
2068 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
2070 if (dynamic_segment
== NULL
)
2072 error (_("Out of memory\n"));
2077 for (i
= 0, entry
= dynamic_segment
;
2081 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
2082 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
2087 /* Find the appropriate symbol table. */
2088 if (dynamic_symbols
== NULL
)
2090 for (i
= 0, entry
= dynamic_segment
;
2094 unsigned long offset
;
2097 if (entry
->d_tag
!= DT_SYMTAB
)
2100 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
2102 /* Since we do not know how big the symbol table is,
2103 we default to reading in the entire file (!) and
2104 processing that. This is overkill, I know, but it
2107 offset
= entry
->d_un
.d_val
- loadaddr
;
2109 if (fseek (file
, 0, SEEK_END
))
2110 error (_("Unable to seek to end of file!"));
2112 num_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
2116 error (_("Unable to determine the number of symbols to load\n"));
2120 dynamic_symbols
= get_elf_symbols (file
, offset
, num_syms
);
2124 /* Similarly find a string table. */
2125 if (dynamic_strings
== NULL
)
2127 for (i
= 0, entry
= dynamic_segment
;
2131 unsigned long offset
;
2134 if (entry
->d_tag
!= DT_STRTAB
)
2137 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
2139 /* Since we do not know how big the string table is,
2140 we default to reading in the entire file (!) and
2141 processing that. This is overkill, I know, but it
2144 offset
= entry
->d_un
.d_val
- loadaddr
;
2145 if (fseek (file
, 0, SEEK_END
))
2146 error (_("Unable to seek to end of file\n"));
2147 str_tab_len
= ftell (file
) - offset
;
2149 if (str_tab_len
< 1)
2152 (_("Unable to determine the length of the dynamic string table\n"));
2156 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
2157 "dynamic string table");
2163 /* And find the syminfo section if available. */
2164 if (dynamic_syminfo
== NULL
)
2166 unsigned int syminsz
= 0;
2168 for (i
= 0, entry
= dynamic_segment
;
2172 if (entry
->d_tag
== DT_SYMINENT
)
2174 /* Note: these braces are necessary to avoid a syntax
2175 error from the SunOS4 C compiler. */
2176 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
2178 else if (entry
->d_tag
== DT_SYMINSZ
)
2179 syminsz
= entry
->d_un
.d_val
;
2180 else if (entry
->d_tag
== DT_SYMINFO
)
2181 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
2184 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
2186 Elf_External_Syminfo
*extsyminfo
;
2187 Elf_Internal_Syminfo
*syminfo
;
2189 /* There is a syminfo section. Read the data. */
2190 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
2191 Elf_External_Syminfo
*, "symbol information");
2193 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
2194 if (dynamic_syminfo
== NULL
)
2196 error (_("Out of memory\n"));
2200 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
2201 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
2204 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
2205 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
2212 if (do_dynamic
&& dynamic_addr
)
2213 printf (_("\nDynamic segment at offset 0x%x contains %d entries:\n"),
2214 dynamic_addr
, dynamic_size
);
2216 printf (_(" Tag Type Name/Value\n"));
2218 for (i
= 0, entry
= dynamic_segment
;
2223 printf (_(" 0x%-8.8lx (%s)%*s"),
2224 (unsigned long) entry
->d_tag
,
2225 get_dynamic_type (entry
->d_tag
),
2226 27 - strlen (get_dynamic_type (entry
->d_tag
)),
2229 switch (entry
->d_tag
)
2235 if (entry
->d_tag
== DT_AUXILIARY
)
2236 printf (_("Auxiliary library"));
2238 printf (_("Filter library"));
2240 if (dynamic_strings
)
2241 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
2243 printf (": %#lx\n", (long) entry
->d_un
.d_val
);
2250 printf (_("Flags:"));
2251 if (entry
->d_un
.d_val
== 0)
2252 printf (_(" None\n"));
2255 unsigned long int val
= entry
->d_un
.d_val
;
2256 if (val
& DTF_1_PARINIT
)
2258 printf (" PARINIT");
2259 val
^= DTF_1_PARINIT
;
2262 printf (" %lx", val
);
2271 printf (_("Flags:"));
2272 if (entry
->d_un
.d_val
== 0)
2273 printf (_(" None\n"));
2276 unsigned long int val
= entry
->d_un
.d_val
;
2277 if (val
& DF_P1_LAZYLOAD
)
2279 printf (" LAZYLOAD");
2280 val
^= DF_P1_LAZYLOAD
;
2282 if (val
& DF_P1_GROUPPERM
)
2284 printf (" GROUPPERM");
2285 val
^= DF_P1_GROUPPERM
;
2288 printf (" %lx", val
);
2297 printf (_("Flags:"));
2298 if (entry
->d_un
.d_val
== 0)
2299 printf (_(" None\n"));
2302 unsigned long int val
= entry
->d_un
.d_val
;
2308 if (val
& DF_1_GLOBAL
)
2313 if (val
& DF_1_GROUP
)
2318 if (val
& DF_1_NODELETE
)
2320 printf (" NODELETE");
2321 val
^= DF_1_NODELETE
;
2323 if (val
& DF_1_LOADFLTR
)
2325 printf (" LOADFLTR");
2326 val
^= DF_1_LOADFLTR
;
2328 if (val
& DF_1_INITFIRST
)
2330 printf (" INITFIRST");
2331 val
^= DF_1_INITFIRST
;
2333 if (val
& DF_1_NOOPEN
)
2338 if (val
& DF_1_ORIGIN
)
2343 if (val
& DF_1_DIRECT
)
2348 if (val
& DF_1_TRANS
)
2353 if (val
& DF_1_INTERPOSE
)
2355 printf (" INTERPOSE");
2356 val
^= DF_1_INTERPOSE
;
2359 printf (" %lx", val
);
2367 puts (get_dynamic_type (entry
->d_un
.d_val
));
2386 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
2392 if (dynamic_strings
== NULL
)
2395 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2399 switch (entry
->d_tag
)
2402 printf (_("Shared library: [%s]"), name
);
2404 if (strcmp (name
, program_interpreter
))
2407 printf (_(" program interpreter\n"));
2411 printf (_("Library soname: [%s]\n"), name
);
2415 printf (_("Library rpath: [%s]\n"), name
);
2419 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2423 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2437 case DT_INIT_ARRAYSZ
:
2438 case DT_FINI_ARRAYSZ
:
2440 printf ("%lu (bytes)\n", (unsigned long) entry
->d_un
.d_val
);
2448 printf ("%lu\n", (unsigned long) entry
->d_un
.d_val
);
2459 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
2463 name
= dynamic_strings
+ entry
->d_un
.d_val
;
2467 printf (_("Not needed object: [%s]\n"), name
);
2472 printf ("%#lx\n", (long) entry
->d_un
.d_val
);
2477 /* The value of this entry is ignored. */
2481 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
2482 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
2487 switch (elf_header
.e_machine
)
2490 case EM_MIPS_RS4_BE
:
2491 dynamic_segment_mips_val (entry
);
2494 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2505 get_ver_flags (flags
)
2508 static char buff
[32];
2515 if (flags
& VER_FLG_BASE
)
2516 strcat (buff
, "BASE ");
2518 if (flags
& VER_FLG_WEAK
)
2520 if (flags
& VER_FLG_BASE
)
2521 strcat (buff
, "| ");
2523 strcat (buff
, "WEAK ");
2526 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
2527 strcat (buff
, "| <unknown>");
2532 /* Display the contents of the version sections. */
2534 process_version_sections (file
)
2537 Elf32_Internal_Shdr
* section
;
2544 for (i
= 0, section
= section_headers
;
2545 i
< elf_header
.e_shnum
;
2548 switch (section
->sh_type
)
2550 case SHT_GNU_verdef
:
2552 Elf_External_Verdef
* edefs
;
2559 (_("\nVersion definition section '%s' contains %ld entries:\n"),
2560 SECTION_NAME (section
), section
->sh_info
);
2562 printf (_(" Addr: 0x"));
2563 printf_vma (section
->sh_addr
);
2564 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
2565 (unsigned long) section
->sh_offset
, section
->sh_link
,
2566 SECTION_NAME (section_headers
+ section
->sh_link
));
2568 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2569 edefs
, Elf_External_Verdef
*,
2570 "version definition section");
2572 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
2575 Elf_External_Verdef
* edef
;
2576 Elf_Internal_Verdef ent
;
2577 Elf_External_Verdaux
* eaux
;
2578 Elf_Internal_Verdaux aux
;
2582 vstart
= ((char *) edefs
) + idx
;
2584 edef
= (Elf_External_Verdef
*) vstart
;
2586 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
2587 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
2588 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
2589 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
2590 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
2591 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
2592 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
2594 printf (_(" %#06x: Rev: %d Flags: %s"),
2595 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
2597 printf (_(" Index: %d Cnt: %d "),
2598 ent
.vd_ndx
, ent
.vd_cnt
);
2600 vstart
+= ent
.vd_aux
;
2602 eaux
= (Elf_External_Verdaux
*) vstart
;
2604 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2605 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2607 if (dynamic_strings
)
2608 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
2610 printf (_("Name index: %ld\n"), aux
.vda_name
);
2612 isum
= idx
+ ent
.vd_aux
;
2614 for (j
= 1; j
< ent
.vd_cnt
; j
++)
2616 isum
+= aux
.vda_next
;
2617 vstart
+= aux
.vda_next
;
2619 eaux
= (Elf_External_Verdaux
*) vstart
;
2621 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
2622 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
2624 if (dynamic_strings
)
2625 printf (_(" %#06x: Parent %d: %s\n"),
2626 isum
, j
, dynamic_strings
+ aux
.vda_name
);
2628 printf (_(" %#06x: Parent %d, name index: %ld\n"),
2629 isum
, j
, aux
.vda_name
);
2639 case SHT_GNU_verneed
:
2641 Elf_External_Verneed
* eneed
;
2647 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
2648 SECTION_NAME (section
), section
->sh_info
);
2650 printf (_(" Addr: 0x"));
2651 printf_vma (section
->sh_addr
);
2652 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
2653 (unsigned long) section
->sh_offset
, section
->sh_link
,
2654 SECTION_NAME (section_headers
+ section
->sh_link
));
2656 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2657 eneed
, Elf_External_Verneed
*,
2658 "version need section");
2660 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
2662 Elf_External_Verneed
* entry
;
2663 Elf_Internal_Verneed ent
;
2668 vstart
= ((char *) eneed
) + idx
;
2670 entry
= (Elf_External_Verneed
*) vstart
;
2672 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
2673 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
2674 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
2675 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
2676 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
2678 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
2680 if (dynamic_strings
)
2681 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
2683 printf (_(" File: %lx"), ent
.vn_file
);
2685 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
2687 vstart
+= ent
.vn_aux
;
2689 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
2691 Elf_External_Vernaux
* eaux
;
2692 Elf_Internal_Vernaux aux
;
2694 eaux
= (Elf_External_Vernaux
*) vstart
;
2696 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
2697 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
2698 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
2699 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
2700 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
2702 if (dynamic_strings
)
2703 printf (_(" %#06x: Name: %s"),
2704 isum
, dynamic_strings
+ aux
.vna_name
);
2706 printf (_(" %#06x: Name index: %lx"),
2707 isum
, aux
.vna_name
);
2709 printf (_(" Flags: %s Version: %d\n"),
2710 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
2712 isum
+= aux
.vna_next
;
2713 vstart
+= aux
.vna_next
;
2723 case SHT_GNU_versym
:
2725 Elf32_Internal_Shdr
* link_section
;
2728 unsigned char * edata
;
2729 unsigned short * data
;
2731 Elf_Internal_Sym
* symbols
;
2732 Elf32_Internal_Shdr
* string_sec
;
2734 link_section
= section_headers
+ section
->sh_link
;
2735 total
= section
->sh_size
/ section
->sh_entsize
;
2739 symbols
= get_elf_symbols
2740 (file
, link_section
->sh_offset
,
2741 link_section
->sh_size
/ link_section
->sh_entsize
);
2743 string_sec
= section_headers
+ link_section
->sh_link
;
2745 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
2746 strtab
, char *, "version string table");
2748 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
2749 SECTION_NAME (section
), total
);
2751 printf (_(" Addr: "));
2752 printf_vma (section
->sh_addr
);
2753 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
2754 (unsigned long) section
->sh_offset
, section
->sh_link
,
2755 SECTION_NAME (link_section
));
2757 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
2759 total
* sizeof (short), edata
,
2760 unsigned char *, "version symbol data");
2762 data
= (unsigned short *) malloc (total
* sizeof (short));
2764 for (cnt
= total
; cnt
--;)
2765 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
2770 for (cnt
= 0; cnt
< total
; cnt
+= 4)
2774 printf (" %03x:", cnt
);
2776 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
2777 switch (data
[cnt
+ j
])
2780 fputs (_(" 0 (*local*) "), stdout
);
2784 fputs (_(" 1 (*global*) "), stdout
);
2788 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
2789 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
2791 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
2792 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
2795 /* We must test both. */
2796 Elf_Internal_Verneed ivn
;
2797 unsigned long offset
;
2799 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2804 Elf_External_Verneed evn
;
2805 Elf_External_Vernaux evna
;
2806 Elf_Internal_Vernaux ivna
;
2807 unsigned long vna_off
;
2809 GET_DATA (offset
, evn
, "version need");
2811 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2812 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2814 vna_off
= offset
+ ivn
.vn_aux
;
2818 GET_DATA (vna_off
, evna
,
2819 "version need aux (1)");
2821 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2822 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2824 vna_off
+= ivna
.vna_next
;
2826 while (ivna
.vna_other
!= data
[cnt
+ j
]
2827 && ivna
.vna_next
!= 0);
2829 if (ivna
.vna_other
== data
[cnt
+ j
])
2831 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2833 nn
+= printf ("(%s%-*s",
2834 strtab
+ ivna
.vna_name
,
2840 else if (ivn
.vn_next
== 0)
2842 if (data
[cnt
+ j
] != 0x8001)
2844 Elf_Internal_Verdef ivd
;
2845 Elf_External_Verdef evd
;
2847 offset
= version_info
2848 [DT_VERSIONTAGIDX (DT_VERDEF
)]
2853 GET_DATA (offset
, evd
,
2854 "version definition");
2856 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2857 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2859 offset
+= ivd
.vd_next
;
2862 != (data
[cnt
+ j
] & 0x7fff)
2863 && ivd
.vd_next
!= 0);
2866 == (data
[cnt
+ j
] & 0x7fff))
2868 Elf_External_Verdaux evda
;
2869 Elf_Internal_Verdaux ivda
;
2871 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2873 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
2874 "version definition aux");
2877 BYTE_GET (evda
.vda_name
);
2881 strtab
+ ivda
.vda_name
,
2892 offset
+= ivn
.vn_next
;
2894 while (ivn
.vn_next
);
2896 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
2898 Elf_Internal_Verneed ivn
;
2899 unsigned long offset
;
2901 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
2906 Elf_Internal_Vernaux ivna
;
2907 Elf_External_Verneed evn
;
2908 Elf_External_Vernaux evna
;
2909 unsigned long a_off
;
2911 GET_DATA (offset
, evn
, "version need");
2913 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
2914 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
2916 a_off
= offset
+ ivn
.vn_aux
;
2920 GET_DATA (a_off
, evna
,
2921 "version need aux (2)");
2923 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
2924 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
2926 a_off
+= ivna
.vna_next
;
2928 while (ivna
.vna_other
!= data
[cnt
+ j
]
2929 && ivna
.vna_next
!= 0);
2931 if (ivna
.vna_other
== data
[cnt
+ j
])
2933 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
2935 nn
+= printf ("(%s%-*s",
2936 strtab
+ ivna
.vna_name
,
2943 offset
+= ivn
.vn_next
;
2945 while (ivn
.vn_next
);
2947 else if (data
[cnt
+ j
] != 0x8001)
2949 Elf_Internal_Verdef ivd
;
2950 Elf_External_Verdef evd
;
2951 unsigned long offset
;
2953 offset
= version_info
2954 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
2958 GET_DATA (offset
, evd
, "version def");
2960 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
2961 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
2963 offset
+= ivd
.vd_next
;
2965 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
2966 && ivd
.vd_next
!= 0);
2968 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
2970 Elf_External_Verdaux evda
;
2971 Elf_Internal_Verdaux ivda
;
2973 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
2975 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
2976 evda
, "version def aux");
2978 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
2980 nn
+= printf ("(%s%-*s",
2981 strtab
+ ivda
.vda_name
,
2989 printf ("%*c", 18 - nn
, ' ');
3007 printf (_("\nNo version information found in this file.\n"));
3013 get_symbol_binding (binding
)
3014 unsigned int binding
;
3016 static char buff
[32];
3020 case STB_LOCAL
: return _("LOCAL");
3021 case STB_GLOBAL
: return _("GLOBAL");
3022 case STB_WEAK
: return _("WEAK");
3024 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
3025 sprintf (buff
, _("<processor specific>: %d"), binding
);
3026 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
3027 sprintf (buff
, _("<OS specific>: %d"), binding
);
3029 sprintf (buff
, _("<unknown>: %d"), binding
);
3035 get_symbol_type (type
)
3038 static char buff
[32];
3042 case STT_NOTYPE
: return _("NOTYPE");
3043 case STT_OBJECT
: return _("OBJECT");
3044 case STT_FUNC
: return _("FUNC");
3045 case STT_SECTION
: return _("SECTION");
3046 case STT_FILE
: return _("FILE");
3048 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
3049 sprintf (buff
, _("<processor specific>: %d"), type
);
3050 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
3051 sprintf (buff
, _("<OS specific>: %d"), type
);
3053 sprintf (buff
, _("<unknown>: %d"), type
);
3059 get_symbol_index_type (type
)
3064 case SHN_UNDEF
: return "UND";
3065 case SHN_ABS
: return "ABS";
3066 case SHN_COMMON
: return "COM";
3068 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
3070 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
3072 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
3076 static char buff
[32];
3078 sprintf (buff
, "%3d", type
);
3086 get_dynamic_data (file
, number
)
3088 unsigned int number
;
3093 e_data
= (char *) malloc (number
* 4);
3097 error (_("Out of memory\n"));
3101 if (fread (e_data
, 4, number
, file
) != number
)
3103 error (_("Unable to read in dynamic data\n"));
3107 i_data
= (int *) malloc (number
* sizeof (* i_data
));
3111 error (_("Out of memory\n"));
3117 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
3124 /* Dump the symbol table */
3126 process_symbol_table (file
)
3129 Elf32_Internal_Shdr
* section
;
3134 int * buckets
= NULL
;
3135 int * chains
= NULL
;
3137 if (! do_syms
&& !do_histogram
)
3140 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
3143 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
3145 error (_("Unable to seek to start of dynamic information"));
3149 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
3151 error (_("Failed to read in number of buckets\n"));
3155 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
3157 error (_("Failed to read in number of chains\n"));
3161 nbuckets
= byte_get (nb
, 4);
3162 nchains
= byte_get (nc
, 4);
3164 buckets
= get_dynamic_data (file
, nbuckets
);
3165 chains
= get_dynamic_data (file
, nchains
);
3167 if (buckets
== NULL
|| chains
== NULL
)
3172 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
3177 printf (_("\nSymbol table for image:\n"));
3178 printf (_(" Num Buc: Value Size Type Bind Ot Ndx Name\n"));
3180 for (hn
= 0; hn
< nbuckets
; hn
++)
3185 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
3187 Elf_Internal_Sym
* psym
;
3189 psym
= dynamic_symbols
+ si
;
3191 printf (" %3d %3d: %8lx %5ld %6s %6s %2d ",
3193 (unsigned long) psym
->st_value
,
3194 (unsigned long) psym
->st_size
,
3195 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
3196 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
3199 printf ("%3.3s", get_symbol_index_type (psym
->st_shndx
));
3201 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
3205 else if (do_syms
&& !do_using_dynamic
)
3209 for (i
= 0, section
= section_headers
;
3210 i
< elf_header
.e_shnum
;
3215 Elf_Internal_Sym
* symtab
;
3216 Elf_Internal_Sym
* psym
;
3219 if ( section
->sh_type
!= SHT_SYMTAB
3220 && section
->sh_type
!= SHT_DYNSYM
)
3223 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
3224 SECTION_NAME (section
),
3225 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
3226 fputs (_(" Num: Value Size Type Bind Ot Ndx Name\n"),
3229 symtab
= get_elf_symbols (file
, section
->sh_offset
,
3230 section
->sh_size
/ section
->sh_entsize
);
3234 if (section
->sh_link
== elf_header
.e_shstrndx
)
3235 strtab
= string_table
;
3238 Elf32_Internal_Shdr
* string_sec
;
3240 string_sec
= section_headers
+ section
->sh_link
;
3242 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3243 strtab
, char *, "string table");
3246 for (si
= 0, psym
= symtab
;
3247 si
< section
->sh_size
/ section
->sh_entsize
;
3250 printf (" %3d: %8lx %5ld %-7s %-6s %2d ",
3252 (unsigned long) psym
->st_value
,
3253 (unsigned long) psym
->st_size
,
3254 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
3255 get_symbol_binding (ELF_ST_BIND (psym
->st_info
)),
3258 printf ("%4s", get_symbol_index_type (psym
->st_shndx
));
3260 printf (" %s", strtab
+ psym
->st_name
);
3262 if (section
->sh_type
== SHT_DYNSYM
&&
3263 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
3265 unsigned char data
[2];
3266 unsigned short vers_data
;
3267 unsigned long offset
;
3271 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3274 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
3277 vers_data
= byte_get (data
, 2);
3279 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
3280 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
3283 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
3285 if ((vers_data
& 0x8000) || vers_data
> 1)
3287 if (is_nobits
|| ! check_def
)
3289 Elf_External_Verneed evn
;
3290 Elf_Internal_Verneed ivn
;
3291 Elf_Internal_Vernaux ivna
;
3293 /* We must test both. */
3294 offset
= version_info
3295 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
3297 GET_DATA (offset
, evn
, "version need");
3299 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3300 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3304 unsigned long vna_off
;
3306 vna_off
= offset
+ ivn
.vn_aux
;
3310 Elf_External_Vernaux evna
;
3312 GET_DATA (vna_off
, evna
,
3313 "version need aux (3)");
3315 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3316 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3317 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3319 vna_off
+= ivna
.vna_next
;
3321 while (ivna
.vna_other
!= vers_data
3322 && ivna
.vna_next
!= 0);
3324 if (ivna
.vna_other
== vers_data
)
3327 offset
+= ivn
.vn_next
;
3329 while (ivn
.vn_next
!= 0);
3331 if (ivna
.vna_other
== vers_data
)
3334 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
3337 else if (! is_nobits
)
3338 error (_("bad dynamic symbol"));
3345 if (vers_data
!= 0x8001)
3347 Elf_Internal_Verdef ivd
;
3348 Elf_Internal_Verdaux ivda
;
3349 Elf_External_Verdaux evda
;
3350 unsigned long offset
;
3353 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
3358 Elf_External_Verdef evd
;
3360 GET_DATA (offset
, evd
, "version def");
3362 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3363 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3364 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3366 offset
+= ivd
.vd_next
;
3368 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
3369 && ivd
.vd_next
!= 0);
3371 offset
-= ivd
.vd_next
;
3372 offset
+= ivd
.vd_aux
;
3374 GET_DATA (offset
, evda
, "version def aux");
3376 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
3378 if (psym
->st_name
!= ivda
.vda_name
)
3379 printf ((vers_data
& 0x8000)
3381 strtab
+ ivda
.vda_name
);
3391 if (strtab
!= string_table
)
3397 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
3399 if (do_histogram
&& buckets
!= NULL
)
3406 int nzero_counts
= 0;
3409 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
3411 printf (_(" Length Number %% of total Coverage\n"));
3413 lengths
= (int *) calloc (nbuckets
, sizeof (int));
3414 if (lengths
== NULL
)
3416 error (_("Out of memory"));
3419 for (hn
= 0; hn
< nbuckets
; ++hn
)
3424 for (si
= buckets
[hn
]; si
; si
= chains
[si
])
3427 if (maxlength
< ++lengths
[hn
])
3432 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
3435 error (_("Out of memory"));
3439 for (hn
= 0; hn
< nbuckets
; ++hn
)
3440 ++ counts
[lengths
[hn
]];
3442 printf (" 0 %-10d (%5.1f%%)\n",
3443 counts
[0], (counts
[0] * 100.0) / nbuckets
);
3444 for (si
= 1; si
<= maxlength
; ++si
)
3446 nzero_counts
+= counts
[si
] * si
;
3447 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
3448 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
3449 (nzero_counts
* 100.0) / nsyms
);
3456 if (buckets
!= NULL
)
3466 process_syminfo (file
)
3471 if (dynamic_syminfo
== NULL
3473 /* No syminfo, this is ok. */
3476 /* There better should be a dynamic symbol section. */
3477 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
3481 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
3482 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
3484 printf (_(" Num: Name BoundTo Flags\n"));
3485 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
3487 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
3489 printf ("%4d: %-30s ", i
,
3490 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
3492 switch (dynamic_syminfo
[i
].si_boundto
)
3494 case SYMINFO_BT_SELF
:
3495 fputs ("SELF ", stdout
);
3497 case SYMINFO_BT_PARENT
:
3498 fputs ("PARENT ", stdout
);
3501 if (dynamic_syminfo
[i
].si_boundto
> 0
3502 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
3505 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
3507 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
3511 if (flags
& SYMINFO_FLG_DIRECT
)
3513 if (flags
& SYMINFO_FLG_PASSTHRU
)
3514 printf (" PASSTHRU");
3515 if (flags
& SYMINFO_FLG_COPY
)
3517 if (flags
& SYMINFO_FLG_LAZYLOAD
)
3518 printf (" LAZYLOAD");
3526 #ifdef SUPPORT_DISASSEMBLY
3528 disassemble_section (section
, file
)
3529 Elf32_Internal_Shdr
* section
;
3532 printf (_("\nAssembly dump of section %s\n"),
3533 SECTION_NAME (section
));
3535 /* XXX -- to be done --- XXX */
3542 dump_section (section
, file
)
3543 Elf32_Internal_Shdr
* section
;
3548 unsigned char * data
;
3549 unsigned char * start
;
3551 bytes
= section
->sh_size
;
3555 printf (_("\nSection '%s' has no data to dump.\n"),
3556 SECTION_NAME (section
));
3560 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
3562 addr
= section
->sh_addr
;
3564 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
3575 lbytes
= (bytes
> 16 ? 16 : bytes
);
3577 printf (" 0x%8.8x ", addr
);
3579 switch (elf_header
.e_ident
[EI_DATA
])
3582 for (j
= 15; j
>= 0; j
--)
3585 printf ("%2.2x", data
[j
]);
3595 for (j
= 0; j
< 16; j
++)
3598 printf ("%2.2x", data
[j
]);
3608 for (j
= 0; j
< lbytes
; j
++)
3611 if (k
>= ' ' && k
< 0x80)
3630 static unsigned long int
3631 read_leb128 (data
, length_return
, sign
)
3632 unsigned char * data
;
3633 int * length_return
;
3636 unsigned long int result
= 0;
3637 unsigned int num_read
= 0;
3646 result
|= (byte
& 0x7f) << shift
;
3651 while (byte
& 0x80);
3653 if (length_return
!= NULL
)
3654 * length_return
= num_read
;
3656 if (sign
&& (shift
< 32) && (byte
& 0x40))
3657 result
|= -1 << shift
;
3662 typedef struct State_Machine_Registers
3664 unsigned long address
;
3667 unsigned int column
;
3671 /* This variable hold the number of the last entry seen
3672 in the File Table. */
3673 unsigned int last_file_entry
;
3676 static SMR state_machine_regs
;
3679 reset_state_machine (is_stmt
)
3682 state_machine_regs
.address
= 0;
3683 state_machine_regs
.file
= 1;
3684 state_machine_regs
.line
= 1;
3685 state_machine_regs
.column
= 0;
3686 state_machine_regs
.is_stmt
= is_stmt
;
3687 state_machine_regs
.basic_block
= 0;
3688 state_machine_regs
.end_sequence
= 0;
3689 state_machine_regs
.last_file_entry
= 0;
3692 /* Handled an extend line op. Returns true if this is the end
3695 process_extended_line_op (data
, is_stmt
)
3696 unsigned char * data
;
3699 unsigned char op_code
;
3702 unsigned char * name
;
3705 len
= read_leb128 (data
, & bytes_read
, 0);
3710 warn (_("badly formed extended line op encountered!"));
3715 op_code
= * data
++;
3717 printf (_(" Extended opcode %d: "), op_code
);
3721 case DW_LNE_end_sequence
:
3722 printf (_("End of Sequence\n\n"));
3723 reset_state_machine (is_stmt
);
3726 case DW_LNE_set_address
:
3727 /* XXX - assumption here that address size is 4! */
3728 adr
= byte_get (data
, 4);
3729 printf (_("set Address to 0x%lx\n"), adr
);
3730 state_machine_regs
.address
= adr
;
3733 case DW_LNE_define_file
:
3734 printf (_(" define new File Table entry\n"));
3735 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3737 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
3739 data
+= strlen (data
) + 1;
3740 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
3742 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
3744 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
3745 printf (_("%s\n\n"), name
);
3749 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
3758 display_debug_lines (section
, start
, file
)
3759 Elf32_Internal_Shdr
* section
;
3760 unsigned char * start
;
3763 DWARF2_External_LineInfo
* external
;
3764 DWARF2_Internal_LineInfo info
;
3765 unsigned char * standard_opcodes
;
3766 unsigned char * data
= start
;
3767 unsigned char * end
= start
+ section
->sh_size
;
3768 unsigned char * end_of_sequence
;
3771 printf (_("\nDump of debug contents of section %s:\n\n"),
3772 SECTION_NAME (section
));
3776 external
= (DWARF2_External_LineInfo
*) data
;
3778 /* Check the length of the block. */
3779 info
.li_length
= BYTE_GET (external
->li_length
);
3780 if (info
.li_length
> section
->sh_size
)
3783 (_("The line info appears to be corrupt - the section is too small\n"));
3787 /* Check its version number. */
3788 info
.li_version
= BYTE_GET (external
->li_version
);
3789 if (info
.li_version
!= 2)
3791 warn (_("Only DWARF version 2 line info is currently supported.\n"));
3795 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
3796 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
3797 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
3798 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
3799 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
3800 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
3802 /* Sign extend the line base field. */
3803 info
.li_line_base
<<= 24;
3804 info
.li_line_base
>>= 24;
3806 printf (_(" Length: %ld\n"), info
.li_length
);
3807 printf (_(" DWARF Version: %d\n"), info
.li_version
);
3808 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
3809 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
3810 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
3811 printf (_(" Line Base: %d\n"), info
.li_line_base
);
3812 printf (_(" Line Range: %d\n"), info
.li_line_range
);
3813 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
3815 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
3817 reset_state_machine (info
.li_default_is_stmt
);
3819 /* Display the contents of the Opcodes table. */
3820 standard_opcodes
= data
+ sizeof (* external
);
3822 printf (_("\n Opcodes:\n"));
3824 for (i
= 1; i
< info
.li_opcode_base
; i
++)
3825 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
]);
3827 /* Display the contents of the Directory table. */
3828 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
3831 printf (_("\n The Directory Table is empty.\n"));
3834 printf (_("\n The Directory Table:\n"));
3838 printf (_(" %s\n"), data
);
3840 data
+= strlen (data
) + 1;
3844 /* Skip the NUL at the end of the table. */
3847 /* Display the contents of the File Name table. */
3849 printf (_("\n The File Name Table is empty.\n"));
3852 printf (_("\n The File Name Table:\n"));
3853 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
3860 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
3863 data
+= strlen (data
) + 1;
3865 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
3867 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
3869 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
3871 printf (_("%s\n"), name
);
3875 /* Skip the NUL at the end of the table. */
3878 /* Now display the statements. */
3879 printf (_("\n Line Number Statements:\n"));
3882 while (data
< end_of_sequence
)
3884 unsigned char op_code
;
3888 op_code
= * data
++;
3892 case DW_LNS_extended_op
:
3893 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
);
3897 printf (_(" Copy\n"));
3900 case DW_LNS_advance_pc
:
3901 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
3903 state_machine_regs
.address
+= adv
;
3904 printf (_(" Advance PC by %d to %lx\n"), adv
,
3905 state_machine_regs
.address
);
3908 case DW_LNS_advance_line
:
3909 adv
= read_leb128 (data
, & bytes_read
, 1);
3911 state_machine_regs
.line
+= adv
;
3912 printf (_(" Advance Line by %d to %d\n"), adv
,
3913 state_machine_regs
.line
);
3916 case DW_LNS_set_file
:
3917 adv
= read_leb128 (data
, & bytes_read
, 0);
3919 printf (_(" Set File Name to entry %d in the File Name Table\n"),
3921 state_machine_regs
.file
= adv
;
3924 case DW_LNS_set_column
:
3925 adv
= read_leb128 (data
, & bytes_read
, 0);
3927 printf (_(" Set column to %d\n"), adv
);
3928 state_machine_regs
.column
= adv
;
3931 case DW_LNS_negate_stmt
:
3932 adv
= state_machine_regs
.is_stmt
;
3934 printf (_(" Set is_stmt to %d\n"), adv
);
3935 state_machine_regs
.is_stmt
= adv
;
3938 case DW_LNS_set_basic_block
:
3939 printf (_(" Set basic block\n"));
3940 state_machine_regs
.basic_block
= 1;
3943 case DW_LNS_const_add_pc
:
3944 adv
= (255 - info
.li_opcode_base
) / info
.li_line_range
;
3945 state_machine_regs
.address
+= adv
;
3946 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
3947 state_machine_regs
.address
);
3950 case DW_LNS_fixed_advance_pc
:
3951 adv
= byte_get (data
, 2);
3953 state_machine_regs
.address
+= adv
;
3954 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
3955 adv
, state_machine_regs
.address
);
3959 op_code
-= info
.li_opcode_base
;
3960 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
3961 state_machine_regs
.address
+= adv
;
3962 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
3963 op_code
, adv
, state_machine_regs
.address
);
3964 adv
+= (op_code
% info
.li_line_range
) + info
.li_line_base
;
3965 state_machine_regs
.line
+= adv
;
3966 printf (_(" and Line by %d to %d\n"),
3967 adv
, state_machine_regs
.line
);
3978 display_debug_pubnames (section
, start
, file
)
3979 Elf32_Internal_Shdr
* section
;
3980 unsigned char * start
;
3983 DWARF2_External_PubNames
* external
;
3984 DWARF2_Internal_PubNames pubnames
;
3985 unsigned char * end
;
3987 end
= start
+ section
->sh_size
;
3989 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
3993 unsigned char * data
;
3994 unsigned long offset
;
3996 external
= (DWARF2_External_PubNames
*) start
;
3998 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
3999 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
4000 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
4001 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
4003 data
= start
+ sizeof (* external
);
4004 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
4006 if (pubnames
.pn_version
!= 2)
4008 warn (_("Only DWARF 2 pubnames are currently supported"));
4012 printf (_(" Length: %ld\n"),
4013 pubnames
.pn_length
);
4014 printf (_(" Version: %d\n"),
4015 pubnames
.pn_version
);
4016 printf (_(" Offset into .debug_info section: %ld\n"),
4017 pubnames
.pn_offset
);
4018 printf (_(" Size of area in .debug_info section: %ld\n"),
4021 printf (_("\n Offset\tName\n"));
4025 offset
= byte_get (data
, 4);
4030 printf (" %ld\t\t%s\n", offset
, data
);
4031 data
+= strlen (data
) + 1;
4034 while (offset
!= 0);
4047 case DW_TAG_padding
: return "DW_TAG_padding";
4048 case DW_TAG_array_type
: return "DW_TAG_array_type";
4049 case DW_TAG_class_type
: return "DW_TAG_class_type";
4050 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
4051 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
4052 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
4053 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
4054 case DW_TAG_label
: return "DW_TAG_label";
4055 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
4056 case DW_TAG_member
: return "DW_TAG_member";
4057 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
4058 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
4059 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
4060 case DW_TAG_string_type
: return "DW_TAG_string_type";
4061 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
4062 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
4063 case DW_TAG_typedef
: return "DW_TAG_typedef";
4064 case DW_TAG_union_type
: return "DW_TAG_union_type";
4065 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
4066 case DW_TAG_variant
: return "DW_TAG_variant";
4067 case DW_TAG_common_block
: return "DW_TAG_common_block";
4068 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
4069 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
4070 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
4071 case DW_TAG_module
: return "DW_TAG_module";
4072 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
4073 case DW_TAG_set_type
: return "DW_TAG_set_type";
4074 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
4075 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
4076 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
4077 case DW_TAG_base_type
: return "DW_TAG_base_type";
4078 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
4079 case DW_TAG_const_type
: return "DW_TAG_const_type";
4080 case DW_TAG_constant
: return "DW_TAG_constant";
4081 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
4082 case DW_TAG_file_type
: return "DW_TAG_file_type";
4083 case DW_TAG_friend
: return "DW_TAG_friend";
4084 case DW_TAG_namelist
: return "DW_TAG_namelist";
4085 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
4086 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
4087 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
4088 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
4089 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
4090 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
4091 case DW_TAG_try_block
: return "DW_TAG_try_block";
4092 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
4093 case DW_TAG_variable
: return "DW_TAG_variable";
4094 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
4095 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
4096 case DW_TAG_format_label
: return "DW_TAG_format_label";
4097 case DW_TAG_function_template
: return "DW_TAG_function_template";
4098 case DW_TAG_class_template
: return "DW_TAG_class_template";
4101 static char buffer
[100];
4103 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
4110 get_AT_name (attribute
)
4111 unsigned long attribute
;
4115 case DW_AT_sibling
: return "DW_AT_sibling";
4116 case DW_AT_location
: return "DW_AT_location";
4117 case DW_AT_name
: return "DW_AT_name";
4118 case DW_AT_ordering
: return "DW_AT_ordering";
4119 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
4120 case DW_AT_byte_size
: return "DW_AT_byte_size";
4121 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
4122 case DW_AT_bit_size
: return "DW_AT_bit_size";
4123 case DW_AT_element_list
: return "DW_AT_element_list";
4124 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
4125 case DW_AT_low_pc
: return "DW_AT_low_pc";
4126 case DW_AT_high_pc
: return "DW_AT_high_pc";
4127 case DW_AT_language
: return "DW_AT_language";
4128 case DW_AT_member
: return "DW_AT_member";
4129 case DW_AT_discr
: return "DW_AT_discr";
4130 case DW_AT_discr_value
: return "DW_AT_discr_value";
4131 case DW_AT_visibility
: return "DW_AT_visibility";
4132 case DW_AT_import
: return "DW_AT_import";
4133 case DW_AT_string_length
: return "DW_AT_string_length";
4134 case DW_AT_common_reference
: return "DW_AT_common_reference";
4135 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
4136 case DW_AT_const_value
: return "DW_AT_const_value";
4137 case DW_AT_containing_type
: return "DW_AT_containing_type";
4138 case DW_AT_default_value
: return "DW_AT_default_value";
4139 case DW_AT_inline
: return "DW_AT_inline";
4140 case DW_AT_is_optional
: return "DW_AT_is_optional";
4141 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
4142 case DW_AT_producer
: return "DW_AT_producer";
4143 case DW_AT_prototyped
: return "DW_AT_prototyped";
4144 case DW_AT_return_addr
: return "DW_AT_return_addr";
4145 case DW_AT_start_scope
: return "DW_AT_start_scope";
4146 case DW_AT_stride_size
: return "DW_AT_stride_size";
4147 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
4148 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
4149 case DW_AT_accessibility
: return "DW_AT_accessibility";
4150 case DW_AT_address_class
: return "DW_AT_address_class";
4151 case DW_AT_artificial
: return "DW_AT_artificial";
4152 case DW_AT_base_types
: return "DW_AT_base_types";
4153 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
4154 case DW_AT_count
: return "DW_AT_count";
4155 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
4156 case DW_AT_decl_column
: return "DW_AT_decl_column";
4157 case DW_AT_decl_file
: return "DW_AT_decl_file";
4158 case DW_AT_decl_line
: return "DW_AT_decl_line";
4159 case DW_AT_declaration
: return "DW_AT_declaration";
4160 case DW_AT_discr_list
: return "DW_AT_discr_list";
4161 case DW_AT_encoding
: return "DW_AT_encoding";
4162 case DW_AT_external
: return "DW_AT_external";
4163 case DW_AT_frame_base
: return "DW_AT_frame_base";
4164 case DW_AT_friend
: return "DW_AT_friend";
4165 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
4166 case DW_AT_macro_info
: return "DW_AT_macro_info";
4167 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
4168 case DW_AT_priority
: return "DW_AT_priority";
4169 case DW_AT_segment
: return "DW_AT_segment";
4170 case DW_AT_specification
: return "DW_AT_specification";
4171 case DW_AT_static_link
: return "DW_AT_static_link";
4172 case DW_AT_type
: return "DW_AT_type";
4173 case DW_AT_use_location
: return "DW_AT_use_location";
4174 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
4175 case DW_AT_virtuality
: return "DW_AT_virtuality";
4176 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
4177 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
4178 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
4179 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
4180 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
4181 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
4182 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
4183 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
4184 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
4185 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
4186 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
4187 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
4188 case DW_AT_sf_names
: return "DW_AT_sf_names";
4189 case DW_AT_src_info
: return "DW_AT_src_info";
4190 case DW_AT_mac_info
: return "DW_AT_mac_info";
4191 case DW_AT_src_coords
: return "DW_AT_src_coords";
4192 case DW_AT_body_begin
: return "DW_AT_body_begin";
4193 case DW_AT_body_end
: return "DW_AT_body_end";
4196 static char buffer
[100];
4198 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
4205 get_FORM_name (form
)
4210 case DW_FORM_addr
: return "DW_FORM_addr";
4211 case DW_FORM_block2
: return "DW_FORM_block2";
4212 case DW_FORM_block4
: return "DW_FORM_block4";
4213 case DW_FORM_data2
: return "DW_FORM_data2";
4214 case DW_FORM_data4
: return "DW_FORM_data4";
4215 case DW_FORM_data8
: return "DW_FORM_data8";
4216 case DW_FORM_string
: return "DW_FORM_string";
4217 case DW_FORM_block
: return "DW_FORM_block";
4218 case DW_FORM_block1
: return "DW_FORM_block1";
4219 case DW_FORM_data1
: return "DW_FORM_data1";
4220 case DW_FORM_flag
: return "DW_FORM_flag";
4221 case DW_FORM_sdata
: return "DW_FORM_sdata";
4222 case DW_FORM_strp
: return "DW_FORM_strp";
4223 case DW_FORM_udata
: return "DW_FORM_udata";
4224 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
4225 case DW_FORM_ref1
: return "DW_FORM_ref1";
4226 case DW_FORM_ref2
: return "DW_FORM_ref2";
4227 case DW_FORM_ref4
: return "DW_FORM_ref4";
4228 case DW_FORM_ref8
: return "DW_FORM_ref8";
4229 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
4230 case DW_FORM_indirect
: return "DW_FORM_indirect";
4233 static char buffer
[100];
4235 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
4241 /* FIXME: There are better and more effiecint ways to handle
4242 these structures. For now though, I just want something that
4243 is simple to implement. */
4244 typedef struct abbrev_attr
4246 unsigned long attribute
;
4248 struct abbrev_attr
* next
;
4252 typedef struct abbrev_entry
4254 unsigned long entry
;
4257 struct abbrev_attr
* first_attr
;
4258 struct abbrev_attr
* last_attr
;
4259 struct abbrev_entry
* next
;
4263 static abbrev_entry
* first_abbrev
= NULL
;
4264 static abbrev_entry
* last_abbrev
= NULL
;
4267 free_abbrevs
PARAMS ((void))
4269 abbrev_entry
* abbrev
;
4271 for (abbrev
= first_abbrev
; abbrev
;)
4273 abbrev_entry
* next
= abbrev
->next
;
4276 for (attr
= abbrev
->first_attr
; attr
;)
4278 abbrev_attr
* next
= attr
->next
;
4288 last_abbrev
= first_abbrev
= NULL
;
4292 add_abbrev (number
, tag
, children
)
4293 unsigned long number
;
4297 abbrev_entry
* entry
;
4299 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
4305 entry
->entry
= number
;
4307 entry
->children
= children
;
4308 entry
->first_attr
= NULL
;
4309 entry
->last_attr
= NULL
;
4312 if (first_abbrev
== NULL
)
4313 first_abbrev
= entry
;
4315 last_abbrev
->next
= entry
;
4317 last_abbrev
= entry
;
4321 add_abbrev_attr (attribute
, form
)
4322 unsigned long attribute
;
4327 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
4333 attr
->attribute
= attribute
;
4337 if (last_abbrev
->first_attr
== NULL
)
4338 last_abbrev
->first_attr
= attr
;
4340 last_abbrev
->last_attr
->next
= attr
;
4342 last_abbrev
->last_attr
= attr
;
4345 /* Processes the (partial) contents of a .debug_abbrev section.
4346 Returns NULL if the end of the section was encountered.
4347 Returns the address after the last byte read if the end of
4348 an abbreviation set was found. */
4350 static unsigned char *
4351 process_abbrev_section (start
, end
)
4352 unsigned char * start
;
4353 unsigned char * end
;
4355 if (first_abbrev
!= NULL
)
4361 unsigned long entry
;
4363 unsigned long attribute
;
4366 entry
= read_leb128 (start
, & bytes_read
, 0);
4367 start
+= bytes_read
;
4372 tag
= read_leb128 (start
, & bytes_read
, 0);
4373 start
+= bytes_read
;
4375 children
= * start
++;
4377 add_abbrev (entry
, tag
, children
);
4383 attribute
= read_leb128 (start
, & bytes_read
, 0);
4384 start
+= bytes_read
;
4386 form
= read_leb128 (start
, & bytes_read
, 0);
4387 start
+= bytes_read
;
4390 add_abbrev_attr (attribute
, form
);
4392 while (attribute
!= 0);
4400 display_debug_abbrev (section
, start
, file
)
4401 Elf32_Internal_Shdr
* section
;
4402 unsigned char * start
;
4405 abbrev_entry
* entry
;
4406 unsigned char * end
= start
+ section
->sh_size
;
4408 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
4412 start
= process_abbrev_section (start
, end
);
4414 printf (_(" Number TAG\n"));
4416 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
4420 printf (_(" %ld %s [%s]\n"),
4422 get_TAG_name (entry
->tag
),
4423 entry
->children
? _("has children") : _("no children"));
4425 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4427 printf (_(" %-18s %s\n"),
4428 get_AT_name (attr
->attribute
),
4429 get_FORM_name (attr
->form
));
4441 static unsigned char *
4442 display_block (data
, length
)
4443 unsigned char * data
;
4444 unsigned long length
;
4446 printf (_(" %lu byte block: "), length
);
4449 printf ("%lx ", byte_get (data
++, 1));
4455 decode_location_expression (data
, pointer_size
)
4456 unsigned char * data
;
4457 unsigned int pointer_size
;
4466 case DW_OP_addr
: printf ("DW_OP_addr: %lx", byte_get (data
, pointer_size
)); break;
4467 case DW_OP_deref
: printf ("DW_OP_deref"); break;
4468 case DW_OP_const1u
: printf ("DW_OP_const1u: %lu", byte_get (data
, 1)); break;
4469 case DW_OP_const1s
: printf ("DW_OP_const1s: %ld", (long) byte_get (data
, 1)); break;
4470 case DW_OP_const2u
: printf ("DW_OP_const2u: %lu", byte_get (data
, 2)); break;
4471 case DW_OP_const2s
: printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2)); break;
4472 case DW_OP_const4u
: printf ("DW_OP_const4u: %lu", byte_get (data
, 4)); break;
4473 case DW_OP_const4s
: printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4)); break;
4474 case DW_OP_const8u
: printf ("DW_OP_const8u: %lu %lu", byte_get (data
, 4), byte_get (data
+ 4, 4)); break;
4475 case DW_OP_const8s
: printf ("DW_OP_const8s: %ld %ld", byte_get (data
, 4), byte_get (data
+ 4, 4)); break;
4476 case DW_OP_constu
: printf ("DW_OP_constu: %lu", read_leb128 (data
, NULL
, 0)); break;
4477 case DW_OP_consts
: printf ("DW_OP_consts: %ld", read_leb128 (data
, NULL
, 1)); break;
4478 case DW_OP_dup
: printf ("DW_OP_dup"); break;
4479 case DW_OP_drop
: printf ("DW_OP_drop"); break;
4480 case DW_OP_over
: printf ("DW_OP_over"); break;
4481 case DW_OP_pick
: printf ("DW_OP_pick: %ld", byte_get (data
, 1)); break;
4482 case DW_OP_swap
: printf ("DW_OP_swap"); break;
4483 case DW_OP_rot
: printf ("DW_OP_rot"); break;
4484 case DW_OP_xderef
: printf ("DW_OP_xderef"); break;
4485 case DW_OP_abs
: printf ("DW_OP_abs"); break;
4486 case DW_OP_and
: printf ("DW_OP_and"); break;
4487 case DW_OP_div
: printf ("DW_OP_div"); break;
4488 case DW_OP_minus
: printf ("DW_OP_minus"); break;
4489 case DW_OP_mod
: printf ("DW_OP_mod"); break;
4490 case DW_OP_mul
: printf ("DW_OP_mul"); break;
4491 case DW_OP_neg
: printf ("DW_OP_neg"); break;
4492 case DW_OP_not
: printf ("DW_OP_not"); break;
4493 case DW_OP_or
: printf ("DW_OP_or"); break;
4494 case DW_OP_plus
: printf ("DW_OP_plus"); break;
4495 case DW_OP_plus_uconst
: printf ("DW_OP_plus_uconst: %lu", read_leb128 (data
, NULL
, 0)); break;
4496 case DW_OP_shl
: printf ("DW_OP_shl"); break;
4497 case DW_OP_shr
: printf ("DW_OP_shr"); break;
4498 case DW_OP_shra
: printf ("DW_OP_shra"); break;
4499 case DW_OP_xor
: printf ("DW_OP_xor"); break;
4500 case DW_OP_bra
: printf ("DW_OP_bra: %ld", byte_get (data
, 2)); break;
4501 case DW_OP_eq
: printf ("DW_OP_eq"); break;
4502 case DW_OP_ge
: printf ("DW_OP_ge"); break;
4503 case DW_OP_gt
: printf ("DW_OP_gt"); break;
4504 case DW_OP_le
: printf ("DW_OP_le"); break;
4505 case DW_OP_lt
: printf ("DW_OP_lt"); break;
4506 case DW_OP_ne
: printf ("DW_OP_ne"); break;
4507 case DW_OP_skip
: printf ("DW_OP_skip: %ld", byte_get (data
, 2)); break;
4508 case DW_OP_lit0
: printf ("DW_OP_lit0"); break;
4509 case DW_OP_lit1
: printf ("DW_OP_lit1"); break;
4510 case DW_OP_lit2
: printf ("DW_OP_lit2"); break;
4511 case DW_OP_lit3
: printf ("DW_OP_lit3"); break;
4512 case DW_OP_lit4
: printf ("DW_OP_lit4"); break;
4513 case DW_OP_lit5
: printf ("DW_OP_lit5"); break;
4514 case DW_OP_lit6
: printf ("DW_OP_lit6"); break;
4515 case DW_OP_lit7
: printf ("DW_OP_lit7"); break;
4516 case DW_OP_lit8
: printf ("DW_OP_lit8"); break;
4517 case DW_OP_lit9
: printf ("DW_OP_lit9"); break;
4518 case DW_OP_lit10
: printf ("DW_OP_lit10"); break;
4519 case DW_OP_lit11
: printf ("DW_OP_lit11"); break;
4520 case DW_OP_lit12
: printf ("DW_OP_lit12"); break;
4521 case DW_OP_lit13
: printf ("DW_OP_lit13"); break;
4522 case DW_OP_lit14
: printf ("DW_OP_lit14"); break;
4523 case DW_OP_lit15
: printf ("DW_OP_lit15"); break;
4524 case DW_OP_lit16
: printf ("DW_OP_lit16"); break;
4525 case DW_OP_lit17
: printf ("DW_OP_lit17"); break;
4526 case DW_OP_lit18
: printf ("DW_OP_lit18"); break;
4527 case DW_OP_lit19
: printf ("DW_OP_lit19"); break;
4528 case DW_OP_lit20
: printf ("DW_OP_lit20"); break;
4529 case DW_OP_lit21
: printf ("DW_OP_lit21"); break;
4530 case DW_OP_lit22
: printf ("DW_OP_lit22"); break;
4531 case DW_OP_lit23
: printf ("DW_OP_lit23"); break;
4532 case DW_OP_lit24
: printf ("DW_OP_lit24"); break;
4533 case DW_OP_lit25
: printf ("DW_OP_lit25"); break;
4534 case DW_OP_lit26
: printf ("DW_OP_lit26"); break;
4535 case DW_OP_lit27
: printf ("DW_OP_lit27"); break;
4536 case DW_OP_lit28
: printf ("DW_OP_lit28"); break;
4537 case DW_OP_lit29
: printf ("DW_OP_lit29"); break;
4538 case DW_OP_lit30
: printf ("DW_OP_lit30"); break;
4539 case DW_OP_lit31
: printf ("DW_OP_lit31"); break;
4540 case DW_OP_reg0
: printf ("DW_OP_reg0"); break;
4541 case DW_OP_reg1
: printf ("DW_OP_reg1"); break;
4542 case DW_OP_reg2
: printf ("DW_OP_reg2"); break;
4543 case DW_OP_reg3
: printf ("DW_OP_reg3"); break;
4544 case DW_OP_reg4
: printf ("DW_OP_reg4"); break;
4545 case DW_OP_reg5
: printf ("DW_OP_reg5"); break;
4546 case DW_OP_reg6
: printf ("DW_OP_reg6"); break;
4547 case DW_OP_reg7
: printf ("DW_OP_reg7"); break;
4548 case DW_OP_reg8
: printf ("DW_OP_reg8"); break;
4549 case DW_OP_reg9
: printf ("DW_OP_reg9"); break;
4550 case DW_OP_reg10
: printf ("DW_OP_reg10"); break;
4551 case DW_OP_reg11
: printf ("DW_OP_reg11"); break;
4552 case DW_OP_reg12
: printf ("DW_OP_reg12"); break;
4553 case DW_OP_reg13
: printf ("DW_OP_reg13"); break;
4554 case DW_OP_reg14
: printf ("DW_OP_reg14"); break;
4555 case DW_OP_reg15
: printf ("DW_OP_reg15"); break;
4556 case DW_OP_reg16
: printf ("DW_OP_reg16"); break;
4557 case DW_OP_reg17
: printf ("DW_OP_reg17"); break;
4558 case DW_OP_reg18
: printf ("DW_OP_reg18"); break;
4559 case DW_OP_reg19
: printf ("DW_OP_reg19"); break;
4560 case DW_OP_reg20
: printf ("DW_OP_reg20"); break;
4561 case DW_OP_reg21
: printf ("DW_OP_reg21"); break;
4562 case DW_OP_reg22
: printf ("DW_OP_reg22"); break;
4563 case DW_OP_reg23
: printf ("DW_OP_reg23"); break;
4564 case DW_OP_reg24
: printf ("DW_OP_reg24"); break;
4565 case DW_OP_reg25
: printf ("DW_OP_reg25"); break;
4566 case DW_OP_reg26
: printf ("DW_OP_reg26"); break;
4567 case DW_OP_reg27
: printf ("DW_OP_reg27"); break;
4568 case DW_OP_reg28
: printf ("DW_OP_reg28"); break;
4569 case DW_OP_reg29
: printf ("DW_OP_reg29"); break;
4570 case DW_OP_reg30
: printf ("DW_OP_reg30"); break;
4571 case DW_OP_reg31
: printf ("DW_OP_reg31"); break;
4572 case DW_OP_breg0
: printf ("DW_OP_breg0: %ld", read_leb128 (data
, NULL
, 1)); break;
4573 case DW_OP_breg1
: printf ("DW_OP_breg1: %ld", read_leb128 (data
, NULL
, 1)); break;
4574 case DW_OP_breg2
: printf ("DW_OP_breg2: %ld", read_leb128 (data
, NULL
, 1)); break;
4575 case DW_OP_breg3
: printf ("DW_OP_breg3: %ld", read_leb128 (data
, NULL
, 1)); break;
4576 case DW_OP_breg4
: printf ("DW_OP_breg4: %ld", read_leb128 (data
, NULL
, 1)); break;
4577 case DW_OP_breg5
: printf ("DW_OP_breg5: %ld", read_leb128 (data
, NULL
, 1)); break;
4578 case DW_OP_breg6
: printf ("DW_OP_breg6: %ld", read_leb128 (data
, NULL
, 1)); break;
4579 case DW_OP_breg7
: printf ("DW_OP_breg7: %ld", read_leb128 (data
, NULL
, 1)); break;
4580 case DW_OP_breg8
: printf ("DW_OP_breg8: %ld", read_leb128 (data
, NULL
, 1)); break;
4581 case DW_OP_breg9
: printf ("DW_OP_breg9: %ld", read_leb128 (data
, NULL
, 1)); break;
4582 case DW_OP_breg10
: printf ("DW_OP_breg10: %ld", read_leb128 (data
, NULL
, 1)); break;
4583 case DW_OP_breg11
: printf ("DW_OP_breg11: %ld", read_leb128 (data
, NULL
, 1)); break;
4584 case DW_OP_breg12
: printf ("DW_OP_breg12: %ld", read_leb128 (data
, NULL
, 1)); break;
4585 case DW_OP_breg13
: printf ("DW_OP_breg13: %ld", read_leb128 (data
, NULL
, 1)); break;
4586 case DW_OP_breg14
: printf ("DW_OP_breg14: %ld", read_leb128 (data
, NULL
, 1)); break;
4587 case DW_OP_breg15
: printf ("DW_OP_breg15: %ld", read_leb128 (data
, NULL
, 1)); break;
4588 case DW_OP_breg16
: printf ("DW_OP_breg16: %ld", read_leb128 (data
, NULL
, 1)); break;
4589 case DW_OP_breg17
: printf ("DW_OP_breg17: %ld", read_leb128 (data
, NULL
, 1)); break;
4590 case DW_OP_breg18
: printf ("DW_OP_breg18: %ld", read_leb128 (data
, NULL
, 1)); break;
4591 case DW_OP_breg19
: printf ("DW_OP_breg19: %ld", read_leb128 (data
, NULL
, 1)); break;
4592 case DW_OP_breg20
: printf ("DW_OP_breg20: %ld", read_leb128 (data
, NULL
, 1)); break;
4593 case DW_OP_breg21
: printf ("DW_OP_breg21: %ld", read_leb128 (data
, NULL
, 1)); break;
4594 case DW_OP_breg22
: printf ("DW_OP_breg22: %ld", read_leb128 (data
, NULL
, 1)); break;
4595 case DW_OP_breg23
: printf ("DW_OP_breg23: %ld", read_leb128 (data
, NULL
, 1)); break;
4596 case DW_OP_breg24
: printf ("DW_OP_breg24: %ld", read_leb128 (data
, NULL
, 1)); break;
4597 case DW_OP_breg25
: printf ("DW_OP_breg25: %ld", read_leb128 (data
, NULL
, 1)); break;
4598 case DW_OP_breg26
: printf ("DW_OP_breg26: %ld", read_leb128 (data
, NULL
, 1)); break;
4599 case DW_OP_breg27
: printf ("DW_OP_breg27: %ld", read_leb128 (data
, NULL
, 1)); break;
4600 case DW_OP_breg28
: printf ("DW_OP_breg28: %ld", read_leb128 (data
, NULL
, 1)); break;
4601 case DW_OP_breg29
: printf ("DW_OP_breg29: %ld", read_leb128 (data
, NULL
, 1)); break;
4602 case DW_OP_breg30
: printf ("DW_OP_breg30: %ld", read_leb128 (data
, NULL
, 1)); break;
4603 case DW_OP_breg31
: printf ("DW_OP_breg31: %ld", read_leb128 (data
, NULL
, 1)); break;
4604 case DW_OP_regx
: printf ("DW_OP_regx: %lu", read_leb128 (data
, NULL
, 0)); break;
4605 case DW_OP_fbreg
: printf ("DW_OP_fbreg: %ld", read_leb128 (data
, NULL
, 1)); break;
4606 case DW_OP_bregx
: printf ("DW_OP_bregx: %lu %ld", read_leb128 (data
, & bytes_read
, 0), read_leb128 (data
+ bytes_read
, NULL
, 1)); break;
4607 case DW_OP_piece
: printf ("DW_OP_piece: %lu", read_leb128 (data
, NULL
, 0)); break;
4608 case DW_OP_deref_size
: printf ("DW_OP_deref_size: %ld", byte_get (data
, 1)); break;
4609 case DW_OP_xderef_size
: printf ("DW_OP_xderef_size: %ld", byte_get (data
, 1)); break;
4610 case DW_OP_nop
: printf ("DW_OP_nop"); break;
4613 if (op
>= DW_OP_lo_user
4614 && op
<= DW_OP_hi_user
)
4615 printf (_("(User defined location op)"));
4617 printf (_("(Unknown location op)"));
4623 static unsigned char *
4624 read_and_display_attr (attribute
, form
, data
, pointer_size
)
4625 unsigned long attribute
;
4627 unsigned char * data
;
4628 unsigned long pointer_size
;
4630 unsigned long uvalue
;
4631 unsigned char * block_start
;
4635 printf (" %-18s:", get_AT_name (attribute
));
4639 case DW_FORM_ref_addr
:
4644 case DW_FORM_ref_udata
:
4650 case DW_FORM_ref_addr
:
4652 uvalue
= byte_get (data
, pointer_size
);
4653 printf (is_ref
? " <%x>" : " %#x", uvalue
);
4654 data
+= pointer_size
;
4660 uvalue
= byte_get (data
++, 1);
4661 printf (is_ref
? " <%x>" : " %d", uvalue
);
4666 uvalue
= byte_get (data
, 2);
4668 printf (is_ref
? " <%x>" : " %d", uvalue
);
4673 uvalue
= byte_get (data
, 4);
4675 printf (is_ref
? " <%x>" : " %d", uvalue
);
4680 uvalue
= byte_get (data
, 4);
4681 printf (" %lx", uvalue
);
4682 printf (" %lx", byte_get (data
+ 4, 4));
4686 case DW_FORM_string
:
4687 printf (" %s", data
);
4688 data
+= strlen (data
) + 1;
4692 uvalue
= read_leb128 (data
, & bytes_read
, 1);
4694 printf (" %ld", (long) uvalue
);
4697 case DW_FORM_ref_udata
:
4699 uvalue
= read_leb128 (data
, & bytes_read
, 0);
4701 printf (is_ref
? " <%lx>" : " %ld", uvalue
);
4705 uvalue
= read_leb128 (data
, & bytes_read
, 0);
4706 block_start
= data
+ bytes_read
;
4707 data
= display_block (block_start
, uvalue
);
4708 uvalue
= * block_start
;
4711 case DW_FORM_block1
:
4712 uvalue
= byte_get (data
, 1);
4713 block_start
= data
+ 1;
4714 data
= display_block (block_start
, uvalue
);
4715 uvalue
= * block_start
;
4718 case DW_FORM_block2
:
4719 uvalue
= byte_get (data
, 2);
4720 block_start
= data
+ 2;
4721 data
= display_block (block_start
, uvalue
);
4722 uvalue
= * block_start
;
4725 case DW_FORM_block4
:
4726 uvalue
= byte_get (data
, 4);
4727 block_start
= data
+ 4;
4728 data
= display_block (block_start
, uvalue
);
4729 uvalue
= * block_start
;
4733 case DW_FORM_indirect
:
4734 warn (_("Unable to handle FORM: %d"), form
);
4738 warn (_("Unrecognised form: %d"), form
);
4742 /* For some attributes we can display futher information. */
4751 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
4752 case DW_INL_inlined
: printf (_("(inlined)")); break;
4753 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
4754 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
4755 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
4759 case DW_AT_frame_base
:
4760 if (uvalue
>= DW_OP_reg0
&& uvalue
<= DW_OP_reg31
)
4761 printf ("(reg %ld)", uvalue
- DW_OP_reg0
);
4764 case DW_AT_language
:
4767 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
4768 case DW_LANG_C89
: printf ("(ANSI C)"); break;
4769 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
4770 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
4771 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
4772 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
4773 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
4774 case DW_LANG_Ada83
: printf ("(Ada)"); break;
4775 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
4776 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
4777 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
4778 default: printf ("(Unknown: %lx)", uvalue
); break;
4782 case DW_AT_encoding
:
4785 case DW_ATE_void
: printf ("(void)"); break;
4786 case DW_ATE_address
: printf ("(machine address)"); break;
4787 case DW_ATE_boolean
: printf ("(boolean)"); break;
4788 case DW_ATE_complex_float
: printf ("(complex float)"); break;
4789 case DW_ATE_float
: printf ("(float)"); break;
4790 case DW_ATE_signed
: printf ("(signed)"); break;
4791 case DW_ATE_signed_char
: printf ("(signed char)"); break;
4792 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
4793 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
4795 if (uvalue
>= DW_ATE_lo_user
4796 && uvalue
<= DW_ATE_hi_user
)
4797 printf ("(user defined type)");
4799 printf ("(unknown type)");
4804 case DW_AT_accessibility
:
4807 case DW_ACCESS_public
: printf ("(public)"); break;
4808 case DW_ACCESS_protected
: printf ("(protected)"); break;
4809 case DW_ACCESS_private
: printf ("(private)"); break;
4810 default: printf ("(unknown accessibility)"); break;
4814 case DW_AT_visibility
:
4817 case DW_VIS_local
: printf ("(local)"); break;
4818 case DW_VIS_exported
: printf ("(exported)"); break;
4819 case DW_VIS_qualified
: printf ("(qualified)"); break;
4820 default: printf ("(unknown visibility)"); break;
4824 case DW_AT_virtuality
:
4827 case DW_VIRTUALITY_none
: printf ("(none)"); break;
4828 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
4829 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
4830 default: printf ("(unknown virtuality)"); break;
4834 case DW_AT_identifier_case
:
4837 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
4838 case DW_ID_up_case
: printf ("(up_case)"); break;
4839 case DW_ID_down_case
: printf ("(down_case)"); break;
4840 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
4841 default: printf ("(unknown case)"); break;
4845 case DW_AT_calling_convention
:
4848 case DW_CC_normal
: printf ("(normal)"); break;
4849 case DW_CC_program
: printf ("(program)"); break;
4850 case DW_CC_nocall
: printf ("(nocall)"); break;
4852 if (uvalue
>= DW_CC_lo_user
4853 && uvalue
<= DW_CC_hi_user
)
4854 printf ("(user defined)");
4856 printf ("(unknown convention)");
4860 case DW_AT_location
:
4861 case DW_AT_data_member_location
:
4862 case DW_AT_vtable_elem_location
:
4864 decode_location_expression (block_start
, pointer_size
);
4877 display_debug_info (section
, start
, file
)
4878 Elf32_Internal_Shdr
* section
;
4879 unsigned char * start
;
4882 unsigned char * end
= start
+ section
->sh_size
;
4883 unsigned char * section_begin
= start
;
4885 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
4889 DWARF2_External_CompUnit
* external
;
4890 DWARF2_Internal_CompUnit compunit
;
4891 unsigned char * tags
;
4895 external
= (DWARF2_External_CompUnit
*) start
;
4897 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
4898 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
4899 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
4900 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
4902 tags
= start
+ sizeof (* external
);
4903 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
4905 if (compunit
.cu_version
!= 2)
4907 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
4911 printf (_(" Compilation Unit:\n"));
4912 printf (_(" Length: %ld\n"), compunit
.cu_length
);
4913 printf (_(" Version: %d\n"), compunit
.cu_version
);
4914 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
4915 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
4917 if (first_abbrev
!= NULL
)
4920 /* Read in the abbrevs used by this compilation unit. */
4923 Elf32_Internal_Shdr
* sec
;
4924 unsigned char * begin
;
4926 /* Locate the .debug_abbrev section and process it. */
4927 for (i
= 0, sec
= section_headers
;
4928 i
< elf_header
.e_shnum
;
4930 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
4933 if (i
== -1 || sec
->sh_size
== 0)
4935 warn (_("Unable to locate .debug_abbrev section!\n"));
4939 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
4940 "debug_abbrev section data");
4942 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
4943 begin
+ sec
->sh_size
);
4949 while (tags
< start
)
4953 abbrev_entry
* entry
;
4956 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
4959 /* A null DIE marks the end of a list of children. */
4960 if (abbrev_number
== 0)
4966 /* Scan through the abbreviation list until we reach the
4968 for (entry
= first_abbrev
;
4969 entry
&& entry
->entry
!= abbrev_number
;
4970 entry
= entry
->next
)
4975 warn (_("Unable to locate entry %d in the abbreviation table\n"),
4980 printf (_(" <%d><%x>: Abbrev Number: %d (%s)\n"),
4981 level
, tags
- section_begin
- bytes_read
,
4983 get_TAG_name (entry
->tag
));
4985 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
4986 tags
= read_and_display_attr (attr
->attribute
,
4989 compunit
.cu_pointer_size
);
4991 if (entry
->children
)
5002 display_debug_aranges (section
, start
, file
)
5003 Elf32_Internal_Shdr
* section
;
5004 unsigned char * start
;
5007 unsigned char * end
= start
+ section
->sh_size
;
5009 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
5013 DWARF2_External_ARange
* external
;
5014 DWARF2_Internal_ARange arange
;
5015 unsigned char * ranges
;
5016 unsigned long length
;
5017 unsigned long address
;
5019 external
= (DWARF2_External_ARange
*) start
;
5021 arange
.ar_length
= BYTE_GET (external
->ar_length
);
5022 arange
.ar_version
= BYTE_GET (external
->ar_version
);
5023 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
5024 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
5025 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
5027 printf (_(" Length: %ld\n"), arange
.ar_length
);
5028 printf (_(" Version: %d\n"), arange
.ar_version
);
5029 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
5030 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
5031 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
5033 printf (_("\n Address Length\n"));
5035 ranges
= start
+ sizeof (* external
);
5039 address
= byte_get (ranges
, arange
.ar_pointer_size
);
5044 ranges
+= arange
.ar_pointer_size
;
5046 length
= byte_get (ranges
, arange
.ar_pointer_size
);
5048 ranges
+= arange
.ar_pointer_size
;
5050 printf (" %8.8lx %lu\n", address
, length
);
5053 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
5063 display_debug_not_supported (section
, start
, file
)
5064 Elf32_Internal_Shdr
* section
;
5065 unsigned char * start
;
5068 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
5069 SECTION_NAME (section
));
5074 /* A structure containing the name of a debug section and a pointer
5075 to a function that can decode it. */
5079 int (* display
) PARAMS((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
5083 { ".debug_info", display_debug_info
},
5084 { ".debug_abbrev", display_debug_abbrev
},
5085 { ".debug_line", display_debug_lines
},
5086 { ".debug_aranges", display_debug_aranges
},
5087 { ".debug_pubnames", display_debug_pubnames
},
5088 { ".debug_macinfo", display_debug_not_supported
},
5089 { ".debug_frame", display_debug_not_supported
},
5090 { ".debug_str", display_debug_not_supported
},
5091 { ".debug_static_func", display_debug_not_supported
},
5092 { ".debug_static_vars", display_debug_not_supported
},
5093 { ".debug_types", display_debug_not_supported
},
5094 { ".debug_weaknames", display_debug_not_supported
}
5098 display_debug_section (section
, file
)
5099 Elf32_Internal_Shdr
* section
;
5102 char * name
= SECTION_NAME (section
);
5103 bfd_size_type length
;
5104 unsigned char * start
;
5107 length
= section
->sh_size
;
5110 printf (_("\nSection '%s' has no debugging data.\n"), name
);
5114 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
5115 "debug section data");
5117 /* See if we know how to display the contents of this section. */
5118 for (i
= NUM_ELEM (debug_displays
); i
--;)
5119 if (strcmp (debug_displays
[i
].name
, name
) == 0)
5121 debug_displays
[i
].display (section
, start
, file
);
5126 printf (_("Unrecognised debug section: %s\n"), name
);
5130 /* If we loaded in the abbrev section at some point,
5131 we must release it here. */
5132 if (first_abbrev
!= NULL
)
5139 process_section_contents (file
)
5142 Elf32_Internal_Shdr
* section
;
5148 for (i
= 0, section
= section_headers
;
5149 i
< elf_header
.e_shnum
5150 && i
< num_dump_sects
;
5153 #ifdef SUPPORT_DISASSEMBLY
5154 if (dump_sects
[i
] & DISASS_DUMP
)
5155 disassemble_section (section
, file
);
5157 if (dump_sects
[i
] & HEX_DUMP
)
5158 dump_section (section
, file
);
5160 if (dump_sects
[i
] & DEBUG_DUMP
)
5161 display_debug_section (section
, file
);
5164 if (i
< num_dump_sects
)
5165 warn (_("Some sections were not dumped because they do not exist!\n"));
5171 process_mips_fpe_exception (mask
)
5177 if (mask
& OEX_FPU_INEX
)
5178 fputs ("INEX", stdout
), first
= 0;
5179 if (mask
& OEX_FPU_UFLO
)
5180 printf ("%sUFLO", first
? "" : "|"), first
= 0;
5181 if (mask
& OEX_FPU_OFLO
)
5182 printf ("%sOFLO", first
? "" : "|"), first
= 0;
5183 if (mask
& OEX_FPU_DIV0
)
5184 printf ("%sDIV0", first
? "" : "|"), first
= 0;
5185 if (mask
& OEX_FPU_INVAL
)
5186 printf ("%sINVAL", first
? "" : "|");
5189 fputs ("0", stdout
);
5193 process_mips_specific (file
)
5196 Elf_Internal_Dyn
*entry
;
5197 size_t liblist_offset
= 0;
5198 size_t liblistno
= 0;
5199 size_t conflictsno
= 0;
5200 size_t options_offset
= 0;
5201 size_t conflicts_offset
= 0;
5203 /* We have a lot of special sections. Thanks SGI! */
5204 if (dynamic_segment
== NULL
)
5205 /* No information available. */
5208 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
5209 switch (entry
->d_tag
)
5211 case DT_MIPS_LIBLIST
:
5212 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
5214 case DT_MIPS_LIBLISTNO
:
5215 liblistno
= entry
->d_un
.d_val
;
5217 case DT_MIPS_OPTIONS
:
5218 options_offset
= entry
->d_un
.d_val
- loadaddr
;
5220 case DT_MIPS_CONFLICT
:
5221 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
5223 case DT_MIPS_CONFLICTNO
:
5224 conflictsno
= entry
->d_un
.d_val
;
5230 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
5232 Elf32_External_Lib
*elib
;
5235 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
5236 elib
, Elf32_External_Lib
*, "liblist");
5238 printf ("\nSection '.liblist' contains %d entries:\n", liblistno
);
5239 fputs (" Library Time Stamp Checksum Version Flags\n",
5242 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
5248 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
5249 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
5250 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
5251 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
5252 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
5254 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
5256 printf ("%3d: %-20s %s %#10lx %-7ld", cnt
,
5257 dynamic_strings
+ liblist
.l_name
, timebuf
,
5258 liblist
.l_checksum
, liblist
.l_version
);
5260 if (liblist
.l_flags
== 0)
5270 { " EXACT_MATCH", LL_EXACT_MATCH
},
5271 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
5272 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
5273 { " EXPORTS", LL_EXPORTS
},
5274 { " DELAY_LOAD", LL_DELAY_LOAD
},
5275 { " DELTA", LL_DELTA
}
5277 int flags
= liblist
.l_flags
;
5281 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
5283 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
5285 fputs (l_flags_vals
[fcnt
].name
, stdout
);
5286 flags
^= l_flags_vals
[fcnt
].bit
;
5289 printf (" %#x", (unsigned int) flags
);
5298 if (options_offset
!= 0)
5300 Elf_External_Options
*eopt
;
5301 Elf_Internal_Shdr
*sect
= section_headers
;
5302 Elf_Internal_Options
*iopt
;
5303 Elf_Internal_Options
*option
;
5307 /* Find the section header so that we get the size. */
5308 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
5311 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
5312 Elf_External_Options
*, "options");
5314 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
5318 error (_("Out of memory"));
5324 while (offset
< sect
->sh_size
)
5326 Elf_External_Options
*eoption
;
5328 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
5330 option
->kind
= BYTE_GET (eoption
->kind
);
5331 option
->size
= BYTE_GET (eoption
->size
);
5332 option
->section
= BYTE_GET (eoption
->section
);
5333 option
->info
= BYTE_GET (eoption
->info
);
5335 offset
+= option
->size
;
5340 printf (_("\nSection '%s' contains %d entries:\n"),
5341 string_table
+ sect
->sh_name
, cnt
);
5348 switch (option
->kind
)
5351 /* This shouldn't happen. */
5352 printf (" NULL %d %lx", option
->section
, option
->info
);
5355 printf (" REGINFO ");
5356 if (elf_header
.e_machine
== EM_MIPS
)
5359 Elf32_External_RegInfo
*ereg
;
5360 Elf32_RegInfo reginfo
;
5362 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
5363 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
5364 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
5365 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
5366 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
5367 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
5368 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
5370 printf ("GPR %08lx GP 0x%lx\n",
5372 (unsigned long) reginfo
.ri_gp_value
);
5373 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
5374 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
5375 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
5380 Elf64_External_RegInfo
*ereg
;
5381 Elf64_Internal_RegInfo reginfo
;
5383 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
5384 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
5385 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
5386 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
5387 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
5388 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
5389 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
5391 printf ("GPR %08lx GP 0x",
5392 reginfo
.ri_gprmask
);
5393 printf_vma (reginfo
.ri_gp_value
);
5396 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
5397 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
5398 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
5402 case ODK_EXCEPTIONS
:
5403 fputs (" EXCEPTIONS fpe_min(", stdout
);
5404 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
5405 fputs (") fpe_max(", stdout
);
5406 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
5407 fputs (")", stdout
);
5409 if (option
->info
& OEX_PAGE0
)
5410 fputs (" PAGE0", stdout
);
5411 if (option
->info
& OEX_SMM
)
5412 fputs (" SMM", stdout
);
5413 if (option
->info
& OEX_FPDBUG
)
5414 fputs (" FPDBUG", stdout
);
5415 if (option
->info
& OEX_DISMISS
)
5416 fputs (" DISMISS", stdout
);
5419 fputs (" PAD ", stdout
);
5420 if (option
->info
& OPAD_PREFIX
)
5421 fputs (" PREFIX", stdout
);
5422 if (option
->info
& OPAD_POSTFIX
)
5423 fputs (" POSTFIX", stdout
);
5424 if (option
->info
& OPAD_SYMBOL
)
5425 fputs (" SYMBOL", stdout
);
5428 fputs (" HWPATCH ", stdout
);
5429 if (option
->info
& OHW_R4KEOP
)
5430 fputs (" R4KEOP", stdout
);
5431 if (option
->info
& OHW_R8KPFETCH
)
5432 fputs (" R8KPFETCH", stdout
);
5433 if (option
->info
& OHW_R5KEOP
)
5434 fputs (" R5KEOP", stdout
);
5435 if (option
->info
& OHW_R5KCVTL
)
5436 fputs (" R5KCVTL", stdout
);
5439 fputs (" FILL ", stdout
);
5440 /* XXX Print content of info word? */
5443 fputs (" TAGS ", stdout
);
5444 /* XXX Print content of info word? */
5447 fputs (" HWAND ", stdout
);
5448 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
5449 fputs (" R4KEOP_CHECKED", stdout
);
5450 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
5451 fputs (" R4KEOP_CLEAN", stdout
);
5454 fputs (" HWOR ", stdout
);
5455 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
5456 fputs (" R4KEOP_CHECKED", stdout
);
5457 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
5458 fputs (" R4KEOP_CLEAN", stdout
);
5461 printf (" GP_GROUP %#06lx self-contained %#06lx",
5462 option
->info
& OGP_GROUP
,
5463 (option
->info
& OGP_SELF
) >> 16);
5466 printf (" IDENT %#06lx self-contained %#06lx",
5467 option
->info
& OGP_GROUP
,
5468 (option
->info
& OGP_SELF
) >> 16);
5471 /* This shouldn't happen. */
5472 printf (" %3d ??? %d %lx",
5473 option
->kind
, option
->section
, option
->info
);
5477 len
= sizeof (*eopt
);
5478 while (len
< option
->size
)
5479 if (((char *) option
)[len
] >= ' '
5480 && ((char *) option
)[len
] < 0x7f)
5481 printf ("%c", ((char *) option
)[len
++]);
5483 printf ("\\%03o", ((char *) option
)[len
++]);
5485 fputs ("\n", stdout
);
5492 if (conflicts_offset
!= 0 && conflictsno
!= 0)
5494 Elf32_External_Conflict
*econf32
;
5495 Elf64_External_Conflict
*econf64
;
5496 Elf32_Conflict
*iconf
;
5499 if (dynamic_symbols
== NULL
)
5501 error (_("conflict list with without table"));
5505 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
5508 error (_("Out of memory"));
5512 if (binary_class
== ELFCLASS32
)
5514 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
5515 econf32
, Elf32_External_Conflict
*, "conflict");
5517 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
5518 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
5522 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
5523 econf64
, Elf64_External_Conflict
*, "conflict");
5525 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
5526 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
5529 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
5530 puts (_(" Num: Index Value Name"));
5532 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
5534 Elf_Internal_Sym
*psym
= &dynamic_symbols
[iconf
[cnt
]];
5536 printf ("%5u: %8lu %#10lx %s\n",
5537 cnt
, iconf
[cnt
], (unsigned long) psym
->st_value
,
5538 dynamic_strings
+ psym
->st_name
);
5549 process_arch_specific (file
)
5552 switch (elf_header
.e_machine
)
5555 case EM_MIPS_RS4_BE
:
5556 return process_mips_specific (file
);
5565 get_file_header (file
)
5568 Elf32_External_Ehdr ehdr
;
5570 if (fread (& ehdr
, sizeof (ehdr
), 1, file
) != 1)
5573 memcpy (elf_header
.e_ident
, ehdr
.e_ident
, EI_NIDENT
);
5575 if (elf_header
.e_ident
[EI_DATA
] == ELFDATA2LSB
)
5576 byte_get
= byte_get_little_endian
;
5578 byte_get
= byte_get_big_endian
;
5580 elf_header
.e_entry
= BYTE_GET (ehdr
.e_entry
);
5581 elf_header
.e_phoff
= BYTE_GET (ehdr
.e_phoff
);
5582 elf_header
.e_shoff
= BYTE_GET (ehdr
.e_shoff
);
5583 elf_header
.e_version
= BYTE_GET (ehdr
.e_version
);
5584 elf_header
.e_flags
= BYTE_GET (ehdr
.e_flags
);
5585 elf_header
.e_type
= BYTE_GET (ehdr
.e_type
);
5586 elf_header
.e_machine
= BYTE_GET (ehdr
.e_machine
);
5587 elf_header
.e_ehsize
= BYTE_GET (ehdr
.e_ehsize
);
5588 elf_header
.e_phentsize
= BYTE_GET (ehdr
.e_phentsize
);
5589 elf_header
.e_phnum
= BYTE_GET (ehdr
.e_phnum
);
5590 elf_header
.e_shentsize
= BYTE_GET (ehdr
.e_shentsize
);
5591 elf_header
.e_shnum
= BYTE_GET (ehdr
.e_shnum
);
5592 elf_header
.e_shstrndx
= BYTE_GET (ehdr
.e_shstrndx
);
5598 process_file (file_name
)
5602 struct stat statbuf
;
5605 if (stat (file_name
, & statbuf
) < 0)
5607 error (_("Cannot stat input file %s.\n"), file_name
);
5611 file
= fopen (file_name
, "rb");
5614 error (_("Input file %s not found.\n"), file_name
);
5618 if (! get_file_header (file
))
5620 error (_("%s: Failed to read file header\n"), file_name
);
5625 /* Initialise per file variables. */
5626 for (i
= NUM_ELEM (version_info
); i
--;)
5627 version_info
[i
] = 0;
5629 for (i
= NUM_ELEM (dynamic_info
); i
--;)
5630 dynamic_info
[i
] = 0;
5632 /* Process the file. */
5634 printf (_("\nFile: %s\n"), file_name
);
5636 if (! process_file_header ())
5642 process_section_headers (file
);
5644 process_program_headers (file
);
5646 process_dynamic_segment (file
);
5648 process_relocs (file
);
5650 process_symbol_table (file
);
5652 process_syminfo (file
);
5654 process_version_sections (file
);
5656 process_section_contents (file
);
5658 process_arch_specific (file
);
5662 if (section_headers
)
5664 free (section_headers
);
5665 section_headers
= NULL
;
5670 free (string_table
);
5671 string_table
= NULL
;
5674 if (dynamic_strings
)
5676 free (dynamic_strings
);
5677 dynamic_strings
= NULL
;
5680 if (dynamic_symbols
)
5682 free (dynamic_symbols
);
5683 dynamic_symbols
= NULL
;
5686 if (dynamic_syminfo
)
5688 free (dynamic_syminfo
);
5689 dynamic_syminfo
= NULL
;
5693 #ifdef SUPPORT_DISASSEMBLY
5694 /* Needed by the i386 disassembler. For extra credit, someone could
5695 fix this so that we insert symbolic addresses here, esp for GOT/PLT
5699 print_address (unsigned int addr
, FILE * outfile
)
5701 fprintf (outfile
,"0x%8.8x", addr
);
5704 /* Needed by the i386 disassembler. */
5706 db_task_printsym (unsigned int addr
)
5708 print_address (addr
, stderr
);
5717 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
5718 setlocale (LC_MESSAGES
, "");
5720 bindtextdomain (PACKAGE
, LOCALEDIR
);
5721 textdomain (PACKAGE
);
5723 parse_args (argc
, argv
);
5725 if (optind
< (argc
- 1))
5728 while (optind
< argc
)
5729 process_file (argv
[optind
++]);
5731 if (dump_sects
!= NULL
)