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"
79 char * program_name
= "readelf";
80 unsigned int dynamic_addr
;
81 bfd_size_type dynamic_size
;
82 unsigned int rela_addr
;
83 unsigned int rela_size
;
84 char * dynamic_strings
;
86 unsigned long num_dynamic_syms
;
87 Elf_Internal_Sym
* dynamic_symbols
;
88 Elf_Internal_Syminfo
* dynamic_syminfo
;
89 unsigned long dynamic_syminfo_offset
;
90 unsigned int dynamic_syminfo_nent
;
91 char program_interpreter
[64];
92 int dynamic_info
[DT_JMPREL
+ 1];
95 Elf_Internal_Ehdr elf_header
;
96 Elf_Internal_Shdr
* section_headers
;
97 Elf_Internal_Dyn
* dynamic_segment
;
104 int do_using_dynamic
;
111 int do_debug_abbrevs
;
113 int do_debug_pubnames
;
114 int do_debug_aranges
;
119 /* A dynamic array of flags indicating which sections require dumping. */
120 char * dump_sects
= NULL
;
121 unsigned int num_dump_sects
= 0;
123 #define HEX_DUMP (1 << 0)
124 #define DISASS_DUMP (1 << 1)
125 #define DEBUG_DUMP (1 << 2)
127 /* How to rpint a vma value. */
128 typedef enum print_mode
140 /* Forward declarations for dumb compilers. */
141 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
142 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
143 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
144 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
145 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
146 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
147 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
148 static const char * get_dynamic_type
PARAMS ((unsigned long));
149 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
150 static char * get_file_type
PARAMS ((unsigned));
151 static char * get_machine_name
PARAMS ((unsigned));
152 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
153 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
154 static const char * get_mips_segment_type
PARAMS ((unsigned long));
155 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
156 static const char * get_segment_type
PARAMS ((unsigned long));
157 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
158 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
159 static const char * get_section_type_name
PARAMS ((unsigned int));
160 static const char * get_symbol_binding
PARAMS ((unsigned int));
161 static const char * get_symbol_type
PARAMS ((unsigned int));
162 static const char * get_symbol_visibility
PARAMS ((unsigned int));
163 static const char * get_symbol_index_type
PARAMS ((unsigned int));
164 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
165 static void usage
PARAMS ((void));
166 static void parse_args
PARAMS ((int, char **));
167 static int process_file_header
PARAMS ((void));
168 static int process_program_headers
PARAMS ((FILE *));
169 static int process_section_headers
PARAMS ((FILE *));
170 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
171 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
172 static int process_dynamic_segment
PARAMS ((FILE *));
173 static int process_symbol_table
PARAMS ((FILE *));
174 static int process_section_contents
PARAMS ((FILE *));
175 static void process_file
PARAMS ((char *));
176 static int process_relocs
PARAMS ((FILE *));
177 static int process_version_sections
PARAMS ((FILE *));
178 static char * get_ver_flags
PARAMS ((unsigned int));
179 static int get_32bit_section_headers
PARAMS ((FILE *));
180 static int get_64bit_section_headers
PARAMS ((FILE *));
181 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
182 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
183 static int get_file_header
PARAMS ((FILE *));
184 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
185 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
186 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
187 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
188 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
189 #ifdef SUPPORT_DISASSEMBLY
190 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
192 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
193 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
194 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
195 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
196 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
197 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
198 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
199 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
200 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
201 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
202 static void reset_state_machine
PARAMS ((int));
203 static char * get_TAG_name
PARAMS ((unsigned long));
204 static char * get_AT_name
PARAMS ((unsigned long));
205 static char * get_FORM_name
PARAMS ((unsigned long));
206 static void free_abbrevs
PARAMS ((void));
207 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
208 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
209 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
210 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
211 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
212 static void request_dump
PARAMS ((unsigned int, char));
213 static const char * get_elf_class
PARAMS ((unsigned char));
214 static const char * get_data_encoding
PARAMS ((unsigned char));
215 static const char * get_osabi_name
PARAMS ((unsigned char));
216 static int guess_is_rela
PARAMS ((unsigned long));
217 static char * get_note_type
PARAMS ((unsigned int));
218 static int process_note
PARAMS ((Elf32_Internal_Note
*));
219 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
220 static int process_corefile_note_segments
PARAMS ((FILE *));
221 static int process_corefile_contents
PARAMS ((FILE *));
223 typedef int Elf32_Word
;
231 #define SECTION_NAME(X) (string_table + (X)->sh_name)
233 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
235 #define BYTE_GET(field) byte_get (field, sizeof (field))
237 /* If we can support a 64 bit data type then BFD64 should be defined
238 and sizeof (bfd_vma) == 8. In this case when translating from an
239 external 8 byte field to an internal field, we can assume that the
240 internal field is also 8 bytes wide and so we can extact all the data.
241 If, however, BFD64 is not defined, then we must assume that the
242 internal data structure only has 4 byte wide fields that are the
243 equivalent of the 8 byte wide external counterparts, and so we must
244 truncate the data. */
246 #define BYTE_GET8(field) byte_get (field, -8)
248 #define BYTE_GET8(field) byte_get (field, 8)
251 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
253 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
254 if (fseek (file, offset, SEEK_SET)) \
256 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
260 var = (type) malloc (size); \
264 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
268 if (fread (var, size, 1, file) != 1) \
270 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
277 #define GET_DATA(offset, var, reason) \
278 if (fseek (file, offset, SEEK_SET)) \
280 error (_("Unable to seek to %x for %s\n"), offset, reason); \
283 else if (fread (& var, sizeof (var), 1, file) != 1) \
285 error (_("Unable to read data at %x for %s\n"), offset, reason); \
289 #define GET_ELF_SYMBOLS(file, offset, size) \
290 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
291 : get_64bit_elf_symbols (file, offset, size))
294 #ifdef ANSI_PROTOTYPES
296 error (const char * message
, ...)
300 fprintf (stderr
, _("%s: Error: "), program_name
);
301 va_start (args
, message
);
302 vfprintf (stderr
, message
, args
);
308 warn (const char * message
, ...)
312 fprintf (stderr
, _("%s: Warning: "), program_name
);
313 va_start (args
, message
);
314 vfprintf (stderr
, message
, args
);
326 fprintf (stderr
, _("%s: Error: "), program_name
);
328 message
= va_arg (args
, char *);
329 vfprintf (stderr
, message
, args
);
341 fprintf (stderr
, _("%s: Warning: "), program_name
);
343 message
= va_arg (args
, char *);
344 vfprintf (stderr
, message
, args
);
351 byte_get_little_endian (field
, size
)
352 unsigned char * field
;
361 return ((unsigned int) (field
[0]))
362 | (((unsigned int) (field
[1])) << 8);
365 /* We want to extract data from an 8 byte wide field and
366 place it into a 4 byte wide field. Since this is a little
367 endian source we can juts use the 4 byte extraction code. */
370 return ((unsigned long) (field
[0]))
371 | (((unsigned long) (field
[1])) << 8)
372 | (((unsigned long) (field
[2])) << 16)
373 | (((unsigned long) (field
[3])) << 24);
377 /* This is a special case, generated by the BYTE_GET8 macro.
378 It means that we are loading an 8 byte value from a field
379 in an external structure into an 8 byte value in a field
380 in an internal strcuture. */
381 return ((bfd_vma
) (field
[0]))
382 | (((bfd_vma
) (field
[1])) << 8)
383 | (((bfd_vma
) (field
[2])) << 16)
384 | (((bfd_vma
) (field
[3])) << 24)
385 | (((bfd_vma
) (field
[4])) << 32)
386 | (((bfd_vma
) (field
[5])) << 40)
387 | (((bfd_vma
) (field
[6])) << 48)
388 | (((bfd_vma
) (field
[7])) << 56);
391 error (_("Unhandled data length: %d\n"), size
);
396 /* Print a VMA value. */
398 print_vma (vma
, mode
)
408 case FULL_HEX
: printf ("0x"); /* drop through */
409 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
410 case PREFIX_HEX
: printf ("0x"); /* drop through */
411 case HEX
: printf ("%lx", (unsigned long) vma
); break;
412 case DEC
: printf ("%ld", (unsigned long) vma
); break;
413 case DEC_5
: printf ("%5ld", (long) vma
); break;
414 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
435 #if BFD_HOST_64BIT_LONG
438 if (_bfd_int64_high (vma
))
439 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
441 printf ("%lx", _bfd_int64_low (vma
));
446 #if BFD_HOST_64BIT_LONG
449 if (_bfd_int64_high (vma
))
451 printf ("++%ld", _bfd_int64_low (vma
));
453 printf ("%ld", _bfd_int64_low (vma
));
458 #if BFD_HOST_64BIT_LONG
459 printf ("%5ld", vma
);
461 if (_bfd_int64_high (vma
))
463 printf ("++%ld", _bfd_int64_low (vma
));
465 printf ("%5ld", _bfd_int64_low (vma
));
470 #if BFD_HOST_64BIT_LONG
473 if (_bfd_int64_high (vma
))
475 printf ("++%lu", _bfd_int64_low (vma
));
477 printf ("%lu", _bfd_int64_low (vma
));
486 byte_get_big_endian (field
, size
)
487 unsigned char * field
;
496 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
499 return ((unsigned long) (field
[3]))
500 | (((unsigned long) (field
[2])) << 8)
501 | (((unsigned long) (field
[1])) << 16)
502 | (((unsigned long) (field
[0])) << 24);
505 /* Although we are extracing data from an 8 byte wide field, we
506 are returning only 4 bytes of data. */
507 return ((unsigned long) (field
[7]))
508 | (((unsigned long) (field
[6])) << 8)
509 | (((unsigned long) (field
[5])) << 16)
510 | (((unsigned long) (field
[4])) << 24);
514 /* This is a special case, generated by the BYTE_GET8 macro.
515 It means that we are loading an 8 byte value from a field
516 in an external structure into an 8 byte value in a field
517 in an internal strcuture. */
518 return ((bfd_vma
) (field
[7]))
519 | (((bfd_vma
) (field
[6])) << 8)
520 | (((bfd_vma
) (field
[5])) << 16)
521 | (((bfd_vma
) (field
[4])) << 24)
522 | (((bfd_vma
) (field
[3])) << 32)
523 | (((bfd_vma
) (field
[2])) << 40)
524 | (((bfd_vma
) (field
[1])) << 48)
525 | (((bfd_vma
) (field
[0])) << 56);
529 error (_("Unhandled data length: %d\n"), size
);
535 /* Guess the relocation sized based on the sized commonly used by the specific machine. */
537 guess_is_rela (e_machine
)
538 unsigned long e_machine
;
542 /* Targets that use REL relocations. */
553 /* Targets that use RELA relocations. */
561 case EM_CYGNUS_MN10200
:
562 case EM_CYGNUS_MN10300
:
591 warn (_("Don't know about relocations on this machine architecture\n"));
596 /* Display the contents of the relocation data found at the specified offset. */
598 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
600 unsigned long rel_offset
;
601 unsigned long rel_size
;
602 Elf_Internal_Sym
* symtab
;
608 Elf_Internal_Rel
* rels
;
609 Elf_Internal_Rela
* relas
;
612 if (is_rela
== UNKNOWN
)
613 is_rela
= guess_is_rela (elf_header
.e_machine
);
619 Elf32_External_Rela
* erelas
;
621 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
622 Elf32_External_Rela
*, "relocs");
624 rel_size
= rel_size
/ sizeof (Elf32_External_Rela
);
626 relas
= (Elf_Internal_Rela
*)
627 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
631 error(_("out of memory parsing relocs"));
635 for (i
= 0; i
< rel_size
; i
++)
637 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
638 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
639 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
644 rels
= (Elf_Internal_Rel
*) relas
;
648 Elf64_External_Rela
* erelas
;
650 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
651 Elf64_External_Rela
*, "relocs");
653 rel_size
= rel_size
/ sizeof (Elf64_External_Rela
);
655 relas
= (Elf_Internal_Rela
*)
656 malloc (rel_size
* sizeof (Elf_Internal_Rela
));
660 error(_("out of memory parsing relocs"));
664 for (i
= 0; i
< rel_size
; i
++)
666 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
667 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
668 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
673 rels
= (Elf_Internal_Rel
*) relas
;
680 Elf32_External_Rel
* erels
;
682 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
683 Elf32_External_Rel
*, "relocs");
685 rel_size
= rel_size
/ sizeof (Elf32_External_Rel
);
687 rels
= (Elf_Internal_Rel
*)
688 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
692 error(_("out of memory parsing relocs"));
696 for (i
= 0; i
< rel_size
; i
++)
698 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
699 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
704 relas
= (Elf_Internal_Rela
*) rels
;
708 Elf64_External_Rel
* erels
;
710 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
711 Elf64_External_Rel
*, "relocs");
713 rel_size
= rel_size
/ sizeof (Elf64_External_Rel
);
715 rels
= (Elf_Internal_Rel
*)
716 malloc (rel_size
* sizeof (Elf_Internal_Rel
));
720 error(_("out of memory parsing relocs"));
724 for (i
= 0; i
< rel_size
; i
++)
726 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
727 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
732 relas
= (Elf_Internal_Rela
*) rels
;
738 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
741 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
743 for (i
= 0; i
< rel_size
; i
++)
748 bfd_vma symtab_index
;
753 offset
= relas
[i
].r_offset
;
754 info
= relas
[i
].r_info
;
758 offset
= rels
[i
].r_offset
;
759 info
= rels
[i
].r_info
;
764 type
= ELF32_R_TYPE (info
);
765 symtab_index
= ELF32_R_SYM (info
);
769 if (elf_header
.e_machine
== EM_SPARCV9
)
770 type
= ELF64_R_TYPE_ID (info
);
772 type
= ELF64_R_TYPE (info
);
773 /* The #ifdef BFD64 below is to prevent a compile time warning.
774 We know that if we do not have a 64 bit data type that we
775 will never execute this code anyway. */
777 symtab_index
= ELF64_R_SYM (info
);
781 #ifdef _bfd_int64_low
782 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
784 printf (" %8.8lx %5.5lx ", offset
, info
);
787 switch (elf_header
.e_machine
)
794 rtype
= elf_m32r_reloc_type (type
);
799 rtype
= elf_i386_reloc_type (type
);
803 rtype
= elf_m68k_reloc_type (type
);
807 rtype
= elf_i960_reloc_type (type
);
811 rtype
= elf_avr_reloc_type (type
);
818 rtype
= elf_sparc_reloc_type (type
);
822 rtype
= v850_reloc_type (type
);
826 rtype
= elf_d10v_reloc_type (type
);
830 rtype
= elf_d30v_reloc_type (type
);
834 rtype
= elf_sh_reloc_type (type
);
837 case EM_CYGNUS_MN10300
:
838 rtype
= elf_mn10300_reloc_type (type
);
841 case EM_CYGNUS_MN10200
:
842 rtype
= elf_mn10200_reloc_type (type
);
846 rtype
= elf_fr30_reloc_type (type
);
850 rtype
= elf_mcore_reloc_type (type
);
854 rtype
= elf_ppc_reloc_type (type
);
859 rtype
= elf_mips_reloc_type (type
);
863 rtype
= elf_alpha_reloc_type (type
);
867 rtype
= elf_arm_reloc_type (type
);
871 rtype
= elf_arc_reloc_type (type
);
875 rtype
= elf_hppa_reloc_type (type
);
879 rtype
= elf_pj_reloc_type (type
);
882 rtype
= elf_ia64_reloc_type (type
);
886 rtype
= elf_cris_reloc_type (type
);
891 #ifdef _bfd_int64_low
892 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
894 printf (_("unrecognised: %-7lx"), type
);
897 printf ("%-21.21s", rtype
);
903 if (symtab_index
>= nsyms
)
904 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
907 Elf_Internal_Sym
* psym
;
909 psym
= symtab
+ symtab_index
;
912 print_vma (psym
->st_value
, LONG_HEX
);
915 if (psym
->st_name
== 0)
917 SECTION_NAME (section_headers
+ psym
->st_shndx
));
918 else if (strtab
== NULL
)
919 printf (_("<string table index %3ld>"), psym
->st_name
);
921 printf ("%-25.25s", strtab
+ psym
->st_name
);
924 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
930 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
931 print_vma (relas
[i
].r_addend
, LONG_HEX
);
934 if (elf_header
.e_machine
== EM_SPARCV9
935 && !strcmp (rtype
, "R_SPARC_OLO10"))
936 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
947 get_mips_dynamic_type (type
)
952 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
953 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
954 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
955 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
956 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
957 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
958 case DT_MIPS_MSYM
: return "MIPS_MSYM";
959 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
960 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
961 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
962 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
963 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
964 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
965 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
966 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
967 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
968 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
969 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
970 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
971 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
972 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
973 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
974 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
975 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
976 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
977 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
978 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
979 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
980 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
981 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
982 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
983 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
984 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
985 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
986 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
987 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
988 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
989 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
990 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
991 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
992 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
993 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
994 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1001 get_sparc64_dynamic_type (type
)
1006 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1013 get_parisc_dynamic_type (type
)
1018 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1019 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1020 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1021 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1022 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1023 case DT_HP_PREINIT
: return "HP_PREINIT";
1024 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1025 case DT_HP_NEEDED
: return "HP_NEEDED";
1026 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1027 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1028 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1029 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1030 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1037 get_dynamic_type (type
)
1040 static char buff
[32];
1044 case DT_NULL
: return "NULL";
1045 case DT_NEEDED
: return "NEEDED";
1046 case DT_PLTRELSZ
: return "PLTRELSZ";
1047 case DT_PLTGOT
: return "PLTGOT";
1048 case DT_HASH
: return "HASH";
1049 case DT_STRTAB
: return "STRTAB";
1050 case DT_SYMTAB
: return "SYMTAB";
1051 case DT_RELA
: return "RELA";
1052 case DT_RELASZ
: return "RELASZ";
1053 case DT_RELAENT
: return "RELAENT";
1054 case DT_STRSZ
: return "STRSZ";
1055 case DT_SYMENT
: return "SYMENT";
1056 case DT_INIT
: return "INIT";
1057 case DT_FINI
: return "FINI";
1058 case DT_SONAME
: return "SONAME";
1059 case DT_RPATH
: return "RPATH";
1060 case DT_SYMBOLIC
: return "SYMBOLIC";
1061 case DT_REL
: return "REL";
1062 case DT_RELSZ
: return "RELSZ";
1063 case DT_RELENT
: return "RELENT";
1064 case DT_PLTREL
: return "PLTREL";
1065 case DT_DEBUG
: return "DEBUG";
1066 case DT_TEXTREL
: return "TEXTREL";
1067 case DT_JMPREL
: return "JMPREL";
1068 case DT_BIND_NOW
: return "BIND_NOW";
1069 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1070 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1071 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1072 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1073 case DT_RUNPATH
: return "RUNPATH";
1074 case DT_FLAGS
: return "FLAGS";
1076 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1077 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1079 case DT_CHECKSUM
: return "CHECKSUM";
1080 case DT_PLTPADSZ
: return "PLTPADSZ";
1081 case DT_MOVEENT
: return "MOVEENT";
1082 case DT_MOVESZ
: return "MOVESZ";
1083 case DT_FEATURE
: return "FEATURE";
1084 case DT_POSFLAG_1
: return "POSFLAG_1";
1085 case DT_SYMINSZ
: return "SYMINSZ";
1086 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1088 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1089 case DT_CONFIG
: return "CONFIG";
1090 case DT_DEPAUDIT
: return "DEPAUDIT";
1091 case DT_AUDIT
: return "AUDIT";
1092 case DT_PLTPAD
: return "PLTPAD";
1093 case DT_MOVETAB
: return "MOVETAB";
1094 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1096 case DT_VERSYM
: return "VERSYM";
1098 case DT_RELACOUNT
: return "RELACOUNT";
1099 case DT_RELCOUNT
: return "RELCOUNT";
1100 case DT_FLAGS_1
: return "FLAGS_1";
1101 case DT_VERDEF
: return "VERDEF";
1102 case DT_VERDEFNUM
: return "VERDEFNUM";
1103 case DT_VERNEED
: return "VERNEED";
1104 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1106 case DT_AUXILIARY
: return "AUXILIARY";
1107 case DT_USED
: return "USED";
1108 case DT_FILTER
: return "FILTER";
1111 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1113 const char * result
;
1115 switch (elf_header
.e_machine
)
1118 case EM_MIPS_RS4_BE
:
1119 result
= get_mips_dynamic_type (type
);
1122 result
= get_sparc64_dynamic_type (type
);
1132 sprintf (buff
, _("Processor Specific: %lx"), type
);
1134 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1136 const char * result
;
1138 switch (elf_header
.e_machine
)
1141 result
= get_parisc_dynamic_type (type
);
1151 sprintf (buff
, _("Operating System specific: %lx"), type
);
1154 sprintf (buff
, _("<unknown>: %lx"), type
);
1161 get_file_type (e_type
)
1164 static char buff
[32];
1168 case ET_NONE
: return _("NONE (None)");
1169 case ET_REL
: return _("REL (Relocatable file)");
1170 case ET_EXEC
: return _("EXEC (Executable file)");
1171 case ET_DYN
: return _("DYN (Shared object file)");
1172 case ET_CORE
: return _("CORE (Core file)");
1175 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1176 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1177 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1178 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1180 sprintf (buff
, _("<unknown>: %x"), e_type
);
1186 get_machine_name (e_machine
)
1189 static char buff
[64]; /* XXX */
1193 case EM_NONE
: return _("None");
1194 case EM_M32
: return "WE32100";
1195 case EM_SPARC
: return "Sparc";
1196 case EM_386
: return "Intel 80386";
1197 case EM_68K
: return "MC68000";
1198 case EM_88K
: return "MC88000";
1199 case EM_486
: return "Intel 80486";
1200 case EM_860
: return "Intel 80860";
1201 case EM_MIPS
: return "MIPS R3000";
1202 case EM_S370
: return "IBM System/370";
1203 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1204 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1205 case EM_PARISC
: return "HPPA";
1206 case EM_PPC_OLD
: return "Power PC (old)";
1207 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1208 case EM_960
: return "Intel 90860";
1209 case EM_PPC
: return "PowerPC";
1210 case EM_V800
: return "NEC V800";
1211 case EM_FR20
: return "Fujitsu FR20";
1212 case EM_RH32
: return "TRW RH32";
1213 case EM_MCORE
: return "MCORE";
1214 case EM_ARM
: return "ARM";
1215 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1216 case EM_SH
: return "Hitachi SH";
1217 case EM_SPARCV9
: return "Sparc v9";
1218 case EM_TRICORE
: return "Siemens Tricore";
1219 case EM_ARC
: return "Argonaut RISC Core";
1220 case EM_H8_300
: return "Hitachi H8/300";
1221 case EM_H8_300H
: return "Hitachi H8/300H";
1222 case EM_H8S
: return "Hitachi H8S";
1223 case EM_H8_500
: return "Hitachi H8/500";
1224 case EM_IA_64
: return "Intel IA-64";
1225 case EM_MIPS_X
: return "Stanford MIPS-X";
1226 case EM_COLDFIRE
: return "Motorola Coldfire";
1227 case EM_68HC12
: return "Motorola M68HC12";
1228 case EM_ALPHA
: return "Alpha";
1229 case EM_CYGNUS_D10V
: return "d10v";
1230 case EM_CYGNUS_D30V
: return "d30v";
1231 case EM_CYGNUS_ARC
: return "Arc";
1232 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1233 case EM_CYGNUS_V850
: return "NEC v850";
1234 case EM_CYGNUS_MN10300
: return "mn10300";
1235 case EM_CYGNUS_MN10200
: return "mn10200";
1236 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1237 case EM_PJ
: return "picoJava";
1238 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1239 case EM_PCP
: return "Siemens PCP";
1240 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1241 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1242 case EM_STARCORE
: return "Motorola Star*Core processor";
1243 case EM_ME16
: return "Toyota ME16 processor";
1244 case EM_ST100
: return "STMicroelectronics ST100 processor";
1245 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1246 case EM_FX66
: return "Siemens FX66 microcontroller";
1247 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1248 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1249 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1250 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1251 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1252 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1253 case EM_SVX
: return "Silicon Graphics SVx";
1254 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1255 case EM_VAX
: return "Digital VAX";
1256 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1257 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1259 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1265 decode_ARM_machine_flags (e_flags
, buf
)
1272 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1273 e_flags
&= ~ EF_ARM_EABIMASK
;
1275 /* Handle "generic" ARM flags. */
1276 if (e_flags
& EF_ARM_RELEXEC
)
1278 strcat (buf
, ", relocatable executable");
1279 e_flags
&= ~ EF_ARM_RELEXEC
;
1282 if (e_flags
& EF_ARM_HASENTRY
)
1284 strcat (buf
, ", has entry point");
1285 e_flags
&= ~ EF_ARM_HASENTRY
;
1288 /* Now handle EABI specific flags. */
1292 strcat (buf
, ", <unknown EABI>");
1297 case EF_ARM_EABI_VER1
:
1302 /* Process flags one bit at a time. */
1303 flag
= e_flags
& - e_flags
;
1308 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_INTERWORK. */
1309 strcat (buf
, ", sorted symbol tables");
1319 case EF_ARM_EABI_UNKNOWN
:
1324 /* Process flags one bit at a time. */
1325 flag
= e_flags
& - e_flags
;
1331 strcat (buf
, ", interworking enabled");
1335 strcat (buf
, ", uses APCS/26");
1339 strcat (buf
, ", uses APCS/float");
1343 strcat (buf
, ", position independent");
1347 strcat (buf
, ", 8 bit structure alignment");
1351 strcat (buf
, ", uses new ABI");
1355 strcat (buf
, ", uses old ABI");
1359 strcat (buf
, ", software FP");
1370 strcat (buf
,", <unknown>");
1374 get_machine_flags (e_flags
, e_machine
)
1378 static char buf
[1024];
1390 decode_ARM_machine_flags (e_flags
, buf
);
1394 if (e_flags
& EF_CPU32
)
1395 strcat (buf
, ", cpu32");
1399 if (e_flags
& EF_PPC_EMB
)
1400 strcat (buf
, ", emb");
1402 if (e_flags
& EF_PPC_RELOCATABLE
)
1403 strcat (buf
, ", relocatable");
1405 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1406 strcat (buf
, ", relocatable-lib");
1409 case EM_CYGNUS_V850
:
1410 switch (e_flags
& EF_V850_ARCH
)
1413 strcat (buf
, ", v850e");
1416 strcat (buf
, ", v850ea");
1419 strcat (buf
, ", v850");
1422 strcat (buf
, ", unknown v850 architecture variant");
1427 case EM_CYGNUS_M32R
:
1428 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1429 strcat (buf
, ", m32r");
1434 case EM_MIPS_RS4_BE
:
1435 if (e_flags
& EF_MIPS_NOREORDER
)
1436 strcat (buf
, ", noreorder");
1438 if (e_flags
& EF_MIPS_PIC
)
1439 strcat (buf
, ", pic");
1441 if (e_flags
& EF_MIPS_CPIC
)
1442 strcat (buf
, ", cpic");
1444 if (e_flags
& EF_MIPS_ABI2
)
1445 strcat (buf
, ", abi2");
1447 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1448 strcat (buf
, ", mips1");
1450 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1451 strcat (buf
, ", mips2");
1453 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1454 strcat (buf
, ", mips3");
1456 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1457 strcat (buf
, ", mips4");
1461 if (e_flags
& EF_SPARC_32PLUS
)
1462 strcat (buf
, ", v8+");
1464 if (e_flags
& EF_SPARC_SUN_US1
)
1465 strcat (buf
, ", ultrasparcI");
1467 if (e_flags
& EF_SPARC_SUN_US3
)
1468 strcat (buf
, ", ultrasparcIII");
1470 if (e_flags
& EF_SPARC_HAL_R1
)
1471 strcat (buf
, ", halr1");
1473 if (e_flags
& EF_SPARC_LEDATA
)
1474 strcat (buf
, ", ledata");
1476 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1477 strcat (buf
, ", tso");
1479 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1480 strcat (buf
, ", pso");
1482 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1483 strcat (buf
, ", rmo");
1487 switch (e_flags
& EF_PARISC_ARCH
)
1489 case EFA_PARISC_1_0
:
1490 strcpy (buf
, ", PA-RISC 1.0");
1492 case EFA_PARISC_1_1
:
1493 strcpy (buf
, ", PA-RISC 1.1");
1495 case EFA_PARISC_2_0
:
1496 strcpy (buf
, ", PA-RISC 2.0");
1501 if (e_flags
& EF_PARISC_TRAPNIL
)
1502 strcat (buf
, ", trapnil");
1503 if (e_flags
& EF_PARISC_EXT
)
1504 strcat (buf
, ", ext");
1505 if (e_flags
& EF_PARISC_LSB
)
1506 strcat (buf
, ", lsb");
1507 if (e_flags
& EF_PARISC_WIDE
)
1508 strcat (buf
, ", wide");
1509 if (e_flags
& EF_PARISC_NO_KABP
)
1510 strcat (buf
, ", no kabp");
1511 if (e_flags
& EF_PARISC_LAZYSWAP
)
1512 strcat (buf
, ", lazyswap");
1516 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1517 strcat (buf
, ", new calling convention");
1519 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1520 strcat (buf
, ", gnu calling convention");
1529 get_mips_segment_type (type
)
1534 case PT_MIPS_REGINFO
:
1536 case PT_MIPS_RTPROC
:
1538 case PT_MIPS_OPTIONS
:
1548 get_parisc_segment_type (type
)
1553 case PT_HP_TLS
: return "HP_TLS";
1554 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1555 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1556 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1557 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1558 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1559 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1560 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1561 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1562 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1563 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1564 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1565 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1566 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1575 get_segment_type (p_type
)
1576 unsigned long p_type
;
1578 static char buff
[32];
1582 case PT_NULL
: return "NULL";
1583 case PT_LOAD
: return "LOAD";
1584 case PT_DYNAMIC
: return "DYNAMIC";
1585 case PT_INTERP
: return "INTERP";
1586 case PT_NOTE
: return "NOTE";
1587 case PT_SHLIB
: return "SHLIB";
1588 case PT_PHDR
: return "PHDR";
1591 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1593 const char * result
;
1595 switch (elf_header
.e_machine
)
1598 case EM_MIPS_RS4_BE
:
1599 result
= get_mips_segment_type (p_type
);
1602 result
= get_parisc_segment_type (p_type
);
1612 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1614 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1616 const char * result
;
1618 switch (elf_header
.e_machine
)
1621 result
= get_parisc_segment_type (p_type
);
1631 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1634 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1641 get_mips_section_type_name (sh_type
)
1642 unsigned int sh_type
;
1646 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1647 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1648 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1649 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1650 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1651 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1652 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1653 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1654 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1655 case SHT_MIPS_RELD
: return "MIPS_RELD";
1656 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1657 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1658 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1659 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1660 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1661 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1662 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1663 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1664 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1665 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1666 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1667 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1668 case SHT_MIPS_LINE
: return "MIPS_LINE";
1669 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1670 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1671 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1672 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1673 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1674 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1675 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1676 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1677 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1678 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1679 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1680 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1681 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1682 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1683 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1684 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1692 get_parisc_section_type_name (sh_type
)
1693 unsigned int sh_type
;
1697 case SHT_PARISC_EXT
: return "PARISC_EXT";
1698 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1699 case SHT_PARISC_DOC
: return "PARISC_DOC";
1707 get_section_type_name (sh_type
)
1708 unsigned int sh_type
;
1710 static char buff
[32];
1714 case SHT_NULL
: return "NULL";
1715 case SHT_PROGBITS
: return "PROGBITS";
1716 case SHT_SYMTAB
: return "SYMTAB";
1717 case SHT_STRTAB
: return "STRTAB";
1718 case SHT_RELA
: return "RELA";
1719 case SHT_HASH
: return "HASH";
1720 case SHT_DYNAMIC
: return "DYNAMIC";
1721 case SHT_NOTE
: return "NOTE";
1722 case SHT_NOBITS
: return "NOBITS";
1723 case SHT_REL
: return "REL";
1724 case SHT_SHLIB
: return "SHLIB";
1725 case SHT_DYNSYM
: return "DYNSYM";
1726 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1727 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1728 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1729 case SHT_GNU_verdef
: return "VERDEF";
1730 case SHT_GNU_verneed
: return "VERNEED";
1731 case SHT_GNU_versym
: return "VERSYM";
1732 case 0x6ffffff0: return "VERSYM";
1733 case 0x6ffffffc: return "VERDEF";
1734 case 0x7ffffffd: return "AUXILIARY";
1735 case 0x7fffffff: return "FILTER";
1738 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1740 const char * result
;
1742 switch (elf_header
.e_machine
)
1745 case EM_MIPS_RS4_BE
:
1746 result
= get_mips_section_type_name (sh_type
);
1749 result
= get_parisc_section_type_name (sh_type
);
1759 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1761 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1762 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1763 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1764 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1766 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1772 struct option options
[] =
1774 {"all", no_argument
, 0, 'a'},
1775 {"file-header", no_argument
, 0, 'h'},
1776 {"program-headers", no_argument
, 0, 'l'},
1777 {"headers", no_argument
, 0, 'e'},
1778 {"histogram", no_argument
, 0, 'I'},
1779 {"segments", no_argument
, 0, 'l'},
1780 {"sections", no_argument
, 0, 'S'},
1781 {"section-headers", no_argument
, 0, 'S'},
1782 {"symbols", no_argument
, 0, 's'},
1783 {"syms", no_argument
, 0, 's'},
1784 {"relocs", no_argument
, 0, 'r'},
1785 {"notes", no_argument
, 0, 'n'},
1786 {"dynamic", no_argument
, 0, 'd'},
1787 {"arch-specific", no_argument
, 0, 'A'},
1788 {"version-info", no_argument
, 0, 'V'},
1789 {"use-dynamic", no_argument
, 0, 'D'},
1790 {"hex-dump", required_argument
, 0, 'x'},
1791 {"debug-dump", optional_argument
, 0, 'w'},
1792 #ifdef SUPPORT_DISASSEMBLY
1793 {"instruction-dump", required_argument
, 0, 'i'},
1796 {"version", no_argument
, 0, 'v'},
1797 {"help", no_argument
, 0, 'H'},
1798 {0, no_argument
, 0, 0}
1804 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1805 fprintf (stdout
, _(" Options are:\n"));
1806 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1807 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1808 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1809 fprintf (stdout
, _(" Display the program headers\n"));
1810 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1811 fprintf (stdout
, _(" Display the sections' header\n"));
1812 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1813 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1814 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1815 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1816 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1817 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1818 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
1819 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
1820 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
1821 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
1822 fprintf (stdout
, _(" -w[liapr] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges]\n"));
1823 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
1824 #ifdef SUPPORT_DISASSEMBLY
1825 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
1826 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
1828 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
1829 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
1830 fprintf (stdout
, _(" -H or --help Display this information\n"));
1831 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
1837 request_dump (section
, type
)
1838 unsigned int section
;
1841 if (section
>= num_dump_sects
)
1843 char * new_dump_sects
;
1845 new_dump_sects
= (char *) calloc (section
+ 1, 1);
1847 if (new_dump_sects
== NULL
)
1848 error (_("Out of memory allocating dump request table."));
1851 /* Copy current flag settings. */
1852 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
1856 dump_sects
= new_dump_sects
;
1857 num_dump_sects
= section
+ 1;
1862 dump_sects
[section
] |= type
;
1868 parse_args (argc
, argv
)
1877 while ((c
= getopt_long
1878 (argc
, argv
, "ersahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
1913 do_using_dynamic
++;
1941 section
= strtoul (optarg
, & cp
, 0);
1942 if (! * cp
&& section
>= 0)
1944 request_dump (section
, HEX_DUMP
);
1964 do_debug_abbrevs
= 1;
1974 do_debug_pubnames
= 1;
1979 do_debug_aranges
= 1;
1983 warn (_("Unrecognised debug option '%s'\n"), optarg
);
1988 #ifdef SUPPORT_DISASSEMBLY
1991 section
= strtoul (optarg
, & cp
, 0);
1992 if (! * cp
&& section
>= 0)
1994 request_dump (section
, DISASS_DUMP
);
2000 print_version (program_name
);
2007 /* xgettext:c-format */
2008 error (_("Invalid option '-%c'\n"), c
);
2015 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_sections
2016 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2017 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2021 warn (_("Nothing to do.\n"));
2027 get_elf_class (elf_class
)
2028 unsigned char elf_class
;
2030 static char buff
[32];
2034 case ELFCLASSNONE
: return _("none");
2035 case ELFCLASS32
: return _("ELF32");
2036 case ELFCLASS64
: return _("ELF64");
2038 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2044 get_data_encoding (encoding
)
2045 unsigned char encoding
;
2047 static char buff
[32];
2051 case ELFDATANONE
: return _("none");
2052 case ELFDATA2LSB
: return _("2's complement, little endian");
2053 case ELFDATA2MSB
: return _("2's complement, big endian");
2055 sprintf (buff
, _("<unknown: %x>"), encoding
);
2061 get_osabi_name (osabi
)
2062 unsigned char osabi
;
2064 static char buff
[32];
2068 case ELFOSABI_NONE
: return _("UNIX - System V");
2069 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2070 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2071 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2072 case ELFOSABI_HURD
: return _("GNU/Hurd");
2073 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2074 case ELFOSABI_MONTEREY
: return _("UNIX - Monterey");
2075 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2076 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2077 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2078 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2079 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2080 case ELFOSABI_STANDALONE
: return _("Standalone App");
2081 case ELFOSABI_ARM
: return _("ARM");
2083 sprintf (buff
, _("<unknown: %x>"), osabi
);
2088 /* Decode the data held in 'elf_header'. */
2090 process_file_header ()
2092 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2093 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2094 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2095 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2098 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2106 printf (_("ELF Header:\n"));
2107 printf (_(" Magic: "));
2108 for (i
= 0; i
< EI_NIDENT
; i
++)
2109 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2111 printf (_(" Class: %s\n"),
2112 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2113 printf (_(" Data: %s\n"),
2114 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2115 printf (_(" Version: %d %s\n"),
2116 elf_header
.e_ident
[EI_VERSION
],
2117 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2119 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2122 printf (_(" OS/ABI: %s\n"),
2123 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2124 printf (_(" ABI Version: %d\n"),
2125 elf_header
.e_ident
[EI_ABIVERSION
]);
2126 printf (_(" Type: %s\n"),
2127 get_file_type (elf_header
.e_type
));
2128 printf (_(" Machine: %s\n"),
2129 get_machine_name (elf_header
.e_machine
));
2130 printf (_(" Version: 0x%lx\n"),
2131 (unsigned long) elf_header
.e_version
);
2133 printf (_(" Entry point address: "));
2134 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2135 printf (_("\n Start of program headers: "));
2136 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2137 printf (_(" (bytes into file)\n Start of section headers: "));
2138 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2139 printf (_(" (bytes into file)\n"));
2141 printf (_(" Flags: 0x%lx%s\n"),
2142 (unsigned long) elf_header
.e_flags
,
2143 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2144 printf (_(" Size of this header: %ld (bytes)\n"),
2145 (long) elf_header
.e_ehsize
);
2146 printf (_(" Size of program headers: %ld (bytes)\n"),
2147 (long) elf_header
.e_phentsize
);
2148 printf (_(" Number of program headers: %ld\n"),
2149 (long) elf_header
.e_phnum
);
2150 printf (_(" Size of section headers: %ld (bytes)\n"),
2151 (long) elf_header
.e_shentsize
);
2152 printf (_(" Number of section headers: %ld\n"),
2153 (long) elf_header
.e_shnum
);
2154 printf (_(" Section header string table index: %ld\n"),
2155 (long) elf_header
.e_shstrndx
);
2163 get_32bit_program_headers (file
, program_headers
)
2165 Elf_Internal_Phdr
* program_headers
;
2167 Elf32_External_Phdr
* phdrs
;
2168 Elf32_External_Phdr
* external
;
2169 Elf32_Internal_Phdr
* internal
;
2172 GET_DATA_ALLOC (elf_header
.e_phoff
,
2173 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2174 phdrs
, Elf32_External_Phdr
*, "program headers");
2176 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2177 i
< elf_header
.e_phnum
;
2178 i
++, internal
++, external
++)
2180 internal
->p_type
= BYTE_GET (external
->p_type
);
2181 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2182 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2183 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2184 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2185 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2186 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2187 internal
->p_align
= BYTE_GET (external
->p_align
);
2196 get_64bit_program_headers (file
, program_headers
)
2198 Elf_Internal_Phdr
* program_headers
;
2200 Elf64_External_Phdr
* phdrs
;
2201 Elf64_External_Phdr
* external
;
2202 Elf64_Internal_Phdr
* internal
;
2205 GET_DATA_ALLOC (elf_header
.e_phoff
,
2206 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2207 phdrs
, Elf64_External_Phdr
*, "program headers");
2209 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2210 i
< elf_header
.e_phnum
;
2211 i
++, internal
++, external
++)
2213 internal
->p_type
= BYTE_GET (external
->p_type
);
2214 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2215 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2216 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2217 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2218 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2219 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2220 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2229 process_program_headers (file
)
2232 Elf_Internal_Phdr
* program_headers
;
2233 Elf_Internal_Phdr
* segment
;
2236 if (elf_header
.e_phnum
== 0)
2239 printf (_("\nThere are no program headers in this file.\n"));
2243 if (do_segments
&& !do_header
)
2245 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2246 printf (_("Entry point "));
2247 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2248 printf (_("\nThere are %d program headers, starting at offset "),
2249 elf_header
.e_phnum
);
2250 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2254 program_headers
= (Elf_Internal_Phdr
*) malloc
2255 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2257 if (program_headers
== NULL
)
2259 error (_("Out of memory\n"));
2264 i
= get_32bit_program_headers (file
, program_headers
);
2266 i
= get_64bit_program_headers (file
, program_headers
);
2270 free (program_headers
);
2277 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2281 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2285 (_(" Type Offset VirtAddr PhysAddr\n"));
2287 (_(" FileSiz MemSiz Flags Align\n"));
2295 for (i
= 0, segment
= program_headers
;
2296 i
< elf_header
.e_phnum
;
2301 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2305 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2306 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2307 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2308 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2309 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2311 (segment
->p_flags
& PF_R
? 'R' : ' '),
2312 (segment
->p_flags
& PF_W
? 'W' : ' '),
2313 (segment
->p_flags
& PF_X
? 'E' : ' '));
2314 printf ("%#lx", (unsigned long) segment
->p_align
);
2318 print_vma (segment
->p_offset
, FULL_HEX
);
2320 print_vma (segment
->p_vaddr
, FULL_HEX
);
2322 print_vma (segment
->p_paddr
, FULL_HEX
);
2324 print_vma (segment
->p_filesz
, FULL_HEX
);
2326 print_vma (segment
->p_memsz
, FULL_HEX
);
2328 (segment
->p_flags
& PF_R
? 'R' : ' '),
2329 (segment
->p_flags
& PF_W
? 'W' : ' '),
2330 (segment
->p_flags
& PF_X
? 'E' : ' '));
2331 print_vma (segment
->p_align
, HEX
);
2335 switch (segment
->p_type
)
2339 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2340 - (segment
->p_offset
& 0xfffff000);
2345 error (_("more than one dynamic segment\n"));
2347 dynamic_addr
= segment
->p_offset
;
2348 dynamic_size
= segment
->p_filesz
;
2352 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2353 error (_("Unable to find program interpreter name\n"));
2356 program_interpreter
[0] = 0;
2357 fscanf (file
, "%63s", program_interpreter
);
2360 printf (_("\n [Requesting program interpreter: %s]"),
2361 program_interpreter
);
2367 putc ('\n', stdout
);
2376 if (do_segments
&& section_headers
!= NULL
)
2378 printf (_("\n Section to Segment mapping:\n"));
2379 printf (_(" Segment Sections...\n"));
2381 assert (string_table
!= NULL
);
2383 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2386 Elf_Internal_Shdr
* section
;
2388 segment
= program_headers
+ i
;
2389 section
= section_headers
;
2391 printf (" %2.2d ", i
);
2393 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2395 if (section
->sh_size
> 0
2396 /* Compare allocated sections by VMA, unallocated
2397 sections by file offset. */
2398 && (section
->sh_flags
& SHF_ALLOC
2399 ? (section
->sh_addr
>= segment
->p_vaddr
2400 && section
->sh_addr
+ section
->sh_size
2401 <= segment
->p_vaddr
+ segment
->p_memsz
)
2402 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2403 && (section
->sh_offset
+ section
->sh_size
2404 <= segment
->p_offset
+ segment
->p_filesz
))))
2405 printf ("%s ", SECTION_NAME (section
));
2412 free (program_headers
);
2419 get_32bit_section_headers (file
)
2422 Elf32_External_Shdr
* shdrs
;
2423 Elf32_Internal_Shdr
* internal
;
2426 GET_DATA_ALLOC (elf_header
.e_shoff
,
2427 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2428 shdrs
, Elf32_External_Shdr
*, "section headers");
2430 section_headers
= (Elf_Internal_Shdr
*) malloc
2431 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2433 if (section_headers
== NULL
)
2435 error (_("Out of memory\n"));
2439 for (i
= 0, internal
= section_headers
;
2440 i
< elf_header
.e_shnum
;
2443 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2444 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2445 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2446 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2447 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2448 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2449 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2450 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2451 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2452 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2461 get_64bit_section_headers (file
)
2464 Elf64_External_Shdr
* shdrs
;
2465 Elf64_Internal_Shdr
* internal
;
2468 GET_DATA_ALLOC (elf_header
.e_shoff
,
2469 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2470 shdrs
, Elf64_External_Shdr
*, "section headers");
2472 section_headers
= (Elf_Internal_Shdr
*) malloc
2473 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2475 if (section_headers
== NULL
)
2477 error (_("Out of memory\n"));
2481 for (i
= 0, internal
= section_headers
;
2482 i
< elf_header
.e_shnum
;
2485 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2486 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2487 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2488 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2489 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2490 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2491 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2492 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2493 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2494 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2502 static Elf_Internal_Sym
*
2503 get_32bit_elf_symbols (file
, offset
, number
)
2505 unsigned long offset
;
2506 unsigned long number
;
2508 Elf32_External_Sym
* esyms
;
2509 Elf_Internal_Sym
* isyms
;
2510 Elf_Internal_Sym
* psym
;
2513 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2514 esyms
, Elf32_External_Sym
*, "symbols");
2516 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2520 error (_("Out of memory\n"));
2526 for (j
= 0, psym
= isyms
;
2530 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2531 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2532 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2533 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2534 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2535 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2543 static Elf_Internal_Sym
*
2544 get_64bit_elf_symbols (file
, offset
, number
)
2546 unsigned long offset
;
2547 unsigned long number
;
2549 Elf64_External_Sym
* esyms
;
2550 Elf_Internal_Sym
* isyms
;
2551 Elf_Internal_Sym
* psym
;
2554 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2555 esyms
, Elf64_External_Sym
*, "symbols");
2557 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2561 error (_("Out of memory\n"));
2567 for (j
= 0, psym
= isyms
;
2571 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2572 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2573 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2574 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2575 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2576 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2585 get_elf_section_flags (sh_flags
)
2588 static char buff
[32];
2596 flag
= sh_flags
& - sh_flags
;
2601 case SHF_WRITE
: strcat (buff
, "W"); break;
2602 case SHF_ALLOC
: strcat (buff
, "A"); break;
2603 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2604 case SHF_MERGE
: strcat (buff
, "M"); break;
2605 case SHF_STRINGS
: strcat (buff
, "S"); break;
2606 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2607 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2608 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2611 if (flag
& SHF_MASKOS
)
2614 sh_flags
&= ~ SHF_MASKOS
;
2616 else if (flag
& SHF_MASKPROC
)
2619 sh_flags
&= ~ SHF_MASKPROC
;
2631 process_section_headers (file
)
2634 Elf_Internal_Shdr
* section
;
2637 section_headers
= NULL
;
2639 if (elf_header
.e_shnum
== 0)
2642 printf (_("\nThere are no sections in this file.\n"));
2647 if (do_sections
&& !do_header
)
2648 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2649 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2653 if (! get_32bit_section_headers (file
))
2656 else if (! get_64bit_section_headers (file
))
2659 /* Read in the string table, so that we have names to display. */
2660 section
= section_headers
+ elf_header
.e_shstrndx
;
2662 if (section
->sh_size
!= 0)
2664 unsigned long string_table_offset
;
2666 string_table_offset
= section
->sh_offset
;
2668 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2669 string_table
, char *, "string table");
2672 /* Scan the sections for the dynamic symbol table
2673 and dynamic string table and debug sections. */
2674 dynamic_symbols
= NULL
;
2675 dynamic_strings
= NULL
;
2676 dynamic_syminfo
= NULL
;
2678 for (i
= 0, section
= section_headers
;
2679 i
< elf_header
.e_shnum
;
2682 char * name
= SECTION_NAME (section
);
2684 if (section
->sh_type
== SHT_DYNSYM
)
2686 if (dynamic_symbols
!= NULL
)
2688 error (_("File contains multiple dynamic symbol tables\n"));
2692 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2694 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2696 else if (section
->sh_type
== SHT_STRTAB
2697 && strcmp (name
, ".dynstr") == 0)
2699 if (dynamic_strings
!= NULL
)
2701 error (_("File contains multiple dynamic string tables\n"));
2705 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2706 dynamic_strings
, char *, "dynamic strings");
2708 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2709 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
)
2710 && strncmp (name
, ".debug_", 7) == 0)
2715 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2716 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2717 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2718 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2719 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2721 request_dump (i
, DEBUG_DUMP
);
2728 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2732 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2735 printf (_(" [Nr] Name Type Address Offset\n"));
2736 printf (_(" Size EntSize Flags Link Info Align\n"));
2739 for (i
= 0, section
= section_headers
;
2740 i
< elf_header
.e_shnum
;
2743 printf (" [%2d] %-17.17s %-15.15s ",
2745 SECTION_NAME (section
),
2746 get_section_type_name (section
->sh_type
));
2750 print_vma (section
->sh_addr
, LONG_HEX
);
2752 printf ( " %6.6lx %6.6lx %2.2lx",
2753 (unsigned long) section
->sh_offset
,
2754 (unsigned long) section
->sh_size
,
2755 (unsigned long) section
->sh_entsize
);
2757 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2759 printf (" %2ld %3lx %ld\n",
2760 (unsigned long) section
->sh_link
,
2761 (unsigned long) section
->sh_info
,
2762 (unsigned long) section
->sh_addralign
);
2767 print_vma (section
->sh_addr
, LONG_HEX
);
2768 printf (" %8.8lx", section
->sh_offset
);
2770 print_vma (section
->sh_size
, LONG_HEX
);
2772 print_vma (section
->sh_entsize
, LONG_HEX
);
2774 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2776 printf (" %2ld %3lx %ld\n",
2777 (unsigned long) section
->sh_link
,
2778 (unsigned long) section
->sh_info
,
2779 (unsigned long) section
->sh_addralign
);
2783 printf (_("Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2784 printf (_(" I (info), L (link order), O (extra OS processing required)\n"));
2785 printf (_(" o (os specific), p (processor specific) x (unknown)\n"));
2790 /* Process the reloc section. */
2792 process_relocs (file
)
2795 unsigned long rel_size
;
2796 unsigned long rel_offset
;
2802 if (do_using_dynamic
)
2804 int is_rela
= FALSE
;
2809 if (dynamic_info
[DT_REL
])
2811 rel_offset
= dynamic_info
[DT_REL
];
2812 rel_size
= dynamic_info
[DT_RELSZ
];
2815 else if (dynamic_info
[DT_RELA
])
2817 rel_offset
= dynamic_info
[DT_RELA
];
2818 rel_size
= dynamic_info
[DT_RELASZ
];
2821 else if (dynamic_info
[DT_JMPREL
])
2823 rel_offset
= dynamic_info
[DT_JMPREL
];
2824 rel_size
= dynamic_info
[DT_PLTRELSZ
];
2826 switch (dynamic_info
[DT_PLTREL
])
2843 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
2844 rel_offset
, rel_size
);
2846 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
2847 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
2850 printf (_("\nThere are no dynamic relocations in this file.\n"));
2854 Elf32_Internal_Shdr
* section
;
2858 for (i
= 0, section
= section_headers
;
2859 i
< elf_header
.e_shnum
;
2862 if ( section
->sh_type
!= SHT_RELA
2863 && section
->sh_type
!= SHT_REL
)
2866 rel_offset
= section
->sh_offset
;
2867 rel_size
= section
->sh_size
;
2871 Elf32_Internal_Shdr
* strsec
;
2872 Elf32_Internal_Shdr
* symsec
;
2873 Elf_Internal_Sym
* symtab
;
2876 unsigned long nsyms
;
2878 printf (_("\nRelocation section "));
2880 if (string_table
== NULL
)
2881 printf ("%d", section
->sh_name
);
2883 printf ("'%s'", SECTION_NAME (section
));
2885 printf (_(" at offset 0x%lx contains %lu entries:\n"),
2886 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
2888 symsec
= section_headers
+ section
->sh_link
;
2890 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
2891 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
2896 strsec
= section_headers
+ symsec
->sh_link
;
2898 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
2899 char *, "string table");
2901 is_rela
= section
->sh_type
== SHT_RELA
;
2903 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
2913 printf (_("\nThere are no relocations in this file.\n"));
2921 dynamic_segment_mips_val (entry
)
2922 Elf_Internal_Dyn
* entry
;
2924 switch (entry
->d_tag
)
2927 if (entry
->d_un
.d_val
== 0)
2931 static const char * opts
[] =
2933 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
2934 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
2935 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
2936 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
2941 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
2942 if (entry
->d_un
.d_val
& (1 << cnt
))
2944 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
2951 case DT_MIPS_IVERSION
:
2952 if (dynamic_strings
!= NULL
)
2953 printf ("Interface Version: %s\n",
2954 dynamic_strings
+ entry
->d_un
.d_val
);
2956 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2959 case DT_MIPS_TIME_STAMP
:
2964 time_t time
= entry
->d_un
.d_val
;
2965 tmp
= gmtime (&time
);
2966 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
2967 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
2968 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
2969 printf ("Time Stamp: %s\n", timebuf
);
2973 case DT_MIPS_RLD_VERSION
:
2974 case DT_MIPS_LOCAL_GOTNO
:
2975 case DT_MIPS_CONFLICTNO
:
2976 case DT_MIPS_LIBLISTNO
:
2977 case DT_MIPS_SYMTABNO
:
2978 case DT_MIPS_UNREFEXTNO
:
2979 case DT_MIPS_HIPAGENO
:
2980 case DT_MIPS_DELTA_CLASS_NO
:
2981 case DT_MIPS_DELTA_INSTANCE_NO
:
2982 case DT_MIPS_DELTA_RELOC_NO
:
2983 case DT_MIPS_DELTA_SYM_NO
:
2984 case DT_MIPS_DELTA_CLASSSYM_NO
:
2985 case DT_MIPS_COMPACT_SIZE
:
2986 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
2990 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
2996 dynamic_segment_parisc_val (entry
)
2997 Elf_Internal_Dyn
* entry
;
2999 switch (entry
->d_tag
)
3001 case DT_HP_DLD_FLAGS
:
3010 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3011 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3012 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3013 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3014 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3015 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3016 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3017 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3018 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3019 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3020 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3024 bfd_vma val
= entry
->d_un
.d_val
;
3026 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3027 if (val
& flags
[cnt
].bit
)
3031 fputs (flags
[cnt
].str
, stdout
);
3033 val
^= flags
[cnt
].bit
;
3036 if (val
!= 0 || first
)
3040 print_vma (val
, HEX
);
3046 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3052 get_32bit_dynamic_segment (file
)
3055 Elf32_External_Dyn
* edyn
;
3056 Elf_Internal_Dyn
* entry
;
3059 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3060 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3062 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3063 how large this .dynamic is now. We can do this even before the byte
3064 swapping since the DT_NULL tag is recognizable. */
3066 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3069 dynamic_segment
= (Elf_Internal_Dyn
*)
3070 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3072 if (dynamic_segment
== NULL
)
3074 error (_("Out of memory\n"));
3079 for (i
= 0, entry
= dynamic_segment
;
3083 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3084 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3093 get_64bit_dynamic_segment (file
)
3096 Elf64_External_Dyn
* edyn
;
3097 Elf_Internal_Dyn
* entry
;
3100 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3101 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3103 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3104 how large this .dynamic is now. We can do this even before the byte
3105 swapping since the DT_NULL tag is recognizable. */
3107 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3110 dynamic_segment
= (Elf_Internal_Dyn
*)
3111 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3113 if (dynamic_segment
== NULL
)
3115 error (_("Out of memory\n"));
3120 for (i
= 0, entry
= dynamic_segment
;
3124 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3125 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3134 get_dynamic_flags (flags
)
3137 static char buff
[64];
3142 flag
= flags
& - flags
;
3147 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3148 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3149 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3150 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3151 default: strcat (buff
, "unknown "); break;
3157 /* Parse and display the contents of the dynamic segment. */
3159 process_dynamic_segment (file
)
3162 Elf_Internal_Dyn
* entry
;
3165 if (dynamic_size
== 0)
3168 printf (_("\nThere is no dynamic segment in this file.\n"));
3175 if (! get_32bit_dynamic_segment (file
))
3178 else if (! get_64bit_dynamic_segment (file
))
3181 /* Find the appropriate symbol table. */
3182 if (dynamic_symbols
== NULL
)
3184 for (i
= 0, entry
= dynamic_segment
;
3188 unsigned long offset
;
3190 if (entry
->d_tag
!= DT_SYMTAB
)
3193 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3195 /* Since we do not know how big the symbol table is,
3196 we default to reading in the entire file (!) and
3197 processing that. This is overkill, I know, but it
3199 offset
= entry
->d_un
.d_val
- loadaddr
;
3201 if (fseek (file
, 0, SEEK_END
))
3202 error (_("Unable to seek to end of file!"));
3205 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3207 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3209 if (num_dynamic_syms
< 1)
3211 error (_("Unable to determine the number of symbols to load\n"));
3215 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3219 /* Similarly find a string table. */
3220 if (dynamic_strings
== NULL
)
3222 for (i
= 0, entry
= dynamic_segment
;
3226 unsigned long offset
;
3229 if (entry
->d_tag
!= DT_STRTAB
)
3232 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3234 /* Since we do not know how big the string table is,
3235 we default to reading in the entire file (!) and
3236 processing that. This is overkill, I know, but it
3239 offset
= entry
->d_un
.d_val
- loadaddr
;
3240 if (fseek (file
, 0, SEEK_END
))
3241 error (_("Unable to seek to end of file\n"));
3242 str_tab_len
= ftell (file
) - offset
;
3244 if (str_tab_len
< 1)
3247 (_("Unable to determine the length of the dynamic string table\n"));
3251 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3252 "dynamic string table");
3258 /* And find the syminfo section if available. */
3259 if (dynamic_syminfo
== NULL
)
3261 unsigned int syminsz
= 0;
3263 for (i
= 0, entry
= dynamic_segment
;
3267 if (entry
->d_tag
== DT_SYMINENT
)
3269 /* Note: these braces are necessary to avoid a syntax
3270 error from the SunOS4 C compiler. */
3271 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3273 else if (entry
->d_tag
== DT_SYMINSZ
)
3274 syminsz
= entry
->d_un
.d_val
;
3275 else if (entry
->d_tag
== DT_SYMINFO
)
3276 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3279 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3281 Elf_External_Syminfo
* extsyminfo
;
3282 Elf_Internal_Syminfo
* syminfo
;
3284 /* There is a syminfo section. Read the data. */
3285 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3286 Elf_External_Syminfo
*, "symbol information");
3288 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3289 if (dynamic_syminfo
== NULL
)
3291 error (_("Out of memory\n"));
3295 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3296 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3299 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3300 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3307 if (do_dynamic
&& dynamic_addr
)
3308 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3309 dynamic_addr
, (long) dynamic_size
);
3311 printf (_(" Tag Type Name/Value\n"));
3313 for (i
= 0, entry
= dynamic_segment
;
3322 print_vma (entry
->d_tag
, FULL_HEX
);
3323 dtype
= get_dynamic_type (entry
->d_tag
);
3324 printf (" (%s)%*s", dtype
,
3325 ((is_32bit_elf
? 27 : 19)
3326 - (int) strlen (dtype
)),
3330 switch (entry
->d_tag
)
3334 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3344 switch (entry
->d_tag
)
3347 printf (_("Auxiliary library"));
3351 printf (_("Filter library"));
3355 printf (_("Configuration file"));
3359 printf (_("Dependency audit library"));
3363 printf (_("Audit library"));
3367 if (dynamic_strings
)
3368 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3372 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3381 printf (_("Flags:"));
3382 if (entry
->d_un
.d_val
== 0)
3383 printf (_(" None\n"));
3386 unsigned long int val
= entry
->d_un
.d_val
;
3387 if (val
& DTF_1_PARINIT
)
3389 printf (" PARINIT");
3390 val
^= DTF_1_PARINIT
;
3392 if (val
& DTF_1_CONFEXP
)
3394 printf (" CONFEXP");
3395 val
^= DTF_1_CONFEXP
;
3398 printf (" %lx", val
);
3407 printf (_("Flags:"));
3408 if (entry
->d_un
.d_val
== 0)
3409 printf (_(" None\n"));
3412 unsigned long int val
= entry
->d_un
.d_val
;
3413 if (val
& DF_P1_LAZYLOAD
)
3415 printf (" LAZYLOAD");
3416 val
^= DF_P1_LAZYLOAD
;
3418 if (val
& DF_P1_GROUPPERM
)
3420 printf (" GROUPPERM");
3421 val
^= DF_P1_GROUPPERM
;
3424 printf (" %lx", val
);
3433 printf (_("Flags:"));
3434 if (entry
->d_un
.d_val
== 0)
3435 printf (_(" None\n"));
3438 unsigned long int val
= entry
->d_un
.d_val
;
3444 if (val
& DF_1_GLOBAL
)
3449 if (val
& DF_1_GROUP
)
3454 if (val
& DF_1_NODELETE
)
3456 printf (" NODELETE");
3457 val
^= DF_1_NODELETE
;
3459 if (val
& DF_1_LOADFLTR
)
3461 printf (" LOADFLTR");
3462 val
^= DF_1_LOADFLTR
;
3464 if (val
& DF_1_INITFIRST
)
3466 printf (" INITFIRST");
3467 val
^= DF_1_INITFIRST
;
3469 if (val
& DF_1_NOOPEN
)
3474 if (val
& DF_1_ORIGIN
)
3479 if (val
& DF_1_DIRECT
)
3484 if (val
& DF_1_TRANS
)
3489 if (val
& DF_1_INTERPOSE
)
3491 printf (" INTERPOSE");
3492 val
^= DF_1_INTERPOSE
;
3494 if (val
& DF_1_NODEFLIB
)
3496 printf (" NODEFLIB");
3497 val
^= DF_1_NODEFLIB
;
3499 if (val
& DF_1_NODUMP
)
3504 if (val
& DF_1_CONLFAT
)
3506 printf (" CONLFAT");
3507 val
^= DF_1_CONLFAT
;
3510 printf (" %lx", val
);
3518 puts (get_dynamic_type (entry
->d_un
.d_val
));
3538 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
3544 if (dynamic_strings
== NULL
)
3547 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3551 switch (entry
->d_tag
)
3554 printf (_("Shared library: [%s]"), name
);
3556 if (strcmp (name
, program_interpreter
) == 0)
3557 printf (_(" program interpreter"));
3561 printf (_("Library soname: [%s]"), name
);
3565 printf (_("Library rpath: [%s]"), name
);
3569 printf (_("Library runpath: [%s]"), name
);
3573 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3578 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3594 case DT_INIT_ARRAYSZ
:
3595 case DT_FINI_ARRAYSZ
:
3598 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3599 printf (" (bytes)\n");
3609 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
3622 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
3626 name
= dynamic_strings
+ entry
->d_un
.d_val
;
3630 printf (_("Not needed object: [%s]\n"), name
);
3635 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3641 /* The value of this entry is ignored. */
3645 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
3646 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
3651 switch (elf_header
.e_machine
)
3654 case EM_MIPS_RS4_BE
:
3655 dynamic_segment_mips_val (entry
);
3658 dynamic_segment_parisc_val (entry
);
3661 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
3673 get_ver_flags (flags
)
3676 static char buff
[32];
3683 if (flags
& VER_FLG_BASE
)
3684 strcat (buff
, "BASE ");
3686 if (flags
& VER_FLG_WEAK
)
3688 if (flags
& VER_FLG_BASE
)
3689 strcat (buff
, "| ");
3691 strcat (buff
, "WEAK ");
3694 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
3695 strcat (buff
, "| <unknown>");
3700 /* Display the contents of the version sections. */
3702 process_version_sections (file
)
3705 Elf32_Internal_Shdr
* section
;
3712 for (i
= 0, section
= section_headers
;
3713 i
< elf_header
.e_shnum
;
3716 switch (section
->sh_type
)
3718 case SHT_GNU_verdef
:
3720 Elf_External_Verdef
* edefs
;
3727 (_("\nVersion definition section '%s' contains %ld entries:\n"),
3728 SECTION_NAME (section
), section
->sh_info
);
3730 printf (_(" Addr: 0x"));
3731 printf_vma (section
->sh_addr
);
3732 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3733 (unsigned long) section
->sh_offset
, section
->sh_link
,
3734 SECTION_NAME (section_headers
+ section
->sh_link
));
3736 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3737 edefs
, Elf_External_Verdef
*,
3738 "version definition section");
3740 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
3743 Elf_External_Verdef
* edef
;
3744 Elf_Internal_Verdef ent
;
3745 Elf_External_Verdaux
* eaux
;
3746 Elf_Internal_Verdaux aux
;
3750 vstart
= ((char *) edefs
) + idx
;
3752 edef
= (Elf_External_Verdef
*) vstart
;
3754 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
3755 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
3756 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
3757 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
3758 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
3759 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
3760 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
3762 printf (_(" %#06x: Rev: %d Flags: %s"),
3763 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
3765 printf (_(" Index: %d Cnt: %d "),
3766 ent
.vd_ndx
, ent
.vd_cnt
);
3768 vstart
+= ent
.vd_aux
;
3770 eaux
= (Elf_External_Verdaux
*) vstart
;
3772 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3773 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3775 if (dynamic_strings
)
3776 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
3778 printf (_("Name index: %ld\n"), aux
.vda_name
);
3780 isum
= idx
+ ent
.vd_aux
;
3782 for (j
= 1; j
< ent
.vd_cnt
; j
++)
3784 isum
+= aux
.vda_next
;
3785 vstart
+= aux
.vda_next
;
3787 eaux
= (Elf_External_Verdaux
*) vstart
;
3789 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
3790 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
3792 if (dynamic_strings
)
3793 printf (_(" %#06x: Parent %d: %s\n"),
3794 isum
, j
, dynamic_strings
+ aux
.vda_name
);
3796 printf (_(" %#06x: Parent %d, name index: %ld\n"),
3797 isum
, j
, aux
.vda_name
);
3807 case SHT_GNU_verneed
:
3809 Elf_External_Verneed
* eneed
;
3815 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
3816 SECTION_NAME (section
), section
->sh_info
);
3818 printf (_(" Addr: 0x"));
3819 printf_vma (section
->sh_addr
);
3820 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
3821 (unsigned long) section
->sh_offset
, section
->sh_link
,
3822 SECTION_NAME (section_headers
+ section
->sh_link
));
3824 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
3825 eneed
, Elf_External_Verneed
*,
3826 "version need section");
3828 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
3830 Elf_External_Verneed
* entry
;
3831 Elf_Internal_Verneed ent
;
3836 vstart
= ((char *) eneed
) + idx
;
3838 entry
= (Elf_External_Verneed
*) vstart
;
3840 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
3841 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
3842 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
3843 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
3844 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
3846 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
3848 if (dynamic_strings
)
3849 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
3851 printf (_(" File: %lx"), ent
.vn_file
);
3853 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
3855 vstart
+= ent
.vn_aux
;
3857 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
3859 Elf_External_Vernaux
* eaux
;
3860 Elf_Internal_Vernaux aux
;
3862 eaux
= (Elf_External_Vernaux
*) vstart
;
3864 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
3865 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
3866 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
3867 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
3868 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
3870 if (dynamic_strings
)
3871 printf (_(" %#06x: Name: %s"),
3872 isum
, dynamic_strings
+ aux
.vna_name
);
3874 printf (_(" %#06x: Name index: %lx"),
3875 isum
, aux
.vna_name
);
3877 printf (_(" Flags: %s Version: %d\n"),
3878 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
3880 isum
+= aux
.vna_next
;
3881 vstart
+= aux
.vna_next
;
3891 case SHT_GNU_versym
:
3893 Elf32_Internal_Shdr
* link_section
;
3896 unsigned char * edata
;
3897 unsigned short * data
;
3899 Elf_Internal_Sym
* symbols
;
3900 Elf32_Internal_Shdr
* string_sec
;
3902 link_section
= section_headers
+ section
->sh_link
;
3903 total
= section
->sh_size
/ section
->sh_entsize
;
3907 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
3908 link_section
->sh_size
/ link_section
->sh_entsize
);
3910 string_sec
= section_headers
+ link_section
->sh_link
;
3912 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
3913 strtab
, char *, "version string table");
3915 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
3916 SECTION_NAME (section
), total
);
3918 printf (_(" Addr: "));
3919 printf_vma (section
->sh_addr
);
3920 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
3921 (unsigned long) section
->sh_offset
, section
->sh_link
,
3922 SECTION_NAME (link_section
));
3924 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
3926 total
* sizeof (short), edata
,
3927 unsigned char *, "version symbol data");
3929 data
= (unsigned short *) malloc (total
* sizeof (short));
3931 for (cnt
= total
; cnt
--;)
3932 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
3937 for (cnt
= 0; cnt
< total
; cnt
+= 4)
3942 printf (" %03x:", cnt
);
3944 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
3945 switch (data
[cnt
+ j
])
3948 fputs (_(" 0 (*local*) "), stdout
);
3952 fputs (_(" 1 (*global*) "), stdout
);
3956 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
3957 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
3959 if (symbols
[cnt
+ j
].st_shndx
< SHN_LORESERVE
3960 && section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
3963 /* We must test both. */
3964 Elf_Internal_Verneed ivn
;
3965 unsigned long offset
;
3967 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
3972 Elf_External_Verneed evn
;
3973 Elf_External_Vernaux evna
;
3974 Elf_Internal_Vernaux ivna
;
3975 unsigned long vna_off
;
3977 GET_DATA (offset
, evn
, "version need");
3979 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
3980 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
3982 vna_off
= offset
+ ivn
.vn_aux
;
3986 GET_DATA (vna_off
, evna
,
3987 "version need aux (1)");
3989 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
3990 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
3992 vna_off
+= ivna
.vna_next
;
3994 while (ivna
.vna_other
!= data
[cnt
+ j
]
3995 && ivna
.vna_next
!= 0);
3997 if (ivna
.vna_other
== data
[cnt
+ j
])
3999 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4001 name
= strtab
+ ivna
.vna_name
;
4002 nn
+= printf ("(%s%-*s",
4004 12 - (int) strlen (name
),
4008 else if (ivn
.vn_next
== 0)
4010 if (data
[cnt
+ j
] != 0x8001)
4012 Elf_Internal_Verdef ivd
;
4013 Elf_External_Verdef evd
;
4015 offset
= version_info
4016 [DT_VERSIONTAGIDX (DT_VERDEF
)]
4021 GET_DATA (offset
, evd
,
4022 "version definition");
4024 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4025 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4027 offset
+= ivd
.vd_next
;
4030 != (data
[cnt
+ j
] & 0x7fff)
4031 && ivd
.vd_next
!= 0);
4034 == (data
[cnt
+ j
] & 0x7fff))
4036 Elf_External_Verdaux evda
;
4037 Elf_Internal_Verdaux ivda
;
4039 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4041 GET_DATA (offset
+ ivd
.vd_aux
, evda
,
4042 "version definition aux");
4045 BYTE_GET (evda
.vda_name
);
4047 name
= strtab
+ ivda
.vda_name
;
4051 12 - (int) strlen (name
),
4059 offset
+= ivn
.vn_next
;
4061 while (ivn
.vn_next
);
4063 else if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4065 Elf_Internal_Verneed ivn
;
4066 unsigned long offset
;
4068 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4073 Elf_Internal_Vernaux ivna
;
4074 Elf_External_Verneed evn
;
4075 Elf_External_Vernaux evna
;
4076 unsigned long a_off
;
4078 GET_DATA (offset
, evn
, "version need");
4080 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4081 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4083 a_off
= offset
+ ivn
.vn_aux
;
4087 GET_DATA (a_off
, evna
,
4088 "version need aux (2)");
4090 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4091 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4093 a_off
+= ivna
.vna_next
;
4095 while (ivna
.vna_other
!= data
[cnt
+ j
]
4096 && ivna
.vna_next
!= 0);
4098 if (ivna
.vna_other
== data
[cnt
+ j
])
4100 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4102 name
= strtab
+ ivna
.vna_name
;
4103 nn
+= printf ("(%s%-*s",
4105 12 - (int) strlen (name
),
4110 offset
+= ivn
.vn_next
;
4112 while (ivn
.vn_next
);
4114 else if (data
[cnt
+ j
] != 0x8001)
4116 Elf_Internal_Verdef ivd
;
4117 Elf_External_Verdef evd
;
4118 unsigned long offset
;
4120 offset
= version_info
4121 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4125 GET_DATA (offset
, evd
, "version def");
4127 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4128 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4130 offset
+= ivd
.vd_next
;
4132 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4133 && ivd
.vd_next
!= 0);
4135 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4137 Elf_External_Verdaux evda
;
4138 Elf_Internal_Verdaux ivda
;
4140 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4142 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4143 evda
, "version def aux");
4145 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4147 name
= strtab
+ ivda
.vda_name
;
4148 nn
+= printf ("(%s%-*s",
4150 12 - (int) strlen (name
),
4156 printf ("%*c", 18 - nn
, ' ');
4174 printf (_("\nNo version information found in this file.\n"));
4180 get_symbol_binding (binding
)
4181 unsigned int binding
;
4183 static char buff
[32];
4187 case STB_LOCAL
: return "LOCAL";
4188 case STB_GLOBAL
: return "GLOBAL";
4189 case STB_WEAK
: return "WEAK";
4191 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4192 sprintf (buff
, _("<processor specific>: %d"), binding
);
4193 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4194 sprintf (buff
, _("<OS specific>: %d"), binding
);
4196 sprintf (buff
, _("<unknown>: %d"), binding
);
4202 get_symbol_type (type
)
4205 static char buff
[32];
4209 case STT_NOTYPE
: return "NOTYPE";
4210 case STT_OBJECT
: return "OBJECT";
4211 case STT_FUNC
: return "FUNC";
4212 case STT_SECTION
: return "SECTION";
4213 case STT_FILE
: return "FILE";
4214 case STT_COMMON
: return "COMMON";
4216 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4218 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4219 return "THUMB_FUNC";
4221 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4224 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4225 return "PARISC_MILLI";
4227 sprintf (buff
, _("<processor specific>: %d"), type
);
4229 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4231 if (elf_header
.e_machine
== EM_PARISC
)
4233 if (type
== STT_HP_OPAQUE
)
4235 if (type
== STT_HP_STUB
)
4239 sprintf (buff
, _("<OS specific>: %d"), type
);
4242 sprintf (buff
, _("<unknown>: %d"), type
);
4248 get_symbol_visibility (visibility
)
4249 unsigned int visibility
;
4253 case STV_DEFAULT
: return "DEFAULT";
4254 case STV_INTERNAL
: return "INTERNAL";
4255 case STV_HIDDEN
: return "HIDDEN";
4256 case STV_PROTECTED
: return "PROTECTED";
4262 get_symbol_index_type (type
)
4267 case SHN_UNDEF
: return "UND";
4268 case SHN_ABS
: return "ABS";
4269 case SHN_COMMON
: return "COM";
4271 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4273 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4275 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4279 static char buff
[32];
4281 sprintf (buff
, "%3d", type
);
4288 get_dynamic_data (file
, number
)
4290 unsigned int number
;
4292 unsigned char * e_data
;
4295 e_data
= (unsigned char *) malloc (number
* 4);
4299 error (_("Out of memory\n"));
4303 if (fread (e_data
, 4, number
, file
) != number
)
4305 error (_("Unable to read in dynamic data\n"));
4309 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4313 error (_("Out of memory\n"));
4319 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4326 /* Dump the symbol table */
4328 process_symbol_table (file
)
4331 Elf32_Internal_Shdr
* section
;
4332 unsigned char nb
[4];
4333 unsigned char nc
[4];
4336 int * buckets
= NULL
;
4337 int * chains
= NULL
;
4339 if (! do_syms
&& !do_histogram
)
4342 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4345 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4347 error (_("Unable to seek to start of dynamic information"));
4351 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4353 error (_("Failed to read in number of buckets\n"));
4357 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4359 error (_("Failed to read in number of chains\n"));
4363 nbuckets
= byte_get (nb
, 4);
4364 nchains
= byte_get (nc
, 4);
4366 buckets
= get_dynamic_data (file
, nbuckets
);
4367 chains
= get_dynamic_data (file
, nchains
);
4369 if (buckets
== NULL
|| chains
== NULL
)
4374 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4379 printf (_("\nSymbol table for image:\n"));
4381 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4383 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4385 for (hn
= 0; hn
< nbuckets
; hn
++)
4390 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4392 Elf_Internal_Sym
* psym
;
4394 psym
= dynamic_symbols
+ si
;
4396 printf (" %3d %3d: ", si
, hn
);
4397 print_vma (psym
->st_value
, LONG_HEX
);
4399 print_vma (psym
->st_size
, DEC_5
);
4401 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4402 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4403 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4404 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4405 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4409 else if (do_syms
&& !do_using_dynamic
)
4413 for (i
= 0, section
= section_headers
;
4414 i
< elf_header
.e_shnum
;
4419 Elf_Internal_Sym
* symtab
;
4420 Elf_Internal_Sym
* psym
;
4423 if ( section
->sh_type
!= SHT_SYMTAB
4424 && section
->sh_type
!= SHT_DYNSYM
)
4427 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4428 SECTION_NAME (section
),
4429 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4431 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4433 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4435 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4436 section
->sh_size
/ section
->sh_entsize
);
4440 if (section
->sh_link
== elf_header
.e_shstrndx
)
4441 strtab
= string_table
;
4444 Elf32_Internal_Shdr
* string_sec
;
4446 string_sec
= section_headers
+ section
->sh_link
;
4448 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4449 strtab
, char *, "string table");
4452 for (si
= 0, psym
= symtab
;
4453 si
< section
->sh_size
/ section
->sh_entsize
;
4456 printf ("%6d: ", si
);
4457 print_vma (psym
->st_value
, LONG_HEX
);
4459 print_vma (psym
->st_size
, DEC_5
);
4460 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4461 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4462 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4463 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4464 printf (" %s", strtab
+ psym
->st_name
);
4466 if (section
->sh_type
== SHT_DYNSYM
&&
4467 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
4469 unsigned char data
[2];
4470 unsigned short vers_data
;
4471 unsigned long offset
;
4475 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4478 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
4481 vers_data
= byte_get (data
, 2);
4483 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
4484 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
4487 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
4489 if ((vers_data
& 0x8000) || vers_data
> 1)
4491 if (is_nobits
|| ! check_def
)
4493 Elf_External_Verneed evn
;
4494 Elf_Internal_Verneed ivn
;
4495 Elf_Internal_Vernaux ivna
;
4497 /* We must test both. */
4498 offset
= version_info
4499 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
4503 unsigned long vna_off
;
4505 GET_DATA (offset
, evn
, "version need");
4507 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4508 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4510 vna_off
= offset
+ ivn
.vn_aux
;
4514 Elf_External_Vernaux evna
;
4516 GET_DATA (vna_off
, evna
,
4517 "version need aux (3)");
4519 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4520 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4521 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4523 vna_off
+= ivna
.vna_next
;
4525 while (ivna
.vna_other
!= vers_data
4526 && ivna
.vna_next
!= 0);
4528 if (ivna
.vna_other
== vers_data
)
4531 offset
+= ivn
.vn_next
;
4533 while (ivn
.vn_next
!= 0);
4535 if (ivna
.vna_other
== vers_data
)
4538 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
4541 else if (! is_nobits
)
4542 error (_("bad dynamic symbol"));
4549 if (vers_data
!= 0x8001)
4551 Elf_Internal_Verdef ivd
;
4552 Elf_Internal_Verdaux ivda
;
4553 Elf_External_Verdaux evda
;
4554 unsigned long offset
;
4557 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
4562 Elf_External_Verdef evd
;
4564 GET_DATA (offset
, evd
, "version def");
4566 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4567 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4568 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4570 offset
+= ivd
.vd_next
;
4572 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
4573 && ivd
.vd_next
!= 0);
4575 offset
-= ivd
.vd_next
;
4576 offset
+= ivd
.vd_aux
;
4578 GET_DATA (offset
, evda
, "version def aux");
4580 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4582 if (psym
->st_name
!= ivda
.vda_name
)
4583 printf ((vers_data
& 0x8000)
4585 strtab
+ ivda
.vda_name
);
4595 if (strtab
!= string_table
)
4601 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
4603 if (do_histogram
&& buckets
!= NULL
)
4610 int nzero_counts
= 0;
4613 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
4615 printf (_(" Length Number %% of total Coverage\n"));
4617 lengths
= (int *) calloc (nbuckets
, sizeof (int));
4618 if (lengths
== NULL
)
4620 error (_("Out of memory"));
4623 for (hn
= 0; hn
< nbuckets
; ++hn
)
4628 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
4631 if (maxlength
< ++lengths
[hn
])
4636 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
4639 error (_("Out of memory"));
4643 for (hn
= 0; hn
< nbuckets
; ++hn
)
4644 ++ counts
[lengths
[hn
]];
4648 printf (" 0 %-10d (%5.1f%%)\n",
4649 counts
[0], (counts
[0] * 100.0) / nbuckets
);
4650 for (si
= 1; si
<= maxlength
; ++si
)
4652 nzero_counts
+= counts
[si
] * si
;
4653 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
4654 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
4655 (nzero_counts
* 100.0) / nsyms
);
4663 if (buckets
!= NULL
)
4673 process_syminfo (file
)
4674 FILE * file ATTRIBUTE_UNUSED
;
4678 if (dynamic_syminfo
== NULL
4680 /* No syminfo, this is ok. */
4683 /* There better should be a dynamic symbol section. */
4684 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
4688 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
4689 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
4691 printf (_(" Num: Name BoundTo Flags\n"));
4692 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
4694 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
4696 printf ("%4d: %-30s ", i
,
4697 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
4699 switch (dynamic_syminfo
[i
].si_boundto
)
4701 case SYMINFO_BT_SELF
:
4702 fputs ("SELF ", stdout
);
4704 case SYMINFO_BT_PARENT
:
4705 fputs ("PARENT ", stdout
);
4708 if (dynamic_syminfo
[i
].si_boundto
> 0
4709 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
4712 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
4714 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
4718 if (flags
& SYMINFO_FLG_DIRECT
)
4720 if (flags
& SYMINFO_FLG_PASSTHRU
)
4721 printf (" PASSTHRU");
4722 if (flags
& SYMINFO_FLG_COPY
)
4724 if (flags
& SYMINFO_FLG_LAZYLOAD
)
4725 printf (" LAZYLOAD");
4733 #ifdef SUPPORT_DISASSEMBLY
4735 disassemble_section (section
, file
)
4736 Elf32_Internal_Shdr
* section
;
4739 printf (_("\nAssembly dump of section %s\n"),
4740 SECTION_NAME (section
));
4742 /* XXX -- to be done --- XXX */
4749 dump_section (section
, file
)
4750 Elf32_Internal_Shdr
* section
;
4753 bfd_size_type bytes
;
4755 unsigned char * data
;
4756 unsigned char * start
;
4758 bytes
= section
->sh_size
;
4762 printf (_("\nSection '%s' has no data to dump.\n"),
4763 SECTION_NAME (section
));
4767 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
4769 addr
= section
->sh_addr
;
4771 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
4782 lbytes
= (bytes
> 16 ? 16 : bytes
);
4784 printf (" 0x%8.8lx ", (unsigned long) addr
);
4786 switch (elf_header
.e_ident
[EI_DATA
])
4790 for (j
= 15; j
>= 0; j
--)
4793 printf ("%2.2x", data
[j
]);
4803 for (j
= 0; j
< 16; j
++)
4806 printf ("%2.2x", data
[j
]);
4816 for (j
= 0; j
< lbytes
; j
++)
4819 if (k
>= ' ' && k
< 0x80)
4838 static unsigned long int
4839 read_leb128 (data
, length_return
, sign
)
4840 unsigned char * data
;
4841 int * length_return
;
4844 unsigned long int result
= 0;
4845 unsigned int num_read
= 0;
4854 result
|= (byte
& 0x7f) << shift
;
4859 while (byte
& 0x80);
4861 if (length_return
!= NULL
)
4862 * length_return
= num_read
;
4864 if (sign
&& (shift
< 32) && (byte
& 0x40))
4865 result
|= -1 << shift
;
4870 typedef struct State_Machine_Registers
4872 unsigned long address
;
4875 unsigned int column
;
4879 /* This variable hold the number of the last entry seen
4880 in the File Table. */
4881 unsigned int last_file_entry
;
4884 static SMR state_machine_regs
;
4887 reset_state_machine (is_stmt
)
4890 state_machine_regs
.address
= 0;
4891 state_machine_regs
.file
= 1;
4892 state_machine_regs
.line
= 1;
4893 state_machine_regs
.column
= 0;
4894 state_machine_regs
.is_stmt
= is_stmt
;
4895 state_machine_regs
.basic_block
= 0;
4896 state_machine_regs
.end_sequence
= 0;
4897 state_machine_regs
.last_file_entry
= 0;
4900 /* Handled an extend line op. Returns true if this is the end
4903 process_extended_line_op (data
, is_stmt
, pointer_size
)
4904 unsigned char * data
;
4908 unsigned char op_code
;
4911 unsigned char * name
;
4914 len
= read_leb128 (data
, & bytes_read
, 0);
4919 warn (_("badly formed extended line op encountered!"));
4924 op_code
= * data
++;
4926 printf (_(" Extended opcode %d: "), op_code
);
4930 case DW_LNE_end_sequence
:
4931 printf (_("End of Sequence\n\n"));
4932 reset_state_machine (is_stmt
);
4935 case DW_LNE_set_address
:
4936 adr
= byte_get (data
, pointer_size
);
4937 printf (_("set Address to 0x%lx\n"), adr
);
4938 state_machine_regs
.address
= adr
;
4941 case DW_LNE_define_file
:
4942 printf (_(" define new File Table entry\n"));
4943 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
4945 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
4947 data
+= strlen ((char *) data
) + 1;
4948 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4950 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4952 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
4953 printf (_("%s\n\n"), name
);
4957 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
4964 /* Size of pointers in the .debug_line section. This information is not
4965 really present in that section. It's obtained before dumping the debug
4966 sections by doing some pre-scan of the .debug_info section. */
4967 static int debug_line_pointer_size
= 4;
4970 display_debug_lines (section
, start
, file
)
4971 Elf32_Internal_Shdr
* section
;
4972 unsigned char * start
;
4973 FILE * file ATTRIBUTE_UNUSED
;
4975 DWARF2_External_LineInfo
* external
;
4976 DWARF2_Internal_LineInfo info
;
4977 unsigned char * standard_opcodes
;
4978 unsigned char * data
= start
;
4979 unsigned char * end
= start
+ section
->sh_size
;
4980 unsigned char * end_of_sequence
;
4983 printf (_("\nDump of debug contents of section %s:\n\n"),
4984 SECTION_NAME (section
));
4988 external
= (DWARF2_External_LineInfo
*) data
;
4990 /* Check the length of the block. */
4991 info
.li_length
= BYTE_GET (external
->li_length
);
4992 if (info
.li_length
> section
->sh_size
)
4995 (_("The line info appears to be corrupt - the section is too small\n"));
4999 /* Check its version number. */
5000 info
.li_version
= BYTE_GET (external
->li_version
);
5001 if (info
.li_version
!= 2)
5003 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5007 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5008 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5009 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5010 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5011 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5012 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5014 /* Sign extend the line base field. */
5015 info
.li_line_base
<<= 24;
5016 info
.li_line_base
>>= 24;
5018 printf (_(" Length: %ld\n"), info
.li_length
);
5019 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5020 printf (_(" Prolgue Length: %d\n"), info
.li_prologue_length
);
5021 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5022 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5023 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5024 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5025 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5027 end_of_sequence
= data
+ info
.li_length
+ sizeof (info
.li_length
);
5029 reset_state_machine (info
.li_default_is_stmt
);
5031 /* Display the contents of the Opcodes table. */
5032 standard_opcodes
= data
+ sizeof (* external
);
5034 printf (_("\n Opcodes:\n"));
5036 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5037 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5039 /* Display the contents of the Directory table. */
5040 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5043 printf (_("\n The Directory Table is empty.\n"));
5046 printf (_("\n The Directory Table:\n"));
5050 printf (_(" %s\n"), data
);
5052 data
+= strlen ((char *) data
) + 1;
5056 /* Skip the NUL at the end of the table. */
5059 /* Display the contents of the File Name table. */
5061 printf (_("\n The File Name Table is empty.\n"));
5064 printf (_("\n The File Name Table:\n"));
5065 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5069 unsigned char * name
;
5072 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5075 data
+= strlen ((char *) data
) + 1;
5077 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5079 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5081 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5083 printf (_("%s\n"), name
);
5087 /* Skip the NUL at the end of the table. */
5090 /* Now display the statements. */
5091 printf (_("\n Line Number Statements:\n"));
5094 while (data
< end_of_sequence
)
5096 unsigned char op_code
;
5100 op_code
= * data
++;
5104 case DW_LNS_extended_op
:
5105 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5106 debug_line_pointer_size
);
5110 printf (_(" Copy\n"));
5113 case DW_LNS_advance_pc
:
5114 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5116 state_machine_regs
.address
+= adv
;
5117 printf (_(" Advance PC by %d to %lx\n"), adv
,
5118 state_machine_regs
.address
);
5121 case DW_LNS_advance_line
:
5122 adv
= read_leb128 (data
, & bytes_read
, 1);
5124 state_machine_regs
.line
+= adv
;
5125 printf (_(" Advance Line by %d to %d\n"), adv
,
5126 state_machine_regs
.line
);
5129 case DW_LNS_set_file
:
5130 adv
= read_leb128 (data
, & bytes_read
, 0);
5132 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5134 state_machine_regs
.file
= adv
;
5137 case DW_LNS_set_column
:
5138 adv
= read_leb128 (data
, & bytes_read
, 0);
5140 printf (_(" Set column to %d\n"), adv
);
5141 state_machine_regs
.column
= adv
;
5144 case DW_LNS_negate_stmt
:
5145 adv
= state_machine_regs
.is_stmt
;
5147 printf (_(" Set is_stmt to %d\n"), adv
);
5148 state_machine_regs
.is_stmt
= adv
;
5151 case DW_LNS_set_basic_block
:
5152 printf (_(" Set basic block\n"));
5153 state_machine_regs
.basic_block
= 1;
5156 case DW_LNS_const_add_pc
:
5157 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5158 * info
.li_min_insn_length
);
5159 state_machine_regs
.address
+= adv
;
5160 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5161 state_machine_regs
.address
);
5164 case DW_LNS_fixed_advance_pc
:
5165 adv
= byte_get (data
, 2);
5167 state_machine_regs
.address
+= adv
;
5168 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5169 adv
, state_machine_regs
.address
);
5173 op_code
-= info
.li_opcode_base
;
5174 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5175 state_machine_regs
.address
+= adv
;
5176 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5177 op_code
, adv
, state_machine_regs
.address
);
5178 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5179 state_machine_regs
.line
+= adv
;
5180 printf (_(" and Line by %d to %d\n"),
5181 adv
, state_machine_regs
.line
);
5192 display_debug_pubnames (section
, start
, file
)
5193 Elf32_Internal_Shdr
* section
;
5194 unsigned char * start
;
5195 FILE * file ATTRIBUTE_UNUSED
;
5197 DWARF2_External_PubNames
* external
;
5198 DWARF2_Internal_PubNames pubnames
;
5199 unsigned char * end
;
5201 end
= start
+ section
->sh_size
;
5203 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5207 unsigned char * data
;
5208 unsigned long offset
;
5210 external
= (DWARF2_External_PubNames
*) start
;
5212 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5213 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5214 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5215 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5217 data
= start
+ sizeof (* external
);
5218 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5220 if (pubnames
.pn_version
!= 2)
5222 warn (_("Only DWARF 2 pubnames are currently supported"));
5226 printf (_(" Length: %ld\n"),
5227 pubnames
.pn_length
);
5228 printf (_(" Version: %d\n"),
5229 pubnames
.pn_version
);
5230 printf (_(" Offset into .debug_info section: %ld\n"),
5231 pubnames
.pn_offset
);
5232 printf (_(" Size of area in .debug_info section: %ld\n"),
5235 printf (_("\n Offset\tName\n"));
5239 offset
= byte_get (data
, 4);
5244 printf (" %ld\t\t%s\n", offset
, data
);
5245 data
+= strlen ((char *) data
) + 1;
5248 while (offset
!= 0);
5261 case DW_TAG_padding
: return "DW_TAG_padding";
5262 case DW_TAG_array_type
: return "DW_TAG_array_type";
5263 case DW_TAG_class_type
: return "DW_TAG_class_type";
5264 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5265 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5266 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5267 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5268 case DW_TAG_label
: return "DW_TAG_label";
5269 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5270 case DW_TAG_member
: return "DW_TAG_member";
5271 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5272 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5273 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5274 case DW_TAG_string_type
: return "DW_TAG_string_type";
5275 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5276 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5277 case DW_TAG_typedef
: return "DW_TAG_typedef";
5278 case DW_TAG_union_type
: return "DW_TAG_union_type";
5279 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5280 case DW_TAG_variant
: return "DW_TAG_variant";
5281 case DW_TAG_common_block
: return "DW_TAG_common_block";
5282 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5283 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5284 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5285 case DW_TAG_module
: return "DW_TAG_module";
5286 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5287 case DW_TAG_set_type
: return "DW_TAG_set_type";
5288 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5289 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5290 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5291 case DW_TAG_base_type
: return "DW_TAG_base_type";
5292 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5293 case DW_TAG_const_type
: return "DW_TAG_const_type";
5294 case DW_TAG_constant
: return "DW_TAG_constant";
5295 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5296 case DW_TAG_file_type
: return "DW_TAG_file_type";
5297 case DW_TAG_friend
: return "DW_TAG_friend";
5298 case DW_TAG_namelist
: return "DW_TAG_namelist";
5299 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5300 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5301 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5302 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5303 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5304 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5305 case DW_TAG_try_block
: return "DW_TAG_try_block";
5306 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5307 case DW_TAG_variable
: return "DW_TAG_variable";
5308 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5309 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5310 case DW_TAG_format_label
: return "DW_TAG_format_label";
5311 case DW_TAG_function_template
: return "DW_TAG_function_template";
5312 case DW_TAG_class_template
: return "DW_TAG_class_template";
5315 static char buffer
[100];
5317 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5324 get_AT_name (attribute
)
5325 unsigned long attribute
;
5329 case DW_AT_sibling
: return "DW_AT_sibling";
5330 case DW_AT_location
: return "DW_AT_location";
5331 case DW_AT_name
: return "DW_AT_name";
5332 case DW_AT_ordering
: return "DW_AT_ordering";
5333 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5334 case DW_AT_byte_size
: return "DW_AT_byte_size";
5335 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5336 case DW_AT_bit_size
: return "DW_AT_bit_size";
5337 case DW_AT_element_list
: return "DW_AT_element_list";
5338 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5339 case DW_AT_low_pc
: return "DW_AT_low_pc";
5340 case DW_AT_high_pc
: return "DW_AT_high_pc";
5341 case DW_AT_language
: return "DW_AT_language";
5342 case DW_AT_member
: return "DW_AT_member";
5343 case DW_AT_discr
: return "DW_AT_discr";
5344 case DW_AT_discr_value
: return "DW_AT_discr_value";
5345 case DW_AT_visibility
: return "DW_AT_visibility";
5346 case DW_AT_import
: return "DW_AT_import";
5347 case DW_AT_string_length
: return "DW_AT_string_length";
5348 case DW_AT_common_reference
: return "DW_AT_common_reference";
5349 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5350 case DW_AT_const_value
: return "DW_AT_const_value";
5351 case DW_AT_containing_type
: return "DW_AT_containing_type";
5352 case DW_AT_default_value
: return "DW_AT_default_value";
5353 case DW_AT_inline
: return "DW_AT_inline";
5354 case DW_AT_is_optional
: return "DW_AT_is_optional";
5355 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5356 case DW_AT_producer
: return "DW_AT_producer";
5357 case DW_AT_prototyped
: return "DW_AT_prototyped";
5358 case DW_AT_return_addr
: return "DW_AT_return_addr";
5359 case DW_AT_start_scope
: return "DW_AT_start_scope";
5360 case DW_AT_stride_size
: return "DW_AT_stride_size";
5361 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5362 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5363 case DW_AT_accessibility
: return "DW_AT_accessibility";
5364 case DW_AT_address_class
: return "DW_AT_address_class";
5365 case DW_AT_artificial
: return "DW_AT_artificial";
5366 case DW_AT_base_types
: return "DW_AT_base_types";
5367 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5368 case DW_AT_count
: return "DW_AT_count";
5369 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5370 case DW_AT_decl_column
: return "DW_AT_decl_column";
5371 case DW_AT_decl_file
: return "DW_AT_decl_file";
5372 case DW_AT_decl_line
: return "DW_AT_decl_line";
5373 case DW_AT_declaration
: return "DW_AT_declaration";
5374 case DW_AT_discr_list
: return "DW_AT_discr_list";
5375 case DW_AT_encoding
: return "DW_AT_encoding";
5376 case DW_AT_external
: return "DW_AT_external";
5377 case DW_AT_frame_base
: return "DW_AT_frame_base";
5378 case DW_AT_friend
: return "DW_AT_friend";
5379 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5380 case DW_AT_macro_info
: return "DW_AT_macro_info";
5381 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5382 case DW_AT_priority
: return "DW_AT_priority";
5383 case DW_AT_segment
: return "DW_AT_segment";
5384 case DW_AT_specification
: return "DW_AT_specification";
5385 case DW_AT_static_link
: return "DW_AT_static_link";
5386 case DW_AT_type
: return "DW_AT_type";
5387 case DW_AT_use_location
: return "DW_AT_use_location";
5388 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5389 case DW_AT_virtuality
: return "DW_AT_virtuality";
5390 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5391 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5392 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5393 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5394 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5395 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5396 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5397 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5398 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5399 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5400 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5401 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5402 case DW_AT_sf_names
: return "DW_AT_sf_names";
5403 case DW_AT_src_info
: return "DW_AT_src_info";
5404 case DW_AT_mac_info
: return "DW_AT_mac_info";
5405 case DW_AT_src_coords
: return "DW_AT_src_coords";
5406 case DW_AT_body_begin
: return "DW_AT_body_begin";
5407 case DW_AT_body_end
: return "DW_AT_body_end";
5410 static char buffer
[100];
5412 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5419 get_FORM_name (form
)
5424 case DW_FORM_addr
: return "DW_FORM_addr";
5425 case DW_FORM_block2
: return "DW_FORM_block2";
5426 case DW_FORM_block4
: return "DW_FORM_block4";
5427 case DW_FORM_data2
: return "DW_FORM_data2";
5428 case DW_FORM_data4
: return "DW_FORM_data4";
5429 case DW_FORM_data8
: return "DW_FORM_data8";
5430 case DW_FORM_string
: return "DW_FORM_string";
5431 case DW_FORM_block
: return "DW_FORM_block";
5432 case DW_FORM_block1
: return "DW_FORM_block1";
5433 case DW_FORM_data1
: return "DW_FORM_data1";
5434 case DW_FORM_flag
: return "DW_FORM_flag";
5435 case DW_FORM_sdata
: return "DW_FORM_sdata";
5436 case DW_FORM_strp
: return "DW_FORM_strp";
5437 case DW_FORM_udata
: return "DW_FORM_udata";
5438 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5439 case DW_FORM_ref1
: return "DW_FORM_ref1";
5440 case DW_FORM_ref2
: return "DW_FORM_ref2";
5441 case DW_FORM_ref4
: return "DW_FORM_ref4";
5442 case DW_FORM_ref8
: return "DW_FORM_ref8";
5443 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5444 case DW_FORM_indirect
: return "DW_FORM_indirect";
5447 static char buffer
[100];
5449 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5455 /* FIXME: There are better and more effiecint ways to handle
5456 these structures. For now though, I just want something that
5457 is simple to implement. */
5458 typedef struct abbrev_attr
5460 unsigned long attribute
;
5462 struct abbrev_attr
* next
;
5466 typedef struct abbrev_entry
5468 unsigned long entry
;
5471 struct abbrev_attr
* first_attr
;
5472 struct abbrev_attr
* last_attr
;
5473 struct abbrev_entry
* next
;
5477 static abbrev_entry
* first_abbrev
= NULL
;
5478 static abbrev_entry
* last_abbrev
= NULL
;
5481 free_abbrevs
PARAMS ((void))
5483 abbrev_entry
* abbrev
;
5485 for (abbrev
= first_abbrev
; abbrev
;)
5487 abbrev_entry
* next
= abbrev
->next
;
5490 for (attr
= abbrev
->first_attr
; attr
;)
5492 abbrev_attr
* next
= attr
->next
;
5502 last_abbrev
= first_abbrev
= NULL
;
5506 add_abbrev (number
, tag
, children
)
5507 unsigned long number
;
5511 abbrev_entry
* entry
;
5513 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
5519 entry
->entry
= number
;
5521 entry
->children
= children
;
5522 entry
->first_attr
= NULL
;
5523 entry
->last_attr
= NULL
;
5526 if (first_abbrev
== NULL
)
5527 first_abbrev
= entry
;
5529 last_abbrev
->next
= entry
;
5531 last_abbrev
= entry
;
5535 add_abbrev_attr (attribute
, form
)
5536 unsigned long attribute
;
5541 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
5547 attr
->attribute
= attribute
;
5551 if (last_abbrev
->first_attr
== NULL
)
5552 last_abbrev
->first_attr
= attr
;
5554 last_abbrev
->last_attr
->next
= attr
;
5556 last_abbrev
->last_attr
= attr
;
5559 /* Processes the (partial) contents of a .debug_abbrev section.
5560 Returns NULL if the end of the section was encountered.
5561 Returns the address after the last byte read if the end of
5562 an abbreviation set was found. */
5564 static unsigned char *
5565 process_abbrev_section (start
, end
)
5566 unsigned char * start
;
5567 unsigned char * end
;
5569 if (first_abbrev
!= NULL
)
5575 unsigned long entry
;
5577 unsigned long attribute
;
5580 entry
= read_leb128 (start
, & bytes_read
, 0);
5581 start
+= bytes_read
;
5583 /* A single zero is supposed to end the section according
5584 to the standard. If there's more, then signal that to
5587 return start
== end
? NULL
: start
;
5589 tag
= read_leb128 (start
, & bytes_read
, 0);
5590 start
+= bytes_read
;
5592 children
= * start
++;
5594 add_abbrev (entry
, tag
, children
);
5600 attribute
= read_leb128 (start
, & bytes_read
, 0);
5601 start
+= bytes_read
;
5603 form
= read_leb128 (start
, & bytes_read
, 0);
5604 start
+= bytes_read
;
5607 add_abbrev_attr (attribute
, form
);
5609 while (attribute
!= 0);
5617 display_debug_abbrev (section
, start
, file
)
5618 Elf32_Internal_Shdr
* section
;
5619 unsigned char * start
;
5620 FILE * file ATTRIBUTE_UNUSED
;
5622 abbrev_entry
* entry
;
5623 unsigned char * end
= start
+ section
->sh_size
;
5625 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5629 start
= process_abbrev_section (start
, end
);
5631 printf (_(" Number TAG\n"));
5633 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
5637 printf (_(" %ld %s [%s]\n"),
5639 get_TAG_name (entry
->tag
),
5640 entry
->children
? _("has children") : _("no children"));
5642 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
5644 printf (_(" %-18s %s\n"),
5645 get_AT_name (attr
->attribute
),
5646 get_FORM_name (attr
->form
));
5658 static unsigned char *
5659 display_block (data
, length
)
5660 unsigned char * data
;
5661 unsigned long length
;
5663 printf (_(" %lu byte block: "), length
);
5666 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
5672 decode_location_expression (data
, pointer_size
, length
)
5673 unsigned char * data
;
5674 unsigned int pointer_size
;
5675 unsigned long length
;
5679 unsigned long uvalue
;
5680 unsigned char *end
= data
+ length
;
5689 printf ("DW_OP_addr: %lx",
5690 (unsigned long) byte_get (data
, pointer_size
));
5691 data
+= pointer_size
;
5694 printf ("DW_OP_deref");
5697 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
5700 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
5703 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
5707 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
5711 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
5715 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
5719 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
5720 (unsigned long) byte_get (data
+ 4, 4));
5724 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
5725 (long) byte_get (data
+ 4, 4));
5729 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
5733 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
5737 printf ("DW_OP_dup");
5740 printf ("DW_OP_drop");
5743 printf ("DW_OP_over");
5746 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
5749 printf ("DW_OP_swap");
5752 printf ("DW_OP_rot");
5755 printf ("DW_OP_xderef");
5758 printf ("DW_OP_abs");
5761 printf ("DW_OP_and");
5764 printf ("DW_OP_div");
5767 printf ("DW_OP_minus");
5770 printf ("DW_OP_mod");
5773 printf ("DW_OP_mul");
5776 printf ("DW_OP_neg");
5779 printf ("DW_OP_not");
5782 printf ("DW_OP_or");
5785 printf ("DW_OP_plus");
5787 case DW_OP_plus_uconst
:
5788 printf ("DW_OP_plus_uconst: %lu",
5789 read_leb128 (data
, &bytes_read
, 0));
5793 printf ("DW_OP_shl");
5796 printf ("DW_OP_shr");
5799 printf ("DW_OP_shra");
5802 printf ("DW_OP_xor");
5805 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
5809 printf ("DW_OP_eq");
5812 printf ("DW_OP_ge");
5815 printf ("DW_OP_gt");
5818 printf ("DW_OP_le");
5821 printf ("DW_OP_lt");
5824 printf ("DW_OP_ne");
5827 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
5863 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
5898 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
5933 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
5934 read_leb128 (data
, &bytes_read
, 1));
5939 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
5943 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
5947 uvalue
= read_leb128 (data
, &bytes_read
, 0);
5949 printf ("DW_OP_bregx: %lu %ld", uvalue
,
5950 read_leb128 (data
, &bytes_read
, 1));
5954 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
5957 case DW_OP_deref_size
:
5958 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
5960 case DW_OP_xderef_size
:
5961 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
5964 printf ("DW_OP_nop");
5968 if (op
>= DW_OP_lo_user
5969 && op
<= DW_OP_hi_user
)
5970 printf (_("(User defined location op)"));
5972 printf (_("(Unknown location op)"));
5973 /* No way to tell where the next op is, so just bail. */
5980 static unsigned char *
5981 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
5982 unsigned long attribute
;
5984 unsigned char * data
;
5985 unsigned long cu_offset
;
5986 unsigned long pointer_size
;
5988 unsigned long uvalue
= 0;
5989 unsigned char * block_start
= NULL
;
5992 printf (" %-18s:", get_AT_name (attribute
));
5999 case DW_FORM_ref_addr
:
6001 uvalue
= byte_get (data
, pointer_size
);
6002 data
+= pointer_size
;
6008 uvalue
= byte_get (data
++, 1);
6013 uvalue
= byte_get (data
, 2);
6019 uvalue
= byte_get (data
, 4);
6024 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6028 case DW_FORM_ref_udata
:
6030 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6037 case DW_FORM_ref_addr
:
6038 printf (" <#%lx>", uvalue
);
6044 case DW_FORM_ref_udata
:
6045 printf (" <%lx>", uvalue
+ cu_offset
);
6049 printf (" %#lx", uvalue
);
6057 printf (" %ld", uvalue
);
6062 uvalue
= byte_get (data
, 4);
6063 printf (" %lx", uvalue
);
6064 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6068 case DW_FORM_string
:
6069 printf (" %s", data
);
6070 data
+= strlen ((char *) data
) + 1;
6074 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6075 block_start
= data
+ bytes_read
;
6076 data
= display_block (block_start
, uvalue
);
6079 case DW_FORM_block1
:
6080 uvalue
= byte_get (data
, 1);
6081 block_start
= data
+ 1;
6082 data
= display_block (block_start
, uvalue
);
6085 case DW_FORM_block2
:
6086 uvalue
= byte_get (data
, 2);
6087 block_start
= data
+ 2;
6088 data
= display_block (block_start
, uvalue
);
6091 case DW_FORM_block4
:
6092 uvalue
= byte_get (data
, 4);
6093 block_start
= data
+ 4;
6094 data
= display_block (block_start
, uvalue
);
6098 case DW_FORM_indirect
:
6099 warn (_("Unable to handle FORM: %d"), form
);
6103 warn (_("Unrecognised form: %d"), form
);
6107 /* For some attributes we can display futher information. */
6116 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6117 case DW_INL_inlined
: printf (_("(inlined)")); break;
6118 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6119 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6120 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6124 case DW_AT_language
:
6127 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6128 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6129 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6130 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6131 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6132 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6133 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6134 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6135 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6136 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6137 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6138 default: printf ("(Unknown: %lx)", uvalue
); break;
6142 case DW_AT_encoding
:
6145 case DW_ATE_void
: printf ("(void)"); break;
6146 case DW_ATE_address
: printf ("(machine address)"); break;
6147 case DW_ATE_boolean
: printf ("(boolean)"); break;
6148 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6149 case DW_ATE_float
: printf ("(float)"); break;
6150 case DW_ATE_signed
: printf ("(signed)"); break;
6151 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6152 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6153 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6155 if (uvalue
>= DW_ATE_lo_user
6156 && uvalue
<= DW_ATE_hi_user
)
6157 printf ("(user defined type)");
6159 printf ("(unknown type)");
6164 case DW_AT_accessibility
:
6167 case DW_ACCESS_public
: printf ("(public)"); break;
6168 case DW_ACCESS_protected
: printf ("(protected)"); break;
6169 case DW_ACCESS_private
: printf ("(private)"); break;
6170 default: printf ("(unknown accessibility)"); break;
6174 case DW_AT_visibility
:
6177 case DW_VIS_local
: printf ("(local)"); break;
6178 case DW_VIS_exported
: printf ("(exported)"); break;
6179 case DW_VIS_qualified
: printf ("(qualified)"); break;
6180 default: printf ("(unknown visibility)"); break;
6184 case DW_AT_virtuality
:
6187 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6188 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6189 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6190 default: printf ("(unknown virtuality)"); break;
6194 case DW_AT_identifier_case
:
6197 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6198 case DW_ID_up_case
: printf ("(up_case)"); break;
6199 case DW_ID_down_case
: printf ("(down_case)"); break;
6200 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6201 default: printf ("(unknown case)"); break;
6205 case DW_AT_calling_convention
:
6208 case DW_CC_normal
: printf ("(normal)"); break;
6209 case DW_CC_program
: printf ("(program)"); break;
6210 case DW_CC_nocall
: printf ("(nocall)"); break;
6212 if (uvalue
>= DW_CC_lo_user
6213 && uvalue
<= DW_CC_hi_user
)
6214 printf ("(user defined)");
6216 printf ("(unknown convention)");
6220 case DW_AT_frame_base
:
6221 case DW_AT_location
:
6222 case DW_AT_data_member_location
:
6223 case DW_AT_vtable_elem_location
:
6227 decode_location_expression (block_start
, pointer_size
, uvalue
);
6241 display_debug_info (section
, start
, file
)
6242 Elf32_Internal_Shdr
* section
;
6243 unsigned char * start
;
6246 unsigned char * end
= start
+ section
->sh_size
;
6247 unsigned char * section_begin
= start
;
6249 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6253 DWARF2_External_CompUnit
* external
;
6254 DWARF2_Internal_CompUnit compunit
;
6255 unsigned char * tags
;
6258 unsigned long cu_offset
;
6260 external
= (DWARF2_External_CompUnit
*) start
;
6262 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6263 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6264 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6265 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6267 tags
= start
+ sizeof (* external
);
6268 cu_offset
= start
- section_begin
;
6269 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6271 if (compunit
.cu_version
!= 2)
6273 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6277 printf (_(" Compilation Unit:\n"));
6278 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6279 printf (_(" Version: %d\n"), compunit
.cu_version
);
6280 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6281 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6283 if (first_abbrev
!= NULL
)
6286 /* Read in the abbrevs used by this compilation unit. */
6289 Elf32_Internal_Shdr
* sec
;
6290 unsigned char * begin
;
6292 /* Locate the .debug_abbrev section and process it. */
6293 for (i
= 0, sec
= section_headers
;
6294 i
< elf_header
.e_shnum
;
6296 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6299 if (i
== -1 || sec
->sh_size
== 0)
6301 warn (_("Unable to locate .debug_abbrev section!\n"));
6305 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6306 "debug_abbrev section data");
6308 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6309 begin
+ sec
->sh_size
);
6315 while (tags
< start
)
6318 unsigned long abbrev_number
;
6319 abbrev_entry
* entry
;
6322 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6325 /* A null DIE marks the end of a list of children. */
6326 if (abbrev_number
== 0)
6332 /* Scan through the abbreviation list until we reach the
6334 for (entry
= first_abbrev
;
6335 entry
&& entry
->entry
!= abbrev_number
;
6336 entry
= entry
->next
)
6341 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6346 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6347 level
, tags
- section_begin
- bytes_read
,
6349 get_TAG_name (entry
->tag
));
6351 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6352 tags
= read_and_display_attr (attr
->attribute
,
6355 compunit
.cu_pointer_size
);
6357 if (entry
->children
)
6368 display_debug_aranges (section
, start
, file
)
6369 Elf32_Internal_Shdr
* section
;
6370 unsigned char * start
;
6371 FILE * file ATTRIBUTE_UNUSED
;
6373 unsigned char * end
= start
+ section
->sh_size
;
6375 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6379 DWARF2_External_ARange
* external
;
6380 DWARF2_Internal_ARange arange
;
6381 unsigned char * ranges
;
6382 unsigned long length
;
6383 unsigned long address
;
6386 external
= (DWARF2_External_ARange
*) start
;
6388 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6389 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6390 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6391 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6392 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6394 printf (_(" Length: %ld\n"), arange
.ar_length
);
6395 printf (_(" Version: %d\n"), arange
.ar_version
);
6396 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6397 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6398 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6400 printf (_("\n Address Length\n"));
6402 ranges
= start
+ sizeof (* external
);
6404 /* Must pad to an alignment boundary that is twice the pointer size. */
6405 excess
= sizeof (*external
) % (2 * arange
.ar_pointer_size
);
6407 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6411 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6413 ranges
+= arange
.ar_pointer_size
;
6415 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6417 ranges
+= arange
.ar_pointer_size
;
6419 /* A pair of zeros marks the end of the list. */
6420 if (address
== 0 && length
== 0)
6423 printf (" %8.8lx %lu\n", address
, length
);
6426 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6436 display_debug_not_supported (section
, start
, file
)
6437 Elf32_Internal_Shdr
* section
;
6438 unsigned char * start ATTRIBUTE_UNUSED
;
6439 FILE * file ATTRIBUTE_UNUSED
;
6441 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
6442 SECTION_NAME (section
));
6447 /* Pre-scan the .debug_info section to record the size of address.
6448 When dumping the .debug_line, we use that size information, assuming
6449 that all compilation units have the same address size. */
6451 prescan_debug_info (section
, start
, file
)
6452 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
6453 unsigned char * start
;
6454 FILE * file ATTRIBUTE_UNUSED
;
6456 DWARF2_External_CompUnit
* external
;
6458 external
= (DWARF2_External_CompUnit
*) start
;
6460 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6464 /* A structure containing the name of a debug section and a pointer
6465 to a function that can decode it. The third field is a prescan
6466 function to be run over the section before displaying any of the
6471 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6472 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
6476 { ".debug_info", display_debug_info
, prescan_debug_info
},
6477 { ".debug_abbrev", display_debug_abbrev
, NULL
},
6478 { ".debug_line", display_debug_lines
, NULL
},
6479 { ".debug_aranges", display_debug_aranges
, NULL
},
6480 { ".debug_pubnames", display_debug_pubnames
, NULL
},
6481 { ".debug_macinfo", display_debug_not_supported
, NULL
},
6482 { ".debug_frame", display_debug_not_supported
, NULL
},
6483 { ".debug_str", display_debug_not_supported
, NULL
},
6484 { ".debug_static_func", display_debug_not_supported
, NULL
},
6485 { ".debug_static_vars", display_debug_not_supported
, NULL
},
6486 { ".debug_types", display_debug_not_supported
, NULL
},
6487 { ".debug_weaknames", display_debug_not_supported
, NULL
}
6491 display_debug_section (section
, file
)
6492 Elf32_Internal_Shdr
* section
;
6495 char * name
= SECTION_NAME (section
);
6496 bfd_size_type length
;
6497 unsigned char * start
;
6500 length
= section
->sh_size
;
6503 printf (_("\nSection '%s' has no debugging data.\n"), name
);
6507 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6508 "debug section data");
6510 /* See if we know how to display the contents of this section. */
6511 for (i
= NUM_ELEM (debug_displays
); i
--;)
6512 if (strcmp (debug_displays
[i
].name
, name
) == 0)
6514 debug_displays
[i
].display (section
, start
, file
);
6519 printf (_("Unrecognised debug section: %s\n"), name
);
6523 /* If we loaded in the abbrev section at some point,
6524 we must release it here. */
6525 if (first_abbrev
!= NULL
)
6532 process_section_contents (file
)
6535 Elf32_Internal_Shdr
* section
;
6541 /* Pre-scan the debug sections to find some debug information not
6542 present in some of them. For the .debug_line, we must find out the
6543 size of address (specified in .debug_info and .debug_aranges). */
6544 for (i
= 0, section
= section_headers
;
6545 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6548 char * name
= SECTION_NAME (section
);
6551 if (section
->sh_size
== 0)
6554 /* See if there is some pre-scan operation for this section. */
6555 for (j
= NUM_ELEM (debug_displays
); j
--;)
6556 if (strcmp (debug_displays
[j
].name
, name
) == 0)
6558 if (debug_displays
[j
].prescan
!= NULL
)
6560 bfd_size_type length
;
6561 unsigned char * start
;
6563 length
= section
->sh_size
;
6564 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
6565 "debug section data");
6567 debug_displays
[j
].prescan (section
, start
, file
);
6575 for (i
= 0, section
= section_headers
;
6576 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
6579 #ifdef SUPPORT_DISASSEMBLY
6580 if (dump_sects
[i
] & DISASS_DUMP
)
6581 disassemble_section (section
, file
);
6583 if (dump_sects
[i
] & HEX_DUMP
)
6584 dump_section (section
, file
);
6586 if (dump_sects
[i
] & DEBUG_DUMP
)
6587 display_debug_section (section
, file
);
6590 if (i
< num_dump_sects
)
6591 warn (_("Some sections were not dumped because they do not exist!\n"));
6597 process_mips_fpe_exception (mask
)
6603 if (mask
& OEX_FPU_INEX
)
6604 fputs ("INEX", stdout
), first
= 0;
6605 if (mask
& OEX_FPU_UFLO
)
6606 printf ("%sUFLO", first
? "" : "|"), first
= 0;
6607 if (mask
& OEX_FPU_OFLO
)
6608 printf ("%sOFLO", first
? "" : "|"), first
= 0;
6609 if (mask
& OEX_FPU_DIV0
)
6610 printf ("%sDIV0", first
? "" : "|"), first
= 0;
6611 if (mask
& OEX_FPU_INVAL
)
6612 printf ("%sINVAL", first
? "" : "|");
6615 fputs ("0", stdout
);
6619 process_mips_specific (file
)
6622 Elf_Internal_Dyn
* entry
;
6623 size_t liblist_offset
= 0;
6624 size_t liblistno
= 0;
6625 size_t conflictsno
= 0;
6626 size_t options_offset
= 0;
6627 size_t conflicts_offset
= 0;
6629 /* We have a lot of special sections. Thanks SGI! */
6630 if (dynamic_segment
== NULL
)
6631 /* No information available. */
6634 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
6635 switch (entry
->d_tag
)
6637 case DT_MIPS_LIBLIST
:
6638 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
6640 case DT_MIPS_LIBLISTNO
:
6641 liblistno
= entry
->d_un
.d_val
;
6643 case DT_MIPS_OPTIONS
:
6644 options_offset
= entry
->d_un
.d_val
- loadaddr
;
6646 case DT_MIPS_CONFLICT
:
6647 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
6649 case DT_MIPS_CONFLICTNO
:
6650 conflictsno
= entry
->d_un
.d_val
;
6656 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
6658 Elf32_External_Lib
* elib
;
6661 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
6662 elib
, Elf32_External_Lib
*, "liblist");
6664 printf ("\nSection '.liblist' contains %lu entries:\n",
6665 (unsigned long) liblistno
);
6666 fputs (" Library Time Stamp Checksum Version Flags\n",
6669 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
6676 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
6677 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
6678 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
6679 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
6680 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
6682 tmp
= gmtime (&time
);
6683 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
6684 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
6685 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
6687 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
6688 dynamic_strings
+ liblist
.l_name
, timebuf
,
6689 liblist
.l_checksum
, liblist
.l_version
);
6691 if (liblist
.l_flags
== 0)
6702 { " EXACT_MATCH", LL_EXACT_MATCH
},
6703 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
6704 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
6705 { " EXPORTS", LL_EXPORTS
},
6706 { " DELAY_LOAD", LL_DELAY_LOAD
},
6707 { " DELTA", LL_DELTA
}
6709 int flags
= liblist
.l_flags
;
6713 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
6715 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
6717 fputs (l_flags_vals
[fcnt
].name
, stdout
);
6718 flags
^= l_flags_vals
[fcnt
].bit
;
6721 printf (" %#x", (unsigned int) flags
);
6730 if (options_offset
!= 0)
6732 Elf_External_Options
* eopt
;
6733 Elf_Internal_Shdr
* sect
= section_headers
;
6734 Elf_Internal_Options
* iopt
;
6735 Elf_Internal_Options
* option
;
6739 /* Find the section header so that we get the size. */
6740 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
6743 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
6744 Elf_External_Options
*, "options");
6746 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
6750 error (_("Out of memory"));
6757 while (offset
< sect
->sh_size
)
6759 Elf_External_Options
* eoption
;
6761 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
6763 option
->kind
= BYTE_GET (eoption
->kind
);
6764 option
->size
= BYTE_GET (eoption
->size
);
6765 option
->section
= BYTE_GET (eoption
->section
);
6766 option
->info
= BYTE_GET (eoption
->info
);
6768 offset
+= option
->size
;
6774 printf (_("\nSection '%s' contains %d entries:\n"),
6775 string_table
+ sect
->sh_name
, cnt
);
6783 switch (option
->kind
)
6786 /* This shouldn't happen. */
6787 printf (" NULL %d %lx", option
->section
, option
->info
);
6790 printf (" REGINFO ");
6791 if (elf_header
.e_machine
== EM_MIPS
)
6794 Elf32_External_RegInfo
*ereg
;
6795 Elf32_RegInfo reginfo
;
6797 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
6798 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6799 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6800 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6801 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6802 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6803 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
6805 printf ("GPR %08lx GP 0x%lx\n",
6807 (unsigned long) reginfo
.ri_gp_value
);
6808 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6809 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6810 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6815 Elf64_External_RegInfo
* ereg
;
6816 Elf64_Internal_RegInfo reginfo
;
6818 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
6819 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
6820 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
6821 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
6822 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
6823 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
6824 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
6826 printf ("GPR %08lx GP 0x",
6827 reginfo
.ri_gprmask
);
6828 printf_vma (reginfo
.ri_gp_value
);
6831 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
6832 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
6833 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
6837 case ODK_EXCEPTIONS
:
6838 fputs (" EXCEPTIONS fpe_min(", stdout
);
6839 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
6840 fputs (") fpe_max(", stdout
);
6841 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
6842 fputs (")", stdout
);
6844 if (option
->info
& OEX_PAGE0
)
6845 fputs (" PAGE0", stdout
);
6846 if (option
->info
& OEX_SMM
)
6847 fputs (" SMM", stdout
);
6848 if (option
->info
& OEX_FPDBUG
)
6849 fputs (" FPDBUG", stdout
);
6850 if (option
->info
& OEX_DISMISS
)
6851 fputs (" DISMISS", stdout
);
6854 fputs (" PAD ", stdout
);
6855 if (option
->info
& OPAD_PREFIX
)
6856 fputs (" PREFIX", stdout
);
6857 if (option
->info
& OPAD_POSTFIX
)
6858 fputs (" POSTFIX", stdout
);
6859 if (option
->info
& OPAD_SYMBOL
)
6860 fputs (" SYMBOL", stdout
);
6863 fputs (" HWPATCH ", stdout
);
6864 if (option
->info
& OHW_R4KEOP
)
6865 fputs (" R4KEOP", stdout
);
6866 if (option
->info
& OHW_R8KPFETCH
)
6867 fputs (" R8KPFETCH", stdout
);
6868 if (option
->info
& OHW_R5KEOP
)
6869 fputs (" R5KEOP", stdout
);
6870 if (option
->info
& OHW_R5KCVTL
)
6871 fputs (" R5KCVTL", stdout
);
6874 fputs (" FILL ", stdout
);
6875 /* XXX Print content of info word? */
6878 fputs (" TAGS ", stdout
);
6879 /* XXX Print content of info word? */
6882 fputs (" HWAND ", stdout
);
6883 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6884 fputs (" R4KEOP_CHECKED", stdout
);
6885 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6886 fputs (" R4KEOP_CLEAN", stdout
);
6889 fputs (" HWOR ", stdout
);
6890 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
6891 fputs (" R4KEOP_CHECKED", stdout
);
6892 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
6893 fputs (" R4KEOP_CLEAN", stdout
);
6896 printf (" GP_GROUP %#06lx self-contained %#06lx",
6897 option
->info
& OGP_GROUP
,
6898 (option
->info
& OGP_SELF
) >> 16);
6901 printf (" IDENT %#06lx self-contained %#06lx",
6902 option
->info
& OGP_GROUP
,
6903 (option
->info
& OGP_SELF
) >> 16);
6906 /* This shouldn't happen. */
6907 printf (" %3d ??? %d %lx",
6908 option
->kind
, option
->section
, option
->info
);
6912 len
= sizeof (*eopt
);
6913 while (len
< option
->size
)
6914 if (((char *) option
)[len
] >= ' '
6915 && ((char *) option
)[len
] < 0x7f)
6916 printf ("%c", ((char *) option
)[len
++]);
6918 printf ("\\%03o", ((char *) option
)[len
++]);
6920 fputs ("\n", stdout
);
6927 if (conflicts_offset
!= 0 && conflictsno
!= 0)
6929 Elf32_External_Conflict
* econf32
;
6930 Elf64_External_Conflict
* econf64
;
6931 Elf32_Conflict
* iconf
;
6934 if (dynamic_symbols
== NULL
)
6936 error (_("conflict list with without table"));
6940 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (*iconf
));
6943 error (_("Out of memory"));
6949 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf32
),
6950 econf32
, Elf32_External_Conflict
*, "conflict");
6952 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6953 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
6957 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (*econf64
),
6958 econf64
, Elf64_External_Conflict
*, "conflict");
6960 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6961 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
6964 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
6965 puts (_(" Num: Index Value Name"));
6967 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
6969 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
6971 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
6972 print_vma (psym
->st_value
, FULL_HEX
);
6973 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
6983 get_note_type (e_type
)
6986 static char buff
[64];
6990 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
6991 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
6992 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
6993 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
6994 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
6995 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
6996 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
6997 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
6998 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
6999 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
7000 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
7002 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
7007 /* Note that by the ELF standard, the name field is already null byte
7008 terminated, and namesz includes the terminating null byte.
7009 I.E. the value of namesz for the name "FSF" is 4.
7011 If the value of namesz is zero, there is no name present. */
7013 process_note (pnote
)
7014 Elf32_Internal_Note
* pnote
;
7016 printf (" %s\t\t0x%08lx\t%s\n",
7017 pnote
->namesz
? pnote
->namedata
: "(NONE)",
7018 pnote
->descsz
, get_note_type (pnote
->type
));
7024 process_corefile_note_segment (file
, offset
, length
)
7029 Elf_External_Note
* pnotes
;
7030 Elf_External_Note
* external
;
7036 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
7040 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
7041 (unsigned long) offset
, (unsigned long) length
);
7042 printf (_(" Owner\t\tData size\tDescription\n"));
7044 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
7046 Elf32_Internal_Note inote
;
7049 inote
.type
= BYTE_GET (external
->type
);
7050 inote
.namesz
= BYTE_GET (external
->namesz
);
7051 inote
.namedata
= external
->name
;
7052 inote
.descsz
= BYTE_GET (external
->descsz
);
7053 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
7054 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
7056 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
7058 /* Verify that name is null terminated. It appears that at least
7059 one version of Linux (RedHat 6.0) generates corefiles that don't
7060 comply with the ELF spec by failing to include the null byte in
7062 if (inote
.namedata
[inote
.namesz
] != '\0')
7064 temp
= malloc (inote
.namesz
+ 1);
7068 error (_("Out of memory\n"));
7073 strncpy (temp
, inote
.namedata
, inote
.namesz
);
7074 temp
[inote
.namesz
] = 0;
7076 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
7077 inote
.namedata
= temp
;
7080 res
&= process_note (& inote
);
7095 process_corefile_note_segments (file
)
7098 Elf_Internal_Phdr
* program_headers
;
7099 Elf_Internal_Phdr
* segment
;
7103 program_headers
= (Elf_Internal_Phdr
*) malloc
7104 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
7106 if (program_headers
== NULL
)
7108 error (_("Out of memory\n"));
7113 i
= get_32bit_program_headers (file
, program_headers
);
7115 i
= get_64bit_program_headers (file
, program_headers
);
7119 free (program_headers
);
7123 for (i
= 0, segment
= program_headers
;
7124 i
< elf_header
.e_phnum
;
7127 if (segment
->p_type
== PT_NOTE
)
7128 res
&= process_corefile_note_segment (file
,
7129 (bfd_vma
) segment
->p_offset
,
7130 (bfd_vma
) segment
->p_filesz
);
7133 free (program_headers
);
7139 process_corefile_contents (file
)
7142 /* If we have not been asked to display the notes then do nothing. */
7146 /* If file is not a core file then exit. */
7147 if (elf_header
.e_type
!= ET_CORE
)
7150 /* No program headers means no NOTE segment. */
7151 if (elf_header
.e_phnum
== 0)
7153 printf (_("No note segments present in the core file.\n"));
7157 return process_corefile_note_segments (file
);
7161 process_arch_specific (file
)
7167 switch (elf_header
.e_machine
)
7170 case EM_MIPS_RS4_BE
:
7171 return process_mips_specific (file
);
7180 get_file_header (file
)
7183 /* Read in the identity array. */
7184 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
7187 /* Determine how to read the rest of the header. */
7188 switch (elf_header
.e_ident
[EI_DATA
])
7190 default: /* fall through */
7191 case ELFDATANONE
: /* fall through */
7192 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
7193 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
7196 /* For now we only support 32 bit and 64 bit ELF files. */
7197 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
7199 /* Read in the rest of the header. */
7202 Elf32_External_Ehdr ehdr32
;
7204 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
7207 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
7208 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
7209 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
7210 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
7211 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
7212 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
7213 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
7214 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
7215 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
7216 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
7217 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
7218 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
7219 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
7223 Elf64_External_Ehdr ehdr64
;
7225 /* If we have been compiled with sizeof (bfd_vma) == 4, then
7226 we will not be able to cope with the 64bit data found in
7227 64 ELF files. Detect this now and abort before we start
7228 overwritting things. */
7229 if (sizeof (bfd_vma
) < 8)
7231 error (_("This instance of readelf has been built without support for a\n"));
7232 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
7236 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
7239 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
7240 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
7241 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
7242 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
7243 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
7244 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
7245 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
7246 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
7247 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
7248 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
7249 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
7250 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
7251 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
7258 process_file (file_name
)
7262 struct stat statbuf
;
7265 if (stat (file_name
, & statbuf
) < 0)
7267 error (_("Cannot stat input file %s.\n"), file_name
);
7271 file
= fopen (file_name
, "rb");
7274 error (_("Input file %s not found.\n"), file_name
);
7278 if (! get_file_header (file
))
7280 error (_("%s: Failed to read file header\n"), file_name
);
7285 /* Initialise per file variables. */
7286 for (i
= NUM_ELEM (version_info
); i
--;)
7287 version_info
[i
] = 0;
7289 for (i
= NUM_ELEM (dynamic_info
); i
--;)
7290 dynamic_info
[i
] = 0;
7292 /* Process the file. */
7294 printf (_("\nFile: %s\n"), file_name
);
7296 if (! process_file_header ())
7302 process_section_headers (file
);
7304 process_program_headers (file
);
7306 process_dynamic_segment (file
);
7308 process_relocs (file
);
7310 process_symbol_table (file
);
7312 process_syminfo (file
);
7314 process_version_sections (file
);
7316 process_section_contents (file
);
7318 process_corefile_contents (file
);
7320 process_arch_specific (file
);
7324 if (section_headers
)
7326 free (section_headers
);
7327 section_headers
= NULL
;
7332 free (string_table
);
7333 string_table
= NULL
;
7336 if (dynamic_strings
)
7338 free (dynamic_strings
);
7339 dynamic_strings
= NULL
;
7342 if (dynamic_symbols
)
7344 free (dynamic_symbols
);
7345 dynamic_symbols
= NULL
;
7346 num_dynamic_syms
= 0;
7349 if (dynamic_syminfo
)
7351 free (dynamic_syminfo
);
7352 dynamic_syminfo
= NULL
;
7356 #ifdef SUPPORT_DISASSEMBLY
7357 /* Needed by the i386 disassembler. For extra credit, someone could
7358 fix this so that we insert symbolic addresses here, esp for GOT/PLT
7362 print_address (unsigned int addr
, FILE * outfile
)
7364 fprintf (outfile
,"0x%8.8x", addr
);
7367 /* Needed by the i386 disassembler. */
7369 db_task_printsym (unsigned int addr
)
7371 print_address (addr
, stderr
);
7380 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
7381 setlocale (LC_MESSAGES
, "");
7383 bindtextdomain (PACKAGE
, LOCALEDIR
);
7384 textdomain (PACKAGE
);
7386 parse_args (argc
, argv
);
7388 if (optind
< (argc
- 1))
7391 while (optind
< argc
)
7392 process_file (argv
[optind
++]);
7394 if (dump_sects
!= NULL
)