1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998, 99, 2000 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
26 #include <sys/types.h>
32 /* Define BFD64 here, even if our default architecture is 32 bit ELF
33 as this will allow us to read in and parse 64bit and 32bit ELF files.
34 Only do this if we belive that the compiler can support a 64 bit
35 data type. For now we only rely on GCC being able to do this. */
41 #include "elf/common.h"
42 #include "elf/external.h"
43 #include "elf/internal.h"
44 #include "elf/dwarf2.h"
46 /* The following headers use the elf/reloc-macros.h file to
47 automatically generate relocation recognition functions
48 such as elf_mips_reloc_type() */
50 #define RELOC_MACROS_GEN_FUNC
56 #include "elf/alpha.h"
59 #include "elf/sparc.h"
64 #include "elf/mn10200.h"
65 #include "elf/mn10300.h"
69 #include "elf/mcore.h"
77 #ifdef ANSI_PROTOTYPES
83 char * program_name
= "readelf";
84 unsigned int dynamic_addr
;
85 bfd_size_type dynamic_size
;
86 unsigned int rela_addr
;
87 unsigned int rela_size
;
88 char * dynamic_strings
;
90 unsigned long num_dynamic_syms
;
91 Elf_Internal_Sym
* dynamic_symbols
;
92 Elf_Internal_Syminfo
* dynamic_syminfo
;
93 unsigned long dynamic_syminfo_offset
;
94 unsigned int dynamic_syminfo_nent
;
95 char program_interpreter
[64];
96 int dynamic_info
[DT_JMPREL
+ 1];
99 Elf_Internal_Ehdr elf_header
;
100 Elf_Internal_Shdr
* section_headers
;
101 Elf_Internal_Dyn
* dynamic_segment
;
108 int do_using_dynamic
;
115 int do_debug_abbrevs
;
117 int do_debug_pubnames
;
118 int do_debug_aranges
;
123 /* A dynamic array of flags indicating which sections require dumping. */
124 char * dump_sects
= NULL
;
125 unsigned int num_dump_sects
= 0;
127 #define HEX_DUMP (1 << 0)
128 #define DISASS_DUMP (1 << 1)
129 #define DEBUG_DUMP (1 << 2)
131 /* How to rpint a vma value. */
132 typedef enum print_mode
144 /* Forward declarations for dumb compilers. */
145 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
146 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
147 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
148 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
149 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
150 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
151 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
152 static const char * get_dynamic_type
PARAMS ((unsigned long));
153 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
154 static char * get_file_type
PARAMS ((unsigned));
155 static char * get_machine_name
PARAMS ((unsigned));
156 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
157 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
158 static const char * get_mips_segment_type
PARAMS ((unsigned long));
159 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
160 static const char * get_segment_type
PARAMS ((unsigned long));
161 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
162 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
163 static const char * get_section_type_name
PARAMS ((unsigned int));
164 static const char * get_symbol_binding
PARAMS ((unsigned int));
165 static const char * get_symbol_type
PARAMS ((unsigned int));
166 static const char * get_symbol_visibility
PARAMS ((unsigned int));
167 static const char * get_symbol_index_type
PARAMS ((unsigned int));
168 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
169 static void usage
PARAMS ((void));
170 static void parse_args
PARAMS ((int, char **));
171 static int process_file_header
PARAMS ((void));
172 static int process_program_headers
PARAMS ((FILE *));
173 static int process_section_headers
PARAMS ((FILE *));
174 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
175 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
176 static int process_dynamic_segment
PARAMS ((FILE *));
177 static int process_symbol_table
PARAMS ((FILE *));
178 static int process_section_contents
PARAMS ((FILE *));
179 static void process_file
PARAMS ((char *));
180 static int process_relocs
PARAMS ((FILE *));
181 static int process_version_sections
PARAMS ((FILE *));
182 static char * get_ver_flags
PARAMS ((unsigned int));
183 static int get_32bit_section_headers
PARAMS ((FILE *));
184 static int get_64bit_section_headers
PARAMS ((FILE *));
185 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
186 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
187 static int get_file_header
PARAMS ((FILE *));
188 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
189 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
190 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
191 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
192 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
193 #ifdef SUPPORT_DISASSEMBLY
194 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
196 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
197 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
198 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
199 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
200 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
201 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
202 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
203 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
204 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
205 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
206 static void reset_state_machine
PARAMS ((int));
207 static char * get_TAG_name
PARAMS ((unsigned long));
208 static char * get_AT_name
PARAMS ((unsigned long));
209 static char * get_FORM_name
PARAMS ((unsigned long));
210 static void free_abbrevs
PARAMS ((void));
211 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
212 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
213 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
214 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
215 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
216 static void request_dump
PARAMS ((unsigned int, char));
217 static const char * get_elf_class
PARAMS ((unsigned char));
218 static const char * get_data_encoding
PARAMS ((unsigned char));
219 static const char * get_osabi_name
PARAMS ((unsigned char));
220 static int guess_is_rela
PARAMS ((unsigned long));
221 static char * get_note_type
PARAMS ((unsigned int));
222 static int process_note
PARAMS ((Elf32_Internal_Note
*));
223 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
224 static int process_corefile_note_segments
PARAMS ((FILE *));
225 static int process_corefile_contents
PARAMS ((FILE *));
227 typedef int Elf32_Word
;
235 #define SECTION_NAME(X) (string_table + (X)->sh_name)
237 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
239 #define BYTE_GET(field) byte_get (field, sizeof (field))
241 /* If we can support a 64 bit data type then BFD64 should be defined
242 and sizeof (bfd_vma) == 8. In this case when translating from an
243 external 8 byte field to an internal field, we can assume that the
244 internal field is also 8 bytes wide and so we can extact all the data.
245 If, however, BFD64 is not defined, then we must assume that the
246 internal data structure only has 4 byte wide fields that are the
247 equivalent of the 8 byte wide external counterparts, and so we must
248 truncate the data. */
250 #define BYTE_GET8(field) byte_get (field, -8)
252 #define BYTE_GET8(field) byte_get (field, 8)
255 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
257 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
258 if (fseek (file, offset, SEEK_SET)) \
260 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
264 var = (type) malloc (size); \
268 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
272 if (fread (var, size, 1, file) != 1) \
274 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
281 #define GET_DATA(offset, var, reason) \
282 if (fseek (file, offset, SEEK_SET)) \
284 error (_("Unable to seek to %x for %s\n"), offset, reason); \
287 else if (fread (& var, sizeof (var), 1, file) != 1) \
289 error (_("Unable to read data at %x for %s\n"), offset, reason); \
293 #define GET_ELF_SYMBOLS(file, offset, size) \
294 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
295 : get_64bit_elf_symbols (file, offset, size))
298 #ifdef ANSI_PROTOTYPES
300 error (const char * message
, ...)
304 fprintf (stderr
, _("%s: Error: "), program_name
);
305 va_start (args
, message
);
306 vfprintf (stderr
, message
, args
);
312 warn (const char * message
, ...)
316 fprintf (stderr
, _("%s: Warning: "), program_name
);
317 va_start (args
, message
);
318 vfprintf (stderr
, message
, args
);
330 fprintf (stderr
, _("%s: Error: "), program_name
);
332 message
= va_arg (args
, char *);
333 vfprintf (stderr
, message
, args
);
345 fprintf (stderr
, _("%s: Warning: "), program_name
);
347 message
= va_arg (args
, char *);
348 vfprintf (stderr
, message
, args
);
355 byte_get_little_endian (field
, size
)
356 unsigned char * field
;
365 return ((unsigned int) (field
[0]))
366 | (((unsigned int) (field
[1])) << 8);
369 /* We want to extract data from an 8 byte wide field and
370 place it into a 4 byte wide field. Since this is a little
371 endian source we can juts use the 4 byte extraction code. */
374 return ((unsigned long) (field
[0]))
375 | (((unsigned long) (field
[1])) << 8)
376 | (((unsigned long) (field
[2])) << 16)
377 | (((unsigned long) (field
[3])) << 24);
381 /* This is a special case, generated by the BYTE_GET8 macro.
382 It means that we are loading an 8 byte value from a field
383 in an external structure into an 8 byte value in a field
384 in an internal strcuture. */
385 return ((bfd_vma
) (field
[0]))
386 | (((bfd_vma
) (field
[1])) << 8)
387 | (((bfd_vma
) (field
[2])) << 16)
388 | (((bfd_vma
) (field
[3])) << 24)
389 | (((bfd_vma
) (field
[4])) << 32)
390 | (((bfd_vma
) (field
[5])) << 40)
391 | (((bfd_vma
) (field
[6])) << 48)
392 | (((bfd_vma
) (field
[7])) << 56);
395 error (_("Unhandled data length: %d\n"), size
);
400 /* Print a VMA value. */
402 print_vma (vma
, mode
)
412 case FULL_HEX
: printf ("0x"); /* drop through */
413 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
414 case PREFIX_HEX
: printf ("0x"); /* drop through */
415 case HEX
: printf ("%lx", (unsigned long) vma
); break;
416 case DEC
: printf ("%ld", (unsigned long) vma
); break;
417 case DEC_5
: printf ("%5ld", (long) vma
); break;
418 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
439 #if BFD_HOST_64BIT_LONG
442 if (_bfd_int64_high (vma
))
443 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
445 printf ("%lx", _bfd_int64_low (vma
));
450 #if BFD_HOST_64BIT_LONG
453 if (_bfd_int64_high (vma
))
455 printf ("++%ld", _bfd_int64_low (vma
));
457 printf ("%ld", _bfd_int64_low (vma
));
462 #if BFD_HOST_64BIT_LONG
463 printf ("%5ld", vma
);
465 if (_bfd_int64_high (vma
))
467 printf ("++%ld", _bfd_int64_low (vma
));
469 printf ("%5ld", _bfd_int64_low (vma
));
474 #if BFD_HOST_64BIT_LONG
477 if (_bfd_int64_high (vma
))
479 printf ("++%lu", _bfd_int64_low (vma
));
481 printf ("%lu", _bfd_int64_low (vma
));
490 byte_get_big_endian (field
, size
)
491 unsigned char * field
;
500 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
503 return ((unsigned long) (field
[3]))
504 | (((unsigned long) (field
[2])) << 8)
505 | (((unsigned long) (field
[1])) << 16)
506 | (((unsigned long) (field
[0])) << 24);
509 /* Although we are extracing data from an 8 byte wide field, we
510 are returning only 4 bytes of data. */
511 return ((unsigned long) (field
[7]))
512 | (((unsigned long) (field
[6])) << 8)
513 | (((unsigned long) (field
[5])) << 16)
514 | (((unsigned long) (field
[4])) << 24);
518 /* This is a special case, generated by the BYTE_GET8 macro.
519 It means that we are loading an 8 byte value from a field
520 in an external structure into an 8 byte value in a field
521 in an internal strcuture. */
522 return ((bfd_vma
) (field
[7]))
523 | (((bfd_vma
) (field
[6])) << 8)
524 | (((bfd_vma
) (field
[5])) << 16)
525 | (((bfd_vma
) (field
[4])) << 24)
526 | (((bfd_vma
) (field
[3])) << 32)
527 | (((bfd_vma
) (field
[2])) << 40)
528 | (((bfd_vma
) (field
[1])) << 48)
529 | (((bfd_vma
) (field
[0])) << 56);
533 error (_("Unhandled data length: %d\n"), size
);
539 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
541 guess_is_rela (e_machine
)
542 unsigned long e_machine
;
546 /* Targets that use REL relocations. */
557 /* Targets that use RELA relocations. */
565 case EM_CYGNUS_MN10200
:
566 case EM_CYGNUS_MN10300
:
592 warn (_("Don't know about relocations on this machine architecture\n"));
597 /* Display the contents of the relocation data found at the specified offset. */
599 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
601 unsigned long rel_offset
;
602 unsigned long rel_size
;
603 Elf_Internal_Sym
* symtab
;
609 Elf_Internal_Rel
* rels
;
610 Elf_Internal_Rela
* relas
;
613 if (is_rela
== UNKNOWN
)
614 is_rela
= guess_is_rela (elf_header
.e_machine
);
620 Elf32_External_Rela
* erelas
;
622 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
623 Elf32_External_Rela
*, "relocs");
625 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
627 relas
= (Elf_Internal_Rela
*)
628 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
632 error(_("out of memory parsing relocs"));
636 for (i
= 0; i
< rel_size
; i
++)
638 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
639 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
640 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
645 rels
= (Elf_Internal_Rel
*) relas
;
649 Elf64_External_Rela
* erelas
;
651 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
652 Elf64_External_Rela
*, "relocs");
654 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
656 relas
= (Elf_Internal_Rela
*)
657 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
661 error(_("out of memory parsing relocs"));
665 for (i
= 0; i
< rel_size
; i
++)
667 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
668 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
669 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
674 rels
= (Elf_Internal_Rel
*) relas
;
681 Elf32_External_Rel
* erels
;
683 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
684 Elf32_External_Rel
*, "relocs");
686 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
688 rels
= (Elf_Internal_Rel
*)
689 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
693 error(_("out of memory parsing relocs"));
697 for (i
= 0; i
< rel_size
; i
++)
699 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
700 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
705 relas
= (Elf_Internal_Rela
*) rels
;
709 Elf64_External_Rel
* erels
;
711 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
712 Elf64_External_Rel
*, "relocs");
714 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
716 rels
= (Elf_Internal_Rel
*)
717 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
721 error(_("out of memory parsing relocs"));
725 for (i
= 0; i
< rel_size
; i
++)
727 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
728 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
733 relas
= (Elf_Internal_Rela
*) rels
;
739 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
742 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
744 for (i
= 0; i
< rel_size
; i
++)
749 bfd_vma symtab_index
;
754 offset
= relas
[i
].r_offset
;
755 info
= relas
[i
].r_info
;
759 offset
= rels
[i
].r_offset
;
760 info
= rels
[i
].r_info
;
765 type
= ELF32_R_TYPE (info
);
766 symtab_index
= ELF32_R_SYM (info
);
770 if (elf_header
.e_machine
== EM_SPARCV9
)
771 type
= ELF64_R_TYPE_ID (info
);
773 type
= ELF64_R_TYPE (info
);
774 /* The #ifdef BFD64 below is to prevent a compile time warning.
775 We know that if we do not have a 64 bit data type that we
776 will never execute this code anyway. */
778 symtab_index
= ELF64_R_SYM (info
);
782 #ifdef _bfd_int64_low
783 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
785 printf (" %8.8lx %5.5lx ", offset
, info
);
788 switch (elf_header
.e_machine
)
795 rtype
= elf_m32r_reloc_type (type
);
800 rtype
= elf_i386_reloc_type (type
);
804 rtype
= elf_m68k_reloc_type (type
);
808 rtype
= elf_i960_reloc_type (type
);
812 rtype
= elf_avr_reloc_type (type
);
819 rtype
= elf_sparc_reloc_type (type
);
823 rtype
= v850_reloc_type (type
);
827 rtype
= elf_d10v_reloc_type (type
);
831 rtype
= elf_d30v_reloc_type (type
);
835 rtype
= elf_sh_reloc_type (type
);
838 case EM_CYGNUS_MN10300
:
839 rtype
= elf_mn10300_reloc_type (type
);
842 case EM_CYGNUS_MN10200
:
843 rtype
= elf_mn10200_reloc_type (type
);
847 rtype
= elf_fr30_reloc_type (type
);
851 rtype
= elf_mcore_reloc_type (type
);
855 rtype
= elf_ppc_reloc_type (type
);
860 rtype
= elf_mips_reloc_type (type
);
864 rtype
= elf_alpha_reloc_type (type
);
868 rtype
= elf_arm_reloc_type (type
);
872 rtype
= elf_arc_reloc_type (type
);
876 rtype
= elf_hppa_reloc_type (type
);
880 rtype
= elf_pj_reloc_type (type
);
885 #ifdef _bfd_int64_low
886 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
888 printf (_("unrecognised: %-7lx"), type
);
891 printf ("%-21.21s", rtype
);
897 if (symtab_index
>= nsyms
)
898 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
901 Elf_Internal_Sym
* psym
;
903 psym
= symtab
+ symtab_index
;
906 print_vma (psym
->st_value
, LONG_HEX
);
909 if (psym
->st_name
== 0)
911 SECTION_NAME (section_headers
+ psym
->st_shndx
));
912 else if (strtab
== NULL
)
913 printf (_("<string table index %3ld>"), psym
->st_name
);
915 printf ("%-25.25s", strtab
+ psym
->st_name
);
918 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
924 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
925 print_vma (relas
[i
].r_addend
, LONG_HEX
);
928 if (elf_header
.e_machine
== EM_SPARCV9
929 && !strcmp (rtype
, "R_SPARC_OLO10"))
930 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
941 get_mips_dynamic_type (type
)
946 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
947 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
948 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
949 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
950 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
951 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
952 case DT_MIPS_MSYM
: return "MIPS_MSYM";
953 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
954 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
955 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
956 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
957 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
958 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
959 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
960 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
961 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
962 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
963 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
964 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
965 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
966 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
967 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
968 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
969 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
970 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
971 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
972 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
973 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
974 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
975 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
976 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
977 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
978 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
979 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
980 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
981 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
982 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
983 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
984 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
985 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
986 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
987 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
988 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
995 get_sparc64_dynamic_type (type
)
1000 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1007 get_parisc_dynamic_type (type
)
1012 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1013 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1014 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1015 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1016 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1017 case DT_HP_PREINIT
: return "HP_PREINIT";
1018 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1019 case DT_HP_NEEDED
: return "HP_NEEDED";
1020 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1021 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1022 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1023 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1024 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1031 get_dynamic_type (type
)
1034 static char buff
[32];
1038 case DT_NULL
: return "NULL";
1039 case DT_NEEDED
: return "NEEDED";
1040 case DT_PLTRELSZ
: return "PLTRELSZ";
1041 case DT_PLTGOT
: return "PLTGOT";
1042 case DT_HASH
: return "HASH";
1043 case DT_STRTAB
: return "STRTAB";
1044 case DT_SYMTAB
: return "SYMTAB";
1045 case DT_RELA
: return "RELA";
1046 case DT_RELASZ
: return "RELASZ";
1047 case DT_RELAENT
: return "RELAENT";
1048 case DT_STRSZ
: return "STRSZ";
1049 case DT_SYMENT
: return "SYMENT";
1050 case DT_INIT
: return "INIT";
1051 case DT_FINI
: return "FINI";
1052 case DT_SONAME
: return "SONAME";
1053 case DT_RPATH
: return "RPATH";
1054 case DT_SYMBOLIC
: return "SYMBOLIC";
1055 case DT_REL
: return "REL";
1056 case DT_RELSZ
: return "RELSZ";
1057 case DT_RELENT
: return "RELENT";
1058 case DT_PLTREL
: return "PLTREL";
1059 case DT_DEBUG
: return "DEBUG";
1060 case DT_TEXTREL
: return "TEXTREL";
1061 case DT_JMPREL
: return "JMPREL";
1062 case DT_BIND_NOW
: return "BIND_NOW";
1063 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1064 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1065 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1066 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1067 case DT_RUNPATH
: return "RUNPATH";
1068 case DT_FLAGS
: return "FLAGS";
1070 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1071 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1073 case DT_PLTPADSZ
: return "PLTPADSZ";
1074 case DT_MOVEENT
: return "MOVEENT";
1075 case DT_MOVESZ
: return "MOVESZ";
1076 case DT_FEATURE_1
: return "FEATURE_1";
1077 case DT_POSFLAG_1
: return "POSFLAG_1";
1078 case DT_SYMINSZ
: return "SYMINSZ";
1079 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1081 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1082 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1084 case DT_VERSYM
: return "VERSYM";
1086 case DT_RELACOUNT
: return "RELACOUNT";
1087 case DT_RELCOUNT
: return "RELCOUNT";
1088 case DT_FLAGS_1
: return "FLAGS_1";
1089 case DT_VERDEF
: return "VERDEF";
1090 case DT_VERDEFNUM
: return "VERDEFNUM";
1091 case DT_VERNEED
: return "VERNEED";
1092 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1094 case DT_AUXILIARY
: return "AUXILARY";
1095 case DT_USED
: return "USED";
1096 case DT_FILTER
: return "FILTER";
1099 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1101 const char * result
;
1103 switch (elf_header
.e_machine
)
1106 case EM_MIPS_RS4_BE
:
1107 result
= get_mips_dynamic_type (type
);
1110 result
= get_sparc64_dynamic_type (type
);
1120 sprintf (buff
, _("Processor Specific: %lx"), type
);
1122 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1124 const char * result
;
1126 switch (elf_header
.e_machine
)
1129 result
= get_parisc_dynamic_type (type
);
1139 sprintf (buff
, _("Operating System specific: %lx"), type
);
1142 sprintf (buff
, _("<unknown>: %lx"), type
);
1149 get_file_type (e_type
)
1152 static char buff
[32];
1156 case ET_NONE
: return _("NONE (None)");
1157 case ET_REL
: return _("REL (Relocatable file)");
1158 case ET_EXEC
: return _("EXEC (Executable file)");
1159 case ET_DYN
: return _("DYN (Shared object file)");
1160 case ET_CORE
: return _("CORE (Core file)");
1163 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1164 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1165 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1166 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1168 sprintf (buff
, _("<unknown>: %x"), e_type
);
1174 get_machine_name (e_machine
)
1177 static char buff
[64]; /* XXX */
1181 case EM_NONE
: return _("None");
1182 case EM_M32
: return "WE32100";
1183 case EM_SPARC
: return "Sparc";
1184 case EM_386
: return "Intel 80386";
1185 case EM_68K
: return "MC68000";
1186 case EM_88K
: return "MC88000";
1187 case EM_486
: return "Intel 80486";
1188 case EM_860
: return "Intel 80860";
1189 case EM_MIPS
: return "MIPS R3000";
1190 case EM_S370
: return "IBM System/370";
1191 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1192 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1193 case EM_PARISC
: return "HPPA";
1194 case EM_PPC_OLD
: return "Power PC (old)";
1195 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1196 case EM_960
: return "Intel 90860";
1197 case EM_PPC
: return "PowerPC";
1198 case EM_V800
: return "NEC V800";
1199 case EM_FR20
: return "Fujitsu FR20";
1200 case EM_RH32
: return "TRW RH32";
1201 case EM_MCORE
: return "MCORE";
1202 case EM_ARM
: return "ARM";
1203 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1204 case EM_SH
: return "Hitachi SH";
1205 case EM_SPARCV9
: return "Sparc v9";
1206 case EM_TRICORE
: return "Siemens Tricore";
1207 case EM_ARC
: return "Argonaut RISC Core";
1208 case EM_H8_300
: return "Hitachi H8/300";
1209 case EM_H8_300H
: return "Hitachi H8/300H";
1210 case EM_H8S
: return "Hitachi H8S";
1211 case EM_H8_500
: return "Hitachi H8/500";
1212 case EM_IA_64
: return "Intel IA-64";
1213 case EM_MIPS_X
: return "Stanford MIPS-X";
1214 case EM_COLDFIRE
: return "Motorola Coldfire";
1215 case EM_68HC12
: return "Motorola M68HC12";
1216 case EM_ALPHA
: return "Alpha";
1217 case EM_CYGNUS_D10V
: return "d10v";
1218 case EM_CYGNUS_D30V
: return "d30v";
1219 case EM_CYGNUS_ARC
: return "Arc";
1220 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1221 case EM_CYGNUS_V850
: return "NEC v850";
1222 case EM_CYGNUS_MN10300
: return "mn10300";
1223 case EM_CYGNUS_MN10200
: return "mn10200";
1224 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1225 case EM_PJ
: return "picoJava";
1226 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1227 case EM_PCP
: return "Siemens PCP";
1228 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1229 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1230 case EM_STARCORE
: return "Motorola Star*Core processor";
1231 case EM_ME16
: return "Toyota ME16 processor";
1232 case EM_ST100
: return "STMicroelectronics ST100 processor";
1233 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1234 case EM_FX66
: return "Siemens FX66 microcontroller";
1235 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1236 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1237 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1238 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1239 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1240 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1241 case EM_SVX
: return "Silicon Graphics SVx";
1242 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1243 case EM_VAX
: return "Digital VAX";
1244 case EM_AVR
: return "AVR";
1246 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1252 decode_ARM_machine_flags (e_flags
, buf
)
1259 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1260 e_flags
&= ~ EF_ARM_EABIMASK
;
1262 /* Handle "generic" ARM flags. */
1263 if (e_flags
& EF_ARM_RELEXEC
)
1265 strcat (buf
, ", relocatable executable");
1266 e_flags
&= ~ EF_ARM_RELEXEC
;
1269 if (e_flags
& EF_ARM_HASENTRY
)
1271 strcat (buf
, ", has entry point");
1272 e_flags
&= ~ EF_ARM_HASENTRY
;
1275 /* Now handle EABI specific flags. */
1279 strcat (buf
, ", <unknown EABI>");
1284 case EF_ARM_EABI_VER1
:
1289 /* Process flags one bit at a time. */
1290 flag
= e_flags
& - e_flags
;
1295 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_INTERWORK. */
1296 strcat (buf
, ", sorted symbol tables");
1306 case EF_ARM_EABI_UNKNOWN
:
1311 /* Process flags one bit at a time. */
1312 flag
= e_flags
& - e_flags
;
1318 strcat (buf
, ", interworking enabled");
1322 strcat (buf
, ", uses APCS/26");
1326 strcat (buf
, ", uses APCS/float");
1330 strcat (buf
, ", position independent");
1334 strcat (buf
, ", 8 bit structure alignment");
1338 strcat (buf
, ", uses new ABI");
1342 strcat (buf
, ", uses old ABI");
1346 strcat (buf
, ", software FP");
1357 strcat (buf
,", <unknown>");
1361 get_machine_flags (e_flags
, e_machine
)
1365 static char buf
[1024];
1377 decode_ARM_machine_flags (e_flags
, buf
);
1381 if (e_flags
& EF_CPU32
)
1382 strcat (buf
, ", cpu32");
1386 if (e_flags
& EF_PPC_EMB
)
1387 strcat (buf
, ", emb");
1389 if (e_flags
& EF_PPC_RELOCATABLE
)
1390 strcat (buf
, ", relocatable");
1392 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1393 strcat (buf
, ", relocatable-lib");
1396 case EM_CYGNUS_V850
:
1397 switch (e_flags
& EF_V850_ARCH
)
1400 strcat (buf
, ", v850e");
1403 strcat (buf
, ", v850ea");
1406 strcat (buf
, ", v850");
1409 strcat (buf
, ", unknown v850 architecture variant");
1414 case EM_CYGNUS_M32R
:
1415 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1416 strcat (buf
, ", m32r");
1421 case EM_MIPS_RS4_BE
:
1422 if (e_flags
& EF_MIPS_NOREORDER
)
1423 strcat (buf
, ", noreorder");
1425 if (e_flags
& EF_MIPS_PIC
)
1426 strcat (buf
, ", pic");
1428 if (e_flags
& EF_MIPS_CPIC
)
1429 strcat (buf
, ", cpic");
1431 if (e_flags
& EF_MIPS_ABI2
)
1432 strcat (buf
, ", abi2");
1434 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1435 strcat (buf
, ", mips1");
1437 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1438 strcat (buf
, ", mips2");
1440 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1441 strcat (buf
, ", mips3");
1443 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1444 strcat (buf
, ", mips4");
1448 if (e_flags
& EF_SPARC_32PLUS
)
1449 strcat (buf
, ", v8+");
1451 if (e_flags
& EF_SPARC_SUN_US1
)
1452 strcat (buf
, ", ultrasparcI");
1454 if (e_flags
& EF_SPARC_SUN_US3
)
1455 strcat (buf
, ", ultrasparcIII");
1457 if (e_flags
& EF_SPARC_HAL_R1
)
1458 strcat (buf
, ", halr1");
1460 if (e_flags
& EF_SPARC_LEDATA
)
1461 strcat (buf
, ", ledata");
1463 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1464 strcat (buf
, ", tso");
1466 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1467 strcat (buf
, ", pso");
1469 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1470 strcat (buf
, ", rmo");
1474 switch (e_flags
& EF_PARISC_ARCH
)
1476 case EFA_PARISC_1_0
:
1477 strcpy (buf
, ", PA-RISC 1.0");
1479 case EFA_PARISC_1_1
:
1480 strcpy (buf
, ", PA-RISC 1.1");
1482 case EFA_PARISC_2_0
:
1483 strcpy (buf
, ", PA-RISC 2.0");
1488 if (e_flags
& EF_PARISC_TRAPNIL
)
1489 strcat (buf
, ", trapnil");
1490 if (e_flags
& EF_PARISC_EXT
)
1491 strcat (buf
, ", ext");
1492 if (e_flags
& EF_PARISC_LSB
)
1493 strcat (buf
, ", lsb");
1494 if (e_flags
& EF_PARISC_WIDE
)
1495 strcat (buf
, ", wide");
1496 if (e_flags
& EF_PARISC_NO_KABP
)
1497 strcat (buf
, ", no kabp");
1498 if (e_flags
& EF_PARISC_LAZYSWAP
)
1499 strcat (buf
, ", lazyswap");
1503 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1504 strcat (buf
, ", new calling convention");
1506 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1507 strcat (buf
, ", gnu calling convention");
1516 get_mips_segment_type (type
)
1521 case PT_MIPS_REGINFO
:
1523 case PT_MIPS_RTPROC
:
1525 case PT_MIPS_OPTIONS
:
1535 get_parisc_segment_type (type
)
1540 case PT_HP_TLS
: return "HP_TLS";
1541 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1542 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1543 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1544 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1545 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1546 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1547 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1548 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1549 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1550 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1551 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1552 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1553 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1562 get_segment_type (p_type
)
1563 unsigned long p_type
;
1565 static char buff
[32];
1569 case PT_NULL
: return "NULL";
1570 case PT_LOAD
: return "LOAD";
1571 case PT_DYNAMIC
: return "DYNAMIC";
1572 case PT_INTERP
: return "INTERP";
1573 case PT_NOTE
: return "NOTE";
1574 case PT_SHLIB
: return "SHLIB";
1575 case PT_PHDR
: return "PHDR";
1578 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1580 const char * result
;
1582 switch (elf_header
.e_machine
)
1585 case EM_MIPS_RS4_BE
:
1586 result
= get_mips_segment_type (p_type
);
1589 result
= get_parisc_segment_type (p_type
);
1599 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1601 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1603 const char * result
;
1605 switch (elf_header
.e_machine
)
1608 result
= get_parisc_segment_type (p_type
);
1618 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1621 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1628 get_mips_section_type_name (sh_type
)
1629 unsigned int sh_type
;
1633 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1634 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1635 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1636 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1637 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1638 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1639 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1640 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1641 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1642 case SHT_MIPS_RELD
: return "MIPS_RELD";
1643 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1644 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1645 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1646 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1647 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1648 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1649 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1650 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1651 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1652 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1653 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1654 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1655 case SHT_MIPS_LINE
: return "MIPS_LINE";
1656 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1657 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1658 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1659 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1660 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1661 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1662 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1663 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1664 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1665 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1666 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1667 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1668 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1669 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1670 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1671 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1679 get_parisc_section_type_name (sh_type
)
1680 unsigned int sh_type
;
1684 case SHT_PARISC_EXT
: return "PARISC_EXT";
1685 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1686 case SHT_PARISC_DOC
: return "PARISC_DOC";
1694 get_section_type_name (sh_type
)
1695 unsigned int sh_type
;
1697 static char buff
[32];
1701 case SHT_NULL
: return "NULL";
1702 case SHT_PROGBITS
: return "PROGBITS";
1703 case SHT_SYMTAB
: return "SYMTAB";
1704 case SHT_STRTAB
: return "STRTAB";
1705 case SHT_RELA
: return "RELA";
1706 case SHT_HASH
: return "HASH";
1707 case SHT_DYNAMIC
: return "DYNAMIC";
1708 case SHT_NOTE
: return "NOTE";
1709 case SHT_NOBITS
: return "NOBITS";
1710 case SHT_REL
: return "REL";
1711 case SHT_SHLIB
: return "SHLIB";
1712 case SHT_DYNSYM
: return "DYNSYM";
1713 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1714 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1715 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1716 case SHT_GNU_verdef
: return "VERDEF";
1717 case SHT_GNU_verneed
: return "VERNEED";
1718 case SHT_GNU_versym
: return "VERSYM";
1719 case 0x6ffffff0: return "VERSYM";
1720 case 0x6ffffffc: return "VERDEF";
1721 case 0x7ffffffd: return "AUXILIARY";
1722 case 0x7fffffff: return "FILTER";
1725 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1727 const char * result
;
1729 switch (elf_header
.e_machine
)
1732 case EM_MIPS_RS4_BE
:
1733 result
= get_mips_section_type_name (sh_type
);
1736 result
= get_parisc_section_type_name (sh_type
);
1746 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1748 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1749 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1750 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1751 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1753 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1759 struct option options
[] =
1761 {"all", no_argument
, 0, 'a'},
1762 {"file-header", no_argument
, 0, 'h'},
1763 {"program-headers", no_argument
, 0, 'l'},
1764 {"headers", no_argument
, 0, 'e'},
1765 {"histogram", no_argument
, 0, 'I'},
1766 {"segments", no_argument
, 0, 'l'},
1767 {"sections", no_argument
, 0, 'S'},
1768 {"section-headers", no_argument
, 0, 'S'},
1769 {"symbols", no_argument
, 0, 's'},
1770 {"syms", no_argument
, 0, 's'},
1771 {"relocs", no_argument
, 0, 'r'},
1772 {"notes", no_argument
, 0, 'n'},
1773 {"dynamic", no_argument
, 0, 'd'},
1774 {"arch-specific", no_argument
, 0, 'A'},
1775 {"version-info", no_argument
, 0, 'V'},
1776 {"use-dynamic", no_argument
, 0, 'D'},
1777 {"hex-dump", required_argument
, 0, 'x'},
1778 {"debug-dump", optional_argument
, 0, 'w'},
1779 #ifdef SUPPORT_DISASSEMBLY
1780 {"instruction-dump", required_argument
, 0, 'i'},
1783 {"version", no_argument
, 0, 'v'},
1784 {"help", no_argument
, 0, 'H'},
1785 {0, no_argument
, 0, 0}
1791 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1792 fprintf (stdout
, _(" Options are:\n"));
1793 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1794 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1795 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1796 fprintf (stdout
, _(" Display the program headers\n"));
1797 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1798 fprintf (stdout
, _(" Display the sections' header\n"));
1799 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1800 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1801 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1802 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1803 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1804 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1805 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1806 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1807 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1808 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1809 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1810 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1811 #ifdef SUPPORT_DISASSEMBLY
1812 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1813 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1815 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1816 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1817 fprintf (stdout
, _(" -H or --help Display this information\n"));
1818 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1824 request_dump (section
, type
)
1825 unsigned int section
;
1828 if (section
>= num_dump_sects
)
1830 char * new_dump_sects
;
1832 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1834 if (new_dump_sects
== NULL
)
1835 error (_("Out of memory allocating dump request table."));
1838 /* Copy current flag settings. */
1839 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1843 dump_sects
= new_dump_sects
;
1844 num_dump_sects
= section
+ 1;
1849 dump_sects
[section
] |= type
;
1855 parse_args (argc
, argv
)
1864 while ((c
= getopt_long
1865 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1900 do_using_dynamic
++;
1928 section
= strtoul (optarg
, & cp
, 0);
1929 if (! * cp
&& section
>= 0)
1931 request_dump (section
, HEX_DUMP
);
1951 do_debug_abbrevs
= 1;
1961 do_debug_pubnames
= 1;
1966 do_debug_aranges
= 1;
1970 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1975 #ifdef SUPPORT_DISASSEMBLY
1978 section
= strtoul (optarg
, & cp
, 0);
1979 if (! * cp
&& section
>= 0)
1981 request_dump (section
, DISASS_DUMP
);
1987 print_version (program_name
);
1994 /* xgettext:c-format */
1995 error (_("Invalid option '-%c'\n"), c
);
2002 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
2003 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2004 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2008 warn (_("Nothing to do.\n"));
2014 get_elf_class (elf_class
)
2015 unsigned char elf_class
;
2017 static char buff
[32];
2021 case ELFCLASSNONE
: return _("none");
2022 case ELFCLASS32
: return _("ELF32");
2023 case ELFCLASS64
: return _("ELF64");
2025 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2031 get_data_encoding (encoding
)
2032 unsigned char encoding
;
2034 static char buff
[32];
2038 case ELFDATANONE
: return _("none");
2039 case ELFDATA2LSB
: return _("2's complement, little endian");
2040 case ELFDATA2MSB
: return _("2's complement, big endian");
2042 sprintf (buff
, _("<unknown: %x>"), encoding
);
2048 get_osabi_name (osabi
)
2049 unsigned char osabi
;
2051 static char buff
[32];
2055 case ELFOSABI_SYSV
: return _("UNIX - System V");
2056 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2057 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2058 case ELFOSABI_STANDALONE
: return _("Standalone App");
2059 case ELFOSABI_ARM
: return _("ARM");
2061 sprintf (buff
, _("<unknown: %x>"), osabi
);
2066 /* Decode the data held in 'elf_header'. */
2068 process_file_header ()
2070 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2071 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2072 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2073 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2076 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2084 printf (_("ELF Header:\n"));
2085 printf (_(" Magic: "));
2086 for (i
= 0; i
< EI_NIDENT
; i
++)
2087 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2089 printf (_(" Class: %s\n"),
2090 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2091 printf (_(" Data: %s\n"),
2092 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2093 printf (_(" Version: %d %s\n"),
2094 elf_header
.e_ident
[EI_VERSION
],
2095 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2097 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2100 printf (_(" OS/ABI: %s\n"),
2101 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2102 printf (_(" ABI Version: %d\n"),
2103 elf_header
.e_ident
[EI_ABIVERSION
]);
2104 printf (_(" Type: %s\n"),
2105 get_file_type (elf_header
.e_type
));
2106 printf (_(" Machine: %s\n"),
2107 get_machine_name (elf_header
.e_machine
));
2108 printf (_(" Version: 0x%lx\n"),
2109 (unsigned long) elf_header
.e_version
);
2111 printf (_(" Entry point address: "));
2112 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2113 printf (_("\n Start of program headers: "));
2114 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2115 printf (_(" (bytes into file)\n Start of section headers: "));
2116 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2117 printf (_(" (bytes into file)\n"));
2119 printf (_(" Flags: 0x%lx%s\n"),
2120 (unsigned long) elf_header
.e_flags
,
2121 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2122 printf (_(" Size of this header: %ld (bytes)\n"),
2123 (long) elf_header
.e_ehsize
);
2124 printf (_(" Size of program headers: %ld (bytes)\n"),
2125 (long) elf_header
.e_phentsize
);
2126 printf (_(" Number of program headers: %ld\n"),
2127 (long) elf_header
.e_phnum
);
2128 printf (_(" Size of section headers: %ld (bytes)\n"),
2129 (long) elf_header
.e_shentsize
);
2130 printf (_(" Number of section headers: %ld\n"),
2131 (long) elf_header
.e_shnum
);
2132 printf (_(" Section header string table index: %ld\n"),
2133 (long) elf_header
.e_shstrndx
);
2141 get_32bit_program_headers (file
, program_headers
)
2143 Elf_Internal_Phdr
* program_headers
;
2145 Elf32_External_Phdr
* phdrs
;
2146 Elf32_External_Phdr
* external
;
2147 Elf32_Internal_Phdr
* internal
;
2150 GET_DATA_ALLOC (elf_header
.e_phoff
,
2151 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2152 phdrs
, Elf32_External_Phdr
*, "program headers");
2154 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2155 i
< elf_header
.e_phnum
;
2156 i
++, internal
++, external
++)
2158 internal
->p_type
= BYTE_GET (external
->p_type
);
2159 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2160 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2161 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2162 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2163 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2164 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2165 internal
->p_align
= BYTE_GET (external
->p_align
);
2174 get_64bit_program_headers (file
, program_headers
)
2176 Elf_Internal_Phdr
* program_headers
;
2178 Elf64_External_Phdr
* phdrs
;
2179 Elf64_External_Phdr
* external
;
2180 Elf64_Internal_Phdr
* internal
;
2183 GET_DATA_ALLOC (elf_header
.e_phoff
,
2184 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2185 phdrs
, Elf64_External_Phdr
*, "program headers");
2187 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2188 i
< elf_header
.e_phnum
;
2189 i
++, internal
++, external
++)
2191 internal
->p_type
= BYTE_GET (external
->p_type
);
2192 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2193 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2194 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2195 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2196 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2197 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2198 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2207 process_program_headers (file
)
2210 Elf_Internal_Phdr
* program_headers
;
2211 Elf_Internal_Phdr
* segment
;
2214 if (elf_header
.e_phnum
== 0)
2217 printf (_("\nThere are no program headers in this file.\n"));
2221 if (do_segments
&& !do_header
)
2223 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2224 printf (_("Entry point "));
2225 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2226 printf (_("\nThere are %d program headers, starting at offset "),
2227 elf_header
.e_phnum
);
2228 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2232 program_headers
= (Elf_Internal_Phdr
*) malloc
2233 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2235 if (program_headers
== NULL
)
2237 error (_("Out of memory\n"));
2242 i
= get_32bit_program_headers (file
, program_headers
);
2244 i
= get_64bit_program_headers (file
, program_headers
);
2248 free (program_headers
);
2255 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2259 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2263 (_(" Type Offset VirtAddr PhysAddr\n"));
2265 (_(" FileSiz MemSiz Flags Align\n"));
2273 for (i
= 0, segment
= program_headers
;
2274 i
< elf_header
.e_phnum
;
2279 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2283 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2284 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2285 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2286 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2287 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2289 (segment
->p_flags
& PF_R
? 'R' : ' '),
2290 (segment
->p_flags
& PF_W
? 'W' : ' '),
2291 (segment
->p_flags
& PF_X
? 'E' : ' '));
2292 printf ("%#lx", (unsigned long) segment
->p_align
);
2296 print_vma (segment
->p_offset
, FULL_HEX
);
2298 print_vma (segment
->p_vaddr
, FULL_HEX
);
2300 print_vma (segment
->p_paddr
, FULL_HEX
);
2302 print_vma (segment
->p_filesz
, FULL_HEX
);
2304 print_vma (segment
->p_memsz
, FULL_HEX
);
2306 (segment
->p_flags
& PF_R
? 'R' : ' '),
2307 (segment
->p_flags
& PF_W
? 'W' : ' '),
2308 (segment
->p_flags
& PF_X
? 'E' : ' '));
2309 print_vma (segment
->p_align
, HEX
);
2313 switch (segment
->p_type
)
2317 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2318 - (segment
->p_offset
& 0xfffff000);
2323 error (_("more than one dynamic segment\n"));
2325 dynamic_addr
= segment
->p_offset
;
2326 dynamic_size
= segment
->p_filesz
;
2330 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2331 error (_("Unable to find program interpreter name\n"));
2334 program_interpreter
[0] = 0;
2335 fscanf (file
, "%63s", program_interpreter
);
2338 printf (_("\n [Requesting program interpreter: %s]"),
2339 program_interpreter
);
2345 putc ('\n', stdout
);
2354 if (do_segments
&& section_headers
!= NULL
)
2356 printf (_("\n Section to Segment mapping:\n"));
2357 printf (_(" Segment Sections...\n"));
2359 assert (string_table
!= NULL
);
2361 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2364 Elf_Internal_Shdr
* section
;
2366 segment
= program_headers
+ i
;
2367 section
= section_headers
;
2369 printf (" %2.2d ", i
);
2371 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2373 if (section
->sh_size
> 0
2374 /* Compare allocated sections by VMA, unallocated
2375 sections by file offset. */
2376 && (section
->sh_flags
& SHF_ALLOC
2377 ? (section
->sh_addr
>= segment
->p_vaddr
2378 && section
->sh_addr
+ section
->sh_size
2379 <= segment
->p_vaddr
+ segment
->p_memsz
)
2380 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2381 && (section
->sh_offset
+ section
->sh_size
2382 <= segment
->p_offset
+ segment
->p_filesz
))))
2383 printf ("%s ", SECTION_NAME (section
));
2390 free (program_headers
);
2397 get_32bit_section_headers (file
)
2400 Elf32_External_Shdr
* shdrs
;
2401 Elf32_Internal_Shdr
* internal
;
2404 GET_DATA_ALLOC (elf_header
.e_shoff
,
2405 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2406 shdrs
, Elf32_External_Shdr
*, "section headers");
2408 section_headers
= (Elf_Internal_Shdr
*) malloc
2409 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2411 if (section_headers
== NULL
)
2413 error (_("Out of memory\n"));
2417 for (i
= 0, internal
= section_headers
;
2418 i
< elf_header
.e_shnum
;
2421 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2422 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2423 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2424 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2425 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2426 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2427 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2428 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2429 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2430 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2439 get_64bit_section_headers (file
)
2442 Elf64_External_Shdr
* shdrs
;
2443 Elf64_Internal_Shdr
* internal
;
2446 GET_DATA_ALLOC (elf_header
.e_shoff
,
2447 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2448 shdrs
, Elf64_External_Shdr
*, "section headers");
2450 section_headers
= (Elf_Internal_Shdr
*) malloc
2451 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2453 if (section_headers
== NULL
)
2455 error (_("Out of memory\n"));
2459 for (i
= 0, internal
= section_headers
;
2460 i
< elf_header
.e_shnum
;
2463 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2464 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2465 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2466 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2467 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2468 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2469 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2470 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2471 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2472 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2480 static Elf_Internal_Sym
*
2481 get_32bit_elf_symbols (file
, offset
, number
)
2483 unsigned long offset
;
2484 unsigned long number
;
2486 Elf32_External_Sym
* esyms
;
2487 Elf_Internal_Sym
* isyms
;
2488 Elf_Internal_Sym
* psym
;
2491 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2492 esyms
, Elf32_External_Sym
*, "symbols");
2494 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2498 error (_("Out of memory\n"));
2504 for (j
= 0, psym
= isyms
;
2508 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2509 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2510 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2511 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2512 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2513 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2521 static Elf_Internal_Sym
*
2522 get_64bit_elf_symbols (file
, offset
, number
)
2524 unsigned long offset
;
2525 unsigned long number
;
2527 Elf64_External_Sym
* esyms
;
2528 Elf_Internal_Sym
* isyms
;
2529 Elf_Internal_Sym
* psym
;
2532 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2533 esyms
, Elf64_External_Sym
*, "symbols");
2535 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2539 error (_("Out of memory\n"));
2545 for (j
= 0, psym
= isyms
;
2549 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2550 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2551 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2552 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2553 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2554 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2563 get_elf_section_flags (sh_flags
)
2566 static char buff
[32];
2574 flag
= sh_flags
& - sh_flags
;
2579 case SHF_WRITE
: strcat (buff
, "W"); break;
2580 case SHF_ALLOC
: strcat (buff
, "A"); break;
2581 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2582 case SHF_MERGE
: strcat (buff
, "M"); break;
2583 case SHF_STRINGS
: strcat (buff
, "S"); break;
2584 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2585 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2586 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2589 if (flag
& SHF_MASKOS
)
2592 sh_flags
&= ~ SHF_MASKOS
;
2594 else if (flag
& SHF_MASKPROC
)
2597 sh_flags
&= ~ SHF_MASKPROC
;
2609 process_section_headers (file
)
2612 Elf_Internal_Shdr
* section
;
2615 section_headers
= NULL
;
2617 if (elf_header
.e_shnum
== 0)
2620 printf (_("\nThere are no sections in this file.\n"));
2625 if (do_sections
&& !do_header
)
2626 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2627 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2631 if (! get_32bit_section_headers (file
))
2634 else if (! get_64bit_section_headers (file
))
2637 /* Read in the string table, so that we have names to display. */
2638 section
= section_headers
+ elf_header
.e_shstrndx
;
2640 if (section
->sh_size
!= 0)
2642 unsigned long string_table_offset
;
2644 string_table_offset
= section
->sh_offset
;
2646 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2647 string_table
, char *, "string table");
2650 /* Scan the sections for the dynamic symbol table
2651 and dynamic string table and debug sections. */
2652 dynamic_symbols
= NULL
;
2653 dynamic_strings
= NULL
;
2654 dynamic_syminfo
= NULL
;
2656 for (i
= 0, section
= section_headers
;
2657 i
< elf_header
.e_shnum
;
2660 char * name
= SECTION_NAME (section
);
2662 if (section
->sh_type
== SHT_DYNSYM
)
2664 if (dynamic_symbols
!= NULL
)
2666 error (_("File contains multiple dynamic symbol tables\n"));
2670 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2672 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2674 else if (section
->sh_type
== SHT_STRTAB
2675 && strcmp (name
, ".dynstr") == 0)
2677 if (dynamic_strings
!= NULL
)
2679 error (_("File contains multiple dynamic string tables\n"));
2683 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2684 dynamic_strings
, char *, "dynamic strings");
2686 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2687 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2688 && strncmp (name
, ".debug_", 7) == 0)
2693 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2694 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2695 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2696 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2697 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2699 request_dump (i
, DEBUG_DUMP
);
2706 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2710 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2713 printf (_(" [Nr] Name Type Address Offset\n"));
2714 printf (_(" Size EntSize Flags Link Info Align\n"));
2717 for (i
= 0, section
= section_headers
;
2718 i
< elf_header
.e_shnum
;
2721 printf (" [%2d] %-17.17s %-15.15s ",
2723 SECTION_NAME (section
),
2724 get_section_type_name (section
->sh_type
));
2728 print_vma (section
->sh_addr
, LONG_HEX
);
2730 printf ( " %6.6lx %6.6lx %2.2lx",
2731 (unsigned long) section
->sh_offset
,
2732 (unsigned long) section
->sh_size
,
2733 (unsigned long) section
->sh_entsize
);
2735 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2737 printf (" %2ld %3lx %ld\n",
2738 (unsigned long) section
->sh_link
,
2739 (unsigned long) section
->sh_info
,
2740 (unsigned long) section
->sh_addralign
);
2745 print_vma (section
->sh_addr
, LONG_HEX
);
2746 printf (" %8.8lx", section
->sh_offset
);
2748 print_vma (section
->sh_size
, LONG_HEX
);
2750 print_vma (section
->sh_entsize
, LONG_HEX
);
2752 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2754 printf (" %2ld %3lx %ld\n",
2755 (unsigned long) section
->sh_link
,
2756 (unsigned long) section
->sh_info
,
2757 (unsigned long) section
->sh_addralign
);
2761 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2762 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2763 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2768 /* Process the reloc section. */
2770 process_relocs (file
)
2773 unsigned long rel_size
;
2774 unsigned long rel_offset
;
2780 if (do_using_dynamic
)
2782 int is_rela
= FALSE
;
2787 if (dynamic_info
[DT_REL
])
2789 rel_offset
= dynamic_info
[DT_REL
];
2790 rel_size
= dynamic_info
[DT_RELSZ
];
2793 else if (dynamic_info
[DT_RELA
])
2795 rel_offset
= dynamic_info
[DT_RELA
];
2796 rel_size
= dynamic_info
[DT_RELASZ
];
2799 else if (dynamic_info
[DT_JMPREL
])
2801 rel_offset
= dynamic_info
[DT_JMPREL
];
2802 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2804 switch (dynamic_info
[DT_PLTREL
])
2821 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2822 rel_offset
, rel_size
);
2824 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2825 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2828 printf (_("\nThere are no dynamic relocations in this file.\n"));
2832 Elf32_Internal_Shdr
* section
;
2836 for (i
= 0, section
= section_headers
;
2837 i
< elf_header
.e_shnum
;
2840 if ( section
->sh_type
!= SHT_RELA
2841 && section
->sh_type
!= SHT_REL
)
2844 rel_offset
= section
->sh_offset
;
2845 rel_size
= section
->sh_size
;
2849 Elf32_Internal_Shdr
* strsec
;
2850 Elf32_Internal_Shdr
* symsec
;
2851 Elf_Internal_Sym
* symtab
;
2854 unsigned long nsyms
;
2856 printf (_("\nRelocation section "));
2858 if (string_table
== NULL
)
2859 printf ("%d", section
->sh_name
);
2861 printf ("'%s'", SECTION_NAME (section
));
2863 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2864 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2866 symsec
= section_headers
+ section
->sh_link
;
2868 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2869 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2874 strsec
= section_headers
+ symsec
->sh_link
;
2876 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2877 char *, "string table");
2879 is_rela
= section
->sh_type
== SHT_RELA
;
2881 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2891 printf (_("\nThere are no relocations in this file.\n"));
2899 dynamic_segment_mips_val (entry
)
2900 Elf_Internal_Dyn
* entry
;
2902 switch (entry
->d_tag
)
2905 if (entry
->d_un
.d_val
== 0)
2909 static const char * opts
[] =
2911 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2912 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2913 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2914 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2919 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2920 if (entry
->d_un
.d_val
& (1 << cnt
))
2922 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2929 case DT_MIPS_IVERSION
:
2930 if (dynamic_strings
!= NULL
)
2931 printf ("Interface Version: %s\n",
2932 dynamic_strings
+ entry
->d_un
.d_val
);
2934 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2937 case DT_MIPS_TIME_STAMP
:
2940 time_t time
= entry
->d_un
.d_val
;
2941 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
2942 printf ("Time Stamp: %s\n", timebuf
);
2946 case DT_MIPS_RLD_VERSION
:
2947 case DT_MIPS_LOCAL_GOTNO
:
2948 case DT_MIPS_CONFLICTNO
:
2949 case DT_MIPS_LIBLISTNO
:
2950 case DT_MIPS_SYMTABNO
:
2951 case DT_MIPS_UNREFEXTNO
:
2952 case DT_MIPS_HIPAGENO
:
2953 case DT_MIPS_DELTA_CLASS_NO
:
2954 case DT_MIPS_DELTA_INSTANCE_NO
:
2955 case DT_MIPS_DELTA_RELOC_NO
:
2956 case DT_MIPS_DELTA_SYM_NO
:
2957 case DT_MIPS_DELTA_CLASSSYM_NO
:
2958 case DT_MIPS_COMPACT_SIZE
:
2959 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2963 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2969 dynamic_segment_parisc_val (entry
)
2970 Elf_Internal_Dyn
* entry
;
2972 switch (entry
->d_tag
)
2974 case DT_HP_DLD_FLAGS
:
2983 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
2984 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
2985 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
2986 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
2987 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
2988 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
2989 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
2990 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
2991 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
2992 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
2993 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
2997 bfd_vma val
= entry
->d_un
.d_val
;
2999 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3000 if (val
& flags
[cnt
].bit
)
3004 fputs (flags
[cnt
].str
, stdout
);
3006 val
^= flags
[cnt
].bit
;
3009 if (val
!= 0 || first
)
3013 print_vma (val
, HEX
);
3019 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3025 get_32bit_dynamic_segment (file
)
3028 Elf32_External_Dyn
* edyn
;
3029 Elf_Internal_Dyn
* entry
;
3032 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3033 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3035 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3036 how large this .dynamic is now. We can do this even before the byte
3037 swapping since the DT_NULL tag is recognizable. */
3039 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3042 dynamic_segment
= (Elf_Internal_Dyn
*)
3043 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3045 if (dynamic_segment
== NULL
)
3047 error (_("Out of memory\n"));
3052 for (i
= 0, entry
= dynamic_segment
;
3056 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3057 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3066 get_64bit_dynamic_segment (file
)
3069 Elf64_External_Dyn
* edyn
;
3070 Elf_Internal_Dyn
* entry
;
3073 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3074 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3076 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3077 how large this .dynamic is now. We can do this even before the byte
3078 swapping since the DT_NULL tag is recognizable. */
3080 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3083 dynamic_segment
= (Elf_Internal_Dyn
*)
3084 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3086 if (dynamic_segment
== NULL
)
3088 error (_("Out of memory\n"));
3093 for (i
= 0, entry
= dynamic_segment
;
3097 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3098 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3107 get_dynamic_flags (flags
)
3110 static char buff
[64];
3115 flag
= flags
& - flags
;
3120 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3121 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3122 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3123 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3124 default: strcat (buff
, "unknown "); break;
3130 /* Parse and display the contents of the dynamic segment. */
3132 process_dynamic_segment (file
)
3135 Elf_Internal_Dyn
* entry
;
3138 if (dynamic_size
== 0)
3141 printf (_("\nThere is no dynamic segment in this file.\n"));
3148 if (! get_32bit_dynamic_segment (file
))
3151 else if (! get_64bit_dynamic_segment (file
))
3154 /* Find the appropriate symbol table. */
3155 if (dynamic_symbols
== NULL
)
3157 for (i
= 0, entry
= dynamic_segment
;
3161 unsigned long offset
;
3163 if (entry
->d_tag
!= DT_SYMTAB
)
3166 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3168 /* Since we do not know how big the symbol table is,
3169 we default to reading in the entire file (!) and
3170 processing that. This is overkill, I know, but it
3172 offset
= entry
->d_un
.d_val
- loadaddr
;
3174 if (fseek (file
, 0, SEEK_END
))
3175 error (_("Unable to seek to end of file!"));
3178 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3180 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3182 if (num_dynamic_syms
< 1)
3184 error (_("Unable to determine the number of symbols to load\n"));
3188 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3192 /* Similarly find a string table. */
3193 if (dynamic_strings
== NULL
)
3195 for (i
= 0, entry
= dynamic_segment
;
3199 unsigned long offset
;
3202 if (entry
->d_tag
!= DT_STRTAB
)
3205 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3207 /* Since we do not know how big the string table is,
3208 we default to reading in the entire file (!) and
3209 processing that. This is overkill, I know, but it
3212 offset
= entry
->d_un
.d_val
- loadaddr
;
3213 if (fseek (file
, 0, SEEK_END
))
3214 error (_("Unable to seek to end of file\n"));
3215 str_tab_len
= ftell (file
) - offset
;
3217 if (str_tab_len
< 1)
3220 (_("Unable to determine the length of the dynamic string table\n"));
3224 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3225 "dynamic string table");
3231 /* And find the syminfo section if available. */
3232 if (dynamic_syminfo
== NULL
)
3234 unsigned int syminsz
= 0;
3236 for (i
= 0, entry
= dynamic_segment
;
3240 if (entry
->d_tag
== DT_SYMINENT
)
3242 /* Note: these braces are necessary to avoid a syntax
3243 error from the SunOS4 C compiler. */
3244 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3246 else if (entry
->d_tag
== DT_SYMINSZ
)
3247 syminsz
= entry
->d_un
.d_val
;
3248 else if (entry
->d_tag
== DT_SYMINFO
)
3249 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3252 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3254 Elf_External_Syminfo
* extsyminfo
;
3255 Elf_Internal_Syminfo
* syminfo
;
3257 /* There is a syminfo section. Read the data. */
3258 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3259 Elf_External_Syminfo
*, "symbol information");
3261 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3262 if (dynamic_syminfo
== NULL
)
3264 error (_("Out of memory\n"));
3268 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3269 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3272 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3273 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3280 if (do_dynamic
&& dynamic_addr
)
3281 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3282 dynamic_addr
, (long) dynamic_size
);
3284 printf (_(" Tag Type Name/Value\n"));
3286 for (i
= 0, entry
= dynamic_segment
;
3295 print_vma (entry
->d_tag
, FULL_HEX
);
3296 dtype
= get_dynamic_type (entry
->d_tag
);
3297 printf (" (%s)%*s", dtype
,
3298 ((is_32bit_elf
? 27 : 19)
3299 - (int) strlen (dtype
)),
3303 switch (entry
->d_tag
)
3307 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3314 if (entry
->d_tag
== DT_AUXILIARY
)
3315 printf (_("Auxiliary library"));
3317 printf (_("Filter library"));
3319 if (dynamic_strings
)
3320 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3324 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3333 printf (_("Flags:"));
3334 if (entry
->d_un
.d_val
== 0)
3335 printf (_(" None\n"));
3338 unsigned long int val
= entry
->d_un
.d_val
;
3339 if (val
& DTF_1_PARINIT
)
3341 printf (" PARINIT");
3342 val
^= DTF_1_PARINIT
;
3345 printf (" %lx", val
);
3354 printf (_("Flags:"));
3355 if (entry
->d_un
.d_val
== 0)
3356 printf (_(" None\n"));
3359 unsigned long int val
= entry
->d_un
.d_val
;
3360 if (val
& DF_P1_LAZYLOAD
)
3362 printf (" LAZYLOAD");
3363 val
^= DF_P1_LAZYLOAD
;
3365 if (val
& DF_P1_GROUPPERM
)
3367 printf (" GROUPPERM");
3368 val
^= DF_P1_GROUPPERM
;
3371 printf (" %lx", val
);
3380 printf (_("Flags:"));
3381 if (entry
->d_un
.d_val
== 0)
3382 printf (_(" None\n"));
3385 unsigned long int val
= entry
->d_un
.d_val
;
3391 if (val
& DF_1_GLOBAL
)
3396 if (val
& DF_1_GROUP
)
3401 if (val
& DF_1_NODELETE
)
3403 printf (" NODELETE");
3404 val
^= DF_1_NODELETE
;
3406 if (val
& DF_1_LOADFLTR
)
3408 printf (" LOADFLTR");
3409 val
^= DF_1_LOADFLTR
;
3411 if (val
& DF_1_INITFIRST
)
3413 printf (" INITFIRST");
3414 val
^= DF_1_INITFIRST
;
3416 if (val
& DF_1_NOOPEN
)
3421 if (val
& DF_1_ORIGIN
)
3426 if (val
& DF_1_DIRECT
)
3431 if (val
& DF_1_TRANS
)
3436 if (val
& DF_1_INTERPOSE
)
3438 printf (" INTERPOSE");
3439 val
^= DF_1_INTERPOSE
;
3442 printf (" %lx", val
);
3450 puts (get_dynamic_type (entry
->d_un
.d_val
));
3469 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3475 if (dynamic_strings
== NULL
)
3478 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3482 switch (entry
->d_tag
)
3485 printf (_("Shared library: [%s]"), name
);
3487 if (strcmp (name
, program_interpreter
) == 0)
3488 printf (_(" program interpreter"));
3492 printf (_("Library soname: [%s]"), name
);
3496 printf (_("Library rpath: [%s]"), name
);
3500 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3505 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3521 case DT_INIT_ARRAYSZ
:
3522 case DT_FINI_ARRAYSZ
:
3525 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3526 printf (" (bytes)\n");
3536 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3549 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3553 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3557 printf (_("Not needed object: [%s]\n"), name
);
3562 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3568 /* The value of this entry is ignored. */
3572 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3573 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3578 switch (elf_header
.e_machine
)
3581 case EM_MIPS_RS4_BE
:
3582 dynamic_segment_mips_val (entry
);
3585 dynamic_segment_parisc_val (entry
);
3588 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3600 get_ver_flags (flags
)
3603 static char buff
[32];
3610 if (flags
& VER_FLG_BASE
)
3611 strcat (buff
, "BASE ");
3613 if (flags
& VER_FLG_WEAK
)
3615 if (flags
& VER_FLG_BASE
)
3616 strcat (buff
, "| ");
3618 strcat (buff
, "WEAK ");
3621 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3622 strcat (buff
, "| <unknown>");
3627 /* Display the contents of the version sections. */
3629 process_version_sections (file
)
3632 Elf32_Internal_Shdr
* section
;
3639 for (i
= 0, section
= section_headers
;
3640 i
< elf_header
.e_shnum
;
3643 switch (section
->sh_type
)
3645 case SHT_GNU_verdef
:
3647 Elf_External_Verdef
* edefs
;
3654 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3655 SECTION_NAME (section
), section
->sh_info
);
3657 printf (_(" Addr: 0x"));
3658 printf_vma (section
->sh_addr
);
3659 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3660 (unsigned long) section
->sh_offset
, section
->sh_link
,
3661 SECTION_NAME (section_headers
+ section
->sh_link
));
3663 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3664 edefs
, Elf_External_Verdef
*,
3665 "version definition section");
3667 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3670 Elf_External_Verdef
* edef
;
3671 Elf_Internal_Verdef ent
;
3672 Elf_External_Verdaux
* eaux
;
3673 Elf_Internal_Verdaux aux
;
3677 vstart
= ((char *) edefs
) + idx
;
3679 edef
= (Elf_External_Verdef
*) vstart
;
3681 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3682 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3683 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3684 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3685 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3686 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3687 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3689 printf (_(" %#06x: Rev: %d Flags: %s"),
3690 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3692 printf (_(" Index: %d Cnt: %d "),
3693 ent
.vd_ndx
, ent
.vd_cnt
);
3695 vstart
+= ent
.vd_aux
;
3697 eaux
= (Elf_External_Verdaux
*) vstart
;
3699 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3700 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3702 if (dynamic_strings
)
3703 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3705 printf (_("Name index: %ld\n"), aux
.vda_name
);
3707 isum
= idx
+ ent
.vd_aux
;
3709 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3711 isum
+= aux
.vda_next
;
3712 vstart
+= aux
.vda_next
;
3714 eaux
= (Elf_External_Verdaux
*) vstart
;
3716 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3717 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3719 if (dynamic_strings
)
3720 printf (_(" %#06x: Parent %d: %s\n"),
3721 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3723 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3724 isum
, j
, aux
.vda_name
);
3734 case SHT_GNU_verneed
:
3736 Elf_External_Verneed
* eneed
;
3742 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3743 SECTION_NAME (section
), section
->sh_info
);
3745 printf (_(" Addr: 0x"));
3746 printf_vma (section
->sh_addr
);
3747 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3748 (unsigned long) section
->sh_offset
, section
->sh_link
,
3749 SECTION_NAME (section_headers
+ section
->sh_link
));
3751 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3752 eneed
, Elf_External_Verneed
*,
3753 "version need section");
3755 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3757 Elf_External_Verneed
* entry
;
3758 Elf_Internal_Verneed ent
;
3763 vstart
= ((char *) eneed
) + idx
;
3765 entry
= (Elf_External_Verneed
*) vstart
;
3767 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3768 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3769 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3770 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3771 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3773 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3775 if (dynamic_strings
)
3776 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3778 printf (_(" File: %lx"), ent
.vn_file
);
3780 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3782 vstart
+= ent
.vn_aux
;
3784 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3786 Elf_External_Vernaux
* eaux
;
3787 Elf_Internal_Vernaux aux
;
3789 eaux
= (Elf_External_Vernaux
*) vstart
;
3791 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3792 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3793 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3794 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3795 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3797 if (dynamic_strings
)
3798 printf (_(" %#06x: Name: %s"),
3799 isum
, dynamic_strings
+ aux
.vna_name
);
3801 printf (_(" %#06x: Name index: %lx"),
3802 isum
, aux
.vna_name
);
3804 printf (_(" Flags: %s Version: %d\n"),
3805 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3807 isum
+= aux
.vna_next
;
3808 vstart
+= aux
.vna_next
;
3818 case SHT_GNU_versym
:
3820 Elf32_Internal_Shdr
* link_section
;
3823 unsigned char * edata
;
3824 unsigned short * data
;
3826 Elf_Internal_Sym
* symbols
;
3827 Elf32_Internal_Shdr
* string_sec
;
3829 link_section
= section_headers
+ section
->sh_link
;
3830 total
= section
->sh_size
/ section
->sh_entsize
;
3834 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3835 link_section
->sh_size
/ link_section
->sh_entsize
);
3837 string_sec
= section_headers
+ link_section
->sh_link
;
3839 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3840 strtab
, char *, "version string table");
3842 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3843 SECTION_NAME (section
), total
);
3845 printf (_(" Addr: "));
3846 printf_vma (section
->sh_addr
);
3847 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3848 (unsigned long) section
->sh_offset
, section
->sh_link
,
3849 SECTION_NAME (link_section
));
3851 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3853 total
* sizeof (short), edata
,
3854 unsigned char *, "version symbol data");
3856 data
= (unsigned short *) malloc (total
* sizeof (short));
3858 for (cnt
= total
; cnt
--;)
3859 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3864 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3869 printf (" %03x:", cnt
);
3871 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3872 switch (data
[cnt
+ j
])
3875 fputs (_(" 0 (*local*) "), stdout
);
3879 fputs (_(" 1 (*global*) "), stdout
);
3883 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3884 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3886 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3887 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3890 /* We must test both. */
3891 Elf_Internal_Verneed ivn
;
3892 unsigned long offset
;
3894 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3899 Elf_External_Verneed evn
;
3900 Elf_External_Vernaux evna
;
3901 Elf_Internal_Vernaux ivna
;
3902 unsigned long vna_off
;
3904 GET_DATA (offset
, evn
, "version need");
3906 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3907 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3909 vna_off
= offset
+ ivn
.vn_aux
;
3913 GET_DATA (vna_off
, evna
,
3914 "version need aux (1)");
3916 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3917 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3919 vna_off
+= ivna
.vna_next
;
3921 while (ivna
.vna_other
!= data
[cnt
+ j
]
3922 && ivna
.vna_next
!= 0);
3924 if (ivna
.vna_other
== data
[cnt
+ j
])
3926 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
3928 name
= strtab
+ ivna
.vna_name
;
3929 nn
+= printf ("(%s%-*s",
3931 12 - (int) strlen (name
),
3935 else if (ivn
.vn_next
== 0)
3937 if (data
[cnt
+ j
] != 0x8001)
3939 Elf_Internal_Verdef ivd
;
3940 Elf_External_Verdef evd
;
3942 offset
= version_info
3943 [DT_VERSIONTAGIDX (DT_VERDEF
)]
3948 GET_DATA (offset
, evd
,
3949 "version definition");
3951 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
3952 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
3954 offset
+= ivd
.vd_next
;
3957 != (data
[cnt
+ j
] & 0x7fff)
3958 && ivd
.vd_next
!= 0);
3961 == (data
[cnt
+ j
] & 0x7fff))
3963 Elf_External_Verdaux evda
;
3964 Elf_Internal_Verdaux ivda
;
3966 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
3968 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
3969 "version definition aux");
3972 BYTE_GET (evda
.vda_name
);
3974 name
= strtab
+ ivda
.vda_name
;
3978 12 - (int) strlen (name
),
3986 offset
+= ivn
.vn_next
;
3988 while (ivn
.vn_next
);
3990 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
3992 Elf_Internal_Verneed ivn
;
3993 unsigned long offset
;
3995 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4000 Elf_Internal_Vernaux ivna
;
4001 Elf_External_Verneed evn
;
4002 Elf_External_Vernaux evna
;
4003 unsigned long a_off
;
4005 GET_DATA (offset
, evn
, "version need");
4007 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4008 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4010 a_off
= offset
+ ivn
.vn_aux
;
4014 GET_DATA (a_off
, evna
,
4015 "version need aux (2)");
4017 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4018 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4020 a_off
+= ivna
.vna_next
;
4022 while (ivna
.vna_other
!= data
[cnt
+ j
]
4023 && ivna
.vna_next
!= 0);
4025 if (ivna
.vna_other
== data
[cnt
+ j
])
4027 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4029 name
= strtab
+ ivna
.vna_name
;
4030 nn
+= printf ("(%s%-*s",
4032 12 - (int) strlen (name
),
4037 offset
+= ivn
.vn_next
;
4039 while (ivn
.vn_next
);
4041 else if (data
[cnt
+ j
] != 0x8001)
4043 Elf_Internal_Verdef ivd
;
4044 Elf_External_Verdef evd
;
4045 unsigned long offset
;
4047 offset
= version_info
4048 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4052 GET_DATA (offset
, evd
, "version def");
4054 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4055 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4057 offset
+= ivd
.vd_next
;
4059 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4060 && ivd
.vd_next
!= 0);
4062 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4064 Elf_External_Verdaux evda
;
4065 Elf_Internal_Verdaux ivda
;
4067 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4069 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4070 evda
, "version def aux");
4072 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4074 name
= strtab
+ ivda
.vda_name
;
4075 nn
+= printf ("(%s%-*s",
4077 12 - (int) strlen (name
),
4083 printf ("%*c", 18 - nn
, ' ');
4101 printf (_("\nNo version information found in this file.\n"));
4107 get_symbol_binding (binding
)
4108 unsigned int binding
;
4110 static char buff
[32];
4114 case STB_LOCAL
: return "LOCAL";
4115 case STB_GLOBAL
: return "GLOBAL";
4116 case STB_WEAK
: return "WEAK";
4118 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4119 sprintf (buff
, _("<processor specific>: %d"), binding
);
4120 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4121 sprintf (buff
, _("<OS specific>: %d"), binding
);
4123 sprintf (buff
, _("<unknown>: %d"), binding
);
4129 get_symbol_type (type
)
4132 static char buff
[32];
4136 case STT_NOTYPE
: return "NOTYPE";
4137 case STT_OBJECT
: return "OBJECT";
4138 case STT_FUNC
: return "FUNC";
4139 case STT_SECTION
: return "SECTION";
4140 case STT_FILE
: return "FILE";
4141 case STT_COMMON
: return "COMMON";
4143 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4145 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4146 return "THUMB_FUNC";
4148 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4151 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4152 return "PARISC_MILLI";
4154 sprintf (buff
, _("<processor specific>: %d"), type
);
4156 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4158 if (elf_header
.e_machine
== EM_PARISC
)
4160 if (type
== STT_HP_OPAQUE
)
4162 if (type
== STT_HP_STUB
)
4166 sprintf (buff
, _("<OS specific>: %d"), type
);
4169 sprintf (buff
, _("<unknown>: %d"), type
);
4175 get_symbol_visibility (visibility
)
4176 unsigned int visibility
;
4180 case STV_DEFAULT
: return "DEFAULT";
4181 case STV_INTERNAL
: return "INTERNAL";
4182 case STV_HIDDEN
: return "HIDDEN";
4183 case STV_PROTECTED
: return "PROTECTED";
4189 get_symbol_index_type (type
)
4194 case SHN_UNDEF
: return "UND";
4195 case SHN_ABS
: return "ABS";
4196 case SHN_COMMON
: return "COM";
4198 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4200 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4202 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4206 static char buff
[32];
4208 sprintf (buff
, "%3d", type
);
4215 get_dynamic_data (file
, number
)
4217 unsigned int number
;
4222 e_data
= (char *) malloc (number
* 4);
4226 error (_("Out of memory\n"));
4230 if (fread (e_data
, 4, number
, file
) != number
)
4232 error (_("Unable to read in dynamic data\n"));
4236 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4240 error (_("Out of memory\n"));
4246 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4253 /* Dump the symbol table */
4255 process_symbol_table (file
)
4258 Elf32_Internal_Shdr
* section
;
4263 int * buckets
= NULL
;
4264 int * chains
= NULL
;
4266 if (! do_syms
&& !do_histogram
)
4269 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4272 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4274 error (_("Unable to seek to start of dynamic information"));
4278 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4280 error (_("Failed to read in number of buckets\n"));
4284 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4286 error (_("Failed to read in number of chains\n"));
4290 nbuckets
= byte_get (nb
, 4);
4291 nchains
= byte_get (nc
, 4);
4293 buckets
= get_dynamic_data (file
, nbuckets
);
4294 chains
= get_dynamic_data (file
, nchains
);
4296 if (buckets
== NULL
|| chains
== NULL
)
4301 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4306 printf (_("\nSymbol table for image:\n"));
4308 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4310 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4312 for (hn
= 0; hn
< nbuckets
; hn
++)
4317 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4319 Elf_Internal_Sym
* psym
;
4321 psym
= dynamic_symbols
+ si
;
4323 printf (" %3d %3d: ", si
, hn
);
4324 print_vma (psym
->st_value
, LONG_HEX
);
4326 print_vma (psym
->st_size
, DEC_5
);
4328 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4329 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4330 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4331 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4332 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4336 else if (do_syms
&& !do_using_dynamic
)
4340 for (i
= 0, section
= section_headers
;
4341 i
< elf_header
.e_shnum
;
4346 Elf_Internal_Sym
* symtab
;
4347 Elf_Internal_Sym
* psym
;
4350 if ( section
->sh_type
!= SHT_SYMTAB
4351 && section
->sh_type
!= SHT_DYNSYM
)
4354 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4355 SECTION_NAME (section
),
4356 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4358 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4360 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4362 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4363 section
->sh_size
/ section
->sh_entsize
);
4367 if (section
->sh_link
== elf_header
.e_shstrndx
)
4368 strtab
= string_table
;
4371 Elf32_Internal_Shdr
* string_sec
;
4373 string_sec
= section_headers
+ section
->sh_link
;
4375 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4376 strtab
, char *, "string table");
4379 for (si
= 0, psym
= symtab
;
4380 si
< section
->sh_size
/ section
->sh_entsize
;
4383 printf ("%6d: ", si
);
4384 print_vma (psym
->st_value
, LONG_HEX
);
4386 print_vma (psym
->st_size
, DEC_5
);
4387 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4388 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4389 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4390 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4391 printf (" %s", strtab
+ psym
->st_name
);
4393 if (section
->sh_type
== SHT_DYNSYM
&&
4394 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4396 unsigned char data
[2];
4397 unsigned short vers_data
;
4398 unsigned long offset
;
4402 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4405 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4408 vers_data
= byte_get (data
, 2);
4410 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4411 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4414 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4416 if ((vers_data
& 0x8000) || vers_data
> 1)
4418 if (is_nobits
|| ! check_def
)
4420 Elf_External_Verneed evn
;
4421 Elf_Internal_Verneed ivn
;
4422 Elf_Internal_Vernaux ivna
;
4424 /* We must test both. */
4425 offset
= version_info
4426 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4430 unsigned long vna_off
;
4432 GET_DATA (offset
, evn
, "version need");
4434 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4435 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4437 vna_off
= offset
+ ivn
.vn_aux
;
4441 Elf_External_Vernaux evna
;
4443 GET_DATA (vna_off
, evna
,
4444 "version need aux (3)");
4446 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4447 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4448 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4450 vna_off
+= ivna
.vna_next
;
4452 while (ivna
.vna_other
!= vers_data
4453 && ivna
.vna_next
!= 0);
4455 if (ivna
.vna_other
== vers_data
)
4458 offset
+= ivn
.vn_next
;
4460 while (ivn
.vn_next
!= 0);
4462 if (ivna
.vna_other
== vers_data
)
4465 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4468 else if (! is_nobits
)
4469 error (_("bad dynamic symbol"));
4476 if (vers_data
!= 0x8001)
4478 Elf_Internal_Verdef ivd
;
4479 Elf_Internal_Verdaux ivda
;
4480 Elf_External_Verdaux evda
;
4481 unsigned long offset
;
4484 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4489 Elf_External_Verdef evd
;
4491 GET_DATA (offset
, evd
, "version def");
4493 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4494 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4495 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4497 offset
+= ivd
.vd_next
;
4499 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4500 && ivd
.vd_next
!= 0);
4502 offset
-= ivd
.vd_next
;
4503 offset
+= ivd
.vd_aux
;
4505 GET_DATA (offset
, evda
, "version def aux");
4507 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4509 if (psym
->st_name
!= ivda
.vda_name
)
4510 printf ((vers_data
& 0x8000)
4512 strtab
+ ivda
.vda_name
);
4522 if (strtab
!= string_table
)
4528 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4530 if (do_histogram
&& buckets
!= NULL
)
4537 int nzero_counts
= 0;
4540 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4542 printf (_(" Length Number %% of total Coverage\n"));
4544 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4545 if (lengths
== NULL
)
4547 error (_("Out of memory"));
4550 for (hn
= 0; hn
< nbuckets
; ++hn
)
4555 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4558 if (maxlength
< ++lengths
[hn
])
4563 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4566 error (_("Out of memory"));
4570 for (hn
= 0; hn
< nbuckets
; ++hn
)
4571 ++ counts
[lengths
[hn
]];
4575 printf (" 0 %-10d (%5.1f%%)\n",
4576 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4577 for (si
= 1; si
<= maxlength
; ++si
)
4579 nzero_counts
+= counts
[si
] * si
;
4580 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4581 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4582 (nzero_counts
* 100.0) / nsyms
);
4590 if (buckets
!= NULL
)
4600 process_syminfo (file
)
4601 FILE * file ATTRIBUTE_UNUSED
;
4605 if (dynamic_syminfo
== NULL
4607 /* No syminfo, this is ok. */
4610 /* There better should be a dynamic symbol section. */
4611 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4615 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4616 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4618 printf (_(" Num: Name BoundTo Flags\n"));
4619 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4621 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4623 printf ("%4d: %-30s ", i
,
4624 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4626 switch (dynamic_syminfo
[i
].si_boundto
)
4628 case SYMINFO_BT_SELF
:
4629 fputs ("SELF ", stdout
);
4631 case SYMINFO_BT_PARENT
:
4632 fputs ("PARENT ", stdout
);
4635 if (dynamic_syminfo
[i
].si_boundto
> 0
4636 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4639 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4641 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4645 if (flags
& SYMINFO_FLG_DIRECT
)
4647 if (flags
& SYMINFO_FLG_PASSTHRU
)
4648 printf (" PASSTHRU");
4649 if (flags
& SYMINFO_FLG_COPY
)
4651 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4652 printf (" LAZYLOAD");
4660 #ifdef SUPPORT_DISASSEMBLY
4662 disassemble_section (section
, file
)
4663 Elf32_Internal_Shdr
* section
;
4666 printf (_("\nAssembly dump of section %s\n"),
4667 SECTION_NAME (section
));
4669 /* XXX -- to be done --- XXX */
4676 dump_section (section
, file
)
4677 Elf32_Internal_Shdr
* section
;
4680 bfd_size_type bytes
;
4682 unsigned char * data
;
4683 unsigned char * start
;
4685 bytes
= section
->sh_size
;
4689 printf (_("\nSection '%s' has no data to dump.\n"),
4690 SECTION_NAME (section
));
4694 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4696 addr
= section
->sh_addr
;
4698 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4709 lbytes
= (bytes
> 16 ? 16 : bytes
);
4711 printf (" 0x%8.8lx ", (unsigned long) addr
);
4713 switch (elf_header
.e_ident
[EI_DATA
])
4717 for (j
= 15; j
>= 0; j
--)
4720 printf ("%2.2x", data
[j
]);
4730 for (j
= 0; j
< 16; j
++)
4733 printf ("%2.2x", data
[j
]);
4743 for (j
= 0; j
< lbytes
; j
++)
4746 if (k
>= ' ' && k
< 0x80)
4765 static unsigned long int
4766 read_leb128 (data
, length_return
, sign
)
4767 unsigned char * data
;
4768 int * length_return
;
4771 unsigned long int result
= 0;
4772 unsigned int num_read
= 0;
4781 result
|= (byte
& 0x7f) << shift
;
4786 while (byte
& 0x80);
4788 if (length_return
!= NULL
)
4789 * length_return
= num_read
;
4791 if (sign
&& (shift
< 32) && (byte
& 0x40))
4792 result
|= -1 << shift
;
4797 typedef struct State_Machine_Registers
4799 unsigned long address
;
4802 unsigned int column
;
4806 /* This variable hold the number of the last entry seen
4807 in the File Table. */
4808 unsigned int last_file_entry
;
4811 static SMR state_machine_regs
;
4814 reset_state_machine (is_stmt
)
4817 state_machine_regs
.address
= 0;
4818 state_machine_regs
.file
= 1;
4819 state_machine_regs
.line
= 1;
4820 state_machine_regs
.column
= 0;
4821 state_machine_regs
.is_stmt
= is_stmt
;
4822 state_machine_regs
.basic_block
= 0;
4823 state_machine_regs
.end_sequence
= 0;
4824 state_machine_regs
.last_file_entry
= 0;
4827 /* Handled an extend line op. Returns true if this is the end
4830 process_extended_line_op (data
, is_stmt
, pointer_size
)
4831 unsigned char * data
;
4835 unsigned char op_code
;
4838 unsigned char * name
;
4841 len
= read_leb128 (data
, & bytes_read
, 0);
4846 warn (_("badly formed extended line op encountered!"));
4851 op_code
= * data
++;
4853 printf (_(" Extended opcode %d: "), op_code
);
4857 case DW_LNE_end_sequence
:
4858 printf (_("End of Sequence\n\n"));
4859 reset_state_machine (is_stmt
);
4862 case DW_LNE_set_address
:
4863 adr
= byte_get (data
, pointer_size
);
4864 printf (_("set Address to 0x%lx\n"), adr
);
4865 state_machine_regs
.address
= adr
;
4868 case DW_LNE_define_file
:
4869 printf (_(" define new File Table entry\n"));
4870 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4872 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4874 data
+= strlen (data
) + 1;
4875 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4877 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4879 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4880 printf (_("%s\n\n"), name
);
4884 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4891 /* Size of pointers in the .debug_line section. This information is not
4892 really present in that section. It's obtained before dumping the debug
4893 sections by doing some pre-scan of the .debug_info section. */
4894 static int debug_line_pointer_size
= 4;
4897 display_debug_lines (section
, start
, file
)
4898 Elf32_Internal_Shdr
* section
;
4899 unsigned char * start
;
4900 FILE * file ATTRIBUTE_UNUSED
;
4902 DWARF2_External_LineInfo
* external
;
4903 DWARF2_Internal_LineInfo info
;
4904 unsigned char * standard_opcodes
;
4905 unsigned char * data
= start
;
4906 unsigned char * end
= start
+ section
->sh_size
;
4907 unsigned char * end_of_sequence
;
4910 printf (_("\nDump of debug contents of section %s:\n\n"),
4911 SECTION_NAME (section
));
4915 external
= (DWARF2_External_LineInfo
*) data
;
4917 /* Check the length of the block. */
4918 info
.li_length
= BYTE_GET (external
->li_length
);
4919 if (info
.li_length
> section
->sh_size
)
4922 (_("The line info appears to be corrupt - the section is too small\n"));
4926 /* Check its version number. */
4927 info
.li_version
= BYTE_GET (external
->li_version
);
4928 if (info
.li_version
!= 2)
4930 warn (_("Only DWARF version 2 line info is currently supported.\n"));
4934 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
4935 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
4936 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
4937 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
4938 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
4939 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
4941 /* Sign extend the line base field. */
4942 info
.li_line_base
<<= 24;
4943 info
.li_line_base
>>= 24;
4945 printf (_(" Length: %ld\n"), info
.li_length
);
4946 printf (_(" DWARF Version: %d\n"), info
.li_version
);
4947 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
4948 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
4949 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
4950 printf (_(" Line Base: %d\n"), info
.li_line_base
);
4951 printf (_(" Line Range: %d\n"), info
.li_line_range
);
4952 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
4954 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
4956 reset_state_machine (info
.li_default_is_stmt
);
4958 /* Display the contents of the Opcodes table. */
4959 standard_opcodes
= data
+ sizeof (* external
);
4961 printf (_("\n Opcodes:\n"));
4963 for (i
= 1; i
< info
.li_opcode_base
; i
++)
4964 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
4966 /* Display the contents of the Directory table. */
4967 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
4970 printf (_("\n The Directory Table is empty.\n"));
4973 printf (_("\n The Directory Table:\n"));
4977 printf (_(" %s\n"), data
);
4979 data
+= strlen (data
) + 1;
4983 /* Skip the NUL at the end of the table. */
4986 /* Display the contents of the File Name table. */
4988 printf (_("\n The File Name Table is empty.\n"));
4991 printf (_("\n The File Name Table:\n"));
4992 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4999 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5002 data
+= strlen (data
) + 1;
5004 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5006 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5008 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5010 printf (_("%s\n"), name
);
5014 /* Skip the NUL at the end of the table. */
5017 /* Now display the statements. */
5018 printf (_("\n Line Number Statements:\n"));
5021 while (data
< end_of_sequence
)
5023 unsigned char op_code
;
5027 op_code
= * data
++;
5031 case DW_LNS_extended_op
:
5032 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5033 debug_line_pointer_size
);
5037 printf (_(" Copy\n"));
5040 case DW_LNS_advance_pc
:
5041 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5043 state_machine_regs
.address
+= adv
;
5044 printf (_(" Advance PC by %d to %lx\n"), adv
,
5045 state_machine_regs
.address
);
5048 case DW_LNS_advance_line
:
5049 adv
= read_leb128 (data
, & bytes_read
, 1);
5051 state_machine_regs
.line
+= adv
;
5052 printf (_(" Advance Line by %d to %d\n"), adv
,
5053 state_machine_regs
.line
);
5056 case DW_LNS_set_file
:
5057 adv
= read_leb128 (data
, & bytes_read
, 0);
5059 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5061 state_machine_regs
.file
= adv
;
5064 case DW_LNS_set_column
:
5065 adv
= read_leb128 (data
, & bytes_read
, 0);
5067 printf (_(" Set column to %d\n"), adv
);
5068 state_machine_regs
.column
= adv
;
5071 case DW_LNS_negate_stmt
:
5072 adv
= state_machine_regs
.is_stmt
;
5074 printf (_(" Set is_stmt to %d\n"), adv
);
5075 state_machine_regs
.is_stmt
= adv
;
5078 case DW_LNS_set_basic_block
:
5079 printf (_(" Set basic block\n"));
5080 state_machine_regs
.basic_block
= 1;
5083 case DW_LNS_const_add_pc
:
5084 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5085 * info
.li_min_insn_length
);
5086 state_machine_regs
.address
+= adv
;
5087 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5088 state_machine_regs
.address
);
5091 case DW_LNS_fixed_advance_pc
:
5092 adv
= byte_get (data
, 2);
5094 state_machine_regs
.address
+= adv
;
5095 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5096 adv
, state_machine_regs
.address
);
5100 op_code
-= info
.li_opcode_base
;
5101 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5102 state_machine_regs
.address
+= adv
;
5103 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5104 op_code
, adv
, state_machine_regs
.address
);
5105 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5106 state_machine_regs
.line
+= adv
;
5107 printf (_(" and Line by %d to %d\n"),
5108 adv
, state_machine_regs
.line
);
5119 display_debug_pubnames (section
, start
, file
)
5120 Elf32_Internal_Shdr
* section
;
5121 unsigned char * start
;
5122 FILE * file ATTRIBUTE_UNUSED
;
5124 DWARF2_External_PubNames
* external
;
5125 DWARF2_Internal_PubNames pubnames
;
5126 unsigned char * end
;
5128 end
= start
+ section
->sh_size
;
5130 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5134 unsigned char * data
;
5135 unsigned long offset
;
5137 external
= (DWARF2_External_PubNames
*) start
;
5139 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5140 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5141 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5142 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5144 data
= start
+ sizeof (* external
);
5145 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5147 if (pubnames
.pn_version
!= 2)
5149 warn (_("Only DWARF 2 pubnames are currently supported"));
5153 printf (_(" Length: %ld\n"),
5154 pubnames
.pn_length
);
5155 printf (_(" Version: %d\n"),
5156 pubnames
.pn_version
);
5157 printf (_(" Offset into .debug_info section: %ld\n"),
5158 pubnames
.pn_offset
);
5159 printf (_(" Size of area in .debug_info section: %ld\n"),
5162 printf (_("\n Offset\tName\n"));
5166 offset
= byte_get (data
, 4);
5171 printf (" %ld\t\t%s\n", offset
, data
);
5172 data
+= strlen (data
) + 1;
5175 while (offset
!= 0);
5188 case DW_TAG_padding
: return "DW_TAG_padding";
5189 case DW_TAG_array_type
: return "DW_TAG_array_type";
5190 case DW_TAG_class_type
: return "DW_TAG_class_type";
5191 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5192 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5193 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5194 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5195 case DW_TAG_label
: return "DW_TAG_label";
5196 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5197 case DW_TAG_member
: return "DW_TAG_member";
5198 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5199 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5200 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5201 case DW_TAG_string_type
: return "DW_TAG_string_type";
5202 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5203 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5204 case DW_TAG_typedef
: return "DW_TAG_typedef";
5205 case DW_TAG_union_type
: return "DW_TAG_union_type";
5206 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5207 case DW_TAG_variant
: return "DW_TAG_variant";
5208 case DW_TAG_common_block
: return "DW_TAG_common_block";
5209 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5210 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5211 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5212 case DW_TAG_module
: return "DW_TAG_module";
5213 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5214 case DW_TAG_set_type
: return "DW_TAG_set_type";
5215 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5216 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5217 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5218 case DW_TAG_base_type
: return "DW_TAG_base_type";
5219 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5220 case DW_TAG_const_type
: return "DW_TAG_const_type";
5221 case DW_TAG_constant
: return "DW_TAG_constant";
5222 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5223 case DW_TAG_file_type
: return "DW_TAG_file_type";
5224 case DW_TAG_friend
: return "DW_TAG_friend";
5225 case DW_TAG_namelist
: return "DW_TAG_namelist";
5226 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5227 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5228 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5229 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5230 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5231 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5232 case DW_TAG_try_block
: return "DW_TAG_try_block";
5233 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5234 case DW_TAG_variable
: return "DW_TAG_variable";
5235 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5236 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5237 case DW_TAG_format_label
: return "DW_TAG_format_label";
5238 case DW_TAG_function_template
: return "DW_TAG_function_template";
5239 case DW_TAG_class_template
: return "DW_TAG_class_template";
5242 static char buffer
[100];
5244 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5251 get_AT_name (attribute
)
5252 unsigned long attribute
;
5256 case DW_AT_sibling
: return "DW_AT_sibling";
5257 case DW_AT_location
: return "DW_AT_location";
5258 case DW_AT_name
: return "DW_AT_name";
5259 case DW_AT_ordering
: return "DW_AT_ordering";
5260 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5261 case DW_AT_byte_size
: return "DW_AT_byte_size";
5262 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5263 case DW_AT_bit_size
: return "DW_AT_bit_size";
5264 case DW_AT_element_list
: return "DW_AT_element_list";
5265 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5266 case DW_AT_low_pc
: return "DW_AT_low_pc";
5267 case DW_AT_high_pc
: return "DW_AT_high_pc";
5268 case DW_AT_language
: return "DW_AT_language";
5269 case DW_AT_member
: return "DW_AT_member";
5270 case DW_AT_discr
: return "DW_AT_discr";
5271 case DW_AT_discr_value
: return "DW_AT_discr_value";
5272 case DW_AT_visibility
: return "DW_AT_visibility";
5273 case DW_AT_import
: return "DW_AT_import";
5274 case DW_AT_string_length
: return "DW_AT_string_length";
5275 case DW_AT_common_reference
: return "DW_AT_common_reference";
5276 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5277 case DW_AT_const_value
: return "DW_AT_const_value";
5278 case DW_AT_containing_type
: return "DW_AT_containing_type";
5279 case DW_AT_default_value
: return "DW_AT_default_value";
5280 case DW_AT_inline
: return "DW_AT_inline";
5281 case DW_AT_is_optional
: return "DW_AT_is_optional";
5282 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5283 case DW_AT_producer
: return "DW_AT_producer";
5284 case DW_AT_prototyped
: return "DW_AT_prototyped";
5285 case DW_AT_return_addr
: return "DW_AT_return_addr";
5286 case DW_AT_start_scope
: return "DW_AT_start_scope";
5287 case DW_AT_stride_size
: return "DW_AT_stride_size";
5288 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5289 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5290 case DW_AT_accessibility
: return "DW_AT_accessibility";
5291 case DW_AT_address_class
: return "DW_AT_address_class";
5292 case DW_AT_artificial
: return "DW_AT_artificial";
5293 case DW_AT_base_types
: return "DW_AT_base_types";
5294 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5295 case DW_AT_count
: return "DW_AT_count";
5296 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5297 case DW_AT_decl_column
: return "DW_AT_decl_column";
5298 case DW_AT_decl_file
: return "DW_AT_decl_file";
5299 case DW_AT_decl_line
: return "DW_AT_decl_line";
5300 case DW_AT_declaration
: return "DW_AT_declaration";
5301 case DW_AT_discr_list
: return "DW_AT_discr_list";
5302 case DW_AT_encoding
: return "DW_AT_encoding";
5303 case DW_AT_external
: return "DW_AT_external";
5304 case DW_AT_frame_base
: return "DW_AT_frame_base";
5305 case DW_AT_friend
: return "DW_AT_friend";
5306 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5307 case DW_AT_macro_info
: return "DW_AT_macro_info";
5308 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5309 case DW_AT_priority
: return "DW_AT_priority";
5310 case DW_AT_segment
: return "DW_AT_segment";
5311 case DW_AT_specification
: return "DW_AT_specification";
5312 case DW_AT_static_link
: return "DW_AT_static_link";
5313 case DW_AT_type
: return "DW_AT_type";
5314 case DW_AT_use_location
: return "DW_AT_use_location";
5315 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5316 case DW_AT_virtuality
: return "DW_AT_virtuality";
5317 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5318 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5319 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5320 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5321 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5322 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5323 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5324 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5325 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5326 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5327 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5328 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5329 case DW_AT_sf_names
: return "DW_AT_sf_names";
5330 case DW_AT_src_info
: return "DW_AT_src_info";
5331 case DW_AT_mac_info
: return "DW_AT_mac_info";
5332 case DW_AT_src_coords
: return "DW_AT_src_coords";
5333 case DW_AT_body_begin
: return "DW_AT_body_begin";
5334 case DW_AT_body_end
: return "DW_AT_body_end";
5337 static char buffer
[100];
5339 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5346 get_FORM_name (form
)
5351 case DW_FORM_addr
: return "DW_FORM_addr";
5352 case DW_FORM_block2
: return "DW_FORM_block2";
5353 case DW_FORM_block4
: return "DW_FORM_block4";
5354 case DW_FORM_data2
: return "DW_FORM_data2";
5355 case DW_FORM_data4
: return "DW_FORM_data4";
5356 case DW_FORM_data8
: return "DW_FORM_data8";
5357 case DW_FORM_string
: return "DW_FORM_string";
5358 case DW_FORM_block
: return "DW_FORM_block";
5359 case DW_FORM_block1
: return "DW_FORM_block1";
5360 case DW_FORM_data1
: return "DW_FORM_data1";
5361 case DW_FORM_flag
: return "DW_FORM_flag";
5362 case DW_FORM_sdata
: return "DW_FORM_sdata";
5363 case DW_FORM_strp
: return "DW_FORM_strp";
5364 case DW_FORM_udata
: return "DW_FORM_udata";
5365 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5366 case DW_FORM_ref1
: return "DW_FORM_ref1";
5367 case DW_FORM_ref2
: return "DW_FORM_ref2";
5368 case DW_FORM_ref4
: return "DW_FORM_ref4";
5369 case DW_FORM_ref8
: return "DW_FORM_ref8";
5370 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5371 case DW_FORM_indirect
: return "DW_FORM_indirect";
5374 static char buffer
[100];
5376 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5382 /* FIXME: There are better and more effiecint ways to handle
5383 these structures. For now though, I just want something that
5384 is simple to implement. */
5385 typedef struct abbrev_attr
5387 unsigned long attribute
;
5389 struct abbrev_attr
* next
;
5393 typedef struct abbrev_entry
5395 unsigned long entry
;
5398 struct abbrev_attr
* first_attr
;
5399 struct abbrev_attr
* last_attr
;
5400 struct abbrev_entry
* next
;
5404 static abbrev_entry
* first_abbrev
= NULL
;
5405 static abbrev_entry
* last_abbrev
= NULL
;
5408 free_abbrevs
PARAMS ((void))
5410 abbrev_entry
* abbrev
;
5412 for (abbrev
= first_abbrev
; abbrev
;)
5414 abbrev_entry
* next
= abbrev
->next
;
5417 for (attr
= abbrev
->first_attr
; attr
;)
5419 abbrev_attr
* next
= attr
->next
;
5429 last_abbrev
= first_abbrev
= NULL
;
5433 add_abbrev (number
, tag
, children
)
5434 unsigned long number
;
5438 abbrev_entry
* entry
;
5440 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5446 entry
->entry
= number
;
5448 entry
->children
= children
;
5449 entry
->first_attr
= NULL
;
5450 entry
->last_attr
= NULL
;
5453 if (first_abbrev
== NULL
)
5454 first_abbrev
= entry
;
5456 last_abbrev
->next
= entry
;
5458 last_abbrev
= entry
;
5462 add_abbrev_attr (attribute
, form
)
5463 unsigned long attribute
;
5468 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5474 attr
->attribute
= attribute
;
5478 if (last_abbrev
->first_attr
== NULL
)
5479 last_abbrev
->first_attr
= attr
;
5481 last_abbrev
->last_attr
->next
= attr
;
5483 last_abbrev
->last_attr
= attr
;
5486 /* Processes the (partial) contents of a .debug_abbrev section.
5487 Returns NULL if the end of the section was encountered.
5488 Returns the address after the last byte read if the end of
5489 an abbreviation set was found. */
5491 static unsigned char *
5492 process_abbrev_section (start
, end
)
5493 unsigned char * start
;
5494 unsigned char * end
;
5496 if (first_abbrev
!= NULL
)
5502 unsigned long entry
;
5504 unsigned long attribute
;
5507 entry
= read_leb128 (start
, & bytes_read
, 0);
5508 start
+= bytes_read
;
5510 /* A single zero is supposed to end the section according
5511 to the standard. If there's more, then signal that to
5514 return start
== end
? NULL
: start
;
5516 tag
= read_leb128 (start
, & bytes_read
, 0);
5517 start
+= bytes_read
;
5519 children
= * start
++;
5521 add_abbrev (entry
, tag
, children
);
5527 attribute
= read_leb128 (start
, & bytes_read
, 0);
5528 start
+= bytes_read
;
5530 form
= read_leb128 (start
, & bytes_read
, 0);
5531 start
+= bytes_read
;
5534 add_abbrev_attr (attribute
, form
);
5536 while (attribute
!= 0);
5544 display_debug_abbrev (section
, start
, file
)
5545 Elf32_Internal_Shdr
* section
;
5546 unsigned char * start
;
5547 FILE * file ATTRIBUTE_UNUSED
;
5549 abbrev_entry
* entry
;
5550 unsigned char * end
= start
+ section
->sh_size
;
5552 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5556 start
= process_abbrev_section (start
, end
);
5558 printf (_(" Number TAG\n"));
5560 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5564 printf (_(" %ld %s [%s]\n"),
5566 get_TAG_name (entry
->tag
),
5567 entry
->children
? _("has children") : _("no children"));
5569 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5571 printf (_(" %-18s %s\n"),
5572 get_AT_name (attr
->attribute
),
5573 get_FORM_name (attr
->form
));
5585 static unsigned char *
5586 display_block (data
, length
)
5587 unsigned char * data
;
5588 unsigned long length
;
5590 printf (_(" %lu byte block: "), length
);
5593 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5599 decode_location_expression (data
, pointer_size
, length
)
5600 unsigned char * data
;
5601 unsigned int pointer_size
;
5602 unsigned long length
;
5606 unsigned long uvalue
;
5607 unsigned char *end
= data
+ length
;
5616 printf ("DW_OP_addr: %lx",
5617 (unsigned long) byte_get (data
, pointer_size
));
5618 data
+= pointer_size
;
5621 printf ("DW_OP_deref");
5624 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
5627 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
5630 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5634 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5638 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5642 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5646 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5647 (unsigned long) byte_get (data
+ 4, 4));
5651 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5652 (long) byte_get (data
+ 4, 4));
5656 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
5660 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
5664 printf ("DW_OP_dup");
5667 printf ("DW_OP_drop");
5670 printf ("DW_OP_over");
5673 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
5676 printf ("DW_OP_swap");
5679 printf ("DW_OP_rot");
5682 printf ("DW_OP_xderef");
5685 printf ("DW_OP_abs");
5688 printf ("DW_OP_and");
5691 printf ("DW_OP_div");
5694 printf ("DW_OP_minus");
5697 printf ("DW_OP_mod");
5700 printf ("DW_OP_mul");
5703 printf ("DW_OP_neg");
5706 printf ("DW_OP_not");
5709 printf ("DW_OP_or");
5712 printf ("DW_OP_plus");
5714 case DW_OP_plus_uconst
:
5715 printf ("DW_OP_plus_uconst: %lu",
5716 read_leb128 (data
, &bytes_read
, 0));
5720 printf ("DW_OP_shl");
5723 printf ("DW_OP_shr");
5726 printf ("DW_OP_shra");
5729 printf ("DW_OP_xor");
5732 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5736 printf ("DW_OP_eq");
5739 printf ("DW_OP_ge");
5742 printf ("DW_OP_gt");
5745 printf ("DW_OP_le");
5748 printf ("DW_OP_lt");
5751 printf ("DW_OP_ne");
5754 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5790 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
5825 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
5860 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
5861 read_leb128 (data
, &bytes_read
, 1));
5866 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
5870 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
5874 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5876 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5877 read_leb128 (data
, &bytes_read
, 1));
5881 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
5884 case DW_OP_deref_size
:
5885 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
5887 case DW_OP_xderef_size
:
5888 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
5891 printf ("DW_OP_nop");
5895 if (op
>= DW_OP_lo_user
5896 && op
<= DW_OP_hi_user
)
5897 printf (_("(User defined location op)"));
5899 printf (_("(Unknown location op)"));
5900 /* No way to tell where the next op is, so just bail. */
5907 static unsigned char *
5908 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
5909 unsigned long attribute
;
5911 unsigned char * data
;
5912 unsigned long cu_offset
;
5913 unsigned long pointer_size
;
5915 unsigned long uvalue
= 0;
5916 unsigned char * block_start
= NULL
;
5919 printf (" %-18s:", get_AT_name (attribute
));
5923 case DW_FORM_ref_addr
:
5925 uvalue
= byte_get (data
, pointer_size
);
5926 data
+= pointer_size
;
5932 uvalue
= byte_get (data
++, 1);
5937 uvalue
= byte_get (data
, 2);
5943 uvalue
= byte_get (data
, 4);
5948 uvalue
= read_leb128 (data
, & bytes_read
, 1);
5952 case DW_FORM_ref_udata
:
5954 uvalue
= read_leb128 (data
, & bytes_read
, 0);
5961 case DW_FORM_ref_addr
:
5962 printf (" <#%lx>", uvalue
);
5968 case DW_FORM_ref_udata
:
5969 printf (" <%lx>", uvalue
+ cu_offset
);
5973 printf (" %#lx", uvalue
);
5981 printf (" %ld", uvalue
);
5986 uvalue
= byte_get (data
, 4);
5987 printf (" %lx", uvalue
);
5988 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
5992 case DW_FORM_string
:
5993 printf (" %s", data
);
5994 data
+= strlen (data
) + 1;
5998 uvalue
= read_leb128 (data
, & bytes_read
, 0);
5999 block_start
= data
+ bytes_read
;
6000 data
= display_block (block_start
, uvalue
);
6003 case DW_FORM_block1
:
6004 uvalue
= byte_get (data
, 1);
6005 block_start
= data
+ 1;
6006 data
= display_block (block_start
, uvalue
);
6009 case DW_FORM_block2
:
6010 uvalue
= byte_get (data
, 2);
6011 block_start
= data
+ 2;
6012 data
= display_block (block_start
, uvalue
);
6015 case DW_FORM_block4
:
6016 uvalue
= byte_get (data
, 4);
6017 block_start
= data
+ 4;
6018 data
= display_block (block_start
, uvalue
);
6022 case DW_FORM_indirect
:
6023 warn (_("Unable to handle FORM: %d"), form
);
6027 warn (_("Unrecognised form: %d"), form
);
6031 /* For some attributes we can display futher information. */
6040 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6041 case DW_INL_inlined
: printf (_("(inlined)")); break;
6042 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6043 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6044 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6048 case DW_AT_language
:
6051 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6052 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6053 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6054 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6055 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6056 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6057 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6058 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6059 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6060 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6061 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6062 default: printf ("(Unknown: %lx)", uvalue
); break;
6066 case DW_AT_encoding
:
6069 case DW_ATE_void
: printf ("(void)"); break;
6070 case DW_ATE_address
: printf ("(machine address)"); break;
6071 case DW_ATE_boolean
: printf ("(boolean)"); break;
6072 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6073 case DW_ATE_float
: printf ("(float)"); break;
6074 case DW_ATE_signed
: printf ("(signed)"); break;
6075 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6076 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6077 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6079 if (uvalue
>= DW_ATE_lo_user
6080 && uvalue
<= DW_ATE_hi_user
)
6081 printf ("(user defined type)");
6083 printf ("(unknown type)");
6088 case DW_AT_accessibility
:
6091 case DW_ACCESS_public
: printf ("(public)"); break;
6092 case DW_ACCESS_protected
: printf ("(protected)"); break;
6093 case DW_ACCESS_private
: printf ("(private)"); break;
6094 default: printf ("(unknown accessibility)"); break;
6098 case DW_AT_visibility
:
6101 case DW_VIS_local
: printf ("(local)"); break;
6102 case DW_VIS_exported
: printf ("(exported)"); break;
6103 case DW_VIS_qualified
: printf ("(qualified)"); break;
6104 default: printf ("(unknown visibility)"); break;
6108 case DW_AT_virtuality
:
6111 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6112 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6113 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6114 default: printf ("(unknown virtuality)"); break;
6118 case DW_AT_identifier_case
:
6121 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6122 case DW_ID_up_case
: printf ("(up_case)"); break;
6123 case DW_ID_down_case
: printf ("(down_case)"); break;
6124 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6125 default: printf ("(unknown case)"); break;
6129 case DW_AT_calling_convention
:
6132 case DW_CC_normal
: printf ("(normal)"); break;
6133 case DW_CC_program
: printf ("(program)"); break;
6134 case DW_CC_nocall
: printf ("(nocall)"); break;
6136 if (uvalue
>= DW_CC_lo_user
6137 && uvalue
<= DW_CC_hi_user
)
6138 printf ("(user defined)");
6140 printf ("(unknown convention)");
6144 case DW_AT_frame_base
:
6145 case DW_AT_location
:
6146 case DW_AT_data_member_location
:
6147 case DW_AT_vtable_elem_location
:
6151 decode_location_expression (block_start
, pointer_size
, uvalue
);
6165 display_debug_info (section
, start
, file
)
6166 Elf32_Internal_Shdr
* section
;
6167 unsigned char * start
;
6170 unsigned char * end
= start
+ section
->sh_size
;
6171 unsigned char * section_begin
= start
;
6173 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6177 DWARF2_External_CompUnit
* external
;
6178 DWARF2_Internal_CompUnit compunit
;
6179 unsigned char * tags
;
6182 unsigned long cu_offset
;
6184 external
= (DWARF2_External_CompUnit
*) start
;
6186 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6187 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6188 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6189 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6191 tags
= start
+ sizeof (* external
);
6192 cu_offset
= start
- section_begin
;
6193 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6195 if (compunit
.cu_version
!= 2)
6197 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6201 printf (_(" Compilation Unit:\n"));
6202 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6203 printf (_(" Version: %d\n"), compunit
.cu_version
);
6204 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6205 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6207 if (first_abbrev
!= NULL
)
6210 /* Read in the abbrevs used by this compilation unit. */
6213 Elf32_Internal_Shdr
* sec
;
6214 unsigned char * begin
;
6216 /* Locate the .debug_abbrev section and process it. */
6217 for (i
= 0, sec
= section_headers
;
6218 i
< elf_header
.e_shnum
;
6220 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6223 if (i
== -1 || sec
->sh_size
== 0)
6225 warn (_("Unable to locate .debug_abbrev section!\n"));
6229 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6230 "debug_abbrev section data");
6232 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6233 begin
+ sec
->sh_size
);
6239 while (tags
< start
)
6242 unsigned long abbrev_number
;
6243 abbrev_entry
* entry
;
6246 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6249 /* A null DIE marks the end of a list of children. */
6250 if (abbrev_number
== 0)
6256 /* Scan through the abbreviation list until we reach the
6258 for (entry
= first_abbrev
;
6259 entry
&& entry
->entry
!= abbrev_number
;
6260 entry
= entry
->next
)
6265 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6270 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6271 level
, tags
- section_begin
- bytes_read
,
6273 get_TAG_name (entry
->tag
));
6275 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6276 tags
= read_and_display_attr (attr
->attribute
,
6279 compunit
.cu_pointer_size
);
6281 if (entry
->children
)
6292 display_debug_aranges (section
, start
, file
)
6293 Elf32_Internal_Shdr
* section
;
6294 unsigned char * start
;
6295 FILE * file ATTRIBUTE_UNUSED
;
6297 unsigned char * end
= start
+ section
->sh_size
;
6299 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6303 DWARF2_External_ARange
* external
;
6304 DWARF2_Internal_ARange arange
;
6305 unsigned char * ranges
;
6306 unsigned long length
;
6307 unsigned long address
;
6310 external
= (DWARF2_External_ARange
*) start
;
6312 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6313 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6314 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6315 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6316 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6318 printf (_(" Length: %ld\n"), arange
.ar_length
);
6319 printf (_(" Version: %d\n"), arange
.ar_version
);
6320 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6321 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6322 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6324 printf (_("\n Address Length\n"));
6326 ranges
= start
+ sizeof (* external
);
6328 /* Must pad to an alignment boundary that is twice the pointer size. */
6329 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6331 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6335 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6337 ranges
+= arange
.ar_pointer_size
;
6339 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6341 ranges
+= arange
.ar_pointer_size
;
6343 /* A pair of zeros marks the end of the list. */
6344 if (address
== 0 && length
== 0)
6347 printf (" %8.8lx %lu\n", address
, length
);
6350 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6360 display_debug_not_supported (section
, start
, file
)
6361 Elf32_Internal_Shdr
* section
;
6362 unsigned char * start ATTRIBUTE_UNUSED
;
6363 FILE * file ATTRIBUTE_UNUSED
;
6365 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6366 SECTION_NAME (section
));
6371 /* Pre-scan the .debug_info section to record the size of address.
6372 When dumping the .debug_line, we use that size information, assuming
6373 that all compilation units have the same address size. */
6375 prescan_debug_info (section
, start
, file
)
6376 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6377 unsigned char * start
;
6378 FILE * file ATTRIBUTE_UNUSED
;
6380 DWARF2_External_CompUnit
* external
;
6382 external
= (DWARF2_External_CompUnit
*) start
;
6384 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6388 /* A structure containing the name of a debug section and a pointer
6389 to a function that can decode it. The third field is a prescan
6390 function to be run over the section before displaying any of the
6395 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6396 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6400 { ".debug_info", display_debug_info
, prescan_debug_info
},
6401 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6402 { ".debug_line", display_debug_lines
, NULL
},
6403 { ".debug_aranges", display_debug_aranges
, NULL
},
6404 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6405 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6406 { ".debug_frame", display_debug_not_supported
, NULL
},
6407 { ".debug_str", display_debug_not_supported
, NULL
},
6408 { ".debug_static_func", display_debug_not_supported
, NULL
},
6409 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6410 { ".debug_types", display_debug_not_supported
, NULL
},
6411 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6415 display_debug_section (section
, file
)
6416 Elf32_Internal_Shdr
* section
;
6419 char * name
= SECTION_NAME (section
);
6420 bfd_size_type length
;
6421 unsigned char * start
;
6424 length
= section
->sh_size
;
6427 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6431 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6432 "debug section data");
6434 /* See if we know how to display the contents of this section. */
6435 for (i
= NUM_ELEM (debug_displays
); i
--;)
6436 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6438 debug_displays
[i
].display (section
, start
, file
);
6443 printf (_("Unrecognised debug section: %s\n"), name
);
6447 /* If we loaded in the abbrev section at some point,
6448 we must release it here. */
6449 if (first_abbrev
!= NULL
)
6456 process_section_contents (file
)
6459 Elf32_Internal_Shdr
* section
;
6465 /* Pre-scan the debug sections to find some debug information not
6466 present in some of them. For the .debug_line, we must find out the
6467 size of address (specified in .debug_info and .debug_aranges). */
6468 for (i
= 0, section
= section_headers
;
6469 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6472 char * name
= SECTION_NAME (section
);
6475 if (section
->sh_size
== 0)
6478 /* See if there is some pre-scan operation for this section. */
6479 for (j
= NUM_ELEM (debug_displays
); j
--;)
6480 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6482 if (debug_displays
[j
].prescan
!= NULL
)
6484 bfd_size_type length
;
6485 unsigned char * start
;
6487 length
= section
->sh_size
;
6488 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6489 "debug section data");
6491 debug_displays
[j
].prescan (section
, start
, file
);
6499 for (i
= 0, section
= section_headers
;
6500 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6503 #ifdef SUPPORT_DISASSEMBLY
6504 if (dump_sects
[i
] & DISASS_DUMP
)
6505 disassemble_section (section
, file
);
6507 if (dump_sects
[i
] & HEX_DUMP
)
6508 dump_section (section
, file
);
6510 if (dump_sects
[i
] & DEBUG_DUMP
)
6511 display_debug_section (section
, file
);
6514 if (i
< num_dump_sects
)
6515 warn (_("Some sections were not dumped because they do not exist!\n"));
6521 process_mips_fpe_exception (mask
)
6527 if (mask
& OEX_FPU_INEX
)
6528 fputs ("INEX", stdout
), first
= 0;
6529 if (mask
& OEX_FPU_UFLO
)
6530 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6531 if (mask
& OEX_FPU_OFLO
)
6532 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6533 if (mask
& OEX_FPU_DIV0
)
6534 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6535 if (mask
& OEX_FPU_INVAL
)
6536 printf ("%sINVAL", first
? "" : "|");
6539 fputs ("0", stdout
);
6543 process_mips_specific (file
)
6546 Elf_Internal_Dyn
* entry
;
6547 size_t liblist_offset
= 0;
6548 size_t liblistno
= 0;
6549 size_t conflictsno
= 0;
6550 size_t options_offset
= 0;
6551 size_t conflicts_offset
= 0;
6553 /* We have a lot of special sections. Thanks SGI! */
6554 if (dynamic_segment
== NULL
)
6555 /* No information available. */
6558 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6559 switch (entry
->d_tag
)
6561 case DT_MIPS_LIBLIST
:
6562 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6564 case DT_MIPS_LIBLISTNO
:
6565 liblistno
= entry
->d_un
.d_val
;
6567 case DT_MIPS_OPTIONS
:
6568 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6570 case DT_MIPS_CONFLICT
:
6571 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6573 case DT_MIPS_CONFLICTNO
:
6574 conflictsno
= entry
->d_un
.d_val
;
6580 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6582 Elf32_External_Lib
* elib
;
6585 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6586 elib
, Elf32_External_Lib
*, "liblist");
6588 printf ("\nSection '.liblist' contains %lu entries:\n",
6589 (unsigned long) liblistno
);
6590 fputs (" Library Time Stamp Checksum Version Flags\n",
6593 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6599 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6600 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6601 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6602 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6603 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6605 strftime (timebuf
, 20, "%Y-%m-%dT%H:%M:%S", gmtime (&time
));
6607 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6608 dynamic_strings
+ liblist
.l_name
, timebuf
,
6609 liblist
.l_checksum
, liblist
.l_version
);
6611 if (liblist
.l_flags
== 0)
6622 { " EXACT_MATCH", LL_EXACT_MATCH
},
6623 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6624 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6625 { " EXPORTS", LL_EXPORTS
},
6626 { " DELAY_LOAD", LL_DELAY_LOAD
},
6627 { " DELTA", LL_DELTA
}
6629 int flags
= liblist
.l_flags
;
6633 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6635 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6637 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6638 flags
^= l_flags_vals
[fcnt
].bit
;
6641 printf (" %#x", (unsigned int) flags
);
6650 if (options_offset
!= 0)
6652 Elf_External_Options
* eopt
;
6653 Elf_Internal_Shdr
* sect
= section_headers
;
6654 Elf_Internal_Options
* iopt
;
6655 Elf_Internal_Options
* option
;
6659 /* Find the section header so that we get the size. */
6660 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6663 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6664 Elf_External_Options
*, "options");
6666 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6670 error (_("Out of memory"));
6677 while (offset
< sect
->sh_size
)
6679 Elf_External_Options
* eoption
;
6681 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6683 option
->kind
= BYTE_GET (eoption
->kind
);
6684 option
->size
= BYTE_GET (eoption
->size
);
6685 option
->section
= BYTE_GET (eoption
->section
);
6686 option
->info
= BYTE_GET (eoption
->info
);
6688 offset
+= option
->size
;
6694 printf (_("\nSection '%s' contains %d entries:\n"),
6695 string_table
+ sect
->sh_name
, cnt
);
6703 switch (option
->kind
)
6706 /* This shouldn't happen. */
6707 printf (" NULL %d %lx", option
->section
, option
->info
);
6710 printf (" REGINFO ");
6711 if (elf_header
.e_machine
== EM_MIPS
)
6714 Elf32_External_RegInfo
*ereg
;
6715 Elf32_RegInfo reginfo
;
6717 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6718 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6719 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6720 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6721 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6722 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6723 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6725 printf ("GPR %08lx GP 0x%lx\n",
6727 (unsigned long) reginfo
.ri_gp_value
);
6728 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6729 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6730 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6735 Elf64_External_RegInfo
* ereg
;
6736 Elf64_Internal_RegInfo reginfo
;
6738 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6739 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6740 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6741 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6742 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6743 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6744 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6746 printf ("GPR %08lx GP 0x",
6747 reginfo
.ri_gprmask
);
6748 printf_vma (reginfo
.ri_gp_value
);
6751 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6752 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6753 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6757 case ODK_EXCEPTIONS
:
6758 fputs (" EXCEPTIONS fpe_min(", stdout
);
6759 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6760 fputs (") fpe_max(", stdout
);
6761 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6762 fputs (")", stdout
);
6764 if (option
->info
& OEX_PAGE0
)
6765 fputs (" PAGE0", stdout
);
6766 if (option
->info
& OEX_SMM
)
6767 fputs (" SMM", stdout
);
6768 if (option
->info
& OEX_FPDBUG
)
6769 fputs (" FPDBUG", stdout
);
6770 if (option
->info
& OEX_DISMISS
)
6771 fputs (" DISMISS", stdout
);
6774 fputs (" PAD ", stdout
);
6775 if (option
->info
& OPAD_PREFIX
)
6776 fputs (" PREFIX", stdout
);
6777 if (option
->info
& OPAD_POSTFIX
)
6778 fputs (" POSTFIX", stdout
);
6779 if (option
->info
& OPAD_SYMBOL
)
6780 fputs (" SYMBOL", stdout
);
6783 fputs (" HWPATCH ", stdout
);
6784 if (option
->info
& OHW_R4KEOP
)
6785 fputs (" R4KEOP", stdout
);
6786 if (option
->info
& OHW_R8KPFETCH
)
6787 fputs (" R8KPFETCH", stdout
);
6788 if (option
->info
& OHW_R5KEOP
)
6789 fputs (" R5KEOP", stdout
);
6790 if (option
->info
& OHW_R5KCVTL
)
6791 fputs (" R5KCVTL", stdout
);
6794 fputs (" FILL ", stdout
);
6795 /* XXX Print content of info word? */
6798 fputs (" TAGS ", stdout
);
6799 /* XXX Print content of info word? */
6802 fputs (" HWAND ", stdout
);
6803 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6804 fputs (" R4KEOP_CHECKED", stdout
);
6805 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6806 fputs (" R4KEOP_CLEAN", stdout
);
6809 fputs (" HWOR ", stdout
);
6810 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6811 fputs (" R4KEOP_CHECKED", stdout
);
6812 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6813 fputs (" R4KEOP_CLEAN", stdout
);
6816 printf (" GP_GROUP %#06lx self-contained %#06lx",
6817 option
->info
& OGP_GROUP
,
6818 (option
->info
& OGP_SELF
) >> 16);
6821 printf (" IDENT %#06lx self-contained %#06lx",
6822 option
->info
& OGP_GROUP
,
6823 (option
->info
& OGP_SELF
) >> 16);
6826 /* This shouldn't happen. */
6827 printf (" %3d ??? %d %lx",
6828 option
->kind
, option
->section
, option
->info
);
6832 len
= sizeof (*eopt
);
6833 while (len
< option
->size
)
6834 if (((char *) option
)[len
] >= ' '
6835 && ((char *) option
)[len
] < 0x7f)
6836 printf ("%c", ((char *) option
)[len
++]);
6838 printf ("\\%03o", ((char *) option
)[len
++]);
6840 fputs ("\n", stdout
);
6847 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6849 Elf32_External_Conflict
* econf32
;
6850 Elf64_External_Conflict
* econf64
;
6851 Elf32_Conflict
* iconf
;
6854 if (dynamic_symbols
== NULL
)
6856 error (_("conflict list with without table"));
6860 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6863 error (_("Out of memory"));
6869 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6870 econf32
, Elf32_External_Conflict
*, "conflict");
6872 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6873 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6877 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6878 econf64
, Elf64_External_Conflict
*, "conflict");
6880 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6881 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6884 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6885 puts (_(" Num: Index Value Name"));
6887 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6889 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6891 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
6892 print_vma (psym
->st_value
, FULL_HEX
);
6893 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6903 get_note_type (e_type
)
6906 static char buff
[64];
6910 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6911 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6912 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6913 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
6914 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
6915 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
6916 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
6917 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
6918 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6919 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
6920 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
6922 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
6927 /* Note that by the ELF standard, the name field is already null byte
6928 terminated, and namesz includes the terminating null byte.
6929 I.E. the value of namesz for the name "FSF" is 4.
6931 If the value of namesz is zero, there is no name present. */
6933 process_note (pnote
)
6934 Elf32_Internal_Note
* pnote
;
6936 printf (" %s\t\t0x%08lx\t%s\n",
6937 pnote
->namesz
? pnote
->namedata
: "(NONE)",
6938 pnote
->descsz
, get_note_type (pnote
->type
));
6944 process_corefile_note_segment (file
, offset
, length
)
6949 Elf_External_Note
* pnotes
;
6950 Elf_External_Note
* external
;
6956 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
6960 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
6961 (unsigned long) offset
, (unsigned long) length
);
6962 printf (_(" Owner\t\tData size\tDescription\n"));
6964 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
6966 Elf32_Internal_Note inote
;
6969 inote
.type
= BYTE_GET (external
->type
);
6970 inote
.namesz
= BYTE_GET (external
->namesz
);
6971 inote
.namedata
= external
->name
;
6972 inote
.descsz
= BYTE_GET (external
->descsz
);
6973 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
6974 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
6976 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
6978 /* Verify that name is null terminated. It appears that at least
6979 one version of Linux (RedHat 6.0) generates corefiles that don't
6980 comply with the ELF spec by failing to include the null byte in
6982 if (inote
.namedata
[inote
.namesz
] != '\0')
6984 temp
= malloc (inote
.namesz
+ 1);
6988 error (_("Out of memory\n"));
6993 strncpy (temp
, inote
.namedata
, inote
.namesz
);
6994 temp
[inote
.namesz
] = 0;
6996 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
6997 inote
.namedata
= temp
;
7000 res
&= process_note (& inote
);
7015 process_corefile_note_segments (file
)
7018 Elf_Internal_Phdr
* program_headers
;
7019 Elf_Internal_Phdr
* segment
;
7023 program_headers
= (Elf_Internal_Phdr
*) malloc
7024 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7026 if (program_headers
== NULL
)
7028 error (_("Out of memory\n"));
7033 i
= get_32bit_program_headers (file
, program_headers
);
7035 i
= get_64bit_program_headers (file
, program_headers
);
7039 free (program_headers
);
7043 for (i
= 0, segment
= program_headers
;
7044 i
< elf_header
.e_phnum
;
7047 if (segment
->p_type
== PT_NOTE
)
7048 res
&= process_corefile_note_segment (file
,
7049 (bfd_vma
) segment
->p_offset
,
7050 (bfd_vma
) segment
->p_filesz
);
7053 free (program_headers
);
7059 process_corefile_contents (file
)
7062 /* If we have not been asked to display the notes then do nothing. */
7066 /* If file is not a core file then exit. */
7067 if (elf_header
.e_type
!= ET_CORE
)
7070 /* No program headers means no NOTE segment. */
7071 if (elf_header
.e_phnum
== 0)
7073 printf (_("No note segments present in the core file.\n"));
7077 return process_corefile_note_segments (file
);
7081 process_arch_specific (file
)
7087 switch (elf_header
.e_machine
)
7090 case EM_MIPS_RS4_BE
:
7091 return process_mips_specific (file
);
7100 get_file_header (file
)
7103 /* Read in the identity array. */
7104 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7107 /* Determine how to read the rest of the header. */
7108 switch (elf_header
.e_ident
[EI_DATA
])
7110 default: /* fall through */
7111 case ELFDATANONE
: /* fall through */
7112 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7113 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7116 /* For now we only support 32 bit and 64 bit ELF files. */
7117 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7119 /* Read in the rest of the header. */
7122 Elf32_External_Ehdr ehdr32
;
7124 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7127 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7128 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7129 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7130 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7131 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7132 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7133 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7134 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7135 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7136 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7137 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7138 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7139 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7143 Elf64_External_Ehdr ehdr64
;
7145 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7146 we will not be able to cope with the 64bit data found in
7147 64 ELF files. Detect this now and abort before we start
7148 overwritting things. */
7149 if (sizeof (bfd_vma
) < 8)
7151 error (_("This instance of readelf has been built without support for a\n"));
7152 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7156 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7159 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7160 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7161 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7162 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7163 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7164 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7165 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7166 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7167 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7168 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7169 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7170 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7171 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7178 process_file (file_name
)
7182 struct stat statbuf
;
7185 if (stat (file_name
, & statbuf
) < 0)
7187 error (_("Cannot stat input file %s.\n"), file_name
);
7191 file
= fopen (file_name
, "rb");
7194 error (_("Input file %s not found.\n"), file_name
);
7198 if (! get_file_header (file
))
7200 error (_("%s: Failed to read file header\n"), file_name
);
7205 /* Initialise per file variables. */
7206 for (i
= NUM_ELEM (version_info
); i
--;)
7207 version_info
[i
] = 0;
7209 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7210 dynamic_info
[i
] = 0;
7212 /* Process the file. */
7214 printf (_("\nFile: %s\n"), file_name
);
7216 if (! process_file_header ())
7222 process_section_headers (file
);
7224 process_program_headers (file
);
7226 process_dynamic_segment (file
);
7228 process_relocs (file
);
7230 process_symbol_table (file
);
7232 process_syminfo (file
);
7234 process_version_sections (file
);
7236 process_section_contents (file
);
7238 process_corefile_contents (file
);
7240 process_arch_specific (file
);
7244 if (section_headers
)
7246 free (section_headers
);
7247 section_headers
= NULL
;
7252 free (string_table
);
7253 string_table
= NULL
;
7256 if (dynamic_strings
)
7258 free (dynamic_strings
);
7259 dynamic_strings
= NULL
;
7262 if (dynamic_symbols
)
7264 free (dynamic_symbols
);
7265 dynamic_symbols
= NULL
;
7266 num_dynamic_syms
= 0;
7269 if (dynamic_syminfo
)
7271 free (dynamic_syminfo
);
7272 dynamic_syminfo
= NULL
;
7276 #ifdef SUPPORT_DISASSEMBLY
7277 /* Needed by the i386 disassembler. For extra credit, someone could
7278 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7282 print_address (unsigned int addr
, FILE * outfile
)
7284 fprintf (outfile
,"0x%8.8x", addr
);
7287 /* Needed by the i386 disassembler. */
7289 db_task_printsym (unsigned int addr
)
7291 print_address (addr
, stderr
);
7300 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7301 setlocale (LC_MESSAGES
, "");
7303 bindtextdomain (PACKAGE
, LOCALEDIR
);
7304 textdomain (PACKAGE
);
7306 parse_args (argc
, argv
);
7308 if (optind
< (argc
- 1))
7311 while (optind
< argc
)
7312 process_file (argv
[optind
++]);
7314 if (dump_sects
!= NULL
)