1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001 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"
76 #include "elf/x86-64.h"
82 char * program_name
= "readelf";
83 unsigned int dynamic_addr
;
84 bfd_size_type dynamic_size
;
85 unsigned int rela_addr
;
86 unsigned int rela_size
;
87 char * dynamic_strings
;
89 unsigned long string_table_length
;
90 unsigned long num_dynamic_syms
;
91 Elf_Internal_Sym
* dynamic_symbols
;
92 Elf_Internal_Syminfo
* dynamic_syminfo
;
93 unsigned long dynamic_syminfo_offset
;
94 unsigned int dynamic_syminfo_nent
;
95 char program_interpreter
[64];
96 int dynamic_info
[DT_JMPREL
+ 1];
99 Elf_Internal_Ehdr elf_header
;
100 Elf_Internal_Shdr
* section_headers
;
101 Elf_Internal_Dyn
* dynamic_segment
;
109 int do_using_dynamic
;
116 int do_debug_abbrevs
;
118 int do_debug_pubnames
;
119 int do_debug_aranges
;
125 /* A dynamic array of flags indicating which sections require dumping. */
126 char * dump_sects
= NULL
;
127 unsigned int num_dump_sects
= 0;
129 #define HEX_DUMP (1 << 0)
130 #define DISASS_DUMP (1 << 1)
131 #define DEBUG_DUMP (1 << 2)
133 /* How to rpint a vma value. */
134 typedef enum print_mode
146 /* Forward declarations for dumb compilers. */
147 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
148 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
149 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
150 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
151 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
152 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
153 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
154 static const char * get_dynamic_type
PARAMS ((unsigned long));
155 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
156 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
157 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
158 static char * get_file_type
PARAMS ((unsigned));
159 static char * get_machine_name
PARAMS ((unsigned));
160 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
161 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
162 static const char * get_mips_segment_type
PARAMS ((unsigned long));
163 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
164 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
165 static const char * get_segment_type
PARAMS ((unsigned long));
166 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
167 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
168 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
169 static const char * get_section_type_name
PARAMS ((unsigned int));
170 static const char * get_symbol_binding
PARAMS ((unsigned int));
171 static const char * get_symbol_type
PARAMS ((unsigned int));
172 static const char * get_symbol_visibility
PARAMS ((unsigned int));
173 static const char * get_symbol_index_type
PARAMS ((unsigned int));
174 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
175 static void usage
PARAMS ((void));
176 static void parse_args
PARAMS ((int, char **));
177 static int process_file_header
PARAMS ((void));
178 static int process_program_headers
PARAMS ((FILE *));
179 static int process_section_headers
PARAMS ((FILE *));
180 static int process_unwind
PARAMS ((FILE *));
181 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
182 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
183 static int process_dynamic_segment
PARAMS ((FILE *));
184 static int process_symbol_table
PARAMS ((FILE *));
185 static int process_section_contents
PARAMS ((FILE *));
186 static void process_file
PARAMS ((char *));
187 static int process_relocs
PARAMS ((FILE *));
188 static int process_version_sections
PARAMS ((FILE *));
189 static char * get_ver_flags
PARAMS ((unsigned int));
190 static int get_32bit_section_headers
PARAMS ((FILE *));
191 static int get_64bit_section_headers
PARAMS ((FILE *));
192 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
193 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
194 static int get_file_header
PARAMS ((FILE *));
195 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
196 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
197 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
198 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
199 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
200 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
201 #ifdef SUPPORT_DISASSEMBLY
202 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
204 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
205 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
206 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
207 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
208 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
209 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
210 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
211 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
212 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
213 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
214 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
215 static void reset_state_machine
PARAMS ((int));
216 static char * get_TAG_name
PARAMS ((unsigned long));
217 static char * get_AT_name
PARAMS ((unsigned long));
218 static char * get_FORM_name
PARAMS ((unsigned long));
219 static void free_abbrevs
PARAMS ((void));
220 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
221 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
222 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
223 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
224 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
225 static void request_dump
PARAMS ((unsigned int, char));
226 static const char * get_elf_class
PARAMS ((unsigned char));
227 static const char * get_data_encoding
PARAMS ((unsigned char));
228 static const char * get_osabi_name
PARAMS ((unsigned char));
229 static int guess_is_rela
PARAMS ((unsigned long));
230 static char * get_note_type
PARAMS ((unsigned int));
231 static int process_note
PARAMS ((Elf32_Internal_Note
*));
232 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
233 static int process_corefile_note_segments
PARAMS ((FILE *));
234 static int process_corefile_contents
PARAMS ((FILE *));
236 typedef int Elf32_Word
;
244 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
245 ((X)->sh_name >= string_table_length \
246 ? "<corrupt>" : string_table + (X)->sh_name))
248 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
250 #define BYTE_GET(field) byte_get (field, sizeof (field))
252 /* If we can support a 64 bit data type then BFD64 should be defined
253 and sizeof (bfd_vma) == 8. In this case when translating from an
254 external 8 byte field to an internal field, we can assume that the
255 internal field is also 8 bytes wide and so we can extract all the data.
256 If, however, BFD64 is not defined, then we must assume that the
257 internal data structure only has 4 byte wide fields that are the
258 equivalent of the 8 byte wide external counterparts, and so we must
259 truncate the data. */
261 #define BYTE_GET8(field) byte_get (field, -8)
263 #define BYTE_GET8(field) byte_get (field, 8)
266 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
268 #define GET_DATA_ALLOC(offset, size, var, type, reason) \
269 if (fseek (file, offset, SEEK_SET)) \
271 error (_("Unable to seek to start of %s at %x\n"), reason, offset); \
275 var = (type) malloc (size); \
279 error (_("Out of memory allocating %d bytes for %s\n"), size, reason); \
283 if (fread (var, size, 1, file) != 1) \
285 error (_("Unable to read in %d bytes of %s\n"), size, reason); \
292 #define GET_DATA(offset, var, reason) \
293 if (fseek (file, offset, SEEK_SET)) \
295 error (_("Unable to seek to %x for %s\n"), offset, reason); \
298 else if (fread (& var, sizeof (var), 1, file) != 1) \
300 error (_("Unable to read data at %x for %s\n"), offset, reason); \
304 #define GET_ELF_SYMBOLS(file, offset, size) \
305 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
306 : get_64bit_elf_symbols (file, offset, size))
309 #ifdef ANSI_PROTOTYPES
311 error (const char * message
, ...)
315 fprintf (stderr
, _("%s: Error: "), program_name
);
316 va_start (args
, message
);
317 vfprintf (stderr
, message
, args
);
323 warn (const char * message
, ...)
327 fprintf (stderr
, _("%s: Warning: "), program_name
);
328 va_start (args
, message
);
329 vfprintf (stderr
, message
, args
);
341 fprintf (stderr
, _("%s: Error: "), program_name
);
343 message
= va_arg (args
, char *);
344 vfprintf (stderr
, message
, args
);
356 fprintf (stderr
, _("%s: Warning: "), program_name
);
358 message
= va_arg (args
, char *);
359 vfprintf (stderr
, message
, args
);
366 byte_get_little_endian (field
, size
)
367 unsigned char * field
;
376 return ((unsigned int) (field
[0]))
377 | (((unsigned int) (field
[1])) << 8);
380 /* We want to extract data from an 8 byte wide field and
381 place it into a 4 byte wide field. Since this is a little
382 endian source we can juts use the 4 byte extraction code. */
385 return ((unsigned long) (field
[0]))
386 | (((unsigned long) (field
[1])) << 8)
387 | (((unsigned long) (field
[2])) << 16)
388 | (((unsigned long) (field
[3])) << 24);
392 /* This is a special case, generated by the BYTE_GET8 macro.
393 It means that we are loading an 8 byte value from a field
394 in an external structure into an 8 byte value in a field
395 in an internal strcuture. */
396 return ((bfd_vma
) (field
[0]))
397 | (((bfd_vma
) (field
[1])) << 8)
398 | (((bfd_vma
) (field
[2])) << 16)
399 | (((bfd_vma
) (field
[3])) << 24)
400 | (((bfd_vma
) (field
[4])) << 32)
401 | (((bfd_vma
) (field
[5])) << 40)
402 | (((bfd_vma
) (field
[6])) << 48)
403 | (((bfd_vma
) (field
[7])) << 56);
406 error (_("Unhandled data length: %d\n"), size
);
411 /* Print a VMA value. */
413 print_vma (vma
, mode
)
423 case FULL_HEX
: printf ("0x"); /* drop through */
424 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
425 case PREFIX_HEX
: printf ("0x"); /* drop through */
426 case HEX
: printf ("%lx", (unsigned long) vma
); break;
427 case DEC
: printf ("%ld", (unsigned long) vma
); break;
428 case DEC_5
: printf ("%5ld", (long) vma
); break;
429 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
450 #if BFD_HOST_64BIT_LONG
453 if (_bfd_int64_high (vma
))
454 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
456 printf ("%lx", _bfd_int64_low (vma
));
461 #if BFD_HOST_64BIT_LONG
464 if (_bfd_int64_high (vma
))
466 printf ("++%ld", _bfd_int64_low (vma
));
468 printf ("%ld", _bfd_int64_low (vma
));
473 #if BFD_HOST_64BIT_LONG
474 printf ("%5ld", vma
);
476 if (_bfd_int64_high (vma
))
478 printf ("++%ld", _bfd_int64_low (vma
));
480 printf ("%5ld", _bfd_int64_low (vma
));
485 #if BFD_HOST_64BIT_LONG
488 if (_bfd_int64_high (vma
))
490 printf ("++%lu", _bfd_int64_low (vma
));
492 printf ("%lu", _bfd_int64_low (vma
));
501 byte_get_big_endian (field
, size
)
502 unsigned char * field
;
511 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
514 return ((unsigned long) (field
[3]))
515 | (((unsigned long) (field
[2])) << 8)
516 | (((unsigned long) (field
[1])) << 16)
517 | (((unsigned long) (field
[0])) << 24);
520 /* Although we are extracing data from an 8 byte wide field, we
521 are returning only 4 bytes of data. */
522 return ((unsigned long) (field
[7]))
523 | (((unsigned long) (field
[6])) << 8)
524 | (((unsigned long) (field
[5])) << 16)
525 | (((unsigned long) (field
[4])) << 24);
529 /* This is a special case, generated by the BYTE_GET8 macro.
530 It means that we are loading an 8 byte value from a field
531 in an external structure into an 8 byte value in a field
532 in an internal strcuture. */
533 return ((bfd_vma
) (field
[7]))
534 | (((bfd_vma
) (field
[6])) << 8)
535 | (((bfd_vma
) (field
[5])) << 16)
536 | (((bfd_vma
) (field
[4])) << 24)
537 | (((bfd_vma
) (field
[3])) << 32)
538 | (((bfd_vma
) (field
[2])) << 40)
539 | (((bfd_vma
) (field
[1])) << 48)
540 | (((bfd_vma
) (field
[0])) << 56);
544 error (_("Unhandled data length: %d\n"), size
);
549 /* Guess the relocation size commonly used by the specific machines. */
552 guess_is_rela (e_machine
)
553 unsigned long e_machine
;
557 /* Targets that use REL relocations. */
568 /* Targets that use RELA relocations. */
576 case EM_CYGNUS_MN10200
:
577 case EM_CYGNUS_MN10300
:
610 warn (_("Don't know about relocations on this machine architecture\n"));
616 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
618 unsigned long rel_offset
;
619 unsigned long rel_size
;
620 Elf_Internal_Rela
**relasp
;
621 unsigned long *nrelasp
;
623 Elf_Internal_Rela
*relas
;
624 unsigned long nrelas
;
629 Elf32_External_Rela
* erelas
;
631 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
632 Elf32_External_Rela
*, "relocs");
634 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
636 relas
= (Elf_Internal_Rela
*)
637 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
641 error(_("out of memory parsing relocs"));
645 for (i
= 0; i
< nrelas
; i
++)
647 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
648 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
649 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
656 Elf64_External_Rela
* erelas
;
658 GET_DATA_ALLOC (rel_offset
, rel_size
, erelas
,
659 Elf64_External_Rela
*, "relocs");
661 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
663 relas
= (Elf_Internal_Rela
*)
664 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
668 error(_("out of memory parsing relocs"));
672 for (i
= 0; i
< nrelas
; i
++)
674 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
675 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
676 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
687 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
689 unsigned long rel_offset
;
690 unsigned long rel_size
;
691 Elf_Internal_Rel
**relsp
;
692 unsigned long *nrelsp
;
694 Elf_Internal_Rel
*rels
;
700 Elf32_External_Rel
* erels
;
702 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
703 Elf32_External_Rel
*, "relocs");
705 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
707 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
711 error(_("out of memory parsing relocs"));
715 for (i
= 0; i
< nrels
; i
++)
717 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
718 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
725 Elf64_External_Rel
* erels
;
727 GET_DATA_ALLOC (rel_offset
, rel_size
, erels
,
728 Elf64_External_Rel
*, "relocs");
730 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
732 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
736 error(_("out of memory parsing relocs"));
740 for (i
= 0; i
< nrels
; i
++)
742 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
743 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
753 /* Display the contents of the relocation data found at the specified offset. */
755 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
757 unsigned long rel_offset
;
758 unsigned long rel_size
;
759 Elf_Internal_Sym
* symtab
;
765 Elf_Internal_Rel
* rels
;
766 Elf_Internal_Rela
* relas
;
769 if (is_rela
== UNKNOWN
)
770 is_rela
= guess_is_rela (elf_header
.e_machine
);
774 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
779 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
785 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
788 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
790 for (i
= 0; i
< rel_size
; i
++)
795 bfd_vma symtab_index
;
800 offset
= relas
[i
].r_offset
;
801 info
= relas
[i
].r_info
;
805 offset
= rels
[i
].r_offset
;
806 info
= rels
[i
].r_info
;
811 type
= ELF32_R_TYPE (info
);
812 symtab_index
= ELF32_R_SYM (info
);
816 if (elf_header
.e_machine
== EM_SPARCV9
)
817 type
= ELF64_R_TYPE_ID (info
);
819 type
= ELF64_R_TYPE (info
);
820 /* The #ifdef BFD64 below is to prevent a compile time warning.
821 We know that if we do not have a 64 bit data type that we
822 will never execute this code anyway. */
824 symtab_index
= ELF64_R_SYM (info
);
828 #ifdef _bfd_int64_low
829 printf (" %8.8lx %5.5lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
831 printf (" %8.8lx %5.5lx ", offset
, info
);
834 switch (elf_header
.e_machine
)
841 rtype
= elf_m32r_reloc_type (type
);
846 rtype
= elf_i386_reloc_type (type
);
850 rtype
= elf_m68k_reloc_type (type
);
854 rtype
= elf_i960_reloc_type (type
);
858 rtype
= elf_avr_reloc_type (type
);
865 rtype
= elf_sparc_reloc_type (type
);
869 rtype
= v850_reloc_type (type
);
873 rtype
= elf_d10v_reloc_type (type
);
877 rtype
= elf_d30v_reloc_type (type
);
881 rtype
= elf_sh_reloc_type (type
);
884 case EM_CYGNUS_MN10300
:
885 rtype
= elf_mn10300_reloc_type (type
);
888 case EM_CYGNUS_MN10200
:
889 rtype
= elf_mn10200_reloc_type (type
);
893 rtype
= elf_fr30_reloc_type (type
);
897 rtype
= elf_mcore_reloc_type (type
);
901 rtype
= elf_ppc_reloc_type (type
);
906 rtype
= elf_mips_reloc_type (type
);
910 rtype
= elf_alpha_reloc_type (type
);
914 rtype
= elf_arm_reloc_type (type
);
919 rtype
= elf_arc_reloc_type (type
);
923 rtype
= elf_hppa_reloc_type (type
);
927 rtype
= elf_pj_reloc_type (type
);
930 rtype
= elf_ia64_reloc_type (type
);
934 rtype
= elf_cris_reloc_type (type
);
938 rtype
= elf_i860_reloc_type (type
);
942 rtype
= elf_x86_64_reloc_type (type
);
947 rtype
= elf_s390_reloc_type (type
);
952 #ifdef _bfd_int64_low
953 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
955 printf (_("unrecognised: %-7lx"), type
);
958 printf ("%-21.21s", rtype
);
964 if (symtab_index
>= nsyms
)
965 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
968 Elf_Internal_Sym
* psym
;
970 psym
= symtab
+ symtab_index
;
973 print_vma (psym
->st_value
, LONG_HEX
);
976 if (psym
->st_name
== 0)
978 SECTION_NAME (section_headers
+ psym
->st_shndx
));
979 else if (strtab
== NULL
)
980 printf (_("<string table index %3ld>"), psym
->st_name
);
982 printf ("%-25.25s", strtab
+ psym
->st_name
);
985 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
991 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
992 print_vma (relas
[i
].r_addend
, LONG_HEX
);
995 if (elf_header
.e_machine
== EM_SPARCV9
996 && !strcmp (rtype
, "R_SPARC_OLO10"))
997 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1011 get_mips_dynamic_type (type
)
1016 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1017 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1018 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1019 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1020 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1021 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1022 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1023 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1024 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1025 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1026 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1027 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1028 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1029 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1030 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1031 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1032 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1033 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1034 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1035 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1036 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1037 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1038 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1039 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1040 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1041 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1042 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1043 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1044 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1045 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1046 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1047 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1048 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1049 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1050 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1051 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1052 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1053 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1054 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1055 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1056 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1057 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1058 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1065 get_sparc64_dynamic_type (type
)
1070 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1077 get_parisc_dynamic_type (type
)
1082 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1083 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1084 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1085 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1086 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1087 case DT_HP_PREINIT
: return "HP_PREINIT";
1088 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1089 case DT_HP_NEEDED
: return "HP_NEEDED";
1090 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1091 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1092 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1093 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1094 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1101 get_dynamic_type (type
)
1104 static char buff
[32];
1108 case DT_NULL
: return "NULL";
1109 case DT_NEEDED
: return "NEEDED";
1110 case DT_PLTRELSZ
: return "PLTRELSZ";
1111 case DT_PLTGOT
: return "PLTGOT";
1112 case DT_HASH
: return "HASH";
1113 case DT_STRTAB
: return "STRTAB";
1114 case DT_SYMTAB
: return "SYMTAB";
1115 case DT_RELA
: return "RELA";
1116 case DT_RELASZ
: return "RELASZ";
1117 case DT_RELAENT
: return "RELAENT";
1118 case DT_STRSZ
: return "STRSZ";
1119 case DT_SYMENT
: return "SYMENT";
1120 case DT_INIT
: return "INIT";
1121 case DT_FINI
: return "FINI";
1122 case DT_SONAME
: return "SONAME";
1123 case DT_RPATH
: return "RPATH";
1124 case DT_SYMBOLIC
: return "SYMBOLIC";
1125 case DT_REL
: return "REL";
1126 case DT_RELSZ
: return "RELSZ";
1127 case DT_RELENT
: return "RELENT";
1128 case DT_PLTREL
: return "PLTREL";
1129 case DT_DEBUG
: return "DEBUG";
1130 case DT_TEXTREL
: return "TEXTREL";
1131 case DT_JMPREL
: return "JMPREL";
1132 case DT_BIND_NOW
: return "BIND_NOW";
1133 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1134 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1135 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1136 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1137 case DT_RUNPATH
: return "RUNPATH";
1138 case DT_FLAGS
: return "FLAGS";
1140 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1141 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1143 case DT_CHECKSUM
: return "CHECKSUM";
1144 case DT_PLTPADSZ
: return "PLTPADSZ";
1145 case DT_MOVEENT
: return "MOVEENT";
1146 case DT_MOVESZ
: return "MOVESZ";
1147 case DT_FEATURE
: return "FEATURE";
1148 case DT_POSFLAG_1
: return "POSFLAG_1";
1149 case DT_SYMINSZ
: return "SYMINSZ";
1150 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1152 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1153 case DT_CONFIG
: return "CONFIG";
1154 case DT_DEPAUDIT
: return "DEPAUDIT";
1155 case DT_AUDIT
: return "AUDIT";
1156 case DT_PLTPAD
: return "PLTPAD";
1157 case DT_MOVETAB
: return "MOVETAB";
1158 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1160 case DT_VERSYM
: return "VERSYM";
1162 case DT_RELACOUNT
: return "RELACOUNT";
1163 case DT_RELCOUNT
: return "RELCOUNT";
1164 case DT_FLAGS_1
: return "FLAGS_1";
1165 case DT_VERDEF
: return "VERDEF";
1166 case DT_VERDEFNUM
: return "VERDEFNUM";
1167 case DT_VERNEED
: return "VERNEED";
1168 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1170 case DT_AUXILIARY
: return "AUXILIARY";
1171 case DT_USED
: return "USED";
1172 case DT_FILTER
: return "FILTER";
1175 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1177 const char * result
;
1179 switch (elf_header
.e_machine
)
1182 case EM_MIPS_RS4_BE
:
1183 result
= get_mips_dynamic_type (type
);
1186 result
= get_sparc64_dynamic_type (type
);
1196 sprintf (buff
, _("Processor Specific: %lx"), type
);
1198 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1200 const char * result
;
1202 switch (elf_header
.e_machine
)
1205 result
= get_parisc_dynamic_type (type
);
1215 sprintf (buff
, _("Operating System specific: %lx"), type
);
1218 sprintf (buff
, _("<unknown>: %lx"), type
);
1225 get_file_type (e_type
)
1228 static char buff
[32];
1232 case ET_NONE
: return _("NONE (None)");
1233 case ET_REL
: return _("REL (Relocatable file)");
1234 case ET_EXEC
: return _("EXEC (Executable file)");
1235 case ET_DYN
: return _("DYN (Shared object file)");
1236 case ET_CORE
: return _("CORE (Core file)");
1239 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1240 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1241 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1242 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1244 sprintf (buff
, _("<unknown>: %x"), e_type
);
1250 get_machine_name (e_machine
)
1253 static char buff
[64]; /* XXX */
1257 case EM_NONE
: return _("None");
1258 case EM_M32
: return "WE32100";
1259 case EM_SPARC
: return "Sparc";
1260 case EM_386
: return "Intel 80386";
1261 case EM_68K
: return "MC68000";
1262 case EM_88K
: return "MC88000";
1263 case EM_486
: return "Intel 80486";
1264 case EM_860
: return "Intel 80860";
1265 case EM_MIPS
: return "MIPS R3000";
1266 case EM_S370
: return "IBM System/370";
1267 case EM_MIPS_RS4_BE
: return "MIPS R4000 big-endian";
1268 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1269 case EM_PARISC
: return "HPPA";
1270 case EM_PPC_OLD
: return "Power PC (old)";
1271 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1272 case EM_960
: return "Intel 90860";
1273 case EM_PPC
: return "PowerPC";
1274 case EM_V800
: return "NEC V800";
1275 case EM_FR20
: return "Fujitsu FR20";
1276 case EM_RH32
: return "TRW RH32";
1277 case EM_MCORE
: return "MCORE";
1278 case EM_ARM
: return "ARM";
1279 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1280 case EM_SH
: return "Hitachi SH";
1281 case EM_SPARCV9
: return "Sparc v9";
1282 case EM_TRICORE
: return "Siemens Tricore";
1283 case EM_ARC
: return "ARC";
1284 case EM_H8_300
: return "Hitachi H8/300";
1285 case EM_H8_300H
: return "Hitachi H8/300H";
1286 case EM_H8S
: return "Hitachi H8S";
1287 case EM_H8_500
: return "Hitachi H8/500";
1288 case EM_IA_64
: return "Intel IA-64";
1289 case EM_MIPS_X
: return "Stanford MIPS-X";
1290 case EM_COLDFIRE
: return "Motorola Coldfire";
1291 case EM_68HC12
: return "Motorola M68HC12";
1292 case EM_ALPHA
: return "Alpha";
1293 case EM_CYGNUS_D10V
: return "d10v";
1294 case EM_CYGNUS_D30V
: return "d30v";
1295 case EM_CYGNUS_ARC
: return "ARC";
1296 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1297 case EM_CYGNUS_V850
: return "NEC v850";
1298 case EM_CYGNUS_MN10300
: return "mn10300";
1299 case EM_CYGNUS_MN10200
: return "mn10200";
1300 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1301 case EM_PJ
: return "picoJava";
1302 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1303 case EM_PCP
: return "Siemens PCP";
1304 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1305 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1306 case EM_STARCORE
: return "Motorola Star*Core processor";
1307 case EM_ME16
: return "Toyota ME16 processor";
1308 case EM_ST100
: return "STMicroelectronics ST100 processor";
1309 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1310 case EM_FX66
: return "Siemens FX66 microcontroller";
1311 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1312 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1313 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1314 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1315 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1316 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1317 case EM_SVX
: return "Silicon Graphics SVx";
1318 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1319 case EM_VAX
: return "Digital VAX";
1320 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1321 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1322 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1323 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1324 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1325 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1326 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1327 case EM_PRISM
: return "SiTera Prism";
1328 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1330 case EM_S390
: return "IBM S/390";
1332 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1338 decode_ARM_machine_flags (e_flags
, buf
)
1345 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1346 e_flags
&= ~ EF_ARM_EABIMASK
;
1348 /* Handle "generic" ARM flags. */
1349 if (e_flags
& EF_ARM_RELEXEC
)
1351 strcat (buf
, ", relocatable executable");
1352 e_flags
&= ~ EF_ARM_RELEXEC
;
1355 if (e_flags
& EF_ARM_HASENTRY
)
1357 strcat (buf
, ", has entry point");
1358 e_flags
&= ~ EF_ARM_HASENTRY
;
1361 /* Now handle EABI specific flags. */
1365 strcat (buf
, ", <unrecognised EABI>");
1370 case EF_ARM_EABI_VER1
:
1371 strcat (buf
, ", Version1 EABI");
1376 /* Process flags one bit at a time. */
1377 flag
= e_flags
& - e_flags
;
1382 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1383 strcat (buf
, ", sorted symbol tables");
1393 case EF_ARM_EABI_VER2
:
1394 strcat (buf
, ", Version2 EABI");
1399 /* Process flags one bit at a time. */
1400 flag
= e_flags
& - e_flags
;
1405 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1406 strcat (buf
, ", sorted symbol tables");
1409 case EF_ARM_DYNSYMSUSESEGIDX
:
1410 strcat (buf
, ", dynamic symbols use segment index");
1413 case EF_ARM_MAPSYMSFIRST
:
1414 strcat (buf
, ", mapping symbols precede others");
1424 case EF_ARM_EABI_UNKNOWN
:
1425 strcat (buf
, ", GNU EABI");
1430 /* Process flags one bit at a time. */
1431 flag
= e_flags
& - e_flags
;
1436 case EF_ARM_INTERWORK
:
1437 strcat (buf
, ", interworking enabled");
1440 case EF_ARM_APCS_26
:
1441 strcat (buf
, ", uses APCS/26");
1444 case EF_ARM_APCS_FLOAT
:
1445 strcat (buf
, ", uses APCS/float");
1449 strcat (buf
, ", position independent");
1453 strcat (buf
, ", 8 bit structure alignment");
1456 case EF_ARM_NEW_ABI
:
1457 strcat (buf
, ", uses new ABI");
1460 case EF_ARM_OLD_ABI
:
1461 strcat (buf
, ", uses old ABI");
1464 case EF_ARM_SOFT_FLOAT
:
1465 strcat (buf
, ", software FP");
1476 strcat (buf
,", <unknown>");
1480 get_machine_flags (e_flags
, e_machine
)
1484 static char buf
[1024];
1496 decode_ARM_machine_flags (e_flags
, buf
);
1500 if (e_flags
& EF_CPU32
)
1501 strcat (buf
, ", cpu32");
1505 if (e_flags
& EF_PPC_EMB
)
1506 strcat (buf
, ", emb");
1508 if (e_flags
& EF_PPC_RELOCATABLE
)
1509 strcat (buf
, ", relocatable");
1511 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1512 strcat (buf
, ", relocatable-lib");
1515 case EM_CYGNUS_V850
:
1516 switch (e_flags
& EF_V850_ARCH
)
1519 strcat (buf
, ", v850e");
1522 strcat (buf
, ", v850ea");
1525 strcat (buf
, ", v850");
1528 strcat (buf
, ", unknown v850 architecture variant");
1533 case EM_CYGNUS_M32R
:
1534 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1535 strcat (buf
, ", m32r");
1540 case EM_MIPS_RS4_BE
:
1541 if (e_flags
& EF_MIPS_NOREORDER
)
1542 strcat (buf
, ", noreorder");
1544 if (e_flags
& EF_MIPS_PIC
)
1545 strcat (buf
, ", pic");
1547 if (e_flags
& EF_MIPS_CPIC
)
1548 strcat (buf
, ", cpic");
1550 if (e_flags
& EF_MIPS_ABI2
)
1551 strcat (buf
, ", abi2");
1553 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1554 strcat (buf
, ", mips1");
1556 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1557 strcat (buf
, ", mips2");
1559 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1560 strcat (buf
, ", mips3");
1562 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1563 strcat (buf
, ", mips4");
1565 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
1566 strcat (buf
, ", mips5");
1568 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
1569 strcat (buf
, ", mips32");
1571 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
1572 strcat (buf
, ", mips64");
1574 switch ((e_flags
& EF_MIPS_MACH
))
1576 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1577 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1578 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1579 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1580 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1581 case E_MIPS_MACH_MIPS32_4K
: strcat (buf
, ", mips32-4k"); break;
1582 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1583 default: strcat (buf
, " UNKNOWN"); break;
1588 if (e_flags
& EF_SPARC_32PLUS
)
1589 strcat (buf
, ", v8+");
1591 if (e_flags
& EF_SPARC_SUN_US1
)
1592 strcat (buf
, ", ultrasparcI");
1594 if (e_flags
& EF_SPARC_SUN_US3
)
1595 strcat (buf
, ", ultrasparcIII");
1597 if (e_flags
& EF_SPARC_HAL_R1
)
1598 strcat (buf
, ", halr1");
1600 if (e_flags
& EF_SPARC_LEDATA
)
1601 strcat (buf
, ", ledata");
1603 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1604 strcat (buf
, ", tso");
1606 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1607 strcat (buf
, ", pso");
1609 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1610 strcat (buf
, ", rmo");
1614 switch (e_flags
& EF_PARISC_ARCH
)
1616 case EFA_PARISC_1_0
:
1617 strcpy (buf
, ", PA-RISC 1.0");
1619 case EFA_PARISC_1_1
:
1620 strcpy (buf
, ", PA-RISC 1.1");
1622 case EFA_PARISC_2_0
:
1623 strcpy (buf
, ", PA-RISC 2.0");
1628 if (e_flags
& EF_PARISC_TRAPNIL
)
1629 strcat (buf
, ", trapnil");
1630 if (e_flags
& EF_PARISC_EXT
)
1631 strcat (buf
, ", ext");
1632 if (e_flags
& EF_PARISC_LSB
)
1633 strcat (buf
, ", lsb");
1634 if (e_flags
& EF_PARISC_WIDE
)
1635 strcat (buf
, ", wide");
1636 if (e_flags
& EF_PARISC_NO_KABP
)
1637 strcat (buf
, ", no kabp");
1638 if (e_flags
& EF_PARISC_LAZYSWAP
)
1639 strcat (buf
, ", lazyswap");
1643 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1644 strcat (buf
, ", new calling convention");
1646 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1647 strcat (buf
, ", gnu calling convention");
1651 if ((e_flags
& EF_IA_64_ABI64
))
1652 strcat (buf
, ", 64-bit");
1654 strcat (buf
, ", 32-bit");
1655 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1656 strcat (buf
, ", reduced fp model");
1657 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1658 strcat (buf
, ", no function descriptors, constant gp");
1659 else if ((e_flags
& EF_IA_64_CONS_GP
))
1660 strcat (buf
, ", constant gp");
1661 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1662 strcat (buf
, ", absolute");
1671 get_mips_segment_type (type
)
1676 case PT_MIPS_REGINFO
:
1678 case PT_MIPS_RTPROC
:
1680 case PT_MIPS_OPTIONS
:
1690 get_parisc_segment_type (type
)
1695 case PT_HP_TLS
: return "HP_TLS";
1696 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1697 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1698 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1699 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1700 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1701 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1702 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1703 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1704 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1705 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1706 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1707 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1708 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1717 get_ia64_segment_type (type
)
1722 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1723 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1732 get_segment_type (p_type
)
1733 unsigned long p_type
;
1735 static char buff
[32];
1739 case PT_NULL
: return "NULL";
1740 case PT_LOAD
: return "LOAD";
1741 case PT_DYNAMIC
: return "DYNAMIC";
1742 case PT_INTERP
: return "INTERP";
1743 case PT_NOTE
: return "NOTE";
1744 case PT_SHLIB
: return "SHLIB";
1745 case PT_PHDR
: return "PHDR";
1748 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1750 const char * result
;
1752 switch (elf_header
.e_machine
)
1755 case EM_MIPS_RS4_BE
:
1756 result
= get_mips_segment_type (p_type
);
1759 result
= get_parisc_segment_type (p_type
);
1762 result
= get_ia64_segment_type (p_type
);
1772 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1774 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1776 const char * result
;
1778 switch (elf_header
.e_machine
)
1781 result
= get_parisc_segment_type (p_type
);
1791 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1794 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1801 get_mips_section_type_name (sh_type
)
1802 unsigned int sh_type
;
1806 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1807 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1808 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1809 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1810 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1811 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1812 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1813 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1814 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1815 case SHT_MIPS_RELD
: return "MIPS_RELD";
1816 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1817 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1818 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1819 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1820 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1821 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1822 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1823 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1824 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1825 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1826 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1827 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1828 case SHT_MIPS_LINE
: return "MIPS_LINE";
1829 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1830 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1831 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1832 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1833 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1834 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1835 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1836 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1837 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1838 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1839 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1840 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1841 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1842 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1843 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1844 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1852 get_parisc_section_type_name (sh_type
)
1853 unsigned int sh_type
;
1857 case SHT_PARISC_EXT
: return "PARISC_EXT";
1858 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1859 case SHT_PARISC_DOC
: return "PARISC_DOC";
1867 get_ia64_section_type_name (sh_type
)
1868 unsigned int sh_type
;
1872 case SHT_IA_64_EXT
: return "IA_64_EXT";
1873 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
1881 get_section_type_name (sh_type
)
1882 unsigned int sh_type
;
1884 static char buff
[32];
1888 case SHT_NULL
: return "NULL";
1889 case SHT_PROGBITS
: return "PROGBITS";
1890 case SHT_SYMTAB
: return "SYMTAB";
1891 case SHT_STRTAB
: return "STRTAB";
1892 case SHT_RELA
: return "RELA";
1893 case SHT_HASH
: return "HASH";
1894 case SHT_DYNAMIC
: return "DYNAMIC";
1895 case SHT_NOTE
: return "NOTE";
1896 case SHT_NOBITS
: return "NOBITS";
1897 case SHT_REL
: return "REL";
1898 case SHT_SHLIB
: return "SHLIB";
1899 case SHT_DYNSYM
: return "DYNSYM";
1900 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1901 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1902 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1903 case SHT_GROUP
: return "GROUP";
1904 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
1905 case SHT_GNU_verdef
: return "VERDEF";
1906 case SHT_GNU_verneed
: return "VERNEED";
1907 case SHT_GNU_versym
: return "VERSYM";
1908 case 0x6ffffff0: return "VERSYM";
1909 case 0x6ffffffc: return "VERDEF";
1910 case 0x7ffffffd: return "AUXILIARY";
1911 case 0x7fffffff: return "FILTER";
1914 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1916 const char * result
;
1918 switch (elf_header
.e_machine
)
1921 case EM_MIPS_RS4_BE
:
1922 result
= get_mips_section_type_name (sh_type
);
1925 result
= get_parisc_section_type_name (sh_type
);
1928 result
= get_ia64_section_type_name (sh_type
);
1938 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1940 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1941 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1942 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
1943 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
1945 sprintf (buff
, _("<unknown>: %x"), sh_type
);
1951 struct option options
[] =
1953 {"all", no_argument
, 0, 'a'},
1954 {"file-header", no_argument
, 0, 'h'},
1955 {"program-headers", no_argument
, 0, 'l'},
1956 {"headers", no_argument
, 0, 'e'},
1957 {"histogram", no_argument
, 0, 'I'},
1958 {"segments", no_argument
, 0, 'l'},
1959 {"sections", no_argument
, 0, 'S'},
1960 {"section-headers", no_argument
, 0, 'S'},
1961 {"symbols", no_argument
, 0, 's'},
1962 {"syms", no_argument
, 0, 's'},
1963 {"relocs", no_argument
, 0, 'r'},
1964 {"notes", no_argument
, 0, 'n'},
1965 {"dynamic", no_argument
, 0, 'd'},
1966 {"arch-specific", no_argument
, 0, 'A'},
1967 {"version-info", no_argument
, 0, 'V'},
1968 {"use-dynamic", no_argument
, 0, 'D'},
1969 {"hex-dump", required_argument
, 0, 'x'},
1970 {"debug-dump", optional_argument
, 0, 'w'},
1971 {"unwind", no_argument
, 0, 'u'},
1972 #ifdef SUPPORT_DISASSEMBLY
1973 {"instruction-dump", required_argument
, 0, 'i'},
1976 {"version", no_argument
, 0, 'v'},
1977 {"help", no_argument
, 0, 'H'},
1978 {0, no_argument
, 0, 0}
1984 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
1985 fprintf (stdout
, _(" Options are:\n"));
1986 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
1987 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
1988 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
1989 fprintf (stdout
, _(" Display the program headers\n"));
1990 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
1991 fprintf (stdout
, _(" Display the sections' header\n"));
1992 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
1993 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
1994 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
1995 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
1996 fprintf (stdout
, _(" -u or --unwind Display the unwind info (if present)\n"));
1997 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
1998 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
1999 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
2000 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
2001 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
2002 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
2003 fprintf (stdout
, _(" -w[liaprf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=frames]\n"));
2004 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
2005 #ifdef SUPPORT_DISASSEMBLY
2006 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
2007 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
2009 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2010 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
2011 fprintf (stdout
, _(" -H or --help Display this information\n"));
2012 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2018 request_dump (section
, type
)
2019 unsigned int section
;
2022 if (section
>= num_dump_sects
)
2024 char * new_dump_sects
;
2026 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2028 if (new_dump_sects
== NULL
)
2029 error (_("Out of memory allocating dump request table."));
2032 /* Copy current flag settings. */
2033 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2037 dump_sects
= new_dump_sects
;
2038 num_dump_sects
= section
+ 1;
2043 dump_sects
[section
] |= type
;
2049 parse_args (argc
, argv
)
2058 while ((c
= getopt_long
2059 (argc
, argv
, "ersuahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
2095 do_using_dynamic
++;
2126 section
= strtoul (optarg
, & cp
, 0);
2127 if (! * cp
&& section
>= 0)
2129 request_dump (section
, HEX_DUMP
);
2149 do_debug_abbrevs
= 1;
2159 do_debug_pubnames
= 1;
2164 do_debug_aranges
= 1;
2169 do_debug_frames
= 1;
2173 warn (_("Unrecognised debug option '%s'\n"), optarg
);
2178 #ifdef SUPPORT_DISASSEMBLY
2181 section
= strtoul (optarg
, & cp
, 0);
2182 if (! * cp
&& section
>= 0)
2184 request_dump (section
, DISASS_DUMP
);
2190 print_version (program_name
);
2197 /* xgettext:c-format */
2198 error (_("Invalid option '-%c'\n"), c
);
2205 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2206 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2207 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2211 warn (_("Nothing to do.\n"));
2217 get_elf_class (elf_class
)
2218 unsigned char elf_class
;
2220 static char buff
[32];
2224 case ELFCLASSNONE
: return _("none");
2225 case ELFCLASS32
: return _("ELF32");
2226 case ELFCLASS64
: return _("ELF64");
2228 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2234 get_data_encoding (encoding
)
2235 unsigned char encoding
;
2237 static char buff
[32];
2241 case ELFDATANONE
: return _("none");
2242 case ELFDATA2LSB
: return _("2's complement, little endian");
2243 case ELFDATA2MSB
: return _("2's complement, big endian");
2245 sprintf (buff
, _("<unknown: %x>"), encoding
);
2251 get_osabi_name (osabi
)
2252 unsigned char osabi
;
2254 static char buff
[32];
2258 case ELFOSABI_NONE
: return _("UNIX - System V");
2259 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2260 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2261 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2262 case ELFOSABI_HURD
: return _("GNU/Hurd");
2263 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2264 case ELFOSABI_AIX
: return _("UNIX - AIX");
2265 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2266 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2267 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2268 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2269 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2270 case ELFOSABI_STANDALONE
: return _("Standalone App");
2271 case ELFOSABI_ARM
: return _("ARM");
2273 sprintf (buff
, _("<unknown: %x>"), osabi
);
2278 /* Decode the data held in 'elf_header'. */
2280 process_file_header ()
2282 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2283 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2284 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2285 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2288 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2296 printf (_("ELF Header:\n"));
2297 printf (_(" Magic: "));
2298 for (i
= 0; i
< EI_NIDENT
; i
++)
2299 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2301 printf (_(" Class: %s\n"),
2302 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2303 printf (_(" Data: %s\n"),
2304 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2305 printf (_(" Version: %d %s\n"),
2306 elf_header
.e_ident
[EI_VERSION
],
2307 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2309 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2312 printf (_(" OS/ABI: %s\n"),
2313 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2314 printf (_(" ABI Version: %d\n"),
2315 elf_header
.e_ident
[EI_ABIVERSION
]);
2316 printf (_(" Type: %s\n"),
2317 get_file_type (elf_header
.e_type
));
2318 printf (_(" Machine: %s\n"),
2319 get_machine_name (elf_header
.e_machine
));
2320 printf (_(" Version: 0x%lx\n"),
2321 (unsigned long) elf_header
.e_version
);
2323 printf (_(" Entry point address: "));
2324 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2325 printf (_("\n Start of program headers: "));
2326 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2327 printf (_(" (bytes into file)\n Start of section headers: "));
2328 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2329 printf (_(" (bytes into file)\n"));
2331 printf (_(" Flags: 0x%lx%s\n"),
2332 (unsigned long) elf_header
.e_flags
,
2333 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2334 printf (_(" Size of this header: %ld (bytes)\n"),
2335 (long) elf_header
.e_ehsize
);
2336 printf (_(" Size of program headers: %ld (bytes)\n"),
2337 (long) elf_header
.e_phentsize
);
2338 printf (_(" Number of program headers: %ld\n"),
2339 (long) elf_header
.e_phnum
);
2340 printf (_(" Size of section headers: %ld (bytes)\n"),
2341 (long) elf_header
.e_shentsize
);
2342 printf (_(" Number of section headers: %ld\n"),
2343 (long) elf_header
.e_shnum
);
2344 printf (_(" Section header string table index: %ld\n"),
2345 (long) elf_header
.e_shstrndx
);
2353 get_32bit_program_headers (file
, program_headers
)
2355 Elf_Internal_Phdr
* program_headers
;
2357 Elf32_External_Phdr
* phdrs
;
2358 Elf32_External_Phdr
* external
;
2359 Elf32_Internal_Phdr
* internal
;
2362 GET_DATA_ALLOC (elf_header
.e_phoff
,
2363 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2364 phdrs
, Elf32_External_Phdr
*, "program headers");
2366 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2367 i
< elf_header
.e_phnum
;
2368 i
++, internal
++, external
++)
2370 internal
->p_type
= BYTE_GET (external
->p_type
);
2371 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2372 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2373 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2374 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2375 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2376 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2377 internal
->p_align
= BYTE_GET (external
->p_align
);
2386 get_64bit_program_headers (file
, program_headers
)
2388 Elf_Internal_Phdr
* program_headers
;
2390 Elf64_External_Phdr
* phdrs
;
2391 Elf64_External_Phdr
* external
;
2392 Elf64_Internal_Phdr
* internal
;
2395 GET_DATA_ALLOC (elf_header
.e_phoff
,
2396 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2397 phdrs
, Elf64_External_Phdr
*, "program headers");
2399 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2400 i
< elf_header
.e_phnum
;
2401 i
++, internal
++, external
++)
2403 internal
->p_type
= BYTE_GET (external
->p_type
);
2404 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2405 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2406 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2407 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2408 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2409 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2410 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2419 process_program_headers (file
)
2422 Elf_Internal_Phdr
* program_headers
;
2423 Elf_Internal_Phdr
* segment
;
2426 if (elf_header
.e_phnum
== 0)
2429 printf (_("\nThere are no program headers in this file.\n"));
2433 if (do_segments
&& !do_header
)
2435 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2436 printf (_("Entry point "));
2437 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2438 printf (_("\nThere are %d program headers, starting at offset "),
2439 elf_header
.e_phnum
);
2440 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2444 program_headers
= (Elf_Internal_Phdr
*) malloc
2445 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2447 if (program_headers
== NULL
)
2449 error (_("Out of memory\n"));
2454 i
= get_32bit_program_headers (file
, program_headers
);
2456 i
= get_64bit_program_headers (file
, program_headers
);
2460 free (program_headers
);
2467 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2471 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2475 (_(" Type Offset VirtAddr PhysAddr\n"));
2477 (_(" FileSiz MemSiz Flags Align\n"));
2485 for (i
= 0, segment
= program_headers
;
2486 i
< elf_header
.e_phnum
;
2491 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2495 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2496 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2497 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2498 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2499 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2501 (segment
->p_flags
& PF_R
? 'R' : ' '),
2502 (segment
->p_flags
& PF_W
? 'W' : ' '),
2503 (segment
->p_flags
& PF_X
? 'E' : ' '));
2504 printf ("%#lx", (unsigned long) segment
->p_align
);
2508 print_vma (segment
->p_offset
, FULL_HEX
);
2510 print_vma (segment
->p_vaddr
, FULL_HEX
);
2512 print_vma (segment
->p_paddr
, FULL_HEX
);
2514 print_vma (segment
->p_filesz
, FULL_HEX
);
2516 print_vma (segment
->p_memsz
, FULL_HEX
);
2518 (segment
->p_flags
& PF_R
? 'R' : ' '),
2519 (segment
->p_flags
& PF_W
? 'W' : ' '),
2520 (segment
->p_flags
& PF_X
? 'E' : ' '));
2521 print_vma (segment
->p_align
, HEX
);
2525 switch (segment
->p_type
)
2529 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2530 - (segment
->p_offset
& 0xfffff000);
2535 error (_("more than one dynamic segment\n"));
2537 dynamic_addr
= segment
->p_offset
;
2538 dynamic_size
= segment
->p_filesz
;
2542 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2543 error (_("Unable to find program interpreter name\n"));
2546 program_interpreter
[0] = 0;
2547 fscanf (file
, "%63s", program_interpreter
);
2550 printf (_("\n [Requesting program interpreter: %s]"),
2551 program_interpreter
);
2557 putc ('\n', stdout
);
2566 if (do_segments
&& section_headers
!= NULL
)
2568 printf (_("\n Section to Segment mapping:\n"));
2569 printf (_(" Segment Sections...\n"));
2571 assert (string_table
!= NULL
);
2573 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2576 Elf_Internal_Shdr
* section
;
2578 segment
= program_headers
+ i
;
2579 section
= section_headers
;
2581 printf (" %2.2d ", i
);
2583 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2585 if (section
->sh_size
> 0
2586 /* Compare allocated sections by VMA, unallocated
2587 sections by file offset. */
2588 && (section
->sh_flags
& SHF_ALLOC
2589 ? (section
->sh_addr
>= segment
->p_vaddr
2590 && section
->sh_addr
+ section
->sh_size
2591 <= segment
->p_vaddr
+ segment
->p_memsz
)
2592 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2593 && (section
->sh_offset
+ section
->sh_size
2594 <= segment
->p_offset
+ segment
->p_filesz
))))
2595 printf ("%s ", SECTION_NAME (section
));
2602 free (program_headers
);
2609 get_32bit_section_headers (file
)
2612 Elf32_External_Shdr
* shdrs
;
2613 Elf32_Internal_Shdr
* internal
;
2616 GET_DATA_ALLOC (elf_header
.e_shoff
,
2617 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2618 shdrs
, Elf32_External_Shdr
*, "section headers");
2620 section_headers
= (Elf_Internal_Shdr
*) malloc
2621 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2623 if (section_headers
== NULL
)
2625 error (_("Out of memory\n"));
2629 for (i
= 0, internal
= section_headers
;
2630 i
< elf_header
.e_shnum
;
2633 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2634 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2635 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2636 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2637 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2638 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2639 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2640 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2641 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2642 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2651 get_64bit_section_headers (file
)
2654 Elf64_External_Shdr
* shdrs
;
2655 Elf64_Internal_Shdr
* internal
;
2658 GET_DATA_ALLOC (elf_header
.e_shoff
,
2659 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2660 shdrs
, Elf64_External_Shdr
*, "section headers");
2662 section_headers
= (Elf_Internal_Shdr
*) malloc
2663 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2665 if (section_headers
== NULL
)
2667 error (_("Out of memory\n"));
2671 for (i
= 0, internal
= section_headers
;
2672 i
< elf_header
.e_shnum
;
2675 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2676 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2677 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2678 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2679 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2680 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2681 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2682 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2683 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2684 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2692 static Elf_Internal_Sym
*
2693 get_32bit_elf_symbols (file
, offset
, number
)
2695 unsigned long offset
;
2696 unsigned long number
;
2698 Elf32_External_Sym
* esyms
;
2699 Elf_Internal_Sym
* isyms
;
2700 Elf_Internal_Sym
* psym
;
2703 GET_DATA_ALLOC (offset
, number
* sizeof (Elf32_External_Sym
),
2704 esyms
, Elf32_External_Sym
*, "symbols");
2706 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2710 error (_("Out of memory\n"));
2716 for (j
= 0, psym
= isyms
;
2720 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2721 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2722 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2723 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2724 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2725 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2733 static Elf_Internal_Sym
*
2734 get_64bit_elf_symbols (file
, offset
, number
)
2736 unsigned long offset
;
2737 unsigned long number
;
2739 Elf64_External_Sym
* esyms
;
2740 Elf_Internal_Sym
* isyms
;
2741 Elf_Internal_Sym
* psym
;
2744 GET_DATA_ALLOC (offset
, number
* sizeof (Elf64_External_Sym
),
2745 esyms
, Elf64_External_Sym
*, "symbols");
2747 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2751 error (_("Out of memory\n"));
2757 for (j
= 0, psym
= isyms
;
2761 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2762 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2763 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2764 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2765 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2766 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2775 get_elf_section_flags (sh_flags
)
2778 static char buff
[32];
2786 flag
= sh_flags
& - sh_flags
;
2791 case SHF_WRITE
: strcat (buff
, "W"); break;
2792 case SHF_ALLOC
: strcat (buff
, "A"); break;
2793 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2794 case SHF_MERGE
: strcat (buff
, "M"); break;
2795 case SHF_STRINGS
: strcat (buff
, "S"); break;
2796 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2797 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2798 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2799 case SHF_GROUP
: strcat (buff
, "G"); break;
2802 if (flag
& SHF_MASKOS
)
2805 sh_flags
&= ~ SHF_MASKOS
;
2807 else if (flag
& SHF_MASKPROC
)
2810 sh_flags
&= ~ SHF_MASKPROC
;
2822 process_section_headers (file
)
2825 Elf_Internal_Shdr
* section
;
2828 section_headers
= NULL
;
2830 if (elf_header
.e_shnum
== 0)
2833 printf (_("\nThere are no sections in this file.\n"));
2838 if (do_sections
&& !do_header
)
2839 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2840 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2844 if (! get_32bit_section_headers (file
))
2847 else if (! get_64bit_section_headers (file
))
2850 /* Read in the string table, so that we have names to display. */
2851 section
= section_headers
+ elf_header
.e_shstrndx
;
2853 if (section
->sh_size
!= 0)
2855 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2856 string_table
, char *, "string table");
2858 string_table_length
= section
->sh_size
;
2861 /* Scan the sections for the dynamic symbol table
2862 and dynamic string table and debug sections. */
2863 dynamic_symbols
= NULL
;
2864 dynamic_strings
= NULL
;
2865 dynamic_syminfo
= NULL
;
2867 for (i
= 0, section
= section_headers
;
2868 i
< elf_header
.e_shnum
;
2871 char * name
= SECTION_NAME (section
);
2873 if (section
->sh_type
== SHT_DYNSYM
)
2875 if (dynamic_symbols
!= NULL
)
2877 error (_("File contains multiple dynamic symbol tables\n"));
2881 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2883 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2885 else if (section
->sh_type
== SHT_STRTAB
2886 && strcmp (name
, ".dynstr") == 0)
2888 if (dynamic_strings
!= NULL
)
2890 error (_("File contains multiple dynamic string tables\n"));
2894 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
2895 dynamic_strings
, char *, "dynamic strings");
2897 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2898 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
|| do_debug_frames
)
2899 && strncmp (name
, ".debug_", 7) == 0)
2904 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2905 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2906 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2907 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2908 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2909 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
2911 request_dump (i
, DEBUG_DUMP
);
2913 /* linkonce section to be combined with .debug_info at link time. */
2914 else if ((do_debugging
|| do_debug_info
)
2915 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
2916 request_dump (i
, DEBUG_DUMP
);
2917 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
2918 request_dump (i
, DEBUG_DUMP
);
2924 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
2928 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
2931 printf (_(" [Nr] Name Type Address Offset\n"));
2932 printf (_(" Size EntSize Flags Link Info Align\n"));
2935 for (i
= 0, section
= section_headers
;
2936 i
< elf_header
.e_shnum
;
2939 printf (" [%2d] %-17.17s %-15.15s ",
2941 SECTION_NAME (section
),
2942 get_section_type_name (section
->sh_type
));
2946 print_vma (section
->sh_addr
, LONG_HEX
);
2948 printf ( " %6.6lx %6.6lx %2.2lx",
2949 (unsigned long) section
->sh_offset
,
2950 (unsigned long) section
->sh_size
,
2951 (unsigned long) section
->sh_entsize
);
2953 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2955 printf ("%2ld %3lx %2ld\n",
2956 (unsigned long) section
->sh_link
,
2957 (unsigned long) section
->sh_info
,
2958 (unsigned long) section
->sh_addralign
);
2963 print_vma (section
->sh_addr
, LONG_HEX
);
2964 printf (" %8.8lx", section
->sh_offset
);
2966 print_vma (section
->sh_size
, LONG_HEX
);
2968 print_vma (section
->sh_entsize
, LONG_HEX
);
2970 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
2972 printf (" %2ld %3lx %ld\n",
2973 (unsigned long) section
->sh_link
,
2974 (unsigned long) section
->sh_info
,
2975 (unsigned long) section
->sh_addralign
);
2979 printf (_("Key to Flags:\n"));
2980 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
2981 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
2982 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
2987 /* Process the reloc section. */
2989 process_relocs (file
)
2992 unsigned long rel_size
;
2993 unsigned long rel_offset
;
2999 if (do_using_dynamic
)
3001 int is_rela
= FALSE
;
3006 if (dynamic_info
[DT_REL
])
3008 rel_offset
= dynamic_info
[DT_REL
];
3009 rel_size
= dynamic_info
[DT_RELSZ
];
3012 else if (dynamic_info
[DT_RELA
])
3014 rel_offset
= dynamic_info
[DT_RELA
];
3015 rel_size
= dynamic_info
[DT_RELASZ
];
3018 else if (dynamic_info
[DT_JMPREL
])
3020 rel_offset
= dynamic_info
[DT_JMPREL
];
3021 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3023 switch (dynamic_info
[DT_PLTREL
])
3040 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3041 rel_offset
, rel_size
);
3043 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3044 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3047 printf (_("\nThere are no dynamic relocations in this file.\n"));
3051 Elf32_Internal_Shdr
* section
;
3055 for (i
= 0, section
= section_headers
;
3056 i
< elf_header
.e_shnum
;
3059 if ( section
->sh_type
!= SHT_RELA
3060 && section
->sh_type
!= SHT_REL
)
3063 rel_offset
= section
->sh_offset
;
3064 rel_size
= section
->sh_size
;
3068 Elf32_Internal_Shdr
* strsec
;
3069 Elf32_Internal_Shdr
* symsec
;
3070 Elf_Internal_Sym
* symtab
;
3073 unsigned long nsyms
;
3075 printf (_("\nRelocation section "));
3077 if (string_table
== NULL
)
3078 printf ("%d", section
->sh_name
);
3080 printf ("'%s'", SECTION_NAME (section
));
3082 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3083 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3085 symsec
= section_headers
+ section
->sh_link
;
3087 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3088 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
3093 strsec
= section_headers
+ symsec
->sh_link
;
3095 GET_DATA_ALLOC (strsec
->sh_offset
, strsec
->sh_size
, strtab
,
3096 char *, "string table");
3098 is_rela
= section
->sh_type
== SHT_RELA
;
3100 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
);
3110 printf (_("\nThere are no relocations in this file.\n"));
3116 #include "unwind-ia64.h"
3118 /* An absolute address consists of a section and an offset. If the
3119 section is NULL, the offset itself is the address, otherwise, the
3120 address equals to LOAD_ADDRESS(section) + offset. */
3124 unsigned short section
;
3130 struct unw_table_entry
3132 struct absaddr start
;
3134 struct absaddr info
;
3136 *table
; /* Unwind table. */
3137 unsigned long table_len
; /* Length of unwind table. */
3138 unsigned char * info
; /* Unwind info. */
3139 unsigned long info_size
; /* Size of unwind info. */
3140 bfd_vma info_addr
; /* starting address of unwind info. */
3141 bfd_vma seg_base
; /* Starting address of segment. */
3142 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3143 unsigned long nsyms
; /* Number of symbols. */
3144 char * strtab
; /* The string table. */
3145 unsigned long strtab_size
; /* Size of string table. */
3148 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3149 struct absaddr
, const char **,
3151 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3152 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3153 Elf32_Internal_Shdr
*));
3156 find_symbol_for_address (aux
, addr
, symname
, offset
)
3157 struct unw_aux_info
*aux
;
3158 struct absaddr addr
;
3159 const char **symname
;
3162 bfd_vma dist
= (bfd_vma
) 0x100000;
3163 Elf_Internal_Sym
*sym
, *best
= NULL
;
3166 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3168 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3169 && sym
->st_name
!= 0
3170 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3171 && addr
.offset
>= sym
->st_value
3172 && addr
.offset
- sym
->st_value
< dist
)
3175 dist
= addr
.offset
- sym
->st_value
;
3182 *symname
= (best
->st_name
>= aux
->strtab_size
3183 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3188 *offset
= addr
.offset
;
3192 dump_ia64_unwind (aux
)
3193 struct unw_aux_info
*aux
;
3196 struct unw_table_entry
* tp
;
3199 addr_size
= is_32bit_elf
? 4 : 8;
3201 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3205 const unsigned char * dp
;
3206 const unsigned char * head
;
3207 const char * procname
;
3209 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3211 fputs ("\n<", stdout
);
3215 fputs (procname
, stdout
);
3218 printf ("+%lx", (unsigned long) offset
);
3221 fputs (">: [", stdout
);
3222 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3223 fputc ('-', stdout
);
3224 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3225 printf ("), info at +0x%lx\n",
3226 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3228 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3229 stamp
= BYTE_GET8 ((unsigned char *) head
);
3231 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3232 (unsigned) UNW_VER (stamp
),
3233 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3234 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3235 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3236 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3238 if (UNW_VER (stamp
) != 1)
3240 printf ("\tUnknown version.\n");
3245 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3246 dp
= unw_decode (dp
, in_body
, & in_body
);
3251 slurp_ia64_unwind_table (file
, aux
, sec
)
3253 struct unw_aux_info
*aux
;
3254 Elf32_Internal_Shdr
*sec
;
3256 unsigned long size
, addr_size
, nrelas
, i
;
3257 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3258 struct unw_table_entry
*tep
;
3259 Elf32_Internal_Shdr
*relsec
;
3260 Elf_Internal_Rela
*rela
, *rp
;
3261 unsigned char *table
, *tp
;
3262 Elf_Internal_Sym
*sym
;
3263 const char *relname
;
3266 addr_size
= is_32bit_elf
? 4 : 8;
3268 /* First, find the starting address of the segment that includes
3271 if (elf_header
.e_phnum
)
3273 prog_hdrs
= (Elf_Internal_Phdr
*)
3274 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3277 result
= get_32bit_program_headers (file
, prog_hdrs
);
3279 result
= get_64bit_program_headers (file
, prog_hdrs
);
3287 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3289 if (seg
->p_type
!= PT_LOAD
)
3292 if (sec
->sh_addr
>= seg
->p_vaddr
3293 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3295 aux
->seg_base
= seg
->p_vaddr
;
3303 /* Second, build the unwind table from the contents of the unwind section: */
3304 size
= sec
->sh_size
;
3305 GET_DATA_ALLOC (sec
->sh_offset
, size
, table
, char *, "unwind table");
3307 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3308 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3310 tep
->start
.section
= SHN_UNDEF
;
3311 tep
->end
.section
= SHN_UNDEF
;
3312 tep
->info
.section
= SHN_UNDEF
;
3315 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3316 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3317 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3321 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3322 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3323 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3325 tep
->start
.offset
+= aux
->seg_base
;
3326 tep
->end
.offset
+= aux
->seg_base
;
3327 tep
->info
.offset
+= aux
->seg_base
;
3331 /* Third, apply any relocations to the unwind table: */
3333 for (relsec
= section_headers
;
3334 relsec
< section_headers
+ elf_header
.e_shnum
;
3337 if (relsec
->sh_type
!= SHT_RELA
3338 || section_headers
+ relsec
->sh_info
!= sec
)
3341 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3345 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3349 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3350 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3352 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3354 warn (_("Skipping unexpected symbol type %u"),
3355 ELF32_ST_TYPE (sym
->st_info
));
3361 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3362 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3364 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3366 warn (_("Skipping unexpected symbol type %u"),
3367 ELF64_ST_TYPE (sym
->st_info
));
3372 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3374 warn (_("Skipping unexpected relocation type %s"), relname
);
3378 i
= rp
->r_offset
/ (3 * addr_size
);
3380 switch (rp
->r_offset
/addr_size
% 3)
3383 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3384 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3387 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3388 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3391 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3392 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3402 aux
->table_len
= size
/ (3 * addr_size
);
3407 process_unwind (file
)
3410 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3411 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3412 struct unw_aux_info aux
;
3417 if (elf_header
.e_machine
!= EM_IA_64
)
3419 printf (_("\nThere are no unwind sections in this file.\n"));
3423 memset (& aux
, 0, sizeof (aux
));
3425 addr_size
= is_32bit_elf
? 4 : 8;
3427 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3429 if (sec
->sh_type
== SHT_SYMTAB
)
3431 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3432 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
->sh_offset
, aux
.nsyms
);
3434 strsec
= section_headers
+ sec
->sh_link
;
3435 aux
.strtab_size
= strsec
->sh_size
;
3436 GET_DATA_ALLOC (strsec
->sh_offset
, aux
.strtab_size
,
3437 aux
.strtab
, char *, "string table");
3439 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3444 printf (_("\nThere are no unwind sections in this file.\n"));
3446 while (unwcount
-- > 0)
3451 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3452 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3453 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3460 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3462 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3465 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3466 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3467 suffix
= SECTION_NAME (unwsec
) + len
;
3468 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3470 if (strncmp (SECTION_NAME (sec
),
3471 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3472 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3477 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3478 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3479 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3480 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3482 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3484 suffix
= SECTION_NAME (unwsec
) + len
;
3485 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3487 if (strncmp (SECTION_NAME (sec
),
3488 ELF_STRING_ia64_unwind_info
, len2
) == 0
3489 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3493 if (i
== elf_header
.e_shnum
)
3495 printf (_("\nCould not find unwind info section for "));
3497 if (string_table
== NULL
)
3498 printf ("%d", unwsec
->sh_name
);
3500 printf ("'%s'", SECTION_NAME (unwsec
));
3504 aux
.info_size
= sec
->sh_size
;
3505 aux
.info_addr
= sec
->sh_addr
;
3506 GET_DATA_ALLOC (sec
->sh_offset
, aux
.info_size
, aux
.info
,
3507 char *, "unwind info");
3509 printf (_("\nUnwind section "));
3511 if (string_table
== NULL
)
3512 printf ("%d", unwsec
->sh_name
);
3514 printf ("'%s'", SECTION_NAME (unwsec
));
3516 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3518 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
3520 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
3522 if (aux
.table_len
> 0)
3523 dump_ia64_unwind (& aux
);
3526 free ((char *) aux
.table
);
3528 free ((char *) aux
.info
);
3537 free ((char *) aux
.strtab
);
3543 dynamic_segment_mips_val (entry
)
3544 Elf_Internal_Dyn
* entry
;
3546 switch (entry
->d_tag
)
3549 if (entry
->d_un
.d_val
== 0)
3553 static const char * opts
[] =
3555 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3556 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3557 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3558 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3563 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
3564 if (entry
->d_un
.d_val
& (1 << cnt
))
3566 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
3573 case DT_MIPS_IVERSION
:
3574 if (dynamic_strings
!= NULL
)
3575 printf ("Interface Version: %s\n",
3576 dynamic_strings
+ entry
->d_un
.d_val
);
3578 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3581 case DT_MIPS_TIME_STAMP
:
3586 time_t time
= entry
->d_un
.d_val
;
3587 tmp
= gmtime (&time
);
3588 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
3589 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
3590 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
3591 printf ("Time Stamp: %s\n", timebuf
);
3595 case DT_MIPS_RLD_VERSION
:
3596 case DT_MIPS_LOCAL_GOTNO
:
3597 case DT_MIPS_CONFLICTNO
:
3598 case DT_MIPS_LIBLISTNO
:
3599 case DT_MIPS_SYMTABNO
:
3600 case DT_MIPS_UNREFEXTNO
:
3601 case DT_MIPS_HIPAGENO
:
3602 case DT_MIPS_DELTA_CLASS_NO
:
3603 case DT_MIPS_DELTA_INSTANCE_NO
:
3604 case DT_MIPS_DELTA_RELOC_NO
:
3605 case DT_MIPS_DELTA_SYM_NO
:
3606 case DT_MIPS_DELTA_CLASSSYM_NO
:
3607 case DT_MIPS_COMPACT_SIZE
:
3608 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3612 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
3618 dynamic_segment_parisc_val (entry
)
3619 Elf_Internal_Dyn
* entry
;
3621 switch (entry
->d_tag
)
3623 case DT_HP_DLD_FLAGS
:
3632 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3633 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3634 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3635 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3636 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3637 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3638 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3639 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3640 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3641 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3642 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3646 bfd_vma val
= entry
->d_un
.d_val
;
3648 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3649 if (val
& flags
[cnt
].bit
)
3653 fputs (flags
[cnt
].str
, stdout
);
3655 val
^= flags
[cnt
].bit
;
3658 if (val
!= 0 || first
)
3662 print_vma (val
, HEX
);
3668 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3674 get_32bit_dynamic_segment (file
)
3677 Elf32_External_Dyn
* edyn
;
3678 Elf_Internal_Dyn
* entry
;
3681 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3682 edyn
, Elf32_External_Dyn
*, "dynamic segment");
3684 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3685 how large this .dynamic is now. We can do this even before the byte
3686 swapping since the DT_NULL tag is recognizable. */
3688 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3691 dynamic_segment
= (Elf_Internal_Dyn
*)
3692 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3694 if (dynamic_segment
== NULL
)
3696 error (_("Out of memory\n"));
3701 for (i
= 0, entry
= dynamic_segment
;
3705 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3706 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3715 get_64bit_dynamic_segment (file
)
3718 Elf64_External_Dyn
* edyn
;
3719 Elf_Internal_Dyn
* entry
;
3722 GET_DATA_ALLOC (dynamic_addr
, dynamic_size
,
3723 edyn
, Elf64_External_Dyn
*, "dynamic segment");
3725 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3726 how large this .dynamic is now. We can do this even before the byte
3727 swapping since the DT_NULL tag is recognizable. */
3729 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3732 dynamic_segment
= (Elf_Internal_Dyn
*)
3733 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3735 if (dynamic_segment
== NULL
)
3737 error (_("Out of memory\n"));
3742 for (i
= 0, entry
= dynamic_segment
;
3746 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3747 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3756 get_dynamic_flags (flags
)
3759 static char buff
[64];
3764 flag
= flags
& - flags
;
3769 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3770 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3771 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3772 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3773 default: strcat (buff
, "unknown "); break;
3779 /* Parse and display the contents of the dynamic segment. */
3781 process_dynamic_segment (file
)
3784 Elf_Internal_Dyn
* entry
;
3787 if (dynamic_size
== 0)
3790 printf (_("\nThere is no dynamic segment in this file.\n"));
3797 if (! get_32bit_dynamic_segment (file
))
3800 else if (! get_64bit_dynamic_segment (file
))
3803 /* Find the appropriate symbol table. */
3804 if (dynamic_symbols
== NULL
)
3806 for (i
= 0, entry
= dynamic_segment
;
3810 unsigned long offset
;
3812 if (entry
->d_tag
!= DT_SYMTAB
)
3815 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3817 /* Since we do not know how big the symbol table is,
3818 we default to reading in the entire file (!) and
3819 processing that. This is overkill, I know, but it
3821 offset
= entry
->d_un
.d_val
- loadaddr
;
3823 if (fseek (file
, 0, SEEK_END
))
3824 error (_("Unable to seek to end of file!"));
3827 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3829 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3831 if (num_dynamic_syms
< 1)
3833 error (_("Unable to determine the number of symbols to load\n"));
3837 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3841 /* Similarly find a string table. */
3842 if (dynamic_strings
== NULL
)
3844 for (i
= 0, entry
= dynamic_segment
;
3848 unsigned long offset
;
3851 if (entry
->d_tag
!= DT_STRTAB
)
3854 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3856 /* Since we do not know how big the string table is,
3857 we default to reading in the entire file (!) and
3858 processing that. This is overkill, I know, but it
3861 offset
= entry
->d_un
.d_val
- loadaddr
;
3862 if (fseek (file
, 0, SEEK_END
))
3863 error (_("Unable to seek to end of file\n"));
3864 str_tab_len
= ftell (file
) - offset
;
3866 if (str_tab_len
< 1)
3869 (_("Unable to determine the length of the dynamic string table\n"));
3873 GET_DATA_ALLOC (offset
, str_tab_len
, dynamic_strings
, char *,
3874 "dynamic string table");
3880 /* And find the syminfo section if available. */
3881 if (dynamic_syminfo
== NULL
)
3883 unsigned int syminsz
= 0;
3885 for (i
= 0, entry
= dynamic_segment
;
3889 if (entry
->d_tag
== DT_SYMINENT
)
3891 /* Note: these braces are necessary to avoid a syntax
3892 error from the SunOS4 C compiler. */
3893 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3895 else if (entry
->d_tag
== DT_SYMINSZ
)
3896 syminsz
= entry
->d_un
.d_val
;
3897 else if (entry
->d_tag
== DT_SYMINFO
)
3898 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
3901 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
3903 Elf_External_Syminfo
* extsyminfo
;
3904 Elf_Internal_Syminfo
* syminfo
;
3906 /* There is a syminfo section. Read the data. */
3907 GET_DATA_ALLOC (dynamic_syminfo_offset
, syminsz
, extsyminfo
,
3908 Elf_External_Syminfo
*, "symbol information");
3910 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
3911 if (dynamic_syminfo
== NULL
)
3913 error (_("Out of memory\n"));
3917 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
3918 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
3921 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
3922 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
3929 if (do_dynamic
&& dynamic_addr
)
3930 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
3931 dynamic_addr
, (long) dynamic_size
);
3933 printf (_(" Tag Type Name/Value\n"));
3935 for (i
= 0, entry
= dynamic_segment
;
3944 print_vma (entry
->d_tag
, FULL_HEX
);
3945 dtype
= get_dynamic_type (entry
->d_tag
);
3946 printf (" (%s)%*s", dtype
,
3947 ((is_32bit_elf
? 27 : 19)
3948 - (int) strlen (dtype
)),
3952 switch (entry
->d_tag
)
3956 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
3966 switch (entry
->d_tag
)
3969 printf (_("Auxiliary library"));
3973 printf (_("Filter library"));
3977 printf (_("Configuration file"));
3981 printf (_("Dependency audit library"));
3985 printf (_("Audit library"));
3989 if (dynamic_strings
)
3990 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
3994 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4003 printf (_("Flags:"));
4004 if (entry
->d_un
.d_val
== 0)
4005 printf (_(" None\n"));
4008 unsigned long int val
= entry
->d_un
.d_val
;
4009 if (val
& DTF_1_PARINIT
)
4011 printf (" PARINIT");
4012 val
^= DTF_1_PARINIT
;
4014 if (val
& DTF_1_CONFEXP
)
4016 printf (" CONFEXP");
4017 val
^= DTF_1_CONFEXP
;
4020 printf (" %lx", val
);
4029 printf (_("Flags:"));
4030 if (entry
->d_un
.d_val
== 0)
4031 printf (_(" None\n"));
4034 unsigned long int val
= entry
->d_un
.d_val
;
4035 if (val
& DF_P1_LAZYLOAD
)
4037 printf (" LAZYLOAD");
4038 val
^= DF_P1_LAZYLOAD
;
4040 if (val
& DF_P1_GROUPPERM
)
4042 printf (" GROUPPERM");
4043 val
^= DF_P1_GROUPPERM
;
4046 printf (" %lx", val
);
4055 printf (_("Flags:"));
4056 if (entry
->d_un
.d_val
== 0)
4057 printf (_(" None\n"));
4060 unsigned long int val
= entry
->d_un
.d_val
;
4066 if (val
& DF_1_GLOBAL
)
4071 if (val
& DF_1_GROUP
)
4076 if (val
& DF_1_NODELETE
)
4078 printf (" NODELETE");
4079 val
^= DF_1_NODELETE
;
4081 if (val
& DF_1_LOADFLTR
)
4083 printf (" LOADFLTR");
4084 val
^= DF_1_LOADFLTR
;
4086 if (val
& DF_1_INITFIRST
)
4088 printf (" INITFIRST");
4089 val
^= DF_1_INITFIRST
;
4091 if (val
& DF_1_NOOPEN
)
4096 if (val
& DF_1_ORIGIN
)
4101 if (val
& DF_1_DIRECT
)
4106 if (val
& DF_1_TRANS
)
4111 if (val
& DF_1_INTERPOSE
)
4113 printf (" INTERPOSE");
4114 val
^= DF_1_INTERPOSE
;
4116 if (val
& DF_1_NODEFLIB
)
4118 printf (" NODEFLIB");
4119 val
^= DF_1_NODEFLIB
;
4121 if (val
& DF_1_NODUMP
)
4126 if (val
& DF_1_CONLFAT
)
4128 printf (" CONLFAT");
4129 val
^= DF_1_CONLFAT
;
4132 printf (" %lx", val
);
4140 puts (get_dynamic_type (entry
->d_un
.d_val
));
4160 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4166 if (dynamic_strings
== NULL
)
4169 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4173 switch (entry
->d_tag
)
4176 printf (_("Shared library: [%s]"), name
);
4178 if (strcmp (name
, program_interpreter
) == 0)
4179 printf (_(" program interpreter"));
4183 printf (_("Library soname: [%s]"), name
);
4187 printf (_("Library rpath: [%s]"), name
);
4191 printf (_("Library runpath: [%s]"), name
);
4195 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4200 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4216 case DT_INIT_ARRAYSZ
:
4217 case DT_FINI_ARRAYSZ
:
4220 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4221 printf (" (bytes)\n");
4231 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4244 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4248 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4252 printf (_("Not needed object: [%s]\n"), name
);
4257 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4263 /* The value of this entry is ignored. */
4267 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4268 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4273 switch (elf_header
.e_machine
)
4276 case EM_MIPS_RS4_BE
:
4277 dynamic_segment_mips_val (entry
);
4280 dynamic_segment_parisc_val (entry
);
4283 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4295 get_ver_flags (flags
)
4298 static char buff
[32];
4305 if (flags
& VER_FLG_BASE
)
4306 strcat (buff
, "BASE ");
4308 if (flags
& VER_FLG_WEAK
)
4310 if (flags
& VER_FLG_BASE
)
4311 strcat (buff
, "| ");
4313 strcat (buff
, "WEAK ");
4316 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4317 strcat (buff
, "| <unknown>");
4322 /* Display the contents of the version sections. */
4324 process_version_sections (file
)
4327 Elf32_Internal_Shdr
* section
;
4334 for (i
= 0, section
= section_headers
;
4335 i
< elf_header
.e_shnum
;
4338 switch (section
->sh_type
)
4340 case SHT_GNU_verdef
:
4342 Elf_External_Verdef
* edefs
;
4349 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4350 SECTION_NAME (section
), section
->sh_info
);
4352 printf (_(" Addr: 0x"));
4353 printf_vma (section
->sh_addr
);
4354 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4355 (unsigned long) section
->sh_offset
, section
->sh_link
,
4356 SECTION_NAME (section_headers
+ section
->sh_link
));
4358 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
4359 edefs
, Elf_External_Verdef
*,
4360 "version definition section");
4362 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4365 Elf_External_Verdef
* edef
;
4366 Elf_Internal_Verdef ent
;
4367 Elf_External_Verdaux
* eaux
;
4368 Elf_Internal_Verdaux aux
;
4372 vstart
= ((char *) edefs
) + idx
;
4374 edef
= (Elf_External_Verdef
*) vstart
;
4376 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4377 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4378 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4379 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4380 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4381 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4382 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4384 printf (_(" %#06x: Rev: %d Flags: %s"),
4385 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4387 printf (_(" Index: %d Cnt: %d "),
4388 ent
.vd_ndx
, ent
.vd_cnt
);
4390 vstart
+= ent
.vd_aux
;
4392 eaux
= (Elf_External_Verdaux
*) vstart
;
4394 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4395 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4397 if (dynamic_strings
)
4398 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4400 printf (_("Name index: %ld\n"), aux
.vda_name
);
4402 isum
= idx
+ ent
.vd_aux
;
4404 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4406 isum
+= aux
.vda_next
;
4407 vstart
+= aux
.vda_next
;
4409 eaux
= (Elf_External_Verdaux
*) vstart
;
4411 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4412 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4414 if (dynamic_strings
)
4415 printf (_(" %#06x: Parent %d: %s\n"),
4416 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4418 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4419 isum
, j
, aux
.vda_name
);
4429 case SHT_GNU_verneed
:
4431 Elf_External_Verneed
* eneed
;
4437 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4438 SECTION_NAME (section
), section
->sh_info
);
4440 printf (_(" Addr: 0x"));
4441 printf_vma (section
->sh_addr
);
4442 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4443 (unsigned long) section
->sh_offset
, section
->sh_link
,
4444 SECTION_NAME (section_headers
+ section
->sh_link
));
4446 GET_DATA_ALLOC (section
->sh_offset
, section
->sh_size
,
4447 eneed
, Elf_External_Verneed
*,
4448 "version need section");
4450 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4452 Elf_External_Verneed
* entry
;
4453 Elf_Internal_Verneed ent
;
4458 vstart
= ((char *) eneed
) + idx
;
4460 entry
= (Elf_External_Verneed
*) vstart
;
4462 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4463 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4464 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4465 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4466 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4468 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
4470 if (dynamic_strings
)
4471 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
4473 printf (_(" File: %lx"), ent
.vn_file
);
4475 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
4477 vstart
+= ent
.vn_aux
;
4479 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
4481 Elf_External_Vernaux
* eaux
;
4482 Elf_Internal_Vernaux aux
;
4484 eaux
= (Elf_External_Vernaux
*) vstart
;
4486 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
4487 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
4488 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
4489 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
4490 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
4492 if (dynamic_strings
)
4493 printf (_(" %#06x: Name: %s"),
4494 isum
, dynamic_strings
+ aux
.vna_name
);
4496 printf (_(" %#06x: Name index: %lx"),
4497 isum
, aux
.vna_name
);
4499 printf (_(" Flags: %s Version: %d\n"),
4500 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
4502 isum
+= aux
.vna_next
;
4503 vstart
+= aux
.vna_next
;
4513 case SHT_GNU_versym
:
4515 Elf32_Internal_Shdr
* link_section
;
4518 unsigned char * edata
;
4519 unsigned short * data
;
4521 Elf_Internal_Sym
* symbols
;
4522 Elf32_Internal_Shdr
* string_sec
;
4524 link_section
= section_headers
+ section
->sh_link
;
4525 total
= section
->sh_size
/ section
->sh_entsize
;
4529 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
4530 link_section
->sh_size
/ link_section
->sh_entsize
);
4532 string_sec
= section_headers
+ link_section
->sh_link
;
4534 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4535 strtab
, char *, "version string table");
4537 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4538 SECTION_NAME (section
), total
);
4540 printf (_(" Addr: "));
4541 printf_vma (section
->sh_addr
);
4542 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4543 (unsigned long) section
->sh_offset
, section
->sh_link
,
4544 SECTION_NAME (link_section
));
4546 GET_DATA_ALLOC (version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
4548 total
* sizeof (short), edata
,
4549 unsigned char *, "version symbol data");
4551 data
= (unsigned short *) malloc (total
* sizeof (short));
4553 for (cnt
= total
; cnt
--;)
4554 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
4559 for (cnt
= 0; cnt
< total
; cnt
+= 4)
4562 int check_def
, check_need
;
4565 printf (" %03x:", cnt
);
4567 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
4568 switch (data
[cnt
+ j
])
4571 fputs (_(" 0 (*local*) "), stdout
);
4575 fputs (_(" 1 (*global*) "), stdout
);
4579 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
4580 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
4584 if (symbols
[cnt
+ j
].st_shndx
>= SHN_LORESERVE
4585 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
4588 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4595 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
4597 Elf_Internal_Verneed ivn
;
4598 unsigned long offset
;
4600 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4605 Elf_Internal_Vernaux ivna
;
4606 Elf_External_Verneed evn
;
4607 Elf_External_Vernaux evna
;
4608 unsigned long a_off
;
4610 GET_DATA (offset
, evn
, "version need");
4612 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4613 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4615 a_off
= offset
+ ivn
.vn_aux
;
4619 GET_DATA (a_off
, evna
,
4620 "version need aux (2)");
4622 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4623 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4625 a_off
+= ivna
.vna_next
;
4627 while (ivna
.vna_other
!= data
[cnt
+ j
]
4628 && ivna
.vna_next
!= 0);
4630 if (ivna
.vna_other
== data
[cnt
+ j
])
4632 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4634 name
= strtab
+ ivna
.vna_name
;
4635 nn
+= printf ("(%s%-*s",
4637 12 - (int) strlen (name
),
4643 offset
+= ivn
.vn_next
;
4645 while (ivn
.vn_next
);
4648 if (check_def
&& data
[cnt
+ j
] != 0x8001
4649 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
4651 Elf_Internal_Verdef ivd
;
4652 Elf_External_Verdef evd
;
4653 unsigned long offset
;
4655 offset
= version_info
4656 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4660 GET_DATA (offset
, evd
, "version def");
4662 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4663 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4665 offset
+= ivd
.vd_next
;
4667 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4668 && ivd
.vd_next
!= 0);
4670 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4672 Elf_External_Verdaux evda
;
4673 Elf_Internal_Verdaux ivda
;
4675 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4677 GET_DATA (offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4678 evda
, "version def aux");
4680 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4682 name
= strtab
+ ivda
.vda_name
;
4683 nn
+= printf ("(%s%-*s",
4685 12 - (int) strlen (name
),
4691 printf ("%*c", 18 - nn
, ' ');
4709 printf (_("\nNo version information found in this file.\n"));
4715 get_symbol_binding (binding
)
4716 unsigned int binding
;
4718 static char buff
[32];
4722 case STB_LOCAL
: return "LOCAL";
4723 case STB_GLOBAL
: return "GLOBAL";
4724 case STB_WEAK
: return "WEAK";
4726 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4727 sprintf (buff
, _("<processor specific>: %d"), binding
);
4728 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4729 sprintf (buff
, _("<OS specific>: %d"), binding
);
4731 sprintf (buff
, _("<unknown>: %d"), binding
);
4737 get_symbol_type (type
)
4740 static char buff
[32];
4744 case STT_NOTYPE
: return "NOTYPE";
4745 case STT_OBJECT
: return "OBJECT";
4746 case STT_FUNC
: return "FUNC";
4747 case STT_SECTION
: return "SECTION";
4748 case STT_FILE
: return "FILE";
4749 case STT_COMMON
: return "COMMON";
4751 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4753 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4754 return "THUMB_FUNC";
4756 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4759 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4760 return "PARISC_MILLI";
4762 sprintf (buff
, _("<processor specific>: %d"), type
);
4764 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4766 if (elf_header
.e_machine
== EM_PARISC
)
4768 if (type
== STT_HP_OPAQUE
)
4770 if (type
== STT_HP_STUB
)
4774 sprintf (buff
, _("<OS specific>: %d"), type
);
4777 sprintf (buff
, _("<unknown>: %d"), type
);
4783 get_symbol_visibility (visibility
)
4784 unsigned int visibility
;
4788 case STV_DEFAULT
: return "DEFAULT";
4789 case STV_INTERNAL
: return "INTERNAL";
4790 case STV_HIDDEN
: return "HIDDEN";
4791 case STV_PROTECTED
: return "PROTECTED";
4797 get_symbol_index_type (type
)
4802 case SHN_UNDEF
: return "UND";
4803 case SHN_ABS
: return "ABS";
4804 case SHN_COMMON
: return "COM";
4806 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4808 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4810 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4814 static char buff
[32];
4816 sprintf (buff
, "%3d", type
);
4823 get_dynamic_data (file
, number
)
4825 unsigned int number
;
4827 unsigned char * e_data
;
4830 e_data
= (unsigned char *) malloc (number
* 4);
4834 error (_("Out of memory\n"));
4838 if (fread (e_data
, 4, number
, file
) != number
)
4840 error (_("Unable to read in dynamic data\n"));
4844 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4848 error (_("Out of memory\n"));
4854 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4861 /* Dump the symbol table */
4863 process_symbol_table (file
)
4866 Elf32_Internal_Shdr
* section
;
4867 unsigned char nb
[4];
4868 unsigned char nc
[4];
4871 int * buckets
= NULL
;
4872 int * chains
= NULL
;
4874 if (! do_syms
&& !do_histogram
)
4877 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
4880 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
4882 error (_("Unable to seek to start of dynamic information"));
4886 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
4888 error (_("Failed to read in number of buckets\n"));
4892 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
4894 error (_("Failed to read in number of chains\n"));
4898 nbuckets
= byte_get (nb
, 4);
4899 nchains
= byte_get (nc
, 4);
4901 buckets
= get_dynamic_data (file
, nbuckets
);
4902 chains
= get_dynamic_data (file
, nchains
);
4904 if (buckets
== NULL
|| chains
== NULL
)
4909 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
4914 printf (_("\nSymbol table for image:\n"));
4916 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4918 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
4920 for (hn
= 0; hn
< nbuckets
; hn
++)
4925 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
4927 Elf_Internal_Sym
* psym
;
4929 psym
= dynamic_symbols
+ si
;
4931 printf (" %3d %3d: ", si
, hn
);
4932 print_vma (psym
->st_value
, LONG_HEX
);
4934 print_vma (psym
->st_size
, DEC_5
);
4936 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4937 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4938 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4939 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
4940 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
4944 else if (do_syms
&& !do_using_dynamic
)
4948 for (i
= 0, section
= section_headers
;
4949 i
< elf_header
.e_shnum
;
4954 Elf_Internal_Sym
* symtab
;
4955 Elf_Internal_Sym
* psym
;
4958 if ( section
->sh_type
!= SHT_SYMTAB
4959 && section
->sh_type
!= SHT_DYNSYM
)
4962 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
4963 SECTION_NAME (section
),
4964 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
4966 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4968 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
4970 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
4971 section
->sh_size
/ section
->sh_entsize
);
4975 if (section
->sh_link
== elf_header
.e_shstrndx
)
4976 strtab
= string_table
;
4979 Elf32_Internal_Shdr
* string_sec
;
4981 string_sec
= section_headers
+ section
->sh_link
;
4983 GET_DATA_ALLOC (string_sec
->sh_offset
, string_sec
->sh_size
,
4984 strtab
, char *, "string table");
4987 for (si
= 0, psym
= symtab
;
4988 si
< section
->sh_size
/ section
->sh_entsize
;
4991 printf ("%6d: ", si
);
4992 print_vma (psym
->st_value
, LONG_HEX
);
4994 print_vma (psym
->st_size
, DEC_5
);
4995 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
4996 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
4997 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
4998 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
4999 printf (" %s", strtab
+ psym
->st_name
);
5001 if (section
->sh_type
== SHT_DYNSYM
&&
5002 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5004 unsigned char data
[2];
5005 unsigned short vers_data
;
5006 unsigned long offset
;
5010 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5013 GET_DATA (offset
+ si
* sizeof (vers_data
), data
,
5016 vers_data
= byte_get (data
, 2);
5018 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
5019 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
5022 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5024 if ((vers_data
& 0x8000) || vers_data
> 1)
5026 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5027 && (is_nobits
|| ! check_def
))
5029 Elf_External_Verneed evn
;
5030 Elf_Internal_Verneed ivn
;
5031 Elf_Internal_Vernaux ivna
;
5033 /* We must test both. */
5034 offset
= version_info
5035 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5039 unsigned long vna_off
;
5041 GET_DATA (offset
, evn
, "version need");
5043 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5044 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5046 vna_off
= offset
+ ivn
.vn_aux
;
5050 Elf_External_Vernaux evna
;
5052 GET_DATA (vna_off
, evna
,
5053 "version need aux (3)");
5055 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5056 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5057 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5059 vna_off
+= ivna
.vna_next
;
5061 while (ivna
.vna_other
!= vers_data
5062 && ivna
.vna_next
!= 0);
5064 if (ivna
.vna_other
== vers_data
)
5067 offset
+= ivn
.vn_next
;
5069 while (ivn
.vn_next
!= 0);
5071 if (ivna
.vna_other
== vers_data
)
5074 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5077 else if (! is_nobits
)
5078 error (_("bad dynamic symbol"));
5085 if (vers_data
!= 0x8001
5086 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5088 Elf_Internal_Verdef ivd
;
5089 Elf_Internal_Verdaux ivda
;
5090 Elf_External_Verdaux evda
;
5091 unsigned long offset
;
5094 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5099 Elf_External_Verdef evd
;
5101 GET_DATA (offset
, evd
, "version def");
5103 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5104 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5105 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5107 offset
+= ivd
.vd_next
;
5109 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5110 && ivd
.vd_next
!= 0);
5112 offset
-= ivd
.vd_next
;
5113 offset
+= ivd
.vd_aux
;
5115 GET_DATA (offset
, evda
, "version def aux");
5117 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5119 if (psym
->st_name
!= ivda
.vda_name
)
5120 printf ((vers_data
& 0x8000)
5122 strtab
+ ivda
.vda_name
);
5132 if (strtab
!= string_table
)
5138 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5140 if (do_histogram
&& buckets
!= NULL
)
5147 int nzero_counts
= 0;
5150 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5152 printf (_(" Length Number %% of total Coverage\n"));
5154 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5155 if (lengths
== NULL
)
5157 error (_("Out of memory"));
5160 for (hn
= 0; hn
< nbuckets
; ++hn
)
5165 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5168 if (maxlength
< ++lengths
[hn
])
5173 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5176 error (_("Out of memory"));
5180 for (hn
= 0; hn
< nbuckets
; ++hn
)
5181 ++ counts
[lengths
[hn
]];
5185 printf (" 0 %-10d (%5.1f%%)\n",
5186 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5187 for (si
= 1; si
<= maxlength
; ++si
)
5189 nzero_counts
+= counts
[si
] * si
;
5190 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5191 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5192 (nzero_counts
* 100.0) / nsyms
);
5200 if (buckets
!= NULL
)
5210 process_syminfo (file
)
5211 FILE * file ATTRIBUTE_UNUSED
;
5215 if (dynamic_syminfo
== NULL
5217 /* No syminfo, this is ok. */
5220 /* There better should be a dynamic symbol section. */
5221 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5225 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5226 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5228 printf (_(" Num: Name BoundTo Flags\n"));
5229 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5231 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5233 printf ("%4d: %-30s ", i
,
5234 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5236 switch (dynamic_syminfo
[i
].si_boundto
)
5238 case SYMINFO_BT_SELF
:
5239 fputs ("SELF ", stdout
);
5241 case SYMINFO_BT_PARENT
:
5242 fputs ("PARENT ", stdout
);
5245 if (dynamic_syminfo
[i
].si_boundto
> 0
5246 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5249 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5251 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5255 if (flags
& SYMINFO_FLG_DIRECT
)
5257 if (flags
& SYMINFO_FLG_PASSTHRU
)
5258 printf (" PASSTHRU");
5259 if (flags
& SYMINFO_FLG_COPY
)
5261 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5262 printf (" LAZYLOAD");
5270 #ifdef SUPPORT_DISASSEMBLY
5272 disassemble_section (section
, file
)
5273 Elf32_Internal_Shdr
* section
;
5276 printf (_("\nAssembly dump of section %s\n"),
5277 SECTION_NAME (section
));
5279 /* XXX -- to be done --- XXX */
5286 dump_section (section
, file
)
5287 Elf32_Internal_Shdr
* section
;
5290 bfd_size_type bytes
;
5292 unsigned char * data
;
5293 unsigned char * start
;
5295 bytes
= section
->sh_size
;
5299 printf (_("\nSection '%s' has no data to dump.\n"),
5300 SECTION_NAME (section
));
5304 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5306 addr
= section
->sh_addr
;
5308 GET_DATA_ALLOC (section
->sh_offset
, bytes
, start
, unsigned char *,
5319 lbytes
= (bytes
> 16 ? 16 : bytes
);
5321 printf (" 0x%8.8lx ", (unsigned long) addr
);
5323 switch (elf_header
.e_ident
[EI_DATA
])
5327 for (j
= 15; j
>= 0; j
--)
5330 printf ("%2.2x", data
[j
]);
5340 for (j
= 0; j
< 16; j
++)
5343 printf ("%2.2x", data
[j
]);
5353 for (j
= 0; j
< lbytes
; j
++)
5356 if (k
>= ' ' && k
< 0x80)
5375 static unsigned long int
5376 read_leb128 (data
, length_return
, sign
)
5377 unsigned char * data
;
5378 int * length_return
;
5381 unsigned long int result
= 0;
5382 unsigned int num_read
= 0;
5391 result
|= (byte
& 0x7f) << shift
;
5396 while (byte
& 0x80);
5398 if (length_return
!= NULL
)
5399 * length_return
= num_read
;
5401 if (sign
&& (shift
< 32) && (byte
& 0x40))
5402 result
|= -1 << shift
;
5407 typedef struct State_Machine_Registers
5409 unsigned long address
;
5412 unsigned int column
;
5416 /* This variable hold the number of the last entry seen
5417 in the File Table. */
5418 unsigned int last_file_entry
;
5421 static SMR state_machine_regs
;
5424 reset_state_machine (is_stmt
)
5427 state_machine_regs
.address
= 0;
5428 state_machine_regs
.file
= 1;
5429 state_machine_regs
.line
= 1;
5430 state_machine_regs
.column
= 0;
5431 state_machine_regs
.is_stmt
= is_stmt
;
5432 state_machine_regs
.basic_block
= 0;
5433 state_machine_regs
.end_sequence
= 0;
5434 state_machine_regs
.last_file_entry
= 0;
5437 /* Handled an extend line op. Returns true if this is the end
5440 process_extended_line_op (data
, is_stmt
, pointer_size
)
5441 unsigned char * data
;
5445 unsigned char op_code
;
5448 unsigned char * name
;
5451 len
= read_leb128 (data
, & bytes_read
, 0);
5456 warn (_("badly formed extended line op encountered!"));
5461 op_code
= * data
++;
5463 printf (_(" Extended opcode %d: "), op_code
);
5467 case DW_LNE_end_sequence
:
5468 printf (_("End of Sequence\n\n"));
5469 reset_state_machine (is_stmt
);
5472 case DW_LNE_set_address
:
5473 adr
= byte_get (data
, pointer_size
);
5474 printf (_("set Address to 0x%lx\n"), adr
);
5475 state_machine_regs
.address
= adr
;
5478 case DW_LNE_define_file
:
5479 printf (_(" define new File Table entry\n"));
5480 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5482 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5484 data
+= strlen ((char *) data
) + 1;
5485 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5487 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5489 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5490 printf (_("%s\n\n"), name
);
5494 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
5501 /* Size of pointers in the .debug_line section. This information is not
5502 really present in that section. It's obtained before dumping the debug
5503 sections by doing some pre-scan of the .debug_info section. */
5504 static int debug_line_pointer_size
= 4;
5507 display_debug_lines (section
, start
, file
)
5508 Elf32_Internal_Shdr
* section
;
5509 unsigned char * start
;
5510 FILE * file ATTRIBUTE_UNUSED
;
5512 DWARF2_External_LineInfo
* external
;
5513 DWARF2_Internal_LineInfo info
;
5514 unsigned char * standard_opcodes
;
5515 unsigned char * data
= start
;
5516 unsigned char * end
= start
+ section
->sh_size
;
5517 unsigned char * end_of_sequence
;
5520 printf (_("\nDump of debug contents of section %s:\n\n"),
5521 SECTION_NAME (section
));
5525 external
= (DWARF2_External_LineInfo
*) data
;
5527 /* Check the length of the block. */
5528 info
.li_length
= BYTE_GET (external
->li_length
);
5529 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
5532 (_("The line info appears to be corrupt - the section is too small\n"));
5536 /* Check its version number. */
5537 info
.li_version
= BYTE_GET (external
->li_version
);
5538 if (info
.li_version
!= 2)
5540 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5544 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5545 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5546 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5547 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5548 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5549 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5551 /* Sign extend the line base field. */
5552 info
.li_line_base
<<= 24;
5553 info
.li_line_base
>>= 24;
5555 printf (_(" Length: %ld\n"), info
.li_length
);
5556 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5557 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
5558 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5559 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5560 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5561 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5562 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5564 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
5566 reset_state_machine (info
.li_default_is_stmt
);
5568 /* Display the contents of the Opcodes table. */
5569 standard_opcodes
= data
+ sizeof (* external
);
5571 printf (_("\n Opcodes:\n"));
5573 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5574 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5576 /* Display the contents of the Directory table. */
5577 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5580 printf (_("\n The Directory Table is empty.\n"));
5583 printf (_("\n The Directory Table:\n"));
5587 printf (_(" %s\n"), data
);
5589 data
+= strlen ((char *) data
) + 1;
5593 /* Skip the NUL at the end of the table. */
5596 /* Display the contents of the File Name table. */
5598 printf (_("\n The File Name Table is empty.\n"));
5601 printf (_("\n The File Name Table:\n"));
5602 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5606 unsigned char * name
;
5609 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5612 data
+= strlen ((char *) data
) + 1;
5614 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5616 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5618 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5620 printf (_("%s\n"), name
);
5624 /* Skip the NUL at the end of the table. */
5627 /* Now display the statements. */
5628 printf (_("\n Line Number Statements:\n"));
5631 while (data
< end_of_sequence
)
5633 unsigned char op_code
;
5637 op_code
= * data
++;
5641 case DW_LNS_extended_op
:
5642 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5643 debug_line_pointer_size
);
5647 printf (_(" Copy\n"));
5650 case DW_LNS_advance_pc
:
5651 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5653 state_machine_regs
.address
+= adv
;
5654 printf (_(" Advance PC by %d to %lx\n"), adv
,
5655 state_machine_regs
.address
);
5658 case DW_LNS_advance_line
:
5659 adv
= read_leb128 (data
, & bytes_read
, 1);
5661 state_machine_regs
.line
+= adv
;
5662 printf (_(" Advance Line by %d to %d\n"), adv
,
5663 state_machine_regs
.line
);
5666 case DW_LNS_set_file
:
5667 adv
= read_leb128 (data
, & bytes_read
, 0);
5669 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5671 state_machine_regs
.file
= adv
;
5674 case DW_LNS_set_column
:
5675 adv
= read_leb128 (data
, & bytes_read
, 0);
5677 printf (_(" Set column to %d\n"), adv
);
5678 state_machine_regs
.column
= adv
;
5681 case DW_LNS_negate_stmt
:
5682 adv
= state_machine_regs
.is_stmt
;
5684 printf (_(" Set is_stmt to %d\n"), adv
);
5685 state_machine_regs
.is_stmt
= adv
;
5688 case DW_LNS_set_basic_block
:
5689 printf (_(" Set basic block\n"));
5690 state_machine_regs
.basic_block
= 1;
5693 case DW_LNS_const_add_pc
:
5694 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5695 * info
.li_min_insn_length
);
5696 state_machine_regs
.address
+= adv
;
5697 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5698 state_machine_regs
.address
);
5701 case DW_LNS_fixed_advance_pc
:
5702 adv
= byte_get (data
, 2);
5704 state_machine_regs
.address
+= adv
;
5705 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5706 adv
, state_machine_regs
.address
);
5710 op_code
-= info
.li_opcode_base
;
5711 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5712 state_machine_regs
.address
+= adv
;
5713 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5714 op_code
, adv
, state_machine_regs
.address
);
5715 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5716 state_machine_regs
.line
+= adv
;
5717 printf (_(" and Line by %d to %d\n"),
5718 adv
, state_machine_regs
.line
);
5729 display_debug_pubnames (section
, start
, file
)
5730 Elf32_Internal_Shdr
* section
;
5731 unsigned char * start
;
5732 FILE * file ATTRIBUTE_UNUSED
;
5734 DWARF2_External_PubNames
* external
;
5735 DWARF2_Internal_PubNames pubnames
;
5736 unsigned char * end
;
5738 end
= start
+ section
->sh_size
;
5740 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5744 unsigned char * data
;
5745 unsigned long offset
;
5747 external
= (DWARF2_External_PubNames
*) start
;
5749 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5750 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5751 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5752 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5754 data
= start
+ sizeof (* external
);
5755 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5757 if (pubnames
.pn_version
!= 2)
5759 static int warned
= 0;
5763 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5770 printf (_(" Length: %ld\n"),
5771 pubnames
.pn_length
);
5772 printf (_(" Version: %d\n"),
5773 pubnames
.pn_version
);
5774 printf (_(" Offset into .debug_info section: %ld\n"),
5775 pubnames
.pn_offset
);
5776 printf (_(" Size of area in .debug_info section: %ld\n"),
5779 printf (_("\n Offset\tName\n"));
5783 offset
= byte_get (data
, 4);
5788 printf (" %ld\t\t%s\n", offset
, data
);
5789 data
+= strlen ((char *) data
) + 1;
5792 while (offset
!= 0);
5805 case DW_TAG_padding
: return "DW_TAG_padding";
5806 case DW_TAG_array_type
: return "DW_TAG_array_type";
5807 case DW_TAG_class_type
: return "DW_TAG_class_type";
5808 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5809 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5810 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5811 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5812 case DW_TAG_label
: return "DW_TAG_label";
5813 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5814 case DW_TAG_member
: return "DW_TAG_member";
5815 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5816 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5817 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5818 case DW_TAG_string_type
: return "DW_TAG_string_type";
5819 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5820 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5821 case DW_TAG_typedef
: return "DW_TAG_typedef";
5822 case DW_TAG_union_type
: return "DW_TAG_union_type";
5823 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5824 case DW_TAG_variant
: return "DW_TAG_variant";
5825 case DW_TAG_common_block
: return "DW_TAG_common_block";
5826 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5827 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5828 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5829 case DW_TAG_module
: return "DW_TAG_module";
5830 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5831 case DW_TAG_set_type
: return "DW_TAG_set_type";
5832 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5833 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5834 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5835 case DW_TAG_base_type
: return "DW_TAG_base_type";
5836 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5837 case DW_TAG_const_type
: return "DW_TAG_const_type";
5838 case DW_TAG_constant
: return "DW_TAG_constant";
5839 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5840 case DW_TAG_file_type
: return "DW_TAG_file_type";
5841 case DW_TAG_friend
: return "DW_TAG_friend";
5842 case DW_TAG_namelist
: return "DW_TAG_namelist";
5843 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5844 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5845 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5846 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5847 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5848 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5849 case DW_TAG_try_block
: return "DW_TAG_try_block";
5850 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5851 case DW_TAG_variable
: return "DW_TAG_variable";
5852 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5853 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5854 case DW_TAG_format_label
: return "DW_TAG_format_label";
5855 case DW_TAG_function_template
: return "DW_TAG_function_template";
5856 case DW_TAG_class_template
: return "DW_TAG_class_template";
5859 static char buffer
[100];
5861 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
5868 get_AT_name (attribute
)
5869 unsigned long attribute
;
5873 case DW_AT_sibling
: return "DW_AT_sibling";
5874 case DW_AT_location
: return "DW_AT_location";
5875 case DW_AT_name
: return "DW_AT_name";
5876 case DW_AT_ordering
: return "DW_AT_ordering";
5877 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
5878 case DW_AT_byte_size
: return "DW_AT_byte_size";
5879 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
5880 case DW_AT_bit_size
: return "DW_AT_bit_size";
5881 case DW_AT_element_list
: return "DW_AT_element_list";
5882 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
5883 case DW_AT_low_pc
: return "DW_AT_low_pc";
5884 case DW_AT_high_pc
: return "DW_AT_high_pc";
5885 case DW_AT_language
: return "DW_AT_language";
5886 case DW_AT_member
: return "DW_AT_member";
5887 case DW_AT_discr
: return "DW_AT_discr";
5888 case DW_AT_discr_value
: return "DW_AT_discr_value";
5889 case DW_AT_visibility
: return "DW_AT_visibility";
5890 case DW_AT_import
: return "DW_AT_import";
5891 case DW_AT_string_length
: return "DW_AT_string_length";
5892 case DW_AT_common_reference
: return "DW_AT_common_reference";
5893 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
5894 case DW_AT_const_value
: return "DW_AT_const_value";
5895 case DW_AT_containing_type
: return "DW_AT_containing_type";
5896 case DW_AT_default_value
: return "DW_AT_default_value";
5897 case DW_AT_inline
: return "DW_AT_inline";
5898 case DW_AT_is_optional
: return "DW_AT_is_optional";
5899 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
5900 case DW_AT_producer
: return "DW_AT_producer";
5901 case DW_AT_prototyped
: return "DW_AT_prototyped";
5902 case DW_AT_return_addr
: return "DW_AT_return_addr";
5903 case DW_AT_start_scope
: return "DW_AT_start_scope";
5904 case DW_AT_stride_size
: return "DW_AT_stride_size";
5905 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
5906 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
5907 case DW_AT_accessibility
: return "DW_AT_accessibility";
5908 case DW_AT_address_class
: return "DW_AT_address_class";
5909 case DW_AT_artificial
: return "DW_AT_artificial";
5910 case DW_AT_base_types
: return "DW_AT_base_types";
5911 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
5912 case DW_AT_count
: return "DW_AT_count";
5913 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
5914 case DW_AT_decl_column
: return "DW_AT_decl_column";
5915 case DW_AT_decl_file
: return "DW_AT_decl_file";
5916 case DW_AT_decl_line
: return "DW_AT_decl_line";
5917 case DW_AT_declaration
: return "DW_AT_declaration";
5918 case DW_AT_discr_list
: return "DW_AT_discr_list";
5919 case DW_AT_encoding
: return "DW_AT_encoding";
5920 case DW_AT_external
: return "DW_AT_external";
5921 case DW_AT_frame_base
: return "DW_AT_frame_base";
5922 case DW_AT_friend
: return "DW_AT_friend";
5923 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
5924 case DW_AT_macro_info
: return "DW_AT_macro_info";
5925 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
5926 case DW_AT_priority
: return "DW_AT_priority";
5927 case DW_AT_segment
: return "DW_AT_segment";
5928 case DW_AT_specification
: return "DW_AT_specification";
5929 case DW_AT_static_link
: return "DW_AT_static_link";
5930 case DW_AT_type
: return "DW_AT_type";
5931 case DW_AT_use_location
: return "DW_AT_use_location";
5932 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
5933 case DW_AT_virtuality
: return "DW_AT_virtuality";
5934 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
5935 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
5936 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
5937 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
5938 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
5939 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
5940 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
5941 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
5942 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
5943 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
5944 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
5945 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
5946 case DW_AT_sf_names
: return "DW_AT_sf_names";
5947 case DW_AT_src_info
: return "DW_AT_src_info";
5948 case DW_AT_mac_info
: return "DW_AT_mac_info";
5949 case DW_AT_src_coords
: return "DW_AT_src_coords";
5950 case DW_AT_body_begin
: return "DW_AT_body_begin";
5951 case DW_AT_body_end
: return "DW_AT_body_end";
5954 static char buffer
[100];
5956 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
5963 get_FORM_name (form
)
5968 case DW_FORM_addr
: return "DW_FORM_addr";
5969 case DW_FORM_block2
: return "DW_FORM_block2";
5970 case DW_FORM_block4
: return "DW_FORM_block4";
5971 case DW_FORM_data2
: return "DW_FORM_data2";
5972 case DW_FORM_data4
: return "DW_FORM_data4";
5973 case DW_FORM_data8
: return "DW_FORM_data8";
5974 case DW_FORM_string
: return "DW_FORM_string";
5975 case DW_FORM_block
: return "DW_FORM_block";
5976 case DW_FORM_block1
: return "DW_FORM_block1";
5977 case DW_FORM_data1
: return "DW_FORM_data1";
5978 case DW_FORM_flag
: return "DW_FORM_flag";
5979 case DW_FORM_sdata
: return "DW_FORM_sdata";
5980 case DW_FORM_strp
: return "DW_FORM_strp";
5981 case DW_FORM_udata
: return "DW_FORM_udata";
5982 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
5983 case DW_FORM_ref1
: return "DW_FORM_ref1";
5984 case DW_FORM_ref2
: return "DW_FORM_ref2";
5985 case DW_FORM_ref4
: return "DW_FORM_ref4";
5986 case DW_FORM_ref8
: return "DW_FORM_ref8";
5987 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
5988 case DW_FORM_indirect
: return "DW_FORM_indirect";
5991 static char buffer
[100];
5993 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
5999 /* FIXME: There are better and more effiecint ways to handle
6000 these structures. For now though, I just want something that
6001 is simple to implement. */
6002 typedef struct abbrev_attr
6004 unsigned long attribute
;
6006 struct abbrev_attr
* next
;
6010 typedef struct abbrev_entry
6012 unsigned long entry
;
6015 struct abbrev_attr
* first_attr
;
6016 struct abbrev_attr
* last_attr
;
6017 struct abbrev_entry
* next
;
6021 static abbrev_entry
* first_abbrev
= NULL
;
6022 static abbrev_entry
* last_abbrev
= NULL
;
6025 free_abbrevs
PARAMS ((void))
6027 abbrev_entry
* abbrev
;
6029 for (abbrev
= first_abbrev
; abbrev
;)
6031 abbrev_entry
* next
= abbrev
->next
;
6034 for (attr
= abbrev
->first_attr
; attr
;)
6036 abbrev_attr
* next
= attr
->next
;
6046 last_abbrev
= first_abbrev
= NULL
;
6050 add_abbrev (number
, tag
, children
)
6051 unsigned long number
;
6055 abbrev_entry
* entry
;
6057 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6063 entry
->entry
= number
;
6065 entry
->children
= children
;
6066 entry
->first_attr
= NULL
;
6067 entry
->last_attr
= NULL
;
6070 if (first_abbrev
== NULL
)
6071 first_abbrev
= entry
;
6073 last_abbrev
->next
= entry
;
6075 last_abbrev
= entry
;
6079 add_abbrev_attr (attribute
, form
)
6080 unsigned long attribute
;
6085 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6091 attr
->attribute
= attribute
;
6095 if (last_abbrev
->first_attr
== NULL
)
6096 last_abbrev
->first_attr
= attr
;
6098 last_abbrev
->last_attr
->next
= attr
;
6100 last_abbrev
->last_attr
= attr
;
6103 /* Processes the (partial) contents of a .debug_abbrev section.
6104 Returns NULL if the end of the section was encountered.
6105 Returns the address after the last byte read if the end of
6106 an abbreviation set was found. */
6108 static unsigned char *
6109 process_abbrev_section (start
, end
)
6110 unsigned char * start
;
6111 unsigned char * end
;
6113 if (first_abbrev
!= NULL
)
6119 unsigned long entry
;
6121 unsigned long attribute
;
6124 entry
= read_leb128 (start
, & bytes_read
, 0);
6125 start
+= bytes_read
;
6127 /* A single zero is supposed to end the section according
6128 to the standard. If there's more, then signal that to
6131 return start
== end
? NULL
: start
;
6133 tag
= read_leb128 (start
, & bytes_read
, 0);
6134 start
+= bytes_read
;
6136 children
= * start
++;
6138 add_abbrev (entry
, tag
, children
);
6144 attribute
= read_leb128 (start
, & bytes_read
, 0);
6145 start
+= bytes_read
;
6147 form
= read_leb128 (start
, & bytes_read
, 0);
6148 start
+= bytes_read
;
6151 add_abbrev_attr (attribute
, form
);
6153 while (attribute
!= 0);
6161 display_debug_abbrev (section
, start
, file
)
6162 Elf32_Internal_Shdr
* section
;
6163 unsigned char * start
;
6164 FILE * file ATTRIBUTE_UNUSED
;
6166 abbrev_entry
* entry
;
6167 unsigned char * end
= start
+ section
->sh_size
;
6169 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6173 start
= process_abbrev_section (start
, end
);
6175 printf (_(" Number TAG\n"));
6177 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6181 printf (_(" %ld %s [%s]\n"),
6183 get_TAG_name (entry
->tag
),
6184 entry
->children
? _("has children") : _("no children"));
6186 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6188 printf (_(" %-18s %s\n"),
6189 get_AT_name (attr
->attribute
),
6190 get_FORM_name (attr
->form
));
6202 static unsigned char *
6203 display_block (data
, length
)
6204 unsigned char * data
;
6205 unsigned long length
;
6207 printf (_(" %lu byte block: "), length
);
6210 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6216 decode_location_expression (data
, pointer_size
, length
)
6217 unsigned char * data
;
6218 unsigned int pointer_size
;
6219 unsigned long length
;
6223 unsigned long uvalue
;
6224 unsigned char * end
= data
+ length
;
6233 printf ("DW_OP_addr: %lx",
6234 (unsigned long) byte_get (data
, pointer_size
));
6235 data
+= pointer_size
;
6238 printf ("DW_OP_deref");
6241 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6244 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6247 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6251 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6255 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6259 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6263 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6264 (unsigned long) byte_get (data
+ 4, 4));
6268 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6269 (long) byte_get (data
+ 4, 4));
6273 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6277 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6281 printf ("DW_OP_dup");
6284 printf ("DW_OP_drop");
6287 printf ("DW_OP_over");
6290 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6293 printf ("DW_OP_swap");
6296 printf ("DW_OP_rot");
6299 printf ("DW_OP_xderef");
6302 printf ("DW_OP_abs");
6305 printf ("DW_OP_and");
6308 printf ("DW_OP_div");
6311 printf ("DW_OP_minus");
6314 printf ("DW_OP_mod");
6317 printf ("DW_OP_mul");
6320 printf ("DW_OP_neg");
6323 printf ("DW_OP_not");
6326 printf ("DW_OP_or");
6329 printf ("DW_OP_plus");
6331 case DW_OP_plus_uconst
:
6332 printf ("DW_OP_plus_uconst: %lu",
6333 read_leb128 (data
, &bytes_read
, 0));
6337 printf ("DW_OP_shl");
6340 printf ("DW_OP_shr");
6343 printf ("DW_OP_shra");
6346 printf ("DW_OP_xor");
6349 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
6353 printf ("DW_OP_eq");
6356 printf ("DW_OP_ge");
6359 printf ("DW_OP_gt");
6362 printf ("DW_OP_le");
6365 printf ("DW_OP_lt");
6368 printf ("DW_OP_ne");
6371 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
6407 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
6442 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
6477 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
6478 read_leb128 (data
, &bytes_read
, 1));
6483 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
6487 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
6491 uvalue
= read_leb128 (data
, &bytes_read
, 0);
6493 printf ("DW_OP_bregx: %lu %ld", uvalue
,
6494 read_leb128 (data
, &bytes_read
, 1));
6498 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
6501 case DW_OP_deref_size
:
6502 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
6504 case DW_OP_xderef_size
:
6505 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
6508 printf ("DW_OP_nop");
6512 if (op
>= DW_OP_lo_user
6513 && op
<= DW_OP_hi_user
)
6514 printf (_("(User defined location op)"));
6516 printf (_("(Unknown location op)"));
6517 /* No way to tell where the next op is, so just bail. */
6524 static unsigned char *
6525 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
6526 unsigned long attribute
;
6528 unsigned char * data
;
6529 unsigned long cu_offset
;
6530 unsigned long pointer_size
;
6532 unsigned long uvalue
= 0;
6533 unsigned char * block_start
= NULL
;
6536 printf (" %-18s:", get_AT_name (attribute
));
6543 case DW_FORM_ref_addr
:
6545 uvalue
= byte_get (data
, pointer_size
);
6546 data
+= pointer_size
;
6552 uvalue
= byte_get (data
++, 1);
6557 uvalue
= byte_get (data
, 2);
6563 uvalue
= byte_get (data
, 4);
6568 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6572 case DW_FORM_ref_udata
:
6574 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6581 case DW_FORM_ref_addr
:
6582 printf (" <#%lx>", uvalue
);
6588 case DW_FORM_ref_udata
:
6589 printf (" <%lx>", uvalue
+ cu_offset
);
6593 printf (" %#lx", uvalue
);
6601 printf (" %ld", uvalue
);
6606 uvalue
= byte_get (data
, 4);
6607 printf (" %lx", uvalue
);
6608 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6612 case DW_FORM_string
:
6613 printf (" %s", data
);
6614 data
+= strlen ((char *) data
) + 1;
6618 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6619 block_start
= data
+ bytes_read
;
6620 data
= display_block (block_start
, uvalue
);
6623 case DW_FORM_block1
:
6624 uvalue
= byte_get (data
, 1);
6625 block_start
= data
+ 1;
6626 data
= display_block (block_start
, uvalue
);
6629 case DW_FORM_block2
:
6630 uvalue
= byte_get (data
, 2);
6631 block_start
= data
+ 2;
6632 data
= display_block (block_start
, uvalue
);
6635 case DW_FORM_block4
:
6636 uvalue
= byte_get (data
, 4);
6637 block_start
= data
+ 4;
6638 data
= display_block (block_start
, uvalue
);
6642 case DW_FORM_indirect
:
6643 warn (_("Unable to handle FORM: %d"), form
);
6647 warn (_("Unrecognised form: %d"), form
);
6651 /* For some attributes we can display futher information. */
6660 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6661 case DW_INL_inlined
: printf (_("(inlined)")); break;
6662 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6663 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6664 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6668 case DW_AT_language
:
6671 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6672 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6673 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6674 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6675 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6676 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6677 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6678 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6679 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6680 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6681 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6682 default: printf ("(Unknown: %lx)", uvalue
); break;
6686 case DW_AT_encoding
:
6689 case DW_ATE_void
: printf ("(void)"); break;
6690 case DW_ATE_address
: printf ("(machine address)"); break;
6691 case DW_ATE_boolean
: printf ("(boolean)"); break;
6692 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6693 case DW_ATE_float
: printf ("(float)"); break;
6694 case DW_ATE_signed
: printf ("(signed)"); break;
6695 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6696 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6697 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6699 if (uvalue
>= DW_ATE_lo_user
6700 && uvalue
<= DW_ATE_hi_user
)
6701 printf ("(user defined type)");
6703 printf ("(unknown type)");
6708 case DW_AT_accessibility
:
6711 case DW_ACCESS_public
: printf ("(public)"); break;
6712 case DW_ACCESS_protected
: printf ("(protected)"); break;
6713 case DW_ACCESS_private
: printf ("(private)"); break;
6714 default: printf ("(unknown accessibility)"); break;
6718 case DW_AT_visibility
:
6721 case DW_VIS_local
: printf ("(local)"); break;
6722 case DW_VIS_exported
: printf ("(exported)"); break;
6723 case DW_VIS_qualified
: printf ("(qualified)"); break;
6724 default: printf ("(unknown visibility)"); break;
6728 case DW_AT_virtuality
:
6731 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6732 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6733 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6734 default: printf ("(unknown virtuality)"); break;
6738 case DW_AT_identifier_case
:
6741 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6742 case DW_ID_up_case
: printf ("(up_case)"); break;
6743 case DW_ID_down_case
: printf ("(down_case)"); break;
6744 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6745 default: printf ("(unknown case)"); break;
6749 case DW_AT_calling_convention
:
6752 case DW_CC_normal
: printf ("(normal)"); break;
6753 case DW_CC_program
: printf ("(program)"); break;
6754 case DW_CC_nocall
: printf ("(nocall)"); break;
6756 if (uvalue
>= DW_CC_lo_user
6757 && uvalue
<= DW_CC_hi_user
)
6758 printf ("(user defined)");
6760 printf ("(unknown convention)");
6764 case DW_AT_frame_base
:
6765 case DW_AT_location
:
6766 case DW_AT_data_member_location
:
6767 case DW_AT_vtable_elem_location
:
6771 decode_location_expression (block_start
, pointer_size
, uvalue
);
6785 display_debug_info (section
, start
, file
)
6786 Elf32_Internal_Shdr
* section
;
6787 unsigned char * start
;
6790 unsigned char * end
= start
+ section
->sh_size
;
6791 unsigned char * section_begin
= start
;
6793 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6797 DWARF2_External_CompUnit
* external
;
6798 DWARF2_Internal_CompUnit compunit
;
6799 unsigned char * tags
;
6802 unsigned long cu_offset
;
6804 external
= (DWARF2_External_CompUnit
*) start
;
6806 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
6807 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
6808 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
6809 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
6811 tags
= start
+ sizeof (* external
);
6812 cu_offset
= start
- section_begin
;
6813 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
6815 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
6816 printf (_(" Length: %ld\n"), compunit
.cu_length
);
6817 printf (_(" Version: %d\n"), compunit
.cu_version
);
6818 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
6819 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
6821 if (compunit
.cu_version
!= 2)
6823 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
6827 if (first_abbrev
!= NULL
)
6830 /* Read in the abbrevs used by this compilation unit. */
6833 Elf32_Internal_Shdr
* sec
;
6834 unsigned char * begin
;
6836 /* Locate the .debug_abbrev section and process it. */
6837 for (i
= 0, sec
= section_headers
;
6838 i
< elf_header
.e_shnum
;
6840 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
6843 if (i
== -1 || sec
->sh_size
== 0)
6845 warn (_("Unable to locate .debug_abbrev section!\n"));
6849 GET_DATA_ALLOC (sec
->sh_offset
, sec
->sh_size
, begin
, unsigned char *,
6850 "debug_abbrev section data");
6852 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
6853 begin
+ sec
->sh_size
);
6859 while (tags
< start
)
6862 unsigned long abbrev_number
;
6863 abbrev_entry
* entry
;
6866 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
6869 /* A null DIE marks the end of a list of children. */
6870 if (abbrev_number
== 0)
6876 /* Scan through the abbreviation list until we reach the
6878 for (entry
= first_abbrev
;
6879 entry
&& entry
->entry
!= abbrev_number
;
6880 entry
= entry
->next
)
6885 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
6890 printf (_(" <%d><%x>: Abbrev Number: %lu (%s)\n"),
6891 level
, tags
- section_begin
- bytes_read
,
6893 get_TAG_name (entry
->tag
));
6895 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6896 tags
= read_and_display_attr (attr
->attribute
,
6899 compunit
.cu_pointer_size
);
6901 if (entry
->children
)
6912 display_debug_aranges (section
, start
, file
)
6913 Elf32_Internal_Shdr
* section
;
6914 unsigned char * start
;
6915 FILE * file ATTRIBUTE_UNUSED
;
6917 unsigned char * end
= start
+ section
->sh_size
;
6919 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
6923 DWARF2_External_ARange
* external
;
6924 DWARF2_Internal_ARange arange
;
6925 unsigned char * ranges
;
6926 unsigned long length
;
6927 unsigned long address
;
6930 external
= (DWARF2_External_ARange
*) start
;
6932 arange
.ar_length
= BYTE_GET (external
->ar_length
);
6933 arange
.ar_version
= BYTE_GET (external
->ar_version
);
6934 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
6935 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
6936 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
6938 if (arange
.ar_version
!= 2)
6940 warn (_("Only DWARF 2 aranges are currently supported.\n"));
6944 printf (_(" Length: %ld\n"), arange
.ar_length
);
6945 printf (_(" Version: %d\n"), arange
.ar_version
);
6946 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
6947 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
6948 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
6950 printf (_("\n Address Length\n"));
6952 ranges
= start
+ sizeof (* external
);
6954 /* Must pad to an alignment boundary that is twice the pointer size. */
6955 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
6957 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
6961 address
= byte_get (ranges
, arange
.ar_pointer_size
);
6963 ranges
+= arange
.ar_pointer_size
;
6965 length
= byte_get (ranges
, arange
.ar_pointer_size
);
6967 ranges
+= arange
.ar_pointer_size
;
6969 /* A pair of zeros marks the end of the list. */
6970 if (address
== 0 && length
== 0)
6973 printf (" %8.8lx %lu\n", address
, length
);
6976 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
6984 typedef struct Frame_Chunk
6986 struct Frame_Chunk
* next
;
6987 unsigned char * chunk_start
;
6989 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
6990 short int * col_type
;
6992 char * augmentation
;
6993 unsigned int code_factor
;
6994 unsigned int data_factor
;
6995 unsigned long pc_begin
;
6996 unsigned long pc_range
;
7003 /* A marker for a col_type that means this column was never referenced
7004 in the frame info. */
7005 #define DW_CFA_unreferenced (-1)
7008 frame_need_space (fc
, reg
)
7012 int prev
= fc
->ncols
;
7014 if (reg
< fc
->ncols
)
7017 fc
->ncols
= reg
+ 1;
7018 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
7019 fc
->ncols
* sizeof (short int));
7020 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
7021 fc
->ncols
* sizeof (int));
7023 while (prev
< fc
->ncols
)
7025 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7026 fc
->col_offset
[prev
] = 0;
7032 frame_display_row (fc
, need_col_headers
, max_regs
)
7034 int * need_col_headers
;
7040 if (* max_regs
< fc
->ncols
)
7041 * max_regs
= fc
->ncols
;
7043 if (* need_col_headers
)
7045 * need_col_headers
= 0;
7047 printf (" LOC CFA ");
7049 for (r
= 0; r
< * max_regs
; r
++)
7050 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7055 printf ("r%-4d", r
);
7061 printf ("%08x ", (unsigned int) fc
->pc_begin
);
7062 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
7063 printf ("%-8s ", tmp
);
7065 for (r
= 0; r
< fc
->ncols
; r
++)
7067 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7069 switch (fc
->col_type
[r
])
7071 case DW_CFA_undefined
:
7074 case DW_CFA_same_value
:
7078 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7080 case DW_CFA_register
:
7081 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
7084 strcpy (tmp
, "n/a");
7087 printf ("%-5s", tmp
);
7093 #define GET(N) byte_get (start, N); start += N
7094 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7095 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7098 display_debug_frames (section
, start
, file
)
7099 Elf32_Internal_Shdr
* section
;
7100 unsigned char * start
;
7101 FILE * file ATTRIBUTE_UNUSED
;
7103 unsigned char * end
= start
+ section
->sh_size
;
7104 unsigned char * section_start
= start
;
7105 Frame_Chunk
* chunks
= 0;
7106 Frame_Chunk
* remembered_state
= 0;
7108 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
7112 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
7116 unsigned char * saved_start
;
7117 unsigned char * block_end
;
7118 unsigned long length
;
7119 unsigned long cie_id
;
7122 int need_col_headers
= 1;
7124 saved_start
= start
;
7125 length
= byte_get (start
, 4); start
+= 4;
7130 block_end
= saved_start
+ length
+ 4;
7131 cie_id
= byte_get (start
, 4); start
+= 4;
7133 printf ("\n%08x %08lx %08lx ", saved_start
- section_start
, length
, cie_id
);
7135 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
7137 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7138 memset (fc
, 0, sizeof (Frame_Chunk
));
7142 fc
->chunk_start
= saved_start
;
7144 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7145 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7146 frame_need_space (fc
, max_regs
-1);
7148 start
++; /* version */
7149 fc
->augmentation
= start
;
7154 start
++; /* skip past NUL */
7156 if (fc
->augmentation
[0] == 'z')
7159 fc
->code_factor
= LEB ();
7160 fc
->data_factor
= SLEB ();
7161 fc
->ra
= byte_get (start
, 1); start
+= 1;
7163 printf ("skipping %d extra bytes\n", xtra
);
7166 else if (strcmp (fc
->augmentation
, "eh") == 0)
7169 fc
->code_factor
= LEB ();
7170 fc
->data_factor
= SLEB ();
7171 fc
->ra
= byte_get (start
, 1); start
+= 1;
7175 fc
->code_factor
= LEB ();
7176 fc
->data_factor
= SLEB ();
7177 fc
->ra
= byte_get (start
, 1); start
+= 1;
7180 printf ("CIE \"%s\" cf=%d df=%d ra=%d\n",
7181 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
, fc
->ra
);
7183 frame_need_space (fc
, fc
->ra
);
7187 unsigned char * look_for
;
7188 static Frame_Chunk fde_fc
;
7191 memset (fc
, 0, sizeof (Frame_Chunk
));
7193 look_for
= is_eh
? start
-4-cie_id
: (unsigned char *) cie_id
;
7195 fc
->pc_begin
= byte_get (start
, 4); start
+= 4;
7196 fc
->pc_range
= byte_get (start
, 4); start
+= 4;
7198 for (cie
=chunks
; cie
&& (cie
->chunk_start
!= look_for
); cie
= cie
->next
);
7201 warn ("Invalid CIE pointer %08x in FDE at %08x\n", cie_id
, saved_start
);
7204 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7205 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7206 frame_need_space (fc
, max_regs
- 1);
7208 fc
->augmentation
= "";
7212 fc
->ncols
= cie
->ncols
;
7213 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
7214 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
7215 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7216 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7217 fc
->augmentation
= cie
->augmentation
;
7218 fc
->code_factor
= cie
->code_factor
;
7219 fc
->data_factor
= cie
->data_factor
;
7220 fc
->cfa_reg
= cie
->cfa_reg
;
7221 fc
->cfa_offset
= cie
->cfa_offset
;
7223 frame_need_space (fc
, max_regs
-1);
7226 if (cie
->augmentation
[0] == 'z')
7228 unsigned long l
= LEB ();
7232 printf ("FDE cie=%08x pc=%08lx..%08lx\n",
7233 cie
->chunk_start
-section_start
, fc
->pc_begin
,
7234 fc
->pc_begin
+ fc
->pc_range
);
7237 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7238 about to interpret instructions for the chunk. */
7240 /* This exists for readelf maintainers. */
7244 /* Start by making a pass over the chunk, allocating storage
7245 and taking note of what registers are used. */
7246 unsigned char * tmp
= start
;
7248 while (start
< block_end
)
7259 /* Warning: if you add any more cases to this switch, be
7260 sure to add them to the corresponding switch below. */
7263 case DW_CFA_advance_loc
:
7267 frame_need_space (fc
, opa
);
7268 fc
->col_type
[opa
] = DW_CFA_undefined
;
7270 case DW_CFA_restore
:
7271 frame_need_space (fc
, opa
);
7272 fc
->col_type
[opa
] = DW_CFA_undefined
;
7274 case DW_CFA_set_loc
:
7275 start
+= sizeof (vma
);
7277 case DW_CFA_advance_loc1
:
7280 case DW_CFA_advance_loc2
:
7283 case DW_CFA_advance_loc4
:
7286 case DW_CFA_offset_extended
:
7287 reg
= LEB (); LEB ();
7288 frame_need_space (fc
, reg
);
7289 fc
->col_type
[reg
] = DW_CFA_undefined
;
7291 case DW_CFA_restore_extended
:
7293 frame_need_space (fc
, reg
);
7294 fc
->col_type
[reg
] = DW_CFA_undefined
;
7296 case DW_CFA_undefined
:
7298 frame_need_space (fc
, reg
);
7299 fc
->col_type
[reg
] = DW_CFA_undefined
;
7301 case DW_CFA_same_value
:
7303 frame_need_space (fc
, reg
);
7304 fc
->col_type
[reg
] = DW_CFA_undefined
;
7306 case DW_CFA_register
:
7307 reg
= LEB (); LEB ();
7308 frame_need_space (fc
, reg
);
7309 fc
->col_type
[reg
] = DW_CFA_undefined
;
7311 case DW_CFA_def_cfa
:
7314 case DW_CFA_def_cfa_register
:
7317 case DW_CFA_def_cfa_offset
:
7320 #ifndef DW_CFA_GNU_args_size
7321 #define DW_CFA_GNU_args_size 0x2e
7323 case DW_CFA_GNU_args_size
:
7326 #ifndef DW_CFA_GNU_negative_offset_extended
7327 #define DW_CFA_GNU_negative_offset_extended 0x2f
7329 case DW_CFA_GNU_negative_offset_extended
:
7330 reg
= LEB (); LEB ();
7331 frame_need_space (fc
, reg
);
7332 fc
->col_type
[reg
] = DW_CFA_undefined
;
7341 /* Now we know what registers are used, make a second pass over
7342 the chunk, this time actually printing out the info. */
7344 while (start
< block_end
)
7347 unsigned long ul
, reg
, roffs
;
7356 /* Warning: if you add any more cases to this switch, be
7357 sure to add them to the corresponding switch above. */
7360 case DW_CFA_advance_loc
:
7361 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7363 printf (" DW_CFA_advance_loc: %08x = %08x + %d*%d\n",
7364 fc
->pc_begin
+ opa
* fc
->code_factor
, fc
->pc_begin
, opa
, fc
->code_factor
);
7366 fc
->pc_begin
+= opa
* fc
->code_factor
;
7372 printf (" DW_CFA_offset: r%d = cfa[%d*%d]\n", opa
, roffs
, fc
->data_factor
);
7374 fc
->col_type
[opa
] = DW_CFA_offset
;
7375 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7378 case DW_CFA_restore
:
7380 printf (" DW_CFA_restore: r%d\n", opa
);
7382 fc
->col_type
[opa
] = cie
->col_type
[opa
];
7383 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
7386 case DW_CFA_set_loc
:
7387 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7388 vma
= byte_get (start
, sizeof (vma
)); start
+= sizeof (vma
);
7390 printf (" DW_CFA_set_loc: %08x\n", vma
);
7395 case DW_CFA_advance_loc1
:
7396 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7397 ofs
= byte_get (start
, 1); start
+= 1;
7399 printf (" DW_CFA_advance_loc1: %08x = %08x + %d*%d\n",
7400 fc
->pc_begin
+ ofs
* fc
->code_factor
, fc
->pc_begin
, ofs
, fc
->code_factor
);
7402 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7405 case DW_CFA_advance_loc2
:
7406 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7407 ofs
= byte_get (start
, 2); start
+= 2;
7409 printf (" DW_CFA_advance_loc2: %08x = %08x + %d*%d\n",
7410 fc
->pc_begin
+ ofs
* fc
->code_factor
, fc
->pc_begin
, ofs
, fc
->code_factor
);
7412 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7415 case DW_CFA_advance_loc4
:
7416 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7417 ofs
= byte_get (start
, 4); start
+= 4;
7419 printf (" DW_CFA_advance_loc4: %08x = %08x + %d*%d\n",
7420 fc
->pc_begin
+ ofs
* fc
->code_factor
, fc
->pc_begin
, ofs
, fc
->code_factor
);
7422 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7425 case DW_CFA_offset_extended
:
7429 printf (" DW_CFA_offset_extended: r%d = cfa[%d*%d]\n", reg
, roffs
, fc
->data_factor
);
7431 fc
->col_type
[reg
] = DW_CFA_offset
;
7432 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
7435 case DW_CFA_restore_extended
:
7438 printf (" DW_CFA_restore_extended: r%d\n", reg
);
7440 fc
->col_type
[reg
] = cie
->col_type
[reg
];
7441 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
7444 case DW_CFA_undefined
:
7447 printf (" DW_CFA_undefined: r%d\n", reg
);
7449 fc
->col_type
[reg
] = DW_CFA_undefined
;
7450 fc
->col_offset
[reg
] = 0;
7453 case DW_CFA_same_value
:
7456 printf (" DW_CFA_same_value: r%d\n", reg
);
7458 fc
->col_type
[reg
] = DW_CFA_same_value
;
7459 fc
->col_offset
[reg
] = 0;
7462 case DW_CFA_register
:
7466 printf (" DW_CFA_register: r%d\n", reg
);
7468 fc
->col_type
[reg
] = DW_CFA_register
;
7469 fc
->col_offset
[reg
] = roffs
;
7472 case DW_CFA_remember_state
:
7474 printf (" DW_CFA_remember_state\n");
7476 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7477 rs
->ncols
= fc
->ncols
;
7478 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
7479 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
7480 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
7481 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
7482 rs
->next
= remembered_state
;
7483 remembered_state
= rs
;
7486 case DW_CFA_restore_state
:
7488 printf (" DW_CFA_restore_state\n");
7490 rs
= remembered_state
;
7491 remembered_state
= rs
->next
;
7492 frame_need_space (fc
, rs
->ncols
-1);
7493 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
7494 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
7495 free (rs
->col_type
);
7496 free (rs
->col_offset
);
7500 case DW_CFA_def_cfa
:
7501 fc
->cfa_reg
= LEB ();
7502 fc
->cfa_offset
= LEB ();
7504 printf (" DW_CFA_def_cfa: reg %d ofs %d\n", fc
->cfa_reg
, fc
->cfa_offset
);
7508 case DW_CFA_def_cfa_register
:
7509 fc
->cfa_reg
= LEB ();
7511 printf (" DW_CFA_def_cfa_reg: %d\n", fc
->cfa_reg
);
7515 case DW_CFA_def_cfa_offset
:
7516 fc
->cfa_offset
= LEB ();
7518 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
7524 printf (" DW_CFA_nop\n");
7528 #ifndef DW_CFA_GNU_window_save
7529 #define DW_CFA_GNU_window_save 0x2d
7531 case DW_CFA_GNU_window_save
:
7533 printf (" DW_CFA_GNU_window_save\n");
7537 #ifndef DW_CFA_GNU_args_size
7538 #define DW_CFA_GNU_args_size 0x2e
7540 case DW_CFA_GNU_args_size
:
7543 printf (" DW_CFA_GNU_args_size: %d\n", ul
);
7547 #ifndef DW_CFA_GNU_negative_offset_extended
7548 #define DW_CFA_GNU_negative_offset_extended 0x2f
7550 case DW_CFA_GNU_negative_offset_extended
:
7553 frame_need_space (fc
, reg
);
7555 printf (" DW_CFA_GNU_negative_offset_extended: r%d = cfa[%d*%d]\n", reg
, l
, fc
->data_factor
);
7557 fc
->col_type
[reg
] = DW_CFA_offset
;
7558 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7562 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
7567 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7582 display_debug_not_supported (section
, start
, file
)
7583 Elf32_Internal_Shdr
* section
;
7584 unsigned char * start ATTRIBUTE_UNUSED
;
7585 FILE * file ATTRIBUTE_UNUSED
;
7587 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7588 SECTION_NAME (section
));
7593 /* Pre-scan the .debug_info section to record the size of address.
7594 When dumping the .debug_line, we use that size information, assuming
7595 that all compilation units have the same address size. */
7597 prescan_debug_info (section
, start
, file
)
7598 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
7599 unsigned char * start
;
7600 FILE * file ATTRIBUTE_UNUSED
;
7602 DWARF2_External_CompUnit
* external
;
7604 external
= (DWARF2_External_CompUnit
*) start
;
7606 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7610 /* A structure containing the name of a debug section and a pointer
7611 to a function that can decode it. The third field is a prescan
7612 function to be run over the section before displaying any of the
7617 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
7618 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
7622 { ".debug_info", display_debug_info
, prescan_debug_info
},
7623 { ".debug_abbrev", display_debug_abbrev
, NULL
},
7624 { ".debug_line", display_debug_lines
, NULL
},
7625 { ".debug_aranges", display_debug_aranges
, NULL
},
7626 { ".debug_pubnames", display_debug_pubnames
, NULL
},
7627 { ".debug_frame", display_debug_frames
, NULL
},
7628 { ".eh_frame", display_debug_frames
, NULL
},
7629 { ".debug_macinfo", display_debug_not_supported
, NULL
},
7630 { ".debug_frame", display_debug_not_supported
, NULL
},
7631 { ".debug_str", display_debug_not_supported
, NULL
},
7632 { ".debug_static_func", display_debug_not_supported
, NULL
},
7633 { ".debug_static_vars", display_debug_not_supported
, NULL
},
7634 { ".debug_types", display_debug_not_supported
, NULL
},
7635 { ".debug_weaknames", display_debug_not_supported
, NULL
}
7639 display_debug_section (section
, file
)
7640 Elf32_Internal_Shdr
* section
;
7643 char * name
= SECTION_NAME (section
);
7644 bfd_size_type length
;
7645 unsigned char * start
;
7648 length
= section
->sh_size
;
7651 printf (_("\nSection '%s' has no debugging data.\n"), name
);
7655 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
7656 "debug section data");
7658 /* See if we know how to display the contents of this section. */
7659 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
7660 name
= ".debug_info";
7662 for (i
= NUM_ELEM (debug_displays
); i
--;)
7663 if (strcmp (debug_displays
[i
].name
, name
) == 0)
7665 debug_displays
[i
].display (section
, start
, file
);
7670 printf (_("Unrecognised debug section: %s\n"), name
);
7674 /* If we loaded in the abbrev section at some point,
7675 we must release it here. */
7676 if (first_abbrev
!= NULL
)
7683 process_section_contents (file
)
7686 Elf32_Internal_Shdr
* section
;
7692 /* Pre-scan the debug sections to find some debug information not
7693 present in some of them. For the .debug_line, we must find out the
7694 size of address (specified in .debug_info and .debug_aranges). */
7695 for (i
= 0, section
= section_headers
;
7696 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7699 char * name
= SECTION_NAME (section
);
7702 if (section
->sh_size
== 0)
7705 /* See if there is some pre-scan operation for this section. */
7706 for (j
= NUM_ELEM (debug_displays
); j
--;)
7707 if (strcmp (debug_displays
[j
].name
, name
) == 0)
7709 if (debug_displays
[j
].prescan
!= NULL
)
7711 bfd_size_type length
;
7712 unsigned char * start
;
7714 length
= section
->sh_size
;
7715 GET_DATA_ALLOC (section
->sh_offset
, length
, start
, unsigned char *,
7716 "debug section data");
7718 debug_displays
[j
].prescan (section
, start
, file
);
7726 for (i
= 0, section
= section_headers
;
7727 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
7730 #ifdef SUPPORT_DISASSEMBLY
7731 if (dump_sects
[i
] & DISASS_DUMP
)
7732 disassemble_section (section
, file
);
7734 if (dump_sects
[i
] & HEX_DUMP
)
7735 dump_section (section
, file
);
7737 if (dump_sects
[i
] & DEBUG_DUMP
)
7738 display_debug_section (section
, file
);
7741 if (i
< num_dump_sects
)
7742 warn (_("Some sections were not dumped because they do not exist!\n"));
7748 process_mips_fpe_exception (mask
)
7754 if (mask
& OEX_FPU_INEX
)
7755 fputs ("INEX", stdout
), first
= 0;
7756 if (mask
& OEX_FPU_UFLO
)
7757 printf ("%sUFLO", first
? "" : "|"), first
= 0;
7758 if (mask
& OEX_FPU_OFLO
)
7759 printf ("%sOFLO", first
? "" : "|"), first
= 0;
7760 if (mask
& OEX_FPU_DIV0
)
7761 printf ("%sDIV0", first
? "" : "|"), first
= 0;
7762 if (mask
& OEX_FPU_INVAL
)
7763 printf ("%sINVAL", first
? "" : "|");
7766 fputs ("0", stdout
);
7770 process_mips_specific (file
)
7773 Elf_Internal_Dyn
* entry
;
7774 size_t liblist_offset
= 0;
7775 size_t liblistno
= 0;
7776 size_t conflictsno
= 0;
7777 size_t options_offset
= 0;
7778 size_t conflicts_offset
= 0;
7780 /* We have a lot of special sections. Thanks SGI! */
7781 if (dynamic_segment
== NULL
)
7782 /* No information available. */
7785 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
7786 switch (entry
->d_tag
)
7788 case DT_MIPS_LIBLIST
:
7789 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
7791 case DT_MIPS_LIBLISTNO
:
7792 liblistno
= entry
->d_un
.d_val
;
7794 case DT_MIPS_OPTIONS
:
7795 options_offset
= entry
->d_un
.d_val
- loadaddr
;
7797 case DT_MIPS_CONFLICT
:
7798 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
7800 case DT_MIPS_CONFLICTNO
:
7801 conflictsno
= entry
->d_un
.d_val
;
7807 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
7809 Elf32_External_Lib
* elib
;
7812 GET_DATA_ALLOC (liblist_offset
, liblistno
* sizeof (Elf32_External_Lib
),
7813 elib
, Elf32_External_Lib
*, "liblist");
7815 printf ("\nSection '.liblist' contains %lu entries:\n",
7816 (unsigned long) liblistno
);
7817 fputs (" Library Time Stamp Checksum Version Flags\n",
7820 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
7827 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
7828 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
7829 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
7830 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
7831 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
7833 tmp
= gmtime (&time
);
7834 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
7835 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
7836 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
7838 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
7839 dynamic_strings
+ liblist
.l_name
, timebuf
,
7840 liblist
.l_checksum
, liblist
.l_version
);
7842 if (liblist
.l_flags
== 0)
7853 { " EXACT_MATCH", LL_EXACT_MATCH
},
7854 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
7855 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
7856 { " EXPORTS", LL_EXPORTS
},
7857 { " DELAY_LOAD", LL_DELAY_LOAD
},
7858 { " DELTA", LL_DELTA
}
7860 int flags
= liblist
.l_flags
;
7864 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
7866 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
7868 fputs (l_flags_vals
[fcnt
].name
, stdout
);
7869 flags
^= l_flags_vals
[fcnt
].bit
;
7872 printf (" %#x", (unsigned int) flags
);
7881 if (options_offset
!= 0)
7883 Elf_External_Options
* eopt
;
7884 Elf_Internal_Shdr
* sect
= section_headers
;
7885 Elf_Internal_Options
* iopt
;
7886 Elf_Internal_Options
* option
;
7890 /* Find the section header so that we get the size. */
7891 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
7894 GET_DATA_ALLOC (options_offset
, sect
->sh_size
, eopt
,
7895 Elf_External_Options
*, "options");
7897 iopt
= (Elf_Internal_Options
*) malloc ((sect
->sh_size
/ sizeof (eopt
))
7901 error (_("Out of memory"));
7908 while (offset
< sect
->sh_size
)
7910 Elf_External_Options
* eoption
;
7912 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
7914 option
->kind
= BYTE_GET (eoption
->kind
);
7915 option
->size
= BYTE_GET (eoption
->size
);
7916 option
->section
= BYTE_GET (eoption
->section
);
7917 option
->info
= BYTE_GET (eoption
->info
);
7919 offset
+= option
->size
;
7925 printf (_("\nSection '%s' contains %d entries:\n"),
7926 SECTION_NAME (sect
), cnt
);
7934 switch (option
->kind
)
7937 /* This shouldn't happen. */
7938 printf (" NULL %d %lx", option
->section
, option
->info
);
7941 printf (" REGINFO ");
7942 if (elf_header
.e_machine
== EM_MIPS
)
7945 Elf32_External_RegInfo
* ereg
;
7946 Elf32_RegInfo reginfo
;
7948 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
7949 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
7950 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
7951 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
7952 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
7953 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
7954 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
7956 printf ("GPR %08lx GP 0x%lx\n",
7958 (unsigned long) reginfo
.ri_gp_value
);
7959 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7960 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
7961 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
7966 Elf64_External_RegInfo
* ereg
;
7967 Elf64_Internal_RegInfo reginfo
;
7969 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
7970 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
7971 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
7972 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
7973 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
7974 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
7975 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
7977 printf ("GPR %08lx GP 0x",
7978 reginfo
.ri_gprmask
);
7979 printf_vma (reginfo
.ri_gp_value
);
7982 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
7983 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
7984 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
7988 case ODK_EXCEPTIONS
:
7989 fputs (" EXCEPTIONS fpe_min(", stdout
);
7990 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
7991 fputs (") fpe_max(", stdout
);
7992 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
7993 fputs (")", stdout
);
7995 if (option
->info
& OEX_PAGE0
)
7996 fputs (" PAGE0", stdout
);
7997 if (option
->info
& OEX_SMM
)
7998 fputs (" SMM", stdout
);
7999 if (option
->info
& OEX_FPDBUG
)
8000 fputs (" FPDBUG", stdout
);
8001 if (option
->info
& OEX_DISMISS
)
8002 fputs (" DISMISS", stdout
);
8005 fputs (" PAD ", stdout
);
8006 if (option
->info
& OPAD_PREFIX
)
8007 fputs (" PREFIX", stdout
);
8008 if (option
->info
& OPAD_POSTFIX
)
8009 fputs (" POSTFIX", stdout
);
8010 if (option
->info
& OPAD_SYMBOL
)
8011 fputs (" SYMBOL", stdout
);
8014 fputs (" HWPATCH ", stdout
);
8015 if (option
->info
& OHW_R4KEOP
)
8016 fputs (" R4KEOP", stdout
);
8017 if (option
->info
& OHW_R8KPFETCH
)
8018 fputs (" R8KPFETCH", stdout
);
8019 if (option
->info
& OHW_R5KEOP
)
8020 fputs (" R5KEOP", stdout
);
8021 if (option
->info
& OHW_R5KCVTL
)
8022 fputs (" R5KCVTL", stdout
);
8025 fputs (" FILL ", stdout
);
8026 /* XXX Print content of info word? */
8029 fputs (" TAGS ", stdout
);
8030 /* XXX Print content of info word? */
8033 fputs (" HWAND ", stdout
);
8034 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8035 fputs (" R4KEOP_CHECKED", stdout
);
8036 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8037 fputs (" R4KEOP_CLEAN", stdout
);
8040 fputs (" HWOR ", stdout
);
8041 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8042 fputs (" R4KEOP_CHECKED", stdout
);
8043 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8044 fputs (" R4KEOP_CLEAN", stdout
);
8047 printf (" GP_GROUP %#06lx self-contained %#06lx",
8048 option
->info
& OGP_GROUP
,
8049 (option
->info
& OGP_SELF
) >> 16);
8052 printf (" IDENT %#06lx self-contained %#06lx",
8053 option
->info
& OGP_GROUP
,
8054 (option
->info
& OGP_SELF
) >> 16);
8057 /* This shouldn't happen. */
8058 printf (" %3d ??? %d %lx",
8059 option
->kind
, option
->section
, option
->info
);
8063 len
= sizeof (* eopt
);
8064 while (len
< option
->size
)
8065 if (((char *) option
)[len
] >= ' '
8066 && ((char *) option
)[len
] < 0x7f)
8067 printf ("%c", ((char *) option
)[len
++]);
8069 printf ("\\%03o", ((char *) option
)[len
++]);
8071 fputs ("\n", stdout
);
8078 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8080 Elf32_External_Conflict
* econf32
;
8081 Elf64_External_Conflict
* econf64
;
8082 Elf32_Conflict
* iconf
;
8085 if (dynamic_symbols
== NULL
)
8087 error (_("conflict list with without table"));
8091 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
8094 error (_("Out of memory"));
8100 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (* econf32
),
8101 econf32
, Elf32_External_Conflict
*, "conflict");
8103 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8104 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8108 GET_DATA_ALLOC (conflicts_offset
, conflictsno
* sizeof (* econf64
),
8109 econf64
, Elf64_External_Conflict
*, "conflict");
8111 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8112 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8115 printf (_("\nSection '.conflict' contains %d entries:\n"), conflictsno
);
8116 puts (_(" Num: Index Value Name"));
8118 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8120 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
8122 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8123 print_vma (psym
->st_value
, FULL_HEX
);
8124 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
8134 get_note_type (e_type
)
8137 static char buff
[64];
8141 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
8142 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
8143 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
8144 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
8145 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
8146 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
8147 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
8148 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
8149 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8150 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8151 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8153 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
8158 /* Note that by the ELF standard, the name field is already null byte
8159 terminated, and namesz includes the terminating null byte.
8160 I.E. the value of namesz for the name "FSF" is 4.
8162 If the value of namesz is zero, there is no name present. */
8164 process_note (pnote
)
8165 Elf32_Internal_Note
* pnote
;
8167 printf (" %s\t\t0x%08lx\t%s\n",
8168 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8169 pnote
->descsz
, get_note_type (pnote
->type
));
8175 process_corefile_note_segment (file
, offset
, length
)
8180 Elf_External_Note
* pnotes
;
8181 Elf_External_Note
* external
;
8187 GET_DATA_ALLOC (offset
, length
, pnotes
, Elf_External_Note
*, "notes");
8191 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8192 (unsigned long) offset
, (unsigned long) length
);
8193 printf (_(" Owner\t\tData size\tDescription\n"));
8195 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8197 Elf32_Internal_Note inote
;
8200 inote
.type
= BYTE_GET (external
->type
);
8201 inote
.namesz
= BYTE_GET (external
->namesz
);
8202 inote
.namedata
= external
->name
;
8203 inote
.descsz
= BYTE_GET (external
->descsz
);
8204 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8205 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8207 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8209 /* Verify that name is null terminated. It appears that at least
8210 one version of Linux (RedHat 6.0) generates corefiles that don't
8211 comply with the ELF spec by failing to include the null byte in
8213 if (inote
.namedata
[inote
.namesz
] != '\0')
8215 temp
= malloc (inote
.namesz
+ 1);
8219 error (_("Out of memory\n"));
8224 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8225 temp
[inote
.namesz
] = 0;
8227 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8228 inote
.namedata
= temp
;
8231 res
&= process_note (& inote
);
8246 process_corefile_note_segments (file
)
8249 Elf_Internal_Phdr
* program_headers
;
8250 Elf_Internal_Phdr
* segment
;
8254 program_headers
= (Elf_Internal_Phdr
*) malloc
8255 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
8257 if (program_headers
== NULL
)
8259 error (_("Out of memory\n"));
8264 i
= get_32bit_program_headers (file
, program_headers
);
8266 i
= get_64bit_program_headers (file
, program_headers
);
8270 free (program_headers
);
8274 for (i
= 0, segment
= program_headers
;
8275 i
< elf_header
.e_phnum
;
8278 if (segment
->p_type
== PT_NOTE
)
8279 res
&= process_corefile_note_segment (file
,
8280 (bfd_vma
) segment
->p_offset
,
8281 (bfd_vma
) segment
->p_filesz
);
8284 free (program_headers
);
8290 process_corefile_contents (file
)
8293 /* If we have not been asked to display the notes then do nothing. */
8297 /* If file is not a core file then exit. */
8298 if (elf_header
.e_type
!= ET_CORE
)
8301 /* No program headers means no NOTE segment. */
8302 if (elf_header
.e_phnum
== 0)
8304 printf (_("No note segments present in the core file.\n"));
8308 return process_corefile_note_segments (file
);
8312 process_arch_specific (file
)
8318 switch (elf_header
.e_machine
)
8321 case EM_MIPS_RS4_BE
:
8322 return process_mips_specific (file
);
8331 get_file_header (file
)
8334 /* Read in the identity array. */
8335 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
8338 /* Determine how to read the rest of the header. */
8339 switch (elf_header
.e_ident
[EI_DATA
])
8341 default: /* fall through */
8342 case ELFDATANONE
: /* fall through */
8343 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
8344 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
8347 /* For now we only support 32 bit and 64 bit ELF files. */
8348 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
8350 /* Read in the rest of the header. */
8353 Elf32_External_Ehdr ehdr32
;
8355 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
8358 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
8359 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
8360 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
8361 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
8362 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
8363 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
8364 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
8365 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
8366 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
8367 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
8368 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
8369 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
8370 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
8374 Elf64_External_Ehdr ehdr64
;
8376 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8377 we will not be able to cope with the 64bit data found in
8378 64 ELF files. Detect this now and abort before we start
8379 overwritting things. */
8380 if (sizeof (bfd_vma
) < 8)
8382 error (_("This instance of readelf has been built without support for a\n"));
8383 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8387 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
8390 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
8391 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
8392 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
8393 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
8394 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
8395 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
8396 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
8397 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
8398 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
8399 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
8400 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
8401 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
8402 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
8409 process_file (file_name
)
8413 struct stat statbuf
;
8416 if (stat (file_name
, & statbuf
) < 0)
8418 error (_("Cannot stat input file %s.\n"), file_name
);
8422 file
= fopen (file_name
, "rb");
8425 error (_("Input file %s not found.\n"), file_name
);
8429 if (! get_file_header (file
))
8431 error (_("%s: Failed to read file header\n"), file_name
);
8436 /* Initialise per file variables. */
8437 for (i
= NUM_ELEM (version_info
); i
--;)
8438 version_info
[i
] = 0;
8440 for (i
= NUM_ELEM (dynamic_info
); i
--;)
8441 dynamic_info
[i
] = 0;
8443 /* Process the file. */
8445 printf (_("\nFile: %s\n"), file_name
);
8447 if (! process_file_header ())
8453 process_section_headers (file
);
8455 process_program_headers (file
);
8457 process_dynamic_segment (file
);
8459 process_relocs (file
);
8461 process_unwind (file
);
8463 process_symbol_table (file
);
8465 process_syminfo (file
);
8467 process_version_sections (file
);
8469 process_section_contents (file
);
8471 process_corefile_contents (file
);
8473 process_arch_specific (file
);
8477 if (section_headers
)
8479 free (section_headers
);
8480 section_headers
= NULL
;
8485 free (string_table
);
8486 string_table
= NULL
;
8487 string_table_length
= 0;
8490 if (dynamic_strings
)
8492 free (dynamic_strings
);
8493 dynamic_strings
= NULL
;
8496 if (dynamic_symbols
)
8498 free (dynamic_symbols
);
8499 dynamic_symbols
= NULL
;
8500 num_dynamic_syms
= 0;
8503 if (dynamic_syminfo
)
8505 free (dynamic_syminfo
);
8506 dynamic_syminfo
= NULL
;
8510 #ifdef SUPPORT_DISASSEMBLY
8511 /* Needed by the i386 disassembler. For extra credit, someone could
8512 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8516 print_address (unsigned int addr
, FILE * outfile
)
8518 fprintf (outfile
,"0x%8.8x", addr
);
8521 /* Needed by the i386 disassembler. */
8523 db_task_printsym (unsigned int addr
)
8525 print_address (addr
, stderr
);
8534 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8535 setlocale (LC_MESSAGES
, "");
8537 bindtextdomain (PACKAGE
, LOCALEDIR
);
8538 textdomain (PACKAGE
);
8540 parse_args (argc
, argv
);
8542 if (optind
< (argc
- 1))
8545 while (optind
< argc
)
8546 process_file (argv
[optind
++]);
8548 if (dump_sects
!= NULL
)