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"
70 #include "elf/mcore.h"
78 #include "elf/x86-64.h"
84 char * program_name
= "readelf";
85 unsigned int dynamic_addr
;
86 bfd_size_type dynamic_size
;
87 unsigned int rela_addr
;
88 unsigned int rela_size
;
89 char * dynamic_strings
;
91 unsigned long string_table_length
;
92 unsigned long num_dynamic_syms
;
93 Elf_Internal_Sym
* dynamic_symbols
;
94 Elf_Internal_Syminfo
* dynamic_syminfo
;
95 unsigned long dynamic_syminfo_offset
;
96 unsigned int dynamic_syminfo_nent
;
97 char program_interpreter
[64];
98 int dynamic_info
[DT_JMPREL
+ 1];
101 Elf_Internal_Ehdr elf_header
;
102 Elf_Internal_Shdr
* section_headers
;
103 Elf_Internal_Dyn
* dynamic_segment
;
111 int do_using_dynamic
;
119 int do_debug_abbrevs
;
121 int do_debug_pubnames
;
122 int do_debug_aranges
;
124 int do_debug_frames_interp
;
125 int do_debug_macinfo
;
130 /* A dynamic array of flags indicating which sections require dumping. */
131 char * dump_sects
= NULL
;
132 unsigned int num_dump_sects
= 0;
134 #define HEX_DUMP (1 << 0)
135 #define DISASS_DUMP (1 << 1)
136 #define DEBUG_DUMP (1 << 2)
138 /* How to rpint a vma value. */
139 typedef enum print_mode
151 /* Forward declarations for dumb compilers. */
152 static void print_vma
PARAMS ((bfd_vma
, print_mode
));
153 static bfd_vma (* byte_get
) PARAMS ((unsigned char *, int));
154 static bfd_vma byte_get_little_endian
PARAMS ((unsigned char *, int));
155 static bfd_vma byte_get_big_endian
PARAMS ((unsigned char *, int));
156 static const char * get_mips_dynamic_type
PARAMS ((unsigned long));
157 static const char * get_sparc64_dynamic_type
PARAMS ((unsigned long));
158 static const char * get_parisc_dynamic_type
PARAMS ((unsigned long));
159 static const char * get_dynamic_type
PARAMS ((unsigned long));
160 static int slurp_rela_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rela
**, unsigned long *));
161 static int slurp_rel_relocs
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Rel
**, unsigned long *));
162 static int dump_relocations
PARAMS ((FILE *, unsigned long, unsigned long, Elf_Internal_Sym
*, unsigned long, char *, int));
163 static char * get_file_type
PARAMS ((unsigned));
164 static char * get_machine_name
PARAMS ((unsigned));
165 static void decode_ARM_machine_flags
PARAMS ((unsigned, char []));
166 static char * get_machine_flags
PARAMS ((unsigned, unsigned));
167 static const char * get_mips_segment_type
PARAMS ((unsigned long));
168 static const char * get_parisc_segment_type
PARAMS ((unsigned long));
169 static const char * get_ia64_segment_type
PARAMS ((unsigned long));
170 static const char * get_segment_type
PARAMS ((unsigned long));
171 static const char * get_mips_section_type_name
PARAMS ((unsigned int));
172 static const char * get_parisc_section_type_name
PARAMS ((unsigned int));
173 static const char * get_ia64_section_type_name
PARAMS ((unsigned int));
174 static const char * get_section_type_name
PARAMS ((unsigned int));
175 static const char * get_symbol_binding
PARAMS ((unsigned int));
176 static const char * get_symbol_type
PARAMS ((unsigned int));
177 static const char * get_symbol_visibility
PARAMS ((unsigned int));
178 static const char * get_symbol_index_type
PARAMS ((unsigned int));
179 static const char * get_dynamic_flags
PARAMS ((bfd_vma
));
180 static void usage
PARAMS ((void));
181 static void parse_args
PARAMS ((int, char **));
182 static int process_file_header
PARAMS ((void));
183 static int process_program_headers
PARAMS ((FILE *));
184 static int process_section_headers
PARAMS ((FILE *));
185 static int process_unwind
PARAMS ((FILE *));
186 static void dynamic_segment_mips_val
PARAMS ((Elf_Internal_Dyn
*));
187 static void dynamic_segment_parisc_val
PARAMS ((Elf_Internal_Dyn
*));
188 static int process_dynamic_segment
PARAMS ((FILE *));
189 static int process_symbol_table
PARAMS ((FILE *));
190 static int process_syminfo
PARAMS ((FILE *));
191 static int process_section_contents
PARAMS ((FILE *));
192 static void process_mips_fpe_exception
PARAMS ((int));
193 static int process_mips_specific
PARAMS ((FILE *));
194 static int process_file
PARAMS ((char *));
195 static int process_relocs
PARAMS ((FILE *));
196 static int process_version_sections
PARAMS ((FILE *));
197 static char * get_ver_flags
PARAMS ((unsigned int));
198 static int get_32bit_section_headers
PARAMS ((FILE *));
199 static int get_64bit_section_headers
PARAMS ((FILE *));
200 static int get_32bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
201 static int get_64bit_program_headers
PARAMS ((FILE *, Elf_Internal_Phdr
*));
202 static int get_file_header
PARAMS ((FILE *));
203 static Elf_Internal_Sym
* get_32bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
204 static Elf_Internal_Sym
* get_64bit_elf_symbols
PARAMS ((FILE *, unsigned long, unsigned long));
205 static const char * get_elf_section_flags
PARAMS ((bfd_vma
));
206 static int * get_dynamic_data
PARAMS ((FILE *, unsigned int));
207 static int get_32bit_dynamic_segment
PARAMS ((FILE *));
208 static int get_64bit_dynamic_segment
PARAMS ((FILE *));
209 #ifdef SUPPORT_DISASSEMBLY
210 static int disassemble_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
212 static int dump_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
213 static int display_debug_section
PARAMS ((Elf32_Internal_Shdr
*, FILE *));
214 static int display_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
215 static int display_debug_not_supported
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
216 static int prescan_debug_info
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
217 static int display_debug_lines
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
218 static int display_debug_pubnames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
219 static int display_debug_abbrev
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
220 static int display_debug_aranges
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
221 static int display_debug_frames
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
222 static int display_debug_macinfo
PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
223 static unsigned char * process_abbrev_section
PARAMS ((unsigned char *, unsigned char *));
224 static unsigned long read_leb128
PARAMS ((unsigned char *, int *, int));
225 static int process_extended_line_op
PARAMS ((unsigned char *, int, int));
226 static void reset_state_machine
PARAMS ((int));
227 static char * get_TAG_name
PARAMS ((unsigned long));
228 static char * get_AT_name
PARAMS ((unsigned long));
229 static char * get_FORM_name
PARAMS ((unsigned long));
230 static void free_abbrevs
PARAMS ((void));
231 static void add_abbrev
PARAMS ((unsigned long, unsigned long, int));
232 static void add_abbrev_attr
PARAMS ((unsigned long, unsigned long));
233 static unsigned char * read_and_display_attr
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
234 static unsigned char * read_and_display_attr_value
PARAMS ((unsigned long, unsigned long, unsigned char *, unsigned long, unsigned long));
235 static unsigned char * display_block
PARAMS ((unsigned char *, unsigned long));
236 static void decode_location_expression
PARAMS ((unsigned char *, unsigned int, unsigned long));
237 static void request_dump
PARAMS ((unsigned int, int));
238 static const char * get_elf_class
PARAMS ((unsigned int));
239 static const char * get_data_encoding
PARAMS ((unsigned int));
240 static const char * get_osabi_name
PARAMS ((unsigned int));
241 static int guess_is_rela
PARAMS ((unsigned long));
242 static char * get_note_type
PARAMS ((unsigned int));
243 static int process_note
PARAMS ((Elf32_Internal_Note
*));
244 static int process_corefile_note_segment
PARAMS ((FILE *, bfd_vma
, bfd_vma
));
245 static int process_corefile_note_segments
PARAMS ((FILE *));
246 static int process_corefile_contents
PARAMS ((FILE *));
247 static int process_arch_specific
PARAMS ((FILE *));
249 typedef int Elf32_Word
;
257 #define SECTION_NAME(X) ((X) == NULL ? "<none>" : \
258 ((X)->sh_name >= string_table_length \
259 ? "<corrupt>" : string_table + (X)->sh_name))
261 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
263 #define BYTE_GET(field) byte_get (field, sizeof (field))
265 /* If we can support a 64 bit data type then BFD64 should be defined
266 and sizeof (bfd_vma) == 8. In this case when translating from an
267 external 8 byte field to an internal field, we can assume that the
268 internal field is also 8 bytes wide and so we can extract all the data.
269 If, however, BFD64 is not defined, then we must assume that the
270 internal data structure only has 4 byte wide fields that are the
271 equivalent of the 8 byte wide external counterparts, and so we must
272 truncate the data. */
274 #define BYTE_GET8(field) byte_get (field, -8)
276 #define BYTE_GET8(field) byte_get (field, 8)
279 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
281 #define GET_ELF_SYMBOLS(file, offset, size) \
282 (is_32bit_elf ? get_32bit_elf_symbols (file, offset, size) \
283 : get_64bit_elf_symbols (file, offset, size))
287 error
VPARAMS ((const char *message
, ...))
289 VA_OPEN (args
, message
);
290 VA_FIXEDARG (args
, const char *, message
);
292 fprintf (stderr
, _("%s: Error: "), program_name
);
293 vfprintf (stderr
, message
, args
);
298 warn
VPARAMS ((const char *message
, ...))
300 VA_OPEN (args
, message
);
301 VA_FIXEDARG (args
, const char *, message
);
303 fprintf (stderr
, _("%s: Warning: "), program_name
);
304 vfprintf (stderr
, message
, args
);
308 static PTR get_data
PARAMS ((PTR
, FILE *, long, size_t, const char *));
311 get_data (var
, file
, offset
, size
, reason
)
323 if (fseek (file
, offset
, SEEK_SET
))
325 error (_("Unable to seek to %x for %s\n"), offset
, reason
);
332 mvar
= (PTR
) malloc (size
);
336 error (_("Out of memory allocating %d bytes for %s\n"),
342 if (fread (mvar
, size
, 1, file
) != 1)
344 error (_("Unable to read in %d bytes of %s\n"), size
, reason
);
354 byte_get_little_endian (field
, size
)
355 unsigned char * field
;
364 return ((unsigned int) (field
[0]))
365 | (((unsigned int) (field
[1])) << 8);
369 /* We want to extract data from an 8 byte wide field and
370 place it into a 4 byte wide field. Since this is a little
371 endian source we can juts use the 4 byte extraction code. */
375 return ((unsigned long) (field
[0]))
376 | (((unsigned long) (field
[1])) << 8)
377 | (((unsigned long) (field
[2])) << 16)
378 | (((unsigned long) (field
[3])) << 24);
383 /* This is a special case, generated by the BYTE_GET8 macro.
384 It means that we are loading an 8 byte value from a field
385 in an external structure into an 8 byte value in a field
386 in an internal strcuture. */
387 return ((bfd_vma
) (field
[0]))
388 | (((bfd_vma
) (field
[1])) << 8)
389 | (((bfd_vma
) (field
[2])) << 16)
390 | (((bfd_vma
) (field
[3])) << 24)
391 | (((bfd_vma
) (field
[4])) << 32)
392 | (((bfd_vma
) (field
[5])) << 40)
393 | (((bfd_vma
) (field
[6])) << 48)
394 | (((bfd_vma
) (field
[7])) << 56);
397 error (_("Unhandled data length: %d\n"), size
);
402 /* Print a VMA value. */
404 print_vma (vma
, mode
)
414 case FULL_HEX
: printf ("0x"); /* drop through */
415 case LONG_HEX
: printf ("%8.8lx", (unsigned long) vma
); break;
416 case PREFIX_HEX
: printf ("0x"); /* drop through */
417 case HEX
: printf ("%lx", (unsigned long) vma
); break;
418 case DEC
: printf ("%ld", (unsigned long) vma
); break;
419 case DEC_5
: printf ("%5ld", (long) vma
); break;
420 case UNSIGNED
: printf ("%lu", (unsigned long) vma
); break;
441 #if BFD_HOST_64BIT_LONG
444 if (_bfd_int64_high (vma
))
445 printf ("%lx%8.8lx", _bfd_int64_high (vma
), _bfd_int64_low (vma
));
447 printf ("%lx", _bfd_int64_low (vma
));
452 #if BFD_HOST_64BIT_LONG
455 if (_bfd_int64_high (vma
))
457 printf ("++%ld", _bfd_int64_low (vma
));
459 printf ("%ld", _bfd_int64_low (vma
));
464 #if BFD_HOST_64BIT_LONG
465 printf ("%5ld", vma
);
467 if (_bfd_int64_high (vma
))
469 printf ("++%ld", _bfd_int64_low (vma
));
471 printf ("%5ld", _bfd_int64_low (vma
));
476 #if BFD_HOST_64BIT_LONG
479 if (_bfd_int64_high (vma
))
481 printf ("++%lu", _bfd_int64_low (vma
));
483 printf ("%lu", _bfd_int64_low (vma
));
492 byte_get_big_endian (field
, size
)
493 unsigned char * field
;
502 return ((unsigned int) (field
[1])) | (((int) (field
[0])) << 8);
505 return ((unsigned long) (field
[3]))
506 | (((unsigned long) (field
[2])) << 8)
507 | (((unsigned long) (field
[1])) << 16)
508 | (((unsigned long) (field
[0])) << 24);
512 /* Although we are extracing data from an 8 byte wide field, we
513 are returning only 4 bytes of data. */
514 return ((unsigned long) (field
[7]))
515 | (((unsigned long) (field
[6])) << 8)
516 | (((unsigned long) (field
[5])) << 16)
517 | (((unsigned long) (field
[4])) << 24);
521 /* This is a special case, generated by the BYTE_GET8 macro.
522 It means that we are loading an 8 byte value from a field
523 in an external structure into an 8 byte value in a field
524 in an internal strcuture. */
525 return ((bfd_vma
) (field
[7]))
526 | (((bfd_vma
) (field
[6])) << 8)
527 | (((bfd_vma
) (field
[5])) << 16)
528 | (((bfd_vma
) (field
[4])) << 24)
529 | (((bfd_vma
) (field
[3])) << 32)
530 | (((bfd_vma
) (field
[2])) << 40)
531 | (((bfd_vma
) (field
[1])) << 48)
532 | (((bfd_vma
) (field
[0])) << 56);
536 error (_("Unhandled data length: %d\n"), size
);
541 /* Guess the relocation size commonly used by the specific machines. */
544 guess_is_rela (e_machine
)
545 unsigned long e_machine
;
549 /* Targets that use REL relocations. */
562 /* Targets that use RELA relocations. */
576 case EM_CYGNUS_MN10200
:
578 case EM_CYGNUS_MN10300
:
614 warn (_("Don't know about relocations on this machine architecture\n"));
620 slurp_rela_relocs (file
, rel_offset
, rel_size
, relasp
, nrelasp
)
622 unsigned long rel_offset
;
623 unsigned long rel_size
;
624 Elf_Internal_Rela
**relasp
;
625 unsigned long *nrelasp
;
627 Elf_Internal_Rela
*relas
;
628 unsigned long nrelas
;
633 Elf32_External_Rela
* erelas
;
635 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
,
636 rel_size
, _("relocs"));
640 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
642 relas
= (Elf_Internal_Rela
*)
643 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
647 error(_("out of memory parsing relocs"));
651 for (i
= 0; i
< nrelas
; i
++)
653 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
654 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
655 relas
[i
].r_addend
= BYTE_GET (erelas
[i
].r_addend
);
662 Elf64_External_Rela
* erelas
;
664 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
,
665 rel_size
, _("relocs"));
669 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
671 relas
= (Elf_Internal_Rela
*)
672 malloc (nrelas
* sizeof (Elf_Internal_Rela
));
676 error(_("out of memory parsing relocs"));
680 for (i
= 0; i
< nrelas
; i
++)
682 relas
[i
].r_offset
= BYTE_GET8 (erelas
[i
].r_offset
);
683 relas
[i
].r_info
= BYTE_GET8 (erelas
[i
].r_info
);
684 relas
[i
].r_addend
= BYTE_GET8 (erelas
[i
].r_addend
);
695 slurp_rel_relocs (file
, rel_offset
, rel_size
, relsp
, nrelsp
)
697 unsigned long rel_offset
;
698 unsigned long rel_size
;
699 Elf_Internal_Rel
**relsp
;
700 unsigned long *nrelsp
;
702 Elf_Internal_Rel
*rels
;
708 Elf32_External_Rel
* erels
;
710 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
,
711 rel_size
, _("relocs"));
715 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
717 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
721 error(_("out of memory parsing relocs"));
725 for (i
= 0; i
< nrels
; i
++)
727 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
728 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
735 Elf64_External_Rel
* erels
;
737 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
,
738 rel_size
, _("relocs"));
742 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
744 rels
= (Elf_Internal_Rel
*) malloc (nrels
* sizeof (Elf_Internal_Rel
));
748 error(_("out of memory parsing relocs"));
752 for (i
= 0; i
< nrels
; i
++)
754 rels
[i
].r_offset
= BYTE_GET8 (erels
[i
].r_offset
);
755 rels
[i
].r_info
= BYTE_GET8 (erels
[i
].r_info
);
765 /* Display the contents of the relocation data found at the specified offset. */
767 dump_relocations (file
, rel_offset
, rel_size
, symtab
, nsyms
, strtab
, is_rela
)
769 unsigned long rel_offset
;
770 unsigned long rel_size
;
771 Elf_Internal_Sym
* symtab
;
777 Elf_Internal_Rel
* rels
;
778 Elf_Internal_Rela
* relas
;
781 if (is_rela
== UNKNOWN
)
782 is_rela
= guess_is_rela (elf_header
.e_machine
);
786 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &relas
, &rel_size
))
791 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
799 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
802 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
808 (_(" Offset Info Type Symbol's Value Symbol's Name Addend\n"));
811 (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
814 for (i
= 0; i
< rel_size
; i
++)
819 bfd_vma symtab_index
;
824 offset
= relas
[i
].r_offset
;
825 info
= relas
[i
].r_info
;
829 offset
= rels
[i
].r_offset
;
830 info
= rels
[i
].r_info
;
835 type
= ELF32_R_TYPE (info
);
836 symtab_index
= ELF32_R_SYM (info
);
840 if (elf_header
.e_machine
== EM_SPARCV9
)
841 type
= ELF64_R_TYPE_ID (info
);
843 type
= ELF64_R_TYPE (info
);
844 /* The #ifdef BFD64 below is to prevent a compile time warning.
845 We know that if we do not have a 64 bit data type that we
846 will never execute this code anyway. */
848 symtab_index
= ELF64_R_SYM (info
);
854 #ifdef _bfd_int64_low
855 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset
), _bfd_int64_low (info
));
857 printf ("%8.8lx %8.8lx ", offset
, info
);
862 #ifdef _bfd_int64_low
863 printf ("%8.8lx%8.8lx %8.8lx%8.8lx ",
864 _bfd_int64_high (offset
),
865 _bfd_int64_low (offset
),
866 _bfd_int64_high (info
),
867 _bfd_int64_low (info
));
869 printf ("%16.16lx %16.16lx ", offset
, info
);
873 switch (elf_header
.e_machine
)
881 rtype
= elf_m32r_reloc_type (type
);
886 rtype
= elf_i386_reloc_type (type
);
890 rtype
= elf_m68k_reloc_type (type
);
894 rtype
= elf_i960_reloc_type (type
);
899 rtype
= elf_avr_reloc_type (type
);
906 rtype
= elf_sparc_reloc_type (type
);
911 rtype
= v850_reloc_type (type
);
916 rtype
= elf_d10v_reloc_type (type
);
921 rtype
= elf_d30v_reloc_type (type
);
925 rtype
= elf_sh_reloc_type (type
);
929 case EM_CYGNUS_MN10300
:
930 rtype
= elf_mn10300_reloc_type (type
);
934 case EM_CYGNUS_MN10200
:
935 rtype
= elf_mn10200_reloc_type (type
);
940 rtype
= elf_fr30_reloc_type (type
);
944 rtype
= elf_mcore_reloc_type (type
);
948 rtype
= elf_mmix_reloc_type (type
);
953 rtype
= elf_ppc_reloc_type (type
);
958 rtype
= elf_mips_reloc_type (type
);
962 rtype
= elf_alpha_reloc_type (type
);
966 rtype
= elf_arm_reloc_type (type
);
970 rtype
= elf_arc_reloc_type (type
);
974 rtype
= elf_hppa_reloc_type (type
);
980 rtype
= elf_h8_reloc_type (type
);
985 rtype
= elf_pj_reloc_type (type
);
988 rtype
= elf_ia64_reloc_type (type
);
992 rtype
= elf_cris_reloc_type (type
);
996 rtype
= elf_i860_reloc_type (type
);
1000 rtype
= elf_x86_64_reloc_type (type
);
1005 rtype
= elf_s390_reloc_type (type
);
1010 #ifdef _bfd_int64_low
1011 printf (_("unrecognised: %-7lx"), _bfd_int64_low (type
));
1013 printf (_("unrecognised: %-7lx"), type
);
1016 printf ("%-21.21s", rtype
);
1020 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1021 printf (" bad symbol index: %08lx", (unsigned long) symtab_index
);
1024 Elf_Internal_Sym
* psym
;
1026 psym
= symtab
+ symtab_index
;
1029 print_vma (psym
->st_value
, LONG_HEX
);
1032 if (psym
->st_name
== 0)
1034 SECTION_NAME (section_headers
+ psym
->st_shndx
));
1035 else if (strtab
== NULL
)
1036 printf (_("<string table index %3ld>"), psym
->st_name
);
1038 printf ("%-25.25s", strtab
+ psym
->st_name
);
1041 printf (" + %lx", (unsigned long) relas
[i
].r_addend
);
1046 printf ("%*c", is_32bit_elf
? 34 : 26, ' ');
1047 print_vma (relas
[i
].r_addend
, LONG_HEX
);
1050 if (elf_header
.e_machine
== EM_SPARCV9
1051 && !strcmp (rtype
, "R_SPARC_OLO10"))
1052 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info
));
1066 get_mips_dynamic_type (type
)
1071 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1072 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1073 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1074 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1075 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1076 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1077 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1078 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1079 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1080 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1081 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1082 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1083 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1084 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1085 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1086 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1087 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1088 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1089 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1090 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1091 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1092 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1093 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1094 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1095 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1096 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1097 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1098 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1099 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1100 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1101 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1102 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1103 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1104 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1105 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1106 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1107 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1108 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1109 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1110 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1111 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1112 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1113 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1120 get_sparc64_dynamic_type (type
)
1125 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1132 get_parisc_dynamic_type (type
)
1137 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1138 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1139 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1140 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1141 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1142 case DT_HP_PREINIT
: return "HP_PREINIT";
1143 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1144 case DT_HP_NEEDED
: return "HP_NEEDED";
1145 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1146 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1147 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1148 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1149 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1156 get_dynamic_type (type
)
1159 static char buff
[32];
1163 case DT_NULL
: return "NULL";
1164 case DT_NEEDED
: return "NEEDED";
1165 case DT_PLTRELSZ
: return "PLTRELSZ";
1166 case DT_PLTGOT
: return "PLTGOT";
1167 case DT_HASH
: return "HASH";
1168 case DT_STRTAB
: return "STRTAB";
1169 case DT_SYMTAB
: return "SYMTAB";
1170 case DT_RELA
: return "RELA";
1171 case DT_RELASZ
: return "RELASZ";
1172 case DT_RELAENT
: return "RELAENT";
1173 case DT_STRSZ
: return "STRSZ";
1174 case DT_SYMENT
: return "SYMENT";
1175 case DT_INIT
: return "INIT";
1176 case DT_FINI
: return "FINI";
1177 case DT_SONAME
: return "SONAME";
1178 case DT_RPATH
: return "RPATH";
1179 case DT_SYMBOLIC
: return "SYMBOLIC";
1180 case DT_REL
: return "REL";
1181 case DT_RELSZ
: return "RELSZ";
1182 case DT_RELENT
: return "RELENT";
1183 case DT_PLTREL
: return "PLTREL";
1184 case DT_DEBUG
: return "DEBUG";
1185 case DT_TEXTREL
: return "TEXTREL";
1186 case DT_JMPREL
: return "JMPREL";
1187 case DT_BIND_NOW
: return "BIND_NOW";
1188 case DT_INIT_ARRAY
: return "INIT_ARRAY";
1189 case DT_FINI_ARRAY
: return "FINI_ARRAY";
1190 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
1191 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
1192 case DT_RUNPATH
: return "RUNPATH";
1193 case DT_FLAGS
: return "FLAGS";
1195 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1196 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
1198 case DT_CHECKSUM
: return "CHECKSUM";
1199 case DT_PLTPADSZ
: return "PLTPADSZ";
1200 case DT_MOVEENT
: return "MOVEENT";
1201 case DT_MOVESZ
: return "MOVESZ";
1202 case DT_FEATURE
: return "FEATURE";
1203 case DT_POSFLAG_1
: return "POSFLAG_1";
1204 case DT_SYMINSZ
: return "SYMINSZ";
1205 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
1207 case DT_ADDRRNGLO
: return "ADDRRNGLO";
1208 case DT_CONFIG
: return "CONFIG";
1209 case DT_DEPAUDIT
: return "DEPAUDIT";
1210 case DT_AUDIT
: return "AUDIT";
1211 case DT_PLTPAD
: return "PLTPAD";
1212 case DT_MOVETAB
: return "MOVETAB";
1213 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
1215 case DT_VERSYM
: return "VERSYM";
1217 case DT_RELACOUNT
: return "RELACOUNT";
1218 case DT_RELCOUNT
: return "RELCOUNT";
1219 case DT_FLAGS_1
: return "FLAGS_1";
1220 case DT_VERDEF
: return "VERDEF";
1221 case DT_VERDEFNUM
: return "VERDEFNUM";
1222 case DT_VERNEED
: return "VERNEED";
1223 case DT_VERNEEDNUM
: return "VERNEEDNUM";
1225 case DT_AUXILIARY
: return "AUXILIARY";
1226 case DT_USED
: return "USED";
1227 case DT_FILTER
: return "FILTER";
1230 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
1232 const char * result
;
1234 switch (elf_header
.e_machine
)
1237 case EM_MIPS_RS3_LE
:
1238 result
= get_mips_dynamic_type (type
);
1241 result
= get_sparc64_dynamic_type (type
);
1251 sprintf (buff
, _("Processor Specific: %lx"), type
);
1253 else if ((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
1255 const char * result
;
1257 switch (elf_header
.e_machine
)
1260 result
= get_parisc_dynamic_type (type
);
1270 sprintf (buff
, _("Operating System specific: %lx"), type
);
1273 sprintf (buff
, _("<unknown>: %lx"), type
);
1280 get_file_type (e_type
)
1283 static char buff
[32];
1287 case ET_NONE
: return _("NONE (None)");
1288 case ET_REL
: return _("REL (Relocatable file)");
1289 case ET_EXEC
: return _("EXEC (Executable file)");
1290 case ET_DYN
: return _("DYN (Shared object file)");
1291 case ET_CORE
: return _("CORE (Core file)");
1294 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
1295 sprintf (buff
, _("Processor Specific: (%x)"), e_type
);
1296 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
1297 sprintf (buff
, _("OS Specific: (%x)"), e_type
);
1299 sprintf (buff
, _("<unknown>: %x"), e_type
);
1305 get_machine_name (e_machine
)
1308 static char buff
[64]; /* XXX */
1312 case EM_NONE
: return _("None");
1313 case EM_M32
: return "WE32100";
1314 case EM_SPARC
: return "Sparc";
1315 case EM_386
: return "Intel 80386";
1316 case EM_68K
: return "MC68000";
1317 case EM_88K
: return "MC88000";
1318 case EM_486
: return "Intel 80486";
1319 case EM_860
: return "Intel 80860";
1320 case EM_MIPS
: return "MIPS R3000";
1321 case EM_S370
: return "IBM System/370";
1322 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
1323 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
1324 case EM_PARISC
: return "HPPA";
1325 case EM_PPC_OLD
: return "Power PC (old)";
1326 case EM_SPARC32PLUS
: return "Sparc v8+" ;
1327 case EM_960
: return "Intel 90860";
1328 case EM_PPC
: return "PowerPC";
1329 case EM_V800
: return "NEC V800";
1330 case EM_FR20
: return "Fujitsu FR20";
1331 case EM_RH32
: return "TRW RH32";
1332 case EM_MCORE
: return "MCORE";
1333 case EM_ARM
: return "ARM";
1334 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
1335 case EM_SH
: return "Hitachi SH";
1336 case EM_SPARCV9
: return "Sparc v9";
1337 case EM_TRICORE
: return "Siemens Tricore";
1338 case EM_ARC
: return "ARC";
1339 case EM_H8_300
: return "Hitachi H8/300";
1340 case EM_H8_300H
: return "Hitachi H8/300H";
1341 case EM_H8S
: return "Hitachi H8S";
1342 case EM_H8_500
: return "Hitachi H8/500";
1343 case EM_IA_64
: return "Intel IA-64";
1344 case EM_MIPS_X
: return "Stanford MIPS-X";
1345 case EM_COLDFIRE
: return "Motorola Coldfire";
1346 case EM_68HC12
: return "Motorola M68HC12";
1347 case EM_ALPHA
: return "Alpha";
1348 case EM_CYGNUS_D10V
:
1349 case EM_D10V
: return "d10v";
1350 case EM_CYGNUS_D30V
:
1351 case EM_D30V
: return "d30v";
1352 case EM_CYGNUS_M32R
:
1353 case EM_M32R
: return "Mitsubishi M32r";
1354 case EM_CYGNUS_V850
:
1355 case EM_V850
: return "NEC v850";
1356 case EM_CYGNUS_MN10300
:
1357 case EM_MN10300
: return "mn10300";
1358 case EM_CYGNUS_MN10200
:
1359 case EM_MN10200
: return "mn10200";
1360 case EM_CYGNUS_FR30
:
1361 case EM_FR30
: return "Fujitsu FR30";
1363 case EM_PJ
: return "picoJava";
1364 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
1365 case EM_PCP
: return "Siemens PCP";
1366 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
1367 case EM_NDR1
: return "Denso NDR1 microprocesspr";
1368 case EM_STARCORE
: return "Motorola Star*Core processor";
1369 case EM_ME16
: return "Toyota ME16 processor";
1370 case EM_ST100
: return "STMicroelectronics ST100 processor";
1371 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
1372 case EM_FX66
: return "Siemens FX66 microcontroller";
1373 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1374 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
1375 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
1376 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
1377 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
1378 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
1379 case EM_SVX
: return "Silicon Graphics SVx";
1380 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
1381 case EM_VAX
: return "Digital VAX";
1383 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
1384 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
1385 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
1386 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
1387 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
1388 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
1389 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
1390 case EM_PRISM
: return "SiTera Prism";
1391 case EM_X86_64
: return "Advanced Micro Devices X86-64";
1393 case EM_S390
: return "IBM S/390";
1395 sprintf (buff
, _("<unknown>: %x"), e_machine
);
1401 decode_ARM_machine_flags (e_flags
, buf
)
1408 eabi
= EF_ARM_EABI_VERSION (e_flags
);
1409 e_flags
&= ~ EF_ARM_EABIMASK
;
1411 /* Handle "generic" ARM flags. */
1412 if (e_flags
& EF_ARM_RELEXEC
)
1414 strcat (buf
, ", relocatable executable");
1415 e_flags
&= ~ EF_ARM_RELEXEC
;
1418 if (e_flags
& EF_ARM_HASENTRY
)
1420 strcat (buf
, ", has entry point");
1421 e_flags
&= ~ EF_ARM_HASENTRY
;
1424 /* Now handle EABI specific flags. */
1428 strcat (buf
, ", <unrecognised EABI>");
1433 case EF_ARM_EABI_VER1
:
1434 strcat (buf
, ", Version1 EABI");
1439 /* Process flags one bit at a time. */
1440 flag
= e_flags
& - e_flags
;
1445 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1446 strcat (buf
, ", sorted symbol tables");
1456 case EF_ARM_EABI_VER2
:
1457 strcat (buf
, ", Version2 EABI");
1462 /* Process flags one bit at a time. */
1463 flag
= e_flags
& - e_flags
;
1468 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
1469 strcat (buf
, ", sorted symbol tables");
1472 case EF_ARM_DYNSYMSUSESEGIDX
:
1473 strcat (buf
, ", dynamic symbols use segment index");
1476 case EF_ARM_MAPSYMSFIRST
:
1477 strcat (buf
, ", mapping symbols precede others");
1487 case EF_ARM_EABI_UNKNOWN
:
1488 strcat (buf
, ", GNU EABI");
1493 /* Process flags one bit at a time. */
1494 flag
= e_flags
& - e_flags
;
1499 case EF_ARM_INTERWORK
:
1500 strcat (buf
, ", interworking enabled");
1503 case EF_ARM_APCS_26
:
1504 strcat (buf
, ", uses APCS/26");
1507 case EF_ARM_APCS_FLOAT
:
1508 strcat (buf
, ", uses APCS/float");
1512 strcat (buf
, ", position independent");
1516 strcat (buf
, ", 8 bit structure alignment");
1519 case EF_ARM_NEW_ABI
:
1520 strcat (buf
, ", uses new ABI");
1523 case EF_ARM_OLD_ABI
:
1524 strcat (buf
, ", uses old ABI");
1527 case EF_ARM_SOFT_FLOAT
:
1528 strcat (buf
, ", software FP");
1539 strcat (buf
,", <unknown>");
1543 get_machine_flags (e_flags
, e_machine
)
1547 static char buf
[1024];
1559 decode_ARM_machine_flags (e_flags
, buf
);
1563 if (e_flags
& EF_CPU32
)
1564 strcat (buf
, ", cpu32");
1568 if (e_flags
& EF_PPC_EMB
)
1569 strcat (buf
, ", emb");
1571 if (e_flags
& EF_PPC_RELOCATABLE
)
1572 strcat (buf
, ", relocatable");
1574 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
1575 strcat (buf
, ", relocatable-lib");
1579 case EM_CYGNUS_V850
:
1580 switch (e_flags
& EF_V850_ARCH
)
1583 strcat (buf
, ", v850e");
1586 strcat (buf
, ", v850ea");
1589 strcat (buf
, ", v850");
1592 strcat (buf
, ", unknown v850 architecture variant");
1598 case EM_CYGNUS_M32R
:
1599 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
1600 strcat (buf
, ", m32r");
1605 case EM_MIPS_RS3_LE
:
1606 if (e_flags
& EF_MIPS_NOREORDER
)
1607 strcat (buf
, ", noreorder");
1609 if (e_flags
& EF_MIPS_PIC
)
1610 strcat (buf
, ", pic");
1612 if (e_flags
& EF_MIPS_CPIC
)
1613 strcat (buf
, ", cpic");
1615 if (e_flags
& EF_MIPS_UCODE
)
1616 strcat (buf
, ", ugen_reserved");
1618 if (e_flags
& EF_MIPS_ABI2
)
1619 strcat (buf
, ", abi2");
1621 if (e_flags
& EF_MIPS_32BITMODE
)
1622 strcat (buf
, ", 32bitmode");
1624 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_1
)
1625 strcat (buf
, ", mips1");
1627 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_2
)
1628 strcat (buf
, ", mips2");
1630 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_3
)
1631 strcat (buf
, ", mips3");
1633 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_4
)
1634 strcat (buf
, ", mips4");
1636 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_5
)
1637 strcat (buf
, ", mips5");
1639 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_32
)
1640 strcat (buf
, ", mips32");
1642 if ((e_flags
& EF_MIPS_ARCH
) == E_MIPS_ARCH_64
)
1643 strcat (buf
, ", mips64");
1645 switch ((e_flags
& EF_MIPS_MACH
))
1647 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
1648 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
1649 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
1650 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
1651 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
1652 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
1653 default: strcat (buf
, " UNKNOWN"); break;
1658 if (e_flags
& EF_SPARC_32PLUS
)
1659 strcat (buf
, ", v8+");
1661 if (e_flags
& EF_SPARC_SUN_US1
)
1662 strcat (buf
, ", ultrasparcI");
1664 if (e_flags
& EF_SPARC_SUN_US3
)
1665 strcat (buf
, ", ultrasparcIII");
1667 if (e_flags
& EF_SPARC_HAL_R1
)
1668 strcat (buf
, ", halr1");
1670 if (e_flags
& EF_SPARC_LEDATA
)
1671 strcat (buf
, ", ledata");
1673 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
1674 strcat (buf
, ", tso");
1676 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
1677 strcat (buf
, ", pso");
1679 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
1680 strcat (buf
, ", rmo");
1684 switch (e_flags
& EF_PARISC_ARCH
)
1686 case EFA_PARISC_1_0
:
1687 strcpy (buf
, ", PA-RISC 1.0");
1689 case EFA_PARISC_1_1
:
1690 strcpy (buf
, ", PA-RISC 1.1");
1692 case EFA_PARISC_2_0
:
1693 strcpy (buf
, ", PA-RISC 2.0");
1698 if (e_flags
& EF_PARISC_TRAPNIL
)
1699 strcat (buf
, ", trapnil");
1700 if (e_flags
& EF_PARISC_EXT
)
1701 strcat (buf
, ", ext");
1702 if (e_flags
& EF_PARISC_LSB
)
1703 strcat (buf
, ", lsb");
1704 if (e_flags
& EF_PARISC_WIDE
)
1705 strcat (buf
, ", wide");
1706 if (e_flags
& EF_PARISC_NO_KABP
)
1707 strcat (buf
, ", no kabp");
1708 if (e_flags
& EF_PARISC_LAZYSWAP
)
1709 strcat (buf
, ", lazyswap");
1714 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
1715 strcat (buf
, ", new calling convention");
1717 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
1718 strcat (buf
, ", gnu calling convention");
1722 if ((e_flags
& EF_IA_64_ABI64
))
1723 strcat (buf
, ", 64-bit");
1725 strcat (buf
, ", 32-bit");
1726 if ((e_flags
& EF_IA_64_REDUCEDFP
))
1727 strcat (buf
, ", reduced fp model");
1728 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
1729 strcat (buf
, ", no function descriptors, constant gp");
1730 else if ((e_flags
& EF_IA_64_CONS_GP
))
1731 strcat (buf
, ", constant gp");
1732 if ((e_flags
& EF_IA_64_ABSOLUTE
))
1733 strcat (buf
, ", absolute");
1742 get_mips_segment_type (type
)
1747 case PT_MIPS_REGINFO
:
1749 case PT_MIPS_RTPROC
:
1751 case PT_MIPS_OPTIONS
:
1761 get_parisc_segment_type (type
)
1766 case PT_HP_TLS
: return "HP_TLS";
1767 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
1768 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
1769 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
1770 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
1771 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
1772 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
1773 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
1774 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
1775 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
1776 case PT_HP_PARALLEL
: return "HP_PARALLEL";
1777 case PT_HP_FASTBIND
: return "HP_FASTBIND";
1778 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
1779 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
1788 get_ia64_segment_type (type
)
1793 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
1794 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
1803 get_segment_type (p_type
)
1804 unsigned long p_type
;
1806 static char buff
[32];
1810 case PT_NULL
: return "NULL";
1811 case PT_LOAD
: return "LOAD";
1812 case PT_DYNAMIC
: return "DYNAMIC";
1813 case PT_INTERP
: return "INTERP";
1814 case PT_NOTE
: return "NOTE";
1815 case PT_SHLIB
: return "SHLIB";
1816 case PT_PHDR
: return "PHDR";
1819 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
1821 const char * result
;
1823 switch (elf_header
.e_machine
)
1826 case EM_MIPS_RS3_LE
:
1827 result
= get_mips_segment_type (p_type
);
1830 result
= get_parisc_segment_type (p_type
);
1833 result
= get_ia64_segment_type (p_type
);
1843 sprintf (buff
, "LOPROC+%lx", p_type
- PT_LOPROC
);
1845 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
1847 const char * result
;
1849 switch (elf_header
.e_machine
)
1852 result
= get_parisc_segment_type (p_type
);
1862 sprintf (buff
, "LOOS+%lx", p_type
- PT_LOOS
);
1865 sprintf (buff
, _("<unknown>: %lx"), p_type
);
1872 get_mips_section_type_name (sh_type
)
1873 unsigned int sh_type
;
1877 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1878 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
1879 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1880 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
1881 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
1882 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
1883 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
1884 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
1885 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
1886 case SHT_MIPS_RELD
: return "MIPS_RELD";
1887 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
1888 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
1889 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1890 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
1891 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
1892 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
1893 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
1894 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
1895 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
1896 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
1897 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
1898 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
1899 case SHT_MIPS_LINE
: return "MIPS_LINE";
1900 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
1901 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
1902 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
1903 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
1904 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
1905 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
1906 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1907 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
1908 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
1909 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
1910 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
1911 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
1912 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
1913 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
1914 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
1915 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
1923 get_parisc_section_type_name (sh_type
)
1924 unsigned int sh_type
;
1928 case SHT_PARISC_EXT
: return "PARISC_EXT";
1929 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
1930 case SHT_PARISC_DOC
: return "PARISC_DOC";
1938 get_ia64_section_type_name (sh_type
)
1939 unsigned int sh_type
;
1943 case SHT_IA_64_EXT
: return "IA_64_EXT";
1944 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
1952 get_section_type_name (sh_type
)
1953 unsigned int sh_type
;
1955 static char buff
[32];
1959 case SHT_NULL
: return "NULL";
1960 case SHT_PROGBITS
: return "PROGBITS";
1961 case SHT_SYMTAB
: return "SYMTAB";
1962 case SHT_STRTAB
: return "STRTAB";
1963 case SHT_RELA
: return "RELA";
1964 case SHT_HASH
: return "HASH";
1965 case SHT_DYNAMIC
: return "DYNAMIC";
1966 case SHT_NOTE
: return "NOTE";
1967 case SHT_NOBITS
: return "NOBITS";
1968 case SHT_REL
: return "REL";
1969 case SHT_SHLIB
: return "SHLIB";
1970 case SHT_DYNSYM
: return "DYNSYM";
1971 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
1972 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
1973 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
1974 case SHT_GROUP
: return "GROUP";
1975 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
1976 case SHT_GNU_verdef
: return "VERDEF";
1977 case SHT_GNU_verneed
: return "VERNEED";
1978 case SHT_GNU_versym
: return "VERSYM";
1979 case 0x6ffffff0: return "VERSYM";
1980 case 0x6ffffffc: return "VERDEF";
1981 case 0x7ffffffd: return "AUXILIARY";
1982 case 0x7fffffff: return "FILTER";
1985 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
1987 const char * result
;
1989 switch (elf_header
.e_machine
)
1992 case EM_MIPS_RS3_LE
:
1993 result
= get_mips_section_type_name (sh_type
);
1996 result
= get_parisc_section_type_name (sh_type
);
1999 result
= get_ia64_section_type_name (sh_type
);
2009 sprintf (buff
, "LOPROC+%x", sh_type
- SHT_LOPROC
);
2011 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
2012 sprintf (buff
, "LOOS+%x", sh_type
- SHT_LOOS
);
2013 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
2014 sprintf (buff
, "LOUSER+%x", sh_type
- SHT_LOUSER
);
2016 sprintf (buff
, _("<unknown>: %x"), sh_type
);
2022 struct option options
[] =
2024 {"all", no_argument
, 0, 'a'},
2025 {"file-header", no_argument
, 0, 'h'},
2026 {"program-headers", no_argument
, 0, 'l'},
2027 {"headers", no_argument
, 0, 'e'},
2028 {"histogram", no_argument
, 0, 'I'},
2029 {"segments", no_argument
, 0, 'l'},
2030 {"sections", no_argument
, 0, 'S'},
2031 {"section-headers", no_argument
, 0, 'S'},
2032 {"symbols", no_argument
, 0, 's'},
2033 {"syms", no_argument
, 0, 's'},
2034 {"relocs", no_argument
, 0, 'r'},
2035 {"notes", no_argument
, 0, 'n'},
2036 {"dynamic", no_argument
, 0, 'd'},
2037 {"arch-specific", no_argument
, 0, 'A'},
2038 {"version-info", no_argument
, 0, 'V'},
2039 {"use-dynamic", no_argument
, 0, 'D'},
2040 {"hex-dump", required_argument
, 0, 'x'},
2041 {"debug-dump", optional_argument
, 0, 'w'},
2042 {"unwind", no_argument
, 0, 'u'},
2043 #ifdef SUPPORT_DISASSEMBLY
2044 {"instruction-dump", required_argument
, 0, 'i'},
2047 {"version", no_argument
, 0, 'v'},
2048 {"wide", no_argument
, 0, 'W'},
2049 {"help", no_argument
, 0, 'H'},
2050 {0, no_argument
, 0, 0}
2056 fprintf (stdout
, _("Usage: readelf {options} elf-file(s)\n"));
2057 fprintf (stdout
, _(" Options are:\n"));
2058 fprintf (stdout
, _(" -a or --all Equivalent to: -h -l -S -s -r -d -V -A -I\n"));
2059 fprintf (stdout
, _(" -h or --file-header Display the ELF file header\n"));
2060 fprintf (stdout
, _(" -l or --program-headers or --segments\n"));
2061 fprintf (stdout
, _(" Display the program headers\n"));
2062 fprintf (stdout
, _(" -S or --section-headers or --sections\n"));
2063 fprintf (stdout
, _(" Display the sections' header\n"));
2064 fprintf (stdout
, _(" -e or --headers Equivalent to: -h -l -S\n"));
2065 fprintf (stdout
, _(" -s or --syms or --symbols Display the symbol table\n"));
2066 fprintf (stdout
, _(" -n or --notes Display the core notes (if present)\n"));
2067 fprintf (stdout
, _(" -r or --relocs Display the relocations (if present)\n"));
2068 fprintf (stdout
, _(" -u or --unwind Display the unwind info (if present)\n"));
2069 fprintf (stdout
, _(" -d or --dynamic Display the dynamic segment (if present)\n"));
2070 fprintf (stdout
, _(" -V or --version-info Display the version sections (if present)\n"));
2071 fprintf (stdout
, _(" -A or --arch-specific Display architecture specific information (if any).\n"));
2072 fprintf (stdout
, _(" -D or --use-dynamic Use the dynamic section info when displaying symbols\n"));
2073 fprintf (stdout
, _(" -x <number> or --hex-dump=<number>\n"));
2074 fprintf (stdout
, _(" Dump the contents of section <number>\n"));
2075 fprintf (stdout
, _(" -w[liaprmf] or --debug-dump[=line,=info,=abbrev,=pubnames,=ranges,=macro,=frames]\n"));
2076 fprintf (stdout
, _(" Display the contents of DWARF2 debug sections\n"));
2077 #ifdef SUPPORT_DISASSEMBLY
2078 fprintf (stdout
, _(" -i <number> or --instruction-dump=<number>\n"));
2079 fprintf (stdout
, _(" Disassemble the contents of section <number>\n"));
2081 fprintf (stdout
, _(" -I or --histogram Display histogram of bucket list lengths\n"));
2082 fprintf (stdout
, _(" -v or --version Display the version number of readelf\n"));
2083 fprintf (stdout
, _(" -W or --wide Don't split lines to fit into 80 columns\n"));
2084 fprintf (stdout
, _(" -H or --help Display this information\n"));
2085 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
2091 request_dump (section
, type
)
2092 unsigned int section
;
2095 if (section
>= num_dump_sects
)
2097 char * new_dump_sects
;
2099 new_dump_sects
= (char *) calloc (section
+ 1, 1);
2101 if (new_dump_sects
== NULL
)
2102 error (_("Out of memory allocating dump request table."));
2105 /* Copy current flag settings. */
2106 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
);
2110 dump_sects
= new_dump_sects
;
2111 num_dump_sects
= section
+ 1;
2116 dump_sects
[section
] |= type
;
2122 parse_args (argc
, argv
)
2131 while ((c
= getopt_long
2132 (argc
, argv
, "ersuahnldSDAIw::x:i:vVW", options
, NULL
)) != EOF
)
2168 do_using_dynamic
++;
2199 section
= strtoul (optarg
, & cp
, 0);
2200 if (! * cp
&& section
>= 0)
2202 request_dump (section
, HEX_DUMP
);
2212 unsigned int index
= 0;
2216 while (optarg
[index
])
2217 switch (optarg
[index
++])
2226 do_debug_abbrevs
= 1;
2236 do_debug_pubnames
= 1;
2241 do_debug_aranges
= 1;
2245 do_debug_frames_interp
= 1;
2247 do_debug_frames
= 1;
2252 do_debug_macinfo
= 1;
2256 warn (_("Unrecognised debug option '%s'\n"), optarg
);
2261 #ifdef SUPPORT_DISASSEMBLY
2264 section
= strtoul (optarg
, & cp
, 0);
2265 if (! * cp
&& section
>= 0)
2267 request_dump (section
, DISASS_DUMP
);
2273 print_version (program_name
);
2283 /* xgettext:c-format */
2284 error (_("Invalid option '-%c'\n"), c
);
2291 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
2292 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
2293 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
)
2297 warn (_("Nothing to do.\n"));
2303 get_elf_class (elf_class
)
2304 unsigned int elf_class
;
2306 static char buff
[32];
2310 case ELFCLASSNONE
: return _("none");
2311 case ELFCLASS32
: return _("ELF32");
2312 case ELFCLASS64
: return _("ELF64");
2314 sprintf (buff
, _("<unknown: %x>"), elf_class
);
2320 get_data_encoding (encoding
)
2321 unsigned int encoding
;
2323 static char buff
[32];
2327 case ELFDATANONE
: return _("none");
2328 case ELFDATA2LSB
: return _("2's complement, little endian");
2329 case ELFDATA2MSB
: return _("2's complement, big endian");
2331 sprintf (buff
, _("<unknown: %x>"), encoding
);
2337 get_osabi_name (osabi
)
2340 static char buff
[32];
2344 case ELFOSABI_NONE
: return _("UNIX - System V");
2345 case ELFOSABI_HPUX
: return _("UNIX - HP-UX");
2346 case ELFOSABI_NETBSD
: return _("UNIX - NetBSD");
2347 case ELFOSABI_LINUX
: return _("UNIX - Linux");
2348 case ELFOSABI_HURD
: return _("GNU/Hurd");
2349 case ELFOSABI_SOLARIS
: return _("UNIX - Solaris");
2350 case ELFOSABI_AIX
: return _("UNIX - AIX");
2351 case ELFOSABI_IRIX
: return _("UNIX - IRIX");
2352 case ELFOSABI_FREEBSD
: return _("UNIX - FreeBSD");
2353 case ELFOSABI_TRU64
: return _("UNIX - TRU64");
2354 case ELFOSABI_MODESTO
: return _("Novell - Modesto");
2355 case ELFOSABI_OPENBSD
: return _("UNIX - OpenBSD");
2356 case ELFOSABI_STANDALONE
: return _("Standalone App");
2357 case ELFOSABI_ARM
: return _("ARM");
2359 sprintf (buff
, _("<unknown: %x>"), osabi
);
2364 /* Decode the data held in 'elf_header'. */
2366 process_file_header ()
2368 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
2369 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
2370 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
2371 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
2374 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
2382 printf (_("ELF Header:\n"));
2383 printf (_(" Magic: "));
2384 for (i
= 0; i
< EI_NIDENT
; i
++)
2385 printf ("%2.2x ", elf_header
.e_ident
[i
]);
2387 printf (_(" Class: %s\n"),
2388 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
2389 printf (_(" Data: %s\n"),
2390 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
2391 printf (_(" Version: %d %s\n"),
2392 elf_header
.e_ident
[EI_VERSION
],
2393 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
2395 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
2398 printf (_(" OS/ABI: %s\n"),
2399 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
2400 printf (_(" ABI Version: %d\n"),
2401 elf_header
.e_ident
[EI_ABIVERSION
]);
2402 printf (_(" Type: %s\n"),
2403 get_file_type (elf_header
.e_type
));
2404 printf (_(" Machine: %s\n"),
2405 get_machine_name (elf_header
.e_machine
));
2406 printf (_(" Version: 0x%lx\n"),
2407 (unsigned long) elf_header
.e_version
);
2409 printf (_(" Entry point address: "));
2410 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2411 printf (_("\n Start of program headers: "));
2412 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2413 printf (_(" (bytes into file)\n Start of section headers: "));
2414 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
2415 printf (_(" (bytes into file)\n"));
2417 printf (_(" Flags: 0x%lx%s\n"),
2418 (unsigned long) elf_header
.e_flags
,
2419 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
2420 printf (_(" Size of this header: %ld (bytes)\n"),
2421 (long) elf_header
.e_ehsize
);
2422 printf (_(" Size of program headers: %ld (bytes)\n"),
2423 (long) elf_header
.e_phentsize
);
2424 printf (_(" Number of program headers: %ld\n"),
2425 (long) elf_header
.e_phnum
);
2426 printf (_(" Size of section headers: %ld (bytes)\n"),
2427 (long) elf_header
.e_shentsize
);
2428 printf (_(" Number of section headers: %ld\n"),
2429 (long) elf_header
.e_shnum
);
2430 printf (_(" Section header string table index: %ld\n"),
2431 (long) elf_header
.e_shstrndx
);
2439 get_32bit_program_headers (file
, program_headers
)
2441 Elf_Internal_Phdr
* program_headers
;
2443 Elf32_External_Phdr
* phdrs
;
2444 Elf32_External_Phdr
* external
;
2445 Elf32_Internal_Phdr
* internal
;
2448 phdrs
= ((Elf32_External_Phdr
*)
2449 get_data (NULL
, file
, elf_header
.e_phoff
,
2450 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2451 _("program headers")));
2455 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2456 i
< elf_header
.e_phnum
;
2457 i
++, internal
++, external
++)
2459 internal
->p_type
= BYTE_GET (external
->p_type
);
2460 internal
->p_offset
= BYTE_GET (external
->p_offset
);
2461 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
2462 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
2463 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
2464 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
2465 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2466 internal
->p_align
= BYTE_GET (external
->p_align
);
2475 get_64bit_program_headers (file
, program_headers
)
2477 Elf_Internal_Phdr
* program_headers
;
2479 Elf64_External_Phdr
* phdrs
;
2480 Elf64_External_Phdr
* external
;
2481 Elf64_Internal_Phdr
* internal
;
2484 phdrs
= ((Elf64_External_Phdr
*)
2485 get_data (NULL
, file
, elf_header
.e_phoff
,
2486 elf_header
.e_phentsize
* elf_header
.e_phnum
,
2487 _("program headers")));
2491 for (i
= 0, internal
= program_headers
, external
= phdrs
;
2492 i
< elf_header
.e_phnum
;
2493 i
++, internal
++, external
++)
2495 internal
->p_type
= BYTE_GET (external
->p_type
);
2496 internal
->p_flags
= BYTE_GET (external
->p_flags
);
2497 internal
->p_offset
= BYTE_GET8 (external
->p_offset
);
2498 internal
->p_vaddr
= BYTE_GET8 (external
->p_vaddr
);
2499 internal
->p_paddr
= BYTE_GET8 (external
->p_paddr
);
2500 internal
->p_filesz
= BYTE_GET8 (external
->p_filesz
);
2501 internal
->p_memsz
= BYTE_GET8 (external
->p_memsz
);
2502 internal
->p_align
= BYTE_GET8 (external
->p_align
);
2511 process_program_headers (file
)
2514 Elf_Internal_Phdr
* program_headers
;
2515 Elf_Internal_Phdr
* segment
;
2518 if (elf_header
.e_phnum
== 0)
2521 printf (_("\nThere are no program headers in this file.\n"));
2525 if (do_segments
&& !do_header
)
2527 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
2528 printf (_("Entry point "));
2529 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
2530 printf (_("\nThere are %d program headers, starting at offset "),
2531 elf_header
.e_phnum
);
2532 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
2536 program_headers
= (Elf_Internal_Phdr
*) malloc
2537 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
2539 if (program_headers
== NULL
)
2541 error (_("Out of memory\n"));
2546 i
= get_32bit_program_headers (file
, program_headers
);
2548 i
= get_64bit_program_headers (file
, program_headers
);
2552 free (program_headers
);
2559 (_("\nProgram Header%s:\n"), elf_header
.e_phnum
> 1 ? "s" : "");
2563 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2566 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
2570 (_(" Type Offset VirtAddr PhysAddr\n"));
2572 (_(" FileSiz MemSiz Flags Align\n"));
2580 for (i
= 0, segment
= program_headers
;
2581 i
< elf_header
.e_phnum
;
2586 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
2590 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2591 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
2592 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
2593 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
2594 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
2596 (segment
->p_flags
& PF_R
? 'R' : ' '),
2597 (segment
->p_flags
& PF_W
? 'W' : ' '),
2598 (segment
->p_flags
& PF_X
? 'E' : ' '));
2599 printf ("%#lx", (unsigned long) segment
->p_align
);
2603 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
2604 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
2607 print_vma (segment
->p_offset
, FULL_HEX
);
2611 print_vma (segment
->p_vaddr
, FULL_HEX
);
2613 print_vma (segment
->p_paddr
, FULL_HEX
);
2616 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
2617 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
2620 print_vma (segment
->p_filesz
, FULL_HEX
);
2624 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
2625 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
2628 print_vma (segment
->p_offset
, FULL_HEX
);
2632 (segment
->p_flags
& PF_R
? 'R' : ' '),
2633 (segment
->p_flags
& PF_W
? 'W' : ' '),
2634 (segment
->p_flags
& PF_X
? 'E' : ' '));
2636 if ((unsigned long) segment
->p_align
== segment
->p_align
)
2637 printf ("%#lx", (unsigned long) segment
->p_align
);
2640 print_vma (segment
->p_align
, PREFIX_HEX
);
2645 print_vma (segment
->p_offset
, FULL_HEX
);
2647 print_vma (segment
->p_vaddr
, FULL_HEX
);
2649 print_vma (segment
->p_paddr
, FULL_HEX
);
2651 print_vma (segment
->p_filesz
, FULL_HEX
);
2653 print_vma (segment
->p_memsz
, FULL_HEX
);
2655 (segment
->p_flags
& PF_R
? 'R' : ' '),
2656 (segment
->p_flags
& PF_W
? 'W' : ' '),
2657 (segment
->p_flags
& PF_X
? 'E' : ' '));
2658 print_vma (segment
->p_align
, HEX
);
2662 switch (segment
->p_type
)
2666 loadaddr
= (segment
->p_vaddr
& 0xfffff000)
2667 - (segment
->p_offset
& 0xfffff000);
2672 error (_("more than one dynamic segment\n"));
2674 dynamic_addr
= segment
->p_offset
;
2675 dynamic_size
= segment
->p_filesz
;
2679 if (fseek (file
, (long) segment
->p_offset
, SEEK_SET
))
2680 error (_("Unable to find program interpreter name\n"));
2683 program_interpreter
[0] = 0;
2684 fscanf (file
, "%63s", program_interpreter
);
2687 printf (_("\n [Requesting program interpreter: %s]"),
2688 program_interpreter
);
2694 putc ('\n', stdout
);
2703 if (do_segments
&& section_headers
!= NULL
)
2705 printf (_("\n Section to Segment mapping:\n"));
2706 printf (_(" Segment Sections...\n"));
2708 assert (string_table
!= NULL
);
2710 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
2713 Elf_Internal_Shdr
* section
;
2715 segment
= program_headers
+ i
;
2716 section
= section_headers
;
2718 printf (" %2.2d ", i
);
2720 for (j
= 0; j
< elf_header
.e_shnum
; j
++, section
++)
2722 if (section
->sh_size
> 0
2723 /* Compare allocated sections by VMA, unallocated
2724 sections by file offset. */
2725 && (section
->sh_flags
& SHF_ALLOC
2726 ? (section
->sh_addr
>= segment
->p_vaddr
2727 && section
->sh_addr
+ section
->sh_size
2728 <= segment
->p_vaddr
+ segment
->p_memsz
)
2729 : ((bfd_vma
) section
->sh_offset
>= segment
->p_offset
2730 && (section
->sh_offset
+ section
->sh_size
2731 <= segment
->p_offset
+ segment
->p_filesz
))))
2732 printf ("%s ", SECTION_NAME (section
));
2739 free (program_headers
);
2746 get_32bit_section_headers (file
)
2749 Elf32_External_Shdr
* shdrs
;
2750 Elf32_Internal_Shdr
* internal
;
2753 shdrs
= ((Elf32_External_Shdr
*)
2754 get_data (NULL
, file
, elf_header
.e_shoff
,
2755 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2756 _("section headers")));
2760 section_headers
= (Elf_Internal_Shdr
*) malloc
2761 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2763 if (section_headers
== NULL
)
2765 error (_("Out of memory\n"));
2769 for (i
= 0, internal
= section_headers
;
2770 i
< elf_header
.e_shnum
;
2773 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2774 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2775 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
2776 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
2777 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2778 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
2779 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2780 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2781 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2782 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
2791 get_64bit_section_headers (file
)
2794 Elf64_External_Shdr
* shdrs
;
2795 Elf64_Internal_Shdr
* internal
;
2798 shdrs
= ((Elf64_External_Shdr
*)
2799 get_data (NULL
, file
, elf_header
.e_shoff
,
2800 elf_header
.e_shentsize
* elf_header
.e_shnum
,
2801 _("section headers")));
2805 section_headers
= (Elf_Internal_Shdr
*) malloc
2806 (elf_header
.e_shnum
* sizeof (Elf_Internal_Shdr
));
2808 if (section_headers
== NULL
)
2810 error (_("Out of memory\n"));
2814 for (i
= 0, internal
= section_headers
;
2815 i
< elf_header
.e_shnum
;
2818 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
2819 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
2820 internal
->sh_flags
= BYTE_GET8 (shdrs
[i
].sh_flags
);
2821 internal
->sh_addr
= BYTE_GET8 (shdrs
[i
].sh_addr
);
2822 internal
->sh_size
= BYTE_GET8 (shdrs
[i
].sh_size
);
2823 internal
->sh_entsize
= BYTE_GET8 (shdrs
[i
].sh_entsize
);
2824 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
2825 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
2826 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
2827 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
2835 static Elf_Internal_Sym
*
2836 get_32bit_elf_symbols (file
, offset
, number
)
2838 unsigned long offset
;
2839 unsigned long number
;
2841 Elf32_External_Sym
* esyms
;
2842 Elf_Internal_Sym
* isyms
;
2843 Elf_Internal_Sym
* psym
;
2846 esyms
= ((Elf32_External_Sym
*)
2847 get_data (NULL
, file
, offset
,
2848 number
* sizeof (Elf32_External_Sym
), _("symbols")));
2852 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2856 error (_("Out of memory\n"));
2862 for (j
= 0, psym
= isyms
;
2866 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2867 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
2868 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
2869 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2870 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2871 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2879 static Elf_Internal_Sym
*
2880 get_64bit_elf_symbols (file
, offset
, number
)
2882 unsigned long offset
;
2883 unsigned long number
;
2885 Elf64_External_Sym
* esyms
;
2886 Elf_Internal_Sym
* isyms
;
2887 Elf_Internal_Sym
* psym
;
2890 esyms
= ((Elf64_External_Sym
*)
2891 get_data (NULL
, file
, offset
,
2892 number
* sizeof (Elf64_External_Sym
), _("symbols")));
2896 isyms
= (Elf_Internal_Sym
*) malloc (number
* sizeof (Elf_Internal_Sym
));
2900 error (_("Out of memory\n"));
2906 for (j
= 0, psym
= isyms
;
2910 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
2911 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
2912 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
2913 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
2914 psym
->st_value
= BYTE_GET8 (esyms
[j
].st_value
);
2915 psym
->st_size
= BYTE_GET8 (esyms
[j
].st_size
);
2924 get_elf_section_flags (sh_flags
)
2927 static char buff
[32];
2935 flag
= sh_flags
& - sh_flags
;
2940 case SHF_WRITE
: strcat (buff
, "W"); break;
2941 case SHF_ALLOC
: strcat (buff
, "A"); break;
2942 case SHF_EXECINSTR
: strcat (buff
, "X"); break;
2943 case SHF_MERGE
: strcat (buff
, "M"); break;
2944 case SHF_STRINGS
: strcat (buff
, "S"); break;
2945 case SHF_INFO_LINK
: strcat (buff
, "I"); break;
2946 case SHF_LINK_ORDER
: strcat (buff
, "L"); break;
2947 case SHF_OS_NONCONFORMING
: strcat (buff
, "O"); break;
2948 case SHF_GROUP
: strcat (buff
, "G"); break;
2951 if (flag
& SHF_MASKOS
)
2954 sh_flags
&= ~ SHF_MASKOS
;
2956 else if (flag
& SHF_MASKPROC
)
2959 sh_flags
&= ~ SHF_MASKPROC
;
2971 process_section_headers (file
)
2974 Elf_Internal_Shdr
* section
;
2977 section_headers
= NULL
;
2979 if (elf_header
.e_shnum
== 0)
2982 printf (_("\nThere are no sections in this file.\n"));
2987 if (do_sections
&& !do_header
)
2988 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
2989 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
2993 if (! get_32bit_section_headers (file
))
2996 else if (! get_64bit_section_headers (file
))
2999 /* Read in the string table, so that we have names to display. */
3000 section
= section_headers
+ elf_header
.e_shstrndx
;
3002 if (section
->sh_size
!= 0)
3004 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3005 section
->sh_size
, _("string table"));
3007 string_table_length
= section
->sh_size
;
3010 /* Scan the sections for the dynamic symbol table
3011 and dynamic string table and debug sections. */
3012 dynamic_symbols
= NULL
;
3013 dynamic_strings
= NULL
;
3014 dynamic_syminfo
= NULL
;
3016 for (i
= 0, section
= section_headers
;
3017 i
< elf_header
.e_shnum
;
3020 char * name
= SECTION_NAME (section
);
3022 if (section
->sh_type
== SHT_DYNSYM
)
3024 if (dynamic_symbols
!= NULL
)
3026 error (_("File contains multiple dynamic symbol tables\n"));
3030 num_dynamic_syms
= section
->sh_size
/ section
->sh_entsize
;
3032 GET_ELF_SYMBOLS (file
, section
->sh_offset
, num_dynamic_syms
);
3034 else if (section
->sh_type
== SHT_STRTAB
3035 && strcmp (name
, ".dynstr") == 0)
3037 if (dynamic_strings
!= NULL
)
3039 error (_("File contains multiple dynamic string tables\n"));
3043 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
3045 _("dynamic strings"));
3047 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
3048 || do_debug_lines
|| do_debug_pubnames
|| do_debug_aranges
3049 || do_debug_frames
|| do_debug_macinfo
)
3050 && strncmp (name
, ".debug_", 7) == 0)
3055 || (do_debug_info
&& (strcmp (name
, "info") == 0))
3056 || (do_debug_abbrevs
&& (strcmp (name
, "abbrev") == 0))
3057 || (do_debug_lines
&& (strcmp (name
, "line") == 0))
3058 || (do_debug_pubnames
&& (strcmp (name
, "pubnames") == 0))
3059 || (do_debug_aranges
&& (strcmp (name
, "aranges") == 0))
3060 || (do_debug_frames
&& (strcmp (name
, "frame") == 0))
3061 || (do_debug_macinfo
&& (strcmp (name
, "macinfo") == 0))
3063 request_dump (i
, DEBUG_DUMP
);
3065 /* linkonce section to be combined with .debug_info at link time. */
3066 else if ((do_debugging
|| do_debug_info
)
3067 && strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
3068 request_dump (i
, DEBUG_DUMP
);
3069 else if (do_debug_frames
&& strcmp (name
, ".eh_frame") == 0)
3070 request_dump (i
, DEBUG_DUMP
);
3076 printf (_("\nSection Header%s:\n"), elf_header
.e_shnum
> 1 ? "s" : "");
3080 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
3083 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
3086 printf (_(" [Nr] Name Type Address Offset\n"));
3087 printf (_(" Size EntSize Flags Link Info Align\n"));
3090 for (i
= 0, section
= section_headers
;
3091 i
< elf_header
.e_shnum
;
3094 printf (" [%2d] %-17.17s %-15.15s ",
3096 SECTION_NAME (section
),
3097 get_section_type_name (section
->sh_type
));
3101 print_vma (section
->sh_addr
, LONG_HEX
);
3103 printf ( " %6.6lx %6.6lx %2.2lx",
3104 (unsigned long) section
->sh_offset
,
3105 (unsigned long) section
->sh_size
,
3106 (unsigned long) section
->sh_entsize
);
3108 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3110 printf ("%2ld %3lx %2ld\n",
3111 (unsigned long) section
->sh_link
,
3112 (unsigned long) section
->sh_info
,
3113 (unsigned long) section
->sh_addralign
);
3117 print_vma (section
->sh_addr
, LONG_HEX
);
3119 if ((long) section
->sh_offset
== section
->sh_offset
)
3120 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
3124 print_vma (section
->sh_offset
, LONG_HEX
);
3127 if ((unsigned long) section
->sh_size
== section
->sh_size
)
3128 printf (" %6.6lx", (unsigned long) section
->sh_size
);
3132 print_vma (section
->sh_size
, LONG_HEX
);
3135 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
3136 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
3140 print_vma (section
->sh_entsize
, LONG_HEX
);
3143 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3145 printf ("%2ld %3lx ",
3146 (unsigned long) section
->sh_link
,
3147 (unsigned long) section
->sh_info
);
3149 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
3150 printf ("%2ld\n", (unsigned long) section
->sh_addralign
);
3153 print_vma (section
->sh_addralign
, DEC
);
3160 print_vma (section
->sh_addr
, LONG_HEX
);
3161 if ((long) section
->sh_offset
== section
->sh_offset
)
3162 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
3166 print_vma (section
->sh_offset
, LONG_HEX
);
3169 print_vma (section
->sh_size
, LONG_HEX
);
3171 print_vma (section
->sh_entsize
, LONG_HEX
);
3173 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
3175 printf (" %2ld %3lx %ld\n",
3176 (unsigned long) section
->sh_link
,
3177 (unsigned long) section
->sh_info
,
3178 (unsigned long) section
->sh_addralign
);
3182 printf (_("Key to Flags:\n"));
3183 printf (_(" W (write), A (alloc), X (execute), M (merge), S (strings)\n"));
3184 printf (_(" I (info), L (link order), G (group), x (unknown)\n"));
3185 printf (_(" O (extra OS processing required) o (OS specific), p (processor specific)\n"));
3190 /* Process the reloc section. */
3192 process_relocs (file
)
3195 unsigned long rel_size
;
3196 unsigned long rel_offset
;
3202 if (do_using_dynamic
)
3204 int is_rela
= FALSE
;
3209 if (dynamic_info
[DT_REL
])
3211 rel_offset
= dynamic_info
[DT_REL
];
3212 rel_size
= dynamic_info
[DT_RELSZ
];
3215 else if (dynamic_info
[DT_RELA
])
3217 rel_offset
= dynamic_info
[DT_RELA
];
3218 rel_size
= dynamic_info
[DT_RELASZ
];
3221 else if (dynamic_info
[DT_JMPREL
])
3223 rel_offset
= dynamic_info
[DT_JMPREL
];
3224 rel_size
= dynamic_info
[DT_PLTRELSZ
];
3226 switch (dynamic_info
[DT_PLTREL
])
3243 (_("\nRelocation section at offset 0x%lx contains %ld bytes:\n"),
3244 rel_offset
, rel_size
);
3246 dump_relocations (file
, rel_offset
- loadaddr
, rel_size
,
3247 dynamic_symbols
, num_dynamic_syms
, dynamic_strings
, is_rela
);
3250 printf (_("\nThere are no dynamic relocations in this file.\n"));
3254 Elf32_Internal_Shdr
* section
;
3258 for (i
= 0, section
= section_headers
;
3259 i
< elf_header
.e_shnum
;
3262 if ( section
->sh_type
!= SHT_RELA
3263 && section
->sh_type
!= SHT_REL
)
3266 rel_offset
= section
->sh_offset
;
3267 rel_size
= section
->sh_size
;
3271 Elf32_Internal_Shdr
* strsec
;
3272 Elf_Internal_Sym
* symtab
;
3275 unsigned long nsyms
;
3277 printf (_("\nRelocation section "));
3279 if (string_table
== NULL
)
3280 printf ("%d", section
->sh_name
);
3282 printf ("'%s'", SECTION_NAME (section
));
3284 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3285 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
3290 if (section
->sh_link
)
3292 Elf32_Internal_Shdr
* symsec
;
3294 symsec
= section_headers
+ section
->sh_link
;
3295 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
3296 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
3301 strsec
= section_headers
+ symsec
->sh_link
;
3303 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3307 is_rela
= section
->sh_type
== SHT_RELA
;
3309 dump_relocations (file
, rel_offset
, rel_size
,
3310 symtab
, nsyms
, strtab
, is_rela
);
3322 printf (_("\nThere are no relocations in this file.\n"));
3328 #include "unwind-ia64.h"
3330 /* An absolute address consists of a section and an offset. If the
3331 section is NULL, the offset itself is the address, otherwise, the
3332 address equals to LOAD_ADDRESS(section) + offset. */
3336 unsigned short section
;
3342 struct unw_table_entry
3344 struct absaddr start
;
3346 struct absaddr info
;
3348 *table
; /* Unwind table. */
3349 unsigned long table_len
; /* Length of unwind table. */
3350 unsigned char * info
; /* Unwind info. */
3351 unsigned long info_size
; /* Size of unwind info. */
3352 bfd_vma info_addr
; /* starting address of unwind info. */
3353 bfd_vma seg_base
; /* Starting address of segment. */
3354 Elf_Internal_Sym
* symtab
; /* The symbol table. */
3355 unsigned long nsyms
; /* Number of symbols. */
3356 char * strtab
; /* The string table. */
3357 unsigned long strtab_size
; /* Size of string table. */
3360 static void find_symbol_for_address
PARAMS ((struct unw_aux_info
*,
3361 struct absaddr
, const char **,
3363 static void dump_ia64_unwind
PARAMS ((struct unw_aux_info
*));
3364 static int slurp_ia64_unwind_table
PARAMS ((FILE *, struct unw_aux_info
*,
3365 Elf32_Internal_Shdr
*));
3368 find_symbol_for_address (aux
, addr
, symname
, offset
)
3369 struct unw_aux_info
*aux
;
3370 struct absaddr addr
;
3371 const char **symname
;
3374 bfd_vma dist
= (bfd_vma
) 0x100000;
3375 Elf_Internal_Sym
*sym
, *best
= NULL
;
3378 for (i
= 0, sym
= aux
->symtab
; i
< aux
->nsyms
; ++i
, ++sym
)
3380 if (ELF_ST_TYPE (sym
->st_info
) == STT_FUNC
3381 && sym
->st_name
!= 0
3382 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
3383 && addr
.offset
>= sym
->st_value
3384 && addr
.offset
- sym
->st_value
< dist
)
3387 dist
= addr
.offset
- sym
->st_value
;
3394 *symname
= (best
->st_name
>= aux
->strtab_size
3395 ? "<corrupt>" : aux
->strtab
+ best
->st_name
);
3400 *offset
= addr
.offset
;
3404 dump_ia64_unwind (aux
)
3405 struct unw_aux_info
*aux
;
3408 struct unw_table_entry
* tp
;
3411 addr_size
= is_32bit_elf
? 4 : 8;
3413 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
3417 const unsigned char * dp
;
3418 const unsigned char * head
;
3419 const char * procname
;
3421 find_symbol_for_address (aux
, tp
->start
, &procname
, &offset
);
3423 fputs ("\n<", stdout
);
3427 fputs (procname
, stdout
);
3430 printf ("+%lx", (unsigned long) offset
);
3433 fputs (">: [", stdout
);
3434 print_vma (tp
->start
.offset
, PREFIX_HEX
);
3435 fputc ('-', stdout
);
3436 print_vma (tp
->end
.offset
, PREFIX_HEX
);
3437 printf ("), info at +0x%lx\n",
3438 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
3440 head
= aux
->info
+ (tp
->info
.offset
- aux
->info_addr
);
3441 stamp
= BYTE_GET8 ((unsigned char *) head
);
3443 printf (" v%u, flags=0x%lx (%s%s ), len=%lu bytes\n",
3444 (unsigned) UNW_VER (stamp
),
3445 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
3446 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
3447 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
3448 (unsigned long) (addr_size
* UNW_LENGTH (stamp
)));
3450 if (UNW_VER (stamp
) != 1)
3452 printf ("\tUnknown version.\n");
3457 for (dp
= head
+ 8; dp
< head
+ 8 + addr_size
* UNW_LENGTH (stamp
);)
3458 dp
= unw_decode (dp
, in_body
, & in_body
);
3463 slurp_ia64_unwind_table (file
, aux
, sec
)
3465 struct unw_aux_info
*aux
;
3466 Elf32_Internal_Shdr
*sec
;
3468 unsigned long size
, addr_size
, nrelas
, i
;
3469 Elf_Internal_Phdr
*prog_hdrs
, *seg
;
3470 struct unw_table_entry
*tep
;
3471 Elf32_Internal_Shdr
*relsec
;
3472 Elf_Internal_Rela
*rela
, *rp
;
3473 unsigned char *table
, *tp
;
3474 Elf_Internal_Sym
*sym
;
3475 const char *relname
;
3478 addr_size
= is_32bit_elf
? 4 : 8;
3480 /* First, find the starting address of the segment that includes
3483 if (elf_header
.e_phnum
)
3485 prog_hdrs
= (Elf_Internal_Phdr
*)
3486 xmalloc (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
3489 result
= get_32bit_program_headers (file
, prog_hdrs
);
3491 result
= get_64bit_program_headers (file
, prog_hdrs
);
3499 for (seg
= prog_hdrs
; seg
< prog_hdrs
+ elf_header
.e_phnum
; ++seg
)
3501 if (seg
->p_type
!= PT_LOAD
)
3504 if (sec
->sh_addr
>= seg
->p_vaddr
3505 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
3507 aux
->seg_base
= seg
->p_vaddr
;
3515 /* Second, build the unwind table from the contents of the unwind section: */
3516 size
= sec
->sh_size
;
3517 table
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3518 size
, _("unwind table"));
3522 tep
= aux
->table
= xmalloc (size
/ (3 * addr_size
) * sizeof (aux
->table
[0]));
3523 for (tp
= table
; tp
< table
+ size
; tp
+= 3 * addr_size
, ++ tep
)
3525 tep
->start
.section
= SHN_UNDEF
;
3526 tep
->end
.section
= SHN_UNDEF
;
3527 tep
->info
.section
= SHN_UNDEF
;
3530 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
3531 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
3532 tep
->info
.offset
= byte_get ((unsigned char *) tp
+ 8, 4);
3536 tep
->start
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 0);
3537 tep
->end
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 8);
3538 tep
->info
.offset
= BYTE_GET8 ((unsigned char *) tp
+ 16);
3540 tep
->start
.offset
+= aux
->seg_base
;
3541 tep
->end
.offset
+= aux
->seg_base
;
3542 tep
->info
.offset
+= aux
->seg_base
;
3546 /* Third, apply any relocations to the unwind table: */
3548 for (relsec
= section_headers
;
3549 relsec
< section_headers
+ elf_header
.e_shnum
;
3552 if (relsec
->sh_type
!= SHT_RELA
3553 || section_headers
+ relsec
->sh_info
!= sec
)
3556 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
3560 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
3564 relname
= elf_ia64_reloc_type (ELF32_R_TYPE (rp
->r_info
));
3565 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
3567 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3569 warn (_("Skipping unexpected symbol type %u\n"),
3570 ELF32_ST_TYPE (sym
->st_info
));
3576 relname
= elf_ia64_reloc_type (ELF64_R_TYPE (rp
->r_info
));
3577 sym
= aux
->symtab
+ ELF64_R_SYM (rp
->r_info
);
3579 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3581 warn (_("Skipping unexpected symbol type %u\n"),
3582 ELF64_ST_TYPE (sym
->st_info
));
3587 if (strncmp (relname
, "R_IA64_SEGREL", 13) != 0)
3589 warn (_("Skipping unexpected relocation type %s\n"), relname
);
3593 i
= rp
->r_offset
/ (3 * addr_size
);
3595 switch (rp
->r_offset
/addr_size
% 3)
3598 aux
->table
[i
].start
.section
= sym
->st_shndx
;
3599 aux
->table
[i
].start
.offset
+= rp
->r_addend
;
3602 aux
->table
[i
].end
.section
= sym
->st_shndx
;
3603 aux
->table
[i
].end
.offset
+= rp
->r_addend
;
3606 aux
->table
[i
].info
.section
= sym
->st_shndx
;
3607 aux
->table
[i
].info
.offset
+= rp
->r_addend
;
3617 aux
->table_len
= size
/ (3 * addr_size
);
3622 process_unwind (file
)
3625 Elf32_Internal_Shdr
*sec
, *unwsec
= NULL
, *strsec
;
3626 unsigned long i
, addr_size
, unwcount
= 0, unwstart
= 0;
3627 struct unw_aux_info aux
;
3632 if (elf_header
.e_machine
!= EM_IA_64
)
3634 printf (_("\nThere are no unwind sections in this file.\n"));
3638 memset (& aux
, 0, sizeof (aux
));
3640 addr_size
= is_32bit_elf
? 4 : 8;
3642 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
3644 if (sec
->sh_type
== SHT_SYMTAB
)
3646 aux
.nsyms
= sec
->sh_size
/ sec
->sh_entsize
;
3647 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
->sh_offset
, aux
.nsyms
);
3649 strsec
= section_headers
+ sec
->sh_link
;
3650 aux
.strtab_size
= strsec
->sh_size
;
3651 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
3652 aux
.strtab_size
, _("string table"));
3654 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3659 printf (_("\nThere are no unwind sections in this file.\n"));
3661 while (unwcount
-- > 0)
3666 for (i
= unwstart
, sec
= section_headers
+ unwstart
;
3667 i
< elf_header
.e_shnum
; ++i
, ++sec
)
3668 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
3675 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
3677 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
,
3680 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO */
3681 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
3682 suffix
= SECTION_NAME (unwsec
) + len
;
3683 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3685 if (strncmp (SECTION_NAME (sec
),
3686 ELF_STRING_ia64_unwind_info_once
, len2
) == 0
3687 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3692 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
3693 .IA_64.unwind or BAR -> .IA_64.unwind_info */
3694 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
3695 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
3697 if (strncmp (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
,
3699 suffix
= SECTION_NAME (unwsec
) + len
;
3700 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
3702 if (strncmp (SECTION_NAME (sec
),
3703 ELF_STRING_ia64_unwind_info
, len2
) == 0
3704 && strcmp (SECTION_NAME (sec
) + len2
, suffix
) == 0)
3708 if (i
== elf_header
.e_shnum
)
3710 printf (_("\nCould not find unwind info section for "));
3712 if (string_table
== NULL
)
3713 printf ("%d", unwsec
->sh_name
);
3715 printf ("'%s'", SECTION_NAME (unwsec
));
3719 aux
.info_size
= sec
->sh_size
;
3720 aux
.info_addr
= sec
->sh_addr
;
3721 aux
.info
= (char *) get_data (NULL
, file
, sec
->sh_offset
,
3722 aux
.info_size
, _("unwind info"));
3724 printf (_("\nUnwind section "));
3726 if (string_table
== NULL
)
3727 printf ("%d", unwsec
->sh_name
);
3729 printf ("'%s'", SECTION_NAME (unwsec
));
3731 printf (_(" at offset 0x%lx contains %lu entries:\n"),
3732 (unsigned long) unwsec
->sh_offset
,
3733 (unsigned long) (unwsec
->sh_size
/ (3 * addr_size
)));
3735 (void) slurp_ia64_unwind_table (file
, & aux
, unwsec
);
3737 if (aux
.table_len
> 0)
3738 dump_ia64_unwind (& aux
);
3741 free ((char *) aux
.table
);
3743 free ((char *) aux
.info
);
3752 free ((char *) aux
.strtab
);
3758 dynamic_segment_mips_val (entry
)
3759 Elf_Internal_Dyn
* entry
;
3761 switch (entry
->d_tag
)
3764 if (entry
->d_un
.d_val
== 0)
3768 static const char * opts
[] =
3770 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
3771 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
3772 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
3773 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
3778 for (cnt
= 0; cnt
< NUM_ELEM (opts
); ++ cnt
)
3779 if (entry
->d_un
.d_val
& (1 << cnt
))
3781 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
3788 case DT_MIPS_IVERSION
:
3789 if (dynamic_strings
!= NULL
)
3790 printf ("Interface Version: %s\n",
3791 dynamic_strings
+ entry
->d_un
.d_val
);
3793 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3796 case DT_MIPS_TIME_STAMP
:
3801 time_t time
= entry
->d_un
.d_val
;
3802 tmp
= gmtime (&time
);
3803 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
3804 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
3805 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
3806 printf ("Time Stamp: %s\n", timebuf
);
3810 case DT_MIPS_RLD_VERSION
:
3811 case DT_MIPS_LOCAL_GOTNO
:
3812 case DT_MIPS_CONFLICTNO
:
3813 case DT_MIPS_LIBLISTNO
:
3814 case DT_MIPS_SYMTABNO
:
3815 case DT_MIPS_UNREFEXTNO
:
3816 case DT_MIPS_HIPAGENO
:
3817 case DT_MIPS_DELTA_CLASS_NO
:
3818 case DT_MIPS_DELTA_INSTANCE_NO
:
3819 case DT_MIPS_DELTA_RELOC_NO
:
3820 case DT_MIPS_DELTA_SYM_NO
:
3821 case DT_MIPS_DELTA_CLASSSYM_NO
:
3822 case DT_MIPS_COMPACT_SIZE
:
3823 printf ("%ld\n", (long) entry
->d_un
.d_ptr
);
3827 printf ("%#lx\n", (long) entry
->d_un
.d_ptr
);
3833 dynamic_segment_parisc_val (entry
)
3834 Elf_Internal_Dyn
* entry
;
3836 switch (entry
->d_tag
)
3838 case DT_HP_DLD_FLAGS
:
3847 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
3848 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
3849 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
3850 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
3851 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
3852 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
3853 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
3854 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
3855 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
3856 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
3857 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" }
3861 bfd_vma val
= entry
->d_un
.d_val
;
3863 for (cnt
= 0; cnt
< sizeof (flags
) / sizeof (flags
[0]); ++cnt
)
3864 if (val
& flags
[cnt
].bit
)
3868 fputs (flags
[cnt
].str
, stdout
);
3870 val
^= flags
[cnt
].bit
;
3873 if (val
!= 0 || first
)
3877 print_vma (val
, HEX
);
3883 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
3889 get_32bit_dynamic_segment (file
)
3892 Elf32_External_Dyn
* edyn
;
3893 Elf_Internal_Dyn
* entry
;
3896 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
3897 dynamic_size
, _("dynamic segment"));
3901 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3902 how large this .dynamic is now. We can do this even before the byte
3903 swapping since the DT_NULL tag is recognizable. */
3905 while (*(Elf32_Word
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3908 dynamic_segment
= (Elf_Internal_Dyn
*)
3909 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3911 if (dynamic_segment
== NULL
)
3913 error (_("Out of memory\n"));
3918 for (i
= 0, entry
= dynamic_segment
;
3922 entry
->d_tag
= BYTE_GET (edyn
[i
].d_tag
);
3923 entry
->d_un
.d_val
= BYTE_GET (edyn
[i
].d_un
.d_val
);
3932 get_64bit_dynamic_segment (file
)
3935 Elf64_External_Dyn
* edyn
;
3936 Elf_Internal_Dyn
* entry
;
3939 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
,
3940 dynamic_size
, _("dynamic segment"));
3944 /* SGI's ELF has more than one section in the DYNAMIC segment. Determine
3945 how large this .dynamic is now. We can do this even before the byte
3946 swapping since the DT_NULL tag is recognizable. */
3948 while (*(bfd_vma
*) edyn
[dynamic_size
++].d_tag
!= DT_NULL
)
3951 dynamic_segment
= (Elf_Internal_Dyn
*)
3952 malloc (dynamic_size
* sizeof (Elf_Internal_Dyn
));
3954 if (dynamic_segment
== NULL
)
3956 error (_("Out of memory\n"));
3961 for (i
= 0, entry
= dynamic_segment
;
3965 entry
->d_tag
= BYTE_GET8 (edyn
[i
].d_tag
);
3966 entry
->d_un
.d_val
= BYTE_GET8 (edyn
[i
].d_un
.d_val
);
3975 get_dynamic_flags (flags
)
3978 static char buff
[64];
3983 flag
= flags
& - flags
;
3988 case DF_ORIGIN
: strcat (buff
, "ORIGIN "); break;
3989 case DF_SYMBOLIC
: strcat (buff
, "SYMBOLIC "); break;
3990 case DF_TEXTREL
: strcat (buff
, "TEXTREL "); break;
3991 case DF_BIND_NOW
: strcat (buff
, "BIND_NOW "); break;
3992 default: strcat (buff
, "unknown "); break;
3998 /* Parse and display the contents of the dynamic segment. */
4000 process_dynamic_segment (file
)
4003 Elf_Internal_Dyn
* entry
;
4006 if (dynamic_size
== 0)
4009 printf (_("\nThere is no dynamic segment in this file.\n"));
4016 if (! get_32bit_dynamic_segment (file
))
4019 else if (! get_64bit_dynamic_segment (file
))
4022 /* Find the appropriate symbol table. */
4023 if (dynamic_symbols
== NULL
)
4025 for (i
= 0, entry
= dynamic_segment
;
4029 unsigned long offset
;
4031 if (entry
->d_tag
!= DT_SYMTAB
)
4034 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
4036 /* Since we do not know how big the symbol table is,
4037 we default to reading in the entire file (!) and
4038 processing that. This is overkill, I know, but it
4040 offset
= entry
->d_un
.d_val
- loadaddr
;
4042 if (fseek (file
, 0, SEEK_END
))
4043 error (_("Unable to seek to end of file!"));
4046 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf32_External_Sym
);
4048 num_dynamic_syms
= (ftell (file
) - offset
) / sizeof (Elf64_External_Sym
);
4050 if (num_dynamic_syms
< 1)
4052 error (_("Unable to determine the number of symbols to load\n"));
4056 dynamic_symbols
= GET_ELF_SYMBOLS (file
, offset
, num_dynamic_syms
);
4060 /* Similarly find a string table. */
4061 if (dynamic_strings
== NULL
)
4063 for (i
= 0, entry
= dynamic_segment
;
4067 unsigned long offset
;
4070 if (entry
->d_tag
!= DT_STRTAB
)
4073 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
4075 /* Since we do not know how big the string table is,
4076 we default to reading in the entire file (!) and
4077 processing that. This is overkill, I know, but it
4080 offset
= entry
->d_un
.d_val
- loadaddr
;
4081 if (fseek (file
, 0, SEEK_END
))
4082 error (_("Unable to seek to end of file\n"));
4083 str_tab_len
= ftell (file
) - offset
;
4085 if (str_tab_len
< 1)
4088 (_("Unable to determine the length of the dynamic string table\n"));
4092 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, str_tab_len
,
4093 _("dynamic string table"));
4099 /* And find the syminfo section if available. */
4100 if (dynamic_syminfo
== NULL
)
4102 unsigned int syminsz
= 0;
4104 for (i
= 0, entry
= dynamic_segment
;
4108 if (entry
->d_tag
== DT_SYMINENT
)
4110 /* Note: these braces are necessary to avoid a syntax
4111 error from the SunOS4 C compiler. */
4112 assert (sizeof (Elf_External_Syminfo
) == entry
->d_un
.d_val
);
4114 else if (entry
->d_tag
== DT_SYMINSZ
)
4115 syminsz
= entry
->d_un
.d_val
;
4116 else if (entry
->d_tag
== DT_SYMINFO
)
4117 dynamic_syminfo_offset
= entry
->d_un
.d_val
- loadaddr
;
4120 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
4122 Elf_External_Syminfo
* extsyminfo
;
4123 Elf_Internal_Syminfo
* syminfo
;
4125 /* There is a syminfo section. Read the data. */
4126 extsyminfo
= ((Elf_External_Syminfo
*)
4127 get_data (NULL
, file
, dynamic_syminfo_offset
,
4128 syminsz
, _("symbol information")));
4132 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
4133 if (dynamic_syminfo
== NULL
)
4135 error (_("Out of memory\n"));
4139 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
4140 for (i
= 0, syminfo
= dynamic_syminfo
; i
< dynamic_syminfo_nent
;
4143 syminfo
->si_boundto
= BYTE_GET (extsyminfo
[i
].si_boundto
);
4144 syminfo
->si_flags
= BYTE_GET (extsyminfo
[i
].si_flags
);
4151 if (do_dynamic
&& dynamic_addr
)
4152 printf (_("\nDynamic segment at offset 0x%x contains %ld entries:\n"),
4153 dynamic_addr
, (long) dynamic_size
);
4155 printf (_(" Tag Type Name/Value\n"));
4157 for (i
= 0, entry
= dynamic_segment
;
4166 print_vma (entry
->d_tag
, FULL_HEX
);
4167 dtype
= get_dynamic_type (entry
->d_tag
);
4168 printf (" (%s)%*s", dtype
,
4169 ((is_32bit_elf
? 27 : 19)
4170 - (int) strlen (dtype
)),
4174 switch (entry
->d_tag
)
4178 printf ("%s", get_dynamic_flags (entry
->d_un
.d_val
));
4188 switch (entry
->d_tag
)
4191 printf (_("Auxiliary library"));
4195 printf (_("Filter library"));
4199 printf (_("Configuration file"));
4203 printf (_("Dependency audit library"));
4207 printf (_("Audit library"));
4211 if (dynamic_strings
)
4212 printf (": [%s]\n", dynamic_strings
+ entry
->d_un
.d_val
);
4216 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4225 printf (_("Flags:"));
4226 if (entry
->d_un
.d_val
== 0)
4227 printf (_(" None\n"));
4230 unsigned long int val
= entry
->d_un
.d_val
;
4231 if (val
& DTF_1_PARINIT
)
4233 printf (" PARINIT");
4234 val
^= DTF_1_PARINIT
;
4236 if (val
& DTF_1_CONFEXP
)
4238 printf (" CONFEXP");
4239 val
^= DTF_1_CONFEXP
;
4242 printf (" %lx", val
);
4251 printf (_("Flags:"));
4252 if (entry
->d_un
.d_val
== 0)
4253 printf (_(" None\n"));
4256 unsigned long int val
= entry
->d_un
.d_val
;
4257 if (val
& DF_P1_LAZYLOAD
)
4259 printf (" LAZYLOAD");
4260 val
^= DF_P1_LAZYLOAD
;
4262 if (val
& DF_P1_GROUPPERM
)
4264 printf (" GROUPPERM");
4265 val
^= DF_P1_GROUPPERM
;
4268 printf (" %lx", val
);
4277 printf (_("Flags:"));
4278 if (entry
->d_un
.d_val
== 0)
4279 printf (_(" None\n"));
4282 unsigned long int val
= entry
->d_un
.d_val
;
4288 if (val
& DF_1_GLOBAL
)
4293 if (val
& DF_1_GROUP
)
4298 if (val
& DF_1_NODELETE
)
4300 printf (" NODELETE");
4301 val
^= DF_1_NODELETE
;
4303 if (val
& DF_1_LOADFLTR
)
4305 printf (" LOADFLTR");
4306 val
^= DF_1_LOADFLTR
;
4308 if (val
& DF_1_INITFIRST
)
4310 printf (" INITFIRST");
4311 val
^= DF_1_INITFIRST
;
4313 if (val
& DF_1_NOOPEN
)
4318 if (val
& DF_1_ORIGIN
)
4323 if (val
& DF_1_DIRECT
)
4328 if (val
& DF_1_TRANS
)
4333 if (val
& DF_1_INTERPOSE
)
4335 printf (" INTERPOSE");
4336 val
^= DF_1_INTERPOSE
;
4338 if (val
& DF_1_NODEFLIB
)
4340 printf (" NODEFLIB");
4341 val
^= DF_1_NODEFLIB
;
4343 if (val
& DF_1_NODUMP
)
4348 if (val
& DF_1_CONLFAT
)
4350 printf (" CONLFAT");
4351 val
^= DF_1_CONLFAT
;
4354 printf (" %lx", val
);
4362 puts (get_dynamic_type (entry
->d_un
.d_val
));
4382 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
4388 if (dynamic_strings
== NULL
)
4391 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4395 switch (entry
->d_tag
)
4398 printf (_("Shared library: [%s]"), name
);
4400 if (strcmp (name
, program_interpreter
) == 0)
4401 printf (_(" program interpreter"));
4405 printf (_("Library soname: [%s]"), name
);
4409 printf (_("Library rpath: [%s]"), name
);
4413 printf (_("Library runpath: [%s]"), name
);
4417 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4422 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4438 case DT_INIT_ARRAYSZ
:
4439 case DT_FINI_ARRAYSZ
:
4442 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4443 printf (" (bytes)\n");
4453 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
4466 if (dynamic_strings
!= NULL
&& entry
->d_tag
== DT_USED
)
4470 name
= dynamic_strings
+ entry
->d_un
.d_val
;
4474 printf (_("Not needed object: [%s]\n"), name
);
4479 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4485 /* The value of this entry is ignored. */
4489 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
4490 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
4495 switch (elf_header
.e_machine
)
4498 case EM_MIPS_RS3_LE
:
4499 dynamic_segment_mips_val (entry
);
4502 dynamic_segment_parisc_val (entry
);
4505 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
4517 get_ver_flags (flags
)
4520 static char buff
[32];
4527 if (flags
& VER_FLG_BASE
)
4528 strcat (buff
, "BASE ");
4530 if (flags
& VER_FLG_WEAK
)
4532 if (flags
& VER_FLG_BASE
)
4533 strcat (buff
, "| ");
4535 strcat (buff
, "WEAK ");
4538 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
))
4539 strcat (buff
, "| <unknown>");
4544 /* Display the contents of the version sections. */
4546 process_version_sections (file
)
4549 Elf32_Internal_Shdr
* section
;
4556 for (i
= 0, section
= section_headers
;
4557 i
< elf_header
.e_shnum
;
4560 switch (section
->sh_type
)
4562 case SHT_GNU_verdef
:
4564 Elf_External_Verdef
* edefs
;
4571 (_("\nVersion definition section '%s' contains %ld entries:\n"),
4572 SECTION_NAME (section
), section
->sh_info
);
4574 printf (_(" Addr: 0x"));
4575 printf_vma (section
->sh_addr
);
4576 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4577 (unsigned long) section
->sh_offset
, section
->sh_link
,
4578 SECTION_NAME (section_headers
+ section
->sh_link
));
4580 edefs
= ((Elf_External_Verdef
*)
4581 get_data (NULL
, file
, section
->sh_offset
,
4583 _("version definition section")));
4587 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++ cnt
)
4590 Elf_External_Verdef
* edef
;
4591 Elf_Internal_Verdef ent
;
4592 Elf_External_Verdaux
* eaux
;
4593 Elf_Internal_Verdaux aux
;
4597 vstart
= ((char *) edefs
) + idx
;
4599 edef
= (Elf_External_Verdef
*) vstart
;
4601 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
4602 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
4603 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
4604 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
4605 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
4606 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
4607 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
4609 printf (_(" %#06x: Rev: %d Flags: %s"),
4610 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
4612 printf (_(" Index: %d Cnt: %d "),
4613 ent
.vd_ndx
, ent
.vd_cnt
);
4615 vstart
+= ent
.vd_aux
;
4617 eaux
= (Elf_External_Verdaux
*) vstart
;
4619 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4620 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4622 if (dynamic_strings
)
4623 printf (_("Name: %s\n"), dynamic_strings
+ aux
.vda_name
);
4625 printf (_("Name index: %ld\n"), aux
.vda_name
);
4627 isum
= idx
+ ent
.vd_aux
;
4629 for (j
= 1; j
< ent
.vd_cnt
; j
++)
4631 isum
+= aux
.vda_next
;
4632 vstart
+= aux
.vda_next
;
4634 eaux
= (Elf_External_Verdaux
*) vstart
;
4636 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
4637 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
4639 if (dynamic_strings
)
4640 printf (_(" %#06x: Parent %d: %s\n"),
4641 isum
, j
, dynamic_strings
+ aux
.vda_name
);
4643 printf (_(" %#06x: Parent %d, name index: %ld\n"),
4644 isum
, j
, aux
.vda_name
);
4654 case SHT_GNU_verneed
:
4656 Elf_External_Verneed
* eneed
;
4662 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
4663 SECTION_NAME (section
), section
->sh_info
);
4665 printf (_(" Addr: 0x"));
4666 printf_vma (section
->sh_addr
);
4667 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
4668 (unsigned long) section
->sh_offset
, section
->sh_link
,
4669 SECTION_NAME (section_headers
+ section
->sh_link
));
4671 eneed
= ((Elf_External_Verneed
*)
4672 get_data (NULL
, file
, section
->sh_offset
,
4673 section
->sh_size
, _("version need section")));
4677 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
4679 Elf_External_Verneed
* entry
;
4680 Elf_Internal_Verneed ent
;
4685 vstart
= ((char *) eneed
) + idx
;
4687 entry
= (Elf_External_Verneed
*) vstart
;
4689 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
4690 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
4691 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
4692 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
4693 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
4695 printf (_(" %#06x: Version: %d"), idx
, ent
.vn_version
);
4697 if (dynamic_strings
)
4698 printf (_(" File: %s"), dynamic_strings
+ ent
.vn_file
);
4700 printf (_(" File: %lx"), ent
.vn_file
);
4702 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
4704 vstart
+= ent
.vn_aux
;
4706 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
4708 Elf_External_Vernaux
* eaux
;
4709 Elf_Internal_Vernaux aux
;
4711 eaux
= (Elf_External_Vernaux
*) vstart
;
4713 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
4714 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
4715 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
4716 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
4717 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
4719 if (dynamic_strings
)
4720 printf (_(" %#06x: Name: %s"),
4721 isum
, dynamic_strings
+ aux
.vna_name
);
4723 printf (_(" %#06x: Name index: %lx"),
4724 isum
, aux
.vna_name
);
4726 printf (_(" Flags: %s Version: %d\n"),
4727 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
4729 isum
+= aux
.vna_next
;
4730 vstart
+= aux
.vna_next
;
4740 case SHT_GNU_versym
:
4742 Elf32_Internal_Shdr
* link_section
;
4745 unsigned char * edata
;
4746 unsigned short * data
;
4748 Elf_Internal_Sym
* symbols
;
4749 Elf32_Internal_Shdr
* string_sec
;
4751 link_section
= section_headers
+ section
->sh_link
;
4752 total
= section
->sh_size
/ section
->sh_entsize
;
4756 symbols
= GET_ELF_SYMBOLS (file
, link_section
->sh_offset
,
4757 link_section
->sh_size
/ link_section
->sh_entsize
);
4759 string_sec
= section_headers
+ link_section
->sh_link
;
4761 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
4762 string_sec
->sh_size
,
4763 _("version string table"));
4767 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
4768 SECTION_NAME (section
), total
);
4770 printf (_(" Addr: "));
4771 printf_vma (section
->sh_addr
);
4772 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
4773 (unsigned long) section
->sh_offset
, section
->sh_link
,
4774 SECTION_NAME (link_section
));
4778 get_data (NULL
, file
,
4779 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] - loadaddr
,
4780 total
* sizeof (short), _("version symbol data")));
4787 data
= (unsigned short *) malloc (total
* sizeof (short));
4789 for (cnt
= total
; cnt
--;)
4790 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
4795 for (cnt
= 0; cnt
< total
; cnt
+= 4)
4798 int check_def
, check_need
;
4801 printf (" %03x:", cnt
);
4803 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
4804 switch (data
[cnt
+ j
])
4807 fputs (_(" 0 (*local*) "), stdout
);
4811 fputs (_(" 1 (*global*) "), stdout
);
4815 nn
= printf ("%4x%c", data
[cnt
+ j
] & 0x7fff,
4816 data
[cnt
+ j
] & 0x8000 ? 'h' : ' ');
4820 if (symbols
[cnt
+ j
].st_shndx
>= SHN_LORESERVE
4821 || section_headers
[symbols
[cnt
+ j
].st_shndx
].sh_type
4824 if (symbols
[cnt
+ j
].st_shndx
== SHN_UNDEF
)
4831 && version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
4833 Elf_Internal_Verneed ivn
;
4834 unsigned long offset
;
4836 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
4841 Elf_Internal_Vernaux ivna
;
4842 Elf_External_Verneed evn
;
4843 Elf_External_Vernaux evna
;
4844 unsigned long a_off
;
4846 get_data (&evn
, file
, offset
, sizeof (evn
),
4849 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
4850 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
4852 a_off
= offset
+ ivn
.vn_aux
;
4856 get_data (&evna
, file
, a_off
, sizeof (evna
),
4857 _("version need aux (2)"));
4859 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
4860 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
4862 a_off
+= ivna
.vna_next
;
4864 while (ivna
.vna_other
!= data
[cnt
+ j
]
4865 && ivna
.vna_next
!= 0);
4867 if (ivna
.vna_other
== data
[cnt
+ j
])
4869 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
4871 name
= strtab
+ ivna
.vna_name
;
4872 nn
+= printf ("(%s%-*s",
4874 12 - (int) strlen (name
),
4880 offset
+= ivn
.vn_next
;
4882 while (ivn
.vn_next
);
4885 if (check_def
&& data
[cnt
+ j
] != 0x8001
4886 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
4888 Elf_Internal_Verdef ivd
;
4889 Elf_External_Verdef evd
;
4890 unsigned long offset
;
4892 offset
= version_info
4893 [DT_VERSIONTAGIDX (DT_VERDEF
)] - loadaddr
;
4897 get_data (&evd
, file
, offset
, sizeof (evd
),
4900 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
4901 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
4903 offset
+= ivd
.vd_next
;
4905 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & 0x7fff)
4906 && ivd
.vd_next
!= 0);
4908 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & 0x7fff))
4910 Elf_External_Verdaux evda
;
4911 Elf_Internal_Verdaux ivda
;
4913 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
4915 get_data (&evda
, file
,
4916 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
4917 sizeof (evda
), _("version def aux"));
4919 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
4921 name
= strtab
+ ivda
.vda_name
;
4922 nn
+= printf ("(%s%-*s",
4924 12 - (int) strlen (name
),
4930 printf ("%*c", 18 - nn
, ' ');
4948 printf (_("\nNo version information found in this file.\n"));
4954 get_symbol_binding (binding
)
4955 unsigned int binding
;
4957 static char buff
[32];
4961 case STB_LOCAL
: return "LOCAL";
4962 case STB_GLOBAL
: return "GLOBAL";
4963 case STB_WEAK
: return "WEAK";
4965 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
4966 sprintf (buff
, _("<processor specific>: %d"), binding
);
4967 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
4968 sprintf (buff
, _("<OS specific>: %d"), binding
);
4970 sprintf (buff
, _("<unknown>: %d"), binding
);
4976 get_symbol_type (type
)
4979 static char buff
[32];
4983 case STT_NOTYPE
: return "NOTYPE";
4984 case STT_OBJECT
: return "OBJECT";
4985 case STT_FUNC
: return "FUNC";
4986 case STT_SECTION
: return "SECTION";
4987 case STT_FILE
: return "FILE";
4988 case STT_COMMON
: return "COMMON";
4990 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
4992 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
4993 return "THUMB_FUNC";
4995 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
4998 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
4999 return "PARISC_MILLI";
5001 sprintf (buff
, _("<processor specific>: %d"), type
);
5003 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
5005 if (elf_header
.e_machine
== EM_PARISC
)
5007 if (type
== STT_HP_OPAQUE
)
5009 if (type
== STT_HP_STUB
)
5013 sprintf (buff
, _("<OS specific>: %d"), type
);
5016 sprintf (buff
, _("<unknown>: %d"), type
);
5022 get_symbol_visibility (visibility
)
5023 unsigned int visibility
;
5027 case STV_DEFAULT
: return "DEFAULT";
5028 case STV_INTERNAL
: return "INTERNAL";
5029 case STV_HIDDEN
: return "HIDDEN";
5030 case STV_PROTECTED
: return "PROTECTED";
5036 get_symbol_index_type (type
)
5041 case SHN_UNDEF
: return "UND";
5042 case SHN_ABS
: return "ABS";
5043 case SHN_COMMON
: return "COM";
5045 if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
5047 else if (type
>= SHN_LORESERVE
&& type
<= SHN_HIRESERVE
)
5049 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
5053 static char buff
[32];
5055 sprintf (buff
, "%3d", type
);
5062 get_dynamic_data (file
, number
)
5064 unsigned int number
;
5066 unsigned char * e_data
;
5069 e_data
= (unsigned char *) malloc (number
* 4);
5073 error (_("Out of memory\n"));
5077 if (fread (e_data
, 4, number
, file
) != number
)
5079 error (_("Unable to read in dynamic data\n"));
5083 i_data
= (int *) malloc (number
* sizeof (* i_data
));
5087 error (_("Out of memory\n"));
5093 i_data
[number
] = byte_get (e_data
+ number
* 4, 4);
5100 /* Dump the symbol table */
5102 process_symbol_table (file
)
5105 Elf32_Internal_Shdr
* section
;
5106 unsigned char nb
[4];
5107 unsigned char nc
[4];
5110 int * buckets
= NULL
;
5111 int * chains
= NULL
;
5113 if (! do_syms
&& !do_histogram
)
5116 if (dynamic_info
[DT_HASH
] && ((do_using_dynamic
&& dynamic_strings
!= NULL
)
5119 if (fseek (file
, dynamic_info
[DT_HASH
] - loadaddr
, SEEK_SET
))
5121 error (_("Unable to seek to start of dynamic information"));
5125 if (fread (nb
, sizeof (nb
), 1, file
) != 1)
5127 error (_("Failed to read in number of buckets\n"));
5131 if (fread (nc
, sizeof (nc
), 1, file
) != 1)
5133 error (_("Failed to read in number of chains\n"));
5137 nbuckets
= byte_get (nb
, 4);
5138 nchains
= byte_get (nc
, 4);
5140 buckets
= get_dynamic_data (file
, nbuckets
);
5141 chains
= get_dynamic_data (file
, nchains
);
5143 if (buckets
== NULL
|| chains
== NULL
)
5148 && dynamic_info
[DT_HASH
] && do_using_dynamic
&& dynamic_strings
!= NULL
)
5153 printf (_("\nSymbol table for image:\n"));
5155 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5157 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
5159 for (hn
= 0; hn
< nbuckets
; hn
++)
5164 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
5166 Elf_Internal_Sym
* psym
;
5168 psym
= dynamic_symbols
+ si
;
5170 printf (" %3d %3d: ", si
, hn
);
5171 print_vma (psym
->st_value
, LONG_HEX
);
5173 print_vma (psym
->st_size
, DEC_5
);
5175 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5176 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5177 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5178 printf (" %3.3s", get_symbol_index_type (psym
->st_shndx
));
5179 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
5183 else if (do_syms
&& !do_using_dynamic
)
5187 for (i
= 0, section
= section_headers
;
5188 i
< elf_header
.e_shnum
;
5193 Elf_Internal_Sym
* symtab
;
5194 Elf_Internal_Sym
* psym
;
5197 if ( section
->sh_type
!= SHT_SYMTAB
5198 && section
->sh_type
!= SHT_DYNSYM
)
5201 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
5202 SECTION_NAME (section
),
5203 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
5205 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5207 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
5209 symtab
= GET_ELF_SYMBOLS (file
, section
->sh_offset
,
5210 section
->sh_size
/ section
->sh_entsize
);
5214 if (section
->sh_link
== elf_header
.e_shstrndx
)
5215 strtab
= string_table
;
5218 Elf32_Internal_Shdr
* string_sec
;
5220 string_sec
= section_headers
+ section
->sh_link
;
5222 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
5223 string_sec
->sh_size
,
5227 for (si
= 0, psym
= symtab
;
5228 si
< section
->sh_size
/ section
->sh_entsize
;
5231 printf ("%6d: ", si
);
5232 print_vma (psym
->st_value
, LONG_HEX
);
5234 print_vma (psym
->st_size
, DEC_5
);
5235 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
5236 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
5237 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym
->st_other
)));
5238 printf (" %4s", get_symbol_index_type (psym
->st_shndx
));
5239 printf (" %s", strtab
+ psym
->st_name
);
5241 if (section
->sh_type
== SHT_DYNSYM
&&
5242 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] != 0)
5244 unsigned char data
[2];
5245 unsigned short vers_data
;
5246 unsigned long offset
;
5250 offset
= version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)]
5253 get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
5254 sizeof (data
), _("version data"));
5256 vers_data
= byte_get (data
, 2);
5258 is_nobits
= psym
->st_shndx
< SHN_LORESERVE
?
5259 (section_headers
[psym
->st_shndx
].sh_type
== SHT_NOBITS
)
5262 check_def
= (psym
->st_shndx
!= SHN_UNDEF
);
5264 if ((vers_data
& 0x8000) || vers_data
> 1)
5266 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)]
5267 && (is_nobits
|| ! check_def
))
5269 Elf_External_Verneed evn
;
5270 Elf_Internal_Verneed ivn
;
5271 Elf_Internal_Vernaux ivna
;
5273 /* We must test both. */
5274 offset
= version_info
5275 [DT_VERSIONTAGIDX (DT_VERNEED
)] - loadaddr
;
5279 unsigned long vna_off
;
5281 get_data (&evn
, file
, offset
, sizeof (evn
),
5284 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
5285 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
5287 vna_off
= offset
+ ivn
.vn_aux
;
5291 Elf_External_Vernaux evna
;
5293 get_data (&evna
, file
, vna_off
,
5295 _("version need aux (3)"));
5297 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
5298 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
5299 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
5301 vna_off
+= ivna
.vna_next
;
5303 while (ivna
.vna_other
!= vers_data
5304 && ivna
.vna_next
!= 0);
5306 if (ivna
.vna_other
== vers_data
)
5309 offset
+= ivn
.vn_next
;
5311 while (ivn
.vn_next
!= 0);
5313 if (ivna
.vna_other
== vers_data
)
5316 strtab
+ ivna
.vna_name
, ivna
.vna_other
);
5319 else if (! is_nobits
)
5320 error (_("bad dynamic symbol"));
5327 if (vers_data
!= 0x8001
5328 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
5330 Elf_Internal_Verdef ivd
;
5331 Elf_Internal_Verdaux ivda
;
5332 Elf_External_Verdaux evda
;
5333 unsigned long offset
;
5336 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)]
5341 Elf_External_Verdef evd
;
5343 get_data (&evd
, file
, offset
, sizeof (evd
),
5346 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
5347 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
5348 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
5350 offset
+= ivd
.vd_next
;
5352 while (ivd
.vd_ndx
!= (vers_data
& 0x7fff)
5353 && ivd
.vd_next
!= 0);
5355 offset
-= ivd
.vd_next
;
5356 offset
+= ivd
.vd_aux
;
5358 get_data (&evda
, file
, offset
, sizeof (evda
),
5359 _("version def aux"));
5361 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
5363 if (psym
->st_name
!= ivda
.vda_name
)
5364 printf ((vers_data
& 0x8000)
5366 strtab
+ ivda
.vda_name
);
5376 if (strtab
!= string_table
)
5382 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
5384 if (do_histogram
&& buckets
!= NULL
)
5391 int nzero_counts
= 0;
5394 printf (_("\nHistogram for bucket list length (total of %d buckets):\n"),
5396 printf (_(" Length Number %% of total Coverage\n"));
5398 lengths
= (int *) calloc (nbuckets
, sizeof (int));
5399 if (lengths
== NULL
)
5401 error (_("Out of memory"));
5404 for (hn
= 0; hn
< nbuckets
; ++hn
)
5409 for (si
= buckets
[hn
]; si
> 0 && si
< nchains
; si
= chains
[si
])
5412 if (maxlength
< ++lengths
[hn
])
5417 counts
= (int *) calloc (maxlength
+ 1, sizeof (int));
5420 error (_("Out of memory"));
5424 for (hn
= 0; hn
< nbuckets
; ++hn
)
5425 ++ counts
[lengths
[hn
]];
5429 printf (" 0 %-10d (%5.1f%%)\n",
5430 counts
[0], (counts
[0] * 100.0) / nbuckets
);
5431 for (si
= 1; si
<= maxlength
; ++si
)
5433 nzero_counts
+= counts
[si
] * si
;
5434 printf ("%7d %-10d (%5.1f%%) %5.1f%%\n",
5435 si
, counts
[si
], (counts
[si
] * 100.0) / nbuckets
,
5436 (nzero_counts
* 100.0) / nsyms
);
5444 if (buckets
!= NULL
)
5454 process_syminfo (file
)
5455 FILE * file ATTRIBUTE_UNUSED
;
5459 if (dynamic_syminfo
== NULL
5461 /* No syminfo, this is ok. */
5464 /* There better should be a dynamic symbol section. */
5465 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
5469 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
5470 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
5472 printf (_(" Num: Name BoundTo Flags\n"));
5473 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
5475 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
5477 printf ("%4d: %-30s ", i
,
5478 dynamic_strings
+ dynamic_symbols
[i
].st_name
);
5480 switch (dynamic_syminfo
[i
].si_boundto
)
5482 case SYMINFO_BT_SELF
:
5483 fputs ("SELF ", stdout
);
5485 case SYMINFO_BT_PARENT
:
5486 fputs ("PARENT ", stdout
);
5489 if (dynamic_syminfo
[i
].si_boundto
> 0
5490 && dynamic_syminfo
[i
].si_boundto
< dynamic_size
)
5493 + dynamic_segment
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
);
5495 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
5499 if (flags
& SYMINFO_FLG_DIRECT
)
5501 if (flags
& SYMINFO_FLG_PASSTHRU
)
5502 printf (" PASSTHRU");
5503 if (flags
& SYMINFO_FLG_COPY
)
5505 if (flags
& SYMINFO_FLG_LAZYLOAD
)
5506 printf (" LAZYLOAD");
5514 #ifdef SUPPORT_DISASSEMBLY
5516 disassemble_section (section
, file
)
5517 Elf32_Internal_Shdr
* section
;
5520 printf (_("\nAssembly dump of section %s\n"),
5521 SECTION_NAME (section
));
5523 /* XXX -- to be done --- XXX */
5530 dump_section (section
, file
)
5531 Elf32_Internal_Shdr
* section
;
5534 bfd_size_type bytes
;
5536 unsigned char * data
;
5537 unsigned char * start
;
5539 bytes
= section
->sh_size
;
5543 printf (_("\nSection '%s' has no data to dump.\n"),
5544 SECTION_NAME (section
));
5548 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section
));
5550 addr
= section
->sh_addr
;
5552 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, bytes
,
5565 lbytes
= (bytes
> 16 ? 16 : bytes
);
5567 printf (" 0x%8.8lx ", (unsigned long) addr
);
5569 switch (elf_header
.e_ident
[EI_DATA
])
5573 for (j
= 15; j
>= 0; j
--)
5576 printf ("%2.2x", data
[j
]);
5586 for (j
= 0; j
< 16; j
++)
5589 printf ("%2.2x", data
[j
]);
5599 for (j
= 0; j
< lbytes
; j
++)
5602 if (k
>= ' ' && k
< 0x80)
5621 static unsigned long int
5622 read_leb128 (data
, length_return
, sign
)
5623 unsigned char * data
;
5624 int * length_return
;
5627 unsigned long int result
= 0;
5628 unsigned int num_read
= 0;
5637 result
|= (byte
& 0x7f) << shift
;
5642 while (byte
& 0x80);
5644 if (length_return
!= NULL
)
5645 * length_return
= num_read
;
5647 if (sign
&& (shift
< 32) && (byte
& 0x40))
5648 result
|= -1 << shift
;
5653 typedef struct State_Machine_Registers
5655 unsigned long address
;
5658 unsigned int column
;
5662 /* This variable hold the number of the last entry seen
5663 in the File Table. */
5664 unsigned int last_file_entry
;
5667 static SMR state_machine_regs
;
5670 reset_state_machine (is_stmt
)
5673 state_machine_regs
.address
= 0;
5674 state_machine_regs
.file
= 1;
5675 state_machine_regs
.line
= 1;
5676 state_machine_regs
.column
= 0;
5677 state_machine_regs
.is_stmt
= is_stmt
;
5678 state_machine_regs
.basic_block
= 0;
5679 state_machine_regs
.end_sequence
= 0;
5680 state_machine_regs
.last_file_entry
= 0;
5683 /* Handled an extend line op. Returns true if this is the end
5686 process_extended_line_op (data
, is_stmt
, pointer_size
)
5687 unsigned char * data
;
5691 unsigned char op_code
;
5694 unsigned char * name
;
5697 len
= read_leb128 (data
, & bytes_read
, 0);
5702 warn (_("badly formed extended line op encountered!\n"));
5707 op_code
= * data
++;
5709 printf (_(" Extended opcode %d: "), op_code
);
5713 case DW_LNE_end_sequence
:
5714 printf (_("End of Sequence\n\n"));
5715 reset_state_machine (is_stmt
);
5718 case DW_LNE_set_address
:
5719 adr
= byte_get (data
, pointer_size
);
5720 printf (_("set Address to 0x%lx\n"), adr
);
5721 state_machine_regs
.address
= adr
;
5724 case DW_LNE_define_file
:
5725 printf (_(" define new File Table entry\n"));
5726 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5728 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5730 data
+= strlen ((char *) data
) + 1;
5731 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5733 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5735 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5736 printf (_("%s\n\n"), name
);
5740 printf (_("UNKNOWN: length %d\n"), len
- bytes_read
);
5747 /* Size of pointers in the .debug_line section. This information is not
5748 really present in that section. It's obtained before dumping the debug
5749 sections by doing some pre-scan of the .debug_info section. */
5750 static int debug_line_pointer_size
= 4;
5753 display_debug_lines (section
, start
, file
)
5754 Elf32_Internal_Shdr
* section
;
5755 unsigned char * start
;
5756 FILE * file ATTRIBUTE_UNUSED
;
5758 DWARF2_External_LineInfo
* external
;
5759 DWARF2_Internal_LineInfo info
;
5760 unsigned char * standard_opcodes
;
5761 unsigned char * data
= start
;
5762 unsigned char * end
= start
+ section
->sh_size
;
5763 unsigned char * end_of_sequence
;
5766 printf (_("\nDump of debug contents of section %s:\n\n"),
5767 SECTION_NAME (section
));
5771 external
= (DWARF2_External_LineInfo
*) data
;
5773 /* Check the length of the block. */
5774 info
.li_length
= BYTE_GET (external
->li_length
);
5776 if (info
.li_length
== 0xffffffff)
5778 warn (_("64-bit DWARF line info is not supported yet.\n"));
5782 if (info
.li_length
+ sizeof (external
->li_length
) > section
->sh_size
)
5785 (_("The line info appears to be corrupt - the section is too small\n"));
5789 /* Check its version number. */
5790 info
.li_version
= BYTE_GET (external
->li_version
);
5791 if (info
.li_version
!= 2)
5793 warn (_("Only DWARF version 2 line info is currently supported.\n"));
5797 info
.li_prologue_length
= BYTE_GET (external
->li_prologue_length
);
5798 info
.li_min_insn_length
= BYTE_GET (external
->li_min_insn_length
);
5799 info
.li_default_is_stmt
= BYTE_GET (external
->li_default_is_stmt
);
5800 info
.li_line_base
= BYTE_GET (external
->li_line_base
);
5801 info
.li_line_range
= BYTE_GET (external
->li_line_range
);
5802 info
.li_opcode_base
= BYTE_GET (external
->li_opcode_base
);
5804 /* Sign extend the line base field. */
5805 info
.li_line_base
<<= 24;
5806 info
.li_line_base
>>= 24;
5808 printf (_(" Length: %ld\n"), info
.li_length
);
5809 printf (_(" DWARF Version: %d\n"), info
.li_version
);
5810 printf (_(" Prologue Length: %d\n"), info
.li_prologue_length
);
5811 printf (_(" Minimum Instruction Length: %d\n"), info
.li_min_insn_length
);
5812 printf (_(" Initial value of 'is_stmt': %d\n"), info
.li_default_is_stmt
);
5813 printf (_(" Line Base: %d\n"), info
.li_line_base
);
5814 printf (_(" Line Range: %d\n"), info
.li_line_range
);
5815 printf (_(" Opcode Base: %d\n"), info
.li_opcode_base
);
5817 end_of_sequence
= data
+ info
.li_length
+ sizeof (external
->li_length
);
5819 reset_state_machine (info
.li_default_is_stmt
);
5821 /* Display the contents of the Opcodes table. */
5822 standard_opcodes
= data
+ sizeof (* external
);
5824 printf (_("\n Opcodes:\n"));
5826 for (i
= 1; i
< info
.li_opcode_base
; i
++)
5827 printf (_(" Opcode %d has %d args\n"), i
, standard_opcodes
[i
- 1]);
5829 /* Display the contents of the Directory table. */
5830 data
= standard_opcodes
+ info
.li_opcode_base
- 1;
5833 printf (_("\n The Directory Table is empty.\n"));
5836 printf (_("\n The Directory Table:\n"));
5840 printf (_(" %s\n"), data
);
5842 data
+= strlen ((char *) data
) + 1;
5846 /* Skip the NUL at the end of the table. */
5849 /* Display the contents of the File Name table. */
5851 printf (_("\n The File Name Table is empty.\n"));
5854 printf (_("\n The File Name Table:\n"));
5855 printf (_(" Entry\tDir\tTime\tSize\tName\n"));
5859 unsigned char * name
;
5862 printf (_(" %d\t"), ++ state_machine_regs
.last_file_entry
);
5865 data
+= strlen ((char *) data
) + 1;
5867 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5869 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5871 printf (_("%lu\t"), read_leb128 (data
, & bytes_read
, 0));
5873 printf (_("%s\n"), name
);
5877 /* Skip the NUL at the end of the table. */
5880 /* Now display the statements. */
5881 printf (_("\n Line Number Statements:\n"));
5884 while (data
< end_of_sequence
)
5886 unsigned char op_code
;
5890 op_code
= * data
++;
5892 if (op_code
>= info
.li_opcode_base
)
5894 op_code
-= info
.li_opcode_base
;
5895 adv
= (op_code
/ info
.li_line_range
) * info
.li_min_insn_length
;
5896 state_machine_regs
.address
+= adv
;
5897 printf (_(" Special opcode %d: advance Address by %d to 0x%lx"),
5898 op_code
, adv
, state_machine_regs
.address
);
5899 adv
= (op_code
% info
.li_line_range
) + info
.li_line_base
;
5900 state_machine_regs
.line
+= adv
;
5901 printf (_(" and Line by %d to %d\n"),
5902 adv
, state_machine_regs
.line
);
5904 else switch (op_code
)
5906 case DW_LNS_extended_op
:
5907 data
+= process_extended_line_op (data
, info
.li_default_is_stmt
,
5908 debug_line_pointer_size
);
5912 printf (_(" Copy\n"));
5915 case DW_LNS_advance_pc
:
5916 adv
= info
.li_min_insn_length
* read_leb128 (data
, & bytes_read
, 0);
5918 state_machine_regs
.address
+= adv
;
5919 printf (_(" Advance PC by %d to %lx\n"), adv
,
5920 state_machine_regs
.address
);
5923 case DW_LNS_advance_line
:
5924 adv
= read_leb128 (data
, & bytes_read
, 1);
5926 state_machine_regs
.line
+= adv
;
5927 printf (_(" Advance Line by %d to %d\n"), adv
,
5928 state_machine_regs
.line
);
5931 case DW_LNS_set_file
:
5932 adv
= read_leb128 (data
, & bytes_read
, 0);
5934 printf (_(" Set File Name to entry %d in the File Name Table\n"),
5936 state_machine_regs
.file
= adv
;
5939 case DW_LNS_set_column
:
5940 adv
= read_leb128 (data
, & bytes_read
, 0);
5942 printf (_(" Set column to %d\n"), adv
);
5943 state_machine_regs
.column
= adv
;
5946 case DW_LNS_negate_stmt
:
5947 adv
= state_machine_regs
.is_stmt
;
5949 printf (_(" Set is_stmt to %d\n"), adv
);
5950 state_machine_regs
.is_stmt
= adv
;
5953 case DW_LNS_set_basic_block
:
5954 printf (_(" Set basic block\n"));
5955 state_machine_regs
.basic_block
= 1;
5958 case DW_LNS_const_add_pc
:
5959 adv
= (((255 - info
.li_opcode_base
) / info
.li_line_range
)
5960 * info
.li_min_insn_length
);
5961 state_machine_regs
.address
+= adv
;
5962 printf (_(" Advance PC by constant %d to 0x%lx\n"), adv
,
5963 state_machine_regs
.address
);
5966 case DW_LNS_fixed_advance_pc
:
5967 adv
= byte_get (data
, 2);
5969 state_machine_regs
.address
+= adv
;
5970 printf (_(" Advance PC by fixed size amount %d to 0x%lx\n"),
5971 adv
, state_machine_regs
.address
);
5974 case DW_LNS_set_prologue_end
:
5975 printf (_(" Set prologue_end to true\n"));
5978 case DW_LNS_set_epilogue_begin
:
5979 printf (_(" Set epilogue_begin to true\n"));
5982 case DW_LNS_set_isa
:
5983 adv
= read_leb128 (data
, & bytes_read
, 0);
5985 printf (_(" Set ISA to %d\n"), adv
);
5989 printf (_(" Unknown opcode %d with operands: "), op_code
);
5992 for (i
= standard_opcodes
[op_code
- 1]; i
> 0 ; --i
)
5994 printf ("0x%lx%s", read_leb128 (data
, &bytes_read
, 0),
5995 i
== 1 ? "" : ", ");
6010 display_debug_pubnames (section
, start
, file
)
6011 Elf32_Internal_Shdr
* section
;
6012 unsigned char * start
;
6013 FILE * file ATTRIBUTE_UNUSED
;
6015 DWARF2_External_PubNames
* external
;
6016 DWARF2_Internal_PubNames pubnames
;
6017 unsigned char * end
;
6019 end
= start
+ section
->sh_size
;
6021 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6025 unsigned char * data
;
6026 unsigned long offset
;
6028 external
= (DWARF2_External_PubNames
*) start
;
6030 pubnames
.pn_length
= BYTE_GET (external
->pn_length
);
6031 pubnames
.pn_version
= BYTE_GET (external
->pn_version
);
6032 pubnames
.pn_offset
= BYTE_GET (external
->pn_offset
);
6033 pubnames
.pn_size
= BYTE_GET (external
->pn_size
);
6035 data
= start
+ sizeof (* external
);
6036 start
+= pubnames
.pn_length
+ sizeof (external
->pn_length
);
6038 if (pubnames
.pn_length
== 0xffffffff)
6040 warn (_("64-bit DWARF pubnames are not supported yet.\n"));
6044 if (pubnames
.pn_version
!= 2)
6046 static int warned
= 0;
6050 warn (_("Only DWARF 2 pubnames are currently supported\n"));
6057 printf (_(" Length: %ld\n"),
6058 pubnames
.pn_length
);
6059 printf (_(" Version: %d\n"),
6060 pubnames
.pn_version
);
6061 printf (_(" Offset into .debug_info section: %ld\n"),
6062 pubnames
.pn_offset
);
6063 printf (_(" Size of area in .debug_info section: %ld\n"),
6066 printf (_("\n Offset\tName\n"));
6070 offset
= byte_get (data
, 4);
6075 printf (" %ld\t\t%s\n", offset
, data
);
6076 data
+= strlen ((char *) data
) + 1;
6079 while (offset
!= 0);
6092 case DW_TAG_padding
: return "DW_TAG_padding";
6093 case DW_TAG_array_type
: return "DW_TAG_array_type";
6094 case DW_TAG_class_type
: return "DW_TAG_class_type";
6095 case DW_TAG_entry_point
: return "DW_TAG_entry_point";
6096 case DW_TAG_enumeration_type
: return "DW_TAG_enumeration_type";
6097 case DW_TAG_formal_parameter
: return "DW_TAG_formal_parameter";
6098 case DW_TAG_imported_declaration
: return "DW_TAG_imported_declaration";
6099 case DW_TAG_label
: return "DW_TAG_label";
6100 case DW_TAG_lexical_block
: return "DW_TAG_lexical_block";
6101 case DW_TAG_member
: return "DW_TAG_member";
6102 case DW_TAG_pointer_type
: return "DW_TAG_pointer_type";
6103 case DW_TAG_reference_type
: return "DW_TAG_reference_type";
6104 case DW_TAG_compile_unit
: return "DW_TAG_compile_unit";
6105 case DW_TAG_string_type
: return "DW_TAG_string_type";
6106 case DW_TAG_structure_type
: return "DW_TAG_structure_type";
6107 case DW_TAG_subroutine_type
: return "DW_TAG_subroutine_type";
6108 case DW_TAG_typedef
: return "DW_TAG_typedef";
6109 case DW_TAG_union_type
: return "DW_TAG_union_type";
6110 case DW_TAG_unspecified_parameters
: return "DW_TAG_unspecified_parameters";
6111 case DW_TAG_variant
: return "DW_TAG_variant";
6112 case DW_TAG_common_block
: return "DW_TAG_common_block";
6113 case DW_TAG_common_inclusion
: return "DW_TAG_common_inclusion";
6114 case DW_TAG_inheritance
: return "DW_TAG_inheritance";
6115 case DW_TAG_inlined_subroutine
: return "DW_TAG_inlined_subroutine";
6116 case DW_TAG_module
: return "DW_TAG_module";
6117 case DW_TAG_ptr_to_member_type
: return "DW_TAG_ptr_to_member_type";
6118 case DW_TAG_set_type
: return "DW_TAG_set_type";
6119 case DW_TAG_subrange_type
: return "DW_TAG_subrange_type";
6120 case DW_TAG_with_stmt
: return "DW_TAG_with_stmt";
6121 case DW_TAG_access_declaration
: return "DW_TAG_access_declaration";
6122 case DW_TAG_base_type
: return "DW_TAG_base_type";
6123 case DW_TAG_catch_block
: return "DW_TAG_catch_block";
6124 case DW_TAG_const_type
: return "DW_TAG_const_type";
6125 case DW_TAG_constant
: return "DW_TAG_constant";
6126 case DW_TAG_enumerator
: return "DW_TAG_enumerator";
6127 case DW_TAG_file_type
: return "DW_TAG_file_type";
6128 case DW_TAG_friend
: return "DW_TAG_friend";
6129 case DW_TAG_namelist
: return "DW_TAG_namelist";
6130 case DW_TAG_namelist_item
: return "DW_TAG_namelist_item";
6131 case DW_TAG_packed_type
: return "DW_TAG_packed_type";
6132 case DW_TAG_subprogram
: return "DW_TAG_subprogram";
6133 case DW_TAG_template_type_param
: return "DW_TAG_template_type_param";
6134 case DW_TAG_template_value_param
: return "DW_TAG_template_value_param";
6135 case DW_TAG_thrown_type
: return "DW_TAG_thrown_type";
6136 case DW_TAG_try_block
: return "DW_TAG_try_block";
6137 case DW_TAG_variant_part
: return "DW_TAG_variant_part";
6138 case DW_TAG_variable
: return "DW_TAG_variable";
6139 case DW_TAG_volatile_type
: return "DW_TAG_volatile_type";
6140 case DW_TAG_MIPS_loop
: return "DW_TAG_MIPS_loop";
6141 case DW_TAG_format_label
: return "DW_TAG_format_label";
6142 case DW_TAG_function_template
: return "DW_TAG_function_template";
6143 case DW_TAG_class_template
: return "DW_TAG_class_template";
6144 /* DWARF 2.1 values. */
6145 case DW_TAG_dwarf_procedure
: return "DW_TAG_dwarf_procedure";
6146 case DW_TAG_restrict_type
: return "DW_TAG_restrict_type";
6147 case DW_TAG_interface_type
: return "DW_TAG_interface_type";
6148 case DW_TAG_namespace
: return "DW_TAG_namespace";
6149 case DW_TAG_imported_module
: return "DW_TAG_imported_module";
6150 case DW_TAG_unspecified_type
: return "DW_TAG_unspecified_type";
6151 case DW_TAG_partial_unit
: return "DW_TAG_partial_unit";
6152 case DW_TAG_imported_unit
: return "DW_TAG_imported_unit";
6155 static char buffer
[100];
6157 sprintf (buffer
, _("Unknown TAG value: %lx"), tag
);
6164 get_AT_name (attribute
)
6165 unsigned long attribute
;
6169 case DW_AT_sibling
: return "DW_AT_sibling";
6170 case DW_AT_location
: return "DW_AT_location";
6171 case DW_AT_name
: return "DW_AT_name";
6172 case DW_AT_ordering
: return "DW_AT_ordering";
6173 case DW_AT_subscr_data
: return "DW_AT_subscr_data";
6174 case DW_AT_byte_size
: return "DW_AT_byte_size";
6175 case DW_AT_bit_offset
: return "DW_AT_bit_offset";
6176 case DW_AT_bit_size
: return "DW_AT_bit_size";
6177 case DW_AT_element_list
: return "DW_AT_element_list";
6178 case DW_AT_stmt_list
: return "DW_AT_stmt_list";
6179 case DW_AT_low_pc
: return "DW_AT_low_pc";
6180 case DW_AT_high_pc
: return "DW_AT_high_pc";
6181 case DW_AT_language
: return "DW_AT_language";
6182 case DW_AT_member
: return "DW_AT_member";
6183 case DW_AT_discr
: return "DW_AT_discr";
6184 case DW_AT_discr_value
: return "DW_AT_discr_value";
6185 case DW_AT_visibility
: return "DW_AT_visibility";
6186 case DW_AT_import
: return "DW_AT_import";
6187 case DW_AT_string_length
: return "DW_AT_string_length";
6188 case DW_AT_common_reference
: return "DW_AT_common_reference";
6189 case DW_AT_comp_dir
: return "DW_AT_comp_dir";
6190 case DW_AT_const_value
: return "DW_AT_const_value";
6191 case DW_AT_containing_type
: return "DW_AT_containing_type";
6192 case DW_AT_default_value
: return "DW_AT_default_value";
6193 case DW_AT_inline
: return "DW_AT_inline";
6194 case DW_AT_is_optional
: return "DW_AT_is_optional";
6195 case DW_AT_lower_bound
: return "DW_AT_lower_bound";
6196 case DW_AT_producer
: return "DW_AT_producer";
6197 case DW_AT_prototyped
: return "DW_AT_prototyped";
6198 case DW_AT_return_addr
: return "DW_AT_return_addr";
6199 case DW_AT_start_scope
: return "DW_AT_start_scope";
6200 case DW_AT_stride_size
: return "DW_AT_stride_size";
6201 case DW_AT_upper_bound
: return "DW_AT_upper_bound";
6202 case DW_AT_abstract_origin
: return "DW_AT_abstract_origin";
6203 case DW_AT_accessibility
: return "DW_AT_accessibility";
6204 case DW_AT_address_class
: return "DW_AT_address_class";
6205 case DW_AT_artificial
: return "DW_AT_artificial";
6206 case DW_AT_base_types
: return "DW_AT_base_types";
6207 case DW_AT_calling_convention
: return "DW_AT_calling_convention";
6208 case DW_AT_count
: return "DW_AT_count";
6209 case DW_AT_data_member_location
: return "DW_AT_data_member_location";
6210 case DW_AT_decl_column
: return "DW_AT_decl_column";
6211 case DW_AT_decl_file
: return "DW_AT_decl_file";
6212 case DW_AT_decl_line
: return "DW_AT_decl_line";
6213 case DW_AT_declaration
: return "DW_AT_declaration";
6214 case DW_AT_discr_list
: return "DW_AT_discr_list";
6215 case DW_AT_encoding
: return "DW_AT_encoding";
6216 case DW_AT_external
: return "DW_AT_external";
6217 case DW_AT_frame_base
: return "DW_AT_frame_base";
6218 case DW_AT_friend
: return "DW_AT_friend";
6219 case DW_AT_identifier_case
: return "DW_AT_identifier_case";
6220 case DW_AT_macro_info
: return "DW_AT_macro_info";
6221 case DW_AT_namelist_items
: return "DW_AT_namelist_items";
6222 case DW_AT_priority
: return "DW_AT_priority";
6223 case DW_AT_segment
: return "DW_AT_segment";
6224 case DW_AT_specification
: return "DW_AT_specification";
6225 case DW_AT_static_link
: return "DW_AT_static_link";
6226 case DW_AT_type
: return "DW_AT_type";
6227 case DW_AT_use_location
: return "DW_AT_use_location";
6228 case DW_AT_variable_parameter
: return "DW_AT_variable_parameter";
6229 case DW_AT_virtuality
: return "DW_AT_virtuality";
6230 case DW_AT_vtable_elem_location
: return "DW_AT_vtable_elem_location";
6231 /* DWARF 2.1 values. */
6232 case DW_AT_allocated
: return "DW_AT_allocated";
6233 case DW_AT_associated
: return "DW_AT_associated";
6234 case DW_AT_data_location
: return "DW_AT_data_location";
6235 case DW_AT_stride
: return "DW_AT_stride";
6236 case DW_AT_entry_pc
: return "DW_AT_entry_pc";
6237 case DW_AT_use_UTF8
: return "DW_AT_use_UTF8";
6238 case DW_AT_extension
: return "DW_AT_extension";
6239 case DW_AT_ranges
: return "DW_AT_ranges";
6240 case DW_AT_trampoline
: return "DW_AT_trampoline";
6241 case DW_AT_call_column
: return "DW_AT_call_column";
6242 case DW_AT_call_file
: return "DW_AT_call_file";
6243 case DW_AT_call_line
: return "DW_AT_call_line";
6244 /* SGI/MIPS extensions. */
6245 case DW_AT_MIPS_fde
: return "DW_AT_MIPS_fde";
6246 case DW_AT_MIPS_loop_begin
: return "DW_AT_MIPS_loop_begin";
6247 case DW_AT_MIPS_tail_loop_begin
: return "DW_AT_MIPS_tail_loop_begin";
6248 case DW_AT_MIPS_epilog_begin
: return "DW_AT_MIPS_epilog_begin";
6249 case DW_AT_MIPS_loop_unroll_factor
: return "DW_AT_MIPS_loop_unroll_factor";
6250 case DW_AT_MIPS_software_pipeline_depth
: return "DW_AT_MIPS_software_pipeline_depth";
6251 case DW_AT_MIPS_linkage_name
: return "DW_AT_MIPS_linkage_name";
6252 case DW_AT_MIPS_stride
: return "DW_AT_MIPS_stride";
6253 case DW_AT_MIPS_abstract_name
: return "DW_AT_MIPS_abstract_name";
6254 case DW_AT_MIPS_clone_origin
: return "DW_AT_MIPS_clone_origin";
6255 case DW_AT_MIPS_has_inlines
: return "DW_AT_MIPS_has_inlines";
6256 /* GNU extensions. */
6257 case DW_AT_sf_names
: return "DW_AT_sf_names";
6258 case DW_AT_src_info
: return "DW_AT_src_info";
6259 case DW_AT_mac_info
: return "DW_AT_mac_info";
6260 case DW_AT_src_coords
: return "DW_AT_src_coords";
6261 case DW_AT_body_begin
: return "DW_AT_body_begin";
6262 case DW_AT_body_end
: return "DW_AT_body_end";
6265 static char buffer
[100];
6267 sprintf (buffer
, _("Unknown AT value: %lx"), attribute
);
6274 get_FORM_name (form
)
6279 case DW_FORM_addr
: return "DW_FORM_addr";
6280 case DW_FORM_block2
: return "DW_FORM_block2";
6281 case DW_FORM_block4
: return "DW_FORM_block4";
6282 case DW_FORM_data2
: return "DW_FORM_data2";
6283 case DW_FORM_data4
: return "DW_FORM_data4";
6284 case DW_FORM_data8
: return "DW_FORM_data8";
6285 case DW_FORM_string
: return "DW_FORM_string";
6286 case DW_FORM_block
: return "DW_FORM_block";
6287 case DW_FORM_block1
: return "DW_FORM_block1";
6288 case DW_FORM_data1
: return "DW_FORM_data1";
6289 case DW_FORM_flag
: return "DW_FORM_flag";
6290 case DW_FORM_sdata
: return "DW_FORM_sdata";
6291 case DW_FORM_strp
: return "DW_FORM_strp";
6292 case DW_FORM_udata
: return "DW_FORM_udata";
6293 case DW_FORM_ref_addr
: return "DW_FORM_ref_addr";
6294 case DW_FORM_ref1
: return "DW_FORM_ref1";
6295 case DW_FORM_ref2
: return "DW_FORM_ref2";
6296 case DW_FORM_ref4
: return "DW_FORM_ref4";
6297 case DW_FORM_ref8
: return "DW_FORM_ref8";
6298 case DW_FORM_ref_udata
: return "DW_FORM_ref_udata";
6299 case DW_FORM_indirect
: return "DW_FORM_indirect";
6302 static char buffer
[100];
6304 sprintf (buffer
, _("Unknown FORM value: %lx"), form
);
6310 static const char *debug_str
;
6311 static bfd_vma debug_str_size
;
6313 /* FIXME: There are better and more effiecint ways to handle
6314 these structures. For now though, I just want something that
6315 is simple to implement. */
6316 typedef struct abbrev_attr
6318 unsigned long attribute
;
6320 struct abbrev_attr
* next
;
6324 typedef struct abbrev_entry
6326 unsigned long entry
;
6329 struct abbrev_attr
* first_attr
;
6330 struct abbrev_attr
* last_attr
;
6331 struct abbrev_entry
* next
;
6335 static abbrev_entry
* first_abbrev
= NULL
;
6336 static abbrev_entry
* last_abbrev
= NULL
;
6339 free_abbrevs
PARAMS ((void))
6341 abbrev_entry
* abbrev
;
6343 for (abbrev
= first_abbrev
; abbrev
;)
6345 abbrev_entry
* next
= abbrev
->next
;
6348 for (attr
= abbrev
->first_attr
; attr
;)
6350 abbrev_attr
* next
= attr
->next
;
6360 last_abbrev
= first_abbrev
= NULL
;
6364 add_abbrev (number
, tag
, children
)
6365 unsigned long number
;
6369 abbrev_entry
* entry
;
6371 entry
= (abbrev_entry
*) malloc (sizeof (* entry
));
6377 entry
->entry
= number
;
6379 entry
->children
= children
;
6380 entry
->first_attr
= NULL
;
6381 entry
->last_attr
= NULL
;
6384 if (first_abbrev
== NULL
)
6385 first_abbrev
= entry
;
6387 last_abbrev
->next
= entry
;
6389 last_abbrev
= entry
;
6393 add_abbrev_attr (attribute
, form
)
6394 unsigned long attribute
;
6399 attr
= (abbrev_attr
*) malloc (sizeof (* attr
));
6405 attr
->attribute
= attribute
;
6409 if (last_abbrev
->first_attr
== NULL
)
6410 last_abbrev
->first_attr
= attr
;
6412 last_abbrev
->last_attr
->next
= attr
;
6414 last_abbrev
->last_attr
= attr
;
6417 /* Processes the (partial) contents of a .debug_abbrev section.
6418 Returns NULL if the end of the section was encountered.
6419 Returns the address after the last byte read if the end of
6420 an abbreviation set was found. */
6422 static unsigned char *
6423 process_abbrev_section (start
, end
)
6424 unsigned char * start
;
6425 unsigned char * end
;
6427 if (first_abbrev
!= NULL
)
6433 unsigned long entry
;
6435 unsigned long attribute
;
6438 entry
= read_leb128 (start
, & bytes_read
, 0);
6439 start
+= bytes_read
;
6441 /* A single zero is supposed to end the section according
6442 to the standard. If there's more, then signal that to
6445 return start
== end
? NULL
: start
;
6447 tag
= read_leb128 (start
, & bytes_read
, 0);
6448 start
+= bytes_read
;
6450 children
= * start
++;
6452 add_abbrev (entry
, tag
, children
);
6458 attribute
= read_leb128 (start
, & bytes_read
, 0);
6459 start
+= bytes_read
;
6461 form
= read_leb128 (start
, & bytes_read
, 0);
6462 start
+= bytes_read
;
6465 add_abbrev_attr (attribute
, form
);
6467 while (attribute
!= 0);
6475 display_debug_macinfo (section
, start
, file
)
6476 Elf32_Internal_Shdr
* section
;
6477 unsigned char * start
;
6478 FILE * file ATTRIBUTE_UNUSED
;
6480 unsigned char * end
= start
+ section
->sh_size
;
6481 unsigned char * curr
= start
;
6482 unsigned int bytes_read
;
6483 enum dwarf_macinfo_record_type op
;
6485 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6489 unsigned int lineno
;
6490 const char * string
;
6497 case DW_MACINFO_start_file
:
6499 unsigned int filenum
;
6501 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6503 filenum
= read_leb128 (curr
, & bytes_read
, 0);
6506 printf (_(" DW_MACINFO_start_file - lineno: %d filenum: %d\n"), lineno
, filenum
);
6510 case DW_MACINFO_end_file
:
6511 printf (_(" DW_MACINFO_end_file\n"));
6514 case DW_MACINFO_define
:
6515 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6518 curr
+= strlen (string
) + 1;
6519 printf (_(" DW_MACINFO_define - lineno : %d macro : %s\n"), lineno
, string
);
6522 case DW_MACINFO_undef
:
6523 lineno
= read_leb128 (curr
, & bytes_read
, 0);
6526 curr
+= strlen (string
) + 1;
6527 printf (_(" DW_MACINFO_undef - lineno : %d macro : %s\n"), lineno
, string
);
6530 case DW_MACINFO_vendor_ext
:
6532 unsigned int constant
;
6534 constant
= read_leb128 (curr
, & bytes_read
, 0);
6537 curr
+= strlen (string
) + 1;
6538 printf (_(" DW_MACINFO_vendor_ext - constant : %d string : %s\n"), constant
, string
);
6549 display_debug_abbrev (section
, start
, file
)
6550 Elf32_Internal_Shdr
* section
;
6551 unsigned char * start
;
6552 FILE * file ATTRIBUTE_UNUSED
;
6554 abbrev_entry
* entry
;
6555 unsigned char * end
= start
+ section
->sh_size
;
6557 printf (_("Contents of the %s section:\n\n"), SECTION_NAME (section
));
6561 start
= process_abbrev_section (start
, end
);
6563 if (first_abbrev
== NULL
)
6566 printf (_(" Number TAG\n"));
6568 for (entry
= first_abbrev
; entry
; entry
= entry
->next
)
6572 printf (_(" %ld %s [%s]\n"),
6574 get_TAG_name (entry
->tag
),
6575 entry
->children
? _("has children") : _("no children"));
6577 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
6579 printf (_(" %-18s %s\n"),
6580 get_AT_name (attr
->attribute
),
6581 get_FORM_name (attr
->form
));
6595 static unsigned char *
6596 display_block (data
, length
)
6597 unsigned char * data
;
6598 unsigned long length
;
6600 printf (_(" %lu byte block: "), length
);
6603 printf ("%lx ", (unsigned long) byte_get (data
++, 1));
6609 decode_location_expression (data
, pointer_size
, length
)
6610 unsigned char * data
;
6611 unsigned int pointer_size
;
6612 unsigned long length
;
6616 unsigned long uvalue
;
6617 unsigned char * end
= data
+ length
;
6626 printf ("DW_OP_addr: %lx",
6627 (unsigned long) byte_get (data
, pointer_size
));
6628 data
+= pointer_size
;
6631 printf ("DW_OP_deref");
6634 printf ("DW_OP_const1u: %lu", (unsigned long) byte_get (data
++, 1));
6637 printf ("DW_OP_const1s: %ld", (long) byte_get (data
++, 1));
6640 printf ("DW_OP_const2u: %lu", (unsigned long) byte_get (data
, 2));
6644 printf ("DW_OP_const2s: %ld", (long) byte_get (data
, 2));
6648 printf ("DW_OP_const4u: %lu", (unsigned long) byte_get (data
, 4));
6652 printf ("DW_OP_const4s: %ld", (long) byte_get (data
, 4));
6656 printf ("DW_OP_const8u: %lu %lu", (unsigned long) byte_get (data
, 4),
6657 (unsigned long) byte_get (data
+ 4, 4));
6661 printf ("DW_OP_const8s: %ld %ld", (long) byte_get (data
, 4),
6662 (long) byte_get (data
+ 4, 4));
6666 printf ("DW_OP_constu: %lu", read_leb128 (data
, &bytes_read
, 0));
6670 printf ("DW_OP_consts: %ld", read_leb128 (data
, &bytes_read
, 1));
6674 printf ("DW_OP_dup");
6677 printf ("DW_OP_drop");
6680 printf ("DW_OP_over");
6683 printf ("DW_OP_pick: %ld", (unsigned long) byte_get (data
++, 1));
6686 printf ("DW_OP_swap");
6689 printf ("DW_OP_rot");
6692 printf ("DW_OP_xderef");
6695 printf ("DW_OP_abs");
6698 printf ("DW_OP_and");
6701 printf ("DW_OP_div");
6704 printf ("DW_OP_minus");
6707 printf ("DW_OP_mod");
6710 printf ("DW_OP_mul");
6713 printf ("DW_OP_neg");
6716 printf ("DW_OP_not");
6719 printf ("DW_OP_or");
6722 printf ("DW_OP_plus");
6724 case DW_OP_plus_uconst
:
6725 printf ("DW_OP_plus_uconst: %lu",
6726 read_leb128 (data
, &bytes_read
, 0));
6730 printf ("DW_OP_shl");
6733 printf ("DW_OP_shr");
6736 printf ("DW_OP_shra");
6739 printf ("DW_OP_xor");
6742 printf ("DW_OP_bra: %ld", (long) byte_get (data
, 2));
6746 printf ("DW_OP_eq");
6749 printf ("DW_OP_ge");
6752 printf ("DW_OP_gt");
6755 printf ("DW_OP_le");
6758 printf ("DW_OP_lt");
6761 printf ("DW_OP_ne");
6764 printf ("DW_OP_skip: %ld", (long) byte_get (data
, 2));
6800 printf ("DW_OP_lit%d", op
- DW_OP_lit0
);
6835 printf ("DW_OP_reg%d", op
- DW_OP_reg0
);
6870 printf ("DW_OP_breg%d: %ld", op
- DW_OP_breg0
,
6871 read_leb128 (data
, &bytes_read
, 1));
6876 printf ("DW_OP_regx: %lu", read_leb128 (data
, &bytes_read
, 0));
6880 printf ("DW_OP_fbreg: %ld", read_leb128 (data
, &bytes_read
, 1));
6884 uvalue
= read_leb128 (data
, &bytes_read
, 0);
6886 printf ("DW_OP_bregx: %lu %ld", uvalue
,
6887 read_leb128 (data
, &bytes_read
, 1));
6891 printf ("DW_OP_piece: %lu", read_leb128 (data
, &bytes_read
, 0));
6894 case DW_OP_deref_size
:
6895 printf ("DW_OP_deref_size: %ld", (long) byte_get (data
++, 1));
6897 case DW_OP_xderef_size
:
6898 printf ("DW_OP_xderef_size: %ld", (long) byte_get (data
++, 1));
6901 printf ("DW_OP_nop");
6904 /* DWARF 2.1 extensions. */
6905 case DW_OP_push_object_address
:
6906 printf ("DW_OP_push_object_address");
6909 printf ("DW_OP_call2: <%lx>", (long) byte_get (data
, 2));
6913 printf ("DW_OP_call4: <%lx>", (long) byte_get (data
, 4));
6917 printf ("DW_OP_calli");
6921 if (op
>= DW_OP_lo_user
6922 && op
<= DW_OP_hi_user
)
6923 printf (_("(User defined location op)"));
6925 printf (_("(Unknown location op)"));
6926 /* No way to tell where the next op is, so just bail. */
6930 /* Separate the ops. */
6936 static unsigned char *
6937 read_and_display_attr_value (attribute
, form
, data
, cu_offset
, pointer_size
)
6938 unsigned long attribute
;
6940 unsigned char * data
;
6941 unsigned long cu_offset
;
6942 unsigned long pointer_size
;
6944 unsigned long uvalue
= 0;
6945 unsigned char * block_start
= NULL
;
6953 case DW_FORM_ref_addr
:
6955 uvalue
= byte_get (data
, pointer_size
);
6956 data
+= pointer_size
;
6960 uvalue
= byte_get (data
, /* offset_size */ 4);
6961 data
+= /* offset_size */ 4;
6967 uvalue
= byte_get (data
++, 1);
6972 uvalue
= byte_get (data
, 2);
6978 uvalue
= byte_get (data
, 4);
6983 uvalue
= read_leb128 (data
, & bytes_read
, 1);
6987 case DW_FORM_ref_udata
:
6989 uvalue
= read_leb128 (data
, & bytes_read
, 0);
6993 case DW_FORM_indirect
:
6994 form
= read_leb128 (data
, & bytes_read
, 0);
6996 printf (" %s", get_FORM_name (form
));
6997 return read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7003 case DW_FORM_ref_addr
:
7004 printf (" <#%lx>", uvalue
);
7010 case DW_FORM_ref_udata
:
7011 printf (" <%lx>", uvalue
+ cu_offset
);
7015 printf (" %#lx", uvalue
);
7023 printf (" %ld", uvalue
);
7028 uvalue
= byte_get (data
, 4);
7029 printf (" %lx", uvalue
);
7030 printf (" %lx", (unsigned long) byte_get (data
+ 4, 4));
7034 case DW_FORM_string
:
7035 printf (" %s", data
);
7036 data
+= strlen ((char *) data
) + 1;
7040 uvalue
= read_leb128 (data
, & bytes_read
, 0);
7041 block_start
= data
+ bytes_read
;
7042 data
= display_block (block_start
, uvalue
);
7045 case DW_FORM_block1
:
7046 uvalue
= byte_get (data
, 1);
7047 block_start
= data
+ 1;
7048 data
= display_block (block_start
, uvalue
);
7051 case DW_FORM_block2
:
7052 uvalue
= byte_get (data
, 2);
7053 block_start
= data
+ 2;
7054 data
= display_block (block_start
, uvalue
);
7057 case DW_FORM_block4
:
7058 uvalue
= byte_get (data
, 4);
7059 block_start
= data
+ 4;
7060 data
= display_block (block_start
, uvalue
);
7064 if (debug_str
== NULL
)
7065 warn (_("DW_FORM_strp used but no .debug_str section\n"));
7066 else if (uvalue
>= debug_str_size
)
7067 warn (_("DW_FORM_strp %lx points outside of .debug_str section\n"),
7070 printf (" %s", debug_str
+ uvalue
);
7073 case DW_FORM_indirect
:
7078 warn (_("Unrecognised form: %d\n"), form
);
7082 /* For some attributes we can display futher information. */
7091 case DW_INL_not_inlined
: printf (_("(not inlined)")); break;
7092 case DW_INL_inlined
: printf (_("(inlined)")); break;
7093 case DW_INL_declared_not_inlined
: printf (_("(declared as inline but ignored)")); break;
7094 case DW_INL_declared_inlined
: printf (_("(declared as inline and inlined)")); break;
7095 default: printf (_(" (Unknown inline attribute value: %lx)"), uvalue
); break;
7099 case DW_AT_language
:
7102 case DW_LANG_C
: printf ("(non-ANSI C)"); break;
7103 case DW_LANG_C89
: printf ("(ANSI C)"); break;
7104 case DW_LANG_C_plus_plus
: printf ("(C++)"); break;
7105 case DW_LANG_Fortran77
: printf ("(FORTRAN 77)"); break;
7106 case DW_LANG_Fortran90
: printf ("(Fortran 90)"); break;
7107 case DW_LANG_Modula2
: printf ("(Modula 2)"); break;
7108 case DW_LANG_Pascal83
: printf ("(ANSI Pascal)"); break;
7109 case DW_LANG_Ada83
: printf ("(Ada)"); break;
7110 case DW_LANG_Cobol74
: printf ("(Cobol 74)"); break;
7111 case DW_LANG_Cobol85
: printf ("(Cobol 85)"); break;
7112 /* DWARF 2.1 values. */
7113 case DW_LANG_C99
: printf ("(ANSI C99)"); break;
7114 case DW_LANG_Ada95
: printf ("(ADA 95)"); break;
7115 case DW_LANG_Fortran95
: printf ("(Fortran 95)"); break;
7116 /* MIPS extension. */
7117 case DW_LANG_Mips_Assembler
: printf ("(MIPS assembler)"); break;
7118 default: printf ("(Unknown: %lx)", uvalue
); break;
7122 case DW_AT_encoding
:
7125 case DW_ATE_void
: printf ("(void)"); break;
7126 case DW_ATE_address
: printf ("(machine address)"); break;
7127 case DW_ATE_boolean
: printf ("(boolean)"); break;
7128 case DW_ATE_complex_float
: printf ("(complex float)"); break;
7129 case DW_ATE_float
: printf ("(float)"); break;
7130 case DW_ATE_signed
: printf ("(signed)"); break;
7131 case DW_ATE_signed_char
: printf ("(signed char)"); break;
7132 case DW_ATE_unsigned
: printf ("(unsigned)"); break;
7133 case DW_ATE_unsigned_char
: printf ("(unsigned char)"); break;
7134 /* DWARF 2.1 value. */
7135 case DW_ATE_imaginary_float
: printf ("(imaginary float)"); break;
7137 if (uvalue
>= DW_ATE_lo_user
7138 && uvalue
<= DW_ATE_hi_user
)
7139 printf ("(user defined type)");
7141 printf ("(unknown type)");
7146 case DW_AT_accessibility
:
7149 case DW_ACCESS_public
: printf ("(public)"); break;
7150 case DW_ACCESS_protected
: printf ("(protected)"); break;
7151 case DW_ACCESS_private
: printf ("(private)"); break;
7152 default: printf ("(unknown accessibility)"); break;
7156 case DW_AT_visibility
:
7159 case DW_VIS_local
: printf ("(local)"); break;
7160 case DW_VIS_exported
: printf ("(exported)"); break;
7161 case DW_VIS_qualified
: printf ("(qualified)"); break;
7162 default: printf ("(unknown visibility)"); break;
7166 case DW_AT_virtuality
:
7169 case DW_VIRTUALITY_none
: printf ("(none)"); break;
7170 case DW_VIRTUALITY_virtual
: printf ("(virtual)"); break;
7171 case DW_VIRTUALITY_pure_virtual
:printf ("(pure_virtual)"); break;
7172 default: printf ("(unknown virtuality)"); break;
7176 case DW_AT_identifier_case
:
7179 case DW_ID_case_sensitive
: printf ("(case_sensitive)"); break;
7180 case DW_ID_up_case
: printf ("(up_case)"); break;
7181 case DW_ID_down_case
: printf ("(down_case)"); break;
7182 case DW_ID_case_insensitive
: printf ("(case_insensitive)"); break;
7183 default: printf ("(unknown case)"); break;
7187 case DW_AT_calling_convention
:
7190 case DW_CC_normal
: printf ("(normal)"); break;
7191 case DW_CC_program
: printf ("(program)"); break;
7192 case DW_CC_nocall
: printf ("(nocall)"); break;
7194 if (uvalue
>= DW_CC_lo_user
7195 && uvalue
<= DW_CC_hi_user
)
7196 printf ("(user defined)");
7198 printf ("(unknown convention)");
7202 case DW_AT_ordering
:
7205 case -1: printf ("(undefined)"); break;
7206 case 0: printf ("(row major)"); break;
7207 case 1: printf ("(column major)"); break;
7211 case DW_AT_frame_base
:
7212 case DW_AT_location
:
7213 case DW_AT_data_member_location
:
7214 case DW_AT_vtable_elem_location
:
7215 case DW_AT_allocated
:
7216 case DW_AT_associated
:
7217 case DW_AT_data_location
:
7219 case DW_AT_upper_bound
:
7220 case DW_AT_lower_bound
:
7224 decode_location_expression (block_start
, pointer_size
, uvalue
);
7236 static unsigned char *
7237 read_and_display_attr (attribute
, form
, data
, cu_offset
, pointer_size
)
7238 unsigned long attribute
;
7240 unsigned char * data
;
7241 unsigned long cu_offset
;
7242 unsigned long pointer_size
;
7244 printf (" %-18s:", get_AT_name (attribute
));
7245 data
= read_and_display_attr_value (attribute
, form
, data
, cu_offset
,
7252 display_debug_info (section
, start
, file
)
7253 Elf32_Internal_Shdr
* section
;
7254 unsigned char * start
;
7257 unsigned char * end
= start
+ section
->sh_size
;
7258 unsigned char * section_begin
= start
;
7260 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7263 Elf32_Internal_Shdr
* sec
;
7266 /* Locate the .debug_str section and read it. */
7267 for (i
= 0, sec
= section_headers
;
7268 i
< elf_header
.e_shnum
;
7270 if (strcmp (SECTION_NAME (sec
), ".debug_str") == 0 && sec
->sh_size
!= 0)
7272 debug_str
= (const char *)
7273 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7274 _("debug_str section data"));
7275 debug_str_size
= sec
->sh_size
;
7282 DWARF2_External_CompUnit
* external
;
7283 DWARF2_Internal_CompUnit compunit
;
7284 Elf32_Internal_Shdr
* relsec
;
7285 unsigned char * tags
;
7288 unsigned long cu_offset
;
7290 external
= (DWARF2_External_CompUnit
*) start
;
7292 compunit
.cu_length
= BYTE_GET (external
->cu_length
);
7293 compunit
.cu_version
= BYTE_GET (external
->cu_version
);
7294 compunit
.cu_abbrev_offset
= BYTE_GET (external
->cu_abbrev_offset
);
7295 compunit
.cu_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
7297 if (compunit
.cu_length
== 0xffffffff)
7299 warn (_("64-bit DWARF debug info is not supported yet.\n"));
7303 /* Check for RELA relocations in the abbrev_offset address, and
7305 for (relsec
= section_headers
;
7306 relsec
< section_headers
+ elf_header
.e_shnum
;
7309 unsigned long nrelas
, nsyms
;
7310 Elf_Internal_Rela
*rela
, *rp
;
7311 Elf32_Internal_Shdr
*symsec
;
7312 Elf_Internal_Sym
*symtab
;
7313 Elf_Internal_Sym
*sym
;
7315 if (relsec
->sh_type
!= SHT_RELA
7316 || section_headers
+ relsec
->sh_info
!= section
)
7319 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7323 symsec
= section_headers
+ relsec
->sh_link
;
7324 nsyms
= symsec
->sh_size
/ symsec
->sh_entsize
;
7325 symtab
= GET_ELF_SYMBOLS (file
, symsec
->sh_offset
, nsyms
);
7327 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7330 != (bfd_vma
) ((unsigned char *) &external
->cu_abbrev_offset
7336 sym
= symtab
+ ELF32_R_SYM (rp
->r_info
);
7338 if (ELF32_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7340 warn (_("Skipping unexpected symbol type %u\n"),
7341 ELF32_ST_TYPE (sym
->st_info
));
7347 sym
= symtab
+ ELF64_R_SYM (rp
->r_info
);
7349 if (ELF64_ST_TYPE (sym
->st_info
) != STT_SECTION
)
7351 warn (_("Skipping unexpected symbol type %u\n"),
7352 ELF64_ST_TYPE (sym
->st_info
));
7357 compunit
.cu_abbrev_offset
+= rp
->r_addend
;
7365 tags
= start
+ sizeof (* external
);
7366 cu_offset
= start
- section_begin
;
7367 start
+= compunit
.cu_length
+ sizeof (external
->cu_length
);
7369 printf (_(" Compilation Unit @ %lx:\n"), cu_offset
);
7370 printf (_(" Length: %ld\n"), compunit
.cu_length
);
7371 printf (_(" Version: %d\n"), compunit
.cu_version
);
7372 printf (_(" Abbrev Offset: %ld\n"), compunit
.cu_abbrev_offset
);
7373 printf (_(" Pointer Size: %d\n"), compunit
.cu_pointer_size
);
7375 if (compunit
.cu_version
!= 2)
7377 warn (_("Only version 2 DWARF debug information is currently supported.\n"));
7381 if (first_abbrev
!= NULL
)
7384 /* Read in the abbrevs used by this compilation unit. */
7387 Elf32_Internal_Shdr
* sec
;
7388 unsigned char * begin
;
7390 /* Locate the .debug_abbrev section and process it. */
7391 for (i
= 0, sec
= section_headers
;
7392 i
< elf_header
.e_shnum
;
7394 if (strcmp (SECTION_NAME (sec
), ".debug_abbrev") == 0)
7397 if (i
== elf_header
.e_shnum
|| sec
->sh_size
== 0)
7399 warn (_("Unable to locate .debug_abbrev section!\n"));
7403 begin
= ((unsigned char *)
7404 get_data (NULL
, file
, sec
->sh_offset
, sec
->sh_size
,
7405 _("debug_abbrev section data")));
7409 process_abbrev_section (begin
+ compunit
.cu_abbrev_offset
,
7410 begin
+ sec
->sh_size
);
7416 while (tags
< start
)
7419 unsigned long abbrev_number
;
7420 abbrev_entry
* entry
;
7423 abbrev_number
= read_leb128 (tags
, & bytes_read
, 0);
7426 /* A null DIE marks the end of a list of children. */
7427 if (abbrev_number
== 0)
7433 /* Scan through the abbreviation list until we reach the
7435 for (entry
= first_abbrev
;
7436 entry
&& entry
->entry
!= abbrev_number
;
7437 entry
= entry
->next
)
7442 warn (_("Unable to locate entry %lu in the abbreviation table\n"),
7447 printf (_(" <%d><%lx>: Abbrev Number: %lu (%s)\n"),
7449 (unsigned long) (tags
- section_begin
- bytes_read
),
7451 get_TAG_name (entry
->tag
));
7453 for (attr
= entry
->first_attr
; attr
; attr
= attr
->next
)
7454 tags
= read_and_display_attr (attr
->attribute
,
7457 compunit
.cu_pointer_size
);
7459 if (entry
->children
)
7464 if (debug_str
!= NULL
)
7466 free ((char *) debug_str
);
7476 display_debug_aranges (section
, start
, file
)
7477 Elf32_Internal_Shdr
* section
;
7478 unsigned char * start
;
7479 FILE * file ATTRIBUTE_UNUSED
;
7481 unsigned char * end
= start
+ section
->sh_size
;
7483 printf (_("The section %s contains:\n\n"), SECTION_NAME (section
));
7487 DWARF2_External_ARange
* external
;
7488 DWARF2_Internal_ARange arange
;
7489 unsigned char * ranges
;
7490 unsigned long length
;
7491 unsigned long address
;
7494 external
= (DWARF2_External_ARange
*) start
;
7496 arange
.ar_length
= BYTE_GET (external
->ar_length
);
7497 arange
.ar_version
= BYTE_GET (external
->ar_version
);
7498 arange
.ar_info_offset
= BYTE_GET (external
->ar_info_offset
);
7499 arange
.ar_pointer_size
= BYTE_GET (external
->ar_pointer_size
);
7500 arange
.ar_segment_size
= BYTE_GET (external
->ar_segment_size
);
7502 if (arange
.ar_length
== 0xffffffff)
7504 warn (_("64-bit DWARF aranges are not supported yet.\n"));
7508 if (arange
.ar_version
!= 2)
7510 warn (_("Only DWARF 2 aranges are currently supported.\n"));
7514 printf (_(" Length: %ld\n"), arange
.ar_length
);
7515 printf (_(" Version: %d\n"), arange
.ar_version
);
7516 printf (_(" Offset into .debug_info: %lx\n"), arange
.ar_info_offset
);
7517 printf (_(" Pointer Size: %d\n"), arange
.ar_pointer_size
);
7518 printf (_(" Segment Size: %d\n"), arange
.ar_segment_size
);
7520 printf (_("\n Address Length\n"));
7522 ranges
= start
+ sizeof (* external
);
7524 /* Must pad to an alignment boundary that is twice the pointer size. */
7525 excess
= sizeof (* external
) % (2 * arange
.ar_pointer_size
);
7527 ranges
+= (2 * arange
.ar_pointer_size
) - excess
;
7531 address
= byte_get (ranges
, arange
.ar_pointer_size
);
7533 ranges
+= arange
.ar_pointer_size
;
7535 length
= byte_get (ranges
, arange
.ar_pointer_size
);
7537 ranges
+= arange
.ar_pointer_size
;
7539 /* A pair of zeros marks the end of the list. */
7540 if (address
== 0 && length
== 0)
7543 printf (" %8.8lx %lu\n", address
, length
);
7546 start
+= arange
.ar_length
+ sizeof (external
->ar_length
);
7554 typedef struct Frame_Chunk
7556 struct Frame_Chunk
* next
;
7557 unsigned char * chunk_start
;
7559 /* DW_CFA_{undefined,same_value,offset,register,unreferenced} */
7560 short int * col_type
;
7562 char * augmentation
;
7563 unsigned int code_factor
;
7565 unsigned long pc_begin
;
7566 unsigned long pc_range
;
7570 unsigned char fde_encoding
;
7574 /* A marker for a col_type that means this column was never referenced
7575 in the frame info. */
7576 #define DW_CFA_unreferenced (-1)
7578 static void frame_need_space
PARAMS ((Frame_Chunk
*, int));
7579 static void frame_display_row
PARAMS ((Frame_Chunk
*, int *, int *));
7580 static int size_of_encoded_value
PARAMS ((int));
7583 frame_need_space (fc
, reg
)
7587 int prev
= fc
->ncols
;
7589 if (reg
< fc
->ncols
)
7592 fc
->ncols
= reg
+ 1;
7593 fc
->col_type
= (short int *) xrealloc (fc
->col_type
,
7594 fc
->ncols
* sizeof (short int));
7595 fc
->col_offset
= (int *) xrealloc (fc
->col_offset
,
7596 fc
->ncols
* sizeof (int));
7598 while (prev
< fc
->ncols
)
7600 fc
->col_type
[prev
] = DW_CFA_unreferenced
;
7601 fc
->col_offset
[prev
] = 0;
7607 frame_display_row (fc
, need_col_headers
, max_regs
)
7609 int * need_col_headers
;
7615 if (* max_regs
< fc
->ncols
)
7616 * max_regs
= fc
->ncols
;
7618 if (* need_col_headers
)
7620 * need_col_headers
= 0;
7622 printf (" LOC CFA ");
7624 for (r
= 0; r
< * max_regs
; r
++)
7625 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7630 printf ("r%-4d", r
);
7636 printf ("%08lx ", fc
->pc_begin
);
7637 sprintf (tmp
, "r%d%+d", fc
->cfa_reg
, fc
->cfa_offset
);
7638 printf ("%-8s ", tmp
);
7640 for (r
= 0; r
< fc
->ncols
; r
++)
7642 if (fc
->col_type
[r
] != DW_CFA_unreferenced
)
7644 switch (fc
->col_type
[r
])
7646 case DW_CFA_undefined
:
7649 case DW_CFA_same_value
:
7653 sprintf (tmp
, "c%+d", fc
->col_offset
[r
]);
7655 case DW_CFA_register
:
7656 sprintf (tmp
, "r%d", fc
->col_offset
[r
]);
7659 strcpy (tmp
, "n/a");
7662 printf ("%-5s", tmp
);
7669 size_of_encoded_value (encoding
)
7672 switch (encoding
& 0x7)
7675 case 0: return is_32bit_elf
? 4 : 8;
7682 #define GET(N) byte_get (start, N); start += N
7683 #define LEB() read_leb128 (start, & length_return, 0); start += length_return
7684 #define SLEB() read_leb128 (start, & length_return, 1); start += length_return
7687 display_debug_frames (section
, start
, file
)
7688 Elf32_Internal_Shdr
* section
;
7689 unsigned char * start
;
7690 FILE * file ATTRIBUTE_UNUSED
;
7692 unsigned char * end
= start
+ section
->sh_size
;
7693 unsigned char * section_start
= start
;
7694 Frame_Chunk
* chunks
= 0;
7695 Frame_Chunk
* remembered_state
= 0;
7697 int is_eh
= (strcmp (SECTION_NAME (section
), ".eh_frame") == 0);
7700 int addr_size
= is_32bit_elf
? 4 : 8;
7702 printf (_("The section %s contains:\n"), SECTION_NAME (section
));
7706 unsigned char * saved_start
;
7707 unsigned char * block_end
;
7708 unsigned long length
;
7709 unsigned long cie_id
;
7712 int need_col_headers
= 1;
7713 unsigned char * augmentation_data
= NULL
;
7714 unsigned long augmentation_data_len
= 0;
7715 int encoded_ptr_size
= addr_size
;
7717 saved_start
= start
;
7718 length
= byte_get (start
, 4); start
+= 4;
7723 if (length
== 0xffffffff)
7725 warn (_("64-bit DWARF format frames are not supported yet.\n"));
7729 block_end
= saved_start
+ length
+ 4;
7730 cie_id
= byte_get (start
, 4); start
+= 4;
7732 if (is_eh
? (cie_id
== 0) : (cie_id
== DW_CIE_ID
))
7736 fc
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
7737 memset (fc
, 0, sizeof (Frame_Chunk
));
7741 fc
->chunk_start
= saved_start
;
7743 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7744 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7745 frame_need_space (fc
, max_regs
-1);
7749 fc
->augmentation
= start
;
7750 start
= strchr (start
, '\0') + 1;
7752 if (fc
->augmentation
[0] == 'z')
7754 fc
->code_factor
= LEB ();
7755 fc
->data_factor
= SLEB ();
7756 fc
->ra
= byte_get (start
, 1); start
+= 1;
7757 augmentation_data_len
= LEB ();
7758 augmentation_data
= start
;
7759 start
+= augmentation_data_len
;
7761 else if (strcmp (fc
->augmentation
, "eh") == 0)
7764 fc
->code_factor
= LEB ();
7765 fc
->data_factor
= SLEB ();
7766 fc
->ra
= byte_get (start
, 1); start
+= 1;
7770 fc
->code_factor
= LEB ();
7771 fc
->data_factor
= SLEB ();
7772 fc
->ra
= byte_get (start
, 1); start
+= 1;
7776 if (do_debug_frames_interp
)
7777 printf ("\n%08lx %08lx %08lx CIE \"%s\" cf=%d df=%d ra=%d\n",
7778 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
7779 fc
->augmentation
, fc
->code_factor
, fc
->data_factor
,
7783 printf ("\n%08lx %08lx %08lx CIE\n",
7784 (unsigned long)(saved_start
- section_start
), length
, cie_id
);
7785 printf (" Version: %d\n", version
);
7786 printf (" Augmentation: \"%s\"\n", fc
->augmentation
);
7787 printf (" Code alignment factor: %u\n", fc
->code_factor
);
7788 printf (" Data alignment factor: %d\n", fc
->data_factor
);
7789 printf (" Return address column: %d\n", fc
->ra
);
7791 if (augmentation_data_len
)
7794 printf (" Augmentation data: ");
7795 for (i
= 0; i
< augmentation_data_len
; ++i
)
7796 printf (" %02x", augmentation_data
[i
]);
7802 if (augmentation_data_len
)
7804 unsigned char *p
, *q
;
7805 p
= fc
->augmentation
+ 1;
7806 q
= augmentation_data
;
7813 q
+= 1 + size_of_encoded_value (*q
);
7815 fc
->fde_encoding
= *q
++;
7821 if (fc
->fde_encoding
)
7822 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7825 frame_need_space (fc
, fc
->ra
);
7829 unsigned char * look_for
;
7830 static Frame_Chunk fde_fc
;
7833 memset (fc
, 0, sizeof (Frame_Chunk
));
7835 look_for
= is_eh
? start
- 4 - cie_id
: section_start
+ cie_id
;
7837 for (cie
= chunks
; cie
; cie
= cie
->next
)
7838 if (cie
->chunk_start
== look_for
)
7843 warn ("Invalid CIE pointer %08lx in FDE at %08lx\n",
7844 cie_id
, saved_start
);
7847 fc
->col_type
= (short int *) xmalloc (sizeof (short int));
7848 fc
->col_offset
= (int *) xmalloc (sizeof (int));
7849 frame_need_space (fc
, max_regs
- 1);
7851 fc
->augmentation
= "";
7852 fc
->fde_encoding
= 0;
7856 fc
->ncols
= cie
->ncols
;
7857 fc
->col_type
= (short int *) xmalloc (fc
->ncols
* sizeof (short int));
7858 fc
->col_offset
= (int *) xmalloc (fc
->ncols
* sizeof (int));
7859 memcpy (fc
->col_type
, cie
->col_type
, fc
->ncols
* sizeof (short int));
7860 memcpy (fc
->col_offset
, cie
->col_offset
, fc
->ncols
* sizeof (int));
7861 fc
->augmentation
= cie
->augmentation
;
7862 fc
->code_factor
= cie
->code_factor
;
7863 fc
->data_factor
= cie
->data_factor
;
7864 fc
->cfa_reg
= cie
->cfa_reg
;
7865 fc
->cfa_offset
= cie
->cfa_offset
;
7867 frame_need_space (fc
, max_regs
-1);
7868 fc
->fde_encoding
= cie
->fde_encoding
;
7871 if (fc
->fde_encoding
)
7872 encoded_ptr_size
= size_of_encoded_value (fc
->fde_encoding
);
7874 fc
->pc_begin
= byte_get (start
, encoded_ptr_size
);
7875 start
+= encoded_ptr_size
;
7876 fc
->pc_range
= byte_get (start
, encoded_ptr_size
);
7877 start
+= encoded_ptr_size
;
7879 if (cie
->augmentation
[0] == 'z')
7881 augmentation_data_len
= LEB ();
7882 augmentation_data
= start
;
7883 start
+= augmentation_data_len
;
7886 printf ("\n%08lx %08lx %08lx FDE cie=%08lx pc=%08lx..%08lx\n",
7887 (unsigned long)(saved_start
- section_start
), length
, cie_id
,
7888 (unsigned long)(cie
->chunk_start
- section_start
),
7889 fc
->pc_begin
, fc
->pc_begin
+ fc
->pc_range
);
7890 if (! do_debug_frames_interp
&& augmentation_data_len
)
7893 printf (" Augmentation data: ");
7894 for (i
= 0; i
< augmentation_data_len
; ++i
)
7895 printf (" %02x", augmentation_data
[i
]);
7901 /* At this point, fc is the current chunk, cie (if any) is set, and we're
7902 about to interpret instructions for the chunk. */
7904 if (do_debug_frames_interp
)
7906 /* Start by making a pass over the chunk, allocating storage
7907 and taking note of what registers are used. */
7908 unsigned char * tmp
= start
;
7910 while (start
< block_end
)
7920 /* Warning: if you add any more cases to this switch, be
7921 sure to add them to the corresponding switch below. */
7924 case DW_CFA_advance_loc
:
7928 frame_need_space (fc
, opa
);
7929 fc
->col_type
[opa
] = DW_CFA_undefined
;
7931 case DW_CFA_restore
:
7932 frame_need_space (fc
, opa
);
7933 fc
->col_type
[opa
] = DW_CFA_undefined
;
7935 case DW_CFA_set_loc
:
7936 start
+= encoded_ptr_size
;
7938 case DW_CFA_advance_loc1
:
7941 case DW_CFA_advance_loc2
:
7944 case DW_CFA_advance_loc4
:
7947 case DW_CFA_offset_extended
:
7948 reg
= LEB (); LEB ();
7949 frame_need_space (fc
, reg
);
7950 fc
->col_type
[reg
] = DW_CFA_undefined
;
7952 case DW_CFA_restore_extended
:
7954 frame_need_space (fc
, reg
);
7955 fc
->col_type
[reg
] = DW_CFA_undefined
;
7957 case DW_CFA_undefined
:
7959 frame_need_space (fc
, reg
);
7960 fc
->col_type
[reg
] = DW_CFA_undefined
;
7962 case DW_CFA_same_value
:
7964 frame_need_space (fc
, reg
);
7965 fc
->col_type
[reg
] = DW_CFA_undefined
;
7967 case DW_CFA_register
:
7968 reg
= LEB (); LEB ();
7969 frame_need_space (fc
, reg
);
7970 fc
->col_type
[reg
] = DW_CFA_undefined
;
7972 case DW_CFA_def_cfa
:
7975 case DW_CFA_def_cfa_register
:
7978 case DW_CFA_def_cfa_offset
:
7981 #ifndef DW_CFA_GNU_args_size
7982 #define DW_CFA_GNU_args_size 0x2e
7984 case DW_CFA_GNU_args_size
:
7987 #ifndef DW_CFA_GNU_negative_offset_extended
7988 #define DW_CFA_GNU_negative_offset_extended 0x2f
7990 case DW_CFA_GNU_negative_offset_extended
:
7991 reg
= LEB (); LEB ();
7992 frame_need_space (fc
, reg
);
7993 fc
->col_type
[reg
] = DW_CFA_undefined
;
8002 /* Now we know what registers are used, make a second pass over
8003 the chunk, this time actually printing out the info. */
8005 while (start
< block_end
)
8008 unsigned long ul
, reg
, roffs
;
8017 /* Warning: if you add any more cases to this switch, be
8018 sure to add them to the corresponding switch above. */
8021 case DW_CFA_advance_loc
:
8022 if (do_debug_frames_interp
)
8023 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8025 printf (" DW_CFA_advance_loc: %d to %08lx\n",
8026 opa
* fc
->code_factor
,
8027 fc
->pc_begin
+ opa
* fc
->code_factor
);
8028 fc
->pc_begin
+= opa
* fc
->code_factor
;
8033 if (! do_debug_frames_interp
)
8034 printf (" DW_CFA_offset: r%d at cfa%+ld\n",
8035 opa
, roffs
* fc
->data_factor
);
8036 fc
->col_type
[opa
] = DW_CFA_offset
;
8037 fc
->col_offset
[opa
] = roffs
* fc
->data_factor
;
8040 case DW_CFA_restore
:
8041 if (! do_debug_frames_interp
)
8042 printf (" DW_CFA_restore: r%d\n", opa
);
8043 fc
->col_type
[opa
] = cie
->col_type
[opa
];
8044 fc
->col_offset
[opa
] = cie
->col_offset
[opa
];
8047 case DW_CFA_set_loc
:
8048 vma
= byte_get (start
, encoded_ptr_size
);
8049 start
+= encoded_ptr_size
;
8050 if (do_debug_frames_interp
)
8051 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8053 printf (" DW_CFA_set_loc: %08lx\n", (unsigned long)vma
);
8057 case DW_CFA_advance_loc1
:
8058 ofs
= byte_get (start
, 1); start
+= 1;
8059 if (do_debug_frames_interp
)
8060 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8062 printf (" DW_CFA_advance_loc1: %ld to %08lx\n",
8063 ofs
* fc
->code_factor
,
8064 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8065 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8068 case DW_CFA_advance_loc2
:
8069 ofs
= byte_get (start
, 2); start
+= 2;
8070 if (do_debug_frames_interp
)
8071 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8073 printf (" DW_CFA_advance_loc2: %ld to %08lx\n",
8074 ofs
* fc
->code_factor
,
8075 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8076 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8079 case DW_CFA_advance_loc4
:
8080 ofs
= byte_get (start
, 4); start
+= 4;
8081 if (do_debug_frames_interp
)
8082 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8084 printf (" DW_CFA_advance_loc4: %ld to %08lx\n",
8085 ofs
* fc
->code_factor
,
8086 fc
->pc_begin
+ ofs
* fc
->code_factor
);
8087 fc
->pc_begin
+= ofs
* fc
->code_factor
;
8090 case DW_CFA_offset_extended
:
8093 if (! do_debug_frames_interp
)
8094 printf (" DW_CFA_offset_extended: r%ld at cfa%+ld\n",
8095 reg
, roffs
* fc
->data_factor
);
8096 fc
->col_type
[reg
] = DW_CFA_offset
;
8097 fc
->col_offset
[reg
] = roffs
* fc
->data_factor
;
8100 case DW_CFA_restore_extended
:
8102 if (! do_debug_frames_interp
)
8103 printf (" DW_CFA_restore_extended: r%ld\n", reg
);
8104 fc
->col_type
[reg
] = cie
->col_type
[reg
];
8105 fc
->col_offset
[reg
] = cie
->col_offset
[reg
];
8108 case DW_CFA_undefined
:
8110 if (! do_debug_frames_interp
)
8111 printf (" DW_CFA_undefined: r%ld\n", reg
);
8112 fc
->col_type
[reg
] = DW_CFA_undefined
;
8113 fc
->col_offset
[reg
] = 0;
8116 case DW_CFA_same_value
:
8118 if (! do_debug_frames_interp
)
8119 printf (" DW_CFA_same_value: r%ld\n", reg
);
8120 fc
->col_type
[reg
] = DW_CFA_same_value
;
8121 fc
->col_offset
[reg
] = 0;
8124 case DW_CFA_register
:
8127 if (! do_debug_frames_interp
)
8128 printf (" DW_CFA_register: r%ld\n", reg
);
8129 fc
->col_type
[reg
] = DW_CFA_register
;
8130 fc
->col_offset
[reg
] = roffs
;
8133 case DW_CFA_remember_state
:
8134 if (! do_debug_frames_interp
)
8135 printf (" DW_CFA_remember_state\n");
8136 rs
= (Frame_Chunk
*) xmalloc (sizeof (Frame_Chunk
));
8137 rs
->ncols
= fc
->ncols
;
8138 rs
->col_type
= (short int *) xmalloc (rs
->ncols
* sizeof (short int));
8139 rs
->col_offset
= (int *) xmalloc (rs
->ncols
* sizeof (int));
8140 memcpy (rs
->col_type
, fc
->col_type
, rs
->ncols
);
8141 memcpy (rs
->col_offset
, fc
->col_offset
, rs
->ncols
* sizeof (int));
8142 rs
->next
= remembered_state
;
8143 remembered_state
= rs
;
8146 case DW_CFA_restore_state
:
8147 if (! do_debug_frames_interp
)
8148 printf (" DW_CFA_restore_state\n");
8149 rs
= remembered_state
;
8150 remembered_state
= rs
->next
;
8151 frame_need_space (fc
, rs
->ncols
-1);
8152 memcpy (fc
->col_type
, rs
->col_type
, rs
->ncols
);
8153 memcpy (fc
->col_offset
, rs
->col_offset
, rs
->ncols
* sizeof (int));
8154 free (rs
->col_type
);
8155 free (rs
->col_offset
);
8159 case DW_CFA_def_cfa
:
8160 fc
->cfa_reg
= LEB ();
8161 fc
->cfa_offset
= LEB ();
8162 if (! do_debug_frames_interp
)
8163 printf (" DW_CFA_def_cfa: r%d ofs %d\n",
8164 fc
->cfa_reg
, fc
->cfa_offset
);
8167 case DW_CFA_def_cfa_register
:
8168 fc
->cfa_reg
= LEB ();
8169 if (! do_debug_frames_interp
)
8170 printf (" DW_CFA_def_cfa_reg: r%d\n", fc
->cfa_reg
);
8173 case DW_CFA_def_cfa_offset
:
8174 fc
->cfa_offset
= LEB ();
8175 if (! do_debug_frames_interp
)
8176 printf (" DW_CFA_def_cfa_offset: %d\n", fc
->cfa_offset
);
8180 if (! do_debug_frames_interp
)
8181 printf (" DW_CFA_nop\n");
8184 #ifndef DW_CFA_GNU_window_save
8185 #define DW_CFA_GNU_window_save 0x2d
8187 case DW_CFA_GNU_window_save
:
8188 if (! do_debug_frames_interp
)
8189 printf (" DW_CFA_GNU_window_save\n");
8192 case DW_CFA_GNU_args_size
:
8194 if (! do_debug_frames_interp
)
8195 printf (" DW_CFA_GNU_args_size: %ld\n", ul
);
8198 case DW_CFA_GNU_negative_offset_extended
:
8201 frame_need_space (fc
, reg
);
8202 if (! do_debug_frames_interp
)
8203 printf (" DW_CFA_GNU_negative_offset_extended: r%ld at cfa%+ld\n",
8204 reg
, l
* fc
->data_factor
);
8205 fc
->col_type
[reg
] = DW_CFA_offset
;
8206 fc
->col_offset
[reg
] = l
* fc
->data_factor
;
8210 fprintf (stderr
, "unsupported or unknown DW_CFA_%d\n", op
);
8215 if (do_debug_frames_interp
)
8216 frame_display_row (fc
, &need_col_headers
, &max_regs
);
8231 display_debug_not_supported (section
, start
, file
)
8232 Elf32_Internal_Shdr
* section
;
8233 unsigned char * start ATTRIBUTE_UNUSED
;
8234 FILE * file ATTRIBUTE_UNUSED
;
8236 printf (_("Displaying the debug contents of section %s is not yet supported.\n"),
8237 SECTION_NAME (section
));
8242 /* Pre-scan the .debug_info section to record the size of address.
8243 When dumping the .debug_line, we use that size information, assuming
8244 that all compilation units have the same address size. */
8246 prescan_debug_info (section
, start
, file
)
8247 Elf32_Internal_Shdr
* section ATTRIBUTE_UNUSED
;
8248 unsigned char * start
;
8249 FILE * file ATTRIBUTE_UNUSED
;
8251 DWARF2_External_CompUnit
* external
;
8253 external
= (DWARF2_External_CompUnit
*) start
;
8255 debug_line_pointer_size
= BYTE_GET (external
->cu_pointer_size
);
8259 /* A structure containing the name of a debug section and a pointer
8260 to a function that can decode it. The third field is a prescan
8261 function to be run over the section before displaying any of the
8266 int (* display
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8267 int (* prescan
) PARAMS ((Elf32_Internal_Shdr
*, unsigned char *, FILE *));
8271 { ".debug_info", display_debug_info
, prescan_debug_info
},
8272 { ".debug_abbrev", display_debug_abbrev
, NULL
},
8273 { ".debug_line", display_debug_lines
, NULL
},
8274 { ".debug_aranges", display_debug_aranges
, NULL
},
8275 { ".debug_pubnames", display_debug_pubnames
, NULL
},
8276 { ".debug_frame", display_debug_frames
, NULL
},
8277 { ".eh_frame", display_debug_frames
, NULL
},
8278 { ".debug_macinfo", display_debug_macinfo
, NULL
},
8279 { ".debug_pubtypes", display_debug_not_supported
, NULL
},
8280 { ".debug_str", display_debug_not_supported
, NULL
},
8281 { ".debug_static_func", display_debug_not_supported
, NULL
},
8282 { ".debug_static_vars", display_debug_not_supported
, NULL
},
8283 { ".debug_types", display_debug_not_supported
, NULL
},
8284 { ".debug_weaknames", display_debug_not_supported
, NULL
}
8288 display_debug_section (section
, file
)
8289 Elf32_Internal_Shdr
* section
;
8292 char * name
= SECTION_NAME (section
);
8293 bfd_size_type length
;
8294 unsigned char * start
;
8297 length
= section
->sh_size
;
8300 printf (_("\nSection '%s' has no debugging data.\n"), name
);
8304 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
, length
,
8305 _("debug section data"));
8309 /* See if we know how to display the contents of this section. */
8310 if (strncmp (name
, ".gnu.linkonce.wi.", 17) == 0)
8311 name
= ".debug_info";
8313 for (i
= NUM_ELEM (debug_displays
); i
--;)
8314 if (strcmp (debug_displays
[i
].name
, name
) == 0)
8316 debug_displays
[i
].display (section
, start
, file
);
8321 printf (_("Unrecognised debug section: %s\n"), name
);
8325 /* If we loaded in the abbrev section at some point,
8326 we must release it here. */
8327 if (first_abbrev
!= NULL
)
8334 process_section_contents (file
)
8337 Elf32_Internal_Shdr
* section
;
8343 /* Pre-scan the debug sections to find some debug information not
8344 present in some of them. For the .debug_line, we must find out the
8345 size of address (specified in .debug_info and .debug_aranges). */
8346 for (i
= 0, section
= section_headers
;
8347 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8350 char * name
= SECTION_NAME (section
);
8353 if (section
->sh_size
== 0)
8356 /* See if there is some pre-scan operation for this section. */
8357 for (j
= NUM_ELEM (debug_displays
); j
--;)
8358 if (strcmp (debug_displays
[j
].name
, name
) == 0)
8360 if (debug_displays
[j
].prescan
!= NULL
)
8362 bfd_size_type length
;
8363 unsigned char * start
;
8365 length
= section
->sh_size
;
8366 start
= ((unsigned char *)
8367 get_data (NULL
, file
, section
->sh_offset
, length
,
8368 _("debug section data")));
8372 debug_displays
[j
].prescan (section
, start
, file
);
8380 for (i
= 0, section
= section_headers
;
8381 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
8384 #ifdef SUPPORT_DISASSEMBLY
8385 if (dump_sects
[i
] & DISASS_DUMP
)
8386 disassemble_section (section
, file
);
8388 if (dump_sects
[i
] & HEX_DUMP
)
8389 dump_section (section
, file
);
8391 if (dump_sects
[i
] & DEBUG_DUMP
)
8392 display_debug_section (section
, file
);
8395 if (i
< num_dump_sects
)
8396 warn (_("Some sections were not dumped because they do not exist!\n"));
8402 process_mips_fpe_exception (mask
)
8408 if (mask
& OEX_FPU_INEX
)
8409 fputs ("INEX", stdout
), first
= 0;
8410 if (mask
& OEX_FPU_UFLO
)
8411 printf ("%sUFLO", first
? "" : "|"), first
= 0;
8412 if (mask
& OEX_FPU_OFLO
)
8413 printf ("%sOFLO", first
? "" : "|"), first
= 0;
8414 if (mask
& OEX_FPU_DIV0
)
8415 printf ("%sDIV0", first
? "" : "|"), first
= 0;
8416 if (mask
& OEX_FPU_INVAL
)
8417 printf ("%sINVAL", first
? "" : "|");
8420 fputs ("0", stdout
);
8424 process_mips_specific (file
)
8427 Elf_Internal_Dyn
* entry
;
8428 size_t liblist_offset
= 0;
8429 size_t liblistno
= 0;
8430 size_t conflictsno
= 0;
8431 size_t options_offset
= 0;
8432 size_t conflicts_offset
= 0;
8434 /* We have a lot of special sections. Thanks SGI! */
8435 if (dynamic_segment
== NULL
)
8436 /* No information available. */
8439 for (entry
= dynamic_segment
; entry
->d_tag
!= DT_NULL
; ++entry
)
8440 switch (entry
->d_tag
)
8442 case DT_MIPS_LIBLIST
:
8443 liblist_offset
= entry
->d_un
.d_val
- loadaddr
;
8445 case DT_MIPS_LIBLISTNO
:
8446 liblistno
= entry
->d_un
.d_val
;
8448 case DT_MIPS_OPTIONS
:
8449 options_offset
= entry
->d_un
.d_val
- loadaddr
;
8451 case DT_MIPS_CONFLICT
:
8452 conflicts_offset
= entry
->d_un
.d_val
- loadaddr
;
8454 case DT_MIPS_CONFLICTNO
:
8455 conflictsno
= entry
->d_un
.d_val
;
8461 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
8463 Elf32_External_Lib
* elib
;
8466 elib
= ((Elf32_External_Lib
*)
8467 get_data (NULL
, file
, liblist_offset
,
8468 liblistno
* sizeof (Elf32_External_Lib
),
8472 printf ("\nSection '.liblist' contains %lu entries:\n",
8473 (unsigned long) liblistno
);
8474 fputs (" Library Time Stamp Checksum Version Flags\n",
8477 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
8484 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
8485 time
= BYTE_GET (elib
[cnt
].l_time_stamp
);
8486 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
8487 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
8488 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
8490 tmp
= gmtime (&time
);
8491 sprintf (timebuf
, "%04u-%02u-%02uT%02u:%02u:%02u",
8492 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
8493 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
8495 printf ("%3lu: %-20s %s %#10lx %-7ld", (unsigned long) cnt
,
8496 dynamic_strings
+ liblist
.l_name
, timebuf
,
8497 liblist
.l_checksum
, liblist
.l_version
);
8499 if (liblist
.l_flags
== 0)
8510 { " EXACT_MATCH", LL_EXACT_MATCH
},
8511 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
8512 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
8513 { " EXPORTS", LL_EXPORTS
},
8514 { " DELAY_LOAD", LL_DELAY_LOAD
},
8515 { " DELTA", LL_DELTA
}
8517 int flags
= liblist
.l_flags
;
8521 fcnt
< sizeof (l_flags_vals
) / sizeof (l_flags_vals
[0]);
8523 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
8525 fputs (l_flags_vals
[fcnt
].name
, stdout
);
8526 flags
^= l_flags_vals
[fcnt
].bit
;
8529 printf (" %#x", (unsigned int) flags
);
8539 if (options_offset
!= 0)
8541 Elf_External_Options
* eopt
;
8542 Elf_Internal_Shdr
* sect
= section_headers
;
8543 Elf_Internal_Options
* iopt
;
8544 Elf_Internal_Options
* option
;
8548 /* Find the section header so that we get the size. */
8549 while (sect
->sh_type
!= SHT_MIPS_OPTIONS
)
8552 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
,
8553 sect
->sh_size
, _("options"));
8556 iopt
= ((Elf_Internal_Options
*)
8557 malloc ((sect
->sh_size
/ sizeof (eopt
)) * sizeof (* iopt
)));
8560 error (_("Out of memory"));
8567 while (offset
< sect
->sh_size
)
8569 Elf_External_Options
* eoption
;
8571 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
8573 option
->kind
= BYTE_GET (eoption
->kind
);
8574 option
->size
= BYTE_GET (eoption
->size
);
8575 option
->section
= BYTE_GET (eoption
->section
);
8576 option
->info
= BYTE_GET (eoption
->info
);
8578 offset
+= option
->size
;
8584 printf (_("\nSection '%s' contains %d entries:\n"),
8585 SECTION_NAME (sect
), cnt
);
8593 switch (option
->kind
)
8596 /* This shouldn't happen. */
8597 printf (" NULL %d %lx", option
->section
, option
->info
);
8600 printf (" REGINFO ");
8601 if (elf_header
.e_machine
== EM_MIPS
)
8604 Elf32_External_RegInfo
* ereg
;
8605 Elf32_RegInfo reginfo
;
8607 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
8608 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8609 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8610 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8611 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8612 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8613 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
8615 printf ("GPR %08lx GP 0x%lx\n",
8617 (unsigned long) reginfo
.ri_gp_value
);
8618 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8619 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8620 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8625 Elf64_External_RegInfo
* ereg
;
8626 Elf64_Internal_RegInfo reginfo
;
8628 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
8629 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
8630 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
8631 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
8632 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
8633 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
8634 reginfo
.ri_gp_value
= BYTE_GET8 (ereg
->ri_gp_value
);
8636 printf ("GPR %08lx GP 0x",
8637 reginfo
.ri_gprmask
);
8638 printf_vma (reginfo
.ri_gp_value
);
8641 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8642 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
8643 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
8647 case ODK_EXCEPTIONS
:
8648 fputs (" EXCEPTIONS fpe_min(", stdout
);
8649 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
8650 fputs (") fpe_max(", stdout
);
8651 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
8652 fputs (")", stdout
);
8654 if (option
->info
& OEX_PAGE0
)
8655 fputs (" PAGE0", stdout
);
8656 if (option
->info
& OEX_SMM
)
8657 fputs (" SMM", stdout
);
8658 if (option
->info
& OEX_FPDBUG
)
8659 fputs (" FPDBUG", stdout
);
8660 if (option
->info
& OEX_DISMISS
)
8661 fputs (" DISMISS", stdout
);
8664 fputs (" PAD ", stdout
);
8665 if (option
->info
& OPAD_PREFIX
)
8666 fputs (" PREFIX", stdout
);
8667 if (option
->info
& OPAD_POSTFIX
)
8668 fputs (" POSTFIX", stdout
);
8669 if (option
->info
& OPAD_SYMBOL
)
8670 fputs (" SYMBOL", stdout
);
8673 fputs (" HWPATCH ", stdout
);
8674 if (option
->info
& OHW_R4KEOP
)
8675 fputs (" R4KEOP", stdout
);
8676 if (option
->info
& OHW_R8KPFETCH
)
8677 fputs (" R8KPFETCH", stdout
);
8678 if (option
->info
& OHW_R5KEOP
)
8679 fputs (" R5KEOP", stdout
);
8680 if (option
->info
& OHW_R5KCVTL
)
8681 fputs (" R5KCVTL", stdout
);
8684 fputs (" FILL ", stdout
);
8685 /* XXX Print content of info word? */
8688 fputs (" TAGS ", stdout
);
8689 /* XXX Print content of info word? */
8692 fputs (" HWAND ", stdout
);
8693 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8694 fputs (" R4KEOP_CHECKED", stdout
);
8695 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8696 fputs (" R4KEOP_CLEAN", stdout
);
8699 fputs (" HWOR ", stdout
);
8700 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
8701 fputs (" R4KEOP_CHECKED", stdout
);
8702 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
8703 fputs (" R4KEOP_CLEAN", stdout
);
8706 printf (" GP_GROUP %#06lx self-contained %#06lx",
8707 option
->info
& OGP_GROUP
,
8708 (option
->info
& OGP_SELF
) >> 16);
8711 printf (" IDENT %#06lx self-contained %#06lx",
8712 option
->info
& OGP_GROUP
,
8713 (option
->info
& OGP_SELF
) >> 16);
8716 /* This shouldn't happen. */
8717 printf (" %3d ??? %d %lx",
8718 option
->kind
, option
->section
, option
->info
);
8722 len
= sizeof (* eopt
);
8723 while (len
< option
->size
)
8724 if (((char *) option
)[len
] >= ' '
8725 && ((char *) option
)[len
] < 0x7f)
8726 printf ("%c", ((char *) option
)[len
++]);
8728 printf ("\\%03o", ((char *) option
)[len
++]);
8730 fputs ("\n", stdout
);
8738 if (conflicts_offset
!= 0 && conflictsno
!= 0)
8740 Elf32_Conflict
* iconf
;
8743 if (dynamic_symbols
== NULL
)
8745 error (_("conflict list with without table"));
8749 iconf
= (Elf32_Conflict
*) malloc (conflictsno
* sizeof (* iconf
));
8752 error (_("Out of memory"));
8758 Elf32_External_Conflict
* econf32
;
8760 econf32
= ((Elf32_External_Conflict
*)
8761 get_data (NULL
, file
, conflicts_offset
,
8762 conflictsno
* sizeof (* econf32
),
8767 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8768 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
8774 Elf64_External_Conflict
* econf64
;
8776 econf64
= ((Elf64_External_Conflict
*)
8777 get_data (NULL
, file
, conflicts_offset
,
8778 conflictsno
* sizeof (* econf64
),
8783 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8784 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
8789 printf (_("\nSection '.conflict' contains %ld entries:\n"),
8790 (long) conflictsno
);
8791 puts (_(" Num: Index Value Name"));
8793 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
8795 Elf_Internal_Sym
* psym
= &dynamic_symbols
[iconf
[cnt
]];
8797 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
8798 print_vma (psym
->st_value
, FULL_HEX
);
8799 printf (" %s\n", dynamic_strings
+ psym
->st_name
);
8809 get_note_type (e_type
)
8812 static char buff
[64];
8816 case NT_PRSTATUS
: return _("NT_PRSTATUS (prstatus structure)");
8817 case NT_FPREGSET
: return _("NT_FPREGSET (floating point registers)");
8818 case NT_PRPSINFO
: return _("NT_PRPSINFO (prpsinfo structure)");
8819 case NT_TASKSTRUCT
: return _("NT_TASKSTRUCT (task structure)");
8820 case NT_PRXFPREG
: return _("NT_PRXFPREG (user_xfpregs structure)");
8821 case NT_PSTATUS
: return _("NT_PSTATUS (pstatus structure)");
8822 case NT_FPREGS
: return _("NT_FPREGS (floating point registers)");
8823 case NT_PSINFO
: return _("NT_PSINFO (psinfo structure)");
8824 case NT_LWPSTATUS
: return _("NT_LWPSTATUS (lwpstatus_t structure)");
8825 case NT_LWPSINFO
: return _("NT_LWPSINFO (lwpsinfo_t structure)");
8826 case NT_WIN32PSTATUS
: return _("NT_WIN32PSTATUS (win32_pstatus strcuture)");
8828 sprintf (buff
, _("Unknown note type: (0x%08x)"), e_type
);
8833 /* Note that by the ELF standard, the name field is already null byte
8834 terminated, and namesz includes the terminating null byte.
8835 I.E. the value of namesz for the name "FSF" is 4.
8837 If the value of namesz is zero, there is no name present. */
8839 process_note (pnote
)
8840 Elf32_Internal_Note
* pnote
;
8842 printf (" %s\t\t0x%08lx\t%s\n",
8843 pnote
->namesz
? pnote
->namedata
: "(NONE)",
8844 pnote
->descsz
, get_note_type (pnote
->type
));
8850 process_corefile_note_segment (file
, offset
, length
)
8855 Elf_External_Note
* pnotes
;
8856 Elf_External_Note
* external
;
8862 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, length
,
8869 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
8870 (unsigned long) offset
, (unsigned long) length
);
8871 printf (_(" Owner\t\tData size\tDescription\n"));
8873 while (external
< (Elf_External_Note
*)((char *) pnotes
+ length
))
8875 Elf32_Internal_Note inote
;
8878 inote
.type
= BYTE_GET (external
->type
);
8879 inote
.namesz
= BYTE_GET (external
->namesz
);
8880 inote
.namedata
= external
->name
;
8881 inote
.descsz
= BYTE_GET (external
->descsz
);
8882 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
8883 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
8885 external
= (Elf_External_Note
*)(inote
.descdata
+ align_power (inote
.descsz
, 2));
8887 /* Verify that name is null terminated. It appears that at least
8888 one version of Linux (RedHat 6.0) generates corefiles that don't
8889 comply with the ELF spec by failing to include the null byte in
8891 if (inote
.namedata
[inote
.namesz
] != '\0')
8893 temp
= malloc (inote
.namesz
+ 1);
8897 error (_("Out of memory\n"));
8902 strncpy (temp
, inote
.namedata
, inote
.namesz
);
8903 temp
[inote
.namesz
] = 0;
8905 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
8906 inote
.namedata
= temp
;
8909 res
&= process_note (& inote
);
8924 process_corefile_note_segments (file
)
8927 Elf_Internal_Phdr
* program_headers
;
8928 Elf_Internal_Phdr
* segment
;
8932 program_headers
= (Elf_Internal_Phdr
*) malloc
8933 (elf_header
.e_phnum
* sizeof (Elf_Internal_Phdr
));
8935 if (program_headers
== NULL
)
8937 error (_("Out of memory\n"));
8942 i
= get_32bit_program_headers (file
, program_headers
);
8944 i
= get_64bit_program_headers (file
, program_headers
);
8948 free (program_headers
);
8952 for (i
= 0, segment
= program_headers
;
8953 i
< elf_header
.e_phnum
;
8956 if (segment
->p_type
== PT_NOTE
)
8957 res
&= process_corefile_note_segment (file
,
8958 (bfd_vma
) segment
->p_offset
,
8959 (bfd_vma
) segment
->p_filesz
);
8962 free (program_headers
);
8968 process_corefile_contents (file
)
8971 /* If we have not been asked to display the notes then do nothing. */
8975 /* If file is not a core file then exit. */
8976 if (elf_header
.e_type
!= ET_CORE
)
8979 /* No program headers means no NOTE segment. */
8980 if (elf_header
.e_phnum
== 0)
8982 printf (_("No note segments present in the core file.\n"));
8986 return process_corefile_note_segments (file
);
8990 process_arch_specific (file
)
8996 switch (elf_header
.e_machine
)
8999 case EM_MIPS_RS3_LE
:
9000 return process_mips_specific (file
);
9009 get_file_header (file
)
9012 /* Read in the identity array. */
9013 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
9016 /* Determine how to read the rest of the header. */
9017 switch (elf_header
.e_ident
[EI_DATA
])
9019 default: /* fall through */
9020 case ELFDATANONE
: /* fall through */
9021 case ELFDATA2LSB
: byte_get
= byte_get_little_endian
; break;
9022 case ELFDATA2MSB
: byte_get
= byte_get_big_endian
; break;
9025 /* For now we only support 32 bit and 64 bit ELF files. */
9026 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
9028 /* Read in the rest of the header. */
9031 Elf32_External_Ehdr ehdr32
;
9033 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
9036 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
9037 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
9038 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
9039 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
9040 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
9041 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
9042 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
9043 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
9044 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
9045 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
9046 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
9047 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
9048 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
9052 Elf64_External_Ehdr ehdr64
;
9054 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9055 we will not be able to cope with the 64bit data found in
9056 64 ELF files. Detect this now and abort before we start
9057 overwritting things. */
9058 if (sizeof (bfd_vma
) < 8)
9060 error (_("This instance of readelf has been built without support for a\n"));
9061 error (_("64 bit data type and so it cannot read 64 bit ELF files.\n"));
9065 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
9068 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
9069 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
9070 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
9071 elf_header
.e_entry
= BYTE_GET8 (ehdr64
.e_entry
);
9072 elf_header
.e_phoff
= BYTE_GET8 (ehdr64
.e_phoff
);
9073 elf_header
.e_shoff
= BYTE_GET8 (ehdr64
.e_shoff
);
9074 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
9075 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
9076 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
9077 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
9078 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
9079 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
9080 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
9087 process_file (file_name
)
9091 struct stat statbuf
;
9094 if (stat (file_name
, & statbuf
) < 0)
9096 error (_("Cannot stat input file %s.\n"), file_name
);
9100 file
= fopen (file_name
, "rb");
9103 error (_("Input file %s not found.\n"), file_name
);
9107 if (! get_file_header (file
))
9109 error (_("%s: Failed to read file header\n"), file_name
);
9114 /* Initialise per file variables. */
9115 for (i
= NUM_ELEM (version_info
); i
--;)
9116 version_info
[i
] = 0;
9118 for (i
= NUM_ELEM (dynamic_info
); i
--;)
9119 dynamic_info
[i
] = 0;
9121 /* Process the file. */
9123 printf (_("\nFile: %s\n"), file_name
);
9125 if (! process_file_header ())
9131 process_section_headers (file
);
9133 process_program_headers (file
);
9135 process_dynamic_segment (file
);
9137 process_relocs (file
);
9139 process_unwind (file
);
9141 process_symbol_table (file
);
9143 process_syminfo (file
);
9145 process_version_sections (file
);
9147 process_section_contents (file
);
9149 process_corefile_contents (file
);
9151 process_arch_specific (file
);
9155 if (section_headers
)
9157 free (section_headers
);
9158 section_headers
= NULL
;
9163 free (string_table
);
9164 string_table
= NULL
;
9165 string_table_length
= 0;
9168 if (dynamic_strings
)
9170 free (dynamic_strings
);
9171 dynamic_strings
= NULL
;
9174 if (dynamic_symbols
)
9176 free (dynamic_symbols
);
9177 dynamic_symbols
= NULL
;
9178 num_dynamic_syms
= 0;
9181 if (dynamic_syminfo
)
9183 free (dynamic_syminfo
);
9184 dynamic_syminfo
= NULL
;
9190 #ifdef SUPPORT_DISASSEMBLY
9191 /* Needed by the i386 disassembler. For extra credit, someone could
9192 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9196 print_address (unsigned int addr
, FILE * outfile
)
9198 fprintf (outfile
,"0x%8.8x", addr
);
9201 /* Needed by the i386 disassembler. */
9203 db_task_printsym (unsigned int addr
)
9205 print_address (addr
, stderr
);
9209 int main
PARAMS ((int, char **));
9218 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9219 setlocale (LC_MESSAGES
, "");
9221 #if defined (HAVE_SETLOCALE)
9222 setlocale (LC_CTYPE
, "");
9224 bindtextdomain (PACKAGE
, LOCALEDIR
);
9225 textdomain (PACKAGE
);
9227 parse_args (argc
, argv
);
9229 if (optind
< (argc
- 1))
9233 while (optind
< argc
)
9234 err
|= process_file (argv
[optind
++]);
9236 if (dump_sects
!= NULL
)