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@redhat.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
;
121 int do_debug_frames_interp
;
122 int do_debug_macinfo
;
127 /* A dynamic array of flags indicating which sections require dumping. */
128 char * dump_sects
= NULL
;
129 unsigned int num_dump_sects
= 0;
131 #define HEX_DUMP (1 << 0)
132 #define DISASS_DUMP (1 << 1)
133 #define DEBUG_DUMP (1 << 2)
135 /* How to rpint a vma value. */
136 typedef enum print_mode
148 /* Forward declarations for dumb compilers. */
149 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
150 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
151 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
152 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
153 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
154 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
155 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
156 static const char * get_dynamic_type
PARAMS ((unsigned long));
157 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
158 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
159 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
160 static char * get_file_type
PARAMS ((unsigned));
161 static char * get_machine_name
PARAMS ((unsigned));
162 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
163 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
164 static const char * get_mips_segment_type
PARAMS ((unsigned long));
165 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
166 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
167 static const char * get_segment_type
PARAMS ((unsigned long));
168 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
169 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
170 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
171 static const char * get_section_type_name
PARAMS ((unsigned int));
172 static const char * get_symbol_binding
PARAMS ((unsigned int));
173 static const char * get_symbol_type
PARAMS ((unsigned int));
174 static const char * get_symbol_visibility
PARAMS ((unsigned int));
175 static const char * get_symbol_index_type
PARAMS ((unsigned int));
176 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
177 static void usage
PARAMS ((void));
178 static void parse_args
PARAMS ((int, char **));
179 static int process_file_header
PARAMS ((void));
180 static int process_program_headers
PARAMS ((FILE *));
181 static int process_section_headers
PARAMS ((FILE *));
182 static int process_unwind
PARAMS ((FILE *));
183 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
184 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
185 static int process_dynamic_segment
PARAMS ((FILE *));
186 static int process_symbol_table
PARAMS ((FILE *));
187 static int process_syminfo
PARAMS ((FILE *));
188 static int process_section_contents
PARAMS ((FILE *));
189 static void process_mips_fpe_exception
PARAMS ((int));
190 static int process_mips_specific
PARAMS ((FILE *));
191 static int process_file
PARAMS ((char *));
192 static int process_relocs
PARAMS ((FILE *));
193 static int process_version_sections
PARAMS ((FILE *));
194 static char * get_ver_flags
PARAMS ((unsigned int));
195 static int get_32bit_section_headers
PARAMS ((FILE *));
196 static int get_64bit_section_headers
PARAMS ((FILE *));
197 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
198 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
199 static int get_file_header
PARAMS ((FILE *));
200 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
201 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
202 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
203 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
204 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
205 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
206 #ifdef SUPPORT_DISASSEMBLY
207 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
209 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
210 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
211 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
212 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
213 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
214 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
215 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
216 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
217 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
218 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
219 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
220 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
221 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
222 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
223 static void reset_state_machine
PARAMS ((int));
224 static char * get_TAG_name
PARAMS ((unsigned long));
225 static char * get_AT_name
PARAMS ((unsigned long));
226 static char * get_FORM_name
PARAMS ((unsigned long));
227 static void free_abbrevs
PARAMS ((void));
228 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
229 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
230 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
231 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
232 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
233 static void request_dump
PARAMS ((unsigned int, char));
234 static const char * get_elf_class
PARAMS ((unsigned char));
235 static const char * get_data_encoding
PARAMS ((unsigned char));
236 static const char * get_osabi_name
PARAMS ((unsigned char));
237 static int guess_is_rela
PARAMS ((unsigned long));
238 static char * get_note_type
PARAMS ((unsigned int));
239 static int process_note
PARAMS ((Elf32_Internal_Note
*));
240 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
241 static int process_corefile_note_segments
PARAMS ((FILE *));
242 static int process_corefile_contents
PARAMS ((FILE *));
243 static int process_arch_specific
PARAMS ((FILE *));
245 typedef int Elf32_Word
;
253 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
254 ((X)->sh_name >= string_table_length \
255 ? "<corrupt>" : string_table + (X)->sh_name))
257 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
259 #define BYTE_GET(field) byte_get (field, sizeof (field))
261 /* If we can support a 64 bit data type then BFD64 should be defined
262 and sizeof (bfd_vma) == 8. In this case when translating from an
263 external 8 byte field to an internal field, we can assume that the
264 internal field is also 8 bytes wide and so we can extract all the data.
265 If, however, BFD64 is not defined, then we must assume that the
266 internal data structure only has 4 byte wide fields that are the
267 equivalent of the 8 byte wide external counterparts, and so we must
268 truncate the data. */
270 #define BYTE_GET8(field) byte_get (field, -8)
272 #define BYTE_GET8(field) byte_get (field, 8)
275 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
277 #define GET_ELF_SYMBOLS(file, offset, size) \
278 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
279 : get_64bit_elf_symbols (file, offset, size))
282 #ifdef ANSI_PROTOTYPES
284 error (const char * message
, ...)
288 fprintf (stderr
, _("%s: Error: "), program_name
);
289 va_start (args
, message
);
290 vfprintf (stderr
, message
, args
);
296 warn (const char * message
, ...)
300 fprintf (stderr
, _("%s: Warning: "), program_name
);
301 va_start (args
, message
);
302 vfprintf (stderr
, message
, args
);
314 fprintf (stderr
, _("%s: Error: "), program_name
);
316 message
= va_arg (args
, char *);
317 vfprintf (stderr
, message
, args
);
329 fprintf (stderr
, _("%s: Warning: "), program_name
);
331 message
= va_arg (args
, char *);
332 vfprintf (stderr
, message
, args
);
338 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
341 get_data (var
, file
, offset
, size
, reason
)
353 if (fseek (file
, offset
, SEEK_SET
))
355 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
362 mvar
= (PTR
) malloc (size
);
366 error (_("Out of memory allocating %d bytes for %s\n"),
372 if (fread (mvar
, size
, 1, file
) != 1)
374 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
384 byte_get_little_endian (field
, size
)
385 unsigned char * field
;
394 return ((unsigned int) (field
[0]))
395 | (((unsigned int) (field
[1])) << 8);
399 /* We want to extract data from an 8 byte wide field and
400 place it into a 4 byte wide field. Since this is a little
401 endian source we can juts use the 4 byte extraction code. */
405 return ((unsigned long) (field
[0]))
406 | (((unsigned long) (field
[1])) << 8)
407 | (((unsigned long) (field
[2])) << 16)
408 | (((unsigned long) (field
[3])) << 24);
413 /* This is a special case, generated by the BYTE_GET8 macro.
414 It means that we are loading an 8 byte value from a field
415 in an external structure into an 8 byte value in a field
416 in an internal strcuture. */
417 return ((bfd_vma
) (field
[0]))
418 | (((bfd_vma
) (field
[1])) << 8)
419 | (((bfd_vma
) (field
[2])) << 16)
420 | (((bfd_vma
) (field
[3])) << 24)
421 | (((bfd_vma
) (field
[4])) << 32)
422 | (((bfd_vma
) (field
[5])) << 40)
423 | (((bfd_vma
) (field
[6])) << 48)
424 | (((bfd_vma
) (field
[7])) << 56);
427 error (_("Unhandled data length: %d\n"), size
);
432 /* Print a VMA value. */
434 print_vma (vma
, mode
)
444 case FULL_HEX
: printf ("0x"); /* drop through */
445 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
446 case PREFIX_HEX
: printf ("0x"); /* drop through */
447 case HEX
: printf ("%lx", (unsigned long) vma
); break;
448 case DEC
: printf ("%ld", (unsigned long) vma
); break;
449 case DEC_5
: printf ("%5ld", (long) vma
); break;
450 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
471 #if BFD_HOST_64BIT_LONG
474 if (_bfd_int64_high (vma
))
475 printf ("%lx%lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
477 printf ("%lx", _bfd_int64_low (vma
));
482 #if BFD_HOST_64BIT_LONG
485 if (_bfd_int64_high (vma
))
487 printf ("++%ld", _bfd_int64_low (vma
));
489 printf ("%ld", _bfd_int64_low (vma
));
494 #if BFD_HOST_64BIT_LONG
495 printf ("%5ld", vma
);
497 if (_bfd_int64_high (vma
))
499 printf ("++%ld", _bfd_int64_low (vma
));
501 printf ("%5ld", _bfd_int64_low (vma
));
506 #if BFD_HOST_64BIT_LONG
509 if (_bfd_int64_high (vma
))
511 printf ("++%lu", _bfd_int64_low (vma
));
513 printf ("%lu", _bfd_int64_low (vma
));
522 byte_get_big_endian (field
, size
)
523 unsigned char * field
;
532 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
535 return ((unsigned long) (field
[3]))
536 | (((unsigned long) (field
[2])) << 8)
537 | (((unsigned long) (field
[1])) << 16)
538 | (((unsigned long) (field
[0])) << 24);
542 /* Although we are extracing data from an 8 byte wide field, we
543 are returning only 4 bytes of data. */
544 return ((unsigned long) (field
[7]))
545 | (((unsigned long) (field
[6])) << 8)
546 | (((unsigned long) (field
[5])) << 16)
547 | (((unsigned long) (field
[4])) << 24);
551 /* This is a special case, generated by the BYTE_GET8 macro.
552 It means that we are loading an 8 byte value from a field
553 in an external structure into an 8 byte value in a field
554 in an internal strcuture. */
555 return ((bfd_vma
) (field
[7]))
556 | (((bfd_vma
) (field
[6])) << 8)
557 | (((bfd_vma
) (field
[5])) << 16)
558 | (((bfd_vma
) (field
[4])) << 24)
559 | (((bfd_vma
) (field
[3])) << 32)
560 | (((bfd_vma
) (field
[2])) << 40)
561 | (((bfd_vma
) (field
[1])) << 48)
562 | (((bfd_vma
) (field
[0])) << 56);
566 error (_("Unhandled data length: %d\n"), size
);
571 /* Guess the relocation size commonly used by the specific machines. */
574 guess_is_rela (e_machine
)
575 unsigned long e_machine
;
579 /* Targets that use REL relocations. */
590 /* Targets that use RELA relocations. */
598 case EM_CYGNUS_MN10200
:
599 case EM_CYGNUS_MN10300
:
632 warn (_("Don't know about relocations on this machine architecture\n"));
638 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
640 unsigned long rel_offset
;
641 unsigned long rel_size
;
642 Elf_Internal_Rela
**relasp
;
643 unsigned long *nrelasp
;
645 Elf_Internal_Rela
*relas
;
646 unsigned long nrelas
;
651 Elf32_External_Rela
* erelas
;
653 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
654 rel_size
, _("relocs"));
658 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
660 relas
= (Elf_Internal_Rela
*)
661 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
665 error(_("out of memory parsing relocs"));
669 for (i
= 0; i
< nrelas
; i
++)
671 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
672 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
673 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
680 Elf64_External_Rela
* erelas
;
682 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
683 rel_size
, _("relocs"));
687 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
689 relas
= (Elf_Internal_Rela
*)
690 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
694 error(_("out of memory parsing relocs"));
698 for (i
= 0; i
< nrelas
; i
++)
700 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
701 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
702 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
713 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
715 unsigned long rel_offset
;
716 unsigned long rel_size
;
717 Elf_Internal_Rel
**relsp
;
718 unsigned long *nrelsp
;
720 Elf_Internal_Rel
*rels
;
726 Elf32_External_Rel
* erels
;
728 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
729 rel_size
, _("relocs"));
733 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
735 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
739 error(_("out of memory parsing relocs"));
743 for (i
= 0; i
< nrels
; i
++)
745 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
746 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
753 Elf64_External_Rel
* erels
;
755 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
756 rel_size
, _("relocs"));
760 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
762 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
766 error(_("out of memory parsing relocs"));
770 for (i
= 0; i
< nrels
; i
++)
772 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
773 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
783 /* Display the contents of the relocation data found at the specified offset. */
785 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
787 unsigned long rel_offset
;
788 unsigned long rel_size
;
789 Elf_Internal_Sym
* symtab
;
795 Elf_Internal_Rel
* rels
;
796 Elf_Internal_Rela
* relas
;
799 if (is_rela
== UNKNOWN
)
800 is_rela
= guess_is_rela (elf_header
.e_machine
);
804 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
809 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
817 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
820 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
826 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
829 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
832 for (i
= 0; i
< rel_size
; i
++)
837 bfd_vma symtab_index
;
842 offset
= relas
[i
].r_offset
;
843 info
= relas
[i
].r_info
;
847 offset
= rels
[i
].r_offset
;
848 info
= rels
[i
].r_info
;
853 type
= ELF32_R_TYPE (info
);
854 symtab_index
= ELF32_R_SYM (info
);
858 if (elf_header
.e_machine
== EM_SPARCV9
)
859 type
= ELF64_R_TYPE_ID (info
);
861 type
= ELF64_R_TYPE (info
);
862 /* The #ifdef BFD64 below is to prevent a compile time warning.
863 We know that if we do not have a 64 bit data type that we
864 will never execute this code anyway. */
866 symtab_index
= ELF64_R_SYM (info
);
872 #ifdef _bfd_int64_low
873 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
875 printf ("%8.8lx %8.8lx ", offset
, info
);
880 #ifdef _bfd_int64_low
881 printf ("%8.8lx%8.8lx %8.8lx%8.8lx ",
882 _bfd_int64_high (offset
),
883 _bfd_int64_low (offset
),
884 _bfd_int64_high (info
),
885 _bfd_int64_low (info
));
887 printf ("%16.16lx %16.16lx ", offset
, info
);
891 switch (elf_header
.e_machine
)
898 rtype
= elf_m32r_reloc_type (type
);
903 rtype
= elf_i386_reloc_type (type
);
907 rtype
= elf_m68k_reloc_type (type
);
911 rtype
= elf_i960_reloc_type (type
);
915 rtype
= elf_avr_reloc_type (type
);
922 rtype
= elf_sparc_reloc_type (type
);
926 rtype
= v850_reloc_type (type
);
930 rtype
= elf_d10v_reloc_type (type
);
934 rtype
= elf_d30v_reloc_type (type
);
938 rtype
= elf_sh_reloc_type (type
);
941 case EM_CYGNUS_MN10300
:
942 rtype
= elf_mn10300_reloc_type (type
);
945 case EM_CYGNUS_MN10200
:
946 rtype
= elf_mn10200_reloc_type (type
);
950 rtype
= elf_fr30_reloc_type (type
);
954 rtype
= elf_mcore_reloc_type (type
);
958 rtype
= elf_ppc_reloc_type (type
);
963 rtype
= elf_mips_reloc_type (type
);
967 rtype
= elf_alpha_reloc_type (type
);
971 rtype
= elf_arm_reloc_type (type
);
976 rtype
= elf_arc_reloc_type (type
);
980 rtype
= elf_hppa_reloc_type (type
);
984 rtype
= elf_pj_reloc_type (type
);
987 rtype
= elf_ia64_reloc_type (type
);
991 rtype
= elf_cris_reloc_type (type
);
995 rtype
= elf_i860_reloc_type (type
);
999 rtype
= elf_x86_64_reloc_type (type
);
1004 rtype
= elf_s390_reloc_type (type
);
1009 #ifdef _bfd_int64_low
1010 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
1012 printf (_("unrecognised: %-7lx"), type
);
1015 printf ("%-21.21s", rtype
);
1019 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1020 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1023 Elf_Internal_Sym
* psym
;
1025 psym
= symtab
+ symtab_index
;
1028 print_vma (psym
->st_value
, LONG_HEX
);
1031 if (psym
->st_name
== 0)
1033 SECTION_NAME (section_headers
+ psym
->st_shndx
));
1034 else if (strtab
== NULL
)
1035 printf (_("<string table index %3ld>"), psym
->st_name
);
1037 printf ("%-25.25s", strtab
+ psym
->st_name
);
1040 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1045 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
1046 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1049 if (elf_header
.e_machine
== EM_SPARCV9
1050 && !strcmp (rtype
, "R_SPARC_OLO10"))
1051 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1065 get_mips_dynamic_type (type
)
1070 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1071 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1072 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1073 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1074 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1075 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1076 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1077 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1078 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1079 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1080 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1081 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1082 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1083 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1084 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1085 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1086 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1087 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1088 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1089 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1090 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1091 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1092 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1093 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1094 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1095 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1096 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1097 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1098 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1099 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1100 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1101 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1102 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1103 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1104 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1105 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1106 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1107 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1108 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1109 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1110 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1111 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1112 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1119 get_sparc64_dynamic_type (type
)
1124 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1131 get_parisc_dynamic_type (type
)
1136 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1137 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1138 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1139 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1140 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1141 case DT_HP_PREINIT
: return "HP_PREINIT";
1142 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1143 case DT_HP_NEEDED
: return "HP_NEEDED";
1144 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1145 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1146 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1147 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1148 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1155 get_dynamic_type (type
)
1158 static char buff
[32];
1162 case DT_NULL
: return "NULL";
1163 case DT_NEEDED
: return "NEEDED";
1164 case DT_PLTRELSZ
: return "PLTRELSZ";
1165 case DT_PLTGOT
: return "PLTGOT";
1166 case DT_HASH
: return "HASH";
1167 case DT_STRTAB
: return "STRTAB";
1168 case DT_SYMTAB
: return "SYMTAB";
1169 case DT_RELA
: return "RELA";
1170 case DT_RELASZ
: return "RELASZ";
1171 case DT_RELAENT
: return "RELAENT";
1172 case DT_STRSZ
: return "STRSZ";
1173 case DT_SYMENT
: return "SYMENT";
1174 case DT_INIT
: return "INIT";
1175 case DT_FINI
: return "FINI";
1176 case DT_SONAME
: return "SONAME";
1177 case DT_RPATH
: return "RPATH";
1178 case DT_SYMBOLIC
: return "SYMBOLIC";
1179 case DT_REL
: return "REL";
1180 case DT_RELSZ
: return "RELSZ";
1181 case DT_RELENT
: return "RELENT";
1182 case DT_PLTREL
: return "PLTREL";
1183 case DT_DEBUG
: return "DEBUG";
1184 case DT_TEXTREL
: return "TEXTREL";
1185 case DT_JMPREL
: return "JMPREL";
1186 case DT_BIND_NOW
: return "BIND_NOW";
1187 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1188 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1189 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1190 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1191 case DT_RUNPATH
: return "RUNPATH";
1192 case DT_FLAGS
: return "FLAGS";
1194 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1195 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1197 case DT_CHECKSUM
: return "CHECKSUM";
1198 case DT_PLTPADSZ
: return "PLTPADSZ";
1199 case DT_MOVEENT
: return "MOVEENT";
1200 case DT_MOVESZ
: return "MOVESZ";
1201 case DT_FEATURE
: return "FEATURE";
1202 case DT_POSFLAG_1
: return "POSFLAG_1";
1203 case DT_SYMINSZ
: return "SYMINSZ";
1204 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1206 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1207 case DT_CONFIG
: return "CONFIG";
1208 case DT_DEPAUDIT
: return "DEPAUDIT";
1209 case DT_AUDIT
: return "AUDIT";
1210 case DT_PLTPAD
: return "PLTPAD";
1211 case DT_MOVETAB
: return "MOVETAB";
1212 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1214 case DT_VERSYM
: return "VERSYM";
1216 case DT_RELACOUNT
: return "RELACOUNT";
1217 case DT_RELCOUNT
: return "RELCOUNT";
1218 case DT_FLAGS_1
: return "FLAGS_1";
1219 case DT_VERDEF
: return "VERDEF";
1220 case DT_VERDEFNUM
: return "VERDEFNUM";
1221 case DT_VERNEED
: return "VERNEED";
1222 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1224 case DT_AUXILIARY
: return "AUXILIARY";
1225 case DT_USED
: return "USED";
1226 case DT_FILTER
: return "FILTER";
1229 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1231 const char * result
;
1233 switch (elf_header
.e_machine
)
1236 case EM_MIPS_RS3_LE
:
1237 result
= get_mips_dynamic_type (type
);
1240 result
= get_sparc64_dynamic_type (type
);
1250 sprintf (buff
, _("Processor Specific: %lx"), type
);
1252 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1254 const char * result
;
1256 switch (elf_header
.e_machine
)
1259 result
= get_parisc_dynamic_type (type
);
1269 sprintf (buff
, _("Operating System specific: %lx"), type
);
1272 sprintf (buff
, _("<unknown>: %lx"), type
);
1279 get_file_type (e_type
)
1282 static char buff
[32];
1286 case ET_NONE
: return _("NONE (None)");
1287 case ET_REL
: return _("REL (Relocatable file)");
1288 case ET_EXEC
: return _("EXEC (Executable file)");
1289 case ET_DYN
: return _("DYN (Shared object file)");
1290 case ET_CORE
: return _("CORE (Core file)");
1293 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1294 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1295 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1296 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1298 sprintf (buff
, _("<unknown>: %x"), e_type
);
1304 get_machine_name (e_machine
)
1307 static char buff
[64]; /* XXX */
1311 case EM_NONE
: return _("None");
1312 case EM_M32
: return "WE32100";
1313 case EM_SPARC
: return "Sparc";
1314 case EM_386
: return "Intel 80386";
1315 case EM_68K
: return "MC68000";
1316 case EM_88K
: return "MC88000";
1317 case EM_486
: return "Intel 80486";
1318 case EM_860
: return "Intel 80860";
1319 case EM_MIPS
: return "MIPS R3000";
1320 case EM_S370
: return "IBM System/370";
1321 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1322 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1323 case EM_PARISC
: return "HPPA";
1324 case EM_PPC_OLD
: return "Power PC (old)";
1325 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1326 case EM_960
: return "Intel 90860";
1327 case EM_PPC
: return "PowerPC";
1328 case EM_V800
: return "NEC V800";
1329 case EM_FR20
: return "Fujitsu FR20";
1330 case EM_RH32
: return "TRW RH32";
1331 case EM_MCORE
: return "MCORE";
1332 case EM_ARM
: return "ARM";
1333 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1334 case EM_SH
: return "Hitachi SH";
1335 case EM_SPARCV9
: return "Sparc v9";
1336 case EM_TRICORE
: return "Siemens Tricore";
1337 case EM_ARC
: return "ARC";
1338 case EM_H8_300
: return "Hitachi H8/300";
1339 case EM_H8_300H
: return "Hitachi H8/300H";
1340 case EM_H8S
: return "Hitachi H8S";
1341 case EM_H8_500
: return "Hitachi H8/500";
1342 case EM_IA_64
: return "Intel IA-64";
1343 case EM_MIPS_X
: return "Stanford MIPS-X";
1344 case EM_COLDFIRE
: return "Motorola Coldfire";
1345 case EM_68HC12
: return "Motorola M68HC12";
1346 case EM_ALPHA
: return "Alpha";
1347 case EM_CYGNUS_D10V
: return "d10v";
1348 case EM_CYGNUS_D30V
: return "d30v";
1349 case EM_CYGNUS_ARC
: return "ARC";
1350 case EM_CYGNUS_M32R
: return "Mitsubishi M32r";
1351 case EM_CYGNUS_V850
: return "NEC v850";
1352 case EM_CYGNUS_MN10300
: return "mn10300";
1353 case EM_CYGNUS_MN10200
: return "mn10200";
1354 case EM_CYGNUS_FR30
: return "Fujitsu FR30";
1355 case EM_PJ
: return "picoJava";
1356 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1357 case EM_PCP
: return "Siemens PCP";
1358 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1359 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1360 case EM_STARCORE
: return "Motorola Star*Core processor";
1361 case EM_ME16
: return "Toyota ME16 processor";
1362 case EM_ST100
: return "STMicroelectronics ST100 processor";
1363 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1364 case EM_FX66
: return "Siemens FX66 microcontroller";
1365 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1366 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1367 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1368 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1369 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1370 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1371 case EM_SVX
: return "Silicon Graphics SVx";
1372 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1373 case EM_VAX
: return "Digital VAX";
1374 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1375 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1376 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1377 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1378 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1379 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1380 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1381 case EM_PRISM
: return "SiTera Prism";
1382 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1384 case EM_S390
: return "IBM S/390";
1386 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1392 decode_ARM_machine_flags (e_flags
, buf
)
1399 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1400 e_flags
&= ~ EF_ARM_EABIMASK
;
1402 /* Handle "generic" ARM flags. */
1403 if (e_flags
& EF_ARM_RELEXEC
)
1405 strcat (buf
, ", relocatable executable");
1406 e_flags
&= ~ EF_ARM_RELEXEC
;
1409 if (e_flags
& EF_ARM_HASENTRY
)
1411 strcat (buf
, ", has entry point");
1412 e_flags
&= ~ EF_ARM_HASENTRY
;
1415 /* Now handle EABI specific flags. */
1419 strcat (buf
, ", <unrecognised EABI>");
1424 case EF_ARM_EABI_VER1
:
1425 strcat (buf
, ", Version1 EABI");
1430 /* Process flags one bit at a time. */
1431 flag
= e_flags
& - e_flags
;
1436 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1437 strcat (buf
, ", sorted symbol tables");
1447 case EF_ARM_EABI_VER2
:
1448 strcat (buf
, ", Version2 EABI");
1453 /* Process flags one bit at a time. */
1454 flag
= e_flags
& - e_flags
;
1459 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1460 strcat (buf
, ", sorted symbol tables");
1463 case EF_ARM_DYNSYMSUSESEGIDX
:
1464 strcat (buf
, ", dynamic symbols use segment index");
1467 case EF_ARM_MAPSYMSFIRST
:
1468 strcat (buf
, ", mapping symbols precede others");
1478 case EF_ARM_EABI_UNKNOWN
:
1479 strcat (buf
, ", GNU EABI");
1484 /* Process flags one bit at a time. */
1485 flag
= e_flags
& - e_flags
;
1490 case EF_ARM_INTERWORK
:
1491 strcat (buf
, ", interworking enabled");
1494 case EF_ARM_APCS_26
:
1495 strcat (buf
, ", uses APCS/26");
1498 case EF_ARM_APCS_FLOAT
:
1499 strcat (buf
, ", uses APCS/float");
1503 strcat (buf
, ", position independent");
1507 strcat (buf
, ", 8 bit structure alignment");
1510 case EF_ARM_NEW_ABI
:
1511 strcat (buf
, ", uses new ABI");
1514 case EF_ARM_OLD_ABI
:
1515 strcat (buf
, ", uses old ABI");
1518 case EF_ARM_SOFT_FLOAT
:
1519 strcat (buf
, ", software FP");
1530 strcat (buf
,", <unknown>");
1534 get_machine_flags (e_flags
, e_machine
)
1538 static char buf
[1024];
1550 decode_ARM_machine_flags (e_flags
, buf
);
1554 if (e_flags
& EF_CPU32
)
1555 strcat (buf
, ", cpu32");
1559 if (e_flags
& EF_PPC_EMB
)
1560 strcat (buf
, ", emb");
1562 if (e_flags
& EF_PPC_RELOCATABLE
)
1563 strcat (buf
, ", relocatable");
1565 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1566 strcat (buf
, ", relocatable-lib");
1569 case EM_CYGNUS_V850
:
1570 switch (e_flags
& EF_V850_ARCH
)
1573 strcat (buf
, ", v850e");
1576 strcat (buf
, ", v850ea");
1579 strcat (buf
, ", v850");
1582 strcat (buf
, ", unknown v850 architecture variant");
1587 case EM_CYGNUS_M32R
:
1588 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1589 strcat (buf
, ", m32r");
1594 case EM_MIPS_RS3_LE
:
1595 if (e_flags
& EF_MIPS_NOREORDER
)
1596 strcat (buf
, ", noreorder");
1598 if (e_flags
& EF_MIPS_PIC
)
1599 strcat (buf
, ", pic");
1601 if (e_flags
& EF_MIPS_CPIC
)
1602 strcat (buf
, ", cpic");
1604 if (e_flags
& EF_MIPS_UCODE
)
1605 strcat (buf
, ", ugen_reserved");
1607 if (e_flags
& EF_MIPS_ABI2
)
1608 strcat (buf
, ", abi2");
1610 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1611 strcat (buf
, ", mips1");
1613 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1614 strcat (buf
, ", mips2");
1616 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1617 strcat (buf
, ", mips3");
1619 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1620 strcat (buf
, ", mips4");
1622 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
1623 strcat (buf
, ", mips5");
1625 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
1626 strcat (buf
, ", mips32");
1628 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
1629 strcat (buf
, ", mips64");
1631 switch ((e_flags
& EF_MIPS_MACH
))
1633 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1634 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1635 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1636 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1637 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1638 case E_MIPS_MACH_MIPS32_4K
: strcat (buf
, ", mips32-4k"); break;
1639 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1640 default: strcat (buf
, " UNKNOWN"); break;
1645 if (e_flags
& EF_SPARC_32PLUS
)
1646 strcat (buf
, ", v8+");
1648 if (e_flags
& EF_SPARC_SUN_US1
)
1649 strcat (buf
, ", ultrasparcI");
1651 if (e_flags
& EF_SPARC_SUN_US3
)
1652 strcat (buf
, ", ultrasparcIII");
1654 if (e_flags
& EF_SPARC_HAL_R1
)
1655 strcat (buf
, ", halr1");
1657 if (e_flags
& EF_SPARC_LEDATA
)
1658 strcat (buf
, ", ledata");
1660 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1661 strcat (buf
, ", tso");
1663 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1664 strcat (buf
, ", pso");
1666 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1667 strcat (buf
, ", rmo");
1671 switch (e_flags
& EF_PARISC_ARCH
)
1673 case EFA_PARISC_1_0
:
1674 strcpy (buf
, ", PA-RISC 1.0");
1676 case EFA_PARISC_1_1
:
1677 strcpy (buf
, ", PA-RISC 1.1");
1679 case EFA_PARISC_2_0
:
1680 strcpy (buf
, ", PA-RISC 2.0");
1685 if (e_flags
& EF_PARISC_TRAPNIL
)
1686 strcat (buf
, ", trapnil");
1687 if (e_flags
& EF_PARISC_EXT
)
1688 strcat (buf
, ", ext");
1689 if (e_flags
& EF_PARISC_LSB
)
1690 strcat (buf
, ", lsb");
1691 if (e_flags
& EF_PARISC_WIDE
)
1692 strcat (buf
, ", wide");
1693 if (e_flags
& EF_PARISC_NO_KABP
)
1694 strcat (buf
, ", no kabp");
1695 if (e_flags
& EF_PARISC_LAZYSWAP
)
1696 strcat (buf
, ", lazyswap");
1700 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1701 strcat (buf
, ", new calling convention");
1703 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1704 strcat (buf
, ", gnu calling convention");
1708 if ((e_flags
& EF_IA_64_ABI64
))
1709 strcat (buf
, ", 64-bit");
1711 strcat (buf
, ", 32-bit");
1712 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1713 strcat (buf
, ", reduced fp model");
1714 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1715 strcat (buf
, ", no function descriptors, constant gp");
1716 else if ((e_flags
& EF_IA_64_CONS_GP
))
1717 strcat (buf
, ", constant gp");
1718 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1719 strcat (buf
, ", absolute");
1728 get_mips_segment_type (type
)
1733 case PT_MIPS_REGINFO
:
1735 case PT_MIPS_RTPROC
:
1737 case PT_MIPS_OPTIONS
:
1747 get_parisc_segment_type (type
)
1752 case PT_HP_TLS
: return "HP_TLS";
1753 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1754 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1755 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1756 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1757 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1758 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1759 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1760 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1761 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1762 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1763 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1764 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1765 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1774 get_ia64_segment_type (type
)
1779 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1780 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1789 get_segment_type (p_type
)
1790 unsigned long p_type
;
1792 static char buff
[32];
1796 case PT_NULL
: return "NULL";
1797 case PT_LOAD
: return "LOAD";
1798 case PT_DYNAMIC
: return "DYNAMIC";
1799 case PT_INTERP
: return "INTERP";
1800 case PT_NOTE
: return "NOTE";
1801 case PT_SHLIB
: return "SHLIB";
1802 case PT_PHDR
: return "PHDR";
1805 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1807 const char * result
;
1809 switch (elf_header
.e_machine
)
1812 case EM_MIPS_RS3_LE
:
1813 result
= get_mips_segment_type (p_type
);
1816 result
= get_parisc_segment_type (p_type
);
1819 result
= get_ia64_segment_type (p_type
);
1829 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1831 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1833 const char * result
;
1835 switch (elf_header
.e_machine
)
1838 result
= get_parisc_segment_type (p_type
);
1848 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1851 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1858 get_mips_section_type_name (sh_type
)
1859 unsigned int sh_type
;
1863 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1864 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1865 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1866 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1867 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1868 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1869 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1870 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1871 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1872 case SHT_MIPS_RELD
: return "MIPS_RELD";
1873 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1874 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1875 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1876 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1877 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1878 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1879 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1880 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1881 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1882 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1883 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1884 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1885 case SHT_MIPS_LINE
: return "MIPS_LINE";
1886 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1887 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1888 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1889 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1890 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1891 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1892 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1893 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1894 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1895 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1896 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1897 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1898 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1899 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1900 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1901 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1909 get_parisc_section_type_name (sh_type
)
1910 unsigned int sh_type
;
1914 case SHT_PARISC_EXT
: return "PARISC_EXT";
1915 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1916 case SHT_PARISC_DOC
: return "PARISC_DOC";
1924 get_ia64_section_type_name (sh_type
)
1925 unsigned int sh_type
;
1929 case SHT_IA_64_EXT
: return "IA_64_EXT";
1930 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
1938 get_section_type_name (sh_type
)
1939 unsigned int sh_type
;
1941 static char buff
[32];
1945 case SHT_NULL
: return "NULL";
1946 case SHT_PROGBITS
: return "PROGBITS";
1947 case SHT_SYMTAB
: return "SYMTAB";
1948 case SHT_STRTAB
: return "STRTAB";
1949 case SHT_RELA
: return "RELA";
1950 case SHT_HASH
: return "HASH";
1951 case SHT_DYNAMIC
: return "DYNAMIC";
1952 case SHT_NOTE
: return "NOTE";
1953 case SHT_NOBITS
: return "NOBITS";
1954 case SHT_REL
: return "REL";
1955 case SHT_SHLIB
: return "SHLIB";
1956 case SHT_DYNSYM
: return "DYNSYM";
1957 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1958 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1959 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1960 case SHT_GROUP
: return "GROUP";
1961 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
1962 case SHT_GNU_verdef
: return "VERDEF";
1963 case SHT_GNU_verneed
: return "VERNEED";
1964 case SHT_GNU_versym
: return "VERSYM";
1965 case 0x6ffffff0: return "VERSYM";
1966 case 0x6ffffffc: return "VERDEF";
1967 case 0x7ffffffd: return "AUXILIARY";
1968 case 0x7fffffff: return "FILTER";
1971 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1973 const char * result
;
1975 switch (elf_header
.e_machine
)
1978 case EM_MIPS_RS3_LE
:
1979 result
= get_mips_section_type_name (sh_type
);
1982 result
= get_parisc_section_type_name (sh_type
);
1985 result
= get_ia64_section_type_name (sh_type
);
1995 sprintf (buff
, "SHT_LOPROC+%x", sh_type
- SHT_LOPROC
);
1997 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
1998 sprintf (buff
, "SHT_LOOS+%x", sh_type
- SHT_LOOS
);
1999 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2000 sprintf (buff
, "SHT_LOUSER+%x", sh_type
- SHT_LOUSER
);
2002 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2008 struct option options
[] =
2010 {"all", no_argument
, 0, 'a'},
2011 {"file-header", no_argument
, 0, 'h'},
2012 {"program-headers", no_argument
, 0, 'l'},
2013 {"headers", no_argument
, 0, 'e'},
2014 {"histogram", no_argument
, 0, 'I'},
2015 {"segments", no_argument
, 0, 'l'},
2016 {"sections", no_argument
, 0, 'S'},
2017 {"section-headers", no_argument
, 0, 'S'},
2018 {"symbols", no_argument
, 0, 's'},
2019 {"syms", no_argument
, 0, 's'},
2020 {"relocs", no_argument
, 0, 'r'},
2021 {"notes", no_argument
, 0, 'n'},
2022 {"dynamic", no_argument
, 0, 'd'},
2023 {"arch-specific", no_argument
, 0, 'A'},
2024 {"version-info", no_argument
, 0, 'V'},
2025 {"use-dynamic", no_argument
, 0, 'D'},
2026 {"hex-dump", required_argument
, 0, 'x'},
2027 {"debug-dump", optional_argument
, 0, 'w'},
2028 {"unwind", no_argument
, 0, 'u'},
2029 #ifdef SUPPORT_DISASSEMBLY
2030 {"instruction-dump", required_argument
, 0, 'i'},
2033 {"version", no_argument
, 0, 'v'},
2034 {"help", no_argument
, 0, 'H'},
2035 {0, no_argument
, 0, 0}
2041 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
2042 fprintf (stdout
, _(" Options are:\n"));
2043 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
2044 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
2045 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
2046 fprintf (stdout
, _(" Display the program headers\n"));
2047 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
2048 fprintf (stdout
, _(" Display the sections' header\n"));
2049 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
2050 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
2051 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
2052 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
2053 fprintf (stdout
, _(" -u or --unwind Display the unwind info (if present)\n"));
2054 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
2055 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
2056 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
2057 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
2058 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
2059 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
2060 fprintf (stdout
, _(" -w[liaprmf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames]\n"));
2061 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
2062 #ifdef SUPPORT_DISASSEMBLY
2063 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
2064 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
2066 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2067 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
2068 fprintf (stdout
, _(" -H or --help Display this information\n"));
2069 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2075 request_dump (section
, type
)
2076 unsigned int section
;
2079 if (section
>= num_dump_sects
)
2081 char * new_dump_sects
;
2083 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2085 if (new_dump_sects
== NULL
)
2086 error (_("Out of memory allocating dump request table."));
2089 /* Copy current flag settings. */
2090 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2094 dump_sects
= new_dump_sects
;
2095 num_dump_sects
= section
+ 1;
2100 dump_sects
[section
] |= type
;
2106 parse_args (argc
, argv
)
2115 while ((c
= getopt_long
2116 (argc
, argv
, "ersuahnldSDAIw::x:i:vV", options
, NULL
)) != EOF
)
2152 do_using_dynamic
++;
2183 section
= strtoul (optarg
, & cp
, 0);
2184 if (! * cp
&& section
>= 0)
2186 request_dump (section
, HEX_DUMP
);
2206 do_debug_abbrevs
= 1;
2216 do_debug_pubnames
= 1;
2221 do_debug_aranges
= 1;
2225 do_debug_frames_interp
= 1;
2227 do_debug_frames
= 1;
2232 do_debug_macinfo
= 1;
2236 warn (_("Unrecognised debug option '%s'\n"), optarg
);
2241 #ifdef SUPPORT_DISASSEMBLY
2244 section
= strtoul (optarg
, & cp
, 0);
2245 if (! * cp
&& section
>= 0)
2247 request_dump (section
, DISASS_DUMP
);
2253 print_version (program_name
);
2260 /* xgettext:c-format */
2261 error (_("Invalid option '-%c'\n"), c
);
2268 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2269 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2270 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2274 warn (_("Nothing to do.\n"));
2280 get_elf_class (elf_class
)
2281 unsigned char elf_class
;
2283 static char buff
[32];
2287 case ELFCLASSNONE
: return _("none");
2288 case ELFCLASS32
: return _("ELF32");
2289 case ELFCLASS64
: return _("ELF64");
2291 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2297 get_data_encoding (encoding
)
2298 unsigned char encoding
;
2300 static char buff
[32];
2304 case ELFDATANONE
: return _("none");
2305 case ELFDATA2LSB
: return _("2's complement, little endian");
2306 case ELFDATA2MSB
: return _("2's complement, big endian");
2308 sprintf (buff
, _("<unknown: %x>"), encoding
);
2314 get_osabi_name (osabi
)
2315 unsigned char osabi
;
2317 static char buff
[32];
2321 case ELFOSABI_NONE
: return _("UNIX - System V");
2322 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2323 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2324 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2325 case ELFOSABI_HURD
: return _("GNU/Hurd");
2326 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2327 case ELFOSABI_AIX
: return _("UNIX - AIX");
2328 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2329 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2330 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2331 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2332 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2333 case ELFOSABI_STANDALONE
: return _("Standalone App");
2334 case ELFOSABI_ARM
: return _("ARM");
2336 sprintf (buff
, _("<unknown: %x>"), osabi
);
2341 /* Decode the data held in 'elf_header'. */
2343 process_file_header ()
2345 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2346 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2347 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2348 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2351 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2359 printf (_("ELF Header:\n"));
2360 printf (_(" Magic: "));
2361 for (i
= 0; i
< EI_NIDENT
; i
++)
2362 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2364 printf (_(" Class: %s\n"),
2365 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2366 printf (_(" Data: %s\n"),
2367 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2368 printf (_(" Version: %d %s\n"),
2369 elf_header
.e_ident
[EI_VERSION
],
2370 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2372 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2375 printf (_(" OS/ABI: %s\n"),
2376 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2377 printf (_(" ABI Version: %d\n"),
2378 elf_header
.e_ident
[EI_ABIVERSION
]);
2379 printf (_(" Type: %s\n"),
2380 get_file_type (elf_header
.e_type
));
2381 printf (_(" Machine: %s\n"),
2382 get_machine_name (elf_header
.e_machine
));
2383 printf (_(" Version: 0x%lx\n"),
2384 (unsigned long) elf_header
.e_version
);
2386 printf (_(" Entry point address: "));
2387 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2388 printf (_("\n Start of program headers: "));
2389 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2390 printf (_(" (bytes into file)\n Start of section headers: "));
2391 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2392 printf (_(" (bytes into file)\n"));
2394 printf (_(" Flags: 0x%lx%s\n"),
2395 (unsigned long) elf_header
.e_flags
,
2396 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2397 printf (_(" Size of this header: %ld (bytes)\n"),
2398 (long) elf_header
.e_ehsize
);
2399 printf (_(" Size of program headers: %ld (bytes)\n"),
2400 (long) elf_header
.e_phentsize
);
2401 printf (_(" Number of program headers: %ld\n"),
2402 (long) elf_header
.e_phnum
);
2403 printf (_(" Size of section headers: %ld (bytes)\n"),
2404 (long) elf_header
.e_shentsize
);
2405 printf (_(" Number of section headers: %ld\n"),
2406 (long) elf_header
.e_shnum
);
2407 printf (_(" Section header string table index: %ld\n"),
2408 (long) elf_header
.e_shstrndx
);
2416 get_32bit_program_headers (file
, program_headers
)
2418 Elf_Internal_Phdr
* program_headers
;
2420 Elf32_External_Phdr
* phdrs
;
2421 Elf32_External_Phdr
* external
;
2422 Elf32_Internal_Phdr
* internal
;
2425 phdrs
= ((Elf32_External_Phdr
*)
2426 get_data (NULL
, file
, elf_header
.e_phoff
,
2427 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2428 _("program headers")));
2432 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2433 i
< elf_header
.e_phnum
;
2434 i
++, internal
++, external
++)
2436 internal
->p_type
= BYTE_GET (external
->p_type
);
2437 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2438 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2439 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2440 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2441 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2442 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2443 internal
->p_align
= BYTE_GET (external
->p_align
);
2452 get_64bit_program_headers (file
, program_headers
)
2454 Elf_Internal_Phdr
* program_headers
;
2456 Elf64_External_Phdr
* phdrs
;
2457 Elf64_External_Phdr
* external
;
2458 Elf64_Internal_Phdr
* internal
;
2461 phdrs
= ((Elf64_External_Phdr
*)
2462 get_data (NULL
, file
, elf_header
.e_phoff
,
2463 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2464 _("program headers")));
2468 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2469 i
< elf_header
.e_phnum
;
2470 i
++, internal
++, external
++)
2472 internal
->p_type
= BYTE_GET (external
->p_type
);
2473 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2474 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2475 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2476 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2477 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2478 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2479 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2488 process_program_headers (file
)
2491 Elf_Internal_Phdr
* program_headers
;
2492 Elf_Internal_Phdr
* segment
;
2495 if (elf_header
.e_phnum
== 0)
2498 printf (_("\nThere are no program headers in this file.\n"));
2502 if (do_segments
&& !do_header
)
2504 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2505 printf (_("Entry point "));
2506 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2507 printf (_("\nThere are %d program headers, starting at offset "),
2508 elf_header
.e_phnum
);
2509 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2513 program_headers
= (Elf_Internal_Phdr
*) malloc
2514 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2516 if (program_headers
== NULL
)
2518 error (_("Out of memory\n"));
2523 i
= get_32bit_program_headers (file
, program_headers
);
2525 i
= get_64bit_program_headers (file
, program_headers
);
2529 free (program_headers
);
2536 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2540 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2544 (_(" Type Offset VirtAddr PhysAddr\n"));
2546 (_(" FileSiz MemSiz Flags Align\n"));
2554 for (i
= 0, segment
= program_headers
;
2555 i
< elf_header
.e_phnum
;
2560 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2564 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2565 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2566 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2567 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2568 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2570 (segment
->p_flags
& PF_R
? 'R' : ' '),
2571 (segment
->p_flags
& PF_W
? 'W' : ' '),
2572 (segment
->p_flags
& PF_X
? 'E' : ' '));
2573 printf ("%#lx", (unsigned long) segment
->p_align
);
2577 print_vma (segment
->p_offset
, FULL_HEX
);
2579 print_vma (segment
->p_vaddr
, FULL_HEX
);
2581 print_vma (segment
->p_paddr
, FULL_HEX
);
2583 print_vma (segment
->p_filesz
, FULL_HEX
);
2585 print_vma (segment
->p_memsz
, FULL_HEX
);
2587 (segment
->p_flags
& PF_R
? 'R' : ' '),
2588 (segment
->p_flags
& PF_W
? 'W' : ' '),
2589 (segment
->p_flags
& PF_X
? 'E' : ' '));
2590 print_vma (segment
->p_align
, HEX
);
2594 switch (segment
->p_type
)
2598 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2599 - (segment
->p_offset
& 0xfffff000);
2604 error (_("more than one dynamic segment\n"));
2606 dynamic_addr
= segment
->p_offset
;
2607 dynamic_size
= segment
->p_filesz
;
2611 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2612 error (_("Unable to find program interpreter name\n"));
2615 program_interpreter
[0] = 0;
2616 fscanf (file
, "%63s", program_interpreter
);
2619 printf (_("\n [Requesting program interpreter: %s]"),
2620 program_interpreter
);
2626 putc ('\n', stdout
);
2635 if (do_segments
&& section_headers
!= NULL
)
2637 printf (_("\n Section to Segment mapping:\n"));
2638 printf (_(" Segment Sections...\n"));
2640 assert (string_table
!= NULL
);
2642 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2645 Elf_Internal_Shdr
* section
;
2647 segment
= program_headers
+ i
;
2648 section
= section_headers
;
2650 printf (" %2.2d ", i
);
2652 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2654 if (section
->sh_size
> 0
2655 /* Compare allocated sections by VMA, unallocated
2656 sections by file offset. */
2657 && (section
->sh_flags
& SHF_ALLOC
2658 ? (section
->sh_addr
>= segment
->p_vaddr
2659 && section
->sh_addr
+ section
->sh_size
2660 <= segment
->p_vaddr
+ segment
->p_memsz
)
2661 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2662 && (section
->sh_offset
+ section
->sh_size
2663 <= segment
->p_offset
+ segment
->p_filesz
))))
2664 printf ("%s ", SECTION_NAME (section
));
2671 free (program_headers
);
2678 get_32bit_section_headers (file
)
2681 Elf32_External_Shdr
* shdrs
;
2682 Elf32_Internal_Shdr
* internal
;
2685 shdrs
= ((Elf32_External_Shdr
*)
2686 get_data (NULL
, file
, elf_header
.e_shoff
,
2687 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2688 _("section headers")));
2692 section_headers
= (Elf_Internal_Shdr
*) malloc
2693 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2695 if (section_headers
== NULL
)
2697 error (_("Out of memory\n"));
2701 for (i
= 0, internal
= section_headers
;
2702 i
< elf_header
.e_shnum
;
2705 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2706 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2707 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2708 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2709 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2710 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2711 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2712 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2713 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2714 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2723 get_64bit_section_headers (file
)
2726 Elf64_External_Shdr
* shdrs
;
2727 Elf64_Internal_Shdr
* internal
;
2730 shdrs
= ((Elf64_External_Shdr
*)
2731 get_data (NULL
, file
, elf_header
.e_shoff
,
2732 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2733 _("section headers")));
2737 section_headers
= (Elf_Internal_Shdr
*) malloc
2738 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2740 if (section_headers
== NULL
)
2742 error (_("Out of memory\n"));
2746 for (i
= 0, internal
= section_headers
;
2747 i
< elf_header
.e_shnum
;
2750 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2751 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2752 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2753 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2754 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2755 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2756 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2757 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2758 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2759 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2767 static Elf_Internal_Sym
*
2768 get_32bit_elf_symbols (file
, offset
, number
)
2770 unsigned long offset
;
2771 unsigned long number
;
2773 Elf32_External_Sym
* esyms
;
2774 Elf_Internal_Sym
* isyms
;
2775 Elf_Internal_Sym
* psym
;
2778 esyms
= ((Elf32_External_Sym
*)
2779 get_data (NULL
, file
, offset
,
2780 number
* sizeof (Elf32_External_Sym
), _("symbols")));
2784 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2788 error (_("Out of memory\n"));
2794 for (j
= 0, psym
= isyms
;
2798 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2799 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2800 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2801 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2802 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2803 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2811 static Elf_Internal_Sym
*
2812 get_64bit_elf_symbols (file
, offset
, number
)
2814 unsigned long offset
;
2815 unsigned long number
;
2817 Elf64_External_Sym
* esyms
;
2818 Elf_Internal_Sym
* isyms
;
2819 Elf_Internal_Sym
* psym
;
2822 esyms
= ((Elf64_External_Sym
*)
2823 get_data (NULL
, file
, offset
,
2824 number
* sizeof (Elf64_External_Sym
), _("symbols")));
2828 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2832 error (_("Out of memory\n"));
2838 for (j
= 0, psym
= isyms
;
2842 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2843 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2844 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2845 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2846 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2847 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2856 get_elf_section_flags (sh_flags
)
2859 static char buff
[32];
2867 flag
= sh_flags
& - sh_flags
;
2872 case SHF_WRITE
: strcat (buff
, "W"); break;
2873 case SHF_ALLOC
: strcat (buff
, "A"); break;
2874 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2875 case SHF_MERGE
: strcat (buff
, "M"); break;
2876 case SHF_STRINGS
: strcat (buff
, "S"); break;
2877 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2878 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2879 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2880 case SHF_GROUP
: strcat (buff
, "G"); break;
2883 if (flag
& SHF_MASKOS
)
2886 sh_flags
&= ~ SHF_MASKOS
;
2888 else if (flag
& SHF_MASKPROC
)
2891 sh_flags
&= ~ SHF_MASKPROC
;
2903 process_section_headers (file
)
2906 Elf_Internal_Shdr
* section
;
2909 section_headers
= NULL
;
2911 if (elf_header
.e_shnum
== 0)
2914 printf (_("\nThere are no sections in this file.\n"));
2919 if (do_sections
&& !do_header
)
2920 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2921 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2925 if (! get_32bit_section_headers (file
))
2928 else if (! get_64bit_section_headers (file
))
2931 /* Read in the string table, so that we have names to display. */
2932 section
= section_headers
+ elf_header
.e_shstrndx
;
2934 if (section
->sh_size
!= 0)
2936 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
2937 section
->sh_size
, _("string table"));
2939 string_table_length
= section
->sh_size
;
2942 /* Scan the sections for the dynamic symbol table
2943 and dynamic string table and debug sections. */
2944 dynamic_symbols
= NULL
;
2945 dynamic_strings
= NULL
;
2946 dynamic_syminfo
= NULL
;
2948 for (i
= 0, section
= section_headers
;
2949 i
< elf_header
.e_shnum
;
2952 char * name
= SECTION_NAME (section
);
2954 if (section
->sh_type
== SHT_DYNSYM
)
2956 if (dynamic_symbols
!= NULL
)
2958 error (_("File contains multiple dynamic symbol tables\n"));
2962 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
2964 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
2966 else if (section
->sh_type
== SHT_STRTAB
2967 && strcmp (name
, ".dynstr") == 0)
2969 if (dynamic_strings
!= NULL
)
2971 error (_("File contains multiple dynamic string tables\n"));
2975 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
2977 _("dynamic strings"));
2979 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
2980 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
2981 || do_debug_frames
|| do_debug_macinfo
)
2982 && strncmp (name
, ".debug_", 7) == 0)
2987 || (do_debug_info
&& (strcmp (name
, "info") == 0))
2988 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
2989 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
2990 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
2991 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
2992 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
2993 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
2995 request_dump (i
, DEBUG_DUMP
);
2997 /* linkonce section to be combined with .debug_info at link time. */
2998 else if ((do_debugging
|| do_debug_info
)
2999 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3000 request_dump (i
, DEBUG_DUMP
);
3001 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3002 request_dump (i
, DEBUG_DUMP
);
3008 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
3012 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3015 printf (_(" [Nr] Name Type Address Offset\n"));
3016 printf (_(" Size EntSize Flags Link Info Align\n"));
3019 for (i
= 0, section
= section_headers
;
3020 i
< elf_header
.e_shnum
;
3023 printf (" [%2d] %-17.17s %-15.15s ",
3025 SECTION_NAME (section
),
3026 get_section_type_name (section
->sh_type
));
3030 print_vma (section
->sh_addr
, LONG_HEX
);
3032 printf ( " %6.6lx %6.6lx %2.2lx",
3033 (unsigned long) section
->sh_offset
,
3034 (unsigned long) section
->sh_size
,
3035 (unsigned long) section
->sh_entsize
);
3037 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3039 printf ("%2ld %3lx %2ld\n",
3040 (unsigned long) section
->sh_link
,
3041 (unsigned long) section
->sh_info
,
3042 (unsigned long) section
->sh_addralign
);
3047 print_vma (section
->sh_addr
, LONG_HEX
);
3048 printf (" %8.8lx", section
->sh_offset
);
3050 print_vma (section
->sh_size
, LONG_HEX
);
3052 print_vma (section
->sh_entsize
, LONG_HEX
);
3054 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3056 printf (" %2ld %3lx %ld\n",
3057 (unsigned long) section
->sh_link
,
3058 (unsigned long) section
->sh_info
,
3059 (unsigned long) section
->sh_addralign
);
3063 printf (_("Key to Flags:\n"));
3064 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
3065 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
3066 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3071 /* Process the reloc section. */
3073 process_relocs (file
)
3076 unsigned long rel_size
;
3077 unsigned long rel_offset
;
3083 if (do_using_dynamic
)
3085 int is_rela
= FALSE
;
3090 if (dynamic_info
[DT_REL
])
3092 rel_offset
= dynamic_info
[DT_REL
];
3093 rel_size
= dynamic_info
[DT_RELSZ
];
3096 else if (dynamic_info
[DT_RELA
])
3098 rel_offset
= dynamic_info
[DT_RELA
];
3099 rel_size
= dynamic_info
[DT_RELASZ
];
3102 else if (dynamic_info
[DT_JMPREL
])
3104 rel_offset
= dynamic_info
[DT_JMPREL
];
3105 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3107 switch (dynamic_info
[DT_PLTREL
])
3124 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3125 rel_offset
, rel_size
);
3127 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3128 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3131 printf (_("\nThere are no dynamic relocations in this file.\n"));
3135 Elf32_Internal_Shdr
* section
;
3139 for (i
= 0, section
= section_headers
;
3140 i
< elf_header
.e_shnum
;
3143 if ( section
->sh_type
!= SHT_RELA
3144 && section
->sh_type
!= SHT_REL
)
3147 rel_offset
= section
->sh_offset
;
3148 rel_size
= section
->sh_size
;
3152 Elf32_Internal_Shdr
* strsec
;
3153 Elf_Internal_Sym
* symtab
;
3156 unsigned long nsyms
;
3158 printf (_("\nRelocation section "));
3160 if (string_table
== NULL
)
3161 printf ("%d", section
->sh_name
);
3163 printf ("'%s'", SECTION_NAME (section
));
3165 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3166 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3171 if (section
->sh_link
)
3173 Elf32_Internal_Shdr
* symsec
;
3175 symsec
= section_headers
+ section
->sh_link
;
3176 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3177 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
3182 strsec
= section_headers
+ symsec
->sh_link
;
3184 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3188 is_rela
= section
->sh_type
== SHT_RELA
;
3190 dump_relocations (file
, rel_offset
, rel_size
,
3191 symtab
, nsyms
, strtab
, is_rela
);
3203 printf (_("\nThere are no relocations in this file.\n"));
3209 #include "unwind-ia64.h"
3211 /* An absolute address consists of a section and an offset. If the
3212 section is NULL, the offset itself is the address, otherwise, the
3213 address equals to LOAD_ADDRESS(section) + offset. */
3217 unsigned short section
;
3223 struct unw_table_entry
3225 struct absaddr start
;
3227 struct absaddr info
;
3229 *table
; /* Unwind table. */
3230 unsigned long table_len
; /* Length of unwind table. */
3231 unsigned char * info
; /* Unwind info. */
3232 unsigned long info_size
; /* Size of unwind info. */
3233 bfd_vma info_addr
; /* starting address of unwind info. */
3234 bfd_vma seg_base
; /* Starting address of segment. */
3235 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3236 unsigned long nsyms
; /* Number of symbols. */
3237 char * strtab
; /* The string table. */
3238 unsigned long strtab_size
; /* Size of string table. */
3241 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3242 struct absaddr
, const char **,
3244 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3245 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3246 Elf32_Internal_Shdr
*));
3249 find_symbol_for_address (aux
, addr
, symname
, offset
)
3250 struct unw_aux_info
*aux
;
3251 struct absaddr addr
;
3252 const char **symname
;
3255 bfd_vma dist
= (bfd_vma
) 0x100000;
3256 Elf_Internal_Sym
*sym
, *best
= NULL
;
3259 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3261 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3262 && sym
->st_name
!= 0
3263 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3264 && addr
.offset
>= sym
->st_value
3265 && addr
.offset
- sym
->st_value
< dist
)
3268 dist
= addr
.offset
- sym
->st_value
;
3275 *symname
= (best
->st_name
>= aux
->strtab_size
3276 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3281 *offset
= addr
.offset
;
3285 dump_ia64_unwind (aux
)
3286 struct unw_aux_info
*aux
;
3289 struct unw_table_entry
* tp
;
3292 addr_size
= is_32bit_elf
? 4 : 8;
3294 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3298 const unsigned char * dp
;
3299 const unsigned char * head
;
3300 const char * procname
;
3302 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3304 fputs ("\n<", stdout
);
3308 fputs (procname
, stdout
);
3311 printf ("+%lx", (unsigned long) offset
);
3314 fputs (">: [", stdout
);
3315 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3316 fputc ('-', stdout
);
3317 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3318 printf ("), info at +0x%lx\n",
3319 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3321 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3322 stamp
= BYTE_GET8 ((unsigned char *) head
);
3324 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3325 (unsigned) UNW_VER (stamp
),
3326 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3327 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3328 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3329 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3331 if (UNW_VER (stamp
) != 1)
3333 printf ("\tUnknown version.\n");
3338 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3339 dp
= unw_decode (dp
, in_body
, & in_body
);
3344 slurp_ia64_unwind_table (file
, aux
, sec
)
3346 struct unw_aux_info
*aux
;
3347 Elf32_Internal_Shdr
*sec
;
3349 unsigned long size
, addr_size
, nrelas
, i
;
3350 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3351 struct unw_table_entry
*tep
;
3352 Elf32_Internal_Shdr
*relsec
;
3353 Elf_Internal_Rela
*rela
, *rp
;
3354 unsigned char *table
, *tp
;
3355 Elf_Internal_Sym
*sym
;
3356 const char *relname
;
3359 addr_size
= is_32bit_elf
? 4 : 8;
3361 /* First, find the starting address of the segment that includes
3364 if (elf_header
.e_phnum
)
3366 prog_hdrs
= (Elf_Internal_Phdr
*)
3367 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3370 result
= get_32bit_program_headers (file
, prog_hdrs
);
3372 result
= get_64bit_program_headers (file
, prog_hdrs
);
3380 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3382 if (seg
->p_type
!= PT_LOAD
)
3385 if (sec
->sh_addr
>= seg
->p_vaddr
3386 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3388 aux
->seg_base
= seg
->p_vaddr
;
3396 /* Second, build the unwind table from the contents of the unwind section: */
3397 size
= sec
->sh_size
;
3398 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3399 size
, _("unwind table"));
3403 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3404 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3406 tep
->start
.section
= SHN_UNDEF
;
3407 tep
->end
.section
= SHN_UNDEF
;
3408 tep
->info
.section
= SHN_UNDEF
;
3411 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3412 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3413 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3417 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3418 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3419 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3421 tep
->start
.offset
+= aux
->seg_base
;
3422 tep
->end
.offset
+= aux
->seg_base
;
3423 tep
->info
.offset
+= aux
->seg_base
;
3427 /* Third, apply any relocations to the unwind table: */
3429 for (relsec
= section_headers
;
3430 relsec
< section_headers
+ elf_header
.e_shnum
;
3433 if (relsec
->sh_type
!= SHT_RELA
3434 || section_headers
+ relsec
->sh_info
!= sec
)
3437 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3441 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3445 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3446 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3448 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3450 warn (_("Skipping unexpected symbol type %u"),
3451 ELF32_ST_TYPE (sym
->st_info
));
3457 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3458 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3460 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3462 warn (_("Skipping unexpected symbol type %u"),
3463 ELF64_ST_TYPE (sym
->st_info
));
3468 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3470 warn (_("Skipping unexpected relocation type %s"), relname
);
3474 i
= rp
->r_offset
/ (3 * addr_size
);
3476 switch (rp
->r_offset
/addr_size
% 3)
3479 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3480 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3483 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3484 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3487 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3488 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3498 aux
->table_len
= size
/ (3 * addr_size
);
3503 process_unwind (file
)
3506 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3507 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3508 struct unw_aux_info aux
;
3513 if (elf_header
.e_machine
!= EM_IA_64
)
3515 printf (_("\nThere are no unwind sections in this file.\n"));
3519 memset (& aux
, 0, sizeof (aux
));
3521 addr_size
= is_32bit_elf
? 4 : 8;
3523 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3525 if (sec
->sh_type
== SHT_SYMTAB
)
3527 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3528 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
->sh_offset
, aux
.nsyms
);
3530 strsec
= section_headers
+ sec
->sh_link
;
3531 aux
.strtab_size
= strsec
->sh_size
;
3532 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3533 aux
.strtab_size
, _("string table"));
3535 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3540 printf (_("\nThere are no unwind sections in this file.\n"));
3542 while (unwcount
-- > 0)
3547 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3548 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3549 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3556 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3558 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3561 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3562 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3563 suffix
= SECTION_NAME (unwsec
) + len
;
3564 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3566 if (strncmp (SECTION_NAME (sec
),
3567 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3568 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3573 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3574 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3575 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3576 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3578 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3580 suffix
= SECTION_NAME (unwsec
) + len
;
3581 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3583 if (strncmp (SECTION_NAME (sec
),
3584 ELF_STRING_ia64_unwind_info
, len2
) == 0
3585 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3589 if (i
== elf_header
.e_shnum
)
3591 printf (_("\nCould not find unwind info section for "));
3593 if (string_table
== NULL
)
3594 printf ("%d", unwsec
->sh_name
);
3596 printf ("'%s'", SECTION_NAME (unwsec
));
3600 aux
.info_size
= sec
->sh_size
;
3601 aux
.info_addr
= sec
->sh_addr
;
3602 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3603 aux
.info_size
, _("unwind info"));
3605 printf (_("\nUnwind section "));
3607 if (string_table
== NULL
)
3608 printf ("%d", unwsec
->sh_name
);
3610 printf ("'%s'", SECTION_NAME (unwsec
));
3612 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3614 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
3616 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
3618 if (aux
.table_len
> 0)
3619 dump_ia64_unwind (& aux
);
3622 free ((char *) aux
.table
);
3624 free ((char *) aux
.info
);
3633 free ((char *) aux
.strtab
);
3639 dynamic_segment_mips_val (entry
)
3640 Elf_Internal_Dyn
* entry
;
3642 switch (entry
->d_tag
)
3645 if (entry
->d_un
.d_val
== 0)
3649 static const char * opts
[] =
3651 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3652 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3653 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3654 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3659 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
3660 if (entry
->d_un
.d_val
& (1 << cnt
))
3662 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
3669 case DT_MIPS_IVERSION
:
3670 if (dynamic_strings
!= NULL
)
3671 printf ("Interface Version: %s\n",
3672 dynamic_strings
+ entry
->d_un
.d_val
);
3674 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3677 case DT_MIPS_TIME_STAMP
:
3682 time_t time
= entry
->d_un
.d_val
;
3683 tmp
= gmtime (&time
);
3684 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
3685 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
3686 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
3687 printf ("Time Stamp: %s\n", timebuf
);
3691 case DT_MIPS_RLD_VERSION
:
3692 case DT_MIPS_LOCAL_GOTNO
:
3693 case DT_MIPS_CONFLICTNO
:
3694 case DT_MIPS_LIBLISTNO
:
3695 case DT_MIPS_SYMTABNO
:
3696 case DT_MIPS_UNREFEXTNO
:
3697 case DT_MIPS_HIPAGENO
:
3698 case DT_MIPS_DELTA_CLASS_NO
:
3699 case DT_MIPS_DELTA_INSTANCE_NO
:
3700 case DT_MIPS_DELTA_RELOC_NO
:
3701 case DT_MIPS_DELTA_SYM_NO
:
3702 case DT_MIPS_DELTA_CLASSSYM_NO
:
3703 case DT_MIPS_COMPACT_SIZE
:
3704 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3708 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
3714 dynamic_segment_parisc_val (entry
)
3715 Elf_Internal_Dyn
* entry
;
3717 switch (entry
->d_tag
)
3719 case DT_HP_DLD_FLAGS
:
3728 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3729 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3730 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3731 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3732 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3733 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3734 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3735 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3736 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3737 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3738 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3742 bfd_vma val
= entry
->d_un
.d_val
;
3744 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3745 if (val
& flags
[cnt
].bit
)
3749 fputs (flags
[cnt
].str
, stdout
);
3751 val
^= flags
[cnt
].bit
;
3754 if (val
!= 0 || first
)
3758 print_vma (val
, HEX
);
3764 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3770 get_32bit_dynamic_segment (file
)
3773 Elf32_External_Dyn
* edyn
;
3774 Elf_Internal_Dyn
* entry
;
3777 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
3778 dynamic_size
, _("dynamic segment"));
3782 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3783 how large this .dynamic is now. We can do this even before the byte
3784 swapping since the DT_NULL tag is recognizable. */
3786 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3789 dynamic_segment
= (Elf_Internal_Dyn
*)
3790 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3792 if (dynamic_segment
== NULL
)
3794 error (_("Out of memory\n"));
3799 for (i
= 0, entry
= dynamic_segment
;
3803 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3804 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3813 get_64bit_dynamic_segment (file
)
3816 Elf64_External_Dyn
* edyn
;
3817 Elf_Internal_Dyn
* entry
;
3820 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
3821 dynamic_size
, _("dynamic segment"));
3825 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3826 how large this .dynamic is now. We can do this even before the byte
3827 swapping since the DT_NULL tag is recognizable. */
3829 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3832 dynamic_segment
= (Elf_Internal_Dyn
*)
3833 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3835 if (dynamic_segment
== NULL
)
3837 error (_("Out of memory\n"));
3842 for (i
= 0, entry
= dynamic_segment
;
3846 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3847 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3856 get_dynamic_flags (flags
)
3859 static char buff
[64];
3864 flag
= flags
& - flags
;
3869 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3870 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3871 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3872 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3873 default: strcat (buff
, "unknown "); break;
3879 /* Parse and display the contents of the dynamic segment. */
3881 process_dynamic_segment (file
)
3884 Elf_Internal_Dyn
* entry
;
3887 if (dynamic_size
== 0)
3890 printf (_("\nThere is no dynamic segment in this file.\n"));
3897 if (! get_32bit_dynamic_segment (file
))
3900 else if (! get_64bit_dynamic_segment (file
))
3903 /* Find the appropriate symbol table. */
3904 if (dynamic_symbols
== NULL
)
3906 for (i
= 0, entry
= dynamic_segment
;
3910 unsigned long offset
;
3912 if (entry
->d_tag
!= DT_SYMTAB
)
3915 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
3917 /* Since we do not know how big the symbol table is,
3918 we default to reading in the entire file (!) and
3919 processing that. This is overkill, I know, but it
3921 offset
= entry
->d_un
.d_val
- loadaddr
;
3923 if (fseek (file
, 0, SEEK_END
))
3924 error (_("Unable to seek to end of file!"));
3927 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
3929 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
3931 if (num_dynamic_syms
< 1)
3933 error (_("Unable to determine the number of symbols to load\n"));
3937 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
3941 /* Similarly find a string table. */
3942 if (dynamic_strings
== NULL
)
3944 for (i
= 0, entry
= dynamic_segment
;
3948 unsigned long offset
;
3951 if (entry
->d_tag
!= DT_STRTAB
)
3954 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
3956 /* Since we do not know how big the string table is,
3957 we default to reading in the entire file (!) and
3958 processing that. This is overkill, I know, but it
3961 offset
= entry
->d_un
.d_val
- loadaddr
;
3962 if (fseek (file
, 0, SEEK_END
))
3963 error (_("Unable to seek to end of file\n"));
3964 str_tab_len
= ftell (file
) - offset
;
3966 if (str_tab_len
< 1)
3969 (_("Unable to determine the length of the dynamic string table\n"));
3973 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
3974 _("dynamic string table"));
3980 /* And find the syminfo section if available. */
3981 if (dynamic_syminfo
== NULL
)
3983 unsigned int syminsz
= 0;
3985 for (i
= 0, entry
= dynamic_segment
;
3989 if (entry
->d_tag
== DT_SYMINENT
)
3991 /* Note: these braces are necessary to avoid a syntax
3992 error from the SunOS4 C compiler. */
3993 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
3995 else if (entry
->d_tag
== DT_SYMINSZ
)
3996 syminsz
= entry
->d_un
.d_val
;
3997 else if (entry
->d_tag
== DT_SYMINFO
)
3998 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4001 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4003 Elf_External_Syminfo
* extsyminfo
;
4004 Elf_Internal_Syminfo
* syminfo
;
4006 /* There is a syminfo section. Read the data. */
4007 extsyminfo
= ((Elf_External_Syminfo
*)
4008 get_data (NULL
, file
, dynamic_syminfo_offset
,
4009 syminsz
, _("symbol information")));
4013 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4014 if (dynamic_syminfo
== NULL
)
4016 error (_("Out of memory\n"));
4020 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4021 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4024 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4025 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4032 if (do_dynamic
&& dynamic_addr
)
4033 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4034 dynamic_addr
, (long) dynamic_size
);
4036 printf (_(" Tag Type Name/Value\n"));
4038 for (i
= 0, entry
= dynamic_segment
;
4047 print_vma (entry
->d_tag
, FULL_HEX
);
4048 dtype
= get_dynamic_type (entry
->d_tag
);
4049 printf (" (%s)%*s", dtype
,
4050 ((is_32bit_elf
? 27 : 19)
4051 - (int) strlen (dtype
)),
4055 switch (entry
->d_tag
)
4059 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
4069 switch (entry
->d_tag
)
4072 printf (_("Auxiliary library"));
4076 printf (_("Filter library"));
4080 printf (_("Configuration file"));
4084 printf (_("Dependency audit library"));
4088 printf (_("Audit library"));
4092 if (dynamic_strings
)
4093 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4097 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4106 printf (_("Flags:"));
4107 if (entry
->d_un
.d_val
== 0)
4108 printf (_(" None\n"));
4111 unsigned long int val
= entry
->d_un
.d_val
;
4112 if (val
& DTF_1_PARINIT
)
4114 printf (" PARINIT");
4115 val
^= DTF_1_PARINIT
;
4117 if (val
& DTF_1_CONFEXP
)
4119 printf (" CONFEXP");
4120 val
^= DTF_1_CONFEXP
;
4123 printf (" %lx", val
);
4132 printf (_("Flags:"));
4133 if (entry
->d_un
.d_val
== 0)
4134 printf (_(" None\n"));
4137 unsigned long int val
= entry
->d_un
.d_val
;
4138 if (val
& DF_P1_LAZYLOAD
)
4140 printf (" LAZYLOAD");
4141 val
^= DF_P1_LAZYLOAD
;
4143 if (val
& DF_P1_GROUPPERM
)
4145 printf (" GROUPPERM");
4146 val
^= DF_P1_GROUPPERM
;
4149 printf (" %lx", val
);
4158 printf (_("Flags:"));
4159 if (entry
->d_un
.d_val
== 0)
4160 printf (_(" None\n"));
4163 unsigned long int val
= entry
->d_un
.d_val
;
4169 if (val
& DF_1_GLOBAL
)
4174 if (val
& DF_1_GROUP
)
4179 if (val
& DF_1_NODELETE
)
4181 printf (" NODELETE");
4182 val
^= DF_1_NODELETE
;
4184 if (val
& DF_1_LOADFLTR
)
4186 printf (" LOADFLTR");
4187 val
^= DF_1_LOADFLTR
;
4189 if (val
& DF_1_INITFIRST
)
4191 printf (" INITFIRST");
4192 val
^= DF_1_INITFIRST
;
4194 if (val
& DF_1_NOOPEN
)
4199 if (val
& DF_1_ORIGIN
)
4204 if (val
& DF_1_DIRECT
)
4209 if (val
& DF_1_TRANS
)
4214 if (val
& DF_1_INTERPOSE
)
4216 printf (" INTERPOSE");
4217 val
^= DF_1_INTERPOSE
;
4219 if (val
& DF_1_NODEFLIB
)
4221 printf (" NODEFLIB");
4222 val
^= DF_1_NODEFLIB
;
4224 if (val
& DF_1_NODUMP
)
4229 if (val
& DF_1_CONLFAT
)
4231 printf (" CONLFAT");
4232 val
^= DF_1_CONLFAT
;
4235 printf (" %lx", val
);
4243 puts (get_dynamic_type (entry
->d_un
.d_val
));
4263 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4269 if (dynamic_strings
== NULL
)
4272 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4276 switch (entry
->d_tag
)
4279 printf (_("Shared library: [%s]"), name
);
4281 if (strcmp (name
, program_interpreter
) == 0)
4282 printf (_(" program interpreter"));
4286 printf (_("Library soname: [%s]"), name
);
4290 printf (_("Library rpath: [%s]"), name
);
4294 printf (_("Library runpath: [%s]"), name
);
4298 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4303 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4319 case DT_INIT_ARRAYSZ
:
4320 case DT_FINI_ARRAYSZ
:
4323 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4324 printf (" (bytes)\n");
4334 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4347 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4351 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4355 printf (_("Not needed object: [%s]\n"), name
);
4360 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4366 /* The value of this entry is ignored. */
4370 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4371 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4376 switch (elf_header
.e_machine
)
4379 case EM_MIPS_RS3_LE
:
4380 dynamic_segment_mips_val (entry
);
4383 dynamic_segment_parisc_val (entry
);
4386 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4398 get_ver_flags (flags
)
4401 static char buff
[32];
4408 if (flags
& VER_FLG_BASE
)
4409 strcat (buff
, "BASE ");
4411 if (flags
& VER_FLG_WEAK
)
4413 if (flags
& VER_FLG_BASE
)
4414 strcat (buff
, "| ");
4416 strcat (buff
, "WEAK ");
4419 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4420 strcat (buff
, "| <unknown>");
4425 /* Display the contents of the version sections. */
4427 process_version_sections (file
)
4430 Elf32_Internal_Shdr
* section
;
4437 for (i
= 0, section
= section_headers
;
4438 i
< elf_header
.e_shnum
;
4441 switch (section
->sh_type
)
4443 case SHT_GNU_verdef
:
4445 Elf_External_Verdef
* edefs
;
4452 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4453 SECTION_NAME (section
), section
->sh_info
);
4455 printf (_(" Addr: 0x"));
4456 printf_vma (section
->sh_addr
);
4457 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4458 (unsigned long) section
->sh_offset
, section
->sh_link
,
4459 SECTION_NAME (section_headers
+ section
->sh_link
));
4461 edefs
= ((Elf_External_Verdef
*)
4462 get_data (NULL
, file
, section
->sh_offset
,
4464 _("version definition section")));
4468 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4471 Elf_External_Verdef
* edef
;
4472 Elf_Internal_Verdef ent
;
4473 Elf_External_Verdaux
* eaux
;
4474 Elf_Internal_Verdaux aux
;
4478 vstart
= ((char *) edefs
) + idx
;
4480 edef
= (Elf_External_Verdef
*) vstart
;
4482 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4483 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4484 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4485 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4486 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4487 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4488 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4490 printf (_(" %#06x: Rev: %d Flags: %s"),
4491 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4493 printf (_(" Index: %d Cnt: %d "),
4494 ent
.vd_ndx
, ent
.vd_cnt
);
4496 vstart
+= ent
.vd_aux
;
4498 eaux
= (Elf_External_Verdaux
*) vstart
;
4500 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4501 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4503 if (dynamic_strings
)
4504 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4506 printf (_("Name index: %ld\n"), aux
.vda_name
);
4508 isum
= idx
+ ent
.vd_aux
;
4510 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4512 isum
+= aux
.vda_next
;
4513 vstart
+= aux
.vda_next
;
4515 eaux
= (Elf_External_Verdaux
*) vstart
;
4517 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4518 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4520 if (dynamic_strings
)
4521 printf (_(" %#06x: Parent %d: %s\n"),
4522 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4524 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4525 isum
, j
, aux
.vda_name
);
4535 case SHT_GNU_verneed
:
4537 Elf_External_Verneed
* eneed
;
4543 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4544 SECTION_NAME (section
), section
->sh_info
);
4546 printf (_(" Addr: 0x"));
4547 printf_vma (section
->sh_addr
);
4548 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4549 (unsigned long) section
->sh_offset
, section
->sh_link
,
4550 SECTION_NAME (section_headers
+ section
->sh_link
));
4552 eneed
= ((Elf_External_Verneed
*)
4553 get_data (NULL
, file
, section
->sh_offset
,
4554 section
->sh_size
, _("version need section")));
4558 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4560 Elf_External_Verneed
* entry
;
4561 Elf_Internal_Verneed ent
;
4566 vstart
= ((char *) eneed
) + idx
;
4568 entry
= (Elf_External_Verneed
*) vstart
;
4570 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4571 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4572 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4573 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4574 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4576 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
4578 if (dynamic_strings
)
4579 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
4581 printf (_(" File: %lx"), ent
.vn_file
);
4583 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
4585 vstart
+= ent
.vn_aux
;
4587 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
4589 Elf_External_Vernaux
* eaux
;
4590 Elf_Internal_Vernaux aux
;
4592 eaux
= (Elf_External_Vernaux
*) vstart
;
4594 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
4595 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
4596 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
4597 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
4598 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
4600 if (dynamic_strings
)
4601 printf (_(" %#06x: Name: %s"),
4602 isum
, dynamic_strings
+ aux
.vna_name
);
4604 printf (_(" %#06x: Name index: %lx"),
4605 isum
, aux
.vna_name
);
4607 printf (_(" Flags: %s Version: %d\n"),
4608 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
4610 isum
+= aux
.vna_next
;
4611 vstart
+= aux
.vna_next
;
4621 case SHT_GNU_versym
:
4623 Elf32_Internal_Shdr
* link_section
;
4626 unsigned char * edata
;
4627 unsigned short * data
;
4629 Elf_Internal_Sym
* symbols
;
4630 Elf32_Internal_Shdr
* string_sec
;
4632 link_section
= section_headers
+ section
->sh_link
;
4633 total
= section
->sh_size
/ section
->sh_entsize
;
4637 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
4638 link_section
->sh_size
/ link_section
->sh_entsize
);
4640 string_sec
= section_headers
+ link_section
->sh_link
;
4642 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
4643 string_sec
->sh_size
,
4644 _("version string table"));
4648 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4649 SECTION_NAME (section
), total
);
4651 printf (_(" Addr: "));
4652 printf_vma (section
->sh_addr
);
4653 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4654 (unsigned long) section
->sh_offset
, section
->sh_link
,
4655 SECTION_NAME (link_section
));
4659 get_data (NULL
, file
,
4660 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
4661 total
* sizeof (short), _("version symbol data")));
4668 data
= (unsigned short *) malloc (total
* sizeof (short));
4670 for (cnt
= total
; cnt
--;)
4671 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
4676 for (cnt
= 0; cnt
< total
; cnt
+= 4)
4679 int check_def
, check_need
;
4682 printf (" %03x:", cnt
);
4684 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
4685 switch (data
[cnt
+ j
])
4688 fputs (_(" 0 (*local*) "), stdout
);
4692 fputs (_(" 1 (*global*) "), stdout
);
4696 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
4697 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
4701 if (symbols
[cnt
+ j
].st_shndx
>= SHN_LORESERVE
4702 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
4705 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4712 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
4714 Elf_Internal_Verneed ivn
;
4715 unsigned long offset
;
4717 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4722 Elf_Internal_Vernaux ivna
;
4723 Elf_External_Verneed evn
;
4724 Elf_External_Vernaux evna
;
4725 unsigned long a_off
;
4727 get_data (&evn
, file
, offset
, sizeof (evn
),
4730 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4731 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4733 a_off
= offset
+ ivn
.vn_aux
;
4737 get_data (&evna
, file
, a_off
, sizeof (evna
),
4738 _("version need aux (2)"));
4740 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4741 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4743 a_off
+= ivna
.vna_next
;
4745 while (ivna
.vna_other
!= data
[cnt
+ j
]
4746 && ivna
.vna_next
!= 0);
4748 if (ivna
.vna_other
== data
[cnt
+ j
])
4750 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4752 name
= strtab
+ ivna
.vna_name
;
4753 nn
+= printf ("(%s%-*s",
4755 12 - (int) strlen (name
),
4761 offset
+= ivn
.vn_next
;
4763 while (ivn
.vn_next
);
4766 if (check_def
&& data
[cnt
+ j
] != 0x8001
4767 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
4769 Elf_Internal_Verdef ivd
;
4770 Elf_External_Verdef evd
;
4771 unsigned long offset
;
4773 offset
= version_info
4774 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4778 get_data (&evd
, file
, offset
, sizeof (evd
),
4781 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4782 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4784 offset
+= ivd
.vd_next
;
4786 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4787 && ivd
.vd_next
!= 0);
4789 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4791 Elf_External_Verdaux evda
;
4792 Elf_Internal_Verdaux ivda
;
4794 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4796 get_data (&evda
, file
,
4797 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4798 sizeof (evda
), _("version def aux"));
4800 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4802 name
= strtab
+ ivda
.vda_name
;
4803 nn
+= printf ("(%s%-*s",
4805 12 - (int) strlen (name
),
4811 printf ("%*c", 18 - nn
, ' ');
4829 printf (_("\nNo version information found in this file.\n"));
4835 get_symbol_binding (binding
)
4836 unsigned int binding
;
4838 static char buff
[32];
4842 case STB_LOCAL
: return "LOCAL";
4843 case STB_GLOBAL
: return "GLOBAL";
4844 case STB_WEAK
: return "WEAK";
4846 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4847 sprintf (buff
, _("<processor specific>: %d"), binding
);
4848 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4849 sprintf (buff
, _("<OS specific>: %d"), binding
);
4851 sprintf (buff
, _("<unknown>: %d"), binding
);
4857 get_symbol_type (type
)
4860 static char buff
[32];
4864 case STT_NOTYPE
: return "NOTYPE";
4865 case STT_OBJECT
: return "OBJECT";
4866 case STT_FUNC
: return "FUNC";
4867 case STT_SECTION
: return "SECTION";
4868 case STT_FILE
: return "FILE";
4869 case STT_COMMON
: return "COMMON";
4871 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4873 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4874 return "THUMB_FUNC";
4876 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4879 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4880 return "PARISC_MILLI";
4882 sprintf (buff
, _("<processor specific>: %d"), type
);
4884 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
4886 if (elf_header
.e_machine
== EM_PARISC
)
4888 if (type
== STT_HP_OPAQUE
)
4890 if (type
== STT_HP_STUB
)
4894 sprintf (buff
, _("<OS specific>: %d"), type
);
4897 sprintf (buff
, _("<unknown>: %d"), type
);
4903 get_symbol_visibility (visibility
)
4904 unsigned int visibility
;
4908 case STV_DEFAULT
: return "DEFAULT";
4909 case STV_INTERNAL
: return "INTERNAL";
4910 case STV_HIDDEN
: return "HIDDEN";
4911 case STV_PROTECTED
: return "PROTECTED";
4917 get_symbol_index_type (type
)
4922 case SHN_UNDEF
: return "UND";
4923 case SHN_ABS
: return "ABS";
4924 case SHN_COMMON
: return "COM";
4926 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
4928 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
4930 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
4934 static char buff
[32];
4936 sprintf (buff
, "%3d", type
);
4943 get_dynamic_data (file
, number
)
4945 unsigned int number
;
4947 unsigned char * e_data
;
4950 e_data
= (unsigned char *) malloc (number
* 4);
4954 error (_("Out of memory\n"));
4958 if (fread (e_data
, 4, number
, file
) != number
)
4960 error (_("Unable to read in dynamic data\n"));
4964 i_data
= (int *) malloc (number
* sizeof (* i_data
));
4968 error (_("Out of memory\n"));
4974 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
4981 /* Dump the symbol table */
4983 process_symbol_table (file
)
4986 Elf32_Internal_Shdr
* section
;
4987 unsigned char nb
[4];
4988 unsigned char nc
[4];
4991 int * buckets
= NULL
;
4992 int * chains
= NULL
;
4994 if (! do_syms
&& !do_histogram
)
4997 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5000 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5002 error (_("Unable to seek to start of dynamic information"));
5006 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5008 error (_("Failed to read in number of buckets\n"));
5012 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5014 error (_("Failed to read in number of chains\n"));
5018 nbuckets
= byte_get (nb
, 4);
5019 nchains
= byte_get (nc
, 4);
5021 buckets
= get_dynamic_data (file
, nbuckets
);
5022 chains
= get_dynamic_data (file
, nchains
);
5024 if (buckets
== NULL
|| chains
== NULL
)
5029 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5034 printf (_("\nSymbol table for image:\n"));
5036 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5038 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5040 for (hn
= 0; hn
< nbuckets
; hn
++)
5045 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5047 Elf_Internal_Sym
* psym
;
5049 psym
= dynamic_symbols
+ si
;
5051 printf (" %3d %3d: ", si
, hn
);
5052 print_vma (psym
->st_value
, LONG_HEX
);
5054 print_vma (psym
->st_size
, DEC_5
);
5056 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5057 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5058 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5059 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
5060 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
5064 else if (do_syms
&& !do_using_dynamic
)
5068 for (i
= 0, section
= section_headers
;
5069 i
< elf_header
.e_shnum
;
5074 Elf_Internal_Sym
* symtab
;
5075 Elf_Internal_Sym
* psym
;
5078 if ( section
->sh_type
!= SHT_SYMTAB
5079 && section
->sh_type
!= SHT_DYNSYM
)
5082 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5083 SECTION_NAME (section
),
5084 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5086 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5088 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5090 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
5091 section
->sh_size
/ section
->sh_entsize
);
5095 if (section
->sh_link
== elf_header
.e_shstrndx
)
5096 strtab
= string_table
;
5099 Elf32_Internal_Shdr
* string_sec
;
5101 string_sec
= section_headers
+ section
->sh_link
;
5103 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5104 string_sec
->sh_size
,
5108 for (si
= 0, psym
= symtab
;
5109 si
< section
->sh_size
/ section
->sh_entsize
;
5112 printf ("%6d: ", si
);
5113 print_vma (psym
->st_value
, LONG_HEX
);
5115 print_vma (psym
->st_size
, DEC_5
);
5116 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5117 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5118 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5119 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
5120 printf (" %s", strtab
+ psym
->st_name
);
5122 if (section
->sh_type
== SHT_DYNSYM
&&
5123 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5125 unsigned char data
[2];
5126 unsigned short vers_data
;
5127 unsigned long offset
;
5131 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5134 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5135 sizeof (data
), _("version data"));
5137 vers_data
= byte_get (data
, 2);
5139 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
5140 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
5143 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5145 if ((vers_data
& 0x8000) || vers_data
> 1)
5147 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5148 && (is_nobits
|| ! check_def
))
5150 Elf_External_Verneed evn
;
5151 Elf_Internal_Verneed ivn
;
5152 Elf_Internal_Vernaux ivna
;
5154 /* We must test both. */
5155 offset
= version_info
5156 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5160 unsigned long vna_off
;
5162 get_data (&evn
, file
, offset
, sizeof (evn
),
5165 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5166 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5168 vna_off
= offset
+ ivn
.vn_aux
;
5172 Elf_External_Vernaux evna
;
5174 get_data (&evna
, file
, vna_off
,
5176 _("version need aux (3)"));
5178 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5179 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5180 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5182 vna_off
+= ivna
.vna_next
;
5184 while (ivna
.vna_other
!= vers_data
5185 && ivna
.vna_next
!= 0);
5187 if (ivna
.vna_other
== vers_data
)
5190 offset
+= ivn
.vn_next
;
5192 while (ivn
.vn_next
!= 0);
5194 if (ivna
.vna_other
== vers_data
)
5197 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5200 else if (! is_nobits
)
5201 error (_("bad dynamic symbol"));
5208 if (vers_data
!= 0x8001
5209 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5211 Elf_Internal_Verdef ivd
;
5212 Elf_Internal_Verdaux ivda
;
5213 Elf_External_Verdaux evda
;
5214 unsigned long offset
;
5217 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5222 Elf_External_Verdef evd
;
5224 get_data (&evd
, file
, offset
, sizeof (evd
),
5227 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5228 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5229 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5231 offset
+= ivd
.vd_next
;
5233 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5234 && ivd
.vd_next
!= 0);
5236 offset
-= ivd
.vd_next
;
5237 offset
+= ivd
.vd_aux
;
5239 get_data (&evda
, file
, offset
, sizeof (evda
),
5240 _("version def aux"));
5242 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5244 if (psym
->st_name
!= ivda
.vda_name
)
5245 printf ((vers_data
& 0x8000)
5247 strtab
+ ivda
.vda_name
);
5257 if (strtab
!= string_table
)
5263 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5265 if (do_histogram
&& buckets
!= NULL
)
5272 int nzero_counts
= 0;
5275 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5277 printf (_(" Length Number %% of total Coverage\n"));
5279 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5280 if (lengths
== NULL
)
5282 error (_("Out of memory"));
5285 for (hn
= 0; hn
< nbuckets
; ++hn
)
5290 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5293 if (maxlength
< ++lengths
[hn
])
5298 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5301 error (_("Out of memory"));
5305 for (hn
= 0; hn
< nbuckets
; ++hn
)
5306 ++ counts
[lengths
[hn
]];
5310 printf (" 0 %-10d (%5.1f%%)\n",
5311 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5312 for (si
= 1; si
<= maxlength
; ++si
)
5314 nzero_counts
+= counts
[si
] * si
;
5315 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5316 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5317 (nzero_counts
* 100.0) / nsyms
);
5325 if (buckets
!= NULL
)
5335 process_syminfo (file
)
5336 FILE * file ATTRIBUTE_UNUSED
;
5340 if (dynamic_syminfo
== NULL
5342 /* No syminfo, this is ok. */
5345 /* There better should be a dynamic symbol section. */
5346 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5350 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5351 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5353 printf (_(" Num: Name BoundTo Flags\n"));
5354 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5356 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5358 printf ("%4d: %-30s ", i
,
5359 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5361 switch (dynamic_syminfo
[i
].si_boundto
)
5363 case SYMINFO_BT_SELF
:
5364 fputs ("SELF ", stdout
);
5366 case SYMINFO_BT_PARENT
:
5367 fputs ("PARENT ", stdout
);
5370 if (dynamic_syminfo
[i
].si_boundto
> 0
5371 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5374 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5376 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5380 if (flags
& SYMINFO_FLG_DIRECT
)
5382 if (flags
& SYMINFO_FLG_PASSTHRU
)
5383 printf (" PASSTHRU");
5384 if (flags
& SYMINFO_FLG_COPY
)
5386 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5387 printf (" LAZYLOAD");
5395 #ifdef SUPPORT_DISASSEMBLY
5397 disassemble_section (section
, file
)
5398 Elf32_Internal_Shdr
* section
;
5401 printf (_("\nAssembly dump of section %s\n"),
5402 SECTION_NAME (section
));
5404 /* XXX -- to be done --- XXX */
5411 dump_section (section
, file
)
5412 Elf32_Internal_Shdr
* section
;
5415 bfd_size_type bytes
;
5417 unsigned char * data
;
5418 unsigned char * start
;
5420 bytes
= section
->sh_size
;
5424 printf (_("\nSection '%s' has no data to dump.\n"),
5425 SECTION_NAME (section
));
5429 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5431 addr
= section
->sh_addr
;
5433 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5446 lbytes
= (bytes
> 16 ? 16 : bytes
);
5448 printf (" 0x%8.8lx ", (unsigned long) addr
);
5450 switch (elf_header
.e_ident
[EI_DATA
])
5454 for (j
= 15; j
>= 0; j
--)
5457 printf ("%2.2x", data
[j
]);
5467 for (j
= 0; j
< 16; j
++)
5470 printf ("%2.2x", data
[j
]);
5480 for (j
= 0; j
< lbytes
; j
++)
5483 if (k
>= ' ' && k
< 0x80)
5502 static unsigned long int
5503 read_leb128 (data
, length_return
, sign
)
5504 unsigned char * data
;
5505 int * length_return
;
5508 unsigned long int result
= 0;
5509 unsigned int num_read
= 0;
5518 result
|= (byte
& 0x7f) << shift
;
5523 while (byte
& 0x80);
5525 if (length_return
!= NULL
)
5526 * length_return
= num_read
;
5528 if (sign
&& (shift
< 32) && (byte
& 0x40))
5529 result
|= -1 << shift
;
5534 typedef struct State_Machine_Registers
5536 unsigned long address
;
5539 unsigned int column
;
5543 /* This variable hold the number of the last entry seen
5544 in the File Table. */
5545 unsigned int last_file_entry
;
5548 static SMR state_machine_regs
;
5551 reset_state_machine (is_stmt
)
5554 state_machine_regs
.address
= 0;
5555 state_machine_regs
.file
= 1;
5556 state_machine_regs
.line
= 1;
5557 state_machine_regs
.column
= 0;
5558 state_machine_regs
.is_stmt
= is_stmt
;
5559 state_machine_regs
.basic_block
= 0;
5560 state_machine_regs
.end_sequence
= 0;
5561 state_machine_regs
.last_file_entry
= 0;
5564 /* Handled an extend line op. Returns true if this is the end
5567 process_extended_line_op (data
, is_stmt
, pointer_size
)
5568 unsigned char * data
;
5572 unsigned char op_code
;
5575 unsigned char * name
;
5578 len
= read_leb128 (data
, & bytes_read
, 0);
5583 warn (_("badly formed extended line op encountered!"));
5588 op_code
= * data
++;
5590 printf (_(" Extended opcode %d: "), op_code
);
5594 case DW_LNE_end_sequence
:
5595 printf (_("End of Sequence\n\n"));
5596 reset_state_machine (is_stmt
);
5599 case DW_LNE_set_address
:
5600 adr
= byte_get (data
, pointer_size
);
5601 printf (_("set Address to 0x%lx\n"), adr
);
5602 state_machine_regs
.address
= adr
;
5605 case DW_LNE_define_file
:
5606 printf (_(" define new File Table entry\n"));
5607 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5609 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5611 data
+= strlen ((char *) data
) + 1;
5612 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5614 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5616 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5617 printf (_("%s\n\n"), name
);
5621 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
5628 /* Size of pointers in the .debug_line section. This information is not
5629 really present in that section. It's obtained before dumping the debug
5630 sections by doing some pre-scan of the .debug_info section. */
5631 static int debug_line_pointer_size
= 4;
5634 display_debug_lines (section
, start
, file
)
5635 Elf32_Internal_Shdr
* section
;
5636 unsigned char * start
;
5637 FILE * file ATTRIBUTE_UNUSED
;
5639 DWARF2_External_LineInfo
* external
;
5640 DWARF2_Internal_LineInfo info
;
5641 unsigned char * standard_opcodes
;
5642 unsigned char * data
= start
;
5643 unsigned char * end
= start
+ section
->sh_size
;
5644 unsigned char * end_of_sequence
;
5647 printf (_("\nDump of debug contents of section %s:\n\n"),
5648 SECTION_NAME (section
));
5652 external
= (DWARF2_External_LineInfo
*) data
;
5654 /* Check the length of the block. */
5655 info
.li_length
= BYTE_GET (external
->li_length
);
5656 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
5659 (_("The line info appears to be corrupt - the section is too small\n"));
5663 /* Check its version number. */
5664 info
.li_version
= BYTE_GET (external
->li_version
);
5665 if (info
.li_version
!= 2)
5667 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5671 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5672 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5673 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5674 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5675 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5676 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5678 /* Sign extend the line base field. */
5679 info
.li_line_base
<<= 24;
5680 info
.li_line_base
>>= 24;
5682 printf (_(" Length: %ld\n"), info
.li_length
);
5683 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5684 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
5685 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5686 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5687 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5688 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5689 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5691 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
5693 reset_state_machine (info
.li_default_is_stmt
);
5695 /* Display the contents of the Opcodes table. */
5696 standard_opcodes
= data
+ sizeof (* external
);
5698 printf (_("\n Opcodes:\n"));
5700 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5701 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5703 /* Display the contents of the Directory table. */
5704 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5707 printf (_("\n The Directory Table is empty.\n"));
5710 printf (_("\n The Directory Table:\n"));
5714 printf (_(" %s\n"), data
);
5716 data
+= strlen ((char *) data
) + 1;
5720 /* Skip the NUL at the end of the table. */
5723 /* Display the contents of the File Name table. */
5725 printf (_("\n The File Name Table is empty.\n"));
5728 printf (_("\n The File Name Table:\n"));
5729 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5733 unsigned char * name
;
5736 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5739 data
+= strlen ((char *) data
) + 1;
5741 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5743 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5745 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5747 printf (_("%s\n"), name
);
5751 /* Skip the NUL at the end of the table. */
5754 /* Now display the statements. */
5755 printf (_("\n Line Number Statements:\n"));
5758 while (data
< end_of_sequence
)
5760 unsigned char op_code
;
5764 op_code
= * data
++;
5768 case DW_LNS_extended_op
:
5769 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5770 debug_line_pointer_size
);
5774 printf (_(" Copy\n"));
5777 case DW_LNS_advance_pc
:
5778 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5780 state_machine_regs
.address
+= adv
;
5781 printf (_(" Advance PC by %d to %lx\n"), adv
,
5782 state_machine_regs
.address
);
5785 case DW_LNS_advance_line
:
5786 adv
= read_leb128 (data
, & bytes_read
, 1);
5788 state_machine_regs
.line
+= adv
;
5789 printf (_(" Advance Line by %d to %d\n"), adv
,
5790 state_machine_regs
.line
);
5793 case DW_LNS_set_file
:
5794 adv
= read_leb128 (data
, & bytes_read
, 0);
5796 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5798 state_machine_regs
.file
= adv
;
5801 case DW_LNS_set_column
:
5802 adv
= read_leb128 (data
, & bytes_read
, 0);
5804 printf (_(" Set column to %d\n"), adv
);
5805 state_machine_regs
.column
= adv
;
5808 case DW_LNS_negate_stmt
:
5809 adv
= state_machine_regs
.is_stmt
;
5811 printf (_(" Set is_stmt to %d\n"), adv
);
5812 state_machine_regs
.is_stmt
= adv
;
5815 case DW_LNS_set_basic_block
:
5816 printf (_(" Set basic block\n"));
5817 state_machine_regs
.basic_block
= 1;
5820 case DW_LNS_const_add_pc
:
5821 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5822 * info
.li_min_insn_length
);
5823 state_machine_regs
.address
+= adv
;
5824 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5825 state_machine_regs
.address
);
5828 case DW_LNS_fixed_advance_pc
:
5829 adv
= byte_get (data
, 2);
5831 state_machine_regs
.address
+= adv
;
5832 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5833 adv
, state_machine_regs
.address
);
5837 op_code
-= info
.li_opcode_base
;
5838 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5839 state_machine_regs
.address
+= adv
;
5840 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5841 op_code
, adv
, state_machine_regs
.address
);
5842 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5843 state_machine_regs
.line
+= adv
;
5844 printf (_(" and Line by %d to %d\n"),
5845 adv
, state_machine_regs
.line
);
5856 display_debug_pubnames (section
, start
, file
)
5857 Elf32_Internal_Shdr
* section
;
5858 unsigned char * start
;
5859 FILE * file ATTRIBUTE_UNUSED
;
5861 DWARF2_External_PubNames
* external
;
5862 DWARF2_Internal_PubNames pubnames
;
5863 unsigned char * end
;
5865 end
= start
+ section
->sh_size
;
5867 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
5871 unsigned char * data
;
5872 unsigned long offset
;
5874 external
= (DWARF2_External_PubNames
*) start
;
5876 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
5877 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
5878 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
5879 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
5881 data
= start
+ sizeof (* external
);
5882 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
5884 if (pubnames
.pn_version
!= 2)
5886 static int warned
= 0;
5890 warn (_("Only DWARF 2 pubnames are currently supported\n"));
5897 printf (_(" Length: %ld\n"),
5898 pubnames
.pn_length
);
5899 printf (_(" Version: %d\n"),
5900 pubnames
.pn_version
);
5901 printf (_(" Offset into .debug_info section: %ld\n"),
5902 pubnames
.pn_offset
);
5903 printf (_(" Size of area in .debug_info section: %ld\n"),
5906 printf (_("\n Offset\tName\n"));
5910 offset
= byte_get (data
, 4);
5915 printf (" %ld\t\t%s\n", offset
, data
);
5916 data
+= strlen ((char *) data
) + 1;
5919 while (offset
!= 0);
5932 case DW_TAG_padding
: return "DW_TAG_padding";
5933 case DW_TAG_array_type
: return "DW_TAG_array_type";
5934 case DW_TAG_class_type
: return "DW_TAG_class_type";
5935 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
5936 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
5937 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
5938 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
5939 case DW_TAG_label
: return "DW_TAG_label";
5940 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
5941 case DW_TAG_member
: return "DW_TAG_member";
5942 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
5943 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
5944 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
5945 case DW_TAG_string_type
: return "DW_TAG_string_type";
5946 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
5947 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
5948 case DW_TAG_typedef
: return "DW_TAG_typedef";
5949 case DW_TAG_union_type
: return "DW_TAG_union_type";
5950 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
5951 case DW_TAG_variant
: return "DW_TAG_variant";
5952 case DW_TAG_common_block
: return "DW_TAG_common_block";
5953 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
5954 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
5955 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
5956 case DW_TAG_module
: return "DW_TAG_module";
5957 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
5958 case DW_TAG_set_type
: return "DW_TAG_set_type";
5959 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
5960 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
5961 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
5962 case DW_TAG_base_type
: return "DW_TAG_base_type";
5963 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
5964 case DW_TAG_const_type
: return "DW_TAG_const_type";
5965 case DW_TAG_constant
: return "DW_TAG_constant";
5966 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
5967 case DW_TAG_file_type
: return "DW_TAG_file_type";
5968 case DW_TAG_friend
: return "DW_TAG_friend";
5969 case DW_TAG_namelist
: return "DW_TAG_namelist";
5970 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
5971 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
5972 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
5973 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
5974 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
5975 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
5976 case DW_TAG_try_block
: return "DW_TAG_try_block";
5977 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
5978 case DW_TAG_variable
: return "DW_TAG_variable";
5979 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
5980 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
5981 case DW_TAG_format_label
: return "DW_TAG_format_label";
5982 case DW_TAG_function_template
: return "DW_TAG_function_template";
5983 case DW_TAG_class_template
: return "DW_TAG_class_template";
5984 /* DWARF 2.1 values. */
5985 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
5986 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
5987 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
5988 case DW_TAG_namespace
: return "DW_TAG_namespace";
5989 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
5990 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
5991 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
5992 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
5995 static char buffer
[100];
5997 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6004 get_AT_name (attribute
)
6005 unsigned long attribute
;
6009 case DW_AT_sibling
: return "DW_AT_sibling";
6010 case DW_AT_location
: return "DW_AT_location";
6011 case DW_AT_name
: return "DW_AT_name";
6012 case DW_AT_ordering
: return "DW_AT_ordering";
6013 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6014 case DW_AT_byte_size
: return "DW_AT_byte_size";
6015 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6016 case DW_AT_bit_size
: return "DW_AT_bit_size";
6017 case DW_AT_element_list
: return "DW_AT_element_list";
6018 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6019 case DW_AT_low_pc
: return "DW_AT_low_pc";
6020 case DW_AT_high_pc
: return "DW_AT_high_pc";
6021 case DW_AT_language
: return "DW_AT_language";
6022 case DW_AT_member
: return "DW_AT_member";
6023 case DW_AT_discr
: return "DW_AT_discr";
6024 case DW_AT_discr_value
: return "DW_AT_discr_value";
6025 case DW_AT_visibility
: return "DW_AT_visibility";
6026 case DW_AT_import
: return "DW_AT_import";
6027 case DW_AT_string_length
: return "DW_AT_string_length";
6028 case DW_AT_common_reference
: return "DW_AT_common_reference";
6029 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6030 case DW_AT_const_value
: return "DW_AT_const_value";
6031 case DW_AT_containing_type
: return "DW_AT_containing_type";
6032 case DW_AT_default_value
: return "DW_AT_default_value";
6033 case DW_AT_inline
: return "DW_AT_inline";
6034 case DW_AT_is_optional
: return "DW_AT_is_optional";
6035 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6036 case DW_AT_producer
: return "DW_AT_producer";
6037 case DW_AT_prototyped
: return "DW_AT_prototyped";
6038 case DW_AT_return_addr
: return "DW_AT_return_addr";
6039 case DW_AT_start_scope
: return "DW_AT_start_scope";
6040 case DW_AT_stride_size
: return "DW_AT_stride_size";
6041 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6042 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6043 case DW_AT_accessibility
: return "DW_AT_accessibility";
6044 case DW_AT_address_class
: return "DW_AT_address_class";
6045 case DW_AT_artificial
: return "DW_AT_artificial";
6046 case DW_AT_base_types
: return "DW_AT_base_types";
6047 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6048 case DW_AT_count
: return "DW_AT_count";
6049 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6050 case DW_AT_decl_column
: return "DW_AT_decl_column";
6051 case DW_AT_decl_file
: return "DW_AT_decl_file";
6052 case DW_AT_decl_line
: return "DW_AT_decl_line";
6053 case DW_AT_declaration
: return "DW_AT_declaration";
6054 case DW_AT_discr_list
: return "DW_AT_discr_list";
6055 case DW_AT_encoding
: return "DW_AT_encoding";
6056 case DW_AT_external
: return "DW_AT_external";
6057 case DW_AT_frame_base
: return "DW_AT_frame_base";
6058 case DW_AT_friend
: return "DW_AT_friend";
6059 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6060 case DW_AT_macro_info
: return "DW_AT_macro_info";
6061 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6062 case DW_AT_priority
: return "DW_AT_priority";
6063 case DW_AT_segment
: return "DW_AT_segment";
6064 case DW_AT_specification
: return "DW_AT_specification";
6065 case DW_AT_static_link
: return "DW_AT_static_link";
6066 case DW_AT_type
: return "DW_AT_type";
6067 case DW_AT_use_location
: return "DW_AT_use_location";
6068 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6069 case DW_AT_virtuality
: return "DW_AT_virtuality";
6070 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6071 /* DWARF 2.1 values. */
6072 case DW_AT_allocated
: return "DW_AT_allocated";
6073 case DW_AT_associated
: return "DW_AT_associated";
6074 case DW_AT_data_location
: return "DW_AT_data_location";
6075 case DW_AT_stride
: return "DW_AT_stride";
6076 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6077 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6078 case DW_AT_extension
: return "DW_AT_extension";
6079 case DW_AT_ranges
: return "DW_AT_ranges";
6080 case DW_AT_trampoline
: return "DW_AT_trampoline";
6081 case DW_AT_call_column
: return "DW_AT_call_column";
6082 case DW_AT_call_file
: return "DW_AT_call_file";
6083 case DW_AT_call_line
: return "DW_AT_call_line";
6084 /* SGI/MIPS extensions. */
6085 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6086 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6087 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6088 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6089 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6090 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6091 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6092 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6093 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6094 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6095 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6096 /* GNU extensions. */
6097 case DW_AT_sf_names
: return "DW_AT_sf_names";
6098 case DW_AT_src_info
: return "DW_AT_src_info";
6099 case DW_AT_mac_info
: return "DW_AT_mac_info";
6100 case DW_AT_src_coords
: return "DW_AT_src_coords";
6101 case DW_AT_body_begin
: return "DW_AT_body_begin";
6102 case DW_AT_body_end
: return "DW_AT_body_end";
6105 static char buffer
[100];
6107 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6114 get_FORM_name (form
)
6119 case DW_FORM_addr
: return "DW_FORM_addr";
6120 case DW_FORM_block2
: return "DW_FORM_block2";
6121 case DW_FORM_block4
: return "DW_FORM_block4";
6122 case DW_FORM_data2
: return "DW_FORM_data2";
6123 case DW_FORM_data4
: return "DW_FORM_data4";
6124 case DW_FORM_data8
: return "DW_FORM_data8";
6125 case DW_FORM_string
: return "DW_FORM_string";
6126 case DW_FORM_block
: return "DW_FORM_block";
6127 case DW_FORM_block1
: return "DW_FORM_block1";
6128 case DW_FORM_data1
: return "DW_FORM_data1";
6129 case DW_FORM_flag
: return "DW_FORM_flag";
6130 case DW_FORM_sdata
: return "DW_FORM_sdata";
6131 case DW_FORM_strp
: return "DW_FORM_strp";
6132 case DW_FORM_udata
: return "DW_FORM_udata";
6133 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6134 case DW_FORM_ref1
: return "DW_FORM_ref1";
6135 case DW_FORM_ref2
: return "DW_FORM_ref2";
6136 case DW_FORM_ref4
: return "DW_FORM_ref4";
6137 case DW_FORM_ref8
: return "DW_FORM_ref8";
6138 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6139 case DW_FORM_indirect
: return "DW_FORM_indirect";
6142 static char buffer
[100];
6144 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6150 /* FIXME: There are better and more effiecint ways to handle
6151 these structures. For now though, I just want something that
6152 is simple to implement. */
6153 typedef struct abbrev_attr
6155 unsigned long attribute
;
6157 struct abbrev_attr
* next
;
6161 typedef struct abbrev_entry
6163 unsigned long entry
;
6166 struct abbrev_attr
* first_attr
;
6167 struct abbrev_attr
* last_attr
;
6168 struct abbrev_entry
* next
;
6172 static abbrev_entry
* first_abbrev
= NULL
;
6173 static abbrev_entry
* last_abbrev
= NULL
;
6176 free_abbrevs
PARAMS ((void))
6178 abbrev_entry
* abbrev
;
6180 for (abbrev
= first_abbrev
; abbrev
;)
6182 abbrev_entry
* next
= abbrev
->next
;
6185 for (attr
= abbrev
->first_attr
; attr
;)
6187 abbrev_attr
* next
= attr
->next
;
6197 last_abbrev
= first_abbrev
= NULL
;
6201 add_abbrev (number
, tag
, children
)
6202 unsigned long number
;
6206 abbrev_entry
* entry
;
6208 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6214 entry
->entry
= number
;
6216 entry
->children
= children
;
6217 entry
->first_attr
= NULL
;
6218 entry
->last_attr
= NULL
;
6221 if (first_abbrev
== NULL
)
6222 first_abbrev
= entry
;
6224 last_abbrev
->next
= entry
;
6226 last_abbrev
= entry
;
6230 add_abbrev_attr (attribute
, form
)
6231 unsigned long attribute
;
6236 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6242 attr
->attribute
= attribute
;
6246 if (last_abbrev
->first_attr
== NULL
)
6247 last_abbrev
->first_attr
= attr
;
6249 last_abbrev
->last_attr
->next
= attr
;
6251 last_abbrev
->last_attr
= attr
;
6254 /* Processes the (partial) contents of a .debug_abbrev section.
6255 Returns NULL if the end of the section was encountered.
6256 Returns the address after the last byte read if the end of
6257 an abbreviation set was found. */
6259 static unsigned char *
6260 process_abbrev_section (start
, end
)
6261 unsigned char * start
;
6262 unsigned char * end
;
6264 if (first_abbrev
!= NULL
)
6270 unsigned long entry
;
6272 unsigned long attribute
;
6275 entry
= read_leb128 (start
, & bytes_read
, 0);
6276 start
+= bytes_read
;
6278 /* A single zero is supposed to end the section according
6279 to the standard. If there's more, then signal that to
6282 return start
== end
? NULL
: start
;
6284 tag
= read_leb128 (start
, & bytes_read
, 0);
6285 start
+= bytes_read
;
6287 children
= * start
++;
6289 add_abbrev (entry
, tag
, children
);
6295 attribute
= read_leb128 (start
, & bytes_read
, 0);
6296 start
+= bytes_read
;
6298 form
= read_leb128 (start
, & bytes_read
, 0);
6299 start
+= bytes_read
;
6302 add_abbrev_attr (attribute
, form
);
6304 while (attribute
!= 0);
6312 display_debug_macinfo (section
, start
, file
)
6313 Elf32_Internal_Shdr
* section
;
6314 unsigned char * start
;
6315 FILE * file ATTRIBUTE_UNUSED
;
6317 unsigned char * end
= start
+ section
->sh_size
;
6318 unsigned char * curr
= start
;
6319 unsigned int bytes_read
;
6320 enum dwarf_macinfo_record_type op
;
6322 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6326 unsigned int lineno
;
6327 const char * string
;
6334 case DW_MACINFO_start_file
:
6336 unsigned int filenum
;
6338 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6340 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6343 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6347 case DW_MACINFO_end_file
:
6348 printf (_(" DW_MACINFO_end_file\n"));
6351 case DW_MACINFO_define
:
6352 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6355 curr
+= strlen (string
) + 1;
6356 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6359 case DW_MACINFO_undef
:
6360 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6363 curr
+= strlen (string
) + 1;
6364 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6367 case DW_MACINFO_vendor_ext
:
6369 unsigned int constant
;
6371 constant
= read_leb128 (curr
, & bytes_read
, 0);
6374 curr
+= strlen (string
) + 1;
6375 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6386 display_debug_abbrev (section
, start
, file
)
6387 Elf32_Internal_Shdr
* section
;
6388 unsigned char * start
;
6389 FILE * file ATTRIBUTE_UNUSED
;
6391 abbrev_entry
* entry
;
6392 unsigned char * end
= start
+ section
->sh_size
;
6394 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6398 start
= process_abbrev_section (start
, end
);
6400 printf (_(" Number TAG\n"));
6402 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6406 printf (_(" %ld %s [%s]\n"),
6408 get_TAG_name (entry
->tag
),
6409 entry
->children
? _("has children") : _("no children"));
6411 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6413 printf (_(" %-18s %s\n"),
6414 get_AT_name (attr
->attribute
),
6415 get_FORM_name (attr
->form
));
6427 static unsigned char *
6428 display_block (data
, length
)
6429 unsigned char * data
;
6430 unsigned long length
;
6432 printf (_(" %lu byte block: "), length
);
6435 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6441 decode_location_expression (data
, pointer_size
, length
)
6442 unsigned char * data
;
6443 unsigned int pointer_size
;
6444 unsigned long length
;
6448 unsigned long uvalue
;
6449 unsigned char * end
= data
+ length
;
6458 printf ("DW_OP_addr: %lx",
6459 (unsigned long) byte_get (data
, pointer_size
));
6460 data
+= pointer_size
;
6463 printf ("DW_OP_deref");
6466 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6469 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6472 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6476 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6480 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6484 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6488 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6489 (unsigned long) byte_get (data
+ 4, 4));
6493 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6494 (long) byte_get (data
+ 4, 4));
6498 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6502 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6506 printf ("DW_OP_dup");
6509 printf ("DW_OP_drop");
6512 printf ("DW_OP_over");
6515 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6518 printf ("DW_OP_swap");
6521 printf ("DW_OP_rot");
6524 printf ("DW_OP_xderef");
6527 printf ("DW_OP_abs");
6530 printf ("DW_OP_and");
6533 printf ("DW_OP_div");
6536 printf ("DW_OP_minus");
6539 printf ("DW_OP_mod");
6542 printf ("DW_OP_mul");
6545 printf ("DW_OP_neg");
6548 printf ("DW_OP_not");
6551 printf ("DW_OP_or");
6554 printf ("DW_OP_plus");
6556 case DW_OP_plus_uconst
:
6557 printf ("DW_OP_plus_uconst: %lu",
6558 read_leb128 (data
, &bytes_read
, 0));
6562 printf ("DW_OP_shl");
6565 printf ("DW_OP_shr");
6568 printf ("DW_OP_shra");
6571 printf ("DW_OP_xor");
6574 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
6578 printf ("DW_OP_eq");
6581 printf ("DW_OP_ge");
6584 printf ("DW_OP_gt");
6587 printf ("DW_OP_le");
6590 printf ("DW_OP_lt");
6593 printf ("DW_OP_ne");
6596 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
6632 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
6667 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
6702 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
6703 read_leb128 (data
, &bytes_read
, 1));
6708 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
6712 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
6716 uvalue
= read_leb128 (data
, &bytes_read
, 0);
6718 printf ("DW_OP_bregx: %lu %ld", uvalue
,
6719 read_leb128 (data
, &bytes_read
, 1));
6723 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
6726 case DW_OP_deref_size
:
6727 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
6729 case DW_OP_xderef_size
:
6730 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
6733 printf ("DW_OP_nop");
6736 /* DWARF 2.1 extensions. */
6737 case DW_OP_push_object_address
:
6738 printf ("DW_OP_push_object_address");
6741 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
6745 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
6749 printf ("DW_OP_calli");
6753 if (op
>= DW_OP_lo_user
6754 && op
<= DW_OP_hi_user
)
6755 printf (_("(User defined location op)"));
6757 printf (_("(Unknown location op)"));
6758 /* No way to tell where the next op is, so just bail. */
6762 /* Separate the ops. */
6768 static unsigned char *
6769 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
6770 unsigned long attribute
;
6772 unsigned char * data
;
6773 unsigned long cu_offset
;
6774 unsigned long pointer_size
;
6776 unsigned long uvalue
= 0;
6777 unsigned char * block_start
= NULL
;
6780 printf (" %-18s:", get_AT_name (attribute
));
6787 case DW_FORM_ref_addr
:
6789 uvalue
= byte_get (data
, pointer_size
);
6790 data
+= pointer_size
;
6796 uvalue
= byte_get (data
++, 1);
6801 uvalue
= byte_get (data
, 2);
6807 uvalue
= byte_get (data
, 4);
6812 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6816 case DW_FORM_ref_udata
:
6818 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6825 case DW_FORM_ref_addr
:
6826 printf (" <#%lx>", uvalue
);
6832 case DW_FORM_ref_udata
:
6833 printf (" <%lx>", uvalue
+ cu_offset
);
6837 printf (" %#lx", uvalue
);
6845 printf (" %ld", uvalue
);
6850 uvalue
= byte_get (data
, 4);
6851 printf (" %lx", uvalue
);
6852 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
6856 case DW_FORM_string
:
6857 printf (" %s", data
);
6858 data
+= strlen ((char *) data
) + 1;
6862 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6863 block_start
= data
+ bytes_read
;
6864 data
= display_block (block_start
, uvalue
);
6867 case DW_FORM_block1
:
6868 uvalue
= byte_get (data
, 1);
6869 block_start
= data
+ 1;
6870 data
= display_block (block_start
, uvalue
);
6873 case DW_FORM_block2
:
6874 uvalue
= byte_get (data
, 2);
6875 block_start
= data
+ 2;
6876 data
= display_block (block_start
, uvalue
);
6879 case DW_FORM_block4
:
6880 uvalue
= byte_get (data
, 4);
6881 block_start
= data
+ 4;
6882 data
= display_block (block_start
, uvalue
);
6886 case DW_FORM_indirect
:
6887 warn (_("Unable to handle FORM: %d"), form
);
6891 warn (_("Unrecognised form: %d"), form
);
6895 /* For some attributes we can display futher information. */
6904 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
6905 case DW_INL_inlined
: printf (_("(inlined)")); break;
6906 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
6907 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
6908 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
6912 case DW_AT_language
:
6915 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
6916 case DW_LANG_C89
: printf ("(ANSI C)"); break;
6917 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
6918 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
6919 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
6920 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
6921 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
6922 case DW_LANG_Ada83
: printf ("(Ada)"); break;
6923 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
6924 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
6925 /* DWARF 2.1 values. */
6926 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
6927 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
6928 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
6929 /* MIPS extension. */
6930 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
6931 default: printf ("(Unknown: %lx)", uvalue
); break;
6935 case DW_AT_encoding
:
6938 case DW_ATE_void
: printf ("(void)"); break;
6939 case DW_ATE_address
: printf ("(machine address)"); break;
6940 case DW_ATE_boolean
: printf ("(boolean)"); break;
6941 case DW_ATE_complex_float
: printf ("(complex float)"); break;
6942 case DW_ATE_float
: printf ("(float)"); break;
6943 case DW_ATE_signed
: printf ("(signed)"); break;
6944 case DW_ATE_signed_char
: printf ("(signed char)"); break;
6945 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
6946 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
6947 /* DWARF 2.1 value. */
6948 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
6950 if (uvalue
>= DW_ATE_lo_user
6951 && uvalue
<= DW_ATE_hi_user
)
6952 printf ("(user defined type)");
6954 printf ("(unknown type)");
6959 case DW_AT_accessibility
:
6962 case DW_ACCESS_public
: printf ("(public)"); break;
6963 case DW_ACCESS_protected
: printf ("(protected)"); break;
6964 case DW_ACCESS_private
: printf ("(private)"); break;
6965 default: printf ("(unknown accessibility)"); break;
6969 case DW_AT_visibility
:
6972 case DW_VIS_local
: printf ("(local)"); break;
6973 case DW_VIS_exported
: printf ("(exported)"); break;
6974 case DW_VIS_qualified
: printf ("(qualified)"); break;
6975 default: printf ("(unknown visibility)"); break;
6979 case DW_AT_virtuality
:
6982 case DW_VIRTUALITY_none
: printf ("(none)"); break;
6983 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
6984 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
6985 default: printf ("(unknown virtuality)"); break;
6989 case DW_AT_identifier_case
:
6992 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
6993 case DW_ID_up_case
: printf ("(up_case)"); break;
6994 case DW_ID_down_case
: printf ("(down_case)"); break;
6995 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
6996 default: printf ("(unknown case)"); break;
7000 case DW_AT_calling_convention
:
7003 case DW_CC_normal
: printf ("(normal)"); break;
7004 case DW_CC_program
: printf ("(program)"); break;
7005 case DW_CC_nocall
: printf ("(nocall)"); break;
7007 if (uvalue
>= DW_CC_lo_user
7008 && uvalue
<= DW_CC_hi_user
)
7009 printf ("(user defined)");
7011 printf ("(unknown convention)");
7015 case DW_AT_ordering
:
7018 case -1: printf ("(undefined)"); break;
7019 case 0: printf ("(row major)"); break;
7020 case 1: printf ("(column major)"); break;
7024 case DW_AT_frame_base
:
7025 case DW_AT_location
:
7026 case DW_AT_data_member_location
:
7027 case DW_AT_vtable_elem_location
:
7028 case DW_AT_allocated
:
7029 case DW_AT_associated
:
7030 case DW_AT_data_location
:
7032 case DW_AT_upper_bound
:
7033 case DW_AT_lower_bound
:
7037 decode_location_expression (block_start
, pointer_size
, uvalue
);
7051 display_debug_info (section
, start
, file
)
7052 Elf32_Internal_Shdr
* section
;
7053 unsigned char * start
;
7056 unsigned char * end
= start
+ section
->sh_size
;
7057 unsigned char * section_begin
= start
;
7059 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7063 DWARF2_External_CompUnit
* external
;
7064 DWARF2_Internal_CompUnit compunit
;
7065 Elf32_Internal_Shdr
* relsec
;
7066 unsigned char * tags
;
7069 unsigned long cu_offset
;
7071 external
= (DWARF2_External_CompUnit
*) start
;
7073 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7074 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7075 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7076 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7078 /* Check for RELA relocations in the abbrev_offset address, and
7080 for (relsec
= section_headers
;
7081 relsec
< section_headers
+ elf_header
.e_shnum
;
7084 unsigned long nrelas
, nsyms
;
7085 Elf_Internal_Rela
*rela
, *rp
;
7086 Elf32_Internal_Shdr
*symsec
;
7087 Elf_Internal_Sym
*symtab
;
7088 Elf_Internal_Sym
*sym
;
7090 if (relsec
->sh_type
!= SHT_RELA
7091 || section_headers
+ relsec
->sh_info
!= section
)
7094 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7098 symsec
= section_headers
+ relsec
->sh_link
;
7099 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
7100 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
7102 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7105 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7111 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7113 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7115 warn (_("Skipping unexpected symbol type %u"),
7116 ELF32_ST_TYPE (sym
->st_info
));
7122 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7124 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7126 warn (_("Skipping unexpected symbol type %u"),
7127 ELF64_ST_TYPE (sym
->st_info
));
7132 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7140 tags
= start
+ sizeof (* external
);
7141 cu_offset
= start
- section_begin
;
7142 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7144 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7145 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7146 printf (_(" Version: %d\n"), compunit
.cu_version
);
7147 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7148 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7150 if (compunit
.cu_version
!= 2)
7152 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7156 if (first_abbrev
!= NULL
)
7159 /* Read in the abbrevs used by this compilation unit. */
7162 Elf32_Internal_Shdr
* sec
;
7163 unsigned char * begin
;
7165 /* Locate the .debug_abbrev section and process it. */
7166 for (i
= 0, sec
= section_headers
;
7167 i
< elf_header
.e_shnum
;
7169 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7172 if (i
== -1 || sec
->sh_size
== 0)
7174 warn (_("Unable to locate .debug_abbrev section!\n"));
7178 begin
= ((unsigned char *)
7179 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7180 _("debug_abbrev section data")));
7184 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7185 begin
+ sec
->sh_size
);
7191 while (tags
< start
)
7194 unsigned long abbrev_number
;
7195 abbrev_entry
* entry
;
7198 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7201 /* A null DIE marks the end of a list of children. */
7202 if (abbrev_number
== 0)
7208 /* Scan through the abbreviation list until we reach the
7210 for (entry
= first_abbrev
;
7211 entry
&& entry
->entry
!= abbrev_number
;
7212 entry
= entry
->next
)
7217 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7222 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7224 (unsigned long) (tags
- section_begin
- bytes_read
),
7226 get_TAG_name (entry
->tag
));
7228 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7229 tags
= read_and_display_attr (attr
->attribute
,
7232 compunit
.cu_pointer_size
);
7234 if (entry
->children
)
7245 display_debug_aranges (section
, start
, file
)
7246 Elf32_Internal_Shdr
* section
;
7247 unsigned char * start
;
7248 FILE * file ATTRIBUTE_UNUSED
;
7250 unsigned char * end
= start
+ section
->sh_size
;
7252 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7256 DWARF2_External_ARange
* external
;
7257 DWARF2_Internal_ARange arange
;
7258 unsigned char * ranges
;
7259 unsigned long length
;
7260 unsigned long address
;
7263 external
= (DWARF2_External_ARange
*) start
;
7265 arange
.ar_length
= BYTE_GET (external
->ar_length
);
7266 arange
.ar_version
= BYTE_GET (external
->ar_version
);
7267 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
7268 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
7269 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
7271 if (arange
.ar_version
!= 2)
7273 warn (_("Only DWARF 2 aranges are currently supported.\n"));
7277 printf (_(" Length: %ld\n"), arange
.ar_length
);
7278 printf (_(" Version: %d\n"), arange
.ar_version
);
7279 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
7280 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7281 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7283 printf (_("\n Address Length\n"));
7285 ranges
= start
+ sizeof (* external
);
7287 /* Must pad to an alignment boundary that is twice the pointer size. */
7288 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
7290 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
7294 address
= byte_get (ranges
, arange
.ar_pointer_size
);
7296 ranges
+= arange
.ar_pointer_size
;
7298 length
= byte_get (ranges
, arange
.ar_pointer_size
);
7300 ranges
+= arange
.ar_pointer_size
;
7302 /* A pair of zeros marks the end of the list. */
7303 if (address
== 0 && length
== 0)
7306 printf (" %8.8lx %lu\n", address
, length
);
7309 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
7317 typedef struct Frame_Chunk
7319 struct Frame_Chunk
* next
;
7320 unsigned char * chunk_start
;
7322 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7323 short int * col_type
;
7325 char * augmentation
;
7326 unsigned int code_factor
;
7328 unsigned long pc_begin
;
7329 unsigned long pc_range
;
7333 unsigned char fde_encoding
;
7337 /* A marker for a col_type that means this column was never referenced
7338 in the frame info. */
7339 #define DW_CFA_unreferenced (-1)
7341 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
7342 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
7343 static int size_of_encoded_value
PARAMS ((int));
7346 frame_need_space (fc
, reg
)
7350 int prev
= fc
->ncols
;
7352 if (reg
< fc
->ncols
)
7355 fc
->ncols
= reg
+ 1;
7356 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
7357 fc
->ncols
* sizeof (short int));
7358 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
7359 fc
->ncols
* sizeof (int));
7361 while (prev
< fc
->ncols
)
7363 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7364 fc
->col_offset
[prev
] = 0;
7370 frame_display_row (fc
, need_col_headers
, max_regs
)
7372 int * need_col_headers
;
7378 if (* max_regs
< fc
->ncols
)
7379 * max_regs
= fc
->ncols
;
7381 if (* need_col_headers
)
7383 * need_col_headers
= 0;
7385 printf (" LOC CFA ");
7387 for (r
= 0; r
< * max_regs
; r
++)
7388 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7393 printf ("r%-4d", r
);
7399 printf ("%08lx ", fc
->pc_begin
);
7400 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
7401 printf ("%-8s ", tmp
);
7403 for (r
= 0; r
< fc
->ncols
; r
++)
7405 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7407 switch (fc
->col_type
[r
])
7409 case DW_CFA_undefined
:
7412 case DW_CFA_same_value
:
7416 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7418 case DW_CFA_register
:
7419 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
7422 strcpy (tmp
, "n/a");
7425 printf ("%-5s", tmp
);
7432 size_of_encoded_value (encoding
)
7435 switch (encoding
& 0x7)
7438 case 0: return is_32bit_elf
? 4 : 8;
7445 #define GET(N) byte_get (start, N); start += N
7446 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7447 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7450 display_debug_frames (section
, start
, file
)
7451 Elf32_Internal_Shdr
* section
;
7452 unsigned char * start
;
7453 FILE * file ATTRIBUTE_UNUSED
;
7455 unsigned char * end
= start
+ section
->sh_size
;
7456 unsigned char * section_start
= start
;
7457 Frame_Chunk
* chunks
= 0;
7458 Frame_Chunk
* remembered_state
= 0;
7460 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
7463 int addr_size
= is_32bit_elf
? 4 : 8;
7465 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
7469 unsigned char * saved_start
;
7470 unsigned char * block_end
;
7471 unsigned long length
;
7472 unsigned long cie_id
;
7475 int need_col_headers
= 1;
7476 unsigned char * augmentation_data
= NULL
;
7477 unsigned long augmentation_data_len
= 0;
7478 int encoded_ptr_size
= addr_size
;
7480 saved_start
= start
;
7481 length
= byte_get (start
, 4); start
+= 4;
7486 block_end
= saved_start
+ length
+ 4;
7487 cie_id
= byte_get (start
, 4); start
+= 4;
7489 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
7493 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7494 memset (fc
, 0, sizeof (Frame_Chunk
));
7498 fc
->chunk_start
= saved_start
;
7500 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7501 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7502 frame_need_space (fc
, max_regs
-1);
7506 fc
->augmentation
= start
;
7507 start
= strchr (start
, '\0') + 1;
7509 if (fc
->augmentation
[0] == 'z')
7511 fc
->code_factor
= LEB ();
7512 fc
->data_factor
= SLEB ();
7513 fc
->ra
= byte_get (start
, 1); start
+= 1;
7514 augmentation_data_len
= LEB ();
7515 augmentation_data
= start
;
7516 start
+= augmentation_data_len
;
7518 else if (strcmp (fc
->augmentation
, "eh") == 0)
7521 fc
->code_factor
= LEB ();
7522 fc
->data_factor
= SLEB ();
7523 fc
->ra
= byte_get (start
, 1); start
+= 1;
7527 fc
->code_factor
= LEB ();
7528 fc
->data_factor
= SLEB ();
7529 fc
->ra
= byte_get (start
, 1); start
+= 1;
7533 if (do_debug_frames_interp
)
7534 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
7535 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
7536 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
7540 printf ("\n%08lx %08lx %08lx CIE\n",
7541 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
7542 printf (" Version: %d\n", version
);
7543 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7544 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7545 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7546 printf (" Return address column: %d\n", fc
->ra
);
7548 if (augmentation_data_len
)
7551 printf (" Augmentation data: ");
7552 for (i
= 0; i
< augmentation_data_len
; ++i
)
7553 printf (" %02x", augmentation_data
[i
]);
7559 if (augmentation_data_len
)
7561 unsigned char *p
, *q
;
7562 p
= fc
->augmentation
+ 1;
7563 q
= augmentation_data
;
7570 q
+= 1 + size_of_encoded_value (*q
);
7572 fc
->fde_encoding
= *q
++;
7578 if (fc
->fde_encoding
)
7579 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7582 frame_need_space (fc
, fc
->ra
);
7586 unsigned char * look_for
;
7587 static Frame_Chunk fde_fc
;
7590 memset (fc
, 0, sizeof (Frame_Chunk
));
7592 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
7594 for (cie
=chunks
; cie
; cie
= cie
->next
)
7595 if (cie
->chunk_start
== look_for
)
7600 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
7601 cie_id
, saved_start
);
7604 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7605 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7606 frame_need_space (fc
, max_regs
- 1);
7608 fc
->augmentation
= "";
7609 fc
->fde_encoding
= 0;
7613 fc
->ncols
= cie
->ncols
;
7614 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
7615 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
7616 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7617 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7618 fc
->augmentation
= cie
->augmentation
;
7619 fc
->code_factor
= cie
->code_factor
;
7620 fc
->data_factor
= cie
->data_factor
;
7621 fc
->cfa_reg
= cie
->cfa_reg
;
7622 fc
->cfa_offset
= cie
->cfa_offset
;
7624 frame_need_space (fc
, max_regs
-1);
7625 fc
->fde_encoding
= cie
->fde_encoding
;
7628 if (fc
->fde_encoding
)
7629 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7631 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
7632 start
+= encoded_ptr_size
;
7633 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
7634 start
+= encoded_ptr_size
;
7636 if (cie
->augmentation
[0] == 'z')
7638 augmentation_data_len
= LEB ();
7639 augmentation_data
= start
;
7640 start
+= augmentation_data_len
;
7643 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
7644 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
7645 (unsigned long)(cie
->chunk_start
- section_start
),
7646 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
7647 if (! do_debug_frames_interp
&& augmentation_data_len
)
7650 printf (" Augmentation data: ");
7651 for (i
= 0; i
< augmentation_data_len
; ++i
)
7652 printf (" %02x", augmentation_data
[i
]);
7658 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7659 about to interpret instructions for the chunk. */
7661 if (do_debug_frames_interp
)
7663 /* Start by making a pass over the chunk, allocating storage
7664 and taking note of what registers are used. */
7665 unsigned char * tmp
= start
;
7667 while (start
< block_end
)
7677 /* Warning: if you add any more cases to this switch, be
7678 sure to add them to the corresponding switch below. */
7681 case DW_CFA_advance_loc
:
7685 frame_need_space (fc
, opa
);
7686 fc
->col_type
[opa
] = DW_CFA_undefined
;
7688 case DW_CFA_restore
:
7689 frame_need_space (fc
, opa
);
7690 fc
->col_type
[opa
] = DW_CFA_undefined
;
7692 case DW_CFA_set_loc
:
7693 start
+= encoded_ptr_size
;
7695 case DW_CFA_advance_loc1
:
7698 case DW_CFA_advance_loc2
:
7701 case DW_CFA_advance_loc4
:
7704 case DW_CFA_offset_extended
:
7705 reg
= LEB (); LEB ();
7706 frame_need_space (fc
, reg
);
7707 fc
->col_type
[reg
] = DW_CFA_undefined
;
7709 case DW_CFA_restore_extended
:
7711 frame_need_space (fc
, reg
);
7712 fc
->col_type
[reg
] = DW_CFA_undefined
;
7714 case DW_CFA_undefined
:
7716 frame_need_space (fc
, reg
);
7717 fc
->col_type
[reg
] = DW_CFA_undefined
;
7719 case DW_CFA_same_value
:
7721 frame_need_space (fc
, reg
);
7722 fc
->col_type
[reg
] = DW_CFA_undefined
;
7724 case DW_CFA_register
:
7725 reg
= LEB (); LEB ();
7726 frame_need_space (fc
, reg
);
7727 fc
->col_type
[reg
] = DW_CFA_undefined
;
7729 case DW_CFA_def_cfa
:
7732 case DW_CFA_def_cfa_register
:
7735 case DW_CFA_def_cfa_offset
:
7738 #ifndef DW_CFA_GNU_args_size
7739 #define DW_CFA_GNU_args_size 0x2e
7741 case DW_CFA_GNU_args_size
:
7744 #ifndef DW_CFA_GNU_negative_offset_extended
7745 #define DW_CFA_GNU_negative_offset_extended 0x2f
7747 case DW_CFA_GNU_negative_offset_extended
:
7748 reg
= LEB (); LEB ();
7749 frame_need_space (fc
, reg
);
7750 fc
->col_type
[reg
] = DW_CFA_undefined
;
7759 /* Now we know what registers are used, make a second pass over
7760 the chunk, this time actually printing out the info. */
7762 while (start
< block_end
)
7765 unsigned long ul
, reg
, roffs
;
7774 /* Warning: if you add any more cases to this switch, be
7775 sure to add them to the corresponding switch above. */
7778 case DW_CFA_advance_loc
:
7779 if (do_debug_frames_interp
)
7780 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7782 printf (" DW_CFA_advance_loc: %d to %08lx\n",
7783 opa
* fc
->code_factor
,
7784 fc
->pc_begin
+ opa
* fc
->code_factor
);
7785 fc
->pc_begin
+= opa
* fc
->code_factor
;
7790 if (! do_debug_frames_interp
)
7791 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
7792 opa
, roffs
* fc
->data_factor
);
7793 fc
->col_type
[opa
] = DW_CFA_offset
;
7794 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
7797 case DW_CFA_restore
:
7798 if (! do_debug_frames_interp
)
7799 printf (" DW_CFA_restore: r%d\n", opa
);
7800 fc
->col_type
[opa
] = cie
->col_type
[opa
];
7801 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
7804 case DW_CFA_set_loc
:
7805 vma
= byte_get (start
, encoded_ptr_size
);
7806 start
+= encoded_ptr_size
;
7807 if (do_debug_frames_interp
)
7808 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7810 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
7814 case DW_CFA_advance_loc1
:
7815 ofs
= byte_get (start
, 1); start
+= 1;
7816 if (do_debug_frames_interp
)
7817 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7819 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
7820 ofs
* fc
->code_factor
,
7821 fc
->pc_begin
+ ofs
* fc
->code_factor
);
7822 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7825 case DW_CFA_advance_loc2
:
7826 ofs
= byte_get (start
, 2); start
+= 2;
7827 if (do_debug_frames_interp
)
7828 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7830 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
7831 ofs
* fc
->code_factor
,
7832 fc
->pc_begin
+ ofs
* fc
->code_factor
);
7833 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7836 case DW_CFA_advance_loc4
:
7837 ofs
= byte_get (start
, 4); start
+= 4;
7838 if (do_debug_frames_interp
)
7839 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7841 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
7842 ofs
* fc
->code_factor
,
7843 fc
->pc_begin
+ ofs
* fc
->code_factor
);
7844 fc
->pc_begin
+= ofs
* fc
->code_factor
;
7847 case DW_CFA_offset_extended
:
7850 if (! do_debug_frames_interp
)
7851 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
7852 reg
, roffs
* fc
->data_factor
);
7853 fc
->col_type
[reg
] = DW_CFA_offset
;
7854 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
7857 case DW_CFA_restore_extended
:
7859 if (! do_debug_frames_interp
)
7860 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
7861 fc
->col_type
[reg
] = cie
->col_type
[reg
];
7862 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
7865 case DW_CFA_undefined
:
7867 if (! do_debug_frames_interp
)
7868 printf (" DW_CFA_undefined: r%ld\n", reg
);
7869 fc
->col_type
[reg
] = DW_CFA_undefined
;
7870 fc
->col_offset
[reg
] = 0;
7873 case DW_CFA_same_value
:
7875 if (! do_debug_frames_interp
)
7876 printf (" DW_CFA_same_value: r%ld\n", reg
);
7877 fc
->col_type
[reg
] = DW_CFA_same_value
;
7878 fc
->col_offset
[reg
] = 0;
7881 case DW_CFA_register
:
7884 if (! do_debug_frames_interp
)
7885 printf (" DW_CFA_register: r%ld\n", reg
);
7886 fc
->col_type
[reg
] = DW_CFA_register
;
7887 fc
->col_offset
[reg
] = roffs
;
7890 case DW_CFA_remember_state
:
7891 if (! do_debug_frames_interp
)
7892 printf (" DW_CFA_remember_state\n");
7893 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7894 rs
->ncols
= fc
->ncols
;
7895 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
7896 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
7897 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
7898 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
7899 rs
->next
= remembered_state
;
7900 remembered_state
= rs
;
7903 case DW_CFA_restore_state
:
7904 if (! do_debug_frames_interp
)
7905 printf (" DW_CFA_restore_state\n");
7906 rs
= remembered_state
;
7907 remembered_state
= rs
->next
;
7908 frame_need_space (fc
, rs
->ncols
-1);
7909 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
7910 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
7911 free (rs
->col_type
);
7912 free (rs
->col_offset
);
7916 case DW_CFA_def_cfa
:
7917 fc
->cfa_reg
= LEB ();
7918 fc
->cfa_offset
= LEB ();
7919 if (! do_debug_frames_interp
)
7920 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
7921 fc
->cfa_reg
, fc
->cfa_offset
);
7924 case DW_CFA_def_cfa_register
:
7925 fc
->cfa_reg
= LEB ();
7926 if (! do_debug_frames_interp
)
7927 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
7930 case DW_CFA_def_cfa_offset
:
7931 fc
->cfa_offset
= LEB ();
7932 if (! do_debug_frames_interp
)
7933 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
7937 if (! do_debug_frames_interp
)
7938 printf (" DW_CFA_nop\n");
7941 #ifndef DW_CFA_GNU_window_save
7942 #define DW_CFA_GNU_window_save 0x2d
7944 case DW_CFA_GNU_window_save
:
7945 if (! do_debug_frames_interp
)
7946 printf (" DW_CFA_GNU_window_save\n");
7949 case DW_CFA_GNU_args_size
:
7951 if (! do_debug_frames_interp
)
7952 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
7955 case DW_CFA_GNU_negative_offset_extended
:
7958 frame_need_space (fc
, reg
);
7959 if (! do_debug_frames_interp
)
7960 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
7961 reg
, l
* fc
->data_factor
);
7962 fc
->col_type
[reg
] = DW_CFA_offset
;
7963 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
7967 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
7972 if (do_debug_frames_interp
)
7973 frame_display_row (fc
, &need_col_headers
, &max_regs
);
7988 display_debug_not_supported (section
, start
, file
)
7989 Elf32_Internal_Shdr
* section
;
7990 unsigned char * start ATTRIBUTE_UNUSED
;
7991 FILE * file ATTRIBUTE_UNUSED
;
7993 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
7994 SECTION_NAME (section
));
7999 /* Pre-scan the .debug_info section to record the size of address.
8000 When dumping the .debug_line, we use that size information, assuming
8001 that all compilation units have the same address size. */
8003 prescan_debug_info (section
, start
, file
)
8004 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8005 unsigned char * start
;
8006 FILE * file ATTRIBUTE_UNUSED
;
8008 DWARF2_External_CompUnit
* external
;
8010 external
= (DWARF2_External_CompUnit
*) start
;
8012 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8016 /* A structure containing the name of a debug section and a pointer
8017 to a function that can decode it. The third field is a prescan
8018 function to be run over the section before displaying any of the
8023 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8024 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8028 { ".debug_info", display_debug_info
, prescan_debug_info
},
8029 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8030 { ".debug_line", display_debug_lines
, NULL
},
8031 { ".debug_aranges", display_debug_aranges
, NULL
},
8032 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8033 { ".debug_frame", display_debug_frames
, NULL
},
8034 { ".eh_frame", display_debug_frames
, NULL
},
8035 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8036 { ".debug_str", display_debug_not_supported
, NULL
},
8037 { ".debug_static_func", display_debug_not_supported
, NULL
},
8038 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8039 { ".debug_types", display_debug_not_supported
, NULL
},
8040 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8044 display_debug_section (section
, file
)
8045 Elf32_Internal_Shdr
* section
;
8048 char * name
= SECTION_NAME (section
);
8049 bfd_size_type length
;
8050 unsigned char * start
;
8053 length
= section
->sh_size
;
8056 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8060 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8061 _("debug section data"));
8065 /* See if we know how to display the contents of this section. */
8066 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8067 name
= ".debug_info";
8069 for (i
= NUM_ELEM (debug_displays
); i
--;)
8070 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8072 debug_displays
[i
].display (section
, start
, file
);
8077 printf (_("Unrecognised debug section: %s\n"), name
);
8081 /* If we loaded in the abbrev section at some point,
8082 we must release it here. */
8083 if (first_abbrev
!= NULL
)
8090 process_section_contents (file
)
8093 Elf32_Internal_Shdr
* section
;
8099 /* Pre-scan the debug sections to find some debug information not
8100 present in some of them. For the .debug_line, we must find out the
8101 size of address (specified in .debug_info and .debug_aranges). */
8102 for (i
= 0, section
= section_headers
;
8103 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8106 char * name
= SECTION_NAME (section
);
8109 if (section
->sh_size
== 0)
8112 /* See if there is some pre-scan operation for this section. */
8113 for (j
= NUM_ELEM (debug_displays
); j
--;)
8114 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8116 if (debug_displays
[j
].prescan
!= NULL
)
8118 bfd_size_type length
;
8119 unsigned char * start
;
8121 length
= section
->sh_size
;
8122 start
= ((unsigned char *)
8123 get_data (NULL
, file
, section
->sh_offset
, length
,
8124 _("debug section data")));
8128 debug_displays
[j
].prescan (section
, start
, file
);
8136 for (i
= 0, section
= section_headers
;
8137 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8140 #ifdef SUPPORT_DISASSEMBLY
8141 if (dump_sects
[i
] & DISASS_DUMP
)
8142 disassemble_section (section
, file
);
8144 if (dump_sects
[i
] & HEX_DUMP
)
8145 dump_section (section
, file
);
8147 if (dump_sects
[i
] & DEBUG_DUMP
)
8148 display_debug_section (section
, file
);
8151 if (i
< num_dump_sects
)
8152 warn (_("Some sections were not dumped because they do not exist!\n"));
8158 process_mips_fpe_exception (mask
)
8164 if (mask
& OEX_FPU_INEX
)
8165 fputs ("INEX", stdout
), first
= 0;
8166 if (mask
& OEX_FPU_UFLO
)
8167 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8168 if (mask
& OEX_FPU_OFLO
)
8169 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8170 if (mask
& OEX_FPU_DIV0
)
8171 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8172 if (mask
& OEX_FPU_INVAL
)
8173 printf ("%sINVAL", first
? "" : "|");
8176 fputs ("0", stdout
);
8180 process_mips_specific (file
)
8183 Elf_Internal_Dyn
* entry
;
8184 size_t liblist_offset
= 0;
8185 size_t liblistno
= 0;
8186 size_t conflictsno
= 0;
8187 size_t options_offset
= 0;
8188 size_t conflicts_offset
= 0;
8190 /* We have a lot of special sections. Thanks SGI! */
8191 if (dynamic_segment
== NULL
)
8192 /* No information available. */
8195 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
8196 switch (entry
->d_tag
)
8198 case DT_MIPS_LIBLIST
:
8199 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
8201 case DT_MIPS_LIBLISTNO
:
8202 liblistno
= entry
->d_un
.d_val
;
8204 case DT_MIPS_OPTIONS
:
8205 options_offset
= entry
->d_un
.d_val
- loadaddr
;
8207 case DT_MIPS_CONFLICT
:
8208 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
8210 case DT_MIPS_CONFLICTNO
:
8211 conflictsno
= entry
->d_un
.d_val
;
8217 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8219 Elf32_External_Lib
* elib
;
8222 elib
= ((Elf32_External_Lib
*)
8223 get_data (NULL
, file
, liblist_offset
,
8224 liblistno
* sizeof (Elf32_External_Lib
),
8228 printf ("\nSection '.liblist' contains %lu entries:\n",
8229 (unsigned long) liblistno
);
8230 fputs (" Library Time Stamp Checksum Version Flags\n",
8233 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8240 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8241 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8242 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8243 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8244 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8246 tmp
= gmtime (&time
);
8247 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
8248 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8249 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8251 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
8252 dynamic_strings
+ liblist
.l_name
, timebuf
,
8253 liblist
.l_checksum
, liblist
.l_version
);
8255 if (liblist
.l_flags
== 0)
8266 { " EXACT_MATCH", LL_EXACT_MATCH
},
8267 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8268 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8269 { " EXPORTS", LL_EXPORTS
},
8270 { " DELAY_LOAD", LL_DELAY_LOAD
},
8271 { " DELTA", LL_DELTA
}
8273 int flags
= liblist
.l_flags
;
8277 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8279 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8281 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8282 flags
^= l_flags_vals
[fcnt
].bit
;
8285 printf (" %#x", (unsigned int) flags
);
8295 if (options_offset
!= 0)
8297 Elf_External_Options
* eopt
;
8298 Elf_Internal_Shdr
* sect
= section_headers
;
8299 Elf_Internal_Options
* iopt
;
8300 Elf_Internal_Options
* option
;
8304 /* Find the section header so that we get the size. */
8305 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8308 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
8309 sect
->sh_size
, _("options"));
8312 iopt
= ((Elf_Internal_Options
*)
8313 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
8316 error (_("Out of memory"));
8323 while (offset
< sect
->sh_size
)
8325 Elf_External_Options
* eoption
;
8327 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8329 option
->kind
= BYTE_GET (eoption
->kind
);
8330 option
->size
= BYTE_GET (eoption
->size
);
8331 option
->section
= BYTE_GET (eoption
->section
);
8332 option
->info
= BYTE_GET (eoption
->info
);
8334 offset
+= option
->size
;
8340 printf (_("\nSection '%s' contains %d entries:\n"),
8341 SECTION_NAME (sect
), cnt
);
8349 switch (option
->kind
)
8352 /* This shouldn't happen. */
8353 printf (" NULL %d %lx", option
->section
, option
->info
);
8356 printf (" REGINFO ");
8357 if (elf_header
.e_machine
== EM_MIPS
)
8360 Elf32_External_RegInfo
* ereg
;
8361 Elf32_RegInfo reginfo
;
8363 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8364 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8365 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8366 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8367 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8368 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8369 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8371 printf ("GPR %08lx GP 0x%lx\n",
8373 (unsigned long) reginfo
.ri_gp_value
);
8374 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8375 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8376 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8381 Elf64_External_RegInfo
* ereg
;
8382 Elf64_Internal_RegInfo reginfo
;
8384 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8385 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8386 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8387 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8388 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8389 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8390 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
8392 printf ("GPR %08lx GP 0x",
8393 reginfo
.ri_gprmask
);
8394 printf_vma (reginfo
.ri_gp_value
);
8397 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8398 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8399 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8403 case ODK_EXCEPTIONS
:
8404 fputs (" EXCEPTIONS fpe_min(", stdout
);
8405 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8406 fputs (") fpe_max(", stdout
);
8407 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8408 fputs (")", stdout
);
8410 if (option
->info
& OEX_PAGE0
)
8411 fputs (" PAGE0", stdout
);
8412 if (option
->info
& OEX_SMM
)
8413 fputs (" SMM", stdout
);
8414 if (option
->info
& OEX_FPDBUG
)
8415 fputs (" FPDBUG", stdout
);
8416 if (option
->info
& OEX_DISMISS
)
8417 fputs (" DISMISS", stdout
);
8420 fputs (" PAD ", stdout
);
8421 if (option
->info
& OPAD_PREFIX
)
8422 fputs (" PREFIX", stdout
);
8423 if (option
->info
& OPAD_POSTFIX
)
8424 fputs (" POSTFIX", stdout
);
8425 if (option
->info
& OPAD_SYMBOL
)
8426 fputs (" SYMBOL", stdout
);
8429 fputs (" HWPATCH ", stdout
);
8430 if (option
->info
& OHW_R4KEOP
)
8431 fputs (" R4KEOP", stdout
);
8432 if (option
->info
& OHW_R8KPFETCH
)
8433 fputs (" R8KPFETCH", stdout
);
8434 if (option
->info
& OHW_R5KEOP
)
8435 fputs (" R5KEOP", stdout
);
8436 if (option
->info
& OHW_R5KCVTL
)
8437 fputs (" R5KCVTL", stdout
);
8440 fputs (" FILL ", stdout
);
8441 /* XXX Print content of info word? */
8444 fputs (" TAGS ", stdout
);
8445 /* XXX Print content of info word? */
8448 fputs (" HWAND ", stdout
);
8449 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8450 fputs (" R4KEOP_CHECKED", stdout
);
8451 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8452 fputs (" R4KEOP_CLEAN", stdout
);
8455 fputs (" HWOR ", stdout
);
8456 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8457 fputs (" R4KEOP_CHECKED", stdout
);
8458 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8459 fputs (" R4KEOP_CLEAN", stdout
);
8462 printf (" GP_GROUP %#06lx self-contained %#06lx",
8463 option
->info
& OGP_GROUP
,
8464 (option
->info
& OGP_SELF
) >> 16);
8467 printf (" IDENT %#06lx self-contained %#06lx",
8468 option
->info
& OGP_GROUP
,
8469 (option
->info
& OGP_SELF
) >> 16);
8472 /* This shouldn't happen. */
8473 printf (" %3d ??? %d %lx",
8474 option
->kind
, option
->section
, option
->info
);
8478 len
= sizeof (* eopt
);
8479 while (len
< option
->size
)
8480 if (((char *) option
)[len
] >= ' '
8481 && ((char *) option
)[len
] < 0x7f)
8482 printf ("%c", ((char *) option
)[len
++]);
8484 printf ("\\%03o", ((char *) option
)[len
++]);
8486 fputs ("\n", stdout
);
8494 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8496 Elf32_Conflict
* iconf
;
8499 if (dynamic_symbols
== NULL
)
8501 error (_("conflict list with without table"));
8505 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
8508 error (_("Out of memory"));
8514 Elf32_External_Conflict
* econf32
;
8516 econf32
= ((Elf32_External_Conflict
*)
8517 get_data (NULL
, file
, conflicts_offset
,
8518 conflictsno
* sizeof (* econf32
),
8523 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8524 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8530 Elf64_External_Conflict
* econf64
;
8532 econf64
= ((Elf64_External_Conflict
*)
8533 get_data (NULL
, file
, conflicts_offset
,
8534 conflictsno
* sizeof (* econf64
),
8539 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8540 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8545 printf (_("\nSection '.conflict' contains %ld entries:\n"),
8546 (long) conflictsno
);
8547 puts (_(" Num: Index Value Name"));
8549 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8551 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
8553 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8554 print_vma (psym
->st_value
, FULL_HEX
);
8555 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
8565 get_note_type (e_type
)
8568 static char buff
[64];
8572 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
8573 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
8574 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
8575 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
8576 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
8577 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
8578 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
8579 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
8580 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8581 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8582 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8584 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
8589 /* Note that by the ELF standard, the name field is already null byte
8590 terminated, and namesz includes the terminating null byte.
8591 I.E. the value of namesz for the name "FSF" is 4.
8593 If the value of namesz is zero, there is no name present. */
8595 process_note (pnote
)
8596 Elf32_Internal_Note
* pnote
;
8598 printf (" %s\t\t0x%08lx\t%s\n",
8599 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8600 pnote
->descsz
, get_note_type (pnote
->type
));
8606 process_corefile_note_segment (file
, offset
, length
)
8611 Elf_External_Note
* pnotes
;
8612 Elf_External_Note
* external
;
8618 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
8625 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8626 (unsigned long) offset
, (unsigned long) length
);
8627 printf (_(" Owner\t\tData size\tDescription\n"));
8629 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8631 Elf32_Internal_Note inote
;
8634 inote
.type
= BYTE_GET (external
->type
);
8635 inote
.namesz
= BYTE_GET (external
->namesz
);
8636 inote
.namedata
= external
->name
;
8637 inote
.descsz
= BYTE_GET (external
->descsz
);
8638 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8639 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8641 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8643 /* Verify that name is null terminated. It appears that at least
8644 one version of Linux (RedHat 6.0) generates corefiles that don't
8645 comply with the ELF spec by failing to include the null byte in
8647 if (inote
.namedata
[inote
.namesz
] != '\0')
8649 temp
= malloc (inote
.namesz
+ 1);
8653 error (_("Out of memory\n"));
8658 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8659 temp
[inote
.namesz
] = 0;
8661 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8662 inote
.namedata
= temp
;
8665 res
&= process_note (& inote
);
8680 process_corefile_note_segments (file
)
8683 Elf_Internal_Phdr
* program_headers
;
8684 Elf_Internal_Phdr
* segment
;
8688 program_headers
= (Elf_Internal_Phdr
*) malloc
8689 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
8691 if (program_headers
== NULL
)
8693 error (_("Out of memory\n"));
8698 i
= get_32bit_program_headers (file
, program_headers
);
8700 i
= get_64bit_program_headers (file
, program_headers
);
8704 free (program_headers
);
8708 for (i
= 0, segment
= program_headers
;
8709 i
< elf_header
.e_phnum
;
8712 if (segment
->p_type
== PT_NOTE
)
8713 res
&= process_corefile_note_segment (file
,
8714 (bfd_vma
) segment
->p_offset
,
8715 (bfd_vma
) segment
->p_filesz
);
8718 free (program_headers
);
8724 process_corefile_contents (file
)
8727 /* If we have not been asked to display the notes then do nothing. */
8731 /* If file is not a core file then exit. */
8732 if (elf_header
.e_type
!= ET_CORE
)
8735 /* No program headers means no NOTE segment. */
8736 if (elf_header
.e_phnum
== 0)
8738 printf (_("No note segments present in the core file.\n"));
8742 return process_corefile_note_segments (file
);
8746 process_arch_specific (file
)
8752 switch (elf_header
.e_machine
)
8755 case EM_MIPS_RS3_LE
:
8756 return process_mips_specific (file
);
8765 get_file_header (file
)
8768 /* Read in the identity array. */
8769 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
8772 /* Determine how to read the rest of the header. */
8773 switch (elf_header
.e_ident
[EI_DATA
])
8775 default: /* fall through */
8776 case ELFDATANONE
: /* fall through */
8777 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
8778 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
8781 /* For now we only support 32 bit and 64 bit ELF files. */
8782 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
8784 /* Read in the rest of the header. */
8787 Elf32_External_Ehdr ehdr32
;
8789 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
8792 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
8793 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
8794 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
8795 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
8796 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
8797 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
8798 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
8799 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
8800 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
8801 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
8802 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
8803 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
8804 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
8808 Elf64_External_Ehdr ehdr64
;
8810 /* If we have been compiled with sizeof (bfd_vma) == 4, then
8811 we will not be able to cope with the 64bit data found in
8812 64 ELF files. Detect this now and abort before we start
8813 overwritting things. */
8814 if (sizeof (bfd_vma
) < 8)
8816 error (_("This instance of readelf has been built without support for a\n"));
8817 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
8821 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
8824 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
8825 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
8826 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
8827 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
8828 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
8829 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
8830 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
8831 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
8832 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
8833 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
8834 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
8835 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
8836 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
8843 process_file (file_name
)
8847 struct stat statbuf
;
8850 if (stat (file_name
, & statbuf
) < 0)
8852 error (_("Cannot stat input file %s.\n"), file_name
);
8856 file
= fopen (file_name
, "rb");
8859 error (_("Input file %s not found.\n"), file_name
);
8863 if (! get_file_header (file
))
8865 error (_("%s: Failed to read file header\n"), file_name
);
8870 /* Initialise per file variables. */
8871 for (i
= NUM_ELEM (version_info
); i
--;)
8872 version_info
[i
] = 0;
8874 for (i
= NUM_ELEM (dynamic_info
); i
--;)
8875 dynamic_info
[i
] = 0;
8877 /* Process the file. */
8879 printf (_("\nFile: %s\n"), file_name
);
8881 if (! process_file_header ())
8887 process_section_headers (file
);
8889 process_program_headers (file
);
8891 process_dynamic_segment (file
);
8893 process_relocs (file
);
8895 process_unwind (file
);
8897 process_symbol_table (file
);
8899 process_syminfo (file
);
8901 process_version_sections (file
);
8903 process_section_contents (file
);
8905 process_corefile_contents (file
);
8907 process_arch_specific (file
);
8911 if (section_headers
)
8913 free (section_headers
);
8914 section_headers
= NULL
;
8919 free (string_table
);
8920 string_table
= NULL
;
8921 string_table_length
= 0;
8924 if (dynamic_strings
)
8926 free (dynamic_strings
);
8927 dynamic_strings
= NULL
;
8930 if (dynamic_symbols
)
8932 free (dynamic_symbols
);
8933 dynamic_symbols
= NULL
;
8934 num_dynamic_syms
= 0;
8937 if (dynamic_syminfo
)
8939 free (dynamic_syminfo
);
8940 dynamic_syminfo
= NULL
;
8946 #ifdef SUPPORT_DISASSEMBLY
8947 /* Needed by the i386 disassembler. For extra credit, someone could
8948 fix this so that we insert symbolic addresses here, esp for GOT/PLT
8952 print_address (unsigned int addr
, FILE * outfile
)
8954 fprintf (outfile
,"0x%8.8x", addr
);
8957 /* Needed by the i386 disassembler. */
8959 db_task_printsym (unsigned int addr
)
8961 print_address (addr
, stderr
);
8972 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
8973 setlocale (LC_MESSAGES
, "");
8975 bindtextdomain (PACKAGE
, LOCALEDIR
);
8976 textdomain (PACKAGE
);
8978 parse_args (argc
, argv
);
8980 if (optind
< (argc
- 1))
8984 while (optind
< argc
)
8985 err
|= process_file (argv
[optind
++]);
8987 if (dump_sects
!= NULL
)